mirc-dataset-handler 0.1.0__tar.gz

mirc_dataset_handler-0.1.0/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2026 Iago Rodrigues
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+This license applies only to the source code, packaging files, and documentation
+contained in this repository for the Python package "mirc-dataset-handler".
+
+It does not grant any rights over the MIRC dataset itself, including but not
+limited to images, videos, annotations, derived data, redistributed copies, or
+third-party mirrors of the dataset. Any use of the MIRC dataset must follow the
+separate dataset terms, ethics requirements, and repository policies published
+in the official dataset repository and/or official distribution channels.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mirc_dataset_handler-0.1.0/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: mirc-dataset-handler
+Version: 0.1.0
+Summary: Utilities for loading MIRC annotations, creating subject-aware cross-validation splits, and building PyTorch DataLoaders for semantic segmentation workflows.
+Author: Iago Rodrigues
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: Pillow
+Requires-Dist: tqdm
+Requires-Dist: opencv-python
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: segmentation-models-pytorch
+Requires-Dist: torch-pruning==0.2.1
+Requires-Dist: notebook
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: torchaudio
+Dynamic: license-file
+
+# mirc-dataset-handler
+
+Utilities for loading, organizing, splitting, and creating PyTorch DataLoaders for the MIRC dataset.
+
+## Features
+
+- Recursive loading of polygon annotations from JSON files
+- Compact in-memory annotation structure
+- Subject-aware cross-validation split
+- Fold-based PyTorch DataLoader creation
+- Support for semantic masks with classes:
+  - `0`: background
+  - `1`: person
+  - `2`: robot
+
+## Repository Structure
+
+    mirc-dataset-handler/
+    ├── mircdataset/
+    │   ├── __init__.py
+    │   ├── data_utils.py
+    │   └── mirc_torch_dataset.py
+    ├── README.md
+    ├── pyproject.toml
+    └── LICENSE
+
+## Installation
+
+### Environment setup
+
+For better environment setup, before installing the mirc-dataset-handler, please consider to create an environment in this way:
+
+- conda create -n test python=3.9
+- conda activate test
+- conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
+
+### Local development
+
+    pip install -e .
+
+### From PyPI
+
+    pip install mirc-dataset-handler
+
+## Package Import
+
+    from mircdataset import data_utils
+
+## Expected Annotation Folder Layout
+
+    annotations/
+    └── multi-person/
+        └── subject6/
+            └── activity1/
+                └── routine01_cam1/
+                    ├── frame_crop_cam1_000000.json
+                    ├── frame_crop_cam1_000015.json
+                    └── ...
+
+## Generated Key Format
+
+Each loaded JSON is stored in a dictionary using the key format:
+
+    subjectid_activityid_routineid_camid_frameid
+
+Example:
+
+    6_1_1_1_000000
+    6_1_1_1_000015
+
+## Stored Annotation Structure
+
+Each key maps to a compact dictionary like:
+
+    {
+        "objects": [
+            {
+                "label": "person",
+                "points": [[x1, y1], [x2, y2], ...]
+            },
+            {
+                "label": "robot",
+                "points": [[x1, y1], [x2, y2], ...]
+            }
+        ],
+        "image_height": 720,
+        "image_width": 1280,
+        "image_path": "/absolute/path/to/frame_crop_cam1_000000.jpg"
+    }
+
+## Basic Usage
+
+    from mircdataset import data_utils
+
+    root_folder = "/media/mirc-dataset/annotations/multi-person/"
+
+    dataset_masks = data_utils.load_dataset_masks(root_folder)
+    cv_dataset_masks = data_utils.split_dataset_by_subject_cross_validation(dataset_masks, k=5)
+    dataloaders = data_utils.create_dataloaders(cv_dataset_masks, batch_size=4)
+
+## Cross-Validation Behavior
+
+The split is subject-aware, so subjects are never mixed between training and validation folds.
+
+Example with subjects `1..9` and `k=5`:
+
+    fold 0: [1, 2]
+    fold 1: [3, 4]
+    fold 2: [5, 6]
+    fold 3: [7, 8]
+    fold 4: [9]
+
+Example with subjects `1..6` and `k=5`:
+
+    fold 0: [1, 2]
+    fold 1: [3]
+    fold 2: [4]
+    fold 3: [5]
+    fold 4: [6]
+
+## DataLoader Output
+
+Each sample returned by the dataset has the format:
+
+    {
+        "image": torch.FloatTensor,
+        "mask": torch.LongTensor
+    }
+
+Expected shapes:
+
+    image -> [3, 256, 256]
+    mask  -> [256, 256]
+
+Mask classes:
+
+    0 -> background
+    1 -> person
+    2 -> robot
+
+## Accessing a Fold
+
+    train_loader, val_loader = dataloaders[0]
+
+If `k=5`, then:
+
+- `dataloaders[0]` uses fold 0 as validation
+- `dataloaders[1]` uses fold 1 as validation
+- `dataloaders[2]` uses fold 2 as validation
+- `dataloaders[3]` uses fold 3 as validation
+- `dataloaders[4]` uses fold 4 as validation
+
+## Inspecting a Batch
+
+    import matplotlib.pyplot as plt
+
+    train_loader, val_loader = dataloaders[0]
+
+    batch = next(iter(train_loader))
+
+    images = batch["image"]
+    masks = batch["mask"]
+
+    image = images[0].cpu().numpy().transpose(1, 2, 0)
+    mask = masks[0].cpu().numpy()
+
+    plt.figure(figsize=(10, 4))
+
+    plt.subplot(1, 2, 1)
+    plt.imshow(image)
+    plt.title("Image")
+    plt.axis("off")
+
+    plt.subplot(1, 2, 2)
+    plt.imshow(mask, vmin=0, vmax=2)
+    plt.title("Mask")
+    plt.axis("off")
+
+    plt.tight_layout()
+    plt.show()
+
+## Main Public Functions
+
+### `load_dataset_masks(root_folder)`
+
+Recursively loads all JSON annotation files and returns a compact dictionary indexed by:
+
+    subjectid_activityid_routineid_camid_frameid
+
+### `split_dataset_by_subject_cross_validation(dataset_dict, k)`
+
+Splits the dataset into `k` subject-aware folds.
+
+### `create_dataloaders(dataset_folds, batch_size=32, transform=None, mask_mode=None, num_workers=0, pin_memory=False)`
+
+Creates a list of `(train_loader, val_loader)` tuples for cross-validation.
+
+## Notes
+
+- Images are resized to `256x256`
+- Masks are generated from polygons and rasterized at `256x256`
+- Training DataLoaders use `shuffle=True`
+- Validation DataLoaders use `shuffle=False`
+- Subjects are never mixed across folds

