pyvale 2025.5.3__cp311-cp311-macosx_13_0_x86_64.whl

pyvale/examples/renderblender/ex3_1_blendercalibration.py

@@ -0,0 +1,120 @@
+# ==============================================================================
+# 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
+
+def main() -> None:
+    #NOTE: All lengths are to be specified in mm
+
+    # 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("./")
+    # If no base directory is specified, it will be set as your home directory
+
+    # Creating the scene
+    # --------------------------------------------------------------------------
+    scene = pyvale.BlenderScene()
+
+    # Add the calibration target
+    # A rectangular calibration target of the specified size is added to the scene
+    target = scene.add_cal_target(target_size=np.array([150, 100, 10]))
+
+    # Add the camera
+    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)
+
+    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, 200),
+                                         rot_world=Rotation.from_euler("xyz",
+                                                                       [0, 0, 0]),
+                                         energy=1)
+    light = scene.add_light(light_data)
+    # The light can be moved and rotated:
+    light.location = (0, 0, 210)
+    light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
+
+    # Apply the calibration target 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)
+    scene.add_speckle(part=target,
+                                    speckle_path=speckle_path,
+                                    mat_data=material_data,
+                                    mm_px_resolution=mm_px_resolution,
+                                    cal=True)
+    # NOTE: The `cal` flag has to be set to True in order to scale the
+    # calibration target pattern correctly
+
+    # Rendering calibration images
+    # --------------------------------------------------------------------------
+    save_dir = Path.cwd() / "blenderimages"
+    save_name = "cal"
+    render_data = pyvale.RenderData(cam_data=(stereo_system.cam_data_0,
+                                              stereo_system.cam_data_1),
+                                    base_dir=base_dir)
+    # NOTE: The number of threads used to render the images is set within
+    # RenderData, it is defaulted to 4 threads
+
+    # The desired limits for the calibration target movement are to be set within
+    # the CalibrationData dataclass
+    calibration_data = pyvale.CalibrationData(angle_lims=(-10, 10),
+                                              angle_step=5,
+                                              plunge_lims=(-5, 5),
+                                              plunge_step=5)
+
+    # The number of calibration images that will be rendered can be calculated
+    number_calibration_images = pyvale.BlenderTools.number_calibration_images(calibration_data)
+    print()
+    print(80*"-")
+    print("Number of calibration images to be rendered:", number_calibration_images)
+    print(80*"-")
+
+    # The calibration images can then be rendered
+    pyvale.BlenderTools.render_calibration_images(render_data,
+                                                  calibration_data,
+                                                  target)
+
+    print()
+    print(80*"-")
+    print("Save directory of the images:", (render_data.base_dir / "calimages"))
+    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/renderrasterisation/ex_rastenp.py

