コード例 #1
0
        private void OnPaintCanvas(object sender, SKPaintSurfaceEventArgs e)
        {
            SKImageInfo info    = e.Info;
            SKSurface   surface = e.Surface;
            SKCanvas    canvas  = surface.Canvas;

            int     surfaceWidth  = info.Width;
            int     surfaceHeight = info.Height;
            SKPoint surfaceSize   = new SKPoint(surfaceWidth, surfaceHeight);



            //絵画開始
            //背景色を塗る
            canvas.Clear(PaintColors.DefaultBackground);
            SKBitmap bitmap = PaintPatterns.CheckeredPattern(PaintColors.Black);


            //pathList絵画
            foreach (var aPath in pathList)
            {
                if (!aPath.IsVisibility)
                {
                    continue;
                }

                if (aPath.Points.Count >= 2)
                {
                    canvas.DrawPath(aPath.ToSKPath(), aPath.FillPaint);
                    canvas.DrawPath(aPath.ToSKPath(), aPath.StrokePaint);
                }
                else if (aPath.Points.Count == 1)
                {
                    canvas.DrawPoint(aPath.GetFirst(), aPath.StrokePaint);
                }
            }


            //最前面
            //Lasso色で暫定Pathを絵画
            if (!inProgressPath.IsEmpty())
            {
                if (inProgressPath.Points.Count >= 2)
                {
                    canvas.DrawPath(inProgressPath.ToSKPath(), inProgressPath.FillPaint);
                    canvas.DrawPath(inProgressPath.ToSKPath(), inProgressPath.StrokePaint);
                }
                else if (inProgressPath.Points.Count == 1)
                {
                    canvas.DrawPoint(inProgressPath.GetFirst(), inProgressPath.StrokePaint);
                }
            }
        }
コード例 #2
0
 public void PaintSurface(SkiaManager skiaManager, SKCanvas canvas)
 {
     foreach (var skiaObject in SketchEngine.SketchObjectList)
     {
         if (skiaObject is IRectTransformable)
         {
             var rect = skiaManager.SketchSpaceToCanvasSpaceMatrix.MapRect((skiaObject as IRectTransformable).RectTransform.Rect.ToSKRect());
             canvas.DrawRect(rect, FramePaint);
             canvas.DrawPoint(skiaManager.SketchSpaceToCanvasSpaceMatrix.MapPoint((skiaObject as IRectTransformable).RectTransform.Rect.Min.ToSKPoint()), MinPointPaint);
             canvas.DrawPoint(skiaManager.SketchSpaceToCanvasSpaceMatrix.MapPoint((skiaObject as IRectTransformable).RectTransform.Rect.Max.ToSKPoint()), MaxPointPaint);
         }
     }
 }
コード例 #3
0
 //
 // Takes a list of points and  draws lines between them
 //
 private void drawRoute(List <MapPoint> points, SKCanvas canvas)
 {
     for (int i = 0; i < points.Count - 1; i++) // count produces higher value than max index
     {
         if (i == 0)
         {
             canvas.DrawPoint(points[i].getPointLocation(), greenStroke);
         }
         else if (i < points.Count - 1)
         {
             canvas.DrawPoint(points[i].getPointLocation(), blackStroke); // not super necessary, illustrating where points were found
         }
         canvas.DrawLine(points[i].getPointLocation(), points[i + 1].getPointLocation(), routeColour);
     }
 }
コード例 #4
0
        ///     handles / calls all the drawing
        ///     if you need to refresh / reset, call invalidate in
        ///         NavigationPageDetail()
        private void canvas_PaintSurface(object sender, SKPaintSurfaceEventArgs e)
        {
            SKSurface surface = e.Surface;      // screen
            SKCanvas  canvas  = surface.Canvas; // drawable screen

            int width  = e.Info.Width;          // screen dimensions
            int height = e.Info.Height;

            canvas.Scale(1, 1);

            setFloorPlan(width, height);

            canvas.DrawBitmap(image, new SKRect(0, 0, width, height));

            canvas.Save(); // unnecessary at this moment, but leave in


            // Calls routing
            if (currentLocation != null)
            {
                LoadPoints      pointLoader = new LoadPoints();
                List <MapPoint> points      = pointLoader.loadPoints(width, height);

                points = calculateRoute(points);
                drawRoute(points, canvas);

                canvas.DrawPoint(points[points.Count - 1].pointLocation, redStroke);
            }
        }
コード例 #5
0
        public void Render(SKCanvas canvas, IGeometryVisual geometry, double scale)
        {
            var moist = geometry as IMoist;

            if (moist == null || !moist.IsValid)
            {
                return;
            }
            using (var paint = new SKPaint())
            {
                // Setup common paint parameters
                paint.Color       = moist.ToolSettings.SelectedColor.ToSkiaColor();
                paint.IsAntialias = true;
                paint.IsStroke    = false;
                var text = moist.ToolSettings.SelectedText;
                if (string.IsNullOrEmpty(text))
                {
                    paint.StrokeWidth = (float)(moist.Size * scale);
                    paint.StrokeCap   = SKStrokeCap.Round;
                    canvas.DrawPoint((float)(moist.Point.X * scale), (float)(moist.Point.Y * scale), paint);
                }
                else
                {
                    paint.TextSize = (float)(moist.Size * scale);
                    // Get the path of the text to calibrate the touch point to the middle of the text area
                    var originalTextPath = paint.GetTextPath(text, (float)(moist.Point.X * scale), (float)(moist.Point.Y * scale));
                    // Set the mid of the text area to the touch point
                    var calibratedX = originalTextPath.Bounds.Left - originalTextPath.Bounds.Width / 2;
                    var calibratedY = originalTextPath.Bounds.Bottom + originalTextPath.Bounds.Height / 2;

                    // Set the right text color
                    var textColor = Converter.ContrastColor(moist.ToolSettings.SelectedColor);
                    // Get the path of the calibrated text area and add some padding to the rect
                    var calibratedTextPath = paint.GetTextPath(text, calibratedX, calibratedY);
                    // Rect parameters
                    float left;
                    float top;
                    float right;
                    float bottom;
                    float cornerRadius;

                    var textSizeDependentPadding = paint.TextSize / 4;
                    left         = calibratedTextPath.Bounds.Left - textSizeDependentPadding;
                    top          = calibratedTextPath.Bounds.Top - textSizeDependentPadding;
                    right        = calibratedTextPath.Bounds.Right + textSizeDependentPadding;
                    bottom       = calibratedTextPath.Bounds.Bottom + textSizeDependentPadding;
                    cornerRadius = paint.TextSize / 2;

                    var rect = new SKRect(left, top, right, bottom);
                    // Draw background rect
                    canvas.DrawRoundRect(rect, cornerRadius, cornerRadius, paint);
                    // Draw text
                    paint.Color = textColor.ToSkiaColor();
                    canvas.DrawText(text, calibratedX, calibratedY, paint);
                    // Draw the background border in same color as text
                    paint.IsStroke = true;
                    canvas.DrawRoundRect(rect, cornerRadius, cornerRadius, paint);
                }
            }
        }
コード例 #6
0
        /// <summary>Draws the test layout area</summary>
        /// <param name="info"></param>
        /// <param name="canvas"></param>
        private void DrawLayout(SKImageInfo info, SKCanvas canvas)
        {
            SKPaint debugPaint = new SKPaint()
            {
                Color = _test, StrokeWidth = 1, Style = SKPaintStyle.Stroke
            };

            // draw origin and control area frame
            canvas.DrawPoint(this.Origin, new SKPaint()
            {
                Color = _test, StrokeWidth = 20, Style = SKPaintStyle.Stroke, StrokeCap = SKStrokeCap.Round
            });
            canvas.DrawRect(this.OuterRect, debugPaint);
            canvas.DrawRect(this.InscribedRect, debugPaint);

            // frame the entire canvas
            canvas.DrawRect(0, 0, info.Width - 1, info.Height - 1, new SKPaint()
            {
                Color = _test, StrokeWidth = 1, Style = SKPaintStyle.Stroke
            });

            // draw cross hairs
            canvas.DrawLine(this.Origin.X, 0, this.Origin.X, info.Height, debugPaint);
            canvas.DrawLine(0, this.Origin.Y, info.Width, this.Origin.Y, debugPaint);
        }
コード例 #7
0
 /// <inheritdoc />
 protected override void DrawBar(ChartSerie serie, SKCanvas canvas, float headerHeight, float itemX, SKSize itemSize, SKSize barSize, float origin, float barX, float barY, SKColor color)
 {
     if (PointMode != PointMode.None)
     {
         var point = new SKPoint(barX - (itemSize.Width / 2) + (barSize.Width / 2), barY);
         canvas.DrawPoint(point, color, PointSize, PointMode);
     }
 }
コード例 #8
0
        public override void Draw(SKCanvas canvas)
        {
            foreach (var point in Points)
            {
                canvas.DrawPoint(point, Paint);
            }

            //canvas.DrawPath(Path, Paint);
        }
コード例 #9
0
        public void DrawPoint(float x, float y, SKPaint paint)
        {
            canvas.DrawPoint(x, y, paint);

            if (calculateBounds)
            {
                displayObject.addBoundingPoint(x, y);
            }
        }
コード例 #10
0
        //public static void DrawPoint(SKCanvas canvas, SKPaint paint, SKPoint point, float raidus) {
        //  canvas.DrawCircle( point, raidus, paint );
        //}

        public static void DrawPoints(SKCanvas canvas, SKPaint paint, List <SKPoint> points)
        {
            if (points == null || points.Count == 0)// < 4
            {
                return;
            }

            for (int i = 0; i < points.Count; i++)
            {
                canvas.DrawPoint(points[i], paint);
            }
        }
コード例 #11
0
 protected void DrawPoints(SKCanvas canvas, SKPoint[] points)
 {
     if (points.Length > 0 && PointMode != PointMode.None)
     {
         for (int i = 0; i < points.Length; i++)
         {
             var entry = this.Entries.ElementAt(i);
             var point = points[i];
             canvas.DrawPoint(point, entry.Color, this.PointSize, this.PointMode);
         }
     }
 }
コード例 #12
0
        /// <summary></summary>
        /// <param name="info"></param>
        /// <param name="canvas"></param>
        private void DrawGraph(SKImageInfo info, SKCanvas canvas)
        {
            if (this.Series == null)
            {
                return;
            }

            float xf = (this.GraphFrame.Width / (this.XMax - this.XMin));
            float yf = (this.GraphFrame.Height / (this.YMax - this.YMin));

            // iterate each line series
            foreach (LineSeries ls in this.Series)
            {
                using (SKPaint axisPaint = new SKPaint()
                {
                    Color = ls.LineColor, StrokeWidth = ls.StrokeWidth, Style = SKPaintStyle.Stroke, IsAntialias = true
                })
                {
                    // normalize the points to the graph frame
                    SKPoint[] tps = new SKPoint[ls.Values.Length];

                    // calculate all the points
                    for (int i = 0; i < ls.Values.Length; ++i)
                    {
                        tps[i] = new SKPoint(this.GraphFrame.Left + ((ls.Values[i].X - this.XMin) * xf), this.TitleHeight + this.GraphFrame.Height - ((ls.Values[i].Y - this.YMin) * yf));
                    }

                    if (tps.Length < 2)
                    {
                        continue;
                    }

                    // draw the lines
                    for (int i = 0; i < tps.Length - 1; ++i)
                    {
                        canvas.DrawLine(tps[i], tps[i + 1], axisPaint);
                    }

                    // draw the dots
                    using (SKPaint ptPaint = new SKPaint()
                    {
                        Color = ls.LineColor, StrokeWidth = ls.StrokeWidth * 5.0F, StrokeCap = SKStrokeCap.Round, IsAntialias = true
                    })
                    {
                        for (int i = 0; i < tps.Length; ++i)
                        {
                            canvas.DrawPoint(tps[i], ptPaint);
                        }
                    }
                }
            }
        }
コード例 #13
0
ファイル: LineChart.cs プロジェクト: fumitaka/Microcharts
 private void DrawPoints(SKCanvas canvas)
 {
     if (PointMode != PointMode.None)
     {
         foreach (var pps in pointsPerSerie)
         {
             var entries = pps.Key.Entries.ToArray();
             for (int i = 0; i < pps.Value.Count; i++)
             {
                 var entry = entries[i];
                 var point = pps.Value.ElementAt(i);
                 canvas.DrawPoint(point, pps.Key.Color ?? entry.Color, PointSize, PointMode);
             }
         }
     }
 }
コード例 #14
0
        /// <summary>
        /// Onload loads map of roskilde and
        /// draws path that was calculated by Wificonnection
        /// </summary>
        private void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
        {
            SKImageInfo info    = args.Info;
            SKSurface   surface = args.Surface;
            SKCanvas    canvas  = surface.Canvas;

            canvas.Clear();
            topOffset = info.Height / 5;

            canvas.DrawBitmap(resourceBitmap, new SKRect(0, info.Height / 5f, info.Width, 2 * info.Height / 2.5f));

            for (int i = 0; i < WifiConnection.xValues.Length; i++)
            {
                canvas.DrawPoint(WifiConnection.xValues[i] + 3, WifiConnection.yValues[i] + topOffset + 20, SKColor.Parse("#ff0000"));
            }
        }
