pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/sensorsim/cameradata.py

@@ -0,0 +1,72 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: This module is a feature under developement.
+"""
+
+from dataclasses import dataclass, field
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+
+@dataclass(slots=True)
+class CameraData:
+    pixels_num: np.ndarray
+    pixels_size: np.ndarray
+
+    pos_world: np.ndarray
+    rot_world: Rotation
+    roi_cent_world: np.ndarray
+
+    focal_length: float | None = 50.0
+    sub_samp: int = 2
+
+    bits: int = 16
+
+    back_face_removal: bool = True
+
+    k1: float = 0.0
+    k2: float = 0.0
+    k3: float = 0.0
+    p1: float = 0.0
+    p2: float = 0.0
+    c0: float | None = None
+    c1: float | None = None
+
+    fstop: float | None = None
+
+    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)
+
+
+    def __post_init__(self) -> None:
+        relative_pos = np.subtract(self.pos_world, self.roi_cent_world)
+        self.image_dist = np.linalg.norm(relative_pos)
+        self.sensor_size = self.pixels_num*self.pixels_size
+        self.image_dims = (self.image_dist
+                           *self.sensor_size/self.focal_length)
+
+        self.cam_to_world_mat = np.zeros((4,4))
+        self.cam_to_world_mat[0:3,0:3] = self.rot_world.as_matrix()
+        self.cam_to_world_mat[-1,-1] = 1.0
+        self.cam_to_world_mat[0:3,-1] = self.pos_world
+        self.world_to_cam_mat = np.linalg.inv(self.cam_to_world_mat)
+
+        if self.c0 is None:
+            self.c0 = self.pixels_num[0] / 2
+        if self.c1 is None:
+            self.c1 = self.pixels_num[1] / 2
+
+
+
+
+
+

pyvale/sensorsim/cameradata2d.py

@@ -0,0 +1,84 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: This module is a feature under developement.
+"""
+
+from dataclasses import dataclass, field
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+@dataclass(slots=True)
+class CameraData2D:
+    pixels_count: np.ndarray | None = None
+    leng_per_px: float = 1.0e-3
+    bits: int = 8
+    roi_cent_world: np.ndarray | None = None
+
+    background: float = 0.5
+    sample_times: np.ndarray | None = None
+    angle: Rotation | None = None
+
+    subsample: int = 2
+
+    field_of_view: np.ndarray = field(init=False)
+    dynamic_range: int = field(init=False)
+
+    world_to_cam: np.ndarray = field(init=False)
+    cam_to_world: np.ndarray = field(init=False)
+
+    def __post_init__(self) -> None:
+
+        if self.pixels_count is None:
+            self.pixels_count = np.array((1000,1000),dtype=np.int32)
+
+        if self.roi_cent_world is None:
+            self.roi_cent_world = np.array((0.0,0.0,0.0),dtype=np.float64)
+
+        self.field_of_view = self.leng_per_px*(self.pixels_count.astype(np.float64))
+        self.dynamic_range = 2**self.bits
+        self.background = self.background*float(self.dynamic_range)
+
+        self.world_to_cam = self.field_of_view/2 - self.roi_cent_world[:-1]
+        self.cam_to_world = -self.world_to_cam
+
+
+#@dataclass(slots=True)
+#class CameraData2D:
+#     #shape=(n_px_X,n_px_Y)
+#     num_pixels: np.ndarray
+
+#     # Center location of the region of interest in world coords
+#     #shape=(3,) as (x,y,z)
+#     roi_center_world: np.ndarray
+
+#     # Converts pixels to length units to align with global coords
+#     leng_per_px: float
+
+#     #shape=(n_time_steps,)
+#     sample_times: np.ndarray | None = None
+
+#     #TODO: this only works for flat surfaces aligned with the axis
+#     view_axes: tuple[int,int] = (0,1)
+
+#     bits_sensor: int = 16
+#     bits_file: int = 16
+
+#     angle: Rotation | None = None
+
+#     field_of_view_center_local: np.ndarray = field(init=False)
+#     field_of_view_local: np.ndarray = field(init=False)
+#     roi_shift_world: np.ndarray = field(init=False)
+
+#     def __post_init__(self) -> None:
+#         self.field_of_view_local = self.num_pixels*self.leng_per_px
+#         self.field_of_view_center_local = self.field_of_view_local/2
+
+#         self.roi_shift_world = np.zeros_like(self.roi_center_world)
+#         for ii,vv in enumerate(self.view_axes):
+#             self.roi_shift_world[vv] = self.roi_center_world[vv] - \
+#                 self.field_of_view_center_local[ii]

