Est-ce que SkiaSharp a une méthode Flatten équivalente à System.Drawing?

Question

J'ai récemment frappé un barrage routier en utilisant SkiaSharp. J'ai porté le code plus ancien de System.Drawing à SkiaSharp. La classe GraphicsPath possédait une méthode aplatie qui convertissait les courbes en une série de segments de ligne connectés.

https://msdn.microsoft.com/en-us/library/system.drawing.drawing2d.graphicspath.flatten(v=vs.110).aspx

Je ne peux pas sembler trouver une méthode équivalente pour SkiaSharp. La méthode SKPath Simplify semble un peu floue sur ce qu'elle fait réellement. Dans mes tests, il n'a pas semblé produire un chemin aplati.

https://developer.xamarin.com/api/member/SkiaSharp.SKPath.Simplify()/

Answer 1

À un certain moment après avoir posé cette question Xamarin documentation ajoutée pour le faire. Il se trouve ici

https://developer.xamarin.com/guides/xamarin-forms/advanced/skiasharp/curves/information/

static class PathExtensions 
{ 
public static SKPath CloneWithTransform(this SKPath pathIn, Func<SKPoint, SKPoint> transform) 
{ 
    SKPath pathOut = new SKPath(); 

    using (SKPath.RawIterator iterator = pathIn.CreateRawIterator()) 
    { 
     SKPoint[] points = new SKPoint[4]; 
     SKPathVerb pathVerb = SKPathVerb.Move; 
     SKPoint firstPoint = new SKPoint(); 
     SKPoint lastPoint = new SKPoint(); 

     while ((pathVerb = iterator.Next(points)) != SKPathVerb.Done) 
     { 
      switch (pathVerb) 
      { 
       case SKPathVerb.Move: 
        pathOut.MoveTo(transform(points[0])); 
        firstPoint = lastPoint = points[0]; 
        break; 

       case SKPathVerb.Line: 
        SKPoint[] linePoints = Interpolate(points[0], points[1]); 

        foreach (SKPoint pt in linePoints) 
        { 
         pathOut.LineTo(transform(pt)); 
        } 

        lastPoint = points[1]; 
        break; 

       case SKPathVerb.Cubic: 
        SKPoint[] cubicPoints = FlattenCubic(points[0], points[1], points[2], points[3]); 

        foreach (SKPoint pt in cubicPoints) 
        { 
         pathOut.LineTo(transform(pt)); 
        } 

        lastPoint = points[3]; 
        break; 

       case SKPathVerb.Quad: 
        SKPoint[] quadPoints = FlattenQuadratic(points[0], points[1], points[2]); 

        foreach (SKPoint pt in quadPoints) 
        { 
         pathOut.LineTo(transform(pt)); 
        } 

        lastPoint = points[2]; 
        break; 

       case SKPathVerb.Conic: 
        SKPoint[] conicPoints = FlattenConic(points[0], points[1], points[2], iterator.ConicWeight()); 

        foreach (SKPoint pt in conicPoints) 
        { 
         pathOut.LineTo(transform(pt)); 
        } 

        lastPoint = points[2]; 
        break; 

       case SKPathVerb.Close: 
        SKPoint[] closePoints = Interpolate(lastPoint, firstPoint); 

        foreach (SKPoint pt in closePoints) 
        { 
         pathOut.LineTo(transform(pt)); 
        } 

        firstPoint = lastPoint = new SKPoint(0, 0); 
        pathOut.Close(); 
        break; 
      } 
     } 
    } 
    return pathOut; 
} 
... 
}