PyNiteFEA 2.0.1__tar.gz → 2.0.2__tar.gz

{pynitefea-2.0.1 → pynitefea-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.0.1
+Version: 2.0.2
 Summary: A simple elastic 3D structural finite element library for Python.
 Home-page: https://github.com/JWock82/Pynite.git
 Author: D. Craig Brinck, PE, SE
@@ -117,6 +117,11 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.0.2
+* Added docstrings to the VTK `Renderer` class to help the user.
+* Enforced use of properties instead of attributes in the VTK `Renderer` and added docstrings to properties help the user make decisions.
+* Removed the VTK `Renderer`'s properties that began with "set_". These were redundant and caused confusion. The prefix "set_" is no longer used to access or set any of the `Renderer`'s properties.
+
 v2.0.1
 * Pynite no longer struggles rendering load cases and combinations when no loads are present. This is especially helpful for rendering modal load combinations, which don't have loads (only masses).
 * The pyvista plotter's "X" button now works just like pressing "q". This was an annoying pyvista-ism that led to error messages when closing the window with the "X" button.

{pynitefea-2.0.1 → pynitefea-2.0.2}/PyNiteFEA.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyNiteFEA
-Version: 2.0.1
+Version: 2.0.2
 Summary: A simple elastic 3D structural finite element library for Python.
 Home-page: https://github.com/JWock82/Pynite.git
 Author: D. Craig Brinck, PE, SE
@@ -117,6 +117,11 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.0.2
+* Added docstrings to the VTK `Renderer` class to help the user.
+* Enforced use of properties instead of attributes in the VTK `Renderer` and added docstrings to properties help the user make decisions.
+* Removed the VTK `Renderer`'s properties that began with "set_". These were redundant and caused confusion. The prefix "set_" is no longer used to access or set any of the `Renderer`'s properties.
+
 v2.0.1
 * Pynite no longer struggles rendering load cases and combinations when no loads are present. This is especially helpful for rendering modal load combinations, which don't have loads (only masses).
 * The pyvista plotter's "X" button now works just like pressing "q". This was an annoying pyvista-ism that led to error messages when closing the window with the "X" button.

{pynitefea-2.0.1 → pynitefea-2.0.2}/Pynite/Rendering.py

@@ -209,13 +209,15 @@ class Renderer:
             generating images in headless environments. Default is `False`.
         """
 
-        # Update the plotter with the latest geometry
-        self.update(reset_camera)
-
         # Set off-screen mode if requested (for testing/headless environments)
+        # This must be done BEFORE calling update() so the plotter is in off-screen mode
+        # when adding meshes, preventing PyVista camera initialization issues
         if off_screen:
             self.plotter.off_screen = True
 
+        # Update the plotter with the latest geometry
+        self.update(reset_camera)
+
         # Render the model (code execution will pause here until the user closes the window)
         try:
             self.plotter.show(title='Pynite - Simple Finite Element Analysis for Python', auto_close=False)
@@ -281,12 +283,6 @@ class Renderer:
         # Clear out the old plot (if any)
         self.plotter.clear()
         
-        # In off-screen mode, ensure renderer is initialized after clear
-        # Accessing plotter.renderer forces lazy initialization in PyVista
-        if pv.OFF_SCREEN and self.plotter.renderer is None:
-            # Force renderer creation by enabling it
-            self.plotter.enable_lightkit()
-        
         # Set up view and axes (works for both interactive and off-screen modes)
         try:
             self.plotter.view_xy()

{pynitefea-2.0.1 → pynitefea-2.0.2}/Pynite/Visualization.py

@@ -1,5 +1,4 @@
 from __future__ import annotations # Allows more recent type hints features
-from json import load
 import warnings
 
 from IPython.display import Image
@@ -8,28 +7,83 @@ from numpy.linalg import norm
 import vtk
 
 class Renderer():
-    """Used to render finite element models.
+    """Renderer for visualizing finite element models using VTK.
+    
+    This class provides a flexible interface for rendering 3D finite element models,
+    including nodes, members, springs, plates, and quads. It supports rendering of
+    undeformed and deformed shapes, load visualizations, and stress/force contours.
+    
+    Parameters
+    ----------
+    model : FEModel3D
+        The finite element model to be rendered.
+    
+    Attributes
+    ----------
+    annotation_size : float
+        Controls the size of text labels and visual elements (default: 5).
+    deformed_shape : bool
+        Whether to render the deformed shape of the model (default: False).
+    deformed_scale : float
+        Scale factor for deformation visualization (default: 30).
+    render_nodes : bool
+        Whether to render nodes in the visualization (default: True).
+    render_loads : bool
+        Whether to render applied loads (default: True).
+    color_map : str or None
+        Type of stress/force contour to display on plates/quads. Options:
+        'Qx', 'Qy', 'Mx', 'My', 'Mxy', 'Sx', 'Sy', 'Txy' (default: None).
+    combo_name : str or None
+        Name of load combination to visualize. Mutually exclusive with case.
+    case : str or None
+        Name of load case to visualize. Mutually exclusive with combo_name.
+    labels : bool
+        Whether to display text labels for elements (default: True).
+    scalar_bar : bool
+        Whether to display a scalar bar for contour plots (default: False).
+    scalar_bar_text_size : int
+        Font size for scalar bar text (default: 24).
+    theme : str
+        Visual theme: 'default' or 'print' (default: 'default').
+    window_size : tuple
+        Window dimensions as (width, height).
+    
+    Examples
+    --------
+    >>> from PyNite import FEModel3D
+    >>> model = FEModel3D()
+    >>> # ... build model ...
+    >>> renderer = Renderer(model)
+    >>> renderer.annotation_size = 6
+    >>> renderer.combo_name = 'Load Combo 1'
+    >>> renderer.render_model()
     """
 
     scalar = None
 
     def __init__(self, model):
-
+        """Initialize the renderer with a finite element model.
+        
+        Parameters
+        ----------
+        model : FEModel3D
+            The finite element model to render.
+        """
         self.model = model
 
         # Default settings for rendering
-        self.annotation_size = 5
-        self.deformed_shape = False
-        self.deformed_scale = 30
-        self.render_nodes = True
-        self.render_loads = True
-        self.color_map = None
-        self.combo_name = 'Combo 1'
-        self.case = None
-        self.labels = True
-        self.scalar_bar = False
-        self.scalar_bar_text_size = 24
-        self.theme = 'default'
+        self._annotation_size = 5
+        self._deformed_shape = False
+        self._deformed_scale = 30
+        self._render_nodes = True
+        self._render_loads = True
+        self._color_map = None
+        self._combo_name = 'Combo 1'
+        self._case = None
+        self._labels = True
+        self._scalar_bar = False
+        self._scalar_bar_text_size = 24
+        self._theme = 'default'
 
         # Initialize VTK objects
         self.renderer = vtk.vtkRenderer()
@@ -38,62 +92,134 @@ class Renderer():
         self.window.AddRenderer(self.renderer)
 
     @property
-    def window_width(self):
-        return self.window.GetSize()[0]
-
-    @window_width.setter
-    def window_width(self, width):
-        height = self.window.GetSize()[1]
+    def window_size(self):
+        """Window size as (width, height) tuple."""
+        return self.window.GetSize()
+
+    @window_size.setter
+    def window_size(self, size):
+        """Set window size from tuple or list (width, height)."""
+        width, height = size
         self.window.SetSize(width, height)
 
     @property
-    def window_height(self):
-        return self.window.GetSize()[1]
-
-    @window_height.setter
-    def window_height(self, height):
-        width = self.window.GetSize()[0]
-        self.window.SetSize(width, height)
+    def combo_name(self):
+        """Load combination name. When set, case is automatically set to None."""
+        return self._combo_name
+    
+    @combo_name.setter
+    def combo_name(self, value):
+        self._combo_name = value
+        if value is not None:
+            self._case = None
+    
+    @property
+    def case(self):
+        """Load case name. When set, combo_name is automatically set to None."""
+        return self._case
+    
+    @case.setter
+    def case(self, value):
+        self._case = value
+        if value is not None:
+            self._combo_name = None
 
-    def set_annotation_size(self, size=5):
-        self.annotation_size = size
+    @property
+    def annotation_size(self):
+        """Size of text annotations and visual elements in model units."""
+        return self._annotation_size
+    
+    @annotation_size.setter
+    def annotation_size(self, value):
+        self._annotation_size = value
 
-    def set_deformed_shape(self, deformed_shape=False):
-        self.deformed_shape = deformed_shape
+    @property
+    def deformed_shape(self):
+        """Whether to render the deformed shape of the model."""
+        return self._deformed_shape
+    
+    @deformed_shape.setter
+    def deformed_shape(self, value):
+        self._deformed_shape = value
 
-    def set_deformed_scale(self, scale=30):
-        self.deformed_scale = scale
+    @property
+    def deformed_scale(self):
+        """Scale factor for deformation visualization."""
+        return self._deformed_scale
+    
+    @deformed_scale.setter
+    def deformed_scale(self, value):
+        self._deformed_scale = value
 
-    def set_render_nodes(self, render_nodes=True):
-        self.render_nodes = render_nodes
+    @property
+    def render_nodes(self):
+        """Whether to render nodes in the visualization."""
+        return self._render_nodes
+    
+    @render_nodes.setter
+    def render_nodes(self, value):
+        self._render_nodes = value
 
-    def set_render_loads(self, render_loads=True):
-        self.render_loads = render_loads
+    @property
+    def render_loads(self):
+        """Whether to render applied loads."""
+        return self._render_loads
     
-    def set_color_map(self, color_map=None):
-        """Sets the color map for plate contours.
+    @render_loads.setter
+    def render_loads(self, value):
+        self._render_loads = value
 
-        :param color_map: The color map to use: Valid options are 'Qx', Qy', 'Mx', 'My', 'Mxy', 'Sx', 'Sy' 'Txy'. Qx and Qy are out-of-plane shear forces. Mx, My, and Mxy are local out-of-plane bending moments. 'Sx' and 'Sy' are membrane forces, and 'Txy' is an in-plane shear force. Defaults to None.
-        :type color_map: str, optional
+    @property
+    def color_map(self):
+        """Type of stress/force contour to display on plates/quads.
+        
+        Valid options: 'Qx', 'Qy', 'Mx', 'My', 'Mxy', 'Sx', 'Sy', 'Txy'
+        - Qx, Qy: Out-of-plane shear forces
+        - Mx, My, Mxy: Local out-of-plane bending moments
+        - Sx, Sy: Membrane forces
+        - Txy: In-plane shear force
         """
-        self.color_map = color_map
-
-    def set_combo_name(self, combo_name='Combo 1'):
-        self.case = None
-        self.combo_name = combo_name
+        return self._color_map
+    
+    @color_map.setter
+    def color_map(self, value):
+        self._color_map = value
 
-    def set_case(self, case=None):
-        self.combo_name = None
-        self.case = case
+    @property
+    def labels(self):
+        """Whether to display text labels for elements."""
+        return self._labels
+    
+    @labels.setter
+    def labels(self, value):
+        self._labels = value
 
-    def set_show_labels(self, show_labels=True):
-        self.labels = show_labels
+    @property
+    def scalar_bar(self):
+        """Whether to display a scalar bar legend for contour plots."""
+        return self._scalar_bar
+    
+    @scalar_bar.setter
+    def scalar_bar(self, value):
+        self._scalar_bar = value
 
-    def set_scalar_bar(self, scalar_bar=False):
-        self.scalar_bar = scalar_bar
+    @property
+    def scalar_bar_text_size(self):
+        """Font size for scalar bar text."""
+        return self._scalar_bar_text_size
+    
+    @scalar_bar_text_size.setter
+    def scalar_bar_text_size(self, value):
+        self._scalar_bar_text_size = value
 
-    def set_scalar_bar_text_size(self, text_size=24):
-        self.scalar_bar_text_size = text_size
+    @property
+    def theme(self):
+        """Visual theme: 'default' (dark background) or 'print' (white background)."""
+        return self._theme
+    
+    @theme.setter
+    def theme(self, value):
+        self._theme = value
 
     def render_model(self, interact=True, reset_camera=True):
         """
@@ -198,11 +324,26 @@ class Renderer():
             return
 
     def update(self, reset_camera=True):
-        """Builds (or rebuilds) the VTK renderer
-
-        :param reset_camera: Resets the render window's camera position if set to True. Defaults to True.
-        :type reset_camera: bool, optional
-        :raises Exception: Visualization failed due to an unexpected error.
+        """Build or rebuild the VTK renderer with current settings.
+        
+        This method updates the visualization based on the current renderer settings,
+        including deformed shape, loads, contours, and other visual elements. It is
+        automatically called by render_model() and screenshot().
+        
+        Parameters
+        ----------
+        reset_camera : bool, optional
+            If True, resets the camera to view the entire model (default: True).
+        
+        Raises
+        ------
+        Exception
+            If the model configuration is invalid for the requested visualization.
+        
+        Notes
+        -----
+        This method validates that deformed_shape is not used with a load case,
+        and that render_loads requires either a load combination or load case.
         """
 
         # Input validation

{pynitefea-2.0.1 → pynitefea-2.0.2}/README.md

@@ -67,6 +67,11 @@ Here's a list of projects that use Pynite:
 * Phaenotyp (https://github.com/bewegende-Architektur/Phaenotyp) (https://youtu.be/shloSw9HjVI)
 
 # What's New?
+v2.0.2
+* Added docstrings to the VTK `Renderer` class to help the user.
+* Enforced use of properties instead of attributes in the VTK `Renderer` and added docstrings to properties help the user make decisions.
+* Removed the VTK `Renderer`'s properties that began with "set_". These were redundant and caused confusion. The prefix "set_" is no longer used to access or set any of the `Renderer`'s properties.
+
 v2.0.1
 * Pynite no longer struggles rendering load cases and combinations when no loads are present. This is especially helpful for rendering modal load combinations, which don't have loads (only masses).
 * The pyvista plotter's "X" button now works just like pressing "q". This was an annoying pyvista-ism that led to error messages when closing the window with the "X" button.

{pynitefea-2.0.1 → pynitefea-2.0.2}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="PyNiteFEA",
-    version="2.0.1",
+    version="2.0.2",
     author="D. Craig Brinck, PE, SE",
     author_email="Building.Code@outlook.com",
     description="A simple elastic 3D structural finite element library for Python.",