mblt-vision-python 0.0.0__py3-none-any.whl

mblt_vision/object_detection/__init__.py

@@ -0,0 +1,153 @@
+"""Object detection model exports."""
+
+from __future__ import annotations
+
+from .._compat import create_model_class
+
+__all__: list[str] = [
+    "YOLO11l",
+    "YOLO11m",
+    "YOLO11n",
+    "YOLO11s",
+    "YOLO11x",
+    "YOLO12l",
+    "YOLO12m",
+    "YOLO12n",
+    "YOLO12s",
+    "YOLO12x",
+    "YOLO26l",
+    "YOLO26lDistill",
+    "YOLO26m",
+    "YOLO26mDistill",
+    "YOLO26n",
+    "YOLO26nDistill",
+    "YOLO26s",
+    "YOLO26sDistill",
+    "YOLO26x",
+    "YOLO26xDistill",
+    "YOLOv3",
+    "YOLOv3_spp",
+    "YOLOv3_sppu",
+    "YOLOv3_tiny",
+    "YOLOv3_tinyu",
+    "YOLOv3u",
+    "YOLOv5l",
+    "YOLOv5l6",
+    "YOLOv5l6u",
+    "YOLOv5lu",
+    "YOLOv5m",
+    "YOLOv5m6",
+    "YOLOv5m6u",
+    "YOLOv5mu",
+    "YOLOv5n",
+    "YOLOv5n6",
+    "YOLOv5n6u",
+    "YOLOv5nu",
+    "YOLOv5s",
+    "YOLOv5s6",
+    "YOLOv5s6u",
+    "YOLOv5su",
+    "YOLOv5x",
+    "YOLOv5x6",
+    "YOLOv5x6u",
+    "YOLOv5xu",
+    "YOLOv7",
+    "YOLOv7d6",
+    "YOLOv7e6",
+    "YOLOv7e6e",
+    "YOLOv7w6",
+    "YOLOv7x",
+    "YOLOv8l",
+    "YOLOv8m",
+    "YOLOv8n",
+    "YOLOv8s",
+    "YOLOv8x",
+    "GELANc",
+    "GELANe",
+    "GELANm",
+    "GELANs",
+    "YOLOv9c",
+    "YOLOv9e",
+    "YOLOv9m",
+    "YOLOv9s",
+    "YOLOv9t",
+    "YOLOv10b",
+    "YOLOv10l",
+    "YOLOv10m",
+    "YOLOv10n",
+    "YOLOv10s",
+    "YOLOv10x",
+]
+
+YOLO11l = create_model_class("YOLO11l", __name__)
+YOLO11m = create_model_class("YOLO11m", __name__)
+YOLO11n = create_model_class("YOLO11n", __name__)
+YOLO11s = create_model_class("YOLO11s", __name__)
+YOLO11x = create_model_class("YOLO11x", __name__)
+YOLO12l = create_model_class("YOLO12l", __name__)
+YOLO12m = create_model_class("YOLO12m", __name__)
+YOLO12n = create_model_class("YOLO12n", __name__)
+YOLO12s = create_model_class("YOLO12s", __name__)
+YOLO12x = create_model_class("YOLO12x", __name__)
+YOLO26l = create_model_class("YOLO26l", __name__)
+YOLO26lDistill = create_model_class("YOLO26lDistill", __name__)
+YOLO26m = create_model_class("YOLO26m", __name__)
+YOLO26mDistill = create_model_class("YOLO26mDistill", __name__)
+YOLO26n = create_model_class("YOLO26n", __name__)
+YOLO26nDistill = create_model_class("YOLO26nDistill", __name__)
+YOLO26s = create_model_class("YOLO26s", __name__)
+YOLO26sDistill = create_model_class("YOLO26sDistill", __name__)
+YOLO26x = create_model_class("YOLO26x", __name__)
+YOLO26xDistill = create_model_class("YOLO26xDistill", __name__)
+YOLOv3 = create_model_class("YOLOv3", __name__)
+YOLOv3_spp = create_model_class("YOLOv3_spp", __name__)
+YOLOv3_sppu = create_model_class("YOLOv3_sppu", __name__)
+YOLOv3_tiny = create_model_class("YOLOv3_tiny", __name__)
+YOLOv3_tinyu = create_model_class("YOLOv3_tinyu", __name__)
+YOLOv3u = create_model_class("YOLOv3u", __name__)
+YOLOv5l = create_model_class("YOLOv5l", __name__)
+YOLOv5l6 = create_model_class("YOLOv5l6", __name__)
+YOLOv5l6u = create_model_class("YOLOv5l6u", __name__)
+YOLOv5lu = create_model_class("YOLOv5lu", __name__)
+YOLOv5m = create_model_class("YOLOv5m", __name__)
+YOLOv5m6 = create_model_class("YOLOv5m6", __name__)
+YOLOv5m6u = create_model_class("YOLOv5m6u", __name__)
+YOLOv5mu = create_model_class("YOLOv5mu", __name__)
+YOLOv5n = create_model_class("YOLOv5n", __name__)
+YOLOv5n6 = create_model_class("YOLOv5n6", __name__)
+YOLOv5n6u = create_model_class("YOLOv5n6u", __name__)
+YOLOv5nu = create_model_class("YOLOv5nu", __name__)
+YOLOv5s = create_model_class("YOLOv5s", __name__)
+YOLOv5s6 = create_model_class("YOLOv5s6", __name__)
+YOLOv5s6u = create_model_class("YOLOv5s6u", __name__)
+YOLOv5su = create_model_class("YOLOv5su", __name__)
+YOLOv5x = create_model_class("YOLOv5x", __name__)
+YOLOv5x6 = create_model_class("YOLOv5x6", __name__)
+YOLOv5x6u = create_model_class("YOLOv5x6u", __name__)
+YOLOv5xu = create_model_class("YOLOv5xu", __name__)
+YOLOv7 = create_model_class("YOLOv7", __name__)
+YOLOv7d6 = create_model_class("YOLOv7d6", __name__)
+YOLOv7e6 = create_model_class("YOLOv7e6", __name__)
+YOLOv7e6e = create_model_class("YOLOv7e6e", __name__)
+YOLOv7w6 = create_model_class("YOLOv7w6", __name__)
+YOLOv7x = create_model_class("YOLOv7x", __name__)
+YOLOv8l = create_model_class("YOLOv8l", __name__)
+YOLOv8m = create_model_class("YOLOv8m", __name__)
+YOLOv8n = create_model_class("YOLOv8n", __name__)
+YOLOv8s = create_model_class("YOLOv8s", __name__)
+YOLOv8x = create_model_class("YOLOv8x", __name__)
+GELANc = create_model_class("GELANc", __name__)
+GELANe = create_model_class("GELANe", __name__)
+GELANm = create_model_class("GELANm", __name__)
+GELANs = create_model_class("GELANs", __name__)
+YOLOv9c = create_model_class("YOLOv9c", __name__)
+YOLOv9e = create_model_class("YOLOv9e", __name__)
+YOLOv9m = create_model_class("YOLOv9m", __name__)
+YOLOv9s = create_model_class("YOLOv9s", __name__)
+YOLOv9t = create_model_class("YOLOv9t", __name__)
+YOLOv10b = create_model_class("YOLOv10b", __name__)
+YOLOv10l = create_model_class("YOLOv10l", __name__)
+YOLOv10m = create_model_class("YOLOv10m", __name__)
+YOLOv10n = create_model_class("YOLOv10n", __name__)
+YOLOv10s = create_model_class("YOLOv10s", __name__)
+YOLOv10x = create_model_class("YOLOv10x", __name__)

mblt_vision/pose_estimation/__init__.py

@@ -0,0 +1,41 @@
+"""Pose estimation model exports."""
+
+from __future__ import annotations
+
+from .._compat import create_model_class
+
+__all__: list[str] = [
+    "YOLO11lPose",
+    "YOLO11mPose",
+    "YOLO11nPose",
+    "YOLO11sPose",
+    "YOLO11xPose",
+    "YOLO26lPose",
+    "YOLO26mPose",
+    "YOLO26nPose",
+    "YOLO26sPose",
+    "YOLO26xPose",
+    "YOLOv8lPose",
+    "YOLOv8mPose",
+    "YOLOv8nPose",
+    "YOLOv8sPose",
+    "YOLOv8xPose",
+    "YOLOv8xPoseP6",
+]
+
+YOLO11lPose = create_model_class("YOLO11lPose", __name__)
+YOLO11mPose = create_model_class("YOLO11mPose", __name__)
+YOLO11nPose = create_model_class("YOLO11nPose", __name__)
+YOLO11sPose = create_model_class("YOLO11sPose", __name__)
+YOLO11xPose = create_model_class("YOLO11xPose", __name__)
+YOLO26lPose = create_model_class("YOLO26lPose", __name__)
+YOLO26mPose = create_model_class("YOLO26mPose", __name__)
+YOLO26nPose = create_model_class("YOLO26nPose", __name__)
+YOLO26sPose = create_model_class("YOLO26sPose", __name__)
+YOLO26xPose = create_model_class("YOLO26xPose", __name__)
+YOLOv8lPose = create_model_class("YOLOv8lPose", __name__)
+YOLOv8mPose = create_model_class("YOLOv8mPose", __name__)
+YOLOv8nPose = create_model_class("YOLOv8nPose", __name__)
+YOLOv8sPose = create_model_class("YOLOv8sPose", __name__)
+YOLOv8xPose = create_model_class("YOLOv8xPose", __name__)
+YOLOv8xPoseP6 = create_model_class("YOLOv8xPoseP6", __name__)

