pyvale 2025.5.3__cp311-cp311-musllinux_1_2_aarch64.whl → 2025.7.1__cp311-cp311-musllinux_1_2_aarch64.whl

pyvale/__init__.py

@@ -46,6 +46,7 @@ from pyvale.camerastereo import *
 import pyvale.cython.rastercyth as rastercyth
 from pyvale.rastercy import *
 
+from pyvale.renderscene import *
 from pyvale.rendermesh import *
 from pyvale.rasternp import *
 
@@ -87,3 +88,14 @@ from pyvale.simtools import *
 from pyvale.output import *
 from pyvale.pyvaleexceptions import *
 
+from pyvale.experimentsimulator import *
+
+from pyvale.dicspecklegenerator import *
+from pyvale.dicspecklequality import *
+from pyvale.dicregionofinterest import *
+from pyvale.dic2d import *
+from pyvale.dicdataimport import *
+from pyvale.dicresults import *
+from pyvale.dic2dcpp import *
+from pyvale.dicstrain import *
+from pyvale.dicchecks import *

pyvale/blendercalibrationdata.py

@@ -12,4 +12,6 @@ class CalibrationData:
     angle_lims: tuple = (-10, 10)
     angle_step: int = 5
     plunge_lims: tuple = (-5, 5)
-    plunge_step: int = 5
+    plunge_step: int = 5
+    x_limit: float | None = None
+    y_limit: float | None = None

pyvale/blenderscene.py

@@ -13,7 +13,7 @@ from pyvale.simtools import SimTools
 from pyvale.blendermaterialdata import BlenderMaterialData
 from pyvale.blenderrenderdata import RenderData, RenderEngine
 from pyvale.camerastereo import CameraStereo
-from pyvale.rendermesh import RenderMeshData
+from pyvale.rendermesh import RenderMesh
 from pyvale.pyvaleexceptions import BlenderError
 
 
@@ -94,12 +94,14 @@ class BlenderScene():
             new_cam.dof.use_dof = True
             new_cam.dof.aperture_fstop = cam_data.fstop
 
+        new_cam.clip_end = ((cam_data.pos_world[2] - cam_data.roi_cent_world[2])
+                            + 100)
+
         bpy.context.scene.camera = camera
         return camera
 
     def add_stereo_system(self, stereo_system: CameraStereo) -> tuple[bpy.data.objects,
                                                            bpy.data.objects]:
-        # TODO: Correct docstring
         """A method to add a stereo camera system within Blender, given an
         instance of the CameraStereo class (that describes a stereo system).
 
@@ -152,7 +154,7 @@ class BlenderScene():
         return light_ob
 
     def add_part(self,
-                 render_mesh: RenderMeshData,
+                 render_mesh: RenderMesh,
                  sim_spat_dim: int) -> bpy.data.objects:
         """A method to add a part mesh into Blender, given a RenderMeshData object.
         This is done by taking the mesh information from the RenderMeshData
