ansys-speos-core 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

ansys/speos/core/body.py

@@ -29,6 +29,8 @@ from typing import List, Mapping, Optional, Union
 
 from ansys.speos.core import proto_message_utils
 import ansys.speos.core.face as face
+import ansys.speos.core.generic.general_methods as general_methods
+from ansys.speos.core.generic.visualization_methods import _VisualData
 from ansys.speos.core.geo_ref import GeoRef
 from ansys.speos.core.kernel.body import ProtoBody
 from ansys.speos.core.kernel.client import SpeosClient
@@ -72,6 +74,7 @@ class Body:
         self._parent_part = parent_part
         self._name = name
         self.body_link = None
+        self._visual_data = _VisualData() if general_methods._GRAPHICS_AVAILABLE else None
         """Link object for the body in database."""
 
         if metadata is None:
@@ -82,6 +85,30 @@ class Body:
 
         self._geom_features = []
 
+    @property
+    def visual_data(self):
+        """Property containing irradiance sensor visualization data.
+
+        Returns
+        -------
+        VisualData
+            Instance of VisualData Class for pyvista.PolyData of feature faces, coordinate_systems.
+
+        """
+        import numpy as np
+
+        if self._visual_data.updated is True:
+            return self._visual_data
+        for feature_face in self._geom_features:
+            vertices = np.array(feature_face._face.vertices).reshape(-1, 3)
+            facets = np.array(feature_face._face.facets).reshape(-1, 3)
+            temp = np.full(facets.shape[0], 3)
+            temp = np.vstack(temp)
+            facets = np.hstack((temp, facets))
+            self._visual_data.add_data_mesh(vertices, facets)
+        self._visual_data.updated = True
+        return self._visual_data
+
     @property
     def geo_path(self) -> GeoRef:
         """Geometry path to be used within other speos objects."""
@@ -159,6 +186,9 @@ class Body:
         ansys.speos.core.body.Body
             Body feature.
         """
+        if general_methods._GRAPHICS_AVAILABLE:
+            self._visual_data.updated = False
+
         # Commit faces contained in this body
         for g in self._geom_features:
             g.commit()

ansys/speos/core/generic/constants.py

@@ -28,7 +28,7 @@ DEFAULT_HOST: str = "localhost"
 """Default host used by Speos RPC server and client """
 DEFAULT_PORT: str = "50098"
 """Default port used by Speos RPC server and client """
-DEFAULT_VERSION: str = "251"
+DEFAULT_VERSION: str = "252"
 """Latest supported Speos version of the current PySpeos Package"""
 MAX_SERVER_MESSAGE_LENGTH: int = int(os.environ.get("SPEOS_MAX_MESSAGE_LENGTH", 256 * 1024**2))
 """Maximum message length value accepted by the Speos RPC server,

ansys/speos/core/generic/general_methods.py

@@ -25,6 +25,8 @@
 this includes decorator and methods
 """
 
+from __future__ import annotations
+
 from collections.abc import Collection
 from functools import lru_cache, wraps
 import os
@@ -44,6 +46,8 @@ GRAPHICS_ERROR = (
     "You can install this using `pip install ansys-speos-core[graphics]`."
 )
 
+VERSION_ERROR = "The pySpeos feature : {feature_name} needs a Speos Version of {version} or higher."
+
 
 def deprecate_kwargs(old_arguments: dict, removed_version="0.3.0"):
     """Issues deprecation warnings for arguments.
