deepdoctection 0.32__py3-none-any.whl → 0.34__py3-none-any.whl

deepdoctection/datapoint/convert.py

@@ -30,10 +30,10 @@ from numpy import uint8
 from numpy.typing import NDArray
 from pypdf import PdfReader
 
-from ..utils.detection_types import ImageType
 from ..utils.develop import deprecated
 from ..utils.error import DependencyError
 from ..utils.pdf_utils import pdf_to_np_array
+from ..utils.types import PixelValues
 from ..utils.viz import viz_handler
 
 __all__ = [
@@ -75,7 +75,7 @@ def as_dict(obj: Any, dict_factory) -> Union[Any]:  # type: ignore
     return copy.deepcopy(obj)
 
 
-def convert_b64_to_np_array(image: str) -> ImageType:
+def convert_b64_to_np_array(image: str) -> PixelValues:
     """
     Converts an image in base4 string encoding representation to a numpy array of shape (width,height,channel).
 
@@ -86,7 +86,7 @@ def convert_b64_to_np_array(image: str) -> ImageType:
     return viz_handler.convert_b64_to_np(image).astype(uint8)
 
 
-def convert_np_array_to_b64(np_image: ImageType) -> str:
+def convert_np_array_to_b64(np_image: PixelValues) -> str:
     """
     Converts an image from numpy array into a base64 string encoding representation
 
@@ -97,7 +97,7 @@ def convert_np_array_to_b64(np_image: ImageType) -> str:
 
 
 @no_type_check
-def convert_np_array_to_b64_b(np_image: ImageType) -> bytes:
+def convert_np_array_to_b64_b(np_image: PixelValues) -> bytes:
     """
     Converts an image from numpy array into a base64 bytes encoding representation
 
@@ -108,7 +108,7 @@ def convert_np_array_to_b64_b(np_image: ImageType) -> bytes:
 
 
 @deprecated("Use convert_pdf_bytes_to_np_array_v2", "2022-02-23")
-def convert_pdf_bytes_to_np_array(pdf_bytes: bytes, dpi: Optional[int] = None) -> ImageType:
+def convert_pdf_bytes_to_np_array(pdf_bytes: bytes, dpi: Optional[int] = None) -> PixelValues:
     """
     Converts a pdf passed as bytes into a numpy array. Note, that this method expects poppler to be installed.
     Please check the installation guides at https://poppler.freedesktop.org/ . If no value for dpi is provided
@@ -143,7 +143,7 @@ def convert_pdf_bytes_to_np_array(pdf_bytes: bytes, dpi: Optional[int] = None) -
     return np_array.astype(uint8)
 
 
-def convert_pdf_bytes_to_np_array_v2(pdf_bytes: bytes, dpi: Optional[int] = None) -> ImageType:
+def convert_pdf_bytes_to_np_array_v2(pdf_bytes: bytes, dpi: Optional[int] = None) -> PixelValues:
     """
     Converts a pdf passed as bytes into a numpy array. Note, that this method expects poppler to be installed. This
     function, however does not rely on the wrapper pdf2image but uses a function of this lib which calls poppler

deepdoctection/datapoint/image.py

@@ -21,19 +21,20 @@ Dataclass Image
 from __future__ import annotations
 
 import json
+from collections import defaultdict
 from dataclasses import dataclass, field
 from os import environ
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Union, no_type_check
+from typing import Any, Optional, Sequence, Union, no_type_check
 
 import numpy as np
 from numpy import uint8
 
-from ..utils.detection_types import ImageType, JsonDict, Pathlike
 from ..utils.error import AnnotationError, BoundingBoxError, ImageError, UUIDError
 from ..utils.identifier import get_uuid, is_uuid_like
-from ..utils.settings import ObjectTypes, get_type
-from .annotation import Annotation, BoundingBox, ImageAnnotation, SummaryAnnotation
+from ..utils.settings import ObjectTypes, SummaryType, get_type
+from ..utils.types import ImageDict, PathLikeOrStr, PixelValues
+from .annotation import Annotation, AnnotationMap, BoundingBox, CategoryAnnotation, ImageAnnotation
 from .box import crop_box_from_image, global_to_local_coords, intersection_box
 from .convert import as_dict, convert_b64_to_np_array, convert_np_array_to_b64, convert_pdf_bytes_to_np_array_v2
 
@@ -86,12 +87,12 @@ class Image:
     page_number: int = field(default=0, init=False, repr=False)
     external_id: Optional[Union[str, int]] = field(default=None, repr=False)
     _image_id: Optional[str] = field(default=None, init=False, repr=True)
-    _image: Optional[ImageType] = field(default=None, init=False, repr=False)
+    _image: Optional[PixelValues] = field(default=None, init=False, repr=False)
     _bbox: Optional[BoundingBox] = field(default=None, init=False, repr=False)
-    embeddings: Dict[str, BoundingBox] = field(default_factory=dict, init=False, repr=True)
-    annotations: List[ImageAnnotation] = field(default_factory=list, init=False, repr=True)
-    _annotation_ids: List[str] = field(default_factory=list, init=False, repr=False)
-    _summary: Optional[SummaryAnnotation] = field(default=None, init=False, repr=False)
+    embeddings: dict[str, BoundingBox] = field(default_factory=dict, init=False, repr=True)
+    annotations: list[ImageAnnotation] = field(default_factory=list, init=False, repr=True)
+    _annotation_ids: list[str] = field(default_factory=list, init=False, repr=False)
+    _summary: Optional[CategoryAnnotation] = field(default=None, init=False, repr=False)
 
     def __post_init__(self) -> None:
         if self.external_id is not None:
@@ -128,14 +129,14 @@ class Image:
             raise UUIDError("image_id must be uuid3 string")
 
     @property
-    def image(self) -> Optional[ImageType]:
+    def image(self) -> Optional[PixelValues]:
         """
         image
         """
         return self._image
 
     @image.setter
-    def image(self, image: Optional[Union[str, ImageType, bytes]]) -> None:
+    def image(self, image: Optional[Union[str, PixelValues, bytes]]) -> None:
         """
         Sets the image for internal storage. Will convert to numpy array before storing internally.
         Note: If the input is an np.array, ensure that the image is in BGR-format as this is the standard
@@ -162,13 +163,19 @@ class Image:
             self._self_embedding()
 
     @property
-    def summary(self) -> Optional[SummaryAnnotation]:
+    def summary(self) -> CategoryAnnotation:
         """summary"""
+        if self._summary is None:
+            self._summary = CategoryAnnotation(category_name=SummaryType.SUMMARY)
+            if self._summary._annotation_id is None:  # pylint: disable=W0212
+                self._summary.annotation_id = self.define_annotation_id(self._summary)
         return self._summary
 
     @summary.setter
-    def summary(self, summary_annotation: SummaryAnnotation) -> None:
+    def summary(self, summary_annotation: CategoryAnnotation) -> None:
         """summary setter"""
+        if self._summary is not None:
+            raise ImageError("Image.summary already defined and cannot be reset")
         if summary_annotation._annotation_id is None:  # pylint: disable=W0212
             summary_annotation.annotation_id = self.define_annotation_id(summary_annotation)
         self._summary = summary_annotation
@@ -222,10 +229,10 @@ class Image:
             Helper class. Do not use it in your code.
             """
 
-            def __init__(self, img: Optional[ImageType]):
+            def __init__(self, img: Optional[PixelValues]):
                 self.img = img
 
-            def to_np_array(self) -> Optional[ImageType]:
+            def to_np_array(self) -> Optional[PixelValues]:
                 """
                 Returns image as numpy array
 
@@ -297,6 +304,15 @@ class Image:
 
         return self.embeddings[image_id]
 
+    def remove_embedding(self, image_id: str) -> None:
+        """
+        Remove an embedding from the image.
+
+        :param image_id: uuid string of the embedding image
+        """
+        if image_id in self.embeddings:
+            self.embeddings.pop(image_id)
+
     def _self_embedding(self) -> None:
         if self._bbox is not None:
             self.set_embedding(self.image_id, self._bbox)
@@ -329,7 +345,7 @@ class Image:
         model_id: Optional[Union[str, Sequence[str]]] = None,
         session_ids: Optional[Union[str, Sequence[str]]] = None,
         ignore_inactive: bool = True,
-    ) -> List[ImageAnnotation]:
+    ) -> list[ImageAnnotation]:
         """
         Selection of annotations from the annotation container. Filter conditions can be defined by specifying
         the annotation_id or the category name. (Since only image annotations are currently allowed in the container,
@@ -349,9 +365,9 @@ class Image:
 
         if category_names is not None:
             category_names = (
-                [get_type(cat_name) for cat_name in category_names]
-                if isinstance(category_names, (list, set))
-                else [get_type(category_names)]  # type:ignore
+                (get_type(category_names),)
+                if isinstance(category_names, str)
+                else tuple(get_type(cat_name) for cat_name in category_names)
             )
 
         ann_ids = [annotation_ids] if isinstance(annotation_ids, str) else annotation_ids
@@ -360,61 +376,28 @@ class Image:
         session_id = [session_ids] if isinstance(session_ids, str) else session_ids
 
         if ignore_inactive:
-            anns = filter(lambda x: x.active, self.annotations)
+            anns: Union[list[ImageAnnotation], filter[ImageAnnotation]] = filter(lambda x: x.active, self.annotations)
         else:
-            anns = self.annotations  # type:ignore
+            anns = self.annotations
 
         if category_names is not None:
-            anns = filter(lambda x: x.category_name in category_names, anns)  # type:ignore
+            anns = filter(lambda x: x.category_name in category_names, anns)
 
         if ann_ids is not None:
-            anns = filter(lambda x: x.annotation_id in ann_ids, anns)  # type:ignore
+            anns = filter(lambda x: x.annotation_id in ann_ids, anns)
 
         if service_id is not None:
-            anns = filter(lambda x: x.service_id in service_id, anns)  # type:ignore
+            anns = filter(lambda x: x.service_id in service_id, anns)
 
         if model_id is not None:
-            anns = filter(lambda x: x.model_id in model_id, anns)  # type:ignore
+            anns = filter(lambda x: x.model_id in model_id, anns)
 
         if session_id is not None:
-            anns = filter(lambda x: x.session_id in session_id, anns)  # type:ignore
+            anns = filter(lambda x: x.session_id in session_id, anns)
 
         return list(anns)
 
-    def get_annotation_iter(
-        self,
-        category_names: Optional[Union[str, ObjectTypes, Sequence[Union[str, ObjectTypes]]]] = None,
-        annotation_ids: Optional[Union[str, Sequence[str]]] = None,
-        service_id: Optional[Union[str, Sequence[str]]] = None,
-        model_id: Optional[Union[str, Sequence[str]]] = None,
-        session_ids: Optional[Union[str, Sequence[str]]] = None,
-        ignore_inactive: bool = True,
-    ) -> Iterable[ImageAnnotation]:
-        """
-        Get annotation as an iterator. Same as `get_annotation` but returns an iterator instead of a list.
-
-        :param category_names: A single name or list of names
-        :param annotation_ids: A single id or list of ids
-        :param service_id: A single service name or list of service names
-        :param model_id: A single model name or list of model names
-        :param session_ids: A single session id or list of session ids
-        :param ignore_inactive: If set to `True` only active annotations are returned.
-
-        :return: A (possibly empty) list of annotations
-        """
-
-        return iter(
-            self.get_annotation(
-                category_names=category_names,
-                annotation_ids=annotation_ids,
-                service_id=service_id,
-                model_id=model_id,
-                session_ids=session_ids,
-                ignore_inactive=ignore_inactive,
-            )
-        )
-
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """
         Returns the full image dataclass as dict. Uses the custom `convert.as_dict` to disregard attributes
         defined by `remove_keys`.