@@ -258,7 +260,7 @@ class BlenderScene():
         BlenderTools.uv_unwrap_part(part, mm_px_resolution, cal)
 
     def _debug_deform(self,
-                      render_mesh: RenderMeshData,
+                      render_mesh: RenderMesh,
                      sim_spat_dim:int,
                      part: bpy.data.objects) -> None:
         """A method to deform the Blender mesh object using the simulation results.
@@ -371,7 +373,7 @@ class BlenderScene():
                 bpy.ops.render.render(write_still=True)
 
     def render_deformed_images(self,
-                               render_mesh: RenderMeshData,
+                               render_mesh: RenderMesh,
                                sim_spat_dim: int,
                                render_data:RenderData,
                                part: bpy.data.objects,

pyvale/blendertools.py

@@ -332,7 +332,9 @@ class BlenderTools:
             A dataclass containing the parameters needed to render the images
         calibration_data : CalibrationData
             A dataclass containing the parameters by which to move the calibration
-            target. These inclcude the plungle depth and rotation angle.
+            target. These inclcude the plungle depth and rotation angle. It also
+            inlcludes optional x and y limits for the movement of the calibration
+            target (if None they will be initialised from the FOV).
         part : bpy.data.objects
             The Blender part object, in this instance the calibration target.
 
@@ -371,15 +373,17 @@ class BlenderTools:
             plunge = calibration_data.plunge_lims[0] + calibration_data.plunge_step * ii
             # Plunge
             (FOV_x, FOV_y) = CameraTools.blender_FOV(render_data.cam_data[0])
-            x_limit = int(round((FOV_x / 2) - (part.dimensions[0] / 2)))
 
-            y_limit = int(round((FOV_y / 2) - (part.dimensions[1] / 2)))
+            if calibration_data.x_limit is None:
+                calibration_data.x_limit = int(round((FOV_x / 2) - (part.dimensions[0] / 2)))
+            if calibration_data.y_limit is None:
+                calibration_data.y_limit = int(round((FOV_y / 2) - (part.dimensions[1] / 2)))
 
             for x in np.arange(-1, 2):
-                x *= x_limit
+                x *= calibration_data.x_limit
                 # Move in x-dir
                 for y in np.arange(-1, 2):
-                    y *= y_limit
+                    y *= calibration_data.y_limit
                     # Move in y-dir
                     part.location = ((x, y, plunge))
                     part.location[2] = plunge
@@ -415,6 +419,24 @@ class BlenderTools:
         print('Total number of calibration images = ' + str(render_counter))
         return render_counter
 
+    def check_for_GPU() -> bool:
+        """A method to check whether the machine has a GPU or not.
+
+        Returns
+        -------
+        bool
+            Returns True if a GPU is present, returns False if only a CPU is
+            present.
+        """
+        accepted_gpus = ["CUDA", "OPTIX", "HIP", "METAL", "ONEAPI"]
+        cycles_prefs = bpy.context.preferences.addons["cycles"].preferences
+        cycles_prefs.refresh_devices()
+        for device in cycles_prefs.devices:
+            print(f"Name: {device.name}, Type: {device.type}, Use: {device.use}")
+            if device.type in accepted_gpus:
+                return True
+        return False
+
 
 
 

pyvale/camera.py

@@ -18,6 +18,7 @@ from pyvale.cameradata2d import CameraData2D
 from pyvale.cameratools import CameraTools
 
 
+
 class CameraBasic2D(ISensorArray):
     __slots__ = ("_cam_data","_field","_error_integrator","_descriptor",
                  "_sensor_data","_truth","_measurements")

pyvale/cameradata.py

@@ -25,6 +25,8 @@ class CameraData:
     focal_length: float | None = 50.0
     sub_samp: int = 2
 
+    bits: int = 16
+
     back_face_removal: bool = True
 
     k1: float = 0.0
@@ -40,6 +42,7 @@ class CameraData:
     sensor_size: np.ndarray = field(init=False)
     image_dims: np.ndarray = field(init=False)
     image_dist: float = field(init=False)
+
     cam_to_world_mat: np.ndarray = field(init=False)
     world_to_cam_mat: np.ndarray = field(init=False)
 

pyvale/camerasensor.py

@@ -0,0 +1,147 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: This module is a feature under developement.
+"""
+
+import numpy as np
+from pyvale.field import IField
+from pyvale.sensorarray import ISensorArray
+from pyvale.errorintegrator import ErrIntegrator
+from pyvale.sensordescriptor import SensorDescriptor
+from pyvale.fieldsampler import sample_field_with_sensor_data
+from pyvale.cameradata2d import CameraData2D
+from pyvale.cameratools import CameraTools
+
+
+
+class CameraBasic2D(ISensorArray):
+    __slots__ = ("_cam_data","_field","_error_integrator","_descriptor",
+                 "_sensor_data","_truth","_measurements")
+
+    def __init__(self,
+                 cam_data: CameraData2D,
+                 field: IField,
+                 descriptor: SensorDescriptor | None = None,
+                 ) -> None:
+
+        self._cam_data = cam_data
+        self._field = field
+        self._error_integrator = None
+
+        self._descriptor = SensorDescriptor()
+        if descriptor is not None:
+            self._descriptor = descriptor
+
+        self._sensor_data = CameraTools.build_sensor_data_from_camera_2d(self._cam_data)
+
+        self._truth = None
+        self._measurements = None
+
+    #---------------------------------------------------------------------------
+    # Accessors
+    def get_sample_times(self) -> np.ndarray:
+        if self._sensor_data.sample_times is None:
+            #shape=(n_time_steps,)
+            return self._field.get_time_steps()
+
+        #shape=(n_time_steps,)
+        return self._sensor_data.sample_times
+
+    def get_measurement_shape(self) -> tuple[int,int,int]:
+        return (self._sensor_data.positions.shape[0],
+                len(self._field.get_all_components()),
+                self.get_sample_times().shape[0])
+
+    def get_image_measurements_shape(self) -> tuple[int,int,int,int]:
+        return (self._cam_data.num_pixels[1],
+                self._cam_data.num_pixels[0],
+                len(self._field.get_all_components()),
+                self.get_sample_times().shape[0])
+
+    def get_field(self) -> IField:
+        return self._field
+
+    def get_descriptor(self) -> SensorDescriptor:
+        return self._descriptor
+
+    #---------------------------------------------------------------------------
+    # Truth calculation from simulation
+    def calc_truth_values(self) -> np.ndarray:
+        self._truth = sample_field_with_sensor_data(self._field,
+                                                    self._sensor_data)
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._truth
+
+    def get_truth(self) -> np.ndarray:
+        if self._truth is None:
+            self._truth = self.calc_truth_values()
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._truth
+
+    #---------------------------------------------------------------------------
+    # Errors
+    def set_error_integrator(self, err_int: ErrIntegrator) -> None:
+        self._error_integrator = err_int
+
+    def get_errors_systematic(self) -> np.ndarray | None:
+        if self._error_integrator is None:
+            return None
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._error_integrator.get_errs_systematic()
+
+    def get_errors_random(self) -> np.ndarray | None:
+        if self._error_integrator is None:
+            return None
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._error_integrator.get_errs_random()
+
+    def get_errors_total(self) -> np.ndarray | None:
+        if self._error_integrator is None:
+            return None
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._error_integrator.get_errs_total()
+
+    #---------------------------------------------------------------------------
+    # Measurements
+    def calc_measurements(self) -> np.ndarray:
+        if self._error_integrator is None:
+            self._measurements = self.get_truth()
+        else:
+            self._measurements = self.get_truth() + \
+                self._error_integrator.calc_errors_from_chain(self.get_truth())
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._measurements
+
+    def get_measurements(self) -> np.ndarray:
+        if self._measurements is None:
+            self._measurements = self.calc_measurements()
+
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        return self._measurements
+
+    #---------------------------------------------------------------------------
+    # Images
+    def calc_measurement_images(self) -> np.ndarray:
+        #shape=(n_pixels,n_field_comps,n_time_steps)
+        self._measurements = self.calc_measurements()
+        image_shape = self.get_image_measurements_shape()
+        #shape=(n_pixels_y,n_pixels_x,n_field_comps,n_time_steps)
+        return np.reshape(self._measurements,image_shape)
+
+    def get_measurement_images(self) -> np.ndarray:
+        self._measurements = self.get_measurements()
+        image_shape = self.get_image_measurements_shape()
+        #shape=(n_pixels_y,n_pixels_x,n_field_comps,n_time_steps)
+        return np.reshape(self._measurements,image_shape)
+
+
+