コード例 #15
0
        /// <summary>
        /// Draws path on canvas when event is triggers
        /// not currently in use
        /// </summary>
        private void DrawingOnCanvas(object senderr, EventArgs ee)
        {
            CanvasView.InvalidateSurface();
            CanvasView.PaintSurface += (sender, e) => {
                SKSurface surface       = e.Surface;
                int       surfaceWidth  = e.Info.Width;
                int       surfaceHeight = e.Info.Height;

                SKCanvas canvas = surface.Canvas;

                for (int i = 0; i < WifiConnection.xValues.Length; i++)
                {
                    canvas.DrawPoint(WifiConnection.xValues[i] + 3, WifiConnection.yValues[i] + topOffset + 20, SKColor.Parse("#ff0000"));
                }
                canvas.Flush();
            };
        }
コード例 #16
0
ファイル: PointChart.cs プロジェクト: CarbonSft/Microcharts
 protected void DrawPoints(IEnumerable <Entry> serie, SKCanvas canvas, SKPoint[] points, SKPoint selectedPoint)
 {
     if (points.Length > 0 && PointMode != PointMode.None)
     {
         var entries = serie as Entry[] ?? serie.ToArray();
         for (int i = 0; i < points.Length; i++)
         {
             var entry = entries.ElementAt(i);
             var point = points[i];
             var size  = PointSize;
             if (point == selectedPoint)
             {
                 size = SelectedPointSize;
             }
             canvas.DrawPoint(point, entry.Color, size, PointMode);
         }
     }
 }
コード例 #17
0
        private static SKBitmap DrawArrayImage(BlockColors basis, PT[][] ArraySrc)
        {
            SKBitmap drawimage = new SKBitmap(blockinfo, SKBitmapAllocFlags.ZeroPixels);
            SKCanvas skc       = new SKCanvas(drawimage);

            for (int y = 0; y < 8; y++)
            {
                for (int x = 0; x < 8; x++)
                {
                    var     PixelType   = ArraySrc[y][x];
                    BCColor ChosenColor = SelectColor(PixelType, basis);
                    SKColor useChosen   = ChosenColor;
                    skc.DrawPoint(new SKPoint(x, y), ChosenColor);
                    //drawimage.SetPixel(x, y, ChosenColor);
                }
            }
            skc.Flush();
            return(drawimage);
        }
コード例 #18
0
ファイル: MarkRenderer.cs プロジェクト: xeterixon/Sketching
        public void Render(SKCanvas canvas, IGeometryVisual gemoetry, double scale)
        {
            var mark = gemoetry as IMark;

            if (mark == null || !mark.IsValid)
            {
                return;
            }
            using (var paint = new SKPaint())
            {
                paint.Color       = mark.ToolSettings.SelectedColor.ToSkiaColor();
                paint.IsAntialias = true;
                paint.IsStroke    = false;
                paint.StrokeWidth = (float)(mark.Size * scale);
                paint.StrokeCap   = SKStrokeCap.Round;
                canvas.DrawPoint((float)(mark.Point.X * scale), (float)(mark.Point.Y * scale), paint);
                //TODO: Maybe fix real fill
            }
        }
コード例 #19
0
        /// <summary>
        /// Рисует ФЧХ для параметра.
        /// </summary>
        /// <param name="plot"></param>
        /// <param name="parameters"></param>
        /// <param name="canvas"></param>
        private void PaintSParameter(ParameterType type, SKPaint paint, Plot plot, Parameters parameters, SKCanvas canvas)
        {
            // цикл для расчета коэффициента масштабирования координат X
            RestrictiveFrame frame         = plot.Frame;
            float            scalingFactor = base.GetXScalingFactor(parameters, frame);

            double i = plot.Frame.GetFirstPointX();
            float  j = (float)parameters.Fmin;

            while (j * scalingFactor <= parameters.Fmax * scalingFactor)
            {
                float x = j;
                float y = plot.GetCenterPointOfYAxis();

                // Встречаем отрицательную бесконечность на 1 шаге.
                if (parameters.GetMagnitude(ParameterType.S12, x) == Double.NegativeInfinity)
                {
                    i += 0.04f;
                    j += 0.04f;
                    continue;
                }

                // Инвертирование значений.
                float currentPhase = (float)parameters.GetPhase(type, x);
                y += -(currentPhase);

                if (plot.FirstPointY + y >= plot.SecondPointY)
                {
                    i += 0.04f;
                    j += 0.04f;
                    continue;
                }
                canvas.DrawPoint(plot.FirstPointX + x * scalingFactor, y, paint);

                i += 0.04f;
                j += 0.04f;
            }
        }
コード例 #20
0
        private static SKImage DrawPath(IEnumerable <int[][]> points, float strokeWidth)
        {
            var info = new SKImageInfo(255, 255);

            using (var surface = SKSurface.Create(info))
            {
                SKCanvas canvas = surface.Canvas;

                canvas.Clear(SKColors.Transparent);

                var paint = new SKPaint
                {
                    StrokeWidth = strokeWidth,
                    Style       = SKPaintStyle.Stroke,
                    Color       = new SKColor(0x00, 0x00, 0x00),
                    StrokeCap   = SKStrokeCap.Round,
                };
                foreach (var pathData in points)
                {
                    if (pathData[0].Length == 1)
                    {
                        canvas.DrawPoint(new SKPoint(pathData[0][0], pathData[1][0]), paint);
                    }
                    else if (pathData[0].Length > 1)
                    {
                        var path = new SKPath();
                        path.MoveTo(new SKPoint(pathData[0][0], pathData[1][0]));
                        for (int i = 1; i < pathData[0].Length; i++)
                        {
                            path.LineTo(new SKPoint(pathData[0][i], pathData[1][i]));
                        }
                        canvas.DrawPath(path, paint);
                    }
                }
                return(surface.Snapshot());
            }
        }
