private Polyline2D method_24(DxfVertex2DCollection points)
{
bool closed = this.Closed;
int count = points.Count;
Polyline2D polyline2D = new Polyline2D(count, closed);
if (count > 0)
{
DxfVertex2D dxfVertex2D = points[0];
polyline2D.Add(dxfVertex2D.Position);
for (int index = 1; index < count; ++index)
{
DxfVertex2D point = points[index];
if (!(dxfVertex2D.Position == point.Position))
{
polyline2D.Add(point.Position);
dxfVertex2D = point;
}
}
if (closed && count > 1 && polyline2D[0] == polyline2D[polyline2D.Count - 1])
{
polyline2D.RemoveAt(polyline2D.Count - 1);
}
}
return(polyline2D);
}
private static void smethod_11(
Polyline2D polyline,
Point2D p0,
Point2D p1,
Point2D p2,
Point2D p3,
double epsilonSquared)
{
Vector2D dp01 = p1 - p0;
Vector2D dp12 = p2 - p1;
Vector2D dp23 = p3 - p2;
if (ShapeTool.smethod_10(dp01, dp12, dp23, p3 - p0, epsilonSquared))
{
polyline.Add(p1);
polyline.Add(p2);
polyline.Add(p3);
}
else
{
Point2D p1_1 = p0 + 0.5 * dp01;
Point2D point2D1 = p1 + 0.5 * dp12;
Point2D p2_1 = p2 + 0.5 * dp23;
Vector2D vector2D1 = point2D1 - p1_1;
Vector2D vector2D2 = p2_1 - point2D1;
Point2D p2_2 = p1_1 + 0.5 * vector2D1;
Point2D p1_2 = point2D1 + 0.5 * vector2D2;
Vector2D vector2D3 = p1_2 - p2_2;
Point2D point2D2 = p2_2 + 0.5 * vector2D3;
ShapeTool.smethod_11(polyline, p0, p1_1, p2_2, point2D2, epsilonSquared);
ShapeTool.smethod_11(polyline, point2D2, p1_2, p2_1, p3, epsilonSquared);
}
}
private static List <Polyline2D> smethod_7(
Polyline2D[] borders,
Point2D reference,
Vector2D offset,
Vector2D direction,
double[] dashPattern,
bool fillInterior)
{
IList <Segment2D[]> segment2DArrayList = (IList <Segment2D[]>)Class811.smethod_8(borders, reference, offset, direction, dashPattern, fillInterior);
List <Polyline2D> polyline2DList = new List <Polyline2D>();
foreach (Segment2D[] segment2DArray in (IEnumerable <Segment2D[]>)segment2DArrayList)
{
foreach (Segment2D segment2D in segment2DArray)
{
Polyline2D polyline2D = new Polyline2D();
polyline2D.Add(new Point2D(segment2D.Start.X, segment2D.Start.Y));
if (segment2D.Start != segment2D.End)
{
polyline2D.Add(new Point2D(segment2D.End.X, segment2D.End.Y));
}
polyline2DList.Add(polyline2D);
}
}
return(polyline2DList);
}
private static void smethod_7(
Polyline2D polyline,
Point2D p0,
Point2D p1,
Point2D p2,
double epsilonSquared)
{
Vector2D dp02 = p2 - p0;
Vector2D dp01 = p1 - p0;
Vector2D dp12 = p2 - p1;
if (ShapeTool.smethod_9(dp01, dp12, dp02, epsilonSquared))
{
polyline.Add(p1);
polyline.Add(p2);
}
else
{
Point2D p1_1 = p0 + 0.5 * dp01;
Point2D p1_2 = p1 + 0.5 * dp12;
Vector2D vector2D = p1_2 - p1_1;
Point2D point2D = p1_1 + 0.5 * vector2D;
ShapeTool.smethod_7(polyline, p0, p1_1, point2D, epsilonSquared);
ShapeTool.smethod_7(polyline, point2D, p1_2, p2, epsilonSquared);
}
}
protected override Polyline2D vmethod_1(ns9.Class107 edge)
{
Point3D location1 = edge.StartVertex.Point.Location;
Point3D location2 = edge.EndVertex.Point.Location;
Polyline2D polyline2D = new Polyline2D(2);
Interface26 pointParamMapper = this.PointParamMapper;
polyline2D.Add(pointParamMapper.imethod_0(location1));
polyline2D.Add(pointParamMapper.imethod_0(location2));
return(polyline2D);
}
public Polyline2D ToPolyline2D()
{
Polyline2D polyline2D = new Polyline2D(this.Count, this.Closed);
foreach (Vector4D vector4D in (List <Vector4D>) this)
{
polyline2D.Add(vector4D.ToPoint2D());
}
return(polyline2D);
}
protected override Polyline2D vmethod_1(ns9.Class107 edge)
{
Point3D location1 = edge.StartVertex.Point.Location;
Point3D location2 = edge.EndVertex.Point.Location;
Polyline2D polyline2D = new Polyline2D(2);
if (location1 == location2 && this.double_2 != 0.0)
{
Point3D point3D1 = new Point3D(this.class247_0.Position);
double length = this.class247_0.MajorAxis.GetLength();
Vector3D normal = this.class247_0.Normal;
normal.Normalize();
Point3D point3D2 = point3D1 - normal * (length / System.Math.Tan(this.double_2));
if ((point3D2 - location1).GetLength() < 0.0001 * length)
{
double x1 = Vector3D.DotProduct(point3D2 - point3D1, normal) / System.Math.Cos(this.double_2);
if (this.class690_0.Value)
{
double x2 = -x1;
polyline2D.Add(new Point2D(x2, 2.0 * System.Math.PI));
polyline2D.Add(new Point2D(x2, 4.0 * System.Math.PI / 3.0));
polyline2D.Add(new Point2D(x2, 2.0 * System.Math.PI / 3.0));
polyline2D.Add(new Point2D(x2, 0.0));
}
else
{
polyline2D.Add(new Point2D(x1, 0.0));
polyline2D.Add(new Point2D(x1, 2.0 * System.Math.PI / 3.0));
polyline2D.Add(new Point2D(x1, 4.0 * System.Math.PI / 3.0));
polyline2D.Add(new Point2D(x1, 2.0 * System.Math.PI));
}
return(polyline2D);
}
}
Interface26 pointParamMapper = this.PointParamMapper;
polyline2D.Add(pointParamMapper.imethod_0(location1));
polyline2D.Add(pointParamMapper.imethod_0(location2));
return(polyline2D);
}
public IShape2D ToShape2D(Matrix4D matrix)
{
Polyline2DCollection polyline2Dcollection = new Polyline2DCollection(this.ilist_0.Count);
foreach (Polyline4D polyline4D in (IEnumerable <Polyline4D>) this.ilist_0)
{
Polyline2D polyline2D = new Polyline2D(polyline4D.Count, polyline4D.Closed);
foreach (Vector4D vector in (List <Vector4D>)polyline4D)
{
polyline2D.Add(matrix.TransformToPoint2D(vector));
}
polyline2Dcollection.Add(polyline2D);
}
return((IShape2D)polyline2Dcollection);
}
private FlatShape4D method_0(Matrix4D transform, Matrix4D inverse)
{
GeneralShape2D generalShape2D = new GeneralShape2D();
foreach (Polyline4D polyline4D in (IEnumerable <Polyline4D>) this.ilist_0)
{
Polyline2D polyline2D = new Polyline2D(polyline4D.Closed);
foreach (Vector4D point in (List <Vector4D>)polyline4D)
{
polyline2D.Add(inverse.TransformTo2D(point));
}
generalShape2D.Append((IShape2D)polyline2D, false);
}
return(new FlatShape4D((IShape2D)generalShape2D, transform, this.IsFilled));
}
private Polyline2D method_30(int degree, GraphicsConfig config)
{
int count1 = this.dxfVertex2DCollection_0.Count;
if (count1 <= degree)
{
return(this.method_18());
}
BSplineCurve2D bsplineCurve2D = new BSplineCurve2D(degree);
bsplineCurve2D.AddKnots(BSplineD.CreateDefaultKnotValues(degree, count1, this.Closed));
foreach (DxfVertex2D dxfVertex2D in (DxfHandledObjectCollection <DxfVertex2D>) this.dxfVertex2DCollection_0)
{
bsplineCurve2D.ControlPoints.AddLast(dxfVertex2D.Position);
}
if (this.Closed)
{
for (int index = 0; index < degree; ++index)
{
bsplineCurve2D.ControlPoints.AddLast(this.dxfVertex2DCollection_0[index].Position);
}
double u = 0.0;
LinkedListNode <double> previousKnot1 = bsplineCurve2D.Knots.First;
LinkedListNode <WW.Math.Point2D> previousPoint1 = bsplineCurve2D.ControlPoints.First;
for (int index = 0; index < degree; ++index)
{
previousKnot1 = previousKnot1.Next;
}
for (int index = 0; index < degree; ++index)
{
bsplineCurve2D.InsertKnot(previousKnot1, previousPoint1, u);
previousKnot1 = previousKnot1.Next;
previousPoint1 = previousPoint1.Next;
}
double count2 = (double)this.dxfVertex2DCollection_0.Count;
LinkedListNode <double> previousKnot2 = bsplineCurve2D.Knots.Last.Previous;
LinkedListNode <WW.Math.Point2D> previousPoint2 = bsplineCurve2D.ControlPoints.Last;
for (int index = 0; index < degree; ++index)
{
previousKnot2 = previousKnot2.Previous;
previousPoint2 = previousPoint2.Previous;
}
for (int index = 0; index < degree; ++index)
{
bsplineCurve2D.InsertKnot(previousKnot2, previousPoint2, count2);
previousKnot2 = previousKnot2.Next;
previousPoint2 = previousPoint2.Next;
}
for (int index = 0; index < degree; ++index)
{
bsplineCurve2D.ControlPoints.RemoveFirst();
bsplineCurve2D.Knots.RemoveFirst();
bsplineCurve2D.ControlPoints.RemoveLast();
bsplineCurve2D.Knots.RemoveLast();
}
}
double epsilon = config.ShapeFlattenEpsilon;
if (epsilon < 0.0)
{
Bounds2D bounds2D = new Bounds2D();
foreach (DxfVertex2D dxfVertex2D in (DxfHandledObjectCollection <DxfVertex2D>) this.dxfVertex2DCollection_0)
{
bounds2D.Update(dxfVertex2D.Position);
}
epsilon = !bounds2D.Initialized ? 0.01 : -epsilon *bounds2D.Delta.GetLength();
}
bsplineCurve2D.RefineKnots(epsilon, 20);
Polyline2D polyline2D = new Polyline2D(this.Closed);
foreach (WW.Math.Point2D controlPoint in bsplineCurve2D.ControlPoints)
{
polyline2D.Add(controlPoint);
}
return(polyline2D);
}
public static Polyline2DCollection GetFlattened(
IShape2D shape,
double epsilon)
{
if (epsilon == 0.0)
{
epsilon = -0.01;
}
Polyline2DCollection polyline2Dcollection = new Polyline2DCollection();
if (epsilon < 0.0)
{
Bounds2D bounds = ShapeTool.GetBounds(shape);
if (!bounds.Initialized)
{
return(polyline2Dcollection);
}
epsilon *= -System.Math.Max(bounds.Delta.X, bounds.Delta.Y);
}
epsilon *= epsilon;
ISegment2DIterator iterator = shape.CreateIterator();
if (iterator.MoveNext())
{
Point2D[] points = new Point2D[3];
Polyline2D polyline = (Polyline2D)null;
do
{
switch (iterator.Current(points, 0))
{
case SegmentType.MoveTo:
polyline = new Polyline2D();
polyline2Dcollection.Add(polyline);
polyline.Add(points[0]);
break;
case SegmentType.LineTo:
polyline.Add(points[0]);
break;
case SegmentType.QuadTo:
ShapeTool.smethod_7(polyline, polyline[polyline.Count - 1], points[0], points[1], epsilon);
break;
case SegmentType.CubicTo:
ShapeTool.smethod_11(polyline, polyline[polyline.Count - 1], points[0], points[1], points[2], epsilon);
break;
case SegmentType.Close:
polyline.Closed = true;
if (polyline.Count > 1 && polyline[polyline.Count - 1] == polyline[0])
{
polyline.RemoveAt(polyline.Count - 1);
break;
}
break;
}
}while (iterator.MoveNext());
}
return(polyline2Dcollection);
}
