Android path 路径相关

作者: zhaoyubetter | 来源:发表于2017-03-15 16:09 被阅读1670次

参考：
https://juejin.im/post/58ce7fe561ff4b006c9a63c6
https://juejin.im/post/58c3b88a44d904006984e58d
https://github.com/lguipeng/BubbleView
https://ghui.me/post/2015/10/android-graphics-path/
http://www.jianshu.com/p/d6b4a9ad022e
弹性圆的绘制：http://www.jianshu.com/p/791d3a791ec2
google api demo
PathMeasure
http://blog.csdn.net/u013831257/article/details/51565591

贝塞尔曲线：
https://juejin.im/post/58ce7f0461ff4b006c9a5e66

Path##

Path 表示路径，可使用Canvas.drawPath方法将其绘制出来，Path不仅可以使用Paint的填充模式和描边模式，也可以用画布裁剪和或者画文字。

Path 是Android中一种绘制工具，表示路径，可以画各种复杂的图形，如：曲线、轮廓等等；

基本方法##

**1. moveTo(x, y) ** ：移动到起点；
** 2. lineTo(x, y) **: 绘制直线；
3. arcTo(rectF, startAngle,sweepAngle): **
在RectF中绘制弧度（rect为弧度的外切rect）, 从起点角度start,绘制sweep个角度；
** 4. arcTo(rectF, startAngle, sweepAngle, true)：表示在rect绘制弧度，并且与 moveTo 的起点分离，类似于另开一个Path；文档解释为：
If true, always begin a new contour with the arc

        mPath.reset();
        RectF rect = new RectF(100, 100, 200, 200);
        mPaint.setColor(Color.RED);
        canvas.drawRect(rect, mPaint);
        mPaint.setColor(Color.GREEN);
        mPath.arcTo(rect, 0, 90);
        canvas.drawPath(mPath, mPaint);

效果图：

arcTo

**5. reset(): ** 表示清空 path；
**6. addOval(rectF, direction): ** 添加一个椭圆，rectF为此椭圆的外切rect；

canvas.translate(200, 200);
RectF oval = new RectF(100, 100, 300, 400);
mPaint.setColor(Color.RED);
canvas.drawRect(oval, mPaint);
mPaint.setColor(Color.GREEN);
mPath.addOval(oval, Path.Direction.CW);// 外，CCW，内
canvas.drawPath(mPath, mPaint);
// 绘制路径上的文字
canvas.drawTextOnPath("sdjfsklfjksiewjf快睡觉富士康福克斯司法局斯柯达", mPath, 0, 0, mTextPaint);
canvas.restore();

效果图：

drawOval
**7.addCircle(x, y, radius,Direction) : ** 绘制圆形；
**8.addPath(path) : ** 添加新的path到当前path；
9.quadTo(x1,y1,x2,y2) : 绘制二次贝塞尔曲线,其中 (x1,y1)为控制点，(x2,y2)为终点

// 曲线
        mPath.moveTo(50, 50);
        // 贝塞尔曲线(二阶)
        mPath.quadTo(200, 200, 300, 100);   // 以(200,200)为控制点，画贝塞尔曲线
        canvas.drawPath(mPath, mPaint);

图示：

二级贝塞尔
10.cubicTo(x1, y1, x2, y2, x3, y3)：三阶贝塞尔，其中(x1,y1),(x2,y2)为控制点，(x3,y3)为终点

rXXX方法##

rXXX与原方法的区别是：r方法是基于当前绘制开始点的offest,比如当前paint位于 (100,100)处，则使用rLineTo(100,100)方法绘制出来的直线是从(100,100)到(200,200)的一条直线，由此可见rXXX方法方便用来基于之前的绘制作连续绘制。

        mPath.reset();
        canvas.translate(500, 500);
        mPath.moveTo(100, 100);
        mPath.lineTo(400, 400);
        mPath.lineTo(400, 100);

        mPath.rLineTo(100, 300);  // mPath.LineTo(100, 300)
        canvas.drawPath(mPath, mPaint);

示例：

rLineTo(100, 300)

lineTo(100, 300)

Path.op方法（API >= 19 ）##