コード例 #21
0
        public override void DrawContent(SKCanvas canvas, int width, int height)
        {
            var total = Series.Count();

            if (total > 0)
            {
                var captionHeight = Series.First().Max(x =>
                {
                    var result = 0.0f;

                    var hasLabel      = !string.IsNullOrEmpty(x.Label);
                    var hasValueLabel = !string.IsNullOrEmpty(x.ValueLabel);
                    if (hasLabel || hasValueLabel)
                    {
                        var hasOffset     = hasLabel && hasValueLabel;
                        var captionMargin = LabelTextSize * 0.60f;
                        var space         = hasOffset ? captionMargin : 0;

                        if (hasLabel)
                        {
                            result += LabelTextSize;
                        }

                        if (hasValueLabel)
                        {
                            result += LabelTextSize;
                        }
                    }

                    return(result);
                });

                var center     = new SKPoint(width / 2, height / 2);
                var radius     = ((Math.Min(width, height) - (2 * Margin)) / 2) - captionHeight;
                var rangeAngle = (float)((Math.PI * 2) / total);
                var startAngle = (float)Math.PI;

                var nextEntry = Series.First().First();
                var nextAngle = startAngle;
                var nextPoint = GetPoint(nextEntry.Value, center, nextAngle, radius);

                DrawBorder(canvas, center, radius);

                for (int i = 0; i < total; i++)
                {
                    var angle = nextAngle;
                    var entry = nextEntry;
                    var point = nextPoint;

                    var nextIndex = (i + 1) % total;
                    nextAngle = startAngle + (rangeAngle * nextIndex);
                    nextEntry = Series.First().ElementAt(nextIndex);
                    nextPoint = GetPoint(nextEntry.Value, center, nextAngle, radius);

                    // Border center bars
                    using (var paint = new SKPaint()
                    {
                        Style = SKPaintStyle.Stroke,
                        StrokeWidth = BorderLineSize,
                        Color = BorderLineColor,
                        IsAntialias = true,
                    })
                    {
                        var borderPoint = GetPoint(MaxValue, center, angle, radius);
                        canvas.DrawLine(point.X, point.Y, borderPoint.X, borderPoint.Y, paint);
                    }

                    // Values points and lines
                    using (var paint = new SKPaint()
                    {
                        Style = SKPaintStyle.Stroke,
                        StrokeWidth = BorderLineSize,
                        Color = entry.Color.WithAlpha((byte)(entry.Color.Alpha * 0.75f)),
                        PathEffect = SKPathEffect.CreateDash(new[] { BorderLineSize, BorderLineSize * 2 }, 0),
                        IsAntialias = true,
                    })
                    {
                        var amount = Math.Abs(entry.Value - AbsoluteMinimum) / ValueRange;
                        canvas.DrawCircle(center.X, center.Y, radius * amount, paint);
                    }

                    canvas.DrawGradientLine(center, entry.Color.WithAlpha(0), point,
                                            entry.Color.WithAlpha((byte)(entry.Color.Alpha * 0.75f)), LineSize);
                    canvas.DrawGradientLine(point, entry.Color, nextPoint, nextEntry.Color, LineSize);
                    canvas.DrawPoint(point, entry.Color, PointSize, PointMode);

                    // Labels
                    var labelPoint = GetPoint(MaxValue, center, angle, radius + LabelTextSize + (PointSize / 2));
                    var alignment  = SKTextAlign.Left;

                    if ((Math.Abs(angle - (startAngle + Math.PI)) < Epsilon) || (Math.Abs(angle - Math.PI) < Epsilon))
                    {
                        alignment = SKTextAlign.Center;
                    }
                    else if (angle > (float)(startAngle + Math.PI))
                    {
                        alignment = SKTextAlign.Right;
                    }

                    canvas.DrawCaptionLabels(entry.Label, entry.TextColor, entry.ValueLabel, entry.Color, LabelTextSize,
                                             labelPoint, alignment);
                }
            }
        }
コード例 #22
0
        /// <summary>Draw a progress meter</summary>
        /// <remarks>
        /// Value 1 is the part and Value 2 is the total possible
        /// Value 1 can exceed value 2 for mutiple revolutions
        /// </remarks>
        private void PaintProgress(SKImageInfo info, SKCanvas canvas)
        {
            // set up the gradient colors
            SKColor[] colors = new SKColor[2] {
                this.ArcColor1.ToSKColor(), this.ArcColor2.ToSKColor()
            };

            // sweep is in DEG -> normalize the sweep angle between 0 and 360
            //float sweep = QuickCalc.Revolution( ( this.Value1 / this.Value2 ) * 360.0F );
            //sweep = ( sweep > 360.0 ) ? 360.0F : sweep;
            float sweep = (this.Value1 % this.Value2 / this.Value2) * 360.0F;

            // we have to roate the drawing canvas 90 degrees CCW
            canvas.RotateDegrees(-90, info.Width / 2, info.Height / 2);

            // no value
            if (this.Value1 <= 0.0)
            {
                // draw background ring
                using (SKPath path = new SKPath())
                {
                    using (SKPaint bkgPaint = new SKPaint()
                    {
                        Color = _disabled, StrokeWidth = this.ArcLineWidth, Style = SKPaintStyle.Stroke, IsAntialias = true
                    })
                    {
                        path.AddArc(this.OuterRect, 0, 360.0F);
                        canvas.DrawPath(path, bkgPaint);
                    }
                }
            }
            // less than 1 revolution
            else if (this.Value1 < this.Value2)
            {
                // draw background ring
                using (SKPath path = new SKPath())
                {
                    using (SKPaint bkgPaint = new SKPaint()
                    {
                        Color = _disabled, StrokeWidth = this.ArcLineWidth, Style = SKPaintStyle.Stroke, IsAntialias = true
                    })
                    {
                        path.AddArc(this.OuterRect, 0, 360.0F);
                        canvas.DrawPath(path, bkgPaint);
                    }
                }

                // draw the partial arc
                using (SKPath path = new SKPath())
                {
                    using (SKPaint arcPaint = new SKPaint {
                        Style = SKPaintStyle.Stroke, Color = this.ArcColor1.ToSKColor()
                    })
                    {
                        arcPaint.StrokeWidth = this.ArcLineWidth;
                        arcPaint.StrokeCap   = SKStrokeCap.Butt;
                        arcPaint.IsAntialias = true;
                        arcPaint.Shader      = SKShader.CreateSweepGradient(this.Origin, colors, new Single[] { 0, 1 }, SKShaderTileMode.Clamp, 0, sweep);

                        // create an arc to sweep along
                        path.AddArc(this.OuterRect, 0, sweep);
                        canvas.DrawPath(path, arcPaint);
                    }
                }
            }
            else             // 1 or more revolution
            {
                // draw background ring
                using (SKPath path = new SKPath())
                {
                    using (SKPaint bkgPaint = new SKPaint()
                    {
                        Color = this.ArcColor1.ToSKColor(), StrokeWidth = this.ArcLineWidth
                    })
                    {
                        bkgPaint.Style       = SKPaintStyle.Stroke;
                        bkgPaint.IsAntialias = true;

                        path.AddArc(this.OuterRect, 0, 360.0F);
                        canvas.DrawPath(path, bkgPaint);
                    }
                }

                // rotate the canvas by the sweep angle so we always start at 0
                canvas.RotateDegrees(sweep - 180, info.Width / 2, info.Height / 2);

                // draw the partial gradiant arc
                using (SKPath path = new SKPath())
                {
                    using (SKPaint arcPaint = new SKPaint {
                        Style = SKPaintStyle.Stroke
                    })
                    {
                        arcPaint.Color       = this.ArcColor2.ToSKColor();
                        arcPaint.StrokeWidth = this.ArcLineWidth;
                        arcPaint.StrokeCap   = SKStrokeCap.Butt;
                        arcPaint.IsAntialias = true;

                        // sweep gradient uses start angle to end angle
                        arcPaint.Shader = SKShader.CreateSweepGradient(this.Origin, colors, new Single[] { 0, 1 }, SKShaderTileMode.Clamp, 0, 180);

                        // create an arc to sweep along - uses start angle and then how many degrees to rotate from start
                        path.AddArc(this.OuterRect, 0, 180);
                        canvas.DrawPath(path, arcPaint);
                    }
                }

                canvas.RotateDegrees(-(sweep - 180), info.Width / 2, info.Height / 2);
            }

            // calc pts for the trailing handle
            Tuple <float, float> pt1 = QuickCalc.Transform(QuickCalc.Deg2Rad(sweep + (this.ArcLineWidth * 0.075F)), this.OuterRect.Width / 2.0F);
            Tuple <float, float> pt2 = QuickCalc.Transform(QuickCalc.Deg2Rad(sweep), this.OuterRect.Width / 2.0F);

            // draw the trailing point with shadow
            using (SKPaint handlePaint = new SKPaint()
            {
                Color = this.BackgroundColor.ToSKColor()
            })
            {
                handlePaint.StrokeCap   = SKStrokeCap.Round;
                handlePaint.StrokeWidth = this.ArcLineWidth * 2;
                handlePaint.IsAntialias = true;

                // shadow
                canvas.DrawPoint(pt1.Item1 + info.Rect.MidX, info.Rect.MidY + pt1.Item2, handlePaint);

                // change color
                handlePaint.Color = this.ArcColor2.ToSKColor();

                // handle
                canvas.DrawPoint(pt2.Item1 + info.Rect.MidX, info.Rect.MidY + pt2.Item2, handlePaint);
            }

            // rotate it all back
            canvas.RotateDegrees(90, info.Width / 2, info.Height / 2);
        }
