Java Code Examples for android.graphics.Path#cubicTo()

The following examples show how to use android.graphics.Path#cubicTo() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: OC_MoreNumbers_S6.java    From GLEXP-Team-onebillion with Apache License 2.0 6 votes vote down vote up
public void animateCirclesFall() throws Exception
{
    List<OBAnim> anims = new ArrayList<>();
    for(OBControl circle : eventTargets)
    {
        PointF startPoint = OBMisc.copyPoint(circle.position());
        PointF endPoint = (PointF) circle.propertyValue("startloc") ;
        circle.setZPosition ( 2);
        Path path = new Path();
        PointF cp1 = new PointF(startPoint.x+ (startPoint.x > endPoint.x ? -2.5f * circle.width() : 2.5f * circle.width() ), startPoint.y);
        PointF cp2 = new PointF(endPoint.x, endPoint.y - circle.width() * 2);
        path.moveTo(startPoint.x, startPoint.y);
        path.cubicTo(cp1.x,cp1.y,cp2.x,cp2.y, endPoint.x, endPoint.y);
        anims.add(OBAnim.pathMoveAnim(circle,path,false,0));
        anims.add(OBAnim.colourAnim("fillColor",currentcolour,((OBGroup)circle).objectDict.get("background")));
    }
    playSfxAudio("number_fly",false);
    OBAnimationGroup.runAnims(anims,1,true,OBAnim.ANIM_EASE_IN,this);
    waitSFX();
}
 
Example 2
Source File: PathInterpolatorCompat.java    From android-dialer with Apache License 2.0 5 votes vote down vote up
private static Path createCubic(
    float controlX1, float controlY1, float controlX2, float controlY2) {
  final Path path = new Path();
  path.moveTo(0.0f, 0.0f);
  path.cubicTo(controlX1, controlY1, controlX2, controlY2, 1.0f, 1.0f);
  return path;
}
 
Example 3
Source File: SVGAndroidRenderer.java    From starcor.xul with GNU Lesser General Public License v3.0 5 votes vote down vote up
private Path makePathAndBoundingBox(SVG.Ellipse obj)
{
   float  cx = (obj.cx != null) ? obj.cx.floatValueX(this) : 0f;
   float  cy = (obj.cy != null) ? obj.cy.floatValueY(this) : 0f;
   float  rx = obj.rx.floatValueX(this);
   float  ry = obj.ry.floatValueY(this);

   float  left = cx - rx;
   float  top = cy - ry;
   float  right = cx + rx;
   float  bottom = cy + ry;

   if (obj.boundingBox == null) {
      obj.boundingBox = new Box(left, top, rx*2, ry*2);
   }

   float  cpx = rx * BEZIER_ARC_FACTOR;
   float  cpy = ry * BEZIER_ARC_FACTOR;

   Path  p = new Path();
   p.moveTo(cx, top);
   p.cubicTo(cx+cpx, top, right, cy-cpy, right, cy);
   p.cubicTo(right, cy+cpy, cx+cpx, bottom, cx, bottom);
   p.cubicTo(cx-cpx, bottom, left, cy+cpy, left, cy);
   p.cubicTo(left, cy-cpy, cx-cpx, top, cx, top);
   p.close();
   return p;
}
 
Example 4
Source File: SVGAndroidRenderer.java    From XDroidAnimation with Apache License 2.0 5 votes vote down vote up
private Path makePathAndBoundingBox(SVG.Ellipse obj)
{
   float  cx = (obj.cx != null) ? obj.cx.floatValueX(this) : 0f;
   float  cy = (obj.cy != null) ? obj.cy.floatValueY(this) : 0f;
   float  rx = obj.rx.floatValueX(this);
   float  ry = obj.ry.floatValueY(this);

   float  left = cx - rx;
   float  top = cy - ry;
   float  right = cx + rx;
   float  bottom = cy + ry;

   if (obj.boundingBox == null) {
      obj.boundingBox = new Box(left, top, rx*2, ry*2);
   }

   float  cpx = rx * BEZIER_ARC_FACTOR;
   float  cpy = ry * BEZIER_ARC_FACTOR;

   Path  p = new Path();
   p.moveTo(cx, top);
   p.cubicTo(cx+cpx, top, right, cy-cpy, right, cy);
   p.cubicTo(right, cy+cpy, cx+cpx, bottom, cx, bottom);
   p.cubicTo(cx-cpx, bottom, left, cy+cpy, left, cy);
   p.cubicTo(left, cy-cpy, cx-cpx, top, cx, top);
   p.close();
   return p;
}
 
