internal static Polyline2D2N smethod_0(
IVertex2DCollection vertices,
GraphicsConfig config,
bool closed)
{
int count = vertices.Count;
if (count == 0)
{
return(new Polyline2D2N(0));
}
IVertex2D vertex = vertices.GetIVertex2D(0);
Polyline2D2N polyline = new Polyline2D2N(count, closed);
for (int index = 1; index < count; ++index)
{
IVertex2D ivertex2D = vertices.GetIVertex2D(index);
Class639.Class641.smethod_1(config, polyline, vertex, ivertex2D);
vertex = ivertex2D;
}
if (closed)
{
Class639.Class641.smethod_1(config, polyline, vertex, vertices.GetIVertex2D(0));
}
else
{
Point2D2N point2D2N = new Point2D2N(vertex.Position);
polyline.Add(point2D2N);
}
return(polyline);
}
private WW.Cad.Drawing.Polyline2D2N method_29(int power, int noOfSplineLineParts)
{
WW.Cad.Drawing.Polyline2D2N polyline2D2N = new WW.Cad.Drawing.Polyline2D2N();
int count = this.dxfVertex2DCollection_0.Count;
if (count <= power)
{
return(this.method_21());
}
BSplineD bsplineD = new BSplineD(power, count, this.Closed);
double[] result = new double[power + 1];
double maxU = bsplineD.MaxU;
int num1 = noOfSplineLineParts + 1;
double num2 = maxU / (double)(num1 - 1);
double[,] derivatives = new double[2, power + 1];
Point2D2N point2D2N1 = (Point2D2N)null;
int num3 = 0;
double u = 0.0;
while (num3 < num1)
{
int knotSpanIndex = bsplineD.GetKnotSpanIndex(u);
bsplineD.EvaluateBasisFunctions(knotSpanIndex, u, result);
WW.Math.Point2D zero1 = WW.Math.Point2D.Zero;
for (int index = 0; index <= power; ++index)
{
DxfVertex2D dxfVertex2D = this.dxfVertex2DCollection_0[(knotSpanIndex - power + index) % count];
zero1 += result[index] * new Vector2D(dxfVertex2D.Position);
}
bsplineD.GetDerivativesBasisFunctions(knotSpanIndex, u, 1, derivatives);
Vector2D zero2 = Vector2D.Zero;
for (int index = 0; index <= power; ++index)
{
zero2 += (Vector2D)this.dxfVertex2DCollection_0[(knotSpanIndex - power + index) % count].Position * derivatives[1, index];
}
Vector2D unit = new Vector2D(-zero2.Y, zero2.X).GetUnit();
Point2D2N point2D2N2 = new Point2D2N(zero1)
{
IsInterpolatedPoint = true
};
point2D2N2.StartNormal = unit;
if (point2D2N1 != null)
{
point2D2N1.EndNormal = unit;
}
polyline2D2N.Add(point2D2N2);
point2D2N1 = point2D2N2;
++num3;
u += num2;
}
if (this.Closed)
{
polyline2D2N[num1 - 1].EndNormal = polyline2D2N[0].StartNormal;
}
return(polyline2D2N);
}
private static void smethod_2(Polyline2D2N polyline, IVertex2D vertex, IVertex2D nextVertex)
{
Vector2D vector2D = nextVertex.Position - vertex.Position;
Point2D2N point2D2N = new Point2D2N(vertex.Position)
{
StartNormal = new Vector2D(-vector2D.Y, vector2D.X).GetUnit()
};
point2D2N.EndNormal = point2D2N.StartNormal;
polyline.Add(point2D2N);
}
private static Vector2D smethod_3(
GraphicsConfig config,
Polyline2D2N polyline,
IVertex2D vertex,
IVertex2D nextVertex)
{
Vector2D vector2D1 = nextVertex.Position - vertex.Position;
double length = vector2D1.GetLength();
double num1 = 4.0 * System.Math.Atan(vertex.Bulge);
double num2 = length / (2.0 * System.Math.Abs(System.Math.Sin(num1 * 0.5)));
Vector2D vector2D2 = vector2D1;
vector2D2.Normalize();
double num3 = (double)System.Math.Sign(vertex.Bulge);
Vector2D vector2D3 = new Vector2D(-vector2D2.Y, vector2D2.X) * num3;
Point2D point2D = (Point2D)(((Vector2D)nextVertex.Position + (Vector2D)vertex.Position) * 0.5) + vector2D3 * System.Math.Cos(num1 * 0.5) * num2;
Vector2D vector2D4 = vertex.Position - point2D;
double num4 = System.Math.Atan2(vector2D4.Y, vector2D4.X);
Vector2D vector2D5 = nextVertex.Position - point2D;
double num5 = System.Math.Atan2(vector2D5.Y, vector2D5.X);
double num6 = num4;
double num7 = num3 * (2.0 * System.Math.PI) / (double)config.NoOfArcLineSegments;
while (num5 < num4)
{
num5 += 2.0 * System.Math.PI;
}
int num8 = (int)System.Math.Ceiling(vertex.Bulge >= 0.0 ? System.Math.Abs(num5 - num4) / num7 : System.Math.Abs((2.0 * System.Math.PI - (num5 - num4)) / num7));
double x1 = System.Math.Cos(num6);
double y1 = System.Math.Sin(num6);
Point2D2N point2D2N1 = new Point2D2N(point2D + new Vector2D(x1 * num2, y1 * num2));
point2D2N1.StartNormal = -num3 * new Vector2D(x1, y1);
polyline.Add(point2D2N1);
double num9 = num6 + num7;
for (int index = 1; index < num8; ++index)
{
double x2 = System.Math.Cos(num9);
double y2 = System.Math.Sin(num9);
Vector2D vector2D6 = -num3 * new Vector2D(x2, y2);
point2D2N1.EndNormal = vector2D6;
Point2D2N point2D2N2 = new Point2D2N(point2D + new Vector2D(x2 * num2, y2 * num2));
point2D2N2.IsInterpolatedPoint = true;
point2D2N2.StartNormal = vector2D6;
polyline.Add(point2D2N2);
num9 += num7;
point2D2N1 = point2D2N2;
}
point2D2N1.EndNormal = -num3 * new Vector2D(System.Math.Cos(num5), System.Math.Sin(num5));
return(vector2D1);
}
private static void smethod_9(
DxfEntity entity,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polyline2D,
Interface41 transformer,
Polyline4D polyline4DBottom,
Polyline4D polyline4DTop)
{
int count = polyline2D.Count;
int startVertexIndex = polyline2D.Closed ? count - 1 : 0;
for (int endVertexIndex = polyline2D.Closed ? 0 : 1; endVertexIndex < count; ++endVertexIndex)
{
Point2D2N point2D2N1 = polyline2D[startVertexIndex];
Point2D2N point2D2N2 = point2D2N1;
int num1 = endVertexIndex;
while (endVertexIndex < count)
{
Point2D2N point2D2N3 = polyline2D[endVertexIndex];
if (!(point2D2N1.EndNormal != point2D2N3.StartNormal))
{
++endVertexIndex;
point2D2N1 = point2D2N3;
}
else
{
break;
}
}
if (endVertexIndex == count)
{
endVertexIndex = count - 1;
}
Vector3D[] vector3DArray = new Vector3D[endVertexIndex - num1 + 2];
vector3DArray[0] = transformer.Transform((Vector3D)point2D2N2.StartNormal);
vector3DArray[1] = transformer.Transform((Vector3D)point2D2N2.EndNormal);
int num2 = num1;
int index1 = 2;
while (num2 < endVertexIndex)
{
int index2 = num2 >= count ? 0 : num2;
vector3DArray[index1] = transformer.Transform((Vector3D)polyline2D[index2].EndNormal);
++num2;
++index1;
}
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4DBottom, (IList <Vector4D>)polyline4DTop, (IList <Vector3D>)vector3DArray, startVertexIndex, endVertexIndex);
startVertexIndex = endVertexIndex;
}
}
public static double GetLength(Polyline2D2N polyline, ILineTypeScaler lineTypeScaler)
{
double num = 0.0;
if (polyline.Count > 1)
{
Point2D2N point2D2N1 = polyline[0];
for (int index = 1; index < polyline.Count; ++index)
{
Point2D2N point2D2N2 = polyline[index];
num += lineTypeScaler.GetScaledLength(point2D2N2.Position - point2D2N1.Position);
point2D2N1 = point2D2N2;
}
if (polyline.Closed)
{
num += lineTypeScaler.GetScaledLength(polyline[0].Position - point2D2N1.Position);
}
}
return(num);
}
internal static void smethod_11(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polylineA,
WW.Cad.Drawing.Polyline2D2N polylineB,
Matrix4D transform,
Vector3D normal,
bool isSurface)
{
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(transform);
if (polylineA.Count == 1)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineB[0];
if (point2D2N1.Position == point2D2N2.Position)
{
graphicsFactory.CreatePoint(transformer.Transform(point2D2N1.Position));
}
else
{
graphicsFactory.CreateSegment(transformer.Transform(point2D2N1.Position), transformer.Transform(point2D2N2.Position));
}
}
else if (polylineA.Count == 2)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineA[1];
Point2D2N point2D2N3 = polylineB[0];
Point2D2N point2D2N4 = polylineB[1];
Vector4D[] vector4DArray = new Vector4D[4] {
transformer.Transform(point2D2N1.Position), transformer.Transform(point2D2N2.Position), transformer.Transform(point2D2N4.Position), transformer.Transform(point2D2N3.Position)
};
if (isSurface)
{
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray, (IList <bool>)null);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray, true);
}
}
else
{
int count = polylineA.Count;
bool closed = polylineA.Closed;
Polyline4D polyline4D1 = DxfUtil.smethod_47(polylineA, transformer);
Polyline4D polyline4D2 = DxfUtil.smethod_47(polylineB, transformer);
if (isSurface)
{
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4D1, (IList <Vector4D>)polyline4D2, normal, closed);
}
else
{
int index1 = 0;
int num = 1;
if (closed)
{
index1 = count - 1;
num = 0;
}
Vector4D start = polyline4D1[index1];
Vector4D end = polyline4D2[index1];
for (int index2 = num; index2 < count; ++index2)
{
Vector4D vector4D1 = polyline4D1[index2];
Vector4D vector4D2 = polyline4D2[index2];
graphicsFactory.CreateSegment(start, end);
start = vector4D1;
end = vector4D2;
}
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D1, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D2, closed);
}
}
}
internal static void smethod_8(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polylineA,
WW.Cad.Drawing.Polyline2D2N polylineB,
bool isSurface,
Matrix4D transform,
Vector3D normal,
double extrusion)
{
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(transform);
Vector3D vector3D = transformer.Transform(new Vector3D(0.0, 0.0, extrusion));
Vector4D vector4D1 = (Vector4D)vector3D;
if (polylineA.Count == 1)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineB[0];
if (point2D2N1.Position == point2D2N2.Position)
{
Vector4D start = transformer.Transform((WW.Math.Point3D)point2D2N1.Position);
graphicsFactory.CreateSegment(start, start + vector4D1);
}
else
{
Vector4D vector4D2 = transformer.Transform(point2D2N1.Position);
Vector4D vector4D3 = transformer.Transform(point2D2N2.Position);
Vector4D[] vector4DArray = new Vector4D[4] {
vector4D2, vector4D3, vector4D3 + vector4D1, vector4D2 + vector4D1
};
if (isSurface)
{
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray, (IList <bool>)null);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray, true);
}
}
}
else if (polylineA.Count == 2)
{
Point2D2N point2D2N1 = polylineA[0];
Point2D2N point2D2N2 = polylineA[1];
Point2D2N point2D2N3 = polylineB[0];
Point2D2N point2D2N4 = polylineB[1];
Vector4D vector4D2 = transformer.Transform(new WW.Math.Point3D(point2D2N1.Position, 0.0));
Vector4D vector4D3 = transformer.Transform(new WW.Math.Point3D(point2D2N2.Position, 0.0));
Vector4D vector4D4 = transformer.Transform(new WW.Math.Point3D(point2D2N3.Position, 0.0));
Vector4D vector4D5 = transformer.Transform(new WW.Math.Point3D(point2D2N4.Position, 0.0));
Vector4D vector4D6 = vector4D2 + vector4D1;
Vector4D vector4D7 = vector4D3 + vector4D1;
Vector4D vector4D8 = vector4D4 + vector4D1;
Vector4D vector4D9 = vector4D5 + vector4D1;
Vector4D[] vector4DArray1 = new Vector4D[4] {
vector4D2, vector4D3, vector4D5, vector4D4
};
Vector4D[] vector4DArray2 = new Vector4D[4] {
vector4D6, vector4D7, vector4D9, vector4D8
};
if (isSurface)
{
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray1, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>)vector4DArray2, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D2,
vector4D4,
vector4D8,
vector4D6
}, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D3,
vector4D5,
vector4D9,
vector4D7
}, (IList <bool>)null);
graphicsFactory.CreateQuadStrip((IList <Vector4D>) new Vector4D[2]
{
vector4D2,
vector4D3
}, (IList <Vector4D>) new Vector4D[2]
{
vector4D6,
vector4D7
}, (IList <Vector3D>) new Vector3D[2]
{
transformer.Transform(new Vector3D(point2D2N1.StartNormal, 0.0)),
transformer.Transform(new Vector3D(point2D2N1.EndNormal, 0.0))
}, 0, 1);
graphicsFactory.CreateQuadStrip((IList <Vector4D>) new Vector4D[2]
{
vector4D8,
vector4D9
}, (IList <Vector4D>) new Vector4D[2]
{
vector4D4,
vector4D5
}, (IList <Vector3D>) new Vector3D[2]
{
transformer.Transform(new Vector3D(point2D2N3.StartNormal, 0.0)),
transformer.Transform(new Vector3D(point2D2N3.EndNormal, 0.0))
}, 0, 1);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray1, true);
graphicsFactory.CreatePolyline((IList <Vector4D>)vector4DArray2, true);
for (int index = 0; index < 4; ++index)
{
graphicsFactory.CreateSegment(vector4DArray1[index], vector4DArray2[index]);
}
}
}
else
{
int count = polylineA.Count;
int index1 = count - 1;
bool closed = polylineA.Closed;
Polyline4D polyline4DBottom1 = DxfUtil.smethod_47(polylineA, transformer);
Polyline4D polyline4DTop1 = DxfUtil.smethod_47(polylineB, transformer);
Polyline4D polyline4DTop2 = new Polyline4D(count, closed);
Polyline4D polyline4DBottom2 = new Polyline4D(count, closed);
for (int index2 = 0; index2 < count; ++index2)
{
polyline4DTop2.Add(polyline4DBottom1[index2] + vector3D);
polyline4DBottom2.Add(polyline4DTop1[index2] + vector3D);
}
if (isSurface)
{
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4DBottom1, (IList <Vector4D>)polyline4DTop1, normal, closed);
graphicsFactory.CreateQuadStrip((IList <Vector4D>)polyline4DTop2, (IList <Vector4D>)polyline4DBottom2, normal, closed);
if (!closed)
{
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
polyline4DBottom1[0],
polyline4DTop2[0],
polyline4DBottom2[0],
polyline4DTop1[0]
}, (IList <bool>)null);
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
polyline4DBottom1[index1],
polyline4DTop2[index1],
polyline4DBottom2[index1],
polyline4DTop1[index1]
}, (IList <bool>)null);
}
Class940.smethod_9(entity, graphicsFactory, polylineA, transformer, polyline4DBottom1, polyline4DTop2);
Class940.smethod_9(entity, graphicsFactory, polylineB, transformer, polyline4DBottom2, polyline4DTop1);
if (closed)
{
return;
}
Vector4D vector4D2 = polyline4DBottom1[0];
Vector4D vector4D3 = polyline4DTop1[0];
Vector4D vector4D4 = polyline4DTop2[0];
Vector4D vector4D5 = polyline4DBottom2[0];
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D2,
vector4D3,
vector4D5,
vector4D4
}, (IList <bool>)null);
int index2 = count - 1;
Vector4D vector4D6 = polyline4DBottom1[index2];
Vector4D vector4D7 = polyline4DTop1[index2];
Vector4D vector4D8 = polyline4DTop2[index2];
Vector4D vector4D9 = polyline4DBottom2[index2];
graphicsFactory.CreateQuad((IList <Vector4D>) new Vector4D[4]
{
vector4D6,
vector4D7,
vector4D9,
vector4D8
}, (IList <bool>)null);
}
else
{
int index2 = 0;
int num = 1;
if (closed)
{
index2 = count - 1;
num = 0;
}
Vector4D start = polyline4DBottom1[index2];
Vector4D vector4D2 = polyline4DTop1[index2];
Vector4D vector4D3 = polyline4DTop2[index2];
Vector4D end = polyline4DBottom2[index2];
for (int index3 = num; index3 < count; ++index3)
{
Vector4D vector4D4 = polyline4DBottom1[index3];
Vector4D vector4D5 = polyline4DTop1[index3];
Vector4D vector4D6 = polyline4DTop2[index3];
Vector4D vector4D7 = polyline4DBottom2[index3];
graphicsFactory.CreateSegment(start, vector4D2);
graphicsFactory.CreateSegment(vector4D3, end);
graphicsFactory.CreateSegment(start, vector4D3);
graphicsFactory.CreateSegment(vector4D2, end);
start = vector4D4;
vector4D2 = vector4D5;
vector4D3 = vector4D6;
end = vector4D7;
}
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DBottom1, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DTop1, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DTop2, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DBottom2, closed);
}
}
}
internal static void smethod_6(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Cad.Drawing.Polyline2D2N polyline,
bool isSurface,
Matrix4D transform,
Vector3D normal,
double extrusion)
{
Interface41 transformer = (Interface41)context.GetTransformer().Clone();
transformer.SetPreTransform(transform);
Vector3D vector3D = transformer.Transform(new Vector3D(0.0, 0.0, extrusion));
Vector4D vector4D1 = (Vector4D)vector3D;
if (polyline.Count == 1)
{
Point2D2N point2D2N = polyline[0];
Vector4D start = transformer.Transform(point2D2N.Position);
graphicsFactory.CreateSegment(start, start + vector4D1);
}
else if (polyline.Count == 2)
{
Point2D2N point2D2N1 = polyline[0];
Point2D2N point2D2N2 = polyline[1];
Vector4D vector4D2 = transformer.Transform(point2D2N1.Position);
Vector4D vector4D3 = transformer.Transform(point2D2N2.Position);
Vector4D vector4D4 = vector4D2 + vector4D1;
Vector4D vector4D5 = vector4D3 + vector4D1;
if (isSurface)
{
graphicsFactory.CreateQuadStrip((IList <Vector4D>) new Vector4D[2]
{
vector4D2,
vector4D3
}, (IList <Vector4D>) new Vector4D[2]
{
vector4D4,
vector4D5
}, (IList <Vector3D>) new Vector3D[2]
{
transformer.Transform(new Vector3D(point2D2N1.StartNormal, 0.0)),
transformer.Transform(new Vector3D(point2D2N1.EndNormal, 0.0))
}, 0, 1);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>) new Vector4D[4]
{
vector4D2,
vector4D3,
vector4D5,
vector4D4
}, true);
}
}
else
{
int count = polyline.Count;
bool closed = polyline.Closed;
Polyline4D polyline4DBottom = DxfUtil.smethod_47(polyline, transformer);
Polyline4D polyline4DTop = new Polyline4D(count, closed);
for (int index = 0; index < count; ++index)
{
polyline4DTop.Add(polyline4DBottom[index] + vector3D);
}
if (isSurface)
{
Class940.smethod_9(entity, graphicsFactory, polyline, transformer, polyline4DBottom, polyline4DTop);
}
else
{
for (int index = 0; index < count; ++index)
{
Vector4D start = polyline4DBottom[index];
Vector4D end = polyline4DTop[index];
graphicsFactory.CreateSegment(start, end);
}
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DBottom, closed);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4DTop, closed);
}
}
}
