1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef LATINIME_PROXIMITY_INFO_STATE_H 18 #define LATINIME_PROXIMITY_INFO_STATE_H 19 20 #include <bitset> 21 #include <cstring> // for memset() 22 #include <stdint.h> 23 #include <string> 24 #include <vector> 25 26 #include "char_utils.h" 27 #include "defines.h" 28 #include "hash_map_compat.h" 29 30 namespace latinime { 31 32 class ProximityInfo; 33 34 class ProximityInfoState { 35 public: 36 typedef std::bitset<MAX_KEY_COUNT_IN_A_KEYBOARD> NearKeycodesSet; 37 static const int NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR_LOG_2; 38 static const int NORMALIZED_SQUARED_DISTANCE_SCALING_FACTOR; 39 static const float NOT_A_DISTANCE_FLOAT; 40 static const int NOT_A_CODE; 41 42 ///////////////////////////////////////// 43 // Defined in proximity_info_state.cpp // 44 ///////////////////////////////////////// 45 void initInputParams(const int pointerId, const float maxPointToKeyLength, 46 const ProximityInfo *proximityInfo, const int32_t *const inputCodes, 47 const int inputSize, const int *xCoordinates, const int *yCoordinates, 48 const int *const times, const int *const pointerIds, const bool isGeometric); 49 50 ///////////////////////////////////////// 51 // Defined here // 52 ///////////////////////////////////////// ProximityInfoState()53 ProximityInfoState() 54 : mProximityInfo(0), mMaxPointToKeyLength(0), 55 mHasTouchPositionCorrectionData(false), mMostCommonKeyWidthSquare(0), mLocaleStr(), 56 mKeyCount(0), mCellHeight(0), mCellWidth(0), mGridHeight(0), mGridWidth(0), 57 mIsContinuationPossible(false), mInputXs(), mInputYs(), mTimes(), mInputIndice(), 58 mDistanceCache(), mLengthCache(), mRelativeSpeeds(), mNearKeysVector(), 59 mTouchPositionCorrectionEnabled(false), mInputSize(0) { 60 memset(mInputCodes, 0, sizeof(mInputCodes)); 61 memset(mNormalizedSquaredDistances, 0, sizeof(mNormalizedSquaredDistances)); 62 memset(mPrimaryInputWord, 0, sizeof(mPrimaryInputWord)); 63 } 64 ~ProximityInfoState()65 virtual ~ProximityInfoState() {} 66 getPrimaryCharAt(const int index)67 inline unsigned short getPrimaryCharAt(const int index) const { 68 return getProximityCharsAt(index)[0]; 69 } 70 existsCharInProximityAt(const int index,const int c)71 inline bool existsCharInProximityAt(const int index, const int c) const { 72 const int *chars = getProximityCharsAt(index); 73 int i = 0; 74 while (chars[i] > 0 && i < MAX_PROXIMITY_CHARS_SIZE_INTERNAL) { 75 if (chars[i++] == c) { 76 return true; 77 } 78 } 79 return false; 80 } 81 existsAdjacentProximityChars(const int index)82 inline bool existsAdjacentProximityChars(const int index) const { 83 if (index < 0 || index >= mInputSize) return false; 84 const int currentChar = getPrimaryCharAt(index); 85 const int leftIndex = index - 1; 86 if (leftIndex >= 0 && existsCharInProximityAt(leftIndex, currentChar)) { 87 return true; 88 } 89 const int rightIndex = index + 1; 90 if (rightIndex < mInputSize && existsCharInProximityAt(rightIndex, currentChar)) { 91 return true; 92 } 93 return false; 94 } 95 96 // In the following function, c is the current character of the dictionary word 97 // currently examined. 98 // currentChars is an array containing the keys close to the character the 99 // user actually typed at the same position. We want to see if c is in it: if so, 100 // then the word contains at that position a character close to what the user 101 // typed. 102 // What the user typed is actually the first character of the array. 103 // proximityIndex is a pointer to the variable where getMatchedProximityId returns 104 // the index of c in the proximity chars of the input index. 105 // Notice : accented characters do not have a proximity list, so they are alone 106 // in their list. The non-accented version of the character should be considered 107 // "close", but not the other keys close to the non-accented version. 108 inline ProximityType getMatchedProximityId(const int index, 109 const unsigned short c, const bool checkProximityChars, int *proximityIndex = 0) const { 110 const int *currentChars = getProximityCharsAt(index); 111 const int firstChar = currentChars[0]; 112 const unsigned short baseLowerC = toBaseLowerCase(c); 113 114 // The first char in the array is what user typed. If it matches right away, 115 // that means the user typed that same char for this pos. 116 if (firstChar == baseLowerC || firstChar == c) { 117 return EQUIVALENT_CHAR; 118 } 119 120 if (!checkProximityChars) return UNRELATED_CHAR; 121 122 // If the non-accented, lowercased version of that first character matches c, 123 // then we have a non-accented version of the accented character the user 124 // typed. Treat it as a close char. 125 if (toBaseLowerCase(firstChar) == baseLowerC) 126 return NEAR_PROXIMITY_CHAR; 127 128 // Not an exact nor an accent-alike match: search the list of close keys 129 int j = 1; 130 while (j < MAX_PROXIMITY_CHARS_SIZE_INTERNAL 131 && currentChars[j] > ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) { 132 const bool matched = (currentChars[j] == baseLowerC || currentChars[j] == c); 133 if (matched) { 134 if (proximityIndex) { 135 *proximityIndex = j; 136 } 137 return NEAR_PROXIMITY_CHAR; 138 } 139 ++j; 140 } 141 if (j < MAX_PROXIMITY_CHARS_SIZE_INTERNAL 142 && currentChars[j] == ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) { 143 ++j; 144 while (j < MAX_PROXIMITY_CHARS_SIZE_INTERNAL 145 && currentChars[j] > ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE) { 146 const bool matched = (currentChars[j] == baseLowerC || currentChars[j] == c); 147 if (matched) { 148 if (proximityIndex) { 149 *proximityIndex = j; 150 } 151 return ADDITIONAL_PROXIMITY_CHAR; 152 } 153 ++j; 154 } 155 } 156 157 // Was not included, signal this as an unrelated character. 158 return UNRELATED_CHAR; 159 } 160 getNormalizedSquaredDistance(const int inputIndex,const int proximityIndex)161 inline int getNormalizedSquaredDistance( 162 const int inputIndex, const int proximityIndex) const { 163 return mNormalizedSquaredDistances[ 164 inputIndex * MAX_PROXIMITY_CHARS_SIZE_INTERNAL + proximityIndex]; 165 } 166 getPrimaryInputWord()167 inline const unsigned short *getPrimaryInputWord() const { 168 return mPrimaryInputWord; 169 } 170 touchPositionCorrectionEnabled()171 inline bool touchPositionCorrectionEnabled() const { 172 return mTouchPositionCorrectionEnabled; 173 } 174 sameAsTyped(const unsigned short * word,int length)175 inline bool sameAsTyped(const unsigned short *word, int length) const { 176 if (length != mInputSize) { 177 return false; 178 } 179 const int *inputCodes = mInputCodes; 180 while (length--) { 181 if (static_cast<unsigned int>(*inputCodes) != static_cast<unsigned int>(*word)) { 182 return false; 183 } 184 inputCodes += MAX_PROXIMITY_CHARS_SIZE_INTERNAL; 185 word++; 186 } 187 return true; 188 } 189 190 int getDuration(const int index) const; 191 isUsed()192 bool isUsed() const { 193 return mInputSize > 0; 194 } 195 size()196 uint32_t size() const { 197 return mInputSize; 198 } 199 getInputX(const int index)200 int getInputX(const int index) const { 201 return mInputXs[index]; 202 } 203 getInputY(const int index)204 int getInputY(const int index) const { 205 return mInputYs[index]; 206 } 207 getLengthCache(const int index)208 int getLengthCache(const int index) const { 209 return mLengthCache[index]; 210 } 211 isContinuationPossible()212 bool isContinuationPossible() const { 213 return mIsContinuationPossible; 214 } 215 216 float getPointToKeyLength(const int inputIndex, const int charCode, const float scale) const; 217 218 int getSpaceY() const; 219 220 int32_t getAllPossibleChars( 221 const size_t startIndex, int32_t *const filter, const int32_t filterSize) const; 222 getRelativeSpeed(const int index)223 float getRelativeSpeed(const int index) const { 224 return mRelativeSpeeds[index]; 225 } 226 private: 227 DISALLOW_COPY_AND_ASSIGN(ProximityInfoState); 228 typedef hash_map_compat<int, float> NearKeysDistanceMap; 229 ///////////////////////////////////////// 230 // Defined in proximity_info_state.cpp // 231 ///////////////////////////////////////// 232 float calculateNormalizedSquaredDistance(const int keyIndex, const int inputIndex) const; 233 234 float calculateSquaredDistanceFromSweetSpotCenter( 235 const int keyIndex, const int inputIndex) const; 236 237 bool pushTouchPoint(const int inputIndex, const int nodeChar, int x, int y, const int time, 238 const bool sample, const bool isLastPoint, 239 NearKeysDistanceMap *const currentNearKeysDistances, 240 const NearKeysDistanceMap *const prevNearKeysDistances, 241 const NearKeysDistanceMap *const prevPrevNearKeysDistances); 242 ///////////////////////////////////////// 243 // Defined here // 244 ///////////////////////////////////////// square(const float x)245 inline float square(const float x) const { return x * x; } 246 hasInputCoordinates()247 bool hasInputCoordinates() const { 248 return mInputXs.size() > 0 && mInputYs.size() > 0; 249 } 250 getProximityCharsAt(const int index)251 inline const int *getProximityCharsAt(const int index) const { 252 return mInputCodes + (index * MAX_PROXIMITY_CHARS_SIZE_INTERNAL); 253 } 254 255 float updateNearKeysDistances(const int x, const int y, 256 NearKeysDistanceMap *const currentNearKeysDistances); 257 bool isPrevLocalMin(const NearKeysDistanceMap *const currentNearKeysDistances, 258 const NearKeysDistanceMap *const prevNearKeysDistances, 259 const NearKeysDistanceMap *const prevPrevNearKeysDistances) const; 260 float getPointScore( 261 const int x, const int y, const int time, const bool last, const float nearest, 262 const NearKeysDistanceMap *const currentNearKeysDistances, 263 const NearKeysDistanceMap *const prevNearKeysDistances, 264 const NearKeysDistanceMap *const prevPrevNearKeysDistances) const; 265 bool checkAndReturnIsContinuationPossible(const int inputSize, const int *const xCoordinates, 266 const int *const yCoordinates, const int *const times); 267 void popInputData(); 268 269 // const 270 const ProximityInfo *mProximityInfo; 271 float mMaxPointToKeyLength; 272 bool mHasTouchPositionCorrectionData; 273 int mMostCommonKeyWidthSquare; 274 std::string mLocaleStr; 275 int mKeyCount; 276 int mCellHeight; 277 int mCellWidth; 278 int mGridHeight; 279 int mGridWidth; 280 bool mIsContinuationPossible; 281 282 std::vector<int> mInputXs; 283 std::vector<int> mInputYs; 284 std::vector<int> mTimes; 285 std::vector<int> mInputIndice; 286 std::vector<float> mDistanceCache; 287 std::vector<int> mLengthCache; 288 std::vector<float> mRelativeSpeeds; 289 std::vector<NearKeycodesSet> mNearKeysVector; 290 bool mTouchPositionCorrectionEnabled; 291 int32_t mInputCodes[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH_INTERNAL]; 292 int mNormalizedSquaredDistances[MAX_PROXIMITY_CHARS_SIZE_INTERNAL * MAX_WORD_LENGTH_INTERNAL]; 293 int mInputSize; 294 unsigned short mPrimaryInputWord[MAX_WORD_LENGTH_INTERNAL]; 295 }; 296 } // namespace latinime 297 #endif // LATINIME_PROXIMITY_INFO_STATE_H 298