ansys-pyensight-core 0.9.1__py3-none-any.whl → 0.9.2__py3-none-any.whl

ansys/pyensight/core/ensight_grpc.py

@@ -4,6 +4,11 @@ This package defines the EnSightGRPC class which provides a simpler
 interface to the EnSight gRPC interface, including event streams.
 
 """
+from concurrent import futures
+import os
+import platform
+import sys
+import tempfile
 import threading
 from typing import Any, Callable, List, Optional, Tuple, Union
 import uuid
@@ -47,6 +52,14 @@ class EnSightGRPC(object):
         # Callback for events (self._events not used)
         self._event_callback: Optional[Callable] = None
         self._prefix: Optional[str] = None
+        self._shmem_module = None
+        self._shmem_filename: Optional[str] = None
+        self._shmem_client = None
+        self._image_stream = None
+        self._image_thread = None
+        self._image = None
+        self._image_number = 0
+        self._sub_service = None
 
     @property
     def host(self) -> str:
@@ -120,6 +133,12 @@ class EnSightGRPC(object):
             if self._channel:
                 self._channel.close()
             self._channel = None
+            if self._shmem_client:
+                if self._shmem_module:
+                    self._shmem_module.stream_destroy(self._shmem_client)
+                else:
+                    self.command("ensight_grpc_shmem.stream_destroy(enscl._shmem_client)")
+                self._shmem_client = None
 
     def is_connected(self) -> bool:
         """Check to see if the gRPC connection is live
@@ -430,3 +449,286 @@ class EnSightGRPC(object):
             # signal that the gRPC connection has broken
             self._event_stream = None
             self._event_thread = None