mirc_dataset_handler-0.1.0/README.md

@@ -0,0 +1,204 @@
+# mirc-dataset-handler
+
+Utilities for loading, organizing, splitting, and creating PyTorch DataLoaders for the MIRC dataset.
+
+## Features
+
+- Recursive loading of polygon annotations from JSON files
+- Compact in-memory annotation structure
+- Subject-aware cross-validation split
+- Fold-based PyTorch DataLoader creation
+- Support for semantic masks with classes:
+  - `0`: background
+  - `1`: person
+  - `2`: robot
+
+## Repository Structure
+
+    mirc-dataset-handler/
+    ├── mircdataset/
+    │   ├── __init__.py
+    │   ├── data_utils.py
+    │   └── mirc_torch_dataset.py
+    ├── README.md
+    ├── pyproject.toml
+    └── LICENSE
+
+## Installation
+
+### Environment setup
+
+For better environment setup, before installing the mirc-dataset-handler, please consider to create an environment in this way:
+
+- conda create -n test python=3.9
+- conda activate test
+- conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
+
+### Local development
+
+    pip install -e .
+
+### From PyPI
+
+    pip install mirc-dataset-handler
+
+## Package Import
+
+    from mircdataset import data_utils
+
+## Expected Annotation Folder Layout
+
+    annotations/
+    └── multi-person/
+        └── subject6/
+            └── activity1/
+                └── routine01_cam1/
+                    ├── frame_crop_cam1_000000.json
+                    ├── frame_crop_cam1_000015.json
+                    └── ...
+
+## Generated Key Format
+
+Each loaded JSON is stored in a dictionary using the key format:
+
+    subjectid_activityid_routineid_camid_frameid
+
+Example:
+
+    6_1_1_1_000000
+    6_1_1_1_000015
+
+## Stored Annotation Structure
+
+Each key maps to a compact dictionary like:
+
+    {
+        "objects": [
+            {
+                "label": "person",
+                "points": [[x1, y1], [x2, y2], ...]
+            },
+            {
+                "label": "robot",
+                "points": [[x1, y1], [x2, y2], ...]
+            }
+        ],
+        "image_height": 720,
+        "image_width": 1280,
+        "image_path": "/absolute/path/to/frame_crop_cam1_000000.jpg"
+    }
+
+## Basic Usage
+
+    from mircdataset import data_utils
+
+    root_folder = "/media/mirc-dataset/annotations/multi-person/"
+
+    dataset_masks = data_utils.load_dataset_masks(root_folder)
+    cv_dataset_masks = data_utils.split_dataset_by_subject_cross_validation(dataset_masks, k=5)
+    dataloaders = data_utils.create_dataloaders(cv_dataset_masks, batch_size=4)
+
+## Cross-Validation Behavior
+
+The split is subject-aware, so subjects are never mixed between training and validation folds.
+
+Example with subjects `1..9` and `k=5`:
+
+    fold 0: [1, 2]
+    fold 1: [3, 4]
+    fold 2: [5, 6]
+    fold 3: [7, 8]
+    fold 4: [9]
+
+Example with subjects `1..6` and `k=5`:
+
+    fold 0: [1, 2]
+    fold 1: [3]
+    fold 2: [4]
+    fold 3: [5]
+    fold 4: [6]
+
+## DataLoader Output
+
+Each sample returned by the dataset has the format:
+
+    {
+        "image": torch.FloatTensor,
+        "mask": torch.LongTensor
+    }
+
+Expected shapes:
+
+    image -> [3, 256, 256]
+    mask  -> [256, 256]
+
+Mask classes:
+
+    0 -> background
+    1 -> person
+    2 -> robot
+
+## Accessing a Fold
+
+    train_loader, val_loader = dataloaders[0]
+
+If `k=5`, then:
+
+- `dataloaders[0]` uses fold 0 as validation
+- `dataloaders[1]` uses fold 1 as validation
+- `dataloaders[2]` uses fold 2 as validation
+- `dataloaders[3]` uses fold 3 as validation
+- `dataloaders[4]` uses fold 4 as validation
+
+## Inspecting a Batch
+
+    import matplotlib.pyplot as plt
+
+    train_loader, val_loader = dataloaders[0]
+
+    batch = next(iter(train_loader))
+
+    images = batch["image"]
+    masks = batch["mask"]
+
+    image = images[0].cpu().numpy().transpose(1, 2, 0)
+    mask = masks[0].cpu().numpy()
+
+    plt.figure(figsize=(10, 4))
+
+    plt.subplot(1, 2, 1)
+    plt.imshow(image)
+    plt.title("Image")
+    plt.axis("off")
+
+    plt.subplot(1, 2, 2)
+    plt.imshow(mask, vmin=0, vmax=2)
+    plt.title("Mask")
+    plt.axis("off")
+
+    plt.tight_layout()
+    plt.show()
+
+## Main Public Functions
+
+### `load_dataset_masks(root_folder)`
+
+Recursively loads all JSON annotation files and returns a compact dictionary indexed by:
+
+    subjectid_activityid_routineid_camid_frameid
+
+### `split_dataset_by_subject_cross_validation(dataset_dict, k)`
+
+Splits the dataset into `k` subject-aware folds.
+
+### `create_dataloaders(dataset_folds, batch_size=32, transform=None, mask_mode=None, num_workers=0, pin_memory=False)`
+
+Creates a list of `(train_loader, val_loader)` tuples for cross-validation.
+
+## Notes
+
+- Images are resized to `256x256`
+- Masks are generated from polygons and rasterized at `256x256`
+- Training DataLoaders use `shuffle=True`
+- Validation DataLoaders use `shuffle=False`
+- Subjects are never mixed across folds

