deepvisiontools 0.0.1__py3-none-any.whl

deepvisiontools/data/batch_augmentations.py

@@ -0,0 +1,211 @@
+from deepvisiontools.formats import BaseFormat, BatchedFormat, SemanticMaskFormat
+import torch
+from torch import Tensor
+from abc import ABC, abstractmethod
+from typing import Tuple, Union, Literal, List
+from random import shuffle, uniform
+from deepvisiontools import Configuration
+import itertools
+from torchvision.transforms.v2 import Resize
+import copy
+
+
+class AbstractBatchAugmenter(ABC):
+    """Abstract class for augmentation within DataLoader (combine elements of batch together such as mosaic type augmentation)
+    Note : these augmentations always come after normal augmentations that are implemented in Dataset instead of dataloader for this one.
+    """
+
+    @abstractmethod
+    def get_new_batch(
+        self, images_batch: Tensor, targets_batch: BatchedFormat
+    ) -> Tuple[Tensor, BatchedFormat]:
+        pass
+
+
+MOSAIC_CONVERTER = {
+    1: (1, 1),
+    2: (1, 2),
+    4: (2, 2),
+    6: (2, 3),
+    8: (2, 4),
+    9: (3, 3),
+    12: (3, 4),
+}
+
+
+class MosaicBatchAugmenter(AbstractBatchAugmenter):
+    """This Batch augmentation generate a mosaic containing n images from a batch (mix some patch of images / targets into one image).
+    If the number of image is larger than batch size shift to smaller possibility (for e.g. n = 4 batch_size=3 -> n becomes 2).
+    if number of image to be mixed is smaller than batch_size, create new mosaics if possible : for e.g batchsize = 5, n=2 -> generate 2 mosaics from the first 2 images, then an additional 2 images with remaining, and finally the remaining is 1.
+    The remaining images are left untouched
+
+        Args:
+            mixed_img_numb (``Literal[1, 2, 4, 6, 8, 9, 12]``, **optional**): Number of img per mosaic. Defaults to 2.
+            probability (``float``, **optional**): _description_. Defaults to 0.5.
+    """
+
+    def __init__(
+        self,
+        mixed_img_numb: Literal[1, 2, 4, 6, 8, 9, 12] = 2,
+        probability: float = 0.5,
+    ):
+
+        assert mixed_img_numb in list(
+            MOSAIC_CONVERTER.keys()
+        ), f"Wrong argument in MosaicBatchAugmenter, mixed_img_num must be one of [1, 2, 4, 6, 8, 9, 12], got {mixed_img_numb}"
+        self.mixed_img_number = mixed_img_numb
+        self._used_mixed_img_nb = mixed_img_numb
+        self.probability = probability
+        self._device = Configuration().device
+        self._imgs_shape = None
+        self._mosaic_shape = None
+        self._resizer = None
+
+    def _adapt_to_batch(self, images_batch: Tensor):
+        assert (
+            images_batch.dim() == 4
+        ), f"To use MosaicBatchAugmenter, batches of images must have dim=4 (N, 3, H, W), got {images_batch.shape}"
+        num_img = images_batch.shape[0]
+        h, w = images_batch.shape[-2:]
+        option_list = [1, 2, 4, 6, 8, 9, 12]
+        # adapt batch size to option of nb of mixed img
+        while self._used_mixed_img_nb > num_img:
+            self._used_mixed_img_nb = option_list[
+                option_list.index(self._used_mixed_img_nb) - 1
+            ]
+        self._imgs_shape = images_batch.shape[-2:]
+        # adapt mosaic shape to largest between h and w of images
+        m_shape = MOSAIC_CONVERTER[self._used_mixed_img_nb]
+        if h > w:
+            m_shape = (max(m_shape), min(m_shape))
+        self._mosaic_shape = m_shape
+        self._resizer = Resize((h, w))
+
+    def _reset(self):
+        self._used_mixed_img_nb = self.mixed_img_number
+        self._mosaic_shape = None
+        self._resizer = None
+
+    def _get_mixing_index(self, images_batch: Tensor) -> Tuple[Tensor, Tensor]:
+        num_imgs = images_batch.shape[0]
+        index = list(range(num_imgs))
+        shuffle(index)
+        kept_index = index
+        mixing_index = []
+        while len(kept_index) >= self._used_mixed_img_nb:
+            mixing_index.append(kept_index[: self._used_mixed_img_nb])
+            kept_index = kept_index[self._used_mixed_img_nb :]
+        return mixing_index, kept_index
+
+    def _generate_batchs_lists(
+        self, images_batch: Tensor, targets_batch: BatchedFormat
+    ) -> Tuple[List[Tensor], List[BatchedFormat], Tensor, BatchedFormat]:
+        mixing_index, kept_indexes = self._get_mixing_index(images_batch)
+        # split batch into the ones that are kept and the ones to be mixed.
+        if kept_indexes != []:
+            images2keep: Tensor = images_batch[kept_indexes]
+            targets2keep: BatchedFormat = targets_batch[kept_indexes]
+        else:
+            images2keep = torch.empty([0])
+            targets2keep = BatchedFormat([])
+
+        images_batches_to_mix: list = [
+            images_batch[mix_batch] for mix_batch in mixing_index
+        ]  # list of Tensor of shape [n_mix, h, w]
+        targets_batches_to_mix: list = [
+            targets_batch[mix_batch] for mix_batch in mixing_index
+        ]  # list of corresponding BatchedFormats
+        return images_batches_to_mix, targets_batches_to_mix, images2keep, targets2keep
+
+    def _get_crop_coords_lists(self):
+        h, w = self._imgs_shape
+        h_divider, w_divider = self._mosaic_shape
+        crop_coords_list = []
+        h_step = float(h) / h_divider
+        w_step = float(w) / w_divider
+        for i, j in itertools.product(list(range(h_divider)), list(range(w_divider))):
+            t_c, l_c, h_c, w_c = i * h_step, j * w_step, h_step, w_step
+            crop_coords_list.append((round(t_c), round(l_c), round(h_c), round(w_c)))
+        return crop_coords_list
+
+    def _mix_batch(
+        self,
+        batch_img: Tensor,
+        batch_targ: BatchedFormat,
+        crops_coords: List[Tuple[int, int, int, int]],
+    ):
+        num_imgs = batch_img.shape[0]
+        cycle = list(range(num_imgs))  # use this for all imgs/targs permutations
+        cycles = []
+        for i in range(len(cycle)):
+            first_elem = cycle.pop(0)
+            cycle.append(first_elem)
+            cycles.append(copy.deepcopy(cycle))
+
+        new_batch_img = []
+        new_batch_targs = []
+        for cy in cycles:
+            new_img, new_tar = self._get_img_targ_from_cycle_of_crops(
+                batch_img, batch_targ, cy, crops_coords
+            )
+            new_batch_img.append(copy.deepcopy(new_img))
+            new_batch_targs.append(copy.deepcopy(new_tar))
+        return torch.stack(new_batch_img), BatchedFormat(new_batch_targs)
+
+    def _get_img_targ_from_cycle_of_crops(
+        self,
+        batch_img: Tensor,
+        batch_targ: BatchedFormat,
+        cycle: list,
+        crops_coords: list,
+    ):
+        list_imgs = [batch_img[i] for i in cycle]
+        list_targs = BatchedFormat([batch_targ.formats[i] for i in cycle])
+        new_img = torch.zeros((3, *self._imgs_shape))
+        new_targ: BaseFormat = type(list_targs.formats[0]).empty(
+            canvas_size=list_targs.formats[0].canvas_size
+        )
+        ori_h, ori_w = new_targ.canvas_size
+        if isinstance(new_targ, SemanticMaskFormat):
+            new_targ = new_targ.generate_scores_from_mask()
+        for im, tar, crop_coord in zip(list_imgs, list_targs, crops_coords):
+            t, l, h, w = crop_coord
+            new_img[:, t : t + h, l : l + w] = im[:, t : t + h, l : l + w]
+            crop_targ = tar.crop(t, l, h, w)[0]
+            t_pad, l_pad, r_pad, b_pad = t, l, ori_w - l - w, ori_h - t - h
+            crop_targ = crop_targ.pad(t_pad, l_pad, r_pad, b_pad)[0]
+            if isinstance(crop_targ, SemanticMaskFormat):
+                crop_targ = crop_targ.generate_scores_from_mask()
+            new_targ += crop_targ
+        return new_img, new_targ
+
+    def get_new_batch(self, images_batch: Tensor, targets_batch: BatchedFormat):
+        # ======= Prepare
+        self._adapt_to_batch(images_batch)
+        # if proba fails or if image nb to mix is 1, don't do mixing
+        if uniform(0, 1) > self.probability or self._used_mixed_img_nb == 1:
+            return images_batch, targets_batch
+        # get to be mixed imgs and targs as well as to be kept images and targs
+        images_batches_to_mix, targets_batches_to_mix, images2keep, targets2keep = (
+            self._generate_batchs_lists(images_batch, targets_batch)
+        )
+        # ======= Handle mixing
+        crops_coords = self._get_crop_coords_lists()
+        final_batchs_img_mixed = []
+        final_batchs_tars_mixed = []
+        for batch_img, batch_targ in zip(images_batches_to_mix, targets_batches_to_mix):
+            new_img, new_targ = self._mix_batch(batch_img, batch_targ, crops_coords)
+            final_batchs_img_mixed.append(new_img)
+            final_batchs_tars_mixed.append(new_targ)
+        final_imgs_mixed = torch.cat(final_batchs_img_mixed).to(Configuration().device)
+        final_targs_mixed = BatchedFormat.cat(final_batchs_tars_mixed)
+        # aggragate untouched and mixed
+        if targets2keep.formats != []:
+            new_img_fullbatch = torch.cat([final_imgs_mixed, images2keep])
+            new_tar_fullbatch = BatchedFormat.cat([final_targs_mixed, targets2keep])
+        else:
+            new_img_fullbatch = final_imgs_mixed
+            new_tar_fullbatch = final_targs_mixed
+        # ======= reset for futu uses
+        self._reset()
+        return new_img_fullbatch, new_tar_fullbatch

