ansys-pyensight-core 0.10.5__tar.gz → 0.10.7__tar.gz

{ansys_pyensight_core-0.10.5 → ansys_pyensight_core-0.10.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ansys-pyensight-core
-Version: 0.10.5
+Version: 0.10.7
 Summary: A python wrapper for Ansys EnSight
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: "ANSYS, Inc." <pyansys.core@ansys.com>
@@ -27,6 +27,7 @@ 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: pygltflib>=1.16.2
+Requires-Dist: grpcio<1.68.0
 Requires-Dist: build>=0.10.0 ; extra == "dev"
 Requires-Dist: bump2version>=1.0.1 ; extra == "dev"
 Requires-Dist: ipdb>=0.9.4 ; extra == "dev"

{ansys_pyensight_core-0.10.5 → ansys_pyensight_core-0.10.7}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "ansys-pyensight-core"
-version = "0.10.5"
+version = "0.10.7"
 description = "A python wrapper for Ansys EnSight"
 readme = "README.rst"
 requires-python = ">=3.10,<3.14"
@@ -36,7 +36,8 @@ dependencies = [
     "pypng>=0.0.20",
     "psutil>=5.9.2",
     "usd-core==24.8; python_version < '3.13' and platform_machine != 'aarch64'",
-    "pygltflib>=1.16.2"
+    "pygltflib>=1.16.2",
+    "grpcio<1.68.0",
 ]
 
 [project.optional-dependencies]
@@ -160,7 +161,7 @@ recursive = true
 exclude = ["venv/*", "tests/*"]
 
 [tool.mypy]
-python_version = 3.10
+python_version = "3.10"
 strict = false
 namespace_packages = true
 explicit_package_bases = true

{ansys_pyensight_core-0.10.5 → ansys_pyensight_core-0.10.7}/src/ansys/pyensight/core/utils/omniverse.py

@@ -5,6 +5,7 @@ import platform
 import subprocess
 import sys
 import tempfile
+import threading
 from types import ModuleType
 from typing import TYPE_CHECKING, List, Optional, Union
 import uuid
@@ -35,8 +36,15 @@ class OmniverseKitInstance:
         The process id of the launched instance
     """
 
-    def __init__(self, pid: int) -> None:
-        self._pid: Optional[int] = pid
+    def __init__(self, proc: subprocess.Popen) -> None:
+        self._proc: subprocess.Popen = proc
+        self._returncode: Optional[int] = None
+        self._rendering = False
+        self._lines_read = 0
+        self._scanner_thread = threading.Thread(
+            target=OmniverseKitInstance._scan_stdout, args=(self,)
+        )
+        self._scanner_thread.start()
 
     def __del__(self) -> None:
         """Close down the instance on delete"""
@@ -50,7 +58,7 @@ class OmniverseKitInstance:
         """
         if not self.is_running():
             return
-        proc = psutil.Process(self._pid)
+        proc = psutil.Process(self._proc.pid)
         for child in proc.children(recursive=True):
             if psutil.pid_exists(child.pid):
                 # This can be a race condition, so it is ok if the child is dead already
@@ -63,7 +71,29 @@ class OmniverseKitInstance:
             proc.terminate()
         except psutil.NoSuchProcess:
             pass
-        self._pid = None
+        self._scanner_thread.join()
+
+        # On a forced close, set a return code of 0
+        self._returncode = 0
+
+    @staticmethod
+    def _scan_stdout(oki: "OmniverseKitInstance"):
+        while oki._proc and oki._proc.poll() is None:
+            if oki._proc.stdout is not None:
+                output_line = oki._proc.stdout.readline().decode("utf-8")
+                oki._lines_read = oki._lines_read + 1
+                if "RTX ready" in output_line:
+                    oki._rendering = True
+
+    def is_rendering(self) -> bool:
+        """Check if the instance has finished launching and is ready to render
+
+        Returns
+        -------
+        bool
+            True if the instance is ready to render.
+        """
+        return self.is_running() and self._rendering
 
     def is_running(self) -> bool:
         """Check if the instance is still running
@@ -73,13 +103,27 @@ class OmniverseKitInstance:
         bool
             True if the instance is still running.
         """
-        if not self._pid:
+        if self._proc is None:
             return False
-        if psutil.pid_exists(self._pid):
+        if self._proc.poll() is None:
             return True
-        self._pid = None
         return False
 
+    def returncode(self) -> Optional[int]:
+        """Get the return code if the process has stopped, or None if still running
+
+        Returns
+        -------
+        int or None
+            Get the return code if the process has stopped, or None if still running
+        """
+        if self._returncode is not None:
+            return self._returncode
+        if self.is_running():
+            return None
+        self._returncode = self._proc.returncode
+        return self._returncode
+
 
 # Deprecated
 def find_kit_filename(fallback_directory: Optional[str] = None) -> Optional[str]:
@@ -216,8 +260,8 @@ def launch_kit_instance(
         cmd.append("--/log/enabled=true")
     # Launch the process
     env_vars = os.environ.copy()
-    p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, env=env_vars)
-    return OmniverseKitInstance(p.pid)
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env_vars)
+    return OmniverseKitInstance(p)
 
 
 def find_app(ansys_installation: Optional[str] = None) -> Optional[str]:
