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 <cstring> // for memset() 21 #include <vector> 22 23 #include "char_utils.h" 24 #include "defines.h" 25 #include "hash_map_compat.h" 26 #include "proximity_info_params.h" 27 #include "proximity_info_state_utils.h" 28 29 namespace latinime { 30 31 class ProximityInfo; 32 33 class ProximityInfoState { 34 public: 35 ///////////////////////////////////////// 36 // Defined in proximity_info_state.cpp // 37 ///////////////////////////////////////// 38 void initInputParams(const int pointerId, const float maxPointToKeyLength, 39 const ProximityInfo *proximityInfo, const int *const inputCodes, 40 const int inputSize, const int *xCoordinates, const int *yCoordinates, 41 const int *const times, const int *const pointerIds, const bool isGeometric); 42 43 ///////////////////////////////////////// 44 // Defined here // 45 ///////////////////////////////////////// 46 AK_FORCE_INLINE ProximityInfoState() 47 : mProximityInfo(0), mMaxPointToKeyLength(0.0f), mAverageSpeed(0.0f), 48 mHasTouchPositionCorrectionData(false), mMostCommonKeyWidthSquare(0), 49 mKeyCount(0), mCellHeight(0), mCellWidth(0), mGridHeight(0), mGridWidth(0), 50 mIsContinuousSuggestionPossible(false), mSampledInputXs(), mSampledInputYs(), 51 mSampledTimes(), mSampledInputIndice(), mSampledLengthCache(), 52 mBeelineSpeedPercentiles(), mSampledNormalizedSquaredLengthCache(), mSpeedRates(), 53 mDirections(), mCharProbabilities(), mSampledNearKeySets(), mSampledSearchKeySets(), 54 mSampledSearchKeyVectors(), mTouchPositionCorrectionEnabled(false), 55 mSampledInputSize(0), mMostProbableStringProbability(0.0f) { 56 memset(mInputProximities, 0, sizeof(mInputProximities)); 57 memset(mNormalizedSquaredDistances, 0, sizeof(mNormalizedSquaredDistances)); 58 memset(mPrimaryInputWord, 0, sizeof(mPrimaryInputWord)); 59 memset(mMostProbableString, 0, sizeof(mMostProbableString)); 60 } 61 62 // Non virtual inline destructor -- never inherit this class 63 AK_FORCE_INLINE ~ProximityInfoState() {} 64 65 inline int getPrimaryCodePointAt(const int index) const { 66 return getProximityCodePointsAt(index)[0]; 67 } 68 69 inline bool sameAsTyped(const int *word, int length) const { 70 if (length != mSampledInputSize) { 71 return false; 72 } 73 const int *inputProximities = mInputProximities; 74 while (length--) { 75 if (*inputProximities != *word) { 76 return false; 77 } 78 inputProximities += MAX_PROXIMITY_CHARS_SIZE; 79 word++; 80 } 81 return true; 82 } 83 84 AK_FORCE_INLINE bool existsCodePointInProximityAt(const int index, const int c) const { 85 const int *codePoints = getProximityCodePointsAt(index); 86 int i = 0; 87 while (codePoints[i] > 0 && i < MAX_PROXIMITY_CHARS_SIZE) { 88 if (codePoints[i++] == c) { 89 return true; 90 } 91 } 92 return false; 93 } 94 95 inline bool existsAdjacentProximityChars(const int index) const { 96 if (index < 0 || index >= mSampledInputSize) return false; 97 const int currentCodePoint = getPrimaryCodePointAt(index); 98 const int leftIndex = index - 1; 99 if (leftIndex >= 0 && existsCodePointInProximityAt(leftIndex, currentCodePoint)) { 100 return true; 101 } 102 const int rightIndex = index + 1; 103 if (rightIndex < mSampledInputSize 104 && existsCodePointInProximityAt(rightIndex, currentCodePoint)) { 105 return true; 106 } 107 return false; 108 } 109 110 inline int getNormalizedSquaredDistance( 111 const int inputIndex, const int proximityIndex) const { 112 return mNormalizedSquaredDistances[ 113 inputIndex * MAX_PROXIMITY_CHARS_SIZE + proximityIndex]; 114 } 115 116 inline const int *getPrimaryInputWord() const { 117 return mPrimaryInputWord; 118 } 119 120 inline bool touchPositionCorrectionEnabled() const { 121 return mTouchPositionCorrectionEnabled; 122 } 123 124 bool isUsed() const { 125 return mSampledInputSize > 0; 126 } 127 128 int size() const { 129 return mSampledInputSize; 130 } 131 132 int getInputX(const int index) const { 133 return mSampledInputXs[index]; 134 } 135 136 int getInputY(const int index) const { 137 return mSampledInputYs[index]; 138 } 139 140 bool hasSpaceProximity(const int index) const; 141 142 int getLengthCache(const int index) const { 143 return mSampledLengthCache[index]; 144 } 145 146 bool isContinuousSuggestionPossible() const { 147 return mIsContinuousSuggestionPossible; 148 } 149 150 // TODO: Rename s/Length/NormalizedSquaredLength/ 151 float getPointToKeyByIdLength(const int inputIndex, const int keyId) const; 152 // TODO: Rename s/Length/NormalizedSquaredLength/ 153 float getPointToKeyLength(const int inputIndex, const int codePoint) const; 154 155 ProximityType getProximityType(const int index, const int codePoint, 156 const bool checkProximityChars, int *proximityIndex = 0) const; 157 158 ProximityType getProximityTypeG(const int index, const int codePoint) const; 159 160 const std::vector<int> *getSearchKeyVector(const int index) const { 161 return &mSampledSearchKeyVectors[index]; 162 } 163 164 float getSpeedRate(const int index) const { 165 return mSpeedRates[index]; 166 } 167 168 AK_FORCE_INLINE int getBeelineSpeedPercentile(const int id) const { 169 return mBeelineSpeedPercentiles[id]; 170 } 171 172 AK_FORCE_INLINE DoubleLetterLevel getDoubleLetterLevel(const int id) const { 173 const int beelineSpeedRate = getBeelineSpeedPercentile(id); 174 if (beelineSpeedRate == 0) { 175 return A_STRONG_DOUBLE_LETTER; 176 } else if (beelineSpeedRate 177 < ProximityInfoParams::MIN_DOUBLE_LETTER_BEELINE_SPEED_PERCENTILE) { 178 return A_DOUBLE_LETTER; 179 } else { 180 return NOT_A_DOUBLE_LETTER; 181 } 182 } 183 184 float getDirection(const int index) const { 185 return mDirections[index]; 186 } 187 // get xy direction 188 float getDirection(const int x, const int y) const; 189 190 float getMostProbableString(int *const codePointBuf) const; 191 192 float getProbability(const int index, const int charCode) const; 193 194 float getLineToKeyDistance( 195 const int from, const int to, const int keyId, const bool extend) const; 196 197 bool isKeyInSerchKeysAfterIndex(const int index, const int keyId) const; 198 199 private: 200 DISALLOW_COPY_AND_ASSIGN(ProximityInfoState); 201 ///////////////////////////////////////// 202 // Defined in proximity_info_state.cpp // 203 ///////////////////////////////////////// 204 float calculateNormalizedSquaredDistance(const int keyIndex, const int inputIndex) const; 205 206 float calculateSquaredDistanceFromSweetSpotCenter( 207 const int keyIndex, const int inputIndex) const; 208 209 ///////////////////////////////////////// 210 // Defined here // 211 ///////////////////////////////////////// 212 213 inline const int *getProximityCodePointsAt(const int index) const { 214 return ProximityInfoStateUtils::getProximityCodePointsAt(mInputProximities, index); 215 } 216 217 // const 218 const ProximityInfo *mProximityInfo; 219 float mMaxPointToKeyLength; 220 float mAverageSpeed; 221 bool mHasTouchPositionCorrectionData; 222 int mMostCommonKeyWidthSquare; 223 int mKeyCount; 224 int mCellHeight; 225 int mCellWidth; 226 int mGridHeight; 227 int mGridWidth; 228 bool mIsContinuousSuggestionPossible; 229 230 std::vector<int> mSampledInputXs; 231 std::vector<int> mSampledInputYs; 232 std::vector<int> mSampledTimes; 233 std::vector<int> mSampledInputIndice; 234 std::vector<int> mSampledLengthCache; 235 std::vector<int> mBeelineSpeedPercentiles; 236 std::vector<float> mSampledNormalizedSquaredLengthCache; 237 std::vector<float> mSpeedRates; 238 std::vector<float> mDirections; 239 // probabilities of skipping or mapping to a key for each point. 240 std::vector<hash_map_compat<int, float> > mCharProbabilities; 241 // The vector for the key code set which holds nearby keys for each sampled input point 242 // 1. Used to calculate the probability of the key 243 // 2. Used to calculate mSampledSearchKeySets 244 std::vector<ProximityInfoStateUtils::NearKeycodesSet> mSampledNearKeySets; 245 // The vector for the key code set which holds nearby keys of some trailing sampled input points 246 // for each sampled input point. These nearby keys contain the next characters which can be in 247 // the dictionary. Specifically, currently we are looking for keys nearby trailing sampled 248 // inputs including the current input point. 249 std::vector<ProximityInfoStateUtils::NearKeycodesSet> mSampledSearchKeySets; 250 std::vector<std::vector<int> > mSampledSearchKeyVectors; 251 bool mTouchPositionCorrectionEnabled; 252 int mInputProximities[MAX_PROXIMITY_CHARS_SIZE * MAX_WORD_LENGTH]; 253 int mNormalizedSquaredDistances[MAX_PROXIMITY_CHARS_SIZE * MAX_WORD_LENGTH]; 254 int mSampledInputSize; 255 int mPrimaryInputWord[MAX_WORD_LENGTH]; 256 float mMostProbableStringProbability; 257 int mMostProbableString[MAX_WORD_LENGTH]; 258 }; 259 } // namespace latinime 260 #endif // LATINIME_PROXIMITY_INFO_STATE_H 261