supervisely 6.73.276__py3-none-any.whl → 6.73.278__py3-none-any.whl

supervisely/convert/image/yolo/yolo_helper.py

@@ -1,8 +1,27 @@
-from typing import List, Tuple, Union
-
-from supervisely import AnyGeometry, GraphNodes, Polygon, Rectangle, logger
-from supervisely.geometry.graph import KeypointsTemplate, Node
+import os
+import shutil
+from pathlib import Path
+from typing import Callable, List, Literal, Optional, Tuple, Union
+
+import yaml
+from tqdm import tqdm
+
+from supervisely._utils import generate_free_name
+from supervisely.annotation.annotation import Annotation
+from supervisely.annotation.label import Label
+from supervisely.geometry.alpha_mask import AlphaMask
+from supervisely.geometry.any_geometry import AnyGeometry
+from supervisely.geometry.bitmap import Bitmap
+from supervisely.geometry.graph import GraphNodes, KeypointsTemplate, Node
+from supervisely.geometry.polygon import Polygon
+from supervisely.geometry.polyline import Polyline
+from supervisely.geometry.rectangle import Rectangle
 from supervisely.imaging.color import generate_rgb
+from supervisely.io.fs import get_file_name_with_ext, touch
+from supervisely.project.project import Dataset, OpenMode, Project
+from supervisely.project.project_meta import ProjectMeta
+from supervisely.sly_logger import logger
+from supervisely.task.progress import tqdm_sly
 
 YOLO_DETECTION_COORDS_NUM = 4
 YOLO_SEGM_MIN_COORDS_NUM = 6
@@ -322,3 +341,319 @@ def get_geometry(
         num_keypoints=num_keypoints,
         num_dims=num_dims,
     )
+
+
+def rectangle_to_yolo_line(
+    class_idx: int,
+    geometry: Rectangle,
+    img_height: int,
+    img_width: int,
+):
+    x = geometry.center.col / img_width
+    y = geometry.center.row / img_height
+    w = geometry.width / img_width
+    h = geometry.height / img_height
+    return f"{class_idx} {x:.6f} {y:.6f} {w:.6f} {h:.6f}"
+
+
+def polygon_to_yolo_line(
+    class_idx: int,
+    geometry: Polygon,
+    img_height: int,
+    img_width: int,
+) -> str:
+    coords = []
+    for point in geometry.exterior:
+        x = point.col / img_width
+        y = point.row / img_height
+        coords.extend([x, y])
+    return f"{class_idx} {' '.join(map(lambda coord: f'{coord:.6f}', coords))}"
+
+
+def keypoints_to_yolo_line(
+    class_idx: int,
+    geometry: GraphNodes,
+    img_height: int,
+    img_width: int,
+    max_kpts_count: int,
+):
+    bbox = geometry.to_bbox()
+    x, y, w, h = bbox.center.col, bbox.center.row, bbox.width, bbox.height
+    x, y, w, h = x / img_width, y / img_height, w / img_width, h / img_height
+
+    line = f"{class_idx} {x:.6f} {y:.6f} {w:.6f} {h:.6f}"
+
+    for node in geometry.nodes.values():
+        node: Node
+        visible = 2 if not node.disabled else 1
+        line += (
+            f" {node.location.col / img_width:.6f} {node.location.row / img_height:.6f} {visible}"
+        )
+    if len(geometry.nodes) < max_kpts_count:
+        for _ in range(max_kpts_count - len(geometry.nodes)):
+            line += " 0 0 0"
+
+    return line
+
+
+def convert_label_geometry_if_needed(
+    label: Label,
+    task_type: Literal["detection", "segmentation", "pose"],
+    verbose: bool = False,
+) -> List[Label]:
+    if task_type == "detection":
+        available_geometry_type = Rectangle
+        convertable_geometry_types = [Polygon, GraphNodes, Bitmap, Polyline, AlphaMask, AnyGeometry]
+    elif task_type == "segmentation":
+        available_geometry_type = Polygon
+        convertable_geometry_types = [Bitmap, AlphaMask, AnyGeometry]
+    elif task_type == "pose":
+        available_geometry_type = GraphNodes
+        convertable_geometry_types = []
+    else:
+        raise ValueError(
+            f"Unsupported task type: {task_type}. "
+            "Supported types: 'detection', 'segmentation', 'pose'"
+        )
+
+    if label.obj_class.geometry_type == available_geometry_type:
+        return [label]
+
+    need_convert = label.obj_class.geometry_type in convertable_geometry_types
+
+    if need_convert:
+        new_obj_cls = label.obj_class.clone(geometry_type=available_geometry_type)
+        return label.convert(new_obj_cls)
+
+    if verbose:
+        logger.warning(
+            f"Label '{label.obj_class.name}' has unsupported geometry type: "
+            f"{type(label.obj_class.geometry_type)}. Skipping."
+        )
+    return []
+
+
+def label_to_yolo_lines(
+    label: Label,
+    img_height: int,
+    img_width: int,
+    class_names: List[str],
+    task_type: Literal["detection", "segmentation", "pose"],
+) -> List[str]:
+    """
+    Convert the Supervisely Label to a line in the YOLO format.
+    """
+
+    labels = convert_label_geometry_if_needed(label, task_type)
+    class_idx = class_names.index(label.obj_class.name)
+
+    lines = []
+    for label in labels:
+        if task_type == "detection":
+            yolo_line = rectangle_to_yolo_line(
+                class_idx=class_idx,
+                geometry=label.geometry,
+                img_height=img_height,
+                img_width=img_width,
+            )
+        elif task_type == "segmentation":
+            yolo_line = polygon_to_yolo_line(
+                class_idx=class_idx,
+                geometry=label.geometry,
+                img_height=img_height,
+                img_width=img_width,
+            )
+        elif task_type == "pose":
+            nodes_field = label.obj_class.geometry_type.items_json_field
+            max_kpts_count = len(label.obj_class.geometry_config[nodes_field])
+            yolo_line = keypoints_to_yolo_line(
+                class_idx=class_idx,
+                geometry=label.geometry,
+                img_height=img_height,
+                img_width=img_width,
+                max_kpts_count=max_kpts_count,
+            )
+        else:
+            raise ValueError(f"Unsupported geometry type: {type(label.obj_class.geometry_type)}")
+
+        if yolo_line is not None:
+            lines.append(yolo_line)
+
+    return lines
+
+
+def sly_ann_to_yolo(
+    ann: Annotation,
+    class_names: List[str],
+    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+) -> List[str]:
+    """
+    Convert the Supervisely annotation to the YOLO format.
+    """
+
+    h, w = ann.img_size
+    yolo_lines = []
+    for label in ann.labels:
+        lines = label_to_yolo_lines(
+            label=label,
+            img_height=h,
+            img_width=w,
+            class_names=class_names,
+            task_type=task_type,
+        )
+        yolo_lines.extend(lines)
+    return yolo_lines
+
+
+def sly_ds_to_yolo(
+    dataset: Dataset,
+    meta: ProjectMeta,
+    dest_dir: Optional[str] = None,
+    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    log_progress: bool = False,
+    progress_cb: Optional[Union[tqdm, Callable]] = None,
+) -> str:
+
+    if progress_cb is not None:
+        log_progress = False
+
+    if log_progress:
+        progress_cb = tqdm_sly(
+            desc=f"Converting dataset '{dataset.short_name}' to YOLO format",
+            total=len(dataset),
+        ).update
+
+    dest_dir = Path(dataset.path) / "yolo" if dest_dir is None else Path(dest_dir)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    # * create train and val directories
+    images_dir = dest_dir / "images"
+    labels_dir = dest_dir / "labels"
+    train_images_dir = images_dir / "train"
+    train_labels_dir = labels_dir / "train"
+    val_images_dir = images_dir / "val"
+    val_labels_dir = labels_dir / "val"
+    for dir_path in [train_images_dir, train_labels_dir, val_images_dir, val_labels_dir]:
+        dir_path.mkdir(parents=True, exist_ok=True)
+
+    # * convert annotations and copy images
+    class_names = [obj_class.name for obj_class in meta.obj_classes]
+    used_names = set(os.listdir(train_images_dir)) | set(os.listdir(val_images_dir))
+    for name in dataset.get_items_names():
+        ann_path = dataset.get_ann_path(name)
+        ann = Annotation.load_json_file(ann_path, meta)
+
+        images_dir = val_images_dir if ann.img_tags.get("val") else train_images_dir
+        labels_dir = val_labels_dir if ann.img_tags.get("val") else train_labels_dir
+
+        img_path = Path(dataset.get_img_path(name))
+        img_name = f"{dataset.short_name}_{get_file_name_with_ext(img_path)}"
+        img_name = generate_free_name(used_names, img_name, with_ext=True, extend_used_names=True)
+        shutil.copy2(img_path, images_dir / img_name)
+
+        label_path = str(labels_dir / f"{img_name}.txt")
+        yolo_lines = ann.to_yolo(class_names, task_type)
+        if len(yolo_lines) > 0:
+            with open(label_path, "w") as f:
+                f.write("\n".join(yolo_lines))
+        else:
+            touch(label_path)
+
+        if progress_cb is not None:
+            progress_cb(1)
+
+    # * save data config file if it does not exist
+    config_path = dest_dir / "data_config.yaml"
+    if not config_path.exists():
+        save_yolo_config(meta, dest_dir, with_keypoint=task_type == "pose")
+
+    return str(dest_dir)
+
+
+def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = False):
+    dest_dir = Path(dest_dir)
+    save_path = dest_dir / "data_config.yaml"
+    class_names = [c.name for c in meta.obj_classes]
+    class_colors = [c.color for c in meta.obj_classes]
+    data_yaml = {
+        "train": f"../{str(dest_dir.name)}/images/train",
+        "val": f"../{str(dest_dir.name)}/images/val",
+        "nc": len(class_names),
+        "names": class_names,
+        "colors": class_colors,
+    }
+    has_keypoints = any(c.geometry_type == GraphNodes for c in meta.obj_classes)
+    if has_keypoints and with_keypoint:
+        max_kpts_count = 0
+        for obj_class in meta.obj_classes:
+            if issubclass(obj_class.geometry_type, GraphNodes):
+                field_name = obj_class.geometry_type.items_json_field
+                max_kpts_count = max(max_kpts_count, len(obj_class.geometry_config[field_name]))
+        data_yaml["kpt_shape"] = [max_kpts_count, 3]
+    with open(save_path, "w") as f:
+        yaml.dump(data_yaml, f, default_flow_style=None)
+
+    logger.info(f"Data config file has been saved to {str(save_path)}")
+
+
+def sly_project_to_yolo(
+    project: Union[Project, str],
+    dest_dir: Optional[str] = None,
+    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    log_progress: bool = False,
+    progress_cb: Optional[Callable] = None,
+):
+    """
+    Convert Supervisely project to YOLO format.
+
+    :param dest_dir: Destination directory.
+    :type dest_dir: :class:`str`, optional
+    :param log_progress: Show uploading progress bar.
+    :type log_progress: :class:`bool`
+    :param progress_cb: Function for tracking conversion progress (for all items in the project).
+    :type progress_cb: callable, optional
+    :return: None
+    :rtype: NoneType
+
+    :Usage example:
+
+    .. code-block:: python
+
+        import supervisely as sly
+
+        # Local folder with Project
+        project_directory = "/home/admin/work/supervisely/source/project"
+
+        # Convert Project to YOLO format
+        sly.Project(project_directory).to_yolo(log_progress=True)
+    """
+    if isinstance(project, str):
+        project = Project(project, mode=OpenMode.READ)
+
+    dest_dir = Path(project.directory).parent / "yolo" if dest_dir is None else Path(dest_dir)
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    if len(os.listdir(dest_dir)) > 0:
+        raise FileExistsError(f"Directory {dest_dir} is not empty.")
+
+    if progress_cb is not None:
+        log_progress = False
+
+    if log_progress:
+        progress_cb = tqdm_sly(
+            desc="Converting Supervisely project to YOLO format", total=project.total_items
+        ).update
+
+    save_yolo_config(project.meta, dest_dir, with_keypoint=task_type == "pose")
+
+    for dataset in project.datasets:
+        dataset: Dataset
+        dataset.to_yolo(
+            meta=project.meta,
+            dest_dir=dest_dir,
+            task_type=task_type,
+            log_progress=log_progress,
+            progress_cb=progress_cb,
+        )
+        logger.info(f"Dataset '{dataset.short_name}' has been converted to YOLO format.")
+    logger.info(f"Project '{project.name}' has been converted to YOLO format.")