mirc_dataset_handler-0.1.0/mirc_dataset_handler.egg-info/PKG-INFO

@@ -0,0 +1,228 @@
+Metadata-Version: 2.4
+Name: mirc-dataset-handler
+Version: 0.1.0
+Summary: Utilities for loading MIRC annotations, creating subject-aware cross-validation splits, and building PyTorch DataLoaders for semantic segmentation workflows.
+Author: Iago Rodrigues
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: Pillow
+Requires-Dist: tqdm
+Requires-Dist: opencv-python
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: segmentation-models-pytorch
+Requires-Dist: torch-pruning==0.2.1
+Requires-Dist: notebook
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: torchaudio
+Dynamic: license-file
+
+# mirc-dataset-handler
+
+Utilities for loading, organizing, splitting, and creating PyTorch DataLoaders for the MIRC dataset.
+
+## Features
+
+- Recursive loading of polygon annotations from JSON files
+- Compact in-memory annotation structure
+- Subject-aware cross-validation split
+- Fold-based PyTorch DataLoader creation
+- Support for semantic masks with classes:
+  - `0`: background
+  - `1`: person
+  - `2`: robot
+
+## Repository Structure
+
+    mirc-dataset-handler/
+    ├── mircdataset/
+    │   ├── __init__.py
+    │   ├── data_utils.py
+    │   └── mirc_torch_dataset.py
+    ├── README.md
+    ├── pyproject.toml
+    └── LICENSE
+
+## Installation
+
+### Environment setup
+
+For better environment setup, before installing the mirc-dataset-handler, please consider to create an environment in this way:
+
+- conda create -n test python=3.9
+- conda activate test
+- conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
+
+### Local development
+
+    pip install -e .
+
+### From PyPI
+
+    pip install mirc-dataset-handler
+
+## Package Import
+
+    from mircdataset import data_utils
+
+## Expected Annotation Folder Layout
+
+    annotations/
+    └── multi-person/
+        └── subject6/
+            └── activity1/
+                └── routine01_cam1/
+                    ├── frame_crop_cam1_000000.json
+                    ├── frame_crop_cam1_000015.json
+                    └── ...
+
+## Generated Key Format
+
+Each loaded JSON is stored in a dictionary using the key format:
+
+    subjectid_activityid_routineid_camid_frameid
+
+Example:
+
+    6_1_1_1_000000
+    6_1_1_1_000015
+
+## Stored Annotation Structure
+
+Each key maps to a compact dictionary like:
+
+    {
+        "objects": [
+            {
+                "label": "person",
+                "points": [[x1, y1], [x2, y2], ...]
+            },
+            {
+                "label": "robot",
+                "points": [[x1, y1], [x2, y2], ...]
+            }
+        ],
+        "image_height": 720,
+        "image_width": 1280,
+        "image_path": "/absolute/path/to/frame_crop_cam1_000000.jpg"
+    }
+
+## Basic Usage
+
+    from mircdataset import data_utils
+
+    root_folder = "/media/mirc-dataset/annotations/multi-person/"
+
+    dataset_masks = data_utils.load_dataset_masks(root_folder)
+    cv_dataset_masks = data_utils.split_dataset_by_subject_cross_validation(dataset_masks, k=5)
+    dataloaders = data_utils.create_dataloaders(cv_dataset_masks, batch_size=4)
+
+## Cross-Validation Behavior
+
+The split is subject-aware, so subjects are never mixed between training and validation folds.
+
+Example with subjects `1..9` and `k=5`:
+
+    fold 0: [1, 2]
+    fold 1: [3, 4]
+    fold 2: [5, 6]
+    fold 3: [7, 8]
+    fold 4: [9]
+
+Example with subjects `1..6` and `k=5`:
+
+    fold 0: [1, 2]
+    fold 1: [3]
+    fold 2: [4]
+    fold 3: [5]
+    fold 4: [6]
+
+## DataLoader Output
+
+Each sample returned by the dataset has the format:
+
+    {
+        "image": torch.FloatTensor,
+        "mask": torch.LongTensor
+    }
+
+Expected shapes:
+
+    image -> [3, 256, 256]
+    mask  -> [256, 256]
+
+Mask classes:
+
+    0 -> background
+    1 -> person
+    2 -> robot
+
+## Accessing a Fold
+
+    train_loader, val_loader = dataloaders[0]
+
+If `k=5`, then:
+
+- `dataloaders[0]` uses fold 0 as validation
+- `dataloaders[1]` uses fold 1 as validation
+- `dataloaders[2]` uses fold 2 as validation
+- `dataloaders[3]` uses fold 3 as validation
+- `dataloaders[4]` uses fold 4 as validation
+
+## Inspecting a Batch
+
+    import matplotlib.pyplot as plt
+
+    train_loader, val_loader = dataloaders[0]
+
+    batch = next(iter(train_loader))
+
+    images = batch["image"]
+    masks = batch["mask"]
+
+    image = images[0].cpu().numpy().transpose(1, 2, 0)
+    mask = masks[0].cpu().numpy()
+
+    plt.figure(figsize=(10, 4))
+
+    plt.subplot(1, 2, 1)
+    plt.imshow(image)
+    plt.title("Image")
+    plt.axis("off")
+
+    plt.subplot(1, 2, 2)
+    plt.imshow(mask, vmin=0, vmax=2)
+    plt.title("Mask")
+    plt.axis("off")
+
+    plt.tight_layout()
+    plt.show()
+
+## Main Public Functions
+
+### `load_dataset_masks(root_folder)`
+
+Recursively loads all JSON annotation files and returns a compact dictionary indexed by:
+
+    subjectid_activityid_routineid_camid_frameid
+
+### `split_dataset_by_subject_cross_validation(dataset_dict, k)`
+
+Splits the dataset into `k` subject-aware folds.
+
+### `create_dataloaders(dataset_folds, batch_size=32, transform=None, mask_mode=None, num_workers=0, pin_memory=False)`
+
+Creates a list of `(train_loader, val_loader)` tuples for cross-validation.
+
+## Notes
+
+- Images are resized to `256x256`
+- Masks are generated from polygons and rasterized at `256x256`
+- Training DataLoaders use `shuffle=True`
+- Validation DataLoaders use `shuffle=False`
+- Subjects are never mixed across folds