mblt_vision/py.typed

@@ -0,0 +1 @@
+# PEP 561 marker: mblt_vision ships inline type information.

mblt_vision/semantic_segmentation/__init__.py

@@ -0,0 +1,29 @@
+"""Semantic segmentation model exports."""
+
+from __future__ import annotations
+
+from .._compat import create_model_class
+
+__all__: list[str] = [
+    "YOLO26lSem",
+    "YOLO26lSemADE20K",
+    "YOLO26mSem",
+    "YOLO26mSemADE20K",
+    "YOLO26nSem",
+    "YOLO26nSemADE20K",
+    "YOLO26sSem",
+    "YOLO26sSemADE20K",
+    "YOLO26xSem",
+    "YOLO26xSemADE20K",
+]
+
+YOLO26lSem = create_model_class("YOLO26lSem", __name__)
+YOLO26lSemADE20K = create_model_class("YOLO26lSemADE20K", __name__)
+YOLO26mSem = create_model_class("YOLO26mSem", __name__)
+YOLO26mSemADE20K = create_model_class("YOLO26mSemADE20K", __name__)
+YOLO26nSem = create_model_class("YOLO26nSem", __name__)
+YOLO26nSemADE20K = create_model_class("YOLO26nSemADE20K", __name__)
+YOLO26sSem = create_model_class("YOLO26sSem", __name__)
+YOLO26sSemADE20K = create_model_class("YOLO26sSemADE20K", __name__)
+YOLO26xSem = create_model_class("YOLO26xSem", __name__)
+YOLO26xSemADE20K = create_model_class("YOLO26xSemADE20K", __name__)

mblt_vision/utils/datasets/__init__.py

