ansys-pyensight-core 0.8.8__py3-none-any.whl → 0.8.9__py3-none-any.whl

ansys/pyensight/core/dockerlauncher.py

@@ -87,6 +87,9 @@ class DockerLauncher(Launcher):
         Number of EnSight servers to use for SOS (Server of Server) mode.
         This parameter is defined on the parent ``Launcher`` class, where
         the default is ``None``, in which case SOS mode is not used.
+    additional_command_line_options: list, optional
+        Additional command line options to be used to launch EnSight.
+        Arguments that contain spaces are not supported.
 
     Examples
     --------
@@ -504,6 +507,9 @@ class DockerLauncher(Launcher):
 
         vnc_url = "vnc://%%3Frfb_port=1999%%26use_auth=0"
         ensight_args += " -vnc " + vnc_url
+        if self._additional_command_line_options:
+            ensight_args += " "
+            ensight_args += " ".join(self._additional_command_line_options)
 
         logging.debug(f"Starting EnSight with args: {ensight_args}\n")
         ret = self._enshell.start_ensight(ensight_args, ensight_env_vars)

ansys/pyensight/core/launcher.py

@@ -59,7 +59,10 @@ class Launcher:
     enable_rest_api : bool, optional
         Whether to enable the EnSight REST API. The default is ``False``.
         This parameter is supported in EnSight 2024 R1 and later.
-
+    additional_command_line_options: list, optional
+        Additional command line options to be used to launch EnSight.
+        Please note, when using DockerLauncher, arguments that contain spaces
+        are not supported.
     """
 
     def __init__(
@@ -68,6 +71,7 @@ class Launcher:
         use_egl: bool = False,
         use_sos: Optional[int] = None,
         enable_rest_api: bool = False,
+        additional_command_line_options: Optional[List] = None,
     ) -> None:
         self._timeout = timeout
         self._use_egl_param_val: bool = use_egl
@@ -87,6 +91,7 @@ class Launcher:
                 self._egl_env_val = False
         # a dict of any optional launcher specific query parameters for URLs
         self._query_parameters: Dict[str, str] = {}
+        self._additional_command_line_options = additional_command_line_options
 
     @property
     def session_directory(self) -> str:

ansys/pyensight/core/locallauncher.py

@@ -56,6 +56,8 @@ class LocalLauncher(Launcher):
         Number of EnSight servers to use for SOS (Server of Server) mode.
         This parameter is defined on the parent ``Launcher`` class, where
         the default is ``None``, in which case SOS mode is not used.
+    additional_command_line_options: list, optional
+        Additional command line options to be used to launch EnSight.
 
     Examples
     --------
@@ -154,6 +156,8 @@ class LocalLauncher(Launcher):
             vnc_url = f"vnc://%%3Frfb_port={self._ports[1]}%%26use_auth=0"
             cmd.extend(["-vnc", vnc_url])
             cmd.extend(["-ports", str(self._ports[4])])
+            if self._additional_command_line_options:
+                cmd.extend(self._additional_command_line_options)
 
             use_egl = self._use_egl()
 

ansys/pyensight/core/session.py

@@ -1064,7 +1064,7 @@ class Session:
         onlyfiles = [f for f in listdir(_utils_dir) if os.path.isfile(os.path.join(_utils_dir, f))]
         for _basename in onlyfiles:
             # skip over any files with the "_server" in their names
-            if "_server" in _basename:
+            if "_server" in _basename or "_cli" in _basename:
                 continue
             _filename = os.path.join(_utils_dir, _basename)
             try:

ansys/pyensight/core/utils/dsg_server.py

@@ -1,8 +1,11 @@
+import hashlib
+import json
 import logging
 import os
 import queue
 import sys
 import threading
+import time
 from typing import Any, Dict, List, Optional
 
 from ansys.api.pyensight.v0 import dynamic_scene_graph_pb2
@@ -32,9 +35,10 @@ class Part(object):
         self.normals = numpy.array([], dtype="float32")
         self.normals_elem = False
         self.tcoords = numpy.array([], dtype="float32")
-        self.tcoords_var_id: Optional[int] = None
         self.tcoords_elem = False
+        self.node_sizes = numpy.array([], dtype="float32")
         self.cmd: Optional[Any] = None
+        self.hash = hashlib.new("sha256")
         self.reset()
 
     def reset(self, cmd: Any = None) -> None:
@@ -46,6 +50,10 @@ class Part(object):
         self.tcoords = numpy.array([], dtype="float32")
         self.tcoords_var_id = None
         self.tcoords_elem = False
+        self.node_sizes = numpy.array([], dtype="float32")
+        self.hash = hashlib.new("sha256")
+        if cmd is not None:
+            self.hash.update(cmd.hash.encode("utf-8"))
         self.cmd = cmd
 
     def update_geom(self, cmd: dynamic_scene_graph_pb2.UpdateGeom) -> None:
@@ -83,17 +91,25 @@ class Part(object):
         ):
             # Get the variable definition
             if cmd.variable_id in self.session.variables:
-                self.tcoords_var_id = cmd.variable_id
-                self.tcoords_elem = (
-                    cmd.payload_type == dynamic_scene_graph_pb2.UpdateGeom.ELEM_VARIABLE
-                )
-                if self.tcoords.size != cmd.total_array_size:
-                    self.tcoords = numpy.resize(self.tcoords, cmd.total_array_size)
-                self.tcoords[
-                    cmd.chunk_offset : cmd.chunk_offset + len(cmd.flt_array)
-                ] = cmd.flt_array
-            else:
-                self.tcoords_var_id = None
+                if self.cmd.color_variableid == cmd.variable_id:  # type: ignore
+                    # Receive the colorby var values
+                    self.tcoords_elem = (
+                        cmd.payload_type == dynamic_scene_graph_pb2.UpdateGeom.ELEM_VARIABLE
+                    )
+                    if self.tcoords.size != cmd.total_array_size:
+                        self.tcoords = numpy.resize(self.tcoords, cmd.total_array_size)
+                    self.tcoords[
+                        cmd.chunk_offset : cmd.chunk_offset + len(cmd.flt_array)
+                    ] = cmd.flt_array
+                if self.cmd.node_size_variableid == cmd.variable_id:  # type: ignore
+                    # Receive the node size var values
+                    if self.node_sizes.size != cmd.total_array_size:
+                        self.node_sizes = numpy.resize(self.node_sizes, cmd.total_array_size)
+                    self.node_sizes[
+                        cmd.chunk_offset : cmd.chunk_offset + len(cmd.flt_array)
+                    ] = cmd.flt_array
+        # Combine the hashes for the UpdatePart and all UpdateGeom messages
+        self.hash.update(cmd.hash.encode("utf-8"))
 
     def nodal_surface_rep(self):
         """
@@ -120,26 +136,7 @@ class Part(object):
             self.session.log(f"Note: part '{self.cmd.name}' contains no triangles.")
             return None, None, None, None, None, None
         verts = self.coords
-        if self.session.normalize_geometry and self.session.scene_bounds is not None:
-            midx = (self.session.scene_bounds[3] + self.session.scene_bounds[0]) * 0.5
-            midy = (self.session.scene_bounds[4] + self.session.scene_bounds[1]) * 0.5
-            midz = (self.session.scene_bounds[5] + self.session.scene_bounds[2]) * 0.5
-            dx = self.session.scene_bounds[3] - self.session.scene_bounds[0]
-            dy = self.session.scene_bounds[4] - self.session.scene_bounds[1]
-            dz = self.session.scene_bounds[5] - self.session.scene_bounds[2]
-            s = dx
-            if dy > s:
-                s = dy
-            if dz > s:
-                s = dz
-            if s == 0:
-                s = 1.0
-            num_verts = int(verts.size / 3)
-            for i in range(num_verts):
-                j = i * 3
-                verts[j + 0] = (verts[j + 0] - midx) / s
-                verts[j + 1] = (verts[j + 1] - midy) / s
-                verts[j + 2] = (verts[j + 2] - midz) / s
+        self.normalize_verts(verts)
 
         conn = self.conn_tris
         normals = self.normals
@@ -242,6 +239,141 @@ class Part(object):
 
         return command, verts, conn, normals, tcoords, var_cmd
 
+    def normalize_verts(self, verts: numpy.ndarray):
+        """
+        This function scales and translates vertices, so the longest axis in the scene is of
+        length 1.0, and data is centered at the origin
+
+        Returns the scale factor
+        """
+        s = 1.0
+        if self.session.normalize_geometry and self.session.scene_bounds is not None:
+            num_verts = int(verts.size / 3)
+            midx = (self.session.scene_bounds[3] + self.session.scene_bounds[0]) * 0.5
+            midy = (self.session.scene_bounds[4] + self.session.scene_bounds[1]) * 0.5
+            midz = (self.session.scene_bounds[5] + self.session.scene_bounds[2]) * 0.5
+            dx = self.session.scene_bounds[3] - self.session.scene_bounds[0]
+            dy = self.session.scene_bounds[4] - self.session.scene_bounds[1]
+            dz = self.session.scene_bounds[5] - self.session.scene_bounds[2]
+            s = dx
+            if dy > s:
+                s = dy
+            if dz > s:
+                s = dz
+            if s == 0:
+                s = 1.0
+            for i in range(num_verts):
+                j = i * 3
+                verts[j + 0] = (verts[j + 0] - midx) / s
+                verts[j + 1] = (verts[j + 1] - midy) / s
+                verts[j + 2] = (verts[j + 2] - midz) / s
+        return 1.0 / s
+
+    def point_rep(self):
+        """
+        This function processes the geometry arrays and returns values to represent point data
+
+        Returns
+        -------
+        On failure, the method returns None for the first return value.  The returned tuple is:
+
+        (part_command, vertices, sizes, colors, var_command)
+
+        part_command: UPDATE_PART command object
+        vertices: numpy array of per-node coordinates
+        sizes: numpy array of per-node radii
+        colors: numpy array of per-node rgb colors
+        var_command: UPDATE_VARIABLE command object for the variable the colors correspond to, if any
+        """
+        if self.cmd is None:
+            return None, None, None, None, None
+        if self.cmd.render != self.cmd.NODES:
+            # Early out.  Rendering type for this object is a surface rep, not a point rep
+            return None, None, None, None, None
+        verts = self.coords
+        num_verts = int(verts.size / 3)
+        norm_scale = self.normalize_verts(verts)
+
+        # Convert var values in self.tcoords to RGB colors
+        # For now, look up RGB colors.  Planned USD enhancements should allow tex coords instead.
+        colors = None
+        var_cmd = None
+
+        if self.tcoords.size and self.tcoords.size == num_verts:
+            var_dsg_id = self.cmd.color_variableid
+            var_cmd = self.session.variables[var_dsg_id]
+            if len(var_cmd.levels) == 0:
+                self.session.log(
+                    f"Note: Node rep not created for part '{self.cmd.name}'.  It has var values, but a palette with 0 levels."
+                )
+                return None, None, None, None, None
+
+            p_min = None
+            p_max = None
+            for lvl in var_cmd.levels:
+                if (p_min is None) or (p_min > lvl.value):
+                    p_min = lvl.value
+                if (p_max is None) or (p_max < lvl.value):
+                    p_max = lvl.value
+
+            num_texels = int(len(var_cmd.texture) / 4)
+
+            colors = numpy.ndarray((num_verts * 3,), dtype="float32")
+            low_color = [c / 255.0 for c in var_cmd.texture[0:3]]
+            high_color = [
+                c / 255.0 for c in var_cmd.texture[4 * (num_texels - 1) : 4 * (num_texels - 1) + 3]
+            ]
+            if p_min == p_max:
+                # Special case where palette min == palette max
+                mid_color = var_cmd[4 * (num_texels // 2) : 4 * (num_texels // 2) + 3]
+                for idx in range(num_verts):
+                    val = self.tcoords[idx]
+                    if val == p_min:
+                        colors[idx * 3 : idx * 3 + 3] = mid_color
+                    elif val < p_min:
+                        colors[idx * 3 : idx * 3 + 3] = low_color
+                    elif val > p_min:
+                        colors[idx * 3 : idx * 3 + 3] = high_color
+            else:
+                for idx in range(num_verts):
+                    val = self.tcoords[idx]
+                    if val <= p_min:
+                        colors[idx * 3 : idx * 3 + 3] = low_color
+                    else:
+                        pal_pos = (num_texels - 1) * (val - p_min) / (p_max - p_min)
+                        pal_idx, pal_sub = divmod(pal_pos, 1)
+                        pal_idx = int(pal_idx)
+
+                        if pal_idx >= num_texels - 1:
+                            colors[idx * 3 : idx * 3 + 3] = high_color
+                        else:
+                            col0 = var_cmd.texture[pal_idx * 4 : pal_idx * 4 + 3]
+                            col1 = var_cmd.texture[4 + pal_idx * 4 : 4 + pal_idx * 4 + 3]
+                            for ii in range(0, 3):
+                                colors[idx * 3 + ii] = (
+                                    col0[ii] * pal_sub + col1[ii] * (1.0 - pal_sub)
+                                ) / 255.0
+            self.session.log(f"Part '{self.cmd.name}' defined: {self.coords.size/3} points.")
+
+        node_sizes = None
+        if self.node_sizes.size and self.node_sizes.size == num_verts:
+            # Pass out the node sizes if there is a size-by variable
+            node_size_default = self.cmd.node_size_default * norm_scale
+            node_sizes = numpy.ndarray((num_verts,), dtype="float32")
+            for ii in range(0, num_verts):
+                node_sizes[ii] = self.node_sizes[ii] * node_size_default
+        elif norm_scale != 1.0:
+            # Pass out the node sizes if the model is normalized to fit in a unit cube
+            node_size_default = self.cmd.node_size_default * norm_scale
+            node_sizes = numpy.ndarray((num_verts,), dtype="float32")
+            for ii in range(0, num_verts):
+                node_sizes[ii] = node_size_default
+
+        self.session.log(f"Part '{self.cmd.name}' defined: {self.coords.size/3} points.")
+        command = self.cmd
+
+        return command, verts, node_sizes, colors, var_cmd
+
 
 class UpdateHandler(object):
     """
@@ -410,6 +542,9 @@ class DSGSession(object):
         self._scene_bounds: Optional[List] = None
         self._cur_timeline: List = [0.0, 0.0]  # Start/End time for current update
         self._callback_handler.session = self
+        # log any status changes to this file.  external apps will be monitoring
+        self._status_file = os.environ.get("ANSYS_OV_SERVER_STATUS_FILENAME", "")
+        self._status = dict(status="idle", start_time=0.0, processed_buffers=0, total_buffers=0)
 
     @property
     def scene_bounds(self) -> Optional[List]:
@@ -474,6 +609,15 @@ class DSGSession(object):
         if level < self._verbose:
             logging.info(s)
 
+    @staticmethod
+    def warn(s: str) -> None:
+        """Issue a warning to the logging system
+
+        The logging message is mapped to "warn" and cannot be blocked via verbosity
+        checks.
+        """
+        logging.warning(s)
+
     def start(self) -> int:
         """Start a gRPC connection to an EnSight instance
 
@@ -518,6 +662,38 @@ class DSGSession(object):
         """Check the service shutdown request status"""
         return self._shutdown
 
+    def _update_status_file(self, timed: bool = False):
+        """
+        Update the status file contents. The status file will contain the
+        following json object, stored as: self._status
+
+        {
+        'status' : "working|idle",
+        'start_time' : timestamp_of_update_begin,
+        'processed_buffers' : number_of_protobuffers_processed,
+        'total_buffers' : number_of_protobuffers_total,
+        }
+
+        Parameters
+        ----------
+        timed : bool, optional:
+            if True, only update every second.
+
+        """
+        if self._status_file:
+            current_time = time.time()
+            if timed:
+                last_time = self._status.get("last_time", 0.0)
+                if current_time - last_time < 1.0:  # type: ignore
+                    return
+            self._status["last_time"] = current_time
+            try:
+                message = json.dumps(self._status)
+                with open(self._status_file, "w") as status_file:
+                    status_file.write(message)
+            except IOError:
+                pass  # Note failure is expected here in some cases
+
     def request_an_update(self, animation: bool = False, allow_spontaneous: bool = True) -> None:
         """Start a DSG update
         Send a command to the DSG protocol to "init" an update.
@@ -590,12 +766,21 @@ class DSGSession(object):
         self._mesh_block_count = 0  # reset when a new group shows up
         self._callback_handler.begin_update()
 
+        # Update our status
+        self._status = dict(
+            status="working", start_time=time.time(), processed_buffers=1, total_buffers=1
+        )
+        self._update_status_file()
+
         # handle the various commands until UPDATE_SCENE_END
         cmd = self._get_next_message()
         while (cmd is not None) and (
             cmd.command_type != dynamic_scene_graph_pb2.SceneUpdateCommand.UPDATE_SCENE_END
         ):
             self._handle_update_command(cmd)
+            self._status["processed_buffers"] += 1  # type: ignore
+            self._status["total_buffers"] = self._status["processed_buffers"] + self._message_queue.qsize()  # type: ignore
+            self._update_status_file(timed=True)
             cmd = self._get_next_message()
 
         # Flush the last part
@@ -603,6 +788,10 @@ class DSGSession(object):
 
         self._callback_handler.end_update()
 
+        # Update our status
+        self._status = dict(status="idle", start_time=0.0, processed_buffers=0, total_buffers=0)
+        self._update_status_file()
+
     def _handle_update_command(self, cmd: dynamic_scene_graph_pb2.SceneUpdateCommand) -> None:
         """Dispatch out a scene update command to the proper handler
 
@@ -647,10 +836,13 @@ class DSGSession(object):
         There is always a part being modified.  This method completes the current part, committing
         it to the handler.
         """
-        self._callback_handler.finalize_part(self.part)
+        try:
+            self._callback_handler.finalize_part(self.part)
+        except Exception as e:
+            self.warn(f"Error encountered while finalizing part geometry: {str(e)}")
         self._mesh_block_count += 1
 
-    def _handle_part(self, part: Any) -> None:
+    def _handle_part(self, part_cmd: Any) -> None:
         """Handle a DSG UPDATE_PART command
 
         Finish the current part and set up the next part.
@@ -661,7 +853,7 @@ class DSGSession(object):
             The command coming from the EnSight stream.
         """
         self._finish_part()
-        self._part.reset(part)
+        self._part.reset(part_cmd)
 
     def _handle_group(self, group: Any) -> None:
         """Handle a DSG UPDATE_GROUP command

ansys/pyensight/core/utils/omniverse.py

@@ -1,9 +1,13 @@
 import glob
+import json
 import os
+import platform
 import subprocess
 import sys
+import tempfile
 from types import ModuleType
 from typing import TYPE_CHECKING, Optional, Union
+import uuid
 
 import psutil
 
@@ -13,8 +17,6 @@ if TYPE_CHECKING:
     except ImportError:
         from ansys.api.pyensight import ensight_api
 
-import ansys.pyensight.core
-
 
 class Omniverse:
     """Provides the ``ensight.utils.omniverse`` interface.
@@ -52,6 +54,7 @@ class Omniverse:
         self._ensight = interface
         self._server_pid: Optional[int] = None
         self._interpreter: str = ""
+        self._status_filename: str = ""
 
     @staticmethod
     def find_kit_filename(fallback_directory: Optional[str] = None) -> Optional[str]:
@@ -129,10 +132,7 @@ class Omniverse:
     def _check_modules(self) -> None:
         """Verify that the Python interpreter is correct
 
-        Check for omni module. If not present, raise an exception.
-        If pxr is there as well, then we can just use sys.executable.
-        If not, check to see if 'kit.bat' or 'kit.sh' can be found and
-        arrange to use those instead.
+        Check for module dependencies. If not present, raise an exception.
 
         Raises
         ------
@@ -144,11 +144,27 @@ class Omniverse:
         if len(self._interpreter):
             return
 
-        kit_exe = self.find_kit_filename()
-        if kit_exe:
-            self._interpreter = kit_exe
+        # if a module, then we are inside EnSight
+        if isinstance(self._ensight, ModuleType):  # pragma: no cover
+            # in this case, we can just use cpython
+            import ceiversion
+            import enve
+
+            cei_home = os.environ.get("CEI_HOME", enve.home())
+            self._interpreter = os.path.join(cei_home, "bin", f"cpython{ceiversion.apex_suffix}")
+            if platform.system() == "Windows":
+                self._interpreter += ".bat"
             return
-        raise RuntimeError("Unable to detect a copy of the Omniverse kit executable.") from None
+        # Using the python interpreter running this code
+        self._interpreter = sys.executable
+
+        # in the future, these will be part of the pyensight wheel
+        # dependencies, but for now we include this check.
+        try:
+            import pxr  # noqa: F401
+            import pygltflib  # noqa: F401
+        except Exception:
+            raise RuntimeError("Unable to detect omniverse dependencies: usd-core, pygltflib.")
 
     def is_running_omniverse(self) -> bool:
         """Check that an Omniverse connection is active
@@ -228,30 +244,73 @@ class Omniverse:
             port = options.get("port", 12345)
             token = options.get("security", "")
 
-        # Launch the server via the 'ansys.geometry.service' kit
+        # Launch the server via the 'ansys.pyensight.core.utils.omniverse_cli' module
         dsg_uri = f"grpc://{hostname}:{port}"
-        kit_dir = os.path.join(os.path.dirname(ansys.pyensight.core.__file__), "exts")
         cmd = [self._interpreter]
-        cmd.extend(["--ext-folder", kit_dir])
-        cmd.extend(["--enable", "ansys.geometry.service"])
+        cmd.extend(["-m", "ansys.pyensight.core.utils.omniverse_cli"])
+        cmd.append(omniverse_path)
         if token:
-            cmd.append(f"--/exts/ansys.geometry.service/securityCode={token}")
+            cmd.extend(["--security_token", token])
         if temporal:
-            cmd.append("--/exts/ansys.geometry.service/temporal=1")
+            cmd.extend(["--temporal", "true"])
         if not include_camera:
-            cmd.append("--/exts/ansys.geometry.service/vrmode=1")
+            cmd.extend(["--include_camera", "false"])
         if normalize_geometry:
-            cmd.append("--/exts/ansys.geometry.service/normalizeGeometry=1")
+            cmd.extend(["--normalize_geometry", "true"])
         if time_scale != 1.0:
-            cmd.append(f"--/exts/ansys.geometry.service/timeScale={time_scale}")
-        cmd.append(f"--/exts/ansys.geometry.service/omniUrl={omniverse_path}")
-        cmd.append(f"--/exts/ansys.geometry.service/dsgUrl={dsg_uri}")
-        cmd.append("--/exts/ansys.geometry.service/run=1")
+            cmd.extend(["--time_scale", str(time_scale)])
+        if not live:
+            cmd.extend(["--oneshot", "1"])
+        cmd.extend(["--dsg_uri", dsg_uri])
         env_vars = os.environ.copy()
-        working_dir = os.path.join(os.path.dirname(ansys.pyensight.core.__file__), "utils")
-        process = subprocess.Popen(cmd, close_fds=True, env=env_vars, cwd=working_dir)
+        # we are launching the kit from EnSight or PyEnSight.  In these cases, we
+        # inform the kit instance of:
+        # (1) the name of the "server status" file, if any
+        self._new_status_file()
+        env_vars["ANSYS_OV_SERVER_STATUS_FILENAME"] = self._status_filename
+        process = subprocess.Popen(cmd, close_fds=True, env=env_vars)
         self._server_pid = process.pid
 
+    def _new_status_file(self, new=True) -> None:
+        """
+        Remove any existing status file and create a new one if requested.
+
+        Parameters
+        ----------
+        new : bool
+            If True, create a new status file.
+        """
+        if self._status_filename:
+            try:
+                os.remove(self._status_filename)
+            except OSError:
+                pass
+        self._status_filename = ""
+        if new:
+            self._status_filename = os.path.join(
+                tempfile.gettempdir(), str(uuid.uuid1()) + "_gs_status.txt"
+            )
+
+    def read_status_file(self) -> dict:
+        """Read the status file and return its contents as a dictionary.
+
+        Note: this can fail if the file is being written to when this call is made, so expect
+        failures.
+
+        Returns
+        -------
+        Optional[dict]
+            A dictionary with the fields 'status', 'start_time', 'processed_buffers', 'total_buffers' or empty
+        """
+        if not self._status_filename:
+            return {}
+        try:
+            with open(self._status_filename, "r") as status_file:
+                data = json.load(status_file)
+        except Exception:
+            return {}
+        return data
+
     def close_connection(self) -> None:
         """Shut down the open EnSight dsg -> omniverse server
 
@@ -275,6 +334,7 @@ class Omniverse:
         except psutil.NoSuchProcess:
             pass
         self._server_pid = None
+        self._new_status_file(new=False)
 
     def update(self, temporal: bool = False) -> None:
         """Update the geometry in Omniverse