pyvale 2025.5.3__cp311-cp311-win32.whl

pyvale/examples/genanalyticdata/ex2_1_analyticsensors.py

@@ -0,0 +1,80 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvale
+
+def main() -> None:
+    (sim_data,_) = pyvale.AnalyticCaseFactory.scalar_linear_2d()
+
+    descriptor = pyvale.SensorDescriptorFactory.temperature_descriptor()
+
+    field_key = 'scalar'
+    t_field = pyvale.FieldScalar(sim_data,
+                                 field_key=field_key,
+                                 elem_dims=2)
+
+    n_sens = (4,1,1)
+    x_lims = (0.0,10.0)
+    y_lims = (0.0,7.5)
+    z_lims = (0.0,0.0)
+    sens_pos = pyvale.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+
+    use_sim_time = False
+    if use_sim_time:
+        sample_times = None
+    else:
+        sample_times = np.linspace(0.0,np.max(sim_data.time),50)
+
+    sensor_data = pyvale.SensorData(positions=sens_pos,
+                                         sample_times=sample_times)
+
+    tc_array = pyvale.SensorArrayPoint(sensor_data,
+                                       t_field,
+                                       descriptor)
+
+    errors_on = {'indep_sys': True,
+                 'rand': True,
+                 'dep_sys': True}
+
+    error_chain = []
+    if errors_on['indep_sys']:
+        error_chain.append(pyvale.ErrSysOffset(offset=-5.0))
+        error_chain.append(pyvale.ErrSysUnif(low=-5.0,
+                                            high=5.0))
+        gen_norm = pyvale.GenNormal(std=1.0)
+
+    if errors_on['rand']:
+        error_chain.append(pyvale.ErrRandNormPercent(std_percent=1.0))
+        error_chain.append(pyvale.ErrRandUnifPercent(low_percent=-1.0,
+                                            high_percent=1.0))
+
+    if errors_on['dep_sys']:
+        error_chain.append(pyvale.ErrSysDigitisation(bits_per_unit=2**8/100))
+        error_chain.append(pyvale.ErrSysSaturation(meas_min=0.0,meas_max=300.0))
+
+    if len(error_chain) > 0:
+        error_integrator = pyvale.ErrIntegrator(error_chain,
+                                                  sensor_data,
+                                                  tc_array.get_measurement_shape())
+        tc_array.set_error_integrator(error_integrator)
+
+    measurements = tc_array.get_measurements()
+
+    pyvale.print_measurements(tc_array,
+                            (0,1), # Sensor 1
+                            (0,1), # Component 1: scalar field = 1 component
+                            (measurements.shape[2]-5,measurements.shape[2]))
+
+    (fig,_) = pyvale.plot_time_traces(tc_array,field_key)
+    plt.show()
+
+    pv_plot = pyvale.plot_point_sensors_on_sim(tc_array,field_key)
+    pv_plot.show(cpos="xy")
+
+if __name__ == '__main__':
+    main()

pyvale/examples/imagedef2d/ex_imagedef2d_todisk.py

@@ -0,0 +1,79 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+
+from pathlib import Path
+import numpy as np
+import mooseherder as mh
+import pyvale as pyv
+
+
+def main() -> None:
+    sim_path = pyv.DataSet.mechanical_2d_path()
+    sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+    image_path = pyv.DataSet.dic_pattern_5mpx_path()
+    image_speckle = pyv.CameraTools.load_image(image_path)
+
+    save_path = Path.cwd()/"exampleoutput"
+
+    coords = sim_data.coords
+    connectivity = (sim_data.connect["connect1"]-1).T # Beware 0 indexing here
+    disp_x = sim_data.node_vars["disp_x"][:,:]
+    disp_y = sim_data.node_vars["disp_y"][:,:]
+
+    print()
+    print(80*"-")
+    print(f"{coords.shape=}")
+    print(f"{connectivity.shape=}")
+    print(f"{disp_x.shape=}")
+    print(f"{disp_y.shape=}")
+    print(80*"-")
+
+
+    cam_data = pyv.CameraData2D(pixels_count=np.array((1040,1540)),
+                                   leng_per_px=0.1e-3,
+                                   bits=8,
+                                   roi_cent_world=np.mean(coords,axis=0),
+                                   subsample=3)
+    id_opts = pyv.ImageDefOpts(save_path=save_path,
+                                  crop_on=True,
+                                  add_static_ref=True)
+
+
+
+    (upsampled_image,
+     image_mask,
+     image_input,
+     disp_x,
+     disp_y) = pyv.ImageDef2D.preprocess(cam_data,
+                                            image_speckle,
+                                            coords,
+                                            connectivity,
+                                            disp_x,
+                                            disp_y,
+                                            id_opts,
+                                            print_on=True)
+
+    ff = -1
+    disp = np.array((disp_x[:,ff],disp_y[:,ff])).T
+    print(f"{disp.shape=}")
+
+
+    pyv.ImageDef2D.deform_images_to_disk(cam_data,
+                                            upsampled_image,
+                                            coords,
+                                            connectivity,
+                                            disp_x,
+                                            disp_y,
+                                            image_mask,
+                                            id_opts,
+                                            print_on=True)
+
+
+if __name__ == "__main__":
+    main()
+