@@ -0,0 +1,85 @@
+"""
+Datasets utilities and loaders.
+"""
+
+from __future__ import annotations
+
+from .ade20k import get_ade20k_palette
+from .cityscapes import get_cityscapes_palette
+from .coco import (
+    get_coco_class_num,
+    get_coco_det_palette,
+    get_coco_inv,
+    get_coco_keypoint_palette,
+    get_coco_label,
+    get_coco_limb_palette,
+    get_coco_pose_skeleton,
+)
+from .dataloader import (
+    CustomADE20K,
+    CustomCityscapes,
+    CustomCocodata,
+    CustomCOCODataset,
+    CustomDOTAv1,
+    CustomImageFolder,
+    CustomNYUDepth,
+    CustomWiderface,
+    CustomWiderFaceDataset,
+    get_ade20k_loader,
+    get_cityscapes_loader,
+    get_coco_loader,
+    get_dota_loader,
+    get_imagenet_loader,
+    get_nyu_depth_loader,
+    get_widerface_loader,
+)
+from .dotav1 import get_dotav1_class_num, get_dotav1_label, get_dotav1_palette
+from .imagenet import get_imagenet_label
+from .organizer import (
+    organize_ade20k,
+    organize_cityscapes,
+    organize_coco,
+    organize_dotav1,
+    organize_imagenet,
+    organize_nyu_depth,
+    organize_widerface,
+)
+
+__all__: list[str] = [
+    "get_ade20k_palette",
+    "get_cityscapes_palette",
+    "get_coco_class_num",
+    "get_coco_det_palette",
+    "get_coco_inv",
+    "get_coco_keypoint_palette",
+    "get_coco_label",
+    "get_coco_limb_palette",
+    "get_coco_pose_skeleton",
+    "get_dotav1_class_num",
+    "get_dotav1_label",
+    "get_dotav1_palette",
+    "CustomADE20K",
+    "CustomCityscapes",
+    "CustomCOCODataset",
+    "CustomCocodata",
+    "CustomDOTAv1",
+    "CustomImageFolder",
+    "CustomNYUDepth",
+    "CustomWiderFaceDataset",
+    "CustomWiderface",
+    "get_ade20k_loader",
+    "get_cityscapes_loader",
+    "get_coco_loader",
+    "get_dota_loader",
+    "get_imagenet_loader",
+    "get_nyu_depth_loader",
+    "get_widerface_loader",
+    "get_imagenet_label",
+    "organize_coco",
+    "organize_ade20k",
+    "organize_cityscapes",
+    "organize_dotav1",
+    "organize_imagenet",
+    "organize_nyu_depth",
+    "organize_widerface",
+]

mblt_vision/utils/datasets/ade20k.py

@@ -0,0 +1,41 @@
+"""
+ADE20K dataset constants and utilities.
+"""
+
+from __future__ import annotations
+
+ADE20K_PALETTE_BGR = [
+    (255, 42, 4),
+    (235, 219, 11),
+    (243, 243, 243),
+    (183, 223, 0),
+    (104, 31, 17),
+    (221, 111, 255),
+    (79, 68, 255),
+    (0, 237, 204),
+    (68, 243, 0),
+    (255, 0, 189),
+    (255, 180, 0),
+    (186, 0, 221),
+    (255, 255, 0),
+    (0, 192, 38),
+    (179, 255, 1),
+    (255, 36, 125),
+    (104, 0, 123),
+    (108, 27, 255),
+    (47, 109, 252),
+    (11, 255, 162),
+]
+
+
+def get_ade20k_palette(idx: int) -> tuple[int, int, int]:
+    """Get an ADE20K visualization color in OpenCV BGR order.
+
+    Args:
+        idx: ADE20K class index.
+
+    Returns:
+        BGR color tuple. Colors repeat when the index exceeds the palette length.
+    """
+
+    return ADE20K_PALETTE_BGR[idx % len(ADE20K_PALETTE_BGR)]

mblt_vision/utils/datasets/cityscapes.py