@@ -0,0 +1,153 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from pathlib import Path
+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
+
+# TODO
+# - Fix the image averaging function to use cython
+# - Saving of the rendered images for post processing or analysis
+# - Collapse image display functions into visual to simplify code
+#
+# CAMERA:
+# - Need option to work camera rotation based on a given position
+#   - The z axis is easy as we can just do roi-cam_pos but what about x and y
+#
+# SCENE OBJECT:
+# - Allow multiple objects in the scene with their own transformations
+# - Allow multiple cameras in the scene
+
+
+def main() -> None:
+    """pyvale example: rasterisation field renderer
+    ----------------------------------------------------------------------------
+    - TODO
+    """
+    # 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()
+
+    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(sim_data,disp_comps,1000.0)
+
+    # Extracts the surface mesh from a full 3d simulation for rendering
+    render_mesh = pyv.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    print()
+    print(80*"-")
+    print("MESH DATA:")
+    print(80*"-")
+    print("connectivity.shape=(num_elems,num_nodes_per_elem)")
+    print(f"{render_mesh.connectivity.shape=}")
+    print()
+    print("coords.shape=(num_nodes,coord[x,y,z])")
+    print(f"{render_mesh.coords.shape=}")
+    print()
+    print("fields.shape=(num_coords,num_time_steps,num_components)")
+    print(f"{render_mesh.fields_render.shape=}")
+    if render_mesh.fields_disp is not None:
+        print(f"{render_mesh.fields_disp.shape=}")
+    print(80*"-")
+    print()
+
+
+    pixel_num = np.array((960,1280))
+    pixel_size = np.array((5.3e-3,5.3e-3))
+    focal_leng: float = 50
+    cam_rot = Rotation.from_euler("zyx",(0.0,-30.0,-10.0),degrees=True)
+    fov_scale_factor: float = 1.1
+
+    (roi_pos_world,
+     cam_pos_world) = pyv.CameraTools.pos_fill_frame_from_rotation(
+         coords_world=render_mesh.coords,
+         pixel_num=pixel_num,
+         pixel_size=pixel_size,
+         focal_leng=focal_leng,
+         cam_rot=cam_rot,
+         frame_fill=fov_scale_factor,
+     )
+
+    cam_data = pyv.CameraData(
+        pixels_num=pixel_num,
+        pixels_size=pixel_size,
+        pos_world=cam_pos_world,
+        rot_world=cam_rot,
+        roi_cent_world=roi_pos_world,
+        focal_length=focal_leng,
+        sub_samp=2,
+        back_face_removal=True,
+    )
+
+    print(80*"-")
+    print("CAMERA DATA:")
+    print(80*"-")
+    print(f"{roi_pos_world=}")
+    print(f"{cam_pos_world=}")
+    print()
+    print("World to camera matrix:")
+    print(cam_data.world_to_cam_mat)
+    print(80*"-")
+    print()
+
+    print(80*"-")
+    total_frames = render_mesh.fields_render.shape[1]*render_mesh.fields_render.shape[2]
+    print(f"Time steps to render: {render_mesh.fields_render.shape[1]}")
+    print(f"Fields to render: {render_mesh.fields_render.shape[2]}")
+    print(f"Total frames to render: {total_frames}")
+    print(80*"-")
+
+    print()
+    print(80*"=")
+    print("RASTER LOOP START")
+
+    #save_path = Path.cwd()/"example_output"
+    save_path = None
+    static_mesh = False
+
+    time_start_loop = time.perf_counter()
+    if static_mesh:
+        images = pyv.RasterNP.raster_static_mesh(
+            cam_data,render_mesh,save_path,threads_num=8
+        )
+    else:
+        time_start_loop = time.perf_counter()
+        images = pyv.RasterNP.raster_deformed_mesh(
+            cam_data,render_mesh,save_path,parallel=8
+        )
+
+    time_end_loop = time.perf_counter()
+    render_time = time_end_loop - time_start_loop
+
+
+    print("RASTER LOOP END")
+    print(80*"=")
+    print("PERFORMANCE")
+    print(f"Total frames = {total_frames}")
+    print(f"Total render time = {render_time:.4f} seconds")
+    print(f"Time per frame = {(render_time/total_frames):.4f} seconds")
+    print(80*"=")
+
+    plot_on = True
+    if plot_on:
+        (fig,ax) = pyv.plot_field_image(images[:,:,-1,0],
+                                        title_str="Disp. y, [mm]")
+        plt.show()
+
+if __name__ == "__main__":
+    main()

pyvale/examples/renderrasterisation/ex_rastercyth_oneframe.py

