Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 28c00842 authored by Ken Wakasa's avatar Ken Wakasa
Browse files

Cleanup in ProximityInfoStateUtils 

Change-Id: I416c0f0a5da6ce69c4ca1e848168e47b83d6597a
parent 40be4c3b

native/jni/src/proximity_info_params.cpp

+55 −1
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 
 * limitations under the License.

 */



#include "defines.h"

#include "proximity_info_params.h"



namespace latinime {
@@ -26,10 +27,17 @@ const int ProximityInfoParams::NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR = 
        1 << NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR_LOG_2;

const float ProximityInfoParams::NOT_A_DISTANCE_FLOAT = -1.0f;



// Per method constants

/* Per method constants */

// Used by ProximityInfoStateUtils::initGeometricDistanceInfos()

const float ProximityInfoParams::NEAR_KEY_NORMALIZED_SQUARED_THRESHOLD = 4.0f;



// Used by ProximityInfoStateUtils::updateNearKeysDistances()

const float ProximityInfoParams::NEAR_KEY_THRESHOLD_FOR_DISTANCE = 2.0f;



// Used by ProximityInfoStateUtils::isPrevLocalMin()

const float ProximityInfoParams::MARGIN_FOR_PREV_LOCAL_MIN = 0.01f;



// Used by ProximityInfoStateUtils::getPointScore()

const int ProximityInfoParams::DISTANCE_BASE_SCALE = 100;

const float ProximityInfoParams::NEAR_KEY_THRESHOLD_FOR_POINT_SCORE = 0.6f;

const int ProximityInfoParams::CORNER_CHECK_DISTANCE_THRESHOLD_SCALE = 25;
@@ -39,6 +47,52 @@ const float ProximityInfoParams::CORNER_ANGLE_THRESHOLD_FOR_POINT_SCORE = M_PI_F 
const float ProximityInfoParams::CORNER_SUM_ANGLE_THRESHOLD = M_PI_F / 4.0f;

const float ProximityInfoParams::CORNER_SCORE = 1.0f;



// Used by ProximityInfoStateUtils::refreshSpeedRates()

const int ProximityInfoParams::NUM_POINTS_FOR_SPEED_CALCULATION = 2;



// Used by ProximityInfoStateUtils::pushTouchPoint()

const int ProximityInfoParams::LAST_POINT_SKIP_DISTANCE_SCALE = 4;



// Used by ProximityInfoStateUtils::updateAlignPointProbabilities()

const float ProximityInfoParams::MIN_PROBABILITY = 0.000001f;

const float ProximityInfoParams::MAX_SKIP_PROBABILITY = 0.95f;

const float ProximityInfoParams::SKIP_FIRST_POINT_PROBABILITY = 0.01f;

const float ProximityInfoParams::SKIP_LAST_POINT_PROBABILITY = 0.1f;

const float ProximityInfoParams::MIN_SPEED_RATE_FOR_SKIP_PROBABILITY = 0.15f;

const float ProximityInfoParams::SPEED_WEIGHT_FOR_SKIP_PROBABILITY = 0.9f;

const float ProximityInfoParams::SLOW_STRAIGHT_WEIGHT_FOR_SKIP_PROBABILITY = 0.6f;

const float ProximityInfoParams::NEAREST_DISTANCE_WEIGHT = 0.5f;

const float ProximityInfoParams::NEAREST_DISTANCE_BIAS = 0.5f;

const float ProximityInfoParams::NEAREST_DISTANCE_WEIGHT_FOR_LAST = 0.6f;

const float ProximityInfoParams::NEAREST_DISTANCE_BIAS_FOR_LAST = 0.4f;

const float ProximityInfoParams::ANGLE_WEIGHT = 0.90f;

const float ProximityInfoParams::DEEP_CORNER_ANGLE_THRESHOLD = M_PI_F * 60.0f / 180.0f;

const float ProximityInfoParams::SKIP_DEEP_CORNER_PROBABILITY = 0.1f;

const float ProximityInfoParams::CORNER_ANGLE_THRESHOLD = M_PI_F * 30.0f / 180.0f;

const float ProximityInfoParams::STRAIGHT_ANGLE_THRESHOLD = M_PI_F * 15.0f / 180.0f;

const float ProximityInfoParams::SKIP_CORNER_PROBABILITY = 0.4f;

const float ProximityInfoParams::SPEED_MARGIN = 0.1f;

const float ProximityInfoParams::CENTER_VALUE_OF_NORMALIZED_DISTRIBUTION = 0.0f;

// TODO: The variance is critical for accuracy; thus, adjusting these parameter by machine

// learning or something would be efficient.

const float ProximityInfoParams::SPEEDxANGLE_WEIGHT_FOR_STANDARD_DIVIATION = 0.3f;

const float ProximityInfoParams::MAX_SPEEDxANGLE_RATE_FOR_STANDERD_DIVIATION = 0.25f;

const float ProximityInfoParams::SPEEDxNEAREST_WEIGHT_FOR_STANDARD_DIVIATION = 0.5f;

const float ProximityInfoParams::MAX_SPEEDxNEAREST_RATE_FOR_STANDERD_DIVIATION = 0.15f;

const float ProximityInfoParams::MIN_STANDERD_DIVIATION = 0.37f;

const float ProximityInfoParams::PREV_DISTANCE_WEIGHT = 0.5f;

const float ProximityInfoParams::NEXT_DISTANCE_WEIGHT = 0.6f;



// Used by ProximityInfoStateUtils::suppressCharProbabilities()

const float ProximityInfoParams::SUPPRESSION_LENGTH_WEIGHT = 1.5f;

const float ProximityInfoParams::MIN_SUPPRESSION_RATE = 0.1f;

const float ProximityInfoParams::SUPPRESSION_WEIGHT = 0.5f;

const float ProximityInfoParams::SUPPRESSION_WEIGHT_FOR_PROBABILITY_GAIN = 0.1f;

const float ProximityInfoParams::SKIP_PROBABALITY_WEIGHT_FOR_PROBABILITY_GAIN = 0.3f;



// Used by ProximityInfoStateUtils::getMostProbableString()

const float ProximityInfoParams::DEMOTION_LOG_PROBABILITY = 0.3f;



// TODO: Investigate if this is required

const float ProximityInfoParams::SEARCH_KEY_RADIUS_RATIO = 0.95f;

} // namespace latinime

