supervisely 6.73.281__tar.gz → 6.73.283__tar.gz

{supervisely-6.73.281/supervisely.egg-info → supervisely-6.73.283}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.281
+Version: 6.73.283
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/base_converter.py

@@ -168,6 +168,7 @@ class BaseConverter:
         self._upload_as_links: bool = upload_as_links
         self._remote_files_map: Optional[Dict[str, str]] = remote_files_map
         self._supports_links = False  # if converter supports uploading by links
+        self._force_shape_for_links = False
         self._api = Api.from_env() if self._upload_as_links else None
         self._team_id = team_id() if self._upload_as_links else None
         self._converter = None

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/cityscapes/cityscapes_converter.py

@@ -34,6 +34,8 @@ class CityscapesConverter(ImageConverter):
         super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
 
         self._classes_mapping = {}
+        self._supports_links = True
+        self._force_shape_for_links = self.upload_as_links
 
     def __str__(self):
         return AvailableImageConverters.CITYSCAPES
@@ -41,6 +43,10 @@ class CityscapesConverter(ImageConverter):
     @property
     def key_file_ext(self) -> str:
         return ".json"
+    
+    @property
+    def ann_ext(self) -> str:
+        return ".json"
 
     def ann_file_ext(self) -> str:
         return ".json"
@@ -108,6 +114,8 @@ class CityscapesConverter(ImageConverter):
             return False
 
     def validate_format(self) -> bool:
+        if self.upload_as_links:
+            self._download_remote_ann_files()
         detected_ann_cnt = 0
         images_list, ann_dict = [], {}
         for root, _, files in os.walk(self._input_data):

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/coco/coco_anntotation_converter.py

@@ -37,6 +37,7 @@ class FastCOCOConverter(COCOConverter, ImageConverter):
         self._items = []
         meta = ProjectMeta()
         warnings = defaultdict(list)
+        item_names = set()
         for ann_path in ann_paths:
             try:
                 with coco_helper.HiddenCocoPrints():
@@ -74,11 +75,18 @@ class FastCOCOConverter(COCOConverter, ImageConverter):
                 coco_ann = coco_anns[image_id]
                 if len(coco_ann) == 0 or coco_ann is None or image_name is None:
                     continue
+                if image_name in item_names:
+                    # * Block to handle the case when there are mixed annotations: caption and segmentations for the same images
+                    item = next(item for item in self._items if item.name == image_name)
+                    if item.shape == (height, width):
+                        item.ann_data.extend(coco_ann)
+                        continue
                 item = self.Item(image_name) if image_url is None else self.Item(image_url)
                 item.name = image_name
                 item.ann_data = coco_ann
                 item.set_shape((height, width))
                 self._items.append(item)
+                item_names.add(image_name)
                 detected_ann_cnt += len(coco_ann)
 
         self._meta = meta

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/coco/coco_converter.py

@@ -25,6 +25,8 @@ class COCOConverter(ImageConverter):
         super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
 
         self._coco_categories = []
+        self._supports_links = True
+        self._force_shape_for_links = self.upload_as_links
 
     def __str__(self) -> str:
         return AvailableImageConverters.COCO
@@ -56,6 +58,8 @@ class COCOConverter(ImageConverter):
     def validate_format(self) -> bool:
         from pycocotools.coco import COCO  # pylint: disable=import-error
 
+        if self.upload_as_links:
+            self._download_remote_ann_files()
         detected_ann_cnt = 0
         images_list, ann_paths = [], []
         for root, _, files in os.walk(self._input_data):
@@ -145,7 +149,8 @@ class COCOConverter(ImageConverter):
         if item.ann_data is None:
             return Annotation.from_img_path(item.path)
         else:
