datamint 1.5.2__py3-none-any.whl → 1.5.5__py3-none-any.whl

datamint/apihandler/annotation_api_handler.py

@@ -221,7 +221,6 @@ class AnnotationAPIHandler(BaseAPIHandler):
                     filename = os.path.basename(file_path)
                     form = aiohttp.FormData()
                     form.add_field('file', f, filename=filename, content_type='application/x-nifti')
-                    model_id = 'c9daf156-5335-4cb3-b374-5b3a776e0025'
                     if model_id is not None:
                         form.add_field('model_id', model_id)  # Add model_id if provided
                     if worklist_id is not None:

datamint/dataset/base_dataset.py

@@ -7,15 +7,16 @@ import shutil
 import json
 import yaml
 import pydicom
+from pydicom.dataset import FileDataset
 import numpy as np
 from datamint import configs
 from torch.utils.data import DataLoader
 import torch
+from torch import Tensor
 from datamint.apihandler.base_api_handler import DatamintException
 from datamint.utils.dicom_utils import is_dicom
 import cv2
 from datamint.utils.io_utils import read_array_normalized
-from deprecated import deprecated
 from datetime import datetime
 
 _LOGGER = logging.getLogger(__name__)
@@ -80,7 +81,7 @@ class DatamintBaseDataset:
                  exclude_frame_label_names: Optional[list[str]] = None
                  ):
         from datamint.apihandler.api_handler import APIHandler
-        
+
         if project_name is None:
             raise ValueError("project_name is required.")
 
@@ -204,6 +205,9 @@ class DatamintBaseDataset:
             self.dataset_length = len(self.images_metainfo)
 
         self.num_frames_per_resource = self.__compute_num_frames_per_resource()
+        
+        # Precompute cumulative frame counts for faster index lookup
+        self._cumulative_frames = np.cumsum([0] + self.num_frames_per_resource)
 
         self.subset_indices = list(range(self.dataset_length))
         # self.labels_set, self.label2code, self.segmentation_labels, self.segmentation_label2code = self.get_labels_set()
@@ -309,7 +313,7 @@ class DatamintBaseDataset:
             scope (str): The scope of the annotations. It can be 'frame', 'image' or 'all'.
 
         Returns:
-            List[Dict]: The annotations of the image.
+            list[dict]: The annotations of the image.
         """
         if index >= len(self):
             raise IndexError(f"Index {index} out of bounds for dataset of length {len(self)}")
@@ -591,7 +595,8 @@ class DatamintBaseDataset:
         with open(datasetjson, 'w') as file:
             json.dump(self.metainfo, file)
 
-    def _load_image(self, filepath: str, index: int = None) -> tuple[torch.Tensor, pydicom.FileDataset]:
+    def _load_image(self, filepath: str,
+                    index: int | None = None) -> tuple[Tensor, FileDataset | None]:
         if os.path.isdir(filepath):
             raise NotImplementedError("Loading a image from a directory is not supported yet.")
 
@@ -601,14 +606,14 @@ class DatamintBaseDataset:
             img, ds = read_array_normalized(filepath, return_metainfo=True)
 
         if img.dtype == np.uint16:
-            # Pytorch doesn't support uint16
-            if self.__logged_uint16_conversion == False:
+            if not self.__logged_uint16_conversion:
                 _LOGGER.info("Original image is uint16, converting to uint8")
                 self.__logged_uint16_conversion = True
 
             # min-max normalization
             img = img.astype(np.float32)
-            img = (img - img.min()) / (img.max() - img.min()) * 255
+            mn = img.min()
+            img = (img - mn) / (img.max() - mn) * 255
             img = img.astype(np.uint8)
 
         img = torch.from_numpy(img).contiguous()
@@ -618,7 +623,7 @@ class DatamintBaseDataset:
         return img, ds
 
     def _get_image_metainfo(self, index: int, bypass_subset_indices=False) -> dict[str, Any]:
-        if bypass_subset_indices == False:
+        if not bypass_subset_indices:
             index = self.subset_indices[index]
         if self.return_frame_by_frame:
             # Find the correct filepath and index
@@ -635,17 +640,18 @@ class DatamintBaseDataset:
         return img_metainfo
 
     def __find_index(self, index: int) -> tuple[int, int]:
-        frame_index = index
-        for i, num_frames in enumerate(self.num_frames_per_resource):
-            if frame_index < num_frames:
-                break
-            frame_index -= num_frames
-        else:
-            raise IndexError(f"Index {index} out of bounds for dataset of length {len(self)}")
-
-        return i, frame_index
+        """
+        Find the resource index and frame index for a given global frame index.
+        
+        """
+        # Use binary search to find the resource containing this frame
+        resource_index = np.searchsorted(self._cumulative_frames[1:], index, side='right')
+        frame_index = index - self._cumulative_frames[resource_index]
+        
+        return resource_index, frame_index
 
-    def __getitem_internal(self, index: int, only_load_metainfo=False) -> dict[str, Any]:
+    def __getitem_internal(self, index: int,
+                           only_load_metainfo=False) -> dict[str, Tensor | FileDataset | dict | list]:
         if self.return_frame_by_frame:
             resource_index, frame_idx = self.__find_index(index)
         else:
@@ -711,7 +717,7 @@ class DatamintBaseDataset:
 
         return filtered_annotations
 
-    def __getitem__(self, index: int) -> dict[str, Any]:
+    def __getitem__(self, index: int) -> dict[str, Tensor | FileDataset | dict | list]:
         """
         Args:
             index (int): Index
@@ -725,8 +731,8 @@ class DatamintBaseDataset:
         return self.__getitem_internal(self.subset_indices[index])
 
     def __iter__(self):
-        for i in range(len(self)):
-            yield self[i]
+        for index in self.subset_indices:
+            yield self.__getitem_internal(index)
 
     def __len__(self) -> int:
         return len(self.subset_indices)

datamint/dataset/dataset.py

@@ -287,7 +287,7 @@ class DatamintDataset(DatamintBaseDataset):
         if len(all_masks_list) != 0:
             all_masks_list = torch.concatenate(all_masks_list).numpy().astype(np.uint8)
         else:
-            all_masks_list = None#np.empty((0,img.shape[-2], img.shape[-1]), dtype=np.uint8)
+            all_masks_list = None  # np.empty((0,img.shape[-2], img.shape[-1]), dtype=np.uint8)
 
         augmented = self.alb_transform(image=img.numpy().transpose(1, 2, 0),
                                        masks=all_masks_list)
@@ -308,6 +308,36 @@ class DatamintDataset(DatamintBaseDataset):
 
         return augmented['image'], new_segmentations
 
+    def _seg_labels_to_names(self, seg_labels: dict | list | None) -> dict | list | None:
+        """
+        Convert segmentation label codes to label names.
+
+        Args:
+            seg_labels: Segmentation labels in various formats:
+                - dict[str, list[Tensor]]: author -> list of frame tensors with label codes
+                - dict[str, Tensor]: author -> tensor with label codes
+                - list[Tensor]: list of frame tensors with label codes
+                - Tensor: tensor with label codes
+                - None: when no segmentation labels are available
+
+        Returns:
+            Same structure as input but with label codes converted to label names.
+            Returns None if input is None.
+        """
+        if seg_labels is None:
+            return None
+
+        code_to_name = self.segmentation_labels_set
+        if isinstance(seg_labels, dict):
+            # author -> list of frame tensors
+            return {author: [code_to_name[code.item()] for code in labels] for author, labels in seg_labels.items()}
+        elif isinstance(seg_labels, list):
+            # list of frame tensors
+            return [[code_to_name[code.item()] for code in labels] for labels in seg_labels]
+
+        _LOGGER.warning(f"Unexpected segmentation labels format: {type(seg_labels)}. Returning None")
+        return None
+
     def __getitem__(self, index) -> dict[str, Any]:
         """
         Get the item at the given index.
@@ -401,6 +431,9 @@ class DatamintDataset(DatamintBaseDataset):
                             seg_labels = seg_labels[0]
                 new_item['segmentations'] = segmentations
                 new_item['seg_labels'] = seg_labels
+                # process seg_labels to convert from code to label names
+                new_item['seg_labels_names'] = self._seg_labels_to_names(seg_labels)
+
         except Exception:
             _LOGGER.error(f'Error in loading/processing segmentations of {metainfo}')
             raise

datamint/utils/dicom_utils.py

@@ -638,3 +638,70 @@ def pixel_to_patient(ds: pydicom.Dataset,
     patient_coords = image_position + pixel_x * pixel_spacing[0] * row_vector + pixel_y * pixel_spacing[1] * col_vector
 
     return patient_coords
+
+
+def determine_anatomical_plane(ds: pydicom.Dataset,
+                               slice_axis: int,
+                               alignment_threshold: float = 0.95) -> str:
+    """
+    Determine the anatomical plane of a DICOM slice (Axial, Sagittal, Coronal, Oblique, or Unknown).
+
+    Args:
+        ds (pydicom.Dataset): The DICOM dataset containing the image metadata.
+        slice_axis (int): The axis of the slice to analyze (0, 1, or 2).
+        alignment_threshold (float): Threshold for considering alignment with anatomical axes.
+
+    Returns:
+        str: The name of the anatomical plane ('Axial', 'Sagittal', 'Coronal', 'Oblique', or 'Unknown').
+
+    Raises:
+        ValueError: If `slice_index` is not 0, 1, or 2.
+    """
+
+    if slice_axis not in [0, 1, 2]:
+        raise ValueError("slice_index must be 0, 1 or 2")
+    # Check if Image Orientation Patient exists
+    if not hasattr(ds, 'ImageOrientationPatient') or ds.ImageOrientationPatient is None:
+        return "Unknown"
+    # Get the Image Orientation Patient (IOP) - 6 values defining row and column directions
+    iop = np.array(ds.ImageOrientationPatient, dtype=float)
+    if len(iop) != 6:
+        return "Unknown"
+    # Extract row and column direction vectors
+    row_dir = iop[:3]  # First 3 values: row direction cosines
+    col_dir = iop[3:]  # Last 3 values: column direction cosines
+    # Calculate the normal vector (slice direction) using cross product
+    normal = np.cross(row_dir, col_dir)
+    normal = normal / np.linalg.norm(normal)  # Normalize
+    # Define standard anatomical axes
+    # LPS coordinate system: L = Left, P = Posterior, S = Superior
+    axes = {
+        'sagittal': np.array([1, 0, 0]),   # L-R axis (left-right)
+        'coronal': np.array([0, 1, 0]),    # A-P axis (anterior-posterior)
+        'axial': np.array([0, 0, 1])       # S-I axis (superior-inferior)
+    }
+    # For each slice_index, determine which axis we're examining
+    if slice_axis == 0:
+        # ds.pixel_array[0,:,:] - slicing along first dimension
+        # The normal vector corresponds to the direction we're slicing through
+        examine_vector = normal
+    elif slice_axis == 1:
+        # ds.pixel_array[:,0,:] - slicing along second dimension
+        # This corresponds to the row direction
+        examine_vector = row_dir
+    elif slice_axis == 2:
+        # ds.pixel_array[:,:,0] - slicing along third dimension
+        # This corresponds to the column direction
+        examine_vector = col_dir
+    # Find which anatomical axis is most aligned with our examine_vector
+    max_dot = 0
+    best_axis = "Unknown"
+    for axis_name, axis_vector in axes.items():
+        dot_product = abs(np.dot(examine_vector, axis_vector))
+        if dot_product > max_dot:
+            max_dot = dot_product
+            best_axis = axis_name
+    if max_dot >= alignment_threshold:
+        return best_axis.capitalize()
+    else:
+        return "Oblique"

datamint/utils/io_utils.py

@@ -53,33 +53,42 @@ def read_video(file_path: str, index: int = None) -> np.ndarray:
     return imgs
 
 
-def read_nifti(file_path: str) -> np.ndarray:
+def read_nifti(file_path: str, mimetype: str | None = None) -> np.ndarray:
     """
     Read a NIfTI file and return the image data in standardized format.
     
     Args:
         file_path: Path to the NIfTI file (.nii or .nii.gz)