コード例 #23
0
        /// <summary></summary>
        /// <param name="info"></param>
        /// <param name="canvas"></param>
        private void DrawGraph(SKImageInfo info, SKCanvas canvas)
        {
            // max height of any bar
            float height = this.BarFrame.Bottom - this.BarFrame.Top;

            // find the max value
            float maxValue = this.Frames.Max(e => e.Entry.Value);
            float maxThreshold = this.Frames.Max(e => e.Entry.Threshold);
            float max = new float[] { maxValue, maxThreshold }.Max();

            // draw the horizontal scale
            if (this.HorizontalScale)
            {
                // draw horizontal line every
                float yline = this.BarFrame.Bottom;
                float n     = 10F;

                using (SKPaint pen = new SKPaint()
                {
                    Color = this.AxisColor.ToSKColor(), StrokeWidth = 1.0F, Style = SKPaintStyle.Stroke
                })
                {
                    while (yline > 0)
                    {
                        canvas.DrawLine(this.BarFrame.Left, yline, this.BarFrame.Right, yline, pen);
                        yline -= height / n;
                    }
                }
            }

            // draw each bar
            foreach (ColumnEntry entry in this.Frames)
            {
                // the bar drawing frame
                SKRect rect = entry.Frame;

                // calc margin from thickness - use denominator from [3,15]
                float denom  = 3.0F + ((15.0F - 3.0F) * (this.BarThickness / 100.0F));
                float margin = rect.Width / denom;

                // calculate threshold & value percentage of height
                float pt = (entry.Entry.Threshold / max) * height;
                float pv = (entry.Entry.Value / max) * height;

                // calculate threshold rect and value rect
                SKRect bart = new SKRect(rect.Left + margin, rect.Bottom - pt, rect.Right - margin, rect.Bottom);
                SKRect barv = new SKRect(rect.Left + margin, rect.Bottom - pv, rect.Right - margin, rect.Bottom);

                // draw threshold bar
                //canvas.DrawRect(bart, new SKPaint() { Color = entry.Entry.BackgroundColor, StrokeWidth = 0, Style = SKPaintStyle.StrokeAndFill });

                // epmty entries are ignored
                if (entry.Entry == null)
                {
                    continue;
                }

                // no data
                if (entry.Entry.IsEmpty)
                {
                    float rad = 10.0F;
                    using (SKPaint ptPaint = new SKPaint()
                    {
                        Color = this.AxisColor.ToSKColor(), StrokeWidth = rad, StrokeCap = SKStrokeCap.Round
                    })
                    {
                        canvas.DrawPoint(rect.MidX, rect.Bottom - rad, ptPaint);
                    }
                }
                // reached goal then paint threshold on top of value
                else if (entry.Entry.Value >= entry.Entry.Threshold)
                {
                    using (SKPaint barPaint = new SKPaint()
                    {
                        Color = entry.Entry.ValueColor, StrokeWidth = 0, Style = SKPaintStyle.StrokeAndFill
                    })
                    {
                        canvas.DrawRect(barv, barPaint);

                        barPaint.Color = entry.Entry.ThresholdColor;
                        canvas.DrawRect(bart, barPaint);
                    }

                    //// draw threshold line
                    //if (entry.Entry.Value > entry.Entry.Threshold)
                    //    canvas.DrawLine(bart.Left, bart.Top, bart.Right, bart.Top,
                    //    new SKPaint() { Color = entry.Entry.BackgroundColor, StrokeWidth = 3.0F, Style = SKPaintStyle.Stroke,
                    //        PathEffect = SKPathEffect.CreateDash(new float[] { 10, 10 }, 20)
                    //    });
                }
                else
                {
                    using (SKPaint barPaint = new SKPaint()
                    {
                        Color = entry.Entry.ThresholdColor, StrokeWidth = 0, Style = SKPaintStyle.StrokeAndFill
                    })
                    {
                        canvas.DrawRect(bart, barPaint);

                        barPaint.Color = entry.Entry.ValueColor;
                        canvas.DrawRect(barv, barPaint);
                    }
                }
            }
        }
