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

deepdoctection/extern/tp/tpfrcnn/modeling/model_frcnn.py

@@ -79,8 +79,8 @@ def sample_fast_rcnn_targets(boxes, gt_boxes, gt_labels, frcnn_fg_thresh, frcnn_
     proposal_metrics(iou)
 
     # add ground truth as proposals as well
-    boxes = tf.concat([boxes, gt_boxes], axis=0)  # (n+m) x 4
-    iou = tf.concat([iou, tf.eye(tf.shape(gt_boxes)[0])], axis=0)  # (n+m) x m
+    boxes = tf.concat([boxes, gt_boxes], axis=0)  # (n+m) x 4  # pylint: disable=E1123
+    iou = tf.concat([iou, tf.eye(tf.shape(gt_boxes)[0])], axis=0)  # (n+m) x m  # pylint: disable=E1123
     # #proposal=n+m from now on
 
     def sample_fg_bg(iou):
@@ -114,10 +114,10 @@ def sample_fast_rcnn_targets(boxes, gt_boxes, gt_labels, frcnn_fg_thresh, frcnn_
     )
     fg_inds_wrt_gt = tf.gather(best_iou_ind, fg_inds)  # num_fg
 
-    all_indices = tf.concat([fg_inds, bg_inds], axis=0)  # indices w.r.t all n+m proposal boxes
+    all_indices = tf.concat([fg_inds, bg_inds], axis=0)  # indices w.r.t all n+m proposal boxes  # pylint: disable=E1123
     ret_boxes = tf.gather(boxes, all_indices)
 
-    ret_labels = tf.concat(
+    ret_labels = tf.concat(  # pylint: disable=E1123
         [tf.gather(gt_labels, fg_inds_wrt_gt), tf.zeros_like(bg_inds, dtype=tf.int64)],
         axis=0,
     )

deepdoctection/extern/tp/tpfrcnn/modeling/model_mrcnn.py

@@ -47,7 +47,7 @@ def maskrcnn_loss(mask_logits, fg_labels, fg_target_masks):
 
     # add some training visualizations to tensorboard
     with tf.name_scope("mask_viz"):
-        viz = tf.concat([fg_target_masks, mask_probs], axis=1)
+        viz = tf.concat([fg_target_masks, mask_probs], axis=1)  # pylint: disable=E1123
         viz = tf.expand_dims(viz, 3)
         viz = tf.cast(viz * 255, tf.uint8, name="viz")
         tf.summary.image("mask_truth|pred", viz, max_outputs=10)
@@ -83,7 +83,7 @@ def maskrcnn_upXconv_head(feature, num_category, num_convs, norm=None, **kwargs)
     with argscope(
         [Conv2D, Conv2DTranspose],
         data_format="channels_first",
-        kernel_initializer=tf.variance_scaling_initializer(
+        kernel_initializer=tf.variance_scaling_initializer(  # pylint: disable=E1101
             scale=2.0,
             mode="fan_out",
             distribution="untruncated_normal" if get_tf_version_tuple() >= (1, 12) else "normal",
@@ -127,5 +127,7 @@ def unpackbits_masks(masks):
     assert masks.dtype == tf.uint8, masks
     bits = tf.constant((128, 64, 32, 16, 8, 4, 2, 1), dtype=tf.uint8)
     unpacked = tf.bitwise.bitwise_and(tf.expand_dims(masks, -1), bits) > 0
-    unpacked = tf.reshape(unpacked, tf.concat([tf.shape(masks)[:-1], [8 * tf.shape(masks)[-1]]], axis=0))
+    unpacked = tf.reshape(
+        unpacked, tf.concat([tf.shape(masks)[:-1], [8 * tf.shape(masks)[-1]]], axis=0)  # pylint: disable=E1123
+    )  # pylint: disable=E1123
     return unpacked

deepdoctection/extern/tp/tpfrcnn/preproc.py

@@ -16,9 +16,9 @@ import numpy as np
 from lazy_imports import try_import
 
 from ....datapoint.convert import box_to_point4, point4_to_box
-from ....utils.detection_types import ImageType, JsonDict
 from ....utils.error import MalformedData
 from ....utils.logger import log_once
+from ....utils.types import JsonDict, PixelValues
 from .common import filter_boxes_inside_shape, np_iou
 from .modeling.model_fpn import get_all_anchors_fpn
 from .utils.np_box_ops import area as np_area
@@ -214,15 +214,15 @@ def get_multilevel_rpn_anchor_input(
 
 
 def get_anchor_labels(
-    anchors: ImageType,
-    gt_boxes: ImageType,
-    crowd_boxes: ImageType,
+    anchors: PixelValues,
+    gt_boxes: PixelValues,
+    crowd_boxes: PixelValues,
     batch_per_image: int,
     front_ground_ratio: float,
     positive_anchor_threshold: float,
     negative_anchor_threshold: float,
     crowd_overlap_threshold: float,
-) -> (ImageType, ImageType):
+) -> (PixelValues, PixelValues):
     """
     Label each anchor as fg/bg/ignore.
 

deepdoctection/extern/tpdetect.py

@@ -18,17 +18,17 @@
 """
 TP Faster RCNN model as predictor for deepdoctection pipeline
 """
+from __future__ import annotations
 
 from abc import ABC
-from copy import copy
 from pathlib import Path
-from typing import Dict, List, Mapping, Optional, Sequence, Union
+from typing import Mapping, Optional, Sequence, Union
 
-from ..utils.detection_types import ImageType, Requirement
 from ..utils.file_utils import get_tensorflow_requirement, get_tensorpack_requirement
 from ..utils.metacfg import set_config_by_yaml
-from ..utils.settings import ObjectTypes, TypeOrStr, get_type
-from .base import DetectionResult, ObjectDetector, PredictorBase
+from ..utils.settings import DefaultType, ObjectTypes, TypeOrStr, get_type
+from ..utils.types import PathLikeOrStr, PixelValues, Requirement
+from .base import DetectionResult, ModelCategories, ObjectDetector
 from .tp.tpcompat import TensorpackPredictor
 from .tp.tpfrcnn.config.config import model_frcnn_config
 from .tp.tpfrcnn.modeling.generalized_rcnn import ResNetFPNModel
@@ -38,41 +38,37 @@ from .tp.tpfrcnn.predict import tp_predict_image
 class TPFrcnnDetectorMixin(ObjectDetector, ABC):
     """Base class for TP FRCNN detector. This class only implements the basic wrapper functions"""
 
-    def __init__(self, categories: Mapping[str, TypeOrStr], filter_categories: Optional[Sequence[TypeOrStr]] = None):
-        self.categories = copy(categories)  # type: ignore
+    def __init__(self, categories: Mapping[int, TypeOrStr], filter_categories: Optional[Sequence[TypeOrStr]] = None):
+        categories = {k: get_type(v) for k, v in categories.items()}
+        categories.update({0: get_type("background")})
+        self.categories = ModelCategories(categories)
         if filter_categories:
-            filter_categories = [get_type(cat) for cat in filter_categories]
-        self.filter_categories = filter_categories
-        self._tp_categories = self._map_to_tp_categories(categories)
+            self.categories.filter_categories = tuple(get_type(cat) for cat in filter_categories)
 
-    def _map_category_names(self, detection_results: List[DetectionResult]) -> List[DetectionResult]:
+    def _map_category_names(self, detection_results: list[DetectionResult]) -> list[DetectionResult]:
         """
         Populating category names to detection results
 
         :param detection_results: list of detection results
         :return: List of detection results with attribute class_name populated
         """
-        filtered_detection_result: List[DetectionResult] = []
+        filtered_detection_result: list[DetectionResult] = []
         for result in detection_results:
-            result.class_name = self._tp_categories[str(result.class_id)]
-            if self.filter_categories:
-                if result.class_name not in self.filter_categories:
-                    filtered_detection_result.append(result)
-            else:
+            result.class_name = self.categories.categories.get(
+                result.class_id if result.class_id else -1, DefaultType.DEFAULT_TYPE
+            )
+            if result.class_name != DefaultType.DEFAULT_TYPE:
                 filtered_detection_result.append(result)
         return filtered_detection_result
 
     @staticmethod
-    def _map_to_tp_categories(categories: Mapping[str, TypeOrStr]) -> Dict[str, ObjectTypes]:
-        categories = {str(key): get_type(categories[val]) for key, val in enumerate(categories, 1)}
-        categories["0"] = get_type("background")
-        return categories  # type: ignore
-
-    @staticmethod
-    def get_name(path_weights: str, architecture: str) -> str:
+    def get_name(path_weights: PathLikeOrStr, architecture: str) -> str:
         """Returns the name of the model"""
         return f"Tensorpack_{architecture}" + "_".join(Path(path_weights).parts[-2:])
 
+    def get_category_names(self) -> tuple[ObjectTypes, ...]:
+        return self.categories.get_categories(as_dict=False)
+
 
 class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
     """
@@ -97,10 +93,10 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
 
     def __init__(
         self,
-        path_yaml: str,
-        path_weights: str,
-        categories: Mapping[str, TypeOrStr],
-        config_overwrite: Optional[List[str]] = None,
+        path_yaml: PathLikeOrStr,
+        path_weights: PathLikeOrStr,
+        categories: Mapping[int, TypeOrStr],
+        config_overwrite: Optional[list[str]] = None,
         ignore_mismatch: bool = False,
         filter_categories: Optional[Sequence[TypeOrStr]] = None,
     ):
@@ -125,14 +121,10 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
         :param filter_categories: The model might return objects that are not supposed to be predicted and that should
                                   be filtered. Pass a list of category names that must not be returned
         """
-        self.path_yaml = path_yaml
-
-        self.categories = copy(categories)  # type: ignore
+        self.path_yaml = Path(path_yaml)
         self.config_overwrite = config_overwrite
-        if filter_categories:
-            filter_categories = [get_type(cat) for cat in filter_categories]
-        self.filter_categories = filter_categories
-        model = TPFrcnnDetector.get_wrapped_model(path_yaml, self.categories, config_overwrite)
+
+        model = TPFrcnnDetector.get_wrapped_model(path_yaml, categories, config_overwrite)
         TensorpackPredictor.__init__(self, model, path_weights, ignore_mismatch)
         TPFrcnnDetectorMixin.__init__(self, categories, filter_categories)
 
@@ -141,7 +133,7 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
 
     @staticmethod
     def get_wrapped_model(
-        path_yaml: str, categories: Mapping[str, ObjectTypes], config_overwrite: Union[List[str], None]
+        path_yaml: PathLikeOrStr, categories: Mapping[int, TypeOrStr], config_overwrite: Union[list[str], None]
     ) -> ResNetFPNModel:
         """
         Calls all necessary methods to build TP ResNetFPNModel
@@ -163,7 +155,7 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
         model_frcnn_config(config=hyper_param_config, categories=categories, print_summary=False)
         return ResNetFPNModel(config=hyper_param_config)
 
-    def predict(self, np_img: ImageType) -> List[DetectionResult]:
+    def predict(self, np_img: PixelValues) -> list[DetectionResult]:
         """
         Prediction per image.
 
@@ -180,15 +172,18 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
         return self._map_category_names(detection_results)
 
     @classmethod
-    def get_requirements(cls) -> List[Requirement]:
+    def get_requirements(cls) -> list[Requirement]:
         return [get_tensorflow_requirement(), get_tensorpack_requirement()]
 
-    def clone(self) -> PredictorBase:
+    def clone(self) -> TPFrcnnDetector:
         return self.__class__(
-            self.path_yaml,
-            self.path_weights,
-            self.categories,
-            self.config_overwrite,
-            self.ignore_mismatch,
-            self.filter_categories,
+            path_yaml=self.path_yaml,
+            path_weights=self.path_weights,
+            categories=dict(self.categories.get_categories()),
+            config_overwrite=self.config_overwrite,
+            ignore_mismatch=self.ignore_mismatch,
+            filter_categories=self.categories.filter_categories,
         )
+
+    def clear_model(self) -> None:
+        self.tp_predictor = None

deepdoctection/mapper/cats.py

@@ -21,19 +21,19 @@ builder method of a dataset.
 """
 
 from collections import defaultdict
-from typing import Any, Dict, List, Literal, Mapping, Optional, Sequence, Tuple, Union
+from typing import Any, Literal, Mapping, Optional, Sequence, Union
 
-from ..datapoint.annotation import CategoryAnnotation, ContainerAnnotation, ImageAnnotation, SummaryAnnotation
+from ..datapoint.annotation import DEFAULT_CATEGORY_ID, CategoryAnnotation, ContainerAnnotation
 from ..datapoint.image import Image
-from ..utils.settings import ObjectTypes, TypeOrStr, get_type
+from ..utils.settings import ObjectTypes, SummaryType, TypeOrStr, get_type
 from .maputils import LabelSummarizer, curry
 
 
 @curry
 def cat_to_sub_cat(
     dp: Image,
-    categories_dict_names_as_key: Dict[TypeOrStr, str],
-    cat_to_sub_cat_dict: Optional[Dict[TypeOrStr, TypeOrStr]] = None,
+    categories_dict_names_as_key: dict[TypeOrStr, int],
+    cat_to_sub_cat_dict: Optional[dict[TypeOrStr, TypeOrStr]] = None,
 ) -> Image:
     """
     Replace some category with its affiliated sub category of CategoryAnnotations. Suppose your category name is `foo`
@@ -49,13 +49,12 @@ def cat_to_sub_cat(
     if cat_to_sub_cat_dict is None:
         return dp
     cat_to_sub_cat_dict_obj_type = {get_type(key): get_type(value) for key, value in cat_to_sub_cat_dict.items()}
-    categories_dict = categories_dict_names_as_key
-    for ann in dp.get_annotation_iter(category_names=list(cat_to_sub_cat_dict_obj_type.keys())):
+    for ann in dp.get_annotation(category_names=list(cat_to_sub_cat_dict_obj_type.keys())):
         sub_cat_type = cat_to_sub_cat_dict_obj_type[get_type(ann.category_name)]
         sub_cat = ann.get_sub_category(sub_cat_type)
         if sub_cat:
             ann.category_name = sub_cat.category_name
-            ann.category_id = categories_dict[ann.category_name]
+            ann.category_id = categories_dict_names_as_key[ann.category_name]
 
     return dp
 
@@ -63,7 +62,7 @@ def cat_to_sub_cat(
 @curry
 def re_assign_cat_ids(
     dp: Image,
-    categories_dict_name_as_key: Optional[Dict[TypeOrStr, str]] = None,
+    categories_dict_name_as_key: Optional[dict[TypeOrStr, int]] = None,
     cat_to_sub_cat_mapping: Optional[Mapping[ObjectTypes, Any]] = None,
 ) -> Image:
     """
@@ -89,13 +88,13 @@ def re_assign_cat_ids(
     :return: Image
     """
 
-    anns_to_remove: List[ImageAnnotation] = []
-    for ann in dp.get_annotation_iter():
+    ann_ids_to_remove: list[str] = []
+    for ann in dp.get_annotation():
         if categories_dict_name_as_key is not None:
             if ann.category_name in categories_dict_name_as_key:
                 ann.category_id = categories_dict_name_as_key[ann.category_name]
             else:
-                anns_to_remove.append(ann)
+                ann_ids_to_remove.append(ann.annotation_id)
 
         if cat_to_sub_cat_mapping:
             if ann.category_name in cat_to_sub_cat_mapping:
@@ -103,17 +102,16 @@ def re_assign_cat_ids(
                 for key in sub_cat_keys_to_sub_cat_values:
                     sub_cat_values_dict = sub_cat_keys_to_sub_cat_values[key]
                     sub_category = ann.get_sub_category(key)
-                    sub_category.category_id = sub_cat_values_dict.get(sub_category.category_name, "")
+                    sub_category.category_id = sub_cat_values_dict.get(sub_category.category_name, DEFAULT_CATEGORY_ID)
 
-    for ann in anns_to_remove:
-        dp.remove(ann)
+    dp.remove(annotation_ids=ann_ids_to_remove)
 
     return dp
 
 
 @curry
 def filter_cat(
-    dp: Image, categories_as_list_filtered: List[TypeOrStr], categories_as_list_unfiltered: List[TypeOrStr]
+    dp: Image, categories_as_list_filtered: list[TypeOrStr], categories_as_list_unfiltered: list[TypeOrStr]
 ) -> Image:
     """
     Filters category annotations based on the on a list of categories to be kept and a list of all possible
@@ -132,7 +130,7 @@ def filter_cat(
     remove_cats_mapper = remove_cats(category_names=cats_to_remove_list)  # pylint: disable=E1120  # 259
     dp = remove_cats_mapper(dp)
 
-    categories_dict_name_as_key = {v: str(k) for k, v in enumerate(categories_as_list_filtered, 1)}
+    categories_dict_name_as_key = {v: k for k, v in enumerate(categories_as_list_filtered, 1)}
     re_assign_cat_ids_mapper = re_assign_cat_ids(  # pylint: disable=E1120
         categories_dict_name_as_key=categories_dict_name_as_key
     )
@@ -160,13 +158,13 @@ def filter_summary(
     :return: Image or None
     """
     for key, values in sub_cat_to_sub_cat_names_or_ids.items():
-        if mode == "name" and dp.summary:
+        if mode == "name":
             if dp.summary.get_sub_category(get_type(key)).category_name in values:
                 return dp
-        elif mode == "value" and dp.summary:
+        elif mode == "value":
             if dp.summary.get_sub_category(get_type(key)).value in values:  # type: ignore
                 return dp
-        elif dp.summary:
+        else:
             if dp.summary.get_sub_category(get_type(key)).category_id in values:
                 return dp
     return None
@@ -179,7 +177,7 @@ def image_to_cat_id(
     sub_categories: Optional[Union[Mapping[TypeOrStr, TypeOrStr], Mapping[TypeOrStr, Sequence[TypeOrStr]]]] = None,
     summary_sub_category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
     id_name_or_value: Literal["id", "name", "value"] = "id",
-) -> Tuple[Dict[TypeOrStr, Union[List[int], List[int]]], str]:
+) -> tuple[dict[TypeOrStr, list[int]], str]:
     """
     Extracts all category_ids, sub category information or summary sub category information with given names into a
     defaultdict. This mapping is useful when running evaluation with e.g. an accuracy metric.
@@ -199,7 +197,7 @@ def image_to_cat_id(
 
         will return
 
-            ({'foo':['1', '1'], 'bak':[ '2'], 'baz':['3']}, image_id)
+            ({'foo':[1,1], 'bak':[2], 'baz':[3]}, image_id)
 
 
     **Example 2:**
@@ -213,7 +211,7 @@ def image_to_cat_id(
 
         will return
 
-            ({'foo_sub_1':['5', '6']}, image_id)
+            ({'foo_sub_1':[5,6]}, image_id)
 
 
 
@@ -238,7 +236,7 @@ def image_to_cat_id(
     if not summary_sub_category_names:
         summary_sub_category_names = []
 
-    tmp_sub_category_names: Dict[str, Sequence[str]] = {}
+    tmp_sub_category_names: dict[str, Sequence[str]] = {}
 
     if sub_categories is not None:
         for key, val in sub_categories.items():
@@ -250,15 +248,15 @@ def image_to_cat_id(
         raise ValueError(f"id_name_or_value must be in ('id', 'name', 'value') but is {id_name_or_value}")
 
     if category_names or sub_categories:
-        for ann in dp.get_annotation_iter():
+        for ann in dp.get_annotation():
             if ann.category_name in category_names:
-                cat_container[ann.category_name].append(int(ann.category_id))
+                cat_container[ann.category_name].append(ann.category_id)
             if ann.category_name in tmp_sub_category_names:
                 for sub_cat_name in tmp_sub_category_names[ann.category_name]:
                     sub_cat = ann.get_sub_category(get_type(sub_cat_name))
                     if sub_cat is not None:
                         if id_name_or_value == "id":
-                            cat_container[sub_cat_name].append(int(sub_cat.category_id))
+                            cat_container[sub_cat_name].append(sub_cat.category_id)
                         if id_name_or_value == "name":
                             cat_container[sub_cat_name].append(sub_cat.category_name)  # type: ignore
                         if id_name_or_value == "value":
@@ -269,11 +267,11 @@ def image_to_cat_id(
                                 )
                             cat_container[sub_cat_name].append(sub_cat.value)  # type: ignore
 
-    if dp.summary is not None and summary_sub_category_names:
+    if summary_sub_category_names:
         for sub_cat_name in summary_sub_category_names:
             sub_cat = dp.summary.get_sub_category(get_type(sub_cat_name))
             if id_name_or_value == "id":
-                cat_container[sub_cat_name].append(int(sub_cat.category_id))
+                cat_container[sub_cat_name].append(sub_cat.category_id)
             if id_name_or_value == "name":
                 cat_container[sub_cat_name].append(sub_cat.category_name)  # type: ignore
             if id_name_or_value == "value":
@@ -322,11 +320,11 @@ def remove_cats(
     if isinstance(summary_sub_categories, str):
         summary_sub_categories = [summary_sub_categories]
 
-    anns_to_remove = []
+    ann_ids_to_remove = []
 
-    for ann in dp.get_annotation_iter():
+    for ann in dp.get_annotation():
         if ann.category_name in category_names:
-            anns_to_remove.append(ann)
+            ann_ids_to_remove.append(ann.annotation_id)
         if ann.category_name in sub_categories.keys():
             sub_cats_to_remove = sub_categories[ann.category_name]
             if isinstance(sub_cats_to_remove, str):
@@ -340,19 +338,17 @@ def remove_cats(
             for relation in relationships_to_remove:
                 ann.remove_relationship(key=get_type(relation))
 
-    for ann in anns_to_remove:
-        dp.remove(ann)
+    dp.remove(annotation_ids=ann_ids_to_remove)
 
     if summary_sub_categories is not None:
-        if dp.summary is not None:
-            for sub_cat in summary_sub_categories:
-                dp.summary.remove_sub_category(get_type(sub_cat))
+        for sub_cat in summary_sub_categories:
+            dp.summary.remove_sub_category(get_type(sub_cat))
 
     return dp
 
 
 @curry
-def add_summary(dp: Image, categories: Mapping[str, ObjectTypes]) -> Image:
+def add_summary(dp: Image, categories: Mapping[int, ObjectTypes]) -> Image:
     """
     Adding a summary with the number of categories in an image.
 
@@ -366,10 +362,10 @@ def add_summary(dp: Image, categories: Mapping[str, ObjectTypes]) -> Image:
     for ann in anns:
         summarizer.dump(ann.category_id)
     summary_dict = summarizer.get_summary()
-    summary = SummaryAnnotation()
+    summary = CategoryAnnotation(category_name=SummaryType.SUMMARY)
     for cat_id, val in summary_dict.items():
         summary.dump_sub_category(
-            categories[cat_id], CategoryAnnotation(category_name=categories[cat_id], category_id=str(val))
+            categories[cat_id], CategoryAnnotation(category_name=categories[cat_id], category_id=val)
         )
     dp.summary = summary
     return dp

deepdoctection/mapper/cocostruct.py

@@ -20,21 +20,21 @@ Module for mapping annotations in coco style structure
 """
 
 import os
-from typing import Dict, List, Mapping, Optional, Tuple
+from typing import Mapping, Optional
 
 from ..datapoint.annotation import CategoryAnnotation, ImageAnnotation
 from ..datapoint.box import BoundingBox
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict
 from ..utils.fs import load_image_from_file
 from ..utils.settings import ObjectTypes
+from ..utils.types import CocoDatapointDict, JsonDict
 from .maputils import MappingContextManager, curry, maybe_get_fake_score
 
 
 @curry
 def coco_to_image(
-    dp: JsonDict,
-    categories: Dict[str, str],
+    dp: CocoDatapointDict,
+    categories: dict[int, ObjectTypes],
     load_image: bool,
     filter_empty_image: bool,
     fake_score: bool,
@@ -88,7 +88,7 @@ def coco_to_image(
             bbox = BoundingBox(absolute_coords=True, ulx=x_1, uly=y_1, height=h, width=w)
 
             annotation = ImageAnnotation(
-                category_name=categories[str(ann["category_id"])],
+                category_name=categories[ann["category_id"]],
                 bounding_box=bbox,
                 category_id=ann["category_id"],
                 score=maybe_get_fake_score(fake_score),
@@ -98,8 +98,8 @@ def coco_to_image(
 
             if coarse_sub_cat_name and coarse_mapping:
                 sub_cat = CategoryAnnotation(
-                    category_name=categories[str(coarse_mapping[ann["category_id"]])],
-                    category_id=str(coarse_mapping[ann["category_id"]]),
+                    category_name=categories[coarse_mapping[ann["category_id"]]],
+                    category_id=coarse_mapping[ann["category_id"]],
                 )
                 annotation.dump_sub_category(coarse_sub_cat_name, sub_cat)
 
@@ -109,7 +109,7 @@ def coco_to_image(
     return image
 
 
-def image_to_coco(dp: Image) -> Tuple[JsonDict, List[JsonDict]]:
+def image_to_coco(dp: Image) -> tuple[JsonDict, list[JsonDict]]:
     """
     Converting an image back into the coco format. As images and anns are separated it will return a dict with the
     image information and one for its annotations.
@@ -122,24 +122,28 @@ def image_to_coco(dp: Image) -> Tuple[JsonDict, List[JsonDict]]:
         raise TypeError(f"datapoints must be of type Image, is of type {type(dp)}")
 
     img: JsonDict = {}
-    anns: List[JsonDict] = []
+    anns: list[JsonDict] = []
 
     img["id"] = int("".join([s for s in dp.image_id if s.isdigit()]))
     img["width"] = dp.width
     img["height"] = dp.height
     img["file_name"] = dp.file_name
 
-    for img_ann in dp.get_annotation_iter():
+    for img_ann in dp.get_annotation():
         ann: JsonDict = {
             "id": int("".join([s for s in img_ann.annotation_id if s.isdigit()])),
             "image_id": img["id"],
-            "category_id": int(img_ann.category_id),
+            "category_id": img_ann.category_id,
         }
         if img_ann.score:
             ann["score"] = img_ann.score
         ann["iscrowd"] = 0
         bounding_box = img_ann.get_bounding_box(dp.image_id)
-        ann["area"] = bounding_box.area
+        ann["area"] = (
+            bounding_box.area
+            if bounding_box.absolute_coords
+            else bounding_box.transform(dp.width, dp.height, absolute_coords=True).area
+        )
         ann["bbox"] = bounding_box.to_list(mode="xywh")
         anns.append(ann)