RCAIDE-GUI 1.0.0__py3-none-any.whl

tabs/visualize_geometry/features/grid.py

@@ -0,0 +1,194 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/grid.py
+
+# RCAIDE-GUI Imports
+from tabs.visualize_geometry.visualize_geometry import VisualizeGeometryWidget
+
+# PyQt imports
+from PyQt6.QtWidgets import QCheckBox
+
+# Python imports
+import vtkmodules.all as vtk
+
+def add_fullscreen_grid(renderer, divisions=12):
+    """Create a layer-1 overlay renderer that draws a 2D grid across the window.
+
+    Returns the overlay renderer or None.
+    """
+    # If renderer or window isn't available, do nothing
+    if renderer is None or not hasattr(renderer, "GetRenderWindow"):
+        return None
+    win = renderer.GetRenderWindow()
+    if win is None:
+        return None
+
+    # Get window size; if zero, don't draw
+    w, h = win.GetActualSize()
+    if not w or not h:
+        return None
+
+    # Simple grid color and opacity
+    color, opacity = (0.6, 0.7, 0.9), 0.25
+
+    # Determine spacing between grid lines
+    step = max(1.0, min(w, h) / float(max(1, divisions)))
+
+    # Build points and line cells for the grid
+    pts = vtk.vtkPoints()
+    lines = vtk.vtkCellArray()
+    pid = 0
+
+    # Add vertical grid lines
+    for i in range(int(w / step) + 1):
+        x = i * step
+        pts.InsertNextPoint(x, 0, 0)
+        pts.InsertNextPoint(x, h, 0)
+        lines.InsertNextCell(2)
+        lines.InsertCellPoint(pid)
+        lines.InsertCellPoint(pid + 1)
+        pid += 2
+
+    # Add horizontal grid lines
+    for j in range(int(h / step) + 1):
+        y = j * step
+        pts.InsertNextPoint(0, y, 0)
+        pts.InsertNextPoint(w, y, 0)
+        lines.InsertNextCell(2)
+        lines.InsertCellPoint(pid)
+        lines.InsertCellPoint(pid + 1)
+        pid += 2
+
+    # Make polydata and a 2D mapper/actor
+    grid = vtk.vtkPolyData()
+    grid.SetPoints(pts)
+    grid.SetLines(lines)
+
+    mapper = vtk.vtkPolyDataMapper2D()
+    mapper.SetInputData(grid)
+
+    actor = vtk.vtkActor2D()
+    actor.SetMapper(mapper)
+    actor.GetProperty().SetColor(color)
+    actor.GetProperty().SetOpacity(opacity)
+
+    # Overlay renderer (non-interactive)
+    overlay = vtk.vtkRenderer()
+    overlay.SetLayer(1)
+    overlay.InteractiveOff()
+    overlay.AddActor(actor)
+    overlay.SetBackgroundAlpha(0.0)
+
+    # Ensure base layer + overlay layer
+    try:
+        win.SetNumberOfLayers(2)
+    except Exception:
+        pass
+
+    win.AddRenderer(overlay)
+    return overlay
+
+def _remove_grid_overlay(self):
+    """Remove overlay renderer if present."""
+    r = getattr(self, "renderer", None)
+    if r is None or not hasattr(r, "GetRenderWindow"):
+        self.overlay_grid = None
+        return
+
+    win = r.GetRenderWindow()
+    overlay = getattr(self, "overlay_grid", None)
+    if overlay is None or win is None:
+        self.overlay_grid = None
+        return
+
+    try:
+        win.RemoveRenderer(overlay)
+    except Exception:
+        pass
+
+    self.overlay_grid = None
+
+def _rebuild_grid_overlay_if_enabled(self):
+    """Toggle/rebuild grid overlay based on checkbox state."""
+    r = getattr(self, "renderer", None)
+    if r is None:
+        return
+
+    cb = getattr(self, "grid_checkbox", None)
+    if cb is None:
+        return
+
+    # Remove if disabled
+    if not cb.isChecked():
+        _remove_grid_overlay(self)
+        try:
+            r.GetRenderWindow().Render()
+        except Exception:
+            pass
+        return
+
+    # Rebuild (remake to match current window size)
+    _remove_grid_overlay(self)
+    self.overlay_grid = add_fullscreen_grid(r, divisions=12)
+
+    try:
+        r.GetRenderWindow().Render()
+    except Exception:
+        pass
+
+def _add_gridline_toggle(self):
+    """Add the gridlines checkbox once; safe to call repeatedly."""
+    if not hasattr(self, "toolbar") or self.toolbar is None:
+        return
+    if getattr(self, "_gridline_toggle_added", False):
+        return
+    if getattr(self, "renderer", None) is None:
+        return
+
+    self._gridline_toggle_added = True
+
+    # Checkbox UI
+    self.grid_checkbox = QCheckBox("Show Gridlines")
+    self.grid_checkbox.setChecked(False)
+    self.grid_checkbox.setStyleSheet("""
+    QCheckBox {
+        color: white;
+        font-size: 10pt;
+        border: 1px solid white;
+        padding: 2px;
+    }
+    """)
+
+    self.toolbar.addSeparator()
+    self.toolbar.addWidget(self.grid_checkbox)
+
+    # Toggle behavior
+    self.grid_checkbox.stateChanged.connect(lambda _s: _rebuild_grid_overlay_if_enabled(self))
+
+    # Resize observer (install once)
+    if not getattr(self, "_grid_resize_observer_added", False):
+        self._grid_resize_observer_added = True
+        try:
+            win = self.renderer.GetRenderWindow()
+
+            def on_resize(_o, _e):
+                _rebuild_grid_overlay_if_enabled(self)
+
+            win.AddObserver("WindowResizeEvent", on_resize)
+        except Exception:
+            pass
+
+# Activate Patch
+def _patch_update_toolbar_for_gridlines():
+    """Patch update_toolbar once (no run_solve wrapper stacking)."""
+    if getattr(VisualizeGeometryWidget, "_grid_update_toolbar_patched", False):
+        return
+
+    old_update_toolbar = VisualizeGeometryWidget.update_toolbar
+
+    def wrapped_update_toolbar(self, *args, **kwargs):
+        old_update_toolbar(self, *args, **kwargs)
+        _add_gridline_toggle(self)
+
+    VisualizeGeometryWidget.update_toolbar = wrapped_update_toolbar
+    VisualizeGeometryWidget._grid_update_toolbar_patched = True
+
+_patch_update_toolbar_for_gridlines()

