ansys-pyensight-core 0.10.10__py3-none-any.whl → 0.10.13__py3-none-any.whl

ansys/pyensight/core/dockerlauncher.py

@@ -539,6 +539,9 @@ class DockerLauncher(Launcher):
         # http port
         wss_cmd += " --http_port " + str(self._service_host_port["http"][1])
         # vnc port
+        if int(self._ansys_version) > 252:
+            wss_cmd += " --separate_loops"
+        wss_cmd += f" --security_token {self._secret_key}"
         wss_cmd += " --client_port 1999"
         # optional PIM instance header
         if self._pim_instance is not None:
@@ -598,11 +601,58 @@ class DockerLauncher(Launcher):
 
         return session
 
+    def close(self, session):
+        """Shut down the launched EnSight session.
+
+        This method closes all associated sessions and then stops the
+        launched EnSight instance.
+
+        Parameters
+        ----------
+        session : ``pyensight.Session``
+            Session to close.
+
+        Raises
+        ------
+        RuntimeError
+            If the session was not launched by this launcher.
+
+        """
+        if self._enshell:
+            if self._enshell.is_connected():  # pragma: no cover
+                logging.debug("Killing WSS\n")
+                command = 'pkill -f "websocketserver.py"'
+                kill_env_vars = None
+                container_env_str = ""
+                if self._pim_instance is not None:
+                    container_env = self._get_container_env()
+                    for i in container_env.items():
+                        container_env_str += f"{i[0]}={i[1]}\n"
+                if container_env_str:  # pragma: no cover
+                    kill_env_vars = container_env_str  # pragma: no cover
+                ret = self._enshell.start_other(command, extra_env=kill_env_vars)
+                if ret[0] != 0:  # pragma: no cover
+                    pass
+        return super().close(session)
+
     def stop(self) -> None:
         """Release any additional resources allocated during launching."""
         if self._enshell:
             if self._enshell.is_connected():  # pragma: no cover
                 try:
+                    logging.debug("Killing WSS\n")
+                    command = 'pkill -f "websocketserver.py"'
+                    kill_env_vars = None
+                    container_env_str = ""
+                    if self._pim_instance is not None:
+                        container_env = self._get_container_env()
+                        for i in container_env.items():
+                            container_env_str += f"{i[0]}={i[1]}\n"
+                    if container_env_str:  # pragma: no cover
+                        kill_env_vars = container_env_str  # pragma: no cover
+                    ret = self._enshell.start_other(command, extra_env=kill_env_vars)
+                    if ret[0] != 0:  # pragma: no cover
+                        pass
                     logging.debug("Stopping EnShell.\n")
                     self._enshell.stop_server()
                 except Exception:  # pragma: no cover

ansys/pyensight/core/launcher.py

@@ -186,7 +186,10 @@ class Launcher:
         url = f"http://{session.hostname}:{session.html_port}/v1/stop"
         if session.secret_key:  # pragma: no cover
             url += f"?security_token={session.secret_key}"
-        _ = requests.get(url)
+        try:
+            _ = requests.get(url)
+        except requests.exceptions.ConnectionError:
+            pass
 
         # Stop the launcher instance
         self.stop()

ansys/pyensight/core/locallauncher.py

@@ -24,6 +24,7 @@ import ansys.pyensight.core as pyensight
 from ansys.pyensight.core.common import find_unused_ports
 from ansys.pyensight.core.launcher import Launcher
 import ansys.pyensight.core.session
+import psutil
 
 
 class LocalLauncher(Launcher):
@@ -283,6 +284,9 @@ class LocalLauncher(Launcher):
                 cmd.extend(["--grpc_port", str(self._ports[0])])
             # EnVision sessions
             cmd.extend(["--local_session", "envision", "5"])
+            if int(version) > 252:
+                cmd.append("--separate_loops")
+            cmd.append(["--security_token", self._secret_key])
             # websocket port
             cmd.append(str(self._ports[3]))
             logging.debug(f"Starting WSS: {cmd}\n")
@@ -322,6 +326,38 @@ class LocalLauncher(Launcher):
             self.launch_webui(version, popen_common)
         return session
 
+    @staticmethod
+    def _kill_process_unix(pid):
+        external_kill = ["kill", "-9", str(pid)]
+        process = psutil.Popen(external_kill, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+        process.wait()
+
+    @staticmethod
+    def _kill_process_windows(pid):
+        external_kill = ["taskkill", "/F", "/PID", str(pid)]
+        process = psutil.Popen(external_kill, stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+        process.wait()
+
+    def _kill_process_by_pid(self, pid):
+        if self._is_windows():
+            self._kill_process_windows(pid)
+        else:
+            self._kill_process_unix(pid)
+
+    def _kill_process_tree(self, pid):
+        try:
+            parent = psutil.Process(pid)
+            for child in parent.children(recursive=True):
+                try:
+                    self._kill_process_by_pid(child.pid)
+                    child.kill()
+                except (psutil.AccessDenied, psutil.ZombieProcess, OSError, psutil.NoSuchProcess):
+                    continue
+            self._kill_process_by_pid(parent.pid)
+            parent.kill()
+        except (psutil.AccessDenied, psutil.ZombieProcess, OSError, psutil.NoSuchProcess):
+            pass
+
     def stop(self) -> None:
         """Release any additional resources allocated during launching."""
         maximum_wait_secs = 120.0
@@ -340,6 +376,26 @@ class LocalLauncher(Launcher):
                 raise
         raise RuntimeError(f"Unable to remove {self.session_directory} in {maximum_wait_secs}s")
 
+    def close(self, session):
+        """Shut down the launched EnSight session.
+
+        This method closes all associated sessions and then stops the
+        launched EnSight instance.
+
+        Parameters
+        ----------
+        session : ``pyensight.Session``
+            Session to close.
+
+        Raises
+        ------
+        RuntimeError
+            If the session was not launched by this launcher.
+
+        """
+        self._kill_process_tree(self._websocketserver_pid)
+        return super().close(session)
+
     @staticmethod
     def get_cei_install_directory(ansys_installation: Optional[str]) -> str:
         """Get the Ansys distribution CEI directory to use.

ansys/pyensight/core/utils/omniverse.py

@@ -268,16 +268,26 @@ def find_app(ansys_installation: Optional[str] = None) -> Optional[str]:
     dirs_to_check = []
     if ansys_installation:
         # Given a different Ansys install
-        local_tp = os.path.join(os.path.join(ansys_installation, "tp", "omni_viewer"))
+        local_tp = os.path.join(os.path.join(ansys_installation, "tp", "showcase"))
         if os.path.exists(local_tp):
             dirs_to_check.append(local_tp)
         # Dev Folder
-        local_dev_omni = os.path.join(ansys_installation, "omni_build")
+        omni_platform_dir = "linux-x86_64"
+        if sys.platform.startswith("win"):
+            omni_platform_dir = "windows-x86_64"
+        local_dev_omni = os.path.join(
+            ansys_installation,
+            "omni_build",
+            "kit-app-template",
+            "_build",
+            omni_platform_dir,
+            "release",
+        )
         if os.path.exists(local_dev_omni):
             dirs_to_check.append(local_dev_omni)
     if "PYENSIGHT_ANSYS_INSTALLATION" in os.environ:
         env_inst = os.environ["PYENSIGHT_ANSYS_INSTALLATION"]
-        dirs_to_check.append(os.path.join(env_inst, "tp", "omni_viewer"))
+        dirs_to_check.append(os.path.join(env_inst, "tp", "showcase"))
 
     # Look for most recent Ansys install, 25.2 or later
     awp_roots = []
@@ -286,7 +296,7 @@ def find_app(ansys_installation: Optional[str] = None) -> Optional[str]:
             awp_roots.append(env_name)
     awp_roots.sort(reverse=True)
     for env_name in awp_roots:
-        dirs_to_check.append(os.path.join(os.environ[env_name], "tp", "omni_viewer"))
+        dirs_to_check.append(os.path.join(os.environ[env_name], "tp", "showcase"))
 
     # check all the collected locations in order
     for install_dir in dirs_to_check:

ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -40,8 +40,8 @@ import png
 try:
     from pxr import Gf, Kind, Sdf, Usd, UsdGeom, UsdLux, UsdShade
 except ModuleNotFoundError:
-    if sys.version_info.minor >= 13:
-        warnings.warn("USD Export not supported for Python >= 3.13")
+    if sys.version_info.minor >= 14:
+        warnings.warn("USD Export not supported for Python >= 3.14")
         sys.exit(1)
     is_linux_arm64 = platform.system() == "Linux" and platform.machine() == "aarch64"
     if is_linux_arm64:
@@ -56,13 +56,15 @@ class OmniverseWrapper(object):
         destination: str = "",
         line_width: float = 0.0,
     ) -> None:
+        # File extension.  For debugging, .usda is sometimes helpful.
+        self._ext = ".usd"
         self._cleaned_index = 0
         self._cleaned_names: dict = {}
         self._connectionStatusSubscription = None
         self._stage = None
         self._destinationPath: str = ""
         self._old_stages: list = []
-        self._stagename: str = "dsg_scene.usd"
+        self._stagename: str = "dsg_scene" + self._ext
         self._live_edit: bool = live_edit
         if self._live_edit:
             self._stagename = "dsg_scene.live"
@@ -75,6 +77,9 @@ class OmniverseWrapper(object):
             self.destination = destination
 
         self._line_width = line_width
+        self._centroid: Optional[list] = None
+        # Record the files per timestep, per mesh type.  {part_name: {"surfaces": [], "lines": [], "points": []} }
+        self._time_files: dict = {}
 
     @property
     def destination(self) -> str:
@@ -148,7 +153,8 @@ class OmniverseWrapper(object):
                 else:
                     shutil.rmtree(stage, ignore_errors=True, onerror=None)
             except OSError:
-                stages_unremoved.append(stage)
+                if not stage.endswith("_manifest" + self._ext):
+                    stages_unremoved.append(stage)
         self._old_stages = stages_unremoved
 
     def create_new_stage(self) -> None:
@@ -276,8 +282,74 @@ class OmniverseWrapper(object):
         t = [t[0] * trans_convert, t[1] * trans_convert, t[2] * trans_convert]
         return s, r, t
 
+    # Common code to create the part manifest file and the file per timestep
+    def create_dsg_surfaces_file(
+        self,
+        file_url,  # SdfPath, location on disk
+        part_path: str,  # base path name, such as "/Root/Case_1/Isosurface_part"
+        verts,
+        normals,
+        conn,
+        tcoords,
+        diffuse,
+        variable,
+        mat_info,
+        is_manifest: bool,
+    ):
+        if is_manifest and file_url in self._old_stages:
+            return False
+        if not is_manifest and os.path.exists(file_url):
+            return False
+
+        stage = Usd.Stage.CreateNew(file_url)
+        UsdGeom.SetStageUpAxis(stage, self._up_axis)
+        UsdGeom.SetStageMetersPerUnit(stage, 1.0 / self._units_per_meter)
+        self._old_stages.append(file_url)
+
+        part_prim = stage.OverridePrim(part_path)
+
+        surfaces_prim = self.create_xform_node(stage, part_path + "/surfaces")
+        mesh = UsdGeom.Mesh.Define(stage, str(surfaces_prim.GetPath()) + "/Mesh")
+        mesh.CreateDoubleSidedAttr().Set(True)
+        pt_attr = mesh.CreatePointsAttr()
+        if verts is not None:
+            pt_attr.Set(verts, 0)
+        norm_attr = mesh.CreateNormalsAttr()
+        if normals is not None:
+            norm_attr.Set(normals, 0)
+        fvc_attr = mesh.CreateFaceVertexCountsAttr()
+        fvi_attr = mesh.CreateFaceVertexIndicesAttr()
+        if conn is not None:
+            fvc_attr.Set([3] * (conn.size // 3), 0)
+            fvi_attr.Set(conn, 0)
+
+        primvarsAPI = UsdGeom.PrimvarsAPI(mesh)
+        texCoords = primvarsAPI.CreatePrimvar(
+            "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
+        )
+        texCoords.SetInterpolation("vertex")
+        if tcoords is not None and variable is not None:
+            texCoords.Set(tcoords, 0)
+
+        stage.SetDefaultPrim(part_prim)
+        stage.SetStartTimeCode(0)
+        stage.SetEndTimeCode(0)
+
+        self.create_dsg_material(
+            stage,
+            mesh,
+            str(surfaces_prim.GetPath()),
+            diffuse=diffuse,
+            variable=variable,
+            mat_info=mat_info,
+        )
+
+        stage.Save()
+        return True
+
     def create_dsg_mesh_block(
         self,
+        part: Part,
         name,
         id,
         part_hash,
@@ -293,82 +365,173 @@ class OmniverseWrapper(object):
         first_timestep=False,
         mat_info={},
     ):
+        if self._stage is None:
+            return
+
         # 1D texture map for variables https://graphics.pixar.com/usd/release/tut_simple_shading.html
         # create the part usd object
-        partname = self.clean_name(name + part_hash.hexdigest())
-        stage_name = "/Parts/" + partname + ".usd"
-        part_stage_url = self.stage_url(os.path.join("Parts", partname + ".usd"))
-        part_stage = None
-
-        if not os.path.exists(part_stage_url):
-            part_stage = Usd.Stage.CreateNew(part_stage_url)
-            UsdGeom.SetStageUpAxis(part_stage, self._up_axis)
-            UsdGeom.SetStageMetersPerUnit(part_stage, 1.0 / self._units_per_meter)
-            self._old_stages.append(part_stage_url)
-            xform = UsdGeom.Xform.Define(part_stage, "/" + partname)
-            mesh = UsdGeom.Mesh.Define(part_stage, "/" + partname + "/Mesh")
-            # mesh.CreateDisplayColorAttr()
-            mesh.CreateDoubleSidedAttr().Set(True)
-            mesh.CreatePointsAttr(verts)
-            mesh.CreateNormalsAttr(normals)
-            mesh.CreateFaceVertexCountsAttr([3] * (conn.size // 3))
-            mesh.CreateFaceVertexIndicesAttr(conn)
-            if (tcoords is not None) and variable:
-                primvarsAPI = UsdGeom.PrimvarsAPI(mesh)
-                texCoords = primvarsAPI.CreatePrimvar(
-                    "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
-                )
-                texCoords.Set(tcoords)
-                texCoords.SetInterpolation("vertex")
-            part_prim = part_stage.GetPrimAtPath("/" + partname)
-            part_stage.SetDefaultPrim(part_prim)
-
-            # Currently, this will never happen, but it is a setup for rigid body transforms
-            # At present, the group transforms have been cooked into the vertices so this is not needed
-            matrixOp = xform.AddXformOp(
-                UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
-            )
-            matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
-
-            self.create_dsg_material(
-                part_stage,
-                mesh,
-                "/" + partname,
-                diffuse=diffuse,
-                variable=variable,
-                mat_info=mat_info,
-            )
+        part_base_name = self.clean_name(name)
+        partname = part_base_name + part_hash.hexdigest()
+        stage_name = "/Parts/" + partname + self._ext
+        part_stage_url = self.stage_url(os.path.join("Parts", partname + self._ext))
+
+        # Make the manifest file - once for all timesteps
+        part_manifest_url_relative = "./Parts/" + part_base_name + "_manifest" + self._ext
+        part_manifest_url = self.stage_url(part_manifest_url_relative)
+        created_file = self.create_dsg_surfaces_file(
+            part_manifest_url,
+            str(parent_prim.GetPath()),
+            None,
+            None,
+            None,
+            None,
+            diffuse,
+            variable,
+            mat_info,
+            True,
+        )
+        if created_file:
+            self._stage.GetRootLayer().subLayerPaths.append(part_manifest_url_relative)
+
+        # Make the per-timestep file
+        created_file = self.create_dsg_surfaces_file(
+            part_stage_url,
+            str(parent_prim.GetPath()),
+            verts,
+            normals,
+            conn,
+            tcoords,
+            diffuse,
+            variable,
+            mat_info,
+            False,
+        )
 
-        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
+        # Glue the file into the main stage
+        path = parent_prim.GetPath().AppendChild("surfaces")
+        surfaces_prim = self._stage.OverridePrim(path)
+        self.add_timestep_valueclip(
+            part_base_name,
+            "surfaces",
+            surfaces_prim,
+            part_manifest_url_relative,
+            timeline,
+            stage_name,
+        )
 
-        # glue it into our stage
-        path = timestep_prim.GetPath().AppendChild("part_ref_" + partname)
-        part_ref = self._stage.OverridePrim(path)
-        part_ref.GetReferences().AddReference("." + stage_name)
+        return part_stage_url
 
-        if part_stage is not None:
-            part_stage.GetRootLayer().Save()
+    def get_time_files(self, part_name: str, mesh_type: str):
+        if part_name not in self._time_files:
+            self._time_files[part_name] = {"surfaces": [], "lines": [], "points": []}
+        return self._time_files[part_name][mesh_type]
 
-        return part_stage_url
+    def add_timestep_valueclip(
+        self,
+        part_name: str,
+        mesh_type: str,
+        part_prim: UsdGeom.Xform,
+        manifest_path: str,
+        timeline: List[float],
+        stage_name: str,
+    ) -> None:
+        clips_api = Usd.ClipsAPI(part_prim)
+        asset_path = "." + stage_name
+
+        time_files = self.get_time_files(part_name, mesh_type)
+
+        if len(time_files) == 0 or time_files[-1][0] != asset_path:
+            time_files.append((asset_path, timeline[0]))
+            clips_api.SetClipAssetPaths([time_file[0] for time_file in time_files])
+            clips_api.SetClipActive(
+                [
+                    (time_file[1] * self._time_codes_per_second, ii)
+                    for ii, time_file in enumerate(time_files)
+                ]
+            )
+            clips_api.SetClipTimes(
+                [
+                    (time_file[1] * self._time_codes_per_second, 0)
+                    for ii, time_file in enumerate(time_files)
+                ]
+            )
+            clips_api.SetClipPrimPath(str(part_prim.GetPath()))
+            clips_api.SetClipManifestAssetPath(Sdf.AssetPath(manifest_path))
 
-    def add_timestep_group(
-        self, parent_prim: UsdGeom.Xform, timeline: List[float], first_timestep: bool
-    ) -> UsdGeom.Xform:
-        # add a layer in the group hierarchy for the timestep
-        timestep_group_path = parent_prim.GetPath().AppendChild(
-            self.clean_name("t" + str(timeline[0]), None)
+    # Common code to create the part manifest file and the file per timestep
+    def create_dsg_lines_file(
+        self,
+        file_url,  # SdfPath, location on disk
+        part_path: str,  # base path name, such as "/Root/Case_1/Isosurface_part"
+        verts,
+        width: float,
+        tcoords,
+        diffuse,
+        var_cmd,
+        mat_info,
+        is_manifest: bool,
+    ):
+        if is_manifest and file_url in self._old_stages:
+            return False
+        if not is_manifest and os.path.exists(file_url):
+            return False
+
+        stage = Usd.Stage.CreateNew(file_url)
+        UsdGeom.SetStageUpAxis(stage, self._up_axis)
+        UsdGeom.SetStageMetersPerUnit(stage, 1.0 / self._units_per_meter)
+        self._old_stages.append(file_url)
+
+        part_prim = stage.OverridePrim(part_path)
+
+        lines_prim = self.create_xform_node(stage, part_path + "/lines")
+
+        lines = UsdGeom.BasisCurves.Define(stage, str(lines_prim.GetPath()) + "/Lines")
+        lines.CreateDoubleSidedAttr().Set(True)
+        pt_attr = lines.CreatePointsAttr()
+        vc_attr = lines.CreateCurveVertexCountsAttr()
+        if verts is not None:
+            pt_attr.Set(verts, 0)
+            vc_attr.Set([2] * (verts.size // 6), 0)
+        lines.CreatePurposeAttr().Set("render")
+        lines.CreateTypeAttr().Set("linear")
+        lines.CreateWidthsAttr([width])
+        lines.SetWidthsInterpolation("constant")
+
+        # Rounded endpoint are a primvar
+        primvarsAPI = UsdGeom.PrimvarsAPI(lines)
+        endCaps = primvarsAPI.CreatePrimvar(
+            "endcaps", Sdf.ValueTypeNames.Int, UsdGeom.Tokens.constant
         )
-        timestep_prim = UsdGeom.Xform.Define(self._stage, timestep_group_path)
-        visibility_attr = UsdGeom.Imageable(timestep_prim).GetVisibilityAttr()
-        if first_timestep:
-            visibility_attr.Set("inherited", Usd.TimeCode.EarliestTime())
-        else:
-            visibility_attr.Set("invisible", Usd.TimeCode.EarliestTime())
-        visibility_attr.Set("inherited", timeline[0] * self._time_codes_per_second)
-        # Final timestep has timeline[0]==timeline[1].  Leave final timestep visible.
-        if timeline[0] < timeline[1]:
-            visibility_attr.Set("invisible", timeline[1] * self._time_codes_per_second)
-        return timestep_prim
+        endCaps.Set(2)  # Rounded = 2
+
+        prim = lines.GetPrim()
+        wireframe = width == 0.0
+        prim.CreateAttribute("omni:scene:visualization:drawWireframe", Sdf.ValueTypeNames.Bool).Set(
+            wireframe
+        )
+
+        if (tcoords is not None) and var_cmd:
+            primvarsAPI = UsdGeom.PrimvarsAPI(lines)
+            texCoords = primvarsAPI.CreatePrimvar(
+                "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
+            )
+            if tcoords is not None and var_cmd is not None:
+                texCoords.Set(tcoords, 0)
+            texCoords.SetInterpolation("vertex")
+        stage.SetDefaultPrim(part_prim)
+        stage.SetStartTimeCode(0)
+        stage.SetEndTimeCode(0)
+
+        self.create_dsg_material(
+            stage,
+            lines,
+            str(lines_prim.GetPath()),
+            diffuse=diffuse,
+            variable=var_cmd,
+            mat_info=mat_info,
+        )
+        stage.Save()
+        return True
 
     def create_dsg_lines(
         self,
@@ -389,78 +552,97 @@ class OmniverseWrapper(object):
         # include the line width in the hash
         part_hash.update(str(self.line_width).encode("utf-8"))
 
-        # 1D texture map for variables https://graphics.pixar.com/usd/release/tut_simple_shading.html
-        # create the part usd object
-        partname = self.clean_name(name + part_hash.hexdigest()) + "_l"
-        stage_name = "/Parts/" + partname + ".usd"
-        part_stage_url = self.stage_url(os.path.join("Parts", partname + ".usd"))
-        part_stage = None
-
-        var_cmd = variable
-
-        if not os.path.exists(part_stage_url):
-            part_stage = Usd.Stage.CreateNew(part_stage_url)
-            UsdGeom.SetStageUpAxis(part_stage, self._up_axis)
-            UsdGeom.SetStageMetersPerUnit(part_stage, 1.0 / self._units_per_meter)
-            self._old_stages.append(part_stage_url)
-            xform = UsdGeom.Xform.Define(part_stage, "/" + partname)
-            lines = UsdGeom.BasisCurves.Define(part_stage, "/" + partname + "/Lines")
-            lines.CreateDoubleSidedAttr().Set(True)
-            lines.CreatePointsAttr(verts)
-            lines.CreateCurveVertexCountsAttr([2] * (verts.size // 6))
-            lines.CreatePurposeAttr().Set("render")
-            lines.CreateTypeAttr().Set("linear")
-            lines.CreateWidthsAttr([width])
-            lines.SetWidthsInterpolation("constant")
-            # Rounded endpoint are a primvar
-            primvarsAPI = UsdGeom.PrimvarsAPI(lines)
-            endCaps = primvarsAPI.CreatePrimvar(
-                "endcaps", Sdf.ValueTypeNames.Int, UsdGeom.Tokens.constant
-            )
-            endCaps.Set(2)  # Rounded = 2
-
-            prim = lines.GetPrim()
-            wireframe = width == 0.0
-            prim.CreateAttribute(
-                "omni:scene:visualization:drawWireframe", Sdf.ValueTypeNames.Bool
-            ).Set(wireframe)
-            if (tcoords is not None) and var_cmd:
-                primvarsAPI = UsdGeom.PrimvarsAPI(lines)
-                texCoords = primvarsAPI.CreatePrimvar(
-                    "st", Sdf.ValueTypeNames.TexCoord2fArray, UsdGeom.Tokens.varying
-                )
-                texCoords.Set(tcoords)
-                texCoords.SetInterpolation("vertex")
-            part_prim = part_stage.GetPrimAtPath("/" + partname)
-            part_stage.SetDefaultPrim(part_prim)
-
-            # Currently, this will never happen, but it is a setup for rigid body transforms
-            # At present, the group transforms have been cooked into the vertices so this is not needed
-            matrixOp = xform.AddXformOp(
-                UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
-            )
-            matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
-
-            self.create_dsg_material(
-                part_stage,
-                lines,
-                "/" + partname,
-                diffuse=diffuse,
-                variable=var_cmd,
-                mat_info=mat_info,
-            )
+        part_base_name = self.clean_name(name) + "_l"
+        partname = part_base_name + part_hash.hexdigest()
+        stage_name = "/Parts/" + partname + self._ext
+        part_stage_url = self.stage_url(os.path.join("Parts", partname + self._ext))
+
+        # Make the manifest file - once for all timesteps
+        part_manifest_url_relative = "./Parts/" + part_base_name + "_manifest" + self._ext
+        part_manifest_url = self.stage_url(part_manifest_url_relative)
+        created_file = self.create_dsg_lines_file(
+            part_manifest_url,
+            str(parent_prim.GetPath()),
+            None,
+            width,
+            None,
+            diffuse,
+            variable,
+            mat_info,
+            True,
+        )
+        if created_file:
+            self._stage.GetRootLayer().subLayerPaths.append(part_manifest_url_relative)
+
+        # Make the per-timestep file
+        created_file = self.create_dsg_lines_file(
+            part_stage_url,
+            str(parent_prim.GetPath()),
+            verts,
+            width,
+            tcoords,
+            diffuse,
+            variable,
+            mat_info,
+            False,
+        )
 
-        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
+        # Glue the file into the main stage
+        path = parent_prim.GetPath().AppendChild("lines")
+        lines_prim = self._stage.OverridePrim(path)
+        self.add_timestep_valueclip(
+            part_base_name, "lines", lines_prim, part_manifest_url_relative, timeline, stage_name
+        )
+
+        return part_stage_url
+
+    # Common code to create the part manifest file and the file per timestep
+    def create_dsg_points_file(
+        self,
+        file_url,  # SdfPath, location on disk
+        part_path: str,  # base path name, such as "/Root/Case_1/Isosurface_part"
+        verts,
+        sizes,
+        colors,
+        default_size: float,
+        default_color,
+        is_manifest: bool,
+    ):
+        if is_manifest and file_url in self._old_stages:
+            return False
+        if not is_manifest and os.path.exists(file_url):
+            return False
+
+        stage = Usd.Stage.CreateNew(file_url)
+        UsdGeom.SetStageUpAxis(stage, self._up_axis)
+        UsdGeom.SetStageMetersPerUnit(stage, 1.0 / self._units_per_meter)
+        self._old_stages.append(file_url)
+
+        part_prim = stage.OverridePrim(part_path)
+        points = UsdGeom.Points.Define(stage, part_path + "/points")
+        pt_attr = points.CreatePointsAttr()
+        w_attr = points.CreateWidthsAttr()
+        if verts is not None:
+            pt_attr.Set(verts, 0)
+            if sizes is not None and sizes.size == (verts.size // 3):
+                w_attr.Set(sizes, 0)
+            else:
+                w_attr.Set([default_size] * (verts.size // 3), 0)
 
-        # glue it into our stage
-        path = timestep_prim.GetPath().AppendChild("part_ref_" + partname)
-        part_ref = self._stage.OverridePrim(path)
-        part_ref.GetReferences().AddReference("." + stage_name)
+        colorAttr = points.GetPrim().GetAttribute("primvars:displayColor")
+        colorAttr.SetMetadata("interpolation", "vertex")
+        if verts is not None:
+            if colors is not None and colors.size == verts.size:
+                colorAttr.Set(colors, 0)
+            else:
+                colorAttr.Set([default_color[0:3]] * (verts.size // 3), 0)
 
-        if part_stage is not None:
-            part_stage.GetRootLayer().Save()
+        stage.SetDefaultPrim(part_prim)
+        stage.SetStartTimeCode(0)
+        stage.SetEndTimeCode(0)
 
-        return part_stage_url
+        stage.Save()
+        return True
 
     def create_dsg_points(
         self,
@@ -477,53 +659,45 @@ class OmniverseWrapper(object):
         timeline=[0.0, 0.0],
         first_timestep=False,
     ):
-        # create the part usd object
-        partname = self.clean_name(name + part_hash.hexdigest())
-        stage_name = "/Parts/" + partname + ".usd"
-        part_stage_url = self.stage_url(os.path.join("Parts", partname + ".usd"))
-        part_stage = None
-
-        if not os.path.exists(part_stage_url):
-            part_stage = Usd.Stage.CreateNew(part_stage_url)
-            UsdGeom.SetStageUpAxis(part_stage, self._up_axis)
-            UsdGeom.SetStageMetersPerUnit(part_stage, 1.0 / self._units_per_meter)
-            self._old_stages.append(part_stage_url)
-            xform = UsdGeom.Xform.Define(part_stage, "/" + partname)
-
-            points = UsdGeom.Points.Define(part_stage, "/" + partname + "/Points")
-            # points.GetPointsAttr().Set(Vt.Vec3fArray(verts.tolist()))
-            points.GetPointsAttr().Set(verts)
-            if sizes is not None and sizes.size == (verts.size // 3):
-                points.GetWidthsAttr().Set(sizes)
-            else:
-                points.GetWidthsAttr().Set([default_size] * (verts.size // 3))
-
-            colorAttr = points.GetPrim().GetAttribute("primvars:displayColor")
-            colorAttr.SetMetadata("interpolation", "vertex")
-            if colors is not None and colors.size == verts.size:
-                colorAttr.Set(colors)
-            else:
-                colorAttr.Set([default_color[0:3]] * (verts.size // 3))
-
-            part_prim = part_stage.GetPrimAtPath("/" + partname)
-            part_stage.SetDefaultPrim(part_prim)
-
-            # Currently, this will never happen, but it is a setup for rigid body transforms
-            # At present, the group transforms have been cooked into the vertices so this is not needed
-            matrixOp = xform.AddXformOp(
-                UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
-            )
-            matrixOp.Set(Gf.Matrix4d(*matrix).GetTranspose())
-
-        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
-
-        # glue it into our stage
-        path = timestep_prim.GetPath().AppendChild("part_ref_" + partname)
-        part_ref = self._stage.OverridePrim(path)
-        part_ref.GetReferences().AddReference("." + stage_name)
+        part_base_name = self.clean_name(name) + "_p"
+        partname = part_base_name + part_hash.hexdigest()
+        stage_name = "/Parts/" + partname + self._ext
+        part_stage_url = self.stage_url(os.path.join("Parts", partname + self._ext))
+
+        # Make the manifest file - once for all timesteps
+        part_manifest_url_relative = "./Parts/" + part_base_name + "_manifest" + self._ext
+        part_manifest_url = self.stage_url(part_manifest_url_relative)
+        created_file = self.create_dsg_points_file(
+            part_manifest_url,
+            str(parent_prim.GetPath()),
+            None,
+            None,
+            None,
+            default_size,
+            default_color,
+            True,
+        )
+        if created_file:
+            self._stage.GetRootLayer().subLayerPaths.append(part_manifest_url_relative)
+
+        # Make the per-timestep file
+        created_file = self.create_dsg_points_file(
+            part_stage_url,
+            str(parent_prim.GetPath()),
+            verts,
+            sizes,
+            colors,
+            default_size,
+            default_color,
+            False,
+        )
 
-        if part_stage is not None:
-            part_stage.GetRootLayer().Save()
+        # Glue the file into the main stage
+        path = parent_prim.GetPath().AppendChild("points")
+        points_prim = self._stage.OverridePrim(path)
+        self.add_timestep_valueclip(
+            part_base_name, "points", points_prim, part_manifest_url_relative, timeline, stage_name
+        )
 
         return part_stage_url
 
@@ -615,9 +789,20 @@ class OmniverseWrapper(object):
             shutil.rmtree(uriPath, ignore_errors=True, onerror=None)
             shutil.copytree(f"{tempdir}/scratch/Textures", uriPath)
 
+    def create_xform_node(self, stage, name):
+        xform_node = UsdGeom.Xform.Define(stage, name)
+        xform_node.AddTranslateOp().Set((0, 0, 0))
+        xform_node.AddRotateXYZOp().Set((0, 0, 0))
+        xform_node.AddScaleOp().Set((1, 1, 1))
+        if self._centroid is not None:
+            xform_api = UsdGeom.XformCommonAPI(xform_node.GetPrim())
+            xform_api.SetPivot(Gf.Vec3f(self._centroid) * self._units_per_meter)
+        return xform_node
+
     def create_dsg_root(self):
         root_name = "/Root"
-        root_prim = UsdGeom.Xform.Define(self._stage, root_name)
+        self.create_xform_node(self._stage, root_name)
+
         # Define the defaultPrim as the /Root prim
         root_prim = self._stage.GetPrimAtPath(root_name)
         self._stage.SetDefaultPrim(root_prim)
@@ -627,8 +812,10 @@ class OmniverseWrapper(object):
         if camera is not None:
             cam_name = "/Root/Cam"
             cam_prim = UsdGeom.Xform.Define(self._stage, cam_name)
-            cam_pos = Gf.Vec3d(camera.lookfrom[0], camera.lookfrom[1], camera.lookfrom[2])
-            target_pos = Gf.Vec3d(camera.lookat[0], camera.lookat[1], camera.lookat[2])
+            s = self._units_per_meter
+            cam_pos = Gf.Vec3d(camera.lookfrom[0], camera.lookfrom[1], camera.lookfrom[2]) * s
+            target_pos = Gf.Vec3d(camera.lookat[0], camera.lookat[1], camera.lookat[2]) * s
+
             up_vec = Gf.Vec3d(camera.upvector[0], camera.upvector[1], camera.upvector[2])
             cam_prim = self._stage.GetPrimAtPath(cam_name)
             geom_cam = UsdGeom.Camera(cam_prim)
@@ -647,7 +834,7 @@ 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
-            dist = (target_pos - cam_pos).GetLength() * self._units_per_meter
+            dist = (target_pos - cam_pos).GetLength()
             cam.clippingRange = Gf.Range1f(0.1 * dist, 1000.0 * dist)
             look_at = Gf.Matrix4d()
             look_at.SetLookAt(cam_pos, target_pos, up_vec)
@@ -686,12 +873,8 @@ class OmniverseWrapper(object):
         path = parent_prim.GetPath().AppendChild(self.clean_name(name))
         group_prim = UsdGeom.Xform.Get(self._stage, path)
         if not group_prim:
-            group_prim = UsdGeom.Xform.Define(self._stage, path)
-            # At present, the group transforms have been cooked into the vertices so this is not needed
-            matrix_op = group_prim.AddXformOp(
-                UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble
-            )
-            matrix_op.Set(Gf.Matrix4d(*matrix).GetTranspose())
+            group_prim = self.create_xform_node(self._stage, path)
+
             # Map kinds
             kind = Kind.Tokens.group
             if obj_type == "ENS_CASE":
@@ -699,7 +882,9 @@ class OmniverseWrapper(object):
             elif obj_type == "ENS_PART":
                 kind = Kind.Tokens.component
             Usd.ModelAPI(group_prim).SetKind(kind)
+            group_prim.GetPrim().SetDisplayName(name)
             logging.info(f"Created group:'{name}' {str(obj_type)}")
+
         return group_prim
 
     def uploadMaterial(self):
@@ -732,6 +917,7 @@ class OmniverseUpdateHandler(UpdateHandler):
         self._group_prims: Dict[int, Any] = dict()
         self._root_prim = None
         self._sent_textures = False
+        self._case_xform_applied_to_camera = False
 
     def add_group(self, id: int, view: bool = False) -> None:
         super().add_group(id, view)
@@ -752,10 +938,17 @@ class OmniverseUpdateHandler(UpdateHandler):
             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:
+                if self.session.scene_bounds is not None:
+                    midx = (self.session.scene_bounds[3] + self.session.scene_bounds[0]) * 0.5
+                    midy = (self.session.scene_bounds[4] + self.session.scene_bounds[1]) * 0.5
+                    midz = (self.session.scene_bounds[5] + self.session.scene_bounds[2]) * 0.5
+                    self._omni._centroid = [midx, midy, midz]
+
+                if not self.session.vrmode and not self._case_xform_applied_to_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
+                    self._case_xform_applied_to_camera = True
                     cam_name = "/Root/Cam"
                     cam_prim = self._omni._stage.GetPrimAtPath(cam_name)  # type: ignore
                     geom_cam = UsdGeom.Camera(cam_prim)
@@ -763,9 +956,12 @@ class OmniverseUpdateHandler(UpdateHandler):
                     cam = geom_cam.GetCamera()
                     c = cam.transform
                     m = Gf.Matrix4d(*matrix).GetTranspose()
+                    s = self._omni._units_per_meter
+                    trans = m.GetRow(3)
+                    trans = Gf.Vec4d(trans[0] * s, trans[1] * s, trans[2] * s, trans[3])
+                    m.SetRow(3, trans)
                     # move the model transform to the camera transform
-                    sc = Gf.Matrix4d(self._omni._units_per_meter)
-                    cam.transform = c * m.GetInverse() * sc
+                    cam.transform = c * m.GetInverse()
 
                     # Determine if the camera is principally more Y, or Z up.  X up not supported.
                     # Omniverse' built in navigator tries to keep this direction up
@@ -874,6 +1070,7 @@ class OmniverseUpdateHandler(UpdateHandler):
                 has_triangles = True
                 # Generate the mesh block
                 _ = self._omni.create_dsg_mesh_block(
+                    part,
                     name,
                     obj_id,
                     part.hash,
@@ -980,6 +1177,7 @@ class OmniverseUpdateHandler(UpdateHandler):
         self._omni.clear_cleaned_names()
         # clear the group Omni prims list
         self._group_prims = dict()
+        self._case_xform_applied_to_camera = False
 
         self._omni.create_new_stage()
         self._root_prim = self._omni.create_dsg_root()

ansys/pyensight/core/utils/views.py

@@ -71,10 +71,11 @@ class _Simba:
         self.ensight.annotation.axis_global("off")
         self.ensight.annotation.axis_local("off")
         self.ensight.annotation.axis_model("off")
+        self.ensight.view_transf.zclip_float("OFF")
 
     def get_center_of_rotation(self):
         """Get EnSight center of rotation."""
-        return self.ensight.objs.core.VPORTS[0].TRANSFORMCENTER
+        return self.ensight.objs.core.VPORTS[0].TRANSFORMCENTER.copy()
 
     def auto_scale(self):
         """Auto scale view."""
@@ -157,44 +158,6 @@ class _Simba:
                 z = 0.25 * s
         return np.array([x, y, z, w])
 
-    def compute_model_rotation_quaternion(self, camera_position, focal_point, view_up):
-        """Compute the quaternion from the input camera."""
-        forward = self.normalize(np.array(focal_point) - np.array(camera_position))
-        right = self.normalize(np.cross(forward, view_up))
-        true_up = np.cross(right, forward)
-        camera_rotation = np.vstack([right, true_up, -forward]).T
-        model_rotation = camera_rotation.T
-        quat = self.rotation_matrix_to_quaternion(model_rotation)
-        return quat
-
-    @staticmethod
-    def quaternion_multiply(q1, q2):
-        x1, y1, z1, w1 = q1
-        x2, y2, z2, w2 = q2
-        w = w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2
-        x = w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2
-        y = w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2
-        z = w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2
-        return np.array([x, y, z, w])
-
-    def quaternion_to_euler(self, q):
-        q = self.normalize(q)
-        x, y, z, w = q
-        sinr_cosp = 2 * (w * x + y * z)
-        cosr_cosp = 1 - 2 * (x * x + y * y)
-        roll = np.arctan2(sinr_cosp, cosr_cosp)
-
-        sinp = 2 * (w * y - z * x)
-        if abs(sinp) >= 1:
-            pitch = np.pi / 2 * np.sign(sinp)
-        else:
-            pitch = np.arcsin(sinp)
-        siny_cosp = 2 * (w * z + x * y)
-        cosy_cosp = 1 - 2 * (y * y + z * z)
-        yaw = np.arctan2(siny_cosp, cosy_cosp)
-
-        return np.degrees([roll, pitch, yaw])
-
     def compute_camera_from_ensight_opengl(self):
         """Simulate a rotating camera using the current quaternion."""
         if isinstance(self.ensight, ModuleType):
@@ -207,38 +170,6 @@ class _Simba:
         parallel_scale = 1 / data[9]
         return camera_position, focal_point, self.views._normalize_vector(view_up), parallel_scale
 
-    def get_camera_axes(self):
-        """
-        Returns the camera's local axes: right, up, and forward vectors.
-        These are useful for applying transformations in view space.
-
-        Parameters:
-            camera (dict): A dictionary with keys 'position', 'focal_point', and 'view_up'.
-
-        Returns:
-            right (np.ndarray): Right vector (X axis in view space).
-            up (np.ndarray): Up vector (Y axis in view space).
-        forw    ard (np.ndarray): Forward vector (Z axis in view space, pointing from position to focal point).
-        """
-        camera = self.get_camera()
-        position = np.array(camera["position"])
-        focal_point = np.array(camera["focal_point"])
-        view_up = np.array(camera["view_up"])
-
-        # Forward vector: from camera position to focal point
-        forward = focal_point - position
-        forward /= np.linalg.norm(forward)
-
-        # Right vector: cross product of forward and view_up
-        right = np.cross(forward, view_up)
-        right /= np.linalg.norm(right)
-
-        # Recompute up vector to ensure orthogonality
-        up = np.cross(right, forward)
-        up /= np.linalg.norm(up)
-
-        return right, up, forward
-
     def set_camera(
         self,
         orthographic,
@@ -246,43 +177,41 @@ class _Simba:
         position=None,
         focal_point=None,
         view_angle=None,
-        pan=None,
-        mousex=None,
-        mousey=None,
-        invert_y=False,
     ):
         """Set the EnSight camera settings from the VTK input."""
         self.ensight.view_transf.function("global")
         perspective = "OFF" if orthographic else "ON"
-        if orthographic:
-            self.ensight.view.perspective(perspective)
+        self.ensight.view.perspective(perspective)
         vport = self.ensight.objs.core.VPORTS[0]
-        if view_angle:
-            vport.PERSPECTIVEANGLE = view_angle / 2
+        vport.PERSPECTIVEANGLE = view_angle / 2
         if view_up and position and focal_point:
-            if not pan:
-                q_current = self.normalize(np.array(vport.ROTATION.copy()))
-                q_target = self.normalize(
-                    self.compute_model_rotation_quaternion(position, focal_point, view_up)
-                )
-                q_relative = self.quaternion_multiply(
-                    q_target, np.array([-q_current[0], -q_current[1], -q_current[2], q_current[3]])
+            current_camera = self.get_camera()
+            center = vport.TRANSFORMCENTER.copy()
+            if isinstance(self.ensight, ModuleType):
+                data = self.ensight.objs.core.VPORTS[0].simba_set_camera_helper(
+                    position,
+                    focal_point,
+                    view_up,
+                    current_camera["position"],
+                    current_camera["focal_point"],
+                    current_camera["view_up"],
+                    center,
+                    vport.ROTATION.copy(),
                 )
-                angles = self.quaternion_to_euler(q_relative)
-                self.ensight.view_transf.rotate(*angles)
             else:
-                if mousex and mousey:
-                    self.screen_to_world(
-                        mousex=mousex, mousey=mousey, invert_y=invert_y, set_center=True
-                    )
-                current_camera = self.get_camera()
-                right, up, _ = self.get_camera_axes()
-                translation_vector = np.array(position) - np.array(current_camera["position"])
-                dx = np.dot(translation_vector, right)
-                dy = np.dot(translation_vector, up)
-                self.ensight.view_transf.translate(-dx, -dy, 0)
+                current_position = current_camera["position"]
+                current_fp = current_camera["focal_point"]
+                current_up = current_camera["view_up"]
+                cmd = "ensight.objs.core.VPORTS[0].simba_set_camera_helper("
+                cmd += f"{position}, {focal_point}, {view_up}, {current_position}, "
+                cmd += f"{current_fp}, {current_up}, {center}, "
+                cmd += f"{vport.ROTATION.copy()})"
+                data = self.ensight._session.cmd(cmd)
+            self.ensight.view_transf.rotate(data[3], data[4], data[5])
+            self.ensight.view_transf.translate(data[0], data[1], 0)
 
         self.render()
+        return self.get_camera()
 
     def set_perspective(self, value):
         self.ensight.view_transf.function("global")

{ansys_pyensight_core-0.10.10.dist-info → ansys_pyensight_core-0.10.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansys-pyensight-core
-Version: 0.10.10
+Version: 0.10.13
 Summary: A python wrapper for Ansys EnSight
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: "ANSYS, Inc." <pyansys.core@ansys.com>
@@ -25,7 +25,7 @@ Requires-Dist: numpy>=1.21.0,<3
 Requires-Dist: Pillow>=9.3.0
 Requires-Dist: pypng>=0.0.20
 Requires-Dist: psutil>=5.9.2
-Requires-Dist: usd-core==24.8; python_version < '3.13' and platform_machine != 'aarch64'
+Requires-Dist: usd-core==25.8; platform_machine != 'aarch64'
 Requires-Dist: pygltflib>=1.16.2
 Requires-Dist: grpcio<1.68.0
 Requires-Dist: build>=0.10.0 ; extra == "dev"
@@ -46,7 +46,7 @@ Requires-Dist: sphinxcontrib.jquery==4.1 ; extra == "doc"
 Requires-Dist: sphinxcontrib-openapi==0.8.4 ; extra == "doc"
 Requires-Dist: coverage-badge==1.1.2 ; extra == "doc"
 Requires-Dist: sphinxcontrib-video==0.2.1 ; extra == "doc"
-Requires-Dist: usd-core>=24.8 ; extra == "doc"
+Requires-Dist: usd-core>=25.8 ; extra == "doc"
 Requires-Dist: pygltflib>=1.16.2 ; extra == "doc"
 Requires-Dist: pytest==8.3.5 ; extra == "tests"
 Requires-Dist: pytest-cov==5.0.0 ; extra == "tests"

{ansys_pyensight_core-0.10.10.dist-info → ansys_pyensight_core-0.10.13.dist-info}/RECORD

@@ -1,17 +1,17 @@
 ansys/pyensight/core/__init__.py,sha256=BCfpDonS2OZRM2O6wjcyOYhLSgdy9hMQRl6G-_9Bvkg,845
 ansys/pyensight/core/common.py,sha256=GhDxSoSscT9ObyTyEcuP0zeKKVJOpWVVYG0SwEby7CA,7575
 ansys/pyensight/core/deep_pixel_view.html,sha256=6u4mGOuzJiPze8N8pIKJsEGPv5y6-zb38m9IfrarATE,3510
-ansys/pyensight/core/dockerlauncher.py,sha256=1ufL3uG170ZmZ5KnhwcFh07iMIbqNCDjD1mC0u7MH20,28371
+ansys/pyensight/core/dockerlauncher.py,sha256=iemgGEotlZjpX_tCvnAdLKRDNLaDuGKeYWihiqUSDNY,30523
 ansys/pyensight/core/dvs.py,sha256=zRhizBkIUCk09BaR-7BxkC6EkIEjG7rU5vznh45QOzA,32018
 ansys/pyensight/core/enscontext.py,sha256=GSKkjZt1QEPyHEQ59EEBgKGMik9vjCdR9coR4uX7fEw,12141
 ansys/pyensight/core/enshell_grpc.py,sha256=OPK84J44kwjbAYQM4acb9zd-abYYkMNculKaWZeVDIk,17123
 ansys/pyensight/core/ensight_grpc.py,sha256=IitEgMzBJTyTgQff0sXPvGkVnC2E9qRKw-HXCF-mVvA,29713
 ansys/pyensight/core/ensobj.py,sha256=uDtM2KHcAwd4hu5pcUYWbSD729ApHGIvuqZhEq8PxTI,18558
 ansys/pyensight/core/launch_ensight.py,sha256=iZJM6GdpzGRDLzrv1V2QZ5veIOpNSB5xPpJUFY7rBuo,10254
-ansys/pyensight/core/launcher.py,sha256=x6L1E6OGpqL2jrDdIGI0p4BxQZhHt93yl1Pwj_2lAiQ,13143
+ansys/pyensight/core/launcher.py,sha256=_AH0Lr_kTFM6c5DYxEXp1pfrbYmoHWHajxnHgq_0CBo,13229
 ansys/pyensight/core/libuserd.py,sha256=P6j-mgT6kDYiuRRDKEepJvZusBYa5jo4AQIwK__9R6Q,76020
 ansys/pyensight/core/listobj.py,sha256=Trw87IxIMXtmUd1DzywRmMzORU704AG4scX4fqYmO6M,9340
-ansys/pyensight/core/locallauncher.py,sha256=b9sgHY1Fw_1lV4h4BE7GybL71GIRPDFw56Mt-5SQYEw,17256
+ansys/pyensight/core/locallauncher.py,sha256=uv6B1gojx7FmT5e4RZQe2knKzChr0Ooh-Wr06QRbsoA,19146
 ansys/pyensight/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ansys/pyensight/core/renderable.py,sha256=KidVTVCZ4hKYq54pP9KoJ8OCxeWBXNUJYyKSwMZ2Sls,36362
 ansys/pyensight/core/session.py,sha256=6iIzw_PPpJ0ry9jwLfNdm5e5x_ppzamYv7BS1rtNZDw,74455
@@ -20,18 +20,18 @@ 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=2jCPhOplPrlDaQNSKSk9qo7bEgfcrhx0rHS_cqW2zAY,47003
 ansys/pyensight/core/utils/export.py,sha256=GC0NbVl0_CXvUUfkbJl49yjTsP_58bJZyjE95q6ATUo,22604
-ansys/pyensight/core/utils/omniverse.py,sha256=Xnjw8XiIzTCOHKvpb7dH-P3ObA3dQHJvxXEsrRt6XvI,24738
+ansys/pyensight/core/utils/omniverse.py,sha256=YhBrlnMcRmmf64jBNm6bV5x-Ej2VIjZOExwzmNHo1Ng,25007
 ansys/pyensight/core/utils/omniverse_cli.py,sha256=ujoBbBGMYsYUn83nrk2dFkOd7kn7-6cs7ljBmmSXodw,20578
-ansys/pyensight/core/utils/omniverse_dsg_server.py,sha256=MuHVurd8zaSIsQkvrY94X_IJSldFShnzEoGItjvZTTw,41067
+ansys/pyensight/core/utils/omniverse_dsg_server.py,sha256=75fGWqwVMLoACox08mwwWDA4pSTTqyjACVKhkeTRQ3Y,45994
 ansys/pyensight/core/utils/omniverse_glb_server.py,sha256=dx2cfR036d3DY6meooNfLZOQpOMaiaLKqBjztpew2_Q,32167
 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=_IluAWz8mmoe5SM3hAewHIqlhtKMfEqrUJoQOlJ4U4I,12138
 ansys/pyensight/core/utils/support.py,sha256=QI3z9ex7zJxjFbkCPba9DWqWgPFIThORqr0nvRfVjuc,4089
 ansys/pyensight/core/utils/variables.py,sha256=ZUiJdDIeRcowrnLXaJQqGwA0RbrfXhc1s4o4v9A4PiY,95133
-ansys/pyensight/core/utils/views.py,sha256=16HhsxhrwjH_vRtyN96S5rItCfb8ACdVIQkBuEGgPh8,27273
+ansys/pyensight/core/utils/views.py,sha256=vyO5w5Z1PFlz26FpXjXYDZyGFv2rUTGHJS5ovJvorvc,24675
 ansys/pyensight/core/utils/resources/Materials/000_sky.exr,sha256=xAR1gFd2uxPZDnvgfegdhEhRaqKtZldQDiR_-1rHKO0,8819933
-ansys_pyensight_core-0.10.10.dist-info/licenses/LICENSE,sha256=K6LiJHOa9IbWFelXmXNRzFr3zG45SOGZIN7vdLdURGU,1097
-ansys_pyensight_core-0.10.10.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-ansys_pyensight_core-0.10.10.dist-info/METADATA,sha256=j2qVkHFkgjFLJbBjOz82BXIEuaVmP-lB_UQC8T5bhxQ,12229
-ansys_pyensight_core-0.10.10.dist-info/RECORD,,
+ansys_pyensight_core-0.10.13.dist-info/licenses/LICENSE,sha256=K6LiJHOa9IbWFelXmXNRzFr3zG45SOGZIN7vdLdURGU,1097
+ansys_pyensight_core-0.10.13.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+ansys_pyensight_core-0.10.13.dist-info/METADATA,sha256=3Aa_Lyq0xtTJ15BAlpI1Y8S_wPxZKSvsRHtHszlJQlU,12201
+ansys_pyensight_core-0.10.13.dist-info/RECORD,,