@@ -430,12 +413,12 @@ class Image:
         return img_dict
 
     @staticmethod
-    def remove_keys() -> List[str]:
+    def remove_keys() -> list[str]:
         """
         A list of attributes to suspend from as_dict creation.
         """
 
-        return ["_image"]
+        return ["_image", "_annotation_ids"]
 
     def define_annotation_id(self, annotation: Annotation) -> str:
         """
@@ -450,7 +433,11 @@ class Image:
         attributes_values = [str(getattr(annotation, attribute)) for attribute in attributes]
         return get_uuid(*attributes_values, str(self.image_id))
 
-    def remove(self, annotation: ImageAnnotation) -> None:
+    def remove(
+        self,
+        annotation_ids: Optional[Union[str, list[str]]] = None,
+        service_ids: Optional[Union[str, list[str]]] = None,
+    ) -> None:
         """
         Instead of removing consider deactivating annotations.
 
@@ -458,9 +445,66 @@ class Image:
 
         :param annotation: The annotation to remove
         """
+        ann_id_to_annotation_maps = self.get_annotation_id_to_annotation_maps()
+
+        if annotation_ids is not None:
+            annotation_ids = [annotation_ids] if isinstance(annotation_ids, str) else annotation_ids
+
+            for ann_id in annotation_ids:
+                if ann_id not in ann_id_to_annotation_maps:
+                    raise ImageError(f"Annotation with id {ann_id} not found")
+                annotation_maps = ann_id_to_annotation_maps[ann_id]
+
+                for annotation_map in annotation_maps:
+                    self._remove_by_annotation_id(ann_id, annotation_map)
+
+        if service_ids is not None:
+            service_ids = [service_ids] if isinstance(service_ids, str) else service_ids
+            service_id_to_annotation_id = self.get_service_id_to_annotation_id()
+
+            for service_id in service_ids:
+                if service_id not in service_id_to_annotation_id:
+                    raise ImageError(f"Service id {service_id} not found")
+                annotation_ids = service_id_to_annotation_id[service_id]
+
+                for ann_id in annotation_ids:
+                    if ann_id not in ann_id_to_annotation_maps:
+                        raise ImageError(f"Annotation with id {ann_id} not found")
+                    annotation_maps = ann_id_to_annotation_maps[ann_id]
+
+                    for annotation_map in annotation_maps:
+                        self._remove_by_annotation_id(ann_id, annotation_map)
+
+    def _remove_by_annotation_id(self, annotation_id: str, location_dict: AnnotationMap) -> None:
+        image_annotation_id = location_dict.image_annotation_id
+        annotations = self.get_annotation(annotation_ids=image_annotation_id)
+        if not annotations:
+            return
+        # There can only be one annotation with a given id
+        annotation = annotations[0]
+
+        if (
+            location_dict.sub_category_key is None
+            and location_dict.relationship_key is None
+            and location_dict.summary_key is None
+        ):
+            self.annotations.remove(annotation)
+            self._annotation_ids.remove(annotation.annotation_id)
+
+        sub_category_key = location_dict.sub_category_key
+
+        if sub_category_key is not None:
+            annotation.remove_sub_category(sub_category_key)
+
+        relationship_key = location_dict.relationship_key
 
-        self.annotations.remove(annotation)
-        self._annotation_ids.remove(annotation.annotation_id)
+        if relationship_key is not None:
+            annotation.remove_relationship(relationship_key, annotation_id)
+
+        summary_key = location_dict.summary_key
+        if summary_key is not None:
+            if annotation.image is not None:
+                annotation.image.summary.remove_sub_category(summary_key)
 
     def image_ann_to_image(self, annotation_id: str, crop_image: bool = False) -> None:
         """