tabs/visualize_geometry/features/measurement.py

@@ -0,0 +1,367 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/measurement.py
+
+# RCAIDE-GUI Imports
+from tabs.visualize_geometry.visualize_geometry import VisualizeGeometryWidget
+
+# PyQt imports
+from PyQt6.QtWidgets import QPushButton
+
+# Python imports
+import math
+import vtkmodules.all as vtk
+
+def add_measure_tool(self):
+    """
+    Injects Measure / Undo / Clear controls into the existing toolbar and wires
+    VTK click-picking to create measurement annotations.
+
+    Safe to call repeatedly; will not duplicate buttons for a live widget instance.
+    """
+    # --- Preconditions ---
+    # Need a toolbar (to add buttons), a renderer (to place VTK actors), and a VTK widget (render window/interactor).
+    if not getattr(self, "toolbar", None) or getattr(self, "renderer", None) is None:
+        return
+    if not getattr(self, "vtkWidget", None):
+        return
+
+    # --- Idempotency guard ---
+    # update_toolbar can be called multiple times; if buttons already exist and are valid, do nothing.
+    btn_existing = getattr(self, "measure_button", None)
+    if btn_existing is not None:
+        try:
+            _ = btn_existing.isChecked()  # if this works, button is still alive
+            return
+        except Exception:
+            # Button object was destroyed (e.g., UI rebuild); drop refs so we recreate below.
+            self.measure_button = None
+
+    # --- UI controls ---
+    btn = QPushButton("📏 Measure")
+    btn.setCheckable(True)  # toggle on/off click observer
+
+    undo = QPushButton("↩ Undo")   # remove last completed measurement
+    clr = QPushButton("🧹 Clear")  # remove all measurements
+
+    # Add them to the existing toolbar
+    self.toolbar.addSeparator()
+    self.toolbar.addWidget(btn)
+    self.toolbar.addWidget(undo)
+    self.toolbar.addWidget(clr)
+
+    # Keep references on the widget so we can detect duplicates and wire events once.
+    self.measure_button = btn
+    self.measure_undo_button = undo
+    self.measure_clear_button = clr
+
+    # --- Persistent tool state ---
+    # State is stored on the widget instance, not in globals, so multiple VG widgets won't conflict.
+    if not hasattr(self, "_measure_state") or self._measure_state is None:
+        self._measure_state = {
+            "picker": vtk.vtkCellPicker(),  # screen -> world pick
+            "pts": [],                      # in-progress points: [(p, dot_actor), ...]
+            "temp_dots": [],                # actors created before a measurement is finalized
+            "measures": [],                 # completed measurements: [{"line":..., "txt":..., "d1":..., "d2":...}, ...]
+            "obs": None,                    # VTK observer id for LeftButtonPressEvent
+        }
+        self._measure_state["picker"].SetTolerance(0.0005)
+
+    st = self._measure_state
+
+    # --- Small helpers (render window / interactor) ---
+    def _rw():
+        """Safely get the RenderWindow."""
+        try:
+            return self.vtkWidget.GetRenderWindow()
+        except Exception:
+            return None
+
+    def _iren():
+        """
+        Safely get the interactor.
+        Prefer an existing attribute if your widget sets it; otherwise pull from RenderWindow.
+        """
+        iren = getattr(self, "render_window_interactor", None)
+        if iren is not None:
+            return iren
+        rw = _rw()
+        return rw.GetInteractor() if rw is not None else None
+
+    # --- Scale helpers (dot radius relative to scene size) ---
+    def _scene_diag():
+        """
+        Estimate a characteristic scene size so dot radius scales with the model.
+        Falls back to 1.0 if bounds are missing/invalid.
+        """
+        try:
+            b = self.renderer.ComputeVisiblePropBounds()
+        except Exception:
+            b = None
+
+        if not b or len(b) != 6:
+            return 1.0
+
+        dx = (b[1] - b[0])
+        dy = (b[3] - b[2])
+        dz = (b[5] - b[4])
+        s = max(dx, dy, dz)
+        return s if s > 0 else 1.0
+
+    # --- VTK actor constructors ---
+    def _make_dot(p, color):
+        """Create a small sphere marker at world point p."""
+        r = 0.0075 * _scene_diag()
+
+        s = vtk.vtkSphereSource()
+        s.SetRadius(r)
+
+        m = vtk.vtkPolyDataMapper()
+        m.SetInputConnection(s.GetOutputPort())
+
+        a = vtk.vtkActor()
+        a.SetMapper(m)
+        a.SetPosition(p[0], p[1], p[2])
+        a.GetProperty().SetColor(color[0], color[1], color[2])
+        a.GetProperty().LightingOff()
+
+        self.renderer.AddActor(a)
+        return a
+
+    def _make_line(p1, p2):
+        """Create a line actor between p1 and p2."""
+        l = vtk.vtkLineSource()
+        l.SetPoint1(p1)
+        l.SetPoint2(p2)
+
+        m = vtk.vtkPolyDataMapper()
+        m.SetInputConnection(l.GetOutputPort())
+
+        a = vtk.vtkActor()
+        a.SetMapper(m)
+
+        prop = a.GetProperty()
+        prop.SetColor(1.0, 1.0, 0.0)
+        prop.SetLineWidth(3.5)
+        prop.LightingOff()
+
+        self.renderer.AddActor(a)
+        return a
+
+    def _make_label(p1, p2, L):
+        """Create a 2D text label anchored in world-space at the midpoint."""
+        mid = (
+            (p1[0] + p2[0]) * 0.5,
+            (p1[1] + p2[1]) * 0.5,
+            (p1[2] + p2[2]) * 0.5,
+        )
+        txt = f"{L:.3f} m"
+
+        coord = vtk.vtkCoordinate()
+        coord.SetCoordinateSystemToWorld()
+        coord.SetValue(mid[0], mid[1], mid[2])
+
+        t = vtk.vtkTextActor()
+        t.SetInput(txt)
+
+        tp = t.GetTextProperty()
+        tp.SetFontSize(26)
+        tp.SetBold(True)
+        tp.SetColor(0.4, 1.0, 1.0)
+        tp.SetShadow(True)
+        tp.SetShadowOffset(2, -2)
+        tp.SetJustificationToCentered()
+        tp.SetVerticalJustificationToCentered()
+
+        # Anchor the 2D text actor to a world coordinate
+        t.GetPositionCoordinate().SetReferenceCoordinate(coord)
+        t.GetPositionCoordinate().SetCoordinateSystemToWorld()
+
+        self.renderer.AddActor2D(t)
+        return t
+
+    # --- Render + cleanup helpers ---
+    def _render():
+        """Request a render, safely."""
+        rw = _rw()
+        if rw is None:
+            return
+        try:
+            rw.Render()
+        except Exception:
+            pass
+
+    def _remove_temp():
+        """
+        Remove any in-progress markers (first click / partial measurement)
+        and reset the in-progress points list.
+        """
+        for d in st["temp_dots"]:
+            try:
+                self.renderer.RemoveActor(d)
+            except Exception:
+                pass
+        st["temp_dots"].clear()
+        st["pts"].clear()
+
+    # --- Main click handler ---
+    def _on_click(_obj, _evt):
+        """
+        If Measure is enabled:
+        - pick a world point
+        - drop a dot
+        - after 2 points: create line + label and commit as a measurement
+        """
+        if not btn.isChecked():
+            return
+
+        iren = _iren()
+        if iren is None:
+            return
+
+        x, y = iren.GetEventPosition()
+
+        # vtkCellPicker.Pick returns truthy when it hits something in the renderer
+        if not st["picker"].Pick(x, y, 0, self.renderer):
+            return
+
+        p = st["picker"].GetPickPosition()
+
+        # Color convention: first point cyan-ish, second point red-ish
+        color = (0.0, 0.7, 1.0) if len(st["pts"]) == 0 else (1.0, 0.2, 0.2)
+        dot = _make_dot(p, color)
+
+        st["pts"].append(((p[0], p[1], p[2]), dot))
+        st["temp_dots"].append(dot)
+
+        # If we have two points, finalize measurement
+        if len(st["pts"]) == 2:
+            (p1, d1), (p2, d2) = st["pts"]
+
+            L = math.dist(p1, p2)
+            line = _make_line(p1, p2)
+            label = _make_label(p1, p2, L)
+
+            st["measures"].append({"line": line, "txt": label, "d1": d1, "d2": d2})
+
+            # Reset in-progress state so next pair starts fresh
+            st["pts"].clear()
+            st["temp_dots"].clear()
+            _render()
+
+    # --- Toggle wiring (observer attach/detach) ---
+    def _toggle(on: bool):
+        """
+        Turn measurement mode on/off by adding/removing a VTK observer.
+        Also cleans up partial state when turning off.
+        """
+        iren = _iren()
+        if iren is None:
+            btn.setChecked(False)
+            return
+
+        if on:
+            # Add observer once; keep id so we can remove it later
+            if st["obs"] is None:
+                st["obs"] = iren.AddObserver("LeftButtonPressEvent", _on_click, 1.0)
+        else:
+            # Remove observer and clear any partial click state
+            if st["obs"] is not None:
+                try:
+                    iren.RemoveObserver(st["obs"])
+                except Exception:
+                    pass
+                st["obs"] = None
+            _remove_temp()
+
+        _render()
+
+    # --- Clear/Undo actions ---
+    def _do_clear():
+        """Remove all measurements + any in-progress markers."""
+        _remove_temp()
+
+        for m in st["measures"]:
+            # Line
+            try:
+                self.renderer.RemoveActor(m["line"])
+            except Exception:
+                pass
+
+            # Endpoints
+            try:
+                self.renderer.RemoveActor(m["d1"])
+                self.renderer.RemoveActor(m["d2"])
+            except Exception:
+                pass
+
+            # Label (Actor2D)
+            try:
+                self.renderer.RemoveActor2D(m["txt"])
+            except Exception:
+                # Fallback if someone added it as a 3D actor in other variants
+                try:
+                    self.renderer.RemoveActor(m["txt"])
+                except Exception:
+                    pass
+
+        st["measures"].clear()
+        _render()
+
+    def _do_undo():
+        """Remove the most recent completed measurement."""
+        _remove_temp()
+
+        if not st["measures"]:
+            return
+
+        m = st["measures"].pop()
+
+        try:
+            self.renderer.RemoveActor(m["line"])
+        except Exception:
+            pass
+
+        try:
+            self.renderer.RemoveActor(m["d1"])
+            self.renderer.RemoveActor(m["d2"])
+        except Exception:
+            pass
+
+        try:
+            self.renderer.RemoveActor2D(m["txt"])
+        except Exception:
+            try:
+                self.renderer.RemoveActor(m["txt"])
+            except Exception:
+                pass
+
+        _render()
+
+    # --- Qt signal hookups ---
+    btn.toggled.connect(_toggle)
+    clr.clicked.connect(_do_clear)
+    undo.clicked.connect(_do_undo)
+
+# Activate Patch
+def _patch_update_toolbar_for_measure_tool():
+    """
+    - Wrap VisualizeGeometryWidget.update_toolbar so the measure tool is injected
+      after the toolbar is created/refreshed.
+    - Does not touch run_solve or any other global patches.
+    """
+    # Guard so we only patch the class once per process
+    if getattr(VisualizeGeometryWidget, "_measure_update_toolbar_patched", False):
+        return
+
+    old_update_toolbar = VisualizeGeometryWidget.update_toolbar
+
+    def wrapped_update_toolbar(self, *args, **kwargs):
+        # 1) Build the toolbar using the original implementation
+        old_update_toolbar(self, *args, **kwargs)
+        # 2) Add measurement controls (idempotent per widget instance)
+        add_measure_tool(self)
+
+    VisualizeGeometryWidget.update_toolbar = wrapped_update_toolbar
+    VisualizeGeometryWidget._measure_update_toolbar_patched = True
+
+# Activate patch at import time so any subsequently created VG widget gets the tool.
+_patch_update_toolbar_for_measure_tool()

