fix methods to make Brectangle retro compatible

Author: rickymaggio02

docling_core/transforms/serializer/doctags.py

@@ -25,7 +25,7 @@
     DocSerializer,
     create_ser_result,
 )
-from docling_core.types.doc.base import BoundingBox
+from docling_core.types.doc.base import BoundingBox, BoundingRectangle
 from docling_core.types.doc.document import (
     CodeItem,
     DocItem,
@@ -423,7 +423,7 @@ def _get_inline_location_tags(
     ) -> SerializationResult:
 
         prov: Optional[ProvenanceItem] = None
-        boxes: list[BoundingBox] = []
+        boxes: list[Union[BoundingBox, BoundingRectangle]] = []
         doc_items: list[DocItem] = []
         for it, _ in doc.iterate_items(root=item):
             if isinstance(it, DocItem):

docling_core/types/doc/__init__.py

@@ -70,7 +70,6 @@
     TableCellLabel,
 )
 from .page import (
-    BoundingRectangle,
     ColorMixin,
     ColorRGBA,
     Coord2D,

docling_core/types/doc/base.py

@@ -1,12 +1,12 @@
 """Models for the base data types."""
 
-from enum import Enum
-from typing import List, Tuple, NamedTuple
-import numpy as np
 import math
-from shapely.geometry import Polygon
+from enum import Enum
+from typing import List, NamedTuple, Tuple, Union
 
+import numpy as np
 from pydantic import BaseModel
+from shapely.geometry import Polygon
 
 
 class ImageRefMode(str, Enum):
@@ -373,7 +373,9 @@ def is_horizontally_connected(
         return False
 
     @classmethod
-    def enclosing_bbox(cls, boxes: List["BoundingBox"]) -> "BoundingBox":
+    def enclosing_bbox(
+        cls, boxes: List[Union["BoundingBox", "BoundingRectangle"]]
+    ) -> "BoundingBox":
         """Create a bounding box that covers all of the given boxes."""
         if not boxes:
             raise ValueError("No bounding boxes provided for union.")
@@ -385,15 +387,21 @@ def enclosing_bbox(cls, boxes: List["BoundingBox"]) -> "BoundingBox":
                 CoordOrigin to compute their union."
             )
 
-        left = min(box.l for box in boxes)
-        right = max(box.r for box in boxes)
+        # transform every BRectangle in the encloser BBox
+        boxes_post = [
+            box.to_bounding_box() if isinstance(box, BoundingRectangle) else box
+            for box in boxes
+        ]
+
+        left = min(box.l for box in boxes_post)
+        right = max(box.r for box in boxes_post)
 
         if origin == CoordOrigin.TOPLEFT:
-            top = min(box.t for box in boxes)
-            bottom = max(box.b for box in boxes)
+            top = min(box.t for box in boxes_post)
+            bottom = max(box.b for box in boxes_post)
         elif origin == CoordOrigin.BOTTOMLEFT:
-            top = max(box.t for box in boxes)
-            bottom = min(box.b for box in boxes)
+            top = max(box.t for box in boxes_post)
+            bottom = min(box.b for box in boxes_post)
         else:
             raise ValueError("BoundingBoxes have different CoordOrigin")
 
@@ -437,6 +445,7 @@ def y_union_with(self, other: "BoundingBox") -> float:
             return max(0.0, max(self.t, other.t) - min(self.b, other.b))
         raise ValueError("Unsupported CoordOrigin")
 
+
 class Coord2D(NamedTuple):
     """A 2D coordinate with x and y components."""
 
@@ -503,6 +512,82 @@ def centre(self):
             self.r_y0 + self.r_y1 + self.r_y2 + self.r_y3
         ) / 4.0
 
+    @property
+    def l(self):  # noqa: E743
+        """Left value of the inclosing rectangle."""
+        return min([self.r_x0, self.r_x1, self.r_x2, self.r_x3])
+
+    @property
+    def r(self):
+        """Right value of the inclosing rectangle."""
+        return max([self.r_x0, self.r_x1, self.r_x2, self.r_x3])
+
+    @property
+    def t(self):
+        """Top value of the inclosing rectangle."""
+        if self.coord_origin == CoordOrigin.BOTTOMLEFT:
+            top = max([self.r_y0, self.r_y1, self.r_y2, self.r_y3])
+        else:
+            top = min([self.r_y0, self.r_y1, self.r_y2, self.r_y3])
+        return top
+
+    @property
+    def b(self):
+        """Bottom value of the inclosing rectangle."""
+        if self.coord_origin == CoordOrigin.BOTTOMLEFT:
+            bottom = min([self.r_y0, self.r_y1, self.r_y2, self.r_y3])
+        else:
+            bottom = max([self.r_y0, self.r_y1, self.r_y2, self.r_y3])
+        return bottom
+
+    def resize_by_scale(self, x_scale: float, y_scale: float):
+        """resize_by_scale."""
+        rect_to_bbox = self.to_bounding_box()
+        return BoundingBox(
+            l=rect_to_bbox.l * x_scale,
+            r=rect_to_bbox.r * x_scale,
+            t=rect_to_bbox.t * y_scale,
+            b=rect_to_bbox.b * y_scale,
+            coord_origin=self.coord_origin,
+        )
+
+    def scale_to_size(self, old_size: Size, new_size: Size):
+        """scale_to_size."""
+        return self.resize_by_scale(
+            x_scale=new_size.width / old_size.width,
+            y_scale=new_size.height / old_size.height,
+        )
+
+    def scaled(self, scale: float):
+        """scaled."""
+        return self.resize_by_scale(x_scale=scale, y_scale=scale)
+
+    def normalized(self, page_size: Size):
+        """normalized."""
+        return self.scale_to_size(
+            old_size=page_size, new_size=Size(height=1.0, width=1.0)
+        )
+
+    def expand_by_scale(self, x_scale: float, y_scale: float) -> "BoundingBox":
+        """expand_to_size."""
+        rect_to_bbox = self.to_bounding_box()
+        if self.coord_origin == CoordOrigin.TOPLEFT:
+            return BoundingBox(
+                l=rect_to_bbox.l - rect_to_bbox.width * x_scale,
+                r=rect_to_bbox.r + rect_to_bbox.width * x_scale,
+                t=rect_to_bbox.t - rect_to_bbox.height * y_scale,
+                b=rect_to_bbox.b + rect_to_bbox.height * y_scale,
+                coord_origin=self.coord_origin,
+            )
+        elif self.coord_origin == CoordOrigin.BOTTOMLEFT:
+            return BoundingBox(
+                l=rect_to_bbox.l - rect_to_bbox.width * x_scale,
+                r=rect_to_bbox.r + rect_to_bbox.width * x_scale,
+                t=rect_to_bbox.t + rect_to_bbox.height * y_scale,
+                b=rect_to_bbox.b - rect_to_bbox.height * y_scale,
+                coord_origin=self.coord_origin,
+            )
+
     def to_bounding_box(self) -> BoundingBox:
         """Convert to a BoundingBox representation."""
         if self.coord_origin == CoordOrigin.BOTTOMLEFT:
@@ -524,8 +609,12 @@ def to_bounding_box(self) -> BoundingBox:
         )
 
     @classmethod
-    def from_bounding_box(cls, bbox: BoundingBox) -> "BoundingRectangle":
+    def from_bounding_box(
+        cls, bbox: Union["BoundingRectangle", BoundingBox]
+    ) -> "BoundingRectangle":
         """Convert a BoundingBox into a BoundingRectangle."""
+        if isinstance(bbox, BoundingRectangle):
+            return bbox
         return cls(
             r_x0=bbox.l,
             r_y0=bbox.b,
@@ -546,7 +635,7 @@ def to_polygon(self) -> List[Coord2D]:
             Coord2D(self.r_x2, self.r_y2),
             Coord2D(self.r_x3, self.r_y3),
         ]