supervisely/convert/pointcloud/__init__.py

@@ -0,0 +1,8 @@
+# Pointcloud
+from supervisely.convert.pointcloud.sly.sly_pointcloud_converter import SLYPointcloudConverter
+from supervisely.convert.pointcloud.las.las_converter import LasConverter
+from supervisely.convert.pointcloud.ply.ply_converter import PlyConverter
+from supervisely.convert.pointcloud.bag.bag_converter import BagConverter
+from supervisely.convert.pointcloud.lyft.lyft_converter import LyftConverter
+from supervisely.convert.pointcloud.nuscenes_conv.nuscenes_converter import NuscenesConverter
+from supervisely.convert.pointcloud.kitti_3d.kitti_3d_converter import KITTI3DConverter

supervisely/convert/pointcloud/kitti_3d/kitti_3d_converter.py

@@ -0,0 +1,139 @@
+import os
+from pathlib import Path
+
+from supervisely import PointcloudAnnotation, ProjectMeta, is_development, logger
+from supervisely.api.api import Api, ApiField
+from supervisely.convert.base_converter import AvailablePointcloudConverters
+from supervisely.convert.pointcloud.kitti_3d import kitti_3d_helper
+from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
+from supervisely.io.fs import (
+    dirs_filter,
+    file_exists,
+    get_file_ext,
+    get_file_name,
+    get_file_name_with_ext,
+    list_files,
+    silent_remove,
+)
+from supervisely.pointcloud_annotation.pointcloud_object_collection import (
+    PointcloudObjectCollection,
+)
+
+
+class KITTI3DConverter(PointcloudConverter):
+    def __str__(self) -> str:
+        return AvailablePointcloudConverters.KITTI3D
+
+    @property
+    def key_file_ext(self) -> str:
+        return ".bin"
+
+    def validate_format(self) -> bool:
+        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])
+
+        input_paths = [d for d in dirs_filter(self._input_data, _dir_filter_fn)]
+        if len(input_paths) == 0:
+            return False
+
+        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")
+        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
+
+        kitti_labels = []
+        for velodyne_path in velodyne_files:
+            file_name = get_file_name(velodyne_path)
+            image_path = os.path.join(image_2_dir, f"{file_name}.png")
+            label_path = os.path.join(label_2_dir, f"{file_name}.txt")
+            calib_path = os.path.join(calib_dir, f"{file_name}.txt")
+            if not file_exists(image_path):
+                logger.debug(f"Skipping item: {velodyne_path}. Image not found.")
+                continue
+            if not file_exists(label_path):
+                logger.debug(f"Skipping item: {velodyne_path}. Label not found.")
+                continue
+            if not file_exists(calib_path):
+                logger.debug(f"Skipping item: {velodyne_path}. Calibration not found.")
+                continue
+
+            label = kitti_3d_helper.read_kitti_label(label_path, calib_path)
+            kitti_labels.append(label)
+            self._items.append(self.Item(velodyne_path, label, (image_path, calib_path)))
+
+        self._meta = kitti_3d_helper.convert_labels_to_meta(kitti_labels)
+        return self.items_count > 0
+
+    def to_supervisely(
+        self,
+        item: PointcloudConverter.Item,
+        meta: ProjectMeta,
+        renamed_classes: dict = {},
+        renamed_tags: dict = {},
+    ) -> PointcloudAnnotation:
+        label = item.ann_data
+        objs, figures = kitti_3d_helper.convert_label_to_annotation(label, meta, renamed_classes)
+        return PointcloudAnnotation(PointcloudObjectCollection(objs), figures)
+
+    def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
+        meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(self.items_count, "Converting pointclouds...")
+        else:
+            progress_cb = None
+
+        for item in self._items:
+            # * Convert pointcloud from ".bin" to ".pcd"
+            pcd_path = str(Path(item.path).with_suffix(".pcd"))
+            if file_exists(pcd_path):
+                logger.warning(f"Overwriting file with path: {pcd_path}")
+            kitti_3d_helper.convert_bin_to_pcd(item.path, pcd_path)
+
+            # * Upload pointcloud
+            pcd_name = get_file_name_with_ext(pcd_path)
+            info = api.pointcloud.upload_path(dataset_id, pcd_name, pcd_path, {})
+            pcd_id = info.id
+
+            # * Convert annotation and upload
+            ann = self.to_supervisely(item, meta, renamed_classes, renamed_tags)
+            api.pointcloud.annotation.append(pcd_id, ann)
+
+            # * Upload related images
+            image_path, calib_path = item._related_images
+            rimage_info = kitti_3d_helper.convert_calib_to_image_meta(image_path, calib_path)
+
+            image_jsons = []
+            camera_names = []
+            img = api.pointcloud.upload_related_image(image_path)
+            image_jsons.append(
+                {
+                    ApiField.ENTITY_ID: pcd_id,
+                    ApiField.NAME: get_file_name_with_ext(rimage_info[ApiField.NAME]),
+                    ApiField.HASH: img,
+                    ApiField.META: rimage_info[ApiField.META],
+                }
+            )
+            camera_names.append(rimage_info[ApiField.META]["deviceId"])
+            if len(image_jsons) > 0:
+                api.pointcloud.add_related_images(image_jsons, camera_names)
+
+            # * Clean up
+            silent_remove(pcd_path)
+            if log_progress:
+                progress_cb(1)
+
+        logger.info(f"Dataset ID:{dataset_id} has been successfully uploaded.")
+
+        if log_progress:
+            if is_development():
+                progress.close()

