pyvale 2025.7.1__cp311-cp311-musllinux_1_2_i686.whl → 2025.8.1__cp311-cp311-musllinux_1_2_i686.whl

pyvale/{dicregionofinterest.py → dic/dicregionofinterest.py}

@@ -15,7 +15,7 @@ import yaml
 import os
 from pathlib import Path
 
-class DICRegionOfInterest:
+class RegionOfInterest:
     """
     A class for interactively selecting and manipulating ROI of an image before passing to the DIC engine. 
 
@@ -84,6 +84,7 @@ class DICRegionOfInterest:
         self.height = None
         self.width = None
         self.subset_size = None
+        self.coord_label = None
 
     def interactive_selection(self, subset_size):
         """
@@ -117,6 +118,8 @@ class DICRegionOfInterest:
         
         # Create graphics widget
         self.graphics_widget = pg.GraphicsLayoutWidget()
+
+
         
         main_layout.addLayout(sidebar)
         main_layout.addWidget(self.graphics_widget)
@@ -165,7 +168,27 @@ class DICRegionOfInterest:
         self.buttons['undo_prev'].setEnabled(False)
         self.buttons['redo_prev'].setEnabled(False)
         
+        self.coord_label = QtWidgets.QLabel("(-, -)")
+        self.coord_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
+
+        # Set fixed width to handle largest expected value comfortably
+        self.coord_label.setMinimumWidth(350)
+        self.coord_label.setMaximumWidth(350)
+
+        self.coord_label.setStyleSheet("""
+            QLabel {
+                background-color: rgba(0, 0, 0, 150);
+                color: white;
+                padding: 5px;
+                border-radius: 3px;
+                font-family: monospace;
+                font-size: 12px;
+            }
+        """)
+        
         sidebar.addStretch()
+        sidebar.addWidget(self.coord_label)
+        
         return sidebar
 
     def _setup_graphics(self):
@@ -222,6 +245,24 @@ class DICRegionOfInterest:
             self.buttons[btn_id].clicked.connect(handler)
 
         self.main_view.scene().sigMouseClicked.connect(self._mouse_clicked)
+        self.main_view.scene().sigMouseMoved.connect(self._mouse_moved)
+
+
+    def _mouse_moved(self, pos):
+        """Handle mouse movement to update coordinate display."""
+        if self.main_view.sceneBoundingRect().contains(pos):
+            mouse_point = self.main_view.mapSceneToView(pos)
+            # Convert from graphics coordinates to image coordinates
+            img_x = int(round(mouse_point.x()))
+            img_y = int(round(self.width - mouse_point.y()))
+            
+            # Clamp coordinates to image bounds
+            img_x = max(0, min(img_x, self.height - 1))
+            img_y = max(0, min(img_y, self.width - 1))
+            
+            self.coord_label.setText(f"({img_x}, {img_y})")
+        else:
+            self.coord_label.setText("(-, -)")
 
     def _start_drawing_mode(self, mode):
         """Start drawing mode for specified shape type."""
@@ -536,7 +577,7 @@ class DICRegionOfInterest:
             self._update_button_states()
 
     def _save_interactive_roi(self):
-        """Save the current ROI to a YAML file."""
+        """Save the current ROI to a YAML file. This only works with the interactive GUI."""
         filename, _ = QtWidgets.QFileDialog.getSaveFileName(self.main_window, 'Save ROI', 'roi_interactive.yaml', filter='YAML Files (*.yaml)')
 
         if filename:
@@ -566,7 +607,7 @@ class DICRegionOfInterest:
                 yaml.dump(serialized, f, sort_keys=False)
 
     def _open_interactive_roi(self):
-        """Open ROI from a YAML file."""
+        """Open ROI from a YAML file. This only works with the interactive GUI."""
         filename, _ = QtWidgets.QFileDialog.getOpenFileName(
             self.main_window, 'Open ROI', filter='YAML Files (*.yaml)'
         )
@@ -586,6 +627,7 @@ class DICRegionOfInterest:
                 if entry.get('type') == 'SeedROI':
                     # Restore the seed ROI
                     x, y = entry['pos']