tabs/visualize_geometry/features/screenshot.py

@@ -0,0 +1,91 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/screenshot.py
+
+# RCAIDE-GUI Imports
+from tabs.visualize_geometry.visualize_geometry import VisualizeGeometryWidget
+
+# PyQt imports
+from PyQt6.QtWidgets import QPushButton, QFileDialog, QMessageBox
+
+# Python imports
+import datetime
+import vtkmodules.all as vtk
+
+def add_screenshot_button(self):
+    # --- need toolbar + vtkWidget ---
+    if not getattr(self, "toolbar", None) or not getattr(self, "vtkWidget", None):
+        return
+
+    # --- prevents adding the button twice ---
+    if getattr(self, "screenshot_button", None) is not None:
+        return
+
+    # --- add button to toolbar ---
+    btn = QPushButton("📷 Export View")
+    self.toolbar.addSeparator()
+    self.toolbar.addWidget(btn)
+    self.screenshot_button = btn
+
+    def save_screenshot():
+        # --- choose filename (default timestamp) ---
+        ts = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        default_name = f"screenshot_{ts}.png"
+
+        path, selected_filter = QFileDialog.getSaveFileName(
+            self,
+            "Save Screenshot As",
+            default_name,
+            "PNG Files (*.png);;JPEG Files (*.jpg *.jpeg);;All Files (*)",
+        )
+        if not path:
+            return
+
+        # --- add extension if missing ---
+        lower = path.lower()
+        if not (lower.endswith(".png") or lower.endswith(".jpg") or lower.endswith(".jpeg")):
+            path += ".jpg" if "JPEG" in selected_filter else ".png"
+
+        # --- grab current render window image ---
+        rw = self.vtkWidget.GetRenderWindow()
+        w2i = vtk.vtkWindowToImageFilter()
+        w2i.SetInput(rw)
+        w2i.ReadFrontBufferOff()
+        w2i.SetInputBufferTypeToRGBA()
+        w2i.Update()
+
+        # --- pick writer based on extension ---
+        if path.lower().endswith((".jpg", ".jpeg")):
+            writer = vtk.vtkJPEGWriter()
+        else:
+            writer = vtk.vtkPNGWriter()
+
+        # --- write file ---
+        writer.SetFileName(path)
+        writer.SetInputConnection(w2i.GetOutputPort())
+
+        try:
+            writer.Write()
+        except Exception as e:
+            QMessageBox.critical(self, "Export Failed", f"Could not save screenshot:\n{e}")
+            return
+
+        QMessageBox.information(self, "Export Successful", f"Saved:\n{path}")
+
+    # --- connect click ---
+    btn.clicked.connect(save_screenshot)
+
+# Activate Patch
+def _patch_update_toolbar_for_screenshot():
+    # --- patch update_toolbar to add screenshot button ---
+    if getattr(VisualizeGeometryWidget, "_screenshot_update_toolbar_patched", False):
+        return
+
+    old_update_toolbar = VisualizeGeometryWidget.update_toolbar
+
+    def wrapped_update_toolbar(self, *args, **kwargs):
+        old_update_toolbar(self, *args, **kwargs)
+        add_screenshot_button(self)
+
+    VisualizeGeometryWidget.update_toolbar = wrapped_update_toolbar
+    VisualizeGeometryWidget._screenshot_update_toolbar_patched = True
+
+_patch_update_toolbar_for_screenshot()

tabs/visualize_geometry/geometry_helper_functions.py

@@ -0,0 +1,3 @@
+# RCAIDE_GUI/tabs/visualize_geometry/geometry_helper_functions.py
+# Thin shim — re-exports from RCAIDE so that legacy callers keep working.
+from RCAIDE.Library.Plots.Geometry.plot_3d_rotor import generate_vtk_object, write_azimuthal_cell_values