-            item.set_shape()
+            if not self.upload_as_links:
+                item.set_shape()
             ann = coco_helper.create_supervisely_annotation(
                 item,
                 meta,

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/coco/coco_helper.py

@@ -182,7 +182,7 @@ def convert_rle_mask_to_polygon(coco_ann):
     return Bitmap(mask).to_contours()
 
 
-def convert_polygon_vertices(coco_ann, image_size):
+def convert_polygon_vertices(coco_ann, image_size: Tuple[int, int]):
     polygons = coco_ann["segmentation"]
     if all(type(coord) is float for coord in polygons):
         polygons = [polygons]

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/image_converter.py

@@ -136,20 +136,16 @@ class ImageConverter(BaseConverter):
             item_names = []
             item_paths = []
             item_metas = []
-            anns = []
             for item in batch:
                 item.path = self.validate_image(item.path)
                 if item.path is None:
                     continue  # image has failed validation
-                item.name = f"{get_file_name(item.path)}{get_file_ext(item.path).lower()}"
-                if self.upload_as_links and not self.supports_links:
-                    ann = None
-                else:
-                    ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
-                name = generate_free_name(
-                    existing_names, item.name, with_ext=True, extend_used_names=True
+                name = f"{get_file_name(item.path)}{get_file_ext(item.path).lower()}"
+
+                item.name = generate_free_name(
+                    existing_names, name, with_ext=True, extend_used_names=True
                 )
-                item_names.append(name)
+                item_names.append(item.name)
                 item_paths.append(item.path)
 
                 if isinstance(item.meta, str):  # path to file
@@ -159,9 +155,6 @@ class ImageConverter(BaseConverter):
                 else:
                     item_metas.append({})
 
-                if ann is not None:
-                    anns.append(ann)
-
             with ApiContext(
                 api=api, project_id=project_id, dataset_id=dataset_id, project_meta=meta
             ):
@@ -173,7 +166,7 @@ class ImageConverter(BaseConverter):
                         metas=item_metas,
                         batch_size=batch_size,
                         conflict_resolution="rename",
-                        force_metadata_for_links=False,
+                        force_metadata_for_links=self._force_shape_for_links,
                     )
                 else:
                     img_infos = api.image.upload_paths(
@@ -183,8 +176,15 @@ class ImageConverter(BaseConverter):
                         metas=item_metas,
                         conflict_resolution="rename",
                     )
-
                 img_ids = [img_info.id for img_info in img_infos]
+
+                anns = []
+                if not (self.upload_as_links and not self.supports_links):
+                    for info, item in zip(img_infos, batch):
+                        if self._force_shape_for_links:
+                            item.set_shape((info.height, info.width))
+                        anns.append(self.to_supervisely(item, meta, renamed_classes, renamed_tags))
+
                 if len(anns) == len(img_ids):
                     api.annotation.upload_anns(
                         img_ids, anns, skip_bounds_validation=self.upload_as_links

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/multi_view/multi_view.py

@@ -1,6 +1,6 @@
 import os
 from collections import defaultdict
-from typing import Dict, Union
+from typing import Dict, Union, Optional
 
 from supervisely import ProjectMeta, generate_free_name, is_development, logger
 from supervisely.api.api import Api, ApiContext
@@ -13,6 +13,18 @@ from supervisely.project.project_settings import LabelingInterface
 
 class MultiViewImageConverter(ImageConverter):
 
+    def __init__(
+            self,
+            input_data: str,
+            labeling_interface: Optional[Union[LabelingInterface, str]],
+            upload_as_links: bool,
+            remote_files_map: Optional[Dict[str, str]] = None,
+    ):
+        super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
+
+        self._supports_links = True
+        self._force_shape_for_links = self.upload_as_links
+
     def __str__(self):
         return AvailableImageConverters.MULTI_VIEW
 
@@ -79,13 +91,16 @@ class MultiViewImageConverter(ImageConverter):
                     logger.warn(f"Image '{name}' already exists. Renamed to '{new_name}'.")
                     os.rename(image, os.path.join(group_path, new_name))
                     image = os.path.join(group_path, new_name)
+                if self._upload_as_links:
+                    image = self.remote_files_map.get(image, image)
                 images.append(image)
 
             with ApiContext(
                 api=api, project_id=project_id, dataset_id=dataset_id, project_meta=meta
             ):
+                kwarg = {"links": images} if self.upload_as_links else {"paths": images}
                 api.image.upload_multiview_images(
-                    dataset.id, group_name, images, progress_cb=progress_cb
+                    dataset.id, group_name, **kwarg, progress_cb=progress_cb
                 )
 
         if log_progress:

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/image/yolo/yolo_converter.py

@@ -38,6 +38,8 @@ class YOLOConverter(ImageConverter):
         self._coco_classes_dict: dict = {}
         self._num_kpts = None
         self._num_dims = None
+        self._supports_links = True
+        self._force_shape_for_links = self.upload_as_links
 
     def __str__(self) -> str:
         return AvailableImageConverters.YOLO
@@ -151,6 +153,9 @@ class YOLOConverter(ImageConverter):
             return False
 
     def validate_format(self) -> bool:
+        if self.upload_as_links:
+            self._download_remote_ann_files()
+
         detected_ann_cnt = 0
         config_path = None
         images_list, ann_dict = [], {}
@@ -238,7 +243,8 @@ class YOLOConverter(ImageConverter):
 
         try:
             labels = []
-            item.set_shape()
+            if not self.upload_as_links:
+                item.set_shape()
             height, width = item.shape
             with open(item.ann_data, "r") as ann_file:
                 lines = ann_file.readlines()

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/pointcloud_episodes/nuscenes_conv/nuscenes_converter.py

@@ -61,35 +61,27 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
             return False
 
         def filter_fn(path):
-            return all(
-                [
-                    (Path(path) / name).exists()
-                    for name in ["maps", "samples", "sweeps", "v1.0-mini"]
-                ]
-            )
+            return all([(Path(path) / name).exists() for name in ["maps", "samples"]])
 
-        try:
-            input_path = [d for d in fs.dirs_filter(self._input_data, filter_fn)].pop()
-        except IndexError:
+        input_path = next((d for d in fs.dirs_filter(self._input_data, filter_fn)), None)
+        if input_path is None:
             return False
 
         sample_dir = input_path + "/samples/"
         if any([not fs.dir_exists(f"{sample_dir}/{d}") for d in helpers.DIR_NAMES]):
             return False
 
-        sweeps_dir = input_path + "/sweeps/"
-        if any([not fs.dir_exists(f"{sweeps_dir}/{d}") for d in helpers.DIR_NAMES]):
-            return False
-
-        ann_dir = input_path + "/v1.0-mini/"
-        if any([not fs.file_exists(f"{ann_dir}/{d}.json") for d in helpers.TABLE_NAMES]):
+        fil_fn = lambda p: all(fs.file_exists(f"{p}/{name}.json") for name in helpers.TABLE_NAMES)
+        ann_dir = next((d for d in fs.dirs_filter(input_path, fil_fn)), None)
+        if ann_dir is None:
             return False
 
+        version = osp.basename(ann_dir)
         try:
             t = TinyTimer()
-            nuscenes = NuScenes(dataroot=input_path, verbose=False)
+            nuscenes = NuScenes(version=version, dataroot=input_path, verbose=False)
             self._nuscenes: NuScenes = nuscenes
-            logger.info(f"NuScenes initialization took {t.get_sec():.3f} sec")
+            logger.debug(f"NuScenes initialization took {t.get_sec():.3f} sec")
         except Exception as e:
             logger.debug(f"Failed to initialize NuScenes: {e}")
             return False
@@ -184,7 +176,9 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
             scene_name_to_dataset[scene_names[0]] = dataset_info
 
         if log_progress:
-            progress, progress_cb = self.get_progress(total_sample_cnt, "Converting episode scenes...")
+            progress, progress_cb = self.get_progress(
+                total_sample_cnt, "Converting episode scenes..."
+            )
         else:
             progress_cb = None
 

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/convert/pointcloud_episodes/nuscenes_conv/nuscenes_helper.py

@@ -16,11 +16,11 @@ DIR_NAMES = [
     "CAM_FRONT_LEFT",
     "CAM_FRONT_RIGHT",
     "LIDAR_TOP",
-    "RADAR_FRONT",
-    "RADAR_FRONT_LEFT",
-    "RADAR_FRONT_RIGHT",
-    "RADAR_BACK_LEFT",
-    "RADAR_BACK_RIGHT",
+    # "RADAR_FRONT",
+    # "RADAR_FRONT_LEFT",
+    # "RADAR_FRONT_RIGHT",
+    # "RADAR_BACK_LEFT",
+    # "RADAR_BACK_RIGHT",
 ]
 
 TABLE_NAMES = [

{supervisely-6.73.281 → supervisely-6.73.283}/supervisely/geometry/cuboid_2d.py

@@ -8,6 +8,13 @@ from typing import Dict, List, Optional, Union
 
 import numpy as np
 
+from supervisely.geometry.constants import (
+    CLASS_ID,
+    CREATED_AT,
+    ID,
+    LABELER_LOGIN,
+    UPDATED_AT,
+)
 from supervisely.geometry.geometry import Geometry
 from supervisely.geometry.graph import EDGES, GraphNodes, Node, _maybe_transform_colors
 from supervisely.geometry.point_location import PointLocation
@@ -36,19 +43,19 @@ CUBOID2D_EDGES_MAPPING = [
 
 class Cuboid2d(GraphNodes):
     """
-    GraphNodes geometry for a single :class:`Label<supervisely.annotation.label.Label>`. :class:`GraphNodes<GraphNodes>` class object is immutable.
+    Cuboid2d geometry for a single :class:`Label<supervisely.annotation.label.Label>`. :class:`Cuboid2d<Cuboid2d>` class object is immutable.
 
     :param nodes: Dict or List containing nodes of graph
     :type nodes: dict
-    :param sly_id: GraphNodes ID in Supervisely server.
+    :param sly_id: Cuboid2d ID in Supervisely server.
     :type sly_id: int, optional
-    :param class_id: ID of :class:`ObjClass<supervisely.annotation.obj_class.ObjClass>` to which GraphNodes belongs.
+    :param class_id: ID of :class:`ObjClass<supervisely.annotation.obj_class.ObjClass>` to which Cuboid2d belongs.
     :type class_id: int, optional
-    :param labeler_login: Login of the user who created GraphNodes.
+    :param labeler_login: Login of the user who created Cuboid2d.
     :type labeler_login: str, optional
-    :param updated_at: Date and Time when GraphNodes was modified last. Date Format: Year:Month:Day:Hour:Minute:Seconds. Example: '2021-01-22T19:37:50.158Z'.
+    :param updated_at: Date and Time when Cuboid2d was modified last. Date Format: Year:Month:Day:Hour:Minute:Seconds. Example: '2021-01-22T19:37:50.158Z'.
     :type updated_at: str, optional
-    :param created_at: Date and Time when GraphNodes was created. Date Format is the same as in "updated_at" parameter.
+    :param created_at: Date and Time when Cuboid2d was created. Date Format is the same as in "updated_at" parameter.
     :type created_at: str, optional
 
     :Usage example:
@@ -56,13 +63,13 @@ class Cuboid2d(GraphNodes):
      .. code-block:: python
 
         import supervisely as sly
-        from supervisely.geometry.graph import Node, GraphNodes
+        from supervisely.geometry.graph import Node, Cuboid2d
 
         vertex_1 = Node(sly.PointLocation(5, 5))
         vertex_2 = Node(sly.PointLocation(100, 100))
         vertex_3 = Node(sly.PointLocation(200, 250))
         nodes = {0: vertex_1, 1: vertex_2, 2: vertex_3}
-        figure = GraphNodes(nodes)
+        figure = Cuboid2d(nodes)
     """
 
     items_json_field = VERTICES
@@ -79,6 +86,9 @@ class Cuboid2d(GraphNodes):
         labeler_login: Optional[int] = None,
         updated_at: Optional[str] = None,
         created_at: Optional[str] = None,
+        position: Optional[Dict] = None,
+        rotation: Optional[Dict] = None,
+        dimensions: Optional[Dict] = None,
     ):
         super().__init__(
             nodes=nodes,
@@ -88,6 +98,9 @@ class Cuboid2d(GraphNodes):
             updated_at=updated_at,
             created_at=created_at,
         )
+        self._position = position
+        self._rotation = rotation
+        self._dimensions = dimensions
 
         if len(self._nodes) != 8:
             raise ValueError("Cuboid2d must have exactly 8 vertices")
@@ -98,10 +111,169 @@ class Cuboid2d(GraphNodes):
         Copy of Cuboid2d vertices.
 
         :return: Cuboid2d vertices
-        :rtype: :class:`dict`
+        :rtype: Optional[Dict]
         """
         return self.nodes
 
+    @property
+    def position(self) -> Optional[Dict]:
+        """
+        Copy of the position of the Cuboid2d.
+
+        :return: Position of the Cuboid2d
+        :rtype: Optional[Dict]
+        """
+        if isinstance(self._position, dict):
+            return self._position.copy()
+
+    @property
+    def rotation(self) -> Optional[Dict]:
+        """
+        Copy of the rotation of the Cuboid2d.
+
+        :return: Rotation of the Cuboid2d
+        :rtype: Optional[Dict]
+        """
+        if isinstance(self._rotation, dict):
+            return self._rotation.copy()
+
+    @property
+    def dimensions(self) -> Optional[Dict]:
+        """
+        Copy of the dimensions of the Cuboid2d.
+
+        :return: Dimensions of the Cuboid2d
+        :rtype: :class:`dict`
+        """
+        if isinstance(self._dimensions, dict):
+            return self._dimensions.copy()
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Dict]) -> Cuboid2d:
+        """
+        Convert a json dict to Cuboid2d. Read more about `Supervisely format <https://docs.supervise.ly/data-organization/00_ann_format_navi>`_.
+
+        :param data: Cuboid2d in json format as a dict.
+        :type data: Dict[str, Dict]
+        :return: Cuboid2d object
+        :rtype: :class:`Cuboid2d<Cuboid2d>`
+        :Usage example:
+
+         .. code-block:: python
+
+            figure_json = {
+                "vertices": {
+                    "0": {
+                        "loc": [5, 5]
+                    },
+                    "1": {
+                        "loc": [100, 100]
+                    },
+                    "2": {
+                        "loc": [250, 200]
+                    },
+                    "position": {
+                        "x": 0.0657651107620552,
+                        "y": -0.05634319555373257,
+                        "z": 0.7267282757573887
+                    },
+                    "rotation": { "x": 0, "y": 0, "z": 0 },
+                    "dimensions": {
+                        "x": 0.1425456564648202,
+                        "y": 0.1,
+                        "z": 0.36738880874660756
+                    }
+                }
+            }
+            from supervisely.geometry.graph import Cuboid2d
+            figure = Cuboid2d.from_json(figure_json)
+        """
+        nodes = {
+            node_id: Node.from_json(node_json)
+            for node_id, node_json in data[cls.items_json_field].items()
+        }
+        labeler_login = data.get(LABELER_LOGIN, None)
+        updated_at = data.get(UPDATED_AT, None)
+        created_at = data.get(CREATED_AT, None)
+        sly_id = data.get(ID, None)
+        class_id = data.get(CLASS_ID, None)
+        position = data.get("position", None)
+        rotation = data.get("rotation", None)
+        dimensions = data.get("dimensions", None)
+        return cls(
+            nodes=nodes,
+            sly_id=sly_id,
+            class_id=class_id,
+            labeler_login=labeler_login,
+            updated_at=updated_at,
+            created_at=created_at,
+            position=position,
+            rotation=rotation,
+            dimensions=dimensions,
+        )
+
+    def to_json(self) -> Dict[str, Dict]:
+        """
+        Convert the Cuboid2d to list. Read more about `Supervisely format <https://docs.supervise.ly/data-organization/00_ann_format_navi>`_.
+
+        :return: Json format as a dict
+        :rtype: Dict[str, Dict]
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+            from supervisely.geometry.graph import Node, Cuboid2d
+
+            vertex_1 = Node(sly.PointLocation(5, 5))
+            vertex_2 = Node(sly.PointLocation(100, 100))
+            vertex_3 = Node(sly.PointLocation(200, 250))
+            nodes = {0: vertex_1, 1: vertex_2, 2: vertex_3}
+            figure = Cuboid2d(nodes)
+
+            figure_json = figure.to_json()
+            print(figure_json)
+            # Output: {
+            #    "nodes": {
+            #        "0": {
+            #            "loc": [5, 5]
+            #        },
+            #        "1": {
+            #            "loc": [100, 100]
+            #        },
+            #        "2": {
+            #            "loc": [250, 200]
+            #        }
+            #    },
+            #    "position": {
+            #         "x": 0.0657651107620552,
+            #         "y": -0.05634319555373257,
+            #         "z": 0.7267282757573887
+            #     },
+            #     "rotation": { "x": 0, "y": 0, "z": 0 },
+            #     "dimensions": {
+            #         "x": 0.1425456564648202,
+            #         "y": 0.1,
+            #         "z": 0.36738880874660756
+            #     }
+
+            # }
+        """
+        res = {
+            self.items_json_field: {
+                node_id: node.to_json() for node_id, node in self._nodes.items()
+            }
+        }
+        if self._position is not None:
+            res["position"] = self._position
+        if self._rotation is not None:
+            res["rotation"] = self._rotation
+        if self._dimensions is not None:
+            res["dimensions"] = self._dimensions
+
+        self._add_creation_info(res)
+        return res
+
     def validate(self, name: str, settings: Dict) -> None:
         """
         Checks the graph for correctness and compliance with the template
@@ -184,7 +356,7 @@ class Cuboid2dTemplate(Cuboid2d, Geometry):
         """
         config = {VERTICES: {}, EDGES: []}
 
-        x = y = w = h = s = 1 # sample values only for config creation
+        x = y = w = h = s = 1  # sample values only for config creation
         base_vertices = [(x, y), (x + w, y), (x + w, y + h), (x, y + h)]
         shifted_vertices = [(vx + s, vy + s) for vx, vy in base_vertices]
         verices_coords = base_vertices + shifted_vertices

{supervisely-6.73.281 → supervisely-6.73.283/supervisely.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.281
+Version: 6.73.283
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely