nanopyx.core.utils.benchmark

  1import math
  2import nanopyx
  3import numpy as np
  4
  5from ..generate.beads import (
  6    generate_channel_misalignment,
  7    generate_timelapse_drift,
  8)
  9
 10
 11def benchmark_all_le_methods(
 12    n_benchmark_runs=3,
 13    img_dims=100,
 14    shift=1,
 15    magnification=2,
 16    rotation=math.radians(15),
 17    conv_kernel_dims=5,
 18):
 19    """
 20    Runs benchmark tests for all LE methods.
 21    Args:
 22        n_benchmark_runs (int): The number of benchmark runs to perform. Default is 3.
 23        img_dims (int): The dimensions of the input image. Default is 100.
 24        shift (int): The amount of shift to apply to the image during benchmarking. Default is 2.
 25        magnification (int): The magnification factor to apply to the image during benchmarking. Default is 5.
 26        rotation (float): The rotation angle to apply to the image during benchmarking. Default is 0.2617993877991494 (equal to 15 degrees in radians).
 27        conv_kernel_dims (int): The dimensions of the convolution kernel to use during benchmarking. Default is 23.
 28    Returns:
 29        None
 30    """
 31
 32    img = np.random.random((img_dims, img_dims)).astype(np.float32)
 33    img_int = np.random.random(
 34        (img_dims * magnification, img_dims * magnification)
 35    ).astype(np.float32)
 36    kernel = np.ones((conv_kernel_dims, conv_kernel_dims)).astype(np.float32)
 37
 38    bicubic_sm = (
 39        nanopyx.core.transform._le_interpolation_bicubic.ShiftAndMagnify()
 40    )
 41    bicubic_ssr = (
 42        nanopyx.core.transform._le_interpolation_bicubic.ShiftScaleRotate()
 43    )
 44    cr_sm = (
 45        nanopyx.core.transform._le_interpolation_catmull_rom.ShiftAndMagnify()
 46    )
 47    cr_ssr = (
 48        nanopyx.core.transform._le_interpolation_catmull_rom.ShiftScaleRotate()
 49    )
 50    l_sm = nanopyx.core.transform._le_interpolation_lanczos.ShiftAndMagnify()
 51    l_ssr = nanopyx.core.transform._le_interpolation_lanczos.ShiftScaleRotate()
 52    nn_sm = (
 53        nanopyx.core.transform._le_interpolation_nearest_neighbor.ShiftAndMagnify()
 54    )
 55    nn_ssr = (
 56        nanopyx.core.transform._le_interpolation_nearest_neighbor.ShiftScaleRotate()
 57    )
 58    nn_pt = (
 59        nanopyx.core.transform._le_interpolation_nearest_neighbor.PolarTransform()
 60    )
 61
 62    conv2d = nanopyx.core.transform._le_convolution.Convolution()
 63
 64    rad = nanopyx.core.transform._le_radiality.Radiality()
 65    rc = (
 66        nanopyx.core.transform._le_roberts_cross_gradients.GradientRobertsCross()
 67    )
 68    rgc = (
 69        nanopyx.core.transform._le_radial_gradient_convergence.RadialGradientConvergence()
 70    )
 71
 72    esrrf = nanopyx.core.transform._le_esrrf.eSRRF()
 73    esrrf3d = nanopyx.core.transform._le_esrrf3d.eSRRF3D()
 74
 75    nlm = nanopyx.core.transform._le_nlm_denoising.NLMDenoising()
 76
 77    for i in range(n_benchmark_runs):
 78        bicubic_sm.benchmark(img, shift, shift, magnification, magnification)
 79    for i in range(n_benchmark_runs):
 80        cr_sm.benchmark(img, shift, shift, magnification, magnification)
 81    for i in range(n_benchmark_runs):
 82        l_sm.benchmark(img, shift, shift, magnification, magnification)
 83    for i in range(n_benchmark_runs):
 84        nn_sm.benchmark(img, shift, shift, magnification, magnification)
 85
 86    for i in range(n_benchmark_runs):
 87        bicubic_ssr.benchmark(
 88            img, shift, shift, magnification, magnification, rotation
 89        )
 90    for i in range(n_benchmark_runs):
 91        cr_ssr.benchmark(
 92            img, shift, shift, magnification, magnification, rotation
 93        )
 94    for i in range(n_benchmark_runs):
 95        l_ssr.benchmark(
 96            img, shift, shift, magnification, magnification, rotation
 97        )
 98    for i in range(n_benchmark_runs):
 99        nn_ssr.benchmark(
100            img, shift, shift, magnification, magnification, rotation
101        )
102
103    for i in range(n_benchmark_runs):
104        nn_pt.benchmark(img, (img_dims, img_dims), "log")
105
106    for i in range(n_benchmark_runs):
107        conv2d.benchmark(img, kernel)
108
109    for i in range(n_benchmark_runs):
110        rad.benchmark(img, img_int)
111    for i in range(n_benchmark_runs):
112        rc.benchmark(img)
113    for i in range(n_benchmark_runs):
114        rgc.benchmark(img_int, img_int, img_int)
115
116    for i in range(n_benchmark_runs):
117        esrrf.benchmark(img)
118
119    for i in range(n_benchmark_runs):
120        esrrf3d.benchmark(img[np.newaxis, ...])
121
122    for i in range(n_benchmark_runs):
123        nlm.benchmark(img)
124
125    channel_reg = (
126        nanopyx.core.analysis._le_channel_registration.ChannelRegistrationEstimator()
127    )
128
129    drift_reg = nanopyx.core.analysis._le_drift_calculator.DriftEstimator()
130
131    channels_img = generate_channel_misalignment().astype(np.float32)
132    drift_img = generate_timelapse_drift().astype(np.float32)
133
134    for i in range(n_benchmark_runs):
135        channel_reg.benchmark(channels_img, 0, 10, 3, 0.5)
136
137    for i in range(n_benchmark_runs):
138        drift_reg.benchmark(drift_img)