pyvale 2025.5.3__cp311-cp311-musllinux_1_2_i686.whl

pyvale/integratorspatial.py

@@ -0,0 +1,89 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from abc import ABC, abstractmethod
+import numpy as np
+from pyvale.sensordata import SensorData
+
+
+def create_int_pt_array(sens_data: SensorData,
+                        int_pt_offsets: np.ndarray,
+                        ) -> np.ndarray:
+    """Creates the integration point locations in local coordinates based on the
+    specified offsets from the local origin.
+
+    Parameters
+    ----------
+    sens_data : SensorData
+        Contains the parameters of the sensor array including: positions, sample
+        times and orientations. If specified the sensor orientations are used
+        to rotate the positions of the integration points.
+    int_pt_offsets : np.ndarray
+        Offsets of the intergation points in non-rotated local coordinates.
+
+    Returns
+    -------
+    np.ndarray
+        The integration point locations in world (simulation) coordinates. The
+        rows of the array are all the integration points for all sensors and the
+        columns are the X,Y,Z coordinates. shape=(num_sensors*num_int_points,3).
+    """
+    n_sens = sens_data.positions.shape[0]
+    n_int_pts = int_pt_offsets.shape[0]
+
+    # shape=(n_sens*n_int_pts,n_dims)
+    offset_array = np.tile(int_pt_offsets,(n_sens,1))
+
+    if sens_data.angles is not None:
+        for ii,rr in enumerate(sens_data.angles):
+            offset_array[ii*n_int_pts:(ii+1)*n_int_pts,:] = \
+                np.matmul(rr.as_matrix(),int_pt_offsets.T).T
+
+    # shape=(n_sens*n_int_pts,n_dims)
+    int_pt_array = np.repeat(sens_data.positions,int_pt_offsets.shape[0],axis=0)
+
+    return int_pt_array + offset_array
+
+
+class IIntegratorSpatial(ABC):
+    """Interface (abstract base class) for spatial integrators. Used for
+    averaging sensor values over a given space.
+    """
+
+    @abstractmethod
+    def calc_averages(self, sens_data: SensorData) -> np.ndarray:
+        """Abstract method. Calculates the spatial average for each sensor using
+        the specified sensor dimensions and integration method. This is done by
+        interpolating the sensor values at each sensors integration points.
+
+        Parameters
+        ----------
+        sens_data : SensorData
+            Contains the parameters of the sensor array including: positions,
+            sample times, spatial averaging and orientations.
+
+        Returns
+        -------
+        np.ndarray
+            Array of simulated sensor measurements. shape=(num_sensors,
+            num_field_components,num_time_steps).
+        """
+
+
+    @abstractmethod
+    def get_averages(self) -> np.ndarray:
+        """Abstract method. Returns the previously calculated spatial averages
+        for each sensor. If these have not been calculated then `calc_averages`
+        is called and the result is returned.
+
+        Returns
+        -------
+        np.ndarray
+            Array of simulated sensor measurements. shape=(num_sensors,
+            num_field_components,num_time_steps).
+        """
+
+

pyvale/integratortype.py

@@ -0,0 +1,43 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import enum
+
+
+class EIntSpatialType(enum.Enum):
+    """Enumeration specifying the type of spatial integrator to build. Used for
+    spatial averaging for sensors.
+
+    RECT1PT
+        Rectangular 2D integrator splitting the area into 1 part.
+
+    RECT4PT
+        Rectangular 2D integrator splitting the area into 4 equal parts.
+
+    RECT9PT
+        Rectangular 2D integrator splitting the area into 9 equal parts.
+
+    QUAD4PT
+        Gaussian quadrature 2D integrator over 4 points.
+
+    QUAD9PT
+        Gaussian quadrature 2D integrator over 9 points.
+    """
+
+    RECT1PT = enum.auto()
+    """Rectangular 2D integrator splitting the area into 1 part."""
+
+    RECT4PT = enum.auto()
+    """Rectangular 2D integrator splitting the area into 4 equal parts."""
+
+    RECT9PT = enum.auto()
+    """Rectangular 2D integrator splitting the area into 9 equal parts."""
+
+    QUAD4PT = enum.auto()
+    """Gaussian quadrature 2D integrator over 4 points."""
+
+    QUAD9PT = enum.auto()
+    """Gaussia quadrature 2D integrator over 9 points."""

