code-loader 1.0.209__tar.gz → 1.0.210__tar.gz

{code_loader-1.0.209 → code_loader-1.0.210}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.209
+Version: 1.0.210
 Summary: 
+Home-page: https://github.com/tensorleap/code-loader
 License: MIT
-License-File: LICENSE
 Author: dorhar
 Author-email: doron.harnoy@tensorleap.ai
 Requires-Python: >=3.8,<3.13
@@ -20,7 +20,6 @@ Requires-Dist: numpy (>=2.3.2,<3.0.0) ; python_version >= "3.11" and python_vers
 Requires-Dist: psutil (>=5.9.5,<6.0.0)
 Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
-Project-URL: Homepage, https://github.com/tensorleap/code-loader
 Project-URL: Repository, https://github.com/tensorleap/code-loader
 Description-Content-Type: text/markdown
 

{code_loader-1.0.209 → code_loader-1.0.210}/code_loader/contract/datasetclasses.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 from code_loader.contract.enums import DataStateType, DataStateEnum, LeapDataType, ConfusionMatrixValue, \
     MetricDirection, DatasetMetadataType, LatentSpaceReduction, CustomLatentSpaceComputedAt
 from code_loader.contract.visualizer_classes import LeapImage, LeapText, LeapGraph, LeapHorizontalBar, \
-    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio
+    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapVolume
 from code_loader.contract.sim_config import SimConfig
 
 custom_latent_space_attribute = "custom_latent_space"
@@ -213,7 +213,7 @@ VisualizerCallableInterface = Union[
 ]
 
 LeapData = Union[LeapImage, LeapText, LeapGraph, LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithBBox,
-LeapImageWithHeatmap, LeapVideo, LeapAudio]
+LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapVolume]
 
 CustomCallableInterface = Callable[..., Any]
 

{code_loader-1.0.209 → code_loader-1.0.210}/code_loader/contract/enums.py

@@ -29,6 +29,7 @@ class LeapDataType(Enum):
     ImageWithHeatmap = 'ImageWithHeatmap'
     Video = 'Video'
     Audio = 'Audio'
+    Volume = 'Volume'
 
 
 class MetricDirection(Enum):

{code_loader-1.0.209 → code_loader-1.0.210}/code_loader/contract/visualizer_classes.py

@@ -377,6 +377,60 @@ class LeapAudio:
             raise LeapValidationError(f'sample_rate must be a positive int, got {self.sample_rate}')
 
 
+@dataclass
+class LeapVolume:
+    """
+    Visualizer representing a volume (3-D scalar field) for Tensorleap: a CT/MRI scan, a microscopy
+    z-stack, or any (D, H, W) grid. The UI slices it along any axis; the engine stores it as uint8.
+
+    Attributes:
+    data (npt.NDArray[np.float32] | npt.NDArray[np.uint8]): The volume, shaped [D, H, W]. Any finite value
+        range is accepted: the engine min-max quantizes it to uint8 for display and keeps the original
+        [min, max] so the UI can show true values.
+    mask (Optional[npt.NDArray[np.uint8]]): Optional label volume shaped like `data`; voxel value v is the
+        index into `labels`.
+    labels (Optional[List[str]]): Names for mask values; required with `mask`, len(labels) > mask.max().
+    spacing (Optional[Tuple[float, float, float]]): Physical voxel size per axis (D, H, W), e.g. mm, so the
+        UI renders anisotropic voxels with the right aspect. None means (1, 1, 1).
+    type (LeapDataType): The data type, default is LeapDataType.Volume.
+
+    Example:
+        volume = np.random.rand(64, 128, 128).astype(np.float32)
+        mask = (volume > 0.8).astype(np.uint8)
+        leap_volume = LeapVolume(data=volume, mask=mask, labels=["background", "lesion"], spacing=(2.0, 0.7, 0.7))
+    """
+    data: Union[npt.NDArray[np.float32], npt.NDArray[np.uint8]]
+    mask: Optional[npt.NDArray[np.uint8]] = None
+    labels: Optional[List[str]] = None
+    spacing: Optional[Tuple[float, float, float]] = None
+    type: LeapDataType = LeapDataType.Volume
+
+    def __post_init__(self) -> None:
+        validate_type(self.type, LeapDataType.Volume)
+        validate_type(type(self.data), np.ndarray)
+        validate_type(self.data.dtype, [np.uint8, np.float32])
+        validate_type(len(self.data.shape), 3, 'Volume data must be of shape 3 [D, H, W]')
+        if not np.isfinite(self.data).all():
+            raise LeapValidationError('Volume data must be finite (no NaN/Inf)')
+        if (self.mask is None) != (self.labels is None):
+            raise LeapValidationError('Volume mask and labels must be given together')
+        if self.mask is not None:
+            validate_type(type(self.mask), np.ndarray)
+            validate_type(self.mask.dtype, np.uint8)
+            if self.mask.shape != self.data.shape:
+                raise LeapValidationError(
+                    f'Volume mask shape {self.mask.shape} must equal data shape {self.data.shape}')
+            validate_type(type(self.labels), list)
+            for label in self.labels:
+                validate_type(type(label), str)
+            if self.mask.size and int(self.mask.max()) >= len(self.labels):
+                raise LeapValidationError(
+                    f'Volume mask has value {int(self.mask.max())} but only {len(self.labels)} labels')
+        if self.spacing is not None:
+            if len(self.spacing) != 3 or any(float(s) <= 0 for s in self.spacing):
+                raise LeapValidationError(f'Volume spacing must be 3 positive numbers, got {self.spacing}')
+
+
 map_leap_data_type_to_visualizer_class = {
     LeapDataType.Image.value: LeapImage,
     LeapDataType.Graph.value: LeapGraph,
@@ -387,5 +441,6 @@ map_leap_data_type_to_visualizer_class = {
     LeapDataType.TextMask.value: LeapTextMask,
     LeapDataType.ImageWithBBox.value: LeapImageWithBBox,
     LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap,
-    LeapDataType.Audio.value: LeapAudio
+    LeapDataType.Audio.value: LeapAudio,
+    LeapDataType.Volume.value: LeapVolume,
 }

{code_loader-1.0.209 → code_loader-1.0.210}/code_loader/inner_leap_binder/leapbinder_decorators.py

@@ -34,7 +34,7 @@ from code_loader.contract.enums import MetricDirection, LeapDataType, DatasetMet
 from code_loader import leap_binder, LeapLoader
 from code_loader.contract.mapping import NodeMapping, NodeMappingType, NodeConnection
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageMask, LeapTextMask, LeapText, LeapGraph, \
-    LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapValidationError, \
+    LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapVolume, LeapValidationError, \
     map_leap_data_type_to_visualizer_class
 from code_loader.inner_leap_binder.leapbinder import mapping_runtime_mode_env_var_mame, \
     _reject_stringized_sample_preprocess_response
@@ -1593,7 +1593,8 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
                 LeapDataType.ImageWithBBox: LeapImageWithBBox,
                 LeapDataType.ImageWithHeatmap: LeapImageWithHeatmap,
                 LeapDataType.Video: LeapVideo,
-                LeapDataType.Audio: LeapAudio
+                LeapDataType.Audio: LeapAudio,
+                LeapDataType.Volume: LeapVolume,
             }
             validate_output_structure(result, func_name=user_function.__name__,
                                       expected_type_name=result_type_map[visualizer_type])

{code_loader-1.0.209 → code_loader-1.0.210}/code_loader/plot_functions/plot_functions.py

@@ -20,7 +20,7 @@ from textwrap import wrap
 import math
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapImageWithBBox, LeapGraph, LeapText, \
-    LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo
+    LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo, LeapVolume
 from code_loader.utils import rescale_min_max
 
 
@@ -420,6 +420,28 @@ def plot_video(leap_data: LeapVideo, title: str) -> None:
         plt.pause(0.1)  # Adjust the pause duration as needed
     plt.show()
 
+@run_only_on_non_mapping_mode()
+def plot_volume(leap_data: LeapVolume, title: str) -> None:
+    """Middle slice along each axis, grayscale as the engine stores it (uint8), mask overlaid."""
+    volume = rescale_min_max(leap_data.data.astype(np.float32))
+    spacing = leap_data.spacing or (1.0, 1.0, 1.0)
+    fig, axes = plt.subplots(1, 3, figsize=(12, 4))
+    fig.patch.set_facecolor('black')
+    fig.suptitle(title, color='white')
+    for axis, ax in enumerate(axes):
+        index = volume.shape[axis] // 2
+        ax.imshow(np.take(volume, index, axis=axis), cmap='gray', vmin=0, vmax=255)
+        if leap_data.mask is not None:
+            mask = np.take(leap_data.mask, index, axis=axis)
+            ax.imshow(np.ma.masked_where(mask == 0, mask), cmap='tab10', alpha=0.4,
+                      vmin=0, vmax=max(9, len(leap_data.labels) - 1))
+        rows, cols = [i for i in range(3) if i != axis]
+        ax.set_aspect(spacing[rows] / spacing[cols])
+        ax.set_title(f'axis {axis} / slice {index}', color='white')
+        ax.axis('off')
+    plt.show()
+
+
 @run_only_on_non_mapping_mode()
 def plot_image_with_heatmap(leap_data: LeapImageWithHeatmap, title: str) -> None:
     """
@@ -474,4 +496,5 @@ plot_switch = {
     LeapDataType.ImageWithHeatmap: plot_image_with_heatmap,
     LeapDataType.ImageWithBBox: plot_image_with_b_box,
     LeapDataType.Video: plot_video,
+    LeapDataType.Volume: plot_volume,
 }

{code_loader-1.0.209 → code_loader-1.0.210}/code_loader/visualizers/default_visualizers.py

@@ -5,7 +5,7 @@ import numpy as np
 import numpy.typing as npt
 
 from code_loader.contract.visualizer_classes import LeapImage, LeapGraph, LeapHorizontalBar, LeapText, \
-    LeapImageMask, LeapTextMask, LeapVideo, LeapAudio
+    LeapImageMask, LeapTextMask, LeapVideo, LeapAudio, LeapVolume
 from code_loader.utils import rescale_min_max
 
 
@@ -92,6 +92,20 @@ def default_audio_visualizer(audio: npt.NDArray[np.float32],
     raise ValueError(f'visual must be 1-D, 2-D, or 3-D, got shape {v.shape}')
 
 
+def default_volume_visualizer(data: npt.NDArray[np.float32]) -> LeapVolume:
+    """Strip the batch axis and a single channel axis (first or last) to get a [D, H, W] volume."""
+    volume = data[0]
+    if volume.ndim == 4:
+        if volume.shape[0] == 1:
+            volume = volume[0]
+        elif volume.shape[-1] == 1:
+            volume = volume[..., 0]
+    if volume.ndim != 3:
+        raise ValueError('default_volume_visualizer expects [1, D, H, W], [1, 1, D, H, W] or [1, D, H, W, 1], '
+                         f'got {data.shape}')
+    return LeapVolume(volume)
+
+
 def default_graph_visualizer(data: npt.NDArray[np.float32]) -> LeapGraph:
     return LeapGraph(data[0])
 

{code_loader-1.0.209 → code_loader-1.0.210}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "code-loader"
-version = "1.0.209"
+version = "1.0.210"
 description = ""
 authors = ["dorhar <doron.harnoy@tensorleap.ai>"]
 license = "MIT"