From f7f84d5e2d48446176ed212bd858f8c3d8b3ae37 Mon Sep 17 00:00:00 2001 From: luandalmazo Date: Fri, 19 Jun 2026 11:44:17 -0300 Subject: [PATCH] add factory --- datamint/dataset/__init__.py | 5 +- datamint/dataset/factory.py | 99 +++++++++ notebooks/build_dataset_tutorial.ipynb | 266 +++++++++++++++++++++++++ 3 files changed, 369 insertions(+), 1 deletion(-) create mode 100644 datamint/dataset/factory.py create mode 100644 notebooks/build_dataset_tutorial.ipynb diff --git a/datamint/dataset/__init__.py b/datamint/dataset/__init__.py index 9d5ba530..d54a5170 100644 --- a/datamint/dataset/__init__.py +++ b/datamint/dataset/__init__.py @@ -6,7 +6,7 @@ - VideoDataset: Temporal sequences (videos, multi-frame DICOM) - VolumetricDataset: 3D volumes (NIfTI, CT, MRI) -Use `create_dataset()` for automatic type detection, or instantiate directly. +Use `build_dataset()` for automatic type detection, or instantiate directly. """ # New modular architecture @@ -18,6 +18,7 @@ from .sliced_dataset import SlicedVolumeDataset from .sliced_video_dataset import SlicedVideoDataset from .detection_dataset import DetectionDataset, detection_collate_fn +from .factory import build_dataset __all__ = [ # Core @@ -32,4 +33,6 @@ 'SlicedVideoDataset', 'DetectionDataset', 'detection_collate_fn', + # Factory + 'build_dataset', ] \ No newline at end of file diff --git a/datamint/dataset/factory.py b/datamint/dataset/factory.py new file mode 100644 index 00000000..ce15c38c --- /dev/null +++ b/datamint/dataset/factory.py @@ -0,0 +1,99 @@ +from __future__ import annotations + +import logging +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from datamint.entities.resource import Resource + from .base import DatamintBaseDataset + +_LOGGER = logging.getLogger(__name__) + + +def _classify_resource(resource: 'Resource') -> str: + if resource.is_video(): + return 'video' + if resource.is_volume(): + try: + if resource.get_depth() == 1: + return 'image' + except Exception: + pass # frame_count not in list-response metadata; assume volume + return 'volume' + if resource.is_image(): + return 'image' + return getattr(resource, 'kind', 'unknown') + + +def build_dataset(project_name: str, **kwargs: Any) -> 'DatamintBaseDataset': + """Auto-detect and return the appropriate dataset class for a project. + + Fetches a small sample of resources from the project to determine the + data type, then instantiates and returns the matching dataset class: + + - 2D images (JPEG, PNG) → :class:`~datamint.dataset.ImageDataset` + - Volumes (NIfTI, DICOM, volumetric) → :class:`~datamint.dataset.VolumeDataset` + - Videos → :class:`~datamint.dataset.VideoDataset` + + Args: + project_name: Name of the Datamint project. + **kwargs: Forwarded to the dataset constructor (transforms, filters, etc.). + + Returns: + An instantiated dataset of the detected type. + + Raises: + ValueError: If the project is empty, contains unknown resource types, + or contains a mix of data types. + + Example:: + + from datamint.dataset import build_dataset + + ds = build_dataset('MyProject', include_unannotated=False) + """ + from datamint import Api + from .image_dataset import ImageDataset + from .volume_dataset import VolumeDataset + from .video_dataset import VideoDataset + + _KIND_TO_CLS = { + 'image': ImageDataset, + 'volume': VolumeDataset, + 'nifti': VolumeDataset, + 'dicom': VolumeDataset, + 'video': VideoDataset, + } + + api = Api() + sample = api.resources.get_list(project_name=project_name, limit=5) + + if not sample: + raise ValueError(f"Project '{project_name}' has no resources.") + + kinds = {_classify_resource(r) for r in sample} + unknown = kinds - set(_KIND_TO_CLS) + if unknown: + raise ValueError( + f"Project '{project_name}' contains unsupported resource types: {sorted(unknown)}. " + "Instantiate the dataset class directly." + ) + + if kinds == {'image', 'volume'}: + _LOGGER.warning( + f"Project '{project_name}' contains a mix of 2D and 3D DICOM resources. " + "Defaulting to VolumeDataset. Use ImageDataset or VolumeDataset directly " + "if you need a specific type." + ) + kinds = {'volume'} + + if len(kinds) > 1: + raise ValueError( + f"Project '{project_name}' contains mixed data types: {sorted(kinds)}. " + "Instantiate the dataset class directly." + ) + + kind = next(iter(kinds)) + dataset_cls = _KIND_TO_CLS[kind] + _LOGGER.info(f"Detected resource type '{kind}'; using {dataset_cls.__name__}.") + return dataset_cls(project=project_name, **kwargs) diff --git a/notebooks/build_dataset_tutorial.ipynb b/notebooks/build_dataset_tutorial.ipynb new file mode 100644 index 00000000..2f881502 --- /dev/null +++ b/notebooks/build_dataset_tutorial.ipynb @@ -0,0 +1,266 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1b2c3d4", + "metadata": {}, + "source": [ + "# `build_dataset` Tutorial\n", + "\n", + "This notebook shows how to use `build_dataset` — a factory function that automatically detects the data type of a Datamint project and returns the appropriate dataset class.\n", + "\n", + "Instead of deciding upfront between `ImageDataset`, `VolumeDataset`, or `VideoDataset`, you just pass the project name and `build_dataset` figures it out.\n", + "\n", + "**What you'll learn:**\n", + "1. Basic usage — load any project without knowing its data type\n", + "2. Inspecting what class was returned\n", + "3. Working with the dataset as usual\n", + "4. Handling mixed or unknown project types" + ] + }, + { + "cell_type": "markdown", + "id": "b2c3d4e5", + "metadata": {}, + "source": [ + "## 1. Installation & Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3d4e5f6", + "metadata": {}, + "outputs": [], + "source": [ + "%pip install -U datamint --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d4e5f6a7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/luan/Desktop/Datamint/Codes/datamint-python-api/datamint/env/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from datamint.dataset import build_dataset" + ] + }, + { + "cell_type": "markdown", + "id": "e5f6a7b8", + "metadata": {}, + "source": [ + "## 2. Basic Usage\n", + "\n", + "`build_dataset` fetches a small sample of resources from your project, detects the data type, and returns the matching dataset — `ImageDataset`, `VolumeDataset`, or `VideoDataset`.\n", + "\n", + "All keyword arguments are forwarded directly to the dataset constructor, so anything you'd pass to `ImageDataset(...)` or `VolumeDataset(...)` works here too." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f6a7b8c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ImageDataset\n", + "Dataset bccd_detection\n", + " Number of datapoints: 364\n" + ] + } + ], + "source": [ + "PROJECT_NAME = \"your-project-name\" # <-- Replace with your project name\n", + "\n", + "ds = build_dataset(\n", + " PROJECT_NAME,\n", + " include_unannotated=True,\n", + " allow_external_annotations=True,\n", + ")\n", + "\n", + "print(ds)" + ] + }, + { + "cell_type": "markdown", + "id": "a7b8c9d0", + "metadata": {}, + "source": [ + "## 3. Inspecting the Returned Dataset\n", + "\n", + "`build_dataset` returns a fully instantiated dataset object. You can check exactly which class was selected and use all its methods normally." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b8c9d0e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset type : VolumeDataset\n", + "Number of items: 20\n", + "Segmentation labels: []\n", + "Image-level labels : []\n" + ] + } + ], + "source": [ + "print(f\"Dataset type : {type(ds).__name__}\")\n", + "print(f\"Number of items: {len(ds)}\")\n", + "print(f\"Segmentation labels: {ds.segmentation_labels_set}\")\n", + "print(f\"Image-level labels : {ds.image_labels_set}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c9d0e1f2", + "metadata": {}, + "source": [ + "## 4. Working with the Dataset\n", + "\n", + "The returned object behaves exactly like the underlying class. Indexing, iterating, slicing — everything works as documented in the individual dataset tutorials." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0e1f2a3", + "metadata": {}, + "outputs": [], + "source": [ + "item = ds[0]\n", + "\n", + "img = item['image']\n", + "print(f\"Image shape: {img.shape}\")\n", + "print(f\"Item keys : {list(item.keys())}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e1f2a3b4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the first item\n", + "# For 3D volumes (C, D, H, W), pick the middle slice; for 2D images (C, H, W), show directly\n", + "if img.ndim == 4: # volume: (C, D, H, W)\n", + " mid = img.shape[1] // 2\n", + " display_img = img[0, mid]\n", + " title = f\"{type(ds).__name__} — axial slice {mid}\"\n", + "else: # image: (C, H, W)\n", + " display_img = img[0]\n", + " title = f\"{type(ds).__name__} — item 0\"\n", + "\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(display_img, cmap='gray')\n", + "plt.title(title)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f2a3b4c5", + "metadata": {}, + "source": [ + "## 5. Class-Specific Features Are Still Available\n", + "\n", + "Because `build_dataset` returns the actual typed class (not a wrapper), you get full access to class-specific methods. For example, if the project contains 3D volumes, the returned `VolumeDataset` exposes `.slice()`." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a3b4c5d6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some resources are not cached locally and will be downloaded during slicing. This may take time and bandwidth, especially for large volumes. Consider pre-caching resources if this is an issue.\n", + "Expanding to 'axial' slices: 100%|██████████| 12/12 [01:00<00:00, 5.01s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sliced dataset: 6144 axial slices\n", + "(1, 256, 47)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from datamint.dataset import VolumeDataset\n", + "\n", + "if isinstance(ds, VolumeDataset):\n", + " sliced = ds.slice(axis='axial')\n", + " print(f\"Sliced dataset: {len(sliced)} axial slices\")\n", + " print(sliced[0]['image'].shape) # (C, H, W)\n", + "else:\n", + " print(f\"Project contains {type(ds).__name__} data — .slice() not applicable.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}