supervisely/convert/pointcloud/kitti_3d/kitti_3d_helper.py

@@ -0,0 +1,110 @@
+import numpy as np
+
+from supervisely import ObjClass, ObjClassCollection, ProjectMeta
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.geometry.point_3d import Vector3d
+from supervisely.pointcloud_annotation.pointcloud_figure import PointcloudFigure
+from supervisely.pointcloud_annotation.pointcloud_object import PointcloudObject
+
+FOLDER_NAMES = ["velodyne", "image_2", "label_2", "calib"]
+
+
+def read_kitti_label(label_path, calib_path):
+    import open3d as o3d  # pylint: disable=import-error
+
+    calib = o3d.ml.datasets.KITTI.read_calib(calib_path)
+    label = o3d.ml.datasets.KITTI.read_label(label_path, calib)
+    return label
+
+
+def convert_labels_to_meta(labels):
+    labels = flatten(labels)
+    unique_labels = np.unique([l.label_class for l in labels])
+    obj_classes = [ObjClass(k, Cuboid3d) for k in unique_labels]
+    meta = ProjectMeta(obj_classes=ObjClassCollection(obj_classes))
+    return meta
+
+
+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 flatten(list_2d):
+    return sum(list_2d, [])
+
+
+def _convert_label_to_geometry(label):
+    geometries = []
+    for l in label:
+        bbox = l.to_xyzwhlr()
+        dim = bbox[[3, 5, 4]]
+        pos = bbox[:3] + [0, 0, dim[1] / 2]
+        yaw = bbox[-1]
+        position = Vector3d(float(pos[0]), float(pos[1]), float(pos[2]))
+        rotation = Vector3d(0, 0, float(-yaw))
+
+        dimension = Vector3d(float(dim[0]), float(dim[2]), float(dim[1]))
+        geometry = Cuboid3d(position, rotation, dimension)
+        geometries.append(geometry)
+    return geometries
+
+
+def convert_label_to_annotation(label, meta, renamed_class_names: dict = None):
+    geometries = _convert_label_to_geometry(label)
+    figures = []
+    objs = []
+    for l, geometry in zip(label, geometries):  # by object in point cloud
+        class_name = renamed_class_names.get(l.label_class, l.label_class)
+        pcobj = PointcloudObject(meta.get_obj_class(class_name))
+        figures.append(PointcloudFigure(pcobj, geometry))
+        objs.append(pcobj)
+
+    return objs, figures
+
+
+def convert_calib_to_image_meta(image_name, calib_path, camera_num=2):
+    with open(calib_path, "r") as f:
+        lines = f.readlines()
+
+    assert 0 < camera_num < 4
+    intrinsic_matrix = lines[camera_num].strip().split(" ")[1:]
+    intrinsic_matrix = np.array(intrinsic_matrix, dtype=np.float32).reshape(3, 4)[:3, :3]
+
+    obj = lines[4].strip().split(" ")[1:]
+    rect_4x4 = np.eye(4, dtype=np.float32)
+    rect_4x4[:3, :3] = np.array(obj, dtype=np.float32).reshape(3, 3)
+
+    obj = lines[5].strip().split(" ")[1:]
+    Tr_velo_to_cam = np.eye(4, dtype=np.float32)
+    Tr_velo_to_cam[:3] = np.array(obj, dtype=np.float32).reshape(3, 4)
+    world_cam = np.transpose(rect_4x4 @ Tr_velo_to_cam)
+    extrinsic_matrix = world_cam[:4, :3].T
+
+    data = {
+        "name": image_name,
+        "meta": {
+            "deviceId": "CAM_LEFT",
+            "sensorsData": {
+                "extrinsicMatrix": list(extrinsic_matrix.flatten().astype(float)),
+                "intrinsicMatrix": list(intrinsic_matrix.flatten().astype(float)),
+            },
+        },
+    }
+    return data