pyvale/output.py

@@ -0,0 +1,17 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+from dataclasses import dataclass
+from pathlib import Path
+
+"""
+NOTE: this module is a feature under developement.
+"""
+
+# TODO: remove this? but check blender tests
+
+@dataclass(slots=True)
+class Outputs():
+    base_dir = Path.home()

pyvale/pyvaleexceptions.py

@@ -0,0 +1,11 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+class BlenderError(Exception):
+    pass
+
+class VisError(Exception):
+    pass

pyvale/raster.py

@@ -0,0 +1,31 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: this module is a feature under developement.
+"""
+
+from abc import ABC, abstractmethod
+import numpy as np
+
+# NOTE:
+# - Need to render a single frame static/deformed
+# - Need to render all frames static/deformed
+class IRaster(ABC):
+    @abstractmethod
+    def render_static_frame() -> None:
+        pass
+
+    @abstractmethod
+    def render_deformed_frame() -> None:
+        pass
+
+
+# NOTE:
+# - Manages parallelisation/saving with different rendering backends
+# - Uses multi-processing
+class Raster:
+    pass

pyvale/rastercy.py

@@ -0,0 +1,77 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: this module is a feature under developement.
+"""
+
+from pathlib import Path
+from multiprocessing.pool import Pool
+import numpy as np
+from pyvale.cameradata import CameraData
+from pyvale.rendermesh import RenderMeshData
+import pyvale.cython.rastercyth as rastercyth
+
+class RasterCY:
+    @staticmethod
+    def raster_static_mesh(cam_data: CameraData,
+                           render_mesh: RenderMeshData,
+                           threads_num: int | None = None,
+                           ) -> tuple[np.ndarray,np.ndarray,np.ndarray] | None:
+
+        frames_num = render_mesh.fields_render.shape[1]
+        field_num = render_mesh.fields_render.shape[2]
+
+        images_out = np.empty((cam_data.pixels_num[1],
+                            cam_data.pixels_num[0],
+                            frames_num,
+                            field_num))
+        depths_out = np.empty((cam_data.pixels_num[1],
+                            cam_data.pixels_num[0],
+                            frames_num))
+        elems_out = np.empty((frames_num,))
+
+        if threads_num is None:
+            for tt in range(frames_num):
+                (image_buffer,
+                depth_buffer,
+                elems_in_image) = rastercyth.raster_frame(
+                                            render_mesh.coords,
+                                            render_mesh.connectivity,
+                                            render_mesh.fields_render[:,tt,:],
+                                            cam_data)
+
+                images_out[:,:,tt,:] = image_buffer
+                depths_out[:,:,tt] = depth_buffer
+                elems_out[tt] = elems_in_image
+
+        else:
+            assert threads_num > 0, "Number of threads must be greater than 0."
+
+            with Pool(threads_num) as pool:
+                processes_with_id = []
+
+                for tt in range(frames_num):
+                    args = (render_mesh.coords,
+                            render_mesh.connectivity,
+                            render_mesh.fields_render[:,tt,:],
+                            cam_data)
+
+                    process = pool.apply_async(rastercyth.raster_frame, args=args)
+                    processes_with_id.append({"process": process,
+                                              "frame": tt})
+
+                for pp in processes_with_id:
+                    (image,depth,elems) = pp["process"].get()
+                    images_out[:,:,pp["frame"],:] = image
+                    depths_out[:,:,pp["frame"]] = depth
+                    elems_out = elems
+
+        return (images_out,depths_out,elems_out)
+
+
+
+