simcats-datasets 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

simcats_datasets/loading/load_ground_truth.py

@@ -18,15 +18,23 @@ import numpy as np
 
 # imports required for eval, to create IdealCSDGeometric objects from metadata strings
 import re
-
 import sympy
 from simcats.ideal_csd import IdealCSDGeometric
 from simcats.ideal_csd.geometric import calculate_all_bezier_anchors, tct_bezier, initialize_tct_functions
+from simcats.sensor import SensorScanSensorGeneric, SensorPeakLorentzian, SensorRiseGLF
+from simcats.sensor.barrier_function import BarrierFunctionGLF
 from numpy import array
 from simcats.distortions import OccupationDotJumps
 from tqdm import tqdm
 
 from simcats_datasets.loading import load_dataset
+from simcats_datasets.support_functions.convert_lines import (points_2d_voltage_to_1d_idx_space,
+                                                              lines_voltage_to_pixel_space)
+from simcats_datasets.support_functions.get_coulomb_oscillation_area_boundaries import (
+    get_coulomb_oscillation_area_boundaries,
+    calc_sensor_potential,
+    calc_fully_conductive_potential)
+from simcats_datasets.support_functions.metadata_utils import reconstruct_metadata_types
 from simcats.support_functions import rotate_points
 
 
@@ -34,7 +42,9 @@ from simcats.support_functions import rotate_points
 _csd_ground_truths = ["load_zeros_masks", "load_tct_masks", "load_tct_by_dot_masks", "load_idt_masks", "load_ct_masks",
                       "load_ct_by_dot_masks", "load_tc_region_masks", "load_tc_region_minus_tct_masks",
                       "load_c_region_masks"]
