//-------------------------------------------------------------------------------------------------- public void Render(IDrawingRenderer renderer) { foreach (var element in this) { element.Render(renderer); } }
//-------------------------------------------------------------------------------------------------- public override bool Render(IDrawingRenderer renderer) { var shapes = _Source?.GetBreps(); if (shapes == null) { return(true); // nothing to do } if (renderer.RenderElement(this)) { return(true); } renderer.SetStyle(_Stroke, _Fill, null); renderer.BeginGroup(Name); bool res = true; foreach (var shape in shapes) { res &= BrepRenderHelper.RenderShape(renderer, shape); } renderer.EndGroup(); return(res); }
//-------------------------------------------------------------------------------------------------- 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); } }
//-------------------------------------------------------------------------------------------------- public static bool RenderLine(IDrawingRenderer renderer, Geom2d_Line line, double first, double last, bool reverse) { var start = line.Value(reverse ? last : first); var end = line.Value(reverse ? first : last); renderer.Line(start, end); return(true); }
public override bool Render(IDrawingRenderer renderer) { renderer.BeginGroup("Text"); renderer.SetStyle(null, new FillStyle(Color.Black), Style); renderer.Text(Text, Pnt2d.Origin, 0.0); renderer.EndGroup(); return(true); }
public static bool RenderShape(IDrawingRenderer renderer, TopoDS_Shape brepShape) { if (renderer.RenderBrepShape(brepShape)) { return(true); } return(RenderFaces(renderer, brepShape)); }
//-------------------------------------------------------------------------------------------------- public static bool RenderEdges(IDrawingRenderer renderer, List <TopoDS_Edge> edges, TopoDS_Face face) { var res = true; // Order edges var order = new ShapeAnalysis_WireOrder(true, 0.0001); foreach (var edge in edges) { var first = BRep_Tool.Pnt(TopExp.FirstVertex(edge)); var last = BRep_Tool.Pnt(TopExp.LastVertex(edge)); if (edge.Orientation() == TopAbs_Orientation.TopAbs_FORWARD) { order.Add(first.Coord, last.Coord); } else { order.Add(last.Coord, first.Coord); } } order.Perform(true); if (order.IsDone()) { order.SetChains(0.0001); for (int chain = 1; chain <= order.NbChains(); chain++) { int startIndex = 0, endIndex = 0; order.Chain(chain, ref startIndex, ref endIndex); if (startIndex > endIndex) { continue; } // Process ordered edges renderer.BeginPathSegment(); for (int index = startIndex; index <= endIndex; index++) { int orderIndex = order.Ordered(index); int originalIndex = Math.Abs(orderIndex) - 1; // order index is 1-based res &= RenderEdge(renderer, edges[originalIndex], orderIndex < 0, face); } renderer.EndPathSegment(); } } else { // Cannot sort, just pump out all edges foreach (var edge in edges) { res &= RenderEdge(renderer, edge, false, face); } } return(res); }
//-------------------------------------------------------------------------------------------------- public override bool Render(IDrawingRenderer renderer) { if (!ComputeParameters(out var p)) { return(false); } if (renderer.RenderElement(this)) { return(true); } // Render each element separately renderer.SetStyle(new StrokeStyle(Color.Black, 0.1f, LineStyle.Solid), null, null); renderer.BeginGroup("Dimension"); if (_Debug_DrawPoints) { DrawingRenderHelper.RenderCross(renderer, _FirstPoint); DrawingRenderHelper.RenderCross(renderer, _SecondPoint); DrawingRenderHelper.RenderCross(renderer, Position); } // Extension lines renderer.Line(_FirstPoint, _FirstPoint.Translated(p.ExtensionVector)); renderer.Line(_SecondPoint, _SecondPoint.Translated(p.ExtensionVector)); // Dimension line var arrowSize = DrawingRenderHelper.GetArrowSize(); renderer.Line(_FirstPoint.Translated(p.DimensionOffset) .Translated(p.DimensionDirection.ToVec(arrowSize.Length * p.Scale)), _SecondPoint.Translated(p.DimensionOffset) .Translated(p.DimensionDirection.Reversed().ToVec(arrowSize.Length * p.Scale))); DrawingRenderHelper.RenderArrow(renderer, new Ax2d(_FirstPoint.Translated(p.DimensionOffset), p.DimensionDirection.Reversed()), p.Scale); DrawingRenderHelper.RenderArrow(renderer, new Ax2d(_SecondPoint.Translated(p.DimensionOffset), p.DimensionDirection), p.Scale); // Dimension text if (!Text.IsNullOrWhiteSpace()) { var fontStyle = DrawingRenderHelper.GetDefaultFontStyle(); renderer.SetStyle(null, new FillStyle(Color.Black), new FontStyle(fontStyle.Family, (float)(fontStyle.Size * p.TextScale))); renderer.Text(Text, p.TextOrigin, p.DimensionRotation); if (_IsNotToScale) { var start = p.TextOrigin.Translated(p.ExtensionVector.Normalized().Scaled(-0.5)); renderer.Line(start, start.Translated(p.DimensionDirection.ToVec(p.TextWidth))); } } renderer.EndGroup(); return(true); }
//-------------------------------------------------------------------------------------------------- public override bool Render(IDrawingRenderer renderer) { if (!ComputeParameters(out var p)) { return(false); } if (renderer.RenderElement(this)) { return(true); } // Render each element separately renderer.SetStyle(new StrokeStyle(Color.Black, 0.1f, LineStyle.Solid), null, null); renderer.BeginGroup("Dimension"); if (_Debug_DrawPoints) { DrawingRenderHelper.RenderCross(renderer, _FirstPoint); DrawingRenderHelper.RenderCross(renderer, _SecondPoint); DrawingRenderHelper.RenderCross(renderer, _CenterPoint); DrawingRenderHelper.RenderCross(renderer, Position); } // Extension lines renderer.Line(_FirstPoint, _FirstPoint.Translated(p.FirstExtensionVector)); renderer.Line(_SecondPoint, _SecondPoint.Translated(p.SecondExtensionVector)); // Dimension line BrepRenderHelper.RenderCircle(renderer, new Geom2d_Circle(new Ax2d(_CenterPoint, Dir2d.DX), p.Radius), p.StartAngle, p.EndAngle, false); DrawingRenderHelper.RenderArrow(renderer, new Ax2d(p.FirstArrowPoint, p.FirstArrowTangent), p.Scale); DrawingRenderHelper.RenderArrow(renderer, new Ax2d(p.SecondArrowPoint, p.SecondArrowTangent), p.Scale); // Dimension text if (!Text.IsNullOrWhiteSpace()) { var fontStyle = DrawingRenderHelper.GetDefaultFontStyle(); renderer.SetStyle(null, new FillStyle(Color.Black), new FontStyle(fontStyle.Family, (float)(fontStyle.Size * p.TextScale))); renderer.Text(Text, p.TextOrigin, p.TextRotation); if (_IsNotToScale) { var start = p.TextOrigin.Translated(Dir2d.DX.Rotated(-p.TextRotation + Maths.HalfPI).ToVec(-0.5)); renderer.Line(start, start.Translated(Dir2d.DX.Rotated(-p.TextRotation).ToVec(p.TextWidth))); } } renderer.EndGroup(); return(true); }
//-------------------------------------------------------------------------------------------------- public static void RenderArrow(IDrawingRenderer renderer, Ax2d location, double scale = 1.0) { var arrowSize = GetArrowSize(); var p1 = location.Location; var backpoint = p1.Translated(location.Direction.Reversed().ToVec(arrowSize.Length * scale)); var rightVec = new Vec2d(location.Direction.Y, -location.Direction.X).Scaled(arrowSize.Width * 0.5 * scale); var p2 = backpoint.Translated(rightVec); var p3 = backpoint.Translated(rightVec.Reversed()); renderer.SetStyle(null, new FillStyle(Common.Color.Black), null); renderer.BeginPath(); renderer.BeginPathSegment(); renderer.Line(p1, p2); renderer.Line(p2, p3); renderer.Line(p3, p1); renderer.EndPathSegment(); renderer.EndPath(); }
//-------------------------------------------------------------------------------------------------- public static bool RenderEdge(IDrawingRenderer renderer, TopoDS_Edge edge, bool reverse, TopoDS_Face face) { var res = true; reverse ^= edge.Orientation() == TopAbs_Orientation.TopAbs_REVERSED; double first = 0, last = 0; if (face != null) { var curve = BRep_Tool.CurveOnSurface(edge, new Geom_Plane(Ax3.XOY), new TopLoc_Location(), ref first, ref last); if (curve == null) { return(false); } res &= RenderCurve(renderer, curve, first, last, reverse); } else { if (!(edge.TShape() is BRep_TEdge tedge)) { return(res); } var curves = tedge.CurvesList(); if (reverse) { curves.Reverse(); } foreach (var curveOnSurface in curves.OfType <BRep_CurveOnSurface>()) { var curve = curveOnSurface.PCurve(); first = curveOnSurface.First(); last = curveOnSurface.Last(); res &= RenderCurve(renderer, curve, first, last, reverse); } } return(res); }
//-------------------------------------------------------------------------------------------------- public static bool RenderFaces(IDrawingRenderer renderer, TopoDS_Shape brepShape) { var res = true; renderer.BeginPath(); var faces = brepShape.Faces(); if (faces.Count == 0) { // Drawings may only contain lines, not faces res = RenderEdges(renderer, brepShape.Edges(), null); } else { foreach (var face in faces) { var outerWire = BRepTools.OuterWire(face); if (outerWire == null) { continue; } res &= RenderEdges(renderer, outerWire.Edges(), face); var wires = face.Wires(); foreach (var wire in wires) { if (wire.IsEqual(outerWire)) { continue; } res &= RenderEdges(renderer, wire.Edges(), face); } } } renderer.EndPath(); return(res); }
//-------------------------------------------------------------------------------------------------- public abstract bool Render(IDrawingRenderer renderer);
//-------------------------------------------------------------------------------------------------- public static bool RenderBSplineCurve(IDrawingRenderer renderer, Geom2d_BSplineCurve bspline, double first, double last, bool reverse) { if (renderer.Capabilities.BSplineCurveMaxDegree > 0) { bspline = Geom2dConvert.SplitBSplineCurve(bspline, first, last, 0.00001); if (bspline.Degree() > renderer.Capabilities.BSplineCurveMaxDegree) { // Try to reduce the order of the curve var continuity = bspline.Continuity(); if (continuity != GeomAbs_Shape.GeomAbs_C0) { continuity = GeomAbs_Shape.GeomAbs_C1; } var converter = new Geom2dConvert_ApproxCurve(bspline, 0.0001, continuity, 100, 3); if (!(converter.IsDone() && converter.HasResult())) { Messages.Warning("BrepRenderHelper: BSpline curve has an undecreasable degree of " + bspline.Degree() + "."); return(false); } bspline = converter.Curve(); } var knotSource = bspline.KnotSequence(); var knots = new double[knotSource.Length()]; int sourceStart = knotSource.Lower(); for (int i = 0; i < knots.Length; i++) { knots[i] = knotSource.Value(sourceStart + i); } var points = new Pnt2d[bspline.NbPoles()]; var weights = new double[points.Length]; for (int i = 0; i < bspline.NbPoles(); i++) { points[i] = bspline.Pole(i + 1); weights[i] = bspline.Weight(i + 1); } renderer.BSplineCurve(bspline.Degree(), knots, points, weights, bspline.IsRational()); return(true); } else { // Cannot render BSpline, Try bezier var converter = new Geom2dConvert_BSplineCurveToBezierCurve(bspline, first, last, 0.001 /*Precision.PConfusion() * 10*/); bool result = true; if (reverse) { for (int i = converter.NbArcs(); i >= 1; i -= 1) { var arc = converter.Arc(i); result &= RenderBezierCurve(renderer, arc, arc.FirstParameter(), arc.LastParameter(), true); } } else { for (int i = 1; i <= converter.NbArcs(); i += 1) { var arc = converter.Arc(i); result &= RenderBezierCurve(renderer, arc, arc.FirstParameter(), arc.LastParameter(), false); } } return(result); } }
//-------------------------------------------------------------------------------------------------- public static void RenderCross(IDrawingRenderer renderer, Pnt2d point) { renderer.Line(point.Translated(new Vec2d(-1, -1)), point.Translated(new Vec2d(1, 1))); renderer.Line(point.Translated(new Vec2d(-1, 1)), point.Translated(new Vec2d(1, -1))); }
//-------------------------------------------------------------------------------------------------- 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); } }