@@ -230,3 +234,82 @@ def retrieve_speos_install_dir(
     if not speos_exec.is_file():
         error_no_install(speos_rpc_path, int(version))
     return speos_rpc_path
+
+
+def wavelength_to_rgb(wavelength: float, gamma: float = 0.8) -> [int, int, int, int]:
+    """Convert a given wavelength of light to an approximate RGB color value.
+
+    The wavelength must be given in nanometers in the range from 380 nm to 750 nm.
+    Based on the code from http://www.physics.sfasu.edu/astro/color/spectra.html
+
+    Parameters
+    ----------
+    wavelength : float
+        Wavelength in nanometer between 380-750 nm
+    gamma : float
+        Gamma value.
+        By default : ``0.8``
+    """
+    wavelength = float(wavelength)
+    if 380 <= wavelength <= 440:
+        attenuation = 0.3 + 0.7 * (wavelength - 380) / (440 - 380)
+        r = ((-(wavelength - 440) / (440 - 380)) * attenuation) ** gamma
+        g = 0.0
+        b = (1.0 * attenuation) ** gamma
+    elif 440 <= wavelength <= 490:
+        r = 0.0
+        g = ((wavelength - 440) / (490 - 440)) ** gamma
+        b = 1.0
+    elif 490 <= wavelength <= 510:
+        r = 0.0
+        g = 1.0
+        b = (-(wavelength - 510) / (510 - 490)) ** gamma
+    elif 510 <= wavelength <= 580:
+        r = ((wavelength - 510) / (580 - 510)) ** gamma
+        g = 1.0
+        b = 0.0
+    elif 580 <= wavelength <= 645:
+        r = 1.0
+        g = (-(wavelength - 645) / (645 - 580)) ** gamma
+        b = 0.0
+    elif 645 <= wavelength <= 750:
+        attenuation = 0.3 + 0.7 * (750 - wavelength) / (750 - 645)
+        r = (1.0 * attenuation) ** gamma
+        g = 0.0
+        b = 0.0
+    else:
+        r = 0.0
+        g = 0.0
+        b = 0.0
+    r *= 255
+    g *= 255
+    b *= 255
+    return [int(r), int(g), int(b), 255]
+
+
+def min_speos_version(major: int, minor: int, service_pack: int):
+    """Raise version warning.
+
+    Parameters
+    ----------
+    major : int
+        Major release version, e.g. 25
+    minor : int
+        Minor release version e.g. 1
+    service_pack : int
+        Service Pack version e.g. 3
+    """
+    version = f"20{major} R{minor} SP{service_pack}"
+
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            if function.__qualname__.endswith("__init__"):
+                name = function.__qualname__[:-9]
+            else:
+                name = function.__qualname__
+            warnings.warn(VERSION_ERROR.format(version=version, feature_name=name), stacklevel=2)
+            return function(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

ansys/speos/core/generic/visualization_methods.py

@@ -22,7 +22,9 @@
 
 """Provides the ``VisualData`` class."""
 
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Tuple, Union
+
+import numpy as np
 
 from ansys.speos.core.generic.general_methods import (
     graphics_required,
@@ -36,7 +38,7 @@ if TYPE_CHECKING:  # pragma: no cover
 
 @graphics_required
 class _VisualCoordinateSystem:
-    """Visualization data for the coordinate system..
+    """Visualization data for the coordinate system.
 
     By default, there is empty visualization data.
 
@@ -52,21 +54,21 @@ class _VisualCoordinateSystem:
         self.__x_axis = pv.Arrow(
             start=self.__origin,
             direction=[1.0, 0.0, 0.0],
-            scale=10.0,
+            scale=1.0,
             tip_radius=0.05,
             shaft_radius=0.01,
         )
         self.__y_axis = pv.Arrow(
             start=self.__origin,
             direction=[0.0, 1.0, 0.0],
-            scale=10.0,
+            scale=1.0,
             tip_radius=0.05,
             shaft_radius=0.01,
         )
         self.__z_axis = pv.Arrow(
             start=self.__origin,
             direction=[0.0, 0.0, 1.0],
-            scale=10.0,
+            scale=1.0,
             tip_radius=0.05,
             shaft_radius=0.01,
         )
@@ -214,6 +216,72 @@ class _VisualCoordinateSystem:
         )
 
 
+@graphics_required
+class _VisualArrow:
+    """Visualization data for the line or arrow.
+
+    By default, there is empty visualization data.
+
+    Notes
+    -----
+    **Do not instantiate this class yourself**.
+    """
+
+    def __init__(
+        self,
+        line_vertices: List[List[float]],
+        color: Tuple[float, float, float] = (0.643, 1.0, 0.0),
+        arrow: bool = False,
+    ) -> None:
+        import pyvista as pv
+
+        if len(line_vertices) != 2 or any(len(point) != 3 for point in line_vertices):
+            raise ValueError(
+                "line_vertices is expected to be composed of 2 vertices with 3 elements each."
+            )
+        line_vertices = np.array(line_vertices)
+        if arrow:
+            self.__data = pv.Arrow(
+                start=line_vertices[0],
+                direction=line_vertices[1],
+                scale=1,
+                tip_radius=0.05,
+                shaft_radius=0.01,
+            )
+        else:
+            self.__data = pv.Line(line_vertices[0], line_vertices[0] + line_vertices[1])
+        if all(value < 1 for value in color):
+            self.__color = color + (255,)
+        else:
+            self.__color = tuple(value / 255 for value in color) + (255,)
+
+    @property
+    def data(self) -> "pv.PolyData":
+        """
+        Returns the pyvista data of _VisualArrow.
+
+        Returns
+        -------
+        pv.PolyData
+            The pyvista data of _VisualArrow.
+
+        """
+        return self.__data
+
+    @property
+    def color(self) -> Tuple[float, float, float]:
+        """
+        Returns the color property of _VisualArrow.
+
+        Returns
+        -------
+        Tuple[float, float, float]
+            The color tuple of _VisualArrow.
+
+        """
+        return self.__color
+
+
 @graphics_required
 class _VisualData:
     """Visualization data for the sensor.
@@ -225,25 +293,26 @@ class _VisualData:
     **Do not instantiate this class yourself**
     """
 
-    def __init__(self, coordinate_system=True):
+    def __init__(self, ray: bool = False, coordinate_system: bool = True):
         import pyvista as pv
 
-        self.__data = pv.PolyData()
+        self._data = [] if ray else pv.PolyData()
         self.coordinates = _VisualCoordinateSystem() if coordinate_system else None
         self.updated = False
 
     @property
-    def data(self) -> "pv.PolyData":
+    def data(self) -> Union["pv.PolyData", List[_VisualArrow]]:
         """
-        Returns the data of the sensor.
+        Returns the pyvista data of _VisualData.
 
         Returns
         -------
-        pv.PolyData
-            The data of the surface visualization.
+        Union["pv.PolyData", List[_VisualArrow]]
+            The data of the surface visualization if surface data,
+            else List[_VisualArrow] containing ray info.
 
         """
-        return self.__data
+        return self._data
 
     def add_data_triangle(self, triangle_vertices: List[List[float]]) -> None:
         """
@@ -265,7 +334,7 @@ class _VisualData:
                 "triangle_vertices is expected to be composed of 3 vertices with 3 elements each."
             )
         faces = [[3, 0, 1, 2]]
-        self.__data = self.__data.append_polydata(pv.PolyData(triangle_vertices, faces))
+        self._data = self._data.append_polydata(pv.PolyData(triangle_vertices, faces))
 
     def add_data_rectangle(self, rectangle_vertices: List[List[float]]) -> None:
         """
@@ -286,4 +355,68 @@ class _VisualData:
             raise ValueError(
                 "rectangle_vertices is expected to be composed of 3 vertices with 3 elements each."
             )
-        self.__data = self.__data.append_polydata(pv.Rectangle(rectangle_vertices))
+        self._data = self._data.append_polydata(pv.Rectangle(rectangle_vertices))
+
+    def add_data_line(self, line: _VisualArrow) -> None:
+        """
+        Add line data to Visualization data.
+
+        Parameters
+        ----------
+        line: _VisualArrow
+            _VisualArrow presenting one line
+
+        Returns
+        -------
+        None
+        """
+        self._data.append(line)
+
+    def add_data_mesh(self, vertices: np.ndarray, facets: np.ndarray) -> None:
+        """
+        Add mesh data to Visualization data.
+
+        Parameters
+        ----------
+        vertices: numpy.ndarray
+            The vertices of the mesh.
+        facets: numpy.ndarray
+            The facets of the mesh.
+
+        Returns
+        -------
+        None
+        """
+        import pyvista as pv
+
+        if vertices.shape[1] != 3 or facets.shape[1] != 4:
+            raise ValueError(
+                "mesh vertices is expected to be composed of 3 elements each, and 4 for facets."
+            )
+        self._data = self._data.append_polydata(pv.PolyData(vertices, facets))
+
+
+def local2absolute(local_vertice: np.ndarray, coordinates) -> np.ndarray:
+    """Convert local coordinate to global coordinate.
+
+    Parameters
+    ----------
+    coordinates: list
+        local coordinate in shape [1, 9],
+        coordinates[3:6] as x-axis,
+        coordinates[3:6] as y-axis,
+        coordinates[3:6] as z-axis.
+    local_vertice: np.ndarray
+        numpy array includes x, y, z info.
+
+    Returns
+    -------
+    np.ndarray
+        numpy array includes x, y, z info
+
+    """
+    global_origin = np.array(coordinates[:3])
+    global_x = np.array(coordinates[3:6]) * local_vertice[0]
+    global_y = np.array(coordinates[6:9]) * local_vertice[1]
+    global_z = np.array(coordinates[9:]) * local_vertice[2]
+    return global_origin + global_x + global_y + global_z

ansys/speos/core/kernel/face.py

@@ -24,10 +24,13 @@
 
 from typing import Iterator, List
 
+from grpc import RpcError
+
 from ansys.api.speos.part.v1 import (
     face_pb2 as messages,
     face_pb2_grpc as service,
 )
+from ansys.speos.core.generic.general_methods import min_speos_version
 from ansys.speos.core.kernel.crud import CrudItem, CrudStub
 from ansys.speos.core.kernel.proto_message_utils import protobuf_message_to_str
 
@@ -102,6 +105,50 @@ class FaceStub(CrudStub):
     def __init__(self, channel):
         super().__init__(stub=service.FacesManagerStub(channel=channel))
         self._actions_stub = service.FaceActionsStub(channel=channel)
+        self._is_batch_available = self._check_if_batch_available()
+
+    def _check_if_batch_available(self) -> bool:
+        try:
+            for reserve_faces_res in self._actions_stub.ReserveFaces(
+                FaceStub._reserve_face_iterator([ProtoFace(name="tmp")])
+            ):
+                FaceLink(self, reserve_faces_res.guids[0]).delete()
+            return True
+        except RpcError:
+            return False
+
+    @min_speos_version(25, 2, 0)
+    def create_batch(self, message_list: List[ProtoFace]) -> List[FaceLink]:
+        """Create new entries.
+
+        Parameters
+        ----------
+        message_list : List[face.Face]
+            List of datamodels for the new entries.
+
+        Returns
+        -------
+        List[ansys.speos.core.kernel.face.FaceLink]
+            List pf link objects created.
+        """
+        if not self._is_batch_available:
+            raise NotImplementedError("Please use a Speos Version of 2025 R2 SP0 or higher.")
+
+        reserve_faces_res = self._actions_stub.ReserveFaces(
+            FaceStub._reserve_face_iterator(message_list)
+        )
+
+        guids = []
+        for res in reserve_faces_res:
+            for guid in res.guids:
+                guids.append(guid)
+
+        chunk_iterator = FaceStub._faces_to_chunks(
+            guids=guids, message_list=message_list, nb_items=128 * 1024
+        )
+        self._actions_stub.Upload(chunk_iterator)
+
+        return [FaceLink(self, guid) for guid in guids]
 
     def create(self, message: ProtoFace) -> FaceLink:
         """Create a new entry.
@@ -118,13 +165,37 @@ class FaceStub(CrudStub):
         """
         resp = CrudStub.create(self, messages.Create_Request(face=ProtoFace(name="tmp")))
 
-        chunk_iterator = FaceStub._face_to_chunks(
-            guid=resp.guid, message=message, nb_items=128 * 1024
+        chunk_iterator = FaceStub._faces_to_chunks(
+            guids=[resp.guid], message_list=[message], nb_items=128 * 1024
         )
         self._actions_stub.Upload(chunk_iterator)
-
         return FaceLink(self, resp.guid)
 
+    @min_speos_version(25, 2, 0)
+    def read_batch(self, refs: List[FaceLink]) -> List[ProtoFace]:
+        """Get existing entries.
+
+        Parameters
+        ----------
+        refs : List[ansys.speos.core.kernel.face.FaceLink]
+            List of link objects to read.
+
+        Returns
+        -------
+        List[face.Face]
+            Datamodels of the entries.
+        """
+        if not self._is_batch_available:
+            raise NotImplementedError("Please use a Speos Version of 2025 R2 SP0 or higher.")
+
+        for ref in refs:
+            if not ref.stub == self:
+                raise ValueError("FaceLink is not on current database. Key=" + ref.key)
+        chunks = self._actions_stub.Download(
+            request=messages.Download_Request(guids=[ref.key for ref in refs])
+        )
+        return FaceStub._chunks_to_faces(chunks)
+
     def read(self, ref: FaceLink) -> ProtoFace:
         """Get an existing entry.
 
@@ -139,9 +210,34 @@ class FaceStub(CrudStub):
             Datamodel of the entry.
         """
         if not ref.stub == self:
-            raise ValueError("FaceLink is not on current database")
+            raise ValueError("FaceLink is not on current database. Key=" + ref.key)
+
         chunks = self._actions_stub.Download(request=messages.Download_Request(guid=ref.key))
-        return FaceStub._chunks_to_face(chunks)
+        return FaceStub._chunks_to_faces(chunks)[0]
+
+    @min_speos_version(25, 2, 0)
+    def update_batch(self, refs: List[FaceLink], data: List[ProtoFace]) -> None:
+        """Change existing entries.
+
+        Parameters
+        ----------
+        ref : List[ansys.speos.core.kernel.face.FaceLink]
+            Link objects to update.
+
+        data : List[face.Face]
+            New datamodels for the entries.
+        """
+        if not self._is_batch_available:
+            raise NotImplementedError("Please use a Speos Version of 2025 R2 SP0 or higher.")
+
+        for ref in refs:
+            if not ref.stub == self:
+                raise ValueError("FaceLink is not on current database")
+
+        chunk_iterator = FaceStub._faces_to_chunks(
+            guids=[ref.key for ref in refs], message_list=data, nb_items=128 * 1024
+        )
+        self._actions_stub.Upload(chunk_iterator)
 
     def update(self, ref: FaceLink, data: ProtoFace) -> None:
         """Change an existing entry.
@@ -157,11 +253,9 @@ class FaceStub(CrudStub):
         if not ref.stub == self:
             raise ValueError("FaceLink is not on current database")
 
-        CrudStub.update(
-            self,
-            messages.Update_Request(guid=ref.key, face=ProtoFace(name="tmp")),
+        chunk_iterator = FaceStub._faces_to_chunks(
+            guids=[ref.key], message_list=[data], nb_items=128 * 1024
         )
-        chunk_iterator = FaceStub._face_to_chunks(guid=ref.key, message=data, nb_items=128 * 1024)
         self._actions_stub.Upload(chunk_iterator)
 
     def delete(self, ref: FaceLink) -> None:
@@ -188,47 +282,63 @@ class FaceStub(CrudStub):
         return list(map(lambda x: FaceLink(self, x), guids))
 
     @staticmethod
-    def _face_to_chunks(guid: str, message: ProtoFace, nb_items: int) -> Iterator[messages.Chunk]:
-        for j in range(4):
-            if j == 0:
-                chunk_face_header = messages.Chunk(
-                    face_header=messages.Chunk.FaceHeader(
-                        guid=guid,
-                        name=message.name,
-                        description=message.description,
-                        metadata=message.metadata,
-                        sizes=[
-                            len(message.vertices),
-                            len(message.facets),
-                            len(message.texture_coordinates_channels),
-                        ],
-                    )
-                )
-                yield chunk_face_header
-            elif j == 1:
-                for i in range(0, len(message.vertices), nb_items):
-                    chunk_vertices = messages.Chunk(
-                        vertices=messages.Chunk.Vertices(data=message.vertices[i : i + nb_items])
-                    )
-                    yield chunk_vertices
-            elif j == 2:
-                for i in range(0, len(message.facets), nb_items):
-                    chunk_facets = messages.Chunk(
-                        facets=messages.Chunk.Facets(data=message.facets[i : i + nb_items])
-                    )
-                    yield chunk_facets
-            elif j == 3:
-                for i in range(0, len(message.normals), nb_items):
-                    chunk_normals = messages.Chunk(
-                        normals=messages.Chunk.Normals(data=message.normals[i : i + nb_items])
+    def _reserve_face_iterator(
+        message_list: List[ProtoFace],
+    ) -> Iterator[messages.ReserveFace_Request]:
+        for message in message_list:
+            yield messages.ReserveFace_Request(faces=[ProtoFace(name="tmp")])
+
+    @staticmethod
+    def _faces_to_chunks(
+        guids: List[str], message_list: List[ProtoFace], nb_items: int
+    ) -> Iterator[messages.Chunk]:
+        for guid, message in zip(guids, message_list):
+            for j in range(4):
+                if j == 0:
+                    chunk_face_header = messages.Chunk(
+                        face_header=messages.Chunk.FaceHeader(
+                            guid=guid,
+                            name=message.name,
+                            description=message.description,
+                            metadata=message.metadata,
+                            sizes=[
+                                len(message.vertices),
+                                len(message.facets),
+                                len(message.vertices_data),
+                            ],
+                        )
                     )
-                    yield chunk_normals
+                    yield chunk_face_header
+                elif j == 1:
+                    for i in range(0, len(message.vertices), nb_items):
+                        chunk_vertices = messages.Chunk(
+                            vertices=messages.Chunk.Vertices(
+                                data=message.vertices[i : i + nb_items]
+                            )
+                        )
+                        yield chunk_vertices
+                elif j == 2:
+                    for i in range(0, len(message.facets), nb_items):
+                        chunk_facets = messages.Chunk(
+                            facets=messages.Chunk.Facets(data=message.facets[i : i + nb_items])
+                        )
+                        yield chunk_facets
+                elif j == 3:
+                    for i in range(0, len(message.normals), nb_items):
+                        chunk_normals = messages.Chunk(
+                            normals=messages.Chunk.Normals(data=message.normals[i : i + nb_items])
+                        )
+                        yield chunk_normals
 
     @staticmethod
-    def _chunks_to_face(chunks: messages.Chunk) -> ProtoFace:
+    def _chunks_to_faces(chunks: messages.Chunk) -> List[ProtoFace]:
+        out_faces = []
         out_face = ProtoFace()
         for chunk in chunks:
             if chunk.HasField("face_header"):
+                if out_face != ProtoFace():  # Add face each time a new one starts
+                    out_faces.append(out_face)
+                    out_face = ProtoFace()
                 out_face.name = chunk.face_header.name
                 out_face.description = chunk.face_header.description
                 out_face.metadata.update(chunk.face_header.metadata)
@@ -239,4 +349,5 @@ class FaceStub(CrudStub):
             if chunk.HasField("normals"):
                 out_face.normals.extend(chunk.normals.data)
 
-        return out_face
+        out_faces.append(out_face)  # Don't forget to add last face
+        return out_faces

ansys/speos/core/kernel/proto_message_utils.py

@@ -57,6 +57,7 @@ def protobuf_message_to_str(message: Message, with_full_name: bool = True) -> st
             including_default_value_fields=True,
             preserving_proto_field_name=True,
             indent=4,
+            ensure_ascii=False,
         )
     else:
         ret += MessageToJson(
@@ -64,6 +65,7 @@ def protobuf_message_to_str(message: Message, with_full_name: bool = True) -> st
             always_print_fields_with_no_presence=True,
             preserving_proto_field_name=True,
             indent=4,
+            ensure_ascii=False,
         )
     return ret