fastMONAI 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

fastMONAI/dataset_info.py

@@ -5,6 +5,7 @@ __all__ = ['MedDataset', 'get_class_weights']
 
 # %% ../nbs/08_dataset_info.ipynb 2
 from .vision_core import *
+from .vision_plot import find_max_slice
 
 from sklearn.utils.class_weight import compute_class_weight
 from concurrent.futures import ThreadPoolExecutor
@@ -12,29 +13,35 @@ import pandas as pd
 import numpy as np
 import torch
 import glob
+import matplotlib.pyplot as plt
 
-# %% ../nbs/08_dataset_info.ipynb 4
+# %% ../nbs/08_dataset_info.ipynb 3
 class MedDataset:
     """A class to extract and present information about the dataset."""
 
-    def __init__(self, path=None, postfix: str = '', img_list: list = None,
-                 reorder: bool = False, dtype: (MedImage, MedMask) = MedImage,
-                 max_workers: int = 1):
+    def __init__(self, dataframe=None, image_col:str=None, mask_col:str="mask_path",
+                 path=None, img_list=None, postfix:str='', apply_reorder:bool=False,
+                 dtype:(MedImage, MedMask)=MedImage, max_workers:int=1):
         """Constructs MedDataset object.
 
         Args:
-            path (str, optional): Path to the image folder.
-            postfix (str, optional): Specify the file type if there are different files in the folder.
-            img_list (List[str], optional): Alternatively, pass in a list with image paths.
-            reorder (bool, optional): Whether to reorder the data to be closest to canonical (RAS+) orientation.
-            dtype (Union[MedImage, MedMask], optional): Load data as datatype. Default is MedImage.
-            max_workers (int, optional): The number of worker threads. Default is 1.
+            dataframe: DataFrame containing image paths.
+            image_col: Column name for image paths (used for visualization).
+            mask_col: Column name for mask/label paths when using dataframe mode.
+            path: Directory path containing images.
+            img_list: List of image file paths to analyze.
+            postfix: File postfix filter when using path mode.
+            apply_reorder: Whether to reorder images to RAS+ orientation.
+            dtype: MedImage for images or MedMask for segmentation masks.
+            max_workers: Number of parallel workers for processing.
         """
-                     
+        self.input_df = dataframe
+        self.image_col = image_col
+        self.mask_col = mask_col
         self.path = path
-        self.postfix = postfix
         self.img_list = img_list
-        self.reorder = reorder
+        self.postfix = postfix
+        self.apply_reorder = apply_reorder
         self.dtype = dtype
         self.max_workers = max_workers
         self.df = self._create_data_frame()
@@ -42,69 +49,207 @@ class MedDataset:
     def _create_data_frame(self):
         """Private method that returns a dataframe with information about the dataset."""
 
-        if self.path:
-            self.img_list = glob.glob(f'{self.path}/*{self.postfix}*')
-            if not self.img_list: print('Could not find images. Check the image path')
+        # Handle img_list (simple list of paths)
+        if self.img_list is not None:
+            file_list = self.img_list
+
+        # Handle path-based initialization
+        elif self.path:
+            file_list = glob.glob(f'{self.path}/*{self.postfix}*')
+            if not file_list:
+                print('Could not find images. Check the image path')
+                return pd.DataFrame()
+
+        # Handle dataframe-based initialization
+        elif self.input_df is not None and self.mask_col in self.input_df.columns:
+            file_list = self.input_df[self.mask_col].tolist()
+
+        else:
+            print('Error: Must provide path, img_list, or dataframe with mask_col')
+            return pd.DataFrame()
 
+        # Process images to extract metadata
         with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
-            data_info_dict = list(executor.map(self._get_data_info, self.img_list))
+            data_info_dict = list(executor.map(self._get_data_info, file_list))
 
         df = pd.DataFrame(data_info_dict)
-        
-        if df.orientation.nunique() > 1:
-            print('The volumes in this dataset have different orientations. '
-                  'Recommended to pass in the argument reorder=True when creating a MedDataset object for this dataset')
+
+        if len(df) > 0 and df.orientation.nunique() > 1 and not self.apply_reorder:
+            raise ValueError(
+                'Mixed orientations detected in dataset. '
+                'Please recreate MedDataset with apply_reorder=True to get correct resample values: '
+                'MedDataset(..., apply_reorder=True)'
+            )
 
         return df
 
     def summary(self):
         """Summary DataFrame of the dataset with example path for similar data."""