@@ -497,7 +541,7 @@ class Image:
 
         ann.image = new_image
 
-    def maybe_ann_to_sub_image(self, annotation_id: str, category_names: Union[str, List[str]]) -> None:
+    def maybe_ann_to_sub_image(self, annotation_id: str, category_names: Union[str, list[str]]) -> None:
         """
         Provides a supplement to `image_ann_to_image` and mainly operates on the `ImageAnnotation.image` of
         the image annotation. The aim is to assign image annotations from this image one hierarchy level lower to the
@@ -572,7 +616,9 @@ class Image:
                     image_ann.image = cls.from_dict(**image_dict)
             image.dump(image_ann)
         if summary_dict := kwargs.get("_summary", kwargs.get("summary")):
-            image.summary = SummaryAnnotation.from_dict(**summary_dict)
+            image.summary = CategoryAnnotation.from_dict(**summary_dict)
+            image.summary.category_name = SummaryType.SUMMARY
+
         return image
 
     @classmethod
@@ -589,7 +635,7 @@ class Image:
         return image
 
     @staticmethod
-    def get_state_attributes() -> List[str]:
+    def get_state_attributes() -> list[str]:
         """
         Returns the list of attributes that define the `state_id` of an image.
 
@@ -636,9 +682,9 @@ class Image:
         self,
         image_to_json: bool = True,
         highest_hierarchy_only: bool = False,
