public void RenderEllipseTest()
{
var ellipse = new DxfEllipse(new DxfPoint(1.0, 2.0, 3.0), new DxfVector(1.0, 0.0, 0.0), 0.5)
{
StartParameter = 0.0,
EndParameter = Math.PI / 2.0 // 90 degrees
};
var path = ellipse.GetSvgPath();
Assert.Equal(2, path.Segments.Count);
var move = (SvgMoveToPath)path.Segments[0];
AssertClose(2.0, move.LocationX);
AssertClose(2.0, move.LocationY);
var arcSegment = (SvgArcToPath)path.Segments[1];
AssertClose(1.0, arcSegment.EndPointX);
AssertClose(2.5, arcSegment.EndPointY);
Assert.Equal(1.0, arcSegment.RadiusX);
Assert.Equal(0.5, arcSegment.RadiusY);
Assert.Equal(0.0, arcSegment.XAxisRotation);
Assert.False(arcSegment.IsLargeArc);
Assert.True(arcSegment.IsCounterClockwiseSweep);
var expected = new XElement("path",
new XAttribute("d", path.ToString()),
new XAttribute("fill-opacity", "0"),
new XAttribute("stroke-width", "1.0px"),
new XAttribute("vector-effect", "non-scaling-stroke"));
var actual = ellipse.ToXElement();
AssertXElement(expected, actual);
}
public static XElement ToXElement(this DxfEllipse ellipse)
{
XElement baseShape;
if (IsCloseTo(ellipse.StartParameter, 0.0) && IsCloseTo(ellipse.EndParameter, Math.PI * 2.0))
{
baseShape = new XElement(DxfToSvgConverter.Xmlns + "ellipse",
new XAttribute("cx", ellipse.Center.X.ToDisplayString()),
new XAttribute("cy", ellipse.Center.Y.ToDisplayString()),
new XAttribute("rx", ellipse.MajorAxis.Length.ToDisplayString()),
new XAttribute("ry", ellipse.MinorAxis().Length.ToDisplayString()));
}
else
{
var path = ellipse.GetSvgPath();
baseShape = new XElement(DxfToSvgConverter.Xmlns + "path",
new XAttribute("d", path.ToString()));
}
baseShape.Add(new XAttribute("fill-opacity", 0));
return(baseShape
.AddStroke(ellipse.Color)
.AddStrokeWidth(1.0)
.AddVectorEffect());
}
public void EllipseAndClosedShapeTest()
{
var ellipse = new DxfEllipse(new DxfPoint(0.0, 0.0, 0.0), new DxfVector(1.0, 0.0, 0.0), 0.5);
var expected = new XElement("ellipse",
new XAttribute("cx", "0.0"), new XAttribute("cy", "0.0"),
new XAttribute("rx", "1.0"), new XAttribute("ry", "0.5"),
new XAttribute("fill-opacity", "0"),
new XAttribute("stroke-width", "1.0px"),
new XAttribute("vector-effect", "non-scaling-stroke"));
var actual = ellipse.ToXElement();
AssertXElement(expected, actual);
}
public void EllipsePathOf180DegreesTest()
{
var ellipse = new DxfEllipse(new DxfPoint(0.0, 0.0, 0.0), new DxfVector(1.0, 0.0, 0.0), 0.5)
{
StartParameter = 0.0,
EndParameter = Math.PI
};
var path = ellipse.GetSvgPath();
Assert.Equal(3, path.Segments.Count);
var move = (SvgMoveToPath)path.Segments[0];
AssertClose(1.0, move.LocationX);
AssertClose(0.0, move.LocationY);
// 180 degree ellipses are difficult to render; split it into two 90s
var first = (SvgArcToPath)path.Segments[1];
AssertClose(0.0, first.EndPointX);
AssertClose(0.5, first.EndPointY);
Assert.Equal(1.0, first.RadiusX);
Assert.Equal(0.5, first.RadiusY);
Assert.Equal(0.0, first.XAxisRotation);
Assert.False(first.IsLargeArc);
Assert.True(first.IsCounterClockwiseSweep);
var second = (SvgArcToPath)path.Segments[2];
AssertClose(-1.0, second.EndPointX);
AssertClose(0.0, second.EndPointY);
Assert.Equal(1.0, second.RadiusX);
Assert.Equal(0.5, second.RadiusY);
Assert.Equal(0.0, second.XAxisRotation);
Assert.False(second.IsLargeArc);
Assert.True(second.IsCounterClockwiseSweep);
}
public void Visit(DxfEllipse ellipse)
{
this.method_0((DxfEntity)ellipse);
}
internal static SvgPath GetSvgPath(this DxfEllipse ellipse)
{
return(SvgPath.FromEllipse(ellipse.Center.X, ellipse.Center.Y, ellipse.MajorAxis.X, ellipse.MajorAxis.Y, ellipse.MinorAxisRatio, ellipse.StartParameter, ellipse.EndParameter));
}
public void Visit(DxfEllipse ellipse)
{
this.bool_0 = true;
}
public static Ellipse ToEllipse(this DxfEllipse el)
{
return(new Ellipse(el.Center.ToPoint(), el.MajorAxis.ToVector(), el.MinorAxisRatio, el.StartParameter * MathHelper.RadiansToDegrees, el.EndParameter * MathHelper.RadiansToDegrees, el.Normal.ToVector(), el.GetEntityColor(), el));
}
/// <summary>
/// Visits the specified entity.
/// See the <see cref="IEntityVisitor"/> for more details.
/// </summary>
public override void Visit(DxfEllipse ellipse)
{
HandleEntity(ellipse);
}
public void DrawArc(
Pen pen,
float x,
float y,
float width,
float height,
float startAngle,
float sweepAngle)
{
double a = -(double)startAngle * System.Math.PI / 180.0;
double num1 = -(double)sweepAngle * System.Math.PI / 180.0;
double b = a + num1;
if (num1 < 0.0)
{
MathUtil.Swap(ref a, ref b);
}
double radius = 0.5 * (double)width;
WW.Math.Point3D center = new WW.Math.Point3D((double)x + radius, -(double)y - 0.5 * (double)height, 0.0);
if ((double)width == (double)height)
{
if (MathUtil.AreApproxEqual(System.Math.Abs(num1), 2.0 * System.Math.PI))
{
DxfCircle dxfCircle = new DxfCircle(center, radius);
dxfCircle.Color = EntityColor.CreateFrom((ArgbColor)pen.Color);
this.list_0.Add((DxfEntity)dxfCircle);
}
else
{
DxfArc dxfArc = new DxfArc(center, radius, a, b);
dxfArc.Color = EntityColor.CreateFrom((ArgbColor)pen.Color);
this.list_0.Add((DxfEntity)dxfArc);
}
}
else
{
double num2 = (double)System.Math.Abs(width);
double num3 = (double)System.Math.Abs(height);
double minorToMajorRatio;
Vector3D majorAxisEndPoint;
double num4;
double num5;
if (num2 > num3)
{
minorToMajorRatio = num3 / num2;
majorAxisEndPoint = new Vector3D(0.5 * num2, 0.0, 0.0);
num4 = a;
num5 = b;
}
else
{
minorToMajorRatio = num2 / num3;
majorAxisEndPoint = new Vector3D(0.0, 0.5 * num3, 0.0);
if (MathUtil.AreApproxEqual(System.Math.Abs(num1), 2.0 * System.Math.PI))
{
num4 = 0.0;
num5 = 2.0 * System.Math.PI;
}
else
{
num4 = a - System.Math.PI / 2.0;
num5 = b - System.Math.PI / 2.0;
}
}
DxfEllipse dxfEllipse = new DxfEllipse(center, majorAxisEndPoint, minorToMajorRatio);
dxfEllipse.Color = EntityColor.CreateFrom((ArgbColor)pen.Color);
dxfEllipse.StartParameter = num4;
dxfEllipse.EndParameter = num5;
this.list_0.Add((DxfEntity)dxfEllipse);
}
}
static void FindEntities(DxfEntityCollection Entities)
{
foreach (var entityGroups in Entities)
{
if (typeof(DxfLine) != entityGroups.GetType() && typeof(DxfLwPolyline) != entityGroups.GetType() && typeof(DxfMText) != entityGroups.GetType() && typeof(DxfText) != entityGroups.GetType() && typeof(DxfCircle) != entityGroups.GetType() && typeof(DxfHatch) != entityGroups.GetType() && typeof(DxfInsert) != entityGroups.GetType() && typeof(DxfSpline) != entityGroups.GetType())
{
// Console.WriteLine(entityGroups.GetType());
}
dxfType.Add(entityGroups.GetType().Name);
if (typeof(DxfLine) == entityGroups.GetType())
{
dxfLine = entityGroups as DxfLine;
int color;
if (dxfLine.Color.ColorType.ToString() == "ByLayer")
{
color = dxfLine.Layer.Color.Rgb;
}
else
{
color = dxfLine.Color.Rgb;
}
CADLine cADLine = new CADLine
{
parentHandle = dxfLine.OwnerObjectSoftReference.Handle,
type = dxfLine.GetType().Name,
color = color,
transform = dxfLine.Transform.DebugString,
startPoint = dxfLine.Start.ToString(),
endPoint = dxfLine.End.ToString(),
lineWeight = dxfLine.LineWeight
};
cadEntities.Add(cADLine);
}
if (typeof(DxfLwPolyline) == entityGroups.GetType())
{
//Console.WriteLine(dxfLwPolyline);
dxfLwPolyline = entityGroups as DxfLwPolyline;
string[] arrVertices = new string[dxfLwPolyline.Vertices.Count];
for (int i = 0; i < dxfLwPolyline.Vertices.Count; i++)
{
arrVertices[i] = dxfLwPolyline.Vertices[i].ToString();
}
int color;
if (dxfLwPolyline.Color.ColorType.ToString() == "ByLayer")
{
color = dxfLwPolyline.Layer.Color.Rgb;
}
else
{
color = dxfLwPolyline.Color.Rgb;
}
CADLwPolyLine cADLwPolyLine = new CADLwPolyLine
{
parentHandle = dxfLwPolyline.OwnerObjectSoftReference.Handle,
type = dxfLwPolyline.GetType().Name,
color = color,
transform = dxfLwPolyline.Transform.DebugString,
vertices = arrVertices,
closed = dxfLwPolyline.Closed.ToString(),
};
cadEntities.Add(cADLwPolyLine);
}
if (typeof(DxfXLine) == entityGroups.GetType())
{
dxfXLine = entityGroups as DxfXLine;
}
if (typeof(DxfSpline) == entityGroups.GetType())
{
dxfSpline = entityGroups as DxfSpline;
string[] arrFitPoints = new string[dxfSpline.FitPoints.Count];
for (int i = 0; i < dxfSpline.FitPoints.Count; i++)
{
arrFitPoints[i] = dxfSpline.FitPoints[i].ToString();
}
int color;
if (dxfSpline.Color.ColorType.ToString() == "ByLayer")
{
color = dxfSpline.Layer.Color.Rgb;
}
else
{
color = dxfSpline.Color.Rgb;
}
CADSpline cADSpline = new CADSpline
{
parentHandle = dxfSpline.OwnerObjectSoftReference.Handle,
type = dxfSpline.GetType().Name,
color = color,
transform = dxfSpline.Transform.DebugString,
fitPoints = arrFitPoints,
};
cadEntities.Add(cADSpline);
}
if (typeof(DxfCircle) == entityGroups.GetType())
{
dxfCircle = entityGroups as DxfCircle;
int color;
if (dxfCircle.Color.ColorType.ToString() == "ByLayer")
{
color = dxfCircle.Layer.Color.Rgb;
}
else
{
color = dxfCircle.Color.Rgb;
}
CADCircle cADCircle = new CADCircle
{
parentHandle = dxfCircle.OwnerObjectSoftReference.Handle,
type = dxfCircle.GetType().Name,
color = color,
transform = dxfCircle.Transform.DebugString,
center = dxfCircle.Center.ToString(),
radius = dxfCircle.Radius
};
cadEntities.Add(cADCircle);
kcircle.Add(dxfCircle);
}
if (typeof(DxfArc) == entityGroups.GetType())
{
dxfArc = entityGroups as DxfArc;
int color;
if (dxfArc.Color.ColorType.ToString() == "ByLayer")
{
color = dxfArc.Layer.Color.Rgb;
}
else
{
color = dxfArc.Color.Rgb;
}
CADArc cADArc = new CADArc
{
parentHandle = dxfArc.OwnerObjectSoftReference.Handle,
type = dxfArc.GetType().Name,
color = color,
transform = dxfArc.Transform.DebugString,
center = dxfArc.Center.ToString(),
startAngle = dxfArc.StartAngle,
endAngle = dxfArc.EndAngle,
radius = dxfArc.Radius
};
cadEntities.Add(cADArc);
}
if (typeof(DxfEllipse) == entityGroups.GetType())
{
dxfEllipse = entityGroups as DxfEllipse;
int color;
if (dxfEllipse.Color.ColorType.ToString() == "ByLayer")
{
color = dxfEllipse.Layer.Color.Rgb;
}
else
{
color = dxfEllipse.Color.Rgb;
}
CADEllipse cADEllipse = new CADEllipse
{
parentHandle = dxfEllipse.OwnerObjectSoftReference.Handle,
type = dxfEllipse.GetType().Name,
color = color,
transform = dxfEllipse.Transform.DebugString,
center = dxfEllipse.Center.ToString(),
majorAxisEndPoint = dxfEllipse.MajorAxisEndPoint.ToString(),
minorAxisEndPoint = dxfEllipse.MinorAxisEndPoint.ToString(),
startParameter = dxfEllipse.StartParameter,
endParameter = dxfEllipse.EndParameter
};
cadEntities.Add(cADEllipse);
}
if (typeof(DxfMText) == entityGroups.GetType())
{
dxfMText = entityGroups as DxfMText;
int color;
if (dxfMText.Color.ColorType.ToString() == "ByLayer")
{
color = dxfMText.Layer.Color.Rgb;
}
else
{
color = dxfMText.Color.Rgb;
}
if (dxfMText.SimplifiedText == "C座一层平面图")
{
ktls.Add(dxfMText);
}
CADMText cADMText = new CADMText
{
parentHandle = dxfMText.OwnerObjectSoftReference.Handle,
type = dxfMText.GetType().Name,
color = color,
transform = dxfMText.Transform.DebugString,
simplifiedText = dxfMText.SimplifiedText.ToString(),
fontStyle = dxfMText.Style.ToString(),
size = dxfMText.Height,
attachmentPoint = dxfMText.AttachmentPoint.ToString(),
boxHeight = dxfMText.BoxHeight,
boxWidth = dxfMText.BoxWidth
};
cadEntities.Add(cADMText);
if (dxfMText.SimplifiedText.ToString() == "图 纸 目 录")
{
//Console.WriteLine(222222);
ktls.Add(dxfMText);
}
if (dxfMText.SimplifiedText.ToString() == "JS-T5-302")
{
//Console.WriteLine(222222);
ktls.Add(dxfMText);
}
}
if (typeof(DxfText) == entityGroups.GetType())
{
dxfText = entityGroups as DxfText;
int color;
if (dxfText.Color.ColorType.ToString() == "ByLayer")
{
color = dxfText.Layer.Color.Rgb;
}
else
{
color = dxfText.Color.Rgb;
}
CADText cADText = new CADText
{
parentHandle = dxfText.OwnerObjectSoftReference.Handle,
type = dxfText.GetType().Name,
color = color,
transform = dxfText.Transform.DebugString,
simplifiedText = dxfText.SimplifiedText.ToString(),
fontStyle = dxfText.Style.ToString(),
size = dxfText.Height,
alignMentPoint1 = dxfText.AlignmentPoint1.ToString(),
rotationAngle = dxfText.Rotation,
};
if (dxfText.SimplifiedText == "JS-T5-001 ")
{
ktest.Add(dxfText);
}
cadEntities.Add(cADText);
}
if (typeof(DxfInsert) == entityGroups.GetType())
{
dxfInsert = entityGroups as DxfInsert;
kins.Add(dxfInsert);
if (dxfInsert.Block != null)
{
ulong count;
if (dxfInsert.Block != null)
{
count = dxfInsert.Block.Handle;
}
else
{
count = 0;
}
CADInsert cADInsert = new CADInsert();
cADInsert.parentHandle = dxfInsert.OwnerObjectSoftReference.Handle;
cADInsert.type = dxfInsert.GetType().Name;
cADInsert.transform = dxfInsert.Transform.DebugString;
cADInsert.insertPoint = dxfInsert.InsertionPoint.ToString();
cADInsert.rotationAngle = dxfInsert.Rotation;
cADInsert.insertName = dxfInsert.Block.Name;
cADInsert.nowHandle = count;
cADInsert.insertScale = dxfInsert.ScaleFactor.ToString();
cadEntities.Add(cADInsert);
FindEntities(dxfInsert.Block.Entities);
}
}
if (typeof(DxfAttributeDefinition) == entityGroups.GetType())
{
dxfAttributeDefinition = entityGroups as DxfAttributeDefinition;
//Console.WriteLine(dxfAttributeDefinition);
}
if (typeof(DxfDimension.Linear) == entityGroups.GetType())
{
Console.WriteLine(11111);
}
}
}
private static List <DxfEntity> OffsetToNest(IList <DxfEntity> dxfEntities, DxfPoint pivot, DxfPoint offset, double rotationAngle)
{
List <DxfEntity> dxfreturn = new List <DxfEntity>();
List <DxfPoint> tmpPts;
foreach (DxfEntity entity in dxfEntities)
{
switch (entity.EntityType)
{
case DxfEntityType.Arc:
DxfArc dxfArc = (DxfArc)entity;
dxfArc.Center = RotateLocation(rotationAngle, dxfArc.Center);
dxfArc.Center += offset;
dxfArc.StartAngle += rotationAngle;
dxfArc.EndAngle += rotationAngle;
dxfreturn.Add(dxfArc);
break;
case DxfEntityType.ArcAlignedText:
DxfArcAlignedText dxfArcAligned = (DxfArcAlignedText)entity;
dxfArcAligned.CenterPoint = RotateLocation(rotationAngle, dxfArcAligned.CenterPoint);
dxfArcAligned.CenterPoint += offset;
dxfArcAligned.StartAngle += rotationAngle;
dxfArcAligned.EndAngle += rotationAngle;
dxfreturn.Add(dxfArcAligned);
break;
case DxfEntityType.Attribute:
DxfAttribute dxfAttribute = (DxfAttribute)entity;
dxfAttribute.Location = RotateLocation(rotationAngle, dxfAttribute.Location);
dxfAttribute.Location += offset;
dxfreturn.Add(dxfAttribute);
break;
case DxfEntityType.AttributeDefinition:
DxfAttributeDefinition dxfAttributecommon = (DxfAttributeDefinition)entity;
dxfAttributecommon.Location = RotateLocation(rotationAngle, dxfAttributecommon.Location);
dxfAttributecommon.Location += offset;
dxfreturn.Add(dxfAttributecommon);
break;
case DxfEntityType.Circle:
DxfCircle dxfCircle = (DxfCircle)entity;
dxfCircle.Center = RotateLocation(rotationAngle, dxfCircle.Center);
dxfCircle.Center += offset;
dxfreturn.Add(dxfCircle);
break;
case DxfEntityType.Ellipse:
DxfEllipse dxfEllipse = (DxfEllipse)entity;
dxfEllipse.Center = RotateLocation(rotationAngle, dxfEllipse.Center);
dxfEllipse.Center += offset;
dxfreturn.Add(dxfEllipse);
break;
case DxfEntityType.Image:
DxfImage dxfImage = (DxfImage)entity;
dxfImage.Location = RotateLocation(rotationAngle, dxfImage.Location);
dxfImage.Location += offset;
dxfreturn.Add(dxfImage);
break;
case DxfEntityType.Leader:
DxfLeader dxfLeader = (DxfLeader)entity;
tmpPts = new List <DxfPoint>();
foreach (DxfPoint vrt in dxfLeader.Vertices)
{
var tmppnt = RotateLocation(rotationAngle, vrt);
tmppnt += offset;
tmpPts.Add(tmppnt);
}
dxfLeader.Vertices.Clear();
dxfLeader.Vertices.Concat(tmpPts);
dxfreturn.Add(dxfLeader);
break;
case DxfEntityType.Line:
DxfLine dxfLine = (DxfLine)entity;
dxfLine.P1 = RotateLocation(rotationAngle, dxfLine.P1);
dxfLine.P2 = RotateLocation(rotationAngle, dxfLine.P2);
dxfLine.P1 += offset;
dxfLine.P2 += offset;
dxfreturn.Add(dxfLine);
break;
case DxfEntityType.LwPolyline:
DxfPolyline dxfPoly = (DxfPolyline)entity;
foreach (DxfVertex vrt in dxfPoly.Vertices)
{
vrt.Location = RotateLocation(rotationAngle, vrt.Location);
vrt.Location += offset;
}
dxfreturn.Add(dxfPoly);
break;
case DxfEntityType.MLine:
DxfMLine mLine = (DxfMLine)entity;
tmpPts = new List <DxfPoint>();
mLine.StartPoint += offset;
mLine.StartPoint = RotateLocation(rotationAngle, mLine.StartPoint);
foreach (DxfPoint vrt in mLine.Vertices)
{
var tmppnt = RotateLocation(rotationAngle, vrt);
tmppnt += offset;
tmpPts.Add(tmppnt);
}
mLine.Vertices.Clear();
mLine.Vertices.Concat(tmpPts);
dxfreturn.Add(mLine);
break;
case DxfEntityType.Polyline:
DxfPolyline polyline = (DxfPolyline)entity;
List <DxfVertex> verts = new List <DxfVertex>();
foreach (DxfVertex vrt in polyline.Vertices)
{
var tmppnt = vrt;
tmppnt.Location = RotateLocation(rotationAngle, tmppnt.Location);
tmppnt.Location += offset;
verts.Add(tmppnt);
}
DxfPolyline polyout = new DxfPolyline(verts);
polyout.Location = polyline.Location + offset;
polyout.IsClosed = polyline.IsClosed;
polyout.Layer = polyline.Layer;
dxfreturn.Add(polyout);
break;
case DxfEntityType.Body:
case DxfEntityType.DgnUnderlay:
case DxfEntityType.Dimension:
case DxfEntityType.DwfUnderlay:
case DxfEntityType.Face:
case DxfEntityType.Helix:
case DxfEntityType.Insert:
case DxfEntityType.Light:
case DxfEntityType.ModelerGeometry:
case DxfEntityType.MText:
case DxfEntityType.OleFrame:
case DxfEntityType.Ole2Frame:
case DxfEntityType.PdfUnderlay:
case DxfEntityType.Point:
case DxfEntityType.ProxyEntity:
case DxfEntityType.Ray:
case DxfEntityType.Region:
case DxfEntityType.RText:
case DxfEntityType.Section:
case DxfEntityType.Seqend:
case DxfEntityType.Shape:
case DxfEntityType.Solid:
case DxfEntityType.Spline:
case DxfEntityType.Text:
case DxfEntityType.Tolerance:
case DxfEntityType.Trace:
case DxfEntityType.Underlay:
case DxfEntityType.Vertex:
case DxfEntityType.WipeOut:
case DxfEntityType.XLine:
throw new ArgumentException("unsupported entity type: " + entity.EntityType);
}
}
return(dxfreturn);
}
/// <summary>
/// Parse DXF into VectorShape list.
/// </summary>
public static List <VectorShape> ReadDXF(Stream dxfStream)
{
List <VectorShape> shapes = new List <VectorShape>();
DxfFile dxfFile = DxfFile.Load(dxfStream);
Dictionary <string, Color32> layerColors = new Dictionary <string, Color32>();
foreach (DxfLayer layer in dxfFile.Layers)
{
layerColors.Add(layer.Name, ConvertColor(layer.Color));
}
foreach (DxfEntity entity in dxfFile.Entities)
{
VectorShape shape = null;
switch (entity.EntityType)
{
case DxfEntityType.Point:
DxfModelPoint point = entity as DxfModelPoint;
shape = new PointShape(ConvertPoint(point.Location));
break;
case DxfEntityType.Line:
DxfLine line = entity as DxfLine;
Vector2[] endpoints = new Vector2[2];
endpoints[0] = ConvertPoint(line.P1);
endpoints[1] = ConvertPoint(line.P2);
shape = new PolyShape(endpoints);
break;
case DxfEntityType.Spline:
DxfSpline spline = entity as DxfSpline;
if ((spline.NumberOfControlPoints % spline.DegreeOfCurve) != 1)
{
Debug.LogError("Invalid spline data! Wrong number of points. " + spline);
break;
}
Vector2[] controlPoints = new Vector2[spline.NumberOfControlPoints];
for (int i = 0; i < controlPoints.Length; i++)
{
controlPoints[i] = ConvertPoint(spline.ControlPoints[i]);
}
shape = new PolyShape(controlPoints[0]);
PolyShape shapeSpline = shape as PolyShape;
switch (spline.DegreeOfCurve)
{
case 1:
for (int i = 1; i < controlPoints.Length; i++)
{
shapeSpline.LineTo(controlPoints[i]);
}
break;
case 2:
for (int i = 1; i < controlPoints.Length; i += 2)
{
shapeSpline.CurveTo(controlPoints[i + 1], controlPoints[i]);
}
break;
case 3:
for (int i = 1; i < controlPoints.Length; i += 3)
{
shapeSpline.CurveTo(controlPoints[i + 2], controlPoints[i], controlPoints[i + 1]);
}
break;
default:
Debug.LogWarning("Spline with unsupported curve of degree: " + spline.DegreeOfCurve);
break;
}
break;
case DxfEntityType.Arc:
DxfArc arc = entity as DxfArc;
// If the arc is a complete circle just make one of those
float startAngle = (float)arc.StartAngle;
while (startAngle < 0f)
{
startAngle += 360f;
}
float endAngle = (float)arc.EndAngle;
while (endAngle < startAngle)
{
endAngle += 360f;
}
float sweep = endAngle - startAngle;
shape = new CircleShape(ConvertPoint(arc.Center), (float)arc.Radius, startAngle, sweep);
break;
case DxfEntityType.Circle:
DxfCircle circle = entity as DxfCircle;
shape = new CircleShape(ConvertPoint(circle.Center), (float)circle.Radius * dxfScale);
break;
case DxfEntityType.Ellipse:
DxfEllipse ellipse = entity as DxfEllipse;
// If the ellipse is actually a circle just make one of those
if (Mathf.Approximately((float)ellipse.MinorAxisRatio, 1f))
{
shape = new CircleShape(ConvertPoint(ellipse.Center), (float)ellipse.MajorAxis.Length * dxfScale);
}
else
{
shape = new EllipseShape(ConvertPoint(ellipse.Center), ConvertVector(ellipse.MajorAxis), (float)ellipse.MinorAxisRatio);
}
break;
case DxfEntityType.Polyline:
DxfPolyline polyline = entity as DxfPolyline;
if (polyline.ContainsVertices)
{
Vector2[] vertices = new Vector2[polyline.Vertices.Count];
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = ConvertPoint(polyline.Vertices[i].Location);
}
shape = new PolyShape(vertices[0]);
PolyShape shapePolyline = shape as PolyShape;
for (int i = 1; i < vertices.Length; i++)
{
float bulge = (float)polyline.Vertices[i - 1].Bulge;
shapePolyline.ArcToDXF(vertices[i], bulge);
}
if (polyline.IsClosed)
{
float bulge = (float)polyline.Vertices[vertices.Length - 1].Bulge;
shapePolyline.ArcToDXF(vertices[0], bulge);
shape.Closed = true;
}
}
break;
case DxfEntityType.LwPolyline:
{
DxfLwPolyline lwPolyline = entity as DxfLwPolyline;
Vector2[] vertices = new Vector2[lwPolyline.Vertices.Count];
for (int i = 0; i < vertices.Length; i++)
{
DxfLwPolylineVertex lwpVertex = lwPolyline.Vertices[i];
vertices[i] = ConvertPoint(lwpVertex.X, lwpVertex.Y);
}
shape = new PolyShape(vertices[0]);
PolyShape shapePolyline = shape as PolyShape;
for (int i = 1; i < vertices.Length; i++)
{
float bulge = (float)lwPolyline.Vertices[i - 1].Bulge;
shapePolyline.ArcToDXF(vertices[i], bulge);
}
if (lwPolyline.IsClosed)
{
float bulge = (float)lwPolyline.Vertices[vertices.Length - 1].Bulge;
shapePolyline.ArcToDXF(vertices[0], bulge);
shape.Closed = true;
}
}
break;
default:
Debug.Log("Unhandled entity of type: " + entity.EntityType);
break;
}
if (shape != null)
{
if (entity.IsVisible)
{
Color32 shapeColor = ConvertColor(entity.Color);
//layerColors.TryGetValue(entity.Layer, out shapeColor);
shape.colorOutline = shapeColor;
shapes.Add(shape);
}
}
}
return(shapes);
}