diff options
Diffstat (limited to 'native/jni/src/proximity_info_state.h')
| -rw-r--r-- | native/jni/src/proximity_info_state.h | 294 |
1 files changed, 294 insertions, 0 deletions
diff --git a/native/jni/src/proximity_info_state.h b/native/jni/src/proximity_info_state.h new file mode 100644 index 000000000..48862a7c7 --- /dev/null +++ b/native/jni/src/proximity_info_state.h @@ -0,0 +1,294 @@ +/* + * Copyright (C) 2012 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_H +#define LATINIME_PROXIMITY_INFO_STATE_H + +#include <bitset> +#include <cstring> // for memset() +#include <stdint.h> +#include <string> +#include <vector> + +#include "char_utils.h" +#include "defines.h" +#include "hash_map_compat.h" + +namespace latinime { + +class ProximityInfo; + +class ProximityInfoState { + public: + typedef std::bitset<MAX_KEY_COUNT_IN_A_KEYBOARD> NearKeycodesSet; + static const int NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR_LOG_2; + static const int NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR; + static const float NOT_A_DISTANCE_FLOAT; + static const int NOT_A_CODE; + + ///////////////////////////////////////// + // Defined in proximity_info_state.cpp // + ///////////////////////////////////////// + void initInputParams(const int pointerId, const float maxPointToKeyLength, + const ProximityInfo *proximityInfo, const int32_t *const inputCodes, + const int inputSize, const int *xCoordinates, const int *yCoordinates, + const int *const times, const int *const pointerIds, const bool isGeometric); + + ///////////////////////////////////////// + // Defined here // + ///////////////////////////////////////// + ProximityInfoState() + : mProximityInfo(0), mMaxPointToKeyLength(0), + mHasTouchPositionCorrectionData(false), mMostCommonKeyWidthSquare(0), mLocaleStr(), + mKeyCount(0), mCellHeight(0), mCellWidth(0), mGridHeight(0), mGridWidth(0), + mIsContinuationPossible(false), mInputXs(), mInputYs(), mTimes(), mInputIndice(), + mDistanceCache(), mLengthCache(), mNearKeysVector(), + mTouchPositionCorrectionEnabled(false), mInputSize(0) { + memset(mInputCodes, 0, sizeof(mInputCodes)); + memset(mNormalizedSquaredDistances, 0, sizeof(mNormalizedSquaredDistances)); + memset(mPrimaryInputWord, 0, sizeof(mPrimaryInputWord)); + } + + virtual ~ProximityInfoState() {} + + inline unsigned short getPrimaryCharAt(const int index) const { + return getProximityCharsAt(index)[0]; + } + + inline bool existsCharInProximityAt(const int index, const int c) const { + const int *chars = getProximityCharsAt(index); + int i = 0; + while (chars[i] > 0 && i < MAX_PROXIMITY_CHARS_SIZE_INTERNAL) { + if (chars[i++] == c) { + return true; + } + } + return false; + } + + inline bool existsAdjacentProximityChars(const int index) const { + if (index < 0 || index >= mInputSize) return false; + const int currentChar = getPrimaryCharAt(index); + const int leftIndex = index - 1; + if (leftIndex >= 0 && existsCharInProximityAt(leftIndex, currentChar)) { + return true; + } + const int rightIndex = index + 1; + if (rightIndex < mInputSize && existsCharInProximityAt(rightIndex, currentChar)) { + return true; + } + return false; + } + + // In the following function, c is the current character of the dictionary word + // currently examined. + // currentChars is an array containing the keys close to the character the + // user actually typed at the same position. We want to see if c is in it: if so, + // then the word contains at that position a character close to what the user + // typed. + // What the user typed is actually the first character of the array. + // proximityIndex is a pointer to the variable where getMatchedProximityId returns + // the index of c in the proximity chars of the input index. + // Notice : accented characters do not have a proximity list, so they are alone + // in their list. The non-accented version of the character should be considered + // "close", but not the other keys close to the non-accented version. + inline ProximityType getMatchedProximityId(const int index, + const unsigned short c, const bool checkProximityChars, int *proximityIndex = 0) const { + const int *currentChars = getProximityCharsAt(index); + const int firstChar = currentChars[0]; + const unsigned short baseLowerC = toBaseLowerCase(c); + + // The first char in the array is what user typed. If it matches right away, + // that means the user typed that same char for this pos. + if (firstChar == baseLowerC || firstChar == c) { + return EQUIVALENT_CHAR; + } + + if (!checkProximityChars) return UNRELATED_CHAR; + + // If the non-accented, lowercased version of that first character matches c, + // then we have a non-accented version of the accented character the user + // typed. Treat it as a close char. + if (toBaseLowerCase(firstChar) == baseLowerC) + return NEAR_PROXIMITY_CHAR; + + // Not an exact nor an accent-alike match: search the list of close keys + int j = 1; + while (j < MAX_PROXIMITY_CHARS_SIZE_INTERNAL + && currentChars[j] > ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) { + const bool matched = (currentChars[j] == baseLowerC || currentChars[j] == c); + if (matched) { + if (proximityIndex) { + *proximityIndex = j; + } + return NEAR_PROXIMITY_CHAR; + } + ++j; + } + if (j < MAX_PROXIMITY_CHARS_SIZE_INTERNAL + && currentChars[j] == ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) { + ++j; + while (j < MAX_PROXIMITY_CHARS_SIZE_INTERNAL + && currentChars[j] > ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) { + const bool matched = (currentChars[j] == baseLowerC || currentChars[j] == c); + if (matched) { + if (proximityIndex) { + *proximityIndex = j; + } + return ADDITIONAL_PROXIMITY_CHAR; + } + ++j; + } + } + + // Was not included, signal this as an unrelated character. + return UNRELATED_CHAR; + } + + inline int getNormalizedSquaredDistance( + const int inputIndex, const int proximityIndex) const { + return mNormalizedSquaredDistances[ + inputIndex * MAX_PROXIMITY_CHARS_SIZE_INTERNAL + proximityIndex]; + } + + inline const unsigned short *getPrimaryInputWord() const { + return mPrimaryInputWord; + } + + inline bool touchPositionCorrectionEnabled() const { + return mTouchPositionCorrectionEnabled; + } + + inline bool sameAsTyped(const unsigned short *word, int length) const { + if (length != mInputSize) { + return false; + } + const int *inputCodes = mInputCodes; + while (length--) { + if (static_cast<unsigned int>(*inputCodes) != static_cast<unsigned int>(*word)) { + return false; + } + inputCodes += MAX_PROXIMITY_CHARS_SIZE_INTERNAL; + word++; + } + return true; + } + + int getDuration(const int index) const; + + bool isUsed() const { + return mInputSize > 0; + } + + uint32_t size() const { + return mInputSize; + } + + int getInputX(const int index) const { + return mInputXs[index]; + } + + int getInputY(const int index) const { + return mInputYs[index]; + } + + int getLengthCache(const int index) const { + return mLengthCache[index]; + } + + bool isContinuationPossible() const { + return mIsContinuationPossible; + } + + float getPointToKeyLength(const int inputIndex, const int charCode, const float scale) const; + + int getSpaceY() const; + + int32_t getAllPossibleChars( + const size_t startIndex, int32_t *const filter, const int32_t filterSize) const; + + float getAveragePointDuration() const; + private: + DISALLOW_COPY_AND_ASSIGN(ProximityInfoState); + typedef hash_map_compat<int, float> NearKeysDistanceMap; + ///////////////////////////////////////// + // Defined in proximity_info_state.cpp // + ///////////////////////////////////////// + float calculateNormalizedSquaredDistance(const int keyIndex, const int inputIndex) const; + + float calculateSquaredDistanceFromSweetSpotCenter( + const int keyIndex, const int inputIndex) const; + + bool pushTouchPoint(const int inputIndex, const int nodeChar, int x, int y, const int time, + const bool sample, const bool isLastPoint, + NearKeysDistanceMap *const currentNearKeysDistances, + const NearKeysDistanceMap *const prevNearKeysDistances, + const NearKeysDistanceMap *const prevPrevNearKeysDistances); + ///////////////////////////////////////// + // Defined here // + ///////////////////////////////////////// + inline float square(const float x) const { return x * x; } + + bool hasInputCoordinates() const { + return mInputXs.size() > 0 && mInputYs.size() > 0; + } + + inline const int *getProximityCharsAt(const int index) const { + return mInputCodes + (index * MAX_PROXIMITY_CHARS_SIZE_INTERNAL); + } + + float updateNearKeysDistances(const int x, const int y, + NearKeysDistanceMap *const currentNearKeysDistances); + bool isPrevLocalMin(const NearKeysDistanceMap *const currentNearKeysDistances, + const NearKeysDistanceMap *const prevNearKeysDistances, + const NearKeysDistanceMap *const prevPrevNearKeysDistances) const; + float getPointScore( + const int x, const int y, const int time, const bool last, const float nearest, + const NearKeysDistanceMap *const currentNearKeysDistances, + const NearKeysDistanceMap *const prevNearKeysDistances, + const NearKeysDistanceMap *const prevPrevNearKeysDistances) const; + bool checkAndReturnIsContinuationPossible(const int inputSize, const int *const xCoordinates, + const int *const yCoordinates, const int *const times); + void popInputData(); + + // const + const ProximityInfo *mProximityInfo; + float mMaxPointToKeyLength; + bool mHasTouchPositionCorrectionData; + int mMostCommonKeyWidthSquare; + std::string mLocaleStr; + int mKeyCount; + int mCellHeight; + int mCellWidth; + int mGridHeight; + int mGridWidth; + bool mIsContinuationPossible; + + std::vector<int> mInputXs; + std::vector<int> mInputYs; + std::vector<int> mTimes; + std::vector<int> mInputIndice; + std::vector<float> mDistanceCache; + std::vector<int> mLengthCache; + std::vector<NearKeycodesSet> mNearKeysVector; + bool mTouchPositionCorrectionEnabled; + int32_t mInputCodes[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH_INTERNAL]; + int mNormalizedSquaredDistances[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH_INTERNAL]; + int mInputSize; + unsigned short mPrimaryInputWord[MAX_WORD_LENGTH_INTERNAL]; +}; +} // namespace latinime +#endif // LATINIME_PROXIMITY_INFO_STATE_H |