pyvale 2026.1.1__cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl

pyvale/examples/blenderimagedef/ex4_blender_imagedefstereo.py

@@ -0,0 +1,213 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Deforming a sample for stereo DIC
+===================================================
+
+This example takes you through creating stereo DIC scene, applying deformation
+to the sample, and rendering images at each deformation timestep.
+
+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
+
+# 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 = dataset.render_mechanical_3d_path()
+sim_data = mh.ExodusLoader(data_path).load_all_sim_data()
+
+# %%
+# This is then scaled to mm, as all lengths in Blender are to be set in mm.
+# The `SimData` object is then converted into a `RenderMeshData` object, as
+# this skins the mesh ready to be imported into Blender.
+# The `disp_comps` are the expected direction of displacement. Since this is a
+# 3D deformation test case, displacement is expected in the x, y and z directions.
+
+disp_comps = ("disp_x","disp_y", "disp_z")
+sim_data = sens.scale_length_units(scale=1000.0,
+                                   sim_data=sim_data,
+                                   disp_keys=disp_comps)
+
+render_mesh = sens.create_render_mesh(sim_data,
+                                      ("disp_y","disp_x"),
+                                      sim_spat_dim=sens.EDim.THREED,
+                                      field_disp_keys=disp_comps)
+
+# %%
+# Firstly, a save path must be set.
+# In order to do this a base path must be set. Then all the generated files will
+# be saved to a subfolder within this specified base directory
+# (e.g. blenderimages).
+# If no base directory is specified, it will be set as your home directory.
+
+base_dir = Path.cwd() / "pyvale-output"
+if not base_dir.is_dir():
+    base_dir.mkdir(parents=True, exist_ok=True)
+
+# %%
+# 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
+# objects and actions necessary are then methods of this class.
+scene = blender.Scene()
+
+# %%
+# The next thing that can be added to the scene is a sample.
+# This is done by passing in the `RenderMeshData` object.
+# It should be noted that the mesh will be centred on the origin to allow for
+# the cameras to be centred on the mesh.
+# Once the part is added to the Blender scene, it can be both moved and rotated.
+
+part = scene.add_part(render_mesh, sim_spat_dim=3)
+# Set the part location
+part_location = np.array([0, 0, 0])
+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)
+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
+# `CameraStereo` object, which contains the intrinsic parameters of both cameras
+# as well as the extrinsic parameters between them.
+# There are two ways to initialise a `CameraStereo` object.
+# One way is to specify the camera parameters separately for each camera, create
+# a `CameraStereo` object, and then add the stereo system using the
+# `add_stereo_system` method.
+# The other method is to use a convenience function, as shown below.
+# This requires you to first initialise one camera. Then you can choose between
+# either a face-on or symmetric stereo system. Then, either of the
+# `symmetric_stereo_cameras` or `faceon_stereo_cameras` functions can be used to
+# initialise a `CameraStereo` object. The only input required to these functions
+# 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 = 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 = sens.CameraTools.symmetric_stereo_cameras(
+        cam_data_0=cam_data_0,
+        stereo_angle=15.0)
+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)
+
+# %%
+# Since this scene contains a stereo DIC system, a calibration file will be
+# required to run the images through a DIC engine.
+# A calibration file can be generated directly from the `CameraStereo` object.
+# The calibration file will be saved in `YAML` format. However, if you wish to
+# use MatchID to process the images, `save_calibration_mid` can be used instead
+# to save the calibration in a format readable by MatchID.
+# The calibration file will be saved to a sub-directory of the base directory
+# called "calibration".
+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 = blender.LightData(type=blender.LightType.POINT,
+                                     pos_world=(0, 0, 400),
+                                     rot_world=Rotation.from_euler("xyz",
+                                                                   [0, 0, 0]),
+                                     energy=1)
+light = scene.add_light(light_data)
+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 = 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
+
+# %%
+# A speckle pattern can then be applied to the sample.
+# Firstly, the material properties of the sample must be specified, but these
+# will all be defaulted if no inputs are provided.
+#The speckle pattern can then be specified by providing a path to an image file
+# with the pattern.
+# The mm/px resolution of the camera must also be specified in order to
+# correctly scale the speckle pattern.
+# It should be noted that for a bigger camera or sample you may need to generate
+# a larger speckle pattern.
+
+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,
+                  mm_px_resolution=mm_px_resolution)
+
+# %%
+# Deforming the sample and rendering images
+# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+# Once all the objects have been added to the scene, the sample can be deformed,
+# and images can be rendered.
+# Firstly, all the rendering parameters must be set, including parameters such as
+# the number of threads to use.
+# Differently to a 2D DIC system, both cameras' parameters must be specified in
+# the `RenderData` object.
+render_data = blender.RenderData(cam_data=(stereo_system.cam_data_0,
+                                            stereo_system.cam_data_1),
+                                base_dir=base_dir,
+                                dir_name="blender-stereo-def",
+                                threads=8)
+
+# %%
+# A series of deformed images can then be rendered.
+# This is done by passing in rendering parameters, as well as the
+# `RenderMeshData` object, the part(sample) and the spatial dimension of the
+# simulation.
+# This will automatically deform the sample, and render images from each camera
+# at each deformation timestep.
+# If `stage_image` is set to True, the image will be saved to disk, converted to
+# an array, deleted and the image array will be returned. This is due to the
+# fact that an image cannot be saved directly as an array through Blender.
+
+scene.render_deformed_images(render_mesh=render_mesh,
+                             sim_spat_dim=3,
+                             render_data=render_data,
+                             part=part,
+                             stage_image=False)
+
+# %%
+# The rendered image will be saved to this filepath:
+
+print("Save directory of the image:", (render_data.base_dir / render_data.dir_name))
+
+# %%
+# 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.
+
+blender.Tools.save_blender_file(base_dir=base_dir,over_write=True)