+
+    def _attempt_shared_mem_import(self):
+        try:
+            import ensight_grpc_shmem
+
+            self._shmem_module = ensight_grpc_shmem
+        except ModuleNotFoundError:
+            try:
+                self.command("import enve", do_eval=False)
+                cei_home = eval(self.command("enve.home()"))
+                self.command("import ceiversion", do_eval=False)
+                cei_version = eval(self.command("ceiversion.version_suffix"))
+                self.command("import sys", do_eval=False)
+                py_version = eval(self.command("sys.version_info[:3]"))
+                is_win = True if "Win" in platform.system() else False
+                plat = "win64" if is_win else "linux_2.6_64"
+                _lib = "DLLs" if is_win else f"lib/python{py_version[0]}.{py_version[1]}"
+                dll_loc = os.path.join(
+                    cei_home,
+                    f"apex{cei_version}",
+                    "machines",
+                    plat,
+                    f"Python-{py_version[0]}.{py_version[1]}.{py_version[2]}",
+                    _lib,
+                )
+                if os.path.exists(dll_loc):
+                    sys.path.append(dll_loc)
+                    import ensight_grpc_shmem
+
+                    self._shmem_module = ensight_grpc_shmem
+            except ModuleNotFoundError:
+                pass
+
+    @classmethod
+    def _find_filename(cls, size=1024 * 1024 * 25):
+        """Create a file on disk to support shared memory transport.
+
+        A file, 25MB in size, will be created using the pid of the current
+        process to generate the filename. It will be located in a temporary
+        directory.
+        """
+        tempdir = tempfile.mkdtemp(prefix="pyensight_shmem")
+        for i in range(100):
+            filename = os.path.join(tempdir, "shmem_{}.bin".format(os.getpid() + i))
+            if not os.path.exists(filename):
+                try:
+                    tmp = open(filename, "wb")
+                    tmp.write(b"\0" * size)  # 25MB
+                    tmp.close()
+                    return filename
+                except Exception:
+                    pass
+        return None
+
+    def get_image(self):
+        """Retrieve the current EnSight image.
+
+        When any of the image streaming systems is enabled, Python threads will receive the
+        most recent image and store them in this instance.  The frame stored in this instance
+        can be accessed by calling this method
+
+        Returns
+        -------
+        (tuple):
+            A tuple containing a dictionary defining the image binary
+            (pixels=bytearray, width=w, height=h) and the image frame number.
+        """
+        return self._image, self._image_number
+
+    def _start_sub_service(self):
+        """Start a gRPC client service.
+        When the client calls one subscribe_events() or subscribe_images() with the
+        connection set to GRPC, the interface requires the client to start a gRPC server
+        that EnSight will call back to with event/image messages.  This method starts
+        such a gRPC server."""
+        try:
+            if self._sub_service is not None:
+                return
+            self._sub_service = _EnSightSubServicer(parent=self)
+            self._sub_service.start()
+        except Exception:
+            self._sub_service = None
+
+    def subscribe_images(self, flip_vertical=False, use_shmem=True):
+        """Subscribe to an image stream.
+
+        This methond makes a EnSightService::SubscribeImages() gRPC call.  If
+        use_shmem is False, the transport system will be made over gRPC.  It causes
+        EnSight to make a reverse gRPC connection over with gRPC calls with the
+        various images will be made.  If use_shmem is True (the default), the \ref shmem will be used.
+
+        Parameters
+        ---------
+        flip_vertical: bool
+            If True, the image pixels will be flipped over the X axis
+        use_shmem: bool
+            If True, use the shared memory transport, otherwise use reverse gRPC"""
+        self.connect()
+        if use_shmem:
+            try:
+                # we need a shared memory file
+                self._shmem_filename = self._find_filename()
+                if self._shmem_filename is not None:
+                    conn_type = ensight_pb2.SubscribeImageOptions.SHARED_MEM
+                    options = dict(filename=self._shmem_filename)
+                    image_options = ensight_pb2.SubscribeImageOptions(
+                        prefix=self.prefix(),
+                        type=conn_type,
+                        options=options,
+                        flip_vertical=flip_vertical,
+                        chunk=False,
+                    )
+                    _ = self._stub.SubscribeImages(image_options, metadata=self._metadata())
+                    # start the local server
+                    if not self._shmem_module:
+                        self._attempt_shared_mem_import()
+                    if self._shmem_module:
+                        self._shmem_client = self._shmem_module.stream_create(self._shmem_filename)
+                    else:
+                        self.command("import ensight_grpc_shmem", do_eval=False)
+                        to_send = self._shmem_filename.replace("\\", "\\\\")
+                        self.command(
+                            f"enscl._shmem_client = ensight_grpc_shmem.stream_create('{to_send}')",
+                            do_eval=False,
+                        )
+                        if self.command("enscl._shmem_client is not None"):
+                            self._shmem_client = True
+
+                    # turn on the polling thread
+                    self._image_thread = threading.Thread(target=self._poll_images)
+                    self._image_thread.daemon = True
+                    self._image_thread.start()
+                    return
+            except Exception as e:
+                print("Unable to subscribe to an image stream via shared memory: {}".format(str(e)))
+
+        self._start_sub_service()
+        conn_type = ensight_pb2.SubscribeImageOptions.GRPC
+        options = {}
+        if self._sub_service:
+            options = dict(uri=self._sub_service._uri)
+        image_options = ensight_pb2.SubscribeImageOptions(
+            prefix=self.prefix(),
+            type=conn_type,
+            options=options,
+            flip_vertical=flip_vertical,
+            chunk=True,
+        )
+        _ = self._stub.SubscribeImages(image_options, metadata=self._metadata())
+
+    def image_stream_enable(self, flip_vertical=False):
+        """Enable a simple gRPC-based image stream from EnSight.
+
+        This method makes a EnSightService::GetImageStream() gRPC call into EnSight, returning
+        an ensightservice::ImageReply stream.  The method creates a thread to hold this
+        stream open and read new image frames from it.  The thread places the read images
+        in this object.  An external application can retrieve the most recent one using
+        get_image().
+
+        Parameters
+        ----------
+        flip_vertical: bool
+            If True, the image will be flipped over the X axis before being sent from EnSight."""
+        if self._image_stream is not None:
+            return
+        self.connect()
+        self._image_stream = self._stub.GetImageStream(
+            ensight_pb2.ImageStreamRequest(flip_vertical=flip_vertical, chunk=True),
+            metadata=self._metadata(),
+        )
+        self._image_thread = threading.Thread(target=self._poll_images)
+        self._image_thread.daemon = True
+        self._image_thread.start()
+
+    def _put_image(self, the_image):
+        """Store an image on this instance.
+
+        This method is used by threads to store the latest image they receive
+        so it can be accessed by get_image.
+        """
+        self._image = the_image
+        self._image_number += 1
+
+    def image_stream_is_enabled(self):
+        """Check to see if the image stream is enabled.
+
+        If an image stream has been successfully established via image_stream_enable(),
+        then this function returns True.
+
+        Returns
+        -------
+        (bool):
+            True if a ensightservice::ImageReply steam is active
+        """
+        return self._image_stream is not None
+
+    def _poll_images(self):
+        """Handle image streams.
+
+        This method is called by a Python thread to read imagery via the shared memory
+        transport system or the the ensightservice::ImageReply stream.
+        """
+        try:
+            while self._stub is not None:
+                if self._shmem_client:
+                    if self._shmem_module:
+                        img = self._shmem_module.stream_lock(self._shmem_client)
+                    else:
+                        img = self.command("ensight_grpc_shmem.stream_lock(enscl._shmem_client)")
+                    if type(img) is dict:
+                        the_image = dict(
+                            pixels=img["pixeldata"], width=img["width"], height=img["height"]
+                        )
+                        self._put_image(the_image)
+                        if self._shmem_module:
+                            self._shmem_module.stream_unlock(self._shmem_client)
+                        else:
+                            self.command(
+                                "ensight_grpc_shmem.stream_unlock(enscl._shmem_client)",
+                                do_eval=False,
+                            )
+
+                if self._image_stream is not None:
+                    img = self._image_stream.next()
+                    buffer = img.pixels
+
+                    while not img.final:
+                        img = self._image_stream.next()
+                        buffer += img.pixels
+
+                    the_image = dict(pixels=buffer, width=img.width, height=img.height)
+                    self._put_image(the_image)
+        except Exception:
+            # signal that the gRPC connection has broken
+            self._image_stream = None
+            self._image_thread = None
+            self._image = None
+
+
+class _EnSightSubServicer(ensight_pb2_grpc.EnSightSubscriptionServicer):
+    """Internal class handling reverse subscription connections.
+    The EnSight gRPC interface has a mechanism for reversing the gRPC
+    streams called Subscriptions.  Image and event streams can be
+    subscribed to.  In this mode, the client application starts a
+    gRPC server that implements the EnSightSubscription protocol.
+    EnSight will connect back to the client using this protocol and
+    send images/events back to the client as regular (non-stream)
+    rpc calls.  This can be useful in situations where it is difficult
+    keep a long-running stream alive.
+    The EnSightSubServicer class implements a gRPC server for the client application.
+    """
+
+    def __init__(self, parent: Optional["EnSightGRPC"] = None):
+        self._server: Optional["grpc.Server"] = None
+        self._uri: str = ""
+        self._parent = parent
+
+    def PublishEvent(self, request: Any, context: Any) -> "ensight_pb2.GenericResponse":
+        """Publish an event to the remote server."""
+        if self._parent is not None:
+            self._parent._put_event(request)
+        return ensight_pb2.GenericResponse(str="Event Published")
+
+    def PublishImage(self, request_iterator: Any, context: Any) -> "ensight_pb2.GenericResponse":
+        """Publish a single image (possibly in chucks) to the remote server."""
+        img: Any = request_iterator.next()
+        buffer = img.pixels
+        while not img.final:
+            img = request_iterator.next()
+            buffer += img.pixels
+        the_image = dict(pixels=buffer, width=img.width, height=img.height)
+        if self._parent is not None:
+            self._parent._put_image(the_image)
+        return ensight_pb2.GenericResponse(str="Image Published")
+
+    def start(self):
+        """Start the gRPC server to be used for the EnSight Subscription Service."""
+        self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
+        ensight_pb2_grpc.add_EnSightSubscriptionServicer_to_server(self, self._server)
+        # Start the server on localhost with a random port
+        port = self._server.add_insecure_port("localhost:0")
+        self._uri = "localhost:" + str(port)
+        self._server.start()

