deepdoctection 0.40.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

deepdoctection/mapper/match.py

@@ -157,8 +157,8 @@ def match_anns_by_intersection(
 
 def match_anns_by_distance(
     dp: Image,
-    parent_ann_category_names:  Optional[Union[TypeOrStr, Sequence[TypeOrStr]]]=None,
-    child_ann_category_names:  Optional[Union[TypeOrStr, Sequence[TypeOrStr]]]=None,
+    parent_ann_category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+    child_ann_category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
     parent_ann_ids: Optional[Union[Sequence[str], str]] = None,
     child_ann_ids: Optional[Union[str, Sequence[str]]] = None,
     parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,

deepdoctection/mapper/tpstruct.py

@@ -95,11 +95,21 @@ def tf_nms_image_annotations(
     """
     if len(anns) == 1:
         return [anns[0].annotation_id]
+
     if not anns:
         return []
-    ann_ids = np.array([ann.annotation_id for ann in anns], dtype="object")
 
-    boxes = convert_to_tensor([ann.get_bounding_box(image_id).to_list(mode="xyxy") for ann in anns])
+    # First, identify priority annotations that should always be kept
+    priority_ann_ids = []
+
+    if prio:
+        for ann in anns:
+            if ann.category_name == prio:
+                priority_ann_ids.append(ann.annotation_id)
+
+    # If all annotations are priority or none are left for NMS, return all priority IDs
+    if len(priority_ann_ids) == len(anns):
+        return priority_ann_ids
 
     def priority_to_confidence(ann: ImageAnnotation, priority: str) -> float:
         if ann.category_name == priority:
@@ -108,10 +118,24 @@ def tf_nms_image_annotations(
             return ann.score
         raise ValueError("score cannot be None")
 
+    # Perform NMS only on non-priority annotations
+    ann_ids = np.array([ann.annotation_id for ann in anns], dtype="object")
+
+    # Get boxes for non-priority annotations
+    boxes = convert_to_tensor([ann.get_bounding_box(image_id).to_list(mode="xyxy") for ann in anns if ann.bounding_box
+                               is not None])
+
     scores = convert_to_tensor([priority_to_confidence(ann, prio) for ann in anns])
     class_mask = convert_to_tensor(len(boxes), dtype=uint8)
+
     keep = non_max_suppression(boxes, scores, class_mask, iou_threshold=threshold)
-    ann_ids_keep = ann_ids[keep]
-    if not isinstance(ann_ids_keep, str):
-        return ann_ids_keep.tolist()
-    return []
+    kept_ids = ann_ids[keep]
+
+    # Convert to list if necessary
+    if isinstance(kept_ids, str):
+        kept_ids = [kept_ids]
+    elif not isinstance(kept_ids, list):
+        kept_ids = kept_ids.tolist()
+
+    # Combine priority annotations with surviving non-priority annotations
+    return list(set(priority_ann_ids + kept_ids))

deepdoctection/pipe/common.py

@@ -30,6 +30,7 @@ import numpy as np
 from ..dataflow import DataFlow, MapData
 from ..datapoint.image import Image
 from ..datapoint.view import IMAGE_DEFAULTS, Page
+from ..extern.base import DetectionResult
 from ..mapper.match import match_anns_by_distance, match_anns_by_intersection
 from ..mapper.misc import to_image
 from ..utils.settings import LayoutType, ObjectTypes, Relationships, TypeOrStr, get_type
@@ -51,8 +52,9 @@ class ImageCroppingService(PipelineComponent):
     """
 
     def __init__(
-        self, category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-             service_ids: Optional[Sequence[str]] = None
+            self,
+            category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            service_ids: Optional[Sequence[str]] = None,
     ) -> None:
         """
         :param category_names: A single name or a list of category names to crop
@@ -105,11 +107,11 @@ class IntersectionMatcher:
     """
 
     def __init__(
-        self,
-        matching_rule: Literal["iou", "ioa"],
-        threshold: float,
-        use_weighted_intersections: bool = False,
-        max_parent_only: bool = False,
+            self,
+            matching_rule: Literal["iou", "ioa"],
+            threshold: float,
+            use_weighted_intersections: bool = False,
+            max_parent_only: bool = False,
     ) -> None:
         """
         :param matching_rule: "iou" or "ioa"
@@ -129,12 +131,12 @@ class IntersectionMatcher:
         self.max_parent_only = max_parent_only
 
     def match(
-        self,
-        dp: Image,
-        parent_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        child_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
-        child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+            self,
+            dp: Image,
+            parent_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            child_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+            child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
     ) -> list[tuple[str, str]]:
         """
         The matching algorithm
@@ -187,12 +189,12 @@ class NeighbourMatcher:
     """
 
     def match(
-        self,
-        dp: Image,
-        parent_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        child_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
-        child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+            self,
+            dp: Image,
+            parent_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            child_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
+            child_ann_service_ids: Optional[Union[str, Sequence[str]]] = None,
     ) -> list[tuple[str, str]]:
         """
         The matching algorithm
@@ -232,6 +234,8 @@ class FamilyCompound:
     child_categories: Optional[Union[ObjectTypes, Sequence[ObjectTypes]]] = field(default=None)
     parent_ann_service_ids: Optional[Union[str, Sequence[str]]] = field(default=None)
     child_ann_service_ids: Optional[Union[str, Sequence[str]]] = field(default=None)
+    create_synthetic_parent: bool = field(default=False)
+    synthetic_parent: Optional[ObjectTypes] = field(default=None)
 
     def __post_init__(self) -> None:
         if isinstance(self.parent_categories, str):
@@ -256,9 +260,9 @@ class MatchingService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        family_compounds: Sequence[FamilyCompound],
-        matcher: Union[IntersectionMatcher, NeighbourMatcher],
+            self,
+            family_compounds: Sequence[FamilyCompound],
+            matcher: Union[IntersectionMatcher, NeighbourMatcher],
     ) -> None:
         """
         :param family_compounds: A list of FamilyCompounds
@@ -286,6 +290,28 @@ class MatchingService(PipelineComponent):
 
             for pair in matched_pairs:
                 self.dp_manager.set_relationship_annotation(family_compound.relationship_key, pair[0], pair[1])
+            if family_compound.synthetic_parent:
+                parent_anns = dp.get_annotation(category_names=family_compound.parent_categories)
+                child_anns = dp.get_annotation(category_names=family_compound.child_categories)
+                child_ann_ids = []
+                for parent in parent_anns:
+                    if family_compound.relationship_key in parent.relationships:
+                        child_ann_ids.extend(parent.get_relationship(family_compound.relationship_key))
+                detect_result_list = []
+                for child_ann in child_anns:
+                    if child_ann.annotation_id not in child_ann_ids:
+                        detect_result_list.append(DetectionResult(
+                            class_name=family_compound.synthetic_parent,
+                            box=child_ann.get_bounding_box(dp.image_id).to_list(mode="xyxy"),
+                            absolute_coords=child_ann.get_bounding_box(dp.image_id).absolute_coords,
+                            relationships={family_compound.relationship_key: child_ann.annotation_id}))
+                for detect_result in detect_result_list:
+                    annotation_id = self.dp_manager.set_image_annotation(detect_result)
+                    if annotation_id is not None and detect_result.relationships is not None:
+                        self.dp_manager.set_relationship_annotation(family_compound.relationship_key,
+                                                                    annotation_id,
+                                                                    detect_result.relationships.get(
+                                                                        family_compound.relationship_key, None))
 
     def clone(self) -> PipelineComponent:
         return self.__class__(self.family_compounds, self.matcher)
@@ -315,10 +341,10 @@ class PageParsingService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        text_container: TypeOrStr,
-        floating_text_block_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
-        include_residual_text_container: bool = True,
+            self,
+            text_container: TypeOrStr,
+            floating_text_block_categories: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
+            include_residual_text_container: bool = True,
     ):
         """
         :param text_container: name of an image annotation that has a CHARS sub category. These annotations will be
@@ -400,10 +426,10 @@ class AnnotationNmsService(PipelineComponent):
     """
 
     def __init__(
-        self,
-        nms_pairs: Sequence[Sequence[TypeOrStr]],
-        thresholds: Union[float, Sequence[float]],
-        priority: Optional[Sequence[Union[Optional[TypeOrStr]]]] = None,
+            self,
+            nms_pairs: Sequence[Sequence[TypeOrStr]],
+            thresholds: Union[float, Sequence[float]],
+            priority: Optional[Sequence[Union[Optional[TypeOrStr]]]] = None,
     ):
         """
         :param nms_pairs: Groups of categories, either as string or by `ObjectType`.

deepdoctection/pipe/segment.py

@@ -441,6 +441,7 @@ def segment_table(
         matching_rule=segment_rule,
         threshold=threshold_rows,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )
@@ -452,6 +453,7 @@ def segment_table(
         matching_rule=segment_rule,
         threshold=threshold_cols,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )
@@ -624,6 +626,7 @@ def segment_pubtables(
         matching_rule=segment_rule,
         threshold=threshold_rows,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )
@@ -635,6 +638,7 @@ def segment_pubtables(
         matching_rule=segment_rule,
         threshold=threshold_cols,
         use_weighted_intersections=True,
+        # Rows and columns are child annotations of the table.
         parent_ann_ids=child_ann_ids,
         child_ann_ids=child_ann_ids,
     )

deepdoctection/pipe/sub_layout.py

@@ -153,8 +153,8 @@ class SubImageLayoutService(PipelineComponent):
     **Example**
 
             detect_result_generator = DetectResultGenerator(categories_items)
-            d_items = TPFrcnnDetector(item_config_path, item_weights_path, {"1": LayoutType.row,
-            "2": LayoutType.column})
+            d_items = TPFrcnnDetector(item_config_path, item_weights_path, {1: LayoutType.row,
+            2: LayoutType.column})
             item_component = SubImageLayoutService(d_items, LayoutType.table, detect_result_generator)
     """
 
@@ -162,6 +162,7 @@ class SubImageLayoutService(PipelineComponent):
         self,
         sub_image_detector: ObjectDetector,
         sub_image_names: Union[str, Sequence[TypeOrStr]],
+        service_ids: Optional[Sequence[str]] = None,
         detect_result_generator: Optional[DetectResultGenerator] = None,
         padder: Optional[PadTransform] = None,
     ):
@@ -170,7 +171,8 @@ class SubImageLayoutService(PipelineComponent):
         :param sub_image_names: Category names of ImageAnnotations to be presented to the detector.
                                 Attention: The selected ImageAnnotations must have: attr:`image` and: attr:`image.image`
                                 not None.
-        :param category_id_mapping: Mapping of category IDs. Usually, the category ids start with 1.
+        :param service_ids: List of service ids to be used for filtering the ImageAnnotations. If None, all
+                            ImageAnnotations will be used.
         :param detect_result_generator: 'DetectResultGenerator' instance. 'categories' attribute has to be the same as
                                         the 'categories' attribute of the 'sub_image_detector'. The generator will be
                                         responsible to create 'DetectionResult' for some categories, if they have not
@@ -184,6 +186,7 @@ class SubImageLayoutService(PipelineComponent):
             if isinstance(sub_image_names, str)
             else tuple((get_type(cat) for cat in sub_image_names))
         )
+        self.service_ids = service_ids
         self.detect_result_generator = detect_result_generator
         self.padder = padder
         self.predictor = sub_image_detector
@@ -205,7 +208,7 @@ class SubImageLayoutService(PipelineComponent):
         - Optionally invoke the DetectResultGenerator
         - Generate ImageAnnotations and dump to parent image and sub image.
         """
-        sub_image_anns = dp.get_annotation(category_names=self.sub_image_name)
+        sub_image_anns = dp.get_annotation(category_names=self.sub_image_name, service_ids=self.service_ids)
         for sub_image_ann in sub_image_anns:
             np_image = self.prepare_np_image(sub_image_ann)
             detect_result_list = self.predictor.predict(np_image)
@@ -246,6 +249,7 @@ class SubImageLayoutService(PipelineComponent):
         return self.__class__(
             predictor,
             self.sub_image_name,
+            self.service_ids,
             self.detect_result_generator,
             padder_clone,
         )

deepdoctection/pipe/transform.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# File: transform.py
+# File: test_transform.py
 
 # Copyright 2022 Dr. Janis Meyer. All rights reserved.
 #
@@ -22,6 +22,7 @@ on images (e.g. deskew, de-noising or more general GAN like operations.
 
 from __future__ import annotations
 
+from .. import DetectionResult
 from ..datapoint.image import Image
 from ..extern.base import ImageTransformer
 from .base import MetaAnnotation, PipelineComponent
@@ -49,25 +50,46 @@ class SimpleTransformService(PipelineComponent):
         super().__init__(self._get_name(transform_predictor.name), self.transform_predictor.model_id)
 
     def serve(self, dp: Image) -> None:
-        if dp.annotations:
-            raise RuntimeError(
-                "SimpleTransformService receives datapoints with ÌmageAnnotations. This violates the "
-                "pipeline building API but this can currently be catched only at runtime. "
-                "Please make sure that this component is the first one in the pipeline."
-            )
-
         if dp.image is not None:
             detection_result = self.transform_predictor.predict(dp.image)
-            transformed_image = self.transform_predictor.transform(dp.image, detection_result)
+            transformed_image = self.transform_predictor.transform_image(dp.image, detection_result)
             self.dp_manager.datapoint.clear_image(True)
             self.dp_manager.datapoint.image = transformed_image
-            self.dp_manager.set_summary_annotation(
-                summary_key=self.transform_predictor.get_category_names()[0],
-                summary_name=self.transform_predictor.get_category_names()[0],
-                summary_number=None,
-                summary_value=getattr(detection_result, self.transform_predictor.get_category_names()[0].value, None),
-                summary_score=detection_result.score,
-            )
+            for category in self.transform_predictor.get_category_names():
+                self.dp_manager.set_summary_annotation(
+                    summary_key=category,
+                    summary_name=category,
+                    summary_number=None,
+                    summary_value=getattr(detection_result, category.value, None),
+                    summary_score=detection_result.score,
+                )
+            detect_results = []
+            for ann in dp.get_annotation():
+                box = ann.get_bounding_box()
+                if not box.absolute_coords:
+                    box = box.transform(dp.width, dp.height)
+                detect_results.append(
+                    DetectionResult(
+                        box=box.to_list(mode="xyxy"),
+                        class_name=ann.category_name,  # type: ignore
+                        score=ann.score,
+                        class_id=ann.category_id,
+                        uuid=ann.annotation_id,
+                    )
+                )
+            output_detect_results = self.transform_predictor.transform_coords(detect_results)
+            for detect_result in output_detect_results:
+                ann = dp.get_annotation(annotation_ids=detect_result.uuid)[0]
+                transformed_ann_id = self.dp_manager.set_image_annotation(detect_result)
+                if transformed_ann_id is None:
+                    print("here")
+                transformed_ann = self.dp_manager.datapoint.get_annotation(annotation_ids=transformed_ann_id)[0]
+
+                for key, sub_ann in ann.sub_categories.items():
+                    transformed_ann.dump_sub_category(key, sub_ann)
+                if ann.image is not None:
+                    dp.image_ann_to_image(transformed_ann.annotation_id, ann.image.image is not None)
+                ann.deactivate()
 
     def clone(self) -> SimpleTransformService:
         return self.__class__(self.transform_predictor)

deepdoctection/train/hf_detr_train.py

@@ -276,7 +276,7 @@ def train_hf_detr(
 
     if path_weights != "":
         model = TableTransformerForObjectDetection.from_pretrained(
-            pretrained_model_name_or_path=path_weights, config=config
+            pretrained_model_name_or_path=path_weights, config=config, ignore_mismatched_sizes=True
         )
     else:
         model = TableTransformerForObjectDetection(config)

deepdoctection/utils/settings.py

@@ -67,6 +67,11 @@ class PageType(ObjectTypes):
     DOCUMENT_TYPE = "document_type"
     LANGUAGE = "language"
     ANGLE = "angle"
+    SIZE = "size"
+    PAD_TOP = "pad_top"
+    PAD_BOTTOM = "pad_bottom"
+    PAD_LEFT = "pad_left"
+    PAD_RIGHT = "pad_right"
 
 
 @object_types_registry.register("SummaryType")