Add support for calculating basic bbox

.gitignore

@@ -5,3 +5,4 @@ __pycache__
 .hypothesis
 .coverage
 dist
+*.png

svglab/bbox.py

@@ -0,0 +1,90 @@
+import copy
+import uuid
+from collections.abc import Iterator
+
+import PIL.Image
+import pydantic
+import typing_extensions
+from typing_extensions import (
+    Protocol,
+    TypeAlias,
+    TypeVar,
+    runtime_checkable,
+)
+
+from svglab import utils
+from svglab.attrparse import point
+from svglab.elements import common
+
+
+_TagT = TypeVar("_TagT", bound=common.Tag)
+_SvgTag: TypeAlias = common.PairedTag
+
+
+@runtime_checkable
+class _SupportsRender(Protocol):
+    def render(self) -> PIL.Image.Image: ...
+
+
+@pydantic.dataclasses.dataclass(frozen=True)
+class BBox:
+    x_min: pydantic.NonNegativeInt
+    y_min: pydantic.NonNegativeInt
+    x_max: pydantic.NonNegativeInt
+    y_max: pydantic.NonNegativeInt
+
+    def as_tuple(self) -> tuple[int, int, int, int]:
+        return self.x_min, self.y_min, self.x_max, self.y_max
+
+    def as_rect(self) -> typing_extensions.Tuple[point.Point, point.Point]:
+        return point.Point(self.x_min, self.y_min), point.Point(
+            self.x_max, self.y_max
+        )
+
+    def __iter__(self) -> Iterator[int]:
+        return iter(self.as_tuple())
+
+
+def _copy_tree(tag: _TagT) -> tuple[_TagT, _SvgTag]:
+    svg = utils.take_last(tag.parents)
+
+    # type(svg) -> tags.Svg
+    assert isinstance(svg, _SvgTag)
+
+    original_id = tag.id
+    tag.id = uuid.uuid4().hex
+
+    try:
+        svg = copy.deepcopy(svg)
+
+        candidates = svg.find_all(type(tag))
+
+        this = next(tag for tag in candidates if tag.id == tag.id)
+    finally:
+        tag.id = original_id
+
+    return this, svg
+
+
+def _bbox_render(tag: common.Tag) -> PIL.Image.Image:
+    tag_copy, svg = _copy_tree(tag)
+
+    for t in svg.find_all():
+        t.visibility = "hidden"
+
+    tag_copy.visibility = "visible"
+
+    assert isinstance(svg, _SupportsRender)
+    return svg.render()
+
+
+def bbox(tag: common.Tag) -> BBox | None:
+    img = _bbox_render(tag)
+    bbox = img.getbbox()
+
+    if bbox is None:
+        return None
+
+    x_min, y_min, x_max, y_max = bbox
+
+    return BBox(x_min, y_min, x_max, y_max)

svglab/elements/common.py

@@ -19,6 +19,7 @@
 )
 
 from svglab import constants, errors, models, serialize, utils
+from svglab.attrs import groups
 from svglab.attrs import names as attr_names
 from svglab.elements import names
 
@@ -94,6 +95,14 @@ def to_beautifulsoup_object(self) -> bs4.PageElement:
     @abc.abstractmethod
     def _eq(self, other: Self, /) -> bool: ...
 
+    @property
+    def parents(self) -> Generator[Element]:
+        curr = self.parent
+
+        while curr is not None:
+            yield curr
+            curr = curr.parent
+
     @override
     def __eq__(self, other: object) -> bool:
         if not utils.basic_compare(other, self=self):
@@ -102,7 +111,9 @@ def __eq__(self, other: object) -> bool:
         return self._eq(other)
 
 
-class Tag(Element, metaclass=abc.ABCMeta):
+class Tag(
+    Element, groups.Core, groups.Presentation, metaclass=abc.ABCMeta
+):
     """A tag.
 
     A tag is an element that has a name and a set of attributes.
@@ -306,14 +317,6 @@ def descendants(self) -> Generator[Element]:
             if isinstance(child, PairedTag):
                 queue.extend(child.children)
 
-    @property
-    def parents(self) -> Generator[Element]:
-        curr = self.parent
-
-        while curr is not None:
-            yield curr
-            curr = curr.parent
-
     @property
     def next_siblings(self) -> Generator[Element]:
         if self.parent is None or not isinstance(self.parent, PairedTag):
@@ -409,6 +412,9 @@ def to_beautifulsoup_object(self) -> bs4.Tag:
 
         return tag
 
+    @overload
+    def find_all(self, /, *, recursive: bool = True) -> Generator[Tag]: ...
+
     @overload
     def find_all(
         self, *tags: type[_T_tag], recursive: bool = True
@@ -426,6 +432,7 @@ def find_all(
 
         Args:
         tags: The tags to search for. Can be tag names or tag classes.
+            If no search criteria are provided, all tags are returned.
         recursive: If `False`, only search the direct children of the tag,
         otherwise search all descendants.
 
@@ -446,8 +453,9 @@ def find_all(
 
         """
         for child in self.descendants if recursive else self.children:
-            if isinstance(child, Tag) and any(
-                _match_tag(child, search=tag) for tag in tags
+            if isinstance(child, Tag) and (
+                len(tags) == 0
+                or any(_match_tag(child, search=tag) for tag in tags)
             ):
                 yield child
 

svglab/elements/traits.py

@@ -1,12 +1,22 @@
+from __future__ import annotations
+
+from svglab import bbox
 from svglab.attrs import groups, regular
 from svglab.elements import common
 
 
-class Element(groups.Core, groups.Presentation, common.Tag):
+# common attributes are defined directly on the Tag class
+class Element(common.Tag):
     pass
 
 
+class _GraphicalOperations(Element):
+    def bbox(self) -> bbox.BBox | None:
+        return bbox.bbox(self)
+
+
 class GraphicsElement(
+    _GraphicalOperations,
     groups.GraphicalEvents,  # TODO: check if this is correct
     Element,
 ):
@@ -28,6 +38,7 @@ class AnimationElement(
 
 
 class ContainerElement(
+    _GraphicalOperations,
     groups.GraphicalEvents,  # TODO: check if this is correct
     common.PairedTag,
 ):