18403757400

Committed 10 Oct 2025 10:25AM UTC coverage: 78.334% (-0.02%) from 78.358%

Build # 18403757400

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #820 from DomCR/issue-819_CadObjectCollection-index-refactor

issue 819

Run Details

6856 of 9495 branches covered (72.21%)

Branch coverage included in aggregate %.

5 of 10 new or added lines in 2 files covered. (50.0%)

10 existing lines in 2 files now uncovered.

26375 of 32927 relevant lines covered (80.1%)

108848.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.07

/src/ACadSharp/Entities/PolyLine.cs

﻿using ACadSharp.Attributes;
using CSMath;
using CSUtilities.Extensions;
using System.Collections.Generic;
using System.Linq;

namespace ACadSharp.Entities
{
        /// <summary>
        /// Represents a <see cref="Polyline{T}"/> entity.
        /// </summary>
        [DxfName(DxfFileToken.EntityPolyline)]
        [DxfSubClass(null, true)]
        public abstract class Polyline<T> : Entity, IPolyline
                where T : Entity, IVertex
        {
                /// <inheritdoc/>
                [DxfCodeValue(30)]
                public double Elevation { get; set; } = 0.0;

                /// <summary>
                /// End width.
                /// </summary>
                [DxfCodeValue(41)]
                public double EndWidth { get; set; } = 0.0;

                /// <summary>
                /// Polyline flags.
                /// </summary>
                [DxfCodeValue(70)]
                public PolylineFlags Flags { get => this._flags; set => this._flags = value; }

                /// <inheritdoc/>
                public bool IsClosed
                {
                        get
                        {
                                return this.Flags.HasFlag(PolylineFlags.ClosedPolylineOrClosedPolygonMeshInM) || this.Flags.HasFlag(PolylineFlags.ClosedPolygonMeshInN);
                        }
                        set
                        {
                                if (value)
                                {
                                        this._flags.AddFlag(PolylineFlags.ClosedPolylineOrClosedPolygonMeshInM);
                                        this._flags.AddFlag(PolylineFlags.ClosedPolygonMeshInN);
                                }
                                else
                                {
                                        this._flags.RemoveFlag(PolylineFlags.ClosedPolylineOrClosedPolygonMeshInM);
                                        this._flags.RemoveFlag(PolylineFlags.ClosedPolygonMeshInN);
                                }
                        }
                }

                /// <inheritdoc/>
                [DxfCodeValue(210, 220, 230)]
                public XYZ Normal { get; set; } = XYZ.AxisZ;

                /// <inheritdoc/>
                public override string ObjectName => DxfFileToken.EntityPolyline;

                /// <summary>
                /// Curves and smooth surface type.
                /// </summary>
                [DxfCodeValue(75)]
                public SmoothSurfaceType SmoothSurface { get; set; }

                /// <summary>
                /// Start width.
                /// </summary>
                [DxfCodeValue(40)]
                public double StartWidth { get; set; } = 0.0;

                /// <inheritdoc/>
                [DxfCodeValue(39)]
                public double Thickness { get; set; } = 0.0;

                /// <summary>
                /// Vertices that form this polyline.
                /// </summary>
                /// <remarks>
                /// Each <see cref="Vertex"/> has it's own unique handle.
                /// </remarks>
                public SeqendCollection<T> Vertices { get; private set; }

                /// <inheritdoc/>
                IEnumerable<IVertex> IPolyline.Vertices { get { return this.Vertices; } }

                private PolylineFlags _flags;

                /// <summary>
                /// Default constructor.
                /// </summary>
                public Polyline() : base()
                {
                        this.Vertices = new SeqendCollection<T>(this);
                }

                public Polyline(IEnumerable<T> vertices, bool isClosed) : this()
                {
                        if (vertices == null)
                                throw new System.ArgumentException("The vertices enumerable cannot be null or empty", nameof(vertices));

                        this.Vertices.AddRange(vertices);
                        this.IsClosed = isClosed;
                }

                /// <inheritdoc/>
                public override void ApplyTransform(Transform transform)
                {
                        var newNormal = this.transformNormal(transform, this.Normal);

                        this.getWorldMatrix(transform, this.Normal, newNormal, out Matrix3 transOW, out Matrix3 transWO);

                        foreach (var vertex in this.Vertices)
                        {
                                XYZ v = transOW * vertex.Location.Convert<XYZ>();
                                v = transform.ApplyTransform(v);
                                v = transWO * v;
                                vertex.Location = v;
                        }

                        this.Normal = newNormal;
                }

                /// <inheritdoc/>
                public override CadObject Clone()
                {
                        Polyline<T> clone = (Polyline<T>)base.Clone();

                        clone.Vertices = new SeqendCollection<T>(clone);
                        foreach (T v in this.Vertices)
                        {
                                clone.Vertices.Add((T)v.Clone());
                        }

                        return clone;
                }

                /// <inheritdoc/>
                public override BoundingBox GetBoundingBox()
                {
                        //TODO: can a polyline have only 1 vertex?
                        if (this.Vertices.Count < 2)
                        {
                                return BoundingBox.Null;
                        }

                        XYZ first = this.Vertices[0].Location.Convert<XYZ>();
                        XYZ second = this.Vertices[1].Location.Convert<XYZ>();

                        XYZ min = new XYZ(System.Math.Min(first.X, second.X), System.Math.Min(first.Y, second.Y), System.Math.Min(first.Z, second.Z));
                        XYZ max = new XYZ(System.Math.Max(first.X, second.X), System.Math.Max(first.Y, second.Y), System.Math.Max(first.Z, second.Z));

                        foreach (T v in this.Vertices.Skip(2))
                        {
                                XYZ curr = v.Location.Convert<XYZ>();

                                min = new XYZ(System.Math.Min(min.X, curr.X), System.Math.Min(min.Y, curr.Y), System.Math.Min(min.Z, curr.Z));
                                max = new XYZ(System.Math.Max(max.X, curr.X), System.Math.Max(max.Y, curr.Y), System.Math.Max(max.Z, curr.Z));
                        }

                        return new BoundingBox(min, max);
                }

                internal static IEnumerable<Entity> Explode(IPolyline polyline)
                {
                        //Generic explode method for Polyline2D and LwPolyline
                        List<Entity> entities = new List<Entity>();

                        for (int i = 0; i < polyline.Vertices.Count(); i++)
                        {
                                IVertex curr = polyline.Vertices.ElementAt(i);
                                IVertex next = polyline.Vertices.ElementAtOrDefault(i + 1);

                                if (next == null && polyline.IsClosed)
                                {
                                        next = polyline.Vertices.First();
                                }
                                else if (next == null)
                                {
                                        break;
                                }

                                Entity e = null;
                                if (curr.Bulge == 0)
                                {
                                        //Is a line
                                        e = new Line
                                        {
                                                StartPoint = curr.Location.Convert<XYZ>(),
                                                EndPoint = next.Location.Convert<XYZ>(),
                                                Normal = polyline.Normal,
                                                Thickness = polyline.Thickness,
                                        };
                                }
                                else
                                {
                                        XY p1 = curr.Location.Convert<XY>();
                                        XY p2 = next.Location.Convert<XY>();

                                        //Is an arc
                                        Arc arc = Arc.CreateFromBulge(p1, p2, curr.Bulge);
                                        arc.Center = new XYZ(arc.Center.X, arc.Center.Y, polyline.Elevation);
                                        arc.Normal = polyline.Normal;
                                        arc.Thickness = polyline.Thickness;

                                        e = arc;
                                }

                                polyline.MatchProperties(e);

                                entities.Add(e);
                        }

                        return entities;
                }

                internal override void AssignDocument(CadDocument doc)
                {
                        base.AssignDocument(doc);
                        doc.RegisterCollection(this.Vertices);
                }

                internal override void UnassignDocument()
                {
                        this.Document.UnregisterCollection(this.Vertices);
                        base.UnassignDocument();
                }
        }
}

