internal static double smethod_3(Polyline4D polyline, Point2D point)
{
int count = polyline.Count;
switch (count)
{
case 0:
return(double.MaxValue);
case 1:
return(((Point2D)polyline[0] - point).GetLengthSquared());
default:
double num1 = double.MaxValue;
int num2 = count + (polyline.Closed ? 1 : 0);
int num3 = count;
Point2D start = (Point2D)polyline[0];
for (int index = 1; index < num2; ++index)
{
Point2D end = (Point2D)polyline[index % num3];
double distanceSquared = new Segment2D(start, end).GetDistanceSquared(point);
if (distanceSquared < num1)
{
num1 = distanceSquared;
}
start = end;
}
return(num1);
}
}
private bool method_6(
Polyline4D polyline,
ArgbColor color,
bool fill,
bool correctForBackgroundColor)
{
if (polyline.Count < 2)
{
return(false);
}
WW.Math.Point2D p = (WW.Math.Point2D)polyline[0];
this.textWriter_0.WriteLine("newpath");
this.method_8(p);
for (int index = 1; index < polyline.Count; ++index)
{
this.method_9((WW.Math.Point2D)polyline[index]);
}
if (polyline.Closed)
{
this.textWriter_0.WriteLine("closepath");
}
this.method_11(color, correctForBackgroundColor);
if (fill)
{
this.textWriter_0.WriteLine(nameof(fill));
}
this.textWriter_0.WriteLine("stroke");
return(true);
}
private bool method_4(Polyline4D polyline)
{
if (polyline.Count < 2)
{
return(false);
}
StringBuilder stringBuilder = this.stack_0.Peek().StringBuilder;
WW.Math.Point2D point2D = this.method_6(polyline[0]);
stringBuilder.Append('M');
stringBuilder.Append(point2D.X.ToString(this.xamlExporter_0.string_2, (IFormatProvider)CultureInfo.InvariantCulture));
stringBuilder.Append(',');
stringBuilder.Append(point2D.Y.ToString(this.xamlExporter_0.string_2, (IFormatProvider)CultureInfo.InvariantCulture));
for (int index = 1; index < polyline.Count; ++index)
{
point2D = this.method_6(polyline[index]);
stringBuilder.Append("L");
stringBuilder.Append(point2D.X.ToString(this.xamlExporter_0.string_2, (IFormatProvider)CultureInfo.InvariantCulture));
stringBuilder.Append(',');
stringBuilder.Append(point2D.Y.ToString(this.xamlExporter_0.string_2, (IFormatProvider)CultureInfo.InvariantCulture));
}
if (polyline.Closed)
{
stringBuilder.Append(" z");
}
return(true);
}
private void method_0(
Polyline4D result,
double startParam,
double endParam,
Class455.Class462 polylineInfo)
{
Polyline3D polyline3D0 = polylineInfo.polyline3D_0;
int count = polyline3D0.Count;
int num1 = (int)System.Math.Floor(startParam);
double parameter1 = startParam - (double)num1;
int num2 = (int)System.Math.Floor(endParam);
double parameter2 = endParam - (double)num2;
if (startParam > endParam)
{
num2 += count;
}
result.Add(this.matrix4D_0.TransformTo4D(Class455.smethod_0(polyline3D0[num1 % count], polyline3D0[(num1 + 1) % count], parameter1)));
for (int index = num1 + 1; index <= num2; ++index)
{
result.Add(this.matrix4D_0.TransformTo4D(polyline3D0[index % count]));
}
if (parameter2 <= 0.0)
{
return;
}
result.Add(this.matrix4D_0.TransformTo4D(Class455.smethod_0(polyline3D0[num2 % count], polyline3D0[(num2 + 1) % count], parameter2)));
}
internal static bool IsInside(Point2D p, Polyline4D polyline)
{
if (polyline == null)
{
return(false);
}
return((0 + Class749.smethod_1(new Ray2D(p, Vector2D.XAxis), polyline)) % 2 == 1);
}
public void CreateImage(
DxfRasterImage rasterImage,
DrawContext.Wireframe drawContext,
Polyline4D clipPolygon,
Polyline4D imageBoundary,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
}
public IList <Polyline4D> Transform(Polyline3D polyline, bool filled)
{
Polyline4D polyline1 = new Polyline4D(polyline.Count, polyline.Closed);
foreach (Point3D point3D in (List <Point3D>)polyline)
{
polyline1.Add((Vector4D)point3D);
}
return(ModelSpaceClippingTransformer.GetTransformed(this.interface32_0.Clip(polyline1, filled), this.matrix4D_0));
}
public void DrawPath(
IShape2D path,
Matrix4D transform,
Color color,
short lineWeight,
bool filled,
bool forText,
double extrusion)
{
if (!path.HasSegments)
{
return;
}
IClippingTransformer transformer = (IClippingTransformer)this.wireframe_0.GetTransformer().Clone();
transformer.SetPreTransform(transform);
if (extrusion == 0.0)
{
IShape4D shape1 = (IShape4D) new FlatShape4D(path, filled);
IShape4D shape2 = transformer.Transform(shape1);
if (shape2.IsEmpty)
{
return;
}
this.iwireframeGraphicsFactory2_0.BeginGeometry(this.dxfEntity_0, this.wireframe_0, this.wireframe_0.GetPlotColor(this.dxfEntity_0, color), false, filled, !filled, true);
this.iwireframeGraphicsFactory2_0.CreateShape(this.dxfEntity_0, shape2);
this.iwireframeGraphicsFactory2_0.EndGeometry();
}
else
{
IList <Polyline2D> flattened = (IList <Polyline2D>)ShapeTool.GetFlattened(path, this.wireframe_0.Config.ShapeFlattenEpsilon);
IList <Polyline4D> polylines1 = DxfUtil.smethod_39(flattened, filled, transformer);
ArgbColor plotColor = this.wireframe_0.GetPlotColor(this.dxfEntity_0, color);
Class940.smethod_3(this.dxfEntity_0, this.wireframe_0, this.iwireframeGraphicsFactory2_0, plotColor, forText, false, true, polylines1);
transformer.SetPreTransform(Transformation4D.Translation(0.0, 0.0, extrusion));
IList <Polyline4D> polylines2 = DxfUtil.smethod_39(flattened, filled, transformer);
Class940.smethod_3(this.dxfEntity_0, this.wireframe_0, this.iwireframeGraphicsFactory2_0, plotColor, forText, false, true, polylines2);
Polyline4D polyline4D1 = new Polyline4D(2);
polyline4D1.Add(Vector4D.Zero);
polyline4D1.Add(Vector4D.Zero);
IList <Polyline4D> polylines3 = (IList <Polyline4D>) new List <Polyline4D>(1);
polylines3.Add(polyline4D1);
for (int index1 = polylines1.Count - 1; index1 >= 0; --index1)
{
Polyline4D polyline4D2 = polylines1[index1];
Polyline4D polyline4D3 = polylines2[index1];
for (int index2 = polyline4D2.Count - 1; index2 >= 0; --index2)
{
polyline4D1[0] = polyline4D2[index2];
polyline4D1[1] = polyline4D3[index2];
Class940.smethod_2(this.dxfEntity_0, this.wireframe_0, this.iwireframeGraphicsFactory2_0, plotColor, forText, false, true, polylines3);
}
}
}
}
public void CreateImage(
DxfRasterImage rasterImage,
DrawContext.Wireframe drawContext,
Polyline4D clipPolygon,
Polyline4D imageBoundary,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.bounds3D_0.Update((IList <Vector4D>)imageBoundary, this.matrix4D_0);
}
public void CreateScalableImage(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
}
private static bool smethod_6(Polyline4D polygon)
{
for (int index = polygon.Count - 1; index > 0; --index)
{
if (polygon[index] == polygon[index - 1])
{
polygon.RemoveAt(index);
}
}
return(polygon.Count > 1);
}
public void CreateImage(
DxfRasterImage rasterImage,
DrawContext.Wireframe drawContext,
Polyline4D clipPolygon,
Polyline4D imageBoundary,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.iwireframeGraphicsFactory_0.CreateImage(rasterImage, drawContext, clipPolygon, imageBoundary, transformedOrigin, transformedXAxis, transformedYAxis);
}
public void CreateImage(
DxfRasterImage rasterImage,
DrawContext.Wireframe drawContext,
Polyline4D clipPolygon,
Polyline4D imageBoundary,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.linkedListNodeRef_0.Insert((IWireframeDrawable) new WireframeGraphicsCache.Class972(rasterImage, drawContext, clipPolygon, imageBoundary, transformedOrigin, transformedXAxis, transformedYAxis));
}
public void CreateScalableImage(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.linkedListNodeRef_0.Insert((IWireframeDrawable) new WireframeGraphicsCache.Class973(entity, drawContext, bitmapProvider, clipPolygon, displaySize, transformedOrigin, transformedXAxis, transformedYAxis));
}
public static void smethod_19(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
List <WW.Math.Point3D> boundary,
List <bool> edgeVisibleList)
{
Interface41 transformer = context.GetTransformer();
Polyline4D boundary1 = DxfUtil.smethod_46(new WW.Math.Geometry.Polyline3D((IList <WW.Math.Point3D>)boundary), transformer);
Class940.smethod_20(entity, context, graphicsFactory, boundary1, edgeVisibleList);
}
public IList <Polyline4D> Transform(Polyline3D polyline, bool filled)
{
Polyline4D polyline4D = new Polyline4D(polyline.Count, polyline.Closed);
for (int index = 0; index < polyline.Count; ++index)
{
polyline4D.Add(this.matrix4D_0.TransformTo4D(polyline[index]));
}
return((IList <Polyline4D>) new Polyline4D[1] {
polyline4D
});
}
public void CreateScalableImage(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.iwireframeGraphicsFactory_0.CreateScalableImage(entity, drawContext, bitmapProvider, clipPolygon, displaySize, transformedOrigin, transformedXAxis, transformedYAxis);
}
public static void smethod_1(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IWireframeGraphicsFactory2 graphicsFactory,
ArgbColor color,
bool forText,
bool fill,
bool stroke,
Polyline4D polyline)
{
graphicsFactory.BeginGeometry(entity, drawContext, color, false, fill, stroke, true);
graphicsFactory.CreatePolyline(entity, polyline);
graphicsFactory.EndGeometry();
}
public static void smethod_15(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
IList <WW.Math.Geometry.Polyline3D> polylines)
{
Interface41 transformer = context.GetTransformer();
foreach (WW.Math.Geometry.Polyline3D polyline in (IEnumerable <WW.Math.Geometry.Polyline3D>)polylines)
{
Polyline4D polyline4D = DxfUtil.smethod_46(polyline, transformer);
graphicsFactory.CreatePolyline((IList <Vector4D>)polyline4D, polyline.Closed);
}
}
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 void CreateImage(
DxfRasterImage rasterImage,
DrawContext.Wireframe drawContext,
Polyline4D clipPolygon,
Polyline4D imageBoundary,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
if (!this.graphicsConfig_0.DrawImages || rasterImage.ImageDef == null || !rasterImage.ImageDef.Bitmap.IsValid)
{
return;
}
this.method_4(false, (Interface12) new Class344((Image)rasterImage.ImageDef.Bitmap.Image, clipPolygon, imageBoundary, transformedOrigin, transformedXAxis, transformedYAxis, (System.Drawing.Color)drawContext.GetPlotColor((DxfEntity)rasterImage), drawContext.GetLineWeight((DxfEntity)rasterImage)));
}
public Class463(
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.ibitmapProvider_0 = bitmapProvider;
this.polyline4D_0 = clipPolygon;
this.size2D_0 = displaySize;
this.vector4D_0 = transformedOrigin;
this.vector4D_1 = transformedXAxis;
this.vector4D_2 = transformedYAxis;
}
public void DrawPath(
IShape2D path,
Matrix4D transform,
Color color,
short lineWeight,
bool filled,
bool forText,
double extrusion)
{
if (!path.HasSegments)
{
return;
}
IClippingTransformer transformer = (IClippingTransformer)this.wireframe_0.GetTransformer().Clone();
transformer.SetPreTransform(transform);
IWireframeGraphicsFactory graphicsFactory0 = this.iwireframeGraphicsFactory_0;
if (extrusion == 0.0)
{
IShape4D shape1 = (IShape4D) new FlatShape4D((IShape2D)(path as GeneralShape2D ?? new GeneralShape2D(path, true)), filled);
IShape4D shape2 = transformer.Transform(shape1);
if (shape2.IsEmpty)
{
return;
}
graphicsFactory0.CreateShape(this.dxfEntity_0, this.wireframe_0, this.wireframe_0.GetPlotColor(this.dxfEntity_0, color), forText, shape2);
}
else
{
IList <Polyline2D> flattened = (IList <Polyline2D>)ShapeTool.GetFlattened(path, this.wireframe_0.Config.ShapeFlattenEpsilon);
IList <Polyline4D> polylines1 = DxfUtil.smethod_39(flattened, filled, transformer);
ArgbColor plotColor = this.wireframe_0.GetPlotColor(this.dxfEntity_0, color);
graphicsFactory0.CreatePathAsOne(this.dxfEntity_0, this.wireframe_0, plotColor, forText, polylines1, false, true);
transformer.SetPreTransform(Transformation4D.Translation(0.0, 0.0, extrusion));
IList <Polyline4D> polylines2 = DxfUtil.smethod_39(flattened, filled, transformer);
graphicsFactory0.CreatePathAsOne(this.dxfEntity_0, this.wireframe_0, plotColor, forText, polylines2, false, true);
for (int index1 = polylines1.Count - 1; index1 >= 0; --index1)
{
Polyline4D polyline4D1 = polylines1[index1];
Polyline4D polyline4D2 = polylines2[index1];
for (int index2 = polyline4D1.Count - 1; index2 >= 0; --index2)
{
graphicsFactory0.CreateLine(this.dxfEntity_0, this.wireframe_0, plotColor, forText, polyline4D1[index2], polyline4D2[index2]);
}
}
}
}
public void CreateScalableImage(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
if (!this.graphicsConfig_0.DrawImages || bitmapProvider == null)
{
return;
}
this.method_4(false, (Interface12) new Class463(bitmapProvider, clipPolygon, displaySize, transformedOrigin, transformedXAxis, transformedYAxis));
}
public void CreateScalableImage(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
transformedXAxis *= displaySize.X;
transformedYAxis *= displaySize.Y;
this.bounds3D_0.Update(this.matrix4D_0.TransformTo3D(transformedOrigin));
this.bounds3D_0.Update(this.matrix4D_0.TransformTo3D(transformedOrigin + transformedXAxis));
this.bounds3D_0.Update(this.matrix4D_0.TransformTo3D(transformedOrigin + transformedYAxis));
this.bounds3D_0.Update(this.matrix4D_0.TransformTo3D(transformedOrigin + transformedXAxis + transformedYAxis));
}
public Class972(
DxfRasterImage rasterImage,
DrawContext.Wireframe drawContext,
Polyline4D clipPolygon,
Polyline4D imageBoundary,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.dxfRasterImage_0 = rasterImage;
this.wireframe_0 = drawContext;
this.polyline4D_0 = clipPolygon;
this.polyline4D_1 = imageBoundary;
this.vector4D_0 = transformedOrigin;
this.vector4D_1 = transformedXAxis;
this.vector4D_2 = transformedYAxis;
}
internal static int smethod_1(Ray2D ray, Polyline4D polyline)
{
int num1 = 0;
int num2 = polyline.Count + (polyline.Closed ? 1 : 0);
int count = polyline.Count;
Point2D start = (Point2D)polyline[0];
for (int index = 1; index < num2; ++index)
{
Point2D end = (Point2D)polyline[index % count];
Segment2D b = new Segment2D(start, end);
if (Ray2D.Intersects(ray, b))
{
++num1;
}
start = end;
}
return(num1);
}
public Class973(
DxfEntity entity,
DrawContext.Wireframe drawContext,
IBitmapProvider bitmapProvider,
Polyline4D clipPolygon,
Size2D displaySize,
Vector4D transformedOrigin,
Vector4D transformedXAxis,
Vector4D transformedYAxis)
{
this.dxfEntity_0 = entity;
this.wireframe_0 = drawContext;
this.ibitmapProvider_0 = bitmapProvider;
this.polyline4D_0 = clipPolygon;
this.size2D_0 = displaySize;
this.vector4D_0 = transformedOrigin;
this.vector4D_1 = transformedXAxis;
this.vector4D_2 = transformedYAxis;
}
public void CreatePolyline(DxfEntity entity, Polyline4D polyline)
{
if (polyline.Count <= 0)
{
return;
}
if (polyline.Count == 1)
{
this.CreateDot(entity, polyline[0]);
}
else
{
this.class453_0.method_1(this.matrix4D_0.TransformToWindowsPoint(polyline[0]), this.class453_0.Fill, polyline.Closed);
for (int index = 1; index < polyline.Count; ++index)
{
this.class453_0.method_4(this.matrix4D_0.TransformToWindowsPoint(polyline[index]));
}
}
}
public static void smethod_17(
DxfEntity entity,
DrawContext.Surface context,
ISurfaceGraphicsFactory graphicsFactory,
WW.Math.Geometry.Polyline3D polyline,
bool isSurface)
{
Interface41 transformer = context.GetTransformer();
Polyline4D boundary = DxfUtil.smethod_46(polyline, transformer);
if (isSurface)
{
Class940.smethod_20(entity, context, graphicsFactory, boundary, (List <bool>)null);
}
else
{
graphicsFactory.CreatePolyline((IList <Vector4D>)boundary, polyline.Closed);
}
}