+        mimetype: Optional MIME type of the file. If provided, it can help in determining how to read the file.
         
     Returns:
         np.ndarray: Image data with shape (#frames, C, H, W)
     """
+    from nibabel.filebasedimages import ImageFileError
     try:
-        nii_img = nib.load(file_path)
-        imgs = nii_img.get_fdata()  # shape: (W, H, #frame) or (W, H)
-        
-        if imgs.ndim == 2:
-            imgs = imgs.transpose(1, 0)  # (W, H) -> (H, W)
-            imgs = imgs[np.newaxis, np.newaxis]  # -> (1, 1, H, W)
-        elif imgs.ndim == 3:
-            imgs = imgs.transpose(2, 1, 0)  # (W, H, #frame) -> (#frame, H, W)
-            imgs = imgs[:, np.newaxis]  # -> (#frame, 1, H, W)
+        imgs = nib.load(file_path).get_fdata()  # shape: (W, H, #frame) or (W, H)
+    except ImageFileError as e:
+        if mimetype is None:
+            raise e
+        # has_ext = os.path.splitext(file_path)[1] != ''
+        if mimetype == 'application/gzip':
+            with gzip.open(file_path, 'rb') as f:
+                imgs = nib.Nifti1Image.from_stream(f).get_fdata()
+        elif mimetype in ('image/x.nifti', 'application/x-nifti'):
+            with open(file_path, 'rb') as f:
+                imgs = nib.Nifti1Image.from_stream(f).get_fdata()
         else:
-            raise ValueError(f"Unsupported number of dimensions in '{file_path}': {imgs.ndim}")
+            raise e
+    if imgs.ndim == 2:
+        imgs = imgs.transpose(1, 0)
+        imgs = imgs[np.newaxis, np.newaxis]
+    elif imgs.ndim == 3:
+        imgs = imgs.transpose(2, 1, 0)
+        imgs = imgs[:, np.newaxis]
+    else:
+        raise ValueError(f"Unsupported number of dimensions in '{file_path}': {imgs.ndim}")
 
-        return imgs
-    except Exception as e:
-        _LOGGER.error(f"Failed to read NIfTI file '{file_path}': {e}")
-        raise e
+    return imgs
 
 
 def read_image(file_path: str) -> np.ndarray:
@@ -94,7 +103,7 @@ def read_image(file_path: str) -> np.ndarray:
 
 
 def read_array_normalized(file_path: str,
-                          index: int = None,
+                          index: int | None = None,
                           return_metainfo: bool = False,
                           use_magic=False) -> np.ndarray | tuple[np.ndarray, Any]:
     """
@@ -102,6 +111,8 @@ def read_array_normalized(file_path: str,
 
     Args:
         file_path: The path to the file.
+        index: If specified, read only the frame at this index (0-based).
+            If None, read all frames.
         Supported file formats are NIfTI (.nii, .nii.gz), PNG (.png), JPEG (.jpg, .jpeg) and npy (.npy).
 
     Returns:
@@ -136,8 +147,8 @@ def read_array_normalized(file_path: str,
             if mime_type.startswith('video/') or file_path.endswith(VIDEO_EXTS):
                 imgs = read_video(file_path, index)
             else:
-                if mime_type == 'image/x.nifti' or file_path.endswith(NII_EXTS):
-                    imgs = read_nifti(file_path)
+                if mime_type in ('image/x.nifti', 'application/x-nifti') or mime_type == 'application/gzip' or file_path.endswith(NII_EXTS):
+                    imgs = read_nifti(file_path, mimetype=mime_type)
                     # For NIfTI files, try to load associated JSON metadata
                     if return_metainfo:
                         json_path = file_path.replace('.nii.gz', '.json').replace('.nii', '.json')

{datamint-1.5.2.dist-info → datamint-1.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: datamint
-Version: 1.5.2
+Version: 1.5.5
 Summary: A library for interacting with the Datamint API, designed for efficient data management, processing and Deep Learning workflows.
 Requires-Python: >=3.10
 Classifier: Programming Language :: Python :: 3

{datamint-1.5.2.dist-info → datamint-1.5.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 datamint/__init__.py,sha256=7rKCCsaa4RBRTIfuHB708rai1xwDHLtkFNFJGKYG5D4,757
-datamint/apihandler/annotation_api_handler.py,sha256=n-I-tKRB9g24f9RScbT-tPMF7h-eTbFexaTQ4sYTJoI,47836
+datamint/apihandler/annotation_api_handler.py,sha256=N8WFk-oO84fBKH9t-R1DW5J7hnxQxcz-zxgLuMkNbwA,47766
 datamint/apihandler/api_handler.py,sha256=cdVSddrFCKlF_BJ81LO1aJ0OP49rssjpNEFzJ6Q7YyY,384
 datamint/apihandler/base_api_handler.py,sha256=XSxZEQEkbQpuixGDu_P9jbxUQht3Z3JgxaeiFKPkVDM,11690
 datamint/apihandler/dto/annotation_dto.py,sha256=otCIesoqGBlbSOw4ErqFsXp2HwJsPNUQlkynQh_7pHg,7110
@@ -10,20 +10,20 @@ datamint/client_cmd_tools/datamint_config.py,sha256=md7dnWrbl10lPtXKbmD9yo6onLJs
 datamint/client_cmd_tools/datamint_upload.py,sha256=VyLL2FgY9ibfbdp4K6HrKt0jgkQH-SVuU71D6e77074,26436
 datamint/configs.py,sha256=Bdp6NydYwyCJ2dk19_gf_o3M2ZyQOmMHpLi8wEWNHUk,1426
 datamint/dataset/__init__.py,sha256=4PlUKSvVhdfQvvuq8jQXrkdqnot-iTTizM3aM1vgSwg,47
-datamint/dataset/base_dataset.py,sha256=EnnIeF3ZaBL2M8qEV39U0ogKptyvezBNoVOvrS12bZ8,38756
-datamint/dataset/dataset.py,sha256=W7W9EcaPdyV8XjOL6jzBqnH2iUCMpA8w-UNUVv1AP9w,25076
+datamint/dataset/base_dataset.py,sha256=MQZ_wNFex4BKBfb4fAcXV6-fQXFV_zBK1ybWrMm6_pg,39092
+datamint/dataset/dataset.py,sha256=AwS92t5kdmpm9NKFfXFmDmZxEbbPfb_FOMn-FWfu3bE,26590
 datamint/examples/__init__.py,sha256=zcYnd5nLVme9GCTPYH-1JpGo8xXK2WEYvhzcy_2alZc,39
 datamint/examples/example_projects.py,sha256=7Nb_EaIdzJTQa9zopqc-WhTBQWQJSoQZ_KjRS4PB4FI,2931
 datamint/experiment/__init__.py,sha256=5qQOMzoG17DEd1YnTF-vS0qiM-DGdbNh42EUo91CRhQ,34
 datamint/experiment/_patcher.py,sha256=ZgbezoevAYhJsbiJTvWPALGTcUiMT371xddcTllt3H4,23296
 datamint/experiment/experiment.py,sha256=aHK9dRFdQTi569xgUg1KqlCZLHZpDmSH3g3ndPIZvXw,44546
 datamint/logging.yaml,sha256=a5dsATpul7QHeUHB2TjABFjWaPXBMbO--dgn8GlRqwk,483
-datamint/utils/dicom_utils.py,sha256=n1CrYg1AgnlbgIktDfVXQ1Logh8lwCqYbjqHu5GElUE,26062
-datamint/utils/io_utils.py,sha256=ebP1atKkhKEf1mUU1LsVwDq0h_so7kVKkD_7hQYn_kM,6754
+datamint/utils/dicom_utils.py,sha256=sLukP6MB_acx7t868O2HDd_RDEILa97mEe_V9m1EMCY,28991
+datamint/utils/io_utils.py,sha256=lKnUCJEip7W9Xj9wOWsTAA855HnKbjwQON1WjMGqJmM,7374
 datamint/utils/logging_utils.py,sha256=DvoA35ATYG3JTwfXEXYawDyKRfHeCrH0a9czfkmz8kM,1851
 datamint/utils/torchmetrics.py,sha256=lwU0nOtsSWfebyp7dvjlAggaqXtj5ohSEUXOg3L0hJE,2837
 datamint/utils/visualization.py,sha256=yaUVAOHar59VrGUjpAWv5eVvQSfztFG0eP9p5Vt3l-M,4470
-datamint-1.5.2.dist-info/METADATA,sha256=WxrWHBdRq5AIOMyZYjVEJ7FrzufZR1yt4d1fMmrZ54U,4065
-datamint-1.5.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-datamint-1.5.2.dist-info/entry_points.txt,sha256=mn5H6jPjO-rY0W0CAZ6Z_KKWhMLvyVaSpoqk77jlTI4,145
-datamint-1.5.2.dist-info/RECORD,,
+datamint-1.5.5.dist-info/METADATA,sha256=o6BFPA7OS3SSPqflC85pJ_2Q7pETUtoZInY97B2Dxm8,4065
+datamint-1.5.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+datamint-1.5.5.dist-info/entry_points.txt,sha256=mn5H6jPjO-rY0W0CAZ6Z_KKWhMLvyVaSpoqk77jlTI4,145
+datamint-1.5.5.dist-info/RECORD,,