segment-toolkit 1.0.0__tar.gz

segment_toolkit-1.0.0/PKG-INFO

@@ -0,0 +1,217 @@
+Metadata-Version: 2.4
+Name: segment_toolkit
+Version: 1.0.0
+Summary: A Python toolkit to convert between binary segmentation masks and YOLO labels
+Author: Antigravity
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Requires-Dist: pillow
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Segment Toolkit 🛠️
+
+A modern, robust, and premium Python package designed to bridge the gap between pixel-level **binary segmentation masks** and **YOLO bounding box labels**. It provides a bidirectional pipeline with exception handling, extensive logging, a command-line interface (CLI), and a Python API.
+
+---
+
+## 📌 Features
+
+- **Bidirectional Conversion**:
+  - **Forward Pipeline**: Convert binary masks to YOLO format labels (supports standard axis-aligned or advanced minimum area rotated bounding boxes).
+  - **Reverse Pipeline**: Reconstruct binary masks from YOLO labels.
+- **Automatic Dependency Installer**: Missing required packages (`numpy`, `opencv-python`, `pillow`, `pandas`, `matplotlib`) are automatically detected and installed via `pip` upon package import or script execution.
+- **Robust Exception Handling**: Try-catch blocks wrapped around file I/O, contour finding, and resizing to prevent application crashes on corrupted or missing files.
+- **Dynamic Dataset Matching**: Read classification mappings (in **CSV** or **JSON** format) to automatically assign multi-class IDs matching standard dataset schemas (like the ISIC dataset).
+- **YOLO Dataset Splitting**: Automatically shuffles and partitions images & labels into training and testing sets with customizable split ratios, creating standard `data.yaml` configs.
+- **Overlay Visualizer**: Overlay bounding boxes and class indicators directly onto source images for annotation inspection.
+- **Dual Interface**: Use as a command-line application (`segment-toolkit`) or import as a Python library (`import segment_toolkit`).
+
+---
+
+## 📂 Installation
+
+To install the toolkit locally in editable mode (missing dependencies will install automatically):
+
+```bash
+pip install -e .
+```
+
+### Manual Installation
+If you prefer to install dependencies manually before installing the toolkit:
+
+```bash
+pip install -r requirements.txt
+pip install .
+```
+
+---
+
+## 🚀 Usage
+
+### 1. Command Line Interface (CLI)
+
+The package installs a console script called `segment-toolkit`.
+
+#### Convert Masks to YOLO Labels
+- **Single File Conversion**:
+  ```bash
+  segment-toolkit mask-to-yolo \
+    --image images/ISIC_0024310.jpg \
+    --mask mask/ISIC_0024310_segmentation.png \
+    --output-txt labels/ISIC_0024310.txt \
+    --class-id 4
+  ```
+
+- **Batch Directory Conversion**:
+  ```bash
+  segment-toolkit mask-to-yolo \
+    --image-dir images/ \
+    --mask-dir mask/ \
+    --output-dir labels/ \
+    --ground-truth GroundTruth.csv
+  ```
+
+- **Options**:
+  - `--rotated`: Use rotated minimum area rectangles (`cv2.minAreaRect`) instead of standard axis-aligned rectangles.
+  - `--resize WIDTH HEIGHT`: Set target size for image and mask resizing (default: `640 640`).
+
+#### Convert YOLO Labels to Masks
+- **Single File Conversion**:
+  ```bash
+  segment-toolkit yolo-to-mask \
+    --label labels/ISIC_0024310.txt \
+    --output-mask masks_reconstructed/ISIC_0024310_segmentation.png
+  ```
+
+- **Batch Directory Conversion**:
+  ```bash
+  segment-toolkit yolo-to-mask \
+    --label-dir labels/ \
+    --output-dir masks_reconstructed/
+  ```
+
+#### Visualize Bounding Boxes
+Draw YOLO labels on top of the original image:
+```bash
+segment-toolkit visualize \
+  --image images/ISIC_0024310.jpg \
+  --label labels/ISIC_0024310.txt \
+  --output visualization.png
+```
+
+#### Split Dataset
+Organize folders into YOLO-compliant structure (`dataset/train` and `dataset/test` splits) and output `data.yaml`:
+```bash
+segment-toolkit split \
+  --images images/ \
+  --labels labels/ \
+  --output dataset/ \
+  --ratio 0.8 \
+  --seed 42
+```
+
+---
+
+### 2. Ground Truth Formats
+
+The `--ground-truth` parameter in batch conversion supports both CSV and JSON formats.
+
+#### CSV Format
+Assumes the first column contains the image identifier/filename, and the subsequent columns represent binary indicator classes (where `1` indicates class presence).
+Example `GroundTruth.csv`:
+```csv
+image,MEL,NV,BCC,AKIEC,BKL,DF,VASC
+ISIC_0024306,0,1,0,0,0,0,0
+ISIC_0024310,1,0,0,0,0,0,0
+```
+
+#### JSON Format
+Supports three distinct schemas:
+
+1. **Flat Dictionary (Format A)**:
+   Maps image IDs directly to class integers or class name strings.
+   ```json
+   {
+     "ISIC_0024306": 5,
+     "ISIC_0024310": "MEL"
+   }
+   ```
+
+2. **Nested Indicators (Format B)**:
+   Maps image IDs to dictionaries of binary class indicators.
+   ```json
+   {
+     "ISIC_0024306": { "MEL": 0, "NV": 1, "BCC": 0 },
+     "ISIC_0024310": { "MEL": 1, "NV": 0, "BCC": 0 }
+   }
+   ```
+
+3. **List of Records (Format C)**:
+   A list of objects containing image IDs and class descriptors.
+   ```json
+   [
+     { "image": "ISIC_0024306", "class_id": 5 },
+     { "image": "ISIC_0024310", "MEL": 1, "NV": 0 }
+   ]
+   ```
+
+*Note: Class name strings (like `"MEL"`, `"NV"`) are automatically mapped to standard ISIC IDs (`AKIEC=0, BCC=1, BKL=2, DF=3, MEL=4, NV=5, VASC=6`). Custom column names default to index-based IDs.*
+
+---
+
+### 3. Python API
+
+Import classes directly into your code to programmatically build custom pipelines:
+
+```python
+from segment_toolkit import MaskToYoloConverter, YoloToMaskConverter
+
+# 1. Convert mask to YOLO label
+yolo_conv = MaskToYoloConverter(target_size=(640, 640), bbox_type="standard")
+yolo_conv.convert_single(
+    image_path="images/ISIC_0024310.jpg",
+    mask_path="mask/ISIC_0024310_segmentation.png",
+    output_txt_path="labels/ISIC_0024310.txt",
+    class_id=4
+)
+
+# 2. Batch convert a folder of masks with a JSON ground truth
+yolo_conv.convert_dataset(
+    images_dir="images",
+    masks_dir="mask",
+    output_labels_dir="labels",
+    ground_truth="GroundTruth.json"
+)
+```
+
+---
+
+## 🧠 Technical Details
+
+### Coordinate Conversion Math
+
+#### Bounding Box Center Calculation (Pixel Space)
+For standard bounding boxes, the pixel coordinates from `boundingRect` are $(x_{min}, y_{min}, w_{pixel}, h_{pixel})$.
+$$\text{Center } X \quad x_{center} = x_{min} + \frac{w_{pixel}}{2.0}$$
+$$\text{Center } Y \quad y_{center} = y_{min} + \frac{h_{pixel}}{2.0}$$
+
+#### Coordinate Normalization (YOLO Format)
+All coordinates are normalized to the range $[0.0, 1.0]$:
+$$x_{norm} = \frac{x_{center}}{img\_width}, \quad y_{norm} = \frac{y_{center}}{img\_height}$$
+$$w_{norm} = \frac{w_{pixel}}{img\_width}, \quad h_{norm} = \frac{h_{pixel}}{img\_height}$$
+
+---
+
+## 🧑‍💻 Author
+**Zakria Gamal**
+- Computer Vision & AI Engineer
+- 🧠 LinkedIn: [Zakria Gamal](https://www.linkedin.com/in/zkaria-gamal-82b486267/)

segment_toolkit-1.0.0/README.md

@@ -0,0 +1,198 @@
+# Segment Toolkit 🛠️
+
+A modern, robust, and premium Python package designed to bridge the gap between pixel-level **binary segmentation masks** and **YOLO bounding box labels**. It provides a bidirectional pipeline with exception handling, extensive logging, a command-line interface (CLI), and a Python API.
+
+---
+
+## 📌 Features
+
+- **Bidirectional Conversion**:
+  - **Forward Pipeline**: Convert binary masks to YOLO format labels (supports standard axis-aligned or advanced minimum area rotated bounding boxes).
+  - **Reverse Pipeline**: Reconstruct binary masks from YOLO labels.
+- **Automatic Dependency Installer**: Missing required packages (`numpy`, `opencv-python`, `pillow`, `pandas`, `matplotlib`) are automatically detected and installed via `pip` upon package import or script execution.
+- **Robust Exception Handling**: Try-catch blocks wrapped around file I/O, contour finding, and resizing to prevent application crashes on corrupted or missing files.
+- **Dynamic Dataset Matching**: Read classification mappings (in **CSV** or **JSON** format) to automatically assign multi-class IDs matching standard dataset schemas (like the ISIC dataset).
+- **YOLO Dataset Splitting**: Automatically shuffles and partitions images & labels into training and testing sets with customizable split ratios, creating standard `data.yaml` configs.
+- **Overlay Visualizer**: Overlay bounding boxes and class indicators directly onto source images for annotation inspection.
+- **Dual Interface**: Use as a command-line application (`segment-toolkit`) or import as a Python library (`import segment_toolkit`).
+
+---
+
+## 📂 Installation
+
+To install the toolkit locally in editable mode (missing dependencies will install automatically):
+
+```bash
+pip install -e .
+```
+
+### Manual Installation
+If you prefer to install dependencies manually before installing the toolkit:
+
+```bash
+pip install -r requirements.txt
+pip install .
+```
+
+---
+
+## 🚀 Usage
+
+### 1. Command Line Interface (CLI)
+
+The package installs a console script called `segment-toolkit`.
+
+#### Convert Masks to YOLO Labels
+- **Single File Conversion**:
+  ```bash
+  segment-toolkit mask-to-yolo \
+    --image images/ISIC_0024310.jpg \
+    --mask mask/ISIC_0024310_segmentation.png \
+    --output-txt labels/ISIC_0024310.txt \
+    --class-id 4
+  ```
+
+- **Batch Directory Conversion**:
+  ```bash
+  segment-toolkit mask-to-yolo \
+    --image-dir images/ \
+    --mask-dir mask/ \
+    --output-dir labels/ \
+    --ground-truth GroundTruth.csv
+  ```
+
+- **Options**:
+  - `--rotated`: Use rotated minimum area rectangles (`cv2.minAreaRect`) instead of standard axis-aligned rectangles.
+  - `--resize WIDTH HEIGHT`: Set target size for image and mask resizing (default: `640 640`).
+
+#### Convert YOLO Labels to Masks
+- **Single File Conversion**:
+  ```bash
+  segment-toolkit yolo-to-mask \
+    --label labels/ISIC_0024310.txt \
+    --output-mask masks_reconstructed/ISIC_0024310_segmentation.png
+  ```
+
+- **Batch Directory Conversion**:
+  ```bash
+  segment-toolkit yolo-to-mask \
+    --label-dir labels/ \
+    --output-dir masks_reconstructed/
+  ```
+
+#### Visualize Bounding Boxes
+Draw YOLO labels on top of the original image:
+```bash
+segment-toolkit visualize \
+  --image images/ISIC_0024310.jpg \
+  --label labels/ISIC_0024310.txt \
+  --output visualization.png
+```
+
+#### Split Dataset
+Organize folders into YOLO-compliant structure (`dataset/train` and `dataset/test` splits) and output `data.yaml`:
+```bash
+segment-toolkit split \
+  --images images/ \
+  --labels labels/ \
+  --output dataset/ \
+  --ratio 0.8 \
+  --seed 42
+```
+
+---
+
+### 2. Ground Truth Formats
+
+The `--ground-truth` parameter in batch conversion supports both CSV and JSON formats.
+
+#### CSV Format
+Assumes the first column contains the image identifier/filename, and the subsequent columns represent binary indicator classes (where `1` indicates class presence).
+Example `GroundTruth.csv`:
+```csv
+image,MEL,NV,BCC,AKIEC,BKL,DF,VASC
+ISIC_0024306,0,1,0,0,0,0,0
+ISIC_0024310,1,0,0,0,0,0,0
+```
+
+#### JSON Format
+Supports three distinct schemas:
+
+1. **Flat Dictionary (Format A)**:
+   Maps image IDs directly to class integers or class name strings.
+   ```json
+   {
+     "ISIC_0024306": 5,
+     "ISIC_0024310": "MEL"
+   }
+   ```
+
+2. **Nested Indicators (Format B)**:
+   Maps image IDs to dictionaries of binary class indicators.
+   ```json
+   {
+     "ISIC_0024306": { "MEL": 0, "NV": 1, "BCC": 0 },
+     "ISIC_0024310": { "MEL": 1, "NV": 0, "BCC": 0 }
+   }
+   ```
+
+3. **List of Records (Format C)**:
+   A list of objects containing image IDs and class descriptors.
+   ```json
+   [
+     { "image": "ISIC_0024306", "class_id": 5 },
+     { "image": "ISIC_0024310", "MEL": 1, "NV": 0 }
+   ]
+   ```
+
+*Note: Class name strings (like `"MEL"`, `"NV"`) are automatically mapped to standard ISIC IDs (`AKIEC=0, BCC=1, BKL=2, DF=3, MEL=4, NV=5, VASC=6`). Custom column names default to index-based IDs.*
+
+---
+
+### 3. Python API
+
+Import classes directly into your code to programmatically build custom pipelines:
+
+```python
+from segment_toolkit import MaskToYoloConverter, YoloToMaskConverter
+
+# 1. Convert mask to YOLO label
+yolo_conv = MaskToYoloConverter(target_size=(640, 640), bbox_type="standard")
+yolo_conv.convert_single(
+    image_path="images/ISIC_0024310.jpg",
+    mask_path="mask/ISIC_0024310_segmentation.png",
+    output_txt_path="labels/ISIC_0024310.txt",
+    class_id=4
+)
+
+# 2. Batch convert a folder of masks with a JSON ground truth
+yolo_conv.convert_dataset(
+    images_dir="images",
+    masks_dir="mask",
+    output_labels_dir="labels",
+    ground_truth="GroundTruth.json"
+)
+```
+
+---
+
+## 🧠 Technical Details
+
+### Coordinate Conversion Math
+
+#### Bounding Box Center Calculation (Pixel Space)
+For standard bounding boxes, the pixel coordinates from `boundingRect` are $(x_{min}, y_{min}, w_{pixel}, h_{pixel})$.
+$$\text{Center } X \quad x_{center} = x_{min} + \frac{w_{pixel}}{2.0}$$
+$$\text{Center } Y \quad y_{center} = y_{min} + \frac{h_{pixel}}{2.0}$$
+
+#### Coordinate Normalization (YOLO Format)
+All coordinates are normalized to the range $[0.0, 1.0]$:
+$$x_{norm} = \frac{x_{center}}{img\_width}, \quad y_{norm} = \frac{y_{center}}{img\_height}$$
+$$w_{norm} = \frac{w_{pixel}}{img\_width}, \quad h_{norm} = \frac{h_{pixel}}{img\_height}$$
+
+---
+
+## 🧑‍💻 Author
+**Zakria Gamal**
+- Computer Vision & AI Engineer
+- 🧠 LinkedIn: [Zakria Gamal](https://www.linkedin.com/in/zkaria-gamal-82b486267/)

segment_toolkit-1.0.0/segment_toolkit/__init__.py

@@ -0,0 +1,60 @@
+"""
+Segment Toolkit: A library and CLI tool for converting binary segmentation masks to YOLO labels and vice versa.
+"""
+
+__version__ = "1.0.0"
+
+import sys
+import subprocess
+
+def _ensure_dependencies():
+    """
+    Checks for required external modules and attempts to install them via pip if missing.
+    """
+    dependencies = {
+        "numpy": "numpy",
+        "cv2": "opencv-python",
+        "PIL": "pillow",
+        "pandas": "pandas",
+        "matplotlib": "matplotlib"
+    }
+    missing = []
+    for module, pip_name in dependencies.items():
+        try:
+            __import__(module)
+        except ImportError:
+            missing.append(pip_name)
+            
+    if missing:
+        print(f"[segment_toolkit] Missing required package(s): {', '.join(missing)}", file=sys.stderr)
+        print("[segment_toolkit] Attempting to auto-install dependencies...", file=sys.stderr)
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", *missing])
+            print("[segment_toolkit] Dependencies installed successfully.", file=sys.stderr)
+        except Exception as err:
+            print(f"[segment_toolkit] Error: Auto-installation of dependencies failed: {err}", file=sys.stderr)
+            print("[segment_toolkit] Please install them manually using: pip install -r requirements.txt", file=sys.stderr)
+
+# Check and install dependencies before importing other submodules
+_ensure_dependencies()
+
+from .source import MaskToYoloConverter, YoloToMaskConverter
+from .helpers import (
+    safe_read_image,
+    preprocess_image,
+    get_largest_contour,
+    calculate_bbox,
+    normalize_coordinates,
+    denormalize_coordinates,
+)
+
+__all__ = [
+    "MaskToYoloConverter",
+    "YoloToMaskConverter",
+    "safe_read_image",
+    "preprocess_image",
+    "get_largest_contour",
+    "calculate_bbox",
+    "normalize_coordinates",
+    "denormalize_coordinates",
+]

segment_toolkit-1.0.0/segment_toolkit/cli.py

@@ -0,0 +1,192 @@
+"""
+Command Line Interface (CLI) for segment_toolkit.
+Exposes mask-to-yolo, yolo-to-mask, split, and visualize commands.
+"""
+
+import argparse
+import sys
+import logging
+from typing import List, Optional
+
+from .source import MaskToYoloConverter, YoloToMaskConverter
+
+# Configure basic logging
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def parse_args(args: List[str]) -> argparse.Namespace:
+    """
+    Parses command-line arguments.
+    """
+    parser = argparse.ArgumentParser(
+        description="Segment Toolkit: Convert segmentation masks to/from YOLO format annotations."
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Subcommands")
+
+    # subcommand: mask-to-yolo
+    m2y_parser = subparsers.add_parser(
+        "mask-to-yolo", help="Convert binary mask(s) to YOLO format labels."
+    )
+    m2y_parser.add_argument("--image", type=str, help="Path to a single input image.")
+    m2y_parser.add_argument("--mask", type=str, help="Path to a single input binary mask.")
+    m2y_parser.add_argument("--output-txt", type=str, help="Output file path for single YOLO label txt.")
+    
+    m2y_parser.add_argument("--image-dir", type=str, help="Directory containing input images.")
+    m2y_parser.add_argument("--mask-dir", type=str, help="Directory containing input masks.")
+    m2y_parser.add_argument("--output-dir", type=str, help="Directory to save generated YOLO label files.")
+
+    m2y_parser.add_argument("--class-id", type=int, default=0, help="Default Class ID to write (default: 0).")
+    m2y_parser.add_argument(
+        "--ground-truth",
+        type=str,
+        help="Path to GroundTruth.csv mapping images to multi-class columns.",
+    )
+    m2y_parser.add_argument(
+        "--rotated",
+        action="store_true",
+        help="Use rotated minimum area rectangle (minAreaRect) instead of axis-aligned.",
+    )
+    m2y_parser.add_argument(
+        "--resize",
+        type=int,
+        nargs=2,
+        default=[640, 640],
+        metavar=("WIDTH", "HEIGHT"),
+        help="Target dimensions for resizing (default: 640 640).",
+    )
+
+    # subcommand: yolo-to-mask
+    y2m_parser = subparsers.add_parser(
+        "yolo-to-mask", help="Convert YOLO format label(s) to binary mask(s)."
+    )
+    y2m_parser.add_argument("--label", type=str, help="Path to a single input YOLO label txt file.")
+    y2m_parser.add_argument("--output-mask", type=str, help="Output path for single binary mask png.")
+
+    y2m_parser.add_argument("--label-dir", type=str, help="Directory containing YOLO label txt files.")
+    y2m_parser.add_argument("--output-dir", type=str, help="Directory to save generated binary mask png files.")
+
+    y2m_parser.add_argument(
+        "--resize",
+        type=int,
+        nargs=2,
+        default=[640, 640],
+        metavar=("WIDTH", "HEIGHT"),
+        help="Output mask dimensions (default: 640 640).",
+    )
+
+    # subcommand: split
+    split_parser = subparsers.add_parser(
+        "split", help="Randomly split a dataset of images and labels into train/test subfolders."
+    )
+    split_parser.add_argument("--images", type=str, required=True, help="Directory of source images.")
+    split_parser.add_argument("--labels", type=str, required=True, help="Directory of source YOLO label txt files.")
+    split_parser.add_argument("--output", type=str, required=True, help="Root directory for split dataset outputs.")
+    split_parser.add_argument(
+        "--ratio", type=float, default=0.8, help="Split ratio for training partition (default: 0.8)."
+    )
+    split_parser.add_argument("--seed", type=int, default=42, help="Seed value for reproduction (default: 42).")
+
+    # subcommand: visualize
+    vis_parser = subparsers.add_parser(
+        "visualize", help="Draw bounding boxes from a YOLO label file onto the source image."
+    )
+    vis_parser.add_argument("--image", type=str, required=True, help="Path to the source image.")
+    vis_parser.add_argument("--label", type=str, required=True, help="Path to the YOLO label file.")
+    vis_parser.add_argument("--output", type=str, required=True, help="Path to save output visualization image.")
+    vis_parser.add_argument(
+        "--resize",
+        type=int,
+        nargs=2,
+        default=[640, 640],
+        metavar=("WIDTH", "HEIGHT"),
+        help="Resize image for visualization (default: 640 640).",
+    )
+
+    return parser.parse_args(args)
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """
+    Main entry point for command-line execution.
+    """
+    if args is None:
+        args = sys.argv[1:]
+
+    try:
+        parsed = parse_args(args)
+
+        if parsed.command == "mask-to-yolo":
+            converter = MaskToYoloConverter(
+                target_size=(parsed.resize[0], parsed.resize[1]),
+                bbox_type="rotated" if parsed.rotated else "standard",
+            )
+            # Check if processing single file or folder
+            if parsed.image or parsed.mask or parsed.output_txt:
+                if not (parsed.image and parsed.mask and parsed.output_txt):
+                    logger.error("Error: --image, --mask, and --output-txt must all be specified for single conversion.")
+                    return 1
+                success = converter.convert_single(
+                    parsed.image, parsed.mask, parsed.output_txt, class_id=parsed.class_id
+                )
+                return 0 if success else 1
+            elif parsed.image_dir or parsed.mask_dir or parsed.output_dir:
+                if not (parsed.image_dir and parsed.mask_dir and parsed.output_dir):
+                    logger.error("Error: --image-dir, --mask-dir, and --output-dir must all be specified for folder conversion.")
+                    return 1
+                converter.convert_dataset(
+                    parsed.image_dir,
+                    parsed.mask_dir,
+                    parsed.output_dir,
+                    default_class_id=parsed.class_id,
+                    ground_truth=parsed.ground_truth,
+                )
+                return 0
+            else:
+                logger.error("Error: Must specify either single file arguments (--image, --mask, --output-txt) or directory arguments (--image-dir, --mask-dir, --output-dir).")
+                return 1
+
+        elif parsed.command == "yolo-to-mask":
+            converter = YoloToMaskConverter(target_size=(parsed.resize[0], parsed.resize[1]))
+            if parsed.label or parsed.output_mask:
+                if not (parsed.label and parsed.output_mask):
+                    logger.error("Error: Both --label and --output-mask must be specified for single conversion.")
+                    return 1
+                success = converter.convert_single(parsed.label, parsed.output_mask)
+                return 0 if success else 1
+            elif parsed.label_dir or parsed.output_dir:
+                if not (parsed.label_dir and parsed.output_dir):
+                    logger.error("Error: Both --label-dir and --output-dir must be specified for folder conversion.")
+                    return 1
+                converter.convert_dataset(parsed.label_dir, parsed.output_dir)
+                return 0
+            else:
+                logger.error("Error: Must specify either single file arguments (--label, --output-mask) or directory arguments (--label-dir, --output-dir).")
+                return 1
+
+        elif parsed.command == "split":
+            converter = MaskToYoloConverter()
+            converter.split_dataset(
+                images_dir=parsed.images,
+                labels_dir=parsed.labels,
+                output_dataset_dir=parsed.output,
+                split_ratio=parsed.ratio,
+                seed=parsed.seed,
+            )
+            return 0
+
+        elif parsed.command == "visualize":
+            converter = YoloToMaskConverter(target_size=(parsed.resize[0], parsed.resize[1]))
+            success = converter.visualize_label(parsed.image, parsed.label, parsed.output)
+            return 0 if success else 1
+
+    except Exception as e:
+        logger.error(f"Execution failed: {str(e)}")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())