lsurf 1.0.0__py3-none-any.whl

lsurf/gui/renderers/surface_renderer.py

@@ -0,0 +1,477 @@
+# 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.
+
+"""Surface renderer - converts lsurf surfaces to 3D mesh data.
+
+Generates vertices and indices for rendering surfaces in the 3D viewport.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from lsurf.surfaces import (
+        AnnularPlaneSurface,
+        BoundedPlaneSurface,
+        LocalRecordingSphereSurface,
+        PlaneSurface,
+        RecordingSphereSurface,
+        SphereSurface,
+        Surface,
+    )
+
+
+class SurfaceRenderer:
+    """Renders lsurf surfaces to 3D mesh data for Dear PyGui.
+
+    Each surface type has a specialized rendering method that generates
+    appropriate vertices and indices for visualization.
+    """
+
+    def __init__(self, default_size: float = 10.0, resolution: int = 32) -> None:
+        """Initialize the renderer.
+
+        Args:
+            default_size: Default size for unbounded surfaces like planes
+            resolution: Number of segments for curved surfaces
+        """
+        self.default_size = default_size
+        self.resolution = resolution
+
+    def render(self, surface: "Surface") -> dict[str, Any]:
+        """Render a surface to mesh data.
+
+        Args:
+            surface: The surface to render
+
+        Returns:
+            Dict with 'vertices', 'indices', and 'wireframe' keys
+        """
+        # Import here to avoid circular imports
+        from lsurf.surfaces import (
+            AnnularPlaneSurface,
+            BoundedPlaneSurface,
+            CurvedWaveSurface,
+            GerstnerWaveSurface,
+            GPUCurvedWaveSurface,
+            GPUGerstnerWaveSurface,
+            GPUMultiCurvedWaveSurface,
+            LocalRecordingSphereSurface,
+            PlaneSurface,
+            RecordingSphereSurface,
+            SphereSurface,
+        )
+
+        # Dispatch to appropriate renderer based on surface type
+        if isinstance(surface, BoundedPlaneSurface):
+            return self._render_bounded_plane(surface)
+        elif isinstance(surface, AnnularPlaneSurface):
+            return self._render_annular_plane(surface)
+        elif isinstance(surface, PlaneSurface):
+            return self._render_plane(surface)
+        elif isinstance(surface, LocalRecordingSphereSurface):
+            return self._render_local_sphere(surface)
+        elif isinstance(surface, RecordingSphereSurface):
+            return self._render_recording_sphere(surface)
+        elif isinstance(surface, SphereSurface):
+            return self._render_sphere(surface)
+        elif isinstance(
+            surface, (GPUGerstnerWaveSurface, GPUCurvedWaveSurface, GerstnerWaveSurface)
+        ):
+            return self._render_wave(surface)
+        elif isinstance(surface, (GPUMultiCurvedWaveSurface, CurvedWaveSurface)):
+            return self._render_multi_wave(surface)
+        else:
+            # Fallback: render as a small marker
+            return self._render_marker(getattr(surface, "point", (0, 0, 0)))
+
+    def _render_plane(self, surface: "PlaneSurface") -> dict[str, Any]:
+        """Render an infinite plane as a finite wireframe rectangle."""
+        point = np.array(surface.point, dtype=np.float32)
+        normal = np.array(surface.normal, dtype=np.float32)
+        normal = normal / np.linalg.norm(normal)
+
+        # Create orthonormal basis
+        u, v = self._create_perpendicular_basis(normal)
+
+        # Create rectangle vertices
+        size = self.default_size
+        corners = [
+            point + size * u + size * v,
+            point - size * u + size * v,
+            point - size * u - size * v,
+            point + size * u - size * v,
+        ]
+        vertices = np.array(corners, dtype=np.float32)
+
+        # Wireframe indices (line segments)
+        indices = np.array([0, 1, 1, 2, 2, 3, 3, 0], dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _render_bounded_plane(self, surface: "BoundedPlaneSurface") -> dict[str, Any]:
+        """Render a bounded rectangular plane as a solid quad."""
+        point = np.array(surface.point, dtype=np.float32)
+        normal = np.array(surface.normal, dtype=np.float32)
+        normal = normal / np.linalg.norm(normal)
+
+        width = surface.width
+        height = surface.height
+
+        # Create orthonormal basis
+        u, v = self._create_perpendicular_basis(normal)
+
+        # Create rectangle vertices
+        hw, hh = width / 2, height / 2
+        corners = [
+            point + hw * u + hh * v,
+            point - hw * u + hh * v,
+            point - hw * u - hh * v,
+            point + hw * u - hh * v,
+        ]
+        vertices = np.array(corners, dtype=np.float32)
+
+        # Triangle indices for solid rendering
+        indices = np.array([0, 1, 2, 0, 2, 3], dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": False}
+
+    def _render_annular_plane(self, surface: "AnnularPlaneSurface") -> dict[str, Any]:
+        """Render an annular (ring) plane."""
+        # AnnularPlaneSurface uses 'center' not 'point'
+        center = np.array(surface.center, dtype=np.float32)
+        normal = np.array(surface.normal, dtype=np.float32)
+        normal = normal / np.linalg.norm(normal)
+
+        inner_r = surface.inner_radius
+        outer_r = surface.outer_radius
+
+        # Create orthonormal basis
+        u, v = self._create_perpendicular_basis(normal)
+
+        # Generate ring vertices
+        n_segments = self.resolution
+        angles = np.linspace(0, 2 * np.pi, n_segments, endpoint=False)
+
+        vertices = []
+        for angle in angles:
+            c, s = np.cos(angle), np.sin(angle)
+            # Inner vertex
+            vertices.append(center + inner_r * (c * u + s * v))
+            # Outer vertex
+            vertices.append(center + outer_r * (c * u + s * v))
+
+        vertices = np.array(vertices, dtype=np.float32)
+
+        # Triangle indices for the ring
+        indices = []
+        for i in range(n_segments):
+            i0 = i * 2
+            i1 = i * 2 + 1
+            i2 = ((i + 1) % n_segments) * 2
+            i3 = ((i + 1) % n_segments) * 2 + 1
+            # Two triangles per segment
+            indices.extend([i0, i1, i3, i0, i3, i2])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": False}
+
+    def _render_sphere(self, surface: "SphereSurface") -> dict[str, Any]:
+        """Render a sphere as a wireframe."""
+        center = np.array(surface.center, dtype=np.float32)
+        radius = surface.radius
+
+        return self._generate_sphere_mesh(center, radius, wireframe=True)
+
+    def _render_local_sphere(
+        self, surface: "LocalRecordingSphereSurface"
+    ) -> dict[str, Any]:
+        """Render a local recording sphere."""
+        center = np.array(surface.center, dtype=np.float32)
+        radius = surface.radius
+
+        return self._generate_sphere_mesh(center, radius, wireframe=True)
+
+    def _render_recording_sphere(
+        self, surface: "RecordingSphereSurface"
+    ) -> dict[str, Any]:
+        """Render a recording sphere at altitude.
+
+        For large spheres (like Earth-scale), we only render a small
+        portion near the relevant area.
+        """
+        # For now, render as a horizontal plane at the altitude
+        # (full Earth sphere would be too large)
+        earth_center = np.array(surface.earth_center, dtype=np.float32)
+        radius = surface.earth_radius + surface.altitude
+
+        # Create a circular section at the top of the sphere
+        n_segments = self.resolution
+        angles = np.linspace(0, 2 * np.pi, n_segments, endpoint=False)
+
+        # Size of the section to render
+        section_radius = min(radius * 0.1, self.default_size * 5)
+
+        # Center at top of sphere
+        section_center = earth_center + np.array([0, 0, radius], dtype=np.float32)
+
+        vertices = [section_center]
+        for angle in angles:
+            x = section_radius * np.cos(angle)
+            y = section_radius * np.sin(angle)
+            vertices.append(section_center + np.array([x, y, 0], dtype=np.float32))
+
+        vertices = np.array(vertices, dtype=np.float32)
+
+        # Triangle fan indices
+        indices = []
+        for i in range(n_segments):
+            indices.extend([0, i + 1, ((i + 1) % n_segments) + 1])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": False}
+
+    def _render_wave(self, surface: Any) -> dict[str, Any]:
+        """Render a single Gerstner wave surface."""
+        # Get wave parameters
+        amplitude = getattr(surface, "amplitude", 1.0)
+        wavelength = getattr(surface, "wavelength", 10.0)
+        direction = np.array(getattr(surface, "direction", (1, 0)), dtype=np.float32)
+        direction = direction / np.linalg.norm(direction)
+        reference_z = getattr(surface, "reference_z", 0.0)
+        phase = getattr(surface, "phase", 0.0)
+        time = getattr(surface, "time", 0.0)
+
+        # Generate mesh grid
+        size = max(wavelength * 3, self.default_size)
+        n = self.resolution
+        x = np.linspace(-size, size, n)
+        y = np.linspace(-size, size, n)
+        X, Y = np.meshgrid(x, y)
+
+        # Compute wave height
+        k = 2 * np.pi / wavelength
+        omega = np.sqrt(9.81 * k)  # Deep water dispersion
+        dot = direction[0] * X + direction[1] * Y
+        Z = reference_z + amplitude * np.cos(k * dot - omega * time + phase)
+
+        return self._grid_to_mesh(X, Y, Z)
+
+    def _render_multi_wave(self, surface: Any) -> dict[str, Any]:
+        """Render a multi-wave surface."""
+        wave_params = getattr(surface, "wave_params", [])
+        time = getattr(surface, "time", 0.0)
+
+        if not wave_params:
+            # Empty wave, render as flat plane
+            return self._render_flat_grid(0.0)
+
+        # Determine grid size from wavelengths
+        max_wavelength = max(wp.wavelength for wp in wave_params)
+        size = max(max_wavelength * 3, self.default_size)
+        n = self.resolution
+        x = np.linspace(-size, size, n)
+        y = np.linspace(-size, size, n)
+        X, Y = np.meshgrid(x, y)
+
+        # Sum all wave contributions
+        Z = np.zeros_like(X)
+        for wp in wave_params:
+            direction = np.array(wp.direction_normalized, dtype=np.float32)
+            k = wp.wave_number
+            omega = wp.angular_frequency
+            dot = direction[0] * X + direction[1] * Y
+            Z += wp.amplitude * np.cos(k * dot - omega * time + wp.phase)
+
+        return self._grid_to_mesh(X, Y, Z)
+
+    def _render_flat_grid(self, z: float) -> dict[str, Any]:
+        """Render a flat grid at height z."""
+        size = self.default_size
+        n = self.resolution
+        x = np.linspace(-size, size, n)
+        y = np.linspace(-size, size, n)
+        X, Y = np.meshgrid(x, y)
+        Z = np.full_like(X, z)
+
+        return self._grid_to_mesh(X, Y, Z)
+
+    def _render_marker(self, position: tuple) -> dict[str, Any]:
+        """Render a small marker at a position (fallback)."""
+        pos = np.array(position, dtype=np.float32)
+        size = 0.5
+
+        # Small cube
+        vertices = np.array(
+            [
+                pos + [-size, -size, -size],
+                pos + [size, -size, -size],
+                pos + [size, size, -size],
+                pos + [-size, size, -size],
+                pos + [-size, -size, size],
+                pos + [size, -size, size],
+                pos + [size, size, size],
+                pos + [-size, size, size],
+            ],
+            dtype=np.float32,
+        )
+
+        # Wireframe indices
+        indices = np.array(
+            [
+                0,
+                1,
+                1,
+                2,
+                2,
+                3,
+                3,
+                0,  # Bottom
+                4,
+                5,
+                5,
+                6,
+                6,
+                7,
+                7,
+                4,  # Top
+                0,
+                4,
+                1,
+                5,
+                2,
+                6,
+                3,
+                7,  # Vertical
+            ],
+            dtype=np.uint32,
+        )
+
+        return {"vertices": vertices, "indices": indices, "wireframe": True}
+
+    def _generate_sphere_mesh(
+        self, center: np.ndarray, radius: float, wireframe: bool = True
+    ) -> dict[str, Any]:
+        """Generate a sphere mesh."""
+        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)
+
+        if wireframe:
+            # Wireframe: latitude and longitude lines
+            indices = []
+            # Latitude lines
+            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])
+            # Longitude lines
+            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)
+        else:
+            # Solid: triangles
+            indices = []
+            for i in range(n_lat):
+                for j in range(n_lon):
+                    i00 = i * n_lon + j
+                    i10 = (i + 1) * n_lon + j
+                    i01 = i * n_lon + (j + 1) % n_lon
+                    i11 = (i + 1) * n_lon + (j + 1) % n_lon
+                    indices.extend([i00, i10, i11, i00, i11, i01])
+
+            indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": wireframe}
+
+    def _grid_to_mesh(
+        self, X: np.ndarray, Y: np.ndarray, Z: np.ndarray
+    ) -> dict[str, Any]:
+        """Convert a grid to a triangle mesh."""
+        n_rows, n_cols = X.shape
+
+        # Create vertices
+        vertices = np.stack([X.ravel(), Y.ravel(), Z.ravel()], axis=1).astype(
+            np.float32
+        )
+
+        # Create triangle indices
+        indices = []
+        for i in range(n_rows - 1):
+            for j in range(n_cols - 1):
+                i00 = i * n_cols + j
+                i10 = (i + 1) * n_cols + j
+                i01 = i * n_cols + (j + 1)
+                i11 = (i + 1) * n_cols + (j + 1)
+                # Two triangles per cell
+                indices.extend([i00, i10, i11, i00, i11, i01])
+
+        indices = np.array(indices, dtype=np.uint32)
+
+        return {"vertices": vertices, "indices": indices, "wireframe": False}
+
+    def _create_perpendicular_basis(
+        self, normal: np.ndarray
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Create two perpendicular unit vectors to the given normal."""
+        # Find a vector not parallel to normal
+        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)
+        v = v / np.linalg.norm(v)
+
+        return u, v

lsurf/gui/views/__init__.py

@@ -0,0 +1,48 @@
+# 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.
+
+"""GUI view components."""
+
+from .config_editor import ConfigEditorPanel
+from .results import ResultsPanel
+from .scene_tree import SceneTreePanel
+from .viewport_3d import Viewport3D
+from .visualizations import VisualizationPanel
+
+__all__ = [
+    "Viewport3D",
+    "SceneTreePanel",
+    "ResultsPanel",
+    "ConfigEditorPanel",
+    "VisualizationPanel",
+]