dataset_loader.py

"""
Multimodal Robot Anomaly Detection Dataset Loader
Data Path Structure:
DATA_PATH/
├── train/
│   ├── Annotations/
│   │   ├── Normal_data/
│   │   │   └── {point_name}/
│   │   │       ├── {point_name}_visible_{timestamp}_frame_{frame_id}.jpg
│   │   │       ├── {point_name}_visible_{timestamp}_frame_{frame_id}.json
│   │   │       └── {point_name}_visible_{timestamp}_frame_{frame_id}.txt
│   │   └── Anomaly_data/
│   │       └── {anomaly_name}/
│   │           ├── {anomaly_name}.jpg
│   │           ├── {anomaly_name}.json
│   │           └── {anomaly_name}.txt
│   ├── Other_modalities/
│   │   └── {point_name}/
│   │       ├── {point_name}_visible_{timestamp}.mp4
│   │       ├── {point_name}_infrared_{timestamp}.mp4
│   │       ├── {point_name}_sensor_{timestamp}.txt
│   │       ├── {point_name}_point_cloud_{timestamp}.bag
│   │       └── {point_name}_audio_{timestamp}.wav
│   └── Parameters/
│       ├── Hardware/
│       └── Device_*.json
└── test/
    └── (same structure as train)
"""

import os
import json
from pathlib import Path
from dataclasses import dataclass, field
from typing import Optional, List, Dict, Any, Tuple, Literal
from enum import Enum
import torch
from torch.utils.data import Dataset
import cv2
import numpy as np


class DataSplit(Enum):
    TRAIN = "train"
    TEST = "test"


class DataType(Enum):
    NORMAL = "Normal_data"
    ANOMALY = "Anomaly_data"


@dataclass
class ImageAnnotation:
    """Image annotation data structure."""
    image_path: str
    json_path: str
    txt_path: str
    label: int  # 0 for normal, 1 for anomaly
    data_type: DataType
    point_name: str
    frame_id: Optional[str] = None
    metadata: Dict[str, Any] = field(default_factory=dict)


@dataclass
class MultimodalData:
    """Multimodal data for a collection point."""
    point_name: str
    rgb_video_path: Optional[str] = None
    infrared_video_path: Optional[str] = None
    sensor_data_path: Optional[str] = None
    point_cloud_path: Optional[str] = None
    audio_path: Optional[str] = None


