lsurf 1.0.0__py3-none-any.whl

lsurf/gui/renderers/source_renderer.py

@@ -0,0 +1,505 @@
+# 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.
+
+"""Source renderer - visualizes ray sources.
+
+Generates 3D representations of ray sources including spheres for
+point sources, cylinders for collimated beams, and cones for diverging beams.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from lsurf.sources import (
+        CollimatedBeam,
+        CustomRaySource,
+        DivergingBeam,
+        GaussianBeam,
+        ParallelBeamFromPositions,
+        PointSource,
+        RaySource,
+        UniformDivergingBeam,
+    )
+
+
+class SourceRenderer:
+    """Renders ray sources to 3D mesh data for Dear PyGui."""
+
+    def __init__(self, arrow_scale: float = 1.0, resolution: int = 16) -> None:
+        """Initialize the renderer.
+
+        Args:
+            arrow_scale: Scale factor for direction arrows
+            resolution: Number of segments for curved surfaces
+        """
+        self.arrow_scale = arrow_scale
+        self.resolution = resolution
+
+    def render(self, source: "RaySource") -> dict[str, Any]:
+        """Render a source to mesh data.
+
+        Args:
+            source: The source to render
+
+        Returns:
+            Dict with 'vertices', 'indices', and 'wireframe' keys
+        """
+        from lsurf.sources import (
+            CollimatedBeam,
+            CustomRaySource,
+            DivergingBeam,
+            GaussianBeam,
+            ParallelBeamFromPositions,
+            PointSource,
+            UniformDivergingBeam,
+        )
+
+        if isinstance(source, PointSource):
+            return self._render_point_source(source)
+        elif isinstance(source, CollimatedBeam):
+            return self._render_collimated_beam(source)
+        elif isinstance(source, (DivergingBeam, UniformDivergingBeam)):
+            return self._render_diverging_beam(source)
+        elif isinstance(source, GaussianBeam):
+            return self._render_gaussian_beam(source)
+        elif isinstance(source, ParallelBeamFromPositions):
+            return self._render_parallel_from_positions(source)
+        elif isinstance(source, CustomRaySource):
+            return self._render_custom_source(source)
+        else:
+            # Fallback: try to render based on available attributes
+            return self._render_fallback(source)
+
+    def _render_point_source(self, source: "PointSource") -> dict[str, Any]:
+        """Render a point source as a sphere with direction arrows."""
+        position = np.array(source.position, dtype=np.float32)
+
+        # Size based on power (arbitrary scaling)
+        size = 0.5 * self.arrow_scale
+
+        # Generate sphere
+        sphere_data = self._generate_sphere(position, size)
+
+        # Generate arrows pointing outward in cardinal directions
+        arrows = self._generate_point_arrows(position, size * 2)
+
+        # Combine sphere and arrows
+        vertices = np.vstack([sphere_data["vertices"], arrows["vertices"]])
+        indices = np.concatenate(
+            [sphere_data["indices"], arrows["indices"] + len(sphere_data["vertices"])]
+        )
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _render_collimated_beam(self, source: "CollimatedBeam") -> dict[str, Any]:
+        """Render a collimated beam as a cylinder with arrow."""
+        center = np.array(source.center, dtype=np.float32)
+        direction = np.array(source.direction, dtype=np.float32)
+        direction = direction / np.linalg.norm(direction)
+        radius = source.radius
+
+        # Cylinder length proportional to radius
+        length = max(radius * 3, self.arrow_scale * 2)
+
+        # Generate cylinder
+        cylinder_data = self._generate_cylinder(center, direction, radius, length)
+
+        # Generate arrow at the front
+        arrow_start = center + direction * length * 0.5
+        arrow_data = self._generate_arrow(
+            arrow_start, direction, length * 0.3, radius * 0.3
+        )
+
+        # Combine
+        vertices = np.vstack([cylinder_data["vertices"], arrow_data["vertices"]])
+        indices = np.concatenate(
+            [
+                cylinder_data["indices"],
+                arrow_data["indices"] + len(cylinder_data["vertices"]),
+            ]
+        )
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _render_diverging_beam(
+        self, source: "DivergingBeam | UniformDivergingBeam"
+    ) -> dict[str, Any]:
+        """Render a diverging beam as a cone."""
+        origin = np.array(source.origin, dtype=np.float32)
+        direction = np.array(source.mean_direction, dtype=np.float32)
+        direction = direction / np.linalg.norm(direction)
+        half_angle = source.divergence_angle
+
+        # Cone length
+        length = self.arrow_scale * 3
+        radius = length * np.tan(half_angle)
+
+        # Generate cone
+        return self._generate_cone(origin, direction, radius, length)
+
+    def _render_gaussian_beam(self, source: "GaussianBeam") -> dict[str, Any]:
+        """Render a Gaussian beam with waist indicator."""
+        waist_pos = np.array(source.waist_position, dtype=np.float32)
+        direction = np.array(source.direction, dtype=np.float32)
+        direction = direction / np.linalg.norm(direction)
+        waist_radius = source.waist_radius
+
+        # Generate waist circle
+        waist_data = self._generate_circle(waist_pos, direction, waist_radius)
+
+        # Generate beam axis with arrow
+        length = self.arrow_scale * 4
+        axis_start = waist_pos - direction * length * 0.3
+        arrow_data = self._generate_arrow(
+            axis_start, direction, length, waist_radius * 0.2
+        )
+
+        # Combine
+        vertices = np.vstack([waist_data["vertices"], arrow_data["vertices"]])
+        indices = np.concatenate(
+            [waist_data["indices"], arrow_data["indices"] + len(waist_data["vertices"])]
+        )
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _render_parallel_from_positions(
+        self, source: "ParallelBeamFromPositions"
+    ) -> dict[str, Any]:
+        """Render parallel rays from explicit positions."""
+        positions = np.array(source.positions, dtype=np.float32)
+        direction = np.array(source.direction, dtype=np.float32)
+        direction = direction / np.linalg.norm(direction)
+
+        # Render a sample of positions as points with arrows
+        max_points = 100
+        if len(positions) > max_points:
+            indices_sample = np.random.choice(len(positions), max_points, replace=False)
+            positions = positions[indices_sample]
+
+        all_vertices = []
+        all_indices = []
+        vertex_offset = 0
+
+        for pos in positions:
+            arrow_data = self._generate_arrow(
+                pos, direction, self.arrow_scale, self.arrow_scale * 0.1
+            )
+            all_vertices.append(arrow_data["vertices"])
+            all_indices.append(arrow_data["indices"] + vertex_offset)
+            vertex_offset += len(arrow_data["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": True}
+
+    def _render_custom_source(self, source: "CustomRaySource") -> dict[str, Any]:
+        """Render a custom source as a point cloud."""
+        positions = np.array(source.positions, dtype=np.float32)
+        directions = np.array(source.directions, dtype=np.float32)
+
+        # Render a sample of rays as arrows
+        max_rays = 50
+        if len(positions) > max_rays:
+            indices_sample = np.random.choice(len(positions), max_rays, replace=False)
+            positions = positions[indices_sample]
+            directions = directions[indices_sample]
+
+        all_vertices = []
+        all_indices = []
+        vertex_offset = 0
+
+        for pos, dir_ in zip(positions, directions):
+            dir_norm = dir_ / np.linalg.norm(dir_)
+            arrow_data = self._generate_arrow(
+                pos, dir_norm, self.arrow_scale * 0.5, self.arrow_scale * 0.05
+            )
+            all_vertices.append(arrow_data["vertices"])
+            all_indices.append(arrow_data["indices"] + vertex_offset)
+            vertex_offset += len(arrow_data["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": True}
+
+    def _render_fallback(self, source: "RaySource") -> dict[str, Any]:
+        """Fallback renderer for unknown source types."""
+        # Try to find a position
+        position = np.array([0, 0, 0], dtype=np.float32)
+        for attr in ["position", "center", "origin", "waist_position"]:
+            if hasattr(source, attr):
+                position = np.array(getattr(source, attr), dtype=np.float32)
+                break
+
+        # Render as a simple marker
+        return self._generate_sphere(position, self.arrow_scale * 0.5)
+
+    def _generate_sphere(self, center: np.ndarray, radius: float) -> dict[str, Any]:
+        """Generate a wireframe sphere."""
+        n_lat = self.resolution // 2
+        n_lon = self.resolution
+
+        vertices = []
+        for i in range(n_lat + 1):
+            lat = np.pi * i / n_lat - np.pi / 2
+            for j in range(n_lon):
+                lon = 2 * np.pi * j / n_lon
+                x = radius * np.cos(lat) * np.cos(lon)
+                y = radius * np.cos(lat) * np.sin(lon)
+                z = radius * np.sin(lat)
+                vertices.append(center + np.array([x, y, z], dtype=np.float32))
+
+        vertices = np.array(vertices, dtype=np.float32)
+
+        # Wireframe indices
+        indices = []
+        for i in range(n_lat + 1):
+            for j in range(n_lon):
+                idx1 = i * n_lon + j
+                idx2 = i * n_lon + (j + 1) % n_lon
+                indices.extend([idx1, idx2])
+        for j in range(n_lon):
+            for i in range(n_lat):
+                idx1 = i * n_lon + j
+                idx2 = (i + 1) * n_lon + j
+                indices.extend([idx1, idx2])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_point_arrows(
+        self, center: np.ndarray, length: float
+    ) -> dict[str, Any]:
+        """Generate arrows pointing in cardinal directions from a point."""
+        directions = [
+            np.array([1, 0, 0], dtype=np.float32),
+            np.array([-1, 0, 0], dtype=np.float32),
+            np.array([0, 1, 0], dtype=np.float32),
+            np.array([0, -1, 0], dtype=np.float32),
+            np.array([0, 0, 1], dtype=np.float32),
+            np.array([0, 0, -1], dtype=np.float32),
+        ]
+
+        all_vertices = []
+        all_indices = []
+        vertex_offset = 0
+
+        for direction in directions:
+            arrow_data = self._generate_arrow(center, direction, length, length * 0.15)
+            all_vertices.append(arrow_data["vertices"])
+            all_indices.append(arrow_data["indices"] + vertex_offset)
+            vertex_offset += len(arrow_data["vertices"])
+
+        vertices = (
+            np.vstack(all_vertices)
+            if all_vertices
+            else np.zeros((0, 3), dtype=np.float32)
+        )
+        indices = (
+            np.concatenate(all_indices) if all_indices else np.zeros(0, dtype=np.uint32)
+        )
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_arrow(
+        self, start: np.ndarray, direction: np.ndarray, length: float, head_size: float
+    ) -> dict[str, Any]:
+        """Generate an arrow (line with arrowhead)."""
+        end = start + direction * length
+        head_base = end - direction * head_size
+
+        # Create perpendicular basis for arrowhead
+        if abs(direction[0]) < 0.9:
+            ref = np.array([1, 0, 0], dtype=np.float32)
+        else:
+            ref = np.array([0, 1, 0], dtype=np.float32)
+        u = np.cross(direction, ref)
+        u = u / np.linalg.norm(u)
+        v = np.cross(direction, u)
+
+        # Arrow vertices
+        vertices = np.array(
+            [
+                start,
+                end,
+                head_base + u * head_size * 0.5,
+                head_base - u * head_size * 0.5,
+                head_base + v * head_size * 0.5,
+                head_base - v * head_size * 0.5,
+            ],
+            dtype=np.float32,
+        )
+
+        # Line indices
+        indices = np.array([0, 1, 1, 2, 1, 3, 1, 4, 1, 5], dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_cylinder(
+        self,
+        center: np.ndarray,
+        direction: np.ndarray,
+        radius: float,
+        length: float,
+    ) -> dict[str, Any]:
+        """Generate a wireframe cylinder."""
+        # Create perpendicular basis
+        if abs(direction[0]) < 0.9:
+            ref = np.array([1, 0, 0], dtype=np.float32)
+        else:
+            ref = np.array([0, 1, 0], dtype=np.float32)
+        u = np.cross(direction, ref)
+        u = u / np.linalg.norm(u)
+        v = np.cross(direction, u)
+
+        # End points
+        start = center - direction * length * 0.5
+        end = center + direction * length * 0.5
+
+        # Generate circles at both ends
+        n = self.resolution
+        angles = np.linspace(0, 2 * np.pi, n, endpoint=False)
+
+        vertices = []
+        for angle in angles:
+            offset = radius * (np.cos(angle) * u + np.sin(angle) * v)
+            vertices.append(start + offset)
+        for angle in angles:
+            offset = radius * (np.cos(angle) * u + np.sin(angle) * v)
+            vertices.append(end + offset)
+
+        vertices = np.array(vertices, dtype=np.float32)
+
+        # Wireframe indices
+        indices = []
+        # Start circle
+        for i in range(n):
+            indices.extend([i, (i + 1) % n])
+        # End circle
+        for i in range(n):
+            indices.extend([n + i, n + (i + 1) % n])
+        # Connecting lines
+        for i in range(0, n, max(1, n // 4)):
+            indices.extend([i, n + i])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_cone(
+        self,
+        apex: np.ndarray,
+        direction: np.ndarray,
+        radius: float,
+        length: float,
+    ) -> dict[str, Any]:
+        """Generate a wireframe cone."""
+        # Create perpendicular basis
+        if abs(direction[0]) < 0.9:
+            ref = np.array([1, 0, 0], dtype=np.float32)
+        else:
+            ref = np.array([0, 1, 0], dtype=np.float32)
+        u = np.cross(direction, ref)
+        u = u / np.linalg.norm(u)
+        v = np.cross(direction, u)
+
+        # Base center
+        base_center = apex + direction * length
+
+        # Generate base circle
+        n = self.resolution
+        angles = np.linspace(0, 2 * np.pi, n, endpoint=False)
+
+        vertices = [apex]
+        for angle in angles:
+            offset = radius * (np.cos(angle) * u + np.sin(angle) * v)
+            vertices.append(base_center + offset)
+
+        vertices = np.array(vertices, dtype=np.float32)
+
+        # Wireframe indices
+        indices = []
+        # Base circle
+        for i in range(n):
+            indices.extend([i + 1, ((i + 1) % n) + 1])
+        # Lines from apex to base
+        for i in range(0, n, max(1, n // 8)):
+            indices.extend([0, i + 1])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_circle(
+        self, center: np.ndarray, normal: np.ndarray, radius: float
+    ) -> dict[str, Any]:
+        """Generate a wireframe circle."""
+        # Create perpendicular basis
+        if abs(normal[0]) < 0.9:
+            ref = np.array([1, 0, 0], dtype=np.float32)
+        else:
+            ref = np.array([0, 1, 0], dtype=np.float32)
+        u = np.cross(normal, ref)
+        u = u / np.linalg.norm(u)
+        v = np.cross(normal, u)
+
+        n = self.resolution
+        angles = np.linspace(0, 2 * np.pi, n, endpoint=False)
+
+        vertices = []
+        for angle in angles:
+            offset = radius * (np.cos(angle) * u + np.sin(angle) * v)
+            vertices.append(center + offset)
+
+        vertices = np.array(vertices, dtype=np.float32)
+
+        # Circle indices
+        indices = []
+        for i in range(n):
+            indices.extend([i, (i + 1) % n])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}