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

ansys/pyensight/core/locallauncher.py

@@ -12,6 +12,7 @@ import glob
 import logging
 import os.path
 import platform
+import re
 import shutil
 import subprocess
 import tempfile
@@ -20,6 +21,7 @@ from typing import Optional
 import uuid
 
 import ansys.pyensight.core as pyensight
+from ansys.pyensight.core.common import find_unused_ports
 from ansys.pyensight.core.launcher import Launcher
 import ansys.pyensight.core.session
 
@@ -56,6 +58,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
     --------
@@ -87,6 +91,7 @@ class LocalLauncher(Launcher):
         # launched process ids
         self._ensight_pid = None
         self._websocketserver_pid = None
+        self._webui_pid = None
         # and ports
         self._ports = None
         # Are we running the instance in batch
@@ -97,6 +102,36 @@ class LocalLauncher(Launcher):
         """Type of app to launch. Options are ``ensight`` and ``envision``."""
         return self._application
 
+    def launch_webui(self, cpython, webui_script, popen_common):
+        cmd = [cpython]
+        cmd += [webui_script]
+        version = re.findall(r"nexus(\d+)", webui_script)[0]
+        path_to_webui = self._install_path
+        path_to_webui = os.path.join(
+            path_to_webui, f"nexus{version}", f"ansys{version}", "ensight", "WebUI", "web", "ui"
+        )
+        cmd += ["--server-listen-port", str(self._ports[5])]
+        cmd += ["--server-web-roots", path_to_webui]
+        cmd += ["--ensight-grpc-port", str(self._ports[0])]
+        cmd += ["--ensight-html-port", str(self._ports[2])]
+        cmd += ["--ensight-ws-port", str(self._ports[3])]
+        cmd += ["--ensight-session-directory", self._session_directory]
+        cmd += ["--ensight-secret-key", self._secret_key]
+        if "PYENSIGHT_DEBUG" in os.environ:
+            try:
+                if int(os.environ["PYENSIGHT_DEBUG"]) > 0:
+                    del popen_common["stdout"]
+                    del popen_common["stderr"]
+            except (ValueError, KeyError):
+                pass
+        popen_common["env"].update(
+            {
+                "SIMBA_WEBSERVER_TOKEN": self._secret_key,
+                "FLUENT_WEBSERVER_TOKEN": self._secret_key,
+            }
+        )
+        self._webui_pid = subprocess.Popen(cmd, **popen_common).pid
+
     def start(self) -> "pyensight.Session":
         """Start an EnSight session using the local EnSight installation.
 
@@ -124,7 +159,10 @@ class LocalLauncher(Launcher):
 
             # gRPC port, VNC port, websocketserver ws, websocketserver html
             to_avoid = self._find_ports_used_by_other_pyensight_and_ensight()
-            self._ports = self._find_unused_ports(5, avoid=to_avoid)
+            num_ports = 5
+            if self._launch_webui:
+                num_ports = 6
+            self._ports = find_unused_ports(num_ports, avoid=to_avoid)
             if self._ports is None:
                 raise RuntimeError("Unable to allocate local ports for EnSight session")
             is_windows = self._is_windows()
@@ -154,6 +192,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()
 
@@ -207,11 +247,12 @@ class LocalLauncher(Launcher):
             except Exception:
                 pass
             websocket_script = found_scripts[idx]
-
+            webui_script = websocket_script.replace("websocketserver.py", "webui_launcher.py")
             # build the commandline
             cmd = [os.path.join(self._install_path, "bin", "cpython"), websocket_script]
             if is_windows:
                 cmd[0] += ".bat"
+            ensight_python = cmd[0]
             cmd.extend(["--http_directory", self.session_directory])
             # http port
             cmd.extend(["--http_port", str(self._ports[2])])
@@ -252,9 +293,13 @@ class LocalLauncher(Launcher):
             timeout=self._timeout,
             sos=use_sos,
             rest_api=self._enable_rest_api,
+            webui_port=self._ports[5] if self._launch_webui else None,
         )
         session.launcher = self
         self._sessions.append(session)
+
+        if self._launch_webui:
+            self.launch_webui(ensight_python, webui_script, popen_common)
         return session
 
     def stop(self) -> None:

ansys/pyensight/core/renderable.py

@@ -3,10 +3,12 @@
 This module provides the interface for creating objects in the EnSight session
 that can be displayed via HTML over the websocket server interface.
 """
+import hashlib
 import os
 import shutil
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, no_type_check
 import uuid
+import warnings
 import webbrowser
 
 import requests
@@ -812,3 +814,31 @@ class RenderableSGEO(Renderable):  # pragma: no cover
         html = html.replace("REVURL_ITEMID", revision_uri)
         html = html.replace("ITEMID", self._guid)
         return html
+
+
+class RenderableFluidsWebUI(Renderable):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._session.ensight_version_check("2025 R1")
+        warnings.warn("The webUI is still under active development and should be considered beta.")
+        self._rendertype = "webui"
+        self._generate_url()
+        self.update()
+
+    def _generate_url(self) -> None:
+        sha256_hash = hashlib.sha256()
+        sha256_hash.update(self._session._secret_key.encode())
+        token = sha256_hash.hexdigest()
+        optional_query = self._get_query_parameters_str()
+        port = self._session._webui_port
+        if "instance_name" in self._session._launcher._get_query_parameters():
+            instance_name = self._session._launcher._get_query_parameters()["instance_name"]
+            # If using PIM, the port needs to be the 443 HTTPS Port;
+            port = self._session.html_port
+            # In the webUI code there's already a workflow to pass down the query parameter
+            # ans_instance_id, just use it
+            instance_name = self._session._launcher._get_query_parameters()["instance_name"]
+            optional_query = f"?ans_instance_id={instance_name}"
+        url = f"{self._http_protocol}://{self._session.html_hostname}:{port}"
+        url += f"{optional_query}#{token}"
+        self._url = url

ansys/pyensight/core/session.py

@@ -31,6 +31,7 @@ from ansys.pyensight.core.listobj import ensobjlist
 from ansys.pyensight.core.renderable import (
     RenderableDeepPixel,
     RenderableEVSN,
+    RenderableFluidsWebUI,
     RenderableImage,
     RenderableMP4,
     RenderableSGEO,
@@ -136,6 +137,7 @@ class Session:
         timeout: float = 120.0,
         rest_api: bool = False,
         sos: bool = False,
+        webui_port: Optional[int] = None,
     ) -> None:
         # every session instance needs a unique name that can be used as a cache key
         self._session_name = str(uuid.uuid1())
@@ -161,6 +163,7 @@ class Session:
         self._grpc_port = grpc_port
         self._halt_ensight_on_close = True
         self._callbacks: Dict[str, Tuple[int, Any]] = dict()
+        self._webui_port = webui_port
         # if the caller passed a session directory we will assume they are
         # creating effectively a proxy Session and create a (stub) launcher
         if session_directory is not None:
@@ -927,6 +930,8 @@ class Session:
         # Undocumented. Available only internally
         elif what == "webensight":
             render = RenderableVNCAngular(self, **kwargs)
+        elif what == "webui":
+            render = RenderableFluidsWebUI(self, **kwargs)
 
         if render is None:
             raise RuntimeError("Unable to generate requested visualization")
@@ -1064,7 +1069,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