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

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

@@ -1,9 +1,9 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: code-loader
-Version: 1.0.209
+Version: 1.0.211
 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.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
+    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]
+LeapImageWithHeatmap, LeapVideo, LeapAudio, LeapPointCloud]
 
 CustomCallableInterface = Callable[..., Any]
 

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

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

{code_loader-1.0.209 → 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.209 → 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):
@@ -377,6 +377,61 @@ class LeapAudio:
             raise LeapValidationError(f'sample_rate must be a positive int, got {self.sample_rate}')
 
 
+@dataclass
+class LeapPointCloud:
+    """
+    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:
+    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:
+        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])
+    """
+    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.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'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 = {
     LeapDataType.Image.value: LeapImage,
     LeapDataType.Graph.value: LeapGraph,
@@ -387,5 +442,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.PointCloud.value: LeapPointCloud,
 }

{code_loader-1.0.209 → 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, 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
@@ -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.PointCloud: LeapPointCloud
             }
             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.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
+    LeapHorizontalBar, LeapImageMask, LeapTextMask, LeapImageWithHeatmap, LeapVideo, LeapPointCloud
 from code_loader.utils import rescale_min_max
 
 
@@ -464,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,
@@ -474,4 +494,5 @@ plot_switch = {
     LeapDataType.ImageWithHeatmap: plot_image_with_heatmap,
     LeapDataType.ImageWithBBox: plot_image_with_b_box,
     LeapDataType.Video: plot_video,
+    LeapDataType.PointCloud: plot_point_cloud,
 }

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

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