pyvale/examples/blenderimagedef/ex5_blender_calibstereo.py

@@ -0,0 +1,190 @@
+# ==============================================================================
+# pyvale: the python validation engine
+# License: MIT
+# Copyright (C) 2025 The Computer Aided Validation Team
+# ==============================================================================
+
+"""
+Rendering calibration images
+---------------------------------------------
+
+This example takes you through how to render calibration images for a given DIC
+setup using in-built tools for calibration target generation.
+
+Note that this example produces a significant number of images and will take a 
+long time to run.
+"""
+import numpy as np
+from scipy.spatial.transform import Rotation
+from pathlib import Path
+
+# pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.blender as blender
+import pyvale.dataset as dataset
+
+# %%
+# Firstly, a save path must be set.
+# In order to do this a base path must be set. Then all the generated files will
+# be saved to a subfolder within this specified base directory
+# (e.g. blenderimages).
+# If no base directory is specified, it will be set as your home directory.
+
+base_dir = Path.cwd() / "pyvale-output" / "blender-calib"
+if not base_dir.is_dir():
+    base_dir.mkdir(parents=True, exist_ok=True)
+
+
+
+# %%
+# 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
+# objects and actions necessary are then methods of this class.
+scene = blender.Scene()
+
+# %%
+# The next thing to add to the scene is the calibration target.
+# This is done by specifing the size of calibration target to add to the scene
+# by passing in an array of (width, height, depth).
+# The calibration target being simulated here is 12 x 9 with 10 mm spacing.
+
+target = scene.add_cal_target(target_size=np.array([150, 100, 10]))
+
+# %%
+# The cameras can then be initialised. A stereo camera system is defined by a
+# `CameraStereo` object, which contains the intrinsic parameters of both cameras
+# as well as the extrinsic parameters between them.
+# There are two ways to initialise a `CameraStereo` object.
+# One way is to specify the camera parameters separately for each camera, create
+# a `CameraStereo` object, and then add the stereo system using the
+# `add_stereo_system` method.
+# The other method is to use a convenience function, as shown below.
+# This requires you to first initialise one camera. Then you can choose between
+# either a face-on or symmetric stereo system. Then, either of the
+# `symmetric_stereo_cameras` or `faceon_stereo_cameras` functions can be used to
+# initialise a `CameraStereo` object. The only input required to these functions
+# 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 = 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 = sens.CameraTools.symmetric_stereo_cameras(
+        cam_data_0=cam_data_0,
+        stereo_angle=15.0)
+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)
+
+# %%
+# Since this scene contains a stereo DIC system, a calibration file will be
+# required to run the images through a DIC engine.
+# A calibration file can be generated directly from the `CameraStereo` object.
+# The calibration file will be saved in `YAML` format. However, if you wish to
+# use MatchID to process the images, `save_calibration_mid` can be used instead
+# to save the calibration in a format readable by MatchID.
+# The calibration file will be saved to a sub-directory of the base directory
+# called "calibration".
+# This calibration file with "perfect" parameters can be used as a comparitive
+# benchmark to the calibration gained from running the calibration files through
+# a DIC engine.
+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 = blender.LightData(type=blender.LightType.POINT,
+                                     pos_world=(0, 0, 200),
+                                     rot_world=Rotation.from_euler("xyz",
+                                                                  [0, 0, 0]),
+                                     energy=1)
+light = scene.add_light(light_data)
+light.location = (0, 0, 210)
+light.rotation_euler = (0, 0, 0) # NOTE: The default is an XYZ Euler angle
+
+# %%
+# The calibration target pattern can then be added to the calibration target
+# object.
+# This is added in the same way that a speckle pattern is added to a sample.
+# However, it is important to set the `cal` flag to True, as this means that the
+# calibration target pattern will not be scaled in the same way as a speckle
+# pattern.
+
+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=cal_target,
+                  mat_data=material_data,
+                  mm_px_resolution=mm_px_resolution,
+                  cal=True)
+
+# %%
+# Rendering a set of images
+# ^^^^^^^^^^^^^^^^^^^^^^^^^
+# Once all the objects have been added to the scene, a set of images can be
+# rendered.Firstly, all the rendering parameters must be set, including
+# parameters such as the number of threads to use.
+
+render_data = blender.RenderData(cam_data=(stereo_system.cam_data_0,
+                                            stereo_system.cam_data_1),
+                                base_dir=base_dir,
+                                dir_name="blender-stereo-cal")
+
+# %%
+# The parameters for the calibration target's movement can then be set. This is
+# done by setting the minimum and maximum angle and plunge limits, as well as
+# the step value that they should be increased by. The x and y limit of the
+# calibration target's movement (from the origin) can also be set if you wish to
+# perform a calibration for a constrained optical setup. If these limits are not
+# passed in they will be initialised from the FOV to cover the whole FOV of the
+# cameras.
+
+calibration_data = blender.CalibrationData(angle_lims=(-10, 10),
+                                          angle_step=20,
+                                          plunge_lims=(-5, 5),
+                                          plunge_step=10)
+
+# %%
+# It is then possible to check the number of calibration images that will be
+# rendered before rendering them. The only input that is needed is the
+# `calibration_data` specified above.
+
+number_calibration_images = blender.Tools.number_calibration_images(calibration_data)
+print("Number of calibration images to be rendered:", number_calibration_images)
+
+# %%
+# The calibration images can then be rendered. This function will move the
+# 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.
+blender.Tools.render_calibration_images(render_data,
+                                        calibration_data,
+                                        target)
+
+# %%
+# The rendered images will be saved to this filepath:
+
+print("Save directory of the images:", (render_data.base_dir / render_data.dir_name))
+
+# %%
+# 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.
+
+blender.Tools.save_blender_file(base_dir=base_dir,over_write=True)

