ansys-pyensight-core 0.9.1__py3-none-any.whl → 0.9.3__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,198 @@ 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
+
+    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 +248,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 +480,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.
@@ -215,6 +209,11 @@ class OmniverseWrapper(object):
             ord(","): "_",
             ord(" "): "_",
             ord("\\"): "_",
+            ord("^"): "_",
+            ord("!"): "_",
+            ord("#"): "_",
+            ord("%"): "_",
+            ord("&"): "_",
         }
         name = name.translate(replacements)
         if name[0].isdigit():
@@ -582,7 +581,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 +639,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 +724,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 +871,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 +942,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()