lsurf 1.0.0__py3-none-any.whl

lsurf/gui/core/__init__.py

@@ -0,0 +1,39 @@
+# 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.
+
+"""Core GUI components for scene and simulation management."""
+
+from .scene import Scene, SceneObject
+from .simulation import SimulationRunner
+
+__all__ = ["Scene", "SceneObject", "SimulationRunner"]

lsurf/gui/core/scene.py

@@ -0,0 +1,343 @@
+# 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.
+
+"""Scene state management for the GUI.
+
+Manages the collection of surfaces, sources, and simulation results
+that are displayed in the 3D viewport.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import TYPE_CHECKING, Any, Callable
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from lsurf.geometry import Geometry
+    from lsurf.simulation import SimulationResult
+    from lsurf.sources import RaySource
+    from lsurf.surfaces import Surface
+
+
+class ObjectType(Enum):
+    """Type of object in the scene."""
+
+    SURFACE = auto()
+    DETECTOR = auto()
+    SOURCE = auto()
+    RAY_PATHS = auto()
+    DETECTIONS = auto()
+
+
+@dataclass
+class SceneObject:
+    """A single object in the scene hierarchy."""
+
+    name: str
+    obj_type: ObjectType
+    data: Any
+    visible: bool = True
+    color: tuple[float, float, float, float] = (0.7, 0.7, 0.7, 1.0)
+    selected: bool = False
+
+    # Mesh data for rendering (computed by renderers)
+    vertices: np.ndarray | None = None
+    indices: np.ndarray | None = None
+    wireframe: bool = False
+
+
+@dataclass
+class Scene:
+    """Central state management for the GUI scene.
+
+    Holds all objects to be rendered and provides methods for
+    adding, removing, and querying objects.
+    """
+
+    objects: dict[str, SceneObject] = field(default_factory=dict)
+    geometry: "Geometry | None" = None
+    source: "RaySource | None" = None
+    result: "SimulationResult | None" = None
+
+    # Camera state
+    camera_position: np.ndarray = field(
+        default_factory=lambda: np.array([0.0, -50.0, 25.0])
+    )
+    camera_target: np.ndarray = field(default_factory=lambda: np.array([0.0, 0.0, 0.0]))
+    camera_up: np.ndarray = field(default_factory=lambda: np.array([0.0, 0.0, 1.0]))
+
+    # Selection state
+    selected_object: str | None = None
+
+    # Callbacks for UI updates
+    _on_change_callbacks: list[Callable[[], None]] = field(default_factory=list)
+
+    def add_object(self, obj: SceneObject) -> None:
+        """Add an object to the scene."""
+        self.objects[obj.name] = obj
+        self._notify_change()
+
+    def remove_object(self, name: str) -> None:
+        """Remove an object from the scene."""
+        if name in self.objects:
+            del self.objects[name]
+            if self.selected_object == name:
+                self.selected_object = None
+            self._notify_change()
+
+    def get_object(self, name: str) -> SceneObject | None:
+        """Get an object by name."""
+        return self.objects.get(name)
+
+    def select_object(self, name: str | None) -> None:
+        """Select an object (or deselect if None)."""
+        # Deselect previous
+        if self.selected_object and self.selected_object in self.objects:
+            self.objects[self.selected_object].selected = False
+
+        # Select new
+        self.selected_object = name
+        if name and name in self.objects:
+            self.objects[name].selected = True
+
+        self._notify_change()
+
+    def toggle_visibility(self, name: str) -> None:
+        """Toggle visibility of an object."""
+        if name in self.objects:
+            self.objects[name].visible = not self.objects[name].visible
+            self._notify_change()
+
+    def clear(self) -> None:
+        """Clear all objects from the scene."""
+        self.objects.clear()
+        self.geometry = None
+        self.source = None
+        self.result = None
+        self.selected_object = None
+        self._notify_change()
+
+    def get_objects_by_type(self, obj_type: ObjectType) -> list[SceneObject]:
+        """Get all objects of a specific type."""
+        return [obj for obj in self.objects.values() if obj.obj_type == obj_type]
+
+    def get_visible_objects(self) -> list[SceneObject]:
+        """Get all visible objects."""
+        return [obj for obj in self.objects.values() if obj.visible]
+
+    def get_bounds(self) -> tuple[np.ndarray, np.ndarray]:
+        """Get the bounding box of all objects.
+
+        Returns:
+            (min_corner, max_corner) as numpy arrays
+        """
+        all_vertices = []
+        for obj in self.objects.values():
+            if obj.visible and obj.vertices is not None and len(obj.vertices) > 0:
+                all_vertices.append(obj.vertices)
+
+        if not all_vertices:
+            # Default bounds if no objects
+            return np.array([-10.0, -10.0, -10.0]), np.array([10.0, 10.0, 10.0])
+
+        all_verts = np.vstack(all_vertices)
+        return all_verts.min(axis=0), all_verts.max(axis=0)
+
+    def fit_camera_to_scene(self) -> None:
+        """Adjust camera to fit all objects in view."""
+        min_bounds, max_bounds = self.get_bounds()
+        center = (min_bounds + max_bounds) / 2
+        size = np.linalg.norm(max_bounds - min_bounds)
+
+        # Position camera at 45-degree angle looking at center
+        distance = max(size * 1.5, 10.0)
+        self.camera_target = center
+        self.camera_position = center + np.array(
+            [distance * 0.5, -distance * 0.7, distance * 0.5]
+        )
+        self._notify_change()
+
+    def on_change(self, callback: Callable[[], None]) -> None:
+        """Register a callback to be called when the scene changes."""
+        self._on_change_callbacks.append(callback)
+
+    def _notify_change(self) -> None:
+        """Notify all registered callbacks of a change."""
+        for callback in self._on_change_callbacks:
+            callback()
+
+    def load_geometry(self, geometry: "Geometry") -> None:
+        """Load a Geometry object into the scene."""
+        from ..renderers import SurfaceRenderer
+
+        self.geometry = geometry
+
+        # Remove existing surfaces and detectors
+        to_remove = [
+            name
+            for name, obj in self.objects.items()
+            if obj.obj_type in (ObjectType.SURFACE, ObjectType.DETECTOR)
+        ]
+        for name in to_remove:
+            del self.objects[name]
+
+        renderer = SurfaceRenderer()
+
+        # Add surfaces
+        for surface in geometry.surfaces:
+            mesh_data = renderer.render(surface)
+            obj = SceneObject(
+                name=surface.name,
+                obj_type=ObjectType.SURFACE,
+                data=surface,
+                color=_get_surface_color(surface),
+                vertices=mesh_data.get("vertices"),
+                indices=mesh_data.get("indices"),
+                wireframe=mesh_data.get("wireframe", False),
+            )
+            self.objects[surface.name] = obj
+            print(
+                f"[Scene] Added surface '{surface.name}': {type(surface).__name__}, vertices={mesh_data.get('vertices') is not None}, indices={mesh_data.get('indices') is not None}"
+            )
+
+        # Add detectors
+        for detector in geometry.detectors:
+            mesh_data = renderer.render(detector)
+            obj = SceneObject(
+                name=detector.name,
+                obj_type=ObjectType.DETECTOR,
+                data=detector,
+                color=(0.2, 0.8, 0.2, 0.8),  # Green for detectors
+                vertices=mesh_data.get("vertices"),
+                indices=mesh_data.get("indices"),
+                wireframe=mesh_data.get("wireframe", False),
+            )
+            self.objects[detector.name] = obj
+            print(
+                f"[Scene] Added detector '{detector.name}': {type(detector).__name__}, vertices={mesh_data.get('vertices') is not None}, indices={mesh_data.get('indices') is not None}"
+            )
+
+        print(f"[Scene] Total objects: {len(self.objects)}")
+        self.fit_camera_to_scene()
+        self._notify_change()
+
+    def load_source(self, source: "RaySource") -> None:
+        """Load a RaySource into the scene."""
+        from ..renderers import SourceRenderer
+
+        self.source = source
+
+        # Remove existing source
+        to_remove = [
+            name
+            for name, obj in self.objects.items()
+            if obj.obj_type == ObjectType.SOURCE
+        ]
+        for name in to_remove:
+            del self.objects[name]
+
+        renderer = SourceRenderer()
+        mesh_data = renderer.render(source)
+
+        obj = SceneObject(
+            name="Source",
+            obj_type=ObjectType.SOURCE,
+            data=source,
+            color=(1.0, 0.8, 0.0, 1.0),  # Yellow/gold for sources
+            vertices=mesh_data.get("vertices"),
+            indices=mesh_data.get("indices"),
+            wireframe=mesh_data.get("wireframe", False),
+        )
+        self.objects["Source"] = obj
+        self._notify_change()
+
+    def load_result(self, result: "SimulationResult", show_rays: bool = True) -> None:
+        """Load simulation results into the scene."""
+        from ..renderers import RayRenderer
+
+        self.result = result
+
+        # Remove existing results
+        to_remove = [
+            name
+            for name, obj in self.objects.items()
+            if obj.obj_type in (ObjectType.RAY_PATHS, ObjectType.DETECTIONS)
+        ]
+        for name in to_remove:
+            del self.objects[name]
+
+        renderer = RayRenderer()
+
+        # Add detection points
+        if result.detected is not None and result.num_detected > 0:
+            mesh_data = renderer.render_detections(result.detected)
+            obj = SceneObject(
+                name="Detections",
+                obj_type=ObjectType.DETECTIONS,
+                data=result.detected,
+                color=(1.0, 0.2, 0.2, 1.0),  # Red for detections
+                vertices=mesh_data.get("vertices"),
+                indices=mesh_data.get("indices"),
+                wireframe=False,
+            )
+            self.objects["Detections"] = obj
+
+        # Add ray paths if available and requested
+        if show_rays and result.surface_hits:
+            mesh_data = renderer.render_ray_paths(result.surface_hits)
+            if mesh_data.get("vertices") is not None:
+                obj = SceneObject(
+                    name="Ray Paths",
+                    obj_type=ObjectType.RAY_PATHS,
+                    data=result.surface_hits,
+                    color=(0.5, 0.5, 1.0, 0.5),  # Blue for rays
+                    vertices=mesh_data.get("vertices"),
+                    indices=mesh_data.get("indices"),
+                    wireframe=True,
+                )
+                self.objects["Ray Paths"] = obj
+
+        self._notify_change()
+
+
+def _get_surface_color(surface: "Surface") -> tuple[float, float, float, float]:
+    """Get a color for a surface based on its role."""
+    from lsurf.surfaces import SurfaceRole
+
+    if surface.role == SurfaceRole.DETECTOR:
+        return (0.2, 0.8, 0.2, 0.8)  # Green
+    elif surface.role == SurfaceRole.ABSORBER:
+        return (0.3, 0.3, 0.3, 0.9)  # Dark gray
+    else:  # OPTICAL
+        return (0.4, 0.6, 0.9, 0.7)  # Light blue

lsurf/gui/core/simulation.py

@@ -0,0 +1,264 @@
+# 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.
+
+"""Background simulation runner for the GUI.
+
+Runs simulations in a separate thread to keep the GUI responsive.
+"""
+
+import threading
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    from lsurf.geometry import Geometry
+    from lsurf.simulation import SimulationConfig, SimulationResult
+    from lsurf.sources import RaySource
+
+
+class SimulationState(Enum):
+    """State of the simulation runner."""
+
+    IDLE = auto()
+    RUNNING = auto()
+    COMPLETED = auto()
+    ERROR = auto()
+    CANCELLED = auto()
+
+
+@dataclass
+class SimulationProgress:
+    """Progress information for a running simulation."""
+
+    state: SimulationState
+    bounce: int = 0
+    max_bounces: int = 0
+    rays_active: int = 0
+    rays_detected: int = 0
+    message: str = ""
+    error: Exception | None = None
+
+
+class SimulationRunner:
+    """Runs simulations in a background thread.
+
+    Usage:
+        runner = SimulationRunner()
+        runner.on_progress(update_progress_bar)
+        runner.on_complete(handle_results)
+        runner.start(geometry, source, config)
+    """
+
+    def __init__(self) -> None:
+        self._thread: threading.Thread | None = None
+        self._cancel_flag = threading.Event()
+        self._progress = SimulationProgress(state=SimulationState.IDLE)
+        self._result: "SimulationResult | None" = None
+
+        # Callbacks
+        self._on_progress_callbacks: list[Callable[[SimulationProgress], None]] = []
+        self._on_complete_callbacks: list[
+            Callable[["SimulationResult | None"], None]
+        ] = []
+
+    @property
+    def state(self) -> SimulationState:
+        """Current state of the simulation."""
+        return self._progress.state
+
+    @property
+    def progress(self) -> SimulationProgress:
+        """Current progress information."""
+        return self._progress
+
+    @property
+    def result(self) -> "SimulationResult | None":
+        """The simulation result (if completed)."""
+        return self._result
+
+    def on_progress(self, callback: Callable[[SimulationProgress], None]) -> None:
+        """Register a callback for progress updates."""
+        self._on_progress_callbacks.append(callback)
+
+    def on_complete(
+        self, callback: Callable[["SimulationResult | None"], None]
+    ) -> None:
+        """Register a callback for completion."""
+        self._on_complete_callbacks.append(callback)
+
+    def start(
+        self,
+        geometry: "Geometry",
+        source: "RaySource",
+        config: "SimulationConfig | None" = None,
+    ) -> bool:
+        """Start a simulation in the background.
+
+        Args:
+            geometry: The geometry to simulate
+            source: The ray source
+            config: Optional simulation configuration
+
+        Returns:
+            True if started successfully, False if already running
+        """
+        if self._thread is not None and self._thread.is_alive():
+            return False
+
+        self._cancel_flag.clear()
+        self._result = None
+        self._progress = SimulationProgress(
+            state=SimulationState.RUNNING, message="Initializing..."
+        )
+        self._notify_progress()
+
+        self._thread = threading.Thread(
+            target=self._run_simulation,
+            args=(geometry, source, config),
+            daemon=True,
+        )
+        self._thread.start()
+        return True
+
+    def cancel(self) -> None:
+        """Request cancellation of the running simulation."""
+        self._cancel_flag.set()
+
+    def is_running(self) -> bool:
+        """Check if a simulation is currently running."""
+        return self._thread is not None and self._thread.is_alive()
+
+    def _run_simulation(
+        self,
+        geometry: "Geometry",
+        source: "RaySource",
+        config: "SimulationConfig | None",
+    ) -> None:
+        """Run the simulation (called in background thread)."""
+        try:
+            from lsurf.simulation import Simulation, SimulationConfig
+
+            # Create simulation
+            sim_config = config or SimulationConfig()
+            simulation = Simulation(geometry, sim_config)
+
+            self._progress.max_bounces = sim_config.max_bounces
+            self._progress.message = "Generating rays..."
+            self._notify_progress()
+
+            # Generate rays
+            rays = source.generate()
+            self._progress.rays_active = rays.num_rays
+            self._progress.message = "Running simulation..."
+            self._notify_progress()
+
+            # Check for cancellation
+            if self._cancel_flag.is_set():
+                self._progress.state = SimulationState.CANCELLED
+                self._progress.message = "Cancelled"
+                self._notify_progress()
+                self._notify_complete()
+                return
+
+            # Run simulation
+            # Note: For more detailed progress, we could use run_single_bounce
+            # in a loop, but the full run is more efficient
+            result = simulation.run(rays)
+
+            # Check for cancellation
+            if self._cancel_flag.is_set():
+                self._progress.state = SimulationState.CANCELLED
+                self._progress.message = "Cancelled"
+                self._notify_progress()
+                self._notify_complete()
+                return
+
+            # Success
+            self._result = result
+            self._progress.state = SimulationState.COMPLETED
+            self._progress.bounce = result.bounces
+            self._progress.rays_detected = result.num_detected
+            self._progress.rays_active = result.num_remaining
+            self._progress.message = f"Complete: {result.num_detected} rays detected"
+            self._notify_progress()
+            self._notify_complete()
+
+        except Exception as e:
+            self._progress.state = SimulationState.ERROR
+            self._progress.error = e
+            self._progress.message = f"Error: {e}"
+            self._notify_progress()
+            self._notify_complete()
+
+    def _notify_progress(self) -> None:
+        """Notify progress callbacks."""
+        for callback in self._on_progress_callbacks:
+            try:
+                callback(self._progress)
+            except Exception:
+                pass  # Don't let callback errors crash the simulation
+
+    def _notify_complete(self) -> None:
+        """Notify completion callbacks."""
+        for callback in self._on_complete_callbacks:
+            try:
+                callback(self._result)
+            except Exception:
+                pass
+
+
+def run_simulation_sync(
+    geometry: "Geometry",
+    source: "RaySource",
+    config: "SimulationConfig | None" = None,
+) -> "SimulationResult":
+    """Run a simulation synchronously (blocking).
+
+    This is a convenience function for running simulations without
+    the background thread infrastructure.
+
+    Args:
+        geometry: The geometry to simulate
+        source: The ray source
+        config: Optional simulation configuration
+
+    Returns:
+        The simulation result
+    """
+    from lsurf.simulation import Simulation, SimulationConfig
+
+    sim_config = config or SimulationConfig()
+    simulation = Simulation(geometry, sim_config)
+    rays = source.generate()
+    return simulation.run(rays)

lsurf/gui/renderers/__init__.py

@@ -0,0 +1,40 @@
+# 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.
+
+"""Renderers for converting lsurf objects to 3D visuals."""
+
+from .ray_renderer import RayRenderer
+from .source_renderer import SourceRenderer
+from .surface_renderer import SurfaceRenderer
+
+__all__ = ["SurfaceRenderer", "SourceRenderer", "RayRenderer"]