+                    y = self.width-y
                     size = entry.get('size', [10, 10])  # fallback default
                     self.seed_roi = pg.RectROI(
                         [x, y], size,
@@ -671,13 +713,13 @@ class DICRegionOfInterest:
     def _finalize_selection(self):
         """Process the final mask and seed location."""
         self.mask = np.flipud(self.temp_mask.T)
-        
+
         if hasattr(self, 'seed_roi'):
             pos = self.seed_roi.pos()
             x = int(np.floor(pos.x()))
             y = int(np.floor(self.width - pos.y()))
             self.seed = [x, y]
-            
+
             if not self.mask[y, x]:
                 raise ValueError(f"Seed location [{x}, {y}] is not within the mask")
             print(f"Final seed location: [{x}, {y}]")
@@ -833,6 +875,111 @@ class DICRegionOfInterest:
         self.__roi_selected = True
 
 
+    def save_yaml(self,  filename: str | Path) -> None:
+        """
+        Save the current ROI to a YAML file. This only works with the after having run the interactive GUI.
+
+        Parameters
+        ----------
+        filename : str or pathlib.Path
+            Filename of the YAML file to save the ROI data.
+
+        Raises
+        ------
+        ValueError
+            If no ROI has been selected.
+        """
+
+        if filename:
+
+            # Ensure extension is added if user doesn't include it
+            if filename and not filename.endswith('.yaml'):
+                filename += '.yaml'
+
+            print("Saving to file:", filename)
+            serialized = [
+                self._get_roi_data(roi, add) 
+                for roi, add in zip(self.roi_list, self.add_list)
+            ]
+
+            # add ROI to serialized data
+            if hasattr(self, 'seed_roi'):
+                self._finalize_selection()
+                seed_data = {
+                    'type': 'SeedROI',
+                    'pos': [self.seed[0], self.seed[1]],
+                    'size': [self.subset_size, self.subset_size],
+                    'add': True
+                }
+                serialized.append(seed_data)
+
+            with open(filename, 'w') as f:
+                yaml.dump(serialized, f, sort_keys=False)
+
+    def read_yaml(self, filename: str | Path) -> None:
+        """
+        Load the ROI from a YAML file and restore the state of the GUI.
+        This method will clear existing ROIs and restore the state from the YAML file.
+
+        Parameters
+        ----------
+        filename : str or pathlib.Path
+            Path to the YAML file containing the ROI data.
+
+        Raises
+        ------
+        FileNotFoundError
+            If the specified file does not exist.
+        ValueError
+            If the loaded data is not a valid ROI format.
+        """
+
+        # need to create a temp qapplication so I can import the ROI.
+        self.__roi_selected = True
+        
+        # Initialize GUI
+        self._setup_gui()
+        self._setup_graphics()
+        self._connect_signals()
+
+        if filename:
+            with open(filename, 'r') as f:
+                data = yaml.safe_load(f)
+
+            self.roi_list = []
+            self.add_list = []
+
+            self.seed_roi = None  # Clear existing seed
+
+            for entry in data:
+                if entry.get('type') == 'SeedROI':
+                    # Restore the seed ROI
+                    x, y = entry['pos']
+                    y = self.width-y
+                    size = entry.get('size', [10, 10])  # fallback default
+                    self.seed_roi = pg.RectROI(
+                        [x, y], size,
+                        pen=pg.mkPen('b', width=3),
+                        hoverPen=pg.mkPen('y', width=3),
+                        handlePen='#0000',
+                        handleHoverPen='#0000'
+                    )
+                    self.main_view.addItem(self.seed_roi)
+
+                else:
+                    # Restore standard ROI
+                    roi = self._create_roi_from_data(entry)
+                    self.roi_list.append(roi)
+                    self.add_list.append(entry['add'])
+                    self.main_view.addItem(roi)
+                    roi.sigRegionChanged.connect(self._redraw_fill_layer)
+
+            self._redraw_fill_layer()
+            self._update_button_states()
+            self._finalize_selection()
+
+
+
     def show_image(self) -> None:
         """
         Displays the current mask in grayscale.
@@ -842,20 +989,30 @@ class DICRegionOfInterest:
             ValueError: If no ROI is selected.
         """
 
-        
-        if not self.__roi_selected:
-                raise ValueError("No ROI selected with 'interactive_selection' or 'rect_boundary'")
+        # Convert grayscale image to 3-channel if needed
+        if self.ref_image.ndim == 2:
+            ref_image_color = cv2.cvtColor(self.ref_image.astype(np.uint8), cv2.COLOR_GRAY2BGR)
+        else:
+            ref_image_color = self.ref_image
 
         # Create a green mask image
-        green_mask = np.zeros_like(self.ref_image)
+        if self.ref_image.ndim == 3:
+            green_mask = np.zeros_like(self.ref_image)
+        elif self.ref_image.ndim == 2:
+            h, w = self.ref_image.shape
+            green_mask = np.zeros((h, w, 3), dtype=self.ref_image.dtype)
+        else:
+            raise ValueError(f"Unsupported image shape: {self.ref_image.shape}")
 
-        green_mask[self.mask,:] = [0, 255, 0]
+        # Apply the green mask
+        green_mask[self.mask, :] = [0, 255, 0]
 
-        # Blend the original image and the mask
-        blended = self.ref_image.astype(float) * 0.7 + green_mask.astype(float) * 0.3
+        # Blend the original image and the green mask
+        blended = ref_image_color.astype(float) * 0.7 + green_mask.astype(float) * 0.3
         blended = blended.astype(np.uint8)
 
         # Display using Matplotlib
+        import matplotlib.pyplot as plt
         plt.figure()
         plt.imshow(blended)
         plt.axis('off')

pyvale/{dicresults.py → dic/dicresults.py}

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 import numpy as np
 
 @dataclass(slots=True)
-class DICResults:
+class Results:
     """
     Data container for Digital Image Correlation (DIC) analysis results.
 
@@ -38,6 +38,8 @@ class DICResults:
         Final `xtol` value from the optimization routine, indicating solution tolerance.
     niter : np.ndarray
         Number of iterations taken to converge for each subset point.
+    shape_params : np.ndarray | None
+        Optional shape parameters if output during DIC calculation (e.g., affine, rigid).
     filenames : list[str]
         name of DIC result files that have been found
     """
@@ -52,4 +54,5 @@ class DICResults:
     ftol: np.ndarray
     xtol: np.ndarray
     niter: np.ndarray
+    shape_params: np.ndarray
     filenames: list[str]

pyvale/{dicstrain.py → dic/dicstrain.py}

@@ -9,13 +9,13 @@ import numpy as np
 import glob
 from pathlib import Path
 
-from pyvale import dic2dcpp
-from pyvale import dicchecks
-from pyvale.dicdataimport import dic_data_import
-from pyvale.dicresults import DICResults
-from pyvale.dicstrainresults import StrainResults
+# pyvale
+import pyvale.dic.dic2dcpp as dic2dcpp
+from pyvale.dic.dicstrainresults import StrainResults
+from pyvale.dic.dicchecks import check_strain_files, check_output_directory
+from pyvale.dic.dicdataimport import data_import
 
-def strain_2d(data: str | Path,
+def strain_two_dimensional(data: str | Path,
               window_size: int=5, 
               window_element: int=4,
               input_binary: bool=False,
@@ -80,10 +80,10 @@ def strain_2d(data: str | Path,
     if window_size % 2 == 0:
         raise ValueError(f"Invalid strain window size: '{window_size}'. Must be an odd number.")
 
-    filenames = dicchecks.check_strain_files(strain_files=data)
+    filenames = check_strain_files(strain_files=data)
 
     # Load data if a file path is given
-    results = dic_data_import(layout="matrix", data=str(data),
+    results = data_import(layout="matrix", data=str(data),
                                   binary=input_binary, delimiter=input_delimiter)
 
     # Extract dimensions from the validated object
@@ -92,7 +92,7 @@ def strain_2d(data: str | Path,
     nimg = results.u.shape[0]
 
 
-    dicchecks.check_output_directory(str(output_basepath), output_prefix)
+    check_output_directory(str(output_basepath), output_prefix)
 
     # assigning c++ struct vals for save config
     strain_save_conf = dic2dcpp.SaveConfig()

pyvale/examples/basics/{ex1_1_basicscalars_therm2d.py → ex1a_basicscalars_therm2d.py}

@@ -18,8 +18,11 @@ Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
 
 from pathlib import Path
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+import pyvale.dataset as dataset
 
 #%%
 # Here we load a pre-generated MOOSE finite element simulation dataset that
@@ -28,13 +31,13 @@ import pyvale as pyv
 # to your own MOOSE simulation with exodus output (*.e). Note that the
 # field_key must match the name of your variable in your MOOSE simulation.
 # We use `mooseherder` to load the exodus file into a `SimData` object.
-data_path = pyv.DataSet.thermal_2d_path()
+data_path = dataset.thermal_2d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 
 #%%
 # Scale to mm to make 3D visualisation scaling easier as pyvista scales
 # everything to unity
-sim_data = pyv.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=None)
 
@@ -46,14 +49,14 @@ n_sens = (3,2,1)
 x_lims = (0.0,100.0)
 y_lims = (0.0,50.0)
 z_lims = (0.0,0.0)
-sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
 #%%
 # This dataclass contains the parameters to build our sensor array. We can
 # also customise the output frequency, the sensor area and the sensor
 # orientation. For now we will use the defaults which assumes an ideal point
 # sensor sampling at the simulation time steps.
-sens_data = pyv.SensorData(positions=sens_pos)
+sens_data = sens.SensorData(positions=sens_pos)
 
 #%%
 # Now that we have our sensor locations we can use the sensor factory to
@@ -63,7 +66,7 @@ sens_data = pyv.SensorData(positions=sens_pos)
 # If you want to remove the simulated errors and just interpolate at the
 # sensor locations then user `.thermocouples_no_errs()`.
 field_key: str = "temperature"
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_basic_errs(sim_data,
                                 sens_data,
                                 elem_dims=2,
@@ -93,7 +96,7 @@ if not output_path.is_dir():
 # This creates a pyvista visualisation of the sensor locations on the
 # simulation mesh. The plot will can be shown in interactive mode by calling
 # `pv_plot.show()`.
-pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
+pv_plot = sens.plot_point_sensors_on_sim(tc_array,field_key)
 
 #%%
 # We determined manually by moving camera in interative mode and then
@@ -125,7 +128,7 @@ print(80*"-"+"\n")
 # markers shows the simulated sensor traces. In later examples we will see
 # how to configure this plot but for now we note we that we are returned a
 # matplotlib figure and axes object which allows for further customisation.
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 
 #%%
 # We can also save the sensor trace plot as a vector and raster graphic

pyvale/examples/basics/{ex1_2_sensormodel_therm2d.py → ex1b_sensormodel_therm2d.py}

@@ -29,8 +29,11 @@ Test case: Scalar field point sensors (thermocouples) on a 2D thermal simulation
 """
 
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.sensorsim as sens
+import pyvale.mooseherder as mh
+import pyvale.dataset as dataset
 
 
 #%%
@@ -40,14 +43,14 @@ import pyvale as pyv
 # Here we load a pre-generated MOOSE finite element simulation dataset that
 # comes packaged with pyvale. The simulation is a 2D rectangular plate with
 # a bi-directional temperature gradient.
-data_path = pyv.DataSet.thermal_2d_path()
+data_path = dataset.thermal_2d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
 field_key: str = "temperature"
 
 #%%
 # Scale to mm to make 3D visualisation scaling easier as pyvista scales
 # everything to unity
-sim_data = pyv.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=None)
 
@@ -59,14 +62,14 @@ n_sens = (4,1,1)
 x_lims = (0.0,100.0)
 y_lims = (0.0,50.0)
 z_lims = (0.0,0.0)
-sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
 #%%
 # This dataclass contains the parameters to build our sensor array. We can
 # also customise the output frequency, the sensor area and the sensor
 # orientation. For now we will use the defaults which assumes an ideal point
 # sensor sampling at the simulation time steps.
-sens_data = pyv.SensorData(positions=sens_pos)
+sens_data = sens.SensorData(positions=sens_pos)
 
 #%%
 # Now that we have our sensor locations we can use the sensor factory to
@@ -74,7 +77,7 @@ sens_data = pyv.SensorData(positions=sens_pos)
 # examples we will see how to customise sensor parameters and errors.
 # This basic thermocouple array includes a 5% systematic and random error -
 # We are specifically using exaggerated errors here for visualisation.
-tc_array = pyv.SensorArrayFactory \
+tc_array = sens.SensorArrayFactory \
     .thermocouples_basic_errs(sim_data,
                                 sens_data,
                                 elem_dims=2,
@@ -111,16 +114,16 @@ print(80*"-")
 print(f"Looking at the last {time_last} virtual measurements for sensor"
         +f" {sens_print}:")
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 print("If we call the `calc_measurements()` method then the errors are "
         + "re-calculated.")
 measurements = tc_array.calc_measurements()
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 ax.set_title("Exp 1: called calc_measurements()")
 
 print(80*"-")
@@ -128,9 +131,9 @@ print("If we call the `get_measurements()` method then the errors are the "
         + "same:")
 measurements = tc_array.get_measurements()
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 ax.set_title("Exp 2: called get_measurements()")
 
 print(80*"-")
@@ -138,9 +141,9 @@ print("If we call the `calc_measurements()` method again we generate / "
         "sample new errors:")
 measurements = tc_array.calc_measurements()
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 ax.set_title("Exp 3: called calc_measurements()")
 
 print(80*"-")

pyvale/examples/basics/{ex1_3_customsens_therm3d.py → ex1c_customsens_therm3d.py}

@@ -18,8 +18,11 @@ Test case: Scalar field point sensors (thermocouples) on a 3D thermal simulation
 from pathlib import Path
 import numpy as np
 import matplotlib.pyplot as plt
-import mooseherder as mh
-import pyvale as pyv
+
+# Pyvale imports
+import pyvale.mooseherder as mh
+import pyvale.sensorsim as sens
+import pyvale.dataset as dataset
 
 #%%
 # To build our custom point sensor array we need to at minimum provide a
@@ -32,9 +35,9 @@ import pyvale as pyv
 # based on the same thermal example we have used in the last two examples so
 # we start by loading our simulation data:
 
-data_path = pyv.DataSet.thermal_3d_path()
+data_path = dataset.thermal_3d_path()
 sim_data = mh.ExodusReader(data_path).read_all_sim_data()
-sim_data = pyv.scale_length_units(scale=1000.0,
+sim_data = sens.scale_length_units(scale=1000.0,
                                     sim_data=sim_data,
                                     disp_comps=None)
 
@@ -43,7 +46,7 @@ sim_data = pyv.scale_length_units(scale=1000.0,
 # field object to perform interpolation to the sensor locations at the
 # desired sampling times.
 field_key: str = "temperature"
-t_field = pyv.FieldScalar(sim_data,
+t_field = sens.FieldScalar(sim_data,
                             field_key=field_key,
                             elem_dims=3)
 
@@ -56,7 +59,7 @@ n_sens = (1,4,1)
 x_lims = (12.5,12.5)
 y_lims = (0.0,33.0)
 z_lims = (0.0,12.0)
-sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
+sens_pos = sens.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 
 #%%
 # We are also going to specify the times at which we would like to simulate
@@ -64,8 +67,8 @@ sens_pos = pyv.create_sensor_pos_array(n_sens,x_lims,y_lims,z_lims)
 # to match the simulation time steps.
 sample_times = np.linspace(0.0,np.max(sim_data.time),50)
 
-sensor_data = pyv.SensorData(positions=sens_pos,
-                                sample_times=sample_times)
+sensor_data = sens.SensorData(positions=sens_pos,
+                             sample_times=sample_times)
 
 #%%
 # Finally, we can create a `SensorDescriptor` which will be used to label
@@ -73,20 +76,20 @@ sensor_data = pyv.SensorData(positions=sens_pos,
 # examples.
 use_auto_descriptor: str = "blank"
 if use_auto_descriptor == "manual":
-    descriptor = pyv.SensorDescriptor(name="Temperature",
+    descriptor = sens.SensorDescriptor(name="Temperature",
                                         symbol="T",
                                         units = r"^{\circ}C",
                                         tag = "TC")
 elif use_auto_descriptor == "factory":
-    descriptor = pyv.SensorDescriptorFactory.temperature_descriptor()
+    descriptor = sens.SensorDescriptorFactory.temperature_descriptor()
 else:
-    descriptor = pyv.SensorDescriptor()
+    descriptor = sens.SensorDescriptor()
 
 #%%
 # We can now build our custom point sensor array. This sensor array has no
 # errors so if we call `get_measurements()` or `calc_measurements()` we will
 # be able to extract the simulation truth values at the sensor locations.
-tc_array = pyv.SensorArrayPoint(sensor_data,
+tc_array = sens.SensorArrayPoint(sensor_data,
                                 t_field,
                                 descriptor)
 
@@ -101,7 +104,7 @@ output_path = Path.cwd() / "pyvale-output"
 if not output_path.is_dir():
     output_path.mkdir(parents=True, exist_ok=True)
 
-pv_plot = pyv.plot_point_sensors_on_sim(tc_array,field_key)
+pv_plot = sens.plot_point_sensors_on_sim(tc_array,field_key)
 
 pv_plot.camera_position = [(59.354, 43.428, 69.946),
                             (-2.858, 13.189, 4.523),
@@ -149,8 +152,8 @@ errors_on = {"sys": True,
 
 error_chain = []
 if errors_on["sys"]:
-    error_chain.append(pyv.ErrSysOffset(offset=-10.0))
-    error_chain.append(pyv.ErrSysUnif(low=-10.0,
+    error_chain.append(sens.ErrSysOffset(offset=-10.0))
+    error_chain.append(sens.ErrSysUnif(low=-10.0,
                                             high=10.0))
 #%%
 # This random error is generated by sampling from a normal distribution
@@ -159,8 +162,8 @@ if errors_on["sys"]:
 # probability distribution
 
 if errors_on["rand"]:
-    error_chain.append(pyv.ErrRandNorm(std=5.0))
-    error_chain.append(pyv.ErrRandUnifPercent(low_percent=-5.0,
+    error_chain.append(sens.ErrRandNorm(std=5.0))
+    error_chain.append(sens.ErrRandUnifPercent(low_percent=-5.0,
                                                 high_percent=5.0))
 
 #%%
@@ -171,11 +174,11 @@ if errors_on["rand"]:
 # INDEPENDENT.
 
 if len(error_chain) > 0:
-    err_int_opts = pyv.ErrIntOpts()
-    error_integrator = pyv.ErrIntegrator(error_chain,
-                                            sensor_data,
-                                            tc_array.get_measurement_shape(),
-                                            err_int_opts=err_int_opts)
+    err_int_opts = sens.ErrIntOpts()
+    error_integrator = sens.ErrIntegrator(error_chain,
+                                         sensor_data,
+                                         tc_array.get_measurement_shape(),
+                                         err_int_opts=err_int_opts)
     tc_array.set_error_integrator(error_integrator)
 
 #%%
@@ -204,11 +207,11 @@ time_print = slice(measurements.shape[2]-time_last,measurements.shape[2])
 print(f"These are the last {time_last} virtual measurements of sensor "
         + f"{sens_print}:")
 
-pyv.print_measurements(tc_array,sens_print,comp_print,time_print)
+sens.print_measurements(tc_array,sens_print,comp_print,time_print)
 
 print(80*"-")
 
-(fig,ax) = pyv.plot_time_traces(tc_array,field_key)
+(fig,ax) = sens.plot_time_traces(tc_array,field_key)
 
 save_traces = output_path/"customsensors_ex1_3_sensortraces.png"
 fig.savefig(save_traces, dpi=300, bbox_inches="tight")