LWPOLYLINE "bulge" to ARC conversion Area and Perimeter of entity

[catalinanesia]

@mozman
Here is the problem description:

1. parse a dxf for all the available entity's (no issues here, straight forward with ezdxf)
2. establish the envelope area and perimeter (done by math not via ezdxf)
3. establish all the contained entities area and perimeter (done by math not via ezdxf)

Option 1
parse all the entities for start/end coordinates and match the points, from there figure out the Area and Perimeter

# helper function
def print_entity(line):
    print("LINE on layer: %s\n" % line.dxf.layer)
    print("start point: %s\n" % line.dxf.start)
    print("end point: %s\n" % line.dxf.end)

# iterate over all entities in modelspace
msp = dxf.modelspace()
for line in msp:
    if line.dxftype() == "LINE":
        print(line)
        print_entity(line)

for arc in msp.query('ARC'):
    print('ARC:')

    # Get all attributes
    attribs = arc.dxfattribs()
    for key in arc.dxfattribs():
        print(f'\t{key}: {attribs[key]}')

Option 1 - while should work seems that is the long and problematic rout to take hence the Option 2

Option 2
parse all the LWPOLYLINE and extract (start, end, bulge)
from bulge convert to arc (start_point, end_point, start_angle, end_angle, radius, center (x,y))

No matter what I do I cant extract the bulge information's, should be easy using this available functions:

1. midpoint, radius, start_angle, end_angle = ezdxf.math.bulge_to_arc(bulge, start, end)
2. center = ezdxf.math.bulge_center(bulge, start, end)

This iterates trough all LWPOLYLINE

from ezdxf.math import bulge_to_arc, bulge_center
from ezdxf.math.bulge import signed_bulge_radius
from ezdxf.math import Vec2 # do not import from ezdxf.acc sub-package
import math

# Get the LWPOLYLINE entities from the DXF file
entities = dwg.entities
lwpolylines = [e for e in entities if e.dxftype() == 'LWPOLYLINE']

# Iterate over each LWPOLYLINE entity
for pline in lwpolylines:
    # Get the bulge value, start and end points of each vertex in the polyline
    for x, y, start_width, end_width, bulge in pline:
        print("Start Point: ({}, {})".format(x, y))
        print("End Point: ({}, {})".format(x, y))
        print("Bulge value: ", bulge)
        print("Start Width: ", start_width)
        print("End Width: ", end_width)
        print("\n")

This should extract all the "bulge" informations:

import ezdxf

# Load the DXF file
dwg = ezdxf.readfile("example.dxf")

# Query all LWPOLYLINE entities in the DXF file
for num, line in enumerate(dwg.query('LWPOLYLINE'), start=1):
    print("\n{}. POLYLINE:".format(num))
    
    # Get the points of the LWPOLYLINE
    with line.points() as points:
        for x, y, start_width, end_width, bulge in points:
            if bulge:
                # Convert bulge to arc information
                midpoint, radius, start_angle, end_angle = ezdxf.math.bulge_to_arc(x, y, start_width, end_width, bulge)
                center = ezdxf.math.bulge_center(x, y, start_width, end_width, bulge)
                
                # Print the arc information
                print("\tMidpoint:", midpoint)
                print("\tRadius:", radius)
                print("\tStart Angle:", start_angle)
                print("\tEnd Angle:", end_angle)
                print("\tCenter:", center)

This is the error I get:

/usr/local/lib/python3.8/dist-packages/ezdxf/math/bulge.py in signed_bulge_radius(start_point, end_point, bulge)
    133 ) -> float:
    134     return (
--> 135         Vec2(start_point).distance(Vec2(end_point))
    136         * (1.0 + (bulge * bulge))
    137         / 4.0

src/ezdxf/acc/vector.pyx in ezdxf.acc.vector.Vec2.__cinit__()

TypeError: object of type 'float' has no len()

How would one determine all the Areas and Perimeters available for all CLOSED entities in the DXF file?
fundamentally this is the question
CLOSED is defined as two variants:

1. • a closed Polyline (LWPOLYLINE) and can have any shape (line, splines and arcs)
2. • closed as in each point would start from the previous entity end point (exploded contour)

Is this relevant to my problem?
#409

You can access virtual LINE and ARC entities of LWPOLYLINE entities: https://ezdxf.mozman.at/docs/dxfentities/lwpolyline.html#ezdxf.entities.LWPolyline.virtual_entities

Virtual entity means, the ARC and LINE entities are not assigned to any layout.

arc_and_lines = list(pline.virtual_entities())

For approximation (flattening) you can convert the LWPOLYLINE into a Path object: https://ezdxf.mozman.at/docs/path.html

python
from ezdxf import path
p = path.make_path(pline)
vertices = p.flattening(0.01)

I appreciate any help I can get! Thanks

[mozman]

The bulge_to_arc() function needs the start- and the endpoint of the bulge, you gave the x-coordinate (a float) as startpoint and the y-coordinate as endpoint (see docs). The arc starts at the vertex which includes the bulge value and ends at the following vertex.

[catalinanesia]

@mozman
Thanks for the hint, sometimes re-reading the same thing written differently yields some results.
I managed to get it working!

[catalinanesia]

Here is the code to solve a fraction of the above problem.
Well getting the "bulge_to_arc" working is fixed:

from ezdxf.math import bulge_to_arc, bulge_center
from ezdxf.math.bulge import signed_bulge_radius
from ezdxf.acc.vector import Vec2
from ezdxf import math

dwg = ezdxf.readfile('your_dxf_file.dxf')
modelspace = dwg.modelspace()

# Get the LWPOLYLINE entities from the DXF file
entities = dwg.entities
lwpolylines = [e for e in entities if e.dxftype() == 'LWPOLYLINE']

for pline in lwpolylines:
    for index, (x, y, start_width, end_width, bulge) in enumerate(pline):
        start_pline = pline[index+0]
        start_point = (start_pline[0], start_pline[1])
        if index+1 >= len(pline):
            break
        next_pline = pline[index+1]
        end_point = (next_pline[0], next_pline[1])
        # Check if the start & end points are the same
        if start_point == end_point:
            bulge = 0.0 # Set the bulge value to 0
            # Print the updated values
            print("Start Point:", start_point)
            print("End Point:", end_point)
            print("Bulge value: ", bulge)
        elif bulge != 0:
            center_point, start_angle, end_angle, radius = math.bulge_to_arc(start_point, end_point, bulge)
            # Print the updated values
            print("Start Point:", start_point)
            print("End Point:", end_point)
            print("Center Point: {}".format(center_point))
            print("Bulge value: ", bulge)
            print("Start Angle: {}".format(start_angle))
            print("End Angle: {}".format(end_angle))
            print("Radius: {}".format(radius))

Output:

Start Point: (0.0, 10.0)
End Point: (20.0, 10.0)
Center Point: (10.0, 10.000000000000002)
Bulge value: 0.9999999999999998
Start Angle: -3.141592653589793
End Angle: -1.7763568394002506e-16
Radius: 10.0

Start Point: (20.0, 50.0)
End Point: (0.0, 50.0)
Center Point: (10.0, 50.0)
Bulge value: 0.9999999999999998
Start Angle: 0.0
End Angle: 3.141592653589793
Radius: 10.0

[mozman]

Some minor remarks:

• don't use the entities property, it represents the ENTITIES section and is a relict from DXF R12 which combines the modelspace and the content of the active paperspace
• use the query() method to iterate over a sub-set of entities from a layout
• use the Vec3.isclose() method to compare floating point coordinates. I wasted a lot of time looking for errors caused by floating point inaccuracies.
• use f-strings, they are so much nicer 😃

...
doc = ezdxf.readfile('your_dxf_file.dxf')
msp = doc.modelspace()

for pline in msp.query("LWPOLYLINE"):
    ...
    start_point = Vec2(start_pline[0], start_pline[1])
    ...
    end_point = Vec2(next_pline[0], next_pline[1])
    if start_point.isclose(end_point):
        ...
        print(f"Center Point: {center_point}")

[catalinanesia]

@mozman
Thanks for the tips, below the updated code

# Get the LWPOLYLINE entities from the DXF file
lwpolylines = msp.query("LWPOLYLINE")

for pline in lwpolylines:
    for index, (x, y, start_width, end_width, bulge) in enumerate(pline):
        start_pline = pline[index+0]
        start_point = Vec2(start_pline[0], start_pline[1])
        if index+1 >= len(pline):
            break
        next_pline = pline[index+1]
        end_point = Vec2(next_pline[0], next_pline[1])
        
        # Check if the start & end points are the same
        if start_point.isclose(end_point):
            # Set the bulge value to 0.0
            bulge = 0.0
            # Print the updated values
            print("Start Point:", start_point)
            print("End Point:", end_point)
            print("Bulge value: ", bulge)
        elif bulge != 0:
            center_point, start_angle, end_angle, radius = math.bulge_to_arc(start_point, end_point, bulge)
            # Print the updated values
            print(f"Start Point: {start_point}")
            print(f"End Point: {end_point}")
            print(f"Center Point: {center_point}")
            print(f"Bulge value: {bulge}")
            print(f"Start Angle: {start_angle}")
            print(f"End Angle: {end_angle}")
            print(f"Radius: {radius}")
            print("\n")

[catalinanesia]

@mozman
with the new updated code the "ceter point" of first bulge is a weird decimal number
Center Point: (10.0, 10.000000000000002)

The AutoCAD lists a nice round number

Command: LI LIST 1 found
LWPOLYLINE Layer: "0"
Space: Model space
Handle = 562
Closed
Constant width 0.0000
area 1114.1593
perimeter 142.8319
at point X= 0.0000 Y= 10.0000 Z= 0.0000
bulge 1.0000
center X= 10.0000 Y= 10.0000 Z= 0.0000
radius 10.0000
start angle 180
end angle 0
at point X= 20.0000 Y= 10.0000 Z= 0.0000
at point X= 20.0000 Y= 50.0000 Z= 0.0000
bulge 1.0000
center X= 10.0000 Y= 50.0000 Z= 0.0000
radius 10.0000
start angle 0
end angle 180
Press ENTER to continue:
at point X= 0.0000 Y= 50.0000 Z= 0.0000

How can I keep only the .000 (3) decimal points at output?

[mozman]

Use format specifiers to round the output f"{x:.3f}" or the Python function round() to round the value itself, Vec2.round() is also available.

Please do your research, I cannot provide support for basic Python functions, there is plenty of documentation freely available.

[catalinanesia]

To calculate the Area and Perimeter of a shape by using Path and Flattening:

import ezdxf
import shapely.geometry

doc = ezdxf.readfile('your_file_path.dxf')
msp = doc.modelspace()

count = 0
for entity in msp.query("LWPOLYLINE POLYLINE"):
    count += 1
    path = ezdxf.path.make_path(entity)
    vertices = list(path.flattening(0.01))
    polygon = shapely.geometry.Polygon(vertices)
    area = polygon.area
    perimeter = polygon.length
    print(f"Polygon #{count}: Area = {area:.3f}, Perimeter = {perimeter:.3f}")

print(f"Total number of polygons encountered: {count}")

The DXF file should contain closed contours entity LWPOLYLINE and POLYLINE
I have experienced with different ways to compute that and by far this was the easy option as hinted by Mozman
Thanks! @mozman