用于将2个对象path做相应的运算组合，有点类似于数学上的集合运算

        canvas.translate(0, 200);
        Path path1 = new Path();
        path1.addCircle(150, 150, 100, Path.Direction.CW);
        Path path2 = new Path();
        path2.addCircle(200, 200, 100, Path.Direction.CW);
        path1.op(path2, Path.Op.INTERSECT); // (相交的部分)Union (inclusive-or) the two paths
        canvas.drawPath(path1, mPaint);

图示：

Path.Op.INTERSECT

总结如下：

Path.Op.DIFFERENCE 减去path1中path1与path2都存在的部分;
path1 = (path1 - path1 ∩ path2)
Path.Op.INTERSECT 保留path1与path2共同的部分;
path1 = path1 ∩ path2
Path.Op.UNION 取path1与path2的并集;
path1 = path1 ∪ path2
Path.Op.REVERSE_DIFFERENCE 与DIFFERENCE刚好相反;
path1 = path2 - (path1 ∩ path2)
Path.Op.XOR 与INTERSECT刚好相反;
path1 = (path1 ∪ path2) - (path1 ∩ path2)

path的例子：圆角矩形##

在Android 中可用 canvas.drawRoundRect 来实现圆角矩形，如果不怕麻烦，
也可以使用 path 来实现；
如下例子：

  private static final float DEFAULT_RADIUS = 50;

@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawRect(canvas);
    }

    private void drawRect(Canvas canvas) {

        RectF rectF = null;
        // 圆弧起点
        mPath.moveTo(100 + DEFAULT_RADIUS, 100);
        mPath.lineTo(500 - DEFAULT_RADIUS, 100);

        // 右上角圆角 (从 rectF 的中间开始画, path 为路径所以会连起来)
        rectF = new RectF(500 - DEFAULT_RADIUS, 100, 500, (100 + DEFAULT_RADIUS));
        mPath.arcTo(rectF, 270, 90);

        // 右下圆角
        mPath.lineTo(500, 300 - DEFAULT_RADIUS);
        rectF = new RectF(500 - DEFAULT_RADIUS, 300 - DEFAULT_RADIUS, 500, 300);
        mPath.arcTo(rectF, 0, 90);

        // 左下圆角
        mPath.lineTo(100 + DEFAULT_RADIUS, 300);
        rectF = new RectF(100, 300 - DEFAULT_RADIUS, 100 + DEFAULT_RADIUS, 300);
        mPath.arcTo(rectF, 90, 90);

        // 左上圆角
        mPath.lineTo(100, 100 + DEFAULT_RADIUS);
        rectF = new RectF(100, 100, 100 + DEFAULT_RADIUS, 100 + DEFAULT_RADIUS);
        mPath.arcTo(rectF, 180, 90);

//      mPath.lineTo(100, 300);
        mPath.close();

        canvas.drawPath(mPath, mPaint);
    }

效果图：

path圆角

聊天气泡形状##

这用drawRoundRect就不能实现了。使用path，简单修改一下就可以了

              //。。。。省略
              // 左下圆角
        mPath.lineTo(100 + DEFAULT_RADIUS, 300);
        rectF = new RectF(100, 300 - DEFAULT_RADIUS, 100 + DEFAULT_RADIUS, 300);
        mPath.arcTo(rectF, 90, 90);


        // 小三角形,
        mPath.lineTo(100, 100 + DEFAULT_RADIUS + 50);
        mPath.lineTo(100 - 50, 100 + DEFAULT_RADIUS + 25);
        mPath.lineTo(100, 100 + DEFAULT_RADIUS);

        // 左上圆角
        rectF = new RectF(100, 100, 100 + DEFAULT_RADIUS, 100 + DEFAULT_RADIUS);
        mPath.arcTo(rectF, 180, 90);

        mPath.close();

        canvas.drawPath(mPath, mPaint);

效果图：

气泡轮廓图

贝塞尔曲线##

贝塞尔曲线需要三个点才能确定，所以quadTo方法中的四个参数分别是确定第二，第三的点的。第一个点就是path上次操作的点。

画一条波浪线：

int WAVE_HEIGHT = 88;
 public WaveView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.RED);
        mPaint.setStyle(Paint.Style.STROKE);
        mPath = new Path();
 }