pyvale/examples/dic/README.md

@@ -0,0 +1,2 @@
+Digital Image Correlation (DIC) Examples
+========================================

pyvale/examples/dic/ex1_region_of_interest.py

@@ -0,0 +1,101 @@
+#================================================================================
+#Example: thermocouples on a 2d plate
+#
+#pyvale: the python validation engine
+#License: MIT
+#Copyright (C) 2024 The Computer Aided Validation Team
+#================================================================================
+
+"""
+Selecting a Region of Interest (ROI)
+---------------------------------------------
+
+This example looks at the current core functionality of the Region of Interest
+(ROI) Selection Firsly we'll need to import `pyvale` itself.
+"""
+
+from pathlib import Path
+
+# pyvale modules
+import pyvale.dataset as dataset
+import pyvale.dic as dic
+
+# %% 
+# We'll begin by selecting our Region of Interest (ROI) using the interactive selection tool.
+# First, we create an instance of the ROI class. We pass a reference image to it, which is
+# displayed as the underlay during ROI selection.
+ref_img = dataset.dic_plate_with_hole_ref()
+roi = dic.RegionOfInterest(ref_image=ref_img)
+roi.interactive_selection(subset_size=31)
+
+# create a directory for the the different outputs
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+# %%
+# .. image:: ../../../../_static/roi_tool.gif
+#    :alt: ROI selection GUI (animated)
+#    :width: 600px
+#    :align: center
+
+# %%
+# After closing the interactive tool, a mask and a set of seed coordinates will be generated.
+# These can be used directly in the DIC engine. If you plan to reuse the ROI, it’s a good idea
+# to save it. For very large images, set `binary=True` to reduce file size and speed up saving.
+roi_file = output_path / "roi.dat"
+roi.save_array(filename=roi_file,binary=False)
+
+# %%
+# To reuse the saved ROI mask in the future, load it using:
+roi.read_array(filename=roi_file,binary=False)
+
+# %%
+# If you are loading a previously saved ROI, you may want to visualize it
+# overlaid on the reference image to verify it before proceeding with correlation.
+roi.show_image()
+
+# %%
+# There are also programmatic ways to define an ROI.
+# For example, to exclude a boundary region and keep only the central part:
+roi.reset_mask()
+roi.rect_boundary(left=50,right=50,bottom=50,top=50)
+boundary_img = output_path / "rect_boundary.tiff"
+roi.save_image(boundary_img)
+
+# %%
+# This excludes 50 pixels along each edge of the image from the ROI.
+# Alternatively, to define a specific rectangular region:
+roi.reset_mask()
+roi.rect_region(x=200,y=200,size_x=200,size_y=200)
+region_img = output_path / "rect_region.tiff"
+roi.save_image(region_img)
+
+# %%
+# .. list-table::
+#    :widths: 50 50
+#    :align: center
+#    :header-rows: 0
+#
+#    * - .. figure:: ../../../../_static/rect_boundary.png
+#          :width: 300px
+#          :align: center
+#
+#          ``roi.rect_boundary(left=200, right=200, bottom=200, top=200)``
+#
+#      - .. figure:: ../../../../_static/rect_region.png
+#          :width: 300px
+#          :align: center
+#
+#          ``roi.rect_region(x=200, y=200, size_x=200, size_y=200)``
+
+# %%
+# The `rect_region` example above creates an ROI starting at pixel coordinates (200, 200)
+# with a size of 200×200 pixels.
+#
+# You can also manually modify the ROI mask. A good starting point is:
+# `roi.rect_boundary(0, 0, 0, 0)` — this sets the ROI to include the full image.
+# From there, you can manipulate `roi.mask` as you would any other 2D NumPy array.
+
+
+