@@ -0,0 +1,218 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+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
+import imagebenchmarks as ib
+
+def main() -> None:
+    """pyvale example: rasterisation field renderer
+    ----------------------------------------------------------------------------
+    - TODO
+    """
+    print()
+    print(80*"=")
+    print("RASTER CYTHON FILE (should be *.so on Linux):")
+    print(pyv.rastercyth.__file__)
+    print(80*"=")
+    print()
+
+    return
+
+    benchmark = True
+    if not benchmark:
+
+        # 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"/"case26_out.e"
+
+        sim_path = pyv.DataSet.render_simple_block_path()
+        sim_path = pyv.DataSet.render_mechanical_3d_path()
+        sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+        disp_comps = ("disp_x","disp_y","disp_z")
+
+        # Scale m -> mm
+        sim_data = pyv.scale_length_units(sim_data,disp_comps,1000.0)
+
+        print()
+        print(f"{np.max(np.abs(sim_data.node_vars['disp_x']))=}")
+        print(f"{np.max(np.abs(sim_data.node_vars['disp_y']))=}")
+        print(f"{np.max(np.abs(sim_data.node_vars['disp_z']))=}")
+        print()
+
+        # Extracts the surface mesh from a full 3d simulation for rendering
+        render_mesh = pyv.create_render_mesh(sim_data,
+                                            ("disp_y","disp_x","disp_z"),
+                                            sim_spat_dim=3,
+                                            field_disp_keys=disp_comps)
+
+
+
+
+
+        pixel_num = np.array((960,1280),dtype=np.int32)
+        pixel_size = np.array((5.3e-3,5.3e-3),dtype=np.float64)
+        focal_leng: float = 50.0
+        cam_rot = Rotation.from_euler("ZYX",(0.0,-30.0,-10.0),degrees=True)
+        fov_scale_factor: float = 1.1
+
+        (roi_pos_world,
+        cam_pos_world) = pyv.CameraTools.pos_fill_frame_from_rotation(
+            coords_world=render_mesh.coords,
+            pixel_num=pixel_num,
+            pixel_size=pixel_size,
+            focal_leng=focal_leng,
+            cam_rot=cam_rot,
+            frame_fill=fov_scale_factor,
+        )
+
+        cam_data = pyv.CameraData(
+            pixels_num=pixel_num,
+            pixels_size=pixel_size,
+            pos_world=cam_pos_world,
+            rot_world=cam_rot,
+            roi_cent_world=roi_pos_world,
+            focal_length=focal_leng,
+            sub_samp=2,
+            back_face_removal=True,
+        )
+
+    else:
+        case_ind = 0
+        (case_ident,render_mesh,cam_data) = ib.load_benchmark_by_index(case_ind)
+        print(80*"=")
+        print("BENCHMARK IDENTIFIER:")
+        print(f"{case_ident}")
+        print(80*"=")
+
+
+    print()
+    print(80*"-")
+    print("MESH DATA:")
+    print(80*"-")
+    print("connectivity.shape=(num_elems,num_nodes_per_elem)")
+    print(f"{render_mesh.connectivity.shape=}")
+    print()
+    print("coords.shape=(num_nodes,coord[x,y,z])")
+    print(f"{render_mesh.coords.shape=}")
+    print()
+    print("fields.shape=(num_coords,num_time_steps,num_components)")
+    print(f"{render_mesh.fields_render.shape=}")
+    if render_mesh.fields_disp is not None:
+        print(f"{render_mesh.fields_disp.shape=}")
+    print(80*"-")
+    print()
+
+    print(80*"-")
+    print("CAMERA DATA:")
+    print(80*"-")
+    print(f"{cam_data.image_dist=}")
+    print(f"{cam_data.roi_cent_world=}")
+    print(f"{cam_data.pos_world=}")
+    print()
+    print("World to camera matrix:")
+    print(cam_data.world_to_cam_mat)
+    print(80*"-")
+    print()
+
+
+    print(80*"-")
+    total_frames = render_mesh.fields_render.shape[1]*render_mesh.fields_render.shape[2]
+    print(f"Time steps to render: {render_mesh.fields_render.shape[1]}")
+    print(f"Fields to render: {render_mesh.fields_render.shape[2]}")
+    print(f"Total frames to render: {total_frames}")
+    print(80*"-")
+
+    print(80*"=")
+    print("RASTER ELEMENT LOOP START")
+    print(80*"=")
+
+    num_loops = 1
+
+    loop_times = np.zeros((num_loops,),dtype=np.float64)
+
+    frame = -1
+    fields_render = render_mesh.fields_render[:,frame,:]
+    total_frames = fields_render.shape[1]
+
+    print()
+    print("Running raster loop.")
+    for nn in range(num_loops):
+        print(f"Running loop {nn}")
+        loop_start = time.perf_counter()
+
+        (image_buffer,
+         depth_buffer,
+         elems_in_image) = pyv.rastercyth.raster_frame(
+                                                render_mesh.coords,
+                                                render_mesh.connectivity,
+                                                fields_render,
+                                                cam_data)
+
+        loop_times[nn] = time.perf_counter() - loop_start
+
+    print()
+    print(80*"=")
+    print("PERFORMANCE TIMERS")
+    print(f"Elements in image = {elems_in_image}")
+    print(f"Image buffer shape = {image_buffer.shape}")
+    print(f"Avg. total render time = {np.mean(loop_times):.4f} seconds")
+    print(f"Avg. render time per frame = {(np.mean(loop_times)/total_frames):.4f} seconds")
+    print(80*"=")
+
+
+    #===========================================================================
+    # PLOTTING
+    plot_on = True
+    plot_field = 0
+
+    # depth_to_plot = np.copy(np.asarray(depth_buffer[:,:,plot_frame]))
+    # depth_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+    # image_to_plot = np.copy(np.asarray(image_buffer[:,:,plot_frame,plot_field]))
+    # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+
+    if plot_on:
+        plot_opts = pyv.PlotOptsGeneral()
+
+
+        (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                layout='constrained')
+        fig.set_dpi(plot_opts.resolution)
+        cset = plt.imshow(depth_buffer[:,:],
+                        cmap=plt.get_cmap(plot_opts.cmap_seq))
+                        #origin='lower')
+        ax.set_aspect('equal','box')
+        fig.colorbar(cset)
+        ax.set_title(f"Depth buffer",fontsize=plot_opts.font_head_size)
+        ax.set_xlabel(r"x ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+        ax.set_ylabel(r"y ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+        (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                layout='constrained')
+        fig.set_dpi(plot_opts.resolution)
+        cset = plt.imshow(image_buffer[:,:,plot_field],
+                        cmap=plt.get_cmap(plot_opts.cmap_seq))
+                        #origin='lower')
+        ax.set_aspect('equal','box')
+        fig.colorbar(cset)
+        ax.set_title(f"Field Image",fontsize=plot_opts.font_head_size)
+        ax.set_xlabel(r"x ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+        ax.set_ylabel(r"y ($px$)",
+                    fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+        plt.show()
+
+
+if __name__ == "__main__":
+    main()

pyvale/examples/renderrasterisation/ex_rastercyth_static_cypara.py

@@ -0,0 +1,187 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+from pathlib import Path
+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
+
+def main() -> None:
+    print()
+    print(80*"=")
+    print("RASTER CYTHON FILE (should be *.so on Linux):")
+    print(pyv.rastercyth.__file__)
+    print(80*"=")
+    print()
+
+    sim_path = pyv.DataSet.render_mechanical_3d_path()
+    #sim_path = pyv.DataSet.render_simple_block_path()
+    #sim_path = Path.home()/"pyvale"/"src"/"pyvale"/"simcases"/"case26_out.e"
+    sim_data = mh.ExodusReader(sim_path).read_all_sim_data()
+
+    disp_comps = ("disp_x","disp_y","disp_z")
+
+    # Scale m -> mm
+    sim_data = pyv.scale_length_units(sim_data,disp_comps,1000.0)
+
+    print()
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_x']))=}")
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_y']))=}")
+    print(f"{np.max(np.abs(sim_data.node_vars['disp_z']))=}")
+    print()
+
+    # Extracts the surface mesh from a full 3d simulation for rendering
+    render_mesh = pyv.create_render_mesh(sim_data,
+                                        ("disp_y","disp_x"),
+                                        sim_spat_dim=3,
+                                        field_disp_keys=disp_comps)
+
+    print()
+    print(80*"-")
+    print("MESH DATA:")
+    print(80*"-")
+    print("connectivity.shape=(num_elems,num_nodes_per_elem)")
+    print(f"{render_mesh.connectivity.shape=}")
+    print()
+    print("coords.shape=(num_nodes,coord[x,y,z])")
+    print(f"{render_mesh.coords.shape=}")
+    print()
+    print("fields.shape=(num_coords,num_time_steps,num_components)")
+    print(f"{render_mesh.fields_render.shape=}")
+    if render_mesh.fields_disp is not None:
+        print(f"{render_mesh.fields_disp.shape=}")
+    print(80*"-")
+    print()
+
+    pixel_num = np.array((960,1280),dtype=np.int32)
+    pixel_size = np.array((5.3e-3,5.3e-3),dtype=np.float64)
+    focal_leng: float = 50.0
+    cam_rot = Rotation.from_euler("zyx",(0.0,-30.0,-10.0),degrees=True)
+    fov_scale_factor: float = 1.1
+
+    (roi_pos_world,
+     cam_pos_world) = pyv.CameraTools.pos_fill_frame_from_rotation(
+         coords_world=render_mesh.coords,
+         pixel_num=pixel_num,
+         pixel_size=pixel_size,
+         focal_leng=focal_leng,
+         cam_rot=cam_rot,
+         frame_fill=fov_scale_factor,
+     )
+
+    cam_data = pyv.CameraData(
+        pixels_num=pixel_num,
+        pixels_size=pixel_size,
+        pos_world=cam_pos_world,
+        rot_world=cam_rot,
+        roi_cent_world=roi_pos_world,
+        focal_length=focal_leng,
+        sub_samp=2,
+        back_face_removal=True,
+    )
+
+    print(80*"-")
+    print("CAMERA DATA:")
+    print(80*"-")
+    print(f"{cam_data.image_dist=}")
+    print(f"{cam_data.roi_cent_world=}")
+    print(f"{cam_data.pos_world=}")
+    print()
+    print("World to camera matrix:")
+    print(cam_data.world_to_cam_mat)
+    print(80*"-")
+    print()
+
+    print(80*"-")
+    total_frames = render_mesh.fields_render.shape[1]*render_mesh.fields_render.shape[2]
+    print(f"Time steps to render: {render_mesh.fields_render.shape[1]}")
+    print(f"Fields to render: {render_mesh.fields_render.shape[2]}")
+    print(f"Total frames to render: {total_frames}")
+    print(80*"-")
+
+    print(80*"=")
+    print("RASTER ELEMENT LOOP START")
+    print(80*"=")
+
+    num_loops = 1
+    loop_times = np.zeros((num_loops,),dtype=np.float64)
+
+    print()
+    print("Running raster loop.")
+    for nn in range(num_loops):
+        print(f"Running loop {nn}")
+        loop_start = time.perf_counter()
+
+        (image_buffer,
+         depth_buffer,
+         elems_in_image) = pyv.rastercyth.raster_static_mesh(
+                                                render_mesh,
+                                                cam_data,
+                                                0)
+
+        loop_times[nn] = time.perf_counter() - loop_start
+
+    print()
+    print(80*"=")
+    print("PERFORMANCE TIMERS")
+    print(f"Elements in image = {elems_in_image}")
+    print(f"Image buffer shape = {image_buffer.shape}")
+    print(f"Avg. total render time = {np.mean(loop_times):.4f} seconds")
+    print(f"Avg. render time per frame = {(np.mean(loop_times)/total_frames):.4f} seconds")
+    print(80*"=")
+
+
+    #===========================================================================
+    # PLOTTING
+    plot_on = True
+    plot_frames = (1,)#range(3)
+    plot_field = 0
+
+    # depth_to_plot = np.copy(np.asarray(depth_buffer[:,:,plot_frame]))
+    # depth_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+    # image_to_plot = np.copy(np.asarray(image_buffer[:,:,plot_frame,plot_field]))
+    # image_to_plot[depth_buffer[:,:,plot_frame] > 10*cam_data.image_dist] = np.nan
+
+    if plot_on:
+        plot_opts = pyv.PlotOptsGeneral()
+
+        for ff in plot_frames:
+            (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                    layout='constrained')
+            fig.set_dpi(plot_opts.resolution)
+            cset = plt.imshow(depth_buffer[:,:,ff],
+                            cmap=plt.get_cmap(plot_opts.cmap_seq))
+                            #origin='lower')
+            ax.set_aspect('equal','box')
+            fig.colorbar(cset)
+            ax.set_title(f"Depth buffer: {ff}",fontsize=plot_opts.font_head_size)
+            ax.set_xlabel(r"x ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+            ax.set_ylabel(r"y ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+            (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                    layout='constrained')
+            fig.set_dpi(plot_opts.resolution)
+            cset = plt.imshow(image_buffer[:,:,ff,plot_field],
+                            cmap=plt.get_cmap(plot_opts.cmap_seq))
+                            #origin='lower')
+            ax.set_aspect('equal','box')
+            fig.colorbar(cset)
+            ax.set_title(f"Field Image: {ff}",fontsize=plot_opts.font_head_size)
+            ax.set_xlabel(r"x ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+            ax.set_ylabel(r"y ($px$)",
+                        fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+        plt.show()
+
+
+if __name__ == "__main__":
+    main()