@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        mWL = getWidth();
        mCenterY = getHeight() / 2;
        startWave();

        // 屏幕外 画第一断波纹的第一条曲线
        mPath.moveTo(-mWL, mCenterY);
        mPath.quadTo(-mWL * 3 / 4, mCenterY + WAVE_HEIGHT, -mWL / 2, mCenterY);
        // 屏幕外 第一段波纹的第二天曲线
        mPath.quadTo(-mWL / 4, mCenterY - WAVE_HEIGHT, 0, mCenterY);

        // 屏幕内 画第二断波纹的第一条曲线
        mPath.quadTo(mWL / 4, mCenterY + WAVE_HEIGHT, mWL / 2, mCenterY);
        // 屏幕内 画第二断波纹的第二条曲线
        mPath.quadTo(mWL * 3 / 4, mCenterY - WAVE_HEIGHT, mWL, mCenterY);

        canvas.drawPath(mPath, mPaint);
    }

效果图：

波浪线

让曲线向右平移，就可以实现波浪效果了，让曲线上每个点的x加入offset平移值(不断绘制来实现动画)；

 private void startWave() {
        ValueAnimator animator = ValueAnimator.ofInt(0, mWL); //mWL是一段波纹的长度
        animator.setDuration(1000);
        animator.setRepeatCount(ValueAnimator.INFINITE);
        animator.setInterpolator(new LinearInterpolator());
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                offset = (Integer) animation.getAnimatedValue(); //offset 的值的范围在[0,mWL]之间。
                postInvalidate();
            }
        });
        animator.start();
    }

// onDraw方法中
    ...
       mPath.reset();
        // 使用 for 循环来画
        mPath.moveTo(-mWL + offset, mCenterY);   // 移动起始点
        for (int i = 0; i < 2; i++) {
            mPath.quadTo(-mWL * 3 / 4 + (i * mWL) + offset, mCenterY + WAVE_HEIGHT, -mWL / 2 + (i * mWL) + offset, mCenterY);
            mPath.quadTo(-mWL / 4 + (i * mWL) + offset, mCenterY - WAVE_HEIGHT, 0 + (i * mWL) + offset, mCenterY);
        }
        canvas.drawPath(mPath, mPaint);

贴一下完整代码：

public class WaveView extends View {

    private Path mPath;
    private Paint mPaint;
    private int mWL;
    private int mCenterY;
    private final int WAVE_HEIGHT = 88;

    public WaveView(Context context) {
        this(context, null);
    }

    public WaveView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public WaveView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
        mPaint.setColor(Color.RED);
        mPaint.setStyle(Paint.Style.STROKE);
        mPath = new Path();
    }

    int offset = 0;

    private void startWave() {
        ValueAnimator animator = ValueAnimator.ofInt(0, mWL); //mWL是一段波纹的长度
        animator.setDuration(1000);
        animator.setRepeatCount(ValueAnimator.INFINITE);
        animator.setInterpolator(new LinearInterpolator());
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                offset = (Integer) animation.getAnimatedValue(); //offset 的值的范围在[0,mWL]之间。
                postInvalidate();
            }
        });
        animator.start();
    }


    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        if (mWL == 0) {
            mWL = getWidth();
            mCenterY = getHeight() / 2;
            startWave();
        }

//        // 屏幕外 画第一断波纹的第一条曲线
//        mPath.moveTo(-mWL, mCenterY);
//        mPath.quadTo(-mWL * 3 / 4, mCenterY + WAVE_HEIGHT, -mWL / 2, mCenterY);
//        // 屏幕外 第一段波纹的第二天曲线
//        mPath.quadTo(-mWL / 4, mCenterY - WAVE_HEIGHT, 0, mCenterY);
//
//        // 屏幕内 画第二断波纹的第一条曲线
//        mPath.quadTo(mWL / 4, mCenterY + WAVE_HEIGHT, mWL / 2, mCenterY);
//        // 屏幕内 画第二断波纹的第二条曲线
//        mPath.quadTo(mWL * 3 / 4, mCenterY - WAVE_HEIGHT, mWL, mCenterY);

        mPath.reset();
        // 使用 for 循环来画
        mPath.moveTo(-mWL + offset, mCenterY);   // 移动起始点
        for (int i = 0; i < 2; i++) {
            mPath.quadTo(-mWL * 3 / 4 + (i * mWL) + offset, mCenterY + WAVE_HEIGHT, -mWL / 2 + (i * mWL) + offset, mCenterY);
            mPath.quadTo(-mWL / 4 + (i * mWL) + offset, mCenterY - WAVE_HEIGHT, 0 + (i * mWL) + offset, mCenterY);
        }
        canvas.drawPath(mPath, mPaint);
    }
}