Example 5
Source File: CloudView.java    From BackgroundView with Apache License 2.0 5 votes vote down vote up
@Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
//        canvas.translate(mCenterX, mCenterY); // 将坐标系移动到画布中央

        Path path = new Path();
        path.moveTo(5.82f * mScaleW, 51.78f * mScaleH);
        path.quadTo(24 * mScaleW, 28 * mScaleH, 51.2f * mScaleW, 34.4f * mScaleH);
        path.cubicTo(51f * mScaleW, 14 * mScaleH, 113 * mScaleW, -3 * mScaleH, mWidth, 51.78f * mScaleH);
        path.lineTo(5.82f * mScaleW, 51.78f * mScaleH);
        canvas.drawPath(path, mPaint);
    }
 
Example 6
Source File: PathInterpolatorDonut.java    From RxTools-master with Apache License 2.0 5 votes vote down vote up
private static Path createCubic(float controlX1, float controlY1,
                                float controlX2, float controlY2) {
    final Path path = new Path();
    path.moveTo(0.0f, 0.0f);
    path.cubicTo(controlX1, controlY1, controlX2, controlY2, 1.0f, 1.0f);
    return path;
}
 
Example 7
Source File: Hasher.java    From crystal-preloaders with Apache License 2.0 5 votes vote down vote up
private void drawPath1(Path path, float factor){

        float x1 = getWidth();
        float y1 = 0f;

        float x3 = getWidth() / 2;
        float y3 = getHeight() / 2 + factor;

        float x2 = getWidth() - factor * 2;
        float y2 = getHeight() / 2;

        // move and draw
        path.moveTo(getWidth(), 0f);
        path.cubicTo(x1, y1, x2, y2, x3, y3);
    }
 
Example 8
Source File: PullableWrapper.java    From Dashchan with Apache License 2.0 5 votes vote down vote up
public LollipopView(Wrapped wrapped, boolean top) {
	this.wrapped = new WeakReference<>(wrapped);
	this.top = top;
	Path startPath = new Path();
	startPath.lineTo(0.5f, 0f);
	startPath.cubicTo(0.7f, 0f, 0.6f, 1f, 1f, 1f);
	startInterpolator = new PathInterpolator(startPath);
	Path endPath = new Path();
	endPath.cubicTo(0.2f, 0f, 0.1f, 1f, 0.5f, 1f);
	endPath.lineTo(1f, 1f);
	endInterpolator = new PathInterpolator(endPath);
	ringPaint.setStyle(Paint.Style.STROKE);
	ringPaint.setStrokeCap(Paint.Cap.SQUARE);
	ringPaint.setStrokeJoin(Paint.Join.MITER);
}
 
Example 9
Source File: BezierIndicatorView.java    From KotlinMVPRxJava2Dagger2GreenDaoRetrofitDemo with Apache License 2.0 5 votes vote down vote up
private Path calculateUnderHalfPath(Indicator indicator) {
    Path mBezierPath = new Path();
    mBezierPath.moveTo(indicator.point0.x, indicator.point0.y);
    mBezierPath.cubicTo(indicator.point1.x, indicator.point1.y, indicator.point2.x, indicator.point2.y, indicator.point3.x, indicator.point3.y);
    mBezierPath.cubicTo(indicator.point4.x, indicator.point4.y, indicator.point5.x, indicator.point5.y, indicator.point6.x, indicator.point6.y);
    mBezierPath.cubicTo(indicator.point7.x, indicator.point7.y, indicator.point8.x, indicator.point8.y, indicator.point9.x, indicator.point9.y);
    mBezierPath.cubicTo(indicator.point10.x, indicator.point10.y, indicator.point11.x, indicator.point11.y, indicator.point0.x, indicator.point0.y);
    mBezierPath.close();
    return mBezierPath;
}
 
Example 10
Source File: GradientLine.java    From WidgetCase with Apache License 2.0 5 votes vote down vote up
@Override
protected void drawUp(Canvas canvas, boolean isAnim) {
    // 设置渐变曲线配置
    if (isAnim) {
        updatePath(canvas, getPoints(),mMode);
    } else {
        upLgMoreConfig(canvas);
        Path path = new Path();
        path.moveTo(mRadius * 2 + mPointPaint.getStrokeWidth(), mView_H - mRadius - mPointPaint.getStrokeWidth());
        path.cubicTo(control1.x, control1.y, control2.x, control2.y, mView_W - (mRadius * 2) - mPointPaint.getStrokeWidth(), control2.y + DensityUtil.dp2px(2));
        canvas.drawPath(path, mPaint);
    }
}
 
