lsurf 1.0.0__py3-none-any.whl

lsurf/gui/views/properties.py

@@ -0,0 +1,257 @@
+# 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.
+
+"""Properties panel - displays and edits properties of selected objects.
+
+Shows detailed information about the currently selected surface, source,
+or result object with editable fields where applicable.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+import dearpygui.dearpygui as dpg
+
+if TYPE_CHECKING:
+    from ..core.scene import Scene, SceneObject
+
+
+class PropertiesPanel:
+    """Properties inspector panel."""
+
+    def __init__(self, scene: "Scene") -> None:
+        self.scene = scene
+        self._window_tag: int | None = None
+        self._content_tag: int | None = None
+
+    def create(self, parent: int | str) -> int:
+        """Create the properties panel.
+
+        Args:
+            parent: Parent container tag
+
+        Returns:
+            The window tag
+        """
+        self._window_tag = parent
+
+        dpg.add_text("Properties", color=(200, 200, 200), parent=parent)
+        dpg.add_separator(parent=parent)
+
+        with dpg.group(tag="properties_content", parent=parent) as self._content_tag:
+            dpg.add_text(
+                "Select an object",
+                color=(128, 128, 128),
+            )
+
+        # Register scene change callback
+        self.scene.on_change(self._update_properties)
+
+        return self._window_tag
+
+    def _update_properties(self) -> None:
+        """Update the properties display for the selected object."""
+        if self._content_tag is None or not dpg.does_item_exist(self._content_tag):
+            return
+
+        # Clear existing content
+        dpg.delete_item(self._content_tag, children_only=True)
+
+        # Get selected object
+        if self.scene.selected_object is None:
+            dpg.add_text(
+                "Select an object",
+                color=(128, 128, 128),
+                parent=self._content_tag,
+            )
+            return
+
+        obj = self.scene.get_object(self.scene.selected_object)
+        if obj is None:
+            dpg.add_text(
+                "Object not found",
+                color=(128, 128, 128),
+                parent=self._content_tag,
+            )
+            return
+
+        # Display object properties
+        self._display_object_properties(obj)
+
+    def _display_object_properties(self, obj: "SceneObject") -> None:
+        """Display properties for a scene object."""
+        from ..core.scene import ObjectType
+
+        parent = self._content_tag
+
+        # Header
+        dpg.add_text(obj.name, color=(255, 255, 100), parent=parent)
+        dpg.add_text(
+            f"Type: {obj.obj_type.name}",
+            color=(150, 150, 150),
+            parent=parent,
+        )
+        dpg.add_separator(parent=parent)
+
+        # Color picker
+        dpg.add_text("Color:", parent=parent)
+        dpg.add_color_edit(
+            default_value=obj.color,
+            callback=lambda s, a, u: self._on_color_change(u, a),
+            user_data=obj.name,
+            no_alpha=False,
+            parent=parent,
+        )
+
+        dpg.add_separator(parent=parent)
+
+        # Type-specific properties
+        if obj.data is not None:
+            if obj.obj_type == ObjectType.SURFACE:
+                self._display_surface_properties(obj.data, parent)
+            elif obj.obj_type == ObjectType.DETECTOR:
+                self._display_surface_properties(obj.data, parent)
+            elif obj.obj_type == ObjectType.SOURCE:
+                self._display_source_properties(obj.data, parent)
+            elif obj.obj_type == ObjectType.DETECTIONS:
+                self._display_detection_properties(obj.data, parent)
+
+    def _display_surface_properties(self, surface: Any, parent: int | str) -> None:
+        """Display properties for a surface object."""
+        dpg.add_text("Surface Properties", color=(180, 180, 180), parent=parent)
+
+        # Common properties
+        self._add_property_row("Name", surface.name, parent)
+        self._add_property_row("Role", str(surface.role.name), parent)
+        self._add_property_row("GPU Capable", str(surface.gpu_capable), parent)
+
+        # Type-specific properties
+        if hasattr(surface, "point"):
+            self._add_property_row("Point", self._format_vector(surface.point), parent)
+        if hasattr(surface, "normal"):
+            self._add_property_row(
+                "Normal", self._format_vector(surface.normal), parent
+            )
+        if hasattr(surface, "center"):
+            self._add_property_row(
+                "Center", self._format_vector(surface.center), parent
+            )
+        if hasattr(surface, "radius"):
+            self._add_property_row("Radius", f"{surface.radius:.4g}", parent)
+        if hasattr(surface, "width"):
+            self._add_property_row("Width", f"{surface.width:.4g}", parent)
+        if hasattr(surface, "height"):
+            self._add_property_row("Height", f"{surface.height:.4g}", parent)
+        if hasattr(surface, "amplitude"):
+            self._add_property_row("Amplitude", f"{surface.amplitude:.4g}", parent)
+        if hasattr(surface, "wavelength"):
+            self._add_property_row("Wavelength", f"{surface.wavelength:.4g}", parent)
+        if hasattr(surface, "direction") and not callable(surface.direction):
+            self._add_property_row(
+                "Direction", self._format_vector(surface.direction), parent
+            )
+
+    def _display_source_properties(self, source: Any, parent: int | str) -> None:
+        """Display properties for a source object."""
+        dpg.add_text("Source Properties", color=(180, 180, 180), parent=parent)
+
+        # Common properties
+        self._add_property_row("Num Rays", str(source.num_rays), parent)
+        self._add_property_row("Power", f"{source.power:.4g} W", parent)
+
+        wavelength = source.wavelength
+        if isinstance(wavelength, tuple):
+            wl_str = f"{wavelength[0]*1e9:.1f}-{wavelength[1]*1e9:.1f} nm"
+        else:
+            wl_str = f"{wavelength*1e9:.1f} nm"
+        self._add_property_row("Wavelength", wl_str, parent)
+
+        # Type-specific
+        if hasattr(source, "position"):
+            self._add_property_row(
+                "Position", self._format_vector(source.position), parent
+            )
+        if hasattr(source, "center"):
+            self._add_property_row("Center", self._format_vector(source.center), parent)
+        if hasattr(source, "origin"):
+            self._add_property_row("Origin", self._format_vector(source.origin), parent)
+        if hasattr(source, "direction"):
+            self._add_property_row(
+                "Direction", self._format_vector(source.direction), parent
+            )
+        if hasattr(source, "mean_direction"):
+            self._add_property_row(
+                "Mean Dir", self._format_vector(source.mean_direction), parent
+            )
+        if hasattr(source, "radius"):
+            self._add_property_row("Radius", f"{source.radius:.4g} m", parent)
+        if hasattr(source, "divergence_angle"):
+            angle_deg = source.divergence_angle * 180 / 3.14159
+            self._add_property_row("Divergence", f"{angle_deg:.2f} deg", parent)
+
+    def _display_detection_properties(self, detected: Any, parent: int | str) -> None:
+        """Display properties for detection results."""
+        dpg.add_text("Detection Results", color=(180, 180, 180), parent=parent)
+
+        if hasattr(detected, "positions") and detected.positions is not None:
+            n_detected = len(detected.positions)
+            self._add_property_row("Count", str(n_detected), parent)
+
+        if hasattr(detected, "intensities") and detected.intensities is not None:
+            total_power = detected.intensities.sum()
+            self._add_property_row("Total Power", f"{total_power:.4g} W", parent)
+
+            if len(detected.intensities) > 0:
+                mean_power = detected.intensities.mean()
+                self._add_property_row("Mean Power", f"{mean_power:.4g} W", parent)
+
+    def _add_property_row(self, label: str, value: str, parent: int | str) -> None:
+        """Add a label-value property row."""
+        with dpg.group(horizontal=True, parent=parent):
+            dpg.add_text(f"{label}:", color=(150, 150, 150))
+            dpg.add_text(value, color=(200, 200, 200))
+
+    def _format_vector(self, vec: Any) -> str:
+        """Format a vector for display."""
+        if hasattr(vec, "__len__"):
+            if len(vec) == 2:
+                return f"({vec[0]:.3g}, {vec[1]:.3g})"
+            elif len(vec) == 3:
+                return f"({vec[0]:.3g}, {vec[1]:.3g}, {vec[2]:.3g})"
+        return str(vec)
+
+    def _on_color_change(self, name: str, color: tuple) -> None:
+        """Handle color change for an object."""
+        obj = self.scene.get_object(name)
+        if obj is not None:
+            obj.color = tuple(color)
+            self.scene._notify_change()

lsurf/gui/views/results.py

@@ -0,0 +1,291 @@
+# 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.
+
+"""Results panel - displays simulation statistics and plots.
+
+Shows simulation results including detection counts, timing statistics,
+and optional matplotlib-based plots.
+"""
+
+from typing import TYPE_CHECKING
+
+import dearpygui.dearpygui as dpg
+
+if TYPE_CHECKING:
+    from lsurf.simulation import SimulationResult
+
+    from ..core.scene import Scene
+    from ..core.simulation import SimulationProgress
+
+
+class ResultsPanel:
+    """Results display panel showing simulation statistics."""
+
+    def __init__(self, scene: "Scene") -> None:
+        self.scene = scene
+        self._window_tag: int | None = None
+        self._stats_tag: int | None = None
+        self._progress_tag: int | None = None
+
+    def create(self, parent: int | str) -> int:
+        """Create the results panel.
+
+        Args:
+            parent: Parent container tag
+
+        Returns:
+            The window tag
+        """
+        # Create a child window for the results section (fills remaining space)
+        with dpg.child_window(
+            parent=parent,
+            tag="results_window",
+            height=-1,  # Fill remaining space after viewport
+            horizontal_scrollbar=True,
+        ) as self._window_tag:
+            dpg.add_text("Results", color=(200, 200, 200))
+            dpg.add_separator()
+
+            # Progress indicator
+            with dpg.group(tag="results_progress") as self._progress_tag:
+                dpg.add_text(
+                    "No simulation running",
+                    color=(128, 128, 128),
+                    tag="progress_text",
+                )
+                dpg.add_progress_bar(
+                    default_value=0,
+                    overlay="",
+                    tag="progress_bar",
+                )
+
+            dpg.add_separator()
+
+            # Statistics table
+            with dpg.group(tag="results_stats", horizontal=True) as self._stats_tag:
+                dpg.add_text("Run a simulation to see results", color=(128, 128, 128))
+
+        return self._window_tag
+
+    def update_progress(self, progress: "SimulationProgress") -> None:
+        """Update the progress display.
+
+        Args:
+            progress: Current simulation progress
+        """
+        from ..core.simulation import SimulationState
+
+        if not dpg.does_item_exist("progress_text"):
+            return
+
+        # Update text
+        dpg.set_value("progress_text", progress.message)
+
+        # Update progress bar
+        if progress.max_bounces > 0:
+            pct = progress.bounce / progress.max_bounces
+        else:
+            pct = 0
+
+        if progress.state == SimulationState.COMPLETED:
+            pct = 1.0
+            dpg.configure_item("progress_text", color=(100, 255, 100))
+        elif progress.state == SimulationState.ERROR:
+            dpg.configure_item("progress_text", color=(255, 100, 100))
+        elif progress.state == SimulationState.RUNNING:
+            dpg.configure_item("progress_text", color=(100, 200, 255))
+        else:
+            dpg.configure_item("progress_text", color=(128, 128, 128))
+
+        dpg.set_value("progress_bar", pct)
+        dpg.configure_item(
+            "progress_bar",
+            overlay=(
+                f"{progress.rays_detected} detected"
+                if progress.rays_detected > 0
+                else ""
+            ),
+        )
+
+    def update_results(self, result: "SimulationResult | None") -> None:
+        """Update the results display.
+
+        Args:
+            result: Simulation result to display
+        """
+        if self._stats_tag is None or not dpg.does_item_exist(self._stats_tag):
+            return
+
+        # Clear existing stats
+        dpg.delete_item(self._stats_tag, children_only=True)
+
+        if result is None:
+            dpg.add_text(
+                "No results available",
+                color=(128, 128, 128),
+                parent=self._stats_tag,
+            )
+            return
+
+        # Create statistics columns
+        self._create_stats_column(result, self._stats_tag)
+
+        # Create per-detector breakdown
+        if result.detections_per_surface:
+            self._create_detector_column(result, self._stats_tag)
+
+    def _create_stats_column(
+        self, result: "SimulationResult", parent: int | str
+    ) -> None:
+        """Create the main statistics column."""
+        with dpg.group(parent=parent):
+            dpg.add_text("Statistics", color=(180, 180, 180))
+
+            stats = result.statistics
+
+            self._add_stat_row("Initial Rays", stats.total_rays_initial, parent=None)
+            self._add_stat_row("Rays Created", stats.total_rays_created, parent=None)
+            self._add_stat_row(
+                "Detected", stats.rays_detected, color=(100, 255, 100), parent=None
+            )
+            self._add_stat_row("Absorbed", stats.rays_absorbed, parent=None)
+            self._add_stat_row(
+                "Low Intensity", stats.rays_terminated_intensity, parent=None
+            )
+            self._add_stat_row(
+                "Out of Bounds", stats.rays_terminated_bounds, parent=None
+            )
+            self._add_stat_row(
+                "Max Bounces", stats.rays_terminated_max_bounces, parent=None
+            )
+            self._add_stat_row("Bounces", stats.bounces_completed, parent=None)
+
+    def _create_detector_column(
+        self, result: "SimulationResult", parent: int | str
+    ) -> None:
+        """Create per-detector breakdown column."""
+        dpg.add_spacer(width=30, parent=parent)
+
+        with dpg.group(parent=parent):
+            dpg.add_text("Per Detector", color=(180, 180, 180))
+
+            for name, count in result.detections_per_surface.items():
+                self._add_stat_row(name, count, parent=None)
+
+    def _add_stat_row(
+        self,
+        label: str,
+        value: int,
+        color: tuple | None = None,
+        parent: int | str | None = None,
+    ) -> None:
+        """Add a statistics row."""
+        if color is None:
+            color = (200, 200, 200)
+
+        with dpg.group(horizontal=True, parent=parent):
+            dpg.add_text(f"{label}:", color=(150, 150, 150))
+            dpg.add_text(f"{value:,}", color=color)
+
+    def clear(self) -> None:
+        """Clear the results display."""
+        if self._stats_tag and dpg.does_item_exist(self._stats_tag):
+            dpg.delete_item(self._stats_tag, children_only=True)
+            dpg.add_text(
+                "Run a simulation to see results",
+                color=(128, 128, 128),
+                parent=self._stats_tag,
+            )
+
+        if dpg.does_item_exist("progress_text"):
+            dpg.set_value("progress_text", "No simulation running")
+            dpg.configure_item("progress_text", color=(128, 128, 128))
+
+        if dpg.does_item_exist("progress_bar"):
+            dpg.set_value("progress_bar", 0)
+            dpg.configure_item("progress_bar", overlay="")
+
+    def display_cli_output(self, stdout: str, stderr: str, return_code: int) -> None:
+        """Display CLI simulation output in the results panel.
+
+        Args:
+            stdout: Standard output from CLI
+            stderr: Standard error from CLI
+            return_code: CLI return code
+        """
+        if self._stats_tag is None or not dpg.does_item_exist(self._stats_tag):
+            return
+
+        # Clear existing content
+        dpg.delete_item(self._stats_tag, children_only=True)
+
+        # Update progress text
+        if dpg.does_item_exist("progress_text"):
+            if return_code == 0:
+                dpg.set_value("progress_text", "Simulation complete")
+                dpg.configure_item("progress_text", color=(100, 255, 100))
+                dpg.set_value("progress_bar", 1.0)
+            else:
+                dpg.set_value(
+                    "progress_text", f"Simulation failed (exit code {return_code})"
+                )
+                dpg.configure_item("progress_text", color=(255, 100, 100))
+
+        # Combine all output for copyable text area
+        full_output = ""
+        if stdout:
+            full_output += stdout
+        if stderr:
+            full_output += "\n\n=== Errors/Warnings ===\n" + stderr
+
+        # Add debug info if available (from print statements)
+        import sys
+
+        if hasattr(sys, "_gui_debug_info"):
+            full_output += "\n\n=== Debug Info ===\n" + sys._gui_debug_info
+
+        with dpg.group(parent=self._stats_tag):
+            dpg.add_text(
+                "CLI Output (select and Ctrl+C to copy):", color=(180, 180, 180)
+            )
+            dpg.add_separator()
+
+            # Use multiline input for copyable text
+            dpg.add_input_text(
+                default_value=full_output.strip(),
+                multiline=True,
+                readonly=True,
+                width=-1,
+                height=200,
+                tab_input=False,
+            )