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

supervisely/convert/image/csv/csv_converter.py

@@ -24,6 +24,7 @@ from supervisely.io.fs import (
     get_file_name_with_ext,
     list_files_recursively,
 )
+from supervisely.io.env import team_id
 from supervisely.io.json import load_json_file
 from supervisely.project.project_settings import LabelingInterface
 
@@ -78,16 +79,16 @@ class CSVConverter(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,
+        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._csv_reader = None
-        self._team_id = None
 
     def __str__(self):
         return AvailableImageConverters.CSV
@@ -121,6 +122,12 @@ class CSVConverter(ImageConverter):
 
         full_path = valid_files[0]
 
+        if self.upload_as_links and self._supports_links:
+            for local_path, remote_path in self._remote_files_map.items():
+                if local_path.endswith(full_path):
+                    self._api.storage.download(self._team_id, remote_path, local_path)
+                    break
+
         file_ext = get_file_ext(full_path)
         if file_ext in self.conversion_functions:
             csv_full_path = os.path.splitext(full_path)[0] + ".csv"
@@ -147,7 +154,7 @@ class CSVConverter(ImageConverter):
                         team_files = False
                     break
             if item_path is None:
-                logger.warn(f"Failed to find image path in row: {row}. Skipping.")
+                logger.warning(f"Failed to find image path in row: {row}. Skipping.")
                 continue
             ann_data = row.get("tag")
             item = CSVConverter.Item(
@@ -192,7 +199,7 @@ class CSVConverter(ImageConverter):
                 ann_json = csv_helper.rename_in_json(ann_json, renamed_classes, renamed_tags)
             return Annotation.from_json(ann_json, meta)
         except Exception as e:
-            logger.warn(f"Failed to convert annotation: {repr(e)}")
+            logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()
 
     def process_remote_image(
@@ -209,19 +216,21 @@ class CSVConverter(ImageConverter):
         image_path = image_path.strip()
         if is_team_file:
             if not api.file.exists(team_id, image_path):
-                logger.warn(f"File {image_path} not found in Team Files. Skipping...")
+                logger.warning(f"File {image_path} not found in Team Files. Skipping...")
                 return None
             team_file_image_info = api.file.list(team_id, image_path)
             image_path = team_file_image_info[0]["fullStorageUrl"]
             if not image_path:
-                logger.warn(f"Failed to get full storage URL for file '{image_path}'. Skipping...")
+                logger.warning(
+                    f"Failed to get full storage URL for file '{image_path}'. Skipping..."
+                )
                 return None
 
         extension = os.path.splitext(image_path)[1]
         if not extension:
-            logger.warn(f"FYI: Image [{image_path}] doesn't have extension.")
+            logger.warning(f"FYI: Image [{image_path}] doesn't have extension.")
         elif extension.lower() not in SUPPORTED_IMG_EXTS:
-            logger.warn(
+            logger.warning(
                 f"Image [{image_path}] has unsupported extension [{extension}]. Skipping..."
             )
             return None
@@ -234,7 +243,7 @@ class CSVConverter(ImageConverter):
                 force_metadata_for_links=force_metadata,
             )
         except Exception:
-            logger.warn(f"Failed to upload image {image_name}. Skipping...")
+            logger.warning(f"Failed to link image {image_name}. Skipping...")
             return None
         if progress_cb is not None:
             progress_cb(1)
@@ -312,7 +321,7 @@ class CSVConverter(ImageConverter):
                     success = False
                     continue
                 if item.name not in info.name:
-                    logger.warn(
+                    logger.warning(
                         f"Batched image with name '{item.name}' doesn't match uploaded image name '{info.name}'"
                     )
                     success = False
@@ -339,4 +348,4 @@ class CSVConverter(ImageConverter):
         if success:
             logger.info(f"Dataset ID:'{dataset_id}' has been successfully uploaded.")
         else:
-            logger.warn(f"Dataset ID:'{dataset_id}' has been uploaded.")
+            logger.warning(f"Dataset ID:'{dataset_id}' has been uploaded.")

supervisely/convert/image/image_converter.py

@@ -136,10 +136,12 @@ class ImageConverter(BaseConverter):
             item_names = []
             item_paths = []
             item_metas = []
+            valid_batch_items = []
             for item in batch:
                 item.path = self.validate_image(item.path)
                 if item.path is None:
                     continue  # image has failed validation
+                valid_batch_items.append(item)
                 name = f"{get_file_name(item.path)}{get_file_ext(item.path).lower()}"
 
                 item.name = generate_free_name(
@@ -180,7 +182,7 @@ class ImageConverter(BaseConverter):
 
                 anns = []
                 if not (self.upload_as_links and not self.supports_links):
-                    for info, item in zip(img_infos, batch):
+                    for info, item in zip(img_infos, valid_batch_items):
                         if self._force_shape_for_links:
                             item.set_shape((info.height, info.width))
                         anns.append(self.to_supervisely(item, meta, renamed_classes, renamed_tags))

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