ezdxf 1.2.0b2__zip → 1.2.0b3__zip

{ezdxf-1.2.0b2/src/ezdxf.egg-info → ezdxf-1.2.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ezdxf
-Version: 1.2.0b2
+Version: 1.2.0b3
 Summary: A Python package to create/manipulate DXF drawings.
 Home-page: https://ezdxf.mozman.at
 Download-URL: https://pypi.org/project/ezdxf/

{ezdxf-1.2.0b2 → ezdxf-1.2.0b3}/setup.py

@@ -15,7 +15,6 @@ ext_modules = [
             "src/ezdxf/acc/vector.pyx",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.matrix44",
@@ -23,25 +22,20 @@ ext_modules = [
             "src/ezdxf/acc/matrix44.pyx",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.bezier4p",
         [
             "src/ezdxf/acc/bezier4p.pyx",
-            "src/ezdxf/acc/_cpp_cubic_bezier.cpp",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.bezier3p",
         [
             "src/ezdxf/acc/bezier3p.pyx",
-            "src/ezdxf/acc/_cpp_quad_bezier.cpp",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.bspline",
@@ -49,7 +43,6 @@ ext_modules = [
             "src/ezdxf/acc/bspline.pyx",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.construct",
@@ -57,7 +50,6 @@ ext_modules = [
             "src/ezdxf/acc/construct.pyx",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.mapbox_earcut",
@@ -65,7 +57,6 @@ ext_modules = [
             "src/ezdxf/acc/mapbox_earcut.pyx",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.linetypes",
@@ -73,7 +64,6 @@ ext_modules = [
             "src/ezdxf/acc/linetypes.pyx",
         ],
         optional=True,
-        language="c++",
     ),
     Extension(
         "ezdxf.acc.np_support",
@@ -81,7 +71,6 @@ ext_modules = [
             "src/ezdxf/acc/np_support.pyx",
         ],
         optional=True,
-        language="c++",
     ),
 ]
 try:

{ezdxf-1.2.0b2 → ezdxf-1.2.0b3}/src/ezdxf/acc/__init__.py

@@ -1,4 +1,4 @@
-#  Copyright (c) 2020-2021, Manfred Moitzi
+#  Copyright (c) 2020-2024, Manfred Moitzi
 #  License: MIT License
 import sys
 from ezdxf._options import options

{ezdxf-1.2.0b2 → ezdxf-1.2.0b3}/src/ezdxf/acc/bezier3p.pyx

@@ -1,13 +1,9 @@
 # cython: language_level=3
-# distutils: language = c++
-# Copyright (c) 2021-2023 Manfred Moitzi
+# Copyright (c) 2021-2024 Manfred Moitzi
 # License: MIT License
-# type: ignore -- pylance sucks at type-checking cython files
-from typing import List, Tuple, TYPE_CHECKING, Sequence
-from .vector cimport Vec3, isclose, v3_dist, v3_from_cpp_vec3, v3_add, Vec2
+from typing import TYPE_CHECKING, Sequence
+from .vector cimport Vec3, isclose, v3_dist, v3_lerp, v3_add, Vec2
 from .matrix44 cimport Matrix44
-from ._cpp_vec3 cimport CppVec3
-from ._cpp_quad_bezier cimport CppQuadBezier
 import warnings
 if TYPE_CHECKING:
     from ezdxf.math import UVec
@@ -20,62 +16,53 @@ cdef extern from "constants.h":
 
 cdef double RECURSION_LIMIT = 1000
 
-# noinspection PyUnresolvedReferences
+
 cdef class Bezier3P:
-    cdef CppQuadBezier curve
-    cdef Vec3 offset
+    cdef:
+        FastQuadCurve curve  # pyright: ignore
+        readonly Vec3 start_point
+        Vec3 cp1
+        readonly Vec3 end_point
 
     def __cinit__(self, defpoints: Sequence[UVec]):
         if not isinstance(defpoints[0], (Vec2, Vec3)):
             warnings.warn(
                 DeprecationWarning, 
-                "Bezier3P requires defpoints of type Vec2 or Vec3 in the furture",
+                "Bezier3P requires defpoints of type Vec2 or Vec3 in the future",
             )
-        cdef CppVec3 cpp_offset
         if len(defpoints) == 3:
-            self.offset = Vec3(defpoints[0])
-            cpp_offset = self.offset.to_cpp_vec3()
-            self.curve = CppQuadBezier(
-                CppVec3(),
-                Vec3(defpoints[1]).to_cpp_vec3() - cpp_offset,
-                Vec3(defpoints[2]).to_cpp_vec3() - cpp_offset,
+            self.start_point = Vec3(defpoints[0])
+            self.cp1 = Vec3(defpoints[1])
+            self.end_point = Vec3(defpoints[2])
+
+            self.curve = FastQuadCurve(
+                self.start_point,
+                self.cp1,
+                self.end_point
             )
         else:
             raise ValueError("Three control points required.")
 
     @property
-    def control_points(self) -> Tuple[Vec3, Vec3, Vec3]:
-        cdef CppVec3 cpp_offset = self.offset.to_cpp_vec3()
-        return self.offset, \
-               v3_from_cpp_vec3(self.curve.p1 + cpp_offset), \
-               v3_from_cpp_vec3(self.curve.p2 + cpp_offset)
-
-    @property
-    def start_point(self) -> Vec3:
-        return self.offset
-
-    @property
-    def end_point(self) -> Vec3:
-        return v3_add(v3_from_cpp_vec3(self.curve.p2), self.offset)
+    def control_points(self) -> tuple[Vec3, Vec3, Vec3]:
+        return self.start_point, self.cp1, self.end_point
 
     def __reduce__(self):
         return Bezier3P, (self.control_points,)
 
     def point(self, double t) -> Vec3:
         if 0.0 <= t <= 1.0:
-            return v3_add(v3_from_cpp_vec3(self.curve.point(t)), self.offset)
+            return self.curve.point(t)
         else:
             raise ValueError("t not in range [0 to 1]")
 
     def tangent(self, double t) -> Vec3:
         if 0.0 <= t <= 1.0:
-            return v3_from_cpp_vec3(self.curve.tangent(t))
+            return self.curve.tangent(t)
         else:
             raise ValueError("t not in range [0 to 1]")
 
-    def approximate(self, int segments) -> List[Vec3]:
-        # A C++ implementation using std::vector<CppVec3> as return type
-        # was significant slower than the current implementation.
+    def approximate(self, int segments) -> list[Vec3]:
         cdef double delta_t
         cdef int segment
         cdef list points = [self.start_point]
@@ -88,18 +75,16 @@ cdef class Bezier3P:
         points.append(self.end_point)
         return points
 
-    def flattening(self, double distance, int segments = 4) -> List[Vec3]:
+    def flattening(self, double distance, int segments = 4) -> list[Vec3]:
         cdef double dt = 1.0 / segments
         cdef double t0 = 0.0, t1
         cdef _Flattening f = _Flattening(self, distance)
-        cdef CppVec3 start_point = self.curve.p0
-        cdef CppVec3 end_point
-        cdef Vec3 offset = self.offset
-        # Flattening of the translated curve!
+        cdef Vec3 start_point = self.start_point
+        cdef Vec3 end_point
         while t0 < 1.0:
             t1 = t0 + dt
             if isclose(t1, 1.0, REL_TOL, ABS_TOL):
-                end_point = self.curve.p2
+                end_point = self.end_point
                 t1 = 1.0
             else:
                 end_point = self.curve.point(t1)
@@ -111,8 +96,7 @@ cdef class Bezier3P:
                 )
             t0 = t1
             start_point = end_point
-        # translate vertices to original location:
-        return [v3_add(p, offset) for p in f.points]
+        return f.points
 
     def approximated_length(self, segments: int = 128) -> float:
         cdef double length = 0.0
@@ -127,21 +111,15 @@ cdef class Bezier3P:
             prev_point = point
         return length
 
-    def reverse(self) -> 'Bezier3P':
-        p0, p1, p2 = self.control_points
-        return Bezier3P((p2, p1, p0))
+    def reverse(self) -> Bezier3P:
+        return Bezier3P((self.end_point, self.cp1, self.start_point))
+
+    def transform(self, Matrix44 m) -> Bezier3P:
+        return Bezier3P(tuple(m.transform_vertices(self.control_points)))
 
-    def transform(self, Matrix44 m) -> 'Bezier3P':
-        p0, p1, p2 = self.control_points
-        transform = m.transform
-        return Bezier3P((
-            transform(<Vec3> p0),
-            transform(<Vec3> p1),
-            transform(<Vec3> p2),
-        ))
 
 cdef class _Flattening:
-    cdef CppQuadBezier curve
+    cdef FastQuadCurve curve  # pyright: ignore
     cdef double distance
     cdef list points
     cdef int _recursion_level
@@ -150,7 +128,7 @@ cdef class _Flattening:
     def __cinit__(self, Bezier3P curve, double distance):
         self.curve = curve.curve
         self.distance = distance
-        self.points = [v3_from_cpp_vec3(self.curve.p0)]
+        self.points = [curve.start_point]
         self._recursion_level = 0
         self._recursion_error = 0
 
@@ -163,8 +141,8 @@ cdef class _Flattening:
 
     cdef flatten(
         self,
-        CppVec3 start_point,
-        CppVec3 end_point,
+        Vec3 start_point,
+        Vec3 end_point,
         double start_t,
         double end_t
     ):
@@ -173,12 +151,72 @@ cdef class _Flattening:
             return
         self._recursion_level += 1
         cdef double mid_t = (start_t + end_t) * 0.5
-        cdef CppVec3 mid_point = self.curve.point(mid_t)
-        cdef double d = mid_point.distance(start_point.lerp(end_point, 0.5))
+        cdef Vec3 mid_point = self.curve.point(mid_t)
+        cdef double d = v3_dist(mid_point, v3_lerp(start_point, end_point, 0.5))
         if d < self.distance:
-            # Convert CppVec3 to Python type Vec3:
-            self.points.append(v3_from_cpp_vec3(end_point))
+            self.points.append(end_point)
         else:
             self.flatten(start_point, mid_point, start_t, mid_t)
             self.flatten(mid_point, end_point, mid_t, end_t)
-        self._recursion_level -= 1
+        self._recursion_level -= 1
+
+
+cdef class FastQuadCurve:
+    cdef:
+        double[3] offset
+        double[3] p1
+        double[3] p2
+
+    def __cinit__(self, Vec3 p0, Vec3 p1, Vec3 p2):
+        self.offset[0] = p0.x
+        self.offset[1] = p0.y
+        self.offset[2] = p0.z
+
+        # 1st control point (p0) is always (0, 0, 0)
+        self.p1[0] = p1.x - p0.x
+        self.p1[1] = p1.y - p0.y
+        self.p1[2] = p1.z - p0.z
+
+        self.p2[0] = p2.x - p0.x
+        self.p2[1] = p2.y - p0.y
+        self.p2[2] = p2.z - p0.z
+
+
+    cdef Vec3 point(self, double t):
+        # 1st control point (p0) is always (0, 0, 0)
+        # => p0 * a is always (0, 0, 0)
+        cdef:
+            Vec3 result = Vec3()
+            # double a = (1 - t) ** 2
+            double b = 2.0 * t * (1.0 - t)
+            double c = t * t
+
+        iadd_mul(result, self.p1, b)
+        iadd_mul(result, self.p2, c)
+
+        # add offset at last - it is maybe very large
+        result.x += self.offset[0]
+        result.y += self.offset[1]
+        result.z += self.offset[2]
+
+        return result
+
+
+    cdef Vec3 tangent(self, double t):
+        # tangent vector is independent from offset location!
+        cdef:
+            Vec3 result = Vec3()
+            # double a = -2 * (1 - t)
+            double b = 2.0 - 4.0 * t
+            double c = 2.0 * t
+
+        iadd_mul(result, self.p1, b)
+        iadd_mul(result, self.p2, c)
+
+        return result
+
+
+cdef void iadd_mul(Vec3 a, double[3] b, double c):
+    a.x += b[0] * c
+    a.y += b[1] * c
+    a.z += b[2] * c