コード例 #24
0
        public override void DrawContent(SKCanvas canvas, int width, int height)
        {
            var total = this.Entries?.Count() ?? 0;

            if (total > 0)
            {
                var captionHeight = this.Entries.Max(x =>
                {
                    var result = 0.0f;

                    var hasLabel      = !string.IsNullOrEmpty(x.Label);
                    var hasValueLabel = !string.IsNullOrEmpty(x.ValueLabel);
                    if (hasLabel || hasValueLabel)
                    {
                        var hasOffset     = hasLabel && hasValueLabel;
                        var captionMargin = this.LabelTextSize * 0.60f;
                        var space         = hasOffset ? captionMargin : 0;

                        if (hasLabel)
                        {
                            result += this.LabelTextSize;
                        }

                        if (hasValueLabel)
                        {
                            result += this.LabelTextSize;
                        }
                    }

                    return(result);
                });

                var center     = new SKPoint(width / 2, height / 2);
                var radius     = ((Math.Min(width, height) - (2 * Margin)) / 2) - captionHeight;
                var rangeAngle = (float)((Math.PI * 2) / total);
                var startAngle = (float)Math.PI;

                var nextEntry = this.Entries.First();
                var nextAngle = startAngle;
                var nextPoint = this.GetPoint(nextEntry.Value * this.AnimationProgress, center, nextAngle, radius);

                this.DrawBorder(canvas, center, radius);

                using (var clip = new SKPath())
                {
                    clip.AddCircle(center.X, center.Y, radius);

                    for (int i = 0; i < total; i++)
                    {
                        var angle = nextAngle;
                        var entry = nextEntry;
                        var point = nextPoint;

                        var nextIndex = (i + 1) % total;
                        nextAngle = startAngle + (rangeAngle * nextIndex);
                        nextEntry = this.Entries.ElementAt(nextIndex);
                        nextPoint = this.GetPoint(nextEntry.Value * this.AnimationProgress, center, nextAngle, radius);

                        canvas.Save();
                        canvas.ClipPath(clip);

                        // Border center bars
                        using (var paint = new SKPaint()
                        {
                            Style = SKPaintStyle.Stroke,
                            StrokeWidth = this.BorderLineSize,
                            Color = this.BorderLineColor,
                            IsAntialias = true,
                        })
                        {
                            var borderPoint = this.GetPoint(this.MaxValue, center, angle, radius);
                            canvas.DrawLine(point.X, point.Y, borderPoint.X, borderPoint.Y, paint);
                        }

                        // Values points and lines
                        using (var paint = new SKPaint()
                        {
                            Style = SKPaintStyle.Stroke,
                            StrokeWidth = this.BorderLineSize,
                            Color = entry.Color.WithAlpha((byte)(entry.Color.Alpha * 0.75f * this.AnimationProgress)),
                            PathEffect = SKPathEffect.CreateDash(new[] { this.BorderLineSize, this.BorderLineSize * 2 }, 0),
                            IsAntialias = true,
                        })
                        {
                            var amount = Math.Abs(entry.Value - this.AbsoluteMinimum) / this.ValueRange;
                            canvas.DrawCircle(center.X, center.Y, radius * amount, paint);
                        }

                        canvas.DrawGradientLine(center, entry.Color.WithAlpha(0), point, entry.Color.WithAlpha((byte)(entry.Color.Alpha * 0.75f)), this.LineSize);
                        canvas.DrawGradientLine(point, entry.Color, nextPoint, nextEntry.Color, this.LineSize);
                        canvas.DrawPoint(point, entry.Color, this.PointSize, this.PointMode);

                        canvas.Restore();

                        // Labels
                        var labelPoint = new SKPoint(0, radius + this.LabelTextSize + (this.PointSize / 2));
                        var rotation   = SKMatrix.MakeRotation(angle);
                        labelPoint = center + rotation.MapPoint(labelPoint);
                        var alignment = SKTextAlign.Left;

                        if ((Math.Abs(angle - (startAngle + Math.PI)) < Epsilon) || (Math.Abs(angle - Math.PI) < Epsilon))
                        {
                            alignment = SKTextAlign.Center;
                        }
                        else if (angle > (float)(startAngle + Math.PI))
                        {
                            alignment = SKTextAlign.Right;
                        }

                        canvas.DrawCaptionLabels(entry.Label, entry.TextColor, entry.ValueLabel, entry.Color.WithAlpha((byte)(255 * this.AnimationProgress)), this.LabelTextSize, labelPoint, alignment, base.Typeface, out var _);
                    }
                }
            }
        }
コード例 #25
0
        /// <summary>Draw a pie meter</summary>
        private void PaintPie(SKImageInfo info, SKCanvas canvas, bool handles = false)
        {
            float arcWidth = (info.Width / 15.0F) * 1.0F;

            // always draw a background ring
            using (SKPath path = new SKPath())
            {
                path.AddArc(this.OuterRect, 0, 360);
                canvas.DrawPath(path, new SKPaint()
                {
                    Color = _disabled, StrokeWidth = this.ArcLineWidth, Style = SKPaintStyle.Stroke, IsAntialias = true
                });
            }

            // calc the sum
            float total = this.Value1 + this.Value2;

            // bail if both are 0
            if (total <= 0.0)
            {
                return;
            }

            // calc the sweep angle
            float sweep = (this.Value1 / total) * 360.0F;

            // calc the angles, 0 is to the right, start from overhead
            float rewardSweep     = (sweep > 360.0) ? 360.0F : sweep;
            float bonusStartAngle = QuickCalc.Revolution(270.0F + rewardSweep);

            // draw arc 1
            using (SKPath path = new SKPath())
            {
                using (SKPaint arcPaint = new SKPaint {
                    Style = SKPaintStyle.Stroke, Color = this.ArcColor1.ToSKColor(), StrokeWidth = this.ArcLineWidth, IsAntialias = true
                })
                {
                    path.AddArc(this.OuterRect, 270, rewardSweep);
                    canvas.DrawPath(path, arcPaint);
                }
            }

            // draw arc 2
            using (SKPath path = new SKPath())
            {
                using (SKPaint arcPaint = new SKPaint {
                    Style = SKPaintStyle.Stroke, Color = this.ArcColor2.ToSKColor(), StrokeWidth = this.ArcLineWidth, IsAntialias = true
                })
                {
                    path.AddArc(this.OuterRect, bonusStartAngle, 360 - rewardSweep);
                    canvas.DrawPath(path, arcPaint);
                }
            }

            if (!handles)
            {
                return;
            }

            // draw handles
            using (SKPaint handlePaint = new SKPaint()
            {
                Color = this.ArcColor1.ToSKColor(), StrokeCap = SKStrokeCap.Round, StrokeWidth = this.ArcLineWidth * 2, IsAntialias = true
            })
            {
                canvas.DrawPoint(this.VerticalCenter, this.OuterRect.Top, handlePaint);

                // where's the other handle?
                float rad = QuickCalc.Deg2Rad(QuickCalc.Revolution(360 - rewardSweep + 90));
                Tuple <float, float> pt = QuickCalc.Transform(rad, this.OuterRect.Width / 2.0F);

                handlePaint.Color = this.ArcColor2.ToSKColor();
                canvas.DrawPoint(pt.Item1 + info.Rect.MidX, info.Rect.MidY - pt.Item2, handlePaint);
            }
        }
コード例 #26
0
ファイル: YPoint.cs プロジェクト: Yzil-C/ProjCsTemp
 public override void Draw(SKCanvas canvas)
 {
     canvas.DrawPoint(DrawingPoint, Paint);
 }