pyvale/examples/renderblender/ex1_1_blenderscene.py

@@ -0,0 +1,121 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pathlib import Path
+import pyvale
+import mooseherder as mh
+
+def main() -> None:
+    data_path = pyvale.DataSet.render_mechanical_3d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y", "disp_z")
+
+    # Scale m -> mm
+    # NOTE: All lengths are to be specified in mm
+    sim_data = pyvale.scale_length_units(sim_data,disp_comps,1000.0)
+
+    render_mesh = pyvale.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    # Set the save path
+    # --------------------------------------------------------------------------
+    # All the files saved will be saved to a subfolder within this specified
+    # base directory.
+    # This base directory can be specified by:
+    base_dir = Path.cwd()
+    # If no base directory is specified, it will be set as your home directory
+
+
+    # Creating the scene
+    # --------------------------------------------------------------------------
+    scene = pyvale.BlenderScene()
+
+
+    # It should be noted that the mesh will be centred to allow for the cameras
+    # to be centred on the mesh.
+    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)
+    # Set part rotation
+    part_rotation = Rotation.from_euler("xyz", [0, 0, 0])
+    pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+
+    # Add the camera
+    cam_data = pyvale.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]),
+                                 roi_cent_world=(0, 0, 0),
+                                 focal_length=15.0)
+    camera = scene.add_camera(cam_data)
+
+    # The camera can be moved and rotated this:
+    camera.location = (0, 0, 410)
+    camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
+
+
+    # Add the light
+    light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+                                         pos_world=(0, 0, 400),
+                                         rot_world=Rotation.from_euler("xyz",
+                                                                       [0, 0, 0]),
+                                         energy=1)
+    light = scene.add_light(light_data)
+
+    # The light can also be moved and rotated:
+    light.location = (0, 0, 410)
+    light.rotation_euler = (0, 0, 0)
+
+    # Apply the speckle pattern
+    material_data = pyvale.BlenderMaterialData()
+    speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
+    # NOTE: If you wish to use a bigger camera, you will need to generate a
+    # bigger speckle pattern generator
+
+    mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data)
+    scene.add_speckle(part=part,
+                                    speckle_path=speckle_path,
+                                    mat_data=material_data,
+                                    mm_px_resolution=mm_px_resolution)
+
+    # Rendering image
+    # --------------------------------------------------------------------------
+    # Set this to True to render image of the current scene
+    render_opts = True
+    if render_opts:
+        # NOTE: If no save directory is specified, this is where the images will
+        # be saved
+        render_data = pyvale.RenderData(cam_data=cam_data,
+                                        base_dir=base_dir,
+                                        threads=8)
+        # NOTE: The number of threads used to render the images is set within
+        # RenderData, it is defaulted to 4 threads
+
+        scene.render_single_image(stage_image=False,
+                                  render_data=render_data)
+        # NOTE: If bounce_image is set to True, the image will be saved to disk,
+        # converted to an array, deleted and the image array will be returned.
+
+        print()
+        print(80*"-")
+        print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
+        print(80*"-")
+        print()
+
+    # Save Blender file
+    # --------------------------------------------------------------------------
+    # The file that will be saved is a Blender project file. This can be opened
+    # with the Blender GUI to view the scene.
+    pyvale.BlenderTools.save_blender_file(base_dir)
+
+if __name__ == "__main__":
+    main()

pyvale/examples/renderblender/ex1_2_blenderdeformed.py

