| /* |
| * 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. |
| */ |
| |
| package com.android.inputmethod.keyboard.internal; |
| |
| import com.android.inputmethod.latin.ResizableIntArray; |
| |
| public final class GestureStrokeWithPreviewPoints extends GestureStroke { |
| public static final int PREVIEW_CAPACITY = 256; |
| |
| private final ResizableIntArray mPreviewEventTimes = new ResizableIntArray(PREVIEW_CAPACITY); |
| private final ResizableIntArray mPreviewXCoordinates = new ResizableIntArray(PREVIEW_CAPACITY); |
| private final ResizableIntArray mPreviewYCoordinates = new ResizableIntArray(PREVIEW_CAPACITY); |
| |
| private int mStrokeId; |
| private int mLastPreviewSize; |
| private final HermiteInterpolator mInterpolator = new HermiteInterpolator(); |
| private int mLastInterpolatedPreviewIndex; |
| |
| private int mLastX; |
| private int mLastY; |
| private double mMinPreviewSamplingDistance; |
| private double mDistanceFromLastSample; |
| private double mInterpolationDistanceThreshold; |
| |
| // TODO: Move these constants to resource. |
| // TODO: Use "dp" instead of ratio to the keyWidth because table has rather large keys. |
| // The minimum trail distance between sample points for preview in keyWidth unit when using |
| // interpolation. |
| private static final float MIN_PREVIEW_SAMPLING_RATIO_TO_KEY_WIDTH = 0.2f; |
| // The angular threshold to use interpolation in radian. PI/12 is 15 degree. |
| private static final double INTERPOLATION_ANGULAR_THRESHOLD = Math.PI / 12.0d; |
| // The distance threshold to use interpolation in keyWidth unit. |
| private static final float INTERPOLATION_DISTANCE_THRESHOLD_TO_KEY_WIDTH = 0.5f; |
| private static final int MAX_INTERPOLATION_PARTITIONS = 6; |
| |
| public GestureStrokeWithPreviewPoints(final int pointerId, final GestureStrokeParams params) { |
| super(pointerId, params); |
| } |
| |
| @Override |
| protected void reset() { |
| super.reset(); |
| mStrokeId++; |
| mLastPreviewSize = 0; |
| mLastInterpolatedPreviewIndex = 0; |
| mPreviewEventTimes.setLength(0); |
| mPreviewXCoordinates.setLength(0); |
| mPreviewYCoordinates.setLength(0); |
| } |
| |
| public int getGestureStrokeId() { |
| return mStrokeId; |
| } |
| |
| @Override |
| public void setKeyboardGeometry(final int keyWidth, final int keyboardHeight) { |
| super.setKeyboardGeometry(keyWidth, keyboardHeight); |
| mMinPreviewSamplingDistance = keyWidth * MIN_PREVIEW_SAMPLING_RATIO_TO_KEY_WIDTH; |
| mInterpolationDistanceThreshold = keyWidth * INTERPOLATION_DISTANCE_THRESHOLD_TO_KEY_WIDTH; |
| } |
| |
| private boolean needsSampling(final int x, final int y) { |
| mDistanceFromLastSample += Math.hypot(x - mLastX, y - mLastY); |
| mLastX = x; |
| mLastY = y; |
| final boolean isDownEvent = (mPreviewEventTimes.getLength() == 0); |
| if (mDistanceFromLastSample >= mMinPreviewSamplingDistance || isDownEvent) { |
| mDistanceFromLastSample = 0.0d; |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean addPointOnKeyboard(final int x, final int y, final int time, |
| final boolean isMajorEvent) { |
| if (needsSampling(x, y)) { |
| mPreviewEventTimes.add(time); |
| mPreviewXCoordinates.add(x); |
| mPreviewYCoordinates.add(y); |
| } |
| return super.addPointOnKeyboard(x, y, time, isMajorEvent); |
| |
| } |
| |
| public void appendPreviewStroke(final ResizableIntArray eventTimes, |
| final ResizableIntArray xCoords, final ResizableIntArray yCoords) { |
| final int length = mPreviewEventTimes.getLength() - mLastPreviewSize; |
| if (length <= 0) { |
| return; |
| } |
| eventTimes.append(mPreviewEventTimes, mLastPreviewSize, length); |
| xCoords.append(mPreviewXCoordinates, mLastPreviewSize, length); |
| yCoords.append(mPreviewYCoordinates, mLastPreviewSize, length); |
| mLastPreviewSize = mPreviewEventTimes.getLength(); |
| } |
| |
| /** |
| * Calculate interpolated points between the last interpolated point and the end of the trail. |
| * And return the start index of the last interpolated segment of input arrays because it |
| * may need to recalculate the interpolated points in the segment if further segments are |
| * added to this stroke. |
| * |
| * @param lastInterpolatedIndex the start index of the last interpolated segment of |
| * <code>eventTimes</code>, <code>xCoords</code>, and <code>yCoords</code>. |
| * @param eventTimes the event time array of gesture preview trail to be drawn. |
| * @param xCoords the x-coordinates array of gesture preview trail to be drawn. |
| * @param yCoords the y-coordinates array of gesture preview trail to be drawn. |
| * @return the start index of the last interpolated segment of input arrays. |
| */ |
| public int interpolateStrokeAndReturnStartIndexOfLastSegment(final int lastInterpolatedIndex, |
| final ResizableIntArray eventTimes, final ResizableIntArray xCoords, |
| final ResizableIntArray yCoords) { |
| final int size = mPreviewEventTimes.getLength(); |
| final int[] pt = mPreviewEventTimes.getPrimitiveArray(); |
| final int[] px = mPreviewXCoordinates.getPrimitiveArray(); |
| final int[] py = mPreviewYCoordinates.getPrimitiveArray(); |
| mInterpolator.reset(px, py, 0, size); |
| // The last segment of gesture stroke needs to be interpolated again because the slope of |
| // the tangent at the last point isn't determined. |
| int lastInterpolatedDrawIndex = lastInterpolatedIndex; |
| int d1 = lastInterpolatedIndex; |
| for (int p2 = mLastInterpolatedPreviewIndex + 1; p2 < size; p2++) { |
| final int p1 = p2 - 1; |
| final int p0 = p1 - 1; |
| final int p3 = p2 + 1; |
| mLastInterpolatedPreviewIndex = p1; |
| lastInterpolatedDrawIndex = d1; |
| mInterpolator.setInterval(p0, p1, p2, p3); |
| final double m1 = Math.atan2(mInterpolator.mSlope1Y, mInterpolator.mSlope1X); |
| final double m2 = Math.atan2(mInterpolator.mSlope2Y, mInterpolator.mSlope2X); |
| final double deltaAngle = Math.abs(angularDiff(m2, m1)); |
| final int partitionsByAngle = (int)Math.ceil( |
| deltaAngle / INTERPOLATION_ANGULAR_THRESHOLD); |
| final double deltaDistance = Math.hypot(mInterpolator.mP1X - mInterpolator.mP2X, |
| mInterpolator.mP1Y - mInterpolator.mP2Y); |
| final int partitionsByDistance = (int)Math.ceil(deltaDistance |
| / mInterpolationDistanceThreshold); |
| final int partitions = Math.min(MAX_INTERPOLATION_PARTITIONS, |
| Math.max(partitionsByAngle, partitionsByDistance)); |
| final int t1 = eventTimes.get(d1); |
| final int dt = pt[p2] - pt[p1]; |
| d1++; |
| for (int i = 1; i < partitions; i++) { |
| final float t = i / (float)partitions; |
| mInterpolator.interpolate(t); |
| eventTimes.add(d1, (int)(dt * t) + t1); |
| xCoords.add(d1, (int)mInterpolator.mInterpolatedX); |
| yCoords.add(d1, (int)mInterpolator.mInterpolatedY); |
| d1++; |
| } |
| eventTimes.add(d1, pt[p2]); |
| xCoords.add(d1, px[p2]); |
| yCoords.add(d1, py[p2]); |
| } |
| return lastInterpolatedDrawIndex; |
| } |
| |
| private static final double TWO_PI = Math.PI * 2.0d; |
| |
| /** |
| * Calculate the angular of rotation from <code>a0</code> to <code>a1</code>. |
| * |
| * @param a1 the angular to which the rotation ends. |
| * @param a0 the angular from which the rotation starts. |
| * @return the angular rotation value from a0 to a1, normalized to [-PI, +PI]. |
| */ |
| private static double angularDiff(final double a1, final double a0) { |
| double deltaAngle = a1 - a0; |
| while (deltaAngle > Math.PI) { |
| deltaAngle -= TWO_PI; |
| } |
| while (deltaAngle < -Math.PI) { |
| deltaAngle += TWO_PI; |
| } |
| return deltaAngle; |
| } |
| } |