-        
+
         columns = ['dim_0', 'dim_1', 'dim_2', 'voxel_0', 'voxel_1', 'voxel_2', 'orientation']
-        
+
         return self.df.groupby(columns, as_index=False).agg(
             example_path=('path', 'min'), total=('path', 'size')
         ).sort_values('total', ascending=False)
 
-    def suggestion(self):
-        """Voxel value that appears most often in dim_0, dim_1 and dim_2, and whether the data should be reoriented."""
-        
-        resample = [float(self.df.voxel_0.mode()[0]), float(self.df.voxel_1.mode()[0]), float(self.df.voxel_2.mode()[0])]
-        return resample, self.reorder
+    def get_suggestion(self):
+        """Returns suggested preprocessing parameters as a dictionary.
+
+        Returns:
+            dict: {'target_spacing': [voxel_0, voxel_1, voxel_2], 'apply_reorder': bool}
+        """
+        target_spacing = [float(self.df.voxel_0.mode()[0]), float(self.df.voxel_1.mode()[0]), float(self.df.voxel_2.mode()[0])]
+        return {'target_spacing': target_spacing, 'apply_reorder': self.apply_reorder}
 
     def _get_data_info(self, fn: str):
         """Private method to collect information about an image file."""
-        _, o, _ = med_img_reader(fn, reorder=self.reorder, only_tensor=False, dtype=self.dtype)
+        try:
+            _, o, _ = med_img_reader(fn, apply_reorder=self.apply_reorder, only_tensor=False, dtype=self.dtype)
 
-        info_dict = {'path': fn, 'dim_0': o.shape[1], 'dim_1': o.shape[2], 'dim_2': o.shape[3],
-                     'voxel_0': round(o.spacing[0], 4), 'voxel_1': round(o.spacing[1], 4), 'voxel_2': round(o.spacing[2], 4),
-                     'orientation': f'{"".join(o.orientation)}+'}
+            info_dict = {'path': fn, 'dim_0': o.shape[1], 'dim_1': o.shape[2], 'dim_2': o.shape[3],
+                         'voxel_0': round(o.spacing[0], 4), 'voxel_1': round(o.spacing[1], 4), 'voxel_2': round(o.spacing[2], 4),
+                         'orientation': f'{"".join(o.orientation)}+'}
 
-        if self.dtype is MedMask:
-            mask_labels_dict = o.count_labels()
-            mask_labels_dict = {f'voxel_count_{int(key)}': val for key, val in mask_labels_dict.items()}
-            info_dict.update(mask_labels_dict)
+            if self.dtype is MedMask:
+                # Calculate voxel volume in mm³
+                voxel_volume = o.spacing[0] * o.spacing[1] * o.spacing[2]
 
-        return info_dict
+                # Get voxel counts for each label
+                mask_labels_dict = o.count_labels()
 
-    def get_largest_img_size(self, resample: list = None) -> list:
-        """Get the largest image size in the dataset."""
-        
-        dims = None
+                # Calculate volumes for each label > 0 (skip background)
+                for key, voxel_count in mask_labels_dict.items():
+                    label_int = int(key)
+                    if label_int > 0 and voxel_count > 0:  # Skip background (label 0)
+                        volume_mm3 = voxel_count * voxel_volume
+                        info_dict[f'label_{label_int}_volume_mm3'] = round(volume_mm3, 4)
 
-        if resample is not None:
+            return info_dict
+
+        except Exception as e:
+            print(f"Warning: Failed to process {fn}: {e}")
+            return {'path': fn, 'error': str(e)}
+
+    def calculate_target_size(self, target_spacing: list = None) -> list:
+        """Calculate the target image size for the dataset.
+
+        Args:
+            target_spacing: If provided, calculates size after resampling to this spacing.
+                           If None, returns original dimensions.
+
+        Returns:
+            list: [dim_0, dim_1, dim_2] largest dimensions in dataset.
+        """
+        if target_spacing is not None:
             org_voxels = self.df[["voxel_0", "voxel_1", 'voxel_2']].values
             org_dims = self.df[["dim_0", "dim_1", 'dim_2']].values
 
-            ratio = org_voxels/resample
+            ratio = org_voxels/target_spacing
             new_dims = (org_dims * ratio).T
-            dims = [float(new_dims[0].max().round()), float(new_dims[1].max().round()), float(new_dims[2].max().round())]
-
+            # Use floor() to match TorchIO's Resample dimension calculation
+            dims = [float(np.floor(new_dims[0].max())), float(np.floor(new_dims[1].max())), float(np.floor(new_dims[2].max()))]
         else:
             dims = [float(self.df.dim_0.max()), float(self.df.dim_1.max()), float(self.df.dim_2.max())]
 
         return dims
 
+    def get_volume_summary(self):
+        """Returns DataFrame with volume statistics for each label.
+
+        Returns:
+            DataFrame with columns: label, count, mean_mm3, median_mm3, min_mm3, max_mm3
+            Returns None if no volume columns found (dtype was not MedMask).
+        """
+        volume_cols = [col for col in self.df.columns if col.endswith('_volume_mm3')]
+
+        if not volume_cols:
+            return None
+
+        summary_data = []
+        for col in volume_cols:
+            non_zero = self.df[self.df[col] > 0][col]
+            if len(non_zero) > 0:
+                summary_data.append({
+                    'label': col.replace('_volume_mm3', ''),
+                    'count': len(non_zero),
+                    'mean_mm3': non_zero.mean(),
+                    'median_mm3': non_zero.median(),
+                    'min_mm3': non_zero.min(),
+                    'max_mm3': non_zero.max()
+                })
+
+        return pd.DataFrame(summary_data) if summary_data else None
+
+    def _visualize_single_case(self, img_path, mask_path, case_id, anatomical_plane=2, cmap='hot', figsize=(12, 5)):
+        """Helper method to visualize a single case."""
+        try:
+            # Create MedImage and MedMask with current preprocessing settings
+            suggestion = self.get_suggestion()
+            MedBase.item_preprocessing(target_spacing=suggestion['target_spacing'], apply_reorder=suggestion['apply_reorder'])
+
+            img = MedImage.create(img_path)
+            mask = MedMask.create(mask_path)
+
+            # Find optimal slice using explicit function
+            mask_data = mask.numpy()[0]  # Remove channel dimension
+            optimal_slice = find_max_slice(mask_data, anatomical_plane)
+
+            # Create subplot
+            fig, axes = plt.subplots(1, 2, figsize=figsize)
+
+            # Show image
+            img.show(ctx=axes[0], anatomical_plane=anatomical_plane, slice_index=optimal_slice)
+            axes[0].set_title(f"{case_id} - Image (slice {optimal_slice})")
+
+            # Show overlay
+            img.show(ctx=axes[1], anatomical_plane=anatomical_plane, slice_index=optimal_slice)
+            mask.show(ctx=axes[1], anatomical_plane=anatomical_plane, slice_index=optimal_slice,
+                     alpha=0.3, cmap=cmap)
+            axes[1].set_title(f"{case_id} - Overlay (slice {optimal_slice})")
+
+            # Adjust spacing to bring plots closer
+            plt.subplots_adjust(wspace=0.1)
+            plt.tight_layout()
+            plt.show()
+
+        except Exception as e:
+            print(f"Failed to visualize case {case_id}: {e}")
+
+    def visualize_cases(self, n_cases=4, anatomical_plane=2, cmap='hot', figsize=(12, 5)):
+        """Visualize cases from the dataset.
+
+        Args:
+            n_cases: Number of cases to show.
+            anatomical_plane: 0=sagittal, 1=coronal, 2=axial
+            cmap: Colormap for mask overlay
+            figsize: Figure size for each case
+        """
+        if self.input_df is None:
+            print("Error: No dataframe provided. Cannot visualize cases.")
+            return
+
+        if self.image_col is None:
+            print("Error: No image_col specified. Cannot visualize cases.")
+            return
+
+        # Check if required columns exist
+        if self.image_col not in self.input_df.columns:
+            print(f"Error: Column '{self.image_col}' not found in dataframe.")
+            return
+
+        if self.mask_col not in self.input_df.columns:
+            print(f"Error: Column '{self.mask_col}' not found in dataframe.")
+            return
+
+        for idx in range(min(n_cases, len(self.input_df))):
+            row = self.input_df.iloc[idx]
+            case_id = row.get('case_id', f'Case_{idx}')  # Fallback if no case_id
+            img_path = row[self.image_col]
+            mask_path = row[self.mask_col]
+
+            self._visualize_single_case(img_path, mask_path, case_id, anatomical_plane, cmap, figsize)
+            print("-" * 60)
+
 # %% ../nbs/08_dataset_info.ipynb 5
 def get_class_weights(labels: (np.array, list), class_weight: str = 'balanced') -> torch.Tensor: 
     """Calculates and returns the class weights.

fastMONAI/external_data.py

@@ -94,7 +94,7 @@ def download_ixi_data(path: (str, Path) = '../data') -> Path:
         if len(list(img_path.iterdir())) >= 581:  # 581 imgs in the IXI dataset
             is_extracted = True
             print(f"Images already downloaded and extracted to {img_path}")
-    except:
+    except (FileNotFoundError, StopIteration, OSError):
         is_extracted = False
 
     if not is_extracted:

fastMONAI/utils.py

@@ -1,7 +1,8 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/07_utils.ipynb.
 
 # %% auto 0
-__all__ = ['store_variables', 'load_variables', 'print_colab_gpu_info', 'ModelTrackingCallback', 'MLflowUIManager']
+__all__ = ['store_variables', 'load_variables', 'store_patch_variables', 'load_patch_variables', 'print_colab_gpu_info',
+           'ModelTrackingCallback', 'MLflowUIManager']
 
 # %% ../nbs/07_utils.ipynb 1
 import pickle
@@ -17,10 +18,10 @@ from fastcore.foundation import L
 from typing import Any
 
 # %% ../nbs/07_utils.ipynb 3
-def store_variables(pkl_fn: str | Path, size: list, reorder: bool, resample: int | list):
+def store_variables(pkl_fn: str | Path, size: list, apply_reorder: bool, target_spacing: int | list):
     """Save variable values in a pickle file."""
     
-    var_vals = [size, reorder, resample]
+    var_vals = [size, apply_reorder, target_spacing]
     
     with open(pkl_fn, 'wb') as f:
         pickle.dump(var_vals, f)
@@ -38,7 +39,89 @@ def load_variables(pkl_fn: (str, Path)):
     with open(pkl_fn, 'rb') as f:
         return pickle.load(f)
 
-# %% ../nbs/07_utils.ipynb 5
+# %% ../nbs/07_utils.ipynb 6
+def store_patch_variables(
+    pkl_fn: str | Path,
+    patch_size: list,
+    patch_overlap: int | float | list,
+    aggregation_mode: str,
+    apply_reorder: bool = False,
+    target_spacing: list = None,
+    sampler_type: str = 'uniform',
+    label_probabilities: dict = None,
+    samples_per_volume: int = 8,
+    queue_length: int = 300,
+    queue_num_workers: int = 4,
+    keep_largest_component: bool = False
+):
+    """Save patch-based training and inference configuration to a pickle file.
+
+    Args:
+        pkl_fn: Path to save the pickle file.
+        patch_size: Size of patches [x, y, z].
+        patch_overlap: Overlap for inference (int, float 0-1, or list).
+        aggregation_mode: GridAggregator mode ('crop', 'average', 'hann').
+        apply_reorder: Whether to reorder to canonical (RAS+) orientation.
+        target_spacing: Target voxel spacing [x, y, z].
+        sampler_type: Type of sampler used during training.
+        label_probabilities: Label probabilities for LabelSampler.
+        samples_per_volume: Number of patches extracted per volume during training.
+        queue_length: Maximum number of patches in queue buffer.
+        queue_num_workers: Number of workers for parallel patch extraction.
+        keep_largest_component: If True, keep only the largest connected component
+            in binary segmentation predictions during inference.
+
+    Example:
+        >>> store_patch_variables(
+        ...     'patch_settings.pkl',
+        ...     patch_size=[96, 96, 96],
+        ...     patch_overlap=0.5,
+        ...     aggregation_mode='hann',
+        ...     apply_reorder=True,
+        ...     target_spacing=[1.0, 1.0, 1.0],
+        ...     samples_per_volume=16,
+        ...     keep_largest_component=True
+        ... )
+    """
+    config = {
+        'patch_size': patch_size,
+        'patch_overlap': patch_overlap,
+        'aggregation_mode': aggregation_mode,
+        'apply_reorder': apply_reorder,
+        'target_spacing': target_spacing,
+        'sampler_type': sampler_type,
+        'label_probabilities': label_probabilities,
+        'samples_per_volume': samples_per_volume,
+        'queue_length': queue_length,
+        'queue_num_workers': queue_num_workers,
+        'keep_largest_component': keep_largest_component
+    }
+
+    with open(pkl_fn, 'wb') as f:
+        pickle.dump(config, f)
+
+# %% ../nbs/07_utils.ipynb 7
+def load_patch_variables(pkl_fn: str | Path) -> dict:
+    """Load patch-based training and inference configuration from a pickle file.
+
+    Args:
+        pkl_fn: Path to the pickle file.
+
+    Returns:
+        Dictionary with patch configuration including:
+        - patch_size, patch_overlap, aggregation_mode
+        - apply_reorder, target_spacing, sampler_type, label_probabilities
+        - samples_per_volume, queue_length, queue_num_workers
+
+    Example:
+        >>> config = load_patch_variables('patch_settings.pkl')
+        >>> from fastMONAI.vision_patch import PatchConfig
+        >>> patch_config = PatchConfig(**config)
+    """
+    with open(pkl_fn, 'rb') as f:
+        return pickle.load(f)
+
+# %% ../nbs/07_utils.ipynb 8
 def print_colab_gpu_info(): 
     """Check if we have a GPU attached to the runtime."""
     
@@ -52,7 +135,7 @@ def print_colab_gpu_info():
     if torch.cuda.is_available(): print('GPU attached.')
     else: print(colab_gpu_msg)
 
-# %% ../nbs/07_utils.ipynb 6
+# %% ../nbs/07_utils.ipynb 9
 class ModelTrackingCallback(Callback):
     """
     A FastAI callback for comprehensive MLflow experiment tracking.
