deepdoctection 0.37.3__tar.gz → 0.38__tar.gz

{deepdoctection-0.37.3 → deepdoctection-0.38}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: deepdoctection
-Version: 0.37.3
+Version: 0.38
 Summary: Repository for Document AI
 Home-page: https://github.com/deepdoctection/deepdoctection
 Author: Dr. Janis Meyer
@@ -127,6 +127,16 @@ Requires-Dist: types-urllib3>=1.26.25.14; extra == "dev"
 Provides-Extra: test
 Requires-Dist: pytest==8.0.2; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 <p align="center">

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/__init__.py

@@ -24,7 +24,7 @@ from .utils.logger import LoggingRecord, logger
 
 # pylint: enable=wrong-import-position
 
-__version__ = "0.37.3"
+__version__ = "0.38"
 
 _IMPORT_STRUCTURE = {
     "analyzer": ["config_sanity_checks", "get_dd_analyzer", "ServiceFactory"],

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/analyzer/_config.py

@@ -91,7 +91,8 @@ cfg.SEGMENTATION.PUBTABLES_SUB_ITEM_NAMES = [CellType.ROW_NUMBER, CellType.COLUM
 cfg.SEGMENTATION.CELL_NAMES = [CellType.HEADER, CellType.BODY, LayoutType.CELL]
 cfg.SEGMENTATION.ITEM_NAMES = [LayoutType.ROW, LayoutType.COLUMN]
 cfg.SEGMENTATION.SUB_ITEM_NAMES = [CellType.ROW_NUMBER, CellType.COLUMN_NUMBER]
-
+cfg.SEGMENTATION.PUBTABLES_ITEM_HEADER_CELL_NAMES = [CellType.COLUMN_HEADER, CellType.ROW_HEADER]
+cfg.SEGMENTATION.PUBTABLES_ITEM_HEADER_THRESHOLDS = [0.6, 0.0001]
 cfg.SEGMENTATION.STRETCH_RULE = "equal"
 
 cfg.USE_TABLE_REFINEMENT = True

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/analyzer/factory.py

@@ -51,7 +51,7 @@ from ..pipe.transform import SimpleTransformService
 from ..utils.file_utils import detectron2_available
 from ..utils.fs import get_configs_dir_path
 from ..utils.metacfg import AttrDict
-from ..utils.settings import LayoutType, Relationships
+from ..utils.settings import CellType, LayoutType, Relationships
 from ..utils.transform import PadTransform
 
 with try_import() as image_guard:
@@ -264,14 +264,17 @@ class ServiceFactory:
         :param mode: either `LAYOUT`,`CELL` or `ITEM`
         :return: `SubImageLayoutService` instance
         """
-        exclude_category_ids = []
+        exclude_category_names = []
         padder = None
         if mode == "ITEM":
             if detector.__class__.__name__ in ("HFDetrDerivedDetector",):
-                exclude_category_ids.extend([1, 3, 4, 5, 6])
+                exclude_category_names.extend(
+                    [LayoutType.TABLE, CellType.COLUMN_HEADER, CellType.PROJECTED_ROW_HEADER, CellType.SPANNING]
+                )
                 padder = ServiceFactory.build_padder(config, mode)
         detect_result_generator = DetectResultGenerator(
-            categories=detector.categories.categories, exclude_category_ids=exclude_category_ids
+            categories_name_as_key=detector.categories.get_categories(as_dict=True, name_as_key=True),
+            exclude_category_names=exclude_category_names,
         )
         return SubImageLayoutService(
             sub_image_detector=detector,
@@ -399,6 +402,8 @@ class ServiceFactory:
                 spanning_cell_names=config.SEGMENTATION.PUBTABLES_SPANNING_CELL_NAMES,
                 item_names=config.SEGMENTATION.PUBTABLES_ITEM_NAMES,
                 sub_item_names=config.SEGMENTATION.PUBTABLES_SUB_ITEM_NAMES,
+                item_header_cell_names=config.SEGMENTATION.PUBTABLES_ITEM_HEADER_CELL_NAMES,
+                item_header_thresholds=config.SEGMENTATION.PUBTABLES_ITEM_HEADER_THRESHOLDS,
                 stretch_rule=config.SEGMENTATION.STRETCH_RULE,
             )
 

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/configs/conf_dd_one.yaml

@@ -1,104 +1,145 @@
-USE_ROTATOR: False
-USE_LAYOUT: True
-USE_TABLE_SEGMENTATION: True
-TF:
-  LAYOUT:
-    WEIGHTS: layout/model-800000_inf_only.data-00000-of-00001
-    FILTER:
+DEVICE: null
+LANGUAGE: null
+LAYOUT_LINK:
+  CHILD_CATEGORIES: []
+  PARENTAL_CATEGORIES: []
+LAYOUT_NMS_PAIRS:
+  COMBINATIONS: null
+  PRIORITY: null
+  THRESHOLDS: null
+LIB: null
+OCR:
+  CONFIG:
+    TESSERACT: dd/conf_tesseract.yaml
+  USE_DOCTR: false
+  USE_TESSERACT: true
+  USE_TEXTRACT: false
+  WEIGHTS:
+    DOCTR_RECOGNITION:
+      PT: doctr/crnn_vgg16_bn/pt/crnn_vgg16_bn-9762b0b0.pt
+      TF: doctr/crnn_vgg16_bn/tf/crnn_vgg16_bn-76b7f2c6.zip
+    DOCTR_WORD:
+      PT: doctr/db_resnet50/pt/db_resnet50-ac60cadc.pt
+      TF: doctr/db_resnet50/tf/db_resnet50-adcafc63.zip
+PDF_MINER:
+  X_TOLERANCE: 3
+  Y_TOLERANCE: 3
+PT:
   CELL:
-    WEIGHTS: cell/model-1800000_inf_only.data-00000-of-00001
-    FILTER:
+    FILTER: null
+    WEIGHTS: cell/d2_model_1849999_cell_inf_only.pt
+    WEIGHTS_TS: cell/d2_model_1849999_cell_inf_only.ts
   ITEM:
-    WEIGHTS: item/model-1620000_inf_only.data-00000-of-00001
-    FILTER:
-PT:
-  LAYOUT:
-    WEIGHTS: layout/d2_model_0829999_layout_inf_only.pt
-    WEIGHTS_TS: layout/d2_model_0829999_layout_inf_only.ts
-    FILTER:
+    FILTER: null
     PAD:
-      TOP: 60
-      RIGHT: 60
       BOTTOM: 60
       LEFT: 60
-  ITEM:
+      RIGHT: 60
+      TOP: 60
     WEIGHTS: item/d2_model_1639999_item_inf_only.pt
     WEIGHTS_TS: item/d2_model_1639999_item_inf_only.ts
-    FILTER:
+  LAYOUT:
+    FILTER: null
     PAD:
-      TOP: 60
-      RIGHT: 60
       BOTTOM: 60
       LEFT: 60
-  CELL:
-    WEIGHTS: cell/d2_model_1849999_cell_inf_only.pt
-    WEIGHTS_TS: cell/d2_model_1849999_cell_inf_only.ts
-    FILTER:
-LAYOUT_NMS_PAIRS:
-  COMBINATIONS:
-  THRESHOLDS:
-  PRIORITY:
+      RIGHT: 60
+      TOP: 60
+    WEIGHTS: layout/d2_model_0829999_layout_inf_only.pt
+    WEIGHTS_TS: layout/d2_model_0829999_layout_inf_only.ts
 SEGMENTATION:
   ASSIGNMENT_RULE: ioa
-  THRESHOLD_ROWS: 0.4
-  THRESHOLD_COLS: 0.4
-  FULL_TABLE_TILING: True
-  REMOVE_IOU_THRESHOLD_ROWS: 0.001
-  REMOVE_IOU_THRESHOLD_COLS: 0.001
   CELL_CATEGORY_ID: 12
-  STRETCH_RULE: equal
-USE_TABLE_REFINEMENT: True
-USE_PDF_MINER: False
-PDF_MINER:
-  X_TOLERANCE: 3
-  Y_TOLERANCE: 3
-USE_OCR: True
-OCR:
-  USE_TESSERACT: True
-  USE_DOCTR: False
-  USE_TEXTRACT: False
-  CONFIG:
-    TESSERACT: dd/conf_tesseract.yaml
-  WEIGHTS:
-    DOCTR_WORD:
-      TF: doctr/db_resnet50/tf/db_resnet50-adcafc63.zip
-      PT: doctr/db_resnet50/pt/db_resnet50-ac60cadc.pt
-    DOCTR_RECOGNITION:
-      TF: doctr/crnn_vgg16_bn/tf/crnn_vgg16_bn-76b7f2c6.zip
-      PT: doctr/crnn_vgg16_bn/pt/crnn_vgg16_bn-9762b0b0.pt
-WORD_MATCHING:
-  PARENTAL_CATEGORIES:
-    - text
-    - title
-    - list
-    - cell
+  CELL_NAMES:
+  - header
+  - body
+  - cell
+  FULL_TABLE_TILING: true
+  ITEM_NAMES:
+  - row
+  - column
+  PUBTABLES_CELL_NAMES:
+  - spanning
+  - row_header
+  - column_header
+  - projected_row_header
+  - cell
+  PUBTABLES_ITEM_NAMES:
+  - row
+  - column
+  PUBTABLES_SPANNING_CELL_NAMES:
+  - spanning
+  - row_header
+  - column_header
+  - projected_row_header
+  PUBTABLES_SUB_ITEM_NAMES:
+  - row_number
+  - column_number
+  PUBTABLES_ITEM_HEADER_CELL_NAMES:
     - column_header
-    - projected_row_header
-    - spanning
     - row_header
-  RULE: ioa
-  THRESHOLD: 0.6
-  MAX_PARENT_ONLY: True
+  PUBTABLES_ITEM_HEADER_THRESHOLDS:
+    - 0.6
+    - 0.0001
+  REMOVE_IOU_THRESHOLD_COLS: 0.001
+  REMOVE_IOU_THRESHOLD_ROWS: 0.001
+  STRETCH_RULE: equal
+  SUB_ITEM_NAMES:
+  - row_number
+  - column_number
+  TABLE_NAME: table
+  THRESHOLD_COLS: 0.4
+  THRESHOLD_ROWS: 0.4
+TEXT_CONTAINER: word
 TEXT_ORDERING:
-  TEXT_BLOCK_CATEGORIES:
-    - title
-    - text
-    - list
-    - cell
-    - column_header
-    - projected_row_header
-    - spanning
-    - row_header
-  FLOATING_TEXT_BLOCK_CATEGORIES:
-    - title
-    - text
-    - list
-  INCLUDE_RESIDUAL_TEXT_CONTAINER: False
-  STARTING_POINT_TOLERANCE: 0.005
   BROKEN_LINE_TOLERANCE: 0.003
+  FLOATING_TEXT_BLOCK_CATEGORIES:
+  - text
+  - title
+  - figure
+  - list
   HEIGHT_TOLERANCE: 2.0
+  INCLUDE_RESIDUAL_TEXT_CONTAINER: false
   PARAGRAPH_BREAK: 0.035
-  USE_LAYOUT_LINK: False
-  LAYOUT_LINK:
-    PARENTAL_CATEGORIES:
-    CHILD_CATEGORIES:
+  STARTING_POINT_TOLERANCE: 0.005
+  TEXT_BLOCK_CATEGORIES:
+  - text
+  - title
+  - list
+  - cell
+  - figure
+  - column_header
+  - projected_row_header
+  - spanning
+  - row_header
+TF:
+  CELL:
+    FILTER: null
+    WEIGHTS: cell/model-1800000_inf_only.data-00000-of-00001
+  ITEM:
+    FILTER: null
+    WEIGHTS: item/model-1620000_inf_only.data-00000-of-00001
+  LAYOUT:
+    FILTER: null
+    WEIGHTS: layout/model-800000_inf_only.data-00000-of-00001
+USE_LAYOUT: true
+USE_LAYOUT_LINK: false
+USE_LAYOUT_NMS: false
+USE_OCR: true
+USE_PDF_MINER: false
+USE_ROTATOR: false
+USE_TABLE_REFINEMENT: true
+USE_TABLE_SEGMENTATION: true
+WORD_MATCHING:
+  MAX_PARENT_ONLY: true
+  PARENTAL_CATEGORIES:
+  - text
+  - title
+  - list
+  - cell
+  - column_header
+  - projected_row_header
+  - spanning
+  - row_header
+  RULE: ioa
+  THRESHOLD: 0.6

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/datapoint/box.py

@@ -491,10 +491,8 @@ def global_to_local_coords(global_box: BoundingBox, embedding_box: BoundingBox)
 
 def merge_boxes(*boxes: BoundingBox) -> BoundingBox:
     """
-    Generating the smallest box containing an arbitrary tuple/list of boxes. This function is only implemented for boxes
-    with absolute coords = "True".
-
-    :param boxes: An arbitrary tuple/list of bounding boxes `BoundingBox` all having absolute_coords="True".
+    Generating the smallest box containing an arbitrary tuple/list of boxes.
+    :param boxes: An arbitrary tuple/list of bounding boxes `BoundingBox`.
     """
     absolute_coords = boxes[0].absolute_coords
     assert all(box.absolute_coords == absolute_coords for box in boxes), "all boxes must have same absolute_coords"

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/datapoint/image.py

@@ -428,7 +428,7 @@ class Image:
         A list of attributes to suspend from as_dict creation.
         """
 
-        return ["_image", "_annotation_ids", "_category_name"]
+        return ["_annotation_ids", "_category_name"]
 
     def define_annotation_id(self, annotation: Annotation) -> str:
         """
@@ -572,24 +572,31 @@ class Image:
         ann = self.get_annotation(annotation_ids=annotation_id)[0]
         if ann.image is None:
             raise ImageError("When adding sub images to ImageAnnotation then ImageAnnotation.image must not be None")
-        assert ann.bounding_box is not None
-        box = ann.bounding_box.to_list("xyxy")
+        box = ann.get_bounding_box(self.image_id).to_list("xyxy")
         proposals = self.get_annotation(category_names)
         points = np.array([prop.get_bounding_box(self.image_id).center for prop in proposals])
+        if not points.size:
+            return
         ann_ids = np.array([prop.annotation_id for prop in proposals])
         indices = np.where(
             (box[0] < points[:, 0]) & (box[1] < points[:, 1]) & (box[2] > points[:, 0]) & (box[3] > points[:, 1])
         )[0]
         selected_ids = ann_ids[indices]
         sub_images = self.get_annotation(annotation_ids=selected_ids.tolist())
+        ann_box = ann.get_bounding_box(self.image_id)
+        if not ann_box.absolute_coords:
+            ann_box = ann_box.transform(self.width, self.height, absolute_coords=True)
         for sub_image in sub_images:
             if sub_image.image is None:
                 raise ImageError(
                     "When setting an embedding to ImageAnnotation then ImageAnnotation.image must not be None"
                 )
+            sub_image_box = sub_image.get_bounding_box(self.image_id)
+            if not sub_image_box.absolute_coords:
+                sub_image_box = sub_image_box.transform(self.width, self.height, absolute_coords=True)
             sub_image.image.set_embedding(
                 annotation_id,
-                global_to_local_coords(sub_image.get_bounding_box(self.image_id), ann.get_bounding_box(self.image_id)),
+                global_to_local_coords(sub_image_box, ann_box),
             )
             ann.image.dump(sub_image)
 

{deepdoctection-0.37.3 → deepdoctection-0.38}/deepdoctection/datapoint/view.py

@@ -28,7 +28,7 @@ import numpy as np
 from typing_extensions import LiteralString
 
 from ..utils.error import AnnotationError, ImageError
-from ..utils.logger import LoggingRecord, logger
+from ..utils.logger import LoggingRecord, log_once, logger
 from ..utils.settings import (
     CellType,
     LayoutType,
@@ -282,25 +282,103 @@ class Table(Layout):
     """
 
     @property
-    def cells(self) -> list[ImageAnnotationBaseView]:
+    def cells(self) -> list[Cell]:
         """
         A list of a table cells.
         """
         all_relation_ids = self.get_relationship(Relationships.CHILD)
-        cell_anns = self.base_page.get_annotation(
+        cell_anns: list[Cell] = self.base_page.get_annotation(  # type: ignore
             annotation_ids=all_relation_ids,
             category_names=[
                 LayoutType.CELL,
                 CellType.HEADER,
                 CellType.BODY,
-                CellType.PROJECTED_ROW_HEADER,
                 CellType.SPANNING,
-                CellType.ROW_HEADER,
-                CellType.COLUMN_HEADER,
             ],
         )
         return cell_anns
 
+    @property
+    def column_header_cells(self) -> list[Cell]:
+        """
+        Retrieve a list of cells that are column headers in the table.
+
+        This property filters and sorts the cells in the table to return only those that are column headers.
+        The cells are sorted by their column number.
+
+        :return: A list of `Cell` objects that are column headers.
+        """
+        all_relation_ids = self.get_relationship(Relationships.CHILD)
+        all_cells: list[Cell] = self.base_page.get_annotation(  # type: ignore
+            category_names=[LayoutType.CELL, CellType.SPANNING], annotation_ids=all_relation_ids
+        )
+        headers = list(filter(lambda cell: CellType.COLUMN_HEADER in cell.sub_categories, all_cells))
+        headers.sort(key=lambda x: x.column_number)  # type: ignore
+        return headers
+
+    @property
+    def row_header_cells(self) -> list[Cell]:
+        """
+        Retrieve a list of cells that are row headers in the table.
+
+        This property filters and sorts the cells in the table to return only those that are row headers.
+        The cells are sorted by their column number.
+
+        :return: A list of `Cell` objects that are row headers.
+        """
+        all_relation_ids = self.get_relationship(Relationships.CHILD)
+        all_cells: list[Cell] = self.base_page.get_annotation( # type: ignore
+            category_names=[LayoutType.CELL, CellType.SPANNING], annotation_ids=all_relation_ids
+        )
+        row_header_cells = list(filter(lambda cell: CellType.ROW_HEADER in cell.sub_categories, all_cells))
+        row_header_cells.sort(key=lambda x: x.column_number)  # type: ignore
+        return row_header_cells
+
+    def kv_header_rows(self, row_number: int) -> Mapping[str, str]:
+        """
+        For a given row number, returns a dictionary mapping column headers to cell values in that row.
+
+        This method retrieves all cells in the specified row and matches them with their corresponding column headers.
+        It then creates a key-value pair where the key is a tuple containing the column number and header text,
+        and the value is the cell text.
+
+        :param row_number: The row number for which to retrieve the key-value pairs.
+        :return: A dictionary where keys are tuples of (column number, header text) and values are cell texts.
+
+        Example:
+        If the table has the following structure:
+        | Header1 | Header2 |
+        |---------|---------|
+        | Value1  | Value2  |
+        | Value3  | Value4  |
+
+        Calling kv_header_rows(1) would return:
+        {
+            (1, 'Header1'): 'Value1',
+            (2, 'Header2'): 'Value2'
+        }
+        """
+        all_relation_ids = self.get_relationship(Relationships.CHILD)
+        all_cells = self.base_page.get_annotation(
+            category_names=[LayoutType.CELL, CellType.SPANNING], annotation_ids=all_relation_ids
+        )
+        row_cells = list(
+            filter(
+                lambda c: row_number in (c.row_number, c.row_number + c.row_span), all_cells  # type: ignore
+            )
+        )
+        row_cells.sort(key=lambda c: c.column_number) # type: ignore
+        column_header_cells = self.column_header_cells
+
+        kv_dict: Mapping[str, str] = {}
+        for cell in row_cells:
+            for header in column_header_cells:
+                if (cell.column_number == header.column_number and  # type: ignore
+                        cell.annotation_id != header.annotation_id):  # type: ignore
+                    kv_dict[(header.column_number, header.text)] = cell.text  # type: ignore
+                    break
+        return kv_dict
+
     @property
     def rows(self) -> list[ImageAnnotationBaseView]:
         """
@@ -335,7 +413,7 @@ class Table(Layout):
             try:
                 html_index = html_list.index(cell.annotation_id)
                 html_list.pop(html_index)
-                html_list.insert(html_index, cell.text)  # type: ignore
+                html_list.insert(html_index, cell.text)
             except ValueError:
                 logger.warning(LoggingRecord("html construction not possible", {"annotation_id": cell.annotation_id}))
 
@@ -357,6 +435,12 @@ class Table(Layout):
         cells = self.cells
         table_list = [["" for _ in range(self.number_of_columns)] for _ in range(self.number_of_rows)]  # type: ignore
         for cell in cells:
+            if cell.category_name == CellType.SPANNING:
+                log_once(
+                    "Table has spanning cells. This implies, that the .csv output will not be correct."
+                    "To prevent spanning cell table creation set PT.ITEM.FILTER=['table','spanning'] ",
+                    "error",
+                )
             table_list[cell.row_number - 1][cell.column_number - 1] = (  # type: ignore
                 table_list[cell.row_number - 1][cell.column_number - 1] + cell.text + " "  # type: ignore
             )
@@ -386,13 +470,13 @@ class Table(Layout):
         token_class_ids: list[str] = []
         token_tag_ids: list[str] = []
         for cell in cells:
-            text.extend(cell.text_["text"])  # type: ignore
-            words.extend(cell.text_["words"])  # type: ignore
-            ann_ids.extend(cell.text_["ann_ids"])  # type: ignore
-            token_classes.extend(cell.text_["token_classes"])  # type: ignore
-            token_tags.extend(cell.text_["token_tags"])  # type: ignore
-            token_class_ids.extend(cell.text_["token_class_ids"])  # type: ignore
-            token_tag_ids.extend(cell.text_["token_tag_ids"])  # type: ignore
+            text.extend(cell.text_["text"])
+            words.extend(cell.text_["words"])
+            ann_ids.extend(cell.text_["ann_ids"])
+            token_classes.extend(cell.text_["token_classes"])
+            token_tags.extend(cell.text_["token_tags"])
+            token_class_ids.extend(cell.text_["token_class_ids"])
+            token_tag_ids.extend(cell.text_["token_tag_ids"])
         return {
             "text": " ".join(text),
             "words": words,
@@ -414,7 +498,7 @@ class Table(Layout):
         if not cells:
             return super().words
         for cell in cells:
-            all_words.extend(cell.words)  # type: ignore
+            all_words.extend(cell.words)
         return all_words
 
     def get_ordered_words(self) -> list[ImageAnnotationBaseView]:
@@ -424,7 +508,7 @@ class Table(Layout):
             all_words = []
             cells.sort(key=lambda x: (x.ROW_NUMBER, x.COLUMN_NUMBER))
             for cell in cells:
-                all_words.extend(cell.get_ordered_words())  # type: ignore
+                all_words.extend(cell.get_ordered_words())
             return all_words
         except (TypeError, AnnotationError):
             return super().get_ordered_words()
@@ -436,10 +520,10 @@ IMAGE_ANNOTATION_TO_LAYOUTS: dict[ObjectTypes, Type[Union[Layout, Table, Word]]]
     LayoutType.TABLE_ROTATED: Table,
     LayoutType.WORD: Word,
     LayoutType.CELL: Cell,
-    CellType.PROJECTED_ROW_HEADER: Cell,
     CellType.SPANNING: Cell,
     CellType.ROW_HEADER: Cell,
     CellType.COLUMN_HEADER: Cell,
+    CellType.PROJECTED_ROW_HEADER: Cell,
 }
 
 
@@ -465,10 +549,7 @@ IMAGE_DEFAULTS: ImageDefaults = {
         LayoutType.LIST,
         LayoutType.CELL,
         LayoutType.FIGURE,
-        CellType.COLUMN_HEADER,
-        CellType.PROJECTED_ROW_HEADER,
         CellType.SPANNING,
-        CellType.ROW_HEADER,
     ),
 }
 
@@ -851,6 +932,16 @@ class Page(Image):
         """
         return self._make_text(False)
 
+    def _ann_viz_bbox(self, ann: ImageAnnotationBaseView) -> list[float]:
+        """
+        Get the bounding box as list and in absolute coordinates of the base page.
+        """
+        bounding_box = ann.get_bounding_box(self.image_id)
+
+        if not bounding_box.absolute_coords:
+            bounding_box = bounding_box.transform(self.width, self.height, absolute_coords=True)
+        return bounding_box.to_list(mode="xyxy")
+
     @no_type_check
     def viz(
         self,
@@ -886,6 +977,7 @@ class Page(Image):
         :param show_tables: Will display all tables boxes as well as cells, rows and columns
         :param show_layouts: Will display all other layout components.
         :param show_figures: Will display all figures
+        :param show_residual_layouts: Will display all residual layouts
         :param show_cells: Will display cells within tables. (Only available if `show_tables=True`)
         :param show_table_structure: Will display rows and columns
         :param show_words: Will display bounding boxes around words labeled with token class and bio tag (experimental)
@@ -910,50 +1002,46 @@ class Page(Image):
         if debug_kwargs:
             anns = self.get_annotation(category_names=list(debug_kwargs.keys()))
             for ann in anns:
-                box_stack.append(ann.bbox)
+                box_stack.append(self._ann_viz_bbox(ann))
                 category_names_list.append(str(getattr(ann, debug_kwargs[ann.category_name])))
 
         if show_layouts and not debug_kwargs:
             for item in self.layouts:
-                box_stack.append(item.bbox)
+                box_stack.append(self._ann_viz_bbox(item))
                 category_names_list.append(item.category_name.value)
 
         if show_figures and not debug_kwargs:
             for item in self.figures:
-                box_stack.append(item.bbox)
+                box_stack.append(self._ann_viz_bbox(item))
                 category_names_list.append(item.category_name.value)
 
         if show_tables and not debug_kwargs:
             for table in self.tables:
-                box_stack.append(table.bbox)
+                box_stack.append(self._ann_viz_bbox(table))
                 category_names_list.append(LayoutType.TABLE.value)
                 if show_cells:
                     for cell in table.cells:
                         if cell.category_name in {
                             LayoutType.CELL,
-                            CellType.PROJECTED_ROW_HEADER,
                             CellType.SPANNING,
-                            CellType.ROW_HEADER,
-                            CellType.COLUMN_HEADER,
                         }:
                             cells_found = True
-                            box_stack.append(cell.bbox)
+                            box_stack.append(self._ann_viz_bbox(cell))
                             category_names_list.append(None)
                 if show_table_structure:
                     rows = table.rows
                     cols = table.columns
                     for row in rows:
-                        box_stack.append(row.bbox)
+                        box_stack.append(self._ann_viz_bbox(row))
                         category_names_list.append(None)
                     for col in cols:
-                        box_stack.append(col.bbox)
+                        box_stack.append(self._ann_viz_bbox(col))
                         category_names_list.append(None)
 
         if show_cells and not cells_found and not debug_kwargs:
-            for ann in self.annotations:
-                if isinstance(ann, Cell) and ann.active:
-                    box_stack.append(ann.bbox)
-                    category_names_list.append(None)
+            for ann in self.get_annotation(category_names=[LayoutType.CELL, CellType.SPANNING]):
+                box_stack.append(self._ann_viz_bbox(ann))
+                category_names_list.append(None)
 
         if show_words and not debug_kwargs:
             all_words = []
@@ -965,7 +1053,7 @@ class Page(Image):
                 all_words = self.get_annotation(category_names=LayoutType.WORD)
             if not ignore_default_token_class:
                 for word in all_words:
-                    box_stack.append(word.bbox)
+                    box_stack.append(self._ann_viz_bbox(word))
                     if show_token_class:
                         category_names_list.append(word.token_class.value if word.token_class is not None else None)
                     else:
@@ -973,7 +1061,7 @@ class Page(Image):
             else:
                 for word in all_words:
                     if word.token_class is not None and word.token_class != TokenClasses.OTHER:
-                        box_stack.append(word.bbox)
+                        box_stack.append(self._ann_viz_bbox(word))
                         if show_token_class:
                             category_names_list.append(word.token_class.value if word.token_class is not None else None)
                         else: