lsurf 1.0.0__py3-none-any.whl

lsurf/gui/renderers/ray_renderer.py

@@ -0,0 +1,353 @@
+# The Clear BSD License
+#
+# Copyright (c) 2026 Tobias Heibges
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted (subject to the limitations in the disclaimer
+# below) provided that the following conditions are met:
+#
+#      * Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+#      * Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions and the following disclaimer in the
+#      documentation and/or other materials provided with the distribution.
+#
+#      * Neither the name of the copyright holder nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+#
+# NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY
+# THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+"""Ray renderer - visualizes ray paths and detection points.
+
+Generates 3D representations of ray trajectories and detection scatter plots.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from lsurf.detectors import DetectorResult
+
+
+class RayRenderer:
+    """Renders ray paths and detection points for Dear PyGui."""
+
+    def __init__(
+        self,
+        max_rays: int = 1000,
+        point_size: float = 0.1,
+    ) -> None:
+        """Initialize the renderer.
+
+        Args:
+            max_rays: Maximum number of rays to render (for performance)
+            point_size: Size of detection point markers
+        """
+        self.max_rays = max_rays
+        self.point_size = point_size
+
+    def render_detections(self, detected: "DetectorResult") -> dict[str, Any]:
+        """Render detection points as a point cloud.
+
+        Args:
+            detected: Detection results from simulation
+
+        Returns:
+            Dict with 'vertices', 'indices', and 'wireframe' keys
+        """
+        if detected is None or len(detected.positions) == 0:
+            return {
+                "vertices": np.zeros((0, 3), dtype=np.float32),
+                "indices": np.zeros(0, dtype=np.uint32),
+                "wireframe": False,
+            }
+
+        positions = np.array(detected.positions, dtype=np.float32)
+
+        # Subsample if too many points
+        if len(positions) > self.max_rays:
+            indices_sample = np.random.choice(
+                len(positions), self.max_rays, replace=False
+            )
+            positions = positions[indices_sample]
+
+        # Generate small markers for each detection point
+        all_vertices = []
+        all_indices = []
+        vertex_offset = 0
+
+        for pos in positions:
+            marker = self._generate_point_marker(pos)
+            all_vertices.append(marker["vertices"])
+            all_indices.append(marker["indices"] + vertex_offset)
+            vertex_offset += len(marker["vertices"])
+
+        if all_vertices:
+            vertices = np.vstack(all_vertices)
+            indices = np.concatenate(all_indices)
+        else:
+            vertices = np.zeros((0, 3), dtype=np.float32)
+            indices = np.zeros(0, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": False}
+
+    def render_ray_paths(self, surface_hits: dict[str, list]) -> dict[str, Any]:
+        """Render ray paths from surface hit records.
+
+        Args:
+            surface_hits: Dict mapping surface names to lists of hit records
+
+        Returns:
+            Dict with 'vertices', 'indices', and 'wireframe' keys
+        """
+        if not surface_hits:
+            return {
+                "vertices": np.zeros((0, 3), dtype=np.float32),
+                "indices": np.zeros(0, dtype=np.uint32),
+                "wireframe": True,
+            }
+
+        # Collect all hit positions
+        all_positions = []
+        for surface_name, hits in surface_hits.items():
+            for hit in hits:
+                if hasattr(hit, "position"):
+                    all_positions.append(np.array(hit.position, dtype=np.float32))
+                elif hasattr(hit, "positions"):
+                    all_positions.extend(
+                        [np.array(p, dtype=np.float32) for p in hit.positions]
+                    )
+
+        if not all_positions:
+            return {
+                "vertices": np.zeros((0, 3), dtype=np.float32),
+                "indices": np.zeros(0, dtype=np.uint32),
+                "wireframe": True,
+            }
+
+        # Subsample if too many
+        if len(all_positions) > self.max_rays:
+            indices_sample = np.random.choice(
+                len(all_positions), self.max_rays, replace=False
+            )
+            all_positions = [all_positions[i] for i in indices_sample]
+
+        vertices = np.array(all_positions, dtype=np.float32)
+
+        # For now, just render as points (connecting rays would require
+        # tracking individual ray paths through bounces)
+        all_indices = []
+        vertex_offset = 0
+
+        markers_vertices = []
+        for pos in vertices:
+            marker = self._generate_point_marker(pos, size=self.point_size * 0.5)
+            markers_vertices.append(marker["vertices"])
+            all_indices.append(marker["indices"] + vertex_offset)
+            vertex_offset += len(marker["vertices"])
+
+        if markers_vertices:
+            final_vertices = np.vstack(markers_vertices)
+            final_indices = np.concatenate(all_indices)
+        else:
+            final_vertices = np.zeros((0, 3), dtype=np.float32)
+            final_indices = np.zeros(0, dtype=np.uint32)
+
+        return {"vertices": final_vertices, "indices": final_indices, "wireframe": True}
+
+    def render_rays_batch(
+        self,
+        origins: np.ndarray,
+        directions: np.ndarray,
+        lengths: np.ndarray | float = 1.0,
+    ) -> dict[str, Any]:
+        """Render a batch of rays as lines.
+
+        Args:
+            origins: Ray origin positions (N, 3)
+            directions: Ray direction vectors (N, 3)
+            lengths: Ray lengths, scalar or array (N,)
+
+        Returns:
+            Dict with 'vertices', 'indices', and 'wireframe' keys
+        """
+        origins = np.array(origins, dtype=np.float32)
+        directions = np.array(directions, dtype=np.float32)
+
+        if np.isscalar(lengths):
+            lengths = np.full(len(origins), lengths, dtype=np.float32)
+        else:
+            lengths = np.array(lengths, dtype=np.float32)
+
+        # Subsample if too many
+        if len(origins) > self.max_rays:
+            indices_sample = np.random.choice(
+                len(origins), self.max_rays, replace=False
+            )
+            origins = origins[indices_sample]
+            directions = directions[indices_sample]
+            lengths = lengths[indices_sample]
+
+        # Normalize directions
+        norms = np.linalg.norm(directions, axis=1, keepdims=True)
+        norms[norms == 0] = 1  # Avoid division by zero
+        directions = directions / norms
+
+        # Compute end points
+        ends = origins + directions * lengths[:, np.newaxis]
+
+        # Interleave origins and ends for line segments
+        n_rays = len(origins)
+        vertices = np.zeros((n_rays * 2, 3), dtype=np.float32)
+        vertices[0::2] = origins
+        vertices[1::2] = ends
+
+        # Line segment indices
+        indices = np.arange(n_rays * 2, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_point_marker(
+        self, position: np.ndarray, size: float | None = None
+    ) -> dict[str, Any]:
+        """Generate a small marker for a single point.
+
+        Uses a small octahedron shape for visibility.
+        """
+        if size is None:
+            size = self.point_size
+
+        pos = np.array(position, dtype=np.float32)
+
+        # Octahedron vertices
+        vertices = np.array(
+            [
+                pos + [size, 0, 0],
+                pos + [-size, 0, 0],
+                pos + [0, size, 0],
+                pos + [0, -size, 0],
+                pos + [0, 0, size],
+                pos + [0, 0, -size],
+            ],
+            dtype=np.float32,
+        )
+
+        # Triangle faces
+        indices = np.array(
+            [
+                0,
+                2,
+                4,
+                2,
+                1,
+                4,
+                1,
+                3,
+                4,
+                3,
+                0,
+                4,
+                0,
+                5,
+                2,
+                2,
+                5,
+                1,
+                1,
+                5,
+                3,
+                3,
+                5,
+                0,
+            ],
+            dtype=np.uint32,
+        )
+
+        return {"vertices": vertices, "indices": indices, "wireframe": False}
+
+    def color_by_intensity(self, intensities: np.ndarray) -> np.ndarray:
+        """Generate colors based on ray intensities.
+
+        Args:
+            intensities: Ray intensity values
+
+        Returns:
+            RGBA colors array (N, 4)
+        """
+        # Normalize to 0-1
+        if len(intensities) == 0:
+            return np.zeros((0, 4), dtype=np.float32)
+
+        i_min, i_max = intensities.min(), intensities.max()
+        if i_max > i_min:
+            normalized = (intensities - i_min) / (i_max - i_min)
+        else:
+            normalized = np.ones_like(intensities)
+
+        # Use a simple colormap (blue -> red)
+        colors = np.zeros((len(intensities), 4), dtype=np.float32)
+        colors[:, 0] = normalized  # Red
+        colors[:, 2] = 1 - normalized  # Blue
+        colors[:, 3] = 1.0  # Alpha
+
+        return colors
+
+    def color_by_wavelength(self, wavelengths: np.ndarray) -> np.ndarray:
+        """Generate colors based on wavelengths (approximate visible spectrum).
+
+        Args:
+            wavelengths: Wavelength values in meters
+
+        Returns:
+            RGBA colors array (N, 4)
+        """
+        if len(wavelengths) == 0:
+            return np.zeros((0, 4), dtype=np.float32)
+
+        # Convert to nanometers
+        wl_nm = wavelengths * 1e9
+
+        colors = np.zeros((len(wavelengths), 4), dtype=np.float32)
+
+        for i, wl in enumerate(wl_nm):
+            if wl < 380:
+                # UV - purple
+                colors[i] = [0.5, 0.0, 0.5, 1.0]
+            elif wl < 440:
+                # Violet
+                colors[i] = [0.5 - 0.5 * (wl - 380) / 60, 0, 1, 1]
+            elif wl < 490:
+                # Blue -> Cyan
+                colors[i] = [0, (wl - 440) / 50, 1, 1]
+            elif wl < 510:
+                # Cyan -> Green
+                colors[i] = [0, 1, 1 - (wl - 490) / 20, 1]
+            elif wl < 580:
+                # Green -> Yellow
+                colors[i] = [(wl - 510) / 70, 1, 0, 1]
+            elif wl < 645:
+                # Yellow -> Red
+                colors[i] = [1, 1 - (wl - 580) / 65, 0, 1]
+            elif wl < 780:
+                # Red
+                colors[i] = [1, 0, 0, 1]
+            else:
+                # IR - dark red
+                colors[i] = [0.5, 0, 0, 1]
+
+        return colors.astype(np.float32)