WPF में StreamGeometry में पूर्ण अंडाकार कैसे आकर्षित करें?

Question

StreamGeometryContext में एकमात्र तरीका जो इलिप्स से संबंधित प्रतीत होता है ArcTo विधि है। दुर्भाग्यवश यह अंडाकारों को चित्रित करने के बजाय लाइनों में शामिल होने के लिए काफी हद तक तैयार है।

विशेष रूप से, चाप की स्थिति एक प्रारंभिक और समापन बिंदु द्वारा निर्धारित की जाती है। एक पूर्ण अंडाकार के लिए दोनों स्पष्ट रूप से मेल खाते हैं, और सटीक अभिविन्यास अपरिभाषित हो जाता है।

अब तक एक अंडाकार आकार 10,10 के 100,100 कि मैंने पाया पर केंद्रित ड्राइंग का सबसे अच्छा तरीका है इस तरह है:

using (var ctx = geometry.Open()) 
{ 
    ctx.BeginFigure(new Point(100+5, 100), isFilled: true, isClosed: true); 
    ctx.ArcTo(
     new Point(100 + 5*Math.Cos(0.01), 100 + 5*Math.Sin(0.01)), // need a small angle but large enough that the ellipse is positioned accurately 
     new Size(10/2, 10/2), // docs say it should be 10,10 but in practice it appears that this should be half the desired width/height... 
     0, true, SweepDirection.Counterclockwise, true, true); 
} 

जो काफी बदसूरत है, और यह भी एक छोटा सा "फ्लैट" क्षेत्र छोड़ देता है (हालांकि सामान्य ज़ूम स्तर पर दिखाई नहीं दे रहा है)।

StreamGeometryContext का उपयोग करके मैं एक पूर्ण अंडाकार कैसे खींच सकता हूं?

Answer 1

जैसा कि आपने देखा है, आर्कटो एक पूर्ण अंडाकार नहीं खींच सकता है। वास्तव में यह "फ्लैट" क्षेत्र को कम करने का प्रयास करते समय संख्यात्मक रूप से अस्थिर हो जाता है। एक और विचार यह है कि आधुनिक हार्डवेयर पर बेजियर ड्राइंग से आर्क ड्राइंग धीमा है। यह सबसे आधुनिक प्रणालियां एक वास्तविक अंडाकार बनाने के बजाए एक अंडाकार का अनुमान लगाने के लिए चार बेजियर घटता का उपयोग करती हैं।

आप देख सकते हैं WPF के EllipseGeometry निम्नलिखित कोड को क्रियान्वित करने, DrawBezierFigure विधि कॉल पर तोड़ने, और डीबगर में PathFigure का परीक्षण करके यह करता है कि:

using(var ctx = geometry.Open()) 
{ 
    var ellipse = new EllipseGeometry(new Point(100,100), 10, 10); 
    var figure = PathGeometry.CreateFromGeometry(ellipse).Figures[0]; 
    DrawBezierFigure(ctx, figure); 
} 

void DrawBezierFigure(StreamGeometryContext ctx, PathFigure figure) 
{ 
    ctx.BeginFigure(figure.StartPoint, figure.IsFilled, figure.IsClosed); 
    foreach(var segment in figure.Segments.OfType<BezierSegment>()) 
    ctx.BezierTo(segment.Point1, segment.Point2, segment.Point3, segment.IsStroked, segment.IsSmoothJoin); 
} 

ऊपर कोड एक आकर्षित करने के लिए एक आसान तरीका है एक StreamGeometry में कुशल अंडाकार, लेकिन बहुत विशेष मामला कोड है। वास्तविक व्यवहार में मैं कई सामान्य प्रयोजन विस्तार तरीकों एक StreamGeometryContext में एक मनमाना ज्यामिति ड्राइंग के लिए परिभाषित उपयोग करती हैं इसलिए मैं बस लिख सकते हैं:

public static class GeometryExtensions 
{ 
    public static void DrawGeometry(this StreamGeometryContext ctx, Geometry geo) 
    { 
    var pathGeometry = geo as PathGeometry ?? PathGeometry.CreateFromGeometry(geo); 
    foreach(var figure in pathGeometry.Figures) 
     ctx.DrawFigure(figure); 
    } 