@@ -67,8 +150,8 @@ class ModelTrackingCallback(Callback):
         loss_function: str, 
         item_tfms: list[Any],
         size: list[int], 
-        resample: list[float], 
-        reorder: bool
+        target_spacing: list[float], 
+        apply_reorder: bool
     ):
         """
         Initialize the MLflow tracking callback.
@@ -77,15 +160,15 @@ class ModelTrackingCallback(Callback):
             model_name: Name of the model architecture for registration
             loss_function: Name of the loss function being used
             size: Model input dimensions
-            resample: Resampling dimensions
-            reorder: Whether reordering augmentation is applied
+            target_spacing: Resampling dimensions
+            apply_reorder: Whether reordering augmentation is applied
         """
         self.model_name = model_name
         self.loss_function = loss_function
         self.item_tfms = item_tfms
         self.size = size
-        self.resample = resample
-        self.reorder = reorder
+        self.target_spacing = target_spacing
+        self.apply_reorder = apply_reorder
         
         self.config = self._build_config()
         
@@ -128,8 +211,8 @@ class ModelTrackingCallback(Callback):
             "loss_function": self.loss_function,
             "transform_details": transform_details,
             "size": self.size,
-            "resample": self.resample,
-            "reorder": self.reorder,
+            "target_spacing": self.target_spacing,
+            "apply_reorder": self.apply_reorder,
         }
     
     def _extract_training_params(self) -> dict[str, Any]:
@@ -143,8 +226,8 @@ class ModelTrackingCallback(Callback):
         
         params["loss_function"] = self.config["loss_function"]
         params["size"] = self.config["size"]
-        params["resample"] = self.config["resample"]
-        params["reorder"] = self.config["reorder"]
+        params["target_spacing"] = self.config["target_spacing"]
+        params["apply_reorder"] = self.config["apply_reorder"]
         
         params["transformations"] = json.dumps(
             self.config["transform_details"], 
@@ -218,7 +301,7 @@ class ModelTrackingCallback(Callback):
         self.learn.cbs = original_cbs
         
         config_path = temp_dir / "inference_settings.pkl"
-        store_variables(config_path, self.size, self.reorder, self.resample)
+        store_variables(config_path, self.size, self.apply_reorder, self.target_spacing)
         mlflow.log_artifact(str(config_path), "config")
     
     def _register_pytorch_model(self) -> None:
@@ -252,7 +335,7 @@ class ModelTrackingCallback(Callback):
             
         print(f"MLflow run completed. Run ID: {mlflow.active_run().info.run_id}")
 
-# %% ../nbs/07_utils.ipynb 7
+# %% ../nbs/07_utils.ipynb 10
 import subprocess
 import threading
 import time
@@ -286,7 +369,7 @@ class MLflowUIManager:
         try:
             response = requests.get(f'http://localhost:{self.port}', timeout=2)
             return response.status_code == 200
-        except:
+        except (requests.RequestException, ConnectionError, OSError):
             return False
     
     def find_available_port(self, start_port=5001):

fastMONAI/vision_all.py

@@ -2,10 +2,11 @@
 from .vision_core import *
 from .vision_data import *
 from .vision_augmentation import *
-from .vision_loss import * 
+from .vision_loss import *
 from .vision_metrics import *
 from .vision_inference import *
-from .utils import * 
+from .vision_patch import *
+from .utils import *
 from .external_data import *
 from .dataset_info import *