贝塞尔实现波浪效果

cubicTo 三级曲线的使用###

使用4条三阶曲线来画一个正圆：

正圆

 private void drawCircle() {
        mPath.reset();
        // 4条三阶曲线来表示圆
        // 右上1/4圆
        mPath.lineTo(0, -radius);
        mPath.cubicTo(radius * sMagicNumber, -radius
                , radius, -radius * sMagicNumber
                , radius, 0);
        mPath.lineTo(0, 0);

        // 右下1/4圆
        mPath.lineTo(0, radius);
        mPath.cubicTo(radius * sMagicNumber, radius
                , radius, radius * sMagicNumber
                , radius, 0);
        mPath.lineTo(0, 0);

        // 左上1/4圆
        mPath.lineTo(0, -radius);
        mPath.cubicTo(-radius * sMagicNumber, -radius
                , -radius, -radius * sMagicNumber
                , -radius, 0);
        mPath.lineTo(0, 0);

        // 左下1/4圆
        mPath.lineTo(0, radius);
        mPath.cubicTo(-radius * sMagicNumber, radius
                , -radius, radius * sMagicNumber
                , -radius, 0);
        mPath.lineTo(0, 0);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.save();
        canvas.translate(getWidth() / 2, getHeight() / 2);
        canvas.drawPath(mPath, mPaint);
        canvas.restore();
    }

效果图：

正圆

确定点来生成圆####

截图来住其他博客

如上图，共12个点，如果要画曲线P0P3，需要知道我们就要知道 P0，P1，P2，P3 这四个点的坐标，P0,P3 已经知道了，分别为P0(0, -r), P3(r, 0);
p1 与 p2,如上，已经算出来了为：P1(rmagic, -r), P2(r, -rmagic);

点的封装

// 魔力数字
    private float c = 0.551915024494f;
    class HorizontalLine {
        public PointF left = new PointF(); //P7 P11
        public PointF middle = new PointF(); //P0 P6
        public PointF right = new PointF(); //P1 P5
        public HorizontalLine(float x, float y) {
            left.x = -radius * c;
            left.y = y;
            middle.x = x;
            middle.y = y;
            right.x = radius * c;
            right.y = y;
        }
        public void setY(float y) {
            left.y = y;
            middle.y = y;
            right.y = y;
        }
    }
    class VerticalLine {
        public PointF top = new PointF(); //P2 P10
        public PointF middle = new PointF(); //P3 P9
        public PointF bottom = new PointF(); //P4 P8
        public VerticalLine(float x, float y) {
            top.x = x;
            top.y = -radius * c;
            middle.x = x;
            middle.y = y;
            bottom.x = x;
            bottom.y = radius * c;
        }
        public void setX(float x) {
            top.x = x;
            middle.x = x;
            bottom.x = x;
        }
    }

画圆，并与onTouchEvent绑定：

// 实现圆
    private void updatePath(float x, float y) {
        float distance = distance(mPrevX, mPrevY, x, y);
        float longRadius = radius + distance;
        float shortRadius = radius - distance * 0.1f;
        mDegree = points2Degrees(mPrevX, mPrevY, x, y);

        // 修改相关参数，缩放
        mRightLine.setX(longRadius);
        mLeftLine.setX(-shortRadius);
        mTopLine.setY(-shortRadius);
        mBottomLine.setY(shortRadius);

        mPath.reset();
        mPath.moveTo(mTopLine.middle.x, mTopLine.middle.y);
        mPath.cubicTo(mTopLine.right.x, mTopLine.right.y,
                mRightLine.top.x, mRightLine.top.y,
                mRightLine.middle.x, mRightLine.middle.y);
        mPath.cubicTo(mRightLine.bottom.x, mRightLine.bottom.y,
                mBottomLine.right.x, mBottomLine.right.y,
                mBottomLine.middle.x, mBottomLine.middle.y);
        mPath.cubicTo(mBottomLine.left.x, mBottomLine.left.y,
                mLeftLine.bottom.x, mLeftLine.bottom.y,
                mLeftLine.middle.x, mLeftLine.middle.y);
        mPath.cubicTo(mLeftLine.top.x, mLeftLine.top.y,
                mTopLine.left.x, mTopLine.left.y,
                mTopLine.middle.x, mTopLine.middle.y);

        invalidate();
    }