Example 11
Source File: SVGAndroidRenderer.java    From microMathematics with GNU General Public License v3.0 4 votes vote down vote up
private Path  makePathAndBoundingBox(Rect obj)
{
   float x, y, w, h, rx, ry;

   if (obj.rx == null && obj.ry == null) {
      rx = 0;
      ry = 0;
   } else if (obj.rx == null) {
      rx = ry = obj.ry.floatValueY(this);
   } else if (obj.ry == null) {
      rx = ry = obj.rx.floatValueX(this);
   } else {
      rx = obj.rx.floatValueX(this);
      ry = obj.ry.floatValueY(this);
   }
   rx = Math.min(rx, obj.width.floatValueX(this) / 2f);
   ry = Math.min(ry, obj.height.floatValueY(this) / 2f);
   x = (obj.x != null) ? obj.x.floatValueX(this) : 0f;
   y = (obj.y != null) ? obj.y.floatValueY(this) : 0f;
   w = obj.width.floatValueX(this);
   h = obj.height.floatValueY(this);

   if (obj.boundingBox == null) {
      obj.boundingBox = new Box(x, y, w, h);
   }

   float  right = x + w;
   float  bottom = y + h;

   Path  p = new Path();
   if (rx == 0 || ry == 0)
   {
      // Simple rect
      p.moveTo(x, y);
      p.lineTo(right, y);
      p.lineTo(right, bottom);
      p.lineTo(x, bottom);
      p.lineTo(x, y);
   }
   else
   {
      // Rounded rect
      
      // Bexier control point lengths for a 90 degress arc
      float  cpx = rx * BEZIER_ARC_FACTOR;
      float  cpy = ry * BEZIER_ARC_FACTOR;

      p.moveTo(x, y+ry);
      p.cubicTo(x, y+ry-cpy, x+rx-cpx, y, x+rx, y);
      p.lineTo(right-rx, y);
      p.cubicTo(right-rx+cpx, y, right, y+ry-cpy, right, y+ry);
      p.lineTo(right, bottom-ry);
      p.cubicTo(right, bottom-ry+cpy, right-rx+cpx, bottom, right-rx, bottom);
      p.lineTo(x+rx, bottom);
      p.cubicTo(x+rx-cpx, bottom, x, bottom-ry+cpy, x, bottom-ry);
      p.lineTo(x, y+ry);
   }
   p.close();
   return p;
}
 
Example 12
Source File: Renderer.java    From numAndroidCharts with GNU General Public License v3.0 4 votes vote down vote up
protected void DrawCubicPath(Canvas canvas, List<ChartData> dataList, Paint paint, float height, boolean area_spline) {

        final int lineSize = dataList.size();
        float prePriviousX = Float.NaN;
        float prePreviousY = Float.NaN;
        float previousX = Float.NaN;
        float previousY = Float.NaN;
        float curr_x = Float.NaN;
        float curr_y = Float.NaN;
        float next_x= Float.NaN;
        float next_y = Float.NaN;

        Path path = new Path();

        if(area_spline){
            paint.setStyle(Paint.Style.FILL_AND_STROKE);
            paint.setAlpha(100);
            path.moveTo(dataList.get(0).getX_values(), height);
            path.lineTo(dataList.get(0).getX_values(),
                    dataList.get(0).getY_values());
        }

        for (int valueIndex = 0; valueIndex < lineSize; ++valueIndex) {

            if (Float.isNaN(curr_x)) {

                curr_x = dataList.get(valueIndex).getX_values();
                curr_y = dataList.get(valueIndex).getY_values();
            }
            if (Float.isNaN(previousX)) {

                if (valueIndex > 0) {

                    previousX = dataList.get(valueIndex - 1).getX_values();
                    previousY = dataList.get(valueIndex - 1).getY_values();
                } else {
                    previousX = curr_x;
                    previousY = curr_y;
                }
            }

            if (Float.isNaN(prePriviousX)) {

                if (valueIndex > 1) {

                    prePriviousX = dataList.get(valueIndex - 2).getX_values();
                    prePreviousY = dataList.get(valueIndex - 2).getY_values();
                }
                else {
                    prePriviousX = previousX;
                    prePreviousY = previousY;
                }
            }

            // nextPoint is always new one or it is equal currentPoint.
            if (valueIndex < lineSize - 1) {

                next_x = dataList.get(valueIndex + 1).getX_values();
                next_y = dataList.get(valueIndex + 1).getY_values();
            }
            else {
                next_x = curr_x;
                next_y = curr_y;
            }

            if (valueIndex == 0) {

                if(!area_spline)
                    path.moveTo(curr_x, curr_y);
            }
            else {
                // Calculate control points.
                final float first_diff_x = (curr_x - prePriviousX);
                final float fisrt_diff_y = (curr_y - prePreviousY);
                final float sec_diff_x = (next_x - previousX);
                final float sec_diff_y = (next_y - previousY);
                final float first_control_x = previousX + (curve_intensity * first_diff_x);
                final float first_control_y = previousY + (curve_intensity * fisrt_diff_y);
                final float secondControlPointX = curr_x - (curve_intensity * sec_diff_x);
                final float secondControlPointY = curr_y - (curve_intensity * sec_diff_y);
                path.cubicTo(first_control_x, first_control_y, secondControlPointX, secondControlPointY,
                        curr_x, curr_y);
            }

            prePriviousX = previousX;
            prePreviousY = previousY;
            previousX = curr_x;
            previousY = curr_y;
            curr_x = next_x;
            curr_y = next_y;
        }

        if(area_spline){
            path.lineTo(dataList.get(dataList.size()-1).getX_values(),
                    height);
        }

        canvas.drawPath(path, paint);
        path.reset();
    }
 