native/jni/src/proximity_info_params.h

+44 −0
Original line number Diff line number Diff line
@@ -50,6 +50,50 @@ class ProximityInfoParams { 
    static const float CORNER_SUM_ANGLE_THRESHOLD;

    static const float CORNER_SCORE;



    // Used by ProximityInfoStateUtils::refreshSpeedRates()

    static const int NUM_POINTS_FOR_SPEED_CALCULATION;



    // Used by ProximityInfoStateUtils::pushTouchPoint()

    static const int LAST_POINT_SKIP_DISTANCE_SCALE;



    // Used by ProximityInfoStateUtils::updateAlignPointProbabilities()

    static const float MIN_PROBABILITY;

    static const float MAX_SKIP_PROBABILITY;

    static const float SKIP_FIRST_POINT_PROBABILITY;

    static const float SKIP_LAST_POINT_PROBABILITY;

    static const float MIN_SPEED_RATE_FOR_SKIP_PROBABILITY;

    static const float SPEED_WEIGHT_FOR_SKIP_PROBABILITY;

    static const float SLOW_STRAIGHT_WEIGHT_FOR_SKIP_PROBABILITY;

    static const float NEAREST_DISTANCE_WEIGHT;

    static const float NEAREST_DISTANCE_BIAS;

    static const float NEAREST_DISTANCE_WEIGHT_FOR_LAST;

    static const float NEAREST_DISTANCE_BIAS_FOR_LAST;

    static const float ANGLE_WEIGHT;

    static const float DEEP_CORNER_ANGLE_THRESHOLD;

    static const float SKIP_DEEP_CORNER_PROBABILITY;

    static const float CORNER_ANGLE_THRESHOLD;

    static const float STRAIGHT_ANGLE_THRESHOLD;

    static const float SKIP_CORNER_PROBABILITY;

    static const float SPEED_MARGIN;

    static const float CENTER_VALUE_OF_NORMALIZED_DISTRIBUTION;

    static const float SPEEDxANGLE_WEIGHT_FOR_STANDARD_DIVIATION;

    static const float MAX_SPEEDxANGLE_RATE_FOR_STANDERD_DIVIATION;

    static const float SPEEDxNEAREST_WEIGHT_FOR_STANDARD_DIVIATION;

    static const float MAX_SPEEDxNEAREST_RATE_FOR_STANDERD_DIVIATION;

    static const float MIN_STANDERD_DIVIATION;

    static const float PREV_DISTANCE_WEIGHT;

    static const float NEXT_DISTANCE_WEIGHT;



    // Used by ProximityInfoStateUtils::suppressCharProbabilities()

    static const float SUPPRESSION_LENGTH_WEIGHT;

    static const float MIN_SUPPRESSION_RATE;

    static const float SUPPRESSION_WEIGHT;

    static const float SUPPRESSION_WEIGHT_FOR_PROBABILITY_GAIN;

    static const float SKIP_PROBABALITY_WEIGHT_FOR_PROBABILITY_GAIN;



    // Used by ProximityInfoStateUtils::getMostProbableString()

    static const float DEMOTION_LOG_PROBABILITY;



 private:

    DISALLOW_IMPLICIT_CONSTRUCTORS(ProximityInfoParams);

    static const int NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR_LOG_2;

native/jni/src/proximity_info_state.cpp

+16 −17
Original line number Diff line number Diff line
@@ -89,29 +89,28 @@ void ProximityInfoState::initInputParams(const int pointerId, const float maxPoi 
    }



    if (xCoordinates && yCoordinates) {

        mSampledInputSize = ProximityInfoStateUtils::updateTouchPoints(

                mProximityInfo->getMostCommonKeyWidth(), mProximityInfo, mMaxPointToKeyLength,

                mInputProximities, xCoordinates, yCoordinates, times, pointerIds, inputSize,

                isGeometric, pointerId, pushTouchPointStartIndex, &mSampledInputXs,

                &mSampledInputYs, &mSampledTimes, &mSampledLengthCache, &mSampledInputIndice);

        mSampledInputSize = ProximityInfoStateUtils::updateTouchPoints(mProximityInfo,

                mMaxPointToKeyLength, mInputProximities, xCoordinates, yCoordinates, times,

                pointerIds, inputSize, isGeometric, pointerId, pushTouchPointStartIndex,

                &mSampledInputXs, &mSampledInputYs, &mSampledTimes, &mSampledLengthCache,

                &mSampledInputIndice);

    }



    if (mSampledInputSize > 0 && isGeometric) {

        mAverageSpeed = ProximityInfoStateUtils::refreshSpeedRates(

                inputSize, xCoordinates, yCoordinates, times, lastSavedInputSize,

                mSampledInputSize, &mSampledInputXs, &mSampledInputYs, &mSampledTimes,

                &mSampledLengthCache, &mSampledInputIndice, &mSpeedRates, &mDirections);

        ProximityInfoStateUtils::refreshBeelineSpeedRates(

                mProximityInfo->getMostCommonKeyWidth(), mAverageSpeed, inputSize,

                xCoordinates, yCoordinates, times, mSampledInputSize, &mSampledInputXs,

                &mSampledInputYs, &mSampledInputIndice, &mBeelineSpeedPercentiles);

        mAverageSpeed = ProximityInfoStateUtils::refreshSpeedRates(inputSize, xCoordinates,

                yCoordinates, times, lastSavedInputSize, mSampledInputSize, &mSampledInputXs,

                &mSampledInputYs, &mSampledTimes, &mSampledLengthCache, &mSampledInputIndice,

                &mSpeedRates, &mDirections);

        ProximityInfoStateUtils::refreshBeelineSpeedRates(mProximityInfo->getMostCommonKeyWidth(),

                mAverageSpeed, inputSize, xCoordinates, yCoordinates, times, mSampledInputSize,

                &mSampledInputXs, &mSampledInputYs, &mSampledInputIndice,

                &mBeelineSpeedPercentiles);

    }



    if (mSampledInputSize > 0) {

        ProximityInfoStateUtils::initGeometricDistanceInfos(

                mProximityInfo, mProximityInfo->getKeyCount(),

                mSampledInputSize, lastSavedInputSize, &mSampledInputXs, &mSampledInputYs,

                &mSampledNearKeysVector, &mSampledDistanceCache_G);

        ProximityInfoStateUtils::initGeometricDistanceInfos(mProximityInfo, mSampledInputSize,

                lastSavedInputSize, &mSampledInputXs, &mSampledInputYs, &mSampledNearKeysVector,

                &mSampledDistanceCache_G);

        if (isGeometric) {

            // updates probabilities of skipping or mapping each key for all points.

            ProximityInfoStateUtils::updateAlignPointProbabilities(

native/jni/src/proximity_info_state_utils.cpp

+81 −106

File changed.

Preview size limit exceeded, changes collapsed.

native/jni/src/proximity_info_state_utils.h

+28 −39
Original line number Diff line number Diff line
@@ -35,9 +35,8 @@ class ProximityInfoStateUtils { 
    static int trimLastTwoTouchPoints(std::vector<int> *sampledInputXs,

            std::vector<int> *sampledInputYs, std::vector<int> *sampledInputTimes,

            std::vector<int> *sampledLengthCache, std::vector<int> *sampledInputIndice);

    static int updateTouchPoints(const int mostCommonKeyWidth,

            const ProximityInfo *const proximityInfo, const int maxPointToKeyLength,

            const int *const inputProximities,

    static int updateTouchPoints(const ProximityInfo *const proximityInfo,

            const int maxPointToKeyLength, const int *const inputProximities,

            const int *const inputXCoordinates, const int *const inputYCoordinates,

            const int *const times, const int *const pointerIds, const int inputSize,

            const bool isGeometric, const int pointerId, const int pushTouchPointStartIndex,
@@ -65,19 +64,17 @@ class ProximityInfoStateUtils { 
            std::vector<int> *beelineSpeedPercentiles);

    static float getDirection(const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs, const int index0, const int index1);

    static void updateAlignPointProbabilities(

            const float maxPointToKeyLength, const int mostCommonKeyWidth, const int keyCount,

            const int start, const int sampledInputSize,

            const std::vector<int> *const sampledInputXs,

    static void updateAlignPointProbabilities(const float maxPointToKeyLength,

            const int mostCommonKeyWidth, const int keyCount, const int start,

            const int sampledInputSize, const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs,

            const std::vector<float> *const sampledSpeedRates,

            const std::vector<int> *const sampledLengthCache,

            const std::vector<float> *const SampledDistanceCache_G,

            std::vector<NearKeycodesSet> *SampledNearKeysVector,

            std::vector<hash_map_compat<int, float> > *charProbabilities);

    static void updateSampledSearchKeysVector(

            const ProximityInfo *const proximityInfo, const int sampledInputSize,

            const int lastSavedInputSize,

    static void updateSampledSearchKeysVector(const ProximityInfo *const proximityInfo,

            const int sampledInputSize, const int lastSavedInputSize,

            const std::vector<int> *const sampledLengthCache,

            const std::vector<NearKeycodesSet> *const SampledNearKeysVector,

            std::vector<NearKeycodesSet> *sampledSearchKeysVector);
@@ -87,22 +84,18 @@ class ProximityInfoStateUtils { 
    static float getPointToKeyByIdLength(const float maxPointToKeyLength,

            const std::vector<float> *const SampledDistanceCache_G, const int keyCount,

            const int inputIndex, const int keyId);

    static void initGeometricDistanceInfos(

            const ProximityInfo *const proximityInfo, const int keyCount,

    static void initGeometricDistanceInfos(const ProximityInfo *const proximityInfo,

            const int sampledInputSize, const int lastSavedInputSize,

            const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs,

            std::vector<NearKeycodesSet> *SampledNearKeysVector,

            std::vector<float> *SampledDistanceCache_G);

    static void initPrimaryInputWord(

            const int inputSize, const int *const inputProximities, int *primaryInputWord);

    static void initNormalizedSquaredDistances(

            const ProximityInfo *const proximityInfo, const int inputSize,

            const int *inputXCoordinates, const int *inputYCoordinates,

            const int *const inputProximities,

            const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs,

            int *normalizedSquaredDistances);

    static void initPrimaryInputWord(const int inputSize, const int *const inputProximities,

            int *primaryInputWord);

    static void initNormalizedSquaredDistances(const ProximityInfo *const proximityInfo,

            const int inputSize, const int *inputXCoordinates, const int *inputYCoordinates,

            const int *const inputProximities, const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs, int *normalizedSquaredDistances);

    static void dump(const bool isGeometric, const int inputSize,

            const int *const inputXCoordinates, const int *const inputYCoordinates,

            const int sampledInputSize, const std::vector<int> *const sampledInputXs,
@@ -117,8 +110,8 @@ class ProximityInfoStateUtils { 
            const std::vector<int> *const sampledTimes,

            const std::vector<int> *const sampledInputIndices);

    // TODO: Move to most_probable_string_utils.h

    static float getMostProbableString(

            const ProximityInfo *const proximityInfo, const int sampledInputSize,

    static float getMostProbableString(const ProximityInfo *const proximityInfo,

            const int sampledInputSize,

            const std::vector<hash_map_compat<int, float> > *const charProbabilities,

            int *const codePointBuf);
@@ -137,11 +130,10 @@ class ProximityInfoStateUtils { 
            const NearKeysDistanceMap *const prevNearKeysDistances,

            const NearKeysDistanceMap *const prevPrevNearKeysDistances,

            std::vector<int> *sampledInputXs, std::vector<int> *sampledInputYs);

    static bool pushTouchPoint(const int mostCommonKeyWidth,

            const ProximityInfo *const proximityInfo, const int maxPointToKeyLength,

            const int inputIndex, const int nodeCodePoint, int x, int y, const int time,

            const bool doSampling, const bool isLastPoint, const float sumAngle,

            NearKeysDistanceMap *const currentNearKeysDistances,

    static bool pushTouchPoint(const ProximityInfo *const proximityInfo,

            const int maxPointToKeyLength, const int inputIndex, const int nodeCodePoint, int x,

            int y, const int time, const bool doSampling, const bool isLastPoint,

            const float sumAngle, NearKeysDistanceMap *const currentNearKeysDistances,

            const NearKeysDistanceMap *const prevNearKeysDistances,

            const NearKeysDistanceMap *const prevPrevNearKeysDistances,

            std::vector<int> *sampledInputXs, std::vector<int> *sampledInputYs,
@@ -153,23 +145,20 @@ class ProximityInfoStateUtils { 
            const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs,

            const std::vector<int> *const inputIndice);

    static float getPointAngle(

            const std::vector<int> *const sampledInputXs,

    static float getPointAngle(const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs, const int index);

    static float getPointsAngle(

            const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs,

            const int index0, const int index1, const int index2);

    static float getPointsAngle(const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs, const int index0, const int index1,

            const int index2);

    static bool suppressCharProbabilities(const int mostCommonKeyWidth,

            const int sampledInputSize, const std::vector<int> *const lengthCache,

            const int index0, const int index1,

            std::vector<hash_map_compat<int, float> > *charProbabilities);

            const int sampledInputSize, const std::vector<int> *const lengthCache, const int index0,

            const int index1, std::vector<hash_map_compat<int, float> > *charProbabilities);

    static float calculateSquaredDistanceFromSweetSpotCenter(

            const ProximityInfo *const proximityInfo, const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs, const int keyIndex,

            const int inputIndex);

     static float calculateNormalizedSquaredDistance(

            const ProximityInfo *const proximityInfo, const std::vector<int> *const sampledInputXs,

     static float calculateNormalizedSquaredDistance(const ProximityInfo *const proximityInfo,

            const std::vector<int> *const sampledInputXs,

            const std::vector<int> *const sampledInputYs, const int keyIndex, const int inputIndex);

};

} // namespace latinime