mirc_dataset_handler-0.1.0/mirc_dataset_handler.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+mirc_dataset_handler.egg-info/PKG-INFO
+mirc_dataset_handler.egg-info/SOURCES.txt
+mirc_dataset_handler.egg-info/dependency_links.txt
+mirc_dataset_handler.egg-info/requires.txt
+mirc_dataset_handler.egg-info/top_level.txt
+mircdataset/__init__.py
+mircdataset/data_utils.py
+mircdataset/mirc_torch_dataset.py

mirc_dataset_handler-0.1.0/mirc_dataset_handler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mirc_dataset_handler-0.1.0/mirc_dataset_handler.egg-info/requires.txt

@@ -0,0 +1,13 @@
+numpy
+Pillow
+tqdm
+opencv-python
+matplotlib
+pandas
+scikit-learn
+segmentation-models-pytorch
+torch-pruning==0.2.1
+notebook
+torch
+torchvision
+torchaudio

mirc_dataset_handler-0.1.0/mirc_dataset_handler.egg-info/top_level.txt

@@ -0,0 +1 @@
+mircdataset

mirc_dataset_handler-0.1.0/mircdataset/__init__.py

@@ -0,0 +1,4 @@
+from . import data_utils
+from .mirc_torch_dataset import MIRCTorchDataset
+
+__all__ = ["data_utils", "MIRCTorchDataset"]