onTouchEvent:

@Override
    public boolean onTouchEvent(MotionEvent event) {
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mPrevX = event.getX();
                mPrevY = event.getY();

                int centerX = getWidth() / 2;
                int centerY = getHeight() / 2;

                //点击位置x坐标与圆心的x坐标的距离
                float distanceX = Math.abs(centerX - mPrevX);
                //点击位置y坐标与圆心的y坐标的距离
                float distanceY = Math.abs(centerY - mPrevY);
                //点击位置与圆心的直线距离
                int distanceZ = (int) Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));
                if (distanceZ > radius) {
                    mIsDown = false;
                } else {
                    mIsDown = true;
                    return true;
                }
                break;
            case MotionEvent.ACTION_MOVE:
                if (mIsDown) {
                    updatePath(event.getX(), event.getY());
                    return true;
                }
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                if (mIsDown) {
                    float endX = event.getX();
                    float endY = event.getY();
                    mIsDown = false;
                    back(endX, endY);        // 还原
                    return true;
                }

                break;
        }

        return super.onTouchEvent(event);
    }

       // 回去
    private void back(final float x, final float y) {
        final float diffX = x - mPrevX;
        final float diffY = y - mPrevY;

        ValueAnimator animator = new ValueAnimator();
        animator.setDuration(200);
        animator.setFloatValues(0, 1);
        animator.setInterpolator(new AccelerateInterpolator());
        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float fract = animation.getAnimatedFraction();
                updatePath(x - diffX * fract, y - diffY * fract);
            }
        });
        animator.start();
    }

绘制：

private float distance(float x1, float y1, float x2, float y2) {
        return (float) Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
    }

private static float points2Degrees(float x1, float y1, float x2, float y2) {
        double angle = Math.atan2(y2 - y1, x2 - x1);
        return (float) Math.toDegrees(angle);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.save();
        canvas.translate(getWidth() / 2, getHeight() / 2);
        canvas.rotate(mDegree);
        canvas.drawPath(mPath, mPaint);
        canvas.restore();
    }

PathMeasure##

PathMeasure是一个用来测量Path的类，主要有以下方法:

构造方法：

PathMeasure(): 创建一个空的PathMeasure；
PathMeasure(path, forceClosed): 创建 PathMeasure 并关联一个指定的Path(Path需要已经创建完成), forceClosed 是否闭合path；

公共方法:

setPath(Path path, boolean forceClosed) : 关联一个Path;
isClose(): 是否闭合；
getLength(): 获取Path的长度；
nextContour() : 跳转到下一个段（轮廓）；
getSegment(float startD, float stopD, Path dst, boolean startWithMoveTo):
getSegment 用于获取Path的一个片段，将截取成功的路径放入 dst中
getPosTan(float distance, float[] pos, float[] tan)：获取指定长度的位置坐标及该点切线值；
getMatrix(float distance, Matrix matrix, int flags)：获取指定长度的位置坐标及该点Matrix

getSegment

getSegment 用于获取Path的一个片段，将截取成功的路径放入 dst中；
android4.4或之前，调用此方法，需关闭硬件加速；
startWithMoveTo：如果 startWithMoveTo 为 true, 则被截取出来到Path片段保持原状，如果 startWithMoveTo 为 false，则会将截取出来的 Path 片段的起始点移动到 dst 的最后一个点，以保证 dst 的连续性，也即保证是否形变，或连续；
被截取的片段，会加入到 dst中，而不是覆盖；

nextContour

Path,很有可能是由多个path片段组成，但不论是 getLength , getgetSegment 或者是其它方法，都只会在其中第一条线段上运行，而这个 nextContour 就是用于跳转到下一条曲线到方法，如果跳转成功，则返回 true，如果跳转失败，则返回 false。

          // path 可分段
        Path path = new Path();
        path.addRect(-100, -100, 100, 100, Path.Direction.CW);
        path.addRect(-200, -200, 200, 200, Path.Direction.CW);
        path.addCircle(0, 0, 50, Path.Direction.CW);

        canvas.drawPath(path, mPaint);

        PathMeasure pathMeasure = new PathMeasure(path, false);    // 与 path关联
        Log.e("TAG", pathMeasure.getLength() + "");        // 800
        pathMeasure.nextContour();      // 获取下一个曲线
        Log.e("TAG", pathMeasure.getLength() + "");        // 1600
        pathMeasure.nextContour();
        Log.e("TAG", pathMeasure.getLength() + "");     // 313.6

