private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out bool fill,
out IList <Polyline4D> polylines4D)
{
DxfHeader header = context.Model.Header;
GraphicsConfig config = context.Config;
IList <WW.Math.Geometry.Polyline3D> polylines = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>();
fill = false;
if (header.ShowSplineControlPoints || config.ShowSplineControlPoints)
{
this.method_14(polylines);
}
if (config.ShowSplineApproximationPoints)
{
this.method_15(polylines);
}
if (!header.ShowSplineControlPoints || config.ShowSplineInterpolatedPoints)
{
int splineLineSegments = (int)context.Config.NoOfSplineLineSegments;
this.method_18(polylines, splineLineSegments, splineLineSegments);
}
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(this.Transform);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer1);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <FlatShape4D> shapes)
{
IList <WW.Math.Geometry.Polyline3D> polylines;
this.method_13(context, transformer.LineTypeScaler, out polylines, out shapes);
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(this.Transform);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer1);
}
private IList <Polyline4D> method_17(
IClippingTransformer transformer,
Bounds2D textBounds)
{
Matrix4D transform = this.Transform;
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(transform);
double num = this.double_1 * (this.backgroundFillInfo_0.BorderOffsetFactor - 1.0);
double x1 = textBounds.Corner1.X - num;
double x2 = this.double_2 + num;
double y1 = textBounds.Corner1.Y - num;
double y2 = textBounds.Corner2.Y + num;
return(DxfUtil.smethod_38(new WW.Math.Geometry.Polyline3D(true, new WW.Math.Point3D[4] {
new WW.Math.Point3D(x1, y1, 0.0), new WW.Math.Point3D(x2, y1, 0.0), new WW.Math.Point3D(x2, y2, 0.0), new WW.Math.Point3D(x1, y2, 0.0)
}), true, transformer1));
}
private IList <Polyline4D> method_16(
DrawContext.Wireframe context,
out Polyline3DT imageBoundaryPolyline,
out IClippingTransformer transformer)
{
Polygon2D clipBoundary = this.GetClipBoundary((DrawContext)context);
if (clipBoundary != null && clipBoundary.Count != 0)
{
Matrix4D preTransform = this.method_15();
transformer = context.GetTransformer();
transformer = (IClippingTransformer)transformer.Clone();
transformer.SetPreTransform(preTransform);
imageBoundaryPolyline = new Polyline3DT(true);
foreach (WW.Math.Point2D point2D in (List <WW.Math.Point2D>)clipBoundary)
{
imageBoundaryPolyline.Add(new Point3DT((WW.Math.Point3D)point2D, 0U));
}
return((IList <Polyline4D>) new List <Polyline4D>((IEnumerable <Polyline4D>)transformer.Transform(imageBoundaryPolyline.ToPolyline3D(), true)));
}
imageBoundaryPolyline = (Polyline3DT)null;
transformer = (IClippingTransformer)null;
return((IList <Polyline4D>) new Polyline4D[0]);
}
private IList <Polyline4D> method_16(IClippingTransformer transformer)
{
WW.Math.Point3D point3D0 = this.point3D_0;
bool closed = this.Closed;
DxfMLine.Segment segment1 = this.list_0[0];
int num1 = int.MaxValue;
foreach (DxfMLine.Segment segment2 in this.list_0)
{
if (segment2.Elements.Count < num1)
{
num1 = segment2.Elements.Count;
}
}
IList <Polyline4D> polyline4DList;
if (num1 >= 2)
{
Polyline3D[] polyline3DArray = new Polyline3D[2];
for (int index = 0; index < polyline3DArray.Length; ++index)
{
polyline3DArray[index] = new Polyline3D(closed);
}
foreach (DxfMLine.Segment segment2 in this.list_0)
{
WW.Math.Vector3D miterDirection = segment2.MiterDirection;
WW.Math.Point3D position = segment2.Position;
if (segment2.Elements.Count == 0)
{
polyline3DArray[0].Add(position);
}
else
{
DxfMLine.Segment.Element element1 = (DxfMLine.Segment.Element)null;
DxfMLine.Segment.Element element2 = (DxfMLine.Segment.Element)null;
double num2 = double.MaxValue;
double num3 = double.MinValue;
for (int index = 0; index < num1; ++index)
{
DxfMLine.Segment.Element element3 = segment2.Elements[index];
if (element3.Parameters.Count != 0)
{
if (element1 == null)
{
element1 = element3;
num2 = element1.Parameters[0];
}
else if (element3.Parameters[0] < num2)
{
element1 = element3;
num2 = element1.Parameters[0];
}
if (element2 == null)
{
element2 = element3;
num3 = element2.Parameters[0];
}
else if (element3.Parameters[0] > num3)
{
element2 = element3;
num3 = element2.Parameters[0];
}
}
}
if (num2 == double.MaxValue)
{
num2 = 0.0;
}
if (num3 == double.MinValue)
{
num3 = 0.0;
}
if (element1 != null && element2 != null)
{
polyline3DArray[0].Add(position + miterDirection * num2);
polyline3DArray[1].Add(position + miterDirection * num3);
}
}
}
List <Polyline3D> polyline3DList;
if (closed)
{
polyline3DList = new List <Polyline3D>(2);
polyline3DList.AddRange((IEnumerable <Polyline3D>)polyline3DArray);
}
else
{
polyline3DList = new List <Polyline3D>(1);
Polyline3D polyline3D = new Polyline3D(polyline3DArray[0].Count + polyline3DArray[1].Count, true);
polyline3D.AddRange((IEnumerable <WW.Math.Point3D>)polyline3DArray[0]);
polyline3D.AddRange((IEnumerable <WW.Math.Point3D>)polyline3DArray[1].GetReverse());
polyline3DList.Add(polyline3D);
}
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(DxfUtil.GetToWCSTransform(this.vector3D_0));
polyline4DList = DxfUtil.smethod_36((IList <Polyline3D>)polyline3DList, false, transformer1);
}
else
{
polyline4DList = (IList <Polyline4D>)null;
}
return(polyline4DList);
}
