215 lines
7.5 KiB
Python
215 lines
7.5 KiB
Python
# Copyright (c) 2019-2024 Manfred Moitzi
|
|
# License: MIT License
|
|
from __future__ import annotations
|
|
from typing import TYPE_CHECKING, Iterable, Optional, Iterator
|
|
import math
|
|
import numpy as np
|
|
|
|
from ezdxf.lldxf import validator
|
|
from ezdxf.math import (
|
|
Vec3,
|
|
Matrix44,
|
|
NULLVEC,
|
|
Z_AXIS,
|
|
arc_segment_count,
|
|
)
|
|
from ezdxf.math.transformtools import OCSTransform, NonUniformScalingError
|
|
from ezdxf.lldxf.attributes import (
|
|
DXFAttr,
|
|
DXFAttributes,
|
|
DefSubclass,
|
|
XType,
|
|
RETURN_DEFAULT,
|
|
group_code_mapping,
|
|
merge_group_code_mappings,
|
|
)
|
|
from ezdxf.lldxf.const import DXF12, SUBCLASS_MARKER, DXFValueError
|
|
from .dxfentity import base_class, SubclassProcessor
|
|
from .dxfgfx import (
|
|
DXFGraphic,
|
|
acdb_entity,
|
|
add_entity,
|
|
replace_entity,
|
|
elevation_to_z_axis,
|
|
acdb_entity_group_codes,
|
|
)
|
|
from .factory import register_entity
|
|
|
|
if TYPE_CHECKING:
|
|
from ezdxf.entities import DXFNamespace
|
|
from ezdxf.lldxf.tagwriter import AbstractTagWriter
|
|
from ezdxf.entities import Ellipse, Spline
|
|
|
|
__all__ = ["Circle"]
|
|
|
|
acdb_circle = DefSubclass(
|
|
"AcDbCircle",
|
|
{
|
|
"center": DXFAttr(10, xtype=XType.point3d, default=NULLVEC),
|
|
# AutCAD/BricsCAD: Radius is <= 0 is valid
|
|
"radius": DXFAttr(40, default=1),
|
|
# Elevation is a legacy feature from R11 and prior, do not use this
|
|
# attribute, store the entity elevation in the z-axis of the vertices.
|
|
# ezdxf does not export the elevation attribute!
|
|
"elevation": DXFAttr(38, default=0, optional=True),
|
|
"thickness": DXFAttr(39, default=0, optional=True),
|
|
"extrusion": DXFAttr(
|
|
210,
|
|
xtype=XType.point3d,
|
|
default=Z_AXIS,
|
|
optional=True,
|
|
validator=validator.is_not_null_vector,
|
|
fixer=RETURN_DEFAULT,
|
|
),
|
|
},
|
|
)
|
|
|
|
acdb_circle_group_codes = group_code_mapping(acdb_circle)
|
|
merged_circle_group_codes = merge_group_code_mappings(
|
|
acdb_entity_group_codes, acdb_circle_group_codes
|
|
)
|
|
|
|
|
|
@register_entity
|
|
class Circle(DXFGraphic):
|
|
"""DXF CIRCLE entity"""
|
|
|
|
DXFTYPE = "CIRCLE"
|
|
DXFATTRIBS = DXFAttributes(base_class, acdb_entity, acdb_circle)
|
|
MERGED_GROUP_CODES = merged_circle_group_codes
|
|
|
|
def load_dxf_attribs(
|
|
self, processor: Optional[SubclassProcessor] = None
|
|
) -> DXFNamespace:
|
|
"""Loading interface. (internal API)"""
|
|
# bypass DXFGraphic, loading proxy graphic is skipped!
|
|
dxf = super(DXFGraphic, self).load_dxf_attribs(processor)
|
|
if processor:
|
|
processor.simple_dxfattribs_loader(dxf, self.MERGED_GROUP_CODES)
|
|
if processor.r12:
|
|
# Transform elevation attribute from R11 to z-axis values:
|
|
elevation_to_z_axis(dxf, ("center",))
|
|
return dxf
|
|
|
|
def export_entity(self, tagwriter: AbstractTagWriter) -> None:
|
|
"""Export entity specific data as DXF tags."""
|
|
super().export_entity(tagwriter)
|
|
if tagwriter.dxfversion > DXF12:
|
|
tagwriter.write_tag2(SUBCLASS_MARKER, acdb_circle.name)
|
|
self.dxf.export_dxf_attribs(
|
|
tagwriter, ["center", "radius", "thickness", "extrusion"]
|
|
)
|
|
|
|
def vertices(self, angles: Iterable[float]) -> Iterator[Vec3]:
|
|
"""Yields the vertices of the circle of all given `angles` as
|
|
:class:`~ezdxf.math.Vec3` instances in :ref:`WCS`.
|
|
|
|
Args:
|
|
angles: iterable of angles in :ref:`OCS` as degrees, angle goes
|
|
counter-clockwise around the extrusion vector, and the OCS x-axis
|
|
defines 0-degree.
|
|
|
|
"""
|
|
ocs = self.ocs()
|
|
radius: float = abs(self.dxf.radius) # AutoCAD ignores the sign too
|
|
center = Vec3(self.dxf.center)
|
|
for angle in angles:
|
|
yield ocs.to_wcs(Vec3.from_deg_angle(angle, radius) + center)
|
|
|
|
def flattening(self, sagitta: float) -> Iterator[Vec3]:
|
|
"""Approximate the circle by vertices in :ref:`WCS` as :class:`~ezdxf.math.Vec3`
|
|
instances. The argument `sagitta`_ is the maximum distance from the center of an
|
|
arc segment to the center of its chord. Yields a closed polygon where the start
|
|
vertex is equal to the end vertex!
|
|
|
|
.. _sagitta: https://en.wikipedia.org/wiki/Sagitta_(geometry)
|
|
"""
|
|
radius = abs(self.dxf.radius)
|
|
if radius > 0.0:
|
|
count = arc_segment_count(radius, math.tau, sagitta)
|
|
yield from self.vertices(np.linspace(0.0, 360.0, count + 1))
|
|
|
|
def transform(self, m: Matrix44) -> Circle:
|
|
"""Transform the CIRCLE entity by transformation matrix `m` inplace.
|
|
Raises ``NonUniformScalingError()`` for non-uniform scaling.
|
|
"""
|
|
circle = self._transform(OCSTransform(self.dxf.extrusion, m))
|
|
self.post_transform(m)
|
|
return circle
|
|
|
|
def _transform(self, ocs: OCSTransform) -> Circle:
|
|
dxf = self.dxf
|
|
if ocs.scale_uniform:
|
|
dxf.extrusion = ocs.new_extrusion
|
|
dxf.center = ocs.transform_vertex(dxf.center)
|
|
# old_ocs has a uniform scaled xy-plane, direction of radius-vector
|
|
# in the xy-plane is not important, choose x-axis for no reason:
|
|
dxf.radius = ocs.transform_length((dxf.radius, 0, 0))
|
|
if dxf.hasattr("thickness"):
|
|
# thickness vector points in the z-direction of the old_ocs,
|
|
# thickness can be negative
|
|
dxf.thickness = ocs.transform_thickness(dxf.thickness)
|
|
else:
|
|
# Caller has to catch this Exception and convert this
|
|
# CIRCLE/ARC into an ELLIPSE.
|
|
raise NonUniformScalingError(
|
|
"CIRCLE/ARC does not support non uniform scaling"
|
|
)
|
|
|
|
return self
|
|
|
|
def translate(self, dx: float, dy: float, dz: float) -> Circle:
|
|
"""Optimized CIRCLE/ARC translation about `dx` in x-axis, `dy` in
|
|
y-axis and `dz` in z-axis, returns `self` (floating interface).
|
|
"""
|
|
ocs = self.ocs()
|
|
self.dxf.center = ocs.from_wcs(Vec3(dx, dy, dz) + ocs.to_wcs(self.dxf.center))
|
|
# Avoid Matrix44 instantiation if not required:
|
|
if self.is_post_transform_required:
|
|
self.post_transform(Matrix44.translate(dx, dy, dz))
|
|
return self
|
|
|
|
def to_ellipse(self, replace=True) -> Ellipse:
|
|
"""Convert the CIRCLE/ARC entity to an :class:`~ezdxf.entities.Ellipse` entity.
|
|
|
|
Adds the new ELLIPSE entity to the entity database and to the same layout as
|
|
the source entity.
|
|
|
|
Args:
|
|
replace: replace (delete) source entity by ELLIPSE entity if ``True``
|
|
|
|
"""
|
|
from ezdxf.entities import Ellipse
|
|
|
|
layout = self.get_layout()
|
|
if layout is None:
|
|
raise DXFValueError("valid layout required")
|
|
ellipse = Ellipse.from_arc(self)
|
|
if replace:
|
|
replace_entity(self, ellipse, layout)
|
|
else:
|
|
add_entity(ellipse, layout)
|
|
return ellipse
|
|
|
|
def to_spline(self, replace=True) -> Spline:
|
|
"""Convert the CIRCLE/ARC entity to a :class:`~ezdxf.entities.Spline` entity.
|
|
|
|
Adds the new SPLINE entity to the entity database and to the same layout as the
|
|
source entity.
|
|
|
|
Args:
|
|
replace: replace (delete) source entity by SPLINE entity if ``True``
|
|
|
|
"""
|
|
from ezdxf.entities import Spline
|
|
|
|
layout = self.get_layout()
|
|
if layout is None:
|
|
raise DXFValueError("valid layout required")
|
|
spline = Spline.from_arc(self)
|
|
if replace:
|
|
replace_entity(self, spline, layout)
|
|
else:
|
|
add_entity(spline, layout)
|
|
return spline
|