supervisely 6.73.320__py3-none-any.whl → 6.73.322__py3-none-any.whl

supervisely/convert/pointcloud_episodes/kitti_360/kitti_360_helper.py

@@ -0,0 +1,386 @@
+from supervisely import logger
+from supervisely.io.fs import get_file_name
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.geometry.point_3d import Vector3d
+from supervisely.geometry.point import Point
+
+from collections import defaultdict
+import os
+import numpy as np
+
+
+MAX_N = 1000
+
+
+def local2global(semanticId, instanceId):
+    globalId = semanticId * MAX_N + instanceId
+    if isinstance(globalId, np.ndarray):
+        return globalId.astype(np.int)
+    else:
+        return int(globalId)
+
+
+def global2local(globalId):
+    semanticId = globalId // MAX_N
+    instanceId = globalId % MAX_N
+    if isinstance(globalId, np.ndarray):
+        return semanticId.astype(int), instanceId.astype(int)
+    else:
+        return int(semanticId), int(instanceId)
+
+
+annotation2global = defaultdict()
+
+
+# Abstract base class for annotation objects
+class KITTI360Object:
+    from abc import ABCMeta
+
+    __metaclass__ = ABCMeta
+
+    def __init__(self):
+        from matplotlib import cm
+
+        # the label
+        self.label = ""
+
+        # colormap
+        self.cmap = cm.get_cmap("Set1")
+        self.cmap_length = 9
+
+    def getColor(self, idx):
+        if idx == 0:
+            return np.array([0, 0, 0])
+        return np.asarray(self.cmap(idx % self.cmap_length)[:3]) * 255.0
+
+    # def assignColor(self):
+    #     from kitti360scripts.helpers.labels import id2label  # pylint: disable=import-error
+
+    #     if self.semanticId >= 0:
+    #         self.semanticColor = id2label[self.semanticId].color
+    #         if self.instanceId > 0:
+    #             self.instanceColor = self.getColor(self.instanceId)
+    #         else:
+    #             self.instanceColor = self.semanticColor
+
+
+# Class that contains the information of a single annotated object as 3D bounding box
+class KITTI360Bbox3D(KITTI360Object):
+    # Constructor
+    def __init__(self):
+        KITTI360Object.__init__(self)
+        # the polygon as list of points
+        self.vertices = []
+        self.faces = []
+        self.lines = [
+            [0, 5],
+            [1, 4],
+            [2, 7],
+            [3, 6],
+            [0, 1],
+            [1, 3],
+            [3, 2],
+            [2, 0],
+            [4, 5],
+            [5, 7],
+            [7, 6],
+            [6, 4],
+        ]
+
+        # the ID of the corresponding object
+        self.semanticId = -1
+        self.instanceId = -1
+        self.annotationId = -1
+
+        # the window that contains the bbox
+        self.start_frame = -1
+        self.end_frame = -1
+
+        # timestamp of the bbox (-1 if statis)
+        self.timestamp = -1
+
+        # projected vertices
+        self.vertices_proj = None
+        self.meshes = []
+
+        # name
+        self.name = ""
+
+    def __str__(self):
+        return self.name
+
+    # def generateMeshes(self):
+    #     self.meshes = []
+    #     if self.vertices_proj:
+    #         for fidx in range(self.faces.shape[0]):
+    #             self.meshes.append(
+    #                 [
+    #                     Point(self.vertices_proj[0][int(x)], self.vertices_proj[1][int(x)])
+    #                     for x in self.faces[fidx]
+    #                 ]
+    #             )
+
+    def parseOpencvMatrix(self, node):
+        rows = int(node.find("rows").text)
+        cols = int(node.find("cols").text)
+        data = node.find("data").text.split(" ")
+
+        mat = []
+        for d in data:
+            d = d.replace("\n", "")
+            if len(d) < 1:
+                continue
+            mat.append(float(d))
+        mat = np.reshape(mat, [rows, cols])
+        return mat
+
+    def parseVertices(self, child):
+        transform = self.parseOpencvMatrix(child.find("transform"))
+        R = transform[:3, :3]
+        T = transform[:3, 3]
+        vertices = self.parseOpencvMatrix(child.find("vertices"))
+        faces = self.parseOpencvMatrix(child.find("faces"))
+
+        vertices = np.matmul(R, vertices.transpose()).transpose() + T
+        self.vertices = vertices
+        self.faces = faces
+        self.R = R
+        self.T = T
+
+        self.transform = transform
+
+    def parseBbox(self, child):
+        from kitti360scripts.helpers.labels import kittiId2label  # pylint: disable=import-error
+
+        semanticIdKITTI = int(child.find("semanticId").text)
+        self.semanticId = kittiId2label[semanticIdKITTI].id
+        self.instanceId = int(child.find("instanceId").text)
+        # self.name = str(child.find('label').text)
+        self.name = kittiId2label[semanticIdKITTI].name
+
+        self.start_frame = int(child.find("start_frame").text)
+        self.end_frame = int(child.find("end_frame").text)
+
+        self.timestamp = int(child.find("timestamp").text)
+
+        self.annotationId = int(child.find("index").text) + 1
+
+        global annotation2global
+        annotation2global[self.annotationId] = local2global(self.semanticId, self.instanceId)
+        self.parseVertices(child)
+
+    def parseStuff(self, child):
+        from kitti360scripts.helpers.labels import name2label  # pylint: disable=import-error
+
+        classmap = {
+            "driveway": "parking",
+            "ground": "terrain",
+            "unknownGround": "ground",
+            "railtrack": "rail track",
+        }
+        label = child.find("label").text
+        if label in classmap.keys():
+            label = classmap[label]
+
+        self.start_frame = int(child.find("start_frame").text)
+        self.end_frame = int(child.find("end_frame").text)
+
+        self.semanticId = name2label[label].id
+        self.instanceId = 0
+        self.parseVertices(child)
+
+
+# Class that contains the information of the point cloud a single frame
+class KITTI360Point3D(KITTI360Object):
+    # Constructor
+    def __init__(self):
+        KITTI360Object.__init__(self)
+
+        self.vertices = []
+
+        self.vertices_proj = None
+
+        # the ID of the corresponding object
+        self.semanticId = -1
+        self.instanceId = -1
+        self.annotationId = -1
+
+        # name
+        self.name = ""
+
+        # color
+        self.semanticColor = None
+        self.instanceColor = None
+
+    def __str__(self):
+        return self.name
+
+    # def generateMeshes(self):
+    #     pass
+
+
+# Meta class for KITTI360Bbox3D
+class Annotation3D:
+    def __init__(self, labelPath):
+        from kitti360scripts.helpers.labels import labels  # pylint: disable=import-error
+        import xml.etree.ElementTree as ET
+
+        key_name = get_file_name(labelPath)
+        # load annotation
+        tree = ET.parse(labelPath)
+        root = tree.getroot()
+
+        self.objects = defaultdict(dict)
+
+        self.num_bbox = 0
+        for child in root:
+            if child.find("transform") is None:
+                continue
+            obj = KITTI360Bbox3D()
+            obj.parseBbox(child)
+            globalId = local2global(obj.semanticId, obj.instanceId)
+            self.objects[globalId][obj.timestamp] = obj
+            self.num_bbox += 1
+
+        globalIds = np.asarray(list(self.objects.keys()))
+        semanticIds, instanceIds = global2local(globalIds)
+        for label in labels:
+            if label.hasInstances:
+                print(f"{label.name:<30}:\t {(semanticIds==label.id).sum()}")
+        print(f"Loaded {len(globalIds)} instances")
+        print(f"Loaded {self.num_bbox} boxes")
+
+    def __call__(self, semanticId, instanceId, timestamp=None):
+        globalId = local2global(semanticId, instanceId)
+        if globalId in self.objects.keys():
+            # static object
+            if len(self.objects[globalId].keys()) == 1:
+                if -1 in self.objects[globalId].keys():
+                    return self.objects[globalId][-1]
+                else:
+                    return None
+            # dynamic object
+            else:
+                return self.objects[globalId][timestamp]
+        else:
+            return None
+
+    def get_objects(self):
+        return [list(obj.values())[0] for obj in self.objects.values()]
+
+class StaticTransformations:
+    def __init__(self, calibrations_path):
+        import kitti360scripts.devkits.commons.loadCalibration as lc  # pylint: disable=import-error
+
+        cam2velo_path = os.path.join(calibrations_path, "calib_cam_to_velo.txt")
+        self.cam2velo = lc.loadCalibrationRigid(cam2velo_path)
+        perspective_path = os.path.join(calibrations_path, "perspective.txt")
+        self.intrinsic_calibrations = lc.loadPerspectiveIntrinsic(perspective_path)
+        self.cam2world = None
+
+    def set_cam2world(self, cam2world_path):
+        if not os.path.isfile(cam2world_path):
+            logger.warn("Camera to world calibration file was not found")
+            return
+
+        cam2world_rows = np.loadtxt(cam2world_path)
+        cam2world_rigid = np.reshape(cam2world_rows[:, 1:], (-1, 4, 4))
+        frames_numbers = list(np.reshape(cam2world_rows[:, :1], (-1)).astype(int))
+        cam2world = {}
+
+        current_rigid = cam2world_rigid[0]
+
+        for frame_index in range(0, frames_numbers[-1]):
+            if frame_index in frames_numbers:
+                mapped_index = frames_numbers.index(frame_index)
+                current_rigid = cam2world_rigid[mapped_index]
+
+            # (Tr(cam -> world))
+            cam2world[frame_index] = current_rigid
+        self.cam2world = cam2world
+
+    def world_to_velo_transformation(self, obj, frame_index):
+        # rotate_z = Rotation.from_rotvec(np.pi * np.array([0, 0, 1])).as_matrix()
+        # rotate_z = np.hstack((rotate_z, np.asarray([[0, 0, 0]]).T))
+
+        # tr0(local -> fixed_coordinates_local)
+        tr0 = np.asarray([[0, -1, 0, 0], [1, 0, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+
+        # tr0(fixed_coordinates_local -> world)
+        tr1 = obj.transform
+
+        # tr2(world -> cam)
+        tr2 = np.linalg.inv(self.cam2world[frame_index])
+
+        # tr3(world -> cam)
+        tr3 = self.cam2velo
+
+        return tr3 @ tr2 @ tr1 @ tr0
+
+    def get_extrinsic_matrix(self):
+        return np.linalg.inv(self.cam2velo)[:3, :4]
+
+    def get_intrinsics_matrix(self, camera_num):
+        try:
+            matrix = self.intrinsic_calibrations[f"P_rect_0{camera_num}"][:3, :3]
+            return matrix
+        except KeyError:
+            logger.warn(f"Camera {camera_num} intrinsic matrix was not found")
+        return
+
+def convert_kitti_cuboid_to_supervisely_geometry(tr_matrix):
+    import transforms3d  # pylint: disable=import-error
+    from scipy.spatial.transform.rotation import Rotation
+
+    Tdash, Rdash, Zdash, _ = transforms3d.affines.decompose44(tr_matrix)
+
+    x, y, z = Tdash[0], Tdash[1], Tdash[2]
+    position = Vector3d(x, y, z)
+
+    rotation_angles = Rotation.from_matrix(Rdash).as_euler("xyz", degrees=False)
+    r_x, r_y, r_z = rotation_angles[0], rotation_angles[1], rotation_angles[2]
+
+    # Invert the bbox by adding π to the yaw while maintaining its degree relative to the world
+    rotation = Vector3d(r_x, r_y, r_z + np.pi)
+
+    w, h, l = Zdash[0], Zdash[1], Zdash[2]
+    dimension = Vector3d(w, h, l)
+
+    return Cuboid3d(position, rotation, dimension)
+
+def convert_bin_to_pcd(src, dst):
+    import open3d as o3d  # pylint: disable=import-error
+
+    try:
+        bin = np.fromfile(src, dtype=np.float32).reshape(-1, 4)
+    except ValueError as e:
+        raise Exception(
+            f"Incorrect data in the KITTI 3D pointcloud file: {src}. "
+            f"There was an error while trying to reshape the data into a 4-column matrix: {e}. "
+            "Please ensure that the binary file contains a multiple of 4 elements to be "
+            "successfully reshaped into a (N, 4) array.\n"
+        )
+    points = bin[:, 0:3]
+    intensity = bin[:, -1]
+    intensity_fake_rgb = np.zeros((intensity.shape[0], 3))
+    intensity_fake_rgb[:, 0] = intensity
+    pc = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(points))
+    pc.colors = o3d.utility.Vector3dVector(intensity_fake_rgb)
+    o3d.io.write_point_cloud(dst, pc)
+
+
+def convert_calib_to_image_meta(image_name, static, cam_num):
+    intrinsic_matrix = static.get_intrinsics_matrix(cam_num)
+    extrinsic_matrix = static.get_extrinsic_matrix()
+
+    data = {
+        "name": image_name,
+        "meta": {
+            "deviceId": cam_num,
+            "sensorsData": {
+                "extrinsicMatrix": list(extrinsic_matrix.flatten().astype(float)),
+                "intrinsicMatrix": list(intrinsic_matrix.flatten().astype(float)),
+            },
+        },
+    }
+    return data

supervisely/io/fs.py

@@ -205,15 +205,19 @@ def list_files_recursively(
             for filename in file_names:
                 yield os.path.join(dir_name, filename)
 
-    valid_extensions = valid_extensions if ignore_valid_extensions_case is False else [ext.lower() for ext in valid_extensions]
+    valid_extensions = (
+        valid_extensions
+        if ignore_valid_extensions_case is False
+        else [ext.lower() for ext in valid_extensions]
+    )
     files = []
     for file_path in file_path_generator():
         file_ext = get_file_ext(file_path)
         if ignore_valid_extensions_case:
             file_ext.lower()
-        if (
-            valid_extensions is None or file_ext in valid_extensions
-        ) and (filter_fn is None or filter_fn(file_path)):
+        if (valid_extensions is None or file_ext in valid_extensions) and (
+            filter_fn is None or filter_fn(file_path)
+        ):
             files.append(file_path)
     return files
 
@@ -1558,3 +1562,76 @@ async def touch_async(path: str) -> None:
     async with aiofiles.open(path, "a"):
         loop = get_or_create_event_loop()
         await loop.run_in_executor(None, os.utime, path, None)
+
+
+async def list_files_recursively_async(
+    dir_path: str,
+    valid_extensions: Optional[List[str]] = None,
+    filter_fn: Optional[Callable[[str], bool]] = None,
+    ignore_valid_extensions_case: bool = False,
+) -> List[str]:
+    """
+    Recursively list files in the directory asynchronously.
+    Returns list with all file paths.
+    Can be filtered by valid extensions and filter function.
+
+    :param dir_path: Target directory path.
+    :type dir_path: str
+    :param valid_extensions: List of valid extensions. Default is None.
+    :type valid_extensions: Optional[List[str]]
+    :param filter_fn: Filter function. Default is None.
+    :type filter_fn: Optional[Callable[[str], bool]]
+    :param ignore_valid_extensions_case: Ignore case when checking valid extensions. Default is False.
+    :type ignore_valid_extensions_case: bool
+    :returns: List of file paths
+    :rtype: List[str]
+
+    :Usage example:
+    
+         .. code-block:: python
+    
+            import supervisely as sly
+    
+            dir_path = '/home/admin/work/projects/examples'
+            loop = sly.utils.get_or_create_event_loop()
+            coro = sly.fs.list_files_recursively_async(dir_path)
+            if loop.is_running():
+                future = asyncio.run_coroutine_threadsafe(coro, loop)
+                files = future.result()
+            else:
+                files = loop.run_until_complete(coro)
+    """
+
+    def sync_file_list():
+        if valid_extensions and ignore_valid_extensions_case:
+            valid_extensions_set = set(map(str.lower, valid_extensions))
+        else:
+            valid_extensions_set = set(valid_extensions) if valid_extensions else None
+
+        files = []
+        for dir_name, _, file_names in os.walk(dir_path):
+            full_paths = [os.path.join(dir_name, filename) for filename in file_names]
+
+            if valid_extensions_set:
+                full_paths = [
+                    fp
+                    for fp in full_paths
+                    if (
+                        ext := (
+                            os.path.splitext(fp)[1].lower()
+                            if ignore_valid_extensions_case
+                            else os.path.splitext(fp)[1]
+                        )
+                    )
+                    in valid_extensions_set
+                ]
+
+            if filter_fn:
+                full_paths = [fp for fp in full_paths if filter_fn(fp)]
+
+            files.extend(full_paths)
+
+        return files
+
+    loop = get_or_create_event_loop()
+    return await loop.run_in_executor(None, sync_file_list)

supervisely/nn/inference/inference.py

@@ -1347,6 +1347,7 @@ class Inference:
                 source=images_np,
                 settings=settings,
             )
+            anns = self._exclude_duplicated_predictions(api, anns, settings, dataset_id, ids)
             results.extend(self._format_output(anns, slides_data))
         return results
 
@@ -1395,6 +1396,10 @@ class Inference:
                 )
                 self.cache.set_project_meta(output_project_id, output_project_meta)
 
+            ann = self._exclude_duplicated_predictions(
+                api, anns, settings, ds_info.id, [image_id], output_project_meta
+            )[0]
+
             logger.debug(
                 "Uploading annotation...",
                 extra={
@@ -1404,6 +1409,10 @@ class Inference:
                 },
             )
             api.annotation.upload_ann(image_id, ann)
+        else:
+            ann = self._exclude_duplicated_predictions(
+                api, anns, settings, image_info.dataset_id, [image_id]
+            )[0]
 
         result = self._format_output(anns, slides_data)[0]
         if async_inference_request_uuid is not None and ann is not None:
@@ -1786,6 +1795,15 @@ class Inference:
                 batch_results = []
                 for i, ann in enumerate(anns):
                     image_info: ImageInfo = images_infos_dict[image_ids_batch[i]]
+                    ds_info = dataset_infos_dict[image_info.dataset_id]
+                    meta = output_project_metas_dict.get(ds_info.project_id, None)
+                    iou = settings.get("existing_objects_iou_thresh")
+                    if meta is None and isinstance(iou, float) and iou > 0:
+                        meta = ProjectMeta.from_json(api.project.get_meta(ds_info.project_id))
+                        output_project_metas_dict[ds_info.project_id] = meta
+                    ann = self._exclude_duplicated_predictions(
+                        api, [ann], settings, ds_info.id, [image_info.id], meta
+                    )[0]
                     batch_results.append(
                         {
                             "annotation": ann.to_json(),
@@ -2086,6 +2104,19 @@ class Inference:
                         source=images_nps,
                         settings=settings,
                     )
+                    iou = settings.get("existing_objects_iou_thresh")
+                    if output_project_meta is None and isinstance(iou, float) and iou > 0:
+                        output_project_meta = ProjectMeta.from_json(
+                            api.project.get_meta(project_info.id)
+                        )
+                    anns = self._exclude_duplicated_predictions(
+                        api,
+                        anns,
+                        settings,
+                        dataset_info.id,
+                        [ii.id for ii in images_infos_batch],
+                        output_project_meta,
+                    )
                     batch_results = []
                     for i, ann in enumerate(anns):
                         batch_results.append(
@@ -2935,7 +2966,9 @@ class Inference:
         parser = argparse.ArgumentParser(description="Run Inference Serving")
 
         # Positional args
-        parser.add_argument("mode", nargs="?", type=str, help="Mode of operation: 'deploy' or 'predict'")
+        parser.add_argument(
+            "mode", nargs="?", type=str, help="Mode of operation: 'deploy' or 'predict'"
+        )
         parser.add_argument("input", nargs="?", type=str, help="Local path to input data")
 
         # Deploy args
@@ -3459,6 +3492,127 @@ class Inference:
                 f"Checkpoint {checkpoint_url} not found in Team Files. Cannot set workflow input"
             )
 
+    def _exclude_duplicated_predictions(
+        self,
+        api: Api,
+        pred_anns: List[Annotation],
+        settings: dict,
+        dataset_id: int,
+        gt_image_ids: List[int],
+        meta: Optional[ProjectMeta] = None,
+    ):
+        """
+        Filter out predictions that significantly overlap with ground truth (GT) objects.
+
+        This is a wrapper around the `_filter_duplicated_predictions_from_ann` method that does the following:
+        - Checks inference settings for the IoU threshold (`existing_objects_iou_thresh`)
+        - Gets ProjectMeta object if not provided
+        - Downloads GT annotations for the specified image IDs
+        - Filters out predictions that have an IoU greater than or equal to the specified threshold with any GT object
+
+        :param api: Supervisely API object
+        :type api: Api
+        :param pred_anns: List of Annotation objects containing predictions
+        :type pred_anns: List[Annotation]
+        :param settings: Inference settings
+        :type settings: dict
+        :param dataset_id: ID of the dataset containing the images
+        :type dataset_id: int
+        :param gt_image_ids: List of image IDs to filter predictions. All images should belong to the same dataset
+        :type gt_image_ids: List[int]
+        :param meta: ProjectMeta object
+        :type meta: Optional[ProjectMeta]
+        :return: List of Annotation objects containing filtered predictions
+        :rtype: List[Annotation]
+
+        Notes:
+        ------
+        - Requires PyTorch and torchvision for IoU calculations
+        - This method is useful for identifying new objects that aren't already annotated in the ground truth
+        """
+        iou = settings.get("existing_objects_iou_thresh")
+        if isinstance(iou, float) and 0 < iou <= 1:
+            if meta is None:
+                ds = api.dataset.get_info_by_id(dataset_id)
+                meta = ProjectMeta.from_json(api.project.get_meta(ds.project_id))
+            gt_anns = api.annotation.download_json_batch(dataset_id, gt_image_ids)
+            gt_anns = [Annotation.from_json(ann, meta) for ann in gt_anns]
+            for i in range(0, len(pred_anns)):
+                before = len(pred_anns[i].labels)
+                with Timer() as timer:
+                    pred_anns[i] = self._filter_duplicated_predictions_from_ann(
+                        gt_anns[i], pred_anns[i], iou
+                    )
+                after = len(pred_anns[i].labels)
+                logger.debug(
+                    f"{[i]}: applied NMS with IoU={iou}. Before: {before}, After: {after}. Time: {timer.get_time():.3f}ms"
+                )
+        return pred_anns
+
+    def _filter_duplicated_predictions_from_ann(
+        self, gt_ann: Annotation, pred_ann: Annotation, iou_threshold: float
+    ) -> Annotation:
+        """
+        Filter out predictions that significantly overlap with ground truth annotations.
+
+        This function compares each prediction with ground truth annotations of the same class
+        and removes predictions that have an IoU (Intersection over Union) greater than or equal
+        to the specified threshold with any ground truth annotation. This is useful for identifying
+        new objects that aren't already annotated in the ground truth.
+
+        :param gt_ann: Annotation object containing ground truth labels
+        :type gt_ann: Annotation
+        :param pred_ann: Annotation object containing prediction labels to be filtered
+        :type pred_ann: Annotation
+        :param iou_threshold:   IoU threshold (0.0-1.0). Predictions with IoU >= threshold with any
+                                ground truth box of the same class will be removed
+        :type iou_threshold: float
+        :return: A new annotation object containing only predictions that don't significantly
+                 overlap with ground truth annotations
+        :rtype: Annotation
+
+
+        Notes:
+        ------
+        - Predictions with classes not present in ground truth will be kept
+        - Requires PyTorch and torchvision for IoU calculations
+        """
+
+        try:
+            import torch
+            from torchvision.ops import box_iou
+
+        except ImportError:
+            raise ImportError("Please install PyTorch and torchvision to use this feature.")
+
+        def _to_tensor(geom):
+            return torch.tensor([geom.left, geom.top, geom.right, geom.bottom]).float()
+
+        new_labels = []
+        pred_cls_bboxes = defaultdict(list)
+        for label in pred_ann.labels:
+            pred_cls_bboxes[label.obj_class.name].append(label)
+
+        gt_cls_bboxes = defaultdict(list)
+        for label in gt_ann.labels:
+            if label.obj_class.name not in pred_cls_bboxes:
+                continue
+            gt_cls_bboxes[label.obj_class.name].append(label)
+
+        for name, pred in pred_cls_bboxes.items():
+            gt = gt_cls_bboxes[name]
+            if len(gt) == 0:
+                new_labels.extend(pred)
+                continue
+            pred_bboxes = torch.stack([_to_tensor(l.geometry.to_bbox()) for l in pred]).float()
+            gt_bboxes = torch.stack([_to_tensor(l.geometry.to_bbox()) for l in gt]).float()
+            iou_matrix = box_iou(pred_bboxes, gt_bboxes)
+            iou_matrix = iou_matrix.cpu().numpy()
+            keep_indices = np.where(np.all(iou_matrix < iou_threshold, axis=1))[0]
+            new_labels.extend([pred[i] for i in keep_indices])
+
+        return pred_ann.clone(labels=new_labels)
+
 
 def _get_log_extra_for_inference_request(inference_request_uuid, inference_request: dict):
     log_extra = {