-_sensor_scan_ground_truths = ["load_zeros_masks", "load_tct_masks"]
+_sensor_scan_ground_truths = ["load_zeros_masks", "load_sensor_regime_masks", "load_sensor_peak_center_masks",
+                              "load_sensor_oscillation_boundaries_masks",
+                              "load_sensor_quadrilateral_oscillation_boundaries_masks"]
 
 
 def load_zeros_masks(file: Union[str, h5py.File],
@@ -491,3 +501,204 @@ def load_c_region_masks(file: Union[str, h5py.File],
     for ct_mask, c_region_mask in zip(ct_masks, c_region_masks):
         c_region_mask[c_region_mask == ct_mask] = 0
     return c_region_masks
+
+
+def load_sensor_regime_masks(file: Union[str, h5py.File],
+                             specific_ids: Union[range, List[int], np.ndarray, None] = None,
+                             progress_bar: bool = True) -> List[np.ndarray]:
+    """Load sensor regime masks as ground truth data for sensor scans.
+
+    In the sensor regime mask, the non-conductive area is marked with 0, the oscillation area with 1 and the fully
+    conductive area with 2.
+
+    Args:
+        file: The file to read the data from. Can either be an object of the type `h5py.File` or the path to the
+            dataset. If you want to do multiple consecutive loads from the same file (e.g. for using th PyTorch
+            SimcatsDataset without preloading), consider initializing the file object yourself and passing it, to
+            improve the performance.
+        specific_ids: Determines if only specific ids should be loaded. Using this option, the returned values are
+            sorted according to the specified ids and not necessarily ascending. If set to None, all data is loaded.
+            Default is None.
+        progress_bar: Determines whether to display a progress bar. Default is True.
+
+    Returns:
+        Sensor regime masks
+    """
+    return load_dataset(file=file, load_csds=False, load_sensor_regime_masks=True, specific_ids=specific_ids,
+                        progress_bar=progress_bar).sensor_regime_masks
+
+
+def load_sensor_peak_center_masks(file: Union[str, h5py.File],
+                                  specific_ids: Union[range, List[int], np.ndarray, None] = None,
+                                  progress_bar: bool = True) -> List[np.ndarray]:
+    """Load sensor peak center masks as ground truth data for sensor scans.
+
+    Args:
+        file: The file to read the data from. Can either be an object of the type `h5py.File` or the path to the
+            dataset. If you want to do multiple consecutive loads from the same file (e.g. for using th PyTorch
+            SimcatsDataset without preloading), consider initializing the file object yourself and passing it, to
+            improve the performance.
+        specific_ids: Determines if only specific ids should be loaded. Using this option, the returned values are
+            sorted according to the specified ids and not necessarily ascending. If set to None, all data is loaded.
+            Default is None.
+        progress_bar: Determines whether to display a progress bar. Default is True.
+
+    Returns:
+        Sensor peak center masks
+    """
+    return load_dataset(file=file, load_csds=False, load_sensor_peak_center_masks=True, specific_ids=specific_ids,
+                        progress_bar=progress_bar).sensor_peak_center_masks
+
+
+def load_sensor_oscillation_boundaries_masks(file: Union[str, h5py.File],
+                                             specific_ids: Union[range, List[int], np.ndarray, None] = None,
+                                             progress_bar: bool = True) -> List[np.ndarray]:
+    """Masks for the boundaries of the oscillation area with a triangular basic shape (in 2D).
+
+    The oscillation area boundaries are marked with value 1 for pinch-off lines and 2 for the fully conductive line.
+    The rest of the mask is 0. In 1D data the oscillation area boundaries are points, in 2D data lines. This method
+    uses the metadata from each scan to calculate the fully conductive line in the sensor potential.
+
+    Args:
+        file: The file to read the data from. Can either be an object of the type `h5py.File` or the path to the
+            dataset. If you want to do multiple consecutive loads from the same file (e.g. for using th PyTorch
+            SimcatsDataset without preloading), consider initializing the file object yourself and passing it, to
+            improve the performance.
+        specific_ids: Determines if only specific ids should be loaded. Using this option, the returned values are
+            sorted according to the specified ids and not necessarily ascending. If set to None, all data is loaded.
+            Default is None.
+        progress_bar: Determines whether to display a progress bar. Default is True.
+
+    Returns:
+        Oscillation area boundaries masks (triangular shape)
+
+    """
+    metadata = load_dataset(file=file, load_csds=False, load_sensor_scans=False, load_metadata=True,
+                            specific_ids=specific_ids, progress_bar=progress_bar).metadata
+
+    sensor_masks = []
+
+    for metadata_sensor in tqdm(metadata, desc="calculating sensor regime boundaries masks", total=len(metadata),
+                                disable=not progress_bar):
+        # adapt metadata types if necessary:
+        meta = reconstruct_metadata_types(metadata_sensor)
+        line_coords, line_labels = get_coulomb_oscillation_area_boundaries(meta)
+
+        if isinstance(meta["resolution"], int):  # 1D
+            oscillation_mask = np.zeros(meta["resolution"], dtype=np.uint8)
+            if line_coords.ndim == 2:
+                coordinate_indices = points_2d_voltage_to_1d_idx_space(coordinates=line_coords[:, :2],
+                                                                       voltage_range_x=meta["sweep_range_sensor_g1"],
+                                                                       voltage_range_y=meta["sweep_range_sensor_g2"],
+                                                                       resolution=meta["resolution"],
+                                                                       round_to_int=True)
+                for i, point in enumerate(coordinate_indices):
+                    if "start" in line_labels[i] or "pinch_off" in line_labels[i]:  # pinch-off line
+                        oscillation_mask[point] = 1
+                    elif "sensor_potential_fully_conductive" == line_labels[i]:  # fully-conductive line
+                        oscillation_mask[point] = 2
+                    # else: quadrangular fully conductive lines not required here
+            # else: no lines in the area of the scan
+        else:  # if isinstance(meta["resolution"], list)  (2D case)
+            oscillation_mask = np.zeros((meta["resolution"][1], meta["resolution"][0]), dtype=np.uint8)
+
+            if line_coords.ndim == 2:
+                coordinate_pixels = lines_voltage_to_pixel_space(lines=line_coords,
+                                                                 voltage_range_x=np.array(meta["sweep_range_sensor_g1"]),
+                                                                 voltage_range_y=np.array(meta["sweep_range_sensor_g2"]),
+                                                                 image_width=meta["resolution"][0],
+                                                                 image_height=meta["resolution"][1],
+                                                                 round_to_int=True)
+
+                for i, line in enumerate(coordinate_pixels):
+                    max_res = np.abs(line[2] - line[0]) if (
+                                np.abs(line[2] - line[0]) > np.abs(line[3] - line[1])) else np.abs(line[3] - line[1])
+                    max_res = max_res + 1 if (
+                                (max_res < meta["resolution"][0]) and (max_res < meta["resolution"][1])) else max_res
+                    x_coords = np.linspace(line[0], line[2], max_res, dtype=int)
+                    y_coords = np.linspace(line[1], line[3], max_res, dtype=int)
+
+                    if "start" in line_labels[i] or "pinch_off" in line_labels[i]:  # pinch-off line
+                        oscillation_mask[y_coords, x_coords] = 1
+                    elif "sensor_potential_fully_conductive" == line_labels[i]:  # fully-conductive line
+                        oscillation_mask[y_coords, x_coords] = 2
+                    # else: quadrangular fully conductive lines not required here
+            # else: no lines in the area of the scan
+        sensor_masks.append(oscillation_mask)
+
+    return sensor_masks
+
+
+def load_sensor_quadrilateral_oscillation_boundaries_masks(file: Union[str, h5py.File],
+                                                           specific_ids: Union[range, List[int], np.ndarray, None] = None,
+                                                           progress_bar: bool = True) -> List[np.ndarray]:
+    """Load quadrilateral oscillation area boundaries masks as ground truth data for sensor scans.
+
+    Unlike the standard triangular masks from load_sensor_oscillation_boundaries_masks, this method does not combine the
+    sensor dot potential with the barriers to determine full conductivity. Instead, it treats the two barriers
+    separately and draws fully conductive lines where each barrier becomes fully conductive (or effectively vanishes).
+
+    The oscillation area boundaries are marked with the values 1 for pinch-off lines and 2 for fully conductive lines.
+    The rest of the mask is 0. In 1D data the oscillation area boundaries are points, in 2D data lines.
+
+    Args:
+        file: The file to read the data from. Can either be an object of the type `h5py.File` or the path to the
+            dataset. If you want to do multiple consecutive loads from the same file (e.g. for using th PyTorch
+            SimcatsDataset without preloading), consider initializing the file object yourself and passing it, to
+            improve the performance.
+        specific_ids: Determines if only specific ids should be loaded. Using this option, the returned values are
+            sorted according to the specified ids and not necessarily ascending. If set to None, all data is loaded.
+            Default is None.
+        progress_bar: Determines whether to display a progress bar. Default is True.
+
+    Returns:
+        Oscillation area boundaries masks
+    """
+    metadata = load_dataset(file=file, load_csds=False, load_sensor_scans=False, load_metadata=True,
+                            specific_ids=specific_ids, progress_bar=progress_bar).metadata
+    coordinates = load_dataset(file=file, load_csds=False, load_sensor_scans=False, load_line_coords=True,
+                               specific_ids=specific_ids, progress_bar=progress_bar).line_coordinates
+    labels = load_dataset(file=file, load_csds=False, load_sensor_scans=False, load_line_labels=True,
+                          specific_ids=specific_ids, progress_bar=progress_bar).line_labels
+
+    oscillation_boundaries_masks = []
+    for meta, coords, label in tqdm(zip(metadata, coordinates, labels), desc="calculating oscillation boundary masks",
+                                   total=len(metadata), disable=not progress_bar):
+        if isinstance(meta["resolution"], str):  # 1D case
+            oscillation_mask = np.zeros(int(meta["resolution"]), dtype=np.uint8)
+            # if coord.shape[0] > 0:
+            coordinate_indices = points_2d_voltage_to_1d_idx_space(coordinates=coords[:,:2],
+                                                                   voltage_range_x=meta["sweep_range_sensor_g1"],
+                                                                   voltage_range_y=meta["sweep_range_sensor_g2"],
+                                                                   resolution=int(meta["resolution"]),
+                                                                   round_to_int=True)
+            for i, point in enumerate(coordinate_indices):
+                if "start" in label[i] or "pinch_off" in label[i]:  # pinch-off line
+                    oscillation_mask[point] = 1
+                elif "stop" in label[i] or "fully_conductive" in label[i]:  # fully-conductive line
+                    oscillation_mask[point] = 2
+
+        else:  # if isinstance(meta["resolution"], list)  (2D case)
+            oscillation_mask = np.zeros((meta["resolution"][1], meta["resolution"][0]), dtype=np.uint8)
+
+            coordinate_pixels = lines_voltage_to_pixel_space(lines=coords,
+                                                             voltage_range_x=np.array(meta["sweep_range_sensor_g1"]),
+                                                             voltage_range_y=np.array(meta["sweep_range_sensor_g2"]),
+                                                             image_width=meta["resolution"][0],
+                                                             image_height=meta["resolution"][1],
+                                                             round_to_int=True)
+
+            for i, line in enumerate(coordinate_pixels):
+                max_res = np.abs(line[2] - line[0]) if (np.abs(line[2]- line[0]) > np.abs(line[3] - line[1])) else np.abs(line[3] - line[1])
+                max_res = max_res + 1 if ((max_res < meta["resolution"][0]) and (max_res < meta["resolution"][1])) else max_res
+                x_coords = np.linspace(line[0], line[2], max_res, dtype=int)
+                y_coords = np.linspace(line[1], line[3], max_res, dtype=int)
+
+                if "start" in label[i] or "pinch_off" in label[i]:  # pinch-off line
+                    oscillation_mask[y_coords, x_coords] = 1
+                elif "stop" in label[i] or ("fully_conductive" in label[i] and not "potential" in label[i]):  # fully-conductive line
+                    oscillation_mask[y_coords, x_coords] = 2
+
+        oscillation_boundaries_masks.append(oscillation_mask)
+
+    return oscillation_boundaries_masks

simcats_datasets/loading/pytorch.py

@@ -26,7 +26,8 @@ class SimcatsDataset(Dataset):
                  load_ground_truth: Union[Callable, str, None] = None,
                  data_preprocessors: Union[List[Union[str, Callable]], None] = None,
                  ground_truth_preprocessors: Union[List[Union[str, Callable]], None] = None,
-                 format_output: Union[Callable, str, None] = None, preload: bool = True,
+                 format_output: Union[Callable, str, None] = None,
+                 preload: bool = True,
                  max_concurrent_preloads: int = 100000,
                  progress_bar: bool = False,
                  sensor_scan_dataset: bool = False,):
@@ -95,6 +96,8 @@ class SimcatsDataset(Dataset):
             # check if it is possible to load the desired ground truth from the given dataset
             try:
                 _ = self.load_ground_truth(file=self.__h5_path, specific_ids=[0], progress_bar=False)
+            except FileNotFoundError:
+                raise
             except:
                 raise ValueError(
                     f"The specified ground truth ({self.load_ground_truth.__name__}) can't be loaded for the given "
@@ -289,13 +292,17 @@ class SimcatsDataset(Dataset):
 
 
 class SimcatsConcatDataset(ConcatDataset):
+    """Pytorch ConcatDataset class implementation for SimCATS datasets. Uses simcats_datasets to load and provide (training) data.
+    """
+
     def __init__(self,
                  h5_paths: List[str],
                  specific_ids: Union[List[Union[range, int, np.ndarray, None]], None] = None,
                  load_ground_truth: Union[Callable, str, None] = None,
                  data_preprocessors: Union[List[Union[str, Callable]], None] = None,
                  ground_truth_preprocessors: Union[List[Union[str, Callable]], None] = None,
-                 format_output: Union[Callable, str, None] = None, preload: bool = True,
+                 format_output: Union[Callable, str, None] = None,
+                 preload: bool = True,
                  max_concurrent_preloads: int = 100000,
                  progress_bar: bool = False,
                  sensor_scan_dataset: bool = False,):

simcats_datasets/support_functions/clip_line_to_rectangle.py

@@ -7,6 +7,7 @@ Used to clip single transition lines into the CSD space to generate transition s
 """
 
 from typing import Tuple, List, Union
+import math
 
 
 def clip_slope_line_to_rectangle(slope: float, point: Tuple[float, float], rect_corners: List[Tuple[float, float]],
@@ -106,12 +107,22 @@ def clip_point_line_to_rectangle(start: Tuple[float, float], end: Tuple[float, f
         # Calculate the intersection point between the line and the rectangle edge
         intersection = line_intersection(start, end, rect_point1, rect_point2)
         if intersection is not None:
-            if clipped_start is None:
+            # set the clipped start point to the newly found intersection, if either no clipped_start was found so far
+            # or if the current value is the same as the initially supplied end point. This happens, if the end point
+            # was exactly on the boundary and therefore also caused an intersection.
+            if (clipped_start is None
+                    or (clipped_end is not None
+                        and math.isclose(clipped_start[0], end[0])
+                        and math.isclose(clipped_start[1], end[1]))):
                 clipped_start = intersection
-            elif clipped_end is None:
+            # set the clipped end point to the newly found intersection, if either no clipped_end was found so far or
+            # if the current value is the same as the initially supplied start point. This happens, if the start point
+            # was exactly on the boundary and therefore also caused an intersection.
+            elif (clipped_end is None
+                  or (clipped_start is not None
+                      and math.isclose(clipped_end[0], start[0])
+                      and math.isclose(clipped_end[1], start[1]))):
                 clipped_end = intersection
-            if clipped_start is not None and clipped_end is not None:
-                break
 
     return clipped_start, clipped_end
 

simcats_datasets/support_functions/convert_lines.py

@@ -4,6 +4,7 @@
 """
 
 from copy import deepcopy
+import math
 from typing import List, Union
 
 import numpy as np
@@ -108,3 +109,36 @@ def lines_convert_two_coordinates_to_coordinate_plus_change(lines: Union[List[np
             else:
                 new_lines_pairs.append([p2[0], p2[1], p1[0] - p2[0], p1[1] - p2[1]])
     return np.array(new_lines_pairs)
+
+
+def points_2d_voltage_to_1d_idx_space(coordinates: Union[List[np.ndarray], np.ndarray],
+                                      voltage_range_x: np.ndarray,
+                                      voltage_range_y: np.ndarray,
+                                      resolution: int,
+                                      round_to_int: bool = False) -> np.ndarray:
+    """Convert points from 2D voltage space to 1D array/index space.
+
+    Args:
+        coordinates: Array or list of points to convert, shape: (n, 2). \n
+            Example: \n
+            [[x, y], ...]
+        voltage_range_x: Voltage range in x direction.
+        voltage_range_y: Voltage range in y direction.
+        resolution: Size of the index space.
+        round_to_int: Toggles if the points are returned as floats (False) or are rounded and then returned as integers
+            (True). Defaults to false.
+
+    Returns:
+        Array with rows containing the converted points.
+    """
+    if math.isclose(voltage_range_x[0], voltage_range_x[1]):  # vertical scan
+        coord_idx = ((resolution - 1) * (np.array(coordinates)[:, 1] - voltage_range_y[0])
+                     / (voltage_range_y[1] - voltage_range_y[0]))
+    else:
+        coord_idx = ((resolution - 1) * (np.array(coordinates)[:, 0] - voltage_range_x[0])
+                     / (voltage_range_x[1] - voltage_range_x[0]))
+
+    if round_to_int:
+        coord_idx = coord_idx.round(decimals=0).astype(int)
+
+    return coord_idx

simcats_datasets/support_functions/data_preprocessing.py

@@ -13,6 +13,7 @@ import cv2
 import skimage.restoration
 import bm3d
 from scipy.signal import resample, decimate
+import warnings
 
 
 def example_preprocessor(data: Union[np.ndarray, List[np.ndarray]]) -> Union[np.ndarray, List[np.ndarray]]:
@@ -49,6 +50,40 @@ def cast_to_float32(data: Union[np.ndarray, List[np.ndarray]]) -> Union[np.ndarr
     return data
 
 
+def quantize_to_int_bit_depth(data: Union[np.ndarray, List[np.ndarray]],
+                              bit_depth: int,
+                              min_float: float,
+                              max_float: float,
+                              dtype: np.dtype = np.int_) -> Union[np.ndarray, List[np.ndarray]]:
+    """Quantize the data to unsigned integers of the specified bit depth.
+    This is especially useful to test algorithms that would rely on low resolution measurements, for example, if an
+    efficient readout is implemented in the cryostat. The data will be quantized by mapping the float range defined by
+    the supplied min and max values to an integer with the specified bit depth. This allows to use the whole integer bit
+    range for the signal, assuming that the readout is precisely calibrated for this range.
+
+    Args:
+        data: Numpy array to be cast to float32 (or a list of such).
+        bit_depth: Number of bits to quantize the data to.
+        min_float: Minimum expected value of the float numbers, that will be mapped to the minimum of the integer (0).
+        max_float: Maximum expected value of the float numbers, that will be mapped to the minimum of the integer
+            (2^(bit_depth)-1).
+        dtype: Data type of the output array. Defaults to np.int_.
+
+    Returns:
+        integer numpy array (or a list of such).
+    """
+    # handle list here, for example with list comprehension
+    if isinstance(data, list):
+        data = [quantize_to_int_bit_depth(temp_data, bit_depth=bit_depth, min=min_float, max=max_float) for temp_data in data]
+    else:
+        assert np.min(data) >= min_float and np.max(data) <= max_float
+        data -= min_float
+        data /= (max_float - min_float)
+        data *= 2**bit_depth - 1
+        data = np.round(data).astype(dtype)
+    return data
+
+
 def cast_to_float16(data: Union[np.ndarray, List[np.ndarray]]) -> Union[np.ndarray, List[np.ndarray]]:
     """Cast the data to float16. Especially useful to reduce memory usage for preloaded datasets.
 
@@ -108,6 +143,69 @@ def min_max_0_1(data: Union[np.ndarray, List[np.ndarray]]) -> Union[np.ndarray,
     return data
 
 
+def min_max_0_1_global(data: Union[np.ndarray, List[np.ndarray]]) -> Union[np.ndarray, List[np.ndarray]]:
+    """Global min max scaling of the data to [0, 1] across the entire data set.
+
+    If a list of data arrays is provided, the global minimum and maximum are computed across all entries. These values
+    are then passed to min_max_0_1_given_limits to perform the scaling.
+
+    Args:
+        data: Numpy array to be scaled (or a list of such).
+
+    Returns:
+        Rescaled numpy array (or a list of such).
+    """
+    if isinstance(data, list):
+        # determine global minimum and maximum
+        global_min = np.min(data[0])
+        global_max = np.max(data[0])
+        for _data in data:
+            global_min = np.min(_data) if np.min(_data) < global_min else global_min
+            global_max = np.max(_data) if np.max(_data) > global_max else global_max
+
+        # min max scaling
+        for _data in data:
+            min_max_0_1_given_limits(_data, minimum=global_min, maximum=global_max)
+    else:
+        min_max_0_1_given_limits(data, minimum=np.min(data), maximum=np.max(data))
+    return data
+
+
+def min_max_0_1_given_limits(data: Union[np.ndarray, List[np.ndarray]], minimum: float, maximum: float) -> Union[np.ndarray, List[np.ndarray]]:
+    """Min max scaling of the data to [0, 1] using the given limits minimum and maximum.
+
+    If a list of data is passed, the data is scaled using the given limits minimum and maximum. If the specified limits
+    of the min max scaling do not match the data and therefore scaled values lie outside the interval [0, 1], a warning
+    is generated.
+
+    Args:
+        data: Numpy array to be scaled (or a list of such).
+        minimum: Minimum value used for scaling.
+        maximum: Maximum value used for scaling.
+
+    Returns:
+        Rescaled numpy array (or a list of such).
+    """
+    if isinstance(data, list):
+        # min max scaling
+        for _data in data:
+            _data -= minimum
+            _data /= (maximum - minimum)
+        if np.any(_data < 0.0) or np.any(_data > 1.0):
+            warnings.warn(
+                f"The specified limits minimum={minimum} and maximum={maximum} do not match the data. "
+                f"At least one scaled value is outside the interval [0, 1].")
+
+    else:
+        data -= minimum
+        data /= (maximum - minimum)
+        if np.any(data < 0.0) or np.any(data > 1.0):
+            warnings.warn(
+                f"The specified limits minimum={minimum} and maximum={maximum} do not match the data. "
+                f"At least one scaled value is outside the interval [0, 1].")
+    return data
+
+
 def min_max_minus_one_one(data: Union[np.ndarray, List[np.ndarray]]) -> Union[np.ndarray, List[np.ndarray]]:
     """Min max scaling of the data to [-1, 1].
 
@@ -223,7 +321,7 @@ def resample_image(data: Union[np.ndarray, List[np.ndarray]], target_size: Tuple
         The resampled image or a list of such.
     """
     if isinstance(data, list):
-        data = [resample_image(temp_data) for temp_data in data]
+        data = [resample_image(data=temp_data, target_size=target_size) for temp_data in data]
     else:
         if data.shape[0] > target_size[0]:
             data = resample(data, target_size[0], axis=0)
@@ -232,6 +330,19 @@ def resample_image(data: Union[np.ndarray, List[np.ndarray]], target_size: Tuple
     return data
 
 
+def resample_image_to_32x32(data: Union[np.ndarray, List[np.ndarray]]) -> Union[
+    np.ndarray, List[np.ndarray]]:
+    """Resample an image to size of 32x32 using scipy.signal.resample.
+
+    Args:
+        data: The image to resample.
+
+    Returns:
+        The resampled image or a list of such.
+    """
+    return resample_image(data=data, target_size=(32, 32))
+
+
 def decimate_image(data: Union[np.ndarray, List[np.ndarray]], target_size: Tuple[int, int]) -> Union[
     np.ndarray, List[np.ndarray]]:
     """Decimate an image to target size using scipy.signal.decimate.