//--------------------------------------------------------------------------------------------------
public void SetAlignedDimension(Pnt2d dimLinePoint, Pnt2d firstPoint, Pnt2d secondPoint)
{
DimensionType = Type.Aligned;
RefPoint0 = dimLinePoint;
RefPoint3 = firstPoint;
RefPoint4 = secondPoint;
}
//--------------------------------------------------------------------------------------------------
public DxfDomDimension(string layer, string blockName, Pnt2d textPointECS, double rotation)
{
LayerName = layer;
BlockName = blockName;
RefPoint1E = textPointECS;
Rotation = rotation;
}
//--------------------------------------------------------------------------------------------------
public void SetLinearDimension(Pnt2d dimLinePoint, Pnt2d firstExtLineStart, Pnt2d secondExtLineStart)
{
DimensionType = Type.Linear;
RefPoint0 = dimLinePoint;
RefPoint3 = firstExtLineStart;
RefPoint4 = secondExtLineStart;
}
public static Pnt2d FindEllipseCenterFromEndpoints(Pnt2d startPnt, Pnt2d endPnt, double rX, double rY, double angle, bool sense)
{
// https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
// F.6.5.1
var matRotation = new Mat2d();
matRotation.SetRotation(-angle);
var v1 = new XY(startPnt.X - endPnt.X, startPnt.Y - endPnt.Y)
.Multiplied(0.5)
.Multiplied(matRotation);
// F.6.5.2
var denom = rX.Sqr() * v1.Y.Sqr() + rY.Sqr() * v1.X.Sqr();
var numer = rX.Sqr() * rY.Sqr() - denom;
var root = Math.Sqrt(Math.Abs(numer / denom)) * (sense ? -1 : 1);
var c1 = new XY(rX * v1.Y / rY, -(rY * v1.X / rX)).Multiplied(root);
// F.6.5.3
matRotation.SetRotation(angle);
var c = new XY(startPnt.X + endPnt.X, startPnt.Y + endPnt.Y)
.Multiplied(0.5)
.Added(c1.Multiplied(matRotation));
return(c.ToPnt());
}
//--------------------------------------------------------------------------------------------------
void _FinishPivotPoint(ToolAction toolAction)
{
if (!(toolAction is PointAction pointAction))
{
return;
}
_Plane = WorkspaceController.Workspace.WorkingPlane;
_PointPlane1 = pointAction.PointOnPlane;
_PivotPoint = pointAction.Point;
pointAction.Stop();
pointAction = new PointAction(this);
if (!WorkspaceController.StartToolAction(pointAction))
{
return;
}
pointAction.Previewed += _PreviewRadius;
pointAction.Finished += _FinishRadius;
_CurrentPhase = Phase.Radius;
StatusText = "Select radius.";
_ValueHudElement = WorkspaceController.HudManager?.CreateElement <ValueHudElement>(this);
if (_ValueHudElement != null)
{
_ValueHudElement.Label = "Radius:";
_ValueHudElement.Units = ValueUnits.Length;
_ValueHudElement.ValueEntered += _ValueEntered;
}
WorkspaceController.HudManager?.SetCursor(Cursors.SetRadius);
}
//--------------------------------------------------------------------------------------------------
internal override bool Read(XmlReader reader, SvgConverter conv)
{
bool res = false;
string sx = reader.GetAttribute("cx") ?? "0";
string sy = reader.GetAttribute("cy") ?? "0";
string srx = reader.GetAttribute("rx");
string sry = reader.GetAttribute("ry");
if (!base.Read(reader, conv))
{
return(false);
}
if (!sx.IsNullOrEmpty() && !sy.IsNullOrEmpty() && !srx.IsNullOrEmpty() && !sry.IsNullOrEmpty())
{
var localCenter = new Pnt2d(conv.FromSvgLength(sx), conv.FromSvgLength(sy));
Center = localCenter;
RadiusX = conv.FromSvgLength(srx);
RadiusY = conv.FromSvgLength(sry);
RimPointX = (localCenter + new Pnt2d(RadiusX, 0));
RimPointY = (localCenter + new Pnt2d(0, RadiusY));
conv.Transform(ref Center);
conv.Transform(ref RimPointX);
conv.Transform(ref RimPointY);
res = true;
}
conv.PopTransform();
return(res);
}
public void SmoothCorner_BezierArc()
{
var sketch = Sketch.Create();
var p1 = sketch.AddPoint(new Pnt2d(0, 0));
var p2 = sketch.AddPoint(new Pnt2d(2, 9));
var p3 = sketch.AddPoint(new Pnt2d(10, 10));
var p4 = sketch.AddPoint(new Pnt2d(20, 0));
var p5 = sketch.AddPoint(new Pnt2d(18, 7));
var bezier1 = new SketchSegmentBezier(p1, p2, p3);
var s1 = sketch.AddSegment(bezier1);
var arc = new SketchSegmentArc(p3, p4, p5);
var s2 = sketch.AddSegment(arc);
var constraint1 = new SketchConstraintSmoothCorner(p3, true);
var c1 = sketch.AddConstraint(constraint1);
Assert.IsTrue(sketch.SolveConstraints(true));
var tan1 = new Vec2d(sketch.Points[p2], sketch.Points[p3]);
var parameter = new double[2];
var circle = arc.GetCircle(sketch.Points, parameter);
var pnt = new Pnt2d();
var tan2 = new Vec2d();
ElCLib.D1(parameter[0], circle, ref pnt, ref tan2);
Assert.IsTrue(tan1.IsParallel(tan2, 0.01));
}
//--------------------------------------------------------------------------------------------------
bool _CalcArcRimPoints(Pnt2d endPoint, int mergeCandidateIndex = -1)
{
// Project end point on circle
if ((_StartPoint.Distance(endPoint) <= 0) || (endPoint.Distance(_CenterPoint) <= 0) || (_StartPoint.Distance(_CenterPoint) <= 0))
{
return(false);
}
var ellipse = Core.Geom.Geom2dUtils.MakeEllipse(_CenterPoint, _StartPoint, endPoint, _ArcDirection);
if (ellipse == null)
{
return(false);
}
// If the last parameter was small (a*0.25), and the current is high (a*0.5), toggle direction
var startParameter = ElCLib.Parameter(ellipse, _StartPoint);
var endParameter = ElCLib.Parameter(ellipse, endPoint);
var maxParameter = Math.Max(startParameter, endParameter);
if (((startParameter > endParameter) && _LastParameterWasEnd) ||
((startParameter < endParameter) && !_LastParameterWasEnd))
{
_LastEndParameter = maxParameter;
_LastParameterWasEnd = !_LastParameterWasEnd;
}
else
{
if (maxParameter > 0.0001)
{
var qa = ellipse.MajorRadius() / 4;
if (((_LastEndParameter < qa) && (maxParameter > qa * 2)) ||
((maxParameter < qa) && (_LastEndParameter > qa * 2)))
{
_ArcDirection = !_ArcDirection;
ellipse = Core.Geom.Geom2dUtils.MakeEllipse(_CenterPoint, _StartPoint, endPoint, _ArcDirection);
// Debug.WriteLine("Toggle direction");
}
// Debug.WriteLine("New: {0} Last: {1}", maxParameter, _LastEndParameter);
_LastEndParameter = maxParameter;
}
}
// Catch points
if (_ArcDirection)
{
_Points[1] = _StartPoint;
_MergePointIndices[1] = _StartPointMergeIndex;
_Points[2] = endPoint;
_MergePointIndices[2] = mergeCandidateIndex;
}
else
{
_Points[1] = endPoint;
_MergePointIndices[1] = mergeCandidateIndex;
_Points[2] = _StartPoint;
_MergePointIndices[2] = _StartPointMergeIndex;
}
return(true);
}
internal override bool Read(XmlReader reader, SvgConverter conv)
{
bool res = false;
string sx = reader.GetAttribute("x") ?? "0";
string sy = reader.GetAttribute("y") ?? "0";
string sw = reader.GetAttribute("width") ?? "0";
string sh = reader.GetAttribute("height") ?? "0";
string srx = reader.GetAttribute("rx") ?? "0";
string sry = reader.GetAttribute("ry") ?? "0";
if (!base.Read(reader, conv))
{
return(false);
}
if (!(sx.IsNullOrEmpty() && sy.IsNullOrEmpty() && sw.IsNullOrEmpty() && sh.IsNullOrEmpty()))
{
Start = new Pnt2d(conv.FromSvgLength(sx), conv.FromSvgLength(sy));
conv.Transform(ref Start);
Width = conv.FromSvgLength(sw);
Height = -conv.FromSvgLength(sh);
CornerRadiusX = conv.FromSvgLength(srx);
CornerRadiusY = -conv.FromSvgLength(sry);
res = true;
}
conv.PopTransform();
return(res);
}
//--------------------------------------------------------------------------------------------------
#endregion
#region Elements
public int AddPoint(Pnt2d point)
{
var index = Points.Keys.Any() ? Points.Keys.Max() + 1 : 0;
Points.Add(index, point);
return(index);
}
//--------------------------------------------------------------------------------------------------
void IDrawingRenderer.Text(string text, Pnt2d position, double rotation)
{
var fontSize = (_CurrentFontStyle?.Size ?? 3.0) / 1.3; // assumed EU/EO = 0.3 * H
var entity = new DxfDomText(_CurrentLayerName, position, fontSize, -rotation, text);
_AddEntity(entity);
}
//--------------------------------------------------------------------------------------------------
#endregion
#region Paths
protected void InitPathExport()
{
CurrentPath = new SvgPathElement();
_PathStart = new Pnt2d();
_PathPosition = new Pnt2d();
_SubPathStartIndex = 0;
}
//--------------------------------------------------------------------------------------------------
bool _AddEllipicalArcSegment(SketchSegmentEllipticalArc arcSegment, Pnt2d start, Pnt2d end)
{
var parameters = new double[2];
var ellipse = arcSegment.GetEllipse(_Sketch.Points, parameters);
if (ellipse == null)
{
return(false);
}
double rotAngle = ellipse.XAxis().Angle(new Ax2d(ellipse.Location(), Dir2d.DX));
double length = parameters[1] - parameters[0];
var size = length < Math.PI ? SvgArcSize.Small : SvgArcSize.Large;
var sense = ellipse.Axis().Sense() > 0;
if (start == _Sketch.Points[arcSegment.EndPoint])
{
sense = !sense; // Sense was inverted by interchanged start/end point
}
var sweep = sense ? SvgArcSweep.Positive : SvgArcSweep.Negative;
var svgSegment = new SvgPathSegArc(start, ellipse.MajorRadius(), ellipse.MinorRadius(), rotAngle.ToDeg(), size, sweep, end);
_CurrentPath.Segments.Add(svgSegment);
return(true);
}
//--------------------------------------------------------------------------------------------------
void _FinishPivotPoint(ToolAction toolAction)
{
if (!(toolAction is PointAction pointAction))
{
return;
}
_ClearPreviews();
_Plane = WorkspaceController.Workspace.WorkingPlane;
_PointPlane1 = pointAction.PointOnPlane;
pointAction.Stop();
pointAction = new PointAction(this);
pointAction.Previewed += _PreviewBaseRect;
pointAction.Finished += _FinishBaseRect;
if (!WorkspaceController.StartToolAction(pointAction))
{
return;
}
_CurrentPhase = Phase.BaseRect;
StatusText = "Select opposite corner point.";
_MultiValueHudElement = WorkspaceController.HudManager?.CreateElement <MultiValueHudElement>(this);
if (_MultiValueHudElement != null)
{
_MultiValueHudElement.Label1 = "Length:";
_MultiValueHudElement.Units1 = ValueUnits.Length;
_MultiValueHudElement.Label2 = "Width:";
_MultiValueHudElement.Units2 = ValueUnits.Length;
_MultiValueHudElement.MultiValueEntered += _MultiValueEntered;
}
}
//--------------------------------------------------------------------------------------------------
bool _AddLineSegment(SketchSegmentLine segment, Pnt2d start, Pnt2d end)
{
var svgSegment = new SvgPathSegLineto(start, end);
_CurrentPath.Segments.Add(svgSegment);
return(true);
}
//--------------------------------------------------------------------------------------------------
void _SetEndPoint(Pnt2d point, int mergeCandidateIndex)
{
// End point
if (_Points[0].Distance(point) < 0.001)
{
// Minimum length not met
_PointAction.Reset();
return;
}
_Points[1] = point;
_Points[2] = point;
_MergePointIndices[2] = mergeCandidateIndex;
_Segment = new SketchSegmentBezier(0, 1, 2);
_Element = new SketchEditorSegmentElement(_SketchEditorTool, -1, _Segment, _SketchEditorTool.Transform, _SketchEditorTool.Sketch.Plane);
_Element.IsCreating = true;
_Element.OnPointsChanged(_Points, null);
_HintLine.Remove();
_HintLine = null;
_SketchEditorTool.WorkspaceController.HudManager?.RemoveElement(_ValueHudElement);
_ValueHudElement = null;
_SketchEditorTool.StatusText = "Select control point for line.";
_PointAction.Reset();
pointsFinished++;
_SketchEditorTool.WorkspaceController.Invalidate();
_SketchEditorTool.WorkspaceController.UpdateSelection();
}
public static IEnumerable <SvgPathSegment> Create(SvgPathSegment lastSegment, string commandString, SvgConverter conv)
{
if (!conv.TrySplitValues(commandString.Substring(1), out var values, false))
{
yield break;
}
int valuePos = 0;
while (valuePos < values.Length)
{
var start = new Pnt2d();
if (lastSegment != null)
{
start = lastSegment.End;
}
double rx = values[0] * conv.Scale;
double ry = values[1] * conv.Scale;
double angle = values[2];
SvgArcSize size = values[3] == 0 ? SvgArcSize.Small : SvgArcSize.Large;
SvgArcSweep sweep = values[4] == 0 ? SvgArcSweep.Negative : SvgArcSweep.Positive;
Pnt2d end = new Pnt2d(values[5] * conv.Scale, values[6] * conv.Scale);
if (char.IsLower(commandString[0]))
{
end += start;
}
valuePos += 7;
lastSegment = new SvgPathSegArc(start, rx, ry, angle, size, sweep, end);
yield return(lastSegment);
}
}
//--------------------------------------------------------------------------------------------------
void _SetSecondPoint(Pnt2d point, int mergeCandidateIndex)
{
if (Math.Abs(_Points[0].X - point.X) < 0.001 ||
Math.Abs(_Points[0].Y - point.Y) < 0.001)
{
// Minimum length not met
_PointAction.Reset();
return;
}
_PointAction.Stop();
_UpdateCornerPoints(point);
_MergePointIndices[1] = -1;
_MergePointIndices[2] = mergeCandidateIndex;
_MergePointIndices[3] = -1;
var constraints = new SketchConstraintPerpendicular[4];
constraints[0] = new SketchConstraintPerpendicular(0, 1);
constraints[1] = new SketchConstraintPerpendicular(1, 2);
constraints[2] = new SketchConstraintPerpendicular(2, 3);
constraints[3] = new SketchConstraintPerpendicular(3, 0);
_SketchEditorTool.FinishSegmentCreation(_Points, _MergePointIndices, _Segments, constraints);
}
//--------------------------------------------------------------------------------------------------
void _ImportArc(DxfDomCircle dxfCircle)
{
Pnt2d center = dxfCircle.CenterPoint;
double radius = dxfCircle.Radius;
if (radius <= 0)
{
return;
}
var startParam = dxfCircle.StartAngle.ToRad();
var endParam = dxfCircle.EndAngle.ToRad();
if (endParam < startParam)
{
endParam += 2 * Math.PI;
}
var geomCircle = new Geom2d_Circle(new Ax2d(center, Dir2d.DX), radius);
var startIndex = _AddPoint(geomCircle.Value(startParam));
var endIndex = _AddPoint(geomCircle.Value(endParam));
var rimIndex = _AddPoint(geomCircle.Value(startParam.Lerp(endParam, 0.5)), false);
if (startIndex != endIndex)
{
_Segments.Add(new SketchSegmentArc(startIndex, endIndex, rimIndex));
}
}
//--------------------------------------------------------------------------------------------------
public override bool OnMouseDown(MouseEventData data)
{
if (data.DetectedEntities.Count == 0)
{
double u = 0, v = 0;
if (Gizmo.IsPartDetected(AIS_TranslationGizmo2D.Part.Part_Plane))
{
_MoveConstraintX = false;
_MoveConstraintY = false;
_Moving = true;
}
else if (Gizmo.IsPartDetected(AIS_TranslationGizmo2D.Part.Part_XAxis))
{
_MoveConstraintX = false;
_MoveConstraintY = true;
_Moving = true;
}
else if (Gizmo.IsPartDetected(AIS_TranslationGizmo2D.Part.Part_YAxis))
{
_MoveConstraintX = true;
_MoveConstraintY = false;
_Moving = true;
}
if (_Moving)
{
ElSLib.Parameters(_Sketch.Plane, data.PointOnPlane, ref u, ref v);
_MoveStartPoint = new Pnt2d(u, v);
return(true);
}
}
return(base.OnMouseDown(data));
}
//--------------------------------------------------------------------------------------------------
bool _CalcArcRimPoints(Pnt2d endPoint)
{
// Project end point on circle
var startPoint = _Points[0];
if ((startPoint.Distance(endPoint) <= 0) || (endPoint.Distance(_CenterPoint) <= 0) || (startPoint.Distance(_CenterPoint) <= 0))
{
return(false);
}
var xAxis = new Ax2d(_CenterPoint, new Dir2d(new Vec2d(_CenterPoint, startPoint)));
var radius = _CenterPoint.Distance(startPoint);
var circ = new gp_Circ2d(xAxis, radius, _ArcDirection);
var projEndPoint = new Geom2dAPI_ProjectPointOnCurve(endPoint, new Geom2d_Circle(circ)).NearestPoint();
// Check if we should toggle the direction
var endParameter = ElCLib.Parameter(circ, projEndPoint);
// If the last parameter was very small (~PI/2), and the current is very high (~PI*1.5), toggle direction
if (((_LastEndParameter < 1) && (endParameter > 5)) ||
((endParameter < 1) && (_LastEndParameter > 5)))
{
_ArcDirection = !_ArcDirection;
circ = new gp_Circ2d(xAxis, radius, _ArcDirection);
endParameter = ElCLib.Parameter(circ, projEndPoint);
}
_LastEndParameter = endParameter;
// Calc rim point
var rimPoint = ElCLib.Value(endParameter / 2, circ);
_Points[1] = projEndPoint;
_Points[2] = rimPoint;
return(true);
}
//--------------------------------------------------------------------------------------------------
internal override bool Read(XmlReader reader, SvgConverter conv)
{
bool res = false;
string sx1 = reader.GetAttribute("x1") ?? "0";
string sy1 = reader.GetAttribute("y1") ?? "0";
string sx2 = reader.GetAttribute("x2") ?? "0";
string sy2 = reader.GetAttribute("y2") ?? "0";
if (!base.Read(reader, conv))
{
return(false);
}
if (!(sx1.IsNullOrEmpty() && sy1.IsNullOrEmpty() && sx2.IsNullOrEmpty() && sy2.IsNullOrEmpty()))
{
Start = new Pnt2d(conv.FromSvgLength(sx1), conv.FromSvgLength(sy1));
conv.Transform(ref Start);
End = new Pnt2d(conv.FromSvgLength(sx1), conv.FromSvgLength(sy1));
conv.Transform(ref End);
res = true;
}
conv.PopTransform();
return(res);
}
//--------------------------------------------------------------------------------------------------
void _AddBSplineCurve(Geom2d_BSplineCurve bspline, double first, double last)
{
// Cut spline
bspline = Geom2dConvert.SplitBSplineCurve(bspline, first, last, 0.00001);
if (_Document.Flags.HasFlag(DxfFlags.ExportSplineAsPolygon))
{
_AddPolygonCurve(bspline);
return;
}
if (bspline.Degree() > 3)
{
// 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, _Precision * 10.0, continuity, 100, 3);
if (!(converter.IsDone() && converter.HasResult()))
{
Messages.Warning("DxfExporter: BSpline curve has an undecreasable degree of " + bspline.Degree() + ".");
return;
}
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);
}
var flags = DxfDomSpline.SplineFlags.None;
if (bspline.IsRational())
{
flags = flags.Added(DxfDomSpline.SplineFlags.IsRational);
}
var entity = new DxfDomSpline(_CurrentLayer, bspline.Degree(), knots, points, weights, flags);
_Document.Entities.Add(entity);
}
//--------------------------------------------------------------------------------------------------
void _UpdateCornerPoints(Pnt2d second)
{
var first = _Points[0];
_Points[1] = new Pnt2d(first.X, second.Y);
_Points[2] = new Pnt2d(second.X, second.Y);
_Points[3] = new Pnt2d(second.X, first.Y);
}
//--------------------------------------------------------------------------------------------------
void _PointActionOnConstraintPoint(SketchPointAction sender, ref Pnt2d point)
{
if (_PointsCompleted == 2)
{
_CalcArcRimPoints(point);
point = _Points[1];
}
}
public void Scale()
{
var p2 = new Pnt2d(1, 2);
Assert.AreEqual(new Pnt2d(0, 2), p2.Scaled(new Pnt2d(2, 2), 2));
p2.Scale(new Pnt2d(2, 2), 2);
Assert.AreEqual(new Pnt2d(0, 2), p2);
}
public void TranslatePnt2dPnt2d()
{
var p2 = new Pnt2d(1, 2);
Assert.AreEqual(new Pnt2d(0, 2), p2.Translated(new Pnt2d(2, 2), new Pnt2d(1, 2)));
p2.Translate(new Pnt2d(2, 2), new Pnt2d(1, 2));
Assert.AreEqual(new Pnt2d(0, 2), p2);
}
public void MirrorPnt2d()
{
var p2 = new Pnt2d(1, 2);
Assert.AreEqual(new Pnt2d(3, 2), p2.Mirrored(new Pnt2d(2, 2)));
p2.Mirror(new Pnt2d(2, 2));
Assert.AreEqual(new Pnt2d(3, 2), p2);
}
//--------------------------------------------------------------------------------------------------
void _SetSecondPoint(Pnt2d second)
{
var first = _Points[0];
_Points[1] = new Pnt2d(first.X, second.Y);
_Points[2] = new Pnt2d(second.X, second.Y);
_Points[3] = new Pnt2d(second.X, first.Y);
}
public void Distance()
{
var p1 = new Pnt2d(1, 2);
var p2 = new Pnt2d(4, 5);
Assert.AreEqual(18, p1.SquareDistance(p2));
Assert.AreEqual(Math.Sqrt(18), p1.Distance(p2));
}
