cutting plane no longer crashes if a model isn't loaded

Author: SteveDoyle2

pyNastran/bdf/mesh_utils/cut_edge_model_by_plane.py

@@ -93,9 +93,13 @@ def _setup_edges(bdf_filename: str) -> tuple[NDArrayNint, NDArrayN3float, NDArra
 def _cut_model(nids: NDArrayNint,
                xyz_cp: NDArrayN3float,
                edges: NDArrayN2int,
-               view_up: NDArray3float, p1: NDArray3float, p2: NDArray3float,
+               view_up: NDArray3float,
+               p1: NDArray3float,
+               p2: NDArray3float,
                tol: float,
-               nodal_result, plane_atol=1e-5, plane_bdf_filename=None):
+               nodal_result: np.ndarray,
+               plane_atol: float=1e-5,
+               plane_bdf_filename: Optional[str]=None):
     """
     Helper method for cut_edge_model_by_axes
 
@@ -153,9 +157,14 @@ def _cut_model(nids: NDArrayNint,
         plane_atol=plane_atol, plane_bdf_filename=plane_bdf_filename)
     return local_points_array, global_points_array, result_array
 
-def _cut_edge_model_by_coord(nids, xyz_cid0, edges, coord, tol,
-                             nodal_result, plane_atol=1e-5,
-                             plane_bdf_filename=None):
+def _cut_edge_model_by_coord(nids: np.ndarray,
+                             xyz_cid0: np.ndarray,
+                             edges: np.ndarray,
+                             coord: CORD2R,
+                             tol: float,
+                             nodal_result: np.ndarray,
+                             plane_atol: float=1e-5,
+                             plane_bdf_filename: Optional[str]=None):
     """
     Cuts a Nastran model with a cutting plane
 

pyNastran/bdf/mesh_utils/cutting_plane_plotter.py

@@ -1,5 +1,8 @@
 """Plots a model cutting plane"""
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
 import numpy as np
+
 from pyNastran.utils import int_version
 try:
     import matplotlib.pyplot as plt
@@ -13,14 +16,23 @@
 from pyNastran.bdf.mesh_utils.cut_model_by_plane import (
     cut_edge_model_by_coord, cut_face_model_by_coord, export_face_cut)
 
