ansys-pyensight-core 0.10.9__py3-none-any.whl → 0.10.12__py3-none-any.whl

ansys/pyensight/core/utils/omniverse.py

@@ -268,7 +268,7 @@ 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
@@ -277,7 +277,7 @@ def find_app(ansys_installation: Optional[str] = None) -> Optional[str]:
             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 +286,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

@@ -38,10 +38,10 @@ import numpy
 import png
 
 try:
-    from pxr import Gf, Kind, Sdf, Usd, UsdGeom, UsdLux, UsdShade
+    from pxr import Gf, 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,8 @@ class OmniverseWrapper(object):
             self.destination = destination
 
         self._line_width = line_width
+        # Record the files per timestep, per mesh type.  {part_name: {"surfaces": [], "lines": [], "points": []} }
+        self._time_files: dict = {}
 
     @property
     def destination(self) -> str:
@@ -148,7 +152,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 +281,75 @@ 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 = UsdGeom.Xform.Define(stage, part_path + "/surfaces")
+        surfaces_prim.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble)
+        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,174 @@ 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)
+        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,
+        )
 
-            # 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,
-            )
+        # 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,
+        )
 
-        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
+        return part_stage_url
 
-        # 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)
+    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]
 
-        if part_stage is not None:
-            part_stage.GetRootLayer().Save()
+    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))
 
-        return part_stage_url
+    # 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 = UsdGeom.Xform.Define(stage, part_path + "/lines")
+
+        lines_prim.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble)
+        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
+        )
+        endCaps.Set(2)  # Rounded = 2
 
-    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)
+        prim = lines.GetPrim()
+        wireframe = width == 0.0
+        prim.CreateAttribute("omni:scene:visualization:drawWireframe", Sdf.ValueTypeNames.Bool).Set(
+            wireframe
         )
-        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
+
+        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 +553,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)
+        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,
+        )
 
-            # 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,
-            )
+        # 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
+        )
 
-        timestep_prim = self.add_timestep_group(parent_prim, timeline, first_timestep)
+        return part_stage_url
 
-        # 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)
+    # 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)
 
-        if part_stage is not None:
-            part_stage.GetRootLayer().Save()
+        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)
 
-        return part_stage_url
+        stage.SetDefaultPrim(part_prim)
+        stage.SetStartTimeCode(0)
+        stage.SetEndTimeCode(0)
+
+        stage.Save()
+        return True
 
     def create_dsg_points(
         self,
@@ -477,53 +660,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
 
@@ -627,8 +802,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 +824,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)
@@ -693,6 +870,7 @@ class OmniverseWrapper(object):
             )
             matrix_op.Set(Gf.Matrix4d(*matrix).GetTranspose())
             # Map kinds
+            """
             kind = Kind.Tokens.group
             if obj_type == "ENS_CASE":
                 kind = Kind.Tokens.assembly
@@ -700,6 +878,7 @@ class OmniverseWrapper(object):
                 kind = Kind.Tokens.component
             Usd.ModelAPI(group_prim).SetKind(kind)
             logging.info(f"Created group:'{name}' {str(obj_type)}")
+            """
         return group_prim
 
     def uploadMaterial(self):
@@ -732,6 +911,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 +932,11 @@ 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 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 +944,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 +1058,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 +1165,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."""
@@ -94,8 +95,7 @@ class _Simba:
             self.views.set_view_direction(
                 1, 1, 1, perspective=self.ensight.objs.core.vports[0].PERSPECTIVE
             )
-        self.auto_scale()
-        return self.get_camera()
+        return self.auto_scale()
 
     def get_camera(self):
         """Get EnSight camera settings in VTK format."""
@@ -107,6 +107,7 @@ class _Simba:
         # if the vport is in orthographic mode. If not, it is defined as the
         # inverge of the tangent of half of the field of view
         parallel_scale = parallel_scale
+        clipping_range = vport.ZCLIPLIMITS
         return {
             "orthographic": not vport.PERSPECTIVE,
             "view_up": view_up,
@@ -119,6 +120,8 @@ class _Simba:
             "reset_parallel_scale": self._original_parallel_scale,
             "reset_view_up": self._original_view_up,
             "reset_view_angle": self._original_view_angle,
+            "near_plane": clipping_range[0],
+            "far_plane": clipping_range[1],
         }
 
     @staticmethod
@@ -208,8 +211,56 @@ 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 _arbitrary_orthogonal(self, v):
+        if abs(v[0]) < abs(v[1]) and abs(v[0]) < abs(v[2]):
+            return self.normalize(np.array(self.views._cross_product(v.tolist(), [1, 0, 0])))
+        elif abs(v[1]) < abs(v[2]):
+            return self.normalize(np.array(self.views._cross_product(v.tolist(), [0, 1, 0])))
+        return self.normalize(np.array(self.views._cross_product(v.tolist(), [0, 0, 1])))
+
     def set_camera(
-        self, orthographic, view_up=None, position=None, focal_point=None, view_angle=None, pan=None
+        self,
+        orthographic,
+        view_up=None,
+        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")
@@ -219,21 +270,65 @@ class _Simba:
         vport = self.ensight.objs.core.VPORTS[0]
         if view_angle:
             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]])
-                )
-                angles = self.quaternion_to_euler(q_relative)
-                self.ensight.view_transf.rotate(*angles)
-            else:
-                self.ensight.view_transf.translate(*pan)
+            # Compute relative rotation
+            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]])
+            )
+            angles = self.quaternion_to_euler(q_relative)
+            self.ensight.view_transf.rotate(*angles)
+            # Decompose eventual translation from rotation
+            current_camera = self.get_camera()
+            center = vport.TRANSFORMCENTER.copy()
+            pos0, focal0, up0 = map(
+                np.array,
+                [
+                    current_camera["position"],
+                    current_camera["focal_point"],
+                    current_camera["view_up"],
+                ],
+            )
+            pos1, focal1, up1 = map(np.array, [position, focal_point, view_up])
+            dir0 = self.normalize(focal0 - pos0)
+            right0 = np.cross(dir0, up0)
+            norm = np.linalg.norm(right0)
+            if norm <= 1e-6:
+                right0 = self._arbitrary_orthogonal(dir0)
+            up0n = np.cross(right0, dir0)
+            dir1 = self.normalize(focal1 - pos1)
+            right1 = np.cross(dir1, up1)
+            norm = np.linalg.norm(right1)
+            if norm <= 1e-6:
+                right1 = self._arbitrary_orthogonal(dir1)
+            up1n = np.cross(right1, dir1)
+            # Now that orthonormal basis have been computed for the
+            # old and new camera, one can compute the rotation matrix
+            # that takes the old camera to the new one
+            A = np.stack([right0, up0n, dir0], axis=1)
+            B = np.stack([right1, up1n, dir1], axis=1)
+            R = B @ A.T
+            # Compute the rotated only vector from the old camera
+            # to the new camera direction
+            rotatedDistance = R @ (pos0 - center) + center
+            # Compute the view matrix for the rotated camera axes
+            rotated_focal = focal0 + (rotatedDistance - pos0)
+            rotated_dir = self.normalize(rotated_focal - rotatedDistance)
+            rotated_right = np.cross(rotated_dir, up0)
+            if np.linalg.norm(rotated_right) <= 1e-6:
+                rotated_right = self._arbitrary_orthogonal(rotated_dir)
+            rotated_up = np.cross(rotated_right, rotated_dir)
+            # Compute the world coordinates translation and move it to
+            # view space
+            offset = pos1 - rotatedDistance
+            translation = -np.stack([rotated_right, rotated_up, rotated_dir]) @ offset
+            self.ensight.view_transf.translate(translation[0], translation[1], 0)
+
         self.render()
+        return self.get_camera()
 
     def set_perspective(self, value):
         self.ensight.view_transf.function("global")
@@ -265,7 +360,37 @@ class _Simba:
         self.ensight.render()
         self.ensight.refresh(1)
 
-    def drag_allowed(self, mousex, mousey, invert_y=False):
+    def _probe_setup(self, part_obj, get_probe_data=False):
+        self.ensight.query_interact.number_displayed(100)
+        self.ensight.query_interact.query("surface")
+        self.ensight.query_interact.display_id("OFF")
+        self.ensight.query_interact.label_always_on_top("ON")
+        self.ensight.query_interact.marker_size_normalized(2)
+        if get_probe_data:
+            variable_string = """Coordinates 'X' 'Y' 'Z'"""
+            variable_list = [variable_string]
+            variable_name = part_obj.COLORBYPALETTE
+            if variable_name:
+                if isinstance(variable_name, str):
+                    variable_list.append(variable_name)
+                else:
+                    if isinstance(variable_name, list):
+                        if variable_name[0]:
+                            variable_name = variable_name[0].DESCRIPTION
+                            variable_list.append(variable_name)
+                        else:
+                            variable_name = None
+            if isinstance(self.ensight, ModuleType):
+                self.ensight.query_interact.select_varname_begin(*variable_list)
+            else:
+                command = "ensight.query_interact.select_varname_begin("
+                for var in variable_list:
+                    command += var + ","
+                command = command[:-1] + ")"
+                self.ensight._session.cmd(command)
+        self.render()
+
+    def drag_allowed(self, mousex, mousey, invert_y=False, probe=False, get_probe_data=False):
         """Return True if the picked object is allowed dragging in the interactor."""
         mousex = int(mousex)
         mousey = int(mousey)
@@ -277,8 +402,14 @@ class _Simba:
             part_id, tool_id = self.ensight._session.cmd(
                 f"ensight.objs.core.VPORTS[0].simba_what_is_picked({mousex}, {mousey}, {invert_y})"
             )
+        coords = [None, None, None]
+        if probe:
+            screen_to_world = self.screen_to_world(
+                mousex=mousex, mousey=mousey, invert_y=invert_y, set_center=False
+            )
+            coords = screen_to_world["model_point"]
         if tool_id > -1:
-            return True
+            return True, coords[0], coords[1], coords[2], False
         part_types_allowed = [
             self.ensight.objs.enums.PART_CLIP_PLANE,
             self.ensight.objs.enums.PART_ISO_SURFACE,
@@ -286,8 +417,22 @@ class _Simba:
         ]
         if part_id > -1:
             part_obj = self.ensight.objs.core.PARTS.find(part_id, "PARTNUMBER")[0]
-            return part_obj.PARTTYPE in part_types_allowed
-        return False
+            if probe:
+                width, height = tuple(self.ensight.objs.core.WINDOWSIZE)
+                if invert_y:
+                    mousey = height - mousey
+                self.ensight.query_interact.number_displayed(100)
+                self.ensight.query_interact.query("surface")
+                self.ensight.query_interact.display_id("OFF")
+                self.ensight.query_interact.create(mousex / width, mousey / height)
+                self._probe_setup(part_obj, get_probe_data=get_probe_data)
+            return part_obj.PARTTYPE in part_types_allowed, coords[0], coords[1], coords[2], True
+        if (
+            get_probe_data and self.ensight.objs.core.PROBES[0].PROBE_DATA
+        ):  # In case we have picked a probe point
+            for part in self.ensight.objs.core.PARTS:
+                self._probe_setup(part, get_probe_data=get_probe_data)
+        return False, coords[0], coords[1], coords[2], False
 
 
 class Views:

{ansys_pyensight_core-0.10.9.dist-info → ansys_pyensight_core-0.10.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansys-pyensight-core
-Version: 0.10.9
+Version: 0.10.12
 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.9.dist-info → ansys_pyensight_core-0.10.12.dist-info}/RECORD

@@ -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=yxLeEX6J1D_NwWSn-sm_C6-VYiLvYehHCbj1b19BxNI,24729
 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=KPsnHstndXiv9jePGW3qnqqjMycKwZUL2vH7Thvq-wA,45547
 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=YyTv7F7g6ixf8xFf0fUKXe7s1pbSgbXGzKrFNIMUH5A,22845
+ansys/pyensight/core/utils/views.py,sha256=qkc_xPZ4Ea8dof6eqRwOd6dPrbruDTODoFzlnczpJGU,29578
 ansys/pyensight/core/utils/resources/Materials/000_sky.exr,sha256=xAR1gFd2uxPZDnvgfegdhEhRaqKtZldQDiR_-1rHKO0,8819933
-ansys_pyensight_core-0.10.9.dist-info/licenses/LICENSE,sha256=K6LiJHOa9IbWFelXmXNRzFr3zG45SOGZIN7vdLdURGU,1097
-ansys_pyensight_core-0.10.9.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-ansys_pyensight_core-0.10.9.dist-info/METADATA,sha256=yV4oBGTFEw5MiNzPVnfN6kkrY9NXQHkJpeAb1X7KV_I,12228
-ansys_pyensight_core-0.10.9.dist-info/RECORD,,
+ansys_pyensight_core-0.10.12.dist-info/licenses/LICENSE,sha256=K6LiJHOa9IbWFelXmXNRzFr3zG45SOGZIN7vdLdURGU,1097
+ansys_pyensight_core-0.10.12.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+ansys_pyensight_core-0.10.12.dist-info/METADATA,sha256=-wrfz96hNIMWHitCBnMbeldilHN4Nfi_NWL4gTpJ8qA,12201
+ansys_pyensight_core-0.10.12.dist-info/RECORD,,