supervisely 6.73.325__py3-none-any.whl → 6.73.327__py3-none-any.whl

supervisely/annotation/annotation.py

@@ -3088,7 +3088,7 @@ class Annotation:
     def to_yolo(
         self,
         class_names: List[str],
-        task_type: Literal["detection", "segmentation", "pose"] = "detection",
+        task_type: Literal["detect", "segment", "pose"] = "detect",
     ) -> List[str]:
         """
         Convert Supervisely annotation to YOLO annotation format.

supervisely/app/widgets/pretrained_models_selector/pretrained_models_selector.py

@@ -4,7 +4,7 @@ from supervisely.api.api import Api
 from supervisely.app.content import DataJson, StateJson
 from supervisely.app.widgets import Widget
 from supervisely.io.fs import get_file_ext
-from supervisely.nn.utils import ModelSource
+from supervisely.nn.utils import ModelSource, _get_model_name
 
 
 class PretrainedModelsSelector(Widget):
@@ -147,9 +147,11 @@ class PretrainedModelsSelector(Widget):
         if train_version == "v1":
             model_name = selected_model.get(model_name_column)
             if model_name is None:
-                raise ValueError(
-                    "Could not find model name. Make sure you have column 'Model' in your models list."
-                )
+                model_name = _get_model_name(selected_model)
+                if model_name is None:
+                    raise ValueError(
+                        "Could not find model name. Make sure you have column 'Model' in your models list."
+                    )
 
             model_meta = selected_model.get("meta")
             if model_meta is None:
@@ -230,24 +232,25 @@ class PretrainedModelsSelector(Widget):
         for task_type in self._table_data:
             for arch_type in self._table_data[task_type]:
                 for idx, model in enumerate(self._table_data[task_type][arch_type]):
-                    model_meta = model.get("meta", {})
-                    if model_meta.get("model_name") == model_name:
-                        self.set_active_task_type(task_type)
-                        self.set_active_arch_type(arch_type)
-                        self.set_active_row(idx)
-                        return
+                    name_from_info = _get_model_name(model)
+                    if name_from_info is not None:
+                        if name_from_info.lower() == model_name.lower():
+                            self.set_active_task_type(task_type)
+                            self.set_active_arch_type(arch_type)
+                            self.set_active_row(idx)
+                            return
 
     def get_by_model_name(self, model_name: str) -> Union[Dict, None]:
         for task_type in self._table_data:
             for arch_type in self._table_data[task_type]:
                 for idx, model in enumerate(self._table_data[task_type][arch_type]):
-                    model_meta = model.get("meta", {})
-                    if model_meta.get("model_name") == model_name:
-                        return model
+                    name_from_info = _get_model_name(model)
+                    if name_from_info is not None:
+                        if name_from_info.lower() == model_name.lower():
+                            return model
 
     def _filter_and_sort_models(self, models: List[Dict], sort_models: bool = True) -> Dict:
         filtered_models = {}
-
         for model in models:
             for key in model:
                 if isinstance(model[key], (int, float)):

supervisely/app/widgets/pretrained_models_selector/template.html

@@ -62,7 +62,8 @@
         <tr>
             <template v-for="(col, colKey) in data.{{{widget.widget_id}}}.tableData[state.{{{widget.widget_id}}}.selectedTaskType][state.{{{widget.widget_id}}}.selectedArchType][0]">
             <th v-if="colKey != 'meta'" :key="colKey">
-                <div>{{ colKey }}</div>
+                <div v-if="colKey==='model_name'">Model</div>
+                <div v-else>{{ colKey }}</div>
             </th>
         </template>
         </tr> 

supervisely/convert/image/yolo/yolo_helper.py

@@ -17,7 +17,8 @@ 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.io.fs import get_file_name, get_file_name_with_ext, touch
+from supervisely.nn.task_type import TaskType
 from supervisely.project.project import Dataset, OpenMode, Project
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.sly_logger import logger
@@ -27,6 +28,20 @@ YOLO_DETECTION_COORDS_NUM = 4
 YOLO_SEGM_MIN_COORDS_NUM = 6
 YOLO_KEYPOINTS_MIN_COORDS_NUM = 6
 
+
+class YOLOTaskType:
+    DETECT = "detect"
+    SEGMENT = "segment"
+    POSE = "pose"
+
+
+SLY_YOLO_TASK_TYPE_MAP = {
+    TaskType.OBJECT_DETECTION: YOLOTaskType.DETECT,
+    TaskType.INSTANCE_SEGMENTATION: YOLOTaskType.SEGMENT,
+    TaskType.POSE_ESTIMATION: YOLOTaskType.POSE,
+}
+
+
 coco_classes = [
     "person",
     "bicycle",
@@ -398,22 +413,22 @@ def keypoints_to_yolo_line(
 
 def convert_label_geometry_if_needed(
     label: Label,
-    task_type: Literal["detection", "segmentation", "pose"],
+    task_type: Literal["detect", "segment", "pose"],
     verbose: bool = False,
 ) -> List[Label]:
-    if task_type == "detection":
+    if task_type == YOLOTaskType.DETECT:
         available_geometry_type = Rectangle
         convertable_geometry_types = [Polygon, GraphNodes, Bitmap, Polyline, AlphaMask, AnyGeometry]
-    elif task_type == "segmentation":
+    elif task_type == YOLOTaskType.SEGMENT:
         available_geometry_type = Polygon
         convertable_geometry_types = [Bitmap, AlphaMask, AnyGeometry]
-    elif task_type == "pose":
+    elif task_type == YOLOTaskType.POSE:
         available_geometry_type = GraphNodes
         convertable_geometry_types = []
     else:
         raise ValueError(
             f"Unsupported task type: {task_type}. "
-            "Supported types: 'detection', 'segmentation', 'pose'"
+            f"Supported types: '{YOLOTaskType.DETECT}', '{YOLOTaskType.SEGMENT}', '{YOLOTaskType.POSE}'"
         )
 
     if label.obj_class.geometry_type == available_geometry_type:
@@ -438,7 +453,7 @@ def label_to_yolo_lines(
     img_height: int,
     img_width: int,
     class_names: List[str],
-    task_type: Literal["detection", "segmentation", "pose"],
+    task_type: Literal["detect", "segment", "pose"],
 ) -> List[str]:
     """
     Convert the Supervisely Label to a line in the YOLO format.
