public override XPoint AddToPath(XGraphicsPath path, XPoint cursor, Base lastPathCommand = null)
{
var previousControlPoint = new PointF((float)cursor.X, (float)cursor.Y);
if (lastPathCommand is BezierCurve bezierCurve)
{
previousControlPoint = bezierCurve.Control2;
}
else if (lastPathCommand is QuadraticCurve quadraticCurve)
{
previousControlPoint = quadraticCurve.Control1;
}
else if (lastPathCommand is ShortcutBezierCurve shortcutBezierCurve)
{
previousControlPoint = shortcutBezierCurve.Control2;
}
else if (lastPathCommand is ShortcutQuadraticCurve shortcutQuadraticCurve)
{
previousControlPoint = shortcutQuadraticCurve.Control2;
}
var deltaX = cursor.X - previousControlPoint.X;
var deltaY = cursor.Y - previousControlPoint.Y;
var control1 = new XPoint(cursor.X + deltaX, cursor.Y + deltaY);
path.AddBezier(cursor, control1, Control2.ToXPoint(), End.ToXPoint());
return(End.ToXPoint());
}
public void Fill(XGraphics graphics, XBrush brush)
{
XGraphicsPath path = new XGraphicsPath
{
FillMode = XFillMode.Winding
};
bool hasFigure = false;
int ptIndex = 0;
foreach (Command command in Commands)
{
switch (command)
{
case Command.MoveTo:
if (hasFigure)
{
path.CloseFigure();
hasFigure = false;
}
ptIndex++;
break;
case Command.LineTo:
path.AddLine(Points[ptIndex - 1], Points[ptIndex]);
ptIndex += 1;
hasFigure = true;
break;
case Command.CubicCurveTo:
path.AddBezier(Points[ptIndex - 1], Points[ptIndex], Points[ptIndex + 1], Points[ptIndex + 2]);
ptIndex += 3;
hasFigure = true;
break;
case Command.CloseSubpath:
if (hasFigure)
{
path.CloseFigure();
hasFigure = false;
}
break;
case Command.Rectangle:
path.AddRectangle(Points[ptIndex + 1].X, Points[ptIndex + 1].Y, Points[ptIndex].X, Points[ptIndex].Y);
ptIndex += 2;
path.CloseFigure();
hasFigure = false;
break;
}
}
if (hasFigure)
{
path.CloseFigure();
}
graphics.DrawPath(brush, path);
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="qbezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XQBezier qbezier, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
double x1 = qbezier.Point1.X;
double y1 = qbezier.Point1.Y;
double x2 = qbezier.Point1.X + (2.0 * (qbezier.Point2.X - qbezier.Point1.X)) / 3.0;
double y2 = qbezier.Point1.Y + (2.0 * (qbezier.Point2.Y - qbezier.Point1.Y)) / 3.0;
double x3 = x2 + (qbezier.Point3.X - qbezier.Point1.X) / 3.0;
double y3 = y2 + (qbezier.Point3.Y - qbezier.Point1.Y) / 3.0;
double x4 = qbezier.Point3.X;
double y4 = qbezier.Point3.Y;
if (qbezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
if (qbezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(qbezier.Style, _scaleToPage),
ToXSolidBrush(qbezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(qbezier.Style.Fill),
path);
}
}
else
{
if (qbezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(qbezier.Style, _scaleToPage),
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XQuadraticBezier quadraticBezier, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
double x1 = quadraticBezier.Point1.X;
double y1 = quadraticBezier.Point1.Y;
double x2 = quadraticBezier.Point1.X + (2.0 * (quadraticBezier.Point2.X - quadraticBezier.Point1.X)) / 3.0;
double y2 = quadraticBezier.Point1.Y + (2.0 * (quadraticBezier.Point2.Y - quadraticBezier.Point1.Y)) / 3.0;
double x3 = x2 + (quadraticBezier.Point3.X - quadraticBezier.Point1.X) / 3.0;
double y3 = y2 + (quadraticBezier.Point3.Y - quadraticBezier.Point1.Y) / 3.0;
double x4 = quadraticBezier.Point3.X;
double y4 = quadraticBezier.Point3.Y;
if (quadraticBezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
if (quadraticBezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(quadraticBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(quadraticBezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(quadraticBezier.Style.Fill),
path);
}
}
else
{
if (quadraticBezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(quadraticBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(x1 + dx),
_scaleToPage(y1 + dy),
_scaleToPage(x2 + dx),
_scaleToPage(y2 + dy),
_scaleToPage(x3 + dx),
_scaleToPage(y3 + dy),
_scaleToPage(x4 + dx),
_scaleToPage(y4 + dy));
}
}
}
public override void CubicCurveTo(double x1, double y1, double x2, double y2, double x, double y)
{
var controlPoint1 = new XPoint(x1, y1);
var controlPoint2 = new XPoint(x2, y2);
var point = new XPoint(x, y);
CurrentPath.AddBezier(CurrentPathPoint, controlPoint1, controlPoint2, point);
CurrentPathPoint = point;
}
public override XPoint AddToPath(XGraphicsPath path, XPoint cursor, Base lastPathCommand = null)
{
var cp1x = cursor.X + 2.0 / 3.0 * (Control1.X - cursor.X);
var cp1y = cursor.Y + 2.0 / 3.0 * (Control1.Y - cursor.Y);
var cp2x = End.X + 2.0 / 3.0 * (Control1.X - End.X);
var cp2y = End.Y + 2.0 / 3.0 * (Control1.Y - End.Y);
path.AddBezier(cursor, new XPoint(cp1x, cp1y), new XPoint(cp2x, cp2y), End.ToXPoint());
return(End.ToXPoint());
}
/// <summary>
///
/// </summary>
/// <param name="gfx"></param>
/// <param name="bezier"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="db"></param>
/// <param name="r"></param>
public void Draw(object gfx, Core2D.XBezier bezier, double dx, double dy, ImmutableArray <Core2D.ShapeProperty> db, Core2D.Record r)
{
var _gfx = gfx as XGraphics;
if (bezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(bezier.Point1.X + dx),
_scaleToPage(bezier.Point1.Y + dy),
_scaleToPage(bezier.Point2.X + dx),
_scaleToPage(bezier.Point2.Y + dy),
_scaleToPage(bezier.Point3.X + dx),
_scaleToPage(bezier.Point3.Y + dy),
_scaleToPage(bezier.Point4.X + dx),
_scaleToPage(bezier.Point4.Y + dy));
if (bezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(bezier.Style, _scaleToPage),
ToXSolidBrush(bezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(bezier.Style.Fill),
path);
}
}
else
{
if (bezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(bezier.Style, _scaleToPage),
_scaleToPage(bezier.Point1.X + dx),
_scaleToPage(bezier.Point1.Y + dy),
_scaleToPage(bezier.Point2.X + dx),
_scaleToPage(bezier.Point2.Y + dy),
_scaleToPage(bezier.Point3.X + dx),
_scaleToPage(bezier.Point3.Y + dy),
_scaleToPage(bezier.Point4.X + dx),
_scaleToPage(bezier.Point4.Y + dy));
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, Core2D.Shapes.XCubicBezier cubicBezier, double dx, double dy, ImmutableArray <Core2D.Data.XProperty> db, Core2D.Data.Database.XRecord r)
{
var _gfx = dc as XGraphics;
if (cubicBezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(cubicBezier.Point1.X + dx),
_scaleToPage(cubicBezier.Point1.Y + dy),
_scaleToPage(cubicBezier.Point2.X + dx),
_scaleToPage(cubicBezier.Point2.Y + dy),
_scaleToPage(cubicBezier.Point3.X + dx),
_scaleToPage(cubicBezier.Point3.Y + dy),
_scaleToPage(cubicBezier.Point4.X + dx),
_scaleToPage(cubicBezier.Point4.Y + dy));
if (cubicBezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(cubicBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(cubicBezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(cubicBezier.Style.Fill),
path);
}
}
else
{
if (cubicBezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(cubicBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(cubicBezier.Point1.X + dx),
_scaleToPage(cubicBezier.Point1.Y + dy),
_scaleToPage(cubicBezier.Point2.X + dx),
_scaleToPage(cubicBezier.Point2.Y + dy),
_scaleToPage(cubicBezier.Point3.X + dx),
_scaleToPage(cubicBezier.Point3.Y + dy),
_scaleToPage(cubicBezier.Point4.X + dx),
_scaleToPage(cubicBezier.Point4.Y + dy));
}
}
}
/// <inheritdoc/>
public override void Draw(object dc, CubicBezierShape cubicBezier, double dx, double dy, object db, object r)
{
var _gfx = dc as XGraphics;
if (cubicBezier.IsFilled)
{
var path = new XGraphicsPath();
path.AddBezier(
_scaleToPage(cubicBezier.Point1.X + dx),
_scaleToPage(cubicBezier.Point1.Y + dy),
_scaleToPage(cubicBezier.Point2.X + dx),
_scaleToPage(cubicBezier.Point2.Y + dy),
_scaleToPage(cubicBezier.Point3.X + dx),
_scaleToPage(cubicBezier.Point3.Y + dy),
_scaleToPage(cubicBezier.Point4.X + dx),
_scaleToPage(cubicBezier.Point4.Y + dy));
if (cubicBezier.IsStroked)
{
_gfx.DrawPath(
ToXPen(cubicBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
ToXSolidBrush(cubicBezier.Style.Fill),
path);
}
else
{
_gfx.DrawPath(
ToXSolidBrush(cubicBezier.Style.Fill),
path);
}
}
else
{
if (cubicBezier.IsStroked)
{
_gfx.DrawBezier(
ToXPen(cubicBezier.Style, _scaleToPage, _sourceDpi, _targetDpi),
_scaleToPage(cubicBezier.Point1.X + dx),
_scaleToPage(cubicBezier.Point1.Y + dy),
_scaleToPage(cubicBezier.Point2.X + dx),
_scaleToPage(cubicBezier.Point2.Y + dy),
_scaleToPage(cubicBezier.Point3.X + dx),
_scaleToPage(cubicBezier.Point3.Y + dy),
_scaleToPage(cubicBezier.Point4.X + dx),
_scaleToPage(cubicBezier.Point4.Y + dy));
}
}
}
private static void DrawLineCurveInternal(XGraphics gfx, XPen pen, bool isStroked, ref XPoint pt1, ref XPoint pt2, double curvature, Core2D.Style.CurveOrientation orientation, Core2D.Shape.PointAlignment pt1a, Core2D.Shape.PointAlignment pt2a)
{
if (isStroked)
{
var path = new XGraphicsPath();
double p1x = pt1.X;
double p1y = pt1.Y;
double p2x = pt2.X;
double p2y = pt2.Y;
Core2D.Shapes.XLineExtensions.GetCurvedLineBezierControlPoints(orientation, curvature, pt1a, pt2a, ref p1x, ref p1y, ref p2x, ref p2y);
path.AddBezier(
pt1.X, pt1.Y,
p1x, p1y,
p2x, p2y,
pt2.X, pt2.Y);
gfx.DrawPath(pen, path);
}
}
public static XGraphicsPath GetPath(PathEx pathEx)
{
var path = new XGraphicsPath();
path.FillMode = (XFillMode)Enum.Parse(typeof(XFillMode), pathEx.FillMode.ToString());
path.StartFigure();
var start = new XPoint();
foreach (var segment in pathEx.Segments)
{
switch (segment.Type)
{
case PathEx.SegmentType.MoveTo:
start = PdfConverter.Convert(segment.Point1.ToPoint());
break;
case PathEx.SegmentType.LineTo:
var end = PdfConverter.Convert(segment.Point1.ToPoint());
path.AddLine(start, end);
start = end;
break;
case PathEx.SegmentType.BezierTo:
var p1 = PdfConverter.Convert(segment.Point1.ToPoint());
var p2 = PdfConverter.Convert(segment.Point2.ToPoint());
var bEnd = PdfConverter.Convert(segment.Point3.ToPoint());
path.AddBezier(start, p1, p2, bEnd);
start = bEnd;
break;
case PathEx.SegmentType.FigureEnd:
if (segment.Closed)
{
path.CloseFigure();
}
break;
}
}
return(path);
}
public override XPoint AddToPath(XGraphicsPath path, XPoint cursor, Base lastPathCommand = null)
{
var previousControlPoint = new PointF((float)cursor.X, (float)cursor.Y);
if (lastPathCommand is BezierCurve bezierCurve)
{
previousControlPoint = bezierCurve.Control2;
}
else if (lastPathCommand is QuadraticCurve quadraticCurve)
{
previousControlPoint = quadraticCurve.Control1;
}
else if (lastPathCommand is ShortcutBezierCurve shortcutBezierCurve)
{
previousControlPoint = shortcutBezierCurve.Control2;
}
else if (lastPathCommand is ShortcutQuadraticCurve shortcutQuadraticCurve)
{
previousControlPoint = shortcutQuadraticCurve.Control2;
}
var deltaX = cursor.X - previousControlPoint.X;
var deltaY = cursor.Y - previousControlPoint.Y;
var control1 = new XPoint(cursor.X + deltaX, cursor.Y + deltaY);
var cp1x = cursor.X + 2.0 / 3.0 * (control1.X - cursor.X);
var cp1y = cursor.Y + 2.0 / 3.0 * (control1.Y - cursor.Y);
var cp2x = End.X + 2.0 / 3.0 * (control1.X - End.X);
var cp2y = End.Y + 2.0 / 3.0 * (control1.Y - End.Y);
path.AddBezier(cursor, new XPoint(cp1x, cp1y), new XPoint(cp2x, cp2y), End.ToXPoint());
//path.AddBezier(cursor, control1, control1, End.ToXPoint());
// for reference by future ShortcutQuadraticCurve elements.
Control2 = new PointF((float)control1.X, (float)control1.Y);
return(End.ToXPoint());
}
internal static void SvgPath2Pdf(SvgPath element, XGraphics graphics)
{
if (element.Display == "none")
{
return;
}
var path = new XGraphicsPath {
FillMode = XFillMode.Winding
};
foreach (var segment in element.PathData)
{
switch (segment)
{
case SvgMoveToSegment svgMoveToSegment:
Console.WriteLine($"{segment.GetType()}, start: {svgMoveToSegment.Start}, end: {svgMoveToSegment.End}");
path.StartFigure();
break;
case SvgCubicCurveSegment svgCubicCurveSegment:
Console.WriteLine(
$"{segment.GetType()}, start: {svgCubicCurveSegment.Start}, first control: {svgCubicCurveSegment.FirstControlPoint}, second control: {svgCubicCurveSegment.SecondControlPoint}, end: {svgCubicCurveSegment.End}");
path.AddBezier(ConvertHelper.Point2XPoint(svgCubicCurveSegment.Start),
ConvertHelper.Point2XPoint(svgCubicCurveSegment.FirstControlPoint),
ConvertHelper.Point2XPoint(svgCubicCurveSegment.SecondControlPoint),
ConvertHelper.Point2XPoint(svgCubicCurveSegment.End));
break;
case SvgQuadraticCurveSegment svgQuadraticCurveSegment:
Console.WriteLine($"{segment.GetType()}, start: {svgQuadraticCurveSegment.Start}, control: {svgQuadraticCurveSegment.ControlPoint}, end: {svgQuadraticCurveSegment.End}");
var(start, control1, control2, end) = MathHelper.Quadratic2Cubic(svgQuadraticCurveSegment.Start, svgQuadraticCurveSegment.ControlPoint, svgQuadraticCurveSegment.End);
path.AddBezier(ConvertHelper.Point2XPoint(start),
ConvertHelper.Point2XPoint(control1),
ConvertHelper.Point2XPoint(control2),
ConvertHelper.Point2XPoint(end));
break;
case SvgLineSegment svgLineSegment:
Console.WriteLine($"{segment.GetType()}, start: {svgLineSegment.Start}, end: {svgLineSegment.End}");
path.AddLine(ConvertHelper.Point2XPoint(svgLineSegment.Start), ConvertHelper.Point2XPoint(svgLineSegment.End));
break;
case SvgClosePathSegment svgClosePathSegment:
Console.WriteLine($"{segment.GetType()}, start: {svgClosePathSegment.Start}, end: {svgClosePathSegment.End}");
path.CloseFigure();
break;
default:
Console.WriteLine(segment.GetType());
break;
}
}
if (element.Fill != SvgPaintServer.None)
{
var brush = ConvertHelper.Fill2XBrush(element.Fill);
graphics.DrawPath(brush, path);
}
if (element.Stroke != null)
{
var pen = ConvertHelper.Stroke2XPen(element.Stroke, element.StrokeWidth, element.StrokeLineCap, element.StrokeLineJoin);
graphics.DrawPath(pen, path);
}
}
public override XPoint AddToPath(XGraphicsPath path, XPoint cursor, Base lastPathCommand = null)
{
path.AddBezier(cursor, Control1.ToXPoint(), Control2.ToXPoint(), End.ToXPoint());
return(End.ToXPoint());
}
/// <summary>
///
/// </summary>
/// <param name="pg"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <param name="scale"></param>
/// <returns></returns>
public static XGraphicsPath ToXGraphicsPath(this Test2d.XPathGeometry pg, double dx, double dy, Func <double, double> scale)
{
var gp = new XGraphicsPath();
gp.FillMode = pg.FillRule == Test2d.XFillRule.EvenOdd ? XFillMode.Alternate : XFillMode.Winding;
foreach (var pf in pg.Figures)
{
var startPoint = pf.StartPoint;
foreach (var segment in pf.Segments)
{
if (segment is Test2d.XArcSegment)
{
#if CORE
//var arcSegment = segment as Test2d.XArcSegment;
// TODO: Convert WPF/SVG elliptical arc segment format to GDI+ bezier curves.
//startPoint = arcSegment.Point;
#endif
#if WPF
var arcSegment = segment as Test2d.XArcSegment;
var point1 = new XPoint(
scale(startPoint.X),
scale(startPoint.Y));
var point2 = new XPoint(
scale(arcSegment.Point.X),
scale(arcSegment.Point.Y));
var size = new XSize(
scale(arcSegment.Size.Width),
scale(arcSegment.Size.Height));
gp.AddArc(
point1,
point2,
size, arcSegment.RotationAngle, arcSegment.IsLargeArc,
arcSegment.SweepDirection == Test2d.XSweepDirection.Clockwise ? XSweepDirection.Clockwise : XSweepDirection.Counterclockwise);
startPoint = arcSegment.Point;
#endif
}
else if (segment is Test2d.XBezierSegment)
{
var bezierSegment = segment as Test2d.XBezierSegment;
gp.AddBezier(
scale(startPoint.X),
scale(startPoint.Y),
scale(bezierSegment.Point1.X),
scale(bezierSegment.Point1.Y),
scale(bezierSegment.Point2.X),
scale(bezierSegment.Point2.Y),
scale(bezierSegment.Point3.X),
scale(bezierSegment.Point3.Y));
startPoint = bezierSegment.Point3;
}
else if (segment is Test2d.XLineSegment)
{
var lineSegment = segment as Test2d.XLineSegment;
gp.AddLine(
scale(startPoint.X),
scale(startPoint.Y),
scale(lineSegment.Point.X),
scale(lineSegment.Point.Y));
startPoint = lineSegment.Point;
}
else if (segment is Test2d.XPolyBezierSegment)
{
var polyBezierSegment = segment as Test2d.XPolyBezierSegment;
if (polyBezierSegment.Points.Count >= 3)
{
gp.AddBezier(
scale(startPoint.X),
scale(startPoint.Y),
scale(polyBezierSegment.Points[0].X),
scale(polyBezierSegment.Points[0].Y),
scale(polyBezierSegment.Points[1].X),
scale(polyBezierSegment.Points[1].Y),
scale(polyBezierSegment.Points[2].X),
scale(polyBezierSegment.Points[2].Y));
}
if (polyBezierSegment.Points.Count > 3 &&
polyBezierSegment.Points.Count % 3 == 0)
{
for (int i = 3; i < polyBezierSegment.Points.Count; i += 3)
{
gp.AddBezier(
scale(polyBezierSegment.Points[i - 1].X),
scale(polyBezierSegment.Points[i - 1].Y),
scale(polyBezierSegment.Points[i].X),
scale(polyBezierSegment.Points[i].Y),
scale(polyBezierSegment.Points[i + 1].X),
scale(polyBezierSegment.Points[i + 1].Y),
scale(polyBezierSegment.Points[i + 2].X),
scale(polyBezierSegment.Points[i + 2].Y));
}
}
startPoint = polyBezierSegment.Points.Last();
}
else if (segment is Test2d.XPolyLineSegment)
{
var polyLineSegment = segment as Test2d.XPolyLineSegment;
if (polyLineSegment.Points.Count >= 1)
{
gp.AddLine(
scale(startPoint.X),
scale(startPoint.Y),
scale(polyLineSegment.Points[0].X),
scale(polyLineSegment.Points[0].Y));
}
if (polyLineSegment.Points.Count > 1)
{
for (int i = 1; i < polyLineSegment.Points.Count; i++)
{
gp.AddLine(
scale(polyLineSegment.Points[i - 1].X),
scale(polyLineSegment.Points[i - 1].Y),
scale(polyLineSegment.Points[i].X),
scale(polyLineSegment.Points[i].Y));
}
}
startPoint = polyLineSegment.Points.Last();
}
else if (segment is Test2d.XPolyQuadraticBezierSegment)
{
var polyQuadraticSegment = segment as Test2d.XPolyQuadraticBezierSegment;
if (polyQuadraticSegment.Points.Count >= 2)
{
var p1 = startPoint;
var p2 = polyQuadraticSegment.Points[0];
var p3 = polyQuadraticSegment.Points[1];
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
}
if (polyQuadraticSegment.Points.Count > 2 &&
polyQuadraticSegment.Points.Count % 2 == 0)
{
for (int i = 3; i < polyQuadraticSegment.Points.Count; i += 3)
{
var p1 = polyQuadraticSegment.Points[i - 1];
var p2 = polyQuadraticSegment.Points[i];
var p3 = polyQuadraticSegment.Points[i + 1];
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
}
}
startPoint = polyQuadraticSegment.Points.Last();
}
else if (segment is Test2d.XQuadraticBezierSegment)
{
var qbezierSegment = segment as Test2d.XQuadraticBezierSegment;
var p1 = startPoint;
var p2 = qbezierSegment.Point1;
var p3 = qbezierSegment.Point2;
double x1 = p1.X;
double y1 = p1.Y;
double x2 = p1.X + (2.0 * (p2.X - p1.X)) / 3.0;
double y2 = p1.Y + (2.0 * (p2.Y - p1.Y)) / 3.0;
double x3 = x2 + (p3.X - p1.X) / 3.0;
double y3 = y2 + (p3.Y - p1.Y) / 3.0;
double x4 = p3.X;
double y4 = p3.Y;
gp.AddBezier(
scale(x1 + dx),
scale(y1 + dy),
scale(x2 + dx),
scale(y2 + dy),
scale(x3 + dx),
scale(y3 + dy),
scale(x4 + dx),
scale(y4 + dy));
startPoint = qbezierSegment.Point2;
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
if (pf.IsClosed)
{
gp.CloseFigure();
}
else
{
gp.StartFigure();
}
}
return(gp);
}
public void AddBezier(Point point1, Point point2, Point point3, Point point4)
{
Path.AddBezier(point1, point2, point3, point4);
}