コード例 #27
0
        private void Canvas_PaintSurface(object sender, SkiaSharp.Views.Forms.SKPaintSurfaceEventArgs e)
        {
            if (BindingContext is MarsRoverModel model)
            {
                if (model.CurrentPlateau != null &&
                    model.CurrentRover != null)
                {
                    SKImageInfo info    = e.Info;
                    SKSurface   surface = e.Surface;
                    SKCanvas    canvas  = surface.Canvas;

                    canvas.Clear();

                    SKPaint gridLinePaint = new SKPaint
                    {
                        Style       = SKPaintStyle.Stroke,
                        Color       = SKColors.LightGray,
                        StrokeWidth = 2
                    };

                    SKPaint startPointPaint = new SKPaint
                    {
                        Style       = SKPaintStyle.Stroke,
                        Color       = SKColors.Green,
                        StrokeWidth = 8
                    };

                    SKPaint endPointPaint = new SKPaint
                    {
                        Style       = SKPaintStyle.Stroke,
                        Color       = SKColors.Red,
                        StrokeWidth = 8
                    };

                    SKPaint pathLinePaint = new SKPaint
                    {
                        Style       = SKPaintStyle.Stroke,
                        Color       = SKColors.Black,
                        StrokeWidth = 2
                    };

                    float xBreak = (float)info.Width / model.CurrentPlateau.UpperX;
                    for (int i = 0; i <= model.CurrentPlateau.UpperX; i++)
                    {
                        canvas.DrawLine(xBreak * i, 0, xBreak * i, info.Width, gridLinePaint);
                    }

                    float yBreak = (float)info.Height / model.CurrentPlateau.UpperY;
                    for (int i = 0; i <= model.CurrentPlateau.UpperY; i++)
                    {
                        canvas.DrawLine(0, yBreak * i, info.Height, yBreak * i, gridLinePaint);
                    }

                    if (model.Path != null)
                    {
                        Tuple <float, float> lastPos = null;
                        foreach (var pos in model.Path)
                        {
                            float posX = pos.Item1 * xBreak;
                            float posY = pos.Item2 * yBreak;
                            if (lastPos == null)
                            {
                                canvas.DrawPoint(posX, posY, startPointPaint);
                            }
                            else
                            {
                                canvas.DrawLine(lastPos.Item1, lastPos.Item2, posX, posY, pathLinePaint);
                            }
                            lastPos = new Tuple <float, float>(posX, posY);
                        }
                        canvas.DrawPoint(lastPos.Item1, lastPos.Item2, endPointPaint);

                        using (var snapshot = surface.Snapshot())
                            using (var data = snapshot.Encode(SKEncodedImageFormat.Png, 80))
                                using (var ms = new MemoryStream())
                                {
                                    data.SaveTo(ms);
                                    byte[] imageBytes = ms.ToArray();

                                    string base64String = Convert.ToBase64String(imageBytes);
                                    model.SendImage(base64String);
                                }
                    }
                }
            }
        }
コード例 #28
0
        void OnCanvasViewPaintSurface(object sender, SKPaintSurfaceEventArgs args)
        {
            SKImageInfo info    = args.Info;
            SKSurface   surface = args.Surface;
            SKCanvas    canvas  = surface.Canvas;

            canvas.Clear();

            // Make image into bitmap
            SKBitmap bitmap = SKBitmap.Decode(ViewModel.Image.GetStreamWithImageRotatedForExternalStorage());

            // Find rectangle to fit bitmap
            float scale = Math.Min((float)info.Width / bitmap.Width,
                                   (float)info.Height / bitmap.Height);
            SKRect rect = SKRect.Create(scale * bitmap.Width,
                                        scale * bitmap.Height);
            float x = (info.Width - rect.Width) / 2;
            float y = (info.Height - rect.Height) / 2;

            rect.Offset(x, y);

            // Draw the image
            canvas.DrawBitmap(bitmap, rect);

            // Prep rectangle paint
            var rectPaint = new SKPaint
            {
                Color       = new SKColor(255, 0, 0),
                IsStroke    = true,
                StrokeWidth = 2
            };

            // Prep text paint
            var textPaint = new SKPaint
            {
                Color    = new SKColor(255, 0, 0),
                TextSize = 48
            };

            // Draw the face boxes
            ViewModel.Faces.ToList().ForEach(face =>
            {
                var faceRect = SKRect.Create(scale * face.FaceRectangle.Left + x,
                                             scale * face.FaceRectangle.Top + y,
                                             scale * face.FaceRectangle.Width,
                                             scale * face.FaceRectangle.Height);

                canvas.DrawRect(faceRect, rectPaint);

                canvas.DrawText(ViewModel.Faces.IndexOf(face).ToString(),
                                (scale * face.FaceRectangle.Left + x) + (scale * face.FaceRectangle.Width / 2),
                                (scale * face.FaceRectangle.Top + y),
                                textPaint);

                // If landmarks are present, draw them too!
                if (face.FaceLandmarks != null)
                {
                    var landmarkPaint = new SKPaint
                    {
                        Color       = new SKColor(255, 0, 0),
                        StrokeWidth = 6
                    };

                    face.FaceLandmarks.GetType().GetProperties().ToList().ForEach(landmark =>
                    {
                        if (landmark.PropertyType == typeof(Coordinate))
                        {
                            var coord = (Coordinate)landmark.GetValue(face.FaceLandmarks);

                            canvas.DrawPoint((float)(scale * coord.X + x), (float)(scale * coord.Y + y), landmarkPaint);
                        }
                    });
                }
            });
        }
