ansys-pyensight-core 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

ansys/pyensight/core/exts/ansys.geometry.serviceui/ansys/geometry/serviceui/extension.py

@@ -0,0 +1,193 @@
+import logging
+from typing import Any, Optional
+from urllib.parse import urlparse
+
+import ansys.geometry.service
+import omni.ext
+import omni.ui as ui
+
+
+class AnsysGeometryServiceUIExtension(omni.ext.IExt):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._window: Any = None
+        self._label_w: Any = None
+        self._logger = logging.getLogger(__name__.rsplit(".", 1)[0])
+        self._grpc = None
+        self._dsg_uri_w = None
+        self._dsg_token_w = None
+        self._omni_uri_w = None
+        self._temporal_w = None
+        self._vrmode_w = None
+        self._normalize_w = None
+        self._time_scale_w = None
+        self._connect_w = None
+        self._update_w = None
+        self._connected = False
+
+    @property
+    def service(self) -> Optional["AnsysGeometryServiceUIExtension"]:
+        return ansys.geometry.service.AnsysGeometryServiceServerExtension.get_instance()
+
+    def info(self, text: str) -> None:
+        self._logger.info(text)
+
+    def warning(self, text: str) -> None:
+        self._logger.warning(text)
+
+    def error(self, text: str) -> None:
+        self._logger.error(text)
+
+    def launch_server(self) -> None:
+        if self.service.is_server_running():
+            return
+        self.service.dsg_uri = self._dsg_uri_w.model.as_string
+        self.service.security_token = self._dsg_token_w.model.as_string
+        self.service.omni_uri = self._omni_uri_w.model.as_string
+        self.service.temporal = self._temporal_w.model.as_bool
+        self.service.vrmode = self._vrmode_w.model.as_bool
+        self.service.normalize_geometry = self._normalize_w.model.as_bool
+        scale = self._time_scale_w.model.as_float
+        if scale <= 0.0:
+            scale = 1.0
+        self.service.time_scale = scale
+        self.service.launch_server()
+        if not self.service.is_server_running():
+            self.error("Failed to launch omniverse service.")
+            return
+
+        # parse the DSG USI
+        parsed = urlparse(self.service.dsg_uri)
+        port = parsed.port
+        host = parsed.hostname
+
+        # make a direct grpc connection to the DSG server
+        from ansys.pyensight.core import ensight_grpc  # pylint: disable=import-outside-toplevel
+
+        self._grpc = ensight_grpc.EnSightGRPC(
+            host=host, port=port, secret_key=self.service.security_token
+        )
+        self._grpc.connect()
+        if not self._grpc.is_connected():
+            self.error(f"Failed to connect to DSG service {host}:{port}")
+            return
+
+        self.info("Connected to DSG service")
+        self._connected = True
+
+    def stop_server(self) -> None:
+        if not self._connected:
+            return
+        self.service.stop_server()
+        self._grpc.shutdown()
+        self._grpc = None
+
+        self.info("Disconnect from DSG service")
+        self._connected = False
+
+    def connect_cb(self) -> None:
+        if self.service is None:
+            self.error("Unable to find ansys.geometry.service instance")
+            return
+        if self._connected:
+            self.stop_server()
+        else:
+            self.launch_server()
+        self.update_ui()
+
+    def update_cb(self) -> None:
+        if not self._connected:
+            self.error("No DSG service connected")
+            return
+        self._grpc.command("import enspyqtgui_int", do_eval=False)
+        update_cmd = "dynamicscenegraph://localhost/client/update"
+        if self._temporal_w.model.as_bool:
+            update_cmd += "?timesteps=1"
+        cmd = f'enspyqtgui_int.dynamic_scene_graph_command("{update_cmd}")'
+        self._grpc.command(cmd, do_eval=False)
+
+    def on_startup(self, ext_id: str) -> None:
+        self.info(f"ANSYS geometry service GUI startup: {ext_id}")
+        if self.service is None:
+            self.error("Unable to find ansys.geometry.service instance")
+        self.build_ui()
+        self.update_ui()
+
+    def update_ui(self) -> None:
+        if self._connected:
+            self._connect_w.text = "Disconnect from DSG Server"
+            self._label_w.text = f"Connected to: {self.service.dsg_uri}"
+        else:
+            self._connect_w.text = "Connect to DSG Server"
+            self._label_w.text = "No connected DSG server"
+        self._update_w.enabled = self._connected
+        self._temporal_w.enabled = True
+        self._vrmode_w.enabled = not self._connected
+        self._normalize_w.enabled = not self._connected
+        self._time_scale_w.enabled = not self._connected
+        self._dsg_uri_w.enabled = not self._connected
+        self._dsg_token_w.enabled = not self._connected
+        self._omni_uri_w.enabled = not self._connected
+
+    def build_ui(self) -> None:
+        self._window = ui.Window("ANSYS Geometry Service")
+        with self._window.frame:
+            with ui.VStack(height=0, spacing=5):
+                self._label_w = ui.Label("No connected DSG server")
+
+                with ui.HStack(spacing=5):
+                    ui.Label("DSG Service URI:", alignment=ui.Alignment.RIGHT_CENTER, width=0)
+                    self._dsg_uri_w = ui.StringField()
+                    self._dsg_uri_w.model.as_string = self.service.dsg_uri
+
+                with ui.HStack(spacing=5):
+                    ui.Label("DSG security code:", alignment=ui.Alignment.RIGHT_CENTER, width=0)
+                    self._dsg_token_w = ui.StringField(password_mode=True)
+                    self._dsg_token_w.model.as_string = self.service.security_token
+
+                with ui.HStack(spacing=5):
+                    ui.Label("Omniverse URI:", alignment=ui.Alignment.RIGHT_CENTER, width=0)
+                    self._omni_uri_w = ui.StringField()
+                    self._omni_uri_w.model.as_string = self.service.omni_uri
+
+                with ui.HStack(spacing=5):
+                    with ui.HStack(spacing=5):
+                        self._temporal_w = ui.CheckBox(width=0)
+                        self._temporal_w.model.set_value(self.service.temporal)
+                        ui.Label("Temporal", alignment=ui.Alignment.LEFT_CENTER)
+
+                    with ui.HStack(spacing=5):
+                        self._vrmode_w = ui.CheckBox(width=0)
+                        self._vrmode_w.model.set_value(self.service.vrmode)
+                        ui.Label("VR Mode", alignment=ui.Alignment.LEFT_CENTER)
+
+                    with ui.HStack(spacing=5):
+                        self._normalize_w = ui.CheckBox(width=0)
+                        self._normalize_w.model.set_value(self.service.normalize_geometry)
+                        ui.Label("Normalize", alignment=ui.Alignment.LEFT_CENTER)
+
+                with ui.HStack(spacing=5):
+                    ui.Label(
+                        "Temporal scaling factor:", alignment=ui.Alignment.RIGHT_CENTER, width=0
+                    )
+                    self._time_scale_w = ui.FloatField()
+                    self._time_scale_w.model.as_float = self.service.time_scale
+
+                with ui.HStack():
+                    self._connect_w = ui.Button("Connect to DSG Server", clicked_fn=self.connect_cb)
+                    self._update_w = ui.Button("Request Update", clicked_fn=self.update_cb)
+
+    def on_shutdown(self) -> None:
+        self.info("ANSYS geometry service shutdown")
+        self.stop_server()
+        self._window = None
+        self._label_w = None
+        self._dsg_uri_w = None
+        self._dsg_token_w = None
+        self._omni_uri_w = None
+        self._temporal_w = None
+        self._vrmode_w = None
+        self._normalize_w = None
+        self._time_scale_w = None
+        self._connect_w = None
+        self._update_w = None

ansys/pyensight/core/exts/ansys.geometry.serviceui/config/extension.toml

@@ -0,0 +1,49 @@
+[package]
+# Semantic Versioning is used: https://semver.org/
+version = "0.8.6"
+
+# Lists people or organizations that are considered the "authors" of the package.
+authors = ["ANSYS"]
+
+# The title and description fields are primarily for displaying extension info in UI
+title = "ANSYS Omniverse Geometry Service GUI"
+description = "A geometry synchronization service that enables export of geometry scenes from ANSYS products to Omniverse."
+
+# Path (relative to the root) or content of readme markdown file for UI.
+readme  = "docs/README.md"
+
+# URL of the extension source repository.
+repository = "https://github.com/ansys/pyensight"
+
+# One of categories for UI.
+category = "simulation"
+
+# Keywords for the extension
+keywords = ["ANSYS", "EnSight", "PyEnSight", "Fluent", "kit"]
+
+# Location of change log file in target (final) folder of extension, relative to the root.
+# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
+changelog = "docs/CHANGELOG.md"
+
+# Preview image and icon. Folder named "data" automatically goes in git lfs (see .gitattributes file).
+# Preview image is shown in "Overview" of Extensions window. Screenshot of an extension might be a good preview image.
+preview_image = "data/preview.png"
+
+# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
+icon = "data/icon.png"
+
+# Use omni.ui to build simple UI
+[dependencies]
+"omni.kit.uiapp" = {}
+"ansys.geometry.service" = {}
+
+# Main python module this extension provides, it will be publicly available as "import ansys.geometry.serviceui".
+[[python.module]]
+name = "ansys.geometry.serviceui"
+
+[[test]]
+# Extra dependencies only to be used during test run
+dependencies = [
+    "omni.kit.ui_test" # UI testing extension
+]
+

ansys/pyensight/core/exts/ansys.geometry.serviceui/docs/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+
+## [0.9.0] - 2024-06-28
+- Initial kit version of ANSYS Geometry Service GUI
+

ansys/pyensight/core/exts/ansys.geometry.serviceui/docs/README.md

@@ -0,0 +1,13 @@
+# ANSYS Omniverse Geometry Service GUI [ansys.geometry.serviceui]
+
+This Omniverse extension is a UI interface to the [ansys.geometry.service]
+kit extension.  It allows an Omniverse application user to connect to
+a running copy of ANSYS EnSight or other application that supports the
+Dynamic Scene Graph gRPC protocol.  The GUI allows for the remote scene
+to be pulled, on request,  into a specified Omniverse location.
+
+
+For more details on this extension see:
+https://ensight.docs.pyansys.com/version/dev/user_guide/omniverse_info.html
+
+

ansys/pyensight/core/exts/ansys.geometry.serviceui/docs/index.rst

@@ -0,0 +1,18 @@
+ansys.geometry.serviceui
+########################
+
+
+.. toctree::
+   :maxdepth: 1
+
+   README
+   CHANGELOG
+
+
+.. automodule::"ansys.geometry.serviceui"
+    :platform: Windows-x86_64, Linux-x86_64
+    :members:
+    :undoc-members:
+    :show-inheritance:
+    :imported-members:
+    :exclude-members: contextmanager

ansys/pyensight/core/launcher.py

@@ -13,10 +13,13 @@ Examples:
 """
 import os.path
 import platform
+import random
+import re
 import socket
 from typing import TYPE_CHECKING, Dict, List, Optional
 import warnings
 
+import psutil
 import requests
 
 if TYPE_CHECKING:
@@ -165,6 +168,38 @@ class Launcher:
         """
         return
 
+    def _find_ports_used_by_other_pyensight_and_ensight(self):
+        """Find ports to avoid when looking for empty ports.
+
+        The ports are found iterating the current processes and
+        looking for PyEnSight/EnSight sessions and their command
+        lines.
+        """
+        pyensight_found = []
+        ensight_found = []
+        for process in psutil.process_iter():
+            try:
+                process_cmdline = process.cmdline()
+            except (psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+            if not process_cmdline:
+                continue
+            if len(process_cmdline) > 1:
+                if "websocketserver.py" in os.path.basename(process_cmdline[1]):
+                    pyensight_found.append(process_cmdline)
+            if any(["ensight" in os.path.basename(x) for x in process_cmdline]):
+                if any([x == "-ports" for x in process_cmdline]):
+                    ensight_found.append(process_cmdline)
+        ports = []
+        for command_line in pyensight_found:
+            for command in command_line:
+                if re.match(r"^\d{4,5}$", command):
+                    ports.append(int(command))
+        for command_line in ensight_found:
+            idx = command_line.index("-ports") + 1
+            ports.append(int(command_line[idx]))
+        return list(set(ports))
+
     @staticmethod
     def _find_unused_ports(count: int, avoid: Optional[List[int]] = None) -> Optional[List[int]]:
         """Find "count" unused ports on the host system
@@ -191,7 +226,7 @@ class Launcher:
         ports = list()
 
         # pick a starting port number
-        start = os.getpid() % 64000
+        start = random.randint(1024, 64000)
         # We will scan for 65530 ports unless end is specified
         port_mod = 65530
         end = start + port_mod - 1

ansys/pyensight/core/locallauncher.py

@@ -123,7 +123,8 @@ class LocalLauncher(Launcher):
             self.session_directory = tempfile.mkdtemp(prefix="pyensight_")
 
             # gRPC port, VNC port, websocketserver ws, websocketserver html
-            self._ports = self._find_unused_ports(4)
+            to_avoid = self._find_ports_used_by_other_pyensight_and_ensight()
+            self._ports = self._find_unused_ports(5, avoid=to_avoid)
             if self._ports is None:
                 raise RuntimeError("Unable to allocate local ports for EnSight session")
             is_windows = self._is_windows()
@@ -152,6 +153,7 @@ class LocalLauncher(Launcher):
             cmd.extend(["-grpc_server", str(self._ports[0])])
             vnc_url = f"vnc://%%3Frfb_port={self._ports[1]}%%26use_auth=0"
             cmd.extend(["-vnc", vnc_url])
+            cmd.extend(["-ports", str(self._ports[4])])
 
             use_egl = self._use_egl()
 

ansys/pyensight/core/utils/dsg_server.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import queue
+import sys
 import threading
 from typing import Any, Dict, List, Optional
 
@@ -94,7 +95,7 @@ class Part(object):
             else:
                 self.tcoords_var_id = None
 
-    def build(self):
+    def nodal_surface_rep(self):
         """
         This function processes the geometry arrays and converts them into nodal representation.
         It will duplicate triangles as needed (to preserve element normals) and will convert
@@ -115,10 +116,8 @@ class Part(object):
         """
         if self.cmd is None:
             return None, None, None, None, None, None
-        if self.conn_lines.size:
-            self.session.log(
-                f"Note: part '{self.cmd.name}' contains lines which are not currently supported."
-            )
+        if self.conn_tris.size == 0:
+            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:
@@ -237,7 +236,7 @@ class Part(object):
             tcoords = tmp
 
         self.session.log(
-            f"Part '{self.cmd.name}' defined: {self.coords.size/3} verts, {self.conn_tris.size/3} tris, {self.conn_lines.size/2} lines."
+            f"Part '{self.cmd.name}' defined: {self.coords.size/3} verts, {self.conn_tris.size/3} tris."
         )
         command = self.cmd
 
@@ -350,6 +349,7 @@ class DSGSession(object):
         verbose: int = 0,
         normalize_geometry: bool = False,
         vrmode: bool = False,
+        time_scale: float = 1.0,
         handler: UpdateHandler = UpdateHandler(),
     ):
         """
@@ -379,6 +379,9 @@ class DSGSession(object):
         vrmode : bool
             If True, do not include the EnSight camera in the generated view group. The default
             is to include the EnSight view in the scene transformations.
+        time_scale : float
+            All DSG protobuffers time values will be multiplied by this factor after
+            being received.  The default is ``1.0``.
         handler : UpdateHandler
             This is an UpdateHandler subclass that is called back when the state of
             a scene transfer changes.  For example, methods are called when the
@@ -395,11 +398,17 @@ class DSGSession(object):
         self._dsg = None
         self._normalize_geometry = normalize_geometry
         self._vrmode = vrmode
+        self._time_scale = time_scale
+        self._time_limits = [
+            sys.float_info.max,
+            -sys.float_info.max,
+        ]  # Min/max across all time steps
         self._mesh_block_count = 0
         self._variables: Dict[int, Any] = dict()
         self._groups: Dict[int, Any] = dict()
         self._part: Part = Part(self)
         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
 
     @property
@@ -438,6 +447,20 @@ class DSGSession(object):
     def part(self) -> Part:
         return self._part
 
+    @property
+    def time_limits(self) -> List:
+        return self._time_limits
+
+    @property
+    def cur_timeline(self) -> List:
+        return self._cur_timeline
+
+    @cur_timeline.setter
+    def cur_timeline(self, timeline: List) -> None:
+        self._cur_timeline = timeline
+        self._time_limits[0] = min(self._time_limits[0], self._cur_timeline[0])
+        self._time_limits[1] = max(self._time_limits[1], self._cur_timeline[1])
+
     @property
     def grpc(self) -> ensight_grpc.EnSightGRPC:
         return self._grpc
@@ -483,7 +506,7 @@ class DSGSession(object):
     def end(self):
         """Stop a gRPC connection to the EnSight instance"""
         self._callback_handler.end_connection()
-        self._grpc.stop_server()
+        self._grpc.shutdown()
         self._shutdown = True
         self._thread.join()
         self._grpc.shutdown()
@@ -515,8 +538,6 @@ class DSGSession(object):
         cmd.init.allow_incremental_updates = False
         cmd.init.maximum_chunk_size = 1024 * 1024
         self._dsg_queue.put(cmd)  # type:ignore
-        # Handle the update messages
-        self.handle_one_update()
 
     def _poll_messages(self) -> None:
         """Core interface to grab DSG events from gRPC and queue them for processing
@@ -626,7 +647,6 @@ class DSGSession(object):
         There is always a part being modified.  This method completes the current part, committing
         it to the handler.
         """
-        self._part.build()
         self._callback_handler.finalize_part(self.part)
         self._mesh_block_count += 1
 
@@ -686,10 +706,15 @@ class DSGSession(object):
         """Handle a DSG UPDATE_VIEW command
 
         Parameters
-        ----------s
+        ----------
         view:
             The command coming from the EnSight stream.
         """
+        self._finish_part()
         self._scene_bounds = None
         self._groups[view.id] = view
+        if len(view.timeline) == 2:
+            view.timeline[0] *= self._time_scale
+            view.timeline[1] *= self._time_scale
+            self.cur_timeline = [view.timeline[0], view.timeline[1]]
         self._callback_handler.add_group(view.id, view=True)