Strange behaviour of Spline.PolygonalVertexes()

[bealni]

Here: bealni.com/dxf is an example of a strange behaviour of Spline.PolygonalVertexes().
You can download the dxf file sample.dxf.
This file contains only SPLINE entities.

The code is:

private List<CSMath.XYZ> CreateEntityVertices_SPLINE(Entity entity)
{
ACadSharp.Entities.Spline spline;
List<CSMath.XYZ> vertices;
spline = entity as ACadSharp.Entities.Spline;
vertices = spline.PolygonalVertexes(SPLINE_PRECISION *
(spline.ControlPoints.Count - 1));
return vertices;
}

The figure 1 was generated using SPLINE_PRECISION = 2, while
the figure 2 was generated using SPLINE_PRECISION = 4.

[bealni]

P.S. By the way, the GetBoundingBox() has the same issue.
Now I added a third figure, in this case, I don't use the GetBoundingBox()
in case of Spline, instead, the bounding box is calculated from generated vertices.
You can notice that now the drawing is displayed using correct extents.

P.P.S. Now I have SPLINE_PRECISION = 8 and all the samples I have are displayed correctly.

P.P.P.S. Well, not all, I found some sample that still has this issue :(

[DomCR]

Hi @bealni,

I've noticed this strange behavior too in my current work, I'll open a branch to fix it.

Thanks for the report!

[bealni]

Thank you.

I'd suggest adding another function which, as PolygonalVertexes() will convert curves to polyline, but instead of the number of vertices will take an angular tolerance as argument.
The point is that in case of Arc, Circle and Ellipse the decision about the needed number of vertices is straightforward: for example, if a circle is converted with 360 vertices, it assures that the angle between consecutive segments equals to one degree, but in case of Spline it is not obvious.

The angular tolerance (in radians) may be defined as follows:

max(acos(dot((v[i+1] - v[i]), (v[i+2] - v[i+1])))), where v[i] are created vertices, i=0,...N-3, N being the number of vertices.

One may write their own function to evaluate the appropriate number of vertices, using control points and knots, but it would be nice to have this function inside the library.

[DomCR]

Hi @bealni,

To convert entities to polylines I've started this PR:

• Entity equivalent #825

The intention is to be able to convert the Hatch.Boundary into entities, and maybe extend it to convert entities to Polylines, but the issue here is that there aren't a lot of entities that can be converted into Polylines, so I think is more useful to implement creation methods and constructors that facilitate the Polyline generation.

The conversion of a SpLine to Polyline is not possible, at least with the exact same shape, polylines only support circular arcs, when you add an ellipse that line is converted to an SpLine, I tried to make it work with the Flags in the vertices but it doesn't seem to work, at least in Autocad.

My idea to solve the precision for arcs is to be able to set the length of the segments of which the arc is split, that way if you are working in meters you can set the segments to 1cm which it will create an arc without any corners, check the code snipped:

https://github.com/DomCR/CSUtilities/blob/b19408c4520a0644d009ceec9e3b4131213b7f28/CSMath/Geometry/CurveExtensions.cs#L73

[bealni]

I found out that the problem is inside the Spline.PointOnSpline() function.

I wrote a very naive algorithm to convert spline into polyline based on angular tolerance in degrees.

The following is the code snippet:

    /*=== SplineToPolyLine() ===*/
    private void SplineToPolyLine(Spline spline,
                                  double AngTolDeg,

                                  List<CSMath.XYZ> vertices)
    {
        int SegCount;
        int VtxCount, VtxIdx;
        double dt, t;
        double MinCos;
        CSMath.XYZ XYZ;

        MinCos = Math.Cos(Math.PI * AngTolDeg / 180.0);

        SegCount = 2;
        while (true)
        {
            vertices.Clear();
            VtxCount = SegCount + 1;
            t = 0.0;
            dt = 1.0 / (double)SegCount;
            for (VtxIdx = 0; VtxIdx < VtxCount; VtxIdx++)
            {
                XYZ = spline.PointOnSpline(t);
                vertices.Add(XYZ);
                if (VtxIdx < VtxCount - 2)
                    t += dt;
                else
                    t = 1.0;
            }
            Regularize(vertices);

            if (AngTolOK(MinCos,
                         vertices))
                break;

            SegCount *= 2;
            if (SegCount > 1024)
                break;
        }
    }

    /*=== Regularize() ===*/
    private void Regularize(List<CSMath.XYZ> vertices)
    {
        int i, Count;
        double vx1, vy1, vx2, vy2;
        double d1, d2;
        double dot;
        List<bool> ToBeRemoved;

        ToBeRemoved = new List<bool>();
        Count = vertices.Count;
        for (i = 0; i < Count; i++)
            ToBeRemoved.Add(false);

        for (i = 0; i < Count - 2; i++)
        {
            vx1 = vertices[i + 1].X - vertices[i].X;
            vy1 = vertices[i + 1].Y - vertices[i].Y;
            d1 = Math.Sqrt(vx1 * vx1 + vy1 * vy1);
            vx1 /= d1;
            vy1 /= d1;

            vx2 = vertices[i + 2].X - vertices[i + 1].X;
            vy2 = vertices[i + 2].Y - vertices[i + 1].Y;
            d2 = Math.Sqrt(vx2 * vx2 + vy2 * vy2);
            vx2 /= d2;
            vy2 /= d2;

            dot = vx1 * vx2 + vy1 * vy2;
            if (dot < -0.99)
                ToBeRemoved[i + 1] = true;
        }

        for (i = Count - 1; i>= 0; i--)
        {
            if (ToBeRemoved[i])
                vertices.RemoveAt(i);
        }

        ToBeRemoved.Clear();
        ToBeRemoved = null;
    }

    /*=== AngTolOK() ===*/
    private bool AngTolOK(double MinCos,
                          List<CSMath.XYZ> vertices)
    {
        int i, Count;
        double vx1, vy1, vx2, vy2;
        double d1, d2;
        double dot;
        double avgdot;

        Count = vertices.Count;
        if (Count < 3)
            return false;

        avgdot = 0.0;
        for (i = 0; i < Count - 2; i++)
        {
            vx1 = vertices[i + 1].X - vertices[i].X;
            vy1 = vertices[i + 1].Y - vertices[i].Y;
            d1 = Math.Sqrt(vx1 * vx1 + vy1 * vy1);
            vx1 /= d1;
            vy1 /= d1;

            vx2 = vertices[i + 2].X - vertices[i + 1].X;
            vy2 = vertices[i + 2].Y - vertices[i + 1].Y;
            d2 = Math.Sqrt(vx2 * vx2 + vy2 * vy2);
            vx2 /= d2;
            vy2 /= d2;

            dot = vx1 * vx2 + vy1 * vy2;
            avgdot += dot;
        }
        avgdot /= (double)(Count - 2);
        if (avgdot < MinCos)
            return false;

        return true;
    }

On bealni.com/dxf there are two figures illustrating two cases:

• the first one without call to Regularize() function
• the second one with using Regularize() to eliminate those "strange" segments.

One-degree angular tolerance was used.

[DomCR]

We can take a look at this feature in a separated PR to keep the scope of this one clean.

Please open a new issue with this feature or a PR with the code.