-    
+
     def to_list(self) -> List[Tuple]:
         """Convert to a list of tuple point coordinates."""
         return [
@@ -555,14 +644,30 @@ def to_list(self) -> List[Tuple]:
             (self.r_x2, self.r_y2),
             (self.r_x3, self.r_y3),
         ]
-    
+
+    def as_tuple(self) -> Tuple[float, float, float, float, float, float, float, float]:
+        """as_tuple."""
+        return (
+            self.r_x0,
+            self.r_y0,
+            self.r_x1,
+            self.r_y1,
+            self.r_x2,
+            self.r_y2,
+            self.r_x3,
+            self.r_y3,
+        )
+
     def to_shapely_polygon(self) -> Polygon:
-        return Polygon([
-            (self.r_x0, self.r_y0),
-            (self.r_x1, self.r_y1),
-            (self.r_x2, self.r_y2),
-            (self.r_x3, self.r_y3),
-        ])
+        """To shapely polygon."""
+        return Polygon(
+            [
+                (self.r_x0, self.r_y0),
+                (self.r_x1, self.r_y1),
+                (self.r_x2, self.r_y2),
+                (self.r_x3, self.r_y3),
+            ]
+        )
 
     def to_bottom_left_origin(self, page_height: float) -> "BoundingRectangle":
         """Convert coordinates to use bottom-left origin.
@@ -615,14 +720,11 @@ def to_top_left_origin(self, page_height: float) -> "BoundingRectangle":
     def intersection_over_union(
         self, other: "BoundingRectangle", eps: float = 1.0e-6
     ) -> float:
-        """intersection_over_union."""
-
+        """Intersection_over_union."""
         polygon_other = other.to_shapely_polygon()
         current_polygon = self.to_shapely_polygon()
-        
+
         intersection_area = current_polygon.intersection(polygon_other).area
         union_area = current_polygon.union(polygon_other).area
-        
-        return intersection_area / (union_area + eps)
-
 
+        return intersection_area / (union_area + eps)

docling_core/types/doc/document.py

@@ -394,7 +394,9 @@ def get_row_bounding_boxes(self) -> dict[int, BoundingBox]:
         row_bboxes: dict[int, BoundingBox] = {}
 
         for row_idx in range(self.num_rows):
-            row_cells_with_bbox: dict[int, list[BoundingBox]] = {}
+            row_cells_with_bbox: dict[
+                int, list[Union["BoundingBox", "BoundingRectangle"]]
+            ] = {}
 
             # Collect all cells in this row that have bounding boxes
             for cell in self.table_cells:
@@ -448,7 +450,9 @@ def get_column_bounding_boxes(self) -> dict[int, BoundingBox]:
         col_bboxes: dict[int, BoundingBox] = {}
 
         for col_idx in range(self.num_cols):
-            col_cells_with_bbox: dict[int, list[BoundingBox]] = {}
+            col_cells_with_bbox: dict[
+                int, list[Union["BoundingBox", "BoundingRectangle"]]
+            ] = {}
 
             # Collect all cells in this row that have bounding boxes
             for cell in self.table_cells:

docling_core/types/doc/page.py

@@ -3,31 +3,23 @@
 import copy
 import json
 import logging
-import math
 import re
 import typing
 from enum import Enum
 from pathlib import Path
-from typing import (
-    Annotated,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Literal,
-    NamedTuple,
-    Optional,
-    Tuple,
-    Union,
-)
+from typing import Annotated, Any, Dict, Iterator, List, Literal, Optional, Tuple, Union
 
-import numpy as np
 from PIL import Image as PILImage
 from PIL import ImageColor, ImageDraw, ImageFont
 from PIL.ImageFont import FreeTypeFont
 from pydantic import AnyUrl, BaseModel, Field, model_validator
 
-from docling_core.types.doc.base import BoundingBox, BoundingRectangle, CoordOrigin, Coord2D
+from docling_core.types.doc.base import (
+    BoundingBox,
+    BoundingRectangle,
+    Coord2D,
+    CoordOrigin,
+)
 from docling_core.types.doc.document import ImageRef
 
 _logger = logging.getLogger(__name__)
@@ -80,6 +72,7 @@ def __iter__(self):
         """Yield the color components for iteration."""
         yield from (self.r, self.g, self.b, self.a)
 
+
 class OrderedElement(BaseModel):
     """Base model for elements that have an ordering index."""
 

docling_core/types/doc/tokens.py

@@ -8,8 +8,8 @@
 from enum import Enum
 from typing import Tuple, Union
 
-from docling_core.types.doc.labels import DocItemLabel
 from docling_core.types.doc.base import BoundingBox, BoundingRectangle
+from docling_core.types.doc.labels import DocItemLabel
 
 
 class TableToken(str, Enum):
@@ -263,7 +263,9 @@ def get_code_language_token(code_language: str) -> str:
         return _CodeLanguageToken(f"<_{code_language}_>").value
 
     @staticmethod
-    def get_location_token(val: float, rnorm: int = 500, prefix=_LOC_PREFIX):  # TODO review
+    def get_location_token(
+        val: float, rnorm: int = 500, prefix=_LOC_PREFIX
+    ):  # TODO review
         """Function to get location tokens."""
         val_ = round(rnorm * val)
         val_ = max(val_, 0)
@@ -280,11 +282,11 @@ def get_location(
     ):
         """Get the location string given bbox and page-dim."""
         if isinstance(bbox, BoundingBox):
-            #the transform this case into the old case
+            # the transform this case into the old case
             bbox = bbox.to_top_left_origin(page_h).as_tuple()
 
         if isinstance(bbox, tuple):
-            #old case
+            # old case
             assert bbox[0] <= bbox[2], f"bbox[0]<=bbox[2] => {bbox[0]}<={bbox[2]}"
             assert bbox[1] <= bbox[3], f"bbox[1]<=bbox[3] => {bbox[1]}<={bbox[3]}"
 
@@ -299,25 +301,33 @@ def get_location(
             y1_tok = DocumentToken.get_location_token(val=max(y0, y1), rnorm=ysize)
 
             loc_str = f"{x0_tok}{y0_tok}{x1_tok}{y1_tok}"
-        
+
         elif isinstance(bbox, BoundingRectangle):
-            #use the prefix rec, 4 elements required
+            # use the prefix rec, 4 elements required
             vertices = bbox.to_top_left_origin(page_h).to_polygon()
             # Convection for the rectangle vertices:
             #     3 +-------+ 2
             #       | hello |
             #     0 +-------+ 1
             # 0->1 line must be the baseline for the words
-            
+
             vertices_tok = []
             for vertex in vertices:
-                vertex_x_norm = vertex.x/ page_w
-                vertices_tok.append(DocumentToken.get_location_token(val= vertex_x_norm, rnorm=xsize, prefix=_REC_PREFIX))
-                vertex_y_norm = vertex.y/ page_h
-                vertices_tok.append(DocumentToken.get_location_token(val=vertex_y_norm, rnorm=ysize, prefix=_REC_PREFIX))
+                vertex_x_norm = vertex.x / page_w
+                vertices_tok.append(
+                    DocumentToken.get_location_token(
+                        val=vertex_x_norm, rnorm=xsize, prefix=_REC_PREFIX
+                    )
+                )
+                vertex_y_norm = vertex.y / page_h
+                vertices_tok.append(
+                    DocumentToken.get_location_token(
+                        val=vertex_y_norm, rnorm=ysize, prefix=_REC_PREFIX
+                    )
+                )
 
             loc_str = ""
             for vertex_tok in vertices_tok:
-                loc_str += f'{vertex_tok}'
+                loc_str += f"{vertex_tok}"
 
         return loc_str