Example 13
Source File: PathParser.java    From SVGLoadersPack-Android with Apache License 2.0 4 votes vote down vote up
/**
 * Converts an arc to cubic Bezier segments and records them in p.
 *
 * @param p     The target for the cubic Bezier segments
 * @param cx    The x coordinate center of the ellipse
 * @param cy    The y coordinate center of the ellipse
 * @param a     The radius of the ellipse in the horizontal direction
 * @param b     The radius of the ellipse in the vertical direction
 * @param e1x   E(eta1) x coordinate of the starting point of the arc
 * @param e1y   E(eta2) y coordinate of the starting point of the arc
 * @param theta The angle that the ellipse bounding rectangle makes with horizontal plane
 * @param start The startAnimation angle of the arc on the ellipse
 * @param sweep The angle (positive or negative) of the sweep of the arc on the ellipse
 */
private static void arcToBezier(Path p,
                                double cx,
                                double cy,
                                double a,
                                double b,
                                double e1x,
                                double e1y,
                                double theta,
                                double start,
                                double sweep) {
    // Taken from equations at: http://spaceroots.org/documents/ellipse/node8.html
    // and http://www.spaceroots.org/documents/ellipse/node22.html

    // Maximum of 45 degrees per cubic Bezier segment
    int numSegments = (int) Math.ceil(Math.abs(sweep * 4 / Math.PI));

    double eta1 = start;
    double cosTheta = Math.cos(theta);
    double sinTheta = Math.sin(theta);
    double cosEta1 = Math.cos(eta1);
    double sinEta1 = Math.sin(eta1);
    double ep1x = (-a * cosTheta * sinEta1) - (b * sinTheta * cosEta1);
    double ep1y = (-a * sinTheta * sinEta1) + (b * cosTheta * cosEta1);

    double anglePerSegment = sweep / numSegments;
    for (int i = 0; i < numSegments; i++) {
        double eta2 = eta1 + anglePerSegment;
        double sinEta2 = Math.sin(eta2);
        double cosEta2 = Math.cos(eta2);
        double e2x = cx + (a * cosTheta * cosEta2) - (b * sinTheta * sinEta2);
        double e2y = cy + (a * sinTheta * cosEta2) + (b * cosTheta * sinEta2);
        double ep2x = -a * cosTheta * sinEta2 - b * sinTheta * cosEta2;
        double ep2y = -a * sinTheta * sinEta2 + b * cosTheta * cosEta2;
        double tanDiff2 = Math.tan((eta2 - eta1) / 2);
        double alpha =
                Math.sin(eta2 - eta1) * (Math.sqrt(4 + (3 * tanDiff2 * tanDiff2)) - 1) / 3;
        double q1x = e1x + alpha * ep1x;
        double q1y = e1y + alpha * ep1y;
        double q2x = e2x - alpha * ep2x;
        double q2y = e2y - alpha * ep2y;

        // Adding this no-op call to workaround a proguard related issue.
        p.rLineTo(0, 0);

        p.cubicTo((float) q1x,
                (float) q1y,
                (float) q2x,
                (float) q2y,
                (float) e2x,
                (float) e2y);
        eta1 = eta2;
        e1x = e2x;
        e1y = e2y;
        ep1x = ep2x;
        ep1y = ep2y;
    }
}
 