class MultimodalRobotDataset(Dataset):
    """
    Multimodal Robot Anomaly Detection Dataset.

    Supports:
    - Loading normal and anomaly images with annotations
    - Loading multimodal data (RGB, infrared, sensor, point cloud, audio)
    - Loading device parameters
    """

    def __init__(
            self,
            root_path: str,
            split: DataSplit = DataSplit.TRAIN,
            data_type: Optional[DataType] = None,  # None means both
            transform=None,
            load_multimodal: bool = False,
            load_parameters: bool = False,
    ):
        """
        Initialize the dataset.

        Args:
            root_path: Root path to DATA_PATH directory
            split: DataSplit.TRAIN or DataSplit.TEST
            data_type: Filter by DataType, None means load all
            transform: Optional transform to apply to images
            load_multimodal: Whether to load multimodal data paths
            load_parameters: Whether to load device parameters
        """
        self.root_path = Path(root_path)
        self.split = split
        self.data_type = data_type
        self.transform = transform
        self.load_multimodal = load_multimodal
        self.load_parameters = load_parameters

        self.annotations: List[ImageAnnotation] = []
        self.multimodal_data: Dict[str, MultimodalData] = {}
        self.device_parameters: Dict[str, Any] = {}

        self._scan_dataset()

        if self.load_parameters:
            self._load_parameters()

    def _scan_dataset(self):
        """Scan and collect all annotation files."""
        split_path = self.root_path / self.split.value
        annotation_path = split_path / "Annotations"

        data_types = [self.data_type] if self.data_type else [DataType.NORMAL, DataType.ANOMALY]

        for dtype in data_types:
            dtype_path = annotation_path / dtype.value
            if not dtype_path.exists():
                continue

            for point_dir in dtype_path.iterdir():
                if not point_dir.is_dir():
                    continue

                point_name = point_dir.name

                # Find all image files
                for img_file in point_dir.glob("*.jpg"):
                    json_file = img_file.with_suffix(".json")
                    txt_file = img_file.with_suffix(".txt")

                    # Extract frame_id from filename
                    frame_id = self._extract_frame_id(img_file.name)

                    annotation = ImageAnnotation(
                        image_path=str(img_file),
                        json_path=str(json_file) if json_file.exists() else "",
                        txt_path=str(txt_file) if txt_file.exists() else "",
                        label=0 if dtype == DataType.NORMAL else 1,
                        data_type=dtype,
                        point_name=point_name,
                        frame_id=frame_id,
                    )
                    self.annotations.append(annotation)

        # Sort by point name for consistent ordering
        self.annotations.sort(key=lambda x: (x.data_type.value, x.point_name, x.frame_id or ""))

        # Load multimodal data if requested
        if self.load_multimodal:
            self._scan_multimodal_data()

    def _extract_frame_id(self, filename: str) -> Optional[str]:
        """Extract frame ID from filename."""
        # Pattern: *_frame_000001.jpg or frame_000001.jpg
        if "_frame_" in filename:
            parts = filename.replace(".jpg", "").split("_frame_")
            return parts[-1] if len(parts) > 1 else None
        elif filename.startswith("frame_"):
            return filename.replace(".jpg", "").replace("frame_", "")
        return None

    def _scan_multimodal_data(self):
        """Scan and collect multimodal data paths."""
        split_path = self.root_path / self.split.value
        multimodal_path = split_path / "Other_modalities"

        if not multimodal_path.exists():
            return

        for point_dir in multimodal_path.iterdir():
            if not point_dir.is_dir():
                continue

            point_name = point_dir.name
            mm_data = MultimodalData(point_name=point_name)

            for file in point_dir.iterdir():
                if "_visible_" in file.name and file.suffix == ".mp4":
                    mm_data.rgb_video_path = str(file)
                elif "_infrared_" in file.name and file.suffix == ".mp4":
                    mm_data.infrared_video_path = str(file)
                elif "_sensor_" in file.name and file.suffix == ".txt":
                    mm_data.sensor_data_path = str(file)
                elif "_point_cloud_" in file.name and file.suffix == ".bag":
                    mm_data.point_cloud_path = str(file)
                elif "_audio_" in file.name and file.suffix == ".wav":
                    mm_data.audio_path = str(file)

            self.multimodal_data[point_name] = mm_data

    def _load_parameters(self):
        """Load device parameters."""
        split_path = self.root_path / self.split.value
        params_path = split_path / "Parameters"

        if not params_path.exists():
            return

        # Load Device_*.json files
        for param_file in params_path.glob("*.json"):
            device_name = param_file.stem
            with open(param_file, 'r', encoding='utf-8') as f:
                self.device_parameters[device_name] = json.load(f)

    def __len__(self) -> int:
        return len(self.annotations)

    def __getitem__(self, idx: int) -> Dict[str, Any]:
        """
        Get a single sample.

        Returns:
            Dictionary containing:
            - image: RGB image tensor (C, H, W)
            - label: 0 for normal, 1 for anomaly
            - json_data: annotation from json file
            - txt_data: semantic description from txt file
            - metadata: additional metadata
        """
        ann = self.annotations[idx]

        # Load image
        image = cv2.imread(ann.image_path)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        if self.transform:
            image = self.transform(image)

        # Load json annotation
        json_data = None
        if ann.json_path and os.path.exists(ann.json_path):
            with open(ann.json_path, 'r', encoding='utf-8') as f:
                json_data = json.load(f)

        # Load txt description
        txt_data = None
        if ann.txt_path and os.path.exists(ann.txt_path):
            with open(ann.txt_path, 'r', encoding='utf-8') as f:
                txt_data = f.read().strip()

        return {
            "image": image,
            "label": ann.label,
            "json_data": json_data,
            "txt_data": txt_data,
            "metadata": {
                "image_path": ann.image_path,
                "point_name": ann.point_name,
                "frame_id": ann.frame_id,
                "data_type": ann.data_type.value,
            }
        }

    def get_multimodal_data(self, point_name: str) -> Optional[MultimodalData]:
        """Get multimodal data for a specific point."""
        return self.multimodal_data.get(point_name)

    def get_parameter(self, device_name: str) -> Optional[Dict[str, Any]]:
        """Get device parameter by name."""
        return self.device_parameters.get(device_name)

    def get_stats(self) -> Dict[str, int]:
        """Get dataset statistics."""
        normal_count = sum(1 for a in self.annotations if a.data_type == DataType.NORMAL)
        anomaly_count = sum(1 for a in self.annotations if a.data_type == DataType.ANOMALY)

        return {
            "total": len(self.annotations),
            "normal": normal_count,
            "anomaly": anomaly_count,
            "points": len(set(a.point_name for a in self.annotations)),
            "multimodal_collections": len(self.multimodal_data),
            "device_parameters": len(self.device_parameters),
        }


def create_train_test_split(
        root_path: str,
        transform=None,
        load_multimodal: bool = False,
        load_parameters: bool = False,
) -> Tuple[MultimodalRobotDataset, MultimodalRobotDataset]:
    """
    Create train and test datasets.

    Args:
        root_path: Root path to DATA_PATH directory
        transform: Optional transform to apply to images
        load_multimodal: Whether to load multimodal data paths
        load_parameters: Whether to load device parameters

    Returns:
        Tuple of (train_dataset, test_dataset)
    """
    train_dataset = MultimodalRobotDataset(
        root_path=root_path,
        split=DataSplit.TRAIN,
        transform=transform,
        load_multimodal=load_multimodal,
        load_parameters=load_parameters,
    )

    test_dataset = MultimodalRobotDataset(
        root_path=root_path,
        split=DataSplit.TEST,
        transform=transform,
        load_multimodal=load_multimodal,
        load_parameters=load_parameters,
    )

    return train_dataset, test_dataset


# Example usage
if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description="Multimodal Robot Anomaly Dataset Loader")
    parser.add_argument("--root", type=str, default="/home/tc/trainData/multimodal_data_process/split1/DATA_PATH",
                        help="Root path to DATA_PATH directory")
    parser.add_argument("--split", type=str, choices=["train", "test", "all"], default="all",
                        help="Which split to load")
    parser.add_argument("--stats", action="store_true", help="Print dataset statistics")
    args = parser.parse_args()

    if args.split == "all":
        train_ds, test_ds = create_train_test_split(
            root_path=args.root,
            load_multimodal=True,
            load_parameters=True,
        )

        print("=" * 50)
        print("TRAIN Dataset Statistics:")
        print("=" * 50)
        for k, v in train_ds.get_stats().items():
            print(f"  {k}: {v}")

        print("\n" + "=" * 50)
        print("TEST Dataset Statistics:")
        print("=" * 50)
        for k, v in test_ds.get_stats().items():
            print(f"  {k}: {v}")

    else:
        split = DataSplit.TRAIN if args.split == "train" else DataSplit.TEST
        dataset = MultimodalRobotDataset(
            root_path=args.root,
            split=split,
            load_multimodal=True,
            load_parameters=True,
        )

        print("=" * 50)
        print(f"{args.split.upper()} Dataset Statistics:")
        print("=" * 50)
        for k, v in dataset.get_stats().items():
            print(f"  {k}: {v}")

    # Test loading a sample
    if args.stats and args.split == "all":
        print("\n" + "=" * 50)
        print("Sample Data (first 3):")
        print("=" * 50)
        for i, sample in enumerate(train_ds):
            if i >= 3:
                break
            print(f"\nSample {i + 1}:")
            print(f"  Label: {sample['label']} ({'Normal' if sample['label'] == 0 else 'Anomaly'})")
            print(f"  Point: {sample['metadata']['point_name']}")
            print(f"  Frame: {sample['metadata']['frame_id']}")
            print(f"  Image shape: {sample['image'].shape if hasattr(sample['image'], 'shape') else 'N/A'}")