ezdxf 1.3.0b0__zip → 1.3.0b1__zip

{ezdxf-1.3.0b0/src/ezdxf.egg-info → ezdxf-1.3.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ezdxf
-Version: 1.3.0b0
+Version: 1.3.0b1
 Summary: A Python package to create/manipulate DXF drawings.
 Author-email: Manfred Moitzi <me@mozman.at>
 Project-URL: Repository, https://github.com/mozman/ezdxf

{ezdxf-1.3.0b0 → ezdxf-1.3.0b1}/src/ezdxf/addons/drawing/frontend.py

@@ -133,10 +133,14 @@ class UniversalFrontend:
         # RenderContext contains all information to resolve resources for a
         # specific DXF document.
         self.ctx = ctx
-        # the designer is the connection between frontend and backend
+        
+        # the render pipeline is the connection between frontend and backend
         self.pipeline = pipeline
         pipeline.set_draw_entities_callback(self.draw_entities_callback)
+
+        # update all configs:
         self.config = ctx.update_configuration(config)
+        # backend.configure() is called in pipeline.set_config()
         pipeline.set_config(self.config)
 
         if self.config.pdsize is None or self.config.pdsize <= 0:

{ezdxf-1.3.0b0 → ezdxf-1.3.0b1}/src/ezdxf/addons/drawing/pipeline.py

@@ -241,7 +241,8 @@ class RenderPipeline2d(AbstractPipeline):
         self.draw_entities = callback
 
     def set_config(self, config: Configuration) -> None:
-        self.config = config
+        self.backend.configure(config)
+        self.config = config      
         stage = self._pipeline
         while True:
             stage.set_config(config)

{ezdxf-1.3.0b0 → ezdxf-1.3.0b1}/src/ezdxf/tools/clipping_portal.py

@@ -68,6 +68,14 @@ class ClippingShape(abc.ABC):
     @abc.abstractmethod
     def bbox(self) -> BoundingBox2d: ...
 
+    @abc.abstractmethod
+    def is_completley_inside(self, other: BoundingBox2d) -> bool: ...
+
+    # returning False means: I don't know!
+
+    @abc.abstractmethod
+    def is_completley_outside(self, other: BoundingBox2d) -> bool: ...
+
     @abc.abstractmethod
     def clip_point(self, point: Vec2) -> Optional[Vec2]: ...
 
@@ -240,9 +248,10 @@ class ClippingPolygon(ClippingShape):
     def clip_polyline(self, points: NumpyPoints2d) -> Sequence[NumpyPoints2d]:
         clipper = self.clipper
         polyline_bbox = BoundingBox2d(points.extents())
-        if not polyline_bbox.has_intersection(self._bbox):
-            # polyline is complete outside
+        if self.is_completley_outside(polyline_bbox):
             return tuple()
+        if self.is_completley_inside(polyline_bbox):
+            return (points,)
         return [
             NumpyPoints2d(part)
             for part in clipper.clip_polyline(points.vertices())
@@ -252,9 +261,10 @@ class ClippingPolygon(ClippingShape):
     def clip_polygon(self, points: NumpyPoints2d) -> Sequence[NumpyPoints2d]:
         clipper = self.clipper
         polygon_bbox = BoundingBox2d(points.extents())
-        if not polygon_bbox.has_intersection(self._bbox):
-            # polygon is complete outside
+        if self.is_completley_outside(polygon_bbox):
             return tuple()
+        if self.is_completley_inside(polygon_bbox):
+            return (points,)
         return [
             NumpyPoints2d(part)
             for part in clipper.clip_polygon(points.vertices())
@@ -268,8 +278,10 @@ class ClippingPolygon(ClippingShape):
         for path in paths:
             for sub_path in path.sub_paths():
                 path_bbox = BoundingBox2d(sub_path.control_vertices())
-                if not path_bbox.has_intersection(self._bbox):
-                    # path is complete outside
+                if self.is_completley_inside(path_bbox):
+                    yield sub_path
+                    continue
+                if self.is_completley_outside(path_bbox):
                     continue
                 polyline = Vec2.list(sub_path.flattening(max_sagitta, segments=4))
                 for part in clipper.clip_polyline(polyline):
@@ -282,12 +294,16 @@ class ClippingPolygon(ClippingShape):
         clipper = self.clipper
         for path in paths:
             for sub_path in path.sub_paths():
+                if len(sub_path) < 2:
+                    continue
                 path_bbox = BoundingBox2d(sub_path.control_vertices())
-                if not path_bbox.has_intersection(self._bbox):
-                    # path is complete outside
+                if self.is_completley_inside(path_bbox):
+                    yield sub_path
+                    continue
+                if self.is_completley_outside(path_bbox):
                     continue
                 for part in clipper.clip_polygon(
-                    Vec2.list(path.flattening(max_sagitta, segments=4))
+                    Vec2.list(sub_path.flattening(max_sagitta, segments=4))
                 ):
                     if len(part) > 0:
                         yield NumpyPath2d.from_vertices(part, close=True)
@@ -312,6 +328,12 @@ class ClippingRect(ClippingPolygon):
 
         super().__init__(bbox, ClippingRect2d(bbox.extmin, bbox.extmax))
 
+    def is_completley_inside(self, other: BoundingBox2d) -> bool:
+        return self._bbox.contains(other)
+
+    def is_completley_outside(self, other: BoundingBox2d) -> bool:
+        return not self._bbox.has_intersection(other)
+
     def clip_point(self, point: Vec2) -> Optional[Vec2]:
         if self.remove_all:
             return None
@@ -359,6 +381,12 @@ class ConvexClippingPolygon(ClippingPolygon):
         polygon = Vec2.list(vertices)
         super().__init__(BoundingBox2d(polygon), ConvexClippingPolygon2d(polygon))
 
+    def is_completley_inside(self, other: BoundingBox2d) -> bool:
+        return False  # I don't know!
+
+    def is_completley_outside(self, other: BoundingBox2d) -> bool:
+        return not self._bbox.has_intersection(other)
+
 
 class ConcaveClippingPolygon(ClippingPolygon):
     """Represents an arbitrary concave polygon as clipping shape.  Removes the geometry
@@ -372,6 +400,12 @@ class ConcaveClippingPolygon(ClippingPolygon):
         polygon = Vec2.list(vertices)
         super().__init__(BoundingBox2d(polygon), ConcaveClippingPolygon2d(polygon))
 
+    def is_completley_inside(self, other: BoundingBox2d) -> bool:
+        return False  # I don't know!
+
+    def is_completley_outside(self, other: BoundingBox2d) -> bool:
+        return not self._bbox.has_intersection(other)
+
 
 class InvertedClippingPolygon(ClippingPolygon):
     """Represents an arbitrary inverted clipping polygon.  Removes the geometry
@@ -385,71 +419,12 @@ class InvertedClippingPolygon(ClippingPolygon):
         polygon = Vec2.list(vertices)
         super().__init__(outer_bounds, InvertedClippingPolygon2d(polygon, outer_bounds))
 
+    def is_completley_inside(self, other: BoundingBox2d) -> bool:
+        # returning False means: I don't know!
+        return False  # not easy to detect
 
-class MultiClip(ClippingShape):
-    """The MultiClip combines multiple clipping shapes into a single clipping shape.
-
-    Overlapping clipping shapes will yield strange results but are not actively
-    prevented.
-
-    """
-
-    def __init__(self, shapes: Iterable[ClippingShape]) -> None:
-        self._clipping_ranges: list[tuple[ClippingShape, BoundingBox2d]] = [
-            (shape, shape.bbox()) for shape in shapes if not shape.bbox().is_empty
-        ]
-
-    def bbox(self) -> BoundingBox2d:
-        bbox = BoundingBox2d()
-        for _, extents in self._clipping_ranges:
-            bbox.extend(extents)
-        return bbox
-
-    def shapes_in_range(self, bbox: BoundingBox2d) -> list[ClippingShape]:
-        return [
-            shape
-            for shape, extents in self._clipping_ranges
-            if bbox.has_intersection(extents)
-        ]
-
-    def clip_point(self, point: Vec2) -> Optional[Vec2]:
-        for shape, _ in self._clipping_ranges:
-            clipped_point = shape.clip_point(point)
-            if clipped_point is not None:
-                return clipped_point
-        return None
-
-    def clip_line(self, start: Vec2, end: Vec2) -> Sequence[tuple[Vec2, Vec2]]:
-        result: list[tuple[Vec2, Vec2]] = []
-        for clipper in self.shapes_in_range(BoundingBox2d((start, end))):
-            result.extend(clipper.clip_line(start, end))
-        return result
-
-    def clip_polyline(self, points: NumpyPoints2d) -> Sequence[NumpyPoints2d]:
-        result: list[NumpyPoints2d] = []
-        for shape in self.shapes_in_range(points.bbox()):
-            result.extend(shape.clip_polyline(points))
-        return result
-
-    def clip_polygon(self, points: NumpyPoints2d) -> Sequence[NumpyPoints2d]:
-        result: list[NumpyPoints2d] = []
-        for shape in self.shapes_in_range(points.bbox()):
-            result.extend(shape.clip_polygon(points))
-        return result
-
-    def clip_paths(
-        self, paths: Iterable[NumpyPath2d], max_sagitta: float
-    ) -> Iterator[NumpyPath2d]:
-        for path in paths:
-            for shape in self.shapes_in_range(path.bbox()):
-                yield from shape.clip_paths((path,), max_sagitta)
-
-    def clip_filled_paths(
-        self, paths: Iterable[NumpyPath2d], max_sagitta: float
-    ) -> Iterator[NumpyPath2d]:
-        for path in paths:
-            for shape in self.shapes_in_range(path.bbox()):
-                yield from shape.clip_filled_paths((path,), max_sagitta)
+    def is_completley_outside(self, other: BoundingBox2d) -> bool:
+        return not self._bbox.has_intersection(other)
 
 
 def find_best_clipping_shape(polygon: Iterable[UVec]) -> ClippingShape:

{ezdxf-1.3.0b0 → ezdxf-1.3.0b1}/src/ezdxf/version.py

@@ -24,5 +24,5 @@
 #   1. bug fix release beta0: VERSION = "0.9.1b0"; version = (0, 9, 1, 'b0')
 #   2. bug fix release: VERSION = "0.9.2"; version = (0, 9, 2, 'release')
 
-version = (1, 3, 0, "b0")
-__version__ = "1.3.0b0"
+version = (1, 3, 0, "b1")
+__version__ = "1.3.0b1"

{ezdxf-1.3.0b0 → ezdxf-1.3.0b1/src/ezdxf.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ezdxf
-Version: 1.3.0b0
+Version: 1.3.0b1
 Summary: A Python package to create/manipulate DXF drawings.
 Author-email: Manfred Moitzi <me@mozman.at>
 Project-URL: Repository, https://github.com/mozman/ezdxf

ezdxf-1.3.0b1/tests/test_05_tools/test_541_clipping_portal.py

@@ -0,0 +1,37 @@
+#  Copyright (c) 2023-2024, Manfred Moitzi
+#  License: MIT License
+import pytest
+import math
+
+from ezdxf.tools.clipping_portal import ClippingRect
+from ezdxf.math import Vec2
+from ezdxf import npshapes
+
+
+class TestClippingRect:
+    def test_clipping_points(self):
+        clipper = ClippingRect([(-1, -1), (1, 1)])
+        assert clipper.clip_point(Vec2(3, 3)) is None
+        assert clipper.clip_point(Vec2(0.5, 0.5)).isclose((0.5, 0.5))  # type: ignore
+
+    def test_clipping_lines(self):
+        clipper = ClippingRect([(-1, -1), (1, 1)])
+        cropped_segments = clipper.clip_line(Vec2(-3, 0), Vec2(3, 0))
+        assert len(cropped_segments) == 1
+
+        points = cropped_segments[0]
+        assert len(points) == 2
+        start, end = points
+        assert start.isclose((-1, 0))
+        assert end.isclose((1, 0))
+
+    def test_clip_polyline(self):
+        clipper = ClippingRect([(-2, -2), (2, 2)])
+        polyline = npshapes.NumpyPoints2d(Vec2.list([(0, 1), (3, 0), (0, -1)]))
+        polygons = clipper.clip_polygon(polyline)
+        assert len(polygons) == 1
+        assert len(polygons[0]) == 4
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

ezdxf-1.3.0b0/tests/test_05_tools/test_541_clipping_portal.py

@@ -1,85 +0,0 @@
-#  Copyright (c) 2023-2024, Manfred Moitzi
-#  License: MIT License
-import pytest
-import math
-
-from ezdxf.tools.clipping_portal import ClippingRect, MultiClip
-from ezdxf.math import Vec2
-from ezdxf import npshapes
-
-
-class TestClippingRect:
-    def test_clipping_points(self):
-        clipper = ClippingRect([(-1, -1), (1, 1)])
-        assert clipper.clip_point(Vec2(3, 3)) is None
-        assert clipper.clip_point(Vec2(0.5, 0.5)).isclose((0.5, 0.5))  # type: ignore
-
-    def test_clipping_lines(self):
-        clipper = ClippingRect([(-1, -1), (1, 1)])
-        cropped_segments = clipper.clip_line(Vec2(-3, 0), Vec2(3, 0))
-        assert len(cropped_segments) == 1
-
-        points = cropped_segments[0]
-        assert len(points) == 2
-        start, end = points
-        assert start.isclose((-1, 0))
-        assert end.isclose((1, 0))
-
-    def test_clip_polyline(self):
-        clipper = ClippingRect([(-2, -2), (2, 2)])
-        polyline = npshapes.NumpyPoints2d(Vec2.list([(0, 1), (3, 0), (0, -1)]))
-        polygons = clipper.clip_polygon(polyline)
-        assert len(polygons) == 1
-        assert len(polygons[0]) == 4
-
-
-class TestMultiClip:
-    @pytest.fixture
-    def multi_clip(self) -> MultiClip:
-        return MultiClip(
-            [
-                ClippingRect([(0, 0), (1, 1)]),
-                ClippingRect([(2, 0), (3, 1)]),
-            ]
-        )
-
-    def test_extents(self, multi_clip: MultiClip) -> None:
-        bbox = multi_clip.bbox()
-        assert bbox.extmin.isclose((0, 0))
-        assert bbox.extmax.isclose((3, 1))
-
-    def test_remove_empty_clipping_shapes(self):
-        r0 = ClippingRect([(0.5, 0.5), (0.5, 0.5)])
-        r1 = ClippingRect([(0, 0), (3, 1)])
-        multi_clip = MultiClip([r0, r1])
-        shapes = multi_clip.shapes_in_range(multi_clip.bbox())
-        assert len(shapes) == 1
-        assert shapes[0] is r1
-
-    @pytest.mark.parametrize(
-        "point",
-        Vec2.list([(0.5, 0.5), (2.5, 0.5), (0, 0), (1, 1), (2, 0), (3, 1)]),
-    )
-    def test_point_inside(self, multi_clip: MultiClip, point: Vec2) -> None:
-        assert point.isclose(multi_clip.clip_point(point))
-
-    @pytest.mark.parametrize(
-        "point",
-        Vec2.list([(-1, 0.5), (1.5, 0.5), (3.5, 0)]),
-    )
-    def test_point_outside(self, multi_clip: MultiClip, point: Vec2) -> None:
-        assert multi_clip.clip_point(point) is None
-
-    def test_clip_line_1(self, multi_clip: MultiClip) -> None:
-        parts = list(multi_clip.clip_line(Vec2(0.5, 0.5), Vec2(2.5, 0.5)))
-        assert len(parts) == 2
-        assert math.isclose(sum(v0.distance(v1) for v0, v1 in parts), 1.0)
-
-    def test_clip_line_2(self, multi_clip: MultiClip) -> None:
-        parts = list(multi_clip.clip_line(Vec2(-0.5, 0.5), Vec2(3.5, 0.5)))
-        assert len(parts) == 2
-        assert math.isclose(sum(v0.distance(v1) for v0, v1 in parts), 2.0)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__])