pyvale 2025.5.2__tar.gz → 2025.7.0__tar.gz

{pyvale-2025.5.2/src/pyvale.egg-info → pyvale-2025.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvale
-Version: 2025.5.2
+Version: 2025.7.0
 Summary: An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration or validation.
 Author-email: "scepticalrabbit et al." <thescepticalrabbit@gmail.com>
 License: MIT License
@@ -46,17 +46,24 @@ Requires-Dist: Cython>=3.0.0
 Requires-Dist: bpy>=4.2.0
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: pytest>=8.3.5
+Requires-Dist: pybind11>=2.13.6
+Requires-Dist: pyqtgraph>=0.13.7
+Requires-Dist: opencv-python<=4.9.0.80
 Dynamic: license-file
 
 # pyvale
-The python validation engine (`pyvale`): An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration/validation.​ Used to simulate experimental data from an input multi-physics simulation by explicitly modelling sensors with realistic uncertainties. Useful for experimental design, sensor placement optimisation, testing simulation validation metrics and virtually testing digital shadows/twins.
+![fig_pyvale_logo](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/pyvale_logo.png)
+
+The python validation engine (`pyvale`) is you virtual engineering laboratory: An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration/validation. Used to simulate experimental data from an input multi-physics simulation by explicitly modelling sensors with realistic uncertainties. Useful for experimental design, sensor placement optimisation, testing simulation validation metrics and virtually testing digital shadows/twins.
+
+We provide dedicated tools for simulation and uncertainty quantification of imaging sensors including digital image correlation (DIC) and infra-red thermography (IRT). Check out the [documentation](https://computer-aided-validation-laboratory.github.io/pyvale/index.html) to get started with some of our examples.
 
 ## Quick Demo: Simulating Point Sensors
 Here we demonstrate how `pyvale` can be used to simulate thermocouples and strain gauges applied to a [MOOSE](https://mooseframework.inl.gov/index.html) thermo-mechanical simulation of a fusion divertor armour heatsink. The figures below show visualisations of the virtual thermocouple and strain gauge locations on the simualtion mesh as well as time traces for each sensor over a series of simulated experiments.
 
 The code to run the simulated experiments and produce the output shown here comes from [this example](https://computer-aided-validation-laboratory.github.io/pyvale/examples/point/ex4_2.html). You can find more examples and details of `pyvale` python API in the `pyvale` [documentation](https://computer-aided-validation-laboratory.github.io/pyvale/index.html).
 
-|![fig_thermomech3d_tc_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_tc_vis.svg)|![fig_thermomech3d_sg_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.svg)|
+|![fig_thermomech3d_tc_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_tc_vis.png)|![fig_thermomech3d_sg_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.png)|
 |--|--|
 |*Visualisation of the thermcouple locations.*|*Visualisation of the strain gauge locations.*|
 
@@ -71,71 +78,19 @@ The code to run the simulated experiments and produce the output shown here come
 pip install pyvale
 ```
 
-## Detailed Install: Ubuntu
-### Managing Python Versions
-To be compatible with `bpy` (the Blender python interface), `pyvale` uses python 3.11. To install python 3.11 without corrupting your operating systems python installation first add the deadsnakes repository to apt:
-```shell
-sudo add-apt-repository ppa:deadsnakes/ppa
-sudo apt update && sudo apt upgrade -y
-```
-
-Install python 3.11:
-```shell
-sudo apt install python3.11
-```
-
-Add `venv` to your python 3.11 install:
-```shell
-sudo apt install python3.11-venv
-```
-
-Check your python 3.11 install is working using the following command which should open an interactive python interpreter:
-```shell
-python3.11
-```
-
-### Virtual Environment
-
-We recommend installing `pyvale` in a virtual environment using `venv` or `pyvale` can be installed into an existing environment of your choice. To create a specific virtual environment for `pyvale` navigate to the directory you want to install the environment and use:
-
-```shell
-python3.11 -m venv .pyvale-env
-source .pyvale-env/bin/activate
-```
-
-### Standard Installation
-`pyvale` can be installed from pypi. Ensure you virtual environment is activated and run:
-```shell
-pip install pyvale
-```
-
-### Developer Installation
-
-Clone `pyvale` to your local system along with submodules using
-```shell
-git clone --recurse-submodules git@github.com:Computer-Aided-Validation-Laboratory/pyvale.git
-```
-
-`cd` to the root directory of `pyvale`. Ensure you virtual environment is activated and run the following commmand from the `pyvale` directory:
-```shell
-pip install -e .
-pip install -e ./dependencies/mooseherder
-```
-
-### Running Physics Simulations with MOOSE
-`pyvale` come pre-packaged with example `moose` physics simulation outputs (as *.e exodus files) to demonstrate its functionality. If you need to run additional simulation cases we recommend `proteus` (https://github.com/aurora-multiphysics/proteus) which has build scripts for common linux distributions.
+We recommend installing `pyvale` into a virtual environment of your choice as `pyvale` requires python 3.11. If you need help setting up your virtual environment and installing `pyvale` head over to the [installation guide](https://computer-aided-validation-laboratory.github.io/pyvale/install.html) in our docs.
 
 ## Contributors
 The Computer Aided Validation Team at UKAEA:
 - Lloyd Fletcher ([ScepticalRabbit](https://github.com/ScepticalRabbit)), UK Atomic Energy Authority
 - Joel Hirst ([JoelPhys](https://github.com/JoelPhys)), UK Atomic Energy Authority
-- John Charlton ([coolmule0](https://github.com/coolmule0)), UK Atomic Energy Authority
 - Lorna Sibson ([lornasibson](https://github.com/lornasibson)), UK Atomic Energy Authority
 - Megan Sampson ([meganasampson](https://github.com/meganasampson)), UK Atomic Energy Authority
 - Michael Atkinson ([mikesmic](https://github.com/mikesmic)), UK Atomic Energy Authority
 - Adel Tayeb ([3adelTayeb](https://github.com/3adelTayeb)), UK Atomic Energy Authority
 - Alex Marsh ([alexmarsh2](https://github.com/alexmarsh2)), UK Atomic Energy Authority
 - Rory Spencer ([fusmatrs](https://github.com/orgs/Computer-Aided-Validation-Laboratory/people/fusmatrs)), UK Atomic Energy Authority
+- John Charlton ([coolmule0](https://github.com/coolmule0)), UK Atomic Energy Authority
 
 
 

{pyvale-2025.5.2 → pyvale-2025.7.0}/README.md

@@ -1,12 +1,16 @@
 # pyvale
-The python validation engine (`pyvale`): An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration/validation.​ Used to simulate experimental data from an input multi-physics simulation by explicitly modelling sensors with realistic uncertainties. Useful for experimental design, sensor placement optimisation, testing simulation validation metrics and virtually testing digital shadows/twins.
+![fig_pyvale_logo](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/pyvale_logo.png)
+
+The python validation engine (`pyvale`) is you virtual engineering laboratory: An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration/validation. Used to simulate experimental data from an input multi-physics simulation by explicitly modelling sensors with realistic uncertainties. Useful for experimental design, sensor placement optimisation, testing simulation validation metrics and virtually testing digital shadows/twins.
+
+We provide dedicated tools for simulation and uncertainty quantification of imaging sensors including digital image correlation (DIC) and infra-red thermography (IRT). Check out the [documentation](https://computer-aided-validation-laboratory.github.io/pyvale/index.html) to get started with some of our examples.
 
 ## Quick Demo: Simulating Point Sensors
 Here we demonstrate how `pyvale` can be used to simulate thermocouples and strain gauges applied to a [MOOSE](https://mooseframework.inl.gov/index.html) thermo-mechanical simulation of a fusion divertor armour heatsink. The figures below show visualisations of the virtual thermocouple and strain gauge locations on the simualtion mesh as well as time traces for each sensor over a series of simulated experiments.
 
 The code to run the simulated experiments and produce the output shown here comes from [this example](https://computer-aided-validation-laboratory.github.io/pyvale/examples/point/ex4_2.html). You can find more examples and details of `pyvale` python API in the `pyvale` [documentation](https://computer-aided-validation-laboratory.github.io/pyvale/index.html).
 
-|![fig_thermomech3d_tc_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_tc_vis.svg)|![fig_thermomech3d_sg_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.svg)|
+|![fig_thermomech3d_tc_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_tc_vis.png)|![fig_thermomech3d_sg_vis](https://raw.githubusercontent.com/Computer-Aided-Validation-Laboratory/pyvale/main/images/thermomech3d_sg_vis.png)|
 |--|--|
 |*Visualisation of the thermcouple locations.*|*Visualisation of the strain gauge locations.*|
 
@@ -21,71 +25,19 @@ The code to run the simulated experiments and produce the output shown here come
 pip install pyvale
 ```
 
-## Detailed Install: Ubuntu
-### Managing Python Versions
-To be compatible with `bpy` (the Blender python interface), `pyvale` uses python 3.11. To install python 3.11 without corrupting your operating systems python installation first add the deadsnakes repository to apt:
-```shell
-sudo add-apt-repository ppa:deadsnakes/ppa
-sudo apt update && sudo apt upgrade -y
-```
-
-Install python 3.11:
-```shell
-sudo apt install python3.11
-```
-
-Add `venv` to your python 3.11 install:
-```shell
-sudo apt install python3.11-venv
-```
-
-Check your python 3.11 install is working using the following command which should open an interactive python interpreter:
-```shell
-python3.11
-```
-
-### Virtual Environment
-
-We recommend installing `pyvale` in a virtual environment using `venv` or `pyvale` can be installed into an existing environment of your choice. To create a specific virtual environment for `pyvale` navigate to the directory you want to install the environment and use:
-
-```shell
-python3.11 -m venv .pyvale-env
-source .pyvale-env/bin/activate
-```
-
-### Standard Installation
-`pyvale` can be installed from pypi. Ensure you virtual environment is activated and run:
-```shell
-pip install pyvale
-```
-
-### Developer Installation
-
-Clone `pyvale` to your local system along with submodules using
-```shell
-git clone --recurse-submodules git@github.com:Computer-Aided-Validation-Laboratory/pyvale.git
-```
-
-`cd` to the root directory of `pyvale`. Ensure you virtual environment is activated and run the following commmand from the `pyvale` directory:
-```shell
-pip install -e .
-pip install -e ./dependencies/mooseherder
-```
-
-### Running Physics Simulations with MOOSE
-`pyvale` come pre-packaged with example `moose` physics simulation outputs (as *.e exodus files) to demonstrate its functionality. If you need to run additional simulation cases we recommend `proteus` (https://github.com/aurora-multiphysics/proteus) which has build scripts for common linux distributions.
+We recommend installing `pyvale` into a virtual environment of your choice as `pyvale` requires python 3.11. If you need help setting up your virtual environment and installing `pyvale` head over to the [installation guide](https://computer-aided-validation-laboratory.github.io/pyvale/install.html) in our docs.
 
 ## Contributors
 The Computer Aided Validation Team at UKAEA:
 - Lloyd Fletcher ([ScepticalRabbit](https://github.com/ScepticalRabbit)), UK Atomic Energy Authority
 - Joel Hirst ([JoelPhys](https://github.com/JoelPhys)), UK Atomic Energy Authority
-- John Charlton ([coolmule0](https://github.com/coolmule0)), UK Atomic Energy Authority
 - Lorna Sibson ([lornasibson](https://github.com/lornasibson)), UK Atomic Energy Authority
 - Megan Sampson ([meganasampson](https://github.com/meganasampson)), UK Atomic Energy Authority
 - Michael Atkinson ([mikesmic](https://github.com/mikesmic)), UK Atomic Energy Authority
 - Adel Tayeb ([3adelTayeb](https://github.com/3adelTayeb)), UK Atomic Energy Authority
 - Alex Marsh ([alexmarsh2](https://github.com/alexmarsh2)), UK Atomic Energy Authority
 - Rory Spencer ([fusmatrs](https://github.com/orgs/Computer-Aided-Validation-Laboratory/people/fusmatrs)), UK Atomic Energy Authority
+- John Charlton ([coolmule0](https://github.com/coolmule0)), UK Atomic Energy Authority
 
 
 

{pyvale-2025.5.2 → pyvale-2025.7.0}/pyproject.toml

@@ -1,10 +1,11 @@
 [build-system]
-requires = ["setuptools>=61.0", "wheel", "Cython", "numpy"]
+requires = ["setuptools>=61.0", "wheel", "Cython>=3.0.0", "numpy<2.0.0",
+    "pybind11>=2.13.6"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyvale"
-version = "2025.5.2"
+version = "2025.7.0"
 description = "An all-in-one package for sensor simulation, sensor uncertainty quantification, sensor placement optimisation and simulation calibration or validation."
 authors = [
   { name = "scepticalrabbit et al.", email = "thescepticalrabbit@gmail.com" },
@@ -30,6 +31,9 @@ dependencies = [
   "bpy>=4.2.0",
   "pyyaml>=6.0.2",
   "pytest>=8.3.5",
+  "pybind11>=2.13.6",
+  "pyqtgraph>=0.13.7",
+  "opencv-python<=4.9.0.80"
 ]
 
 [project.urls]

pyvale-2025.7.0/setup.py

@@ -0,0 +1,60 @@
+from setuptools import  setup, Extension
+from Cython.Build import cythonize
+import numpy
+import sys
+from glob import glob
+import pybind11
+
+
+debug_mode = '--debug' in sys.argv
+if debug_mode:
+    sys.argv.remove('--debug')
+
+# check if we are on windows
+is_windows = sys.platform.startswith("win")
+if is_windows:
+    openmp_flag = '/openmp'
+    cpp_std_flag = '/std:c++17'
+    compile_flags = [cpp_std_flag, openmp_flag]
+    if debug_mode:
+        compile_flags += ['/Od', '/Zi']
+    else:
+        compile_flags += ['/O2']
+    link_flags = []
+else:
+    openmp_flag = '-fopenmp'
+    cpp_std_flag = '-std=c++17'
+    compile_flags = [cpp_std_flag, openmp_flag]
+    if debug_mode:
+        compile_flags += ['-O0', '-g']
+        link_flags = [openmp_flag, '-g']
+    else:
+        compile_flags += ['-O3']
+        link_flags = [openmp_flag]
+
+
+ext_cython = Extension(
+    "pyvale.cython.rastercyth",
+    ["src/pyvale/cython/rastercyth.py"],
+    include_dirs=[numpy.get_include()],
+    extra_compile_args=[openmp_flag],
+    extra_link_args=[openmp_flag],
+)
+
+
+
+ext_dic = Extension(
+    'pyvale.dic2dcpp',
+    sorted(glob("src/pyvale/dic/cpp/dic*.cpp")),
+    language="c++",
+    include_dirs=[pybind11.get_include()],
+    extra_compile_args=compile_flags,
+    extra_link_args=link_flags,
+)
+
+ext_modules = cythonize([ext_cython], annotate=True) + [ext_dic]
+
+setup(
+    ext_modules=cythonize(ext_modules,
+                          annotate=True),
+)

{pyvale-2025.5.2 → pyvale-2025.7.0}/src/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-2025.5.2 → pyvale-2025.7.0}/src/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-2025.5.2 → pyvale-2025.7.0}/src/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-2025.5.2 → pyvale-2025.7.0}/src/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-2025.5.2 → pyvale-2025.7.0}/src/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-2025.5.2 → pyvale-2025.7.0}/src/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-2025.7.0/src/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-2025.5.2 → pyvale-2025.7.0}/src/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]'],