mirc_dataset_handler-0.1.0/mircdataset/data_utils.py

@@ -0,0 +1,207 @@
+import os
+import re
+import json
+from tqdm import tqdm
+from torch.utils.data import DataLoader
+from .mirc_torch_dataset import MIRCTorchDataset
+
+
+def load_dataset_masks(root_folder):
+    json_data = {}
+
+    all_json_files = []
+
+    for current_root, _, files in os.walk(root_folder):
+        for file_name in files:
+            if file_name.endswith(".json"):
+                all_json_files.append(os.path.join(current_root, file_name))
+
+    for file_path in tqdm(all_json_files):
+        file_name = os.path.basename(file_path)
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            raw_content = json.load(f)
+
+        key = _process_json_key(file_path, file_name)
+        content = _build_simplified_json_content(
+            folder_path=os.path.dirname(file_path),
+            raw_content=raw_content
+        )
+
+        json_data[key] = content
+
+        del raw_content
+        del content
+
+    return json_data
+
+
+def _process_json_key(file_path, file_name):
+    subject_id, activity_id, routine_id, cam_id = _extract_ids_from_path(file_path)
+    frame_id = _extract_frame_id_from_filename(file_name)
+
+    return f"{subject_id}_{activity_id}_{routine_id}_{cam_id}_{frame_id}"
+
+
+def _extract_ids_from_path(file_path):
+    normalized_path = os.path.normpath(file_path)
+
+    pattern = r"subject(\d+)[/\\]+activity(\d+)[/\\]+routine(\d+)_cam(\d+)"
+    match = re.search(pattern, normalized_path, re.IGNORECASE)
+
+    if not match:
+        raise ValueError(f"Not possible to extract IDs from the folder: {file_path}")
+
+    subject_id, activity_id, routine_id, cam_id = match.groups()
+
+    return int(subject_id), int(activity_id), int(routine_id), int(cam_id)
+
+
+def _extract_frame_id_from_filename(file_name):
+    pattern = r"_(\d+)\.json$"
+    match = re.search(pattern, file_name, re.IGNORECASE)
+
+    if not match:
+        raise ValueError(f"Not possible to extract info from file: {file_name}")
+
+    return match.group(1)
+
+
+def _build_simplified_json_content(folder_path, raw_content):
+    objects = []
+
+    for shape in raw_content.get("shapes", []):
+        objects.append({
+            "label": shape.get("label"),
+            "points": shape.get("points", [])
+        })
+
+    image_path_in_json = raw_content.get("imagePath", "")
+    full_image_path = os.path.join(folder_path, image_path_in_json)
+
+    simplified_content = {
+        "objects": objects,
+        "image_height": raw_content.get("imageHeight"),
+        "image_width": raw_content.get("imageWidth"),
+        "image_path": full_image_path
+    }
+
+    return simplified_content
+
+
+def split_dataset_by_subject_cross_validation(dataset_dict, k):
+    subject_folds = _split_subjects_for_cross_validation(dataset_dict, k)
+
+    subject_to_fold = {}
+
+    for fold_index, fold_subjects in enumerate(subject_folds):
+        for subject_index in fold_subjects:
+            subject_to_fold[subject_index] = fold_index
+
+    splitted_dicts = [dict() for _ in range(len(subject_folds))]
+
+    keys_to_move = list(dataset_dict.keys())
+
+    for key in keys_to_move:
+        parts = key.split("_")
+
+        if len(parts) < 5:
+            raise ValueError(f"Invalid key format: {key}")
+
+        subject_index = int(parts[0])
+
+        if subject_index not in subject_to_fold:
+            raise ValueError(f"Subject index {subject_index} not found in fold mapping")
+
+        fold_index = subject_to_fold[subject_index]
+        splitted_dicts[fold_index][key] = dataset_dict.pop(key)
+
+    return splitted_dicts
+
+
+def _split_subjects_for_cross_validation(dataset_dict, k):
+    if k <= 1:
+        raise ValueError("k must be greater than 1")
+
+    subject_indices = _get_unique_subject_indices(dataset_dict)
+    total_subjects = len(subject_indices)
+
+    if total_subjects == 0:
+        return []
+
+    folds = [[] for _ in range(k)]
+
+    base_size = total_subjects // k
+    remainder = total_subjects % k
+
+    current_index = 0
+
+    for fold_index in range(k):
+        extra = 1 if fold_index < remainder else 0
+        fold_size = base_size + extra
+
+        if fold_size > 0:
+            folds[fold_index] = subject_indices[current_index:current_index + fold_size]
+            current_index += fold_size
+
+    return folds
+
+
+def _get_unique_subject_indices(dataset_dict):
+    subject_indices = set()
+
+    for key in dataset_dict.keys():
+        parts = key.split("_")
+
+        if len(parts) < 5:
+            raise ValueError(f"Invalid key format: {key}")
+
+        subject_indices.add(int(parts[0]))
+
+    return sorted(subject_indices)
+
+
+def create_dataloaders(dataset_folds, batch_size=32, transform=None, mask_mode=None, num_workers=0, pin_memory=False):
+    if len(dataset_folds) <= 1:
+        raise ValueError("dataset_folds must contain at least 2 folds")
+
+    dataloaders = []
+    total_folds = len(dataset_folds)
+
+    for val_fold_index in range(total_folds):
+        train_partitions = [dataset_folds[i] for i in range(total_folds) if i != val_fold_index]
+        val_partition = [dataset_folds[val_fold_index]]
+
+        train_dataset = MIRCTorchDataset(
+            dataset_partitions=train_partitions,
+            transform=transform,
+            mask_mode=mask_mode,
+            target_size=(256, 256)
+        )
+
+        val_dataset = MIRCTorchDataset(
+            dataset_partitions=val_partition,
+            transform=transform,
+            mask_mode=mask_mode,
+            target_size=(256, 256)
+        )
+
+        train_loader = DataLoader(
+            train_dataset,
+            batch_size=batch_size,
+            shuffle=True,
+            num_workers=num_workers,
+            pin_memory=pin_memory
+        )
+
+        val_loader = DataLoader(
+            val_dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=num_workers,
+            pin_memory=pin_memory
+        )
+
+        dataloaders.append((train_loader, val_loader))
+
+    return dataloaders

