RCAIDE-GUI 1.0.0__py3-none-any.whl

tabs/style_sheet.py

@@ -0,0 +1,114 @@
+# RCAIDE_GUI/tabs/style_sheet.py
+
+# PyQt imports
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit, QPushButton, QTreeWidget, QTreeWidgetItem, QFrame, QMainWindow, QApplication, QMainWindow, QTabWidget, QFileDialog, QMenu
+
+# ------------------------------------------------------------------------------
+# Style Sheet Utilities
+# ------------------------------------------------------------------------------
+def add_line(shape = "HLine", shadow = "Sunken", color = "gray", height = "20"):
+    line = QFrame()
+    shape_dict = {
+        'NoFrame': QFrame.Shape.NoFrame,
+        'Box': QFrame.Shape.Box,
+        'Panel': QFrame.Shape.Panel,
+        'StyledPanel': QFrame.Shape.StyledPanel,
+        'HLine': QFrame.Shape.HLine,
+        'VLine': QFrame.Shape.VLine
+    }
+    shadow_dict = {
+        'Plain': QFrame.Shadow.Plain,
+        'Raised': QFrame.Shadow.Raised,
+        'Sunken': QFrame.Shadow.Sunken
+    }
+    if shape not in shape_dict:
+        raise TypeError("Have problem in shape format, shape should be 'NoFrame , Box , Panel , StyledPanel , HLine, VLine'" )
+    #shape:NoFrame , Box , Panel , StyledPanel , HLine, VLine
+    line.setFrameShape(shape_dict[shape])
+    if shadow not in shadow_dict:
+        raise TypeError("Have problem in shadow format, shadow should be 'Plain , Raised and Sunken'" )
+    #shadow:Plain , Raised and Sunken
+    line.setFrameShadow(shadow_dict[shadow])
+    try:
+        line.setStyleSheet(f"background-color: {color}; height: {height}px;")
+    except:
+        raise TypeError("Color format:1.Specific color like:red, blue, lightblue. 2.Hex Code like: #FF5733. 3. RGB like: rgb(255, 87, 51)." )
+    return line
+
+def add_title(text, font_weight="bold", color = "black", font_size="20", Alignment="AlignLeft"):
+    title = QLabel(text)
+    Alignment_dict={
+        "AlignLeft":Qt.AlignmentFlag.AlignLeft,
+        "AlignRight": Qt.AlignmentFlag.AlignRight,
+        "AlignHCenter":Qt.AlignmentFlag.AlignHCenter,
+        "AlignJustify":Qt.AlignmentFlag.AlignJustify,
+        "AlignTop":Qt.AlignmentFlag.AlignTop,
+        "AlignBottom":Qt.AlignmentFlag.AlignBottom,
+        "AlignVCenter":Qt.AlignmentFlag.AlignCenter,
+        "AlignBaseline":Qt.AlignmentFlag.AlignVCenter
+    }
+    if Alignment not in Alignment_dict:
+        raise TypeError("Have problem in Alignment format, Alignment should be 'AlignLeft, AlignRight, AlignHCenter, AlignJustify, AlignTop, AlignBottom, AlignVCenter, AlignBaseline'" )
+    else:
+        title.setAlignment(Alignment_dict[Alignment])
+    try:
+        title.setStyleSheet(f"font-size: {font_size}px; font-weight: {font_weight}; color: {color};")
+    except:
+        raise TypeError("font-size format:integer, font-weight format:'bold',Makes the text bold, Color format:1.Specific color like:red, blue, lightblue. 2.Hex Code like: #FF5733. 3. RGB like: rgb(255, 87, 51)." )
+    return title
+
+def add_subtitle(text, font_weight="bold", color = "black", font_size="15", Alignment="AlignLeft"):
+    subtitle = QLabel(text)
+    Alignment_dict={
+        "AlignLeft":Qt.AlignmentFlag.AlignLeft,
+        "AlignRight": Qt.AlignmentFlag.AlignRight,
+        "AlignHCenter":Qt.AlignmentFlag.AlignHCenter,
+        "AlignJustify":Qt.AlignmentFlag.AlignJustify,
+        "AlignTop":Qt.AlignmentFlag.AlignTop,
+        "AlignBottom":Qt.AlignmentFlag.AlignBottom,
+        "AlignVCenter":Qt.AlignmentFlag.AlignCenter,
+        "AlignBaseline":Qt.AlignmentFlag.AlignVCenter
+    }
+    if Alignment not in Alignment_dict:
+        raise TypeError("Have problem in Alignment format, Alignment should be 'AlignLeft, AlignRight, AlignHCenter, AlignJustify, AlignTop, AlignBottom, AlignVCenter, AlignBaseline'" )
+    else:
+        subtitle.setAlignment(Alignment_dict[Alignment])
+    try:
+        subtitle.setStyleSheet(f"font-size: {font_size}px; font-weight: {font_weight}; color: {color};")
+    except:
+        raise TypeError("font-size format:integer, font-weight format:'bold',Makes the text bold, Color format:1.Specific color like:red, blue, lightblue. 2.Hex Code like: #FF5733. 3. RGB like: rgb(255, 87, 51)." )
+    return subtitle
+
+
+#This is a function help build header.It has three inputs. The first input is from QMainWindow(), usually it is "self".
+#The second input is the name for this window. The third input is menu_list. like["File","Documentation"].
+def add_header(window, window_name, menu_list = None):
+    window.setWindowTitle(window_name)
+    menubar = window.menuBar()
+    if menubar is None:
+        return
+    if menu_list:
+        for i in menu_list:
+            menubar.addMenu(i)
+    return
+
+#After use this function,programmer can find exact menu.
+def find_menu_variable(window, target_menu):
+    menubar = window.menuBar()
+    if menubar is None:
+        print("No menu bar found.")
+        return
+    menus = [child for child in menubar.children() if isinstance(child, QMenu)]
+    for menu in menus:
+        if menu.title() == target_menu:
+            return menu
+
+if __name__ == '__main__':
+    app = QApplication([])
+    window = QMainWindow()
+    add_header(window, "My Application", menu_list=["File", "Edit", "View"])
+    file_mune = find_menu_variable(window,"File")
+    file_mune.addAction("Quit")
+    window.show()
+    app.exec()