supervisely/convert/pointcloud_episodes/__init__.py

@@ -0,0 +1,9 @@
+# Pointcloud Episodes
+from supervisely.convert.pointcloud_episodes.sly.sly_pointcloud_episodes_converter import (
+    SLYPointcloudEpisodesConverter,
+)
+from supervisely.convert.pointcloud_episodes.bag.bag_converter import BagEpisodesConverter
+from supervisely.convert.pointcloud_episodes.lyft.lyft_converter import LyftEpisodesConverter
+from supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_converter import (
+    NuscenesEpisodesConverter,
+)

supervisely/convert/video/__init__.py

@@ -0,0 +1,3 @@
+# Video
+from supervisely.convert.video.mot.mot_converter import MOTConverter
+from supervisely.convert.video.sly.sly_video_converter import SLYVideoConverter

supervisely/convert/volume/__init__.py

@@ -0,0 +1,3 @@
+# Volume
+from supervisely.convert.volume.sly.sly_volume_converter import SLYVolumeConverter
+from supervisely.convert.volume.dicom.dicom_converter import DICOMConverter

supervisely/nn/training/gui/training_artifacts.py

@@ -102,7 +102,7 @@ class TrainingArtifacts:
                     apps = api.app.get_list(
                         team_id,
                         filter=[{"field": "name", "operator": "=", "value": app_name}],
-                        only_running=True,
+                        only_running=False,
                     )
                     if len(apps) == 1:
                         app_info = apps[0]

supervisely/nn/training/train_app.py

@@ -1674,8 +1674,9 @@ class TrainApp:
                 self.gui.training_artifacts.model_benchmark_report_thumbnail.show()
                 self.gui.training_artifacts.model_benchmark_report_field.show()
             else:
-                self.gui.training_artifacts.model_benchmark_fail_text.show()
-                self.gui.training_artifacts.model_benchmark_report_field.show()
+                if self.gui.hyperparameters_selector.get_model_benchmark_checkbox_value():
+                    self.gui.training_artifacts.model_benchmark_fail_text.show()
+                    self.gui.training_artifacts.model_benchmark_report_field.show()
         # ---------------------------- #
 
         # Set instruction to GUI