//--------------------------------------------------------------------------------------------------
public static bool RenderEllipse(IDrawingRenderer renderer, Geom2d_Ellipse ellipse, double first, double last, bool reverse)
{
if (renderer.Capabilities.EllipseAsCurve)
{
var bsplineCurve = ShapeConstruct.ConvertCurveToBSpline(ellipse, first, last, 0.001, GeomAbs_Shape.GeomAbs_C1, 100, 3);
if (bsplineCurve != null)
{
return(RenderBSplineCurve(renderer, bsplineCurve, first, last, reverse));
}
return(false);
}
var center = ellipse.Location();
var majorRadius = ellipse.MajorRadius();
var minorRadius = ellipse.MinorRadius();
double rotation = ellipse.XAxis().Direction.Angle(Dir2d.DX);
if (ellipse.Position().Sense() > 0)
{
first = Maths.DoublePI - first;
last = Maths.DoublePI - last;
}
if (reverse)
{
first.Swap(ref last);
}
renderer.Ellipse(center, majorRadius, minorRadius, rotation, first, last);
return(false);
}
//--------------------------------------------------------------------------------------------------
public static bool RenderCircle(IDrawingRenderer renderer, Geom2d_Circle circle, double first, double last, bool reverse)
{
if (renderer.Capabilities.CircleAsCurve)
{
var bsplineCurve = ShapeConstruct.ConvertCurveToBSpline(circle, first, last, 0.001, GeomAbs_Shape.GeomAbs_C2, 100, 3);
if (bsplineCurve != null)
{
return(RenderBSplineCurve(renderer, bsplineCurve, first, last, reverse));
}
return(false);
}
var center = circle.Location();
var radius = circle.Radius();
double rotation = circle.XAxis().Direction.Angle(Dir2d.DX);
if (circle.Position().Sense() > 0)
{
first = Maths.DoublePI - first;
last = Maths.DoublePI - last;
}
if (reverse)
{
first.Swap(ref last);
}
renderer.Circle(center, radius, first - rotation, last - rotation);
return(true);
}
//--------------------------------------------------------------------------------------------------
public static bool RenderCurve(IDrawingRenderer renderer, Geom2d_Curve curve2d, double first, double last, bool reverse)
{
switch (curve2d)
{
case Geom2d_Line line:
return(RenderLine(renderer, line, first, last, reverse));
case Geom2d_Ellipse ellipse:
return(RenderEllipse(renderer, ellipse, first, last, reverse));
case Geom2d_Circle circle:
return(RenderCircle(renderer, circle, first, last, reverse));
case Geom2d_BSplineCurve bspline:
return(RenderBSplineCurve(renderer, bspline, first, last, reverse));
case Geom2d_BezierCurve bezier:
return(RenderBezierCurve(renderer, bezier, first, last, reverse));
default:
// Try to create B-Spline curve
var bsplineCurve = ShapeConstruct.ConvertCurveToBSpline(curve2d, first, last, 0.001 /*Precision.Confusion()*10*/, curve2d.Continuity(), 10000, 3);
if (bsplineCurve != null)
{
return(RenderBSplineCurve(renderer, bsplineCurve, first, last, reverse));
}
Messages.Warning("BrepRenderHelper: Unsupported curve class.");
return(false);
}
}
//--------------------------------------------------------------------------------------------------
void _AddCurve(Geom2d_Curve curve2d, double first, double last)
{
// Process curve
switch (curve2d)
{
case Geom2d_Line line:
_AddLine(line, first, last);
break;
case Geom2d_Ellipse ellipse:
_AddEllipse(ellipse, first, last);
break;
case Geom2d_Circle circle:
_AddCircle(circle, first, last);
break;
case Geom2d_BSplineCurve bspline:
_AddBSplineCurve(bspline, first, last);
break;
default:
// Try to create B-Spline curve
var bsplineCurve = ShapeConstruct.ConvertCurveToBSpline(curve2d, first, last, _Precision * 10.0, curve2d.Continuity(), 10000, 3);
if (bsplineCurve != null)
{
_AddBSplineCurve(bsplineCurve, first, last);
return;
}
Messages.Warning($"DxfExporter: Unsupported curve class: {curve2d.GetType().Name}.");
break;
}
}
//--------------------------------------------------------------------------------------------------
protected void AddCurve(Geom2d_Curve curve2d, bool reverse, double first, double last)
{
// Process curve
switch (curve2d)
{
case Geom2d_Line line:
AddLine(line, first, last, reverse);
break;
case Geom2d_Ellipse ellipse:
AddEllipse(ellipse, first, last, reverse);
break;
case Geom2d_Circle circle:
AddCircle(circle, first, last, reverse);
break;
case Geom2d_BSplineCurve bspline:
AddBSplineCurve(bspline, first, last, reverse);
break;
case Geom2d_BezierCurve bezier:
AddBezierCurve(bezier, first, last, reverse);
break;
default:
// Try to create B-Spline curve
var bsplineCurve = ShapeConstruct.ConvertCurveToBSpline(curve2d, first, last, 0.001 /*Precision.Confusion()*10*/, curve2d.Continuity(), 10000, 3);
if (bsplineCurve != null)
{
AddBSplineCurve(bsplineCurve, first, last, reverse);
return;
}
Messages.Warning("SvgExporter: Unsupported curve class.");
break;
}
}
//--------------------------------------------------------------------------------------------------
public static bool RenderBezierCurve(IDrawingRenderer renderer, Geom2d_BezierCurve bezier, double first, double last, bool reverse)
{
if (renderer.Capabilities.BezierCurveMaxDegree > 0)
{
var maxDegree = Math.Min(3, renderer.Capabilities.BezierCurveMaxDegree);
if (bezier.Degree() > maxDegree)
{
// Try to reduce the order of the curve
var continuity = bezier.Continuity();
if (continuity != GeomAbs_Shape.GeomAbs_C0)
{
continuity = GeomAbs_Shape.GeomAbs_C1;
}
var converter = new Geom2dConvert_ApproxCurve(bezier, 0.0001, continuity, 1000, maxDegree);
if (!(converter.IsDone() && converter.HasResult()))
{
Messages.Warning("BrepRenderHelper: Bezier curve has an undecreasable order of " + bezier.Degree() + ".");
return(false);
}
return(RenderBSplineCurve(renderer, converter.Curve(), first, last, reverse));
}
bezier.Segment(first, last);
Pnt2d c1, c2;
var start = reverse ? bezier.EndPoint() : bezier.StartPoint();
var end = reverse ? bezier.StartPoint() : bezier.EndPoint();
switch (bezier.Degree())
{
case 1:
renderer.Line(start, end);
return(true);
case 2:
c1 = bezier.Pole(2);
renderer.BezierCurve(new[] { start, c1, end });
return(true);
case 3:
c1 = bezier.Pole(reverse ? 3 : 2);
c2 = bezier.Pole(reverse ? 2 : 3);
renderer.BezierCurve(new[] { start, c1, c2, end });
return(true);
default:
Messages.Warning("BrepRenderHelper: Bezier curve has an unsupported order of " + bezier.Degree() + ".");
break;
}
return(false);
}
else
{
// Try to create B-Spline curve
var bsplineCurve = ShapeConstruct.ConvertCurveToBSpline(bezier, first, last, 0.0001, bezier.Continuity(), 10000, 3);
if (bsplineCurve != null)
{
return(RenderBSplineCurve(renderer, bsplineCurve, first, last, reverse));
}
Messages.Warning("BrepRenderHelper: Bezier curve is not supported by exporter and conversion to BSpline failed.");
return(false);
}
}