@@ -322,8 +366,8 @@ def launch_app(
 
     # Launch the process
     env_vars = os.environ.copy()
-    p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, env=env_vars)
-    return OmniverseKitInstance(p.pid)
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env_vars)
+    return OmniverseKitInstance(p)
 
 
 class Omniverse:

{ansys_pyensight_core-0.10.5 → ansys_pyensight_core-0.10.7}/src/ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -70,7 +70,7 @@ class OmniverseWrapper(object):
         self._time_codes_per_second: float = 120.0
         # Omniverse content currently only scales correctly for scenes in cm.  DJB, Feb 2025
         self._units_per_meter: float = 100.0
-
+        self._up_axis: str = UsdGeom.Tokens.y
         if destination:
             self.destination = destination
 
@@ -163,7 +163,7 @@ class OmniverseWrapper(object):
         self._stage = Usd.Stage.CreateNew(self.stage_url())
         # record the stage in the "_old_stages" list.
         self._old_stages.append(self.stage_url())
-        UsdGeom.SetStageUpAxis(self._stage, UsdGeom.Tokens.y)
+        UsdGeom.SetStageUpAxis(self._stage, self._up_axis)
         UsdGeom.SetStageMetersPerUnit(self._stage, 1.0 / self._units_per_meter)
         logging.info(f"Created stage: {self.stage_url()}")
 
@@ -302,7 +302,7 @@ class OmniverseWrapper(object):
 
         if not os.path.exists(part_stage_url):
             part_stage = Usd.Stage.CreateNew(part_stage_url)
-            UsdGeom.SetStageUpAxis(part_stage, UsdGeom.Tokens.y)
+            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)
@@ -400,7 +400,7 @@ class OmniverseWrapper(object):
 
         if not os.path.exists(part_stage_url):
             part_stage = Usd.Stage.CreateNew(part_stage_url)
-            UsdGeom.SetStageUpAxis(part_stage, UsdGeom.Tokens.y)
+            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)
@@ -485,7 +485,7 @@ class OmniverseWrapper(object):
 
         if not os.path.exists(part_stage_url):
             part_stage = Usd.Stage.CreateNew(part_stage_url)
-            UsdGeom.SetStageUpAxis(part_stage, UsdGeom.Tokens.y)
+            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)
@@ -766,6 +766,17 @@ class OmniverseUpdateHandler(UpdateHandler):
                     # move the model transform to the camera transform
                     sc = Gf.Matrix4d(self._omni._units_per_meter)
                     cam.transform = c * m.GetInverse() * sc
+
+                    # 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
+                    # If the view is principally -Y, there is no good choice.  +Y is least bad.
+                    cam_upvec = Gf.Vec4d(0, 1, 0, 0) * cam.transform
+                    if abs(cam_upvec[1]) >= abs(cam_upvec[2]):
+                        self._up_axis = UsdGeom.Tokens.y
+                    else:
+                        self._up_axis = UsdGeom.Tokens.z
+                    UsdGeom.SetStageUpAxis(self._omni._stage, self._up_axis)
+
                     # set the updated camera
                     geom_cam.SetFromCamera(cam)
                     # apply the inverse cam transform to move the center of interest

{ansys_pyensight_core-0.10.5 → ansys_pyensight_core-0.10.7}/src/ansys/pyensight/core/utils/views.py