mirc_dataset_handler-0.1.0/mircdataset/mirc_torch_dataset.py

@@ -0,0 +1,106 @@
+import numpy as np
+from PIL import Image
+from cv2 import fillPoly as cv2_fillPoly
+from torch import from_numpy as torch_from_numpy
+from torch.utils.data import Dataset
+
+
+class MIRCTorchDataset(Dataset):
+    def __init__(self, dataset_partitions, transform=None, mask_mode=None, target_size=(256, 256)):
+        if isinstance(dataset_partitions, dict):
+            dataset_partitions = [dataset_partitions]
+
+        self.dataset_partitions = dataset_partitions
+        self.transform = transform
+        self.mask_mode = mask_mode
+        self.target_width = target_size[0]
+        self.target_height = target_size[1]
+        self.sample_index = []
+
+        for partition_index, partition in enumerate(self.dataset_partitions):
+            for key in partition.keys():
+                self.sample_index.append((partition_index, key))
+
+    def __len__(self):
+        return len(self.sample_index)
+
+    def __getitem__(self, idx):
+        partition_index, sample_key = self.sample_index[idx]
+        sample = self.dataset_partitions[partition_index][sample_key]
+
+        image_nd = self.__load_image(sample["image_path"])
+        mask_human, mask_robot = self.__build_binary_masks(sample)
+        mask_nd = self.__transform_masks(mask_human, mask_robot)
+
+        image_chw = image_nd.transpose((2, 0, 1)).astype(np.float32) / 255.0
+
+        return {
+            "image": torch_from_numpy(image_chw).float(),
+            "mask": torch_from_numpy(mask_nd).long()
+        }
+
+    def __load_image(self, image_path):
+        with Image.open(image_path) as image:
+            image = image.convert("RGB")
+            image = image.resize((self.target_width, self.target_height), Image.BILINEAR)
+            image_nd = np.array(image, dtype=np.uint8)
+
+        return image_nd
+
+    def __build_binary_masks(self, sample):
+        mask_human = np.zeros((self.target_height, self.target_width), dtype=np.uint8)
+        mask_robot = np.zeros((self.target_height, self.target_width), dtype=np.uint8)
+
+        image_width = sample["image_width"]
+        image_height = sample["image_height"]
+
+        scale_x = self.target_width / image_width
+        scale_y = self.target_height / image_height
+
+        for obj in sample["objects"]:
+            label = obj["label"]
+            points = obj["points"]
+
+            if not points:
+                continue
+
+            polygon = self.__scale_polygon(points, scale_x, scale_y)
+
+            if polygon is None or len(polygon) == 0:
+                continue
+
+            if label == "person":
+                cv2_fillPoly(mask_human, [polygon], 1)
+            elif label == "robot":
+                cv2_fillPoly(mask_robot, [polygon], 1)
+
+        return mask_human, mask_robot
+
+    def __scale_polygon(self, points, scale_x, scale_y):
+        polygon = np.array(points, dtype=np.float32)
+
+        if polygon.ndim != 2 or polygon.shape[0] == 0 or polygon.shape[1] != 2:
+            return None
+
+        polygon[:, 0] = polygon[:, 0] * scale_x
+        polygon[:, 1] = polygon[:, 1] * scale_y
+
+        polygon = np.rint(polygon).astype(np.int32)
+
+        polygon[:, 0] = np.clip(polygon[:, 0], 0, self.target_width - 1)
+        polygon[:, 1] = np.clip(polygon[:, 1], 0, self.target_height - 1)
+
+        return polygon
+
+    def __transform_masks(self, mask_human, mask_robot):
+        mask_human = np.where(mask_human > 0, 1, 0).astype(np.uint8)
+        mask_robot = np.where(mask_robot > 0, 1, 0).astype(np.uint8)
+
+        if self.mask_mode == "entropy":
+            mask = np.where(mask_robot == 1, 2, mask_human).astype(np.uint8)
+        else:
+            mask = np.zeros_like(mask_human, dtype=np.uint8)
+            mask[mask_human == 1] = 1
+            mask[mask_robot == 1] = 2
+
+        return mask

mirc_dataset_handler-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "mirc-dataset-handler"
+version = "0.1.0"
+description = "Utilities for loading MIRC annotations, creating subject-aware cross-validation splits, and building PyTorch DataLoaders for semantic segmentation workflows."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Iago Rodrigues" }
+]
+dependencies = [
+  "numpy",
+  "Pillow",
+  "tqdm",
+  "opencv-python",
+  "matplotlib",
+  "pandas",
+  "scikit-learn",
+  "segmentation-models-pytorch",
+  "torch-pruning==0.2.1",
+  "notebook",
+  "torch",
+  "torchvision",
+  "torchaudio"
+]
+
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["mircdataset*"]

mirc_dataset_handler-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+