@@ -0,0 +1,119 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pathlib import Path
+import pyvale
+import mooseherder as mh
+
+def main() -> None:
+    data_path = pyvale.DataSet.render_mechanical_3d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y", "disp_z")
+
+    # Scale m -> mm
+    sim_data = pyvale.scale_length_units(sim_data,disp_comps,1000.0)
+
+    render_mesh = pyvale.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    # Set the save path
+    # --------------------------------------------------------------------------
+    # All the files saved will be saved to a subfolder within this specified
+    # base directory.
+    # This base directory can be specified by:
+    base_dir = Path.cwd()
+    # If no base directory is specified, it will be set as your home directory
+
+    # Creating the scene
+    # --------------------------------------------------------------------------
+    scene = pyvale.BlenderScene()
+
+    # It should be noted that the mesh will be centred to allow for the cameras
+    # to be centred on the mesh.
+    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)
+    # Set part rotation
+    part_rotation = Rotation.from_euler("xyz", [0, 0, 0])
+    pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+
+    # Add the camera
+    cam_data = pyvale.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]),
+                                 roi_cent_world=(0, 0, 0),
+                                 focal_length=15.0)
+    camera = scene.add_camera(cam_data)
+
+    # The camera can be moved and rotated this:
+    camera.location = (0, 0, 410)
+    camera.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
+
+    # Add the light
+    light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+                                         pos_world=(0, 0, 400),
+                                         rot_world=Rotation.from_euler("xyz",
+                                                                       [0, 0, 0]),
+                                         energy=1)
+    light = scene.add_light(light_data)
+
+    # The light can also be moved and rotated:
+    light.location = (0, 0, 410)
+    light.rotation_euler = (0, 0, 0)
+
+    # Apply the speckle pattern
+    material_data = pyvale.BlenderMaterialData()
+    speckle_path = pyvale.DataSet.dic_pattern_5mpx_path()
+    # NOTE: If you wish to use a bigger camera, you will need to generate a
+    # bigger speckle pattern generator
+    mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data)
+    scene.add_speckle(part=part,
+                      speckle_path=speckle_path,
+                      mat_data=material_data,
+                      mm_px_resolution=mm_px_resolution)
+
+    # Deform and render images
+    # --------------------------------------------------------------------------
+    # Set this to True to render image of the deforming part
+    render_opts = True
+    if render_opts:
+        # NOTE: If no save directory is specified, this is where the images will
+        # be saved
+        render_data = pyvale.RenderData(cam_data=cam_data,
+                                        base_dir=base_dir,
+                                        threads=8)
+        # NOTE: The number of threads used to render the images is set within
+        # RenderData, it is defaulted to 4 threads
+
+        scene.render_deformed_images(render_mesh,
+                                     sim_spat_dim=3,
+                                     render_data=render_data,
+                                     part=part,
+                                     stage_image=False)
+        # NOTE: If bounce_image is set to True, the image will be saved to disk,
+        # converted to an array, deleted and the image array will be returned.
+
+        print()
+        print(80*"-")
+        print("Save directory of the image:", render_data.base_dir)
+        print(80*"-")
+        print()
+
+    # Save Blender file
+    # --------------------------------------------------------------------------
+    # The file that will be saved is a Blender project file. This can be opened
+    # with the Blender GUI to view the scene.
+    pyvale.BlenderTools.save_blender_file(base_dir)
+
+if __name__ == "__main__":
+    main()

pyvale/examples/renderblender/ex2_1_stereoscene.py

@@ -0,0 +1,128 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pathlib import Path
+import pyvale
+import mooseherder as mh
+
+def main() -> None:
+    data_path = pyvale.DataSet.render_mechanical_3d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y", "disp_z")
+
+    # Scale m -> mm
+    # NOTE: All lengths are to be specified in mm
+    sim_data = pyvale.scale_length_units(sim_data,disp_comps,1000.0)
+
+    render_mesh = pyvale.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    # Set the save path
+    # --------------------------------------------------------------------------
+    # All the files saved will be saved to a subfolder within this specified
+    # base directory.
+    # This base directory can be specified by:
+    base_dir = Path.cwd()
+    # If no base directory is specified, it will be set as your home directory
+
+    # Creating the scene
+    # --------------------------------------------------------------------------
+    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)
+    # Set part rotation
+    part_rotation = Rotation.from_euler("xyz", [0, 0, 0])
+    pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+
+    # Add the stereo camera system
+    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)
+    # 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(
+            cam_data_0=cam_data_0,
+            stereo_angle=15.0)
+    if stereo_setup == "faceon":
+        stereo_system = pyvale.CameraTools.faceon_stereo_cameras(
+            cam_data_0=cam_data_0,
+            stereo_angle=15.0)
+
+    cam0, cam1 = scene.add_stereo_system(stereo_system)
+
+    # Generate calibration file
+    stereo_system.save_calibration(base_dir)
+
+    # Add the light
+    light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+                                         pos_world=(0, 0, 400),
+                                         rot_world=Rotation.from_euler("xyz",
+                                                                       [0, 0, 0]),
+                                         energy=1)
+    light = scene.add_light(light_data)
+
+    # The light can also be moved and rotated:
+    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()
+    # NOTE: If you wish to use a bigger camera, you will need to generate a
+    # bigger speckle pattern generator
+
+    mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+    scene.add_speckle(part=part,
+                      speckle_path=speckle_path,
+                      mat_data=material_data,
+                      mm_px_resolution=mm_px_resolution)
+
+    # Rendering image
+    # --------------------------------------------------------------------------
+    # Set this to True to render image of the current scene
+    render_opts = True
+    if render_opts:
+        # NOTE: If no save directory is specified, this is where the images will
+        # be saved
+        render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+                                                  stereo_system.cam_data_1),
+                                        base_dir=base_dir,
+                                        threads=8)
+        # NOTE: The number of threads used to render the images is set within
+        # RenderData, it is defaulted to 4 threads
+
+        scene.render_single_image(stage_image=False,
+                                  render_data=render_data)
+        # NOTE: If bounce_image is set to True, the image will be saved to disk,
+        # converted to an array, deleted and the image array will be returned.
+
+        print()
+        print(80*"-")
+        print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
+        print(80*"-")
+        print()
+
+    # Save Blender file
+    # --------------------------------------------------------------------------
+    # The file that will be saved is a Blender project file. This can be opened
+    # with the Blender GUI to view the scene.
+    pyvale.BlenderTools.save_blender_file(base_dir=base_dir)
+
+if __name__ == "__main__":
+    main()