@@ -0,0 +1,66 @@
+"""Cityscapes dataset visualization utilities."""
+
+from __future__ import annotations
+
+import numpy as np
+
+# OpenCV images use BGR channel order. These are the official Cityscapes train-ID
+# colors converted from RGB so familiar classes retain their standard appearance.
+CITYSCAPES_PALETTE_BGR: tuple[tuple[int, int, int], ...] = (
+    (128, 64, 128),  # road
+    (232, 35, 244),  # sidewalk
+    (70, 70, 70),  # building
+    (156, 102, 102),  # wall
+    (153, 153, 190),  # fence
+    (153, 153, 153),  # pole
+    (30, 170, 250),  # traffic light
+    (0, 220, 220),  # traffic sign
+    (35, 142, 107),  # vegetation
+    (152, 251, 152),  # terrain
+    (180, 130, 70),  # sky
+    (60, 20, 220),  # person
+    (0, 0, 255),  # rider
+    (142, 0, 0),  # car
+    (70, 0, 0),  # truck
+    (100, 60, 0),  # bus
+    (100, 80, 0),  # train
+    (230, 0, 0),  # motorcycle
+    (32, 11, 119),  # bicycle
+)
+
+CITYSCAPES_SOURCE_IDS: tuple[int, ...] = (
+    7,
+    8,
+    11,
+    12,
+    13,
+    17,
+    *range(19, 29),
+    31,
+    32,
+    33,
+)
+CITYSCAPES_SOURCE_TO_TRAIN_ID = np.full(256, 255, dtype=np.uint8)
+CITYSCAPES_SOURCE_TO_TRAIN_ID[list(CITYSCAPES_SOURCE_IDS)] = np.arange(
+    19, dtype=np.uint8
+)
+
+
+def get_cityscapes_palette(class_id: int) -> tuple[int, int, int]:
+    """Return the BGR visualization color for a Cityscapes train ID.
+
+    Args:
+        class_id: Cityscapes train ID in the range 0 through 18.
+
+    Returns:
+        The corresponding color in OpenCV BGR order.
+
+    Raises:
+        ValueError: If ``class_id`` is outside the Cityscapes train-ID range.
+    """
+
+    if not 0 <= class_id < len(CITYSCAPES_PALETTE_BGR):
+        raise ValueError(
+            f"Cityscapes class ID must be in [0, {len(CITYSCAPES_PALETTE_BGR) - 1}]."
+        )
+    return CITYSCAPES_PALETTE_BGR[class_id]

mblt_vision/utils/datasets/coco.py

