Fix scaling and add global COS

- Fixed scaling problems when switching between files. Specifically,
there is a new update_vtu_render_window function which performs manual
scaling procedures for vtk components which do not scale automatically.
- Added global coordinate system which also scales with the problem.
- Introduced CTXT context object of the SERVER. This is a
server-side-only state object. We use this for the non-serializable
objects which do not have to be shared with the client. This resolves the
errors we received regarding these objects.
- Improved docstring documentation of various functions.

Author: dragos-ana

src/fourc_webviewer/run_webserver.py

@@ -34,8 +34,8 @@
 
 # create server object and the state, control variables
 SERVER = get_server()
-STATE, CTRL = SERVER.state, SERVER.controller
-# STATE contains all the state variables, CTRL contains all the control functions / elements, UI
+STATE, CTRL, CTXT = SERVER.state, SERVER.controller, SERVER.context
+# STATE contains all the state variables to be shared between server and client, CTRL contains all the control functions / elements, CTXT is a server-only state object which can be utilized to collect global server variables
 
 
 def run_webviewer(dat_file=None):
@@ -84,11 +84,18 @@ def run_webviewer(dat_file=None):
     vtu_threshold_condition_points = vtu.create_vtu_threshold_points(reader, STATE)
     vtu_sphere = vtu.create_vtu_sphere(reader)
 
+    # create global coordinate system
+    vtu_global_cos = vtu.create_vtu_global_cos(reader)
+
     STATE.TEMP_DIR = temp_dir
-    STATE.READER = reader
-    STATE.VTU_THRESHOLD_MAT = vtu_threshold_mat
-    STATE.VTU_THRESHOLD_CONDITION_POINTS = vtu_threshold_condition_points
-    STATE.VTU_SPHERE = vtu_sphere
+
+    # we put the non-serializable objects into CTXT instead of STATE 
+    # -> no errors anymore, and functionality is preserved, because these variables are only required on the server side
+    CTXT.READER = reader
+    CTXT.VTU_THRESHOLD_MAT = vtu_threshold_mat
+    CTXT.VTU_THRESHOLD_CONDITION_POINTS = vtu_threshold_condition_points
+    CTXT.VTU_SPHERE = vtu_sphere
+    CTXT.VTU_GLOBAL_COS = vtu_global_cos
 
     # append functions to CTRL
     CTRL.CLICK_INFO_BUTTON = click_info_button
@@ -98,7 +105,7 @@ def run_webviewer(dat_file=None):
 
     # create vtu render window
     render_window = vtu.create_vtu_render_window(
-        reader, vtu_threshold_condition_points, vtu_threshold_mat, vtu_sphere
+        reader, vtu_threshold_condition_points, vtu_threshold_mat, vtu_sphere, vtu_global_cos
     )
 
     gui.create_gui(SERVER, render_window)
@@ -371,22 +378,9 @@ def STATE_initialization(temp_dir, dat_file_name, dat_file_lines, dat_file_size,
     STATE.COND_TYPE_LIST = dat_file_content["cond_type_list"]
 
     # GET THE RESULT DESCRIPTION
-    # STATE.RESULT_DESCRIPTION = STATE.CATEGORY_ITEMS[
-    #    STATE.CATEGORIES.index("RESULT DESCRIPTION")
-    # ]
-    STATE.RESULT_DESCRIPTION = [
-        [1, 2, 3, 4, 5, 6, 7, 8],
-        [
-            "STRUCTURE DIS structure NODE 4 QUANTITY dispy VALUE -1.31962249833408790e-01 TOLERANCE 9.1e-10",
-            "STRUCTURE DIS structure NODE 5 QUANTITY dispx VALUE -1.31962249833408513e-01 TOLERANCE 9.1e-10",
-            "STRUCTURE DIS structure NODE 8 QUANTITY dispx VALUE -9.06271329067036280e-02 TOLERANCE 9.1e-10",
-            "STRUCTURE DIS structure NODE 8 QUANTITY dispy VALUE -9.06271329067068060e-02 TOLERANCE 9.1e-10",
-            "STRUCTURE DIS structure NODE 8 QUANTITY dispz VALUE 2.84025416687741394e-01 TOLERANCE 2.8e-09",
-            "STRUCTURE DIS structure NODE 6 QUANTITY dispx VALUE -9.06271329067021153e-02 TOLERANCE 9.1e-10",
-            "STRUCTURE DIS structure NODE 4 QUANTITY stress_zz VALUE  1.83879098311578976e-01 TOLERANCE 1.8e-07",
-            "STRUCTURE DIS structure NODE 8 QUANTITY stress_zz VALUE  1.83879098311589884e-01 TOLERANCE 1.8e-07",
-        ],
-    ]
+    STATE.RESULT_DESCRIPTION = STATE.CATEGORY_ITEMS[
+        STATE.CATEGORIES.index("RESULT DESCRIPTION")
+     ]
 
     # GET THE GEOMETRY LINES
     STATE.GEOMETRY_LINES = dat_file_content["geometry_lines"]
@@ -570,8 +564,8 @@ def change_selected_cmm_line(SELECTED_CMM_LINE, **kwargs):
     )
 
     # set threshold of the material of the vtk local view
-    STATE.VTU_THRESHOLD_MAT.SetLowerThreshold(STATE.SELECTED_CMM_LINE_INDEX + 1)
-    STATE.VTU_THRESHOLD_MAT.SetUpperThreshold(STATE.SELECTED_CMM_LINE_INDEX + 1)
+    CTXT.VTU_THRESHOLD_MAT.SetLowerThreshold(STATE.SELECTED_CMM_LINE_INDEX + 1)
+    CTXT.VTU_THRESHOLD_MAT.SetUpperThreshold(STATE.SELECTED_CMM_LINE_INDEX + 1)
     # update the vtk local view
     CTRL.VIEW_UPDATE()
 
@@ -611,7 +605,7 @@ def change_selected_cond_general_type(SELECTED_COND_GENERAL_TYPE, **kwargs):
             STATE.SELECTED_COND_GENERAL_TYPE_INDEX
         ][0]
         # set thresholdPoints of the condition of the vtk figure
-        STATE.VTU_THRESHOLD_CONDITION_POINTS.SetInputArrayToProcess(
+        CTXT.VTU_THRESHOLD_CONDITION_POINTS.SetInputArrayToProcess(
             0,
             0,
             0,
@@ -633,7 +627,7 @@ def change_selected_cond_entity(SELECTED_COND_ENTITY, **kwargs):
     ].index(SELECTED_COND_ENTITY)
 
     # set thresholdPoints of the condition of the vtk figure
-    STATE.VTU_THRESHOLD_CONDITION_POINTS.SetInputArrayToProcess(
+    CTXT.VTU_THRESHOLD_CONDITION_POINTS.SetInputArrayToProcess(
         0,
         0,
         0,
@@ -656,19 +650,7 @@ def change_selected_result_descr_index(SELECTED_RESULT_DESCR_INDEX, **kwargs):
 # after selecting a result description from the list: item change
 @STATE.change("SELECTED_RESULT_DESCR")
 def change_selected_result_descr(SELECTED_RESULT_DESCR, **kwargs):
-    # check if the line contains the marker "NODE"
-    if len(re.findall("NODE", STATE.SELECTED_RESULT_DESCR)) > 0:
-        # get the specified node
-        result_descr_components = STATE.SELECTED_RESULT_DESCR.split(" ")
-        node_index = (
-            int(result_descr_components[result_descr_components.index("NODE") + 1]) - 1
-        )
-
-        # update graphic representation
-        node_coords = STATE.READER.GetOutput().GetPoints().GetPoint(node_index)
-        STATE.VTU_SPHERE.SetCenter(node_coords[0], node_coords[1], node_coords[2])
-        # update the vtk figure
-        CTRL.VIEW_UPDATE()
+    vtu.update_vtu_render_window(CTXT.READER, CTXT.VTU_SPHERE, CTXT.VTU_GLOBAL_COS, SERVER)
 
 
 # changing the values for t_max, x, y or z for the function plots
@@ -738,7 +720,7 @@ def click_convert_button():
     vtu_path = convert_to_vtu(temp_dat_file, STATE.TEMP_DIR)
 
     # update reader to read the current vtu file
-    vtu.update_vtu_reader(STATE.READER, vtu_path)
+    vtu.update_vtu_reader(CTXT.READER, vtu_path)
 
     # read dat file content
     dat_file_content = read_dat_file(STATE.DAT_NAME, STATE.DAT_LINES)
@@ -754,10 +736,9 @@ def click_convert_button():
     # flush state: force push server changes
     STATE.flush()
 
-    # it is not required to update the actor_cond point size
-    STATE.VTU_SPHERE.SetRadius(
-        vtu.get_length_scale_rendered_object(STATE.READER) / 50.0
-    )
+
+    # update render window (manual scaling of various elements)
+    vtu.update_vtu_render_window(CTXT.READER, CTXT.VTU_SPHERE, CTXT.VTU_GLOBAL_COS, SERVER)
 
     CTRL.VIEW_RESET_CAMERA()
     CTRL.VIEW_UPDATE()

src/fourc_webviewer/vturender.py

@@ -1,10 +1,10 @@
-## VTK
+"""Import modules"""
 # import of vtk modules for the vtk pipelines
 from vtkmodules.vtkCommonDataModel import vtkDataObject
 from vtkmodules.vtkCommonCore import vtkLookupTable
 from vtkmodules.vtkFiltersSources import vtkSphereSource
 from vtkmodules.vtkIOXML import vtkXMLUnstructuredGridReader
-from vtkmodules.vtkRenderingAnnotation import vtkCubeAxesActor
+from vtkmodules.vtkRenderingAnnotation import vtkAxesActor
 from vtkmodules.vtkFiltersCore import (
     vtkThreshold,
     vtkThresholdPoints,
@@ -17,7 +17,6 @@
     vtkRenderWindowInteractor,
 )
 
-
 # import required modules for interactor
 from vtkmodules.vtkInteractionStyle import vtkInteractorStyleSwitch  # noqa
 
@@ -26,7 +25,16 @@
 # import colors for vtk visualization
 from vtkmodules.vtkCommonColor import vtkNamedColors
 
+import re
+import math
+
+"""Global variables"""
+vtu_global_cos_frac_scale_ = 1.0 / 5.0 # factor which scales the coordinate system axes with respect to the problem length scale
+vtu_sphere_frac_scale_ = 1.0 / 50.0 # factor which scales the nodal result description with respect to the problem length scale
+vtu_cond_marker_frac_scale_ = 50.0 # factor which scales the condition markers on points, lines, ... with respect to the problem length scale
+
 
+"""VTU objects"""
 def create_vtu_reader():
     return vtkXMLUnstructuredGridReader()
 
@@ -61,13 +69,25 @@ def create_vtu_threshold_points(reader, server_state):
 
 def create_vtu_sphere(reader):
     vtu_sphere = vtkSphereSource()
-    vtu_sphere.SetRadius(get_length_scale_rendered_object(reader) / 50.0)
+
+    # scale using problem length scale
+    vtu_sphere.SetRadius(get_length_scale_rendered_object(reader) * vtu_sphere_frac_scale_)
 
     return vtu_sphere
 
+def create_vtu_global_cos(reader):
+    vtu_global_cos = vtkAxesActor()
+    vtu_global_cos.SetPosition(0,0,0)
+
+    # scale using problem length scale
+    scale_fac = get_length_scale_rendered_object(reader) * vtu_global_cos_frac_scale_
+    vtu_global_cos.SetTotalLength(scale_fac, scale_fac, scale_fac)
+
+    return vtu_global_cos
+
 
 def create_vtu_render_window(
-    reader, vtu_threshold_condition_points, vtu_threshold_mat, vtu_sphere
+    reader, vtu_threshold_condition_points, vtu_threshold_mat, vtu_sphere, vtu_global_cos
 ):
 
     # create renderer
@@ -104,7 +124,7 @@ def create_vtu_render_window(
     actor_cond.SetMapper(mapper_cond)
     actor_cond.GetProperty().SetColor(vtkNamedColors().GetColor3d("LimeGreen"))
     actor_cond.GetProperty().SetPointSize(
-        get_length_scale_rendered_object(reader) * 50.0
+        get_length_scale_rendered_object(reader) * vtu_cond_marker_frac_scale_
     )
     actor_cond.GetProperty().SetOpacity(1.0)
 
@@ -120,41 +140,74 @@ def create_vtu_render_window(
     renderer.AddActor(actor_mat)
     renderer.AddActor(actor_cond)
     renderer.AddActor(actor_res_descr)
+    renderer.AddActor(vtu_global_cos)
     renderer.SetBackground(vtkNamedColors().GetColor3d("White"))
     renderer.ResetCamera()
 
     return renderWindow
 
-
+"""Update functions"""
 def update_vtu_reader(vtu_reader, vtu_file_path):
     # This function updates a given vtu reader with the corresponding vtu file path
     vtu_reader.SetFileName(vtu_file_path)
     vtu_reader.Update()
 
+def update_vtu_render_window(reader, sphere, global_cos, server):
+    """Perform manual scaling of several render window objects.
+
+    This is required, since some of the independent components, such as the vtkSphereSource,
+    do not scale directly with our problem size.
+
+    Args:
+        reader (vtkXMLUnstructuredGridReader): grid reader
+        sphere (vtkSphereSource): sphere used for the depiction of nodes with prescribed results
+        global_cos (vtkAxesActor): global coordinate system
+        server (trame server): server object of the application
+
+    Returns:
+        None 
+    """ 
+
+
+    ###   we need to update the vtkSphere, since it does not scale automatically with the new view
+    # check if the line contains the marker "NODE"
+    if len(re.findall("NODE", server.state.SELECTED_RESULT_DESCR)) > 0:
+        # get the specified node
+        result_descr_components = server.state.SELECTED_RESULT_DESCR.split(" ")
+        node_index = (
+            int(result_descr_components[result_descr_components.index("NODE") + 1]) - 1
+        )
+
+        # update graphic representation
+        node_coords = reader.GetOutput().GetPoints().GetPoint(node_index)
+        sphere.SetCenter(node_coords[0], node_coords[1], node_coords[2])
+        # it is not required to update the actor_cond point size
+        sphere.SetRadius(
+            get_length_scale_rendered_object(reader) * vtu_sphere_frac_scale_
+        )   
+
+        # update the vtk figure
+        server.controller.VIEW_UPDATE()
+
+    ### we also need to update the axes lengths of the global COS
+    scale_fac = get_length_scale_rendered_object(reader) * vtu_global_cos_frac_scale_
+    global_cos.SetTotalLength(scale_fac, scale_fac, scale_fac)
+
+
 
 def get_length_scale_rendered_object(reader):
-    # The function is used to extract a geometric length scale for the problem, which is used in the rendering process (e.g. to define the radius of the sphere source object representing the nodes in the "RESULT DESCRIPTION" section)
-    #   Output:
-    #       length_scale: maximum of the domain bound deltas [max_x-min_x, max_y-min_y, max_z-min_z]
-
-    all_point_coords = [
-        [
-            reader.GetOutput().GetPoints().GetPoint(point_index)[0]
-            for point_index in range(reader.GetOutput().GetPoints().GetNumberOfPoints())
-        ],
-        [
-            reader.GetOutput().GetPoints().GetPoint(point_index)[1]
-            for point_index in range(reader.GetOutput().GetPoints().GetNumberOfPoints())
-        ],
-        [
-            reader.GetOutput().GetPoints().GetPoint(point_index)[2]
-            for point_index in range(reader.GetOutput().GetPoints().GetNumberOfPoints())
-        ],
-    ]
-    return max(
-        [
-            max(all_point_coords[0]) - min(all_point_coords[0]),
-            max(all_point_coords[1]) - min(all_point_coords[1]),
-            max(all_point_coords[2]) - min(all_point_coords[2]),
-        ]
-    )
+    """Compute problem length scale from the bounds of the considered object.
+
+    Args:
+        reader (vtkXMLUnstructuredGridReader): grid reader
+    Returns:
+        float: maximum coordinate bound difference in 3-dimensions 
+
+    """
+
+    # get object bounds
+    bounds = reader.GetOutput().GetBounds()
+
+    # get maximum bound difference as the problem length scale
+    return max(bounds[1]-bounds[0], bounds[3]-bounds[2], bounds[5]-bounds[4])
+