    public static void DrawFigure(this StreamGeometryContext ctx, PathFigure figure) 
    { 
    ctx.BeginFigure(figure.StartPoint, figure.IsFilled, figure.IsClosed); 
    foreach(var segment in figure.Segments) 
    { 
     var lineSegment = segment as LineSegment; 
     if(lineSegment!=null) { ctx.LineTo(lineSegment.Point, lineSegment.IsStroked, lineSegment.IsSmoothJoin); continue; } 

     var bezierSegment = segment as BezierSegment; 
     if(bezierSegment!=null) { ctx.BezierTo(bezierSegment.Point1, bezierSegment.Point2, bezierSegment.Point3, bezierSegment.IsStroked, bezierSegment.IsSmoothJoin); continue; } 

     var quadraticSegment = segment as QuadraticBezierSegment; 
     if(quadraticSegment!=null) { ctx.QuadraticBezierTo(quadraticSegment.Point1, quadraticSegment.Point2, quadraticSegment.IsStroked, quadraticSegment.IsSmoothJoin); continue; } 

     var polyLineSegment = segment as PolyLineSegment; 
     if(polyLineSegment!=null) { ctx.PolyLineTo(polyLineSegment.Points, polyLineSegment.IsStroked, polyLineSegment.IsSmoothJoin); continue; } 

     var polyBezierSegment = segment as PolyBezierSegment; 
     if(polyBezierSegment!=null) { ctx.PolyBezierTo(polyBezierSegment.Points, polyBezierSegment.IsStroked, polyBezierSegment.IsSmoothJoin); continue; } 

     var polyQuadraticSegment = segment as PolyQuadraticBezierSegment; 
     if(polyQuadraticSegment!=null) { ctx.PolyQuadraticBezierTo(polyQuadraticSegment.Points, polyQuadraticSegment.IsStroked, polyQuadraticSegment.IsSmoothJoin); continue; } 

     var arcSegment = segment as ArcSegment; 
     if(arcSegment!=null) { ctx.ArcTo(arcSegment.Point, arcSegment.Size, arcSegment.RotationAngle, arcSegment.IsLargeArc, arcSegment.SweepDirection, arcSegment.IsStroked, arcSegment.IsSmoothJoin); continue; } 
    } 
    } 
} 

:

using(var ctx = geometry.Open()) 
{ 
    ctx.DrawGeometry(new EllipseGeometry(new Point(100,100), 10, 10)); 
} 

यहाँ DrawGeometry विस्तार विधि के क्रियान्वयन है एक और विकल्प खुद को अंक की गणना करना है। एक अंडाकार के लिए सबसे अच्छा अनुमान नियंत्रण बिंदुओं को सेट करके पाया जाता है (त्रिज्या के Math.Sqrt (2) -1) * 4/3। तो आप स्पष्ट रूप से अंक गणना कर सकता है और इस प्रकार बेज़ियर आकर्षित:

const double ControlPointRatio = (Math.Sqrt(2)-1)*4/3; 

var x0 = centerX - radiusX; 
var x1 = centerX - radiusX * ControlPointRatio; 
var x2 = centerX; 
var x3 = centerX + radiusX * ControlPointRatio; 
var x4 = centerX + radiusX; 

var y0 = centerY - radiusY; 
var y1 = centerY - radiusY * ControlPointRatio; 
var y2 = centerY; 
var y3 = centerY + radiusY * ControlPointRatio; 
var y4 = centerY + radiusY; 

ctx.BeginFigure(new Point(x2,y0), true, true); 
ctx.BezierTo(new Point(x3, y0), new Point(x4, y1), new Point(x4,y2), true, true); 
ctx.BezierTo(new Point(x4, y3), new Point(x3, y4), new Point(x2,y4), true, true); 
ctx.BezierTo(new Point(x1, y4), new Point(x0, y3), new Point(x0,y2), true, true); 
ctx.BezierTo(new Point(x0, y1), new Point(x1, y0), new Point(x2,y0), true, true); 

एक अन्य विकल्प दो ArcTo कॉल उपयोग करने के लिए होगा, लेकिन मैंने कहा के रूप में पहले इस कम कुशल है। मुझे यकीन है कि यदि आप इस तरह से जाना चाहते हैं तो आप दो आर्कटो कॉल के ब्योरे को समझ सकते हैं।