ansys/pyensight/core/utils/omniverse.py

@@ -6,7 +6,7 @@ import subprocess
 import sys
 import tempfile
 from types import ModuleType
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union
 import uuid
 
 import psutil
@@ -18,6 +18,199 @@ if TYPE_CHECKING:
         from ansys.api.pyensight import ensight_api
 
 
+class OmniverseKitInstance:
+    """Interface to an Omniverse application instance
+
+    Parameters
+    ----------
+    pid : int
+        The process id of the launched instance
+    """
+
+    def __init__(self, pid: int) -> None:
+        self._pid: Optional[int] = pid
+        print("CTOR:", pid)
+
+    def __del__(self) -> None:
+        """Close down the instance on delete"""
+        self.close()
+
+    def close(self) -> None:
+        """Shutdown the Omniverse instance
+
+        If the instance associated with this object is still running,
+        shut it down.
+        """
+        if not self.is_running():
+            return
+        proc = psutil.Process(self._pid)
+        for child in proc.children(recursive=True):
+            if psutil.pid_exists(child.pid):
+                # This can be a race condition, so it is ok if the child is dead already
+                try:
+                    child.kill()
+                except psutil.NoSuchProcess:
+                    pass
+        # Same issue, this process might already be shutting down, so NoSuchProcess is ok.
+        try:
+            proc.kill()
+        except psutil.NoSuchProcess:
+            pass
+        self._pid = None
+
+    def is_running(self) -> bool:
+        """Check if the instance is still running
+
+        Returns
+        -------
+        bool
+            True if the instance is still running.
+        """
+        if not self._pid:
+            return False
+        if psutil.pid_exists(self._pid):
+            return True
+        self._pid = None
+        return False
+
+
+def find_kit_filename(fallback_directory: Optional[str] = None) -> Optional[str]:
+    """
+    Use a combination of the current omniverse application and the information
+    in the local .nvidia-omniverse/config/omniverse.toml file to come up with
+    the pathname of a kit executable suitable for hosting another copy of the
+    ansys.geometry.server kit.
+
+    Returns
+    -------
+    Optional[str]
+        The pathname of a kit executable or None
+
+    """
+    # parse the toml config file for the location of the installed apps
+    try:
+        import tomllib
+    except ModuleNotFoundError:
+        import pip._vendor.tomli as tomllib
+
+    homedir = os.path.expanduser("~")
+    ov_config = os.path.join(homedir, ".nvidia-omniverse", "config", "omniverse.toml")
+    if not os.path.exists(ov_config):
+        return None
+    # read the Omniverse configuration toml file
+    with open(ov_config, "r") as ov_file:
+        ov_data = ov_file.read()
+    config = tomllib.loads(ov_data)
+    appdir = config.get("paths", {}).get("library_root", fallback_directory)
+
+    # If we are running inside an Omniverse app, use that information
+    try:
+        import omni.kit.app
+
+        # get the current application
+        app = omni.kit.app.get_app()
+        app_name = app.get_app_filename().split(".")[-1]
+        app_version = app.get_app_version().split("-")[0]
+        # and where it is installed
+        appdir = os.path.join(appdir, f"{app_name}-{app_version}")
+    except ModuleNotFoundError:
+        # Names should be like: "C:\\Users\\foo\\AppData\\Local\\ov\\pkg\\create-2023.2.3\\launcher.toml"
+        target = None
+        target_version = None
+        for d in glob.glob(os.path.join(appdir, "*", "launcher.toml")):
+            test_dir = os.path.dirname(d)
+            # the name will be something like "create-2023.2.3"
+            name = os.path.basename(test_dir).split("-")
+            if len(name) != 2:
+                continue
+            if name[0] not in ("kit", "create", "view"):
+                continue
+            if (target_version is None) or (name[1] > target_version):
+                target = test_dir
+                target_version = name[1]
+        if target is None:
+            return None
+        appdir = target
+
+    # Windows: 'kit.bat' in '.' or 'kit' followed by 'kit.exe' in '.' or 'kit'
+    # Linux: 'kit.sh' in '.' or 'kit' followed by 'kit' in '.' or 'kit'
+    exe_names = ["kit.sh", "kit"]
+    if sys.platform.startswith("win"):
+        exe_names = ["kit.bat", "kit.exe"]
+
+    # look in 4 places...
+    for dir_name in [appdir, os.path.join(appdir, "kit")]:
+        for exe_name in exe_names:
+            if os.path.exists(os.path.join(dir_name, exe_name)):
+                return os.path.join(dir_name, exe_name)
+
+    return None
+
+
+def launch_kit_instance(
+    kit_path: Optional[str] = None,
+    extension_paths: Optional[List[str]] = None,
+    extensions: Optional[List[str]] = None,
+    cli_options: Optional[List[str]] = None,
+    log_file: Optional[str] = None,
+    log_level: str = "warn",
+) -> "OmniverseKitInstance":
+    """Launch an Omniverse application instance
+
+    Parameters
+    ----------
+    kit_path : Optional[str]
+        The full pathname of to a binary capable of serving as a kit runner.
+    extension_paths : Optional[List[str]]
+        List of directory names to include the in search for kits.
+    extensions : Optional[List[str]]
+        List of kit extensions to be loaded into the launched kit instance.
+    log_file : Optional[str]
+        The name of a text file where the logging information for the instance will be saved.
+    log_level : str
+        The level of the logging information to record: "verbose", "info", "warn", "error", "fatal",
+        the default is "warn".
+
+    Returns
+    -------
+    OmniverseKitInstance
+        The object interface for the launched instance
+
+    Examples
+    --------
+    Run a simple, empty GUI kit instance.
+
+    >>> from ansys.pyensight.core.utils import omniverse
+    >>> ov = omniverse.launch_kit_instance(extensions=['omni.kit.uiapp'])
+
+    """
+    # build the command line
+    if not kit_path:
+        kit_path = find_kit_filename()
+    if not kit_path:
+        raise RuntimeError("Unable to find a suitable Omniverse kit install")
+    cmd = [kit_path]
+    if extension_paths:
+        for path in extension_paths:
+            cmd.extend(["--ext-folder", path])
+    if extensions:
+        for ext in extensions:
+            cmd.extend(["--enable", ext])
+    if cli_options:
+        for opt in cli_options:
+            cmd.append(opt)
+    if log_level not in ("verbose", "info", "warn", "error", "fatal"):
+        raise RuntimeError(f"Invalid logging level: {log_level}")
+    cmd.append(f"--/log/level={log_level}")
+    if log_file:
+        cmd.append(f"--/log/file={log_file}")
+        cmd.append("--/log/enabled=true")
+    # Launch the process
+    env_vars = os.environ.copy()
+    p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, env=env_vars)
+    return OmniverseKitInstance(p.pid)
+
+
 class Omniverse:
     """Provides the ``ensight.utils.omniverse`` interface.
 
@@ -56,79 +249,6 @@ class Omniverse:
         self._interpreter: str = ""
         self._status_filename: str = ""
 
-    @staticmethod
-    def find_kit_filename(fallback_directory: Optional[str] = None) -> Optional[str]:
-        """
-        Use a combination of the current omniverse application and the information
-        in the local .nvidia-omniverse/config/omniverse.toml file to come up with
-        the pathname of a kit executable suitable for hosting another copy of the
-        ansys.geometry.server kit.
-
-        Returns
-        -------
-        Optional[str]
-            The pathname of a kit executable or None
-
-        """
-        # parse the toml config file for the location of the installed apps
-        try:
-            import tomllib
-        except ModuleNotFoundError:
-            import pip._vendor.tomli as tomllib
-
-        homedir = os.path.expanduser("~")
-        ov_config = os.path.join(homedir, ".nvidia-omniverse", "config", "omniverse.toml")
-        if not os.path.exists(ov_config):
-            return None
-        # read the Omniverse configuration toml file
-        with open(ov_config, "r") as ov_file:
-            ov_data = ov_file.read()
-        config = tomllib.loads(ov_data)
-        appdir = config.get("paths", {}).get("library_root", fallback_directory)
-
-        # If we are running inside an Omniverse app, use that information
-        try:
-            import omni.kit.app
-
-            # get the current application
-            app = omni.kit.app.get_app()
-            app_name = app.get_app_filename().split(".")[-1]
-            app_version = app.get_app_version().split("-")[0]
-            # and where it is installed
-            appdir = os.path.join(appdir, f"{app_name}-{app_version}")
-        except ModuleNotFoundError:
-            # Names should be like: "C:\\Users\\foo\\AppData\\Local\\ov\\pkg\\create-2023.2.3\\launcher.toml"
-            target = None
-            target_version = None
-            for d in glob.glob(os.path.join(appdir, "*", "launcher.toml")):
-                test_dir = os.path.dirname(d)
-                # the name will be something like "create-2023.2.3"
-                name = os.path.basename(test_dir).split("-")
-                if len(name) != 2:
-                    continue
-                if name[0] not in ("kit", "create", "view"):
-                    continue
-                if (target_version is None) or (name[1] > target_version):
-                    target = test_dir
-                    target_version = name[1]
-            if target is None:
-                return None
-            appdir = target
-
-        # Windows: 'kit.bat' in '.' or 'kit' followed by 'kit.exe' in '.' or 'kit'
-        # Linux: 'kit.sh' in '.' or 'kit' followed by 'kit' in '.' or 'kit'
-        exe_names = ["kit.sh", "kit"]
-        if sys.platform.startswith("win"):
-            exe_names = ["kit.bat", "kit.exe"]
-
-        # look in 4 places...
-        for dir_name in [appdir, os.path.join(appdir, "kit")]:
-            for exe_name in exe_names:
-                if os.path.exists(os.path.join(dir_name, exe_name)):
-                    return os.path.join(dir_name, exe_name)
-
-        return None
-
     def _check_modules(self) -> None:
         """Verify that the Python interpreter is correct
 
@@ -361,9 +481,15 @@ class Omniverse:
             update_cmd += f"{prefix}timesteps=1"
             prefix = "&"
         if line_width != 0.0:
-            # only in 2025 R2 and beyond
-            if self._ensight._session.ensight_version_check("2025 R2", exception=False):
-                update_cmd += f"{prefix}line_width={line_width}"
+            add_linewidth = False
+            if isinstance(self._ensight, ModuleType):
+                add_linewidth = True
+            else:
+                # only in 2025 R2 and beyond
+                if self._ensight._session.ensight_version_check("2025 R2", exception=False):
+                    add_linewidth = True
+            if add_linewidth:
+                update_cmd += f"{prefix}ANSYS_linewidth={line_width}"
                 prefix = "&"
         self._check_modules()
         if not self.is_running_omniverse():

ansys/pyensight/core/utils/omniverse_cli.py

@@ -78,8 +78,7 @@ class OmniverseGeometryServer(object):
         normalize_geometry: bool = False,
         dsg_uri: str = "",
         monitor_directory: str = "",
-        line_width: float = -0.0001,
-        use_lines: bool = False,
+        line_width: float = 0.0,
     ) -> None:
         self._dsg_uri = dsg_uri
         self._destination = destination
@@ -96,7 +95,6 @@ class OmniverseGeometryServer(object):
         self._status_filename: str = ""
         self._monitor_directory: str = monitor_directory
         self._line_width = line_width
-        self._use_lines = use_lines
 
     @property
     def monitor_directory(self) -> Optional[str]:
@@ -173,6 +171,14 @@ class OmniverseGeometryServer(object):
     def time_scale(self, value: float) -> None:
         self._time_scale = value
 
+    @property
+    def line_width(self) -> float:
+        return self._line_width
+
+    @line_width.setter
+    def line_width(self, line_width: float) -> None:
+        self._line_width = line_width
+
     def run_server(self, one_shot: bool = False) -> None:
         """
         Run a DSG to Omniverse server in process.
@@ -189,11 +195,11 @@ class OmniverseGeometryServer(object):
 
         # Build the Omniverse connection
         omni_link = ov_dsg_server.OmniverseWrapper(
-            destination=self._destination, line_width=self._line_width, use_lines=self._use_lines
+            destination=self._destination, line_width=self.line_width
         )
         logging.info("Omniverse connection established.")
 
-        # parse the DSG USI
+        # parse the DSG URI
         parsed = urlparse(self.dsg_uri)
         port = parsed.port
         host = parsed.hostname
@@ -223,7 +229,10 @@ class OmniverseGeometryServer(object):
 
         # until the link is dropped, continue
         while not dsg_link.is_shutdown() and not self._shutdown:
+            # Reset the line width to the CLI default before each update
+            omni_link.line_width = self.line_width
             dsg_link.handle_one_update()
+
             if one_shot:
                 break
 
@@ -276,7 +285,7 @@ class OmniverseGeometryServer(object):
 
         # Build the Omniverse connection
         omni_link = ov_dsg_server.OmniverseWrapper(
-            destination=self._destination, line_width=self._line_width, use_lines=self._use_lines
+            destination=self._destination, line_width=self.line_width
         )
         logging.info("Omniverse connection established.")
 
@@ -347,6 +356,8 @@ class OmniverseGeometryServer(object):
                             logging.warning("Time values not currently supported.")
                         if len(files_to_process) > 1:
                             logging.warning("Multiple glb files not currently fully supported.")
+                        # Reset the line width to the CLI default before each update
+                        omni_link.line_width = self.line_width
                         # Upload the files
                         glb_link.start_uploads([timeline[0], timeline[-1]])
                         for glb_file, timestamp in zip(files_to_process, file_timestamps):
@@ -463,13 +474,12 @@ if __name__ == "__main__":
             line_default = float(line_default)
         except ValueError:
             line_default = None
-    # Potential future default: -0.0001
     parser.add_argument(
         "--line_width",
         metavar="line_width",
         default=line_default,
         type=float,
-        help=f"Width of lines: >0=absolute size. <0=fraction of diagonal. 0=wireframe. Default: {line_default}",
+        help=f"Width of lines: >0=absolute size. <0=fraction of diagonal. 0=none. Default: {line_default}",
     )
 
     # parse the command line
@@ -492,8 +502,7 @@ if __name__ == "__main__":
     logging.basicConfig(**log_args)  # type: ignore
 
     # size of lines in data units or fraction of bounding box diagonal
-    use_lines = args.line_width is not None
-    line_width = -0.0001
+    line_width = 0.0
     if args.line_width is not None:
         line_width = args.line_width
 
@@ -508,7 +517,6 @@ if __name__ == "__main__":
         vrmode=not args.include_camera,
         temporal=args.temporal,
         line_width=line_width,
-        use_lines=use_lines,
     )
 
     # run the server

ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -41,8 +41,7 @@ class OmniverseWrapper(object):
         self,
         live_edit: bool = False,
         destination: str = "",
-        line_width: float = -0.0001,
-        use_lines: bool = False,
+        line_width: float = 0.0,
     ) -> None:
         self._cleaned_index = 0
         self._cleaned_names: dict = {}
@@ -61,7 +60,6 @@ class OmniverseWrapper(object):
             self.destination = destination
 
         self._line_width = line_width
-        self._use_lines = use_lines
 
     @property
     def destination(self) -> str:
@@ -82,10 +80,6 @@ class OmniverseWrapper(object):
     def line_width(self, line_width: float) -> None:
         self._line_width = line_width
 
-    @property
-    def use_lines(self) -> bool:
-        return self._use_lines
-
     def shutdown(self) -> None:
         """
         Shutdown the connection to Omniverse cleanly.