pyvale/examples/renderblender/ex2_2_stereodeformed.py

@@ -0,0 +1,131 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pathlib import Path
+import pyvale
+import mooseherder as mh
+
+def main() -> None:
+    data_path = pyvale.DataSet.render_mechanical_3d_path()
+    sim_data = mh.ExodusReader(data_path).read_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y", "disp_z")
+
+    # Scale m -> mm
+    # NOTE: All lengths are to be specified in mm
+    sim_data = pyvale.scale_length_units(sim_data,disp_comps,1000.0)
+
+    render_mesh = pyvale.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    # Set the save path
+    # --------------------------------------------------------------------------
+    # All the files saved will be saved to a subfolder within this specified
+    # base directory.
+    # This base directory can be specified by:
+    base_dir = Path.cwd()
+    # If no base directory is specified, it will be set as your home directory
+
+    # Creating the scene
+    # --------------------------------------------------------------------------
+    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)
+    # Set part rotation
+    part_rotation = Rotation.from_euler("xyz", [0, 0, 0])
+    pyvale.BlenderTools.rotate_blender_obj(part=part, rot_world=part_rotation)
+
+    # Add the stereo camera system
+    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)
+    # 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(
+            cam_data_0=cam_data_0,
+            stereo_angle=15.0)
+    if stereo_setup == "faceon":
+        stereo_system = pyvale.CameraTools.faceon_stereo_cameras(
+            cam_data_0=cam_data_0,
+            stereo_angle=15.0)
+
+    cam0, cam1 = scene.add_stereo_system(stereo_system)
+
+    # Generate calibration file
+    stereo_system.save_calibration(base_dir)
+
+    # Add the light
+    light_data = pyvale.BlenderLightData(type=pyvale.BlenderLightType.POINT,
+                                         pos_world=(0, 0, 400),
+                                         rot_world=Rotation.from_euler("xyz",
+                                                                       [0, 0, 0]),
+                                         energy=1)
+    light = scene.add_light(light_data)
+
+    # The light can also be moved and rotated:
+    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()
+    # NOTE: If you wish to use a bigger camera, you will need to generate a
+    # bigger speckle pattern generator
+
+    mm_px_resolution = pyvale.CameraTools.calculate_mm_px_resolution(cam_data_0)
+    scene.add_speckle(part=part,
+                      speckle_path=speckle_path,
+                      mat_data=material_data,
+                      mm_px_resolution=mm_px_resolution)
+
+    # Deform and render images
+    # --------------------------------------------------------------------------
+    # Set this to True to render image of the deforming part
+    render_opts = True
+    if render_opts:
+        # NOTE: If no save directory is specified, this is where the images will
+        # be saved
+        render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+                                                  stereo_system.cam_data_1),
+                                        base_dir=base_dir,
+                                        threads=8)
+        # NOTE: The number of threads used to render the images is set within
+        # RenderData, it is defaulted to 4 threads
+
+        scene.render_deformed_images(render_mesh=render_mesh,
+                                     sim_spat_dim=3,
+                                     render_data=render_data,
+                                     part=part,
+                                     stage_image=False)
+        # NOTE: If bounce_image is set to True, the image will be saved to disk,
+        # converted to an array, deleted and the image array will be returned.
+
+        print()
+        print(80*"-")
+        print("Save directory of the image:", (render_data.base_dir / "blenderimages"))
+        print(80*"-")
+        print()
+
+    # Save Blender file
+    # --------------------------------------------------------------------------
+    # The file that will be saved is a Blender project file. This can be opened
+    # with the Blender GUI to view the scene.
+    pyvale.BlenderTools.save_blender_file(base_dir)
+
+if __name__ == "__main__":
+    main()