pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/sensorsim/integratorrectangle.py

@@ -0,0 +1,165 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+from pyvale.sensorsim.field import IField
+from pyvale.sensorsim.integratorspatial import (IIntegratorSpatial,
+                                           create_int_pt_array)
+from pyvale.sensorsim.sensordata import SensorData
+
+#NOTE: code below is very similar to quadrature integrator should be able to
+# refactor into injected classes/functions
+
+class Rectangle2D(IIntegratorSpatial):
+    """Rectangular numerical integrator for spatial averaging in 2D. Used to
+    model spatial averaging of sensors over a rectangular area which is
+    specified in the SensorData object. Handles sampling of the physical field
+    at the integration points and averages them back to a single value per
+    sensor location as specified in the SensorData object.
+
+    Implements the `IIntegratorSpatial` interface allowing for interoperability
+    of different spatial integration algorithms for modelling sensor averaging.
+    """
+    __slots__ = ("_field","sens_data","_area","_area_int","_n_int_pts",
+                 "_int_pt_offsets","_int_pts","_averages")
+
+    def __init__(self,
+                 field: IField,
+                 sens_data: SensorData,
+                 int_pt_offsets: np.ndarray) -> None:
+        """
+        Parameters
+        ----------
+        field : IField
+            A physical field interface that will be sampled at the integration
+            points and averaged back to single value per sensor.
+        sens_data : SensorData
+            Parameters of the sensor array including the sensor locations,
+            sampling times, type of spatial integrator and its dimensions. See
+            the `SensorData` dataclass for more details.
+        int_pt_offsets : np.ndarray
+            Offsets from the central location of the integration area with
+            shape=(n_gauss_pts,coord[X,Y,Z])
+        """
+        self._field = field
+        self._sens_data = sens_data
+
+        self._area = (self._sens_data.spatial_dims[0]
+                      * self._sens_data.spatial_dims[1])
+        self._area_int = self._area/int_pt_offsets.shape[0]
+
+        self._n_int_pts = int_pt_offsets.shape[0]
+        self._int_pt_offsets = int_pt_offsets
+        self._int_pts = create_int_pt_array(self._sens_data,
+                                            self._int_pt_offsets)
+
+        self._averages = None
+
+
+    def calc_integrals(self, sens_data: SensorData | None = None) -> np.ndarray:
+        """Calculates the numerical integrals for each sensor based on the
+        specified sensor data and numerical integration options (i.e. geometry
+        and integration points).
+
+        Parameters
+        ----------
+        sens_data : SensorData | None, optional
+            Specifies the sensor parameters used to calculate the averages, by
+            default None. Is a sensor data object is passed a reference to that
+            object is stored by this class and used in later calculations. If
+            None then it uses the SensorData object stored by this class.
+            Defaults to None.
+
+        Returns
+        -------
+        np.ndarray
+            Array of virtual sensor integrals with shape=(n_sensors,n_comps,
+            n_timsteps). Note this is consistent with pyvales measurement array.
+        """
+        self._averages = self.calc_averages(sens_data)
+        return self._area*self.get_averages()
+
+
+    def get_integrals(self) -> np.ndarray:
+        """Gets the most recent calculation of the spatial averages for all
+        sensors in the sensor array without performing any new interpolation. If
+        the averages have not been calculated they are first calculated and then
+        returned.
+
+        Returns
+        -------
+        np.ndarray
+            Array of virtual sensor averages with shape=(n_sensors,n_comps,
+            n_timsteps). Note this is consistent with pyvales measurement array.
+        """
+        return self._area*self.get_averages()
+
+    def calc_averages(self, sens_data: SensorData | None = None) -> np.ndarray:
+        """Calculates the spatial averages for each sensor based on the
+        specified sensor data and numerical integration options (i.e. geometry
+        and integration points).
+
+        Parameters
+        ----------
+        sens_data : SensorData | None, optional
+            Specifies the sensor parameters used to calculate the averages, by
+            default None. Is a sensor data object is passed a reference to that
+            object is stored by this class and used in later calculations. If
+            None then it uses the SensorData object stored by this class.
+            Defaults to None.
+
+        Returns
+        -------
+        np.ndarray
+            Array of virtual sensor averages with shape=(n_sensors,n_comps,
+            n_timsteps). Note this is consistent with pyvales measurement array.
+        """
+        if sens_data is not None:
+            self._sens_data = sens_data
+
+        # shape=(n_sens*n_int_pts,n_dims)
+        self._int_pts = create_int_pt_array(self._sens_data,
+                                            self._int_pt_offsets)
+
+
+        # shape=(n_int_pts*n_sens,n_comps,n_timesteps)
+        int_vals = self._field.sample_field(self._int_pts,
+                                            self._sens_data.sample_times,
+                                            self._sens_data.angles)
+
+        meas_shape = (self._sens_data.positions.shape[0],
+                      int_vals.shape[1],
+                      int_vals.shape[2])
+
+        # shape=(n_gauss_pts,n_sens,n_comps,n_timesteps)
+        int_vals = int_vals.reshape((self._n_int_pts,)+meas_shape,
+                                     order='F')
+
+        # shape=(n_sensors,n_comps,n_timsteps)
+        self._averages = 1/self._area * np.sum(self._area_int*int_vals,axis=0)
+
+        return self._averages
+
+
+    def get_averages(self) -> np.ndarray:
+        """Gets the most recent calculation of the spatial averages for all
+        sensors in the sensor array without performing any new interpolation. If
+        the averages have not been calculated they are first calculated and then
+        returned.
+
+        Returns
+        -------
+        np.ndarray
+            Array of virtual sensor averages with shape=(n_sensors,n_comps,
+            n_timsteps). Note this is consistent with pyvales measurement array.
+        """
+        if self._averages is None:
+            self._averages = self.calc_averages()
+
+        return self._averages
+
+
+

