supervisely 6.73.452__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/convert/image/image_helper.py

@@ -1,12 +1,14 @@
 import mimetypes
+import re
 from pathlib import Path
+from typing import List, Union
 
 import magic
 import numpy as np
 from PIL import Image
-from typing import Union, List
 
-from supervisely import Rectangle, Label, logger
+from supervisely import Label, Rectangle, logger
+from supervisely.geometry.oriented_bbox import OrientedBBox
 from supervisely.imaging.image import read, write
 from supervisely.io.fs import (
     get_file_ext,
@@ -88,7 +90,14 @@ def read_tiff_image(path: str) -> Union[np.ndarray, None]:
     import tifffile
 
     logger.debug(f"Found tiff file: {path}.")
-    image = tifffile.imread(path)
+    try:
+        image = tifffile.imread(path)
+    except Exception as e:
+        logger.warning(
+            f"tifffile failed to read TIFF, trying Pillow fallback: {repr(e)}",
+            extra={"file_path": path},
+        )
+        image = _read_tiff_image_fallback(path)
     name = get_file_name_with_ext(path)
     if image is not None:
         tiff_shape = image.shape
@@ -100,11 +109,46 @@ def read_tiff_image(path: str) -> Union[np.ndarray, None]:
     return image
 
 
+def _read_tiff_image_fallback(path: str) -> Union[np.ndarray, None]:
+    """
+    Fallback method to read tiff image using Pillow.
+    """
+    from PIL import ImageSequence
+
+    try:
+        with Image.open(path) as pil_img:
+            frames = [np.asarray(frame) for frame in ImageSequence.Iterator(pil_img)]
+        if not frames:
+            return None
+        if len(frames) == 1:
+            return frames[0]
+
+        if all(frame.shape == frames[0].shape for frame in frames):
+            return np.stack(frames, axis=0)
+
+        logger.warning(
+            "TIFF has multiple pages with different shapes; using the first page only.",
+            extra={"file_path": path},
+        )
+        return frames[0]
+    except Exception as e:
+        logger.warning(
+            f"Pillow failed to read TIFF: {repr(e)}",
+            extra={"file_path": path},
+        )
+        return None
+
+
 def validate_image_bounds(labels: List[Label], img_rect: Rectangle) -> List[Label]:
     """
     Check if labels are localed inside the image canvas, print a warning and skip them if not.
     """
-    new_labels = [label for label in labels if img_rect.contains(label.geometry.to_bbox())]
+    new_labels = []
+    for label in labels:
+        if isinstance(label.geometry, OrientedBBox):
+            new_labels.append(label)
+        elif img_rect.contains(label.geometry.to_bbox()):
+            new_labels.append(label)
     if new_labels != labels:
         logger.warning(
             f"{len(labels) - len(new_labels)} annotation objects are out of image bounds. Skipping..."

supervisely/convert/image/label_studio/label_studio_converter.py

@@ -31,6 +31,8 @@ class LabelStudioConverter(ImageConverter):
             return False
         if len(raw_ann) == 0:
             return False
+        if not all([isinstance(ann, dict) for ann in raw_ann]):
+            return False
         if not all([isinstance(ann.get("data"), dict) for ann in raw_ann]):
             return False
         anns = []

supervisely/convert/image/medical2d/medical2d_helper.py

@@ -8,10 +8,9 @@ import nrrd
 import numpy as np
 import pydicom
 from pydicom import FileDataset
-from tqdm import tqdm
-
 from supervisely import image, logger, volume
 from supervisely.annotation.tag import Tag
+from supervisely.convert.volume.dicom.dicom_helper import convert_to_monochrome2
 from supervisely.io.fs import (
     dir_exists,
     get_file_ext,
@@ -19,6 +18,7 @@ from supervisely.io.fs import (
     get_file_name_with_ext,
     mkdir,
 )
+from tqdm import tqdm
 
 _MEDICAL_DEFAULT_GROUP_TAG_NAMES = [
     "StudyInstanceUID",
@@ -135,28 +135,6 @@ def create_pixel_data_set(dcm: FileDataset, frame_axis: int) -> Tuple[List[np.nd
     list_of_images = np.split(pixel_array, int(dcm.NumberOfFrames), axis=frame_axis)
     return list_of_images, frame_axis
 
-def convert_to_monochrome2(dcm_path: str, dcm: FileDataset) -> FileDataset:
-    if getattr(dcm, "PhotometricInterpretation", None) == "YBR_FULL_422":
-        # * Convert dicom to monochrome
-        if len(dcm.pixel_array.shape) == 4 and dcm.pixel_array.shape[-1] == 3:
-            monochrome = dcm.pixel_array[..., 0].astype(np.uint8)
-        else:
-            logger.warn("Unexpected shape for YBR_FULL_422 data: " + str(dcm.pixel_array.shape))
-
-        try:
-            dcm.SamplesPerPixel = 1
-            dcm.PhotometricInterpretation = "MONOCHROME2"
-            dcm.PlanarConfiguration = 0
-            if len(monochrome.shape) == 3:
-                dcm.NumberOfFrames = str(monochrome.shape[0])
-                dcm.Rows, dcm.Columns = monochrome.shape[1:3]
-            dcm.PixelData = monochrome.tobytes()
-        except AttributeError as ae:
-            logger.error(f"Error occurred while converting dicom to monochrome: {ae}")
-
-        logger.info("Rewriting DICOM file with monochrome2 format")
-        dcm.save_as(dcm_path)
-    return dcm
 
 def convert_dcm_to_nrrd(
     image_path: str, converted_dir: str, group_tag_name: Optional[list] = None

supervisely/convert/image/multispectral/multispectral_converter.py

@@ -132,4 +132,10 @@ class MultiSpectralImageConverter(ImageConverter):
             logger.warning(f"Failed to read image {file_path}.")
             return
 
+        # Handle single-channel images (grayscale)
+        if len(image.shape) == 2:
+            logger.debug(f"Image {file_path} has single channel.")
+            return [image]
+        
+        # Handle multi-channel images
         return [image[:, :, i] for i in range(image.shape[2])]

supervisely/convert/image/pascal_voc/pascal_voc_converter.py

@@ -180,11 +180,14 @@ class PascalVOCConverter(ImageConverter):
             if tag_meta is not None:
                 continue
             if tag_name in pascal_voc_helper.DEFAULT_SUBCLASSES:
-                if values.difference({"0", "1"}):
-                    logger.warning(
-                        f"Tag '{tag_name}' has non-binary values.", extra={"values": values}
-                    )
-                tag_meta = TagMeta(tag_name, TagValueType.NONE)
+                if tag_name == "pose":
+                    tag_meta = TagMeta(tag_name, TagValueType.ANY_STRING)
+                else:
+                    if values.difference({"0", "1"}):
+                        logger.warning(
+                            f"Tag '{tag_name}' has non-binary values.", extra={"values": values}
+                        )
+                    tag_meta = TagMeta(tag_name, TagValueType.NONE)
             elif tag_name in object_class_names:
                 tag_meta = TagMeta(
                     tag_name,

supervisely/convert/image/pascal_voc/pascal_voc_helper.py

@@ -231,11 +231,18 @@ def xml_to_sly_labels(
                 if tag_meta is None:
                     logger.warning(f"Tag meta for '{field_name}' is not found in meta. Skipping.")
                     continue
+
                 if tag_meta.value_type == TagValueType.ANY_STRING:
                     if not isinstance(value, str):
                         value = str(value)
                     tags.append(Tag(tag_meta, value))
                 elif tag_meta.value_type == TagValueType.NONE:
+                    # check if value is numeric
+                    try:
+                        int(value)
+                    except ValueError:
+                        logger.warning(f"Tag value is not numeric: '{value}'. Skipping.")
+                        continue
                     if int(value) == 1:
                         tags.append(Tag(tag_meta))
                     else:

supervisely/convert/pointcloud/kitti_3d/kitti_3d_converter.py

@@ -1,5 +1,6 @@
 import os
 from pathlib import Path
+from typing import Optional
 
 from supervisely import PointcloudAnnotation, ProjectMeta, is_development, logger
 from supervisely.api.api import Api, ApiField
@@ -28,12 +29,32 @@ class KITTI3DConverter(PointcloudConverter):
     def key_file_ext(self) -> str:
         return ".bin"
 
+    @property
+    def ann_ext(self) -> str:
+        return ".txt"
+
     def validate_format(self) -> bool:
+        def _calib_file_filter_fn(file_path):
+            return get_file_ext(file_path).lower() == self.ann_ext
+
         def _file_filter_fn(file_path):
             return get_file_ext(file_path).lower() == self.key_file_ext
 
         def _dir_filter_fn(path):
-            return all([(Path(path) / name).exists() for name in kitti_3d_helper.FOLDER_NAMES])
+            return all(
+                [_resolve_dir(path, name) is not None for name in kitti_3d_helper.FOLDER_NAMES]
+            )
+
+        def _resolve_dir(base_dir: str, expected_name: str) -> Optional[str]:
+            prefix = expected_name.split("_")[0]
+            exact_path = os.path.join(base_dir, expected_name)
+            if os.path.isdir(exact_path):
+                return exact_path
+            for entry in sorted(os.listdir(base_dir)):
+                candidate = os.path.join(base_dir, entry)
+                if entry.lower().startswith(prefix) and os.path.isdir(candidate):
+                    return candidate
+            return None
 
         input_paths = [d for d in dirs_filter(self._input_data, _dir_filter_fn)]
         if len(input_paths) == 0:
@@ -41,15 +62,22 @@ class KITTI3DConverter(PointcloudConverter):
 
         input_path = input_paths[0]
         velodyne_dir = os.path.join(input_path, "velodyne")
-        image_2_dir = os.path.join(input_path, "image_2")
-        label_2_dir = os.path.join(input_path, "label_2")
+        image_2_dir = _resolve_dir(input_path, "image_2")
+        label_2_dir = _resolve_dir(input_path, "label_2")
         calib_dir = os.path.join(input_path, "calib")
 
         self._items = []
+
         velodyne_files = list_files(velodyne_dir, filter_fn=_file_filter_fn)
         if len(velodyne_files) == 0:
             return False
 
+        calib_files = list_files(calib_dir, filter_fn=_calib_file_filter_fn)
+        if len(calib_files) == 0:
+            raise RuntimeError(
+                f"Calibration directory '{calib_dir}' does not contain any .txt files, which are required for KITTI 3D format."
+            )
+
         kitti_labels = []
         for velodyne_path in velodyne_files:
             file_name = get_file_name(velodyne_path)
@@ -67,6 +95,8 @@ class KITTI3DConverter(PointcloudConverter):
                 continue
 
             label = kitti_3d_helper.read_kitti_label(label_path, calib_path)
+            if label is None:
+                continue
             kitti_labels.append(label)
             self._items.append(self.Item(velodyne_path, label, (image_path, calib_path)))
 

supervisely/convert/pointcloud/kitti_3d/kitti_3d_helper.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from supervisely import ObjClass, ObjClassCollection, ProjectMeta
+from supervisely import ObjClass, ObjClassCollection, ProjectMeta, logger
 from supervisely.geometry.cuboid_3d import Cuboid3d
 from supervisely.geometry.point_3d import Vector3d
 from supervisely.pointcloud_annotation.pointcloud_figure import PointcloudFigure
@@ -10,11 +10,18 @@ FOLDER_NAMES = ["velodyne", "image_2", "label_2", "calib"]
 
 
 def read_kitti_label(label_path, calib_path):
-    import open3d as o3d  # pylint: disable=import-error
+    """
+    Read KITTI label file with calibration.
+    """
 
-    calib = o3d.ml.datasets.KITTI.read_calib(calib_path)
-    label = o3d.ml.datasets.KITTI.read_label(label_path, calib)
-    return label
+    import open3d as o3d  # pylint: disable=import-error
+    try:
+        calib = o3d.ml.datasets.KITTI.read_calib(calib_path)
+        label = o3d.ml.datasets.KITTI.read_label(label_path, calib)
+        return label
+    except Exception as e:
+        logger.warning(f"Failed to read KITTI label or calibration: {e}")
+        return None
 
 
 def convert_labels_to_meta(labels):

supervisely/convert/pointcloud/las/las_converter.py

@@ -26,12 +26,24 @@ class LasConverter(PointcloudConverter):
 
         # create Items
         self._items = []
+
+        # Warning about coordinate shift
+        if len(las_list) > 0:
+            logger.info(
+                "⚠️ IMPORTANT: Coordinate shift will be applied to all LAS/LAZ files during conversion to PCD format. "
+                "This is necessary to avoid floating-point precision issues and visual artifacts. "
+                "The shift values (X, Y, Z offsets) will be logged for each file. "
+                "If you need to convert annotations back to original LAS coordinates or use them with original LAS files, "
+                "you MUST add these shift values back to the PCD/annotation coordinates. "
+                "Check the logs for 'Applied coordinate shift' messages for each file."
+            )
+
         for las_path in las_list:
             ext = get_file_ext(las_path)
             pcd_path = las_path.replace(ext, ".pcd")
             las_helper.las2pcd(las_path, pcd_path)
             if not os.path.exists(pcd_path):
-                logger.warn(f"Failed to convert LAS/LAZ to PCD. Skipping: {las_path}")
+                logger.warning(f"Failed to convert LAS/LAZ to PCD. Skipping: {las_path}")
                 continue
             item = self.Item(pcd_path)
             self._items.append(item)

supervisely/convert/pointcloud/las/las_helper.py

@@ -1,20 +1,39 @@
+import numpy as np
+
 from supervisely import logger
+from supervisely.io.fs import get_file_name_with_ext
 
-import numpy as np
 
+def las2pcd(input_path: str, output_path: str) -> None:
+    """
+    Convert a LAS/LAZ point cloud to PCD format.
 
-def las2pcd(input_path, output_path):
-    import laspy # pylint: disable=import-error
-    import open3d as o3d # pylint: disable=import-error
+    The function reads a LAS/LAZ file, applies coordinate scaling and offsets,
+    recenters the point cloud to improve numerical stability, and writes
+    the result to a PCD file compatible with common point cloud viewers.
 
+    :param input_path: Path to the input LAS/LAZ file.
+    :type input_path: str
+    :param output_path: Path where the output PCD file will be written.
+    :type output_path: str
+    :return: None
+    """
+    import laspy  # pylint: disable=import-error
+    from pypcd4 import Encoding  # pylint: disable=import-error
+    from pypcd4 import PointCloud as pypcd4_pcd  # pylint: disable=import-error
+
+    # Read LAS file
     try:
+        input_file_name = get_file_name_with_ext(input_path)
+        logger.info(f"Start processing file: {input_file_name}")
         las = laspy.read(input_path)
     except Exception as e:
         if "buffer size must be a multiple of element size" in str(e):
-            from laspy.point.record import PackedPointRecord # pylint: disable=import-error
-            logger.warn(
-                "Could not read LAS file in laspy. Trying to read it without EXTRA_BYTES..."
+            logger.warning(
+                f"{input_file_name} file read failed due to buffer size mismatch with EXTRA_BYTES. "
+                "Retrying with EXTRA_BYTES disabled as a workaround..."
             )
+            from laspy.point.record import PackedPointRecord  # pylint: disable=import-error
 
             @classmethod
             def from_buffer_without_extra_bytes(cls, buffer, point_format, count=-1, offset=0):
@@ -23,10 +42,90 @@ def las2pcd(input_path, output_path):
                 points_dtype = point_format.dtype()
                 data = np.frombuffer(buffer, dtype=points_dtype, offset=offset, count=count)
                 return cls(data, point_format)
+
             PackedPointRecord.from_buffer = from_buffer_without_extra_bytes
             las = laspy.read(input_path)
         else:
-            raise e
-    point_cloud = np.vstack((las.X, las.Y, las.Z)).T
-    pc = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(point_cloud))
-    o3d.io.write_point_cloud(output_path, pc)
+            logger.error(f"Failed to read {input_file_name}: {e}")
+            return
+
+    try:
+        # Use scaled coordinates (scale and offset applied)
+        x = np.asarray(las.x, dtype=np.float64)
+        y = np.asarray(las.y, dtype=np.float64)
+        z = np.asarray(las.z, dtype=np.float64)
+
+        # Check for empty point cloud
+        if len(x) == 0:
+            logger.warning(f"{input_file_name} file is empty (0 points).")
+            return
+
+        # Recenter point cloud to reduce floating point precision issues
+        # Calculate shift for each axis independently (avoids creating intermediate pts array)
+        shift_x = x.mean()
+        shift_y = y.mean()
+        shift_z = z.mean()
+
+        logger.info(
+            f"Applied coordinate shift for {input_file_name}: "
+            f"X={shift_x}, Y={shift_y}, Z={shift_z}"
+        )
+
+        # Base PCD fields - apply shift and convert to float32 in one operation
+        data = {
+            "x": (x - shift_x).astype(np.float32),
+            "y": (y - shift_y).astype(np.float32),
+            "z": (z - shift_z).astype(np.float32),
+            "intensity": las.intensity.astype(np.float32),
+        }
+
+        # Handle RGB attributes if present
+        if hasattr(las, "red") and hasattr(las, "green") and hasattr(las, "blue"):
+            # Convert LAS colors to 8-bit.
+            # Some files store 0–255 values in 16-bit fields; detect this and only shift when needed.
+            r_raw = np.asarray(las.red)
+            g_raw = np.asarray(las.green)
+            b_raw = np.asarray(las.blue)
+
+            # Determine if the values are full 16-bit range (0–65535) or already 0–255.
+            max_rgb = max(
+                r_raw.max(initial=0),
+                g_raw.max(initial=0),
+                b_raw.max(initial=0),
+            )
+
+            if max_rgb > 255:
+                # Typical LAS case: 16-bit colors; downscale to 8-bit.
+                r = (r_raw >> 8).astype(np.uint32)
+                g = (g_raw >> 8).astype(np.uint32)
+                b = (b_raw >> 8).astype(np.uint32)
+            else:
+                # Values are already in 0–255 range; use as-is.
+                r = r_raw.astype(np.uint32)
+                g = g_raw.astype(np.uint32)
+                b = b_raw.astype(np.uint32)
+
+            # Pack RGB into a single float field (PCL-compatible)
+            rgb = (r << 16) | (g << 8) | b
+            data["rgb"] = rgb.view(np.float32)
+
+        # Write PCD file
+        # Create structured array for pypcd4
+        field_names = ["x", "y", "z", "intensity"]
+        types = [np.float32, np.float32, np.float32, np.float32]
+
+        if "rgb" in data:
+            field_names.append("rgb")
+            types.append(np.float32)
+
+        arrays = [data[field] for field in field_names]
+    except Exception as e:
+        logger.error(f"Error processing {input_file_name}: {e}")
+        return
+
+    try:
+        pd = pypcd4_pcd.from_points(arrays, field_names, types)
+        pd.save(output_path, encoding=Encoding.BINARY_COMPRESSED)
+    except Exception as e:
+        logger.error(f"Failed to write PCD file for {input_file_name}: {e}")
+        return

supervisely/convert/pointcloud/nuscenes_conv/nuscenes_converter.py

@@ -1,9 +1,10 @@
 import os
+import uuid
 from typing import Dict, List, Optional
 
 import supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_helper as helpers
 import supervisely.io.fs as fs
-from supervisely import PointcloudAnnotation, PointcloudObject
+from supervisely import KeyIdMap, PointcloudAnnotation, PointcloudObject
 from supervisely._utils import is_development
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
@@ -30,19 +31,6 @@ from supervisely.sly_logger import logger
 class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
     """Converter for NuScenes pointcloud format."""
 
-    def __init__(
-        self,
-        input_data: str,
-        labeling_interface: 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._nuscenes = None
-
-    def __str__(self) -> str:
-        return AvailablePointcloudConverters.NUSCENES
-
     def to_supervisely(
         self,
         scene_sample: helpers.Sample,
@@ -69,14 +57,21 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
         return PointcloudAnnotation(PointcloudObjectCollection(objs), figures)
 
     def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
-        nuscenes = self._nuscenes
+        from nuscenes.nuscenes import NuScenes  # pylint: disable=import-error
+
+        nuscenes: NuScenes = self._nuscenes
+
+        key_id_map = KeyIdMap()
 
         tag_metas = [TagMeta(attr["name"], TagValueType.NONE) for attr in nuscenes.attribute]
         obj_classes = []
+        classes_token_map = {}
         for category in nuscenes.category:
             color = nuscenes.colormap[category["name"]]
             description = helpers.trim_description(category["description"])
             obj_classes.append(ObjClass(category["name"], Cuboid3d, color, description=description))
+            classes_token_map[category["token"]] = category["name"]
+        self._custom_data["classes_token_map"] = classes_token_map
 
         self._meta = ProjectMeta(obj_classes, tag_metas)
         meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
@@ -108,6 +103,7 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
         else:
             progress_cb = None
 
+        self._custom_data["frame_token_map"] = {}
         for scene in nuscenes.scene:
             current_dataset_id = scene_name_to_dataset[scene["name"]].id
 
@@ -116,8 +112,10 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
 
             # * Extract scene's samples
             scene_samples: List[helpers.Sample] = []
+            frame_token_map = {}
             for i in range(scene["nbr_samples"]):
                 sample = nuscenes.get("sample", sample_token)
+                frame_token_map[sample["token"]] = i
                 lidar_path, boxes, _ = nuscenes.get_sample_data(sample["data"]["LIDAR_TOP"])
                 if not os.path.exists(lidar_path):
                     logger.warning(f'Scene "{scene["name"]}" has no LIDAR data.')
@@ -137,9 +135,11 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
                     ]
                     visibility = nuscenes.get("visibility", ann["visibility_token"])["level"]
 
+                    ann_uuid = uuid.UUID(ann["token"])
                     ann = helpers.AnnotationObject(
                         name=name,
                         bbox=box,
+                        token=ann_uuid,
                         instance_token=current_instance_token,
                         parent_token=parent_token,
                         category=category,
@@ -162,6 +162,7 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
                 ]
                 scene_samples.append(helpers.Sample(timestamp, lidar_path, anns, camera_data))
                 sample_token = sample["next"]
+            self._custom_data["frame_token_map"][current_dataset_id] = frame_token_map
 
             # * Convert and upload pointclouds w/ annotations
             for idx, sample in enumerate(scene_samples):
@@ -182,7 +183,7 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
                 pcd_id = info.id
                 # * Upload pointcloud annotation
                 try:
-                    api.pointcloud.annotation.append(pcd_id, pcd_ann)
+                    api.pointcloud.annotation.append(pcd_id, pcd_ann, key_id_map)
                 except Exception as e:
                     error_msg = getattr(getattr(e, "response", e), "text", str(e))
                     logger.warning(
@@ -213,6 +214,16 @@ class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
 
             logger.info(f"Dataset ID:{current_dataset_id} has been successfully uploaded.")
 
+        key_id_map = key_id_map.to_dict()
+        key_id_map.pop("tags")
+        key_id_map.pop("videos")
+        self._custom_data["key_id_map"] = key_id_map
+
+        project_id = dataset_info.project_id
+        current_custom_data = api.project.get_custom_data(project_id)
+        current_custom_data.update(self._custom_data)
+        api.project.update_custom_data(project_id, current_custom_data)
+
         if log_progress:
             if is_development():
                 progress.close()