pyvale/camerastereo.py

@@ -62,10 +62,10 @@ class CameraStereo:
             An instance of the CameraStereo class, given the specified parameters.
         """
         calib_params = yaml.safe_load(calib_path.read_text())
-        pixels_num_cam0 = np.array([calib_params['Cam0_Cx [pixels]']*2,
-                           calib_params['Cam0_Cy [pixels]']*2])
-        pixels_num_cam1 = np.array([calib_params['Cam1_Cx [pixels]']*2,
-                           calib_params['Cam1_Cy [pixels]']*2])
+        pixels_num_cam0 = np.array([int(calib_params['Cam0_Cx [pixels]']*2),
+                           int(calib_params['Cam0_Cy [pixels]']*2)])
+        pixels_num_cam1 = np.array([int(calib_params['Cam1_Cx [pixels]']*2),
+                           int(calib_params['Cam1_Cy [pixels]']*2)])
         pixels_size = focal_length / calib_params["Cam0_Fx [pixels]"]
         stereo_rotation = Rotation.from_euler("xyz", ([calib_params['Theta [deg]'],
                                     calib_params['Phi [deg]'],

pyvale/cameratools.py

@@ -23,43 +23,6 @@ from pyvale.camerastereo import CameraStereo
 
 
 class CameraTools:
-    @staticmethod
-    def load_image(im_path: Path) -> np.ndarray:
-
-        input_im = mplim.imread(im_path).astype(np.float64)
-        # If we have RGB then get rid of it
-        # TODO: make sure this is collapsing RGB to grey scale coorectly
-        if input_im.ndim > 2:
-            input_im = input_im[:,:,0]
-
-        return input_im
-
-    @staticmethod
-    def save_image(save_file: Path,
-                image: np.ndarray,
-                n_bits: int = 16) -> None:
-
-        # Need to flip image so coords are top left with Y down
-        # TODO check this
-        image = image[::-1,:]
-
-        if n_bits > 8:
-            im = Image.fromarray(image.astype(np.uint16))
-        else:
-            im = Image.fromarray(image.astype(np.uint8))
-
-        im.save(save_file)
-
-    @staticmethod
-    def image_num_str(im_num: int, width: int , cam_num: int = -1) -> str:
-        num_str = str(im_num)
-        num_str = num_str.zfill(width)
-
-        if cam_num >= 0:
-            num_str = num_str+'_'+str(cam_num)
-
-        return num_str
-
     @staticmethod
     def pixel_vec_px(pixels_count: np.ndarray) -> tuple[np.ndarray,np.ndarray]:
         px_vec_x = np.arange(0,pixels_count[0],1)
@@ -258,21 +221,14 @@ class CameraTools:
                                          [bb_max[xx],bb_max[yy],bb_min[zz]],
                                          [bb_min[xx],bb_max[yy],bb_min[zz]],])
 
+        print(80*"-")
+        print(bound_box_world_vecs)
+        print(80*"-")
+
         bound_box_cam_vecs = np.matmul(world_to_cam_mat,bound_box_world_vecs.T)
         boundbox_cam_leng = (np.max(bound_box_cam_vecs,axis=1)
                             - np.min(bound_box_cam_vecs,axis=1))
 
-        # print(80*"-")
-        # print(f"{bb_min=}")
-        # print(f"{bb_max=}")
-        # print()
-        # print("Cam to world mat:")
-        # print(cam_to_world_mat)
-        # print()
-        # print("World to cam mat:")
-        # print(world_to_cam_mat)
-        # print(80*"-")
-
         return np.array((boundbox_cam_leng[xx],boundbox_cam_leng[yy]))
 
     @staticmethod
@@ -287,14 +243,14 @@ class CameraTools:
         return image_dist
 
     @staticmethod
-    def pos_fill_frame_from_rotation(coords_world: np.ndarray,
-                                     pixel_num: np.ndarray,
-                                     pixel_size: np.ndarray,
-                                     focal_leng: float,
-                                     cam_rot: Rotation,
-                                     frame_fill: float = 1.0,
-                                     ) -> tuple[np.ndarray,
-                                                np.ndarray]:
+    def pos_fill_frame(coords_world: np.ndarray,
+                        pixel_num: np.ndarray,
+                        pixel_size: np.ndarray,
+                        focal_leng: float,
+                        cam_rot: Rotation,
+                        frame_fill: float = 1.0,
+                        ) -> tuple[np.ndarray,np.ndarray]:
+
         fov_leng = CameraTools.fov_from_cam_rot_3d(
             cam_rot=cam_rot,
             coords_world=coords_world,
@@ -316,13 +272,19 @@ class CameraTools:
         cam_z_dir_world = cam_rot.as_matrix()[:,-1]
         cam_pos_world = (roi_pos_world + np.max(image_dist)*cam_z_dir_world)
 
-        print(80*"-")
-        print(f"{fov_leng=}")
-        print(f"{image_dist=}")
-        print(80*"-")
-
         return (roi_pos_world,cam_pos_world)
 
+    @staticmethod
+    def pos_fill_frame_all(coords_world_list: list[np.ndarray],
+                            pixel_num: np.ndarray,
+                            pixel_size: np.ndarray,
+                            focal_leng: float,
+                            cam_rot: Rotation,
+                            frame_fill: float = 1.0,
+                            ) -> tuple[np.ndarray,np.ndarray]:
+        pass
+
+
 
     #---------------------------------------------------------------------------
     # Blender camera tools