@@ -582,7 +576,8 @@ class OmniverseWrapper(object):
             pbrShader.CreateInput("specularColor", Sdf.ValueTypeNames.Color3f).Set(color)
 
         material.CreateSurfaceOutput().ConnectToSource(pbrShader.ConnectableAPI(), "surface")
-        UsdShade.MaterialBindingAPI(mesh).Bind(material)
+        mat_binding_api = UsdShade.MaterialBindingAPI.Apply(mesh.GetPrim())
+        mat_binding_api.Bind(material)
 
         return material
 
@@ -639,7 +634,8 @@ class OmniverseWrapper(object):
             cam = geom_cam.GetCamera()
             # LOL, not sure why is might be correct, but so far it seems to work???
             cam.focalLength = camera.fieldofview
-            cam.clippingRange = Gf.Range1f(0.1, 10)
+            dist = (target_pos - cam_pos).GetLength()
+            cam.clippingRange = Gf.Range1f(0.1 * dist, 10.0 * dist)
             look_at = Gf.Matrix4d()
             look_at.SetLookAt(cam_pos, target_pos, up_vec)
             trans_row = look_at.GetRow(3)
@@ -723,14 +719,83 @@ class OmniverseUpdateHandler(UpdateHandler):
         self._group_prims: Dict[int, Any] = dict()
         self._root_prim = None
         self._sent_textures = False
+        self._updated_camera = False
 
     def add_group(self, id: int, view: bool = False) -> None:
         super().add_group(id, view)
         group = self.session.groups[id]
+
         if not view:
+            # Capture changes in line/sphere sizes if it was not set from cli
+            width = self.get_dsg_cmd_attribute(group, "ANSYS_linewidth")
+            if width:
+                try:
+                    self._omni.line_width = float(width)
+                except ValueError:
+                    pass
+
             parent_prim = self._group_prims[group.parent_id]
+            # get the EnSight object type and the transform matrix
             obj_type = self.get_dsg_cmd_attribute(group, "ENS_OBJ_TYPE")
-            matrix = self.group_matrix(group)
+            matrix = group.matrix4x4
+            # Is this a "case" group (it will contain part of the camera view in the matrix)
+            if obj_type == "ENS_CASE":
+                if (not self.session.vrmode) and (not self._updated_camera):
+                    # if in camera mode, we need to update the camera matrix so we can
+                    # use the identity matrix on this group.  The camera should have been
+                    # created in the "view" handler
+                    cam_name = "/Root/Cam"
+                    cam_prim = self._omni._stage.GetPrimAtPath(cam_name)  # type: ignore
+                    geom_cam = UsdGeom.Camera(cam_prim)
+                    # get the camera
+                    cam = geom_cam.GetCamera()
+                    c = cam.transform
+                    m = Gf.Matrix4d(*matrix).GetTranspose()
+                    # move the model transform to the camera transform
+                    cam.transform = c * m.GetInverse()
+                    # set the updated camera
+                    geom_cam.SetFromCamera(cam)
+                    # apply the inverse cam transform to move the center of interest
+                    # from data space to camera space
+                    coi_attr = cam_prim.GetAttribute("omni:kit:centerOfInterest")
+                    if coi_attr.IsValid():
+                        coi_data = coi_attr.Get()
+                        coi_cam = (
+                            Gf.Vec4d(coi_data[0], coi_data[1], coi_data[2], 1.0)
+                            * cam.transform.GetInverse()
+                        )
+                        coi_attr.Set(
+                            Gf.Vec3d(
+                                coi_cam[0] / coi_cam[3],
+                                coi_cam[1] / coi_cam[3],
+                                coi_cam[2] / coi_cam[3],
+                            )
+                        )
+                    # use the camera view by default
+                    self._omni._stage.GetRootLayer().customLayerData = {  # type: ignore
+                        "cameraSettings": {"boundCamera": "/Root/Cam"}
+                    }
+
+                    # We only want to do this once
+                    self._updated_camera = True
+                matrix = [
+                    1.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    1.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    1.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    0.0,
+                    1.0,
+                ]
             prim = self._omni.create_dsg_group(
                 group.name, parent_prim, matrix=matrix, obj_type=obj_type
             )
@@ -801,40 +866,37 @@ class OmniverseUpdateHandler(UpdateHandler):
                     first_timestep=(self.session.cur_timeline[0] == self.session.time_limits[0]),
                     mat_info=mat_info,
                 )