@@ -0,0 +1,243 @@
+"""
+COCO dataset constants and utilities.
+"""
+
+from __future__ import annotations
+
+from ...datasets import get_dataset_category_ids, get_dataset_class_names
+
+DET_PALETTE = [
+    (220, 20, 60),
+    (119, 11, 32),
+    (0, 0, 142),
+    (0, 0, 230),
+    (106, 0, 228),
+    (0, 60, 100),
+    (0, 80, 100),
+    (0, 0, 70),
+    (0, 0, 192),
+    (250, 170, 30),
+    (100, 170, 30),
+    (220, 220, 0),
+    (175, 116, 175),
+    (250, 0, 30),
+    (165, 42, 42),
+    (255, 77, 255),
+    (0, 226, 252),
+    (182, 182, 255),
+    (0, 82, 0),
+    (120, 166, 157),
+    (110, 76, 0),
+    (174, 57, 255),
+    (199, 100, 0),
+    (72, 0, 118),
+    (255, 179, 240),
+    (0, 125, 92),
+    (209, 0, 151),
+    (188, 208, 182),
+    (0, 220, 176),
+    (255, 99, 164),
+    (92, 0, 73),
+    (133, 129, 255),
+    (78, 180, 255),
+    (0, 228, 0),
+    (174, 255, 243),
+    (45, 89, 255),
+    (134, 134, 103),
+    (145, 148, 174),
+    (255, 208, 186),
+    (197, 226, 255),
+    (171, 134, 1),
+    (109, 63, 54),
+    (207, 138, 255),
+    (151, 0, 95),
+    (9, 80, 61),
+    (84, 105, 51),
+    (74, 65, 105),
+    (166, 196, 102),
+    (208, 195, 210),
+    (255, 109, 65),
+    (0, 143, 149),
+    (179, 0, 194),
+    (209, 99, 106),
+    (5, 121, 0),
+    (227, 255, 205),
+    (147, 186, 208),
+    (153, 69, 1),
+    (3, 95, 161),
+    (163, 255, 0),
+    (119, 0, 170),
+    (0, 182, 199),
+    (0, 165, 120),
+    (183, 130, 88),
+    (95, 32, 0),
+    (130, 114, 135),
+    (110, 129, 133),
+    (166, 74, 118),
+    (219, 142, 185),
+    (79, 210, 114),
+    (178, 90, 62),
+    (65, 70, 15),
+    (127, 167, 115),
+    (59, 105, 106),
+    (142, 108, 45),
+    (196, 172, 0),
+    (95, 54, 80),
+    (128, 76, 255),
+    (201, 57, 1),
+    (246, 0, 122),
+    (191, 162, 208),
+]
+
+POSE_PALETTE = [
+    [255, 128, 0],
+    [255, 153, 51],
+    [255, 178, 102],
+    [230, 230, 0],
+    [255, 153, 255],
+    [153, 204, 255],
+    [255, 102, 255],
+    [255, 51, 255],
+    [102, 178, 255],
+    [51, 153, 255],
+    [255, 153, 153],
+    [255, 102, 102],
+    [255, 51, 51],
+    [153, 255, 153],
+    [102, 255, 102],
+    [51, 255, 51],
+    [0, 255, 0],
+    [0, 0, 255],
+    [255, 0, 0],
+    [255, 255, 255],
+]
+
+POSE_SKELETON = [
+    [16, 14],
+    [14, 12],
+    [17, 15],
+    [15, 13],
+    [12, 13],
+    [6, 12],
+    [7, 13],
+    [6, 7],
+    [6, 8],
+    [7, 9],
+    [8, 10],
+    [9, 11],
+    [2, 3],
+    [1, 2],
+    [1, 3],
+    [2, 4],
+    [3, 5],
+    [4, 6],
+    [5, 7],
+]
+
+LIMB_PALETTE = [
+    POSE_PALETTE[i]
+    for i in [9, 9, 9, 9, 7, 7, 7, 0, 0, 0, 0, 0, 16, 16, 16, 16, 16, 16, 16]
+]
+KEYPOINT_PALETTE = [
+    POSE_PALETTE[i] for i in [16, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9]
+]
+
+
+def get_coco_class_num() -> int:
+    """Get the number of COCO classes.
+
+    Returns:
+        int: The number of COCO classes.
+    """
+    return len(get_dataset_class_names("coco"))
+
+
+def get_coco_label(idx: int) -> str:
+    """
+    Get the COCO class label for a given index.
+
+    Args:
+        idx (int): Zero-based class index.
+
+    Returns:
+        str: Descriptive label for the class (e.g., "person").
+
+    Raises:
+        ValueError: If index is out of range.
+    """
+    if not 0 <= idx < get_coco_class_num():
+        raise ValueError(
+            f"COCO class index must be in [0, {get_coco_class_num() - 1}], got {idx}."
+        )
+
+    return get_dataset_class_names("coco")[idx]
+
+
+def get_coco_inv(idx: int) -> int:
+    """Get the original COCO category ID for a given model output index.
+
+    Args:
+        idx (int): Model output class index.
+
+    Returns:
+        int: Original COCO category ID.
+    """
+    return get_dataset_category_ids("coco")[idx]
+
+
+def get_coco_det_palette(idx: int) -> tuple[int, int, int]:
+    """
+    Get a distinct color for a COCO detection class.
+
+    Args:
+        idx (int): Class index.
+
+    Returns:
+        tuple[int, int, int]: (R, G, B) color tuple.
+    """
+    return DET_PALETTE[idx]
+
+
+def get_coco_pose_palette(idx: int) -> list[int]:
+    """Get the COCO pose palette by index.
+
+    Args:
+        idx (int): The index of the COCO pose palette.
+
+    Returns:
+        list[int]: The COCO pose palette as an [R, G, B] list.
+    """
+    return POSE_PALETTE[idx]
+
+
+def get_coco_pose_skeleton() -> list[list[int]]:
+    """Get the COCO pose skeleton.
+
+    Returns:
+        list[list[int]]: The COCO pose skeleton.
+    """
+    return POSE_SKELETON
+
+
+def get_coco_limb_palette(idx: int) -> list[int]:
+    """Get the COCO limb palette by index.
+
+    Args:
+        idx (int): The index of the COCO limb palette.
+
+    Returns:
+        list[int]: The COCO limb palette as an [R, G, B] list.
+    """
+    return LIMB_PALETTE[idx]
+
+
+def get_coco_keypoint_palette(idx: int) -> list[int]:
+    """Get the COCO keypoint palette by index.
+
+    Args:
+        idx (int): The index of the COCO keypoint palette.
+
+    Returns:
+        list[int]: The COCO keypoint palette as an [R, G, B] list.
+    """
+    return KEYPOINT_PALETTE[idx]