1	using ACadSharp.Attributes;
2	using CSMath;
3	using CSUtilities.Extensions;
4	using System.Collections.Generic;
5	using System.Linq;
6
7	namespace ACadSharp.Entities
8	{
9	/// <summary>
10	/// Represents a <see cref="Polyline{T}"/> entity.
11	/// </summary>
12	[DxfName(DxfFileToken.EntityPolyline)]
13	[DxfSubClass(null, true)]
14	public abstract class Polyline<T> : Entity, IPolyline
15	where T : Entity, IVertex
16	{
17	/// <inheritdoc/>
18	[DxfCodeValue(30)]
19	public double Elevation { get; set; } = 0.0;	23,104✔
20
21	/// <summary>
22	/// End width.
23	/// </summary>
24	[DxfCodeValue(41)]
25	public double EndWidth { get; set; } = 0.0;	22,564✔
26
27	/// <summary>
28	/// Polyline flags.
29	/// </summary>
30	[DxfCodeValue(70)]
31	public PolylineFlags Flags { get => this._flags; set => this._flags = value; }	872✔
32
33	/// <inheritdoc/>
34	public bool IsClosed
35	{
36	get
37	{	30✔
38	return this.Flags.HasFlag(PolylineFlags.ClosedPolylineOrClosedPolygonMeshInM) \|\| this.Flags.HasFlag(PolylineFlags.ClosedPolygonMeshInN);	30✔
39	}	30✔
40	set
41	{	94✔
42	if (value)	94✔
43	{	30✔
44	this._flags.AddFlag(PolylineFlags.ClosedPolylineOrClosedPolygonMeshInM);	30✔
45	this._flags.AddFlag(PolylineFlags.ClosedPolygonMeshInN);	30✔
46	}	30✔
47	else
48	{	64✔
49	this._flags.RemoveFlag(PolylineFlags.ClosedPolylineOrClosedPolygonMeshInM);	64✔
50	this._flags.RemoveFlag(PolylineFlags.ClosedPolygonMeshInN);	64✔
51	}	64✔
52	}	94✔
53	}
54
55	/// <inheritdoc/>
56	[DxfCodeValue(210, 220, 230)]
57	public XYZ Normal { get; set; } = XYZ.AxisZ;	22,648✔
58
59	/// <inheritdoc/>
60	public override string ObjectName => DxfFileToken.EntityPolyline;	2,736✔
61
62	/// <summary>
63	/// Curves and smooth surface type.
64	/// </summary>
65	[DxfCodeValue(75)]
66	public SmoothSurfaceType SmoothSurface { get; set; }	92✔
67
68	/// <summary>
69	/// Start width.
70	/// </summary>
71	[DxfCodeValue(40)]
72	public double StartWidth { get; set; } = 0.0;	22,564✔
73
74	/// <inheritdoc/>
75	[DxfCodeValue(39)]
76	public double Thickness { get; set; } = 0.0;	22,564✔
77
78	/// <summary>
79	/// Vertices that form this polyline.
80	/// </summary>
81	/// <remarks>
82	/// Each <see cref="Vertex"/> has it's own unique handle.
83	/// </remarks>
84	public SeqendCollection<T> Vertices { get; private set; }	538,077✔
85
86	/// <inheritdoc/>
87	IEnumerable<IVertex> IPolyline.Vertices { get { return this.Vertices; } }	630✔
88
89	private PolylineFlags _flags;
90
91	/// <summary>
92	/// Default constructor.
93	/// </summary>
94	public Polyline() : base()	22,529✔
95	{	22,529✔
96	this.Vertices = new SeqendCollection<T>(this);	22,529✔
97	}	22,529✔
98
99	public Polyline(IEnumerable<T> vertices, bool isClosed) : this()	48✔
100	{	48✔
101	if (vertices == null)	48!
102	throw new System.ArgumentException("The vertices enumerable cannot be null or empty", nameof(vertices));	×
103
104	this.Vertices.AddRange(vertices);	48✔
105	this.IsClosed = isClosed;	48✔
106	}	48✔
107
108	/// <inheritdoc/>
109	public override void ApplyTransform(Transform transform)
110	{	×
111	var newNormal = this.transformNormal(transform, this.Normal);	×
112
113	this.getWorldMatrix(transform, this.Normal, newNormal, out Matrix3 transOW, out Matrix3 transWO);	×
114
115	foreach (var vertex in this.Vertices)	×
116	{	×
117	XYZ v = transOW * vertex.Location.Convert<XYZ>();	×
118	v = transform.ApplyTransform(v);	×
119	v = transWO * v;	×
120	vertex.Location = v;	×
121	}	×
122
123	this.Normal = newNormal;	×
124	}	×
125
126	/// <inheritdoc/>
127	public override CadObject Clone()
128	{	10✔
129	Polyline<T> clone = (Polyline<T>)base.Clone();	10✔
130
131	clone.Vertices = new SeqendCollection<T>(clone);	10✔
132	foreach (T v in this.Vertices)	36✔
133	{	3✔
134	clone.Vertices.Add((T)v.Clone());	3✔
135	}	3✔
136
137	return clone;	10✔
138	}	10✔
139
140	/// <inheritdoc/>
141	public override BoundingBox GetBoundingBox()
142	{	3✔
143	//TODO: can a polyline have only 1 vertex?
144	if (this.Vertices.Count < 2)	3!
145	{	3✔
146	return BoundingBox.Null;	3✔
147	}
148
149	XYZ first = this.Vertices[0].Location.Convert<XYZ>();	×
150	XYZ second = this.Vertices[1].Location.Convert<XYZ>();	×
151
152	XYZ min = new XYZ(System.Math.Min(first.X, second.X), System.Math.Min(first.Y, second.Y), System.Math.Min(first.Z, second.Z));	×
153	XYZ max = new XYZ(System.Math.Max(first.X, second.X), System.Math.Max(first.Y, second.Y), System.Math.Max(first.Z, second.Z));	×
154
NEW 155	foreach (T v in this.Vertices.Skip(2))	×
156	{	×
NEW 157	XYZ curr = v.Location.Convert<XYZ>();	×
158
159	min = new XYZ(System.Math.Min(min.X, curr.X), System.Math.Min(min.Y, curr.Y), System.Math.Min(min.Z, curr.Z));	×
160	max = new XYZ(System.Math.Max(max.X, curr.X), System.Math.Max(max.Y, curr.Y), System.Math.Max(max.Z, curr.Z));	×
161	}	×
162
163	return new BoundingBox(min, max);	×
164	}	3✔
165
166	internal static IEnumerable<Entity> Explode(IPolyline polyline)
167	{	×
168	//Generic explode method for Polyline2D and LwPolyline
169	List<Entity> entities = new List<Entity>();	×
170
171	for (int i = 0; i < polyline.Vertices.Count(); i++)	×
172	{	×
173	IVertex curr = polyline.Vertices.ElementAt(i);	×
174	IVertex next = polyline.Vertices.ElementAtOrDefault(i + 1);	×
175
176	if (next == null && polyline.IsClosed)	×
177	{	×
178	next = polyline.Vertices.First();	×
179	}	×
180	else if (next == null)	×
181	{	×
182	break;	×
183	}
184
185	Entity e = null;	×
186	if (curr.Bulge == 0)	×
187	{	×
188	//Is a line
189	e = new Line	×
190	{	×
191	StartPoint = curr.Location.Convert<XYZ>(),	×
192	EndPoint = next.Location.Convert<XYZ>(),	×
193	Normal = polyline.Normal,	×
194	Thickness = polyline.Thickness,	×
195	};	×
196	}	×
197	else
198	{	×
199	XY p1 = curr.Location.Convert<XY>();	×
200	XY p2 = next.Location.Convert<XY>();	×
201
202	//Is an arc
203	Arc arc = Arc.CreateFromBulge(p1, p2, curr.Bulge);	×
204	arc.Center = new XYZ(arc.Center.X, arc.Center.Y, polyline.Elevation);	×
205	arc.Normal = polyline.Normal;	×
206	arc.Thickness = polyline.Thickness;	×
207
208	e = arc;	×
209	}	×
210
211	polyline.MatchProperties(e);	×
212
213	entities.Add(e);	×
214	}	×
215
216	return entities;	×
217	}	×
218
219	internal override void AssignDocument(CadDocument doc)
220	{	10,806✔
221	base.AssignDocument(doc);	10,806✔
222	doc.RegisterCollection(this.Vertices);	10,806✔
223	}	10,806✔
224
225	internal override void UnassignDocument()
226	{	52✔
227	this.Document.UnregisterCollection(this.Vertices);	52✔
228	base.UnassignDocument();	52✔
229	}	52✔
230	}
231	}

DomCR / ACadSharp / 18403757400

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous