def _from_polyline(polyline: Polyline, **kwargs) -> 'Path':
if polyline.is_polygon_mesh or polyline.is_poly_face_mesh:
raise TypeError('Unsupported DXF type PolyMesh or PolyFaceMesh')
path = Path()
if len(polyline.vertices) == 0:
return path
if polyline.is_3d_polyline:
return from_vertices(polyline.points(), polyline.is_closed)
points = [vertex.format('xyb') for vertex in polyline.vertices]
ocs = polyline.ocs()
if polyline.dxf.hasattr('elevation'):
elevation = Vec3(polyline.dxf.elevation).z
else:
# Elevation attribute is mandatory, but you never know,
# take elevation from first vertex.
elevation = Vec3(polyline.vertices[0].dxf.location).z
tools.add_2d_polyline(
path,
points,
close=polyline.is_closed,
ocs=ocs,
elevation=elevation,
)
return path
def test_add_virtual_polyline_to_layout(doc, layout):
polyline = Polyline()
polyline.append_vertex((0, 0))
layout.add_entity(polyline)
assert factory.is_bound(polyline, doc) is True, \
'POLYLINE must be bound to document'
assert factory.is_bound(polyline.seqend, doc) is True, \
'SEQEND must be bound to document'
assert len(polyline) == 1
assert factory.is_bound(polyline.vertices[0], doc) is True, \
'VERTEX must be bound to document'
def test_polyline_lines():
from ezdxf.entities import Polyline
pline = Polyline()
pline.append_formatted_vertices([(1, 1), (2, 1), (2, 2)], format='xy')
path = make_path(pline)
assert path.start == (1, 1)
assert path.end == (2, 2)
assert len(path) == 2
pline.dxf.elevation = (0, 0, 1)
path = make_path(pline)
assert path.start == (1, 1, 1)
assert path.end == (2, 2, 1)
def to_polylines3d(paths: Iterable[Path],
*,
distance: float = MAX_DISTANCE,
segments: int = MIN_SEGMENTS,
dxfattribs: Optional[Dict] = None) -> Iterable[Polyline]:
""" Convert the given `paths` into 3D :class:`~ezdxf.entities.Polyline`
entities.
Args:
paths: iterable of :class:`Path` objects
distance: maximum distance, see :meth:`Path.flattening`
segments: minimum segment count per Bézier curve
dxfattribs: additional DXF attribs
Returns:
iterable of 3D :class:`~ezdxf.entities.Polyline` objects
.. versionadded:: 0.16
"""
if isinstance(paths, Path):
paths = [paths]
dxfattribs = dxfattribs or {}
dxfattribs['flags'] = const.POLYLINE_3D_POLYLINE
for path in paths:
p = Polyline.new(dxfattribs=dxfattribs)
p.append_vertices(path.flattening(distance, segments))
yield p
def test_3d_polyline():
from ezdxf.entities import Polyline
pline = Polyline.new(dxfattribs={'flags': Polyline.POLYLINE_3D})
pline.append_vertices([(1, 1, 1), (2, 1, 3), (2, 2, 2)])
path = make_path(pline)
assert path.start == (1, 1, 1)
assert path.end == (2, 2, 2)
assert len(path) == 2
def to_polylines2d(
paths: Iterable[Path],
*,
distance: float = MAX_DISTANCE,
segments: int = MIN_SEGMENTS,
extrusion: "Vertex" = Z_AXIS,
dxfattribs=None,
) -> Iterable[Polyline]:
"""Convert the given `paths` into 2D :class:`~ezdxf.entities.Polyline`
entities.
The `extrusion` vector is applied to all paths, all vertices are projected
onto the plane normal to this extrusion vector. The default extrusion vector
is the WCS z-axis. The plane elevation is the distance from the WCS origin
to the start point of the first path.
Args:
paths: iterable of :class:`Path` objects
distance: maximum distance, see :meth:`Path.flattening`
segments: minimum segment count per Bézier curve
extrusion: extrusion vector for all paths
dxfattribs: additional DXF attribs
Returns:
iterable of 2D :class:`~ezdxf.entities.Polyline` objects
.. versionadded:: 0.16
"""
if isinstance(paths, Path):
paths = [paths]
else:
paths = list(paths)
if len(paths) == 0:
return []
extrusion = Vec3(extrusion)
reference_point = paths[0].start
dxfattribs = dict(dxfattribs or {})
if not Z_AXIS.isclose(extrusion):
ocs, elevation = _get_ocs(extrusion, reference_point)
paths = tools.transform_paths_to_ocs(paths, ocs)
dxfattribs["elevation"] = Vec3(0, 0, elevation)
dxfattribs["extrusion"] = extrusion
elif reference_point.z != 0:
dxfattribs["elevation"] = Vec3(0, 0, reference_point.z)
for path in tools.single_paths(paths):
if len(path) > 0:
p = Polyline.new(dxfattribs=dxfattribs)
p.append_vertices(path.flattening(distance, segments))
yield p
def test_polyine_with_bulges():
from ezdxf.entities import Polyline
pline = Polyline()
pline.close(True)
pline.append_formatted_vertices(POINTS, format='xyb')
path = make_path(pline)
assert path.start == (0, 0)
assert path.end == (0, 0) # closed
assert any(cmd.type == Command.CURVE4_TO for cmd in path)
def to_splines_and_polylines(
paths: Iterable[Path],
*,
g1_tol: float = G1_TOL,
dxfattribs: Optional[Dict] = None
) -> Iterable[Union[Spline, Polyline]]:
""" Convert the given `paths` into :class:`~ezdxf.entities.Spline` and 3D
:class:`~ezdxf.entities.Polyline` entities.
Args:
paths: iterable of :class:`Path` objects
g1_tol: tolerance for G1 continuity check
dxfattribs: additional DXF attribs
Returns:
iterable of :class:`~ezdxf.entities.Line` objects
.. versionadded:: 0.16
"""
if isinstance(paths, Path):
paths = [paths]
dxfattribs = dxfattribs or {}
for path in paths:
for data in to_bsplines_and_vertices(path, g1_tol):
if isinstance(data, BSpline):
spline = Spline.new(dxfattribs=dxfattribs)
spline.apply_construction_tool(data)
yield spline
else:
attribs = dict(dxfattribs)
attribs['flags'] = const.POLYLINE_3D_POLYLINE
polyline = Polyline.new(dxfattribs=dxfattribs)
polyline.append_vertices(data)
yield polyline