@@ -18,9 +18,13 @@ Example to set an isometric view:
 
 """
 
+
 import math
+from types import ModuleType
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
 
+import numpy as np
+
 if TYPE_CHECKING:
     try:
         import ensight
@@ -28,14 +32,239 @@ if TYPE_CHECKING:
         from ansys.api.pyensight import ensight_api
 
 
+VIEW_DICT = {
+    "x+": (1, 0, 0),
+    "x-": (-1, 0, 0),
+    "y+": (0, 1, 0),
+    "y-": (0, -1, 0),
+    "z+": (0, 0, 1),
+    "z-": (0, 0, -1),
+    "isometric": (1, 1, 1),
+}
+
+
+class _Simba:
+    """Hidden class to manage the interactor layer in simba"""
+
+    def __init__(self, ensight: Union["ensight_api.ensight", "ensight"], views: "Views"):
+        self.ensight = ensight
+        self.views = views
+        self._original_look_at = None
+        self._original_look_from = None
+        self._original_parallel_scale = None
+        self._original_view_angle = None
+        self._original_view_up = None
+
+    def _initialize_simba_view(self):
+        """Initialize the data for resetting the camera."""
+        vport = self.ensight.objs.core.VPORTS[0]
+        near_clip = vport.ZCLIPLIMITS[0]
+        view_angle = 2 * vport.PERSPECTIVEANGLE
+        self._original_parallel_scale = near_clip * math.tan(math.radians(view_angle) / 2)
+        self._original_view_angle = view_angle
+        (
+            self._original_look_from,
+            self._original_look_at,
+            self._original_view_up,
+            self._original_parallel_scale,
+        ) = self.compute_camera_from_ensight_opengl()
+        self.ensight.annotation.axis_global("off")
+        self.ensight.annotation.axis_local("off")
+        self.ensight.annotation.axis_model("off")
+
+    def get_center_of_rotation(self):
+        """Get EnSight center of rotation."""
+        return self.ensight.objs.core.VPORTS[0].TRANSFORMCENTER
+
+    def auto_scale(self):
+        """Auto scale view."""
+        self.ensight.view_transf.fit()
+        self._initialize_simba_view()
+        self.render()
+        return self.get_camera()
+
+    def set_view(self, value: str):
+        """Set the view."""
+        if value != "isometric":
+            new_value = value[1].upper() + value[0]
+            self.ensight.view_transf.view_recall(new_value)
+        else:
+            self.views.set_view_direction(
+                1, 1, 1, perspective=self.ensight.objs.core.vports[0].PERSPECTIVE
+            )
+        self.auto_scale()
+        return self.get_camera()
+
+    def get_camera(self):
+        """Get EnSight camera settings in VTK format."""
+        vport = self.ensight.objs.core.VPORTS[0]
+        position, focal_point, view_up, parallel_scale = self.compute_camera_from_ensight_opengl()
+        vport = self.ensight.objs.core.VPORTS[0]
+        view_angle = 2 * vport.PERSPECTIVEANGLE
+        # The parameter parallel scale is the actual parallel scale only
+        # 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
+        return {
+            "orthographic": not vport.PERSPECTIVE,
+            "view_up": view_up,
+            "position": position,
+            "focal_point": focal_point,
+            "view_angle": view_angle,
+            "parallel_scale": parallel_scale,
+            "reset_focal_point": self._original_look_at,
+            "reset_position": self._original_look_from,
+            "reset_parallel_scale": self._original_parallel_scale,
+            "reset_view_up": self._original_view_up,
+            "reset_view_angle": self._original_view_angle,
+        }
+
+    @staticmethod
+    def normalize(v):
+        """Normalize a numpy vector."""
+        norm = np.linalg.norm(v)
+        return v / norm if norm > 0 else v
+
+    @staticmethod
+    def rotation_matrix_to_quaternion(m):
+        """Convert a numpy rotation matrix to a quaternion."""
+        trace = np.trace(m)
+        if trace > 0:
+            s = 0.5 / np.sqrt(trace + 1.0)
+            w = 0.25 / s
+            x = (m[2, 1] - m[1, 2]) * s
+            y = (m[0, 2] - m[2, 0]) * s
+            z = (m[1, 0] - m[0, 1]) * s
+        else:
+            if m[0, 0] > m[1, 1] and m[0, 0] > m[2, 2]:
+                s = 2.0 * np.sqrt(1.0 + m[0, 0] - m[1, 1] - m[2, 2])
+                w = (m[2, 1] - m[1, 2]) / s
+                x = 0.25 * s
+                y = (m[0, 1] + m[1, 0]) / s
+                z = (m[0, 2] + m[2, 0]) / s
+            elif m[1, 1] > m[2, 2]:
+                s = 2.0 * np.sqrt(1.0 + m[1, 1] - m[0, 0] - m[2, 2])
+                w = (m[0, 2] - m[2, 0]) / s
+                x = (m[0, 1] + m[1, 0]) / s
+                y = 0.25 * s
+                z = (m[1, 2] + m[2, 1]) / s
+            else:
+                s = 2.0 * np.sqrt(1.0 + m[2, 2] - m[0, 0] - m[1, 1])
+                w = (m[1, 0] - m[0, 1]) / s
+                x = (m[0, 2] + m[2, 0]) / s
+                y = (m[1, 2] + m[2, 1]) / s
+                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):
+            data = self.ensight.objs.core.VPORTS[0].simba_camera()
+        else:
+            data = self.ensight._session.cmd("ensight.objs.core.VPORTS[0].simba_camera())")
+        camera_position = [data[0], data[1], data[2]]
+        focal_point = [data[3], data[4], data[5]]
+        view_up = [data[6], data[7], data[8]]
+        parallel_scale = 1 / data[9]
+        return camera_position, focal_point, self.views._normalize_vector(view_up), parallel_scale
+
+    def set_camera(
+        self, orthographic, view_up=None, position=None, focal_point=None, view_angle=None
+    ):
+        """Set the EnSight camera settings from the VTK input."""
+        perspective = "OFF" if orthographic else "ON"
+        if orthographic:
+            self.ensight.view.perspective(perspective)
+        vport = self.ensight.objs.core.VPORTS[0]
+        if view_angle:
+            vport.PERSPECTIVEANGLE = view_angle / 2
+
+        if view_up and position and focal_point:
+            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)
+        self.render()
+
+    def set_perspective(self, value):
+        vport = self.ensight.objs.core.VPORTS[0]
+        self.ensight.view.perspective(value)
+        vport.PERSPECTIVE = value == "ON"
+        self.ensight.view_transf.zoom(1)
+        self.ensight.view_transf.rotate(0, 0, 0)
+        self.render()
+        return self.get_camera()
+
+    def screen_to_world(self, mousex, mousey, invert_y=False, set_center=False):
+        mousex = int(mousex)
+        mousey = int(mousey)
+        if isinstance(self.ensight, ModuleType):
+            model_point = self.ensight.objs.core.VPORTS[0].screen_to_coords(
+                mousex, mousey, invert_y, set_center
+            )
+        else:
+            model_point = self.ensight._session.cmd(
+                f"ensight.objs.core.VPORTS[0].screen_to_coords({mousex}, {mousey}, {invert_y}, {set_center})"
+            )
+        self.render()
+        return {"model_point": model_point, "camera": self.get_camera()}
+
+    def render(self):
+        self.ensight.render()
+        self.ensight.refresh(1)
+
+
 class Views:
     """Controls the view in the current EnSight ``Session`` instance."""
 
     def __init__(self, ensight: Union["ensight_api.ensight", "ensight"]):
         self.ensight = ensight
         self._views_dict: Dict[str, Tuple[int, List[float]]] = {}
+        self._simba = _Simba(ensight, self)
 
-    # Utilities
     @staticmethod
     def _normalize_vector(direction: List[float]) -> List[float]:
         """Return the normalized input (3D) vector.
@@ -295,14 +524,17 @@ class Views:
         vportindex : int, optional
             Viewport to set the view direction for. The default is ``0``.
         """
-        self.ensight.view.perspective("OFF")
-        direction = [xdir, ydir, zdir]
         vport = self.ensight.objs.core.VPORTS[vportindex]
+        if not perspective:
+            self.ensight.view.perspective("OFF")
+            vport.PERSPECTIVE = False
+        direction = [xdir, ydir, zdir]
         rots = vport.ROTATION.copy()
         rots[0:4] = self._convert_view_direction_to_quaternion(direction, up_axis=up_axis)
         vport.ROTATION = rots
         if perspective:
             self.ensight.view.perspective("ON")
+            vport.PERSPECTIVE = True
         self.save_current_view(name=name, vportindex=vportindex)
 
     def save_current_view(