pyvale 2025.7.2__cp311-cp311-win32.whl → 2025.8.1__cp311-cp311-win32.whl

pyvale/examples/renderblender/ex1_2_blenderdeformed.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Deforming a sample with 2D DIC
+Deforming a sample with 2D DIC
 ===============================================
 
 This example follows a similar workflow to the previous Blender example.
@@ -18,15 +18,19 @@ Test case: mechanical analysis of a plate with a hole loaded in tension.
 import numpy as np
 from scipy.spatial.transform import Rotation
 from pathlib import Path
-import pyvale
-import mooseherder as mh
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+import pyvale.blender as blender
+import pyvale.mooseherder as mh
 
 # %%
 # The simulation results are loaded in here in the same way as the previous
 # example. As mentioned this `data_path` can be replaced with your own MOOSE
 # simulation output in exodus format (*.e).
 
-data_path = pyvale.DataSet.render_mechanical_3d_path()
+data_path = dataset.render_mechanical_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 # %%
@@ -37,11 +41,11 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 3D deformation test case, displacement is expected in the x, y and z directions.
 
 disp_comps = ("disp_x","disp_y", "disp_z")
-sim_data = pyvale.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                      sim_data=sim_data,
                                      disp_comps=disp_comps)
 
-render_mesh = pyvale.create_render_mesh(sim_data,
+render_mesh = sens.create_render_mesh(sim_data,
                                         ("disp_y","disp_x"),
                                         sim_spat_dim=3,
                                         field_disp_keys=disp_comps)
@@ -62,7 +66,7 @@ base_dir = Path.cwd()
 # A scene is initialised using the `BlenderScene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
 
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -75,9 +79,9 @@ scene = pyvale.BlenderScene()
 part = scene.add_part(render_mesh, sim_spat_dim=3)
 # Set the part location
 part_location = np.array([0, 0, 0])
-pyvale.BlenderTools.move_blender_obj(part=part, pos_world=part_location)
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
 part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
-pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
 
 # %%
 # A camera can then be added to the scene.
@@ -86,7 +90,7 @@ pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
 # This camera can then be added to the Blender scene.
 # The camera can also be moved and rotated.
 
-cam_data = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
+cam_data = sens.CameraData(pixels_num=np.array([1540, 1040]),
                              pixels_size=np.array([0.00345, 0.00345]),
                              pos_world=(0, 0, 400),
                              rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
@@ -101,7 +105,7 @@ camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
 
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+light_data = blender.LightData(type=blender.LightType.POINT,
                                      pos_world=(0, 0, 400),
                                      rot_world=Rotation.from_euler("xyz",
                                                                    [0, 0, 0]),
@@ -121,9 +125,9 @@ light.rotation_euler = (0, 0, 0)
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data)
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data)
 scene.add_speckle(part=part,
                     speckle_path=speckle_path,
                     mat_data=material_data,
@@ -137,9 +141,9 @@ scene.add_speckle(part=part,
 # Firstly, all the rendering parameters must be set, including parameters such as
 # the number of threads to use.
 
-render_data = pyvale.RenderData(cam_data=cam_data,
-                                base_dir=base_dir,
-                                threads=8)
+render_data = blender.RenderData(cam_data=cam_data,
+                                 base_dir=base_dir,
+                                 threads=8)
 
 # %%
 # A series of deformed images can then be rendered.
@@ -167,4 +171,4 @@ print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
 # There is also the option to save the scene as a Blender project file.
 # This file can be opened with the Blender GUI to view the scene.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/renderblender/ex2_1_stereoscene.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Creating a scene with stereo DIC
+Creating a scene with stereo DIC
 -------------------------------------------------
 
 This example takes you through creating a scene and adding all the necessary
@@ -18,15 +18,19 @@ Test case: mechanical analysis of a plate with a hole loaded in tension.
 import numpy as np
 from scipy.spatial.transform import Rotation
 from pathlib import Path
-import pyvale
-import mooseherder as mh
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+import pyvale.blender as blender
+import pyvale.mooseherder as mh
 
 # %%
 # The simulation results are loaded in here in the same way as the previous
 # example. As mentioned this `data_path` can be replaced with your own MOOSE
 # simulation output in exodus format (*.e).
 
-data_path = pyvale.DataSet.render_mechanical_3d_path()
+data_path = dataset.render_mechanical_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 # %%
@@ -37,11 +41,11 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 3D deformation test case, displacement is expected in the x, y and z directions.
 
 disp_comps = ("disp_x","disp_y", "disp_z")
-sim_data = pyvale.scale_length_units(scale=1000.0,
-                                        sim_data=sim_data,
-                                        disp_comps=disp_comps)
+sim_data = sens.scale_length_units(scale=1000.0,
+                                  sim_data=sim_data,
+                                  disp_comps=disp_comps)
 
-render_mesh = pyvale.create_render_mesh(sim_data,
+render_mesh = sens.create_render_mesh(sim_data,
                                     ("disp_y","disp_x"),
                                     sim_spat_dim=3,
                                     field_disp_keys=disp_comps)
@@ -59,9 +63,9 @@ base_dir = Path.cwd()
 # Creating the scene
 # ^^^^^^^^^^^^^^^^^^
 # In order to create a DIC setup in Blender, first a scene must be created.
-# A scene is initialised using the `BlenderScene` class. All the subsequent
+# A scene is initialised using the `blender.Scene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -73,10 +77,10 @@ scene = pyvale.BlenderScene()
 part = scene.add_part(render_mesh, sim_spat_dim=3)
 # Set the part location
 part_location = np.array([0, 0, 0])
-pyvale.BlenderTools.move_blender_obj(part=part, pos_world=part_location)
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
 # Set part rotation
 part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
-pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
 
 # %%
 # The cameras can then be initialised. A stereo camera system is defined by a
@@ -95,23 +99,26 @@ pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
 # between the two. The cameras can then be added to the Blender scene using the
 # `add_stereo_system` method.
 
-cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
-                                pixels_size=np.array([0.00345, 0.00345]),
-                                pos_world=np.array([0, 0, 400]),
-                                rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
-                                roi_cent_world=(0, 0, 0),
-                                focal_length=15.0)
+cam_data_0 = sens.CameraData(pixels_num=np.array([1540, 1040]),
+                            pixels_size=np.array([0.00345, 0.00345]),
+                            pos_world=np.array([0, 0, 400]),
+                            rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
+                            roi_cent_world=(0, 0, 0),
+                            focal_length=15.0)
 # Set this to "symmetric" to get a symmetric stereo system or set this to
 # "faceon" to get a face-on stereo system
 stereo_setup = "faceon"
 if stereo_setup == "symmetric":
-    stereo_system = pyvale.CameraTools.symmetric_stereo_cameras(
+    stereo_system = sens.CameraTools.symmetric_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
-if stereo_setup == "faceon":
-    stereo_system = pyvale.CameraTools.faceon_stereo_cameras(
+elif stereo_setup == "faceon":
+    stereo_system = sens.CameraTools.faceon_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
+else:
+    raise ValueError(f"Unknown stereo_setup: {stereo_setup}")
+
 cam0, cam1 = scene.add_stereo_system(stereo_system)
 
 # %%
@@ -130,7 +137,7 @@ stereo_system.save_calibration(base_dir)
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
 
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+light_data = blender.LightData(type=blender.LightType.POINT,
                                      pos_world=(0, 0, 400),
                                      rot_world=Rotation.from_euler("xyz",
                                                                    [0, 0, 0]),
@@ -150,10 +157,10 @@ light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
 
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data_0)
 scene.add_speckle(part=part,
                   speckle_path=speckle_path,
                   mat_data=material_data,
@@ -168,10 +175,10 @@ scene.add_speckle(part=part,
 # Differently to a 2D DIC system, both cameras' parameters must be specified in
 # the `RenderData` object.
 
-render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+render_data = blender.RenderData(cam_data=(stereo_system.cam_data_0,
                                             stereo_system.cam_data_1),
-                                base_dir=base_dir,
-                                threads=8)
+                                 base_dir=base_dir,
+                                 threads=8)
 
 # %%
 # A single set of images of the scene can then be rendered.
@@ -192,4 +199,4 @@ print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
 # There is also the option to save the scene as a Blender project file.
 # This file can be opened with the Blender GUI to view the scene.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/renderblender/ex2_2_stereodeformed.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Deforming a sample with stereo DIC
+Deforming a sample with stereo DIC
 ===================================================
 
 This example takes you through creating stereo DIC scene, applying deformation
@@ -17,15 +17,19 @@ Test case: mechanical analysis of a plate with a hole loaded in tension.
 import numpy as np
 from scipy.spatial.transform import Rotation
 from pathlib import Path
-import pyvale
-import mooseherder as mh
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
+import pyvale.blender as blender
+import pyvale.mooseherder as mh
 
 # %%
 # The simulation results are loaded in here in the same way as the previous
 # example. As mentioned this `data_path` can be replaced with your own MOOSE
 # simulation output in exodus format (*.e).
 
-data_path = pyvale.DataSet.render_mechanical_3d_path()
+data_path = dataset.render_mechanical_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 # %%
@@ -36,11 +40,11 @@ sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 # 3D deformation test case, displacement is expected in the x, y and z directions.
 
 disp_comps = ("disp_x","disp_y", "disp_z")
-sim_data = pyvale.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                      sim_data=sim_data,
                                      disp_comps=disp_comps)
 
-render_mesh = pyvale.create_render_mesh(sim_data,
+render_mesh = sens.create_render_mesh(sim_data,
                                         ("disp_y","disp_x"),
                                         sim_spat_dim=3,
                                         field_disp_keys=disp_comps)
@@ -60,7 +64,7 @@ base_dir = Path.cwd()
 # In order to create a DIC setup in Blender, first a scene must be created.
 # A scene is initialised using the `BlenderScene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing that can be added to the scene is a sample.
@@ -72,10 +76,10 @@ scene = pyvale.BlenderScene()
 part = scene.add_part(render_mesh, sim_spat_dim=3)
 # Set the part location
 part_location = np.array([0, 0, 0])
-pyvale.BlenderTools.move_blender_obj(part=part, pos_world=part_location)
+blender.Tools.move_blender_obj(part=part, pos_world=part_location)
 # Set part rotation
 part_rotation = Rotation.from_euler("xyz", [0, 0, 0], degrees=True)
-pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+blender.Tools.rotate_blender_obj(part=part, rot_world=part_rotation)
 
 # %%
 # The cameras can then be initialised. A stereo camera system is defined by a
@@ -94,7 +98,7 @@ pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
 # between the two. The cameras can then be added to the Blender scene using the
 # `add_stereo_system` method.
 
-cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
+cam_data_0 = sens.CameraData(pixels_num=np.array([1540, 1040]),
                                pixels_size=np.array([0.00345, 0.00345]),
                                pos_world=np.array([0, 0, 400]),
                                rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
@@ -104,13 +108,16 @@ cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
 # "faceon" to get a face-on stereo system
 stereo_setup = "faceon"
 if stereo_setup == "symmetric":
-    stereo_system = pyvale.CameraTools.symmetric_stereo_cameras(
+    stereo_system = sens.CameraTools.symmetric_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
-if stereo_setup == "faceon":
-    stereo_system = pyvale.CameraTools.faceon_stereo_cameras(
+elif stereo_setup == "faceon":
+    stereo_system = sens.CameraTools.faceon_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
+else:
+    raise ValueError(f"Unknown stereo_setup: {stereo_setup}")
+
 cam0, cam1 = scene.add_stereo_system(stereo_system)
 
 # %%
@@ -128,7 +135,7 @@ stereo_system.save_calibration(base_dir)
 # A light can the be added to the scene.
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+light_data = blender.LightData(type=blender.LightType.POINT,
                                      pos_world=(0, 0, 400),
                                      rot_world=Rotation.from_euler("xyz",
                                                                    [0, 0, 0]),
@@ -138,8 +145,8 @@ light.location = (0, 0, 410)
 light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 
 # Apply the speckle pattern
-material_data = pyvale.BlenderMaterialData()
-speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
+material_data = blender.MaterialData()
+speckle_path = dataset.dic_pattern_5mpx_path()
 # NOTE: If you wish to use a bigger camera, you will need to generate a
 # bigger speckle pattern generator
 
@@ -154,7 +161,7 @@ speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
 # It should be noted that for a bigger camera or sample you may need to generate
 # a larger speckle pattern.
 
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data_0)
 scene.add_speckle(part=part,
                   speckle_path=speckle_path,
                   mat_data=material_data,
@@ -169,7 +176,7 @@ scene.add_speckle(part=part,
 # the number of threads to use.
 # Differently to a 2D DIC system, both cameras' parameters must be specified in
 # the `RenderData` object.
-render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+render_data = blender.RenderData(cam_data=(stereo_system.cam_data_0,
                                             stereo_system.cam_data_1),
                                 base_dir=base_dir,
                                 threads=8)
@@ -200,5 +207,4 @@ print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
 # There is also the option to save the scene as a Blender project file.
 # This file can be opened with the Blender GUI to view the scene.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
-
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/renderblender/ex3_1_blendercalibration.py

@@ -5,7 +5,7 @@
 # ==============================================================================
 
 """
-Blender example: Rendering calibration images
+Rendering calibration images
 ---------------------------------------------
 
 This example takes you through how to render calibration images for a given DIC
@@ -14,7 +14,11 @@ setup.
 import numpy as np
 from scipy.spatial.transform import Rotation
 from pathlib import Path
-import pyvale
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.blender as blender
+import pyvale.dataset as dataset
 
 # %%
 # Firstly, a save path must be set.
@@ -31,7 +35,7 @@ base_dir = Path.cwd()
 # In order to create a DIC setup in Blender, first a scene must be created.
 # A scene is initialised using the `BlenderScene` class. All the subsequent
 # objects and actions necessary are then methods of this class.
-scene = pyvale.BlenderScene()
+scene = blender.Scene()
 
 # %%
 # The next thing to add to the scene is the calibration target.
@@ -57,7 +61,7 @@ target = scene.add_cal_target(target_size=np.array([150, 100, 10]))
 # are the camera parameters for the first camera, and the desired stereo angle
 # between the two. The cameras can then be added to the Blender scene using the
 # `add_stereo_system` method.
-cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
+cam_data_0 = sens.CameraData(pixels_num=np.array([1540, 1040]),
                                pixels_size=np.array([0.00345, 0.00345]),
                                pos_world=np.array([0, 0, 400]),
                                rot_world=Rotation.from_euler("xyz", [0, 0, 0]),
@@ -67,13 +71,16 @@ cam_data_0 = pyvale.CameraData(pixels_num=np.array([1540, 1040]),
 # "faceon" to get a face-on stereo system
 stereo_setup = "faceon"
 if stereo_setup == "symmetric":
-    stereo_system = pyvale.CameraTools.symmetric_stereo_cameras(
+    stereo_system = sens.CameraTools.symmetric_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
-if stereo_setup == "faceon":
-    stereo_system = pyvale.CameraTools.faceon_stereo_cameras(
+elif stereo_setup == "faceon":
+    stereo_system = sens.CameraTools.faceon_stereo_cameras(
         cam_data_0=cam_data_0,
         stereo_angle=15.0)
+else:
+    raise ValueError(f"Unknown stereo_setup: {stereo_setup}")
+
 scene.add_stereo_system(stereo_system)
 
 # %%
@@ -95,7 +102,7 @@ stereo_system.save_calibration(base_dir)
 # Blender offers different light types: Point, Sun, Spot and Area.
 # The light can also be moved and rotated like the camera.
 
-light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+light_data = blender.LightData(type=blender.LightType.POINT,
                                      pos_world=(0, 0, 200),
                                      rot_world=Rotation.from_euler("xyz",
                                                                   [0, 0, 0]),
@@ -112,11 +119,11 @@ light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
 # calibration target pattern will not be scaled in the same way as a speckle
 # pattern.
 
-material_data = pyvale.BlenderMaterialData()
-speckle_path = Path.cwd() / "src/pyvale/data/cal_target.tiff"
-mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+material_data = blender.MaterialData()
+cal_target = dataset.cal_target()
+mm_px_resolution = sens.CameraTools.calculate_mm_px_resolution(cam_data_0)
 scene.add_speckle(part=target,
-                  speckle_path=speckle_path,
+                  speckle_path=cal_target,
                   mat_data=material_data,
                   mm_px_resolution=mm_px_resolution,
                   cal=True)
@@ -128,7 +135,7 @@ scene.add_speckle(part=target,
 # rendered.Firstly, all the rendering parameters must be set, including
 # parameters such as the number of threads to use.
 
-render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+render_data = blender.RenderData(cam_data=(stereo_system.cam_data_0,
                                             stereo_system.cam_data_1),
                                 base_dir=base_dir)
 
@@ -141,7 +148,7 @@ render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
 # passed in they will be initialised from the FOV to cover the whole FOV of the
 # cameras.
 
-calibration_data = pyvale.CalibrationData(angle_lims=(-10, 10),
+calibration_data = blender.CalibrationData(angle_lims=(-10, 10),
                                           angle_step=5,
                                           plunge_lims=(-5, 5),
                                           plunge_step=5)
@@ -151,7 +158,7 @@ calibration_data = pyvale.CalibrationData(angle_lims=(-10, 10),
 # rendered before rendering them. The only input that is needed is the
 # `calibration_data` specified above.
 
-number_calibration_images = pyvale.BlenderTools.number_calibration_images(calibration_data)
+number_calibration_images = blender.Tools.number_calibration_images(calibration_data)
 print("Number of calibration images to be rendered:", number_calibration_images)
 
 # %%
@@ -159,7 +166,7 @@ print("Number of calibration images to be rendered:", number_calibration_images)
 # calibration target according to movement limits set above, and will also move
 # the target rigidly across the FOV of the camera, in order to characterise the
 # entire FOV of the cameras.
-pyvale.BlenderTools.render_calibration_images(render_data,
+blender.Tools.render_calibration_images(render_data,
                                               calibration_data,
                                               target)
 
@@ -172,4 +179,4 @@ print("Save directory of the images:", (render_data.base_dir / "calimages"))
 # There is also the option to save the scene as a Blender project file.
 # This file can be opened with the Blender GUI to view the scene.
 
-pyvale.BlenderTools.save_blender_file(base_dir)
+blender.Tools.save_blender_file(base_dir)

pyvale/examples/renderrasterisation/ex_rastenp.py

@@ -10,8 +10,10 @@ import time
 import numpy as np
 from scipy.spatial.transform import Rotation
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
 
 # TODO
 # - Fix the image averaging function to use cython
@@ -34,17 +36,17 @@ def main() -> None:
     # This a path to an exodus *.e output file from MOOSE, this can be
     # replaced with a path to your own simulation file
     sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case21_out.e"
-    #sim_path = pyv.DataSet.render_mechanical_3d_path()
+    #sim_path = sens.DataSet.render_mechanical_3d_path()
 
     disp_comps = ("disp_x","disp_y","disp_z")
 
     sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
 
     # Scale m -> mm
-    sim_data = pyv.scale_length_units(1000.0,sim_data,disp_comps)
+    sim_data = sens.scale_length_units(1000.0,sim_data,disp_comps)
 
     # Extracts the surface mesh from a full 3d simulation for rendering
-    render_mesh = pyv.create_render_mesh(sim_data,
+    render_mesh = sens.create_render_mesh(sim_data,
                                         ("disp_y","disp_x"),
                                         sim_spat_dim=3,
                                         field_disp_keys=disp_comps)
@@ -59,7 +61,7 @@ def main() -> None:
     meshes[1].set_pos(np.array((0.0,12.5,0.0)))
     meshes[1].set_rot(Rotation.from_euler("zyx",(0.0, 0.0, 0.0),degrees=True))
     meshes[1].fields_disp = None
-    coords_all = pyv.get_all_coords_world(meshes)
+    coords_all = sens.get_all_coords_world(meshes)
 
     print()
     print(80*"-")
@@ -85,7 +87,7 @@ def main() -> None:
     fov_scale_factor: float = 1.0
 
     (roi_pos_world,
-     cam_pos_world) = pyv.CameraTools.pos_fill_frame(
+     cam_pos_world) = sens.CameraTools.pos_fill_frame(
          coords_world=coords_all,
          pixel_num=pixel_num,
          pixel_size=pixel_size,
@@ -94,7 +96,7 @@ def main() -> None:
          frame_fill=fov_scale_factor,
      )
 
-    cam_data = pyv.CameraData(
+    cam_data = sens.CameraData(
         pixels_num=pixel_num,
         pixels_size=pixel_size,
         pos_world=cam_pos_world,
@@ -115,7 +117,7 @@ def main() -> None:
     print(cam_data.world_to_cam_mat)
     print(80*"-")
 
-    scene = pyv.RenderScene([cam_data,cam_data],meshes)
+    scene = sens.RenderScene([cam_data,cam_data],meshes)
 
     frames_per_camera = (scene.meshes[0].fields_render.shape[1]
                         *scene.meshes[0].fields_render.shape[2])
@@ -139,8 +141,8 @@ def main() -> None:
     print(80*"=")
     print("IN MEM: Raster Loop start")
 
-    raster_opts = pyv.RasterOpts(parallel=8)
-    renderer = pyv.RasterNumpy(raster_opts)
+    raster_opts = sens.RasterOpts(parallel=8)
+    renderer = sens.RasterNumpy(raster_opts)
 
     time_start_loop = time.perf_counter()
 
@@ -183,7 +185,7 @@ def main() -> None:
 
     plot_on = True
     if plot_on:
-        (fig,ax) = pyv.plot_field_image(images[1][:,:,-1,0],
+        (fig,ax) = sens.plot_field_image(images[1][:,:,-1,0],
                                         title_str="Disp. y, [mm]")
 
     plt.show()