pyvale/sensorsim/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 pyavle.sensorsim.field import IField
+from pyavle.sensorsim.sensorarray import ISensorArray
+from pyavle.sensorsim.errorintegrator import ErrIntegrator
+from pyavle.sensorsim.sensordescriptor import SensorDescriptor
+from pyavle.sensorsim.fieldsampler import sample_field_with_sensor_data
+from pyavle.sensorsim.cameradata2d import CameraData2D
+from pyavle.sensorsim.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(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()
+        #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 sim_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.sim_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.sim_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/sensorsim/camerastereo.py

@@ -0,0 +1,217 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+NOTE: This module is a feature under developement.
+"""
+
+from typing import Self
+from pathlib import Path
+import numpy as np
+import yaml
+from scipy.spatial.transform import Rotation
+from pyvale.sensorsim.cameradata import CameraData
+from pyvale.blender.blenderexceptions import BlenderError
+
+
+class CameraStereo:
+    __slots__ = ("cam_data_0","cam_data_1","stereo_dist","stereo_rotation")
+
+    def __init__(self, cam_data_0: CameraData, cam_data_1: CameraData) -> None:
+        self.cam_data_0 = cam_data_0
+        self.cam_data_1 = cam_data_1
+
+        cam0_rot_matrix = Rotation.as_matrix(self.cam_data_0.rot_world)
+        cam1_rot_matrix = Rotation.as_matrix(self.cam_data_1.rot_world)
+        (self.stereo_rotation, _) = Rotation.align_vectors(cam0_rot_matrix,
+                                                           cam1_rot_matrix)
+        dist = self.cam_data_0.pos_world - self.cam_data_1.pos_world
+        dist_rot = self.cam_data_0.rot_world.apply(dist)
+        inverse = self.stereo_rotation.inv().as_quat()
+        inverse[3] *= -1
+        inverse = Rotation.from_quat(inverse)
+        self.stereo_dist = inverse.apply(dist_rot)
+
+    @classmethod
+    def from_calibration(cls,
+                         calib_path: Path,
+                         pos_world_0: np.ndarray,
+                         rot_world_0: Rotation,
+                         focal_length: float) -> Self:
+        """A method to initialise the CameraStereo using a calibration file and
+        some additional parameters. This creates an instance of the CameraStereo
+        class from the calibration parameters.
+
+        Parameters
+        ----------
+        calib_path : Path
+            The path to the calibration file (in yaml format).
+        pos_world_0 : np.ndarray
+            The position of camera 0 in world coordinates.
+        rot_world_0 : Rotation
+            The rotation of camera 0 in world coordinates.
+        focal_length : float
+            The focal length of camera 0.
+
+        Returns
+        -------
+        Self
+            An instance of the CameraStereo class, given the specified parameters.
+        """
+        calib_params = yaml.safe_load(calib_path.read_text())
+        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]'],
+                                    calib_params['Psi [deg]']]), degrees=True)
+        stereo_dist = np.array([calib_params["Tx [mm]"],
+                                calib_params["Ty [mm]"],
+                                calib_params["Tz [mm]"]])
+
+        rot_world_1 = stereo_rotation * rot_world_0
+
+        inverse = stereo_rotation.inv().as_quat()
+        inverse[3] *= -1
+        inverse = Rotation.from_quat(inverse)
+
+        dist_rot = inverse.inv().apply(stereo_dist)
+        dist = rot_world_0.inv().apply(dist_rot)
+        pos_world_1 = pos_world_0 - dist
+
+        cam_data_0 = CameraData(pixels_num=pixels_num_cam0,
+                                pixels_size=np.array([pixels_size, pixels_size]),
+                                pos_world=pos_world_0,
+                                rot_world=rot_world_0,
+                                roi_cent_world=np.array([0, 0, 0]),
+                                focal_length=focal_length)
+        cam_data_1 = CameraData(pixels_num=pixels_num_cam1,
+                                pixels_size=np.array([pixels_size, pixels_size]),
+                                pos_world=pos_world_1,
+                                rot_world=rot_world_1,
+                                roi_cent_world=np.array([0, 0, 0]),
+                                focal_length=focal_length)
+        camera_stereo = cls(cam_data_0, cam_data_1)
+
+        return camera_stereo
+
+    def save_calibration(self, base_dir: Path) -> None:
+        """A method to save a calibration file of the stereo system as a yaml.
+        This is so that the file can easily be read into python, but is also
+        user-readable.
+
+        Parameters
+        ----------
+        base_dir : Path
+            The base directory to which all files should be saved. The
+            calibration file will be saved in a sub-directory named "calibration"
+            within this directory.
+
+        Raises
+        ------
+        BlenderError
+            "The specified save directory does not exist"
+        """
+        stereo_rotation = self.stereo_rotation.as_euler("xyz", degrees=True)
+        calib_params = {
+            "Cam0_Fx [pixels]": float(self.cam_data_0.focal_length /
+                                 self.cam_data_0.pixels_size[0]),
+            "Cam0_Fy [pixels]": float(self.cam_data_0.focal_length /
+                                 self.cam_data_0.pixels_size[1]),
+            "Cam0_Fs [pixels]": 0,
+            "Cam0_Kappa 1": self.cam_data_0.k1,
+            "Cam0_Kappa 2": self.cam_data_0.k2,
+            "Cam0_Kappa 3": self.cam_data_0.k3,
+            "Cam0_P1": self.cam_data_0.p1,
+            "Cam0_P2": self.cam_data_0.p2,
+            "Cam0_Cx [pixels]": float(self.cam_data_0.c0),
+            "Cam0_Cy [pixels]": float(self.cam_data_0.c1),
+            "Cam1_Fx [pixels]": float(self.cam_data_1.focal_length /
+                                 self.cam_data_1.pixels_size[0]),
+            "Cam1_Fy [pixels]": float(self.cam_data_1.focal_length /
+                                 self.cam_data_1.pixels_size[1]),
+            "Cam1_Fs [pixels]": 0,
+            "Cam1_Kappa 1": self.cam_data_1.k1,
+            "Cam1_Kappa 2": self.cam_data_1.k2,
+            "Cam1_Kappa 3": self.cam_data_1.k3,
+            "Cam1_P1": self.cam_data_1.p1,
+            "Cam1_P2": self.cam_data_1.p2,
+            "Cam1_Cx [pixels]": float(self.cam_data_1.c0),
+            "Cam1_Cy [pixels]": float(self.cam_data_1.c1),
+            "Tx [mm]": float(self.stereo_dist[0]),
+            "Ty [mm]": float(self.stereo_dist[1]),
+            "Tz [mm]": float(self.stereo_dist[2]),
+            "Theta [deg]": float(stereo_rotation[0]),
+            "Phi [deg]": float(stereo_rotation[1]),
+            "Psi [deg]": float(stereo_rotation[2])
+        }
+        if not base_dir.is_dir():
+            raise BlenderError("The specified save directory does not exist")
+
+        save_dir = base_dir / "calibration"
+        if not save_dir.is_dir():
+            save_dir.mkdir(parents=True, exist_ok=True)
+
+        filepath = str(save_dir / "calibration.yaml")
+        calib_file = open(filepath, "w")
+        yaml.safe_dump(calib_params, calib_file)
+        calib_file.close()
+        print("Calibration file saved to:", (save_dir / "calibration.yaml"))
+
+    def save_calibration_mid(self, base_dir: Path) -> None:
+        """A method to save a calibration file of the stereo system in a MatchID
+        accepted format.
+
+        Parameters
+        ----------
+        base_dir : Path
+            The base directory to which all files should be saved. The
+            calibration file will be saved in a sub-directory named "calibration"
+            within this directory.
+
+        Raises
+        ------
+        BlenderError
+            "The specified save directory does not exist"
+        """
+        if not base_dir.is_dir():
+            raise BlenderError("The specified save directory does not exist")
+
+        save_dir = base_dir / "calibration"
+        if not save_dir.is_dir():
+            save_dir.mkdir(parents=True, exist_ok=True)
+
+        filepath = str(save_dir / "calibration.caldat")
+        with open(filepath, "w") as file:
+            file.write(f'Cam0_Fx [pixels]; {self.cam_data_0.focal_length/ self.cam_data_0.pixels_size[0]}\n')
+            file.write(f'Cam0_Fy [pixels]; {self.cam_data_0.focal_length/ self.cam_data_0.pixels_size[1]}\n')
+            file.write("Cam0_Fs [pixels];0\n")
+            file.write(f'Cam0_Kappa 1;{self.cam_data_0.k1}\n')
+            file.write(f'Cam0_Kappa 2;{self.cam_data_0.k2}\n')
+            file.write(f'Cam0_Kappa 3;{self.cam_data_0.k3}\n')
+            file.write(f'Cam0_P1;{self.cam_data_0.p1}\n')
+            file.write(f'Cam0_P2;{self.cam_data_0.p2}\n')
+            file.write(f'Cam0_Cx [pixels];{self.cam_data_0.c0}\n')
+            file.write(f'Cam0_Cy [pixels];{self.cam_data_0.c1}\n')
+            file.write(f'Cam1_Fx [pixels]; {self.cam_data_1.focal_length/ self.cam_data_1.pixels_size[0]}\n')
+            file.write(f'Cam1_Fy [pixels]; {self.cam_data_1.focal_length/ self.cam_data_1.pixels_size[1]}\n')
+            file.write("Cam1_Fs [pixels];0\n")
+            file.write(f'Cam1_Kappa 1;{self.cam_data_1.k1}\n')
+            file.write(f'Cam1_Kappa 2;{self.cam_data_1.k2}\n')
+            file.write(f'Cam1_Kappa 3;{self.cam_data_1.k3}\n')
+            file.write(f'Cam1_P1;{self.cam_data_1.p1}\n')
+            file.write(f'Cam1_P2;{self.cam_data_1.p2}\n')
+            file.write(f'Cam1_Cx [pixels];{self.cam_data_1.c0}\n')
+            file.write(f'Cam1_Cy [pixels];{self.cam_data_1.c1}\n')
+            file.write(f"Tx [mm];{self.stereo_dist[0]}\n")
+            file.write(f"Ty [mm];{self.stereo_dist[1]}\n")
+            file.write(f"Tz [mm];{self.stereo_dist[2]}\n")
+            stereo_rotation = self.stereo_rotation.as_euler("xyz", degrees=True)
+            file.write(f"Theta [deg];{stereo_rotation[0]}\n")
+            file.write(f"Phi [deg];{stereo_rotation[1]}\n")
+            file.write(f"Psi [deg];{stereo_rotation[2]}")