-        path: Optional[Pathlike] = None,
+        path: Optional[PathLikeOrStr] = None,
         dry: bool = False,
-    ) -> Optional[JsonDict]:
+    ) -> Optional[Union[ImageDict, str]]:
         """
         Export image as dictionary. As numpy array cannot be serialized `image` values will be converted into
         base64 encodings.
@@ -650,10 +696,9 @@ class Image:
 
         :return: optional dict
         """
-        if isinstance(path, str):
-            path = Path(path)
-        elif path is None:
+        if path is None:
             path = Path(self.location)
+        path = Path(path)
         if path.is_dir():
             path = path / self.image_id
         suffix = path.suffix
@@ -671,8 +716,45 @@ class Image:
             return export_dict
         with open(path_json, "w", encoding="UTF-8") as file:
             json.dump(export_dict, file, indent=2)
-        return None
+        return path_json
 
-    def get_categories_from_current_state(self) -> Set[str]:
+    def get_categories_from_current_state(self) -> set[str]:
         """Returns all active dumped categories"""
         return {ann.category_name for ann in self.get_annotation()}
+
+    def get_service_id_to_annotation_id(self) -> defaultdict[str, list[str]]:
+        """
+        Returns a dictionary with service ids as keys and lists of annotation ids that have been generated by the
+        service
+        :return: default with service ids as keys and lists of annotation ids as values
+        """
+        service_id_dict = defaultdict(list)
+        for ann in self.get_annotation():
+            if ann.service_id:
+                service_id_dict[ann.service_id].append(ann.annotation_id)
+            for sub_cat_key in ann.sub_categories:
+                sub_cat = ann.get_sub_category(sub_cat_key)
+                if sub_cat.service_id:
+                    service_id_dict[sub_cat.service_id].append(sub_cat.annotation_id)
+            if ann.image is not None:
+                for summary_cat_key in ann.image.summary:
+                    summary_cat = ann.get_summary(summary_cat_key)
+                    if summary_cat.service_id:
+                        service_id_dict[summary_cat.service_id].append(summary_cat.annotation_id)
+
+        return service_id_dict
+
+    def get_annotation_id_to_annotation_maps(self) -> defaultdict[str, list[AnnotationMap]]:
+        """
+        Returns a dictionary with annotation ids as keys and lists of AnnotationMap as values. The range of ids
+        is the union of all ImageAnnotation, CategoryAnnotation and ContainerAnnotation of the image.
+
+        :return: default dict with annotation ids as keys and lists of AnnotationMap as values
+        """
+        all_ann_id_dict = defaultdict(list)
+        for ann in self.get_annotation():
+            ann_id_dict = ann.get_annotation_map()
+            for key, val in ann_id_dict.items():
+                all_ann_id_dict[key].extend(val)
+
+        return all_ann_id_dict