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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.210
+Version: 1.0.211
 Summary: 
 Home-page: https://github.com/tensorleap/code-loader
 License: MIT

{code_loader-1.0.210 → code_loader-1.0.211}/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, LeapVolume
+    LeapTextMask, LeapImageMask, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapPointCloud
 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, LeapVolume]
+LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapPointCloud]
 
 CustomCallableInterface = Callable[..., Any]
 

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

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

{code_loader-1.0.210 → code_loader-1.0.211}/code_loader/contract/responsedataclasses.py

@@ -131,6 +131,35 @@ class BoundingBox:
     metadata: Optional[Dict[str, Union[str, int, float]]] = None
 
 
+@dataclass
+class BoundingBox3D:
+    """
+    Represents an oriented 3D bounding box in a point cloud's coordinate frame.
+
+    Attributes:
+    x, y, z (float): The center of the box.
+    width (float): Extent along the box's local y axis.
+    length (float): Extent along the box's local x axis (the heading axis).
+    height (float): Extent along the box's local z axis.
+    yaw (float): Rotation about +z in radians, counter-clockwise from +x. The +length/2 face is the front.
+    label (str): The class name of the box.
+    confidence (float): Prediction score, typically in [0, 1]; 1.0 for ground truth.
+    metadata (Optional[Dict[str, Union[str, int, float]]]): Optional extra fields shown with the box.
+
+    Corners are the local points (±length/2, ±width/2, ±height/2) rotated by yaw about z, then translated to (x, y, z).
+    """
+    x: float
+    y: float
+    z: float
+    width: float
+    length: float
+    height: float
+    yaw: float
+    label: str
+    confidence: float = 1.0
+    metadata: Optional[Dict[str, Union[str, int, float]]] = None
+
+
 
 @dataclass
 class LeapAnalysisConfiguration:

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

@@ -5,7 +5,7 @@ import numpy.typing as npt
 from dataclasses import dataclass
 
 from code_loader.contract.enums import LeapDataType
-from code_loader.contract.responsedataclasses import BoundingBox
+from code_loader.contract.responsedataclasses import BoundingBox, BoundingBox3D
 
 
 class LeapValidationError(Exception):
@@ -378,57 +378,58 @@ class LeapAudio:
 
 
 @dataclass
-class LeapVolume:
+class LeapPointCloud:
     """
-    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.
+    Visualizer representing a set of 3D points for Tensorleap: a LiDAR sweep, a depth-camera frame, a mesh's
+    vertices, or any (N, 3) point set. The UI renders it with an orbit camera; the engine stores the points as a
+    raw float32 blob.
 
     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.
+    points (npt.NDArray[np.float32]): The points, shaped [N, 3] as x, y, z in any consistent frame and unit.
+    intensity (Optional[npt.NDArray[np.float32]]): Optional per-point scalar shaped [N]: the LiDAR return
+        intensity in most formats, but any per-point value (reflectance, depth, an error) fits. The UI offers it as a
+        color mode.
+    bounding_boxes (Optional[List[BoundingBox3D]]): Optional oriented 3D boxes in the same frame as `points`.
+        An empty list is valid.
+    type (LeapDataType): The data type, default is LeapDataType.PointCloud.
 
     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))
+        points = (np.random.rand(1000, 3) * 50).astype(np.float32)
+        box = BoundingBox3D(x=10, y=0, z=1, width=2, length=4.5, height=1.8, yaw=0.3, label="car", confidence=0.9)
+        leap_point_cloud = LeapPointCloud(points=points, intensity=points[:, 2].copy(), bounding_boxes=[box])
     """
-    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
+    points: npt.NDArray[np.float32]
+    intensity: Optional[npt.NDArray[np.float32]] = None
+    bounding_boxes: Optional[List[BoundingBox3D]] = None
+    type: LeapDataType = LeapDataType.PointCloud
 
     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):
+        validate_type(self.type, LeapDataType.PointCloud)
+        validate_type(type(self.points), np.ndarray)
+        validate_type(self.points.dtype, np.float32)
+        validate_type(len(self.points.shape), 2, 'Point cloud points must be of shape 2 [N, 3]')
+        if self.points.shape[1] != 3 or self.points.shape[0] < 1:
+            raise LeapValidationError(
+                f'Point cloud points must be of shape [N, 3] with N >= 1, got {self.points.shape}')
+        if not np.isfinite(self.points).all():
+            raise LeapValidationError('Point cloud points must be finite (no NaN/Inf)')
+        if self.intensity is not None:
+            validate_type(type(self.intensity), np.ndarray)
+            validate_type(self.intensity.dtype, np.float32)
+            if self.intensity.shape != (self.points.shape[0],):
                 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}')
+                    f'Point cloud intensity shape {self.intensity.shape} must be ({self.points.shape[0]},)')
+            if not np.isfinite(self.intensity).all():
+                raise LeapValidationError('Point cloud intensity must be finite (no NaN/Inf)')
+        if self.bounding_boxes is not None:
+            validate_type(type(self.bounding_boxes), list)
+            for box in self.bounding_boxes:
+                validate_type(type(box), BoundingBox3D)
+                numbers = (box.x, box.y, box.z, box.width, box.length, box.height, box.yaw, box.confidence)
+                if not all(np.isfinite(float(v)) for v in numbers):
+                    raise LeapValidationError(f'BoundingBox3D "{box.label}" has a non-finite field')
+                if min(box.width, box.length, box.height) <= 0:
+                    raise LeapValidationError(f'BoundingBox3D "{box.label}" extents must be positive')
 
 
 map_leap_data_type_to_visualizer_class = {
@@ -442,5 +443,5 @@ map_leap_data_type_to_visualizer_class = {
     LeapDataType.ImageWithBBox.value: LeapImageWithBBox,
     LeapDataType.ImageWithHeatmap.value: LeapImageWithHeatmap,
     LeapDataType.Audio.value: LeapAudio,
-    LeapDataType.Volume.value: LeapVolume,
+    LeapDataType.PointCloud.value: LeapPointCloud,
 }

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

@@ -34,8 +34,8 @@ 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, LeapVolume, LeapValidationError, \
-    map_leap_data_type_to_visualizer_class
+    LeapHorizontalBar, LeapImageWithBBox, LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapPointCloud, \
+    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
 from code_loader.mixpanel_tracker import clear_integration_events, AnalyticsEvent, emit_integration_event_once
@@ -1594,7 +1594,7 @@ def tensorleap_custom_visualizer(name: str, visualizer_type: LeapDataType,
                 LeapDataType.ImageWithHeatmap: LeapImageWithHeatmap,
                 LeapDataType.Video: LeapVideo,
                 LeapDataType.Audio: LeapAudio,
-                LeapDataType.Volume: LeapVolume,
+                LeapDataType.PointCloud: LeapPointCloud
             }
             validate_output_structure(result, func_name=user_function.__name__,
                                       expected_type_name=result_type_map[visualizer_type])

{code_loader-1.0.210 → code_loader-1.0.211}/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, LeapVolume
+    LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo, LeapPointCloud
 from code_loader.utils import rescale_min_max
 
 
@@ -420,28 +420,6 @@ 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:
     """
@@ -486,6 +464,26 @@ def plot_image_with_heatmap(leap_data: LeapImageWithHeatmap, title: str) -> None
 
 
 
+@run_only_on_non_mapping_mode()
+def plot_point_cloud(leap_data: LeapPointCloud, title: str) -> None:
+    """Bird's-eye view (x right, y up, equal aspect): points colored by height, box footprints as polylines."""
+    points = leap_data.points
+    fig, ax = plt.subplots(figsize=(7, 7))
+    fig.patch.set_facecolor('black')
+    ax.set_facecolor('black')
+    ax.scatter(points[:, 0], points[:, 1], s=1, c=points[:, 2], cmap='viridis')
+    for box in leap_data.bounding_boxes or []:
+        c, s = np.cos(box.yaw), np.sin(box.yaw)
+        local = np.array([[1, 1], [1, -1], [-1, -1], [-1, 1], [1, 1]], dtype=np.float64) * [box.length / 2, box.width / 2]
+        corners = local @ np.array([[c, -s], [s, c]]).T + [box.x, box.y]
+        ax.plot(corners[:, 0], corners[:, 1], linewidth=1.5, color='orange')
+        ax.text(box.x, box.y, f'{box.label} {box.confidence:.2f}', color='orange', fontsize=6)
+    ax.set_aspect('equal')
+    ax.set_title(f'{title} ({points.shape[0]} points)', color='white')
+    ax.tick_params(colors='white')
+    plt.show()
+
+
 plot_switch = {
     LeapDataType.Image: plot_image,
     LeapDataType.Text: plot_text_with_heatmap,
@@ -496,5 +494,5 @@ plot_switch = {
     LeapDataType.ImageWithHeatmap: plot_image_with_heatmap,
     LeapDataType.ImageWithBBox: plot_image_with_b_box,
     LeapDataType.Video: plot_video,
-    LeapDataType.Volume: plot_volume,
+    LeapDataType.PointCloud: plot_point_cloud,
 }

{code_loader-1.0.210 → code_loader-1.0.211}/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, LeapVolume
+    LeapImageMask, LeapTextMask, LeapVideo, LeapAudio
 from code_loader.utils import rescale_min_max
 
 
@@ -92,20 +92,6 @@ 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.210 → code_loader-1.0.211}/pyproject.toml

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