pyvale 2025.4.0__py3-none-any.whl

pyvale/core/visualexpplotter.py

@@ -0,0 +1,151 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from typing import Any
+
+import numpy as np
+import matplotlib.pyplot as plt
+from pyvale.core.visualopts import (PlotOptsGeneral,
+                                   TraceOptsExperiment)
+from pyvale.core.experimentsimulator import ExperimentSimulator
+
+#TODO: Docstrings
+
+def plot_exp_traces(exp_sim: ExperimentSimulator,
+                    component: str,
+                    sens_array_num: int,
+                    sim_num: int,
+                    trace_opts: TraceOptsExperiment | None = None,
+                    plot_opts: PlotOptsGeneral | None = None) -> tuple[Any,Any]:
+
+    if trace_opts is None:
+        trace_opts = TraceOptsExperiment()
+
+    if plot_opts is None:
+        plot_opts = PlotOptsGeneral()
+
+    descriptor = exp_sim.sensor_arrays[sens_array_num].descriptor
+    comp_ind = exp_sim.sensor_arrays[sens_array_num].field.get_component_index(component)
+    samp_time = exp_sim.sensor_arrays[sens_array_num].get_sample_times()
+    num_sens = exp_sim.sensor_arrays[sens_array_num].get_measurement_shape()[0]
+
+    exp_data = exp_sim.get_data()
+    exp_stats = exp_sim.get_stats()
+
+    if trace_opts.sensors_to_plot is None:
+        sensors_to_plot = range(num_sens)
+    else:
+        sensors_to_plot = trace_opts.sensors_to_plot
+
+    #---------------------------------------------------------------------------
+    # Figure canvas setup
+    fig, ax = plt.subplots(figsize=plot_opts.single_fig_size_portrait,
+                           layout='constrained')
+    fig.set_dpi(plot_opts.resolution)
+
+    #---------------------------------------------------------------------------
+    # Plot all simulated experimental points
+    if trace_opts.plot_all_exp_points:
+        for ss in sensors_to_plot:
+            for ee in range(exp_sim.num_exp_per_sim):
+                ax.plot(samp_time,
+                        exp_data[sens_array_num][sim_num,ee,ss,comp_ind,:],
+                        "+",
+                        lw=plot_opts.lw,
+                        ms=plot_opts.ms,
+                        color=plot_opts.colors[ss % plot_opts.n_colors])
+
+    for ss in sensors_to_plot:
+        if trace_opts.centre == "median":
+            ax.plot(samp_time,
+                    exp_stats[sens_array_num].median[sim_num,ss,comp_ind,:],
+                    trace_opts.exp_mean_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ss % plot_opts.n_colors])
+        else:
+            ax.plot(samp_time,
+                    exp_stats[sens_array_num].mean[sim_num,ss,comp_ind,:],
+                    trace_opts.exp_mean_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ss % plot_opts.n_colors])
+
+        if trace_opts is not None:
+            upper = np.zeros_like(exp_stats[sens_array_num].min)
+            lower = np.zeros_like(exp_stats[sens_array_num].min)
+
+            if trace_opts.fill_between == 'max':
+                upper = exp_stats[sens_array_num].min
+                lower = exp_stats[sens_array_num].max
+
+            elif trace_opts.fill_between == 'quartile':
+                upper = exp_stats[sens_array_num].q25
+                lower = exp_stats[sens_array_num].q75
+
+            elif trace_opts.fill_between == '2std':
+                upper = exp_stats[sens_array_num].mean + \
+                        2*exp_stats[sens_array_num].std
+                lower = exp_stats[sens_array_num].mean - \
+                        2*exp_stats[sens_array_num].std
+
+            elif trace_opts.fill_between == '3std':
+                upper = exp_stats[sens_array_num].mean + \
+                        3*exp_stats[sens_array_num].std
+                lower = exp_stats[sens_array_num].mean - \
+                        3*exp_stats[sens_array_num].std
+
+            ax.fill_between(samp_time,
+                upper[sim_num,ss,comp_ind,:],
+                lower[sim_num,ss,comp_ind,:],
+                color=plot_opts.colors[ss % plot_opts.n_colors],
+                alpha=0.2)
+
+    #---------------------------------------------------------------------------
+    # Plot simulation and truth line
+    if trace_opts.sim_line is not None:
+        sim_time = exp_sim.sensor_arrays[sens_array_num].field.get_time_steps()
+        sim_vals = exp_sim.sensor_arrays[sens_array_num].field.sample_field(
+                    exp_sim.sensor_arrays[sens_array_num].positions)
+
+        for ss in sensors_to_plot:
+            ax.plot(sim_time,
+                    sim_vals[ss,comp_ind,:],
+                    trace_opts.sim_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms)
+
+    if trace_opts.truth_line is not None:
+        truth = exp_sim.sensor_arrays[sens_array_num].get_truth()
+        for ss in sensors_to_plot:
+            ax.plot(samp_time,
+                    truth[ss,comp_ind,:],
+                    trace_opts.truth_line,
+                    lw=plot_opts.lw,
+                    ms=plot_opts.ms,
+                    color=plot_opts.colors[ss % plot_opts.n_colors])
+
+    #---------------------------------------------------------------------------
+    # Axis / legend labels and options
+    ax.set_xlabel(trace_opts.time_label,
+                fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+    ax.set_ylabel(descriptor.create_label(comp_ind),
+                fontsize=plot_opts.font_ax_size, fontname=plot_opts.font_name)
+
+    if trace_opts.time_min_max is None:
+        ax.set_xlim((np.min(samp_time),np.max(samp_time))) # type: ignore
+    else:
+        ax.set_xlim(trace_opts.time_min_max)
+
+    trace_opts.legend = False
+    if trace_opts.legend:
+        ax.legend(prop={"size":plot_opts.font_leg_size},loc='best')
+
+    plt.grid(True)
+    plt.draw()
+
+    return (fig,ax)

pyvale/core/visualimagedef.py

@@ -0,0 +1,71 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+
+class ImageDefDiags:
+    @staticmethod
+    def plot_speckle_image(image: np.ndarray,
+                   title: str = "",
+                   cmap: str = "gray") -> None:
+        fig, ax = plt.subplots()
+        cset = plt.imshow(image,cmap=plt.get_cmap(cmap),origin='lower')
+        ax.set_aspect('equal','box')
+        ax.set_title(title,fontsize=12)
+        fig.colorbar(cset)
+
+    @staticmethod
+    def plot_vector_image(image: np.ndarray,
+                   title: str = "",
+                   cmap: str = "plasma") -> None:
+        fig, ax = plt.subplots()
+        cset = plt.imshow(image,cmap=plt.get_cmap(cmap),origin='lower')
+        ax.set_aspect('equal','box')
+        ax.set_title(title,fontsize=12)
+        fig.colorbar(cset)
+
+
+    @staticmethod
+    def plot_image_xy(image: np.ndarray,
+                      extent: tuple[float,float,float,float],
+                      title: str = "",
+                      cmap: str = "plasma",
+                      ax_units: str = "mm") -> None:
+
+        fig, ax = plt.subplots()
+        cset = plt.imshow(image,
+                        aspect='auto',interpolation='none',
+                        origin='lower',cmap=plt.get_cmap(cmap),
+                        extent=extent)
+        ax.set_aspect('equal','box')
+        ax.set_title(title,fontsize=12)
+        ax.set_xlabel(f'x [{ax_units}]',fontsize=12)
+        ax.set_ylabel(f'y [{ax_units}]',fontsize=12)
+        fig.colorbar(cset)
+
+    @staticmethod
+    def plot_all_diags(def_image: np.ndarray,
+                    def_mask: np.ndarray | None,
+                    def_image_subpx: np.ndarray,
+                    subpx_disp_x: np.ndarray,
+                    subpx_disp_y: np.ndarray,
+                    subpx_grid_xm: np.ndarray,
+                    subpx_grid_ym: np.ndarray) -> None:
+        image_map = "gray"
+        vector_map = "plasma"
+
+        if def_mask is not None:
+            ImageDefDiags.plot_image('Def. Mask',def_mask,image_map)
+
+        ImageDefDiags.plot_image('Subpx Def. Image',def_image_subpx,image_map)
+        ImageDefDiags.plot_image('Def. Image',def_image,image_map)
+
+        ext = tuple(np.array([subpx_grid_xm.min(),subpx_grid_xm.max(),
+                        subpx_grid_ym.min(),subpx_grid_ym.max()])*10**3)
+        ImageDefDiags.plot_image_xy('Sub Pixel Disp X',subpx_disp_x,ext,V_CMAP)
+        ImageDefDiags.plot_image_xy('Sub Pixel Disp Y',subpx_disp_y,ext,V_CMAP)

pyvale/core/visualimages.py

@@ -0,0 +1,75 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from typing import Any
+import numpy as np
+import matplotlib.pyplot as plt
+from pyvale.core.camera import CameraBasic2D
+from pyvale.core.visualopts import PlotOptsGeneral
+
+# NOTE: This module is a feature under developement.
+
+# TODO: this only works for a 2D camera, maybe this should be deprecated
+def plot_measurement_image(camera: CameraBasic2D,
+                           component: str,
+                           time_step: int = -1,
+                           plot_opts: PlotOptsGeneral | None = None
+                           ) -> tuple[Any,Any]:
+
+    if plot_opts is None:
+        plot_opts = PlotOptsGeneral()
+
+    comp_ind = camera.get_field().get_component_index(component)
+    meas_image = camera.get_measurement_images()[:,:,comp_ind,time_step]
+    descriptor = camera.get_descriptor()
+
+    (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                             layout='constrained')
+    fig.set_dpi(plot_opts.resolution)
+
+    cset = plt.imshow(meas_image,
+                      cmap=plt.get_cmap(plot_opts.cmap_seq),
+                      origin='lower')
+    ax.set_aspect('equal','box')
+
+    fig.colorbar(cset,
+                 label=descriptor.create_label_flat(comp_ind))
+
+    title = f"Time: {camera.get_sample_times()[time_step]}s"
+    ax.set_title(title,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)
+
+    return (fig,ax)
+
+
+def plot_field_image(image: np.ndarray,
+                     title_str: str | None = None,
+                     plot_opts: PlotOptsGeneral | None = None
+                     ) -> tuple[Any,Any]:
+
+    if plot_opts is None:
+        plot_opts = PlotOptsGeneral()
+
+        (fig, ax) = plt.subplots(figsize=plot_opts.single_fig_size_square,
+                                layout='constrained')
+        fig.set_dpi(plot_opts.resolution)
+        cset = plt.imshow(image,
+                          cmap=plt.get_cmap(plot_opts.cmap_seq))
+                          #origin='lower')
+        ax.set_aspect('equal','box')
+        fig.colorbar(cset)
+        if title_str is not None:
+            ax.set_title(title_str,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)
+
+        return (fig,ax)

pyvale/core/visualopts.py

@@ -0,0 +1,180 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+from pathlib import Path
+import enum
+from dataclasses import dataclass
+import numpy as np
+import matplotlib as plt
+
+
+@dataclass(slots=True)
+class PlotOptsGeneral:
+    """ Dataclass for controlling the properties of figures and graphs such as
+    figure size, resolution, font sizes, marker sizes, line widths and
+    colormaps.
+    """
+    aspect_ratio: float = 1.62
+    # These are in inches because of matplotlib
+    a4_width: float = 8.25
+    a4_height: float = 11.75
+    a4_margin_width: float = 0.5
+    a4_margin_height: float = 0.5
+    a4_print_width: float = a4_width-2*a4_margin_width
+    a4_print_height: float = a4_height-2*a4_margin_height
+
+    single_fig_scale: float = 0.5
+
+    single_fig_size_square: tuple[float,float] = (
+        a4_print_width*single_fig_scale,
+        a4_print_width*single_fig_scale
+     )
+    single_fig_size_portrait: tuple[float,float] = (
+        a4_print_width*single_fig_scale/aspect_ratio,
+        a4_print_width*single_fig_scale
+     )
+    single_fig_size_landscape: tuple[float,float] = (
+        a4_print_width*single_fig_scale,
+        a4_print_width*single_fig_scale/aspect_ratio
+     )
+
+    resolution: float = 300.0
+
+    font_name: str = 'Liberation Sans'
+    font_def_weight: str = 'normal'
+    font_def_size: float = 8.0
+    font_tick_size: float = 8.0
+    font_head_size: float = 9.0
+    font_ax_size: float = 8.0
+    font_leg_size: float = 8.0
+
+    ms: float = 3.2
+    lw: float = 0.8
+
+    cmap_seq: str = "cividis"
+    cmap_div: str = "RdBu"
+
+    colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+    n_colors = len(plt.rcParams['axes.prop_cycle'].by_key()['color'])
+
+    def __post_init__(self) -> None:
+        plt.rc('font', size=self.font_def_size)
+        plt.rc('axes', titlesize=self.font_def_size)
+
+
+@dataclass(slots=True)
+class TraceOptsSensor:
+    """Dataclass for controlling the properties of sensor trace plots.
+    """
+    legend: bool = True
+
+    x_label: str = r"x [$m$]"
+    y_label: str = r"y [$m$]"
+    z_label: str = r"z [$m$]"
+    time_label: str = r"Time, $t$ [$s$]"
+
+    truth_line: str | None = "-"
+    sim_line: str | None = "-"
+    meas_line: str = "--o"
+
+    sensors_to_plot: np.ndarray | None = None
+    time_min_max: tuple[float,float] | None = None
+
+
+@dataclass(slots=True)
+class TraceOptsExperiment:
+    """Dataclass for contorlling the properties of sensor trace plots from
+    batches of simulated experiments.
+    """
+    legend: bool = True
+
+    x_label: str = r"x [$m$]"
+    y_label: str = r"y [$m$]"
+    z_label: str = r"z [$m$]"
+    time_label: str = r"Time, $t$ [$s$]"
+
+    truth_line: str | None = None
+    sim_line: str | None = None
+    exp_mean_line: str = "-"
+    exp_marker_line: str = "+"
+
+    sensors_to_plot: np.ndarray | None = None
+    time_min_max: tuple[float,float] | None = None
+
+    centre: str = "mean"
+    plot_all_exp_points: bool = False
+    fill_between: str | None = "3std"
+
+
+@dataclass(slots=True)
+class VisOptsSimSensors:
+    """Dataclass for controlling displays of the simulation mesh and sensor
+    locations using pyvista.
+    """
+    # pyvista ops
+    window_size_px: tuple[int,int] = (1280,800)
+    camera_position: np.ndarray | str = "xy"
+    show_edges: bool = True
+    interactive: bool = True
+
+    font_colour: str = "black"
+    background_colour: str = "white" # "white"
+
+    time_label_font_size: float = 12
+    time_label_position: str = "upper_left"
+    time_label_show: bool = True
+
+    colour_bar_font_size: float = 18
+    colour_bar_show: bool = True
+    colour_bar_lims: tuple[float,float] | None = None
+    colour_bar_vertical: bool = True
+
+    # pyvale ops
+    show_perturbed_pos: bool = True
+    sens_colour_nom: str = "red"
+    sens_colour_pert: str = "blue"
+    sens_point_size: float = 20
+    sens_label_font_size: float = 30
+    sens_label_colour: str = "grey"
+
+
+class EImageType(enum.Enum):
+    PNG = enum.auto()
+    SVG = enum.auto()
+
+@dataclass(slots=True)
+class VisOptsImageSave:
+    """Dataclass for image save options.
+    """
+    path: Path | None = None
+    image_type: EImageType = EImageType.PNG
+    transparent_background: bool = False
+
+
+class EAnimationType(enum.Enum):
+    MP4 = enum.auto()
+    GIF = enum.auto()
+
+@dataclass(slots=True)
+class VisOptsAnimation:
+    """Dataclass for animation save options.
+    """
+    frames_per_second: float = 10.0
+    off_screen: bool = False
+
+    # save options
+    save_animation: EAnimationType | None = None
+    save_path: Path | None = None
+
+
+
+
+
+
+
+
+

pyvale/core/visualsimanimator.py

@@ -0,0 +1,83 @@
+"""
+================================================================================
+pyvale: the python validation engine
+License: MIT
+Copyright (C) 2025 The Computer Aided Validation Team
+================================================================================
+"""
+import numpy as np
+#import vtk #NOTE: has to be here to fix latex bug in pyvista/vtk
+# See: https://github.com/pyvista/pyvista/discussions/2928
+#NOTE: causes output to console to be suppressed unfortunately
+import pyvista as pv
+from pyvale.core.sensorarraypoint import SensorArrayPoint
+from pyvale.core.visualopts import VisOptsSimSensors, VisOptsAnimation
+from pyvale.core.visualtools import (create_pv_plotter,
+                                     get_colour_lims,
+                                     set_animation_writer)
+from pyvale.core.visualsimplotter import (add_sensor_points_nom,
+                                          add_sensor_points_pert,
+                                          add_sim_field)
+
+#TODO: Docstrings
+
+def animate_sim_with_sensors(sensor_array: SensorArrayPoint,
+                            component: str,
+                            time_steps: np.ndarray | None = None,
+                            vis_opts: VisOptsSimSensors | None = None,
+                            anim_opts: VisOptsAnimation | None = None,
+                            ) -> pv.Plotter:
+
+    if vis_opts is None:
+        vis_opts = VisOptsSimSensors()
+
+    if anim_opts is None:
+        anim_opts = VisOptsAnimation()
+
+    if time_steps is None:
+        time_steps = np.arange(0,sensor_array.get_sample_times().shape[0])
+
+    sim_data = sensor_array.field.get_sim_data()
+    vis_opts.colour_bar_lims = get_colour_lims(
+        sim_data.node_vars[component][:,time_steps],
+        vis_opts.colour_bar_lims)
+
+    #---------------------------------------------------------------------------
+    pv_plot = create_pv_plotter(vis_opts)
+
+    pv_plot = add_sensor_points_pert(pv_plot,sensor_array,vis_opts)
+    pv_plot = add_sensor_points_nom(pv_plot,sensor_array,vis_opts)
+    (pv_plot,sim_vis) = add_sim_field(pv_plot,
+                                      sensor_array,
+                                      component,
+                                      time_step = 0,
+                                      vis_opts = vis_opts)
+
+    pv_plot.camera_position = vis_opts.camera_position
+    pv_plot.show(auto_close=False,interactive=False)
+
+    pv_plot = set_animation_writer(pv_plot,anim_opts)
+
+    #---------------------------------------------------------------------------
+    for tt in time_steps:
+        # Updates the field plotted on the mesh
+        sim_vis[component] = sim_data.node_vars[component][:,tt]
+
+        if vis_opts.time_label_show:
+            pv_plot.add_text(f"Time: {sim_data.time[tt]} " + \
+                             f"{sensor_array.descriptor.time_units}",
+                             position=vis_opts.time_label_position,
+                             font_size=vis_opts.time_label_font_size,
+                             name='time-label')
+
+        if anim_opts.save_animation is not None:
+            pv_plot.write_frame()
+
+    pv_plot.show(auto_close=False,interactive=vis_opts.interactive)
+    return pv_plot
+
+
+
+
+
+