svg-ultralight 0.37.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

svg_ultralight/bounding_boxes/bound_helpers.py

@@ -8,10 +8,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from lxml.etree import _Element as EtreeElement  # type: ignore
+from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
+from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.bounding_boxes.type_bound_element import BoundElement
-from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
+from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox, HasBoundingBox
 from svg_ultralight.bounding_boxes.type_padded_text import PaddedText
 from svg_ultralight.constructors import new_element
 
@@ -66,15 +67,7 @@ def new_bbox_union(*blems: SupportsBounds | EtreeElement) -> BoundingBox:
 
     Will used the padded_box attribute of PaddedText instances.
     """
-    bboxes: list[BoundingBox] = []
-    for blem in blems:
-        if isinstance(blem, BoundingBox):
-            bboxes.append(blem)
-        elif isinstance(blem, BoundElement):
-            bboxes.append(blem.bbox)
-        elif isinstance(blem, PaddedText):
-            bboxes.append(blem.padded_bbox)
-
+    bboxes = [x.bbox for x in blems if isinstance(x, HasBoundingBox)]
     if not bboxes:
         msg = (
             "Cannot find any bounding boxes to union. "

svg_ultralight/bounding_boxes/supports_bounds.py

@@ -37,7 +37,7 @@ class SupportsBounds(Protocol):
         cy (float): The center y coordinate.
         width (float): The width of the object.
         height(float): The height of the object.
-        scale (float): The scale of the object.
+        scale ((float, float)): The x and yx and y scale of the object.
 
     There is no setter for scale. Scale is a function of width and height.
     Setting scale would be ambiguous. because the typical implementation of
@@ -45,16 +45,11 @@ class SupportsBounds(Protocol):
     set width and height.
     """
 
-    @property
-    def transformation(self) -> _Matrix:
-        """Return an svg-style transformation matrix."""
-        ...
-
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):
@@ -158,12 +153,12 @@ class SupportsBounds(Protocol):
         """
 
     @property
-    def scale(self) -> float:
+    def scale(self) -> tuple[float, float]:
         """Return scale of the object."""
         ...
 
     @scale.setter
-    def scale(self, value: float):
+    def scale(self, value: tuple[float, float]):
         """Return scale of the object.
 
         :param value: The scale of the object.

svg_ultralight/bounding_boxes/type_bound_collection.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import dataclasses
 from typing import TYPE_CHECKING
 
-from lxml.etree import _Element as EtreeElement  # type: ignore
+from lxml.etree import _Element as EtreeElement  # pyright: ignore[reportPrivateUsage]
 
 from svg_ultralight.bounding_boxes.bound_helpers import new_bbox_union
 from svg_ultralight.bounding_boxes.type_bounding_box import HasBoundingBox
@@ -44,7 +44,7 @@ class BoundCollection(HasBoundingBox):
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):

svg_ultralight/bounding_boxes/type_bound_element.py

@@ -19,7 +19,9 @@ from svg_ultralight.bounding_boxes.type_bounding_box import HasBoundingBox
 from svg_ultralight.transformations import new_transformation_matrix, transform_element
 
 if TYPE_CHECKING:
-    from lxml.etree import _Element as EtreeElement  # type: ignore
+    from lxml.etree import (
+        _Element as EtreeElement,  # pyright: ignore[reportPrivateUsage]
+    )
 
     from svg_ultralight.bounding_boxes.type_bounding_box import BoundingBox
 
@@ -43,14 +45,11 @@ class BoundElement(HasBoundingBox):
         self.elem = element
         self.bbox = bounding_box
 
-    def _update_elem(self):
-        self.elem.attrib["transform"] = self.bbox.transform_string
-
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):

svg_ultralight/bounding_boxes/type_bounding_box.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import dataclasses
+import math
 
 from svg_ultralight.bounding_boxes.supports_bounds import SupportsBounds
 from svg_ultralight.string_conversion import format_number
@@ -15,85 +16,64 @@ from svg_ultralight.transformations import mat_apply, mat_dot, new_transformatio
 _Matrix = tuple[float, float, float, float, float, float]
 
 
-@dataclasses.dataclass
-class BoundingBox(SupportsBounds):
-    """Mutable bounding box object for svg_ultralight.
-
-    :param x: left x value
-    :param y: top y value
-    :param width: width of the bounding box
-    :param height: height of the bounding box
-
-    The below optional parameter, in addition to the required parameters, captures
-    the entire state of a BoundingBox instance. It could be used to make a copy or
-    to initialize a transformed box with the same transform_string as another box.
-    Under most circumstances, it will not be used.
-
-    :param _transformation: transformation matrix
-
-    Functions that return a bounding box will return a BoundingBox instance. This
-    instance can be transformed (uniform scale and translate only). Transformations
-    will be combined and scored to be passed to new_element as a transform value.
-
-    Define the bbox with x=, y=, width=, height=
-
-    Transform the BoundingBox by setting these variables. Each time you set x, cx,
-    x2, y, cy, y2, width, or height, private transformation value _transformation
-    will be updated.
-
-    The ultimate transformation can be accessed through ``.transform_string``.
-    So the workflow will look like :
-
-        1. Get the bounding box of an svg element
-        2. Update the bounding box x, y, width, and height
-        3. Transform the original svg element with
-            update_element(elem, transform=bbox.transform_string)
-        4. The transformed element will lie in the transformed BoundingBox
-
-    In addition to x, y, width, and height, x2 and y2 can be set to establish the
-    right x value or bottom y value.
-
-    The point of all of this is to simplify stacking and aligning elements. To stack:
-
-        ```
-        elem_a = new_element(*args)
-        bbox_a = get_bounding_box(elem_a)
-
-        elem_b = new_element(*args)
-        bbox_b = get_bounding_box(elem_b)
-
-        # align at same x
-        bbox_b.x = bbox_a.x
-
-        # make the same width
-        bbox_b.width = bbox_a.width
+class HasBoundingBox(SupportsBounds):
+    """A parent class for BoundElement and others that have a bbox attribute."""
 
-        # stack a on top of b
-        bbox_a.y2 = bbox_b.y
+    def __init__(self, bbox: BoundingBox) -> None:
+        """Initialize the HasBoundingBox instance."""
+        self.bbox = bbox
 
-        update_element(elem_a, transform=bbox_a.transform_string)
-        update_element(elem_b, transform=bbox_b.transform_string)
-    """
+    def _get_input_corners(
+        self,
+    ) -> tuple[
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+    ]:
+        """Get the input corners of the bounding box.
+
+        :return: four corners counter-clockwise starting at top left
+        """
+        x = self.bbox.base_x
+        y = self.bbox.base_y
+        x2 = x + self.bbox.base_width
+        y2 = y + self.bbox.base_height
+        return (x, y), (x2, y), (x2, y2), (x, y2)
+
+    def _get_transformed_corners(
+        self,
+    ) -> tuple[
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+        tuple[float, float],
+    ]:
+        """Get the transformed corners of the bounding box.
 
-    _x: float
-    _y: float
-    _width: float
-    _height: float
-    _transformation: _Matrix = (1, 0, 0, 1, 0, 0)
+        :return: four corners counter-clockwise starting at top left, transformed by
+            self.transformation
+        """
+        c0, c1, c2, c3 = (
+            mat_apply(self.bbox.transformation, c) for c in self._get_input_corners()
+        )
+        return c0, c1, c2, c3
 
-    @property
-    def transformation(self) -> _Matrix:
-        """Return transformation matrix.
+    def _scale_scale_by_uniform_scalar(self, scalar: float) -> None:
+        """Scale the bounding box uniformly by a factor.
 
-        :return: transformation matrix
+        :param scale: scale factor
+        Unlike self.scale, this does not set the scale, but scales the scale. So if
+        the current scale is (2, 6), and you call this with a scalar of 2, the new
+        scale will be (4, 12).
         """
-        return self._transformation
+        self.transform(scale=(scalar, scalar))
 
     def transform(
         self,
         transformation: _Matrix | None = None,
         *,
-        scale: float | None = None,
+        scale: tuple[float, float] | None = None,
         dx: float | None = None,
         dy: float | None = None,
     ):
@@ -112,10 +92,10 @@ class BoundingBox(SupportsBounds):
         when applying a transformation from another bounding box instance.
         """
         tmat = new_transformation_matrix(transformation, scale=scale, dx=dx, dy=dy)
-        self._transformation = mat_dot(tmat, self.transformation)
+        self.bbox.transformation = mat_dot(tmat, self.bbox.transformation)
 
     @property
-    def scale(self) -> float:
+    def scale(self) -> tuple[float, float]:
         """Get scale of the bounding box.
 
         :return: uniform scale of the bounding box
@@ -127,10 +107,11 @@ class BoundingBox(SupportsBounds):
         width*scale, height => height*scale, scale => scale*scale. This matches how
         scale works in almost every other context.
         """
-        return self.transformation[0]
+        xx, xy, yx, yy, *_ = self.bbox.transformation
+        return math.sqrt(xx * xx + xy * xy), math.sqrt(yx * yx + yy * yy)
 
     @scale.setter
-    def scale(self, value: float) -> None:
+    def scale(self, value: tuple[float, float]) -> None:
         """Scale the bounding box by a uniform factor.
 
         :param value: new scale value
@@ -142,7 +123,8 @@ class BoundingBox(SupportsBounds):
         `scale = 2` -> ignore whatever scale was previously defined and set scale to 2
         `scale *= 2` -> make it twice as big as it was.
         """
-        self.transform(scale=value / self.scale)
+        new_scale = value[0] / self.scale[0], value[1] / self.scale[1]
+        self.transform(scale=new_scale)
 
     @property
     def x(self) -> float:
@@ -150,13 +132,13 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _x value transformed by scale and translation
         """
-        return mat_apply(self.transformation, (self._x, 0))[0]
+        return min(x for x, _ in self._get_transformed_corners())
 
     @x.setter
-    def x(self, value: float) -> None:
-        """Update transformation values (do not alter self._x).
+    def x(self, value: float):
+        """Set the x coordinate of the left edge of the bounding box.
 
-        :param value: new x value after transformation
+        :param value: the new x coordinate of the left edge of the bounding box
         """
         self.transform(dx=value - self.x)
 
@@ -182,7 +164,7 @@ class BoundingBox(SupportsBounds):
 
         :return: transformed x + transformed width
         """
-        return self.x + self.width
+        return max(x for x, _ in self._get_transformed_corners())
 
     @x2.setter
     def x2(self, value: float) -> None:
@@ -198,7 +180,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _y value transformed by scale and translation
         """
-        return mat_apply(self.transformation, (0, self._y))[1]
+        return min(y for _, y in self._get_transformed_corners())
 
     @y.setter
     def y(self, value: float) -> None:
@@ -230,7 +212,7 @@ class BoundingBox(SupportsBounds):
 
         :return: transformed y + transformed height
         """
-        return self.y + self.height
+        return max(y for _, y in self._get_transformed_corners())
 
     @y2.setter
     def y2(self, value: float) -> None:
@@ -246,7 +228,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _width value transformed by scale
         """
-        return self._width * self.scale
+        return self.x2 - self.x
 
     @width.setter
     def width(self, value: float) -> None:
@@ -259,7 +241,7 @@ class BoundingBox(SupportsBounds):
         """
         current_x = self.x
         current_y = self.y
-        self.scale *= value / self.width
+        self._scale_scale_by_uniform_scalar(value / self.width)
         self.x = current_x
         self.y = current_y
 
@@ -269,7 +251,7 @@ class BoundingBox(SupportsBounds):
 
         :return: internal _height value transformed by scale
         """
-        return self._height * self.scale
+        return self.y2 - self.y
 
     @height.setter
     def height(self, value: float) -> None:
@@ -291,7 +273,96 @@ class BoundingBox(SupportsBounds):
         Use with
         ``update_element(elem, transform=bbox.transform_string)``
         """
-        return f"matrix({' '.join(map(format_number, self.transformation))})"
+        return f"matrix({' '.join(map(format_number, self.bbox.transformation))})"
+
+
+@dataclasses.dataclass
+class BoundingBox(HasBoundingBox):
+    """Mutable bounding box object for svg_ultralight.
+
+    :param x: left x value
+    :param y: top y value
+    :param width: width of the bounding box
+    :param height: height of the bounding box
+
+    The below optional parameter, in addition to the required parameters, captures
+    the entire state of a BoundingBox instance. It could be used to make a copy or
+    to initialize a transformed box with the same transform_string as another box.
+    Under most circumstances, it will not be used.
+
+    :param transformation: transformation matrix
+
+    Functions that return a bounding box will return a BoundingBox instance. This
+    instance can be transformed (uniform scale and translate only). Transformations
+    will be combined and scored to be passed to new_element as a transform value.
+
+    Define the bbox with x=, y=, width=, height=
+
+    Transform the BoundingBox by setting these variables. Each time you set x, cx,
+    x2, y, cy, y2, width, or height, private transformation value transformation
+    will be updated.
+
+    The ultimate transformation can be accessed through ``.transform_string``.
+    So the workflow will look like :
+
+        1. Get the bounding box of an svg element
+        2. Update the bounding box x, y, width, and height
+        3. Transform the original svg element with
+            update_element(elem, transform=bbox.transform_string)
+        4. The transformed element will lie in the transformed BoundingBox
+
+    In addition to x, y, width, and height, x2 and y2 can be set to establish the
+    right x value or bottom y value.
+
+    The point of all of this is to simplify stacking and aligning elements. To stack:
+
+        ```
+        elem_a = new_element(*args)
+        bbox_a = get_bounding_box(elem_a)
+
+        elem_b = new_element(*args)
+        bbox_b = get_bounding_box(elem_b)
+
+        # align at same x
+        bbox_b.x = bbox_a.x
+
+        # make the same width
+        bbox_b.width = bbox_a.width
+
+        # stack a on top of b
+        bbox_a.y2 = bbox_b.y
+
+        update_element(elem_a, transform=bbox_a.transform_string)
+        update_element(elem_b, transform=bbox_b.transform_string)
+    """
+
+    base_x: float = dataclasses.field(init=False)
+    base_y: float = dataclasses.field(init=False)
+    base_width: float = dataclasses.field(init=False)
+    base_height: float = dataclasses.field(init=False)
+    transformation: _Matrix = dataclasses.field(init=False)
+
+    def __init__(
+        self,
+        x: float,
+        y: float,
+        width: float,
+        height: float,
+        transformation: _Matrix = (1, 0, 0, 1, 0, 0),
+    ) -> None:
+        """Initialize a BoundingBox instance.
+
+        :param x: left x value
+        :param y: top y value
+        :param width: width of the bounding box
+        :param height: height of the bounding box
+        """
+        self.base_x = x
+        self.base_y = y
+        self.base_width = width
+        self.base_height = height
+        self.transformation = transformation
+        self.bbox = self
 
     def merge(self, *others: BoundingBox) -> BoundingBox:
         """Create a bounding box around all other bounding boxes.
@@ -321,181 +392,3 @@ class BoundingBox(SupportsBounds):
         min_y = min(x.y for x in bboxes)
         max_y = max(x.y + x.height for x in bboxes)
         return BoundingBox(min_x, min_y, max_x - min_x, max_y - min_y)
-
-
-class HasBoundingBox(SupportsBounds):
-    """A parent class for BoundElement and others that have a bbox attribute."""
-
-    def __init__(self, bbox: BoundingBox) -> None:
-        """Initialize the HasBoundingBox instance."""
-        self.bbox = bbox
-
-    @property
-    def transformation(self) -> _Matrix:
-        """The transformation matrix of the bounding box."""
-        return self.bbox.transformation
-
-    def transform(
-        self,
-        transformation: _Matrix | None = None,
-        *,
-        scale: float | None = None,
-        dx: float | None = None,
-        dy: float | None = None,
-    ):
-        """Transform the element and bounding box.
-
-        :param transformation: a 6-tuple transformation matrix
-        :param scale: a scaling factor
-        :param dx: the x translation
-        :param dy: the y translation
-        """
-        self.bbox.transform(transformation, scale=scale, dx=dx, dy=dy)
-
-    @property
-    def scale(self) -> float:
-        """The scale of the bounding box.
-
-        :return: the scale of the bounding box
-        """
-        return self.transformation[0]
-
-    @scale.setter
-    def scale(self, value: float):
-        """Set the scale of the bounding box.
-
-        :param value: the scale of the bounding box
-        """
-        self.transform(scale=value / self.scale)
-
-    @property
-    def x(self) -> float:
-        """The x coordinate of the left edge of the bounding box.
-
-        :return: the x coordinate of the left edge of the bounding box
-        """
-        return self.bbox.x
-
-    @x.setter
-    def x(self, value: float):
-        """Set the x coordinate of the left edge of the bounding box.
-
-        :param value: the new x coordinate of the left edge of the bounding box
-        """
-        self.transform(dx=value - self.x)
-
-    @property
-    def x2(self) -> float:
-        """The x coordinate of the right edge of the bounding box.
-
-        :return: the x coordinate of the right edge of the bounding box
-        """
-        return self.bbox.x2
-
-    @x2.setter
-    def x2(self, value: float):
-        """Set the x coordinate of the right edge of the bounding box.
-
-        :param value: the new x coordinate of the right edge of the bounding box
-        """
-        self.x += value - self.x2
-
-    @property
-    def cx(self) -> float:
-        """The x coordinate of the center of the bounding box.
-
-        :return: the x coordinate of the center of the bounding box
-        """
-        return self.bbox.cx
-
-    @cx.setter
-    def cx(self, value: float):
-        """Set the x coordinate of the center of the bounding box.
-
-        :param value: the new x coordinate of the center of the bounding box
-        """
-        self.x += value - self.cx
-
-    @property
-    def y(self) -> float:
-        """The y coordinate of the top edge of the bounding box.
-
-        :return: the y coordinate of the top edge of the bounding box
-        """
-        return self.bbox.y
-
-    @y.setter
-    def y(self, value: float):
-        """Set the y coordinate of the top edge of the bounding box.
-
-        :param value: the new y coordinate of the top edge of the bounding box
-        """
-        self.transform(dy=value - self.y)
-
-    @property
-    def y2(self) -> float:
-        """The y coordinate of the bottom edge of the bounding box.
-
-        :return: the y coordinate of the bottom edge of the bounding box
-        """
-        return self.bbox.y2
-
-    @y2.setter
-    def y2(self, value: float):
-        """Set the y coordinate of the bottom edge of the bounding box.
-
-        :param value: the new y coordinate of the bottom edge of the bounding box
-        """
-        self.y += value - self.y2
-
-    @property
-    def cy(self) -> float:
-        """The y coordinate of the center of the bounding box.
-
-        :return: the y coordinate of the center of the bounding box
-        """
-        return self.bbox.cy
-
-    @cy.setter
-    def cy(self, value: float):
-        """Set the y coordinate of the center of the bounding box.
-
-        :param value: the new y coordinate of the center of the bounding box
-        """
-        self.y += value - self.cy
-
-    @property
-    def width(self) -> float:
-        """The width of the bounding box.
-
-        :return: the width of the bounding box
-        """
-        return self.bbox.width
-
-    @width.setter
-    def width(self, value: float):
-        """Set the width of the bounding box.
-
-        :param value: the new width of the bounding box
-        """
-        current_x = self.x
-        current_y = self.y
-        self.scale *= value / self.width
-        self.x = current_x
-        self.y = current_y
-
-    @property
-    def height(self) -> float:
-        """The height of the bounding box.
-
-        :return: the height of the bounding box
-        """
-        return self.bbox.height
-
-    @height.setter
-    def height(self, value: float):
-        """Set the height of the bounding box.
-
-        :param value: the new height of the bounding box
-        """
-        self.width *= value / self.height