argus-cv 1.4.0__tar.gz → 1.5.0__tar.gz

{argus_cv-1.4.0 → argus_cv-1.5.0}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 <!-- version list -->
 
+## v1.5.0 (2026-01-28)
+
+### Features
+
+- Support Roboflow COCO format and improve YOLO classification detection
+  ([`902a59f`](https://github.com/pirnerjonas/argus/commit/902a59fbb506aa586d8677312d21ae240585b511))
+
+
 ## v1.4.0 (2026-01-26)
 
 ### Features

{argus_cv-1.4.0 → argus_cv-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-cv
-Version: 1.4.0
+Version: 1.5.0
 Summary: CLI tool for working with vision AI datasets
 Requires-Python: >=3.10
 Requires-Dist: numpy>=1.24.0

{argus_cv-1.4.0 → argus_cv-1.5.0}/docs/guides/datasets.md

@@ -59,6 +59,26 @@ dataset/
 If your annotation filenames include `train`, `val`, or `test`, Argus will treat
 those as splits. Otherwise it defaults to `train`.
 
+### Roboflow COCO
+
+Argus also supports the Roboflow variant of COCO format, where annotations live
+inside split directories:
+
+```text
+dataset/
+├── train/
+│   ├── _annotations.coco.json
+│   └── *.jpg
+├── valid/
+│   ├── _annotations.coco.json
+│   └── *.jpg
+└── test/
+    ├── _annotations.coco.json
+    └── *.jpg
+```
+
+Splits are detected from directory names (`train`, `valid`/`val`, `test`).
+
 ## Mask (semantic segmentation)
 
 Mask datasets are simple image + mask folders. Argus detects a few common

{argus_cv-1.4.0 → argus_cv-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "argus-cv"
-version = "1.4.0"
+version = "1.5.0"
 description = "CLI tool for working with vision AI datasets"
 readme = "README.md"
 requires-python = ">=3.10"

{argus_cv-1.4.0 → argus_cv-1.5.0}/src/argus/__init__.py

@@ -1,3 +1,3 @@
 """Argus - Vision AI dataset toolkit."""
 
-__version__ = "1.4.0"
+__version__ = "1.5.0"

{argus_cv-1.4.0 → argus_cv-1.5.0}/src/argus/cli.py

@@ -8,11 +8,18 @@ import cv2
 import numpy as np
 import typer
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskProgressColumn,
+    TextColumn,
+)
 from rich.table import Table
 
 from argus.core import COCODataset, Dataset, MaskDataset, YOLODataset
 from argus.core.base import DatasetFormat, TaskType
+from argus.core.convert import convert_mask_to_yolo_seg
 from argus.core.split import (
     is_coco_unsplit,
     parse_ratio,
@@ -632,6 +639,148 @@ def split_dataset(
     )
 
 
+@app.command(name="convert")
+def convert_dataset(
+    input_path: Annotated[
+        Path,
+        typer.Option(
+            "--input-path",
+            "-i",
+            help="Path to the source dataset.",
+        ),
+    ] = Path("."),
+    output_path: Annotated[
+        Path,
+        typer.Option(
+            "--output-path",
+            "-o",
+            help="Output directory for converted dataset.",
+        ),
+    ] = Path("converted"),
+    to_format: Annotated[
+        str,
+        typer.Option(
+            "--to",
+            help="Target format (currently only 'yolo-seg' is supported).",
+        ),
+    ] = "yolo-seg",
+    epsilon_factor: Annotated[
+        float,
+        typer.Option(
+            "--epsilon-factor",
+            "-e",
+            help="Polygon simplification factor (Douglas-Peucker algorithm).",
+            min=0.0,
+            max=1.0,
+        ),
+    ] = 0.005,
+    min_area: Annotated[
+        float,
+        typer.Option(
+            "--min-area",
+            "-a",
+            help="Minimum contour area in pixels to include.",
+            min=0.0,
+        ),
+    ] = 100.0,
+) -> None:
+    """Convert a dataset from one format to another.
+
+    Currently supports converting MaskDataset to YOLO segmentation format.
+
+    Example:
+        uvx argus-cv convert -i /path/to/masks -o /path/to/output --to yolo-seg
+    """
+    # Validate format
+    if to_format != "yolo-seg":
+        console.print(
+            f"[red]Error: Unsupported target format '{to_format}'.[/red]\n"
+            "[yellow]Currently only 'yolo-seg' is supported.[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    # Resolve and validate input path
+    input_path = input_path.resolve()
+    if not input_path.exists():
+        console.print(f"[red]Error: Path does not exist: {input_path}[/red]")
+        raise typer.Exit(1)
+    if not input_path.is_dir():
+        console.print(f"[red]Error: Path is not a directory: {input_path}[/red]")
+        raise typer.Exit(1)
+
+    # Detect source dataset - must be MaskDataset for yolo-seg conversion
+    dataset = MaskDataset.detect(input_path)
+    if not dataset:
+        console.print(
+            f"[red]Error: No MaskDataset found at {input_path}[/red]\n"
+            "[yellow]Ensure the path contains images/ + masks/ directories "
+            "(or equivalent patterns like img/+gt/ or leftImg8bit/+gtFine/).[/yellow]"
+        )
+        raise typer.Exit(1)
+
+    # Resolve output path
+    if not output_path.is_absolute():
+        output_path = input_path.parent / output_path
+    output_path = output_path.resolve()
+
+    # Check if output already exists
+    if output_path.exists() and any(output_path.iterdir()):
+        console.print(
+            f"[red]Error: Output directory already exists and is not empty: "
+            f"{output_path}[/red]"
+        )
+        raise typer.Exit(1)
+
+    # Show conversion info
+    console.print("[cyan]Converting MaskDataset to YOLO segmentation format[/cyan]")
+    console.print(f"  Source: {input_path}")
+    console.print(f"  Output: {output_path}")
+    console.print(f"  Classes: {dataset.num_classes}")
+    splits_str = ", ".join(dataset.splits) if dataset.splits else "unsplit"
+    console.print(f"  Splits: {splits_str}")
+    console.print()
+
+    # Run conversion with progress bar
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Processing images...", total=None)
+
+        def update_progress(current: int, total: int) -> None:
+            progress.update(task, completed=current, total=total)
+
+        try:
+            stats = convert_mask_to_yolo_seg(
+                dataset=dataset,
+                output_path=output_path,
+                epsilon_factor=epsilon_factor,
+                min_area=min_area,
+                progress_callback=update_progress,
+            )
+        except Exception as exc:
+            console.print(f"[red]Error during conversion: {exc}[/red]")
+            raise typer.Exit(1) from exc
+
+    # Show results
+    console.print()
+    console.print("[green]Conversion complete![/green]")
+    console.print(f"  Images processed: {stats['images']}")
+    console.print(f"  Labels created: {stats['labels']}")
+    console.print(f"  Polygons extracted: {stats['polygons']}")
+
+    if stats["skipped"] > 0:
+        skipped = stats["skipped"]
+        console.print(f"  [yellow]Skipped: {skipped} (no mask or empty)[/yellow]")
+    if stats["warnings"] > 0:
+        console.print(f"  [yellow]Warnings: {stats['warnings']}[/yellow]")
+
+    console.print(f"\n[cyan]Output dataset: {output_path}[/cyan]")
+
+
 class _ImageViewer:
     """Interactive image viewer with zoom and pan support."""
 

{argus_cv-1.4.0 → argus_cv-1.5.0}/src/argus/core/__init__.py

@@ -2,6 +2,13 @@
 
 from argus.core.base import Dataset
 from argus.core.coco import COCODataset
+from argus.core.convert import (
+    ConversionParams,
+    Polygon,
+    convert_mask_to_yolo_labels,
+    convert_mask_to_yolo_seg,
+    mask_to_polygons,
+)
 from argus.core.mask import ConfigurationError, MaskDataset
 from argus.core.split import split_coco_dataset, split_yolo_dataset
 from argus.core.yolo import YOLODataset
@@ -14,4 +21,9 @@ __all__ = [
     "ConfigurationError",
     "split_coco_dataset",
     "split_yolo_dataset",
+    "ConversionParams",
+    "Polygon",
+    "mask_to_polygons",
+    "convert_mask_to_yolo_labels",
+    "convert_mask_to_yolo_seg",
 ]

{argus_cv-1.4.0 → argus_cv-1.5.0}/src/argus/core/coco.py

@@ -75,6 +75,13 @@ class COCODataset(Dataset):
         # Also check root directory for single annotation file
         annotation_files.extend(path.glob("*.json"))
 
+        # Check split directories for Roboflow COCO format
+        for split_name in ["train", "valid", "val", "test"]:
+            split_dir = path / split_name
+            if split_dir.is_dir():
+                annotation_files.extend(split_dir.glob("*annotations*.json"))
+                annotation_files.extend(split_dir.glob("*coco*.json"))
+
         # Filter to only include files that might be COCO annotations
         # (exclude package.json, tsconfig.json, etc.)
         filtered_files = []
@@ -185,8 +192,10 @@ class COCODataset(Dataset):
                     if isinstance(cat, dict) and "id" in cat and "name" in cat:
                         id_to_name[cat["id"]] = cat["name"]
 
-                # Determine split from filename
-                split = self._get_split_from_filename(ann_file.stem)
+                # Determine split from filename or parent directory
+                split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
 
                 # Count annotations per category
                 split_counts: dict[str, int] = counts.get(split, {})
@@ -224,7 +233,9 @@ class COCODataset(Dataset):
                 if not isinstance(data, dict):
                     continue
 
-                split = self._get_split_from_filename(ann_file.stem)
+                split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
 
                 images = data.get("images", [])
                 annotations = data.get("annotations", [])
@@ -256,11 +267,12 @@ class COCODataset(Dataset):
         return counts
 
     @staticmethod
-    def _get_split_from_filename(filename: str) -> str:
-        """Extract split name from annotation filename.
+    def _get_split_from_filename(filename: str, parent_dir: str | None = None) -> str:
+        """Extract split name from annotation filename or parent directory.
 
         Args:
             filename: Annotation file stem (without extension).
+            parent_dir: Optional parent directory name (for Roboflow COCO format).
 
         Returns:
             Split name (train, val, test) or 'train' as default.
@@ -272,6 +284,17 @@ class COCODataset(Dataset):
             return "val"
         elif "test" in name_lower:
             return "test"
+
+        # Check parent directory name (Roboflow COCO format)
+        if parent_dir:
+            parent_lower = parent_dir.lower()
+            if parent_lower == "train":
+                return "train"
+            elif parent_lower in ("val", "valid"):
+                return "val"
+            elif parent_lower == "test":
+                return "test"
+
         return "train"
 
     @classmethod
@@ -301,7 +324,7 @@ class COCODataset(Dataset):
 
     @classmethod
     def _detect_splits(cls, annotation_files: list[Path]) -> list[str]:
-        """Detect available splits from annotation filenames.
+        """Detect available splits from annotation filenames or parent directories.
 
         Args:
             annotation_files: List of annotation file paths.
@@ -313,13 +336,22 @@ class COCODataset(Dataset):
 
         for ann_file in annotation_files:
             name_lower = ann_file.stem.lower()
+            parent_lower = ann_file.parent.name.lower()
 
+            # Check filename first
             if "train" in name_lower and "train" not in splits:
                 splits.append("train")
             elif "val" in name_lower and "val" not in splits:
                 splits.append("val")
             elif "test" in name_lower and "test" not in splits:
                 splits.append("test")
+            # Check parent directory (Roboflow COCO format)
+            elif parent_lower == "train" and "train" not in splits:
+                splits.append("train")
+            elif parent_lower in ("val", "valid") and "val" not in splits:
+                splits.append("val")
+            elif parent_lower == "test" and "test" not in splits:
+                splits.append("test")
 
         # If no splits detected from filenames, default to train
         if not splits:
@@ -342,7 +374,9 @@ class COCODataset(Dataset):
         for ann_file in self.annotation_files:
             # Filter by split if specified
             if split:
-                file_split = self._get_split_from_filename(ann_file.stem)
+                file_split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
                 if file_split != split:
                     continue
 
@@ -354,7 +388,9 @@ class COCODataset(Dataset):
                     continue
 
                 images = data.get("images", [])
-                file_split = self._get_split_from_filename(ann_file.stem)
+                file_split = self._get_split_from_filename(
+                    ann_file.stem, ann_file.parent.name
+                )
 
                 for img in images:
                     if not isinstance(img, dict) or "file_name" not in img:
@@ -371,6 +407,8 @@ class COCODataset(Dataset):
                         self.path / "images" / file_name,
                         self.path / file_split / file_name,
                         self.path / file_name,
+                        # Roboflow format: images alongside annotations
+                        ann_file.parent / file_name,
                     ]
 
                     for img_path in possible_paths:

argus_cv-1.5.0/src/argus/core/convert.py

@@ -0,0 +1,277 @@
+"""Conversion functions for dataset format transformation."""
+
+import logging
+import shutil
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+import cv2
+import numpy as np
+import yaml
+from numpy.typing import NDArray
+
+from argus.core.mask import MaskDataset
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ConversionParams:
+    """Parameters for mask-to-polygon conversion.
+
+    Attributes:
+        class_id: Class ID for the resulting polygon.
+        epsilon_factor: Douglas-Peucker simplification factor (relative to perimeter).
+        min_area: Minimum contour area in pixels to include.
+    """
+
+    class_id: int = 0
+    epsilon_factor: float = 0.005
+    min_area: float = 100.0
+
+
+@dataclass
+class Polygon:
+    """A polygon annotation with class ID and normalized points.
+
+    Attributes:
+        class_id: Class ID for this polygon.
+        points: List of (x, y) points normalized to [0, 1].
+    """
+
+    class_id: int
+    points: list[tuple[float, float]]
+
+    def to_yolo(self) -> str:
+        """Convert to YOLO segmentation format string.
+
+        Returns:
+            String in format: "class_id x1 y1 x2 y2 ... xn yn"
+        """
+        coords = " ".join(f"{x:.6f} {y:.6f}" for x, y in self.points)
+        return f"{self.class_id} {coords}"
+
+
+def mask_to_polygons(
+    mask: NDArray[np.uint8],
+    params: ConversionParams | None = None,
+) -> list[Polygon]:
+    """Convert a binary mask to simplified polygons.
+
+    Args:
+        mask: Binary mask (255 for foreground, 0 for background).
+        params: Conversion parameters. Uses defaults if None.
+
+    Returns:
+        List of Polygon objects with normalized coordinates.
+    """
+    if params is None:
+        params = ConversionParams()
+
+    h, w = mask.shape[:2]
+    polygons: list[Polygon] = []
+
+    # Find contours
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area < params.min_area:
+            continue
+
+        # Simplify polygon using Douglas-Peucker
+        perimeter = cv2.arcLength(contour, closed=True)
+        epsilon = params.epsilon_factor * perimeter
+        simplified = cv2.approxPolyDP(contour, epsilon, closed=True)
+
+        # Need at least 3 points for a valid polygon
+        if len(simplified) < 3:
+            continue
+
+        # Normalize coordinates to [0, 1]
+        points: list[tuple[float, float]] = []
+        for point in simplified:
+            x, y = point[0]
+            points.append((x / w, y / h))
+
+        polygons.append(Polygon(class_id=params.class_id, points=points))
+
+    return polygons
+
+
+def convert_mask_to_yolo_labels(
+    mask: np.ndarray,
+    class_ids: list[int],
+    epsilon_factor: float = 0.005,
+    min_area: float = 100.0,
+) -> list[str]:
+    """Convert a multi-class mask to YOLO label lines.
+
+    Args:
+        mask: Grayscale mask where pixel values represent class IDs.
+        class_ids: List of class IDs to extract (excluding ignore index).
+        epsilon_factor: Douglas-Peucker simplification factor.
+        min_area: Minimum contour area in pixels.
+
+    Returns:
+        List of YOLO format label strings.
+    """
+    lines: list[str] = []
+
+    for class_id in class_ids:
+        # Create binary mask for this class
+        binary_mask = (mask == class_id).astype(np.uint8) * 255
+
+        params = ConversionParams(
+            class_id=class_id,
+            epsilon_factor=epsilon_factor,
+            min_area=min_area,
+        )
+        polygons = mask_to_polygons(binary_mask, params)
+        lines.extend(poly.to_yolo() for poly in polygons)
+
+    return lines
+
+
+def convert_mask_to_yolo_seg(
+    dataset: MaskDataset,
+    output_path: Path,
+    epsilon_factor: float = 0.005,
+    min_area: float = 100.0,
+    progress_callback: Callable[[int, int], None] | None = None,
+) -> dict[str, int]:
+    """Convert a MaskDataset to YOLO segmentation format.
+
+    Args:
+        dataset: Source MaskDataset to convert.
+        output_path: Output directory for YOLO dataset.
+        epsilon_factor: Douglas-Peucker simplification factor.
+        min_area: Minimum contour area in pixels.
+        progress_callback: Optional callback(current, total) for progress updates.
+
+    Returns:
+        Dictionary with conversion statistics:
+        - "images": Total images processed
+        - "labels": Total label files created
+        - "polygons": Total polygons extracted
+        - "skipped": Images skipped (no mask or empty)
+        - "warnings": Number of warnings (dimension mismatch, etc.)
+    """
+    stats = {
+        "images": 0,
+        "labels": 0,
+        "polygons": 0,
+        "skipped": 0,
+        "warnings": 0,
+    }
+
+    # Create output directory structure
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    # Get class mapping and build id-to-name for data.yaml
+    class_mapping = dataset.get_class_mapping()
+    class_ids = sorted(class_mapping.keys())
+
+    # Build data.yaml content
+    data_yaml: dict = {
+        "path": ".",
+        "names": {i: class_mapping[i] for i in class_ids},
+    }
+
+    # Determine splits to process
+    splits = dataset.splits if dataset.splits else [None]
+
+    # Count total images for progress
+    total_images = 0
+    for split in splits:
+        total_images += len(dataset.get_image_paths(split))
+
+    current_image = 0
+
+    for split in splits:
+        split_name = split if split else "train"  # Default to train if unsplit
+
+        # Create directories
+        images_dir = output_path / "images" / split_name
+        labels_dir = output_path / "labels" / split_name
+        images_dir.mkdir(parents=True, exist_ok=True)
+        labels_dir.mkdir(parents=True, exist_ok=True)
+
+        # Add split to data.yaml
+        data_yaml[split_name] = f"images/{split_name}"
+
+        # Process images in this split
+        image_paths = dataset.get_image_paths(split)
+
+        for image_path in image_paths:
+            current_image += 1
+            if progress_callback:
+                progress_callback(current_image, total_images)
+
+            stats["images"] += 1
+
+            # Load mask
+            mask = dataset.load_mask(image_path)
+            if mask is None:
+                logger.warning(f"No mask found for {image_path.name}, skipping")
+                stats["skipped"] += 1
+                continue
+
+            # Load image to check dimensions
+            img = cv2.imread(str(image_path))
+            if img is None:
+                logger.warning(f"Could not load image {image_path.name}, skipping")
+                stats["skipped"] += 1
+                continue
+
+            # Check dimension match
+            if img.shape[:2] != mask.shape[:2]:
+                logger.warning(
+                    f"Dimension mismatch for {image_path.name}: "
+                    f"image={img.shape[:2]}, mask={mask.shape[:2]}"
+                )
+                stats["warnings"] += 1
+                # Continue anyway - mask might still be usable
+
+            # Get unique class IDs present in this mask (excluding ignore index)
+            unique_ids = [
+                int(v)
+                for v in np.unique(mask)
+                if v != dataset.ignore_index and v in class_ids
+            ]
+
+            if not unique_ids:
+                # Empty mask (only background/ignored)
+                logger.debug(f"Empty mask for {image_path.name}")
+                stats["skipped"] += 1
+                continue
+
+            # Convert mask to YOLO labels
+            label_lines = convert_mask_to_yolo_labels(
+                mask, unique_ids, epsilon_factor, min_area
+            )
+
+            if not label_lines:
+                # No polygons extracted (all contours too small)
+                logger.debug(f"No valid polygons for {image_path.name}")
+                stats["skipped"] += 1
+                continue
+
+            # Copy image to output
+            dest_image = images_dir / image_path.name
+            shutil.copy2(image_path, dest_image)
+
+            # Write label file
+            label_file = labels_dir / f"{image_path.stem}.txt"
+            label_file.write_text("\n".join(label_lines) + "\n")
+
+            stats["labels"] += 1
+            stats["polygons"] += len(label_lines)
+
+    # Write data.yaml
+    data_yaml_path = output_path / "data.yaml"
+    with open(data_yaml_path, "w") as f:
+        yaml.dump(data_yaml, f, default_flow_style=False, sort_keys=False)
+
+    return stats