Example 14
Source File: BaseRating.java    From SmileyRating with Apache License 2.0 4 votes vote down vote up
protected Path transformSmile(float trans, float fraction, Path path, Smile s1, Smile s2, FloatEvaluator evaluator) {
    path.reset();
    path.moveTo(
            evaluator.evaluate(fraction, s1.START_POINT.x, s2.START_POINT.x) + trans,
            evaluator.evaluate(fraction, s1.START_POINT.y, s2.START_POINT.y)
    );
    path.cubicTo(
            evaluator.evaluate(fraction, s1.TOP_CURVE[0].x, s2.TOP_CURVE[0].x) + trans,
            evaluator.evaluate(fraction, s1.TOP_CURVE[0].y, s2.TOP_CURVE[0].y),
            evaluator.evaluate(fraction, s1.TOP_CURVE[1].x, s2.TOP_CURVE[1].x) + trans,
            evaluator.evaluate(fraction, s1.TOP_CURVE[1].y, s2.TOP_CURVE[1].y),
            evaluator.evaluate(fraction, s1.TOP_CURVE[2].x, s2.TOP_CURVE[2].x) + trans,
            evaluator.evaluate(fraction, s1.TOP_CURVE[2].y, s2.TOP_CURVE[2].y)
    );
    path.cubicTo(
            evaluator.evaluate(fraction, s1.RIGHT_CURVE[0].x, s2.RIGHT_CURVE[0].x) + trans,
            evaluator.evaluate(fraction, s1.RIGHT_CURVE[0].y, s2.RIGHT_CURVE[0].y),
            evaluator.evaluate(fraction, s1.RIGHT_CURVE[1].x, s2.RIGHT_CURVE[1].x) + trans,
            evaluator.evaluate(fraction, s1.RIGHT_CURVE[1].y, s2.RIGHT_CURVE[1].y),
            evaluator.evaluate(fraction, s1.RIGHT_CURVE[2].x, s2.RIGHT_CURVE[2].x) + trans,
            evaluator.evaluate(fraction, s1.RIGHT_CURVE[2].y, s2.RIGHT_CURVE[2].y)
    );
    path.cubicTo(
            evaluator.evaluate(fraction, s1.BOTTOM_CURVE[0].x, s2.BOTTOM_CURVE[0].x) + trans,
            evaluator.evaluate(fraction, s1.BOTTOM_CURVE[0].y, s2.BOTTOM_CURVE[0].y),
            evaluator.evaluate(fraction, s1.BOTTOM_CURVE[1].x, s2.BOTTOM_CURVE[1].x) + trans,
            evaluator.evaluate(fraction, s1.BOTTOM_CURVE[1].y, s2.BOTTOM_CURVE[1].y),
            evaluator.evaluate(fraction, s1.BOTTOM_CURVE[2].x, s2.BOTTOM_CURVE[2].x) + trans,
            evaluator.evaluate(fraction, s1.BOTTOM_CURVE[2].y, s2.BOTTOM_CURVE[2].y)
    );
    path.cubicTo(
            evaluator.evaluate(fraction, s1.LEFT_CURVE[0].x, s2.LEFT_CURVE[0].x) + trans,
            evaluator.evaluate(fraction, s1.LEFT_CURVE[0].y, s2.LEFT_CURVE[0].y),
            evaluator.evaluate(fraction, s1.LEFT_CURVE[1].x, s2.LEFT_CURVE[1].x) + trans,
            evaluator.evaluate(fraction, s1.LEFT_CURVE[1].y, s2.LEFT_CURVE[1].y),
            evaluator.evaluate(fraction, s1.LEFT_CURVE[2].x, s2.LEFT_CURVE[2].x) + trans,
            evaluator.evaluate(fraction, s1.LEFT_CURVE[2].y, s2.LEFT_CURVE[2].y)
    );
    path.close();
    return path;
}
 
Example 15
Source File: ColorizeFaceActivity.java    From FaceT with Mozilla Public License 2.0 4 votes vote down vote up
private void drawRouge(String blushColor, Bitmap getBitmap) {

        selectedBrushColor = blushColor;
        Log.d(TAG + " selectedBlushColor ", selectedBrushColor);
        Canvas drawCanvas = new Canvas(getBitmap);
        Paint mPaint = new Paint();

        int rougeColor = stringColorRGBToARGB(blushColor, 40 + alphaValueRouge, 0, 0, 0);

        mPaint.setColor(rougeColor);
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setStrokeJoin(Paint.Join.ROUND);    // set the join to round you want
        mPaint.setStrokeCap(Paint.Cap.ROUND);      // set the paint cap to round too
        mPaint.setPathEffect(new CornerPathEffect(70));
        mPaint.setXfermode(mXfermode);
        mPaint.setStrokeWidth(1f);

        int sc = drawCanvas.saveLayer(0, 0, getBitmap.getWidth(), getBitmap.getHeight(), null, Canvas.ALL_SAVE_FLAG);
        mPaint.setMaskFilter(new BlurMaskFilter(10, BlurMaskFilter.Blur.NORMAL));

        //nose_contour_left2 - contour_left3
        float rouge_left_x = landmark_pt_x.get(30) - (landmark_pt_x.get(30) - landmark_pt_x.get(2)) / 2f;
        float rouge_left_y = landmark_pt_y.get(31);
        float slope = ((landmark_pt_y.get(31) - landmark_pt_y.get(35)) / (landmark_pt_x.get(31) - landmark_pt_x.get(35)));
        rouge_left_y = ((rouge_left_x - landmark_pt_x.get(31)) * slope) + landmark_pt_y.get(31);
//        drawCanvas.drawCircle(rouge_left_x, rouge_left_y, 30f, mPaint);
//        nose_contour_right2 - contour_right3
        float rouge_right_x = landmark_pt_x.get(30) + (landmark_pt_x.get(14) - landmark_pt_x.get(30)) / 2f;
        float rouge_right_y = landmark_pt_y.get(35);
        rouge_right_y = ((rouge_right_x - landmark_pt_x.get(35)) * slope) + landmark_pt_y.get(35);

        Path path = new Path();
        path.reset();
        //draw left rouge
//        contour_left3
        path.moveTo(landmark_pt_x.get(2) + 3f, landmark_pt_y.get(2));
        path.cubicTo(landmark_pt_x.get(3) + 3f, landmark_pt_y.get(3),
                landmark_pt_x.get(4) + 3f, landmark_pt_y.get(4),
                landmark_pt_x.get(5) + 3f, landmark_pt_y.get(5) - 4f
        );
        path.lineTo(rouge_left_x, rouge_left_y);
        path.lineTo(landmark_pt_x.get(2) + 3f, landmark_pt_y.get(2));

        path.close();
        drawCanvas.drawPath(path, mPaint);

        path.reset();
        //draw right rouge
//        contour_right3
        path.moveTo(landmark_pt_x.get(14) - 3f, landmark_pt_y.get(14));
        path.cubicTo(landmark_pt_x.get(13) - 3f, landmark_pt_y.get(13),
                landmark_pt_x.get(12) - 3f, landmark_pt_y.get(12),
                landmark_pt_x.get(11) - 3f, landmark_pt_y.get(11) - 4f
        );

        path.lineTo(rouge_right_x, rouge_right_y);
        path.lineTo(landmark_pt_x.get(14) - 3f, landmark_pt_y.get(14));

        drawCanvas.drawPath(path, mPaint);
        //设置混合模式
        mPaint.setXfermode(mXfermode);
        //清除混合模式
        mPaint.setXfermode(null);
        //还原画布
        drawCanvas.restoreToCount(sc);
        drawCanvas.setBitmap(getBitmap);
    }
 
Example 16
Source File: BizierUtils.java    From zone-sdk with MIT License 4 votes vote down vote up
public static Path getTwoCircle_CutLineMergePath(Circle c1, Circle c2, double expandAngel) {
    float startAngel = GeometryUtils.getP2AngleByX(c2.center, c1.center);
    Matrix m = new Matrix();
    float[] src = new float[]{c2.center.x, c2.center.y};
    float[] dst = new float[2];//代替了c2.center的点
    m.postRotate(-startAngel, c1.center.x, c1.center.y); //现在都在右边了
    m.mapPoints(dst, src);
    //现在为止   就是 c1,c2 x点都是相同了 并且 c2在c1右边
    ZPointF pA, pB, pC, pD;//AD 在c1,  BC在c2上
    ZPointF pApDControl, pBpCControl;//AD 在c1,  BC在c2上

    pA = new ZPointF((float) Math.cos(Math.toRadians(expandAngel / 2)) * c1.r, -(float) Math.sin(Math.toRadians(expandAngel / 2)) * c1.r);
    pA.offset(c1.center);

    pD = new ZPointF((float) Math.cos(Math.toRadians(expandAngel / 2)) * c1.r, (float) Math.sin(Math.toRadians(expandAngel / 2)) * c1.r);
    pD.offset(c1.center);

    pApDControl = new ZPointF((float) (c1.r / Math.cos(Math.toRadians(expandAngel / 2))), 0);
    pApDControl.offset(c1.center);

    pB = new ZPointF(-(float) Math.cos(Math.toRadians(expandAngel / 2)) * c2.r, -(float) Math.sin(Math.toRadians(expandAngel / 2)) * c2.r);
    pB.offset(dst[0], dst[1]);

    pC = new ZPointF(-(float) Math.cos(Math.toRadians(expandAngel / 2)) * c2.r, (float) Math.sin(Math.toRadians(expandAngel / 2)) * c2.r);
    pC.offset(dst[0], dst[1]);

    pBpCControl = new ZPointF(-(float) (c2.r / Math.cos(Math.toRadians(expandAngel / 2))), 0);
    pBpCControl.offset(dst[0], dst[1]);

    Path resultPath = new Path();
    resultPath.moveTo(pA.x, pA.y);
    resultPath.cubicTo(pApDControl.x, pApDControl.y, pBpCControl.x, pBpCControl.y, pB.x, pB.y);
    resultPath.lineTo(pC.x, pC.y);
    resultPath.cubicTo(pBpCControl.x, pBpCControl.y, pApDControl.x, pApDControl.y, pD.x, pD.y);
    resultPath.close();

    Matrix m2 = new Matrix();
    m2.postRotate(startAngel, c1.center.x, c1.center.y);
    resultPath.transform(m2);
    return resultPath;
}
 
Example 17
Source File: GravityArcMotion.java    From Mysplash with GNU Lesser General Public License v3.0 4 votes vote down vote up
@Override
public Path getPath(float startX, float startY, float endX, float endY) {
    Path path = new Path();
    path.moveTo(startX, startY);

    float ex;
    float ey;
    if (startY == endY) {
        ex = (startX + endX) / 2;
        ey = startY + mMinimumHorizontalTangent * Math.abs(endX - startX) / 2;
    } else if (startX == endX) {
        ex = startX + mMinimumVerticalTangent * Math.abs(endY - startY) / 2;
        ey = (startY + endY) / 2;
    } else {
        float deltaX = endX - startX;

        float deltaY;
        if (endY < startY) {
            deltaY = startY - endY; // Y is inverted compared to diagram above.
        } else {
            deltaY = endY - startY;
        }

        // hypotenuse squared.
        float h2 = deltaX * deltaX + deltaY * deltaY;

        // Midpoint between start and end
        float dx = (startX + endX) / 2;
        float dy = (startY + endY) / 2;

        // Distance squared between end point and mid point is (1/2 hypotenuse)^2
        float midDist2 = h2 * 0.25f;

        float minimumArcDist2;

        if (Math.abs(deltaX) < Math.abs(deltaY)) {
            // Similar triangles bfa and bde mean that (ab/fb = eb/bd)
            // Therefore, eb = ab * bd / fb
            // ab = hypotenuse
            // bd = hypotenuse/2
            // fb = deltaY
            float eDistY = h2 / (2 * deltaY);
            ey = endY + eDistY;
            ex = endX;

            minimumArcDist2 = midDist2 * mMinimumVerticalTangent
                    * mMinimumVerticalTangent;
        } else {
            // Same as above, but flip X & Y
            float eDistX = h2 / (2 * deltaX);
            ex = endX + eDistX;
            ey = endY;

            minimumArcDist2 = midDist2
                    * mMinimumHorizontalTangent
                    * mMinimumHorizontalTangent;
        }
        float arcDistX = dx - ex;
        float arcDistY = dy - ey;
        float arcDist2 = arcDistX * arcDistX + arcDistY * arcDistY;

        float maximumArcDist2 = midDist2 * mMaximumTangent * mMaximumTangent;

        float newArcDistance2 = 0;
        if (arcDist2 < minimumArcDist2) {
            newArcDistance2 = minimumArcDist2;
        } else if (arcDist2 > maximumArcDist2) {
            newArcDistance2 = maximumArcDist2;
        }
        if (newArcDistance2 != 0) {
            float ratio2 = newArcDistance2 / arcDist2;
            float ratio = (float) Math.sqrt(ratio2);
            ex = dx + (ratio * (ex - dx));
            ey = dy + (ratio * (ey - dy));
        }
    }
    float controlX1 = (startX + ex) / 2;
    float controlY1 = (startY + ey) / 2;
    float controlX2 = (ex + endX) / 2;
    float controlY2 = (ey + endY) / 2;
    path.cubicTo(controlX1, controlY1, controlX2, controlY2, endX, endY);
    return path;
}
 
Example 18
Source File: PlayerFragment.java    From android-material-motion with Apache License 2.0 4 votes vote down vote up
private void backAnimation() {
  float endX = 0;
  float endY = 0;
  float startX = actionButton.getTranslationX();
  float startY = actionButton.getTranslationY();
  final float curveRadius = -background.getHeight() / 2;

  Path arcPath = new Path();

  float midX = startX + ((endX - startX) / 2);
  float midY = startY + ((endY - startY) / 2);
  float xDiff = midX - startX;
  float yDiff = midY - startY;

  double angle = (Math.atan2(yDiff, xDiff) * (180 / Math.PI)) - 90;
  double angleRadians = Math.toRadians(angle);

  float pointX = (float) (midX + curveRadius * Math.cos(angleRadians));
  float pointY = (float) (midY + curveRadius * Math.sin(angleRadians));

  arcPath.moveTo(startX, startY);
  arcPath.cubicTo(startX, startY, pointX, pointY, endX, endY);

  ValueAnimator pathAnimator = ValueAnimator.ofFloat(0, 1);
  pathAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    private float point[] = new float[2];
    private PathMeasure pathMeasure = new PathMeasure(arcPath, false);

    @Override
    public void onAnimationUpdate(ValueAnimator animation) {
      final float value = animation.getAnimatedFraction();
      // Gets the point at the fractional path length
      pathMeasure.getPosTan(pathMeasure.getLength() * value, point, null);

      // Sets view location to the above point
      actionButton.setTranslationX(point[0]);
      actionButton.setTranslationY(point[1]);
    }
  });
  pathAnimator.setInterpolator(new DecelerateInterpolator());
  pathAnimator.setDuration(duration(R.integer.path_duration));
  pathAnimator.start();
}
 
Example 19
Source File: PathParser.java    From CanDialog with Apache License 2.0 4 votes vote down vote up
/**
 * Converts an arc to cubic Bezier segments and records them in p.
 *
 * @param p The target for the cubic Bezier segments
 * @param cx The x coordinate center of the ellipse
 * @param cy The y coordinate center of the ellipse
 * @param a The radius of the ellipse in the horizontal direction
 * @param b The radius of the ellipse in the vertical direction
 * @param e1x E(eta1) x coordinate of the starting point of the arc
 * @param e1y E(eta2) y coordinate of the starting point of the arc
 * @param theta The angle that the ellipse bounding rectangle makes with horizontal plane
 * @param start The start angle of the arc on the ellipse
 * @param sweep The angle (positive or negative) of the sweep of the arc on the ellipse
 */
private static void arcToBezier(Path p,
                                double cx,
                                double cy,
                                double a,
                                double b,
                                double e1x,
                                double e1y,
                                double theta,
                                double start,
                                double sweep) {
    // Taken from equations at: http://spaceroots.org/documents/ellipse/node8.html
    // and http://www.spaceroots.org/documents/ellipse/node22.html

    // Maximum of 45 degrees per cubic Bezier segment
    int numSegments = Math.abs((int) Math.ceil(sweep * 4 / Math.PI));

    double eta1 = start;
    double cosTheta = Math.cos(theta);
    double sinTheta = Math.sin(theta);
    double cosEta1 = Math.cos(eta1);
    double sinEta1 = Math.sin(eta1);
    double ep1x = (-a * cosTheta * sinEta1) - (b * sinTheta * cosEta1);
    double ep1y = (-a * sinTheta * sinEta1) + (b * cosTheta * cosEta1);

    double anglePerSegment = sweep / numSegments;
    for (int i = 0; i < numSegments; i++) {
        double eta2 = eta1 + anglePerSegment;
        double sinEta2 = Math.sin(eta2);
        double cosEta2 = Math.cos(eta2);
        double e2x = cx + (a * cosTheta * cosEta2) - (b * sinTheta * sinEta2);
        double e2y = cy + (a * sinTheta * cosEta2) + (b * cosTheta * sinEta2);
        double ep2x = -a * cosTheta * sinEta2 - b * sinTheta * cosEta2;
        double ep2y = -a * sinTheta * sinEta2 + b * cosTheta * cosEta2;
        double tanDiff2 = Math.tan((eta2 - eta1) / 2);
        double alpha =
                Math.sin(eta2 - eta1) * (Math.sqrt(4 + (3 * tanDiff2 * tanDiff2)) - 1) / 3;
        double q1x = e1x + alpha * ep1x;
        double q1y = e1y + alpha * ep1y;
        double q2x = e2x - alpha * ep2x;
        double q2y = e2y - alpha * ep2y;

        p.cubicTo((float) q1x,
                (float) q1y,
                (float) q2x,
                (float) q2y,
                (float) e2x,
                (float) e2y);
        eta1 = eta2;
        e1x = e2x;
        e1y = e2y;
        ep1x = ep2x;
        ep1y = ep2y;
    }
}
 
Example 20
Source File: Landscape.java    From LandscapeView with Apache License 2.0 4 votes vote down vote up
Landscape(LandscapeView landscapeView, int color, int color2, float height, float fluctuation, float scale) {
    this.landscapeView = landscapeView;
    this.color = color;
    this.color2 = color2;
    this.height = height;
    this.fluctuation = fluctuation;
    this.scale = scale;

    path = new Path();
    path.moveTo(0, landscapeView.getMaximumHeight());
    path.lineTo(landscapeView.getWidth(), landscapeView.getMaximumHeight());
    float prevX = landscapeView.getWidth();
    float prevY = (float) (landscapeView.getMaximumHeight() - height - Math.random() * fluctuation);
    path.lineTo(prevX, prevY);
    int widthDiv100 = (int) (landscapeView.getWidth() / (landscapeView.getResources().getDimension(R.dimen.landscapeView_1dip) * 100));
    int segments = LandscapeView.random.nextInt(widthDiv100) + widthDiv100;
    for (int i = 0; i <= segments; i++) {
        float x = landscapeView.getWidth() * (segments - i) / segments;
        float y = (float) (landscapeView.getMaximumHeight() - height - Math.random() * fluctuation);
        float x33 = MathUtils.lerp(prevX, x, 0.33f);
        float x67 = MathUtils.lerp(prevX, x, 0.67f);
        path.cubicTo(x33, prevY, x67, y, x, y);
        if (LandscapeView.random.nextFloat() > LandscapeView.TREE_RANDOM)
            trees.add(new Tree(landscapeView,prevX, prevY, scale));
        if (LandscapeView.random.nextFloat() > LandscapeView.TREE_RANDOM)
            trees.add(new Tree(landscapeView,x33, MathUtils.lerp(prevY, y, 0.33f), scale));
        if (LandscapeView.random.nextFloat() > LandscapeView.TREE_RANDOM)
            trees.add(new Tree(landscapeView,x67, MathUtils.lerp(prevY, y, 0.67f), scale));
        if (LandscapeView.random.nextFloat() > LandscapeView.TREE_RANDOM)
            trees.add(new Tree(landscapeView,x, y, scale));
        prevX = x;
        prevY = y;
    }
    path.close();

    if (landscapeView.drawClouds) {
        clouds.clear();
        int cloudCount = LandscapeView.random.nextInt(MAX_CLOUDS - MIN_CLOUDS) + MIN_CLOUDS;
        for (int i = 0; i < cloudCount; i++)
            clouds.add(new Cloud(LandscapeView.random.nextInt(landscapeView.getWidth()), LandscapeView.random.nextInt((int) landscapeView.skyHeight) + landscapeView.padding, landscapeView.cloudColor,scale));
    }
}