deepvisiontools/data/data_reader/__init__.py

@@ -0,0 +1,3 @@
+from deepvisiontools.data.data_reader.readers import BaseReader, CocoReader
+
+__all__ = ("BaseReader", "CocoReader")

deepvisiontools/data/data_reader/readers.py

@@ -0,0 +1,490 @@
+from typing import Union, Tuple, Dict, List, Any
+from pathlib import Path
+from abc import ABC, abstractmethod
+from deepvisiontools.formats import (
+    BaseFormat,
+    BboxFormat,
+    InstanceMaskFormat,
+    SemanticMaskFormat,
+)
+from deepvisiontools.formats.base_data import (
+    InstanceMaskData,
+    BboxData,
+    SemanticMaskData,
+)
+from deepvisiontools import Configuration
+import torch
+import numpy as np
+from torch import Tensor
+import json
+import cv2
+from tqdm import tqdm
+from deepvisiontools.preprocessing import load_mask
+
+ANNOTATION_TYPE_DICT = {
+    "json": "file",
+    "png": "mask",
+    "tif": "mask",
+    "tiff": "mask",
+    "jpg": "mask",
+    "jpeg": "mask",
+}
+
+SUPPORTED_IMAGE_EXTENSIONS = [
+    "png",
+    "PNG",
+    "jpg",
+    "JPG",
+    "jpeg",
+    "JPEG",
+    "tif",
+    "TIF",
+    "tiff",
+    "TIFF",
+]
+
+
+class BaseReader(ABC):
+    """Base class for readers. __len__ and __getitem__ methods must be implemented in concrete class.
+    Your concrete class must implement concrete category_id property that returns Dict[int, str] where int is label and str category name.
+    Your concrete class must have a class attribute describing annotation file type ("json" for json file, "png" for image etc.)
+    You must implement export_annotation and group_export methods in concrete classes
+    See CocoReader class for concrete implementation
+    """
+
+    @property
+    def annotation_file_type(cls):
+        raise NotImplementedError
+
+    @abstractmethod
+    def __getitem__(self, index: int) -> Tuple[str, BaseFormat]:
+        """From a given index ([0, N-1] where N is the number of images) returns image name, Format
+
+        Args:
+            index (``int``): Index of image from 0 to N-1
+
+        Returns:
+            ``Tuple[str, Format]``:
+                - returns image name (ex: something.jpg), target as Format
+        """
+        pass
+
+    @abstractmethod
+    def __len__(self) -> int:
+        pass
+
+    @abstractmethod
+    def export_annotation(self, image: Tensor, annotation: BaseFormat):
+        pass
+
+    @abstractmethod
+    def group_export(
+        sub_anns_dir: Union[str, Path],
+        destination: Union[str, Path],
+        categories: Dict[int, str] = None,
+    ):
+        pass
+
+    @property
+    @abstractmethod
+    def category_ids(self) -> Dict[int, str]:
+        pass
+
+    @category_ids.setter
+    @abstractmethod
+    def category_ids(self, val):
+        pass
+
+
+DEFAULT_COCO_ANNOT = "coco_annotations.json"
+
+DEFAULT_SEMANTIC_ANNOT_PATH = "masks"
+
+
+# TODO check everything
+class SemanticReader(BaseReader):
+
+    annotation_file_type = "tiff"  # used for export dataset only
+
+    def __init__(self, dataset_path: Union[str, Path]):
+        dataset_path = (
+            dataset_path if isinstance(dataset_path, Path) else Path(dataset_path)
+        )
+        # load all files paths (images and masks)
+        self.masks_path = dataset_path / DEFAULT_SEMANTIC_ANNOT_PATH
+        images_path = dataset_path / "images"
+        self.images_path = images_path
+        self.images = list(images_path.glob("*"))
+        self.images = [
+            f.name for f in self.images if f.suffix[1:] in SUPPORTED_IMAGE_EXTENSIONS
+        ]
+        self.images = sorted(self.images)
+        self.masks = list(self.masks_path.glob("*"))
+        self.masks = [
+            f for f in self.masks if f.suffix[1:] in SUPPORTED_IMAGE_EXTENSIONS
+        ]
+        self.masks = sorted(self.masks)
+        assert len(self.masks) == len(
+            self.images
+        ), "Not same number of masks and images. You must have the same."
+        self.category_ids = {
+            i + 1: str(i + 1) for i in range(Configuration().num_classes)
+        }
+
+    @property
+    def category_ids(self):
+        return self._category_ids
+
+    @category_ids.setter
+    def category_ids(self, val: Dict[int, str]):
+        self._category_ids = val
+
+    def __getitem__(self, index):
+        img_name = self.images[index]
+        assert (
+            Path(img_name).stem == self.masks[index].stem
+        ), f"In Reader: index {index} leads to different name for image and mask, got {img_name} and {self.masks[index].name}"
+        target = load_mask(self.masks[index])
+        target = SemanticMaskData(target)
+        target = SemanticMaskFormat(target)
+        return img_name, target
+
+    def __len__(self):
+        return len(self.images)
+
+    def export_annotation(
+        self, image_name, image, annotation: SemanticMaskFormat, cats
+    ):
+        assert isinstance(
+            annotation, SemanticMaskFormat
+        ), "In semanticreader : annotation must be SemanticMaskFormat"
+        mask = annotation.data.value
+        mask = mask.to("cpu")
+        return image_name, mask
+
+    def group_export(
+        self,
+        sub_anns_dir: Union[str, Path],
+        destination: Union[str, Path],
+        categories: Dict[int, str] = None,
+    ):
+        destination = "masks"
+        sub_anns_dir.rename(sub_anns_dir.parent / destination)
+
+
+class CocoReader(BaseReader):
+    """Child class of BaseReader. Coco format reader class. Handles dataset with structure:
+
+    Dataset Name -> Image_dir, coco_annotations.json
+
+    Note : bboxes must be in XYWH format
+
+    Args:
+        annotation_path (Union[str, Path]): path to json file or to dataset directory.
+
+    Attributes
+    ----------
+
+    Attributes:
+        - annot_dict (``Dict[Any, Any]``): coco dict loaded.
+
+    Attributes
+    ----------
+
+    Properties:
+        - category_ids Dict[int, str]: label / category correspondance
+
+
+    **Methods**
+    """
+
+    annotation_file_type = "json"
+
+    def __init__(self, annotation_path: Union[str, Path]) -> None:
+
+        annotation_path = (
+            annotation_path
+            if isinstance(annotation_path, Path)
+            else Path(annotation_path)
+        )
+        if annotation_path.is_dir():
+            annotation_path = annotation_path / DEFAULT_COCO_ANNOT
+        with open(annotation_path) as f:
+            self.annot_dict = json.load(f)
+        # if items of annot_dict are dict convert them to lists
+        if isinstance(self.annot_dict["categories"], dict):
+            self.annot_dict["categories"] = [v for v in self.annot_dict["categories"]]
+        if isinstance(self.annot_dict["images"], dict):
+            self.annot_dict["images"] = [v for v in self.annot_dict["images"]]
+        if isinstance(self.annot_dict["annotations"], dict):
+            self.annot_dict["annotations"] = [v for v in self.annot_dict["annotations"]]
+        # compute reindexer dict for imgs
+        self._imgs_reindex_dict = {
+            i: im["id"] for i, im in enumerate(self.annot_dict["images"])
+        }
+        # compute reindexer dict for labels / categories
+        ordered_keys = [cat["name"] for cat in self.annot_dict["categories"]]
+        ordered_keys.sort()
+        self._category_converter = {}
+        for i, name in enumerate(ordered_keys):
+            for cat in self.annot_dict["categories"]:
+                if name == cat["name"]:
+                    self._category_converter.update({i: cat})
+        self._label_converter = {
+            k["id"]: i for i, k in self._category_converter.items()
+        }
+        # generate a correspondance between new labels and cat name
+        self.category_ids = {i: k["name"] for i, k in self._category_converter.items()}
+
+    @property
+    def category_ids(self):
+        return self._category_ids
+
+    @category_ids.setter
+    def category_ids(self, val: Dict[int, str]):
+        self._category_ids = val
+
+    def get_img_anns(self, index: int) -> Tuple[str, Tuple[int, int], List[dict]]:
+        """return from index image as img name, spatial size as Tuple[int, int] (h, w) and all annotations for given image index
+
+        Args:
+            index (int)
+        Returns:
+            Tuple[str, Tuple[int, int], List[dict]]: img_name, spatial_size, list of coco anns
+        """
+        image = [
+            img
+            for img in self.annot_dict["images"]
+            if img["id"] == self._imgs_reindex_dict[index]
+        ]
+        spatial_size = (image[0]["height"], image[0]["width"])
+        image = image[0]["file_name"]
+        anns = [
+            ann
+            for ann in self.annot_dict["annotations"]
+            if ann["image_id"] == self._imgs_reindex_dict[index]
+        ]
+        return image, spatial_size, anns
+
+    def __getitem__(self, index: int) -> Tuple[str, BaseFormat]:
+        """From a given index ([0, N-1] where N is the number of images) returns image name, Format
+
+        Args:
+            index (``int``): Index of image from 0 to N-1
+
+        Returns:
+            ``Tuple[str, Format]``:
+                - returns image name (ex: something.jpg), target as Format
+        """
+        image_name, spatial_size, anns = self.get_img_anns(index)
+
+        # handle empty anns
+        if anns == []:
+            if Configuration().data_type == "bbox":
+                format = BboxFormat.empty(spatial_size)
+            if Configuration().data_type == "instance_mask":
+                format = InstanceMaskFormat.empty(spatial_size)
+        elif Configuration().data_type == "bbox":
+            labels = torch.tensor(
+                [
+                    self._label_converter[ann["category_id"]]
+                    for ann in anns
+                    if "bbox" in ann.keys()
+                ]
+            )
+            bboxes = [ann["bbox"] for ann in anns if "bbox" in ann.keys()]
+            # handle empty
+            if bboxes == []:
+                format = BboxFormat.empty(spatial_size)
+            else:
+                bboxes = [torch.tensor(box)[None, :] for box in bboxes]
+                bboxes = BboxData(
+                    torch.cat(bboxes), format="XYWH", canvas_size=spatial_size
+                )
+                format = BboxFormat(bboxes, labels)
+        elif Configuration().data_type == "instance_mask":
+            labels = torch.tensor(
+                [
+                    self._label_converter[ann["category_id"]]
+                    for ann in anns
+                    if "segmentation" in ann.keys()
+                ]
+            )
+            if labels == []:
+                format = InstanceMaskFormat.empty(spatial_size)
+            else:
+                object_masks = [
+                    self.segment2mask(ann, spatial_size)
+                    for ann in anns
+                    if "segmentation" in ann.keys()
+                ]
+                # reindex objects and stack them with id in [1 ... N_obj] range
+                object_masks = [m * (i + 1) for i, m in enumerate(object_masks)]
+                mask = np.max(np.stack(object_masks, axis=0), axis=0)
+                mask = torch.tensor(mask).long()
+                format = InstanceMaskFormat(InstanceMaskData(mask), labels)
+        return image_name, format
+
+    def segment2mask(
+        self, ann: Dict[Any, Any], spatial_size: Tuple[int, int]
+    ) -> np.ndarray:
+        """Convert segment to object mask.
+
+        Args:
+            ann (Dict[Any, Any]): coco format annotation dict
+            spatial_size (Tuple[int, int]): size of image as (h, w)
+
+        Returns:
+            np.ndarray: mask
+        """
+        segments = ann["segmentation"]
+        # handle RLE coding
+        if isinstance(segments, dict):
+            assert (
+                "counts" in segments.keys()
+            ), f"Segmentation {segments} is dict but not RLE encoded."
+            mask: np.ndarray = self.rleToMask(segments, spatial_size)
+        else:
+            mask = np.zeros((spatial_size[0], spatial_size[1], 3))
+            segments = [
+                np.array(seg, dtype=np.int32).reshape(-1, 2)
+                for seg in segments
+                if len(seg) > 4
+            ]
+
+            assert segments != [], "Empty annotation after filtering segment length"
+            for poly in segments:
+                cv2.drawContours(mask, [poly], -1, color=(1), thickness=-1)
+            mask = mask[:, :, 0]
+        mask: np.ndarray = mask.astype(np.uint64)
+        return mask
+
+    def rleToMask(self, rle: str, shape: Tuple[int, int]) -> np.ndarray:
+        """convert rle encoding to binary mask
+
+        Args:
+            rle (str)
+            shape (Tuple[int, int])
+
+        Returns:
+            np.ndarray: mask
+        """
+        rle = rle["counts"]
+        # force even number of elem
+        if not len(rle) % 2 == 0:
+            rle.append(0)
+        width, height = shape[:2]
+
+        mask = np.zeros(width * height).astype(np.uint64)
+
+        array = np.asarray(rle)
+        starts = array[0::2]
+        lengths = array[1::2]
+
+        current_position = 0
+        for i, start in enumerate(starts):
+            current_position += start
+            mask[current_position : int(current_position + lengths[i])] = 1
+            current_position += lengths[i]
+
+        return mask.reshape(height, width).T
+
+    def __len__(self) -> int:
+        return len(self.annot_dict["images"])
+
+    def export_annotation(
+        self,
+        image_name: str,
+        image: Tensor,
+        format: BaseFormat,
+        categories: Dict[int, str],
+    ) -> Tuple[str, Dict[Any, Any]]:
+        """from image, image name, categories and target (as BaseFormat) returns a writeable coco dict.
+
+        Args:
+            image_name (str)
+            image (Tensor)
+            format (BaseFormat)
+            categories (Dict[int, str]): Dict of label / category name correspondance
+
+        Returns:
+            Tuple[str, Dict[Any, Any]]: image_name, coco dict
+        """
+        format.device = "cpu"
+        images = [
+            {
+                "file_name": image_name,
+                "height": image.shape[-2],
+                "width": image.shape[-1],
+                "id": 0,
+            }
+        ]
+        categories = [{"name": k, "id": v} for v, k in categories.items()]
+        anns = []
+        for i in range(format.nb_object):
+            obj, _ = format[i]
+            # if no object, stop loop
+            if obj.nb_object == 0:
+                break
+            # retrieve mask/box and label
+            label = obj.labels.item()
+            obj.device = "cpu"
+            ann_dict = {"id": 0, "image_id": 0, "category_id": label}
+            if isinstance(obj, InstanceMaskFormat):
+                bboxes: BboxData = BboxData.from_mask(obj.data)
+                bboxes.format = "XYWH"
+                bboxes.device = "cpu"
+                bboxes: Tensor = bboxes.value
+                bboxes_coco = bboxes.numpy()[0]
+                bboxes_coco = [int(b) for b in bboxes_coco]
+                contours, _ = cv2.findContours(
+                    obj.data.value.numpy().astype(np.uint8),
+                    cv2.RETR_EXTERNAL,
+                    cv2.CHAIN_APPROX_NONE,
+                )
+                contours = [c.reshape(-1).tolist() for c in contours]
+                ann_dict.update({"bbox": bboxes_coco, "segmentation": contours})
+            elif isinstance(obj, BboxFormat):
+                obj.data.format = "XYWH"
+                bboxes = obj.data.value
+                bboxes_coco = bboxes.numpy()[0]
+                bboxes_coco = [int(b) for b in bboxes_coco]
+                ann_dict.update({"bbox": bboxes_coco})
+            anns.append(ann_dict)
+        coco_dict = {"categories": categories, "images": images, "annotations": anns}
+        return image_name, coco_dict
+
+    def group_export(
+        self,
+        sub_anns_dir: Union[str, Path],
+        destination: Union[str, Path],
+        categories: Dict[int, str] = None,
+    ):
+        destination = destination / "coco_annotations.json"
+        categories = self.category_ids if categories == None else categories
+        """Final layer of export dataset function. Here looks at all individual json files and merge them to coco_annotations.json
+
+        Args:
+            sub_anns_dir (Union[str, Path])
+            destination (Union[str, Path])
+            categories (Dict[int, str])
+        """
+        categories = [{"name": k, "id": v} for v, k in categories.items()]
+        grouped_dict = {"categories": categories, "images": [], "annotations": []}
+        jsons_list = sub_anns_dir.glob("*.json")
+        jsons_list = [json.as_posix() for json in jsons_list]
+        img_idx = 0
+        ann_idx = 0
+        for j_file in tqdm(jsons_list, desc="Grouping jsons : "):
+            with open(j_file) as f:
+                d = json.load(f)
+            d["images"][0]["id"] = img_idx
+            grouped_dict["images"].append(d["images"][0])
+            for i in range(len(d["annotations"])):
+                d["annotations"][i]["id"] = ann_idx
+                d["annotations"][i]["image_id"] = img_idx
+                grouped_dict["annotations"].append(d["annotations"][i])
+                ann_idx += 1
+            img_idx += 1
+        with open(destination, "w") as f:
+            json.dump(grouped_dict, f)