tabs/tab_widget.py

@@ -0,0 +1,14 @@
+# RCAIDE_GUI/tabs/tab_widget.py
+
+# PyQt imports
+from PyQt6.QtWidgets import QWidget
+
+# ------------------------------------------------------------------------------
+# Tab Widget
+# ------------------------------------------------------------------------------
+class TabWidget(QWidget):
+    def update_layout(self):
+        pass
+
+    def load_from_values(self):
+        pass

tabs/visualize_geometry/__init__.py

@@ -0,0 +1,4 @@
+# RCAIDE_GUI/tabs/visualize_geometry/__init__.py
+from .core_3d_viewer import *
+from .visualize_geometry import *
+from . import features

tabs/visualize_geometry/core_3d_viewer.py

@@ -0,0 +1,253 @@
+# RCAIDE_GUI/tabs/visualize_geometry/core_3d_viewer.py
+
+# RCAIDE imports
+import RCAIDE
+from RCAIDE.Framework.Core import Units
+from RCAIDE.Library.Components.Airfoils import Airfoil
+from RCAIDE.Library.Plots.Geometry.generate_3d_wing_points      import *
+from RCAIDE.Library.Plots.Geometry.generate_3d_fuselage_points  import *
+from RCAIDE.Library.Plots.Geometry.plot_3d_rotor                import generate_3d_blade_points
+from RCAIDE.Library.Plots.Geometry.generate_3d_nacelle_points   import *
+from RCAIDE.Library.Methods.Geometry.Planform                   import fuselage_planform, wing_planform
+ 
+ # RCAIDE-GUI imports
+from tabs import TabWidget
+from vtkmodules.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
+from tabs.visualize_geometry import geometry_helper_functions
+
+# PyQt imports
+from PyQt6.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QTreeWidget, QPushButton, QTreeWidgetItem, QHeaderView, QLabel, QToolBar, QColorDialog, QSpacerItem, QSizePolicy, QFrame, QLineEdit
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QIcon
+
+# python imports
+import matplotlib.colors as mcolors 
+import vtk
+import rcaide_io
+import os
+from copy import deepcopy 
+
+# ------------------------------------------------------------------------------
+# make_object
+# ------------------------------------------------------------------------------
+def make_object(renderer, actor_group,  GEOM,  rgb_color, opacity): 
+
+    actor = geometry_helper_functions.generate_vtk_object(GEOM.PTS)
+
+    # Set color of fuselage
+    mapper = actor.GetMapper()
+    mapper.ScalarVisibilityOff()
+    prop = actor.GetProperty()
+    prop.SetColor(rgb_color[0] * 1.2, rgb_color[1] * 1.2, rgb_color[2] * 1.2)  # slightly brighter
+    prop.SetDiffuse(0.8)
+    prop.SetAmbient(0.4)      # adds base light even in dark areas
+    prop.SetSpecular(0.3)     # gives a soft highlight
+    prop.SetSpecularPower(20)
+    prop.SetOpacity(opacity)
+    renderer.AddActor(actor)
+    actor_group.append(actor) 
+    return
+
+def make_actuator_disc(renderer, inner_radius, outer_radius, origin, rot_x,rot_y,rot_z, rgb_color, opacity): 
+    
+    disk_source = vtk.vtkDiskSource()
+    disk_source.SetInnerRadius(inner_radius)
+    disk_source.SetOuterRadius(outer_radius)
+    disk_source.SetRadialResolution(50)
+    disk_source.SetCircumferentialResolution(50) 
+    
+    transform = vtk.vtkTransform()
+    transform.RotateX(rot_x/Units.degrees)  
+    transform.RotateY(rot_y/Units.degrees)  
+    transform.RotateZ(rot_z/Units.degrees)  
+    transformFilter = vtk.vtkTransformPolyDataFilter()
+    transformFilter.SetTransform(transform)
+    transformFilter.SetInputConnection(disk_source.GetOutputPort()) 
+  
+    mapper = vtk.vtkPolyDataMapper()
+    mapper.SetInputConnection(transformFilter.GetOutputPort())
+    
+    actor = vtk.vtkActor()
+    actor.SetMapper(mapper) 
+    actor.GetProperty().SetColor(rgb_color[0], rgb_color[1], rgb_color[2])  
+    actor.GetProperty().SetDiffuse(1.0)  
+    actor.GetProperty().SetSpecular(0.0) 
+    actor.GetProperty().SetOpacity(opacity)
+    actor.SetPosition( origin[0][0],  origin[0][1],  origin[0][2]) 
+    renderer.AddActor(actor)
+    return
+
+class Core3DViewer(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        
+        # Setup Layout
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        
+        # Setup VTK Window
+        self.vtkWidget = QVTKRenderWindowInteractor(self)
+        layout.addWidget(self.vtkWidget)
+        
+        self.renderer = vtk.vtkRenderer()
+        self.vtkWidget.GetRenderWindow().AddRenderer(self.renderer)
+        self.render_window_interactor = self.vtkWidget.GetRenderWindow().GetInteractor()
+        style = vtk.vtkInteractorStyleTrackballCamera()
+        self.render_window_interactor.SetInteractorStyle(style)
+        self.wing_actors = []
+        self.fuselage_actors = []
+        self.boom_actors = []
+        self.nacelle_actors = []
+        self.rotor_actors = []
+        self.fuel_tank_actors = []
+        self.part_actors = [] # General list if needed
+
+        self.render_window_interactor.Initialize()
+
+    def clear_scene(self):
+        """Wipes the 3D canvas clean before drawing a new airplane."""
+        self.renderer.RemoveAllViewProps()
+        self.wing_actors.clear()
+        self.fuselage_actors.clear()
+        self.boom_actors.clear()
+        self.nacelle_actors.clear()
+        self.rotor_actors.clear()
+        self.fuel_tank_actors.clear()
+        self.part_actors.clear()
+
+    def run_solve(self):
+        """Calculates and draws the geometry based on rcaide_io.vehicle"""
+        
+        self.clear_scene()
+
+        wing_color          = 'grey'  
+        fuselage_color      = 'grey'  
+        nacelle_color       = 'grey' 
+        boom_color          = 'grey' 
+        rotor_color         = 'black'
+        wing_opacity        = 0.5
+        fuselage_opacity    = 0.5
+        nacelle_opacity     = 1.0
+        rotor_opacity       = 0.6
+        number_of_airfoil_points    = 101 
+        tessellation        = 96 
+        boom_opacity        = 1.0
+        camera_eye_x  = -1 
+        camera_eye_y  = -1 
+        camera_eye_z  = 0.35  
+        
+        wing_rgb_color      = mcolors.to_rgb(wing_color)
+        fuselage_rgb_color  = mcolors.to_rgb(fuselage_color) 
+        nacelle_rgb_color   = mcolors.to_rgb(nacelle_color) 
+        rotor_rgb_color     = mcolors.to_rgb(rotor_color)
+        boom_rgb_color      = mcolors.to_rgb(boom_color)
+
+        if not rcaide_io.vehicle:
+            return # Don't try to draw if there's no vehicle
+            
+        geometry = deepcopy(rcaide_io.vehicle)
+
+    
+        for wing in geometry.wings:   
+            try: wing_planform(wing)
+            except: pass # Bypass if not fully defined yet in GUI
+                             
+        for fuselage in geometry.fuselages:
+            try:
+                fuselage_planform(fuselage)
+            except: pass
+
+        for wing in geometry.wings:
+            n_segments = len(wing.segments)
+            dim        = n_segments if n_segments > 0 else 2
+            try:
+                GEOM       = generate_3d_wing_points(wing, number_of_airfoil_points, dim)
+                make_object(self.renderer, self.wing_actors, GEOM, wing_rgb_color, wing_opacity)
+                if wing.yz_plane_symmetric: 
+                    GEOM.PTS[:, :, 0] = -GEOM.PTS[:, :, 0]
+                    make_object(self.renderer, self.wing_actors,GEOM,wing_rgb_color,wing_opacity)
+                if wing.xz_plane_symmetric: 
+                    GEOM.PTS[:, :, 1] = -GEOM.PTS[:, :, 1]
+                    make_object(self.renderer,self.wing_actors, GEOM,wing_rgb_color,wing_opacity)
+                if wing.xy_plane_symmetric: 
+                    GEOM.PTS[:, :, 2] = -GEOM.PTS[:, :, 2]
+                    make_object(self.renderer,self.wing_actors, GEOM,wing_rgb_color,wing_opacity)
+            except Exception as e:
+                print(f"Skipping a wing due to incomplete data: {e}")
+    
+
+        for fuselage in geometry.fuselages:
+            try:
+                GEOM = generate_3d_fuselage_points(fuselage, tessellation)
+                make_object(self.renderer, self.fuselage_actors,GEOM, fuselage_rgb_color,fuselage_opacity)
+            except: pass
+
+        for boom in geometry.booms:
+            try:
+                GEOM = generate_3d_fuselage_points(boom, tessellation)
+                make_object(self.renderer, self.boom_actors, GEOM, boom_rgb_color,boom_opacity)
+            except: pass
+
+        for nacelle in geometry.nacelles:
+            try:
+                GEOM = generate_3d_BOR_nacelle_points(nacelle, tessellation=tessellation, number_of_airfoil_points=number_of_airfoil_points)
+                make_object(self.renderer, self.nacelle_actors, GEOM, nacelle_rgb_color, nacelle_opacity)
+            except: pass
+        
+        for network in geometry.networks: 
+            for propulsor in network.propulsors:  
+                if 'nacelle' in propulsor and propulsor.nacelle != None: 
+                    try:
+                        if type(propulsor.nacelle) == RCAIDE.Library.Components.Nacelles.Stack_Nacelle: 
+                            GEOM = generate_3d_stack_nacelle_points(propulsor.nacelle,tessellation = tessellation,number_of_airfoil_points = number_of_airfoil_points)
+                        elif type(propulsor.nacelle) == RCAIDE.Library.Components.Nacelles.Body_of_Revolution_Nacelle: 
+                            GEOM = generate_3d_BOR_nacelle_points(propulsor.nacelle,tessellation = tessellation,number_of_airfoil_points = number_of_airfoil_points)
+                        else:
+                            GEOM= generate_3d_basic_nacelle_points(propulsor.nacelle,tessellation = tessellation,number_of_airfoil_points = number_of_airfoil_points)
+                        make_object(self.renderer,self.nacelle_actors,  GEOM, nacelle_rgb_color,nacelle_opacity)
+                    except: pass
+                        
+                if 'rotor' in propulsor:  
+                    try:
+                        rot       = propulsor.rotor
+                        rot_x     = rot.orientation_euler_angles[0]
+                        rot_y     = rot.orientation_euler_angles[1]
+                        rot_z     = rot.orientation_euler_angles[2]
+                        num_B     = int(rot.number_of_blades) 
+                        if rot.radius_distribution is None:
+                            make_actuator_disc(self.renderer, rot.hub_radius, rot.tip_radius, rot.origin, rot_x,rot_y,rot_z, rotor_rgb_color,rotor_opacity) 
+                        else:
+                            dim       = len(rot.radius_distribution) 
+                            for i in range(num_B):
+                                GEOM = generate_3d_blade_points(rot,number_of_airfoil_points,dim,i)
+                                make_object(self.renderer,self.rotor_actors,  GEOM, rotor_rgb_color,rotor_opacity) 
+                    except: pass
+    
+                if 'propeller' in propulsor:
+                    try:
+                        prop      = propulsor.propeller
+                        rot_x     = prop.orientation_euler_angles[0]
+                        rot_y     = np.pi / 2 +  prop.orientation_euler_angles[1]
+                        rot_z     = prop.orientation_euler_angles[2]
+                        num_B     = int(prop.number_of_blades) 
+                        if prop.radius_distribution is None:
+                            make_actuator_disc(self.renderer, prop.hub_radius, prop.tip_radius, prop.origin, rot_x,rot_y,rot_z,rotor_rgb_color,rotor_opacity) 
+                        else:
+                            dim       = len(prop.radius_distribution)
+                            for i in range(num_B):
+                                GEOM = generate_3d_blade_points(prop,number_of_airfoil_points,dim,i) 
+                                make_object(self.renderer,self.rotor_actors, GEOM, rotor_rgb_color,rotor_opacity) 
+                    except: pass
+    
+
+        # Set camera and background
+        camera = vtk.vtkCamera()
+        camera.SetPosition(camera_eye_x, camera_eye_y, camera_eye_z)
+        camera.SetFocalPoint(0, 0, 0)
+        camera.SetViewUp(0, 0, 1)
+
+        self.renderer.SetActiveCamera(camera)
+        self.renderer.ResetCamera()
+        self.renderer.SetBackground(0.1, 0.1, 0.15)  # A nice dark theme background
+
+        self.vtkWidget.GetRenderWindow().Render()

tabs/visualize_geometry/features/__init__.py

@@ -0,0 +1,10 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/__init__.py
+
+from .axes_gizmo import *
+from .background import *
+from .blueprint import *
+from .camera import *
+from .drag_aircraft import *
+from .grid import *
+from .measurement import *
+from .screenshot import *

tabs/visualize_geometry/features/axes_gizmo.py

@@ -0,0 +1,173 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/axes_gizmo.py
+
+# Created: M Clarke, LEADS, 2024
+# RCAIDE-GUI imports 
+# RCAIDE-GUI Imports 
+from tabs.visualize_geometry.visualize_geometry import VisualizeGeometryWidget
+
+# Python imports
+import vtkmodules.all as vtk
+# ------------------------------------------------------------------------------
+# Gizmo functions
+# ------------------------------------------------------------------------------
+def _bind_gizmo_renderer(widget, renderer):
+    # VTK uses different method names depending on the version
+    try:
+        widget.SetCurrentRenderer(renderer)
+    except Exception:
+        try:
+            widget.SetDefaultRenderer(renderer)
+        except Exception:
+            pass
+
+def add_orientation_gizmo(self):
+    # Need renderer + render window + interactor
+    r = getattr(self, "renderer", None)
+    if r is None:
+        return
+    try:
+        rw = self.vtkWidget.GetRenderWindow()
+    except Exception:
+        return
+    if rw is None:
+        return
+    iren = rw.GetInteractor()
+    if iren is None:
+        return
+
+    # Reuse existing widget so we don’t create duplicates
+    widget = getattr(self, "_axes_widget", None) or getattr(iren, "_axes_widget", None)
+
+    if widget is None:
+        # Axes + label styling
+        axes = vtk.vtkAxesActor()
+        for cap in (
+            axes.GetXAxisCaptionActor2D(),
+            axes.GetYAxisCaptionActor2D(),
+            axes.GetZAxisCaptionActor2D(),
+        ):
+            tp = cap.GetTextActor().GetTextProperty()
+            tp.SetFontSize(14)
+            tp.SetColor(1.0, 1.0, 1.0)
+
+        # Light wireframe border around the gizmo
+        border = vtk.vtkCubeSource()
+        border.SetXLength(1.2)
+        border.SetYLength(1.2)
+        border.SetZLength(1.2)
+
+        border_mapper = vtk.vtkPolyDataMapper()
+        border_mapper.SetInputConnection(border.GetOutputPort())
+
+        border_actor = vtk.vtkActor()
+        border_actor.SetMapper(border_mapper)
+        p = border_actor.GetProperty()
+        p.SetColor(0.8, 0.8, 0.8)
+        p.SetOpacity(0.1)
+        p.SetRepresentationToWireframe()
+        p.LightingOff()
+
+        # Combine axes + border into one marker
+        assembly = vtk.vtkPropAssembly()
+        assembly.AddPart(border_actor)
+        assembly.AddPart(axes)
+
+        # Small overlay widget in the corner
+        widget = vtk.vtkOrientationMarkerWidget()
+        widget.SetOrientationMarker(assembly)
+        widget.SetViewport(0.0, 0.0, 0.18, 0.28)
+        widget.SetInteractor(iren)
+
+    # Attach to the current renderer (important if renderer was rebuilt)
+    _bind_gizmo_renderer(widget, r)
+
+    # Some VTK builds need this before enabling the widget
+    try:
+        if not iren.GetInitialized():
+            iren.Initialize()
+    except Exception:
+        pass
+
+    # Keep it visible but not clickable
+    widget.EnabledOn()
+    widget.InteractiveOff()
+
+    # Store in both places so it survives tab switches
+    self._axes_widget = widget
+    iren._axes_widget = widget
+
+    # Redraw now
+    try:
+        rw.Render()
+    except Exception:
+        pass
+
+def _rebind_axes_gizmo_on_show(self):
+    # Tab switching can recreate the renderer/interactor, so we reattach the gizmo
+    r = getattr(self, "renderer", None)
+    if r is None:
+        return
+    try:
+        rw = self.vtkWidget.GetRenderWindow()
+    except Exception:
+        return
+    if rw is None:
+        return
+    iren = rw.GetInteractor()
+    if iren is None:
+        return
+
+    # Find existing gizmo widget
+    w = getattr(self, "_axes_widget", None) or getattr(iren, "_axes_widget", None)
+    if w is None:
+        return
+
+    # Reattach to the current interactor/renderer
+    try:
+        w.SetInteractor(iren)
+    except Exception:
+        pass
+    _bind_gizmo_renderer(w, r)
+
+    # Turn it back on and redraw
+    try:
+        w.EnabledOn()
+        w.InteractiveOff()
+        rw.Render()
+    except Exception:
+        pass
+
+# Activate Patch
+def _patch_run_solve_for_axes_gizmo():
+    # After run_solve builds the scene, make sure the gizmo exists
+    if getattr(VisualizeGeometryWidget, "_axes_gizmo_patched", False):
+        return
+    base = VisualizeGeometryWidget.run_solve
+
+    def wrapped(self, *args, **kwargs):
+        base(self, *args, **kwargs)
+        add_orientation_gizmo(self)
+
+    VisualizeGeometryWidget.run_solve = wrapped
+    VisualizeGeometryWidget._axes_gizmo_patched = True
+
+# Activate Patch
+def _patch_showEvent_for_axes_gizmo_rebind():
+    # When the widget becomes visible again, rebind the gizmo
+    if getattr(VisualizeGeometryWidget, "_axes_showevent_patched", False):
+        return
+    old = getattr(VisualizeGeometryWidget, "showEvent", None)
+
+    def wrapped(self, event):
+        if old is not None:
+            try:
+                old(self, event)
+            except Exception:
+                pass
+        _rebind_axes_gizmo_on_show(self)
+
+    VisualizeGeometryWidget.showEvent = wrapped
+    VisualizeGeometryWidget._axes_showevent_patched = True
+
+_patch_run_solve_for_axes_gizmo()
+_patch_showEvent_for_axes_gizmo_rebind()