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

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

ansys/pyensight/core/utils/omniverse_cli.py

@@ -0,0 +1,481 @@
+import argparse
+from functools import partial
+import glob
+import json
+import logging
+import os
+import pathlib
+import time
+from typing import Any, List, Optional
+from urllib.parse import urlparse
+
+import ansys.pyensight.core
+import ansys.pyensight.core.utils.dsg_server as dsg_server
+import ansys.pyensight.core.utils.omniverse_dsg_server as ov_dsg_server
+import ansys.pyensight.core.utils.omniverse_glb_server as ov_glb_server
+
+
+def str2bool_type(v: Any) -> bool:
+    """
+    This function is designed to be a 'type=' filter for an argparse entry returning a boolean.
+    It allows for additional, common alternative strings as booleans.  These include 'yes','no',
+    'true','false','t','f','y','n','1' and '0'.  If the value does not meet the requirements,
+    the function will raise the argparse.ArgumentTypeError exception.
+    :param v: The (potential) boolean argument.
+    :return: The actual boolean value.
+    :raises: argparse.ArgumentTypeError
+    """
+    if isinstance(v, bool):
+        return v
+    if v.lower() in ("yes", "true", "t", "y", "1"):
+        return True
+    elif v.lower() in ("no", "false", "f", "n", "0"):
+        return False
+    else:
+        raise argparse.ArgumentTypeError("Boolean value expected.")
+
+
+def int_range_type(
+    v: Any, min_value: int = 0, max_value: int = 100, allow: Optional[List[int]] = None
+) -> int:
+    """
+    This function is designed to be a 'type=' filter for an argparse entry returning an integer value within
+    a specified range.  If the value does not meet the requirements, the function will raise the
+    argparse.ArgumentTypeError exception.  This function is normally used with functools.partial to bind
+    the minimum and maximum values.  For example:  type=partial(int_range_type, min_value=0, max_value=65535)
+    :param v: The (potential) integer argument.
+    :param min_value: The minimum legal integer value.
+    :param max_value: The maximum legal integer value.
+    :param allow：A list of additional, legal values
+    :return: The validated integer value.
+    :raises: argparse.ArgumentTypeError
+    """
+    try:
+        value = int(v)
+    except ValueError:
+        raise argparse.ArgumentTypeError("Integer value expected.")
+    if allow is None:
+        allow = []
+    if (value >= min_value) and (value <= max_value):
+        return value
+    elif value in allow:
+        return value
+    else:
+        msg = f"Integer value is not in the range [{min_value},{max_value}]"
+        if allow:
+            msg += f" or in the list {allow}"
+        raise argparse.ArgumentTypeError(msg + ".")
+
+
+class OmniverseGeometryServer(object):
+    def __init__(
+        self,
+        security_token: str = "",
+        destination: str = "",
+        temporal: bool = False,
+        vrmode: bool = False,
+        time_scale: float = 1.0,
+        normalize_geometry: bool = False,
+        dsg_uri: str = "",
+        monitor_directory: str = "",
+    ) -> None:
+        self._dsg_uri = dsg_uri
+        self._destination = destination
+        self._security_token = security_token
+        if not self._security_token:
+            self._security_token = os.environ.get("ENSIGHT_SECURITY_TOKEN", "")
+        self._temporal = temporal
+        self._vrmode = vrmode
+        self._time_scale = time_scale
+        self._normalize_geometry = normalize_geometry
+        self._version = "unknown"
+        self._shutdown = False
+        self._server_process = None
+        self._status_filename: str = ""
+        self._monitor_directory: str = monitor_directory
+
+    @property
+    def monitor_directory(self) -> Optional[str]:
+        if self._monitor_directory:
+            return self._monitor_directory
+        # converts "" -> None
+        return None
+
+    @property
+    def pyensight_version(self) -> str:
+        """The ansys.pyensight.core version"""
+        return ansys.pyensight.core.VERSION
+
+    @property
+    def dsg_uri(self) -> str:
+        """The endpoint of a Dynamic Scene Graph service:  grpc://{hostname}:{port}"""
+        return self._dsg_uri
+
+    @dsg_uri.setter
+    def dsg_uri(self, uri: str) -> None:
+        self._dsg_uri = uri
+
+    @property
+    def destination(self) -> str:
+        """The endpoint of an Omniverse Nucleus service:  omniverse://{hostname}/{path}"""
+        return self._destination
+
+    @destination.setter
+    def destination(self, value: str) -> None:
+        self._destination = value
+
+    @property
+    def security_token(self) -> str:
+        """The security token of the DSG service instance."""
+        return self._security_token
+
+    @security_token.setter
+    def security_token(self, value: str) -> None:
+        self._security_token = value
+
+    @property
+    def temporal(self) -> bool:
+        """If True, the DSG update should include all timesteps."""
+        return self._temporal
+
+    @temporal.setter
+    def temporal(self, value: bool) -> None:
+        self._temporal = bool(value)
+
+    @property
+    def vrmode(self) -> bool:
+        """If True, the DSG update should not include camera transforms."""
+        return self._vrmode
+
+    @vrmode.setter
+    def vrmode(self, value: bool) -> None:
+        self._vrmode = bool(value)
+
+    @property
+    def normalize_geometry(self) -> bool:
+        """If True, the DSG geometry should be remapped into normalized space."""
+        return self._normalize_geometry
+
+    @normalize_geometry.setter
+    def normalize_geometry(self, val: bool) -> None:
+        self._normalize_geometry = val
+
+    @property
+    def time_scale(self) -> float:
+        """Value to multiply DSG time values by before passing to Omniverse"""
+        return self._time_scale
+
+    @time_scale.setter
+    def time_scale(self, value: float) -> None:
+        self._time_scale = value
+
+    def run_server(self, one_shot: bool = False) -> None:
+        """
+        Run a DSG to Omniverse server in process.
+
+        Note: this method does not return until the DSG connection is dropped or
+        self.stop_server() has been called.
+
+        Parameters
+        ----------
+        one_shot : bool
+            If True, only run the server to transfer a single scene and
+            then return.
+        """
+
+        # Build the Omniverse connection
+        omni_link = ov_dsg_server.OmniverseWrapper(destination=self._destination)
+        logging.info("Omniverse connection established.")
+
+        # parse the DSG USI
+        parsed = urlparse(self.dsg_uri)
+        port = parsed.port
+        host = parsed.hostname
+
+        # link it to a DSG session
+        update_handler = ov_dsg_server.OmniverseUpdateHandler(omni_link)
+        dsg_link = dsg_server.DSGSession(
+            port=port,
+            host=host,
+            vrmode=self.vrmode,
+            security_code=self.security_token,
+            verbose=1,
+            normalize_geometry=self.normalize_geometry,
+            time_scale=self.time_scale,
+            handler=update_handler,
+        )
+
+        # Start the DSG link
+        logging.info(f"Making DSG connection to: {self.dsg_uri}")
+        err = dsg_link.start()
+        if err < 0:
+            logging.error("Omniverse connection failed.")
+            return
+
+        # Initial pull request
+        dsg_link.request_an_update(animation=self.temporal)
+
+        # until the link is dropped, continue
+        while not dsg_link.is_shutdown() and not self._shutdown:
+            dsg_link.handle_one_update()
+            if one_shot:
+                break
+
+        logging.info("Shutting down DSG connection")
+        dsg_link.end()
+        omni_link.shutdown()
+
+    def run_monitor(self):
+        """
+        Run monitor and upload GLB files to Omniverse in process.  There are two cases:
+
+        1) the "directory name" is actually a .glb file.  In this case, simply push
+        the glb file contents to Omniverse.
+
+        2) If a directory, then we periodically scan the directory for files named "*.upload".
+        If this file is found, there are two cases:
+
+            a) The file is empty.  In this case, for a file named ABC.upload, the file
+            ABC.glb will be read and uploaded before both files are deleted.
+
+            b) The file contains valid json.  In this case, the json object is parsed with
+            the following format (two glb files for the first timestep and one for the second):
+
+                {
+                    "version": 1,
+                    "destination": "",
+                    "files": ["a.glb", "b.glb", "c.glb"],
+                    "times": [0.0, 0.0, 1.0]
+                }
+
+            "times" is optional and defaults to [0*len("files")].  Once processed,
+            all the files referenced in the json and the json file itself are deleted.
+            "omniuri" is optional and defaults to the passed Omniverse path.
+
+            Note: In this mode, the method does not return until a "shutdown" file or
+            an error is encountered.
+
+            TODO: add "push" mechanism to trigger a DSG push from the connected session.  This
+                can be done via the monitor mechanism and used by the Omniverse kit to implement
+                a "pull".
+        """
+        the_dir = self.monitor_directory
+        single_file_upload = False
+        if os.path.isfile(the_dir) and the_dir.lower().endswith(".glb"):
+            single_file_upload = True
+        else:
+            if not os.path.isdir(the_dir):
+                logging.error(f"The monitor directory {the_dir} does not exist.")
+                return
+
+        # Build the Omniverse connection
+        omni_link = ov_dsg_server.OmniverseWrapper(destination=self._destination)
+        logging.info("Omniverse connection established.")
+
+        # use an OmniverseUpdateHandler
+        update_handler = ov_dsg_server.OmniverseUpdateHandler(omni_link)
+
+        # Link it to the GLB file monitoring service
+        glb_link = ov_glb_server.GLBSession(
+            verbose=1,
+            handler=update_handler,
+        )
+        if single_file_upload:
+            start_time = time.time()
+            logging.info(f"Uploading file: {the_dir}.")
+            try:
+                glb_link.upload_file(the_dir)
+            except Exception as error:
+                logging.warning(f"Error uploading file: {the_dir}: {error}")
+            logging.info(f"Uploaded in {(time.time() - start_time):.2f}")
+        else:
+            logging.info(f"Starting file monitoring for {the_dir}.")
+            the_dir_path = pathlib.Path(the_dir)
+            try:
+                stop_file = os.path.join(the_dir, "shutdown")
+                orig_destination = omni_link.destination
+                while not os.path.exists(stop_file):
+                    loop_time = time.time()
+                    files_to_remove = []
+                    for filename in glob.glob(os.path.join(the_dir, "*", "*.upload")):
+                        # reset to the launch URI/directory
+                        omni_link.destination = orig_destination
+                        # Keep track of the files and time values
+                        files_to_remove.append(filename)
+                        files_to_process = []
+                        file_timestamps = []
+                        if os.path.getsize(filename) == 0:
+                            # replace the ".upload" extension with ".glb"
+                            glb_file = os.path.splitext(filename)[0] + ".glb"
+                            if os.path.exists(glb_file):
+                                files_to_process.append(glb_file)
+                                file_timestamps.append(0.0)
+                                files_to_remove.append(glb_file)
+                        else:
+                            # read the .upload file json content
+                            try:
+                                with open(filename, "r") as fp:
+                                    glb_info = json.load(fp)
+                            except Exception:
+                                logging.warning(f"Error reading file: {filename}")
+                                continue
+                            # if specified, set the URI/directory target
+                            omni_link.destination = glb_info.get("destination", orig_destination)
+                            # Get the GLB files to process
+                            the_files = glb_info.get("files", [])
+                            files_to_remove.extend(the_files)
+                            # Times not used for now, but parse them anyway
+                            the_times = glb_info.get("times", [0.0] * len(the_files))
+                            # Validate a few things
+                            if len(the_files) != len(the_times):
+                                logging.warning(
+                                    f"Number of times and files are not the same in: {filename}"
+                                )
+                                continue
+                            if len(set(the_times)) != 1:
+                                logging.warning("Time values not currently supported.")
+                            if len(the_files) > 1:
+                                logging.warning("Multiple glb files not currently fully supported.")
+                            files_to_process.extend(the_files)
+                            # Upload the files
+                            for glb_file in files_to_process:
+                                start_time = time.time()
+                                logging.info(
+                                    f"Uploading file: {glb_file} to {omni_link.destination}."
+                                )
+                                try:
+                                    glb_link.upload_file(glb_file)
+                                except Exception as error:
+                                    logging.warning(f"Error uploading file: {glb_file}: {error}")
+                                logging.info(f"Uploaded in {(time.time() - start_time):%.2f}")
+                    for filename in files_to_remove:
+                        try:
+                            # Only delete the file if it is in the_dir_path
+                            filename_path = pathlib.Path(filename)
+                            if filename_path.is_relative_to(the_dir_path):
+                                os.remove(filename)
+                        except IOError:
+                            pass
+                    if time.time() - loop_time < 0.1:
+                        time.sleep(0.25)
+            except Exception as error:
+                logging.error(f"Error encountered while monitoring: {error}")
+            logging.info("Stopping file monitoring.")
+            os.remove(stop_file)
+
+        omni_link.shutdown()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="PyEnSight Omniverse Geometry Service")
+    parser.add_argument(
+        "destination", default="", type=str, help="The directory to save the USD scene graph into."
+    )
+    parser.add_argument(
+        "--verbose",
+        metavar="verbose_level",
+        default=0,
+        type=partial(int_range_type, min_value=0, max_value=3),
+        help="Enable logging information (0-3).  Default: 0",
+    )
+    parser.add_argument(
+        "--log_file",
+        metavar="log_filename",
+        default="",
+        type=str,
+        help="Save logging output to the named log file instead of stdout.",
+    )
+    parser.add_argument(
+        "--dsg_uri",
+        default="grpc://127.0.0.1:5234",
+        type=str,
+        help="The URI of the EnSight Dynamic Scene Graph server.  Default: grpc://127.0.0.1:5234",
+    )
+    parser.add_argument(
+        "--security_token",
+        metavar="token",
+        default="",
+        type=str,
+        help="Dynamic scene graph API security token.  Default: none",
+    )
+    parser.add_argument(
+        "--monitor_directory",
+        metavar="glb_directory",
+        default="",
+        type=str,
+        help="Monitor specified directory for GLB files to be exported.  Default: none",
+    )
+    parser.add_argument(
+        "--time_scale",
+        metavar="time_scale",
+        default=1.0,
+        type=float,
+        help="Scaling factor to be applied to input time values.  Default: 1.0",
+    )
+    parser.add_argument(
+        "--normalize_geometry",
+        metavar="yes|no|true|false|1|0",
+        default=False,
+        type=str2bool_type,
+        help="Enable mapping of geometry to a normalized Cartesian space. Default: false",
+    )
+    parser.add_argument(
+        "--include_camera",
+        metavar="yes|no|true|false|1|0",
+        default=True,
+        type=str2bool_type,
+        help="Include the camera in the output USD scene graph. Default: true",
+    )
+    parser.add_argument(
+        "--temporal",
+        metavar="yes|no|true|false|1|0",
+        default=False,
+        type=str2bool_type,
+        help="Export a temporal scene graph. Default: false",
+    )
+    parser.add_argument(
+        "--oneshot",
+        metavar="yes|no|true|false|1|0",
+        default=False,
+        type=str2bool_type,
+        help="Convert a single geometry into USD and exit.  Default: false",
+    )
+
+    # parse the command line
+    args = parser.parse_args()
+
+    # set up logging
+    level = logging.ERROR
+    if args.verbose == 1:
+        level = logging.WARN
+    elif args.verbose == 2:
+        level = logging.INFO
+    elif args.verbose == 3:
+        level = logging.DEBUG
+    log_args = dict(format="GeometryService:%(levelname)s:%(message)s", level=level)
+    if args.log_file:
+        log_args["filename"] = args.log_file
+    # start with a clean logging instance
+    while logging.root.hasHandlers():
+        logging.root.removeHandler(logging.root.handlers[0])
+    logging.basicConfig(**log_args)  # type: ignore
+
+    # Build the server object
+    server = OmniverseGeometryServer(
+        destination=args.destination,
+        dsg_uri=args.dsg_uri,
+        security_token=args.security_token,
+        monitor_directory=args.monitor_directory,
+        time_scale=args.time_scale,
+        normalize_geometry=args.normalize_geometry,
+        vrmode=not args.include_camera,
+        temporal=args.temporal,
+    )
+
+    # run the server
+    logging.info("Server startup.")
+    if server.monitor_directory:
+        server.run_monitor()
+    else:
+        server.run_server(one_shot=args.oneshot)
+    logging.info("Server shutdown.")