getPosTan

得到路径上某一长度的位置以及该位置的正切值；

boolean getPosTan (float distance, float[] pos, float[] tan)

distance: 距离Path的起点，0<=distance<=getLength()
pos: 该点的坐标值；
tan: 该点的正切值，是用来判断 Path 的趋势的，即在这个位置上曲线的走向；
如下：

箭头沿着 path 在移动

实现代码：

 float currentValue = 0.0f;
    float[] pos = new float[2];        // 点的时间坐标
    float[] tan = new float[2];        //   tangent值,用于计算角度
    Bitmap mInDicator;        // 指示器
    Matrix matrix = new Matrix();
// 箭头图片
mInDicator = BitmapFactory.decodeResource(context.getResources(), R.mipmap.indicator);

  @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        // 移动到屏幕中间
        canvas.translate(mWidth / 2, mHeight / 2);

        // 画圆
        Path path = new Path();
        path.addCircle(0, 0, 200, Path.Direction.CW);
        canvas.drawPath(path, mPaint);

        PathMeasure measure = new PathMeasure(path, false);
        currentValue += 0.005;
        if (currentValue >= 1) {
            currentValue = 0;
        }

        // pos 点的坐标值
        // tan 可用来计算点的正切值，是用来判断 Path 的趋势的，即在这个位置上曲线的走向
        measure.getPosTan(measure.getLength() * currentValue, pos, tan);
        float degree = (float) (Math.atan2(tan[1], tan[0]) * 180 / Math.PI);

        /* =============== 第一种方式,转canvas，点为中心选择 ================= */
        canvas.save();
        canvas.rotate(degree, pos[0],pos[1]);

        int halfDrawableWidth = mInDicator.getWidth() / 2;
        int halfDrawableHeight = mInDicator.getHeight() / 2;
        Rect bounds = new Rect((int) pos[0] - halfDrawableWidth, (int) pos[1] - halfDrawableHeight, (int) pos[0] + halfDrawableWidth, (int) pos[1] + halfDrawableHeight);
        canvas.drawBitmap(mInDicator, null, bounds, mPaint);
        canvas.restore();
        invalidate();
        /* =============== 第一种方式,转canvas，点为中心选择 ================= */

    /* =============== 第二种方式,利用Matrix选择 ================= */
        /*
        matrix.reset();
        matrix.postRotate(degree, mInDicator.getWidth() / 2, mInDicator.getHeight() / 2);    // 旋转图片
        // 偏移图片绘制中心，将绘制中心调整到与当前点重合
        matrix.postTranslate(pos[0] - mInDicator.getWidth() / 2, pos[1] - mInDicator.getHeight() / 2);
        canvas.drawBitmap(mInDicator, matrix, mPaint);
        invalidate();
        */
        /* =============== 第二种方式,利用Matrix ================= */

      /* =============== 第三种方式,利用getMatrix() 简洁 ================= */
        matrix.reset();
        measure.getMatrix(measure.getLength() * currentValue, matrix, PathMeasure.TANGENT_MATRIX_FLAG | PathMeasure.POSITION_MATRIX_FLAG);
        matrix.preTranslate(-mInDicator.getWidth() / 2, -mInDicator.getHeight() / 2);
        canvas.drawBitmap(mInDicator, matrix, mPaint);
        invalidate();
        /* =============== 第三种方式,利用getMatrix() ================= */

getMatrix

得到路径上某一长度的位置以及该位置的正切值的矩阵；上面的第三种方式；

Android path 路径相关

Path##

基本方法##

rXXX方法##

Path.op方法（API >= 19 ）##

path的例子：圆角矩形##

聊天气泡形状##

贝塞尔曲线##

cubicTo 三级曲线的使用###

确定点来生成圆####

PathMeasure##

getSegment

nextContour

getPosTan

getMatrix

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Android 自定义View API