-            if self._omni.use_lines:
-                command, verts, tcoords, var_cmd = part.line_rep()
-                if command is not None:
-                    # If there are no triangle (ideally if these are not hidden line
-                    # edges), then use the base color for the part.  If there are
-                    # triangles, then assume these are hidden line edges and use the
-                    # line_color.
-                    line_color = color
-                    if has_triangles:
-                        line_color = [
-                            part.cmd.line_color[0] * part.cmd.diffuse,
-                            part.cmd.line_color[1] * part.cmd.diffuse,
-                            part.cmd.line_color[2] * part.cmd.diffuse,
-                            part.cmd.line_color[3],
-                        ]
-                    # TODO: texture coordinates on lines are current invalid in OV
-                    var_cmd = None
-                    tcoords = None
-                    # Generate the lines
-                    _ = self._omni.create_dsg_lines(
-                        name,
-                        obj_id,
-                        part.hash,
-                        parent_prim,
-                        verts,
-                        tcoords,
-                        matrix=matrix,
-                        diffuse=line_color,
-                        variable=var_cmd,
-                        timeline=self.session.cur_timeline,
-                        first_timestep=(
-                            self.session.cur_timeline[0] == self.session.time_limits[0]
-                        ),
-                    )
+            command, verts, tcoords, var_cmd = part.line_rep()
+            if command is not None:
+                # If there are no triangle (ideally if these are not hidden line
+                # edges), then use the base color for the part.  If there are
+                # triangles, then assume these are hidden line edges and use the
+                # line_color.
+                line_color = color
+                if has_triangles:
+                    line_color = [
+                        part.cmd.line_color[0] * part.cmd.diffuse,
+                        part.cmd.line_color[1] * part.cmd.diffuse,
+                        part.cmd.line_color[2] * part.cmd.diffuse,
+                        part.cmd.line_color[3],
+                    ]
+                # TODO: texture coordinates on lines are current invalid in OV
+                var_cmd = None
+                tcoords = None
+                # Generate the lines
+                _ = self._omni.create_dsg_lines(
+                    name,
+                    obj_id,
+                    part.hash,
+                    parent_prim,
+                    verts,
+                    tcoords,
+                    matrix=matrix,
+                    diffuse=line_color,
+                    variable=var_cmd,
+                    timeline=self.session.cur_timeline,
+                    first_timestep=(self.session.cur_timeline[0] == self.session.time_limits[0]),
+                )
 
         elif part.cmd.render == part.cmd.NODES:
             command, verts, sizes, colors, var_cmd = part.point_rep()
@@ -875,6 +937,8 @@ class OmniverseUpdateHandler(UpdateHandler):
         # Upload a material to the Omniverse server
         self._omni.uploadMaterial()
         self._sent_textures = False
+        # We want to update the camera a single time within this update
+        self._updated_camera = False
 
     def end_update(self) -> None:
         super().end_update()

ansys/pyensight/core/utils/omniverse_glb_server.py

@@ -132,7 +132,6 @@ class GLBSession(dsg_server.DSGSession):
         """
         mesh = self._gltf.meshes[meshid]
         for prim_idx, prim in enumerate(mesh.primitives):
-            # TODO: line width/point size
             # POINTS, LINES, TRIANGLES, LINE_LOOP, LINE_STRIP, TRIANGLE_STRIP, TRIANGLE_FAN
             mode = prim.mode
             if mode not in (
@@ -147,9 +146,7 @@ class GLBSession(dsg_server.DSGSession):
                 self.warn(f"Unhandled connectivity detected: {mode}.  Geometry skipped.")
                 continue
             glb_materialid = prim.material
-
             line_width = self._callback_handler._omni.line_width
-            # TODO: override from scene extension: ANSYS_linewidth
 
             # GLB Prim -> DSG Part
             part_name = f"{parentname}_prim{prim_idx}_"
@@ -583,7 +580,16 @@ class GLBSession(dsg_server.DSGSession):
                         view_pb.fieldofview = camera.perspective.yfov
                         view_pb.aspectratio = camera.aspectratio.aspectRatio
                 self._handle_update_command(cmd)
-                for node_id in self._gltf.scenes[scene_idx].nodes:
+                # walk the scene nodes RJF
+                scene = self._gltf.scenes[scene_idx]
+                try:
+                    if self._callback_handler._omni.line_width == 0.0:
+                        width = float(scene.extensions["ANSYS_linewidth"]["linewidth"])
+                        self._callback_handler._omni.line_width = width
+                except (KeyError, ValueError):
+                    # in the case where the extension does not exist or is mal-formed
+                    pass
+                for node_id in scene.nodes:
                     self._walk_node(node_id, view_pb.id)
                 self._finish_part()
 
@@ -621,11 +627,22 @@ class GLBSession(dsg_server.DSGSession):
         List[float]
             The computed timeline.
         """
-        # if ANSYS_scene_time is used, time ranges will come from there
-        if "ANSYS_scene_time" in self._gltf.scenes[scene_idx].extensions:
-            return self._gltf.scenes[scene_idx].extensions["ANSYS_scene_time"]
-        # if there is only one scene, then use the input timeline
         num_scenes = len(self._gltf.scenes)
+        # if ANSYS_scene_timevalue is used, time ranges will come from there
+        try:
+            t0 = self._gltf.scenes[scene_idx].extensions["ANSYS_scene_timevalue"]["timevalue"]
+            idx = scene_idx + 1
+            if idx >= num_scenes:
+                idx = scene_idx
+                t1 = self._gltf.scenes[idx].extensions["ANSYS_scene_timevalue"]["timevalue"]
+            else:
+                t1 = t0
+            return [t0, t1]
+        except KeyError:
+            # If we fail due to dictionary key issue, the extension does not exist or is
+            # improperly formatted.
+            pass
+        # if there is only one scene, then use the input timeline
         if num_scenes == 1:
             return input_timeline
         # if the timeline has zero length, we make it the number of scenes

{ansys_pyensight_core-0.9.1.dist-info → ansys_pyensight_core-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ansys-pyensight-core
-Version: 0.9.1
+Version: 0.9.2
 Summary: A python wrapper for Ansys EnSight
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: "ANSYS, Inc." <pyansys.core@ansys.com>

{ansys_pyensight_core-0.9.1.dist-info → ansys_pyensight_core-0.9.2.dist-info}/RECORD

@@ -4,7 +4,7 @@ ansys/pyensight/core/deep_pixel_view.html,sha256=6u4mGOuzJiPze8N8pIKJsEGPv5y6-zb
 ansys/pyensight/core/dockerlauncher.py,sha256=LmgEFEjl0l3D_JaeJu5bbGR28aluHYtzb0-BmrC7ta8,28251
 ansys/pyensight/core/enscontext.py,sha256=GSKkjZt1QEPyHEQ59EEBgKGMik9vjCdR9coR4uX7fEw,12141
 ansys/pyensight/core/enshell_grpc.py,sha256=-OxSdFI_p3DmQnqh1jT_a_aSh_w-EUD2IaWGKxrnyjI,17122
-ansys/pyensight/core/ensight_grpc.py,sha256=0_qv9gUQsWyRSGGtTW84PNNEVegtsCPrnT6oXix-hvc,16415
+ansys/pyensight/core/ensight_grpc.py,sha256=IkntqzHmNzhADZ1VZJtWGpaB3ZlSThcovsbXyliW_Sk,29458
 ansys/pyensight/core/ensobj.py,sha256=uDtM2KHcAwd4hu5pcUYWbSD729ApHGIvuqZhEq8PxTI,18558
 ansys/pyensight/core/launch_ensight.py,sha256=iZJM6GdpzGRDLzrv1V2QZ5veIOpNSB5xPpJUFY7rBuo,10254
 ansys/pyensight/core/launcher.py,sha256=ymwfixwoHO7_c4qOetqccQbZjGT1HjeA7jwPi2JxlmE,10585
@@ -19,10 +19,10 @@ ansys/pyensight/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 ansys/pyensight/core/utils/adr.py,sha256=XslZhlwcrSGzOlnhzprOv3ju_ppxxsWBjCnQL5KiNms,3570
 ansys/pyensight/core/utils/dsg_server.py,sha256=FfiTJ7XsTW3OhI2w7PKMX5SLVoznGgZ6In-Q_wpkggE,45017
 ansys/pyensight/core/utils/export.py,sha256=UAJQcrElo3esQD0CWdxxjMQ8yE1vB4cdAhF33_uZfQw,22605
-ansys/pyensight/core/utils/omniverse.py,sha256=vzPAyPH0cd5fJaeVv3iNPE4shPtuamwEIavq_OBsW48,14716
-ansys/pyensight/core/utils/omniverse_cli.py,sha256=m5TgxHxDVVSqEY4kGss0OwV-aYHDVX076JPwKlx1fp0,20042
-ansys/pyensight/core/utils/omniverse_dsg_server.py,sha256=gW9uQfHmuSYS9VrwI6jkn6BxIfu3MoxUbK7QlN6Cuec,35482
-ansys/pyensight/core/utils/omniverse_glb_server.py,sha256=K-LLXrQsYES19ai6D8BqmxH6PjvGLIqdMVdbaSnfHQA,29118
+ansys/pyensight/core/utils/omniverse.py,sha256=Y16_nXjfymnXpJmddAkqNnVCWGr8RTjHqA6JSNz8GA8,18483
+ansys/pyensight/core/utils/omniverse_cli.py,sha256=aVYu4HsSZBl7A9_xU3DfItNB-hpxCdMPXm_oMAOU_HQ,20261
+ansys/pyensight/core/utils/omniverse_dsg_server.py,sha256=Bnc99LU2216Dk2t8v0rVNH8sJm8pQiYwqkcH1N5zTvE,38384
+ansys/pyensight/core/utils/omniverse_glb_server.py,sha256=gP6NEmrmqB1ALFGGLkNwnIhn7JWHylRvyIb8JbXrbmA,29879
 ansys/pyensight/core/utils/parts.py,sha256=222XFRCjLgH7hho-cK9JrGCg3-KlTf54KIgc7y50sTE,52173
 ansys/pyensight/core/utils/query.py,sha256=OXKDbf1sOTX0sUvtKcp64LhVl-BcrEsE43w8uMxLOYI,19828
 ansys/pyensight/core/utils/readers.py,sha256=cNNzrE5pjy4wpQKWAzIIJfJCSpY3HU43az02f5I3pVU,11968
@@ -30,7 +30,7 @@ ansys/pyensight/core/utils/support.py,sha256=QI3z9ex7zJxjFbkCPba9DWqWgPFIThORqr0
 ansys/pyensight/core/utils/variables.py,sha256=ZUiJdDIeRcowrnLXaJQqGwA0RbrfXhc1s4o4v9A4PiY,95133
 ansys/pyensight/core/utils/views.py,sha256=ZKhJ6vMT7Rdd4bwJ0egMYTV7-D7Q7I19fF2_j_CMQ0o,12489
 ansys/pyensight/core/utils/resources/Materials/000_sky.exr,sha256=xAR1gFd2uxPZDnvgfegdhEhRaqKtZldQDiR_-1rHKO0,8819933
-ansys_pyensight_core-0.9.1.dist-info/LICENSE,sha256=qQWivZ12ETN5l3QxvTARY-QI5eoRRlyHdwLlAj0Bg5I,1089
-ansys_pyensight_core-0.9.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
-ansys_pyensight_core-0.9.1.dist-info/METADATA,sha256=wnkwJoIFTKw7ZiJTeN2_w54IN8wLj2VVO-gF6TfjXVI,12113
-ansys_pyensight_core-0.9.1.dist-info/RECORD,,
+ansys_pyensight_core-0.9.2.dist-info/LICENSE,sha256=qQWivZ12ETN5l3QxvTARY-QI5eoRRlyHdwLlAj0Bg5I,1089
+ansys_pyensight_core-0.9.2.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+ansys_pyensight_core-0.9.2.dist-info/METADATA,sha256=KkO1m505t8Zbu76uwkfORfA33vR2HpHwyros1mwRFvs,12113
+ansys_pyensight_core-0.9.2.dist-info/RECORD,,