1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/*
* 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.common.ResizableIntArray;
/**
* This class holds drawing points to represent a gesture stroke on the screen.
*/
public final class GestureStrokeDrawingPoints {
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 final GestureStrokeDrawingParams mDrawingParams;
private int mStrokeId;
private int mLastPreviewSize;
private final HermiteInterpolator mInterpolator = new HermiteInterpolator();
private int mLastInterpolatedPreviewIndex;
private int mLastX;
private int mLastY;
private double mDistanceFromLastSample;
public GestureStrokeDrawingPoints(final GestureStrokeDrawingParams drawingParams) {
mDrawingParams = drawingParams;
}
private void reset() {
mStrokeId++;
mLastPreviewSize = 0;
mLastInterpolatedPreviewIndex = 0;
mPreviewEventTimes.setLength(0);
mPreviewXCoordinates.setLength(0);
mPreviewYCoordinates.setLength(0);
}
public int getGestureStrokeId() {
return mStrokeId;
}
public void onDownEvent(final int x, final int y, final int elapsedTimeSinceFirstDown) {
reset();
onMoveEvent(x, y, elapsedTimeSinceFirstDown);
}
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 >= mDrawingParams.mMinSamplingDistance || isDownEvent) {
mDistanceFromLastSample = 0.0d;
return true;
}
return false;
}
public void onMoveEvent(final int x, final int y, final int elapsedTimeSinceFirstDown) {
if (needsSampling(x, y)) {
mPreviewEventTimes.add(elapsedTimeSinceFirstDown);
mPreviewXCoordinates.add(x);
mPreviewYCoordinates.add(y);
}
}
/**
* Append sampled preview points.
*
* @param eventTimes the event time array of gesture trail to be drawn.
* @param xCoords the x-coordinates array of gesture trail to be drawn.
* @param yCoords the y-coordinates array of gesture trail to be drawn.
* @param types the point types array of gesture trail. This is valid only when
* {@link GestureTrailDrawingPoints#DEBUG_SHOW_POINTS} is true.
*/
public void appendPreviewStroke(final ResizableIntArray eventTimes,
final ResizableIntArray xCoords, final ResizableIntArray yCoords,
final ResizableIntArray types) {
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);
if (GestureTrailDrawingPoints.DEBUG_SHOW_POINTS) {
types.fill(GestureTrailDrawingPoints.POINT_TYPE_SAMPLED, types.getLength(), 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 trail to be drawn.
* @param xCoords the x-coordinates array of gesture trail to be drawn.
* @param yCoords the y-coordinates array of gesture trail to be drawn.
* @param types the point types array of gesture trail. This is valid only when
* {@link GestureTrailDrawingPoints#DEBUG_SHOW_POINTS} is true.
* @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 ResizableIntArray types) {
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 segmentsByAngle = (int)Math.ceil(
deltaAngle / mDrawingParams.mMaxInterpolationAngularThreshold);
final double deltaDistance = Math.hypot(mInterpolator.mP1X - mInterpolator.mP2X,
mInterpolator.mP1Y - mInterpolator.mP2Y);
final int segmentsByDistance = (int)Math.ceil(deltaDistance
/ mDrawingParams.mMaxInterpolationDistanceThreshold);
final int segments = Math.min(mDrawingParams.mMaxInterpolationSegments,
Math.max(segmentsByAngle, segmentsByDistance));
final int t1 = eventTimes.get(d1);
final int dt = pt[p2] - pt[p1];
d1++;
for (int i = 1; i < segments; i++) {
final float t = i / (float)segments;
mInterpolator.interpolate(t);
eventTimes.addAt(d1, (int)(dt * t) + t1);
xCoords.addAt(d1, (int)mInterpolator.mInterpolatedX);
yCoords.addAt(d1, (int)mInterpolator.mInterpolatedY);
if (GestureTrailDrawingPoints.DEBUG_SHOW_POINTS) {
types.addAt(d1, GestureTrailDrawingPoints.POINT_TYPE_INTERPOLATED);
}
d1++;
}
eventTimes.addAt(d1, pt[p2]);
xCoords.addAt(d1, px[p2]);
yCoords.addAt(d1, py[p2]);
if (GestureTrailDrawingPoints.DEBUG_SHOW_POINTS) {
types.addAt(d1, GestureTrailDrawingPoints.POINT_TYPE_SAMPLED);
}
}
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;
}
}
|
