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

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
 
@@ -190,6 +310,7 @@ class Omniverse:
         live: bool = True,
         debug_filename: str = "",
         time_scale: float = 1.0,
+        line_width: float = 0.0,
         options: dict = {},
     ) -> None:
         """Ensure that an EnSight dsg -> omniverse server is running
@@ -224,6 +345,9 @@ class Omniverse:
             If the name of a file is provided, it will be used to save logging information on
             the connection between EnSight and Omniverse.  This option is no longer supported,
             but the API remains for backwards compatibility.
+        line_width : float
+            If set, line objects will be represented as "tubes" of the size specified by
+            this factor.  The default is 0.0 and causes lines not to be exported.
         options : dict
             Allows for a fallback for the grpc host/port and the security token.
         """
@@ -259,6 +383,8 @@ class Omniverse:
             cmd.extend(["--normalize_geometry", "true"])
         if time_scale != 1.0:
             cmd.extend(["--time_scale", str(time_scale)])
+        if line_width != 0.0:
+            cmd.extend(["--line_width", str(line_width)])
         if not live:
             cmd.extend(["--oneshot", "1"])
         cmd.extend(["--dsg_uri", dsg_uri])
@@ -336,7 +462,7 @@ class Omniverse:
         self._server_pid = None
         self._new_status_file(new=False)
 
-    def update(self, temporal: bool = False) -> None:
+    def update(self, temporal: bool = False, line_width: float = 0.0) -> None:
         """Update the geometry in Omniverse
 
         Export the current EnSight scene to the current Omniverse connection.
@@ -345,10 +471,26 @@ class Omniverse:
         ----------
         temporal : bool
             If True, export all timesteps.
+        line_width : float
+            If set to a non-zero value, lines will be exported with this thickness.
+            This feature is only available in 2025 R2 and later.
         """
         update_cmd = "dynamicscenegraph://localhost/client/update"
+        prefix = "?"
         if temporal:
-            update_cmd += "?timesteps=1"
+            update_cmd += f"{prefix}timesteps=1"
+            prefix = "&"
+        if line_width != 0.0:
+            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():
             raise RuntimeError("No Omniverse server connection is currently active.")

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()