ansys-pyensight-core 0.10.12__tar.gz → 0.10.13__tar.gz

{ansys_pyensight_core-0.10.12 → ansys_pyensight_core-0.10.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansys-pyensight-core
-Version: 0.10.12
+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>

{ansys_pyensight_core-0.10.12 → ansys_pyensight_core-0.10.13}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "ansys-pyensight-core"
-version = "0.10.12"
+version = "0.10.13"
 description = "A python wrapper for Ansys EnSight"
 readme = "README.rst"
 requires-python = ">=3.10,<3.14"

{ansys_pyensight_core-0.10.12 → ansys_pyensight_core-0.10.13}/src/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-0.10.12 → ansys_pyensight_core-0.10.13}/src/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-0.10.12 → ansys_pyensight_core-0.10.13}/src/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-0.10.12 → ansys_pyensight_core-0.10.13}/src/ansys/pyensight/core/utils/omniverse.py

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

{ansys_pyensight_core-0.10.12 → ansys_pyensight_core-0.10.13}/src/ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -38,7 +38,7 @@ import numpy
 import png
 
 try:
-    from pxr import Gf, Sdf, Usd, UsdGeom, UsdLux, UsdShade
+    from pxr import Gf, Kind, Sdf, Usd, UsdGeom, UsdLux, UsdShade
 except ModuleNotFoundError:
     if sys.version_info.minor >= 14:
         warnings.warn("USD Export not supported for Python >= 3.14")
@@ -77,6 +77,7 @@ 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 = {}
 
@@ -307,8 +308,7 @@ class OmniverseWrapper(object):
 
         part_prim = stage.OverridePrim(part_path)
 
-        surfaces_prim = UsdGeom.Xform.Define(stage, part_path + "/surfaces")
-        surfaces_prim.AddXformOp(UsdGeom.XformOp.TypeTransform, UsdGeom.XformOp.PrecisionDouble)
+        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()
@@ -483,9 +483,8 @@ class OmniverseWrapper(object):
 
         part_prim = stage.OverridePrim(part_path)
 
-        lines_prim = UsdGeom.Xform.Define(stage, part_path + "/lines")
+        lines_prim = self.create_xform_node(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()
@@ -790,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)
@@ -863,22 +873,18 @@ 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":
                 kind = Kind.Tokens.assembly
             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):
@@ -932,6 +938,12 @@ 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 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

{ansys_pyensight_core-0.10.12 → ansys_pyensight_core-0.10.13}/src/ansys/pyensight/core/utils/views.py

@@ -107,7 +107,6 @@ 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,
@@ -120,8 +119,6 @@ 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
@@ -161,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):
@@ -211,45 +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 _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,
@@ -257,75 +177,38 @@ 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:
-            # 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,
-                [
+            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"],
-                ],
-            )
-            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)
+                    center,
+                    vport.ROTATION.copy(),
+                )
+            else:
+                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()