pyvale/sensorsim/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.sensorsim.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/sensorsim/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/sensorsim/logger.py

@@ -0,0 +1,23 @@
+import logging
+import logging.handlers
+import sys
+
+class Logger():
+
+    def __init__(self,
+                 logger_name: str = __name__,
+                 logger = None):
+        
+        self.logger_name = logger_name
+
+    def make_logger(self):
+        logger = logging.getLogger(self.logger_name)
+        file_handler = logging.FileHandler("plotter_log.log", mode = 'a')
+        logger.addHandler(file_handler)
+
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        file_handler.setFormatter(formatter)
+        self.logger = logger
+
+    def put_error(self):
+        self.logger.error("This error came from a Logger object")

pyvale/sensorsim/plotting_logs.py

@@ -0,0 +1,22 @@
+import logging
+import logging.handlers
+import sys
+
+logger = logging.getLogger(__name__)
+
+logger.setLevel(logging.DEBUG)
+
+file_handler = logging.FileHandler("plotter_log.log", mode = 'a')
+console_handler = logging.StreamHandler()
+
+file_handler.setLevel(logging.DEBUG)
+console_handler.setLevel(logging.DEBUG)
+
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+file_handler.setFormatter(formatter)
+console_handler.setFormatter(formatter)
+
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
+
+console_handler.setLevel(30)

pyvale/sensorsim/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/sensorsim/rastercy.py

@@ -0,0 +1,107 @@
+# ==============================================================================
+# 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.sensorsim.cameradata import CameraData
+from pyvale.sensorsim.rendermesh import RenderMesh
+from pyvale.sensorsim.renderer import IRenderer
+from pyvale.sensorsim.rasteropts import RasterOpts
+import pyvale.sensorsim.cython.rastercyth as rastercyth
+
+# NOTE: This module is a feature under developement.
+
+
+# class RasterCyth(IRenderEngine):
+#     __slots__ = ("opts",)
+
+#     def __init__(self, opts: RasterOpts) -> None:
+#         self.opts = opts
+
+
+#     def one_frame(self, frame_ind: int = 0) -> list[np.ndarray]:
+#         pass
+
+
+#     def all_frames(self, para_by_frame: int = 1) -> list[np.ndarray]:
+#         pass
+
+
+#     def one_frame_to_disk(self, frame_ind: int = 0) -> None:
+#         pass
+
+
+#     def all_frames_to_disk(self, para_by_frame: int = 1) -> None:
+#         pass
+
+
+
+
+class RasterCY:
+    @staticmethod
+    def raster_static_mesh(cam_data: CameraData,
+                           render_mesh: RenderMesh,
+                           workers: 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 workers is None:
+            for tt in range(frames_num):
+                (image_buffer,
+                depth_buffer,
+                elems_in_image) = rastercyth.raster_static_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 workers > 0, "Number of threads must be greater than 0."
+
+            with Pool(workers) 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_static_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)
+
+
+
+