LatinIME/native/jni/src/proximity_info_state.h

/*
 * 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(), mRelativeSpeeds(), 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 getRelativeSpeed(const int index) const {
        return mRelativeSpeeds[index];
    }
 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<float> mRelativeSpeeds;
    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