private static void WriteDxfFile() { DxfDocument dxf = new DxfDocument(); //arc Arc arc = new Arc(new Vector3(10, 10, 0), 10, 45, 135); arc.Layer = new Layer("arc"); arc.Layer.Color.Index = 1; dxf.AddEntity(arc); //xData sample XData xdata = new XData(new ApplicationRegistry("netDxf")); xdata.XDataRecord.Add(new XDataRecord(XDataCode.String, "extended data with netDxf")); xdata.XDataRecord.Add(XDataRecord.OpenControlString); xdata.XDataRecord.Add(new XDataRecord(XDataCode.WorldSpacePositionX, 0)); xdata.XDataRecord.Add(new XDataRecord(XDataCode.WorldSpacePositionY, 0)); xdata.XDataRecord.Add(new XDataRecord(XDataCode.WorldSpacePositionZ, 0)); xdata.XDataRecord.Add(XDataRecord.CloseControlString); XData xdata2 = new XData(new ApplicationRegistry("other application")); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.String, "extended data with netDxf")); xdata2.XDataRecord.Add(XDataRecord.OpenControlString); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.String, "string record")); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.Real, 15.5)); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.Int32, 350)); xdata2.XDataRecord.Add(XDataRecord.CloseControlString); //circle Vector3 extrusion = new Vector3(1, 1, 1); Vector3 centerWCS = new Vector3(1, 1, 1); Vector3 centerOCS = MathHelper.Transform(centerWCS, extrusion, CoordinateSystem.World, CoordinateSystem.Object); Circle circle = new Circle(centerOCS, 5); circle.Layer = new Layer("circle with spaces"); circle.Layer.Color=AciColor.Yellow; circle.LineType = LineType.Dashed; circle.Normal = extrusion; circle.XData.Add(xdata); circle.XData.Add(xdata2); dxf.AddEntity(circle); //points Point point1 = new Point(new Vector3(-3, -3, 0)); point1.Layer = new Layer("point"); point1.Color = new AciColor(30); Point point2 = new Point(new Vector3(1, 1, 1)); point2.Layer = point1.Layer; point2.Layer.Color.Index = 9; point2.Normal = new Vector3(1, 1, 1); dxf.AddEntity(point1); dxf.AddEntity(point2); //3dface Face3d face3D = new Face3d(new Vector3(-5, -5, 5), new Vector3(5, -5, 5), new Vector3(5, 5, 5), new Vector3(-5, 5, 5)); face3D.Layer = new Layer("3dface"); face3D.Layer.Color.Index = 3; dxf.AddEntity(face3D); //polyline LwPolylineVertex polyVertex; List<LwPolylineVertex> polyVertexes = new List<LwPolylineVertex>(); polyVertex = new LwPolylineVertex(new Vector2(-50, -50)); polyVertex.StartWidth = 2; polyVertexes.Add(polyVertex); polyVertex = new LwPolylineVertex(new Vector2(50, -50)); polyVertex.StartWidth = 1; polyVertexes.Add(polyVertex); polyVertex = new LwPolylineVertex(new Vector2(50, 50)); polyVertex.Bulge = 1; polyVertexes.Add(polyVertex); polyVertex = new LwPolylineVertex(new Vector2(-50, 50)); polyVertexes.Add(polyVertex); LwPolyline polyline2d = new LwPolyline(polyVertexes, true); polyline2d.Layer = new Layer("polyline2d"); polyline2d.Layer.Color.Index = 5; polyline2d.Normal = new Vector3(1, 1, 1); polyline2d.Elevation = 100.0f; dxf.AddEntity(polyline2d); //lightweight polyline LwPolylineVertex lwVertex; List<LwPolylineVertex> lwVertexes = new List<LwPolylineVertex>(); lwVertex = new LwPolylineVertex(new Vector2(-25, -25)); lwVertex.StartWidth = 2; lwVertexes.Add(lwVertex); lwVertex = new LwPolylineVertex(new Vector2(25, -25)); lwVertex.StartWidth = 1; lwVertexes.Add(lwVertex); lwVertex = new LwPolylineVertex(new Vector2(25, 25)); lwVertex.Bulge = 1; lwVertexes.Add(lwVertex); lwVertex = new LwPolylineVertex(new Vector2(-25, 25)); lwVertexes.Add(lwVertex); LwPolyline lwPolyline = new LwPolyline(lwVertexes, true); lwPolyline.Layer = new Layer("lwpolyline"); lwPolyline.Layer.Color.Index = 5; lwPolyline.Normal = new Vector3(1, 1, 1); lwPolyline.Elevation = 100.0f; dxf.AddEntity(lwPolyline); // polyfaceMesh List<PolyfaceMeshVertex> meshVertexes = new List<PolyfaceMeshVertex> { new PolyfaceMeshVertex(0, 0, 0), new PolyfaceMeshVertex(10, 0, 0), new PolyfaceMeshVertex(10, 10, 0), new PolyfaceMeshVertex(5, 15, 0), new PolyfaceMeshVertex(0, 10, 0) }; List<PolyfaceMeshFace> faces = new List<PolyfaceMeshFace> { new PolyfaceMeshFace(new short[] {1, 2, -3}), new PolyfaceMeshFace(new short[] {-1, 3, -4}), new PolyfaceMeshFace(new short[] {-1, 4, 5}) }; PolyfaceMesh mesh = new PolyfaceMesh(meshVertexes, faces); mesh.Layer = new Layer("polyfacemesh"); mesh.Layer.Color.Index = 104; dxf.AddEntity(mesh); //line Line line = new Line(new Vector3(0, 0, 0), new Vector3(10, 10, 10)); line.Layer = new Layer("line"); line.Layer.Color.Index = 6; dxf.AddEntity(line); //3d polyline PolylineVertex vertex; List<PolylineVertex> vertexes = new List<PolylineVertex>(); vertex = new PolylineVertex(new Vector3(-50, -50, 0)); vertexes.Add(vertex); vertex = new PolylineVertex(new Vector3(50, -50, 10)); vertexes.Add(vertex); vertex = new PolylineVertex(new Vector3(50, 50, 25)); vertexes.Add(vertex); vertex = new PolylineVertex(new Vector3(-50, 50, 50)); vertexes.Add(vertex); Polyline polyline = new Polyline(vertexes, true); polyline.Layer = new Layer("polyline3d"); polyline.Layer.Color.Index = 24; dxf.AddEntity(polyline); //block definition Block block = new Block("TestBlock"); block.Entities.Add(new Line(new Vector3(-5, -5, 5), new Vector3(5, 5, 5))); block.Entities.Add(new Line(new Vector3(5, -5, 5), new Vector3(-5, 5, 5))); //insert Insert insert = new Insert(block, new Vector3(5, 5, 5)); insert.Layer = new Layer("insert"); insert.Layer.Color.Index = 4; dxf.AddEntity(insert); //text TextStyle style=new TextStyle("True type font","Arial.ttf"); Text text = new Text("Hello world!", Vector3.Zero, 10.0f,style); text.Layer = new Layer("text"); text.Layer.Color.Index = 8; text.Alignment = TextAlignment.TopRight; dxf.AddEntity(text); dxf.DrawingVariables.AcadVer = DxfVersion.AutoCad2010; dxf.Save("AutoCad2010.dxf"); dxf.DrawingVariables.AcadVer = DxfVersion.AutoCad2007; dxf.Save("AutoCad2007.dxf"); dxf.DrawingVariables.AcadVer = DxfVersion.AutoCad2004; dxf.Save("AutoCad2004.dxf"); dxf.DrawingVariables.AcadVer = DxfVersion.AutoCad2000; dxf.Save("AutoCad2000.dxf"); dxf = DxfDocument.Load("AutoCad2000.dxf"); dxf.Save("AutoCad2000 result.dxf"); }
void ReadArc(netDxf.Entities.Arc arc, double x, double y) { // TODO : var point0 = CreateHiddenPoint(arc.Center.X + x, arc.Center.Y + y); var aPoint1 = CreateHiddenPoint(point0.X + arc.Radius * System.Math.Cos(System.Math.PI / 180 * arc.StartAngle), point0.Y + arc.Radius * System.Math.Sin(System.Math.PI / 180 * arc.StartAngle)); var point1 = compareFreePoints(this.drawing.Figures, aPoint1); if (point1 == null) { point1 = aPoint1; this.drawing.Figures.Add(point1); } var aPoint2 = CreateHiddenPoint(point0.X + arc.Radius * System.Math.Cos(System.Math.PI / 180 * arc.EndAngle), point0.Y + arc.Radius * System.Math.Sin(System.Math.PI / 180 * arc.EndAngle)); var point2 = compareFreePoints(this.drawing.Figures, aPoint2); if (point2 == null) { point2 = aPoint2; this.drawing.Figures.Add(point2); } var figure = Factory.CreateArc(drawing, new[] { point0, point1, point2 }); Actions.Add(drawing, figure); }
private EntityObject ExportEllipse(GeoObject.Ellipse elli) { netDxf.Entities.EntityObject entity = null; if (elli.IsArc) { Plane dxfPlane; if (elli.CounterClockWise) { dxfPlane = Import.Plane(Vector3(elli.Center), Vector3(elli.Plane.Normal)); } else { dxfPlane = Import.Plane(Vector3(elli.Center), Vector3(-elli.Plane.Normal)); } if (elli.IsCircle) { GeoObject.Ellipse aligned = GeoObject.Ellipse.Construct(); aligned.SetArcPlaneCenterStartEndPoint(dxfPlane, dxfPlane.Project(elli.Center), dxfPlane.Project(elli.StartPoint), dxfPlane.Project(elli.EndPoint), dxfPlane, true); entity = new netDxf.Entities.Arc(Vector3(aligned.Center), aligned.Radius, aligned.StartParameter / Math.PI * 180, (aligned.StartParameter + aligned.SweepParameter) / Math.PI * 180); entity.Normal = Vector3(dxfPlane.Normal); } else { netDxf.Entities.Ellipse expelli = new netDxf.Entities.Ellipse(Vector3(elli.Center), 2 * elli.MajorRadius, 2 * elli.MinorRadius); entity = expelli; entity.Normal = Vector3(elli.Plane.Normal); Plane cdbplane = elli.Plane; GeoVector2D dir = dxfPlane.Project(cdbplane.DirectionX); SweepAngle rot = new SweepAngle(GeoVector2D.XAxis, dir); expelli.Rotation = rot.Degree; SetEllipseParameters(expelli, elli.StartParameter, elli.StartParameter + elli.SweepParameter); } } else { if (elli.IsCircle) { entity = new netDxf.Entities.Circle(Vector3(elli.Center), elli.Radius); entity.Normal = Vector3(elli.Plane.Normal); } else { netDxf.Entities.Ellipse expelli = new netDxf.Entities.Ellipse(Vector3(elli.Center), 2 * elli.MajorRadius, 2 * elli.MinorRadius); entity = expelli; entity.Normal = Vector3(elli.Plane.Normal); Plane dxfplane = Import.Plane(expelli.Center, expelli.Normal); // this plane is not correct, it has to be rotated Plane cdbplane = elli.Plane; GeoVector2D dir = dxfplane.Project(cdbplane.DirectionX); SweepAngle rot = new SweepAngle(GeoVector2D.XAxis, dir); expelli.Rotation = rot.Degree; } } return(entity); }
public Arc(netDxf.Entities.Arc inputArc) { InputArc = inputArc; var startPoint = new Point(); startPoint.X = inputArc.Radius * Math.Cos(Math.PI * inputArc.StartAngle / 180) + inputArc.Center.X; startPoint.Y = inputArc.Radius * Math.Sin(Math.PI * inputArc.StartAngle / 180) + inputArc.Center.Y; if (angleSubtract(inputArc.EndAngle, inputArc.StartAngle) > 180) { Length = 2 * Math.PI * inputArc.Radius * angleSubtract(inputArc.EndAngle, inputArc.StartAngle) / 360; } else { Length = 2 * Math.PI * inputArc.Radius * angleSubtract(inputArc.EndAngle, inputArc.StartAngle) / 360; } MinXMinY = new Vector3( Math.Cos(Math.PI * inputArc.StartAngle / 180) * inputArc.Radius + inputArc.Center.X, Math.Sin(Math.PI * inputArc.StartAngle / 180) * inputArc.Radius + inputArc.Center.Y, 0); MaxXMaxY = MinXMinY; if (angleSubtract(inputArc.EndAngle, inputArc.StartAngle) > 180) { for (double i = 0; i < Math.Ceiling(Length); i += 0.5) { var tempX = Math.Cos(Math.PI * (inputArc.StartAngle + i * angleSubtract(inputArc.EndAngle, inputArc.StartAngle) / Length ) / 180) * inputArc.Radius + inputArc.Center.X; var tempY = Math.Sin(Math.PI * (inputArc.StartAngle + i * angleSubtract(inputArc.EndAngle, inputArc.StartAngle) / Length ) / 180) * inputArc.Radius + inputArc.Center.Y; CheckIfNewPointExtendArea(new Vector3(tempX, tempY, 0)); } } else { for (double i = 0; i < Math.Ceiling(Length); i += 0.5) { var tempX = Math.Cos(Math.PI * (inputArc.StartAngle + i * angleSubtract(inputArc.EndAngle, inputArc.StartAngle) / Length ) / 180) * inputArc.Radius + inputArc.Center.X; var tempY = Math.Sin(Math.PI * (inputArc.StartAngle + i * angleSubtract(inputArc.EndAngle, inputArc.StartAngle) / Length ) / 180) * inputArc.Radius + inputArc.Center.Y; CheckIfNewPointExtendArea(new Vector3(tempX, tempY, 0)); } } MinXMinY.Y -= 1; }
/// <summary> /// Initializes a new instance of the <c>RadialDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="rotation">Rotation in degrees of the dimension line.</param> /// <param name="offset">Distance between the reference point and the dimension text</param> /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param> /// <remarks>The center point and the definition point define the distance to be measure.</remarks> public RadialDimension(Arc arc, double rotation, double offset, DimensionStyle style) : base(DimensionType.Radius) { double angle = rotation * MathHelper.DegToRad; Vector3 point = MathHelper.Transform(new Vector3(arc.Radius * Math.Sin(angle), arc.Radius * Math.Cos(angle), 0.0), arc.Normal, MathHelper.CoordinateSystem.Object, MathHelper.CoordinateSystem.World); this.center = arc.Center; this.refPoint = arc.Center + point; this.offset = offset; if (style == null) throw new ArgumentNullException("style", "The Dimension style cannot be null."); this.style = style; }
void AddArc(netDxf.Entities.Arc a) { var c = new UnityEngine.Vector3((float)a.Center.X, (float)a.Center.Y, (float)a.Center.Z); var e = a.StartAngle; float sa = (float)a.StartAngle * Mathf.Deg2Rad; float ea = (float)a.EndAngle * Mathf.Deg2Rad; float r = (float)a.Radius; var rvs = new UnityEngine.Vector3(r * Mathf.Cos(sa), r * Mathf.Sin(sa), c.z) + c; var rve = new UnityEngine.Vector3(r * Mathf.Cos(ea), r * Mathf.Sin(ea), c.z) + c; ArcEntity arc = new ArcEntity(DetailEditor.instance.currentSketch.GetSketch()); arc.c.SetPosition(c); arc.p0.SetPosition(rvs); arc.p1.SetPosition(rve); }
/// <summary> /// Initializes a new instance of the <c>DiametricDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="rotation">Rotation in degrees of the dimension line.</param> /// <param name="offset">Distance between the reference point and the dimension text</param> /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param> /// <remarks>The center point and the definition point define the distance to be measure.</remarks> public DiametricDimension(Arc arc, double rotation, double offset, DimensionStyle style) : base(DimensionType.Diameter) { if (arc == null) throw new ArgumentNullException(nameof(arc)); Vector3 ocsCenter = MathHelper.Transform(arc.Center, arc.Normal, CoordinateSystem.World, CoordinateSystem.Object); this.center = new Vector2(ocsCenter.X, ocsCenter.Y); this.refPoint = Vector2.Polar(this.center, arc.Radius, rotation*MathHelper.DegToRad); this.offset = offset; if (style == null) throw new ArgumentNullException(nameof(style)); this.Style = style; this.Normal = arc.Normal; this.Elevation = ocsCenter.Z; }
public Path GetCanvasArc(netDxf.Entities.Arc arc, Vector3 startVector, double canvasHeight) { var startPoint = new Point(); startPoint.X = arc.Radius * Math.Cos(Math.PI * arc.StartAngle / 180) + arc.Center.X - startVector.X; startPoint.Y = -arc.Radius * Math.Sin(Math.PI * arc.StartAngle / 180) - arc.Center.Y + canvasHeight + startVector.Y; var endPoint = new Point(); endPoint.X = arc.Radius * Math.Cos(Math.PI * arc.EndAngle / 180) + arc.Center.X - startVector.X; endPoint.Y = -arc.Radius * Math.Sin(Math.PI * arc.EndAngle / 180) - arc.Center.Y + canvasHeight + startVector.Y; var g = new StreamGeometry(); StreamGeometryContext gc; using (gc = g.Open()) { gc.BeginFigure( startPoint, false, false); gc.ArcTo( endPoint, new Size(arc.Radius, arc.Radius), 180d, angleSubtract(arc.EndAngle, arc.StartAngle) > 180, SweepDirection.Counterclockwise, true, false); } var path = new Path { Stroke = Brushes.Black, StrokeThickness = 1, Data = g }; return(path); }
/// <summary> /// Convert a Nucleus arc to a netDXF one /// </summary> /// <param name="arc"></param> /// <returns></returns> public static nDE.EntityObject Convert(Arc arc) { if (arc.Closed) { var result = new nDE.Circle(Convert(arc.Circle.Origin), arc.Circle.Radius * ConversionScaling); result.Normal = Convert(arc.Circle.L, 1); SetAttributes(result, arc.Attributes); return(result); } else { Plane plane = new Plane(arc.Circle.Origin, arc.Circle.L); var result = new nDE.Arc(Convert(arc.Circle.Origin), arc.Circle.Radius * ConversionScaling, plane.GlobalToLocal(arc.StartPoint).Angle.Degrees, plane.GlobalToLocal(arc.EndPoint).Angle.Degrees); result.Normal = Convert(plane.Z, 1); SetAttributes(result, arc.Attributes); return(result); } }
/// <summary> /// Initializes a new instance of the <c>Angular3PointDimension</c> class. /// </summary> /// <param name="arc">Angle <see cref="Arc">arc</see> to measure.</param> /// <param name="offset">Distance between the center of the arc and the dimension line.</param> /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param> public Angular3PointDimension(Arc arc, double offset, DimensionStyle style) : base(DimensionType.Angular3Point) { if (arc == null) throw new ArgumentNullException(nameof(arc)); Vector3 refPoint = MathHelper.Transform(arc.Center, arc.Normal, CoordinateSystem.World, CoordinateSystem.Object); this.center = new Vector2(refPoint.X, refPoint.Y); this.start = Vector2.Polar(this.center, arc.Radius, arc.StartAngle*MathHelper.DegToRad); this.end = Vector2.Polar(this.center, arc.Radius, arc.EndAngle*MathHelper.DegToRad); if (MathHelper.IsZero(offset)) throw new ArgumentOutOfRangeException(nameof(offset), "The offset value cannot be zero."); this.offset = offset; if (style == null) throw new ArgumentNullException(nameof(style)); this.Style = style; this.Normal = arc.Normal; this.Elevation = refPoint.Z; }
/// <summary> /// Initializes a new instance of the <c>Angular3PointDimension</c> class. /// </summary> /// <param name="arc">Angle <see cref="Arc">arc</see> to measure.</param> /// <param name="offset">Distance between the center of the arc and the dimension line.</param> /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param> public Angular3PointDimension(Arc arc, double offset, DimensionStyle style) : base(DimensionType.Angular3Point) { this.center = arc.Center; Vector3 refPoint = MathHelper.Transform(arc.Center, arc.Normal, MathHelper.CoordinateSystem.World, MathHelper.CoordinateSystem.Object); Vector2 centerRef = new Vector2(refPoint.X, refPoint.Y); double elev = refPoint.Z; Vector2 ref1 = Vector2.Polar(centerRef, arc.Radius, arc.StartAngle * MathHelper.DegToRad); this.start = MathHelper.Transform(new Vector3(ref1.X, ref1.Y, elev), arc.Normal, MathHelper.CoordinateSystem.Object, MathHelper.CoordinateSystem.World); Vector2 ref2 = Vector2.Polar(centerRef, arc.Radius, arc.EndAngle * MathHelper.DegToRad); this.end = MathHelper.Transform(new Vector3(ref2.X, ref2.Y, elev), arc.Normal, MathHelper.CoordinateSystem.Object, MathHelper.CoordinateSystem.World); if (MathHelper.IsZero(offset)) throw new ArgumentOutOfRangeException("offset", "The offset value cannot be zero."); this.offset = offset; if (style == null) throw new ArgumentNullException("style", "The Dimension style cannot be null."); this.style = style; }
/// <summary> /// Initializes a new instance of the <c>Angular3PointDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="offset">Distance between the center of the arc and the dimension line.</param> public Angular3PointDimension(Arc arc, double offset) : this(arc, offset, DimensionStyle.Default) { }
private static void WriteDxfFile() { DxfDocument dxf = new DxfDocument(); //arc Arc arc = new Arc(new Vector3d(10, 10, 0), 10, 45, 135); arc.Layer = new Layer("arc"); arc.Layer.Color.Index = 1; dxf.AddEntity(arc); //xData sample XData xdata = new XData(new ApplicationRegistry("netDxf")); xdata.XDataRecord.Add(new XDataRecord(XDataCode.String, "extended data with netDxf")); xdata.XDataRecord.Add(XDataRecord.OpenControlString); xdata.XDataRecord.Add(new XDataRecord(XDataCode.WorldSpacePositionX, 0)); xdata.XDataRecord.Add(new XDataRecord(XDataCode.WorldSpacePositionY, 0)); xdata.XDataRecord.Add(new XDataRecord(XDataCode.WorldSpacePositionZ, 0)); xdata.XDataRecord.Add(XDataRecord.CloseControlString); XData xdata2 = new XData(new ApplicationRegistry("other application")); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.String, "extended data with netDxf")); xdata2.XDataRecord.Add(XDataRecord.OpenControlString); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.String, "string record")); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.Real, 15.5)); xdata2.XDataRecord.Add(new XDataRecord(XDataCode.Long, 350)); xdata2.XDataRecord.Add(XDataRecord.CloseControlString); //circle Vector3d extrusion = new Vector3d(1, 1, 1); Vector3d centerWCS = new Vector3d(1, 1, 1); Vector3d centerOCS = MathHelper.Transform(centerWCS, extrusion, MathHelper.CoordinateSystem.World, MathHelper.CoordinateSystem.Object); Circle circle = new Circle(centerOCS, 5); circle.Layer = new Layer("circle with spaces"); circle.Layer.Color=AciColor.Yellow; circle.LineType = LineType.Dashed; circle.Normal = extrusion; circle.XData=new Dictionary<ApplicationRegistry, XData> { {xdata.ApplicationRegistry, xdata}, {xdata2.ApplicationRegistry, xdata2} }; dxf.AddEntity(circle); //points Point point1 = new Point(new Vector3d(-3, -3, 0)); point1.Layer = new Layer("point"); point1.Color = new AciColor(30); Point point2 = new Point(new Vector3d(1, 1, 1)); point2.Layer = point1.Layer; point2.Layer.Color.Index = 9; point2.Normal = new Vector3d(1, 1, 1); dxf.AddEntity(point1); dxf.AddEntity(point2); //3dface Face3d face3D = new Face3d(new Vector3d(-5, -5, 5), new Vector3d(5, -5, 5), new Vector3d(5, 5, 5), new Vector3d(-5, 5, 5)); face3D.Layer = new Layer("3dface"); face3D.Layer.Color.Index = 3; dxf.AddEntity(face3D); //polyline PolylineVertex polyVertex; List<PolylineVertex> polyVertexes = new List<PolylineVertex>(); polyVertex = new PolylineVertex(new Vector2d(-50, -50)); polyVertex.BeginThickness = 2; polyVertexes.Add(polyVertex); polyVertex = new PolylineVertex(new Vector2d(50, -50)); polyVertex.BeginThickness = 1; polyVertexes.Add(polyVertex); polyVertex = new PolylineVertex(new Vector2d(50, 50)); polyVertex.Bulge = 1; polyVertexes.Add(polyVertex); polyVertex = new PolylineVertex(new Vector2d(-50, 50)); polyVertexes.Add(polyVertex); Polyline polyline2d = new Polyline(polyVertexes, true); polyline2d.Layer = new Layer("polyline2d"); polyline2d.Layer.Color.Index = 5; polyline2d.Normal = new Vector3d(1, 1, 1); polyline2d.Elevation = 100.0; dxf.AddEntity(polyline2d); //lightweight polyline LightWeightPolylineVertex lwVertex; List<LightWeightPolylineVertex> lwVertexes = new List<LightWeightPolylineVertex>(); lwVertex = new LightWeightPolylineVertex(new Vector2d(-25, -25)); lwVertex.BeginThickness = 2; lwVertexes.Add(lwVertex); lwVertex = new LightWeightPolylineVertex(new Vector2d(25, -25)); lwVertex.BeginThickness = 1; lwVertexes.Add(lwVertex); lwVertex = new LightWeightPolylineVertex(new Vector2d(25, 25)); lwVertex.Bulge = 1; lwVertexes.Add(lwVertex); lwVertex = new LightWeightPolylineVertex(new Vector2d(-25, 25)); lwVertexes.Add(lwVertex); LightWeightPolyline lwPolyline = new LightWeightPolyline(lwVertexes, true); lwPolyline.Layer = new Layer("lwpolyline"); lwPolyline.Layer.Color.Index = 5; lwPolyline.Normal = new Vector3d(1, 1, 1); lwPolyline.Elevation = 100.0; dxf.AddEntity(lwPolyline); //line Line line = new Line(new Vector3d(0, 0, 0), new Vector3d(10, 10, 10)); line.Layer = new Layer("line"); line.Layer.Color.Index = 6; dxf.AddEntity(line); //3d polyline Polyline3dVertex vertex; List<Polyline3dVertex> vertexes = new List<Polyline3dVertex>(); vertex = new Polyline3dVertex(new Vector3d(-50, -50, 0)); vertexes.Add(vertex); vertex = new Polyline3dVertex(new Vector3d(50, -50, 10)); vertexes.Add(vertex); vertex = new Polyline3dVertex(new Vector3d(50, 50, 25)); vertexes.Add(vertex); vertex = new Polyline3dVertex(new Vector3d(-50, 50, 50)); vertexes.Add(vertex); Polyline3d polyline = new Polyline3d(vertexes, true); polyline.Layer = new Layer("polyline3d"); polyline.Layer.Color.Index = 24; dxf.AddEntity(polyline); //block definition Block block = new Block("TestBlock"); block.Entities.Add(new Line(new Vector3d(-5, -5, 5), new Vector3d(5, 5, 5))); block.Entities.Add(new Line(new Vector3d(5, -5, 5), new Vector3d(-5, 5, 5))); //insert Insert insert = new Insert(block, new Vector3d(5, 5, 5)); insert.Layer = new Layer("insert"); insert.Layer.Color.Index = 4; dxf.AddEntity(insert); //text TextStyle style=new TextStyle("True type font","Arial.ttf"); Text text = new Text("Hello world!", Vector3d.Zero, 10.0f,style); text.Layer = new Layer("text"); text.Layer.Color.Index = 8; text.Alignment = TextAlignment.TopRight; dxf.AddEntity(text); dxf.Save("AutoCad2007.dxf", DxfVersion.AutoCad2007); dxf.Save("AutoCad2004.dxf", DxfVersion.AutoCad2004); dxf.Save("AutoCad2000.dxf", DxfVersion.AutoCad2000); dxf.Save("AutoCad12.dxf", DxfVersion.AutoCad12); }
/// <summary> /// Initializes a new instance of the <c>DiametricDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="rotation">Rotation in degrees of the dimension line.</param> /// <param name="offset">Distance between the reference point and the dimension text</param> /// <remarks>The center point and the definition point define the distance to be measure.</remarks> public DiametricDimension(Arc arc, double rotation, double offset) : this(arc, rotation, offset, DimensionStyle.Default) { }
/// <summary> /// Initializes a new instance of the <c>RadialDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="rotation">Rotation in degrees of the dimension line.</param> /// <param name="offset">Distance between the reference point and the dimension text</param> /// <remarks>The center point and the definition point define the distance to be measure.</remarks> public RadialDimension(Arc arc, double rotation, double offset) : this(arc, rotation, offset, DimensionStyle.Default) { }
private void WriteArc(Arc arc) { this.chunk.Write(100, SubclassMarker.Circle); this.chunk.Write(39, arc.Thickness); // this is just an example of the weird Autodesk dxf way of doing things, while an ellipse the center is given in world coordinates, // the center of an arc is given in object coordinates (different rules for the same concept). // It is a lot more intuitive to give the center in world coordinates and then define the orientation with the normal.. Vector3 ocsCenter = MathHelper.Transform(arc.Center, arc.Normal, CoordinateSystem.World, CoordinateSystem.Object); this.chunk.Write(10, ocsCenter.X); this.chunk.Write(20, ocsCenter.Y); this.chunk.Write(30, ocsCenter.Z); this.chunk.Write(40, arc.Radius); this.chunk.Write(210, arc.Normal.X); this.chunk.Write(220, arc.Normal.Y); this.chunk.Write(230, arc.Normal.Z); this.chunk.Write(100, SubclassMarker.Arc); this.chunk.Write(50, arc.StartAngle); this.chunk.Write(51, arc.EndAngle); this.WriteXData(arc.XData); }
private static EntityObject ProcessArc(Arc arc, Matrix3 trans, Vector3 pos) { arc.Center = trans * arc.Center + pos; arc.Normal = trans * arc.Normal; return(arc); }
private static EntityObject ProcessArc(Arc arc, Matrix3 trans, Vector3 pos) { arc.Center = trans*arc.Center + pos; arc.Normal = trans*arc.Normal; return arc; }
private void SetInternalInfo(ICollection <EntityObject> entities) { bool containsClosedPolyline = false; foreach (EntityObject entity in entities) { if ((this.pathTypeFlag & HatchBoundaryPathTypeFlags.Polyline) == HatchBoundaryPathTypeFlags.Polyline) { if (this.edges.Count >= 1) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } } // it seems that AutoCad does not have problems on creating loops that theoretically does not make sense, like, for example an internal loop that is made of a single arc. // so if AutoCAD is ok with that I am too, the program that make use of this information will take care of this inconsistencies switch (entity.Type) { case EntityType.Arc: if (containsClosedPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Arc.ConvertFrom(entity)); break; case EntityType.Circle: if (containsClosedPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Arc.ConvertFrom(entity)); break; case EntityType.Ellipse: if (containsClosedPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Ellipse.ConvertFrom(entity)); break; case EntityType.Line: if (containsClosedPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Line.ConvertFrom(entity)); break; case EntityType.LightWeightPolyline: if (containsClosedPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } LwPolyline poly = (LwPolyline)entity; if (poly.IsClosed) { this.edges.Add(Polyline.ConvertFrom(entity)); // A polyline HatchBoundaryPath must be closed this.pathTypeFlag |= HatchBoundaryPathTypeFlags.Polyline; containsClosedPolyline = true; } else { this.SetInternalInfo(poly.Explode()); // open polylines will always be exploded, only one polyline can be present in a path } break; case EntityType.Spline: if (containsClosedPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Spline.ConvertFrom(entity)); break; default: throw new ArgumentException(string.Format("The entity type {0} cannot be part of a hatch boundary.", entity.Type)); } } }
/// <summary> /// Explodes the current insert. /// </summary> /// <returns>A list of entities.</returns> public List <EntityObject> Explode() { List <EntityObject> entities = new List <EntityObject>(); Matrix3 transformation = this.GetTransformation(); Vector3 translation = this.Position - transformation * this.block.Origin; foreach (EntityObject entity in this.block.Entities) { Vector3 localScale = MathHelper.Transform(this.Scale, entity.Normal, CoordinateSystem.World, CoordinateSystem.Object); bool isUniformScale = MathHelper.IsEqual(localScale.X, localScale.Y); // entities with reactors are associated with other entities they will handle the transformation if (entity.Reactors.Count > 0) { continue; } if (!isUniformScale) { switch (entity.Type) { case EntityType.Circle: { Circle circle = (Circle)entity; Ellipse ellipse = new Ellipse { //EntityObject properties Layer = (Layer)entity.Layer.Clone(), Linetype = (Linetype)entity.Linetype.Clone(), Color = (AciColor)entity.Color.Clone(), Lineweight = entity.Lineweight, Transparency = (Transparency)entity.Transparency.Clone(), LinetypeScale = entity.LinetypeScale, Normal = entity.Normal, IsVisible = entity.IsVisible, //Ellipse properties Center = circle.Center, MajorAxis = 2 * circle.Radius, MinorAxis = 2 * circle.Radius, Thickness = circle.Thickness }; ellipse.TransformBy(transformation, translation); entities.Add(ellipse); break; } case EntityType.Arc: { Arc arc = (Arc)entity; Ellipse ellipse = new Ellipse { //EntityObject properties Layer = (Layer)entity.Layer.Clone(), Linetype = (Linetype)entity.Linetype.Clone(), Color = (AciColor)entity.Color.Clone(), Lineweight = entity.Lineweight, Transparency = (Transparency)entity.Transparency.Clone(), LinetypeScale = entity.LinetypeScale, Normal = entity.Normal, IsVisible = entity.IsVisible, //Ellipse properties Center = arc.Center, MajorAxis = 2 * arc.Radius, MinorAxis = 2 * arc.Radius, StartAngle = arc.StartAngle, EndAngle = arc.EndAngle, Thickness = arc.Thickness }; ellipse.TransformBy(transformation, translation); entities.Add(ellipse); break; } case EntityType.LwPolyline: { List <EntityObject> newEntities = ((LwPolyline)entity).Explode(); foreach (EntityObject newEntity in newEntities) { if (newEntity.Type == EntityType.Arc) { Arc arc = (Arc)newEntity; Ellipse ellipse = new Ellipse { //EntityObject properties Layer = (Layer)entity.Layer.Clone(), Linetype = (Linetype)entity.Linetype.Clone(), Color = (AciColor)entity.Color.Clone(), Lineweight = entity.Lineweight, Transparency = (Transparency)entity.Transparency.Clone(), LinetypeScale = entity.LinetypeScale, Normal = entity.Normal, IsVisible = entity.IsVisible, //Ellipse properties Center = arc.Center, MajorAxis = 2 * arc.Radius, MinorAxis = 2 * arc.Radius, StartAngle = arc.StartAngle, EndAngle = arc.EndAngle, Thickness = arc.Thickness }; ellipse.TransformBy(transformation, translation); entities.Add(ellipse); } else { newEntity.TransformBy(transformation, translation); entities.Add(newEntity); } } break; } case EntityType.MLine: { List <EntityObject> newEntities = ((MLine)entity).Explode(); foreach (EntityObject newEntity in newEntities) { if (newEntity.Type == EntityType.Arc) { Arc arc = (Arc)newEntity; Ellipse ellipse = new Ellipse { //EntityObject properties Layer = (Layer)entity.Layer.Clone(), Linetype = (Linetype)entity.Linetype.Clone(), Color = (AciColor)entity.Color.Clone(), Lineweight = entity.Lineweight, Transparency = (Transparency)entity.Transparency.Clone(), LinetypeScale = entity.LinetypeScale, Normal = entity.Normal, IsVisible = entity.IsVisible, //Ellipse properties Center = arc.Center, MajorAxis = 2 * arc.Radius, MinorAxis = 2 * arc.Radius, StartAngle = arc.StartAngle, EndAngle = arc.EndAngle, Thickness = arc.Thickness }; ellipse.TransformBy(transformation, translation); entities.Add(ellipse); } else { newEntity.TransformBy(transformation, translation); entities.Add(newEntity); } } break; } default: { EntityObject newEntity = (EntityObject)entity.Clone(); newEntity.TransformBy(transformation, translation); entities.Add(newEntity); break; } } } else { EntityObject newEntity = (EntityObject)entity.Clone(); newEntity.TransformBy(transformation, translation); entities.Add(newEntity); } } foreach (Attribute attribute in this.attributes) { // the attributes will be exploded as a Text entity Text text = new Text { //Attribute properties Layer = (Layer)attribute.Layer.Clone(), Linetype = (Linetype)attribute.Linetype.Clone(), Color = (AciColor)attribute.Color.Clone(), Lineweight = attribute.Lineweight, Transparency = (Transparency)attribute.Transparency.Clone(), LinetypeScale = attribute.LinetypeScale, Normal = attribute.Normal, IsVisible = attribute.IsVisible, Height = attribute.Height, WidthFactor = attribute.WidthFactor, ObliqueAngle = attribute.ObliqueAngle, Value = attribute.Value.ToString(), Style = (TextStyle)attribute.Style.Clone(), Position = attribute.Position, Rotation = attribute.Rotation, Alignment = attribute.Alignment, IsBackward = attribute.IsBackward, IsUpsideDown = attribute.IsUpsideDown }; entities.Add(text); } return(entities); }
/// <summary> /// Gets the the block that contains the entities that make up the dimension picture. /// </summary> /// <param name="name">Name to be asigned to the generated block.</param> /// <returns>The block that represents the actual dimension.</returns> internal override Block BuildBlock(string name) { // we will build the dimension block in object coordinates with normal the dimension normal Vector3 localPoint = MathHelper.Transform(this.center, this.normal, MathHelper.CoordinateSystem.World, MathHelper.CoordinateSystem.Object); Vector2 refCenter = new Vector2(localPoint.X, localPoint.Y); localPoint = MathHelper.Transform(this.start, this.normal, MathHelper.CoordinateSystem.World, MathHelper.CoordinateSystem.Object); Vector2 refStart = new Vector2(localPoint.X, localPoint.Y); localPoint = MathHelper.Transform(this.end, this.normal, MathHelper.CoordinateSystem.World, MathHelper.CoordinateSystem.Object); Vector2 refEnd = new Vector2(localPoint.X, localPoint.Y); double elev = localPoint.Z; // reference points Layer defPoints = new Layer("Defpoints") { Plot = false }; Point startRef = new Point(refStart) { Layer = defPoints }; Point endRef = new Point(refEnd) { Layer = defPoints }; Point centerPoint = new Point(refCenter) { Layer = defPoints }; // dimension lines double startAngle = Vector2.Angle(refCenter, refStart); double endAngle = Vector2.Angle(refCenter, refEnd); Vector2 startArc = Vector2.Polar(refCenter, this.offset, startAngle); Line startBorder = new Line(Vector2.Polar(refStart, this.style.DIMEXO, startAngle), Vector2.Polar(startArc, this.style.DIMEXE, startAngle)); Vector2 endArc = Vector2.Polar(refCenter, this.offset, endAngle); Line endBorder = new Line(Vector2.Polar(refEnd, this.style.DIMEXO, endAngle), Vector2.Polar(endArc, this.style.DIMEXE, endAngle)); Arc dimArc = new Arc(refCenter, this.offset, startAngle * MathHelper.RadToDeg, endAngle * MathHelper.RadToDeg); // dimension arrows Vector2 arrowRefBegin = Vector2.Polar(startArc, this.style.DIMASZ, startAngle + MathHelper.HalfPI); Solid arrowBegin = new Solid(startArc, Vector2.Polar(arrowRefBegin, -this.style.DIMASZ / 6, startAngle), Vector2.Polar(arrowRefBegin, this.style.DIMASZ / 6, startAngle), startArc); Vector2 arrowRefEnd = Vector2.Polar(endArc, -this.style.DIMASZ, endAngle + MathHelper.HalfPI); Solid arrowEnd = new Solid(endArc, Vector2.Polar(arrowRefEnd, this.style.DIMASZ / 6, endAngle), Vector2.Polar(arrowRefEnd, -this.style.DIMASZ / 6, endAngle), endArc); // dimension text double aperture = this.Value; double rotText = Vector2.Angle(endArc, startArc); Vector2 midText = Vector2.Polar(refCenter, this.offset + this.style.DIMGAP, startAngle + aperture * MathHelper.DegToRad * 0.5); this.definitionPoint = MathHelper.Transform(new Vector3(midText.X, midText.Y, elev), this.normal, MathHelper.CoordinateSystem.Object, MathHelper.CoordinateSystem.World); this.midTextPoint = new Vector3(midText.X, midText.Y, elev); // this value is in OCS MText text = new MText(this.FormatDimensionText(aperture), this.midTextPoint, this.style.DIMTXT, 0.0, this.style.TextStyle) { AttachmentPoint = MTextAttachmentPoint.BottomCenter, Rotation = rotText * MathHelper.RadToDeg }; // drawing block Block dim = new Block(name); dim.Entities.Add(startRef); dim.Entities.Add(endRef); dim.Entities.Add(centerPoint); dim.Entities.Add(startBorder); dim.Entities.Add(endBorder); dim.Entities.Add(dimArc); dim.Entities.Add(arrowBegin); dim.Entities.Add(arrowEnd); dim.Entities.Add(text); this.block = dim; return(dim); }
/// <summary> /// Initializes a new instance of the <c>RadialDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="rotation">Rotation in degrees of the dimension line.</param> /// <remarks>The center point and the definition point define the distance to be measure.</remarks> public RadialDimension(Arc arc, double rotation) : this(arc, rotation, DimensionStyle.Default) { }
private static void Angular3PointDimension() { DxfDocument dxf = new DxfDocument(); DimensionStyle myStyle = CreateDimStyle(); Vector3 center = new Vector3(1, 2, 0); double radius = 2.42548; Arc arc = new Arc(center, radius, -30, 60); Angular3PointDimension dim1 = new Angular3PointDimension(arc, 5, myStyle); Angular3PointDimension dim2 = new Angular3PointDimension(arc, -5, myStyle); dxf.AddEntity(arc); dxf.AddEntity(dim1); dxf.AddEntity(dim2); dxf.Save("dimension drawing.dxf"); dxf = DxfDocument.Load("dimension drawing.dxf"); }
private void SetInternalInfo(IEnumerable <EntityObject> contour, bool clearEdges) { bool containsPolyline = false; if (clearEdges) { this.edges.Clear(); } foreach (EntityObject entity in contour) { if (containsPolyline) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } // it seems that AutoCad does not have problems on creating loops that theoretically does not make sense, // like, for example, an internal loop that is made of a single arc. // so if AutoCAD is OK with that I am too, the program that make use of this information will take care of this inconsistencies switch (entity.Type) { case EntityType.Arc: this.edges.Add(Arc.ConvertFrom(entity)); break; case EntityType.Circle: this.edges.Add(Arc.ConvertFrom(entity)); break; case EntityType.Ellipse: this.edges.Add(Ellipse.ConvertFrom(entity)); break; case EntityType.Line: this.edges.Add(Line.ConvertFrom(entity)); break; case EntityType.LwPolyline: Entities.LwPolyline lwpoly = (Entities.LwPolyline)entity; if (lwpoly.IsClosed) { if (this.edges.Count != 0) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Polyline.ConvertFrom(entity)); this.pathType |= HatchBoundaryPathTypeFlags.Polyline; containsPolyline = true; } else { this.SetInternalInfo(lwpoly.Explode(), false); // open polylines will always be exploded, only one polyline can be present in a path } break; case EntityType.Polyline: Entities.Polyline poly = (Entities.Polyline)entity; if (poly.IsClosed) { if (this.edges.Count != 0) { throw new ArgumentException("Closed polylines cannot be combined with other entities to make a hatch boundary path."); } this.edges.Add(Polyline.ConvertFrom(entity)); this.pathType |= HatchBoundaryPathTypeFlags.Polyline; containsPolyline = true; } else { this.SetInternalInfo(poly.Explode(), false); // open polylines will always be exploded, only one polyline can be present in a path } break; case EntityType.Spline: this.edges.Add(Spline.ConvertFrom(entity)); break; default: throw new ArgumentException(string.Format("The entity type {0} cannot be part of a hatch boundary. Only Arc, Circle, Ellipse, Line, LwPolyline, and Spline entities are allowed.", entity.Type)); } } }
public static Arc3D ToArc3D(this netDxf.Entities.Arc dxf_arc) { return(new Arc3D(new CoordinateSystem3D(dxf_arc.Center, dxf_arc.Normal, CoordinateSystem3DAutoEnum.AAA), dxf_arc.Radius, dxf_arc.StartAngle.ToRad(), dxf_arc.EndAngle.ToRad())); }
private Arc ReadArc() { Vector3 center = Vector3.Zero; double radius = 1.0; double startAngle = 0.0; double endAngle = 180.0; double thickness = 0.0; Vector3 normal = Vector3.UnitZ; List<XData> xData = new List<XData>(); this.chunk.Next(); while (this.chunk.Code != 0) { switch (this.chunk.Code) { case 10: center.X = this.chunk.ReadDouble(); this.chunk.Next(); break; case 20: center.Y = this.chunk.ReadDouble(); this.chunk.Next(); break; case 30: center.Z = this.chunk.ReadDouble(); this.chunk.Next(); break; case 40: radius = this.chunk.ReadDouble(); if (radius <= 0) radius = 1.0; this.chunk.Next(); break; case 50: startAngle = this.chunk.ReadDouble(); this.chunk.Next(); break; case 51: endAngle = this.chunk.ReadDouble(); this.chunk.Next(); break; case 39: thickness = this.chunk.ReadDouble(); this.chunk.Next(); break; case 210: normal.X = this.chunk.ReadDouble(); this.chunk.Next(); break; case 220: normal.Y = this.chunk.ReadDouble(); this.chunk.Next(); break; case 230: normal.Z = this.chunk.ReadDouble(); this.chunk.Next(); break; case 1001: string appId = this.DecodeEncodedNonAsciiCharacters(this.chunk.ReadString()); XData data = this.ReadXDataRecord(this.GetApplicationRegistry(appId)); xData.Add(data); break; default: if (this.chunk.Code >= 1000 && this.chunk.Code <= 1071) throw new Exception("The extended data of an entity must start with the application registry code."); this.chunk.Next(); break; } } // this is just an example of the stupid autodesk dxf way of doing things, while an ellipse the center is given in world coordinates, // the center of an arc is given in object coordinates (different rules for the same concept). // It is a lot more intuitive to give the center in world coordinates and then define the orientation with the normal.. Vector3 wcsCenter = MathHelper.Transform(center, normal, CoordinateSystem.Object, CoordinateSystem.World); Arc entity = new Arc { Center = wcsCenter, Radius = radius, StartAngle = startAngle, EndAngle = endAngle, Thickness = thickness, Normal = normal }; entity.XData.AddRange(xData); return entity; }
/// <summary> /// Convert a netDXF arc to a Nucleus one /// </summary> /// <param name="arc"></param> /// <returns></returns> public static Arc Convert(netDxf.Entities.Arc arc) { Circle circ = new Circle(arc.Radius * ConversionScaling, Convert(arc.Center), Convert(arc.Normal, 1)); return(new Arc(circ, Angle.FromDegrees(arc.StartAngle), Angle.FromDegrees(arc.EndAngle), ExtractAttributes(arc))); }
void ReadArc(netDxf.Entities.Arc arc, double x, double y) { // TODO : }
/// <summary> /// Initializes a new instance of the <c>RadialDimension</c> class. /// </summary> /// <param name="arc"><see cref="Arc">Arc</see> to measure.</param> /// <param name="rotation">Rotation in degrees of the dimension line.</param> /// <param name="style">The <see cref="DimensionStyle">style</see> to use with the dimension.</param> /// <remarks>The center point and the definition point define the distance to be measure.</remarks> public RadialDimension(Arc arc, double rotation, DimensionStyle style) : this(arc.Center, arc.Radius, rotation, style) { this.normal = arc.Normal; }
void WriteArc(ArcGeometry line) { IPointGeometry center = line.Circle.Center; double bcAngle = GetAngle(center, line.BC); double ecAngle = GetAngle(center, line.EC); Arc acLine = new Arc(); acLine.Center = new Vector3d(center.X, center.Y, 0.0); acLine.Radius = line.Circle.Radius; // AutoCad arcs are *always* drawn counter-clockwise if (line.IsClockwise) { acLine.StartAngle = ecAngle; acLine.EndAngle = bcAngle; } else { acLine.StartAngle = bcAngle; acLine.EndAngle = ecAngle; } acLine.Layer = m_Layer; m_Dxf.AddEntity(acLine); }
private static void Angular3PointDimension() { DxfDocument dxf = new DxfDocument(); DimensionStyle myStyle = CreateDimStyle(); myStyle.DIMADEC = 4; myStyle.DIMAUNIT = AngleUnitType.DegreesMinutesSeconds; Vector3 center = new Vector3(1, 2, 0); double radius = 2.5; Arc arc = new Arc(center, radius, -32.8, 160.5); Angular3PointDimension dim1 = new Angular3PointDimension(arc, 5, myStyle); Angular3PointDimension dim2 = new Angular3PointDimension(arc, -5, myStyle); dxf.AddEntity(arc); dxf.AddEntity(dim1); dxf.AddEntity(dim2); dxf.Save("dimension drawing.dxf"); dxf = DxfDocument.Load("dimension drawing.dxf"); DxfDocument doc = new DxfDocument(); foreach (var c in dxf.Circles) { doc.AddEntity((EntityObject)c.Clone()); } foreach (var d in dxf.Dimensions) { doc.AddEntity((EntityObject)d.Clone()); } doc.Save("dimension drawing saved.dxf"); }
public override object Clone() { Arc copy = new Arc { Center = this.Center, Radius = this.Radius, StartAngle = this.StartAngle, EndAngle = this.EndAngle, IsCounterclockwise = this.IsCounterclockwise }; return copy; }
/// <summary> /// Creates a new Arc that is a copy of the current instance. /// </summary> /// <returns>A new Arc that is a copy of this instance.</returns> public override object Clone() { Arc entity = new Arc { //EntityObject properties Layer = (Layer) this.Layer.Clone(), Linetype = (Linetype) this.Linetype.Clone(), Color = (AciColor) this.Color.Clone(), Lineweight = this.Lineweight, Transparency = (Transparency) this.Transparency.Clone(), LinetypeScale = this.LinetypeScale, Normal = this.Normal, IsVisible = this.IsVisible, //Arc properties Center = this.center, Radius = this.radius, StartAngle = this.startAngle, EndAngle = this.endAngle, Thickness = this.thickness }; foreach (XData data in this.XData.Values) entity.XData.Add((XData) data.Clone()); return entity; }
private void WriteArc(Arc arc) { if (this.activeSection != StringCode.EntitiesSection && !this.isBlockEntities) { throw new InvalidDxfSectionException(this.activeSection, this.file); } this.WriteCodePair(0, arc.CodeName); this.WriteCodePair(5, arc.Handle); this.WriteCodePair(100, SubclassMarker.Entity); this.WriteEntityCommonCodes(arc); this.WriteCodePair(100, SubclassMarker.Circle); this.WriteCodePair(39, arc.Thickness); this.WriteCodePair(10, arc.Center.X); this.WriteCodePair(20, arc.Center.Y); this.WriteCodePair(30, arc.Center.Z); this.WriteCodePair(40, arc.Radius); this.WriteCodePair(210, arc.Normal.X); this.WriteCodePair(220, arc.Normal.Y); this.WriteCodePair(230, arc.Normal.Z); this.WriteCodePair(100, SubclassMarker.Arc); this.WriteCodePair(50, arc.StartAngle); this.WriteCodePair(51, arc.EndAngle); this.WriteXData(arc.XData); }
private static void HatchTest3() { DxfDocument dxf = new DxfDocument(); LwPolyline poly = new LwPolyline(); poly.Vertexes.Add(new LwPolylineVertex(-10, -10)); poly.Vertexes.Add(new LwPolylineVertex(10, -10)); poly.Vertexes.Add(new LwPolylineVertex(10, 10)); poly.Vertexes.Add(new LwPolylineVertex(-10, 10)); poly.Vertexes[2].Bulge = 1; poly.IsClosed = true; Ellipse ellipse = new Ellipse(Vector3.Zero, 16, 10); ellipse.Rotation = 0; ellipse.StartAngle = 0; ellipse.EndAngle = 180; LwPolyline poly2 = new LwPolyline(); poly2.Vertexes.Add(new LwPolylineVertex(-8, 0)); poly2.Vertexes.Add(new LwPolylineVertex(0, -4)); poly2.Vertexes.Add(new LwPolylineVertex(8, 0)); Arc arc = new Arc(Vector3.Zero,8,180,0); Line line =new Line(new Vector3(8,0,0), new Vector3(-8,0,0)); List<HatchBoundaryPath> boundary = new List<HatchBoundaryPath>{ new HatchBoundaryPath(new List<EntityObject>{poly}), new HatchBoundaryPath(new List<EntityObject>{poly2, ellipse}) }; Hatch hatch = new Hatch(HatchPattern.Line, boundary); hatch.Pattern.Angle = 45; dxf.AddEntity(poly); dxf.AddEntity(ellipse); //dxf.AddEntity(arc); //dxf.AddEntity(line); dxf.AddEntity(poly2); dxf.AddEntity(hatch); dxf.Save("hatchTest3.dxf"); }
private Arc ReadArc(ref CodeValuePair code) { var arc = new Arc(); Vector3d center = Vector3d.Zero; Vector3d normal = Vector3d.UnitZ; Dictionary<ApplicationRegistry, XData> xData = new Dictionary<ApplicationRegistry, XData>(); code = this.ReadCodePair(); while (code.Code != 0) { switch (code.Code) { case 5: arc.Handle = code.Value; code = this.ReadCodePair(); break; case 8: //layer code arc.Layer = this.GetLayer(code.Value); code = this.ReadCodePair(); break; case 62: //aci color code arc.Color = new AciColor(short.Parse(code.Value)); code = this.ReadCodePair(); break; case 6: //type line code arc.LineType = this.GetLineType(code.Value); code = this.ReadCodePair(); break; case 10: center.X = double.Parse(code.Value); code = this.ReadCodePair(); break; case 20: center.Y = double.Parse(code.Value); code = this.ReadCodePair(); break; case 30: center.Z = double.Parse(code.Value); code = this.ReadCodePair(); break; case 40: arc.Radius = double.Parse(code.Value); code = this.ReadCodePair(); break; case 50: arc.StartAngle = double.Parse(code.Value); code = this.ReadCodePair(); break; case 51: arc.EndAngle = double.Parse(code.Value); code = this.ReadCodePair(); break; case 39: arc.Thickness = float.Parse(code.Value); code = this.ReadCodePair(); break; case 210: normal.X = double.Parse(code.Value); code = this.ReadCodePair(); break; case 220: normal.Y = double.Parse(code.Value); code = this.ReadCodePair(); break; case 230: normal.Z = double.Parse(code.Value); code = this.ReadCodePair(); break; case 1001: XData xDataItem = this.ReadXDataRecord(code.Value, ref code); xData.Add(xDataItem.ApplicationRegistry, xDataItem); break; default: if (code.Code >= 1000 && code.Code <= 1071) throw new DxfInvalidCodeValueEntityException(code.Code, code.Value, this.file, "The extended data of an entity must start with the application registry code " + this.fileLine); code = this.ReadCodePair(); break; } } arc.XData = xData; arc.Center = center; arc.Normal = normal; return arc; }
private static void ToPolyline() { DxfDocument dxf = new DxfDocument(); Vector3 center = new Vector3(1, 8, -7); Vector3 normal = new Vector3(1, 1, 1); Circle circle = new Circle(center, 7.5); circle.Normal = normal; Arc arc = new Arc(center, 5, -45, 45); arc.Normal = normal; Ellipse ellipse = new Ellipse(center, 15, 7.5); ellipse.Rotation = 35; ellipse.Normal = normal; Ellipse ellipseArc = new Ellipse(center, 10, 5); ellipseArc.StartAngle = 315; ellipseArc.EndAngle = 45; ellipseArc.Rotation = 35; ellipseArc.Normal = normal; dxf.AddEntity(circle); dxf.AddEntity(circle.ToPolyline(10)); dxf.AddEntity(arc); dxf.AddEntity(arc.ToPolyline(10)); dxf.AddEntity(ellipse); dxf.AddEntity(ellipse.ToPolyline(10)); dxf.AddEntity(ellipseArc); dxf.AddEntity(ellipseArc.ToPolyline(10)); dxf.Save("to polyline.dxf"); dxf = DxfDocument.Load("to polyline.dxf"); dxf.Save("to polyline2.dxf"); }
/*Draw Arc*/ public static void DrawArc(netDxf.Entities.Arc arc, Canvas mainCanvas) { System.Windows.Shapes.Path path = new System.Windows.Shapes.Path(); path.Stroke = System.Windows.Media.Brushes.Black; path.StrokeThickness = 1; System.Windows.Point endPoint = new System.Windows.Point( (arc.Center.X + Math.Cos(arc.StartAngle * Math.PI / 180) * arc.Radius), mainCanvas.Height - (arc.Center.Y + Math.Sin(arc.StartAngle * Math.PI / 180) * arc.Radius)); System.Windows.Point startPoint = new System.Windows.Point( (arc.Center.X + Math.Cos(arc.EndAngle * Math.PI / 180) * arc.Radius), mainCanvas.Height - (arc.Center.Y + Math.Sin(arc.EndAngle * Math.PI / 180) * arc.Radius)); Debug.WriteLine("debut:"+startPoint.Y+" fin:"+endPoint.Y); getMaxPt((arc.Center.X + Math.Cos(arc.StartAngle * Math.PI / 180) * arc.Radius), (arc.Center.Y + Math.Sin(arc.StartAngle * Math.PI / 180) * arc.Radius)); getMaxPt((arc.Center.X + Math.Cos(arc.EndAngle * Math.PI / 180) * arc.Radius), (arc.Center.Y + Math.Sin(arc.EndAngle * Math.PI / 180) * arc.Radius)); ArcSegment arcSegment = new ArcSegment(); double sweep = 0.0; if (arc.EndAngle < arc.StartAngle) sweep = (360 + arc.EndAngle) - arc.StartAngle; else sweep = Math.Abs(arc.EndAngle - arc.StartAngle); arcSegment.IsLargeArc = sweep >= 180; arcSegment.Point = endPoint; arcSegment.Size = new System.Windows.Size(arc.Radius, arc.Radius); arcSegment.SweepDirection = arc.Normal.Z >= 0 ? SweepDirection.Clockwise : SweepDirection.Counterclockwise; PathGeometry geometry = new PathGeometry(); PathFigure pathFigure = new PathFigure(); pathFigure.StartPoint = startPoint; pathFigure.Segments.Add(arcSegment); geometry.Figures.Add(pathFigure); path.Data = geometry; TypeConverter.Entity2Shape(arc, path); if(arc.StartAngle <=90 && arc.EndAngle >=90) { //Debug.WriteLine("ARC Blue "+arc.Center.ToString()+" R:"+arc.Radius+" start:"+arc.StartAngle+" end:"+arc.EndAngle); getMaxPt((arc.Center.X), (arc.Center.Y + arc.Radius)); } if(arc.StartAngle <=180 && arc.EndAngle >=180) { //Debug.WriteLine("ARC Red "+arc.Center.ToString()+" R:"+arc.Radius+" start:"+arc.StartAngle+" end:"+arc.EndAngle); getMaxPt((arc.Center.X - arc.Radius), (arc.Center.Y)); } if(arc.StartAngle <=270 && arc.EndAngle >=270) { //Debug.WriteLine("ARC Green "+arc.Center.ToString()+" R:"+arc.Radius+" start:"+arc.StartAngle+" end:"+arc.EndAngle); getMaxPt((arc.Center.X), (arc.Center.Y - arc.Radius)); } if(arc.StartAngle <=380 && arc.EndAngle >=0 && arc.StartAngle>arc.EndAngle) { //Debug.WriteLine("ARC Green "+arc.Center.ToString()+" R:"+arc.Radius+" start:"+arc.StartAngle+" end:"+arc.EndAngle); getMaxPt((arc.Center.X + arc.Radius), (arc.Center.Y)); } mainCanvas.Children.Add(path); }
public void DrawArc( string strLayer, Vec2 vCentre, double dRadius, double dStartAngle, double dEndAngle ) { Arc a = new Arc( new Vector3d( vCentre.x, vCentre.y, 0 ), dRadius, dStartAngle, dEndAngle ); a.Layer = m_layers[ strLayer ]; m_dxf.AddEntity( a ); }
private static void DocumentUnits() { DxfDocument dxf = new DxfDocument(); // setting the LUnit variable to engineering or architectural will also set the InsUnits variable to Inches, // this need to be this way since AutoCad will show those units in feet and inches and will always consider the drawing base units as inches. // You can change again the InsUnits it at your own risk. // its main purpose is at the user interface level //dxf.DrawingVariables.LUnits = LinearUnitType.Engineering; // this is the recommended document unit type dxf.DrawingVariables.LUnits = LinearUnitType.Decimal; // this is the real important unit, // it is used when inserting blocks or images into the drawing as this and the block units will give the scale of the resulting Insert dxf.DrawingVariables.InsUnits = DrawingUnits.Millimeters; // the angle unit type is purely cosmetic as it has no influence on how the angles are stored in the dxf // its purpose is only at the user interface level dxf.DrawingVariables.AUnits = AngleUnitType.Radians; // even though we have set the drawing angles in radians the dxf always stores angle data in degrees, // this arc goes from 45 to 270 degrees and not radians or whatever the AUnits header variable says. Arc arc = new Arc(Vector2.Zero, 5, 45, 270); // Remember, at the moment, once the entity has been added to the document is not safe to modify it, changes in some of their properties might generate problems dxf.AddEntity(arc); // the units of this line will correspond to the ones set in InsUnits Line lineM = new Line(new Vector2(-5, -5), new Vector2(5, 5)); dxf.AddEntity(lineM); // All entities added to a block are expressed in the coordinates defined by the block // You can set a default unit so all new blocks will use them, the default value is Unitless // You might want to use the same units as the drawing, this is just a convenient way to make sure all blocks share the same units BlockRecord.DefaultUnits = dxf.DrawingVariables.InsUnits; // In this case the line will be 10 cm long Line lineCm = new Line(new Vector2(-5, 0), new Vector2(5, 0)); Block blockCm = new Block("CmBlock"); // You can override the default units changing the block.Record.Units value blockCm.Record.Units = DrawingUnits.Centimeters; blockCm.Entities.Add(lineCm); Insert insCm = new Insert(blockCm); // In this case the line will be 10 dm long Line lineDm = new Line(new Vector2(0, 5), new Vector2(0, -5)); Block blockDm = new Block("DmBlock"); blockDm.Record.Units = DrawingUnits.Decimeters; // AllowExploding and ScaleUniformy properties will only be recognized by dxf version AutoCad2007 and upwards blockDm.Record.AllowExploding = false; blockDm.Record.ScaleUniformly = true; blockDm.Entities.Add(lineDm); blockDm.Entities.Add(insCm); Insert insDm = new Insert(blockDm); dxf.AddEntity(insDm); // the image units are stored in the raster variables units, it is recommended to use the same units as the document to avoid confusions dxf.RasterVariables.Units = ImageUnits.Millimeters; // Sometimes AutoCad does not like image file relative paths, in any case reloading the references will fix the problem ImageDefinition imgDefinition = new ImageDefinition("image.jpg"); // the resolution units is only used to calculate the image resolution that will return pixels per inch or per centimeter (the use of NoUnits is not recommended). imgDefinition.ResolutionUnits = ImageResolutionUnits.Inches; // this image will be 10x10 mm in size Image img = new Image(imgDefinition, Vector3.Zero, 10, 10); dxf.AddEntity(img); dxf.Save("Document Units.dxf"); DxfDocument dxfLoad = DxfDocument.Load("Document Units.dxf"); }
private static void Ellipse() { DxfDocument dxf = new DxfDocument(); Line line = new Line(new Vector3d(0, 0, 0), new Vector3d((2 * Math.Cos(Math.PI / 4)), (2 * Math.Cos(Math.PI / 4)), 0)); dxf.AddEntity(line); Line line2 = new Line(new Vector3d(0, 0, 0), new Vector3d(0, -2, 0)); dxf.AddEntity(line2); Arc arc=new Arc(Vector3d.Zero,2,45,270); dxf.AddEntity(arc); // ellipses are saved as polylines Ellipse ellipse = new Ellipse(new Vector3d(2,2,0), 5,3); ellipse.Rotation = 30; ellipse.Normal=new Vector3d(1,1,1); ellipse.Thickness = 2; dxf.AddEntity(ellipse); dxf.Save("ellipse.dxf", DxfVersion.AutoCad2000); dxf = new DxfDocument(); dxf.Load("ellipse.dxf"); }
/// <summary> /// 门把手绘制 /// </summary> /// <param name="dxf"></param> /// <param name="location"></param> public static void Draw(DxfDocument dxf, Location location) { float factor = 0.05f; float distance = 30; //底部小圆的圆心 Vector3f sCircle = new Vector3f(location.X + 10 * factor, location.Y, location.Z); //上部同心圆圆心 Vector3f bCircle = new Vector3f(location.X + 10 * factor, location.Y + 5 * factor + distance*factor, location.Z); double alpha = Math.Asin(3 / distance); double beta = Math.Acos(0.8); Vector3f v1 = new Vector3f( location.X + 10 * factor - float.Parse((5 * factor * Math.Cos(alpha)).ToString()), location.Y + 5 * factor - float.Parse((5 * factor * Math.Sin(alpha)).ToString()), location.Z); Vector3f v2 = new Vector3f( location.X + 10 * factor + float.Parse((5 * factor * Math.Cos(alpha)).ToString()), location.Y + 5 * factor - float.Parse((5 * factor * Math.Sin(alpha)).ToString()), location.Z); Vector3f v4 = new Vector3f( location.X + 10 * factor -float.Parse((8*factor* Math.Cos(alpha)).ToString()), location.Y + 5 * factor + distance * factor - float.Parse((8 * factor * Math.Sin(alpha)).ToString()), location.Z ); Vector3f v5 = new Vector3f( location.X + 10 * factor + float.Parse((8*factor*Math.Cos(alpha)).ToString()), location.Y + 5 * factor + distance * factor - float.Parse((8 * factor * Math.Sin(alpha)).ToString()), location.Z ); Layer layer = new Layer("line"); Line line14 = new Line(v1, v4); line14.Layer = layer; line14.Layer.Color.Index = 6; dxf.AddEntity(line14); Line line25 = new Line(v2, v5); line25.Layer = new Layer("line"); line25.Layer = layer; dxf.AddEntity(line25); //arc Arc arc = new Arc( new Vector3f(location.X + 10 * factor, location.Y + 5 * factor, location.Z), 5 * factor, Convert.ToInt32(180 + alpha * 180 / Math.PI), Convert.ToInt32(360 - alpha * 180 / Math.PI)); arc.Layer = layer; dxf.AddEntity(arc); //arcup Arc arcup = new Arc( new Vector3f(location.X + 10 * factor, location.Y + 5 * factor + distance * factor, location.Z), 8 * factor, Convert.ToInt32(-alpha * 180 / Math.PI), Convert.ToInt32(180 + alpha * 180 / Math.PI)); arcup.Layer = layer; dxf.AddEntity(arcup); //arcround Arc arcround = new Arc( new Vector3f(location.X + 10 * factor, location.Y + 5 * factor + distance * factor, location.Z), 10 * factor, Convert.ToInt32(-(alpha +beta) * 180 / Math.PI), Convert.ToInt32(180 + (alpha +beta) * 180 / Math.PI)); arcround.Layer = layer; dxf.AddEntity(arcround); //circle Vector3f extrusion = new Vector3f(0, 0, 1); Vector3f centerWCS = new Vector3f(location.X+10*factor, location.Y+5*factor+distance*factor, location.Z); Vector3d centerOCS = MathHelper.Transform((Vector3d)centerWCS, (Vector3d)extrusion, MathHelper.CoordinateSystem.World, MathHelper.CoordinateSystem.Object); Circle circle = new Circle((Vector3f)centerOCS, 7*factor); circle.Layer = layer; circle.LineType = LineType.Continuous; circle.Normal = extrusion; dxf.AddEntity(circle); //上部同心圆圆心 Vector3f t1 = new Vector3f( location.X + 8 * factor, location.Y + 5 * factor + (distance - 7) * factor * 0.7f, location.Z); Vector3f t2 = new Vector3f( location.X + 8 * factor, location.Y + 5 * factor + (distance - 7) * factor * 0.5f, location.Z); Vector3f t3 = new Vector3f( location.X + 8 * factor, location.Y + 5 * factor + (distance - 7) * factor * 0.3f, location.Z); Vector3f t4 = new Vector3f( location.X + 8 * factor, location.Y + 5 * factor + (distance - 7) * factor * 0.1f, location.Z); //text TextStyle style = new TextStyle("True type font", "Arial.ttf"); Text text1 = new Text("A", t1, 0.2f, style); text1.Layer = layer; text1.Alignment = TextAlignment.TopLeft; dxf.AddEntity(text1); //text Text text2 = new Text("A", t2, 0.2f, style); text2.Layer = layer; text2.Alignment = TextAlignment.TopLeft; dxf.AddEntity(text2); //text Text text3 = new Text("O", t3, 0.2f, style); text3.Layer = layer; text3.Alignment = TextAlignment.TopLeft; dxf.AddEntity(text3); //text Text text4 = new Text("N", t4, 0.2f, style); text4.Layer = layer; text4.Alignment = TextAlignment.TopLeft; dxf.AddEntity(text4); }
private static void Angular3PointDimensionDrawing() { DxfDocument dxf = new DxfDocument(); Vector3 center = new Vector3(1, 2, 0); double radius = 2.42548; Arc arc = new Arc(center, radius, -30, 60); //arc.Normal = new Vector3(1, 1, 1); DimensionStyle myStyle = new DimensionStyle("MyStyle"); Angular3PointDimension dim = new Angular3PointDimension(arc, 5, myStyle); dxf.AddEntity(arc); dxf.AddEntity(dim); dxf.Save("angular 3 point dimension.dxf"); dxf = DxfDocument.Load("angular 3 point dimension.dxf"); }