FileDocCategorySizeDatePackage
GestureStroke.javaAPI DocAndroid 5.1 API7031Thu Mar 12 22:22:10 GMT 2015android.gesture

GestureStroke

public class GestureStroke extends Object
A gesture stroke started on a touch down and ended on a touch up. A stroke consists of a sequence of timed points. One or multiple strokes form a gesture.

Fields Summary
static final float
TOUCH_TOLERANCE
public final android.graphics.RectF
boundingBox
public final float
length
public final float[]
points
private final long[]
timestamps
private android.graphics.Path
mCachedPath
Constructors Summary
public GestureStroke(ArrayList points)
A constructor that constructs a gesture stroke from a list of gesture points.

param
points


                         
       
        final int count = points.size();
        final float[] tmpPoints = new float[count * 2];
        final long[] times = new long[count];

        RectF bx = null;
        float len = 0;
        int index = 0;

        for (int i = 0; i < count; i++) {
            final GesturePoint p = points.get(i);
            tmpPoints[i * 2] = p.x;
            tmpPoints[i * 2 + 1] = p.y;
            times[index] = p.timestamp;

            if (bx == null) {
                bx = new RectF();
                bx.top = p.y;
                bx.left = p.x;
                bx.right = p.x;
                bx.bottom = p.y;
                len = 0;
            } else {
                len += Math.sqrt(Math.pow(p.x - tmpPoints[(i - 1) * 2], 2)
                        + Math.pow(p.y - tmpPoints[(i -1 ) * 2 + 1], 2));
                bx.union(p.x, p.y);
            }
            index++;
        }
        
        timestamps = times;
        this.points = tmpPoints;
        boundingBox = bx;
        length = len;
private GestureStroke(android.graphics.RectF bbx, float len, float[] pts, long[] times)
A faster constructor specially for cloning a stroke.

        boundingBox = new RectF(bbx.left, bbx.top, bbx.right, bbx.bottom);
        length = len;
        points = pts.clone();
        timestamps = times.clone();
Methods Summary
public voidclearPath()
Invalidates the cached path that is used to render the stroke.

        if (mCachedPath != null) mCachedPath.rewind();
public java.lang.Objectclone()

        return new GestureStroke(boundingBox, length, points, timestamps);
public OrientedBoundingBoxcomputeOrientedBoundingBox()
Computes an oriented bounding box of the stroke.

return
OrientedBoundingBox

        return GestureUtils.computeOrientedBoundingBox(points);
static android.gesture.GestureStrokedeserialize(java.io.DataInputStream in)

        // Number of points
        final int count = in.readInt();

        final ArrayList<GesturePoint> points = new ArrayList<GesturePoint>(count);
        for (int i = 0; i < count; i++) {
            points.add(GesturePoint.deserialize(in));
        }

        return new GestureStroke(points);
voiddraw(android.graphics.Canvas canvas, android.graphics.Paint paint)
Draws the stroke with a given canvas and paint.

param
canvas

        if (mCachedPath == null) {
            makePath();
        }

        canvas.drawPath(mCachedPath, paint);
public android.graphics.PathgetPath()

        if (mCachedPath == null) {
            makePath();
        }

        return mCachedPath;
private voidmakePath()

        final float[] localPoints = points;
        final int count = localPoints.length;

        Path path = null;

        float mX = 0;
        float mY = 0;

        for (int i = 0; i < count; i += 2) {
            float x = localPoints[i];
            float y = localPoints[i + 1];
            if (path == null) {
                path = new Path();
                path.moveTo(x, y);
                mX = x;
                mY = y;
            } else {
                float dx = Math.abs(x - mX);
                float dy = Math.abs(y - mY);
                if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
                    path.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2);
                    mX = x;
                    mY = y;
                }
            }
        }

        mCachedPath = path;
voidserialize(java.io.DataOutputStream out)

        final float[] pts = points;
        final long[] times = timestamps;
        final int count = points.length;

        // Write number of points
        out.writeInt(count / 2);

        for (int i = 0; i < count; i += 2) {
            // Write X
            out.writeFloat(pts[i]);
            // Write Y
            out.writeFloat(pts[i + 1]);
            // Write timestamp
            out.writeLong(times[i / 2]);
        }
public android.graphics.PathtoPath(float width, float height, int numSample)
Converts the stroke to a Path of a given number of points.

param
width the width of the bounding box of the target path
param
height the height of the bounding box of the target path
param
numSample the number of points needed
return
the path

        final float[] pts = GestureUtils.temporalSampling(this, numSample);
        final RectF rect = boundingBox;

        GestureUtils.translate(pts, -rect.left, -rect.top);
        
        float sx = width / rect.width();
        float sy = height / rect.height();
        float scale = sx > sy ? sy : sx;
        GestureUtils.scale(pts, scale, scale);

        float mX = 0;
        float mY = 0;

        Path path = null;

        final int count = pts.length;

        for (int i = 0; i < count; i += 2) {
            float x = pts[i];
            float y = pts[i + 1];
            if (path == null) {
                path = new Path();
                path.moveTo(x, y);
                mX = x;
                mY = y;
            } else {
                float dx = Math.abs(x - mX);
                float dy = Math.abs(y - mY);
                if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {
                    path.quadTo(mX, mY, (x + mX) / 2, (y + mY) / 2);
                    mX = x;
                    mY = y;
                }
            }
        }

        return path;