コード例 #29
0
        protected void DrawPoints(SKCanvas canvas, SKPoint[] points, float origin = 0)
        {
            if (points.Length > 0 && PointMode != PointMode.None)
            {
                for (int i = 0; i < points.Length; i++)
                {
                    var entry = this.Entries.ElementAt(i);
                    var point = points[i];

                    var size = entry.Selected ? 20 : this.PointSize;

                    if (entry.Selected)
                    {
                        // Line from Point to bottom
                        canvas.DrawLine(point.X, point.Y, point.X, origin, new SKPaint()
                        {
                            Color = new SKColor(255, 255, 255)
                        });

                        // Draw Annotation
                        var path = new SKPath();

                        if (i == 0)                         // Inverse
                        {
                            canvas.DrawRoundRect(new SKRect(point.X + 90, point.Y - 70, point.X, point.Y - 20), 5, 5, new SKPaint()
                            {
                                Color = new SKColor(255, 255, 255)
                            });
                            path.MoveTo(point.X, point.Y - 15);
                            path.RLineTo(0, -10);
                            path.RLineTo(20, 0);
                            path.LineTo(point.X, point.Y - 15);
                            canvas.DrawText(entry.AnnotationLabel ?? "$790", point.X + 45, point.Y - 30, new SKPaint()
                            {
                                IsAntialias = true, Color = new SKColor(0, 0, 0), TextAlign = SKTextAlign.Center, TextSize = 20
                            });
                            canvas.DrawText(entry.AnnotationHeadingLabel ?? "3/14 - 7/14", point.X + 45, point.Y - 55, new SKPaint()
                            {
                                IsAntialias = true, Color = new SKColor(61, 61, 61), TextAlign = SKTextAlign.Center, TextSize = 11
                            });
                            // TODO: SkTypeface.FromFile("path/to/typeface.ttf");
                        }
                        else
                        {
                            canvas.DrawRoundRect(new SKRect(point.X - 90, point.Y - 70, point.X, point.Y - 20), 5, 5, new SKPaint()
                            {
                                Color = new SKColor(255, 255, 255)
                            });
                            path.MoveTo(point.X, point.Y - 15);
                            path.RLineTo(0, -10);
                            path.RLineTo(-20, 0);
                            path.LineTo(point.X, point.Y - 15);
                            canvas.DrawText(entry.AnnotationLabel ?? "$790", point.X - 45, point.Y - 30, new SKPaint()
                            {
                                IsAntialias = true, Color = new SKColor(0, 0, 0), TextAlign = SKTextAlign.Center, TextSize = 20
                            });
                            canvas.DrawText(entry.AnnotationHeadingLabel ?? "3/14 - 7/14", point.X - 45, point.Y - 55, new SKPaint()
                            {
                                IsAntialias = true, Color = new SKColor(61, 61, 61), TextAlign = SKTextAlign.Center, TextSize = 11
                            });
                            // TODO: SkTypeface.FromFile("path/to/typeface.ttf");
                        }

                        canvas.DrawPath(path, new SKPaint()
                        {
                            IsAntialias = true, Color = new SKColor(255, 255, 255), StrokeWidth = 1, Style = SKPaintStyle.StrokeAndFill
                        });

                        canvas.DrawPoint(point, entry.Color, size, this.PointMode);
                        canvas.DrawPoint(point, new SKColor(0, 0, 0), size - 12, this.PointMode);
                    }
                    else
                    {
                        // Line from Point to bottom
                        canvas.DrawLine(point.X, point.Y, point.X, origin, new SKPaint()
                        {
                            Color = new SKColor(255, 255, 255, 127), PathEffect = SKPathEffect.CreateDash(new float[] { 10, 2 }, 20)
                        });
                        canvas.DrawPoint(point, entry.Color, size, this.PointMode);
                    }

                    AddTouchHandler(new Rectangle(new Point(point.X - 20, point.Y - 20), new Size(40, 40)), () =>
                    {
                        foreach (var item in Entries)
                        {
                            if (item == entry)
                            {
                                entry.Selected = !entry.Selected;
                            }
                            else
                            {
                                item.Selected = false;
                            }
                        }
                    });
                }
            }
        }
コード例 #30
0
        protected override void OnPaintSurface(SKPaintSurfaceEventArgs e)
        {
            base.OnPaintSurface(e);
            SKImageInfo info    = e.Info;
            SKSurface   surface = e.Surface;
            SKCanvas    canvas  = surface.Canvas;

            canvas.Clear();

            using (var primaryPaint = new SKPaint
            {
                IsAntialias = true,
                Style = SKPaintStyle.Stroke,
                StrokeCap = SKStrokeCap.Butt,
                StrokeWidth = (float)Thickness,
            })
                using (var path = new SKPath())
                    using (var backgroundPath = new SKPath())
                    {
                        var margin = (float)Thickness / 2.0f;

                        if (RadialBackgroundColor != Color.Default && RadialBackgroundColor != Color.Transparent)
                        {
                            primaryPaint.Color = RadialBackgroundColor.ToSKColor();
                            backgroundPath.AddArc(new SKRect(margin, margin, info.Width - margin, info.Height - margin), -90 + (float)StartAngle, (float)SweepAngle);
                            canvas.DrawPath(backgroundPath, primaryPaint);
                            if (backgroundPath.PointCount > 0)
                            {
                                if (StartStrokeCap == RadialProgressStrokeCap.Round)
                                {
                                    primaryPaint.StrokeCap = SKStrokeCap.Round;
                                    canvas.DrawPoint(backgroundPath.Points[0], primaryPaint);
                                }
                                if (EndStrokeCap == RadialProgressStrokeCap.Round)
                                {
                                    primaryPaint.StrokeCap = SKStrokeCap.Round;
                                    canvas.DrawPoint(backgroundPath.Points[backgroundPath.PointCount - 1], primaryPaint);
                                }
                            }
                        }

                        SKColor[] colors = new SKColor[]
                        {
                            RadialStartColor.ToSKColor(),
                                  RadialStartColor.ToSKColor(),
                                  RadialMiddleColor.ToSKColor(),
                                  RadialMiddleColor.ToSKColor(),
                                  RadialEndColor.ToSKColor(),
                                  RadialEndColor.ToSKColor(),
                                  RadialStartColor.ToSKColor(),
                        };

                        float[] colorPos = new float[]
                        {
                            0,                 // start
                            (1 / 6.0f) * 1,    // start
                            (1 / 6.0f) * 2,    // mid
                            (1 / 6.0f) * 3,    // mid
                            (1 / 6.0f) * 4,    // end
                            (1 / 6.0f) * 5.7f, // end
                            0.95f              // start
                        };

                        primaryPaint.StrokeCap = SKStrokeCap.Butt;

                        primaryPaint.Shader = SKShader.CreateSweepGradient(new SKPoint(info.Rect.MidX, info.Rect.MidY), colors, colorPos, SKShaderTileMode.Repeat, -90 + (float)StartAngle, -90 + (float)StartAngle + (float)SweepAngle);

                        path.AddArc(new SKRect(margin, margin, info.Width - margin, info.Height - margin), -90 + (float)StartAngle, (float)SweepAngle * (float)Progress);
                        canvas.DrawPath(path, primaryPaint);

                        if (path.PointCount > 2)
                        {
                            if (StartStrokeCap == RadialProgressStrokeCap.Round)
                            {
                                primaryPaint.StrokeCap = SKStrokeCap.Round;
                                canvas.DrawPoint(path.Points[0], primaryPaint);
                            }

                            if (EndStrokeCap == RadialProgressStrokeCap.Round)
                            {
                                primaryPaint.StrokeCap = SKStrokeCap.Round;
                                canvas.DrawPoint(path.Points[path.PointCount - 1], primaryPaint);
                            }
                        }

                        if (HasLabel)
                        {
                            using (var fontPaint = new SKPaint
                            {
                                IsAntialias = true,
                                Color = TextColor.ToSKColor(),
                                TextSize = (float)FontSize,
                            })
                                using (var fontPath = new SKPath())
                                {
                                    fontPath.AddPathReverse(path);
                                    canvas.DrawTextOnPath(string.Format(TextFormat, Progress), fontPath, 0, (float)FontSize / 3.0f, fontPaint);
                                }
                        }
                    }
        }