pyvale/examples/dic/ex2_plate_with_hole.py

@@ -0,0 +1,155 @@
+#================================================================================
+#Example: thermocouples on a 2d plate
+#
+#pyvale: the python validation engine
+#License: MIT
+#Copyright (C) 2024 The Computer Aided Validation Team
+#================================================================================
+"""
+2D Plate with a Hole
+---------------------
+
+This example walks through setting up a DIC and strain calculation for the
+classic "plate with a hole" problem. The images used are synthetically generated,
+allowing for comparison to analytically known values.
+"""
+
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+# pyvale modules
+import pyvale.dataset as dataset
+import pyvale.dic as dic
+
+# %%
+# We'll start by defining some variables that will be reused throughout the example:
+# the reference image, deformed image(s), and the subset size.
+#
+# If you're working with a series of deformed images, it's a good idea to place
+# them in a separate folder or ensure they follow a consistent naming convention.
+# In such cases, the wildcard operator `*` can be used to select multiple files.
+#
+# The images used here are included in the `data <https://github.com/Computer-Aided-Validation-Laboratory/pyvale/tree/main/src/pyvale/data>`_ folder.
+# We've provided helper functions to load them regardless of your installation path.
+subset_size = 31
+ref_img = dataset.dic_plate_with_hole_ref()
+def_img = dataset.dic_plate_with_hole_def()
+
+# create a directory for the the different outputs
+output_path = Path.cwd() / "pyvale-output"
+if not output_path.is_dir():
+    output_path.mkdir(parents=True, exist_ok=True)
+
+# %%
+# Next, we’ll select our Region of Interest (ROI) using the interactive tool.
+# Create an instance of the ROI class and pass the reference image
+# as input. This image will be shown as the underlay during any ROI selection or
+# visualization.
+roi = dic.RegionOfInterest(ref_img)
+roi.interactive_selection(subset_size)
+
+# %%
+# Once you've closed the ROI interactive window, a mask and seed location coordinates
+# will be generated. These are needed for the DIC engine.
+#
+# If you intend to reuse this ROI, it's a good idea to save it. For large images,
+# setting `binary=True` is recommended to reduce file size and write time.
+roi_file = output_path / "roi.dat"
+roi.save_array(filename=roi_file, binary=False)
+
+# %%
+# To load a previously saved ROI for future use, use the `read_array` method.
+# Make sure the filename and format (binary or human-readable) match what was saved.
+roi.read_array(filename=roi_file, binary=False)
+
+# %%
+# Now we can run the 2D DIC engine using :func:`pyvale.dic_2d`.
+#
+# This function accepts many optional arguments — consult the documentation for full details.
+# At a minimum, you’ll need to specify:
+#
+# - Reference image
+# - Deformed image(s)
+# - ROI mask
+# - Seed coordinates (If using a Reliability Guided approach)
+# - Subset size
+#
+# By default, the engine uses an affine shape function with the Zero Normalised
+# Sum of Squared Differences (ZNSSD) correlation criterion.
+#
+# At present, the DIC engine doesn't return any results to the user, instead the results are saved to disk.
+# You can customize the filename, location, format, and delimiter using
+# the options options `output_basepath`, `output_prefix`, `output_delimiter`, and `output_binary`.
+# More info on these options can be found in the documentation for :func:`dic.two_dimensional`.
+# By default, the results will be saved with the prefix `dic_results_` followed
+# by the original filename. The file extension will be replaced will either ".csv" or "dic2d"
+# depending on whether the results are being saved in human-readable or binary format.
+dic.calculate_2d(reference=ref_img,
+                 deformed=def_img,
+                 roi_mask=roi.mask,
+                 seed=roi.seed,
+                 subset_size=subset_size,
+                 subset_step=10,
+                 shape_function="AFFINE",
+                 max_displacement=10,
+                 correlation_criteria="ZNSSD",
+                 output_basepath=output_path,
+                 output_delimiter=",",
+                 output_prefix="dic_results_")
+
+# %%
+# If you saved the results in a human-readable format, you can use any tool
+# (e.g., Excel, Python, MATLAB) for post-processing.
+#
+# For convenience, we provide a utility function to import results back into Python
+# for analysis and visualization: :func:`pyvale.dic.import_2d`.
+#
+# The returned object is an instance of :class:`pyvale.DICResults`. If the results
+# were saved in binary format or with a custom delimiter, be sure to specify those parameters.
+dic_files = output_path / "dic_results_*.csv"
+dicdata = dic.import_2d(data=dic_files, delimiter=",", binary=False)
+
+# %%
+# As an example, here's a simple visualization of the displacement (u, v) and
+# correlation cost for the two deformed images using matplotlib. You'll need to
+# ensure you have `matplotlib.pyplot` installed and imported.
+fig, axes = plt.subplots(2, 3, figsize=(15, 10))
+axes = axes.flatten()
+
+# First deformation image
+im1 = axes[0].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.u[0])
+im2 = axes[1].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.v[0])
+im3 = axes[2].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.cost[0])
+
+# Second deformation image
+im4 = axes[3].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.u[1])
+im5 = axes[4].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.v[1])
+im6 = axes[5].pcolor(dicdata.ss_x, dicdata.ss_y, dicdata.cost[1])
+
+# Titles
+axes[0].set_title('u component (def0000.tiff)')
+axes[1].set_title('v component (def0000.tiff)')
+axes[2].set_title('cost (def0000.tiff)')
+axes[3].set_title('u component (def0001.tiff)')
+axes[4].set_title('v component (def0001.tiff)')
+axes[5].set_title('cost (def0001.tiff)')
+
+for aa in axes:
+    aa.set_aspect('equal')
+
+# Colorbars
+fig.colorbar(im1, ax=axes[0])
+fig.colorbar(im2, ax=axes[1])
+fig.colorbar(im3, ax=axes[2])
+fig.colorbar(im4, ax=axes[3])
+fig.colorbar(im5, ax=axes[4])
+fig.colorbar(im6, ax=axes[5])
+
+plt.tight_layout()
+plt.show()
+
+# %%
+# .. image:: ../../../../_static/plate_with_hole.png
+#    :alt: Displacement and cost values
+#    :width: 800px
+#    :align: center