@@ -449,21 +464,21 @@ def label_to_yolo_lines(
 
     lines = []
     for label in labels:
-        if task_type == "detection":
+        if task_type == YOLOTaskType.DETECT:
             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":
+        elif task_type == YOLOTaskType.SEGMENT:
             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":
+        elif task_type == YOLOTaskType.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(
@@ -474,7 +489,10 @@ def label_to_yolo_lines(
                 max_kpts_count=max_kpts_count,
             )
         else:
-            raise ValueError(f"Unsupported task type: {task_type}")
+            raise ValueError(
+                f"Unsupported task type: {task_type}. "
+                f"Supported types: '{YOLOTaskType.DETECT}', '{YOLOTaskType.SEGMENT}', '{YOLOTaskType.POSE}'"
+            )
 
         if yolo_line is not None:
             lines.append(yolo_line)
@@ -485,12 +503,11 @@ def label_to_yolo_lines(
 def sly_ann_to_yolo(
     ann: Annotation,
     class_names: List[str],
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
 ) -> List[str]:
     """
     Convert the Supervisely annotation to the YOLO format.
     """
-
     h, w = ann.img_size
     yolo_lines = []
     for label in ann.labels:
@@ -509,11 +526,12 @@ def sly_ds_to_yolo(
     dataset: Dataset,
     meta: ProjectMeta,
     dest_dir: Optional[str] = None,
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
     log_progress: bool = False,
     progress_cb: Optional[Union[tqdm, Callable]] = None,
+    is_val: Optional[bool] = None,
 ) -> str:
-
+    task_type = validate_task_type(task_type)
     if progress_cb is not None:
         log_progress = False
 
@@ -543,15 +561,19 @@ def sly_ds_to_yolo(
         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
+        if is_val is not None:
+            images_dir = val_images_dir if is_val else train_images_dir
+            labels_dir = val_labels_dir if is_val else train_labels_dir
+        else:
+            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")
+        label_path = str(labels_dir / f"{get_file_name(img_name)}.txt")
         yolo_lines = ann.to_yolo(class_names, task_type)
         if len(yolo_lines) > 0:
             with open(label_path, "w") as f:
@@ -565,7 +587,8 @@ def sly_ds_to_yolo(
     # * 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")
+        with_keypoint = task_type is YOLOTaskType.POSE
+        save_yolo_config(meta, dest_dir, with_keypoint=with_keypoint)
 
     return str(dest_dir)
 
@@ -578,6 +601,8 @@ def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = Fal
     data_yaml = {
         "train": f"../{str(dest_dir.name)}/images/train",
         "val": f"../{str(dest_dir.name)}/images/val",
+        "train_labels": f"../{str(dest_dir.name)}/labels/train",
+        "val_labels": f"../{str(dest_dir.name)}/labels/val",
         "nc": len(class_names),
         "names": class_names,
         "colors": class_colors,
@@ -590,6 +615,7 @@ def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = Fal
                 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]
+        data_yaml["flip_idx"] = [i for i in range(max_kpts_count)]
     with open(save_path, "w") as f:
         yaml.dump(data_yaml, f, default_flow_style=None)
 
@@ -599,21 +625,31 @@ def save_yolo_config(meta: ProjectMeta, dest_dir: str, with_keypoint: bool = Fal
 def sly_project_to_yolo(
     project: Union[Project, str],
     dest_dir: Optional[str] = None,
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
     log_progress: bool = False,
     progress_cb: Optional[Callable] = None,
+    val_datasets: Optional[List[str]] = None,
 ):
     """
     Convert Supervisely project to YOLO format.
 
+    :param project: Supervisely project or path to the directory with the project.
+    :type project: :class:`supervisely.project.project.Project` or :class:`str`
     :param dest_dir: Destination directory.
     :type dest_dir: :class:`str`, optional
+    :param task_type: Task type.
+    :type task_type: :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
+    :param val_datasets:    List of dataset names for validation.
+                            Full dataset names are required (e.g., 'ds0/nested_ds1/ds3').
+                            If specified, datasets from the list will be marked as val, others as train.
+                            If not specified, the function will determine the validation datasets automatically.
+    :type val_datasets: :class:`list`, optional
+    :return: Path to the destination directory.
+    :rtype: :class:`str`
 
     :Usage example:
 
@@ -627,6 +663,7 @@ def sly_project_to_yolo(
         # Convert Project to YOLO format
         sly.Project(project_directory).to_yolo(log_progress=True)
     """
+    task_type = validate_task_type(task_type)
     if isinstance(project, str):
         project = Project(project, mode=OpenMode.READ)
 
@@ -644,9 +681,15 @@ def sly_project_to_yolo(
             desc="Converting Supervisely project to YOLO format", total=project.total_items
         ).update
 
-    save_yolo_config(project.meta, dest_dir, with_keypoint=task_type == "pose")
+    with_keypoint = task_type is YOLOTaskType.POSE
+    save_yolo_config(project.meta, dest_dir, with_keypoint=with_keypoint)
 
     for dataset in project.datasets:
+        if val_datasets is not None:
+            is_val = dataset.name in val_datasets
+        else:
+            is_val = None
+
         dataset: Dataset
         dataset.to_yolo(
             meta=project.meta,
@@ -654,18 +697,23 @@ def sly_project_to_yolo(
             task_type=task_type,
             log_progress=log_progress,
             progress_cb=progress_cb,
+            is_val=is_val,
         )
         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.")
 
+    return str(dest_dir)
+
 
 def to_yolo(
     input_data: Union[Project, Dataset, str],
     dest_dir: Optional[str] = None,
-    task_type: Literal["detection", "segmentation", "pose"] = "detection",
+    task_type: Literal["detect", "segment", "pose"] = "detect",
     meta: Optional[ProjectMeta] = None,
     log_progress: bool = True,
     progress_cb: Optional[Callable] = None,
+    val_datasets: Optional[List[str]] = None,
+    is_val: Optional[bool] = None,
 ) -> Union[None, str]:
     """
     Universal function to convert Supervisely project or dataset  to YOLO format.
@@ -691,6 +739,13 @@ def to_yolo(
     :type log_progress: :class:`bool`
     :param progress_cb: Function for tracking conversion progress (for all items in the project).
     :type progress_cb: callable, optional
+    :param val_datasets:    List of dataset names for validation.
+                            Full dataset names are required (e.g., 'ds0/nested_ds1/ds3').
+                            If specified, datasets from the list will be marked as val, others as train.
+                            If not specified, the function will determine the validation datasets automatically.
+    :type val_datasets: :class:`list`, optional
+    :param is_val: Whether the dataset is for validation.
+    :type is_val: :class:`bool`, optional
     :return: None, list of YOLO lines, or path to the destination directory.
     :rtype: NoneType, list, str
 
@@ -711,7 +766,7 @@ def to_yolo(
 
         # Convert Dataset to YOLO format
         dataset: sly.Dataset = project_fs.datasets.get("dataset_name")
-        sly.convert.to_yolo(dataset, dest_dir="./yolo", meta=project_fs.meta)
+        sly.convert.to_yolo(dataset, dest_dir="./yolo", meta=project_fs.meta, is_val=True)
     """
     if isinstance(input_data, str):
         try:
@@ -728,6 +783,7 @@ def to_yolo(
             task_type=task_type,
             log_progress=log_progress,
             progress_cb=progress_cb,
+            val_datasets=val_datasets,
         )
     elif isinstance(input_data, Dataset):
         return sly_ds_to_yolo(
@@ -737,6 +793,20 @@ def to_yolo(
             task_type=task_type,
             log_progress=log_progress,
             progress_cb=progress_cb,
+            is_val=is_val,
         )
     else:
         raise ValueError("Unsupported input type. Only Project or Dataset are supported.")
+
+
+def validate_task_type(task_type: Literal["detect", "segment", "pose"]) -> str:
+    if task_type not in [YOLOTaskType.DETECT, YOLOTaskType.SEGMENT, YOLOTaskType.POSE]:
+        task_type = SLY_YOLO_TASK_TYPE_MAP.get(task_type)
+        if task_type is None:
+            raise ValueError(
+                f"Unsupported task type: {task_type}. "
+                f"Supported types: '{YOLOTaskType.DETECT}', '{SLY_YOLO_TASK_TYPE_MAP[TaskType.OBJECT_DETECTION]}', "
+                f"'{YOLOTaskType.SEGMENT}', '{SLY_YOLO_TASK_TYPE_MAP[TaskType.INSTANCE_SEGMENTATION]}', "
+                f"'{YOLOTaskType.POSE}', '{SLY_YOLO_TASK_TYPE_MAP[TaskType.POSE_ESTIMATION]}'"
+            )
+    return task_type

supervisely/convert/volume/nii/nii_planes_volume_converter.py

@@ -8,7 +8,7 @@ from supervisely.convert.volume.nii import nii_volume_helper as helper
 from supervisely.convert.volume.nii.nii_volume_converter import NiiConverter
 from supervisely.convert.volume.volume_converter import VolumeConverter
 from supervisely.geometry.mask_3d import Mask3D
-from supervisely.io.fs import get_file_name
+from supervisely.io.fs import get_file_ext, get_file_name
 from supervisely.volume.volume import is_nifti_file
 from supervisely.volume_annotation.volume_annotation import VolumeAnnotation
 from supervisely.volume_annotation.volume_object import VolumeObject
@@ -34,14 +34,46 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
         ├── 🩻 sag_inference_1.nii class 1
         ├── 🩻 sag_inference_2.nii class 2
         └── 🩻 sag_inference_3.nii class 3
+
+    Additionally, if a TXT file with class color map is present, it will be used to
+    create the classes with names and colors corresponding to the pixel values in the NIfTI files.
+    The TXT file should be structured as follows:
+
+    ```txt
+    1 Femur 255 0 0
+    2 Femoral cartilage 0 255 0
+    3 Tibia 0 0 255
+    4 Tibia cartilage 255 255 0
+    5 Patella 0 255 255
+    6 Patellar cartilage 255 0 255
+    7 Miniscus 175 175 175
+    ```
+    where   1, 2, ... are the pixel values in the NIfTI files
+            Femur, Femoral cartilage, ... are the names of the classes
+            255, 0, 0, ... are the RGB colors of the classes
+    The class name will be used to create the corresponding ObjClass in Supervisely.
     """
 
+    class Item(VolumeConverter.BaseItem):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self._is_semantic = False
+
+        @property
+        def is_semantic(self) -> bool:
+            return self._is_semantic
+
+        @is_semantic.setter
+        def is_semantic(self, value: bool):
+            self._is_semantic = value
+
     def validate_format(self) -> bool:
         # create Items
         converted_dir_name = "converted"
 
         volumes_dict = defaultdict(list)
         ann_dict = defaultdict(list)
+        cls_color_map = None
 
         for root, _, files in os.walk(self._input_data):
             if converted_dir_name in root:
@@ -56,17 +88,24 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
                     if prefix not in helper.PlanePrefix.values():
                         continue
                     name = full_name.split("_")[1]
-                    idx = 1 if len(name.split("_")) < 3 else int(name.split("_")[2])
                     if name in helper.LABEL_NAME or name[:-1] in helper.LABEL_NAME:
                         ann_dict[prefix].append(path)
                     else:
                         volumes_dict[prefix].append(path)
+                ext = get_file_ext(path)
+                if ext == ".txt":
+                    cls_color_map = helper.read_cls_color_map(path)
+                    if cls_color_map is None:
+                        logger.warning(f"Failed to read class color map from {path}.")
 
         self._items = []
         for prefix, paths in volumes_dict.items():
             if len(paths) == 1:
                 item = self.Item(item_path=paths[0])
-                item.ann_data = ann_dict.get(prefix)
+                item.ann_data = ann_dict.get(prefix, [])
+                item.is_semantic = len(item.ann_data) == 1
+                if cls_color_map is not None:
+                    item.custom_data["cls_color_map"] = cls_color_map
                 self._items.append(item)
             elif len(paths) > 1:
                 logger.info(
@@ -79,6 +118,9 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
                         if Path(ann_path).parent == Path(path).parent:
                             possible_ann_paths.append(ann_path)
                     item.ann_data = possible_ann_paths
+                    item.is_semantic = len(possible_ann_paths) == 1
+                    if cls_color_map is not None:
+                        item.custom_data["cls_color_map"] = cls_color_map
                     self._items.append(item)
         self._meta = ProjectMeta()
         return self.items_count > 0
@@ -96,12 +138,18 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
             objs = []
             spatial_figures = []
             for idx, ann_path in enumerate(item.ann_data, start=1):
-                for mask, _ in helper.get_annotation_from_nii(ann_path):
-                    class_name = f"Segment_{idx}"
+                for mask, pixel_id in helper.get_annotation_from_nii(ann_path):
+                    class_id = pixel_id if item.is_semantic else idx
+                    class_name = f"Segment_{class_id}"
+                    color = None
+                    if item.custom_data.get("cls_color_map") is not None:
+                        class_info = item.custom_data["cls_color_map"].get(class_id)
+                        if class_info is not None:
+                            class_name, color = class_info
                     class_name = renamed_classes.get(class_name, class_name)
                     obj_class = meta.get_obj_class(class_name)
                     if obj_class is None:
-                        obj_class = ObjClass(class_name, Mask3D)
+                        obj_class = ObjClass(class_name, Mask3D, color)
                         meta = meta.add_obj_class(obj_class)
                         self._meta_changed = True
                         self._meta = meta

supervisely/convert/volume/nii/nii_volume_converter.py

@@ -169,11 +169,11 @@ class NiiConverter(VolumeConverter):
             item_paths = []
 
             for item in batch:
-                if self._upload_as_links:
-                    remote_path = self.remote_files_map.get(item.path)
-                    if remote_path is not None:
-                        item.custom_data = {"remote_path": remote_path}
-                # nii_path = item.path
+                # if self._upload_as_links:
+                #     remote_path = self.remote_files_map.get(item.path)
+                #     if remote_path is not None:
+                #         item.custom_data = {"remote_path": remote_path}
+
                 item.path = helper.nifti_to_nrrd(item.path, converted_dir)
                 ext = get_file_ext(item.path)
                 if ext.lower() != ext:
@@ -195,8 +195,8 @@ class NiiConverter(VolumeConverter):
                     leave=True if progress_cb is None else False,
                     position=1,
                 )
-                if item.custom_data is not None:
-                    volume_meta.update(item.custom_data)
+                # if item.custom_data is not None:
+                #     volume_meta.update(item.custom_data)
                 api.volume.upload_np(dataset_id, item.name, volume_np, volume_meta, progress_nrrd)
                 info = api.volume.get_info_by_name(dataset_id, item.name)
                 item.volume_meta = info.meta

supervisely/convert/volume/nii/nii_volume_helper.py

@@ -7,6 +7,7 @@ import numpy as np
 from supervisely.collection.str_enum import StrEnum
 from supervisely.geometry.mask_3d import Mask3D
 from supervisely.io.fs import ensure_base_path, get_file_ext, get_file_name
+from supervisely.sly_logger import logger
 from supervisely.volume.volume import convert_3d_nifti_to_nrrd
 
 VOLUME_NAME = "anatomic"
@@ -21,6 +22,54 @@ class PlanePrefix(str, StrEnum):
     AXIAL = "axl"
 
 
+def read_cls_color_map(path: str) -> dict:
+    """Read class color map from TXT file.
+
+    ```txt
+    1 Femur 255 0 0
+    2 Femoral cartilage 0 255 0
+    3 Tibia 0 0 255
+    4 Tibia cartilage 255 255 0
+    5 Patella 0 255 255
+    6 Patellar cartilage 255 0 255
+    7 Miniscus 175 175 175
+    ```
+    """
+
+    cls_color_map = {}
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r") as file:
+            for line in file:
+                parts = line.strip().split()
+                color = None
+                try:
+                    color = list(map(int, parts[-3:]))
+                except:
+                    pass
+                cls_id = int(parts[0])
+                if not color:
+                    cls_name = " ".join(parts[1:])
+                else:
+                    cls_name = " ".join(parts[1:-3])
+                if cls_id in cls_color_map:
+                    logger.warning(f"Duplicate class ID {cls_id} found in color map.")
+                if cls_name in cls_color_map:
+                    logger.warning(f"Duplicate class name {cls_name} found in color map.")
+                if len(color) != 3:
+                    logger.warning(f"Invalid color format for class {cls_name}. Expected 3 values.")
+                if any(c < 0 or c > 255 for c in color):
+                    logger.warning(
+                        f"Invalid color value for class {cls_name}. Expected values between 0 and 255."
+                    )
+                cls_color_map[cls_id] = (cls_name, color)
+    except Exception as e:
+        logger.warning(f"Failed to read class color map from {path}: {e}")
+        return None
+    return cls_color_map
+
+
 def nifti_to_nrrd(nii_file_path: str, converted_dir: str) -> str:
     """Convert NIfTI 3D volume file to NRRD 3D volume file."""
 

supervisely/nn/inference/gui/serving_gui_template.py

@@ -23,7 +23,7 @@ from supervisely.app.widgets.pretrained_models_selector.pretrained_models_select
 )
 from supervisely.nn.experiments import get_experiment_infos
 from supervisely.nn.inference.gui.serving_gui import ServingGUI
-from supervisely.nn.utils import ModelSource, RuntimeType
+from supervisely.nn.utils import ModelSource, RuntimeType, _get_model_name
 
 
 class ServingGUITemplate(ServingGUI):
@@ -149,8 +149,7 @@ class ServingGUITemplate(ServingGUI):
     @property
     def model_name(self) -> Optional[str]:
         if self.model_source == ModelSource.PRETRAINED:
-            model_meta = self.model_info.get("meta", {})
-            return model_meta.get("model_name")
+            return _get_model_name(self.model_info)
         else:
             return self.model_info.get("model_name")