-
-def cut_and_plot_model(title, p1, p2, zaxis,
-                       model, coord, nodal_result,
-                       log, ytol,
-                       plane_atol=1e-5,
-                       csv_filename=None,
-                       invert_yaxis=False,
-                       cut_type='edge', plot=True, show=True):
+if TYPE_CHECKING:
+    from cpylog import SimpleLogger
+    from pyNastran.bdf.bdf import BDF, CORD2R
+
+def cut_and_plot_model(title: str,
+                       p1: np.ndarray,
+                       p2: np.ndarray,
+                       zaxis: np.ndarray,
+                       model: BDF, coord: CORD2R,
+                       nodal_result: np.ndarray,
+                       log: SimpleLogger,
+                       ytol: float,
+                       plane_atol: float=1e-5,
+                       csv_filename: Optional[str]=None,
+                       invert_yaxis: bool=False,
+                       cut_type: str='edge',
+                       plot: bool=True, show: bool=True):
     """
     Cuts a Nastran model with a cutting plane
 
@@ -63,14 +75,16 @@ def cut_and_plot_model(title, p1, p2, zaxis,
         local_points_array, global_points_array, result_array = cut_edge_model_by_coord(
             model, coord, ytol,
             nodal_result, plane_atol=plane_atol, csv_filename=csv_filename_edge)
+
         if len(local_points_array) == 0:
             log.error('No elements were piereced.  Check your cutting plane.')
             return
         if plot or csv_filename:
-            plot_cutting_plane_edges(title, p1, p2, zaxis,
-                                     local_points_array, global_points_array, result_array,
-                                     csv_filename=csv_filename, invert_yaxis=invert_yaxis,
-                                     plot=plot, show=show)
+            plot_cutting_plane_edges(
+                title, p1, p2, zaxis,
+                local_points_array, global_points_array, result_array,
+                csv_filename=csv_filename, invert_yaxis=invert_yaxis,
+                plot=plot, show=show)
     elif cut_type == 'face':
         csv_filename_face = None
         if csv_filename:
@@ -82,15 +96,22 @@ def cut_and_plot_model(title, p1, p2, zaxis,
 
         plot_cutting_plane_faces(title, p1, p2, zaxis,
                                  geometry_arrays, results_arrays,
-                                 csv_filename=csv_filename, invert_yaxis=invert_yaxis,
+                                 csv_filename=csv_filename,
+                                 invert_yaxis=invert_yaxis,
                                  show=show)
     else:  # pragma: no cover
         raise NotImplementedError(f'cut_type={cut_type!r} and must be [edge, face]')
 
 
-def plot_cutting_plane_faces(title, p1, p2, zaxis,
-                             geometry_arrays, result_arrays,
-                             csv_filename=None, invert_yaxis=False, show=True):
+def plot_cutting_plane_faces(title: str,
+                             p1: np.ndarray,
+                             p2: np.ndarray,
+                             zaxis: np.ndarray,
+                             geometry_arrays: np.ndarray,
+                             result_arrays: np.ndarray,
+                             csv_filename: Optional[str]=None,
+                             invert_yaxis: bool=False,
+                             show: bool=True):
     """for faces"""
     try:
         local_x = result_arrays[:, 0]
@@ -146,11 +167,20 @@ def plot_cutting_plane_faces(title, p1, p2, zaxis,
     #with open(csv_filename, 'w') as csv_file:
     #np.savetxt(csv_filename, result_arrays[0], delimiter=',', header=header, comments='# ',
     #           encoding=None)
-    export_face_cut(csv_filename, geometry_arrays, result_arrays, header=header)
-
-def plot_cutting_plane_edges(title, p1, p2, zaxis,
-                             local_points_array, global_points_array, result_array,
-                             csv_filename=None, invert_yaxis=False, plot=True, show=True):
+    export_face_cut(csv_filename, geometry_arrays, result_arrays,
+                    header=header)
+
+def plot_cutting_plane_edges(title: str,
+                             p1: np.ndarray,
+                             p2: np.ndarray,
+                             zaxis: np.ndarray,
+                             local_points_array: np.ndarray,
+                             global_points_array: np.ndarray,
+                             result_array: np.ndarray,
+                             csv_filename: Optional[str]=None,
+                             invert_yaxis: bool=False,
+                             plot: bool=True,
+                             show: bool=True):
     """for edges"""
     local_x = local_points_array[:, 0]
 

pyNastran/gui/menus/cutting_plane/cutting_plane_object.py

@@ -152,6 +152,19 @@ def make_cutting_plane(self,
         gui: MainWindow = self.gui
         log = gui.log
 
+        try:
+            model_objs = gui.load_actions.model_objs
+        except AttributeError:
+            log.error('Load a model')
+            return
+
+        origin = np.array([0., 0., 0.])
+        zaxis = np.array([0., 0., 1.])
+        xzplane = np.array([1., 0., 0.])
+        default_coords = {
+            0: CORD2R(0, origin, zaxis, xzplane),
+        }
+
         model = gui.models[model_name]
         class_name = model.__class__.__name__
         if class_name in {'BDF', 'OP2Geom'}:
@@ -166,7 +179,7 @@ def make_cutting_plane(self,
         # elif class_name in {'Fluent'}:
         #     xyz_cid0 = model.xyz
         else:
-            model_obj = gui.load_actions.model_objs['main']
+            model_obj = model_objs['main']
             model = model_obj.model
             if model is None:
                 msg = f'{class_name!r} is not supported'
@@ -177,20 +190,14 @@ def make_cutting_plane(self,
 
             class_name = model.__class__.__name__
             if not hasattr(model, 'cut_model_node'):  # pragma: no cover
-                raise NotImplementedError(model)
+                log.error(f'Cutting plane is not supported for {class_name}.')
+                #raise NotImplementedError(model)
+                return
             #if not hasattr(model, 'cut_model_centroid'):  # pragma: no cover
                 #raise NotImplementedError(res_format)
 
-            if class_name in {'Cart3D'}:
-                origin = np.array([0., 0., 0.])
-                zaxis = np.array([0., 0., 1.])
-                xzplane = np.array([1., 0., 0.])
-                model.coords = {
-                    0: CORD2R(0, origin, zaxis, xzplane),
-                }
-                xyz_cid0 = model.points
-            else:  # pragma: no cover
-                raise RuntimeError(class_name)
+            model.coords = default_coords
+            xyz_cid0 = get_xyz_cid0(model, class_name)
 
         #xyz_min, xyz_max = model.xyz_limits
         xyz_min = xyz_cid0.min(axis=0)
@@ -306,33 +313,7 @@ def make_cutting_plane(self,
             else:
                 xyz_rel2, res2 = model.cut_model_node(
                     nodal_result, yslices, xyz=xyz_rel)
-
-            fig1 = plt.figure()
-            fig2 = plt.figure()
-            fig3 = plt.figure()
-            ax1 = fig1.gca()
-            ax2 = fig2.gca()
-            ax3 = fig3.gca()
-            xs = xyz_rel2[:, 0]
-            ys = xyz_rel2[:, 1]
-            zs = xyz_rel2[:, 2]
-
-            ax1.plot(xs, zs, 'o')
-            ax2.plot(xs, res2, 'o', label=title)
-
-            ax1.set_xlabel('X Coord')
-            ax1.set_ylabel('Z Coord')
-
-            ax2.set_xlabel('X Coord')
-            ax2.set_ylabel(title)
-
-            ax3.plot(ys, zs, 'o')
-            ax3.set_xlabel('Y Coord')
-            ax3.set_ylabel('Z Coord')
-            ax1.grid(True)
-            ax2.grid(True)
-            ax3.grid(True)
-            plt.show()
+            plot_cuts(title, xyz_rel2, res2)
 
 
     #def create_plane_actor(self,
@@ -368,3 +349,41 @@ def make_cutting_plane(self,
         #plane_actor.VisibilityOn()
         #gui.rend.Render()
         #return plane_actor, prop
+
+def get_xyz_cid0(model, class_name: str) -> np.ndarray:
+    if class_name in {'Cart3D'}:
+        xyz_cid0 = model.points
+    else:  # pragma: no cover
+        raise RuntimeError(class_name)
+    return xyz_cid0
+
+
+def plot_cuts(title: str,
+              xyz_rel2: np.ndarray,
+              res2: np.ndarray) -> None:
+    fig1 = plt.figure()
+    fig2 = plt.figure()
+    fig3 = plt.figure()
+    ax1 = fig1.gca()
+    ax2 = fig2.gca()
+    ax3 = fig3.gca()
+    xs = xyz_rel2[:, 0]
+    ys = xyz_rel2[:, 1]
+    zs = xyz_rel2[:, 2]
+
+    ax1.plot(xs, zs, 'o')
+    ax2.plot(xs, res2, 'o', label=title)
+
+    ax1.set_xlabel('X Coord')
+    ax1.set_ylabel('Z Coord')
+
+    ax2.set_xlabel('X Coord')
+    ax2.set_ylabel(title)
+
+    ax3.plot(ys, zs, 'o')
+    ax3.set_xlabel('Y Coord')
+    ax3.set_ylabel('Z Coord')
+    ax1.grid(True)
+    ax2.grid(True)
+    ax3.grid(True)
+    plt.show()