private Path CreateChildPath() { float bezierOffset = mChildOvalRadius * OVAL_BEZIER_FACTOR; Path path = new Path(); path.MoveTo(mChildPosition[0], mChildPosition[1] - mChildOvalRadius); //left_top arc path.CubicTo(mChildPosition[0] - bezierOffset - mChildLeftXOffset, mChildPosition[1] - mChildOvalRadius, mChildPosition[0] - mChildOvalRadius - mChildLeftXOffset, mChildPosition[1] - bezierOffset + mChildLeftYOffset, mChildPosition[0] - mChildOvalRadius - mChildLeftXOffset, mChildPosition[1]); //left_bottom arc path.CubicTo(mChildPosition[0] - mChildOvalRadius - mChildLeftXOffset, mChildPosition[1] + bezierOffset - mChildLeftYOffset, mChildPosition[0] - bezierOffset - mChildLeftXOffset, mChildPosition[1] + mChildOvalRadius, mChildPosition[0], mChildPosition[1] + mChildOvalRadius); //right_bottom arc path.CubicTo(mChildPosition[0] + bezierOffset + mChildRightXOffset, mChildPosition[1] + mChildOvalRadius, mChildPosition[0] + mChildOvalRadius + mChildRightXOffset, mChildPosition[1] + bezierOffset - mChildRightYOffset, mChildPosition[0] + mChildOvalRadius + mChildRightXOffset, mChildPosition[1]); //right_top arc path.CubicTo(mChildPosition[0] + mChildOvalRadius + mChildRightXOffset, mChildPosition[1] - bezierOffset + mChildRightYOffset, mChildPosition[0] + bezierOffset + mChildRightXOffset, mChildPosition[1] - mChildOvalRadius, mChildPosition[0], mChildPosition[1] - mChildOvalRadius); return(path); }
private Path CreateLinkPath() { Path path = new Path(); float bezierOffset = mMotherOvalHalfWidth * OVAL_BEZIER_FACTOR; float distance = (float)Math.Sqrt(Math.Pow(mMotherPosition[0] - mChildPosition[0], 2.0f) + Math.Pow(mMotherPosition[1] - mChildPosition[1], 2.0f)); if (distance <= mMotherOvalHalfWidth + mChildOvalRadius * 1.2f && distance >= mMotherOvalHalfWidth - mChildOvalRadius * 1.2f) { float maxOffsetY = 2 * mChildOvalRadius * 1.2f; float offsetRate = (distance - (mMotherOvalHalfWidth - mChildOvalRadius * 1.2f)) / maxOffsetY; float mMotherOvalOffsetY = mMotherOvalHalfHeight - offsetRate * (mMotherOvalHalfHeight - mChildOvalRadius) * 0.85f; mMotherOvalPath.AddOval(new RectF(mMotherPosition[0] - mMotherOvalHalfWidth, mMotherPosition[1] - mMotherOvalOffsetY, mMotherPosition[0] + mMotherOvalHalfWidth, mMotherPosition[1] + mMotherOvalOffsetY), Path.Direction.Cw); float mMotherXOffset = distance - mMotherOvalHalfWidth + mChildOvalRadius; float distanceUltraLeft = (float)Math.Sqrt(Math.Pow(mMotherPosition[0] - mMotherOvalHalfWidth - mChildPosition[0], 2.0f) + Math.Pow(mMotherPosition[1] - mChildPosition[1], 2.0f)); float distanceUltraRight = (float)Math.Sqrt(Math.Pow(mMotherPosition[0] + mMotherOvalHalfWidth - mChildPosition[0], 2.0f) + Math.Pow(mMotherPosition[1] - mChildPosition[1], 2.0f)); path.MoveTo(mMotherPosition[0], mMotherPosition[1] + mMotherOvalOffsetY); if (distanceUltraRight < distanceUltraLeft) { //right_bottom arc path.CubicTo(mMotherPosition[0] + bezierOffset + mMotherXOffset, mMotherPosition[1] + mMotherOvalOffsetY, mMotherPosition[0] + distance + mChildOvalRadius, mMotherPosition[1] + mChildOvalRadius * 1.5f, mMotherPosition[0] + distance + mChildOvalRadius, mMotherPosition[1]); //right_top arc path.CubicTo(mMotherPosition[0] + distance + mChildOvalRadius, mMotherPosition[1] - mChildOvalRadius * 1.5f, mMotherPosition[0] + bezierOffset + mMotherXOffset, mMotherPosition[1] - mMotherOvalOffsetY, mMotherPosition[0], mMotherPosition[1] - mMotherOvalOffsetY); } else { //left_bottom arc path.CubicTo(mMotherPosition[0] - bezierOffset - mMotherXOffset, mMotherPosition[1] + mMotherOvalOffsetY, mMotherPosition[0] - distance - mChildOvalRadius, mMotherPosition[1] + mChildOvalRadius * 1.5f, mMotherPosition[0] - distance - mChildOvalRadius, mMotherPosition[1]); //left_top arc path.CubicTo(mMotherPosition[0] - distance - mChildOvalRadius, mMotherPosition[1] - mChildOvalRadius * 1.5f, mMotherPosition[0] - bezierOffset - mMotherXOffset, mMotherPosition[1] - mMotherOvalOffsetY, mMotherPosition[0], mMotherPosition[1] - mMotherOvalOffsetY); } path.LineTo(mMotherPosition[0], mMotherPosition[1] + mMotherOvalOffsetY); } return(path); }
/// <summary> /// Coordinates are approximate, you have better cooperate with the designer's design draft /// </summary> private Path CreateBalloonPath(RectF balloonRect, float progress) { Path path = new Path(); path.MoveTo(balloonRect.CenterX(), balloonRect.Bottom); float progressWidth = balloonRect.Width() * progress; float progressHeight = balloonRect.Height() * progress; //draw left half float leftIncrementX1 = progressWidth * -0.48f; float leftIncrementY1 = progressHeight * 0.75f; float leftIncrementX2 = progressWidth * -0.03f; float leftIncrementY2 = progressHeight * -1.6f; float leftIncrementX3 = progressWidth * 0.9f; float leftIncrementY3 = progressHeight * -1.0f; path.CubicTo(balloonRect.Left + balloonRect.Width() * 0.25f + leftIncrementX1, balloonRect.CenterY() - balloonRect.Height() * 0.4f + leftIncrementY1, balloonRect.Left - balloonRect.Width() * 0.20f + leftIncrementX2, balloonRect.CenterY() + balloonRect.Height() * 1.15f + leftIncrementY2, balloonRect.Left - balloonRect.Width() * 0.4f + leftIncrementX3, balloonRect.Bottom + leftIncrementY3); // the results of the left final transformation // path.cubicTo(balloonRect.left - balloonRect.width() * 0.13f, balloonRect.CenterY() + balloonRect.height() * 0.35f, // balloonRect.left - balloonRect.width() * 0.23f, balloonRect.CenterY() - balloonRect.height() * 0.45f, // balloonRect.left + balloonRect.width() * 0.5f, balloonRect.bottom - balloonRect.height()); //draw right half float rightIncrementX1 = progressWidth * 1.51f; float rightIncrementY1 = progressHeight * -0.05f; float rightIncrementX2 = progressWidth * 0.03f; float rightIncrementY2 = progressHeight * 0.5f; float rightIncrementX3 = 0.0f; float rightIncrementY3 = 0.0f; path.CubicTo(balloonRect.Left - balloonRect.Width() * 0.38f + rightIncrementX1, balloonRect.CenterY() - balloonRect.Height() * 0.4f + rightIncrementY1, balloonRect.Left + balloonRect.Width() * 1.1f + rightIncrementX2, balloonRect.CenterY() - balloonRect.Height() * 0.15f + rightIncrementY2, balloonRect.Left + balloonRect.Width() * 0.5f + rightIncrementX3, balloonRect.Bottom + rightIncrementY3); // the results of the right final transformation // path.cubicTo(balloonRect.left + balloonRect.width() * 1.23f, balloonRect.CenterY() - balloonRect.height() * 0.45f, // balloonRect.left + balloonRect.width() * 1.13f, balloonRect.CenterY() + balloonRect.height() * 0.35f, // balloonRect.left + balloonRect.width() * 0.5f, balloonRect.bottom); return(path); }
void Initialize () { // Create Paint for all drawing paint = new Paint (); // All paths are based on 100-unit clock radius // centered at (0, 0). // Define circle for tick marks. tickMarks = new Path (); tickMarks.AddCircle (0, 0, 90, Path.Direction.Cw); // Hour, minute, second hands defined to point straight up. // Define hour hand. hourHand = new Path (); hourHand.MoveTo (0, -60); hourHand.CubicTo (0, -30, 20, -30, 5, -20); hourHand.LineTo (5, 0); hourHand.CubicTo (5, 7.5f, -5, 7.5f, -5, 0); hourHand.LineTo (-5, -20); hourHand.CubicTo (-20, -30, 0, -30, 0, -60); hourHand.Close (); // Define minute hand. minuteHand = new Path (); minuteHand.MoveTo (0, -80); minuteHand.CubicTo (0, -75, 0, -70, 2.5f, -60); minuteHand.LineTo (2.5f, 0); minuteHand.CubicTo (2.5f, 5, -2.5f, 5, -2.5f, 0); minuteHand.LineTo (-2.5f, -60); minuteHand.CubicTo (0, -70, 0, -75, 0, -80); minuteHand.Close (); // Define second hand. secondHand = new Path (); secondHand.MoveTo (0, 10); secondHand.LineTo (0, -80); }
private void AndroidDrawPath(GraphicsPath p) { var path = new Android.Graphics.Path(); float d = density; for (int i = 0; i < p._segments.Count; i++) { { var ln = p._segments[i] as GraphicsPath._LineSegment; if (ln != null) { if (i == 0) { path.MoveTo(ln.x1 * d, ln.y1 * d); } else { path.LineTo(ln.x1 * d, ln.y1 * d); } path.LineTo(ln.x2 * d, ln.y2 * d); continue; } } { var bz = p._segments[i] as GraphicsPath._BezierSegment; if (bz != null) { if (i == 0) { path.MoveTo(bz.x1 * d, bz.y1 * d); } else { path.LineTo(bz.x1 * d, bz.y1 * d); } path.CubicTo( bz.x2 * d, bz.y2 * d, bz.x3 * d, bz.y3 * d, bz.x4 * d, bz.y4 * d); continue; } } } if (p._closed) { path.Close(); } canvas.DrawPath(path, paint); }
private Path CreateChildMovePath() { Path path = new Path(); float CenterX = mCurrentBounds.CenterX(); float CenterY = mCurrentBounds.CenterY(); float currentPathLength = 0.0f; //start path.MoveTo(CenterX, CenterY); //pre forward top left path.LineTo(CenterX + mMotherOvalHalfWidth * 0.75f, CenterY); mStageChildPreForwardTopLeftLength = GetRestLength(path, currentPathLength); currentPathLength += mStageChildPreForwardTopLeftLength; //forward top left path.QuadTo(CenterX - mMotherOvalHalfWidth * 0.5f, CenterY, CenterX - mMotherOvalHalfWidth * 2.0f, CenterY - mMotherOvalHalfHeight); mStageChildForwardTopLeftLength = GetRestLength(path, currentPathLength); currentPathLength += mStageChildForwardTopLeftLength; //pre backward top left path.LineTo(CenterX - mMotherOvalHalfWidth * 2.0f + mMotherOvalHalfWidth * 0.2f, CenterY - mMotherOvalHalfHeight); path.QuadTo(CenterX - mMotherOvalHalfWidth * 2.5f, CenterY - mMotherOvalHalfHeight * 2, CenterX - mMotherOvalHalfWidth * 1.5f, CenterY - mMotherOvalHalfHeight * 2.25f); mStageChildPreBackwardTopLeftLength = GetRestLength(path, currentPathLength); currentPathLength += mStageChildPreBackwardTopLeftLength; //backward top left path.QuadTo(CenterX - mMotherOvalHalfWidth * 0.2f, CenterY - mMotherOvalHalfHeight * 2.25f, CenterX, CenterY); mStageChildBackwardTopLeftLength = GetRestLength(path, currentPathLength); currentPathLength += mStageChildBackwardTopLeftLength; //forward bottom left path.CubicTo(CenterX, CenterY + mMotherOvalHalfHeight, CenterX - mMotherOvalHalfWidth, CenterY + mMotherOvalHalfHeight * 2.5f, CenterX - mMotherOvalHalfWidth * 1.5f, CenterY + mMotherOvalHalfHeight * 2.5f); mStageChildForwardBottomLeftLength = GetRestLength(path, currentPathLength); currentPathLength += mStageChildForwardBottomLeftLength; //backward bottom left path.CubicTo(CenterX - mMotherOvalHalfWidth * 2.0f, CenterY + mMotherOvalHalfHeight * 2.5f, CenterX - mMotherOvalHalfWidth * 3.0f, CenterY + mMotherOvalHalfHeight * 0.8f, CenterX, CenterY); mStageChildBackwardBottomLeftLength = GetRestLength(path, currentPathLength); return(path); }
protected override void OnDraw(Canvas canvas) { var rect = new Rect(); this.GetDrawingRect(rect); var path = new Android.Graphics.Path(); var lastPoint = new PointF(); foreach (var command in PathDataParser.Parse(Element.Data)) { switch (command.Type) { case PathDataParser.CommandType.MoveTo: lastPoint = new PointF(command.Arguments[0], command.Arguments[1]); path.MoveTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.LineTo: lastPoint = new PointF(command.Arguments[0], command.Arguments[1]); path.LineTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.LineHor: lastPoint = new PointF(command.Arguments[0], lastPoint.Y); path.LineTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.LineVer: lastPoint = new PointF(lastPoint.X, command.Arguments[0]); path.LineTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.RelativeLineHor: lastPoint = new PointF(command.Arguments[0] + lastPoint.X, lastPoint.Y); path.LineTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.RelativeLineVer: lastPoint = new PointF(lastPoint.X, lastPoint.Y + command.Arguments[0]); path.LineTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.RelativeLineTo: lastPoint = new PointF(lastPoint.X + command.Arguments[0], lastPoint.Y + command.Arguments[1]); path.LineTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.RelativeMoveTo: lastPoint = new PointF(lastPoint.X + command.Arguments[0], lastPoint.Y + command.Arguments[1]); path.MoveTo(lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.QBezier: path.QuadTo(command.Arguments[0], command.Arguments[1], command.Arguments[2], command.Arguments[3]); lastPoint = new PointF(command.Arguments[2], command.Arguments[3]); break; case PathDataParser.CommandType.Bezier: path.CubicTo( command.Arguments[0], command.Arguments[1], command.Arguments[2], command.Arguments[3], command.Arguments[4], command.Arguments[5]); lastPoint = new PointF(command.Arguments[4], command.Arguments[5]); break; case PathDataParser.CommandType.RelativeBezier: var p1 = new PointF(lastPoint.X + command.Arguments[0], lastPoint.Y + command.Arguments[1]); var p2 = new PointF(p1.X + command.Arguments[2], p1.Y + command.Arguments[3]); lastPoint = new PointF(p2.X + command.Arguments[4], p2.Y + command.Arguments[5]); path.CubicTo(p1.X, p1.Y, p2.X, p2.Y, lastPoint.X, lastPoint.Y); break; case PathDataParser.CommandType.Close: path.Close(); break; } } var paint = new Paint(PaintFlags.AntiAlias); paint.StrokeWidth = Element.StrokeThickness; paint.StrokeMiter = 10f; canvas.Save(); paint.SetStyle(Paint.Style.Stroke); paint.Color = Element.Stroke.ToAndroid(); canvas.DrawPath(path, paint); canvas.Restore(); }
public void DrawPath(IEnumerable<PathOperation> ops, Pen pen = null, BaseBrush brush = null) { using (var path = new Path()) { var bb = new BoundingBoxBuilder(); foreach (var op in ops) { var moveTo = op as MoveTo; if (moveTo != null) { var start = moveTo.Start; var end = moveTo.End; path.MoveTo((float) start.X, (float) start.Y); bb.Add(start); bb.Add(end); continue; } var lineTo = op as LineTo; if (lineTo != null) { var start = lineTo.Start; var end = lineTo.End; path.LineTo((float) start.X, (float) start.Y); path.LineTo((float) end.X, (float) end.Y); bb.Add(start); bb.Add(end); continue; } var at = op as ArcTo; if (at != null) { var p = at.Point; path.LineTo((float) p.X, (float) p.Y); bb.Add(p); continue; } var curveTo = op as CurveTo; if (curveTo != null) { var end = curveTo.End; var firstControlPoint = curveTo.FirstControlPoint; var secondControlPoint = curveTo.SecondControlPoint; path.CubicTo((float) firstControlPoint.X, (float) firstControlPoint.Y, (float) secondControlPoint.X, (float) secondControlPoint.Y, (float) end.X, (float) end.Y); bb.Add(firstControlPoint); bb.Add(secondControlPoint); bb.Add(end); continue; } var cp = op as ClosePath; if (cp != null) { path.Close(); continue; } throw new NotSupportedException("Path Op " + op); } var frame = bb.BoundingBox; if (brush != null) { var solidBrush = brush as SolidBrush; if (solidBrush != null) { path.SetFillType(GetPathFillType(((SolidBrush)brush).FillMode)); } var brushPaint = GetBrushPaint(brush, frame); graphics.DrawPath(path, brushPaint); } if (pen != null) { var penPaint = GetPenPaint(pen); graphics.DrawPath(path, penPaint); } } }
public static APath ToAPath(this Geometry geometry, Context context) { APath path = new APath(); float density = context.Resources.DisplayMetrics.Density; if (geometry is LineGeometry) { LineGeometry lineGeometry = geometry as LineGeometry; path.MoveTo( density * (float)lineGeometry.StartPoint.X, density * (float)lineGeometry.StartPoint.Y); path.LineTo( density * (float)lineGeometry.EndPoint.X, density * (float)lineGeometry.EndPoint.Y); } else if (geometry is RectangleGeometry) { FormsRectangle rect = (geometry as RectangleGeometry).Rect; path.AddRect( density * (float)rect.Left, density * (float)rect.Top, density * (float)rect.Right, density * (float)rect.Bottom, APath.Direction.Cw); } else if (geometry is EllipseGeometry) { EllipseGeometry ellipseGeometry = geometry as EllipseGeometry; path.AddOval(new RectF( density * (float)(ellipseGeometry.Center.X - ellipseGeometry.RadiusX), density * (float)(ellipseGeometry.Center.Y - ellipseGeometry.RadiusY), density * (float)(ellipseGeometry.Center.X + ellipseGeometry.RadiusX), density * (float)(ellipseGeometry.Center.Y + ellipseGeometry.RadiusY)), APath.Direction.Cw); } else if (geometry is GeometryGroup) { GeometryGroup geometryGroup = geometry as GeometryGroup; path.SetFillType(geometryGroup.FillRule == FillRule.Nonzero ? APath.FillType.Winding : APath.FillType.EvenOdd); foreach (Geometry child in geometryGroup.Children) { APath childPath = child.ToAPath(context); path.AddPath(childPath); } } else if (geometry is PathGeometry) { PathGeometry pathGeometry = geometry as PathGeometry; path.SetFillType(pathGeometry.FillRule == FillRule.Nonzero ? APath.FillType.Winding : APath.FillType.EvenOdd); foreach (PathFigure pathFigure in pathGeometry.Figures) { path.MoveTo( density * (float)pathFigure.StartPoint.X, density * (float)pathFigure.StartPoint.Y); Point lastPoint = pathFigure.StartPoint; foreach (PathSegment pathSegment in pathFigure.Segments) { // LineSegment if (pathSegment is LineSegment) { LineSegment lineSegment = pathSegment as LineSegment; path.LineTo( density * (float)lineSegment.Point.X, density * (float)lineSegment.Point.Y); lastPoint = lineSegment.Point; } // PolylineSegment else if (pathSegment is PolyLineSegment) { PolyLineSegment polylineSegment = pathSegment as PolyLineSegment; PointCollection points = polylineSegment.Points; for (int i = 0; i < points.Count; i++) { path.LineTo( density * (float)points[i].X, density * (float)points[i].Y); } lastPoint = points[points.Count - 1]; } // BezierSegment else if (pathSegment is BezierSegment) { BezierSegment bezierSegment = pathSegment as BezierSegment; path.CubicTo( density * (float)bezierSegment.Point1.X, density * (float)bezierSegment.Point1.Y, density * (float)bezierSegment.Point2.X, density * (float)bezierSegment.Point2.Y, density * (float)bezierSegment.Point3.X, density * (float)bezierSegment.Point3.Y); lastPoint = bezierSegment.Point3; } // PolyBezierSegment else if (pathSegment is PolyBezierSegment) { PolyBezierSegment polyBezierSegment = pathSegment as PolyBezierSegment; PointCollection points = polyBezierSegment.Points; if (points.Count >= 3) { for (int i = 0; i < points.Count; i += 3) { path.CubicTo( density * (float)points[i + 0].X, density * (float)points[i + 0].Y, density * (float)points[i + 1].X, density * (float)points[i + 1].Y, density * (float)points[i + 2].X, density * (float)points[i + 2].Y); } } lastPoint = points[points.Count - 1]; } // QuadraticBezierSegment else if (pathSegment is QuadraticBezierSegment) { QuadraticBezierSegment bezierSegment = pathSegment as QuadraticBezierSegment; path.QuadTo( density * (float)bezierSegment.Point1.X, density * (float)bezierSegment.Point1.Y, density * (float)bezierSegment.Point2.X, density * (float)bezierSegment.Point2.Y); lastPoint = bezierSegment.Point2; } // PolyQuadraticBezierSegment else if (pathSegment is PolyQuadraticBezierSegment) { PolyQuadraticBezierSegment polyBezierSegment = pathSegment as PolyQuadraticBezierSegment; PointCollection points = polyBezierSegment.Points; if (points.Count >= 2) { for (int i = 0; i < points.Count; i += 2) { path.QuadTo( density * (float)points[i + 0].X, density * (float)points[i + 0].Y, density * (float)points[i + 1].X, density * (float)points[i + 1].Y); } } lastPoint = points[points.Count - 1]; } // ArcSegment else if (pathSegment is ArcSegment) { ArcSegment arcSegment = pathSegment as ArcSegment; List <Point> points = new List <Point>(); GeometryHelper.FlattenArc( points, lastPoint, arcSegment.Point, arcSegment.Size.Width, arcSegment.Size.Height, arcSegment.RotationAngle, arcSegment.IsLargeArc, arcSegment.SweepDirection == SweepDirection.CounterClockwise, 1); for (int i = 0; i < points.Count; i++) { path.LineTo( density * (float)points[i].X, density * (float)points[i].Y); } if (points.Count > 0) { lastPoint = points[points.Count - 1]; } } } if (pathFigure.IsClosed) { path.Close(); } } } return(path); }
public DrawerArrowDrawable(Resources resources, Boolean rounded1) { rounded = rounded1; float density = resources.DisplayMetrics.Density; float strokeWidthPixel = STROKE_WIDTH_DP * density; halfStrokeWidthPixel = strokeWidthPixel / 2; linePaint = new Paint(Android.Graphics.PaintFlags.SubpixelText | Android.Graphics.PaintFlags.AntiAlias); linePaint.StrokeCap=rounded ? Android.Graphics.Paint.Cap.Round : Android.Graphics.Paint.Cap.Butt; linePaint.Color=Android.Graphics.Color.Black; linePaint.SetStyle (Android.Graphics.Paint.Style.Stroke); linePaint.StrokeWidth=strokeWidthPixel; int dimen = (int) (DIMEN_DP * density); bounds = new Rect(0, 0, dimen, dimen); Path first, second; JoinedPath joinedA, joinedB; // Top first = new Path(); first.MoveTo(5.042f, 20f); first.RCubicTo(8.125f, -16.317f, 39.753f, -27.851f, 55.49f, -2.765f); second = new Path(); second.MoveTo(60.531f, 17.235f); second.RCubicTo(11.301f, 18.015f, -3.699f, 46.083f, -23.725f, 43.456f); scalePath(first, density); scalePath(second, density); joinedA = new JoinedPath(first, second); first = new Path(); first.MoveTo(64.959f, 20f); first.RCubicTo(4.457f, 16.75f, 1.512f, 37.982f, -22.557f, 42.699f); second = new Path(); second.MoveTo(42.402f, 62.699f); second.CubicTo(18.333f, 67.418f, 8.807f, 45.646f, 8.807f, 32.823f); scalePath(first, density); scalePath(second, density); joinedB = new JoinedPath(first, second); topLine = new BridgingLine(joinedA, joinedB); // Middle first = new Path(); first.MoveTo(5.042f, 35f); first.CubicTo(5.042f, 20.333f, 18.625f, 6.791f, 35f, 6.791f); second = new Path(); second.MoveTo(35f, 6.791f); second.RCubicTo(16.083f, 0f, 26.853f, 16.702f, 26.853f, 28.209f); scalePath(first, density); scalePath(second, density); joinedA = new JoinedPath(first, second); first = new Path(); first.MoveTo(64.959f, 35f); first.RCubicTo(0f, 10.926f, -8.709f, 26.416f, -29.958f, 26.416f); second = new Path(); second.MoveTo(35f, 61.416f); second.RCubicTo(-7.5f, 0f, -23.946f, -8.211f, -23.946f, -26.416f); scalePath(first, density); scalePath(second, density); joinedB = new JoinedPath(first, second); middleLine = new BridgingLine(joinedA, joinedB); // Bottom first = new Path(); first.MoveTo(5.042f, 50f); first.CubicTo(2.5f, 43.312f, 0.013f, 26.546f, 9.475f, 17.346f); second = new Path(); second.MoveTo(9.475f, 17.346f); second.RCubicTo(9.462f, -9.2f, 24.188f, -10.353f, 27.326f, -8.245f); scalePath(first, density); scalePath(second, density); joinedA = new JoinedPath(first, second); first = new Path(); first.MoveTo(64.959f, 50f); first.RCubicTo(-7.021f, 10.08f, -20.584f, 19.699f, -37.361f, 12.74f); second = new Path(); second.MoveTo(27.598f, 62.699f); second.RCubicTo(-15.723f, -6.521f, -18.8f, -23.543f, -18.8f, -25.642f); scalePath(first, density); scalePath(second, density); joinedB = new JoinedPath(first, second); bottomLine = new BridgingLine(joinedA, joinedB); }
public void DrawPath(IEnumerable <PathOperation> ops, Pen pen = null, BaseBrush brush = null) { using (var path = new Path()) { var bb = new BoundingBoxBuilder(); foreach (var op in ops) { var moveTo = op as MoveTo; if (moveTo != null) { var start = moveTo.Start; var end = moveTo.End; path.MoveTo((float)start.X, (float)start.Y); bb.Add(start); bb.Add(end); continue; } var lineTo = op as LineTo; if (lineTo != null) { var start = lineTo.Start; var end = lineTo.End; path.LineTo((float)start.X, (float)start.Y); path.LineTo((float)end.X, (float)end.Y); bb.Add(start); bb.Add(end); continue; } var at = op as ArcTo; if (at != null) { var p = at.Point; path.LineTo((float)p.X, (float)p.Y); bb.Add(p); continue; } var curveTo = op as CurveTo; if (curveTo != null) { var end = curveTo.End; var firstControlPoint = curveTo.FirstControlPoint; var secondControlPoint = curveTo.SecondControlPoint; path.CubicTo((float)firstControlPoint.X, (float)firstControlPoint.Y, (float)secondControlPoint.X, (float)secondControlPoint.Y, (float)end.X, (float)end.Y); bb.Add(firstControlPoint); bb.Add(secondControlPoint); bb.Add(end); continue; } var cp = op as ClosePath; if (cp != null) { path.Close(); continue; } throw new NotSupportedException("Path Op " + op); } var frame = bb.BoundingBox; if (brush != null) { var solidBrush = brush as SolidBrush; if (solidBrush != null) { path.SetFillType(GetPathFillType(((SolidBrush)brush).FillMode)); } var brushPaint = GetBrushPaint(brush, frame); graphics.DrawPath(path, brushPaint); } if (pen != null) { var penPaint = GetPenPaint(pen); graphics.DrawPath(path, penPaint); } } }
public static APath AsAndroidPath(this PathF path) { var nativePath = new APath(); int pointIndex = 0; int arcAngleIndex = 0; int arcClockwiseIndex = 0; foreach (var operation in path.PathOperations) { if (operation == PathOperation.MoveTo) { var point = path[pointIndex++]; nativePath.MoveTo(point.X, point.Y); } else if (operation == PathOperation.Line) { var point = path[pointIndex++]; nativePath.LineTo(point.X, point.Y); } else if (operation == PathOperation.Quad) { var controlPoint = path[pointIndex++]; var point = path[pointIndex++]; nativePath.QuadTo(controlPoint.X, controlPoint.Y, point.X, point.Y); } else if (operation == PathOperation.Cubic) { var controlPoint1 = path[pointIndex++]; var controlPoint2 = path[pointIndex++]; var point = path[pointIndex++]; nativePath.CubicTo(controlPoint1.X, controlPoint1.Y, controlPoint2.X, controlPoint2.Y, point.X, point.Y); } else if (operation == PathOperation.Arc) { var topLeft = path[pointIndex++]; var bottomRight = path[pointIndex++]; var startAngle = path.GetArcAngle(arcAngleIndex++); var endAngle = path.GetArcAngle(arcAngleIndex++); var clockwise = path.IsArcClockwise(arcClockwiseIndex++); while (startAngle < 0) { startAngle += 360; } while (endAngle < 0) { endAngle += 360; } var rect = new RectF(topLeft.X, topLeft.Y, bottomRight.X, bottomRight.Y); var sweep = GraphicsOperations.GetSweep(startAngle, endAngle, clockwise); startAngle *= -1; if (!clockwise) { sweep *= -1; } nativePath.ArcTo(rect, startAngle, sweep); } else if (operation == PathOperation.Close) { nativePath.Close(); } } return(nativePath); }
public override void Draw(Canvas canvas) { var w = width / (Count - 2); var path = new Path (); path.MoveTo (0, height - u1 [0]); for (int i = 1; i < Count; i += 3) { path.CubicTo (i * w, height - u1 [Math.Min (Count - 1, i)], (i + 1) * w, height - u1 [Math.Min (Count - 1, i + 1)], (i + 2) * w, height - u1 [Math.Min (Count - 1, i + 2)]); } path.LineTo (width, height); path.LineTo (0, height); path.Close (); canvas.DrawPath (path, paint); if (bubblesEnabled) DrawBubbles (canvas, w); }
protected override void OnDraw(Canvas canvas) { base.OnDraw(canvas); switch(mShape) { case Shape.TRIANGLE: { if (mIsLoading) { mAnimPercent += 0.1611113f; Path path = new Path(); path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0.5f)); if (mAnimPercent >= 1) { mShape = Shape.CIRCLE; mIsLoading = false; mAnimPercent = 1; } float controlX = mControlX - RelativeXFromView(mAnimPercent * triangle2Circle) * genhao3; float controlY = mControlY - RelativeYFromView(mAnimPercent * triangle2Circle); path.QuadTo(RelativeXFromView(1) - controlX, controlY, RelativeXFromView(0.5f + genhao3 / 4), RelativeYFromView(0.75f)); path.QuadTo(RelativeXFromView(0.5f), RelativeYFromView(0.75f + 2 * mAnimPercent * triangle2Circle), RelativeXFromView(0.5f - genhao3 / 4), RelativeYFromView(0.75f)); path.QuadTo(controlX, controlY, RelativeXFromView(0.5f), RelativeYFromView(0f)); path.Close(); canvas.DrawPath(path, mPaint); Invalidate(); } else { Path path = new Path(); mPaint.Color = Resources.GetColor(Resource.Color.triangle); path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0f)); path.LineTo(RelativeXFromView(1), RelativeYFromView(genhao3 / 2f)); path.LineTo(RelativeXFromView(0), RelativeYFromView(genhao3 / 2f)); mControlX = RelativeXFromView(0.5f - genhao3 / 8f); mControlY = RelativeYFromView(3 / 8f); mAnimPercent = 0; path.Close(); canvas.DrawPath(path, mPaint); } } break; case Shape.CIRCLE: { if(mIsLoading) { float magicNumber = mMagicNumber + mAnimPercent; mAnimPercent += 0.12f; if(magicNumber + mAnimPercent > 1.9f) { mShape = Shape.RECT; mIsLoading = false; } Path path = new Path(); path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0f)); path.CubicTo(RelativeXFromView(0.5f + magicNumber / 2), RelativeYFromView(0f), RelativeXFromView(1), RelativeYFromView(0.5f - magicNumber / 2), RelativeXFromView(1f), RelativeYFromView(0.5f)); path.CubicTo(RelativeXFromView(1), RelativeXFromView(0.5f + magicNumber / 2), RelativeXFromView(0.5f + mMagicNumber / 2), RelativeYFromView(1f), RelativeXFromView(0.5f), RelativeYFromView(1f)); path.CubicTo(RelativeXFromView(0.5f - magicNumber / 2), RelativeXFromView(1f), RelativeXFromView(0), RelativeYFromView(0.5f + magicNumber / 2), RelativeXFromView(0f), RelativeYFromView(0.5f)); path.CubicTo(RelativeXFromView(0f), RelativeXFromView(0.5f - magicNumber / 2), RelativeXFromView(0.5f - magicNumber / 2), RelativeYFromView(0), RelativeXFromView(0.5f), RelativeYFromView(0f)); path.Close(); canvas.DrawPath(path, mPaint); Invalidate(); } else { mPaint.Color = Resources.GetColor(Resource.Color.circle); Path path = new Path(); float magicNumber = mMagicNumber; path.MoveTo(RelativeXFromView(0.5f), RelativeYFromView(0f)); path.CubicTo(RelativeXFromView(0.5f + magicNumber / 2), 0, RelativeXFromView(1), RelativeYFromView(magicNumber / 2), RelativeXFromView(1f), RelativeYFromView(0.5f)); path.CubicTo( RelativeXFromView(1), RelativeXFromView(0.5f + magicNumber / 2), RelativeXFromView(0.5f + magicNumber / 2), RelativeYFromView(1f), RelativeXFromView(0.5f), RelativeYFromView(1f)); path.CubicTo(RelativeXFromView(0.5f - magicNumber / 2), RelativeXFromView(1f), RelativeXFromView(0), RelativeYFromView(0.5f + magicNumber / 2), RelativeXFromView(0f), RelativeYFromView(0.5f)); path.CubicTo(RelativeXFromView(0f), RelativeXFromView(0.5f - magicNumber / 2), RelativeXFromView(0.5f - magicNumber / 2), RelativeYFromView(0), RelativeXFromView(0.5f), RelativeYFromView(0f)); mAnimPercent = 0; path.Close(); canvas.DrawPath(path, mPaint); } } break; case Shape.RECT: { if(mIsLoading) { mAnimPercent += 0.15f; if(mAnimPercent >= 1) { mShape = Shape.TRIANGLE; mIsLoading = false; mAnimPercent = 1; } Path path = new Path(); path.MoveTo(RelativeXFromView(0.5f * mAnimPercent), 0); path.LineTo(RelativeYFromView(1 - 0.5f * mAnimPercent), 0); float distanceX = (mControlX) * mAnimPercent; float distanceY = (RelativeYFromView(1f) - mControlY) * mAnimPercent; path.LineTo(RelativeXFromView(1f) - distanceX, RelativeYFromView(1f) - distanceY); path.LineTo(RelativeXFromView(0f) + distanceX, RelativeYFromView(1f) - distanceY); path.Close(); canvas.DrawPath(path, mPaint); Invalidate(); } else { mPaint.Color = Resources.GetColor(Resource.Color.rect); mControlX = RelativeXFromView(0.5f - genhao3 / 4); mControlY = RelativeYFromView(0.75f); Path path = new Path(); path.MoveTo(RelativeXFromView(0f), RelativeYFromView(0f)); path.LineTo(RelativeXFromView(1f), RelativeYFromView(0f)); path.LineTo(RelativeXFromView(1f), RelativeYFromView(1f)); path.LineTo(RelativeXFromView(0f), RelativeYFromView(1f)); path.Close(); mAnimPercent = 0; canvas.DrawPath(path, mPaint); } } break; } }
public object ConvertToNative(Geometry geometry) { // TODO: Can we keep this object around and reset it? droidGraphics.Path path = new droidGraphics.Path(); // TODO: Might we also save a non-transformed path and a transformed path? -- No, that fails for GeometryGroup // Determine what type of Geometry we're dealing with if (geometry is LineGeometry) { LineGeometry lineGeometry = geometry as LineGeometry; path.MoveTo(PixelsPerDip * (float)lineGeometry.StartPoint.X, PixelsPerDip * (float)lineGeometry.StartPoint.Y); path.LineTo(PixelsPerDip * (float)lineGeometry.EndPoint.X, PixelsPerDip * (float)lineGeometry.EndPoint.Y); } else if (geometry is RectangleGeometry) { Rect rect = (geometry as RectangleGeometry).Rect; path.AddRect(PixelsPerDip * (float)rect.Left, PixelsPerDip * (float)rect.Top, PixelsPerDip * (float)rect.Right, PixelsPerDip * (float)rect.Bottom, droidGraphics.Path.Direction.Cw); // TODO: Check for compatibility! } else if (geometry is EllipseGeometry) { EllipseGeometry ellipseGeometry = geometry as EllipseGeometry; path.AddOval(new droidGraphics.RectF( PixelsPerDip * (float)(ellipseGeometry.Center.X - ellipseGeometry.RadiusX), PixelsPerDip * (float)(ellipseGeometry.Center.Y - ellipseGeometry.RadiusY), PixelsPerDip * (float)(ellipseGeometry.Center.X + ellipseGeometry.RadiusX), PixelsPerDip * (float)(ellipseGeometry.Center.Y + ellipseGeometry.RadiusY)), droidGraphics.Path.Direction.Cw); // TODO: Check for compatibility! } else if (geometry is GeometryGroup) { GeometryGroup geometryGroup = geometry as GeometryGroup; SetFillRule(path, geometryGroup.FillRule); foreach (Geometry child in geometryGroup.Children) { droidGraphics.Path childPath = ConvertToNative(child) as droidGraphics.Path; path.AddPath(childPath); } } else if (geometry is PathGeometry) { PathGeometry pathGeometry = geometry as PathGeometry; SetFillRule(path, pathGeometry.FillRule); foreach (PathFigure pathFigure in pathGeometry.Figures) { path.MoveTo(PixelsPerDip * (float)pathFigure.StartPoint.X, PixelsPerDip * (float)pathFigure.StartPoint.Y); Point lastPoint = pathFigure.StartPoint; foreach (PathSegment pathSegment in pathFigure.Segments) { // LineSegment if (pathSegment is LineSegment) { LineSegment lineSegment = pathSegment as LineSegment; path.LineTo(PixelsPerDip * (float)lineSegment.Point.X, PixelsPerDip * (float)lineSegment.Point.Y); lastPoint = lineSegment.Point; } // PolylineSegment else if (pathSegment is PolyLineSegment) { PolyLineSegment polylineSegment = pathSegment as PolyLineSegment; PointCollection points = polylineSegment.Points; for (int i = 0; i < points.Count; i++) { path.LineTo(PixelsPerDip * (float)points[i].X, PixelsPerDip * (float)points[i].Y); } lastPoint = points[points.Count - 1]; } // BezierSegment else if (pathSegment is BezierSegment) { BezierSegment bezierSegment = pathSegment as BezierSegment; path.CubicTo(PixelsPerDip * (float)bezierSegment.Point1.X, PixelsPerDip * (float)bezierSegment.Point1.Y, PixelsPerDip * (float)bezierSegment.Point2.X, PixelsPerDip * (float)bezierSegment.Point2.Y, PixelsPerDip * (float)bezierSegment.Point3.X, PixelsPerDip * (float)bezierSegment.Point3.Y); lastPoint = bezierSegment.Point3; } // PolyBezierSegment else if (pathSegment is PolyBezierSegment) { PolyBezierSegment polyBezierSegment = pathSegment as PolyBezierSegment; PointCollection points = polyBezierSegment.Points; for (int i = 0; i < points.Count; i += 3) { path.CubicTo(PixelsPerDip * (float)points[i + 0].X, PixelsPerDip * (float)points[i + 0].Y, PixelsPerDip * (float)points[i + 1].X, PixelsPerDip * (float)points[i + 1].Y, PixelsPerDip * (float)points[i + 2].X, PixelsPerDip * (float)points[i + 2].Y); } lastPoint = points[points.Count - 1]; } // QuadraticBezierSegment else if (pathSegment is QuadraticBezierSegment) { QuadraticBezierSegment bezierSegment = pathSegment as QuadraticBezierSegment; path.QuadTo(PixelsPerDip * (float)bezierSegment.Point1.X, PixelsPerDip * (float)bezierSegment.Point1.Y, PixelsPerDip * (float)bezierSegment.Point2.X, PixelsPerDip * (float)bezierSegment.Point2.Y); lastPoint = bezierSegment.Point2; } // PolyQuadraticBezierSegment else if (pathSegment is PolyQuadraticBezierSegment) { PolyQuadraticBezierSegment polyBezierSegment = pathSegment as PolyQuadraticBezierSegment; PointCollection points = polyBezierSegment.Points; for (int i = 0; i < points.Count; i += 2) { path.QuadTo(PixelsPerDip * (float)points[i + 0].X, PixelsPerDip * (float)points[i + 0].Y, PixelsPerDip * (float)points[i + 1].X, PixelsPerDip * (float)points[i + 1].Y); } lastPoint = points[points.Count - 1]; } // ArcSegment else if (pathSegment is ArcSegment) { ArcSegment arcSegment = pathSegment as ArcSegment; List <Point> points = new List <Point>(); Xamarin.Forms.Shapes.Shapes.FlattenArc(points, lastPoint, arcSegment.Point, arcSegment.Size.Width, arcSegment.Size.Height, arcSegment.RotationAngle, arcSegment.IsLargeArc, arcSegment.SweepDirection == SweepDirection.Counterclockwise, 1); for (int i = 0; i < points.Count; i++) { path.LineTo(PixelsPerDip * (float)points[i].X, PixelsPerDip * (float)points[i].Y); } lastPoint = points[points.Count - 1]; } } if (pathFigure.IsClosed) { path.Close(); } } } // Apply transform if (geometry.Transform != null) { path.Transform((droidGraphics.Matrix)geometry.Transform.GetNativeObject()); } return(path); }
void drawLines (Canvas canvas, Paint paint) { float x, y; // Draw curved graph line var whiteAlpha25 = Color.Argb (64, 255, 255, 255); //var whiteAlpha70 = Color.Argb (64, 255, 255, 255); var start = new PointF (); var end = new PointF (); using (Path path = new Path ()) { var count = hourly ? HourlyTemps.Count : (Forecasts.Count * 2); for (int i = 0; i < count; i++) { // adjusted index var ai = i; double temp; if (hourly) { temp = HourlyTemps [ai]; } else { // reset start when switching from highs to lows if (i == Forecasts.Count) start = new PointF (); var highs = i < Forecasts.Count; ai = highs ? i : i - Forecasts.Count; temp = highs ? HighTemps [ai] : LowTemps [ai]; } var percent = ((float)temp - scaleLow) / scaleRange; x = padding + inset + (ai * scaleX); y = graphRect.Bottom - (graphRect.Height () * percent); end = new PointF (x, y); if (!hourly) { path.AddCircle (end.X - lineWidth, end.Y - lineWidth, lineWidth / 2, Path.Direction.Cw); } if (start.IsEmpty ()) { path.MoveTo (end); } else { path.MoveTo (start); if (hourly) { path.LineTo (end); } else { var diff = (end.X - start.X) / 2; path.CubicTo (end.X - diff, start.Y, start.X + diff, end.Y, end.X, end.Y); } } start = end; } paint.Color = whiteAlpha25; paint.StrokeWidth = lineWidth; paint.SetStyle (Paint.Style.Stroke); canvas.DrawPath (path, paint); } }