From 47cc52415e3affb83eb4369190425b2a17b956c5 Mon Sep 17 00:00:00 2001 From: Satoshi Kataoka Date: Mon, 21 Jan 2013 16:33:24 +0900 Subject: [PATCH] refactor proximity info Change-Id: I1e37ca655b4c1ba91a04aaf5aea8267cd46b4f43 --- native/jni/src/geometry_utils.h | 5 + native/jni/src/proximity_info.cpp | 2 +- native/jni/src/proximity_info_state.cpp | 262 +--------------- native/jni/src/proximity_info_state.h | 3 +- native/jni/src/proximity_info_state_utils.h | 319 ++++++++++++++++++++ native/jni/src/proximity_info_utils.h | 5 - 6 files changed, 340 insertions(+), 256 deletions(-) create mode 100644 native/jni/src/proximity_info_state_utils.h diff --git a/native/jni/src/geometry_utils.h b/native/jni/src/geometry_utils.h index 64bbbd4b8..4cbb127e8 100644 --- a/native/jni/src/geometry_utils.h +++ b/native/jni/src/geometry_utils.h @@ -44,5 +44,10 @@ static AK_FORCE_INLINE float getAngleDiff(const float a1, const float a2) { } return diff; } + +static AK_FORCE_INLINE int getDistanceInt(const int x1, const int y1, const int x2, + const int y2) { + return static_cast(hypotf(static_cast(x1 - x2), static_cast(y1 - y2))); +} } // namespace latinime #endif // LATINIME_GEOMETRY_UTILS_H diff --git a/native/jni/src/proximity_info.cpp b/native/jni/src/proximity_info.cpp index 3669fd33d..c563b0796 100644 --- a/native/jni/src/proximity_info.cpp +++ b/native/jni/src/proximity_info.cpp @@ -164,7 +164,7 @@ void ProximityInfo::initializeG() { for (int i = 0; i < KEY_COUNT; i++) { mKeyKeyDistancesG[i][i] = 0; for (int j = i + 1; j < KEY_COUNT; j++) { - mKeyKeyDistancesG[i][j] = ProximityInfoUtils::getDistanceInt( + mKeyKeyDistancesG[i][j] = getDistanceInt( mCenterXsG[i], mCenterYsG[i], mCenterXsG[j], mCenterYsG[j]); mKeyKeyDistancesG[j][i] = mKeyKeyDistancesG[i][j]; } diff --git a/native/jni/src/proximity_info_state.cpp b/native/jni/src/proximity_info_state.cpp index 118d5c001..31b6e4baf 100644 --- a/native/jni/src/proximity_info_state.cpp +++ b/native/jni/src/proximity_info_state.cpp @@ -23,7 +23,7 @@ #include "geometry_utils.h" #include "proximity_info.h" #include "proximity_info_state.h" -#include "proximity_info_utils.h" +#include "proximity_info_state_utils.h" namespace latinime { @@ -94,82 +94,11 @@ void ProximityInfoState::initInputParams(const int pointerId, const float maxPoi mSampledInputSize = 0; if (xCoordinates && yCoordinates) { - if (DEBUG_SAMPLING_POINTS) { - if (isGeometric) { - for (int i = 0; i < inputSize; ++i) { - AKLOGI("(%d) x %d, y %d, time %d", - i, xCoordinates[i], yCoordinates[i], times[i]); - } - } - } -#ifdef DO_ASSERT_TEST - if (times) { - for (int i = 0; i < inputSize; ++i) { - if (i > 0) { - ASSERT(times[i] >= times[i - 1]); - } - } - } -#endif - const bool proximityOnly = !isGeometric && (xCoordinates[0] < 0 || yCoordinates[0] < 0); - int lastInputIndex = pushTouchPointStartIndex; - for (int i = lastInputIndex; i < inputSize; ++i) { - const int pid = pointerIds ? pointerIds[i] : 0; - if (pointerId == pid) { - lastInputIndex = i; - } - } - if (DEBUG_GEO_FULL) { - AKLOGI("Init ProximityInfoState: last input index = %d", lastInputIndex); - } - // Working space to save near keys distances for current, prev and prevprev input point. - NearKeysDistanceMap nearKeysDistances[3]; - // These pointers are swapped for each inputs points. - NearKeysDistanceMap *currentNearKeysDistances = &nearKeysDistances[0]; - NearKeysDistanceMap *prevNearKeysDistances = &nearKeysDistances[1]; - NearKeysDistanceMap *prevPrevNearKeysDistances = &nearKeysDistances[2]; - // "sumAngle" is accumulated by each angle of input points. And when "sumAngle" exceeds - // the threshold we save that point, reset sumAngle. This aims to keep the figure of - // the curve. - float sumAngle = 0.0f; - - for (int i = pushTouchPointStartIndex; i <= lastInputIndex; ++i) { - // Assuming pointerId == 0 if pointerIds is null. - const int pid = pointerIds ? pointerIds[i] : 0; - if (DEBUG_GEO_FULL) { - AKLOGI("Init ProximityInfoState: (%d)PID = %d", i, pid); - } - if (pointerId == pid) { - const int c = isGeometric ? NOT_A_COORDINATE : getPrimaryCodePointAt(i); - const int x = proximityOnly ? NOT_A_COORDINATE : xCoordinates[i]; - const int y = proximityOnly ? NOT_A_COORDINATE : yCoordinates[i]; - const int time = times ? times[i] : -1; - - if (i > 1) { - const float prevAngle = getAngle(xCoordinates[i - 2], yCoordinates[i - 2], - xCoordinates[i - 1], yCoordinates[i - 1]); - const float currentAngle = - getAngle(xCoordinates[i - 1], yCoordinates[i - 1], x, y); - sumAngle += getAngleDiff(prevAngle, currentAngle); - } - - if (pushTouchPoint(i, c, x, y, time, isGeometric /* do sampling */, - i == lastInputIndex, sumAngle, currentNearKeysDistances, - prevNearKeysDistances, prevPrevNearKeysDistances)) { - // Previous point information was popped. - NearKeysDistanceMap *tmp = prevNearKeysDistances; - prevNearKeysDistances = currentNearKeysDistances; - currentNearKeysDistances = tmp; - } else { - NearKeysDistanceMap *tmp = prevPrevNearKeysDistances; - prevPrevNearKeysDistances = prevNearKeysDistances; - prevNearKeysDistances = currentNearKeysDistances; - currentNearKeysDistances = tmp; - sumAngle = 0.0f; - } - } - } - mSampledInputSize = mSampledInputXs.size(); + mSampledInputSize = ProximityInfoStateUtils::updateTouchPoints( + mProximityInfo->getMostCommonKeyWidth(), mProximityInfo, mMaxPointToKeyLength, + mInputProximities, xCoordinates, yCoordinates, times, pointerIds, inputSize, + isGeometric, pointerId, pushTouchPointStartIndex, + &mSampledInputXs, &mSampledInputYs, &mTimes, &mLengthCache, &mInputIndice); } if (mSampledInputSize > 0 && isGeometric) { @@ -324,7 +253,7 @@ void ProximityInfoState::refreshSpeedRates(const int inputSize, const int *const if (i < mSampledInputSize - 1 && j >= mInputIndice[i + 1]) { break; } - length += ProximityInfoUtils::getDistanceInt(xCoordinates[j], yCoordinates[j], + length += getDistanceInt(xCoordinates[j], yCoordinates[j], xCoordinates[j + 1], yCoordinates[j + 1]); duration += times[j + 1] - times[j]; } @@ -333,7 +262,7 @@ void ProximityInfoState::refreshSpeedRates(const int inputSize, const int *const break; } // TODO: use mLengthCache instead? - length += ProximityInfoUtils::getDistanceInt(xCoordinates[j], yCoordinates[j], + length += getDistanceInt(xCoordinates[j], yCoordinates[j], xCoordinates[j + 1], yCoordinates[j + 1]); duration += times[j + 1] - times[j]; } @@ -388,8 +317,7 @@ float ProximityInfoState::calculateBeelineSpeedRate( while (start > 0 && tempBeelineDistance < lookupRadius) { tempTime += times[start] - times[start - 1]; --start; - tempBeelineDistance = ProximityInfoUtils::getDistanceInt(x0, y0, xCoordinates[start], - yCoordinates[start]); + tempBeelineDistance = getDistanceInt(x0, y0, xCoordinates[start], yCoordinates[start]); } // Exclusive unless this is an edge point if (start > 0 && start < actualInputIndex) { @@ -402,8 +330,7 @@ float ProximityInfoState::calculateBeelineSpeedRate( while (end < (inputSize - 1) && tempBeelineDistance < lookupRadius) { tempTime += times[end + 1] - times[end]; ++end; - tempBeelineDistance = ProximityInfoUtils::getDistanceInt(x0, y0, xCoordinates[end], - yCoordinates[end]); + tempBeelineDistance = getDistanceInt(x0, y0, xCoordinates[end], yCoordinates[end]); } // Exclusive unless this is an edge point if (end > actualInputIndex && end < (inputSize - 1)) { @@ -421,7 +348,7 @@ float ProximityInfoState::calculateBeelineSpeedRate( const int y2 = yCoordinates[start]; const int x3 = xCoordinates[end]; const int y3 = yCoordinates[end]; - const int beelineDistance = ProximityInfoUtils::getDistanceInt(x2, y2, x3, y3); + const int beelineDistance = getDistanceInt(x2, y2, x3, y3); int adjustedStartTime = times[start]; if (start == 0 && actualInputIndex == 0 && inputSize > 1) { adjustedStartTime += FIRST_POINT_TIME_OFFSET_MILLIS; @@ -477,166 +404,6 @@ bool ProximityInfoState::checkAndReturnIsContinuationPossible(const int inputSiz return true; } -// Calculating point to key distance for all near keys and returning the distance between -// the given point and the nearest key position. -float ProximityInfoState::updateNearKeysDistances(const int x, const int y, - NearKeysDistanceMap *const currentNearKeysDistances) { - static const float NEAR_KEY_THRESHOLD = 2.0f; - - currentNearKeysDistances->clear(); - const int keyCount = mProximityInfo->getKeyCount(); - float nearestKeyDistance = mMaxPointToKeyLength; - for (int k = 0; k < keyCount; ++k) { - const float dist = mProximityInfo->getNormalizedSquaredDistanceFromCenterFloatG(k, x, y); - if (dist < NEAR_KEY_THRESHOLD) { - currentNearKeysDistances->insert(std::pair(k, dist)); - } - if (nearestKeyDistance > dist) { - nearestKeyDistance = dist; - } - } - return nearestKeyDistance; -} - -// Check if previous point is at local minimum position to near keys. -bool ProximityInfoState::isPrevLocalMin(const NearKeysDistanceMap *const currentNearKeysDistances, - const NearKeysDistanceMap *const prevNearKeysDistances, - const NearKeysDistanceMap *const prevPrevNearKeysDistances) const { - static const float MARGIN = 0.01f; - - for (NearKeysDistanceMap::const_iterator it = prevNearKeysDistances->begin(); - it != prevNearKeysDistances->end(); ++it) { - NearKeysDistanceMap::const_iterator itPP = prevPrevNearKeysDistances->find(it->first); - NearKeysDistanceMap::const_iterator itC = currentNearKeysDistances->find(it->first); - if ((itPP == prevPrevNearKeysDistances->end() || itPP->second > it->second + MARGIN) - && (itC == currentNearKeysDistances->end() || itC->second > it->second + MARGIN)) { - return true; - } - } - return false; -} - -// Calculating a point score that indicates usefulness of the point. -float ProximityInfoState::getPointScore( - const int x, const int y, const int time, const bool lastPoint, const float nearest, - const float sumAngle, const NearKeysDistanceMap *const currentNearKeysDistances, - const NearKeysDistanceMap *const prevNearKeysDistances, - const NearKeysDistanceMap *const prevPrevNearKeysDistances) const { - static const int DISTANCE_BASE_SCALE = 100; - static const float NEAR_KEY_THRESHOLD = 0.6f; - static const int CORNER_CHECK_DISTANCE_THRESHOLD_SCALE = 25; - static const float NOT_LOCALMIN_DISTANCE_SCORE = -1.0f; - static const float LOCALMIN_DISTANCE_AND_NEAR_TO_KEY_SCORE = 1.0f; - static const float CORNER_ANGLE_THRESHOLD = M_PI_F * 2.0f / 3.0f; - static const float CORNER_SUM_ANGLE_THRESHOLD = M_PI_F / 4.0f; - static const float CORNER_SCORE = 1.0f; - - const size_t size = mSampledInputXs.size(); - // If there is only one point, add this point. Besides, if the previous point's distance map - // is empty, we re-compute nearby keys distances from the current point. - // Note that the current point is the first point in the incremental input that needs to - // be re-computed. - if (size <= 1 || prevNearKeysDistances->empty()) { - return 0.0f; - } - - const int baseSampleRate = mProximityInfo->getMostCommonKeyWidth(); - const int distPrev = ProximityInfoUtils::getDistanceInt( - mSampledInputXs.back(), mSampledInputYs.back(), - mSampledInputXs[size - 2], mSampledInputYs[size - 2]) * DISTANCE_BASE_SCALE; - float score = 0.0f; - - // Location - if (!isPrevLocalMin(currentNearKeysDistances, prevNearKeysDistances, - prevPrevNearKeysDistances)) { - score += NOT_LOCALMIN_DISTANCE_SCORE; - } else if (nearest < NEAR_KEY_THRESHOLD) { - // Promote points nearby keys - score += LOCALMIN_DISTANCE_AND_NEAR_TO_KEY_SCORE; - } - // Angle - const float angle1 = getAngle(x, y, mSampledInputXs.back(), mSampledInputYs.back()); - const float angle2 = getAngle(mSampledInputXs.back(), mSampledInputYs.back(), - mSampledInputXs[size - 2], mSampledInputYs[size - 2]); - const float angleDiff = getAngleDiff(angle1, angle2); - - // Save corner - if (distPrev > baseSampleRate * CORNER_CHECK_DISTANCE_THRESHOLD_SCALE - && (sumAngle > CORNER_SUM_ANGLE_THRESHOLD || angleDiff > CORNER_ANGLE_THRESHOLD)) { - score += CORNER_SCORE; - } - return score; -} - -// Sampling touch point and pushing information to vectors. -// Returning if previous point is popped or not. -bool ProximityInfoState::pushTouchPoint(const int inputIndex, const int nodeCodePoint, int x, int y, - const int time, const bool sample, const bool isLastPoint, const float sumAngle, - NearKeysDistanceMap *const currentNearKeysDistances, - const NearKeysDistanceMap *const prevNearKeysDistances, - const NearKeysDistanceMap *const prevPrevNearKeysDistances) { - static const int LAST_POINT_SKIP_DISTANCE_SCALE = 4; - - size_t size = mSampledInputXs.size(); - bool popped = false; - if (nodeCodePoint < 0 && sample) { - const float nearest = updateNearKeysDistances(x, y, currentNearKeysDistances); - const float score = getPointScore(x, y, time, isLastPoint, nearest, sumAngle, - currentNearKeysDistances, prevNearKeysDistances, prevPrevNearKeysDistances); - if (score < 0) { - // Pop previous point because it would be useless. - popInputData(); - size = mSampledInputXs.size(); - popped = true; - } else { - popped = false; - } - // Check if the last point should be skipped. - if (isLastPoint && size > 0) { - if (ProximityInfoUtils::getDistanceInt(x, y, mSampledInputXs.back(), - mSampledInputYs.back()) * LAST_POINT_SKIP_DISTANCE_SCALE - < mProximityInfo->getMostCommonKeyWidth()) { - // This point is not used because it's too close to the previous point. - if (DEBUG_GEO_FULL) { - AKLOGI("p0: size = %zd, x = %d, y = %d, lx = %d, ly = %d, dist = %d, " - "width = %d", size, x, y, mSampledInputXs.back(), mSampledInputYs.back(), - ProximityInfoUtils::getDistanceInt(x, y, mSampledInputXs.back(), - mSampledInputYs.back()), - mProximityInfo->getMostCommonKeyWidth() - / LAST_POINT_SKIP_DISTANCE_SCALE); - } - return popped; - } - } - } - - if (nodeCodePoint >= 0 && (x < 0 || y < 0)) { - const int keyId = mProximityInfo->getKeyIndexOf(nodeCodePoint); - if (keyId >= 0) { - x = mProximityInfo->getKeyCenterXOfKeyIdG(keyId); - y = mProximityInfo->getKeyCenterYOfKeyIdG(keyId); - } - } - - // Pushing point information. - if (size > 0) { - mLengthCache.push_back( - mLengthCache.back() + ProximityInfoUtils::getDistanceInt( - x, y, mSampledInputXs.back(), mSampledInputYs.back())); - } else { - mLengthCache.push_back(0); - } - mSampledInputXs.push_back(x); - mSampledInputYs.push_back(y); - mTimes.push_back(time); - mInputIndice.push_back(inputIndex); - if (DEBUG_GEO_FULL) { - AKLOGI("pushTouchPoint: x = %03d, y = %03d, time = %d, index = %d, popped ? %01d", - x, y, time, inputIndex, popped); - } - return popped; -} - float ProximityInfoState::calculateNormalizedSquaredDistance( const int keyIndex, const int inputIndex) const { if (keyIndex == NOT_AN_INDEX) { @@ -809,11 +576,8 @@ bool ProximityInfoState::isKeyInSerchKeysAfterIndex(const int index, const int k } void ProximityInfoState::popInputData() { - mSampledInputXs.pop_back(); - mSampledInputYs.pop_back(); - mTimes.pop_back(); - mLengthCache.pop_back(); - mInputIndice.pop_back(); + ProximityInfoStateUtils::popInputData(&mSampledInputXs, &mSampledInputYs, &mTimes, + &mLengthCache, &mInputIndice); } float ProximityInfoState::getDirection(const int index0, const int index1) const { diff --git a/native/jni/src/proximity_info_state.h b/native/jni/src/proximity_info_state.h index 655fda55e..0f0eb7d39 100644 --- a/native/jni/src/proximity_info_state.h +++ b/native/jni/src/proximity_info_state.h @@ -24,6 +24,7 @@ #include "char_utils.h" #include "defines.h" #include "hash_map_compat.h" +#include "proximity_info_state_utils.h" namespace latinime { @@ -230,7 +231,7 @@ class ProximityInfoState { } inline const int *getProximityCodePointsAt(const int index) const { - return mInputProximities + (index * MAX_PROXIMITY_CHARS_SIZE_INTERNAL); + return ProximityInfoStateUtils::getProximityCodePointsAt(mInputProximities, index); } float updateNearKeysDistances(const int x, const int y, diff --git a/native/jni/src/proximity_info_state_utils.h b/native/jni/src/proximity_info_state_utils.h new file mode 100644 index 000000000..53b992a2a --- /dev/null +++ b/native/jni/src/proximity_info_state_utils.h @@ -0,0 +1,319 @@ +/* + * Copyright (C) 2013 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LATINIME_PROXIMITY_INFO_STATE_UTILS_H +#define LATINIME_PROXIMITY_INFO_STATE_UTILS_H + +#include + +#include "defines.h" +#include "geometry_utils.h" +#include "hash_map_compat.h" +#include "proximity_info.h" + +namespace latinime { +class ProximityInfoStateUtils { + public: + static int updateTouchPoints(const int mostCommonKeyWidth, + 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, + std::vector *sampledInputXs, std::vector *sampledInputYs, + std::vector *sampledInputTimes, std::vector *sampledLengthCache, + std::vector *sampledInputIndice) { + if (DEBUG_SAMPLING_POINTS) { + if (times) { + for (int i = 0; i < inputSize; ++i) { + AKLOGI("(%d) x %d, y %d, time %d", + i, xCoordinates[i], yCoordinates[i], times[i]); + } + } + } +#ifdef DO_ASSERT_TEST + if (times) { + for (int i = 0; i < inputSize; ++i) { + if (i > 0) { + ASSERT(times[i] >= times[i - 1]); + } + } + } +#endif + const bool proximityOnly = !isGeometric + && (inputXCoordinates[0] < 0 || inputYCoordinates[0] < 0); + int lastInputIndex = pushTouchPointStartIndex; + for (int i = lastInputIndex; i < inputSize; ++i) { + const int pid = pointerIds ? pointerIds[i] : 0; + if (pointerId == pid) { + lastInputIndex = i; + } + } + if (DEBUG_GEO_FULL) { + AKLOGI("Init ProximityInfoState: last input index = %d", lastInputIndex); + } + // Working space to save near keys distances for current, prev and prevprev input point. + NearKeysDistanceMap nearKeysDistances[3]; + // These pointers are swapped for each inputs points. + NearKeysDistanceMap *currentNearKeysDistances = &nearKeysDistances[0]; + NearKeysDistanceMap *prevNearKeysDistances = &nearKeysDistances[1]; + NearKeysDistanceMap *prevPrevNearKeysDistances = &nearKeysDistances[2]; + // "sumAngle" is accumulated by each angle of input points. And when "sumAngle" exceeds + // the threshold we save that point, reset sumAngle. This aims to keep the figure of + // the curve. + float sumAngle = 0.0f; + + for (int i = pushTouchPointStartIndex; i <= lastInputIndex; ++i) { + // Assuming pointerId == 0 if pointerIds is null. + const int pid = pointerIds ? pointerIds[i] : 0; + if (DEBUG_GEO_FULL) { + AKLOGI("Init ProximityInfoState: (%d)PID = %d", i, pid); + } + if (pointerId == pid) { + const int c = isGeometric ? + NOT_A_COORDINATE : getPrimaryCodePointAt(inputProximities, i); + const int x = proximityOnly ? NOT_A_COORDINATE : inputXCoordinates[i]; + const int y = proximityOnly ? NOT_A_COORDINATE : inputYCoordinates[i]; + const int time = times ? times[i] : -1; + + if (i > 1) { + const float prevAngle = getAngle( + inputXCoordinates[i - 2], inputYCoordinates[i - 2], + inputXCoordinates[i - 1], inputYCoordinates[i - 1]); + const float currentAngle = + getAngle(inputXCoordinates[i - 1], inputYCoordinates[i - 1], x, y); + sumAngle += getAngleDiff(prevAngle, currentAngle); + } + + if (pushTouchPoint(mostCommonKeyWidth, proximityInfo, maxPointToKeyLength, + i, c, x, y, time, isGeometric /* do sampling */, + i == lastInputIndex, sumAngle, currentNearKeysDistances, + prevNearKeysDistances, prevPrevNearKeysDistances, + sampledInputXs, sampledInputYs, sampledInputTimes, sampledLengthCache, + sampledInputIndice)) { + // Previous point information was popped. + NearKeysDistanceMap *tmp = prevNearKeysDistances; + prevNearKeysDistances = currentNearKeysDistances; + currentNearKeysDistances = tmp; + } else { + NearKeysDistanceMap *tmp = prevPrevNearKeysDistances; + prevPrevNearKeysDistances = prevNearKeysDistances; + prevNearKeysDistances = currentNearKeysDistances; + currentNearKeysDistances = tmp; + sumAngle = 0.0f; + } + } + } + return sampledInputXs->size(); + } + + static const int *getProximityCodePointsAt( + const int *const inputProximities, const int index) { + return inputProximities + (index * MAX_PROXIMITY_CHARS_SIZE_INTERNAL); + } + + static int getPrimaryCodePointAt(const int *const inputProximities, const int index) { + return getProximityCodePointsAt(inputProximities, index)[0]; + } + + static void popInputData(std::vector *sampledInputXs, std::vector *sampledInputYs, + std::vector *sampledInputTimes, std::vector *sampledLengthCache, + std::vector *sampledInputIndice) { + sampledInputXs->pop_back(); + sampledInputYs->pop_back(); + sampledInputTimes->pop_back(); + sampledLengthCache->pop_back(); + sampledInputIndice->pop_back(); + } + + private: + DISALLOW_IMPLICIT_CONSTRUCTORS(ProximityInfoStateUtils); + + typedef hash_map_compat NearKeysDistanceMap; + + // Calculating point to key distance for all near keys and returning the distance between + // the given point and the nearest key position. + static float updateNearKeysDistances(const ProximityInfo *const proximityInfo, + const float maxPointToKeyLength, const int x, const int y, + NearKeysDistanceMap *const currentNearKeysDistances) { + static const float NEAR_KEY_THRESHOLD = 2.0f; + + currentNearKeysDistances->clear(); + const int keyCount = proximityInfo->getKeyCount(); + float nearestKeyDistance = maxPointToKeyLength; + for (int k = 0; k < keyCount; ++k) { + const float dist = proximityInfo->getNormalizedSquaredDistanceFromCenterFloatG(k, x, y); + if (dist < NEAR_KEY_THRESHOLD) { + currentNearKeysDistances->insert(std::pair(k, dist)); + } + if (nearestKeyDistance > dist) { + nearestKeyDistance = dist; + } + } + return nearestKeyDistance; + } + + // Check if previous point is at local minimum position to near keys. + static bool isPrevLocalMin(const NearKeysDistanceMap *const currentNearKeysDistances, + const NearKeysDistanceMap *const prevNearKeysDistances, + const NearKeysDistanceMap *const prevPrevNearKeysDistances) { + static const float MARGIN = 0.01f; + + for (NearKeysDistanceMap::const_iterator it = prevNearKeysDistances->begin(); + it != prevNearKeysDistances->end(); ++it) { + NearKeysDistanceMap::const_iterator itPP = prevPrevNearKeysDistances->find(it->first); + NearKeysDistanceMap::const_iterator itC = currentNearKeysDistances->find(it->first); + if ((itPP == prevPrevNearKeysDistances->end() || itPP->second > it->second + MARGIN) + && (itC == currentNearKeysDistances->end() + || itC->second > it->second + MARGIN)) { + return true; + } + } + return false; + } + + // Calculating a point score that indicates usefulness of the point. + static float getPointScore(const int mostCommonKeyWidth, + const int x, const int y, const int time, const bool lastPoint, const float nearest, + const float sumAngle, const NearKeysDistanceMap *const currentNearKeysDistances, + const NearKeysDistanceMap *const prevNearKeysDistances, + const NearKeysDistanceMap *const prevPrevNearKeysDistances, + std::vector *sampledInputXs, std::vector *sampledInputYs) { + static const int DISTANCE_BASE_SCALE = 100; + static const float NEAR_KEY_THRESHOLD = 0.6f; + static const int CORNER_CHECK_DISTANCE_THRESHOLD_SCALE = 25; + static const float NOT_LOCALMIN_DISTANCE_SCORE = -1.0f; + static const float LOCALMIN_DISTANCE_AND_NEAR_TO_KEY_SCORE = 1.0f; + static const float CORNER_ANGLE_THRESHOLD = M_PI_F * 2.0f / 3.0f; + static const float CORNER_SUM_ANGLE_THRESHOLD = M_PI_F / 4.0f; + static const float CORNER_SCORE = 1.0f; + + const size_t size = sampledInputXs->size(); + // If there is only one point, add this point. Besides, if the previous point's distance map + // is empty, we re-compute nearby keys distances from the current point. + // Note that the current point is the first point in the incremental input that needs to + // be re-computed. + if (size <= 1 || prevNearKeysDistances->empty()) { + return 0.0f; + } + + const int baseSampleRate = mostCommonKeyWidth; + const int distPrev = getDistanceInt( + sampledInputXs->back(), sampledInputYs->back(), + (*sampledInputXs)[size - 2], (*sampledInputYs)[size - 2]) * DISTANCE_BASE_SCALE; + float score = 0.0f; + + // Location + if (!isPrevLocalMin(currentNearKeysDistances, prevNearKeysDistances, + prevPrevNearKeysDistances)) { + score += NOT_LOCALMIN_DISTANCE_SCORE; + } else if (nearest < NEAR_KEY_THRESHOLD) { + // Promote points nearby keys + score += LOCALMIN_DISTANCE_AND_NEAR_TO_KEY_SCORE; + } + // Angle + const float angle1 = getAngle(x, y, sampledInputXs->back(), sampledInputYs->back()); + const float angle2 = getAngle(sampledInputXs->back(), sampledInputYs->back(), + (*sampledInputXs)[size - 2], (*sampledInputYs)[size - 2]); + const float angleDiff = getAngleDiff(angle1, angle2); + + // Save corner + if (distPrev > baseSampleRate * CORNER_CHECK_DISTANCE_THRESHOLD_SCALE + && (sumAngle > CORNER_SUM_ANGLE_THRESHOLD || angleDiff > CORNER_ANGLE_THRESHOLD)) { + score += CORNER_SCORE; + } + return score; + } + + // Sampling touch point and pushing information to vectors. + // Returning if previous point is popped or not. + 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 sample, const bool isLastPoint, const float sumAngle, + NearKeysDistanceMap *const currentNearKeysDistances, + const NearKeysDistanceMap *const prevNearKeysDistances, + const NearKeysDistanceMap *const prevPrevNearKeysDistances, + std::vector *sampledInputXs, std::vector *sampledInputYs, + std::vector *sampledInputTimes, std::vector *sampledLengthCache, + std::vector *sampledInputIndice) { + static const int LAST_POINT_SKIP_DISTANCE_SCALE = 4; + + size_t size = sampledInputXs->size(); + bool popped = false; + if (nodeCodePoint < 0 && sample) { + const float nearest = updateNearKeysDistances( + proximityInfo, maxPointToKeyLength, x, y, currentNearKeysDistances); + const float score = getPointScore(mostCommonKeyWidth, x, y, time, isLastPoint, nearest, + sumAngle, currentNearKeysDistances, prevNearKeysDistances, + prevPrevNearKeysDistances, sampledInputXs, sampledInputYs); + if (score < 0) { + // Pop previous point because it would be useless. + popInputData(sampledInputXs, sampledInputYs, sampledInputTimes, sampledLengthCache, + sampledInputIndice); + size = sampledInputXs->size(); + popped = true; + } else { + popped = false; + } + // Check if the last point should be skipped. + if (isLastPoint && size > 0) { + if (getDistanceInt(x, y, sampledInputXs->back(), + sampledInputYs->back()) * LAST_POINT_SKIP_DISTANCE_SCALE + < mostCommonKeyWidth) { + // This point is not used because it's too close to the previous point. + if (DEBUG_GEO_FULL) { + AKLOGI("p0: size = %zd, x = %d, y = %d, lx = %d, ly = %d, dist = %d, " + "width = %d", size, x, y, mSampledInputXs.back(), + mSampledInputYs.back(), ProximityInfoUtils::getDistanceInt( + x, y, mSampledInputXs.back(), mSampledInputYs.back()), + mProximityInfo->getMostCommonKeyWidth() + / LAST_POINT_SKIP_DISTANCE_SCALE); + } + return popped; + } + } + } + + if (nodeCodePoint >= 0 && (x < 0 || y < 0)) { + const int keyId = proximityInfo->getKeyIndexOf(nodeCodePoint); + if (keyId >= 0) { + x = proximityInfo->getKeyCenterXOfKeyIdG(keyId); + y = proximityInfo->getKeyCenterYOfKeyIdG(keyId); + } + } + + // Pushing point information. + if (size > 0) { + sampledLengthCache->push_back( + sampledLengthCache->back() + getDistanceInt( + x, y, sampledInputXs->back(), sampledInputYs->back())); + } else { + sampledLengthCache->push_back(0); + } + sampledInputXs->push_back(x); + sampledInputYs->push_back(y); + sampledInputTimes->push_back(time); + sampledInputIndice->push_back(inputIndex); + if (DEBUG_GEO_FULL) { + AKLOGI("pushTouchPoint: x = %03d, y = %03d, time = %d, index = %d, popped ? %01d", + x, y, time, inputIndex, popped); + } + return popped; + } +}; +} // namespace latinime +#endif // LATINIME_PROXIMITY_INFO_STATE_UTILS_H diff --git a/native/jni/src/proximity_info_utils.h b/native/jni/src/proximity_info_utils.h index 5adcc2ee9..09302075a 100644 --- a/native/jni/src/proximity_info_utils.h +++ b/native/jni/src/proximity_info_utils.h @@ -92,11 +92,6 @@ class ProximityInfoUtils { return SQUARE_FLOAT(x1 - x2) + SQUARE_FLOAT(y1 - y2); } - static AK_FORCE_INLINE int getDistanceInt(const int x1, const int y1, const int x2, - const int y2) { - return static_cast(hypotf(static_cast(x1 - x2), static_cast(y1 - y2))); - } - static inline float pointToLineSegSquaredDistanceFloat(const float x, const float y, const float x1, const float y1, const float x2, const float y2, const bool extend) { const float ray1x = x - x1;