diff --git a/notebooks/SRMetrics.ipynb b/notebooks/SRMetrics.ipynb index 33cb8bc3..a95d0811 100644 --- a/notebooks/SRMetrics.ipynb +++ b/notebooks/SRMetrics.ipynb @@ -667,7 +667,11 @@ ] } ], - "metadata": {}, + "metadata": { + "language_info": { + "name": "python" + } + }, "nbformat": 4, "nbformat_minor": 5 } diff --git a/src/include/_c_gradients.c b/src/include/_c_gradients.c index 13cdd488..a4b7b5a3 100644 --- a/src/include/_c_gradients.c +++ b/src/include/_c_gradients.c @@ -1,3 +1,4 @@ +#include void _c_gradient_radiality(float* image, float* imGc, float* imGr, int rows, int cols) { @@ -66,23 +67,27 @@ void _c_gradient_roberts_cross(float* image, float* imGc, float* imGr, int rows, // as in https://www.nature.com/articles/s41592-022-01669-y#MOESM1 // 3D Gradient calculation -void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slice, +void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) { float ip0, ip1, ip2, ip3, ip4, ip5, ip6, ip7; - int z_i, y_i, x_i; + int z_i, y_i, x_i, z_1, y_1, x_1; - for (z_i = 0; z_i < slice - 1; z_i++) { - for (y_i = 0; y_i < rows - 1; y_i++) { - for (x_i = 0; x_i < cols - 1; x_i++) { + for (z_i = 0; z_i < slices; z_i++) { + for (y_i = 0; y_i < rows; y_i++) { + for (x_i = 0; x_i < cols; x_i++) { + + z_1 = z_i >= slices - 1 ? slices - 1 : z_i + 1; + y_1 = y_i >= rows - 1 ? rows - 1 : y_i + 1; + x_1 = x_i >= cols - 1 ? cols - 1 : x_i + 1; ip0 = image[z_i * rows * cols + y_i * cols + x_i]; - ip1 = image[z_i * rows * cols + y_i * cols + x_i + 1]; - ip2 = image[z_i * rows * cols + (y_i + 1) * cols + x_i]; - ip3 = image[z_i * rows * cols + (y_i + 1) * cols + x_i + 1]; - ip4 = image[(z_i + 1) * rows * cols + y_i * cols + x_i]; - ip5 = image[(z_i + 1) * rows * cols + y_i * cols + x_i + 1]; - ip6 = image[(z_i + 1) * rows * cols + (y_i + 1) * cols + x_i]; - ip7 = image[(z_i + 1) * rows * cols + (y_i + 1) * cols + x_i + 1]; + ip1 = image[z_i * rows * cols + y_i * cols + x_1]; + ip2 = image[z_i * rows * cols + y_1 * cols + x_i]; + ip3 = image[z_i * rows * cols + y_1 * cols + x_1]; + ip4 = image[z_1 * rows * cols + y_i * cols + x_i]; + ip5 = image[z_1 * rows * cols + y_i * cols + x_1]; + ip6 = image[z_1 * rows * cols + y_1 * cols + x_i]; + ip7 = image[z_1 * rows * cols + y_1 * cols + x_1]; imGc[z_i * rows* cols + y_i * cols + x_i] = (ip1 + ip3 + ip5 + ip7 - ip0 - ip2 - ip4 - ip6) / 4; imGr[z_i * rows* cols + y_i * cols + x_i] = @@ -93,3 +98,21 @@ void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int sli } } } + +void _c_gradient_2_point_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) { + int s_i, y_i, x_i, s0, y0, x0; + + for (s_i=0; s_i 0 ? s_i - 1 : 0; + y0 = y_i > 0 ? y_i - 1 : 0; + x0 = x_i > 0 ? x_i - 1 : 0; + imGc[s_i*rows*cols + y_i*cols + x_i] = image[s_i*rows*cols + y_i*cols + x_i] - image[s_i*rows*cols + y_i*cols + x0]; + imGr[s_i*rows*cols + y_i*cols + x_i] = image[s_i*rows*cols + y_i*cols + x_i] - image[s_i*rows*cols + y0*cols + x_i]; + imGs[s_i*rows*cols + y_i*cols + x_i] = image[s_i*rows*cols + y_i*cols + x_i] - image[s0*rows*cols + y_i*cols + x_i]; + + } + } + } +} \ No newline at end of file diff --git a/src/include/_c_gradients.h b/src/include/_c_gradients.h index 132e6bdd..fb946bf4 100644 --- a/src/include/_c_gradients.h +++ b/src/include/_c_gradients.h @@ -9,7 +9,9 @@ void _c_gradient_2point(float* image, float* imGc, float* imGr, int rows, void _c_gradient_roberts_cross(float* image, float* imGc, float* imGr, int rows, int cols); -void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slice, +void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols); +void _c_gradient_2_point_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols); + #endif diff --git a/src/include/_c_sr_radial_gradient_convergence.c b/src/include/_c_sr_radial_gradient_convergence.c index 41d3a1fe..af141bc5 100644 --- a/src/include/_c_sr_radial_gradient_convergence.c +++ b/src/include/_c_sr_radial_gradient_convergence.c @@ -1,4 +1,5 @@ #include +#include double _c_calculate_dw(double distance, double tSS) { return pow((distance * exp((-distance * distance) / tSS)), 4); @@ -68,3 +69,136 @@ float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM return RGC; } + +double _c_calculate_dw3D_isotropic(double distance, double tSS) { + return pow((distance * exp(-(distance * distance) / tSS)), 4); +} + +double _c_calculate_dw3D(double distance, double distance_xy, double distance_z,double tSS, double tSS_z) { + float D_weight_xy, D_weight_z, D_weight; + D_weight_xy = (exp((-distance_xy * distance_xy) / tSS)); + D_weight_z = (exp((-distance_z * distance_z) / tSS_z)); + D_weight = distance * (D_weight_xy * D_weight_z); + return pow(D_weight, 4); +} + +double _c_calculate_dw_xy(double distance_xy, double tSS) { + return pow((distance_xy * exp((-distance_xy * distance_xy) / tSS)), 4); +} + +double _c_calculate_dw_z(double distance_z, double tSS_z) { + return pow((distance_z * exp((-distance_z * distance_z) / tSS_z)), 4); +} + +double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance) { + float Dk = sqrtf((Gy * dz - Gz * dy) * (Gy * dz - Gz * dy) + (Gz * dx - Gx * dz) * (Gz * dx - Gx * dz) + (Gx * dy - Gy * dx) * (Gx * dy - Gy * dx)) / sqrt(Gx * Gx + Gy * Gy + Gz * Gz); + if (isnan(Dk)) { + Dk = distance; + } + Dk = 1 - Dk / distance; + return Dk; +} + +float _c_get_bound_value(float* im, int slices, int rows, int cols, int s, int r, int c){ + int _s = s > 0 ? s : 0; + _s = _s < slices - 1 ? _s : slices - 1; + int _r = r > 0 ? r : 0; + _r = _r < rows - 1 ? _r : rows - 1; + int _c = c > 0 ? c : 0; + _c = _c < cols - 1 ? _c : cols - 1; + + return im[_s * rows * cols + _r * cols + _c]; +} + +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float ratio_px, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) { + + float vx, vy, vz, Gx, Gy, Gz, dx, dy, dz, dz_real, distance, distance_xy, distance_z, distanceWeight, distanceWeight_xy, distanceWeight_z, GdotR, Dk; + + float xc = (xM + 0.5) / magnification_xy; + float yc = (yM + 0.5) / magnification_xy; + float zc = (sliceM + 0.5) / magnification_z; + + float RGC = 0; + float distanceWeightSum = 0; + float distanceWeightSum_xy = 0; + float distanceWeightSum_z = 0; + + int _start = -(int)(Gx_Gy_MAGNIFICATION * fwhm); + int _end = (int)(Gx_Gy_MAGNIFICATION * fwhm + 1); + + int _start_z = -(int)(Gz_MAGNIFICATION * fwhm_z); + int _end_z = (int)(Gz_MAGNIFICATION * fwhm_z + 1); + + for (int j = _start; j <= _end; j++) { + vy = ((float) ((int) (Gx_Gy_MAGNIFICATION*yc)) + j)/(float) Gx_Gy_MAGNIFICATION; + + if (0 < vy && vy < rowsM - 1) { + for (int i = _start; i <= _end; i++) { + vx = ((float) ((int) (Gx_Gy_MAGNIFICATION*xc)) + i)/(float) Gx_Gy_MAGNIFICATION; + + if (0 < vx && vx < colsM - 1) { + for (int k = _start_z; k <= _end_z; k++) { + vz = ((float) ((int) (zc)) + k); + + if (0 < vz && vz < slicesM - 1) { + dx = vx - xc; + dy = vy - yc; + dz = vz - zc; + dz_real = dz * ratio_px; // This has been already divided by magnification_z + distance = sqrt(dx * dx + dy * dy + dz_real * dz_real); + distance_xy = sqrt(dx * dx + dy * dy); + distance_z = dz_real; + + if (distance != 0 && distance_xy <= tSO && distance_z <= tSO_z) { + Gx = _c_get_bound_value(imIntGx, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + Gy = _c_get_bound_value(imIntGy, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + Gz = _c_get_bound_value(imIntGz, slicesM*Gz_MAGNIFICATION, rowsM*Gx_Gy_MAGNIFICATION, colsM*Gx_Gy_MAGNIFICATION, vz * magnification_z * Gz_MAGNIFICATION, magnification_xy * Gx_Gy_MAGNIFICATION * vy, magnification_xy * Gx_Gy_MAGNIFICATION * vx); + + // distanceWeight = _c_calculate_dw3D_isotropic(distance, tSS); + distanceWeight = _c_calculate_dw3D(distance, distance_xy, distance_z, tSS, tSS_z); + + // distanceWeight_xy = _c_calculate_dw_xy(distance_xy, tSS); + // distanceWeight_z = _c_calculate_dw_z(distance_z, tSS_z); + + distanceWeightSum += distanceWeight; + // distanceWeightSum_xy += distanceWeight_xy; + // distanceWeightSum_z += distanceWeight_z; + GdotR = Gx*dx + Gy*dy + Gz*dz_real; + + if (GdotR < 0) { + Dk = _c_calculate_dk3D(Gx, Gy, Gz, dx, dy, dz_real, distance); + RGC += (Dk * distanceWeight); + } + } + } + } + } + } + } + } + + RGC /= distanceWeightSum; + + if (RGC >= 0) { + RGC = pow(RGC, sensitivity); + } else { + RGC = 0; + } + + return RGC; +} + +float _c_calculate_dk_3d(float dx, float dy, float dz, float Gx, float Gy, float Gz, float Gmag, float distance) { + float G1 = dy*Gz - dz*Gy; + float G2 = dz*Gx - dx*Gz; + float G3 = dx*Gy - dy*Gx; + float cross_product = sqrt(G1*G1 + G2*G2 + G3*G3)/Gmag; + + if (isnan(cross_product)) { + cross_product = distance; + } + + cross_product = 1 - cross_product / distance; + + return cross_product; +} diff --git a/src/include/_c_sr_radial_gradient_convergence.h b/src/include/_c_sr_radial_gradient_convergence.h index b99e11b8..b9793678 100644 --- a/src/include/_c_sr_radial_gradient_convergence.h +++ b/src/include/_c_sr_radial_gradient_convergence.h @@ -9,4 +9,18 @@ double _c_calculate_dk(float Gx, float Gy, float dx, float dy, float distance); float _c_calculate_rgc(int xM, int yM, float* imIntGx, float* imIntGy, int colsM, int rowsM, int magnification, float Gx_Gy_MAGNIFICATION, float fwhm, float tSO, float tSS, float sensitivity); +double _c_calculate_dw3D_isotropic(double distance, double tSS); + +double _c_calculate_dw3D(double distance, double distance_xy, double distance_z, double tSS, double tSS_z); + +double _c_calculate_dw_xy(double distance_xy, double tSS); + +double _c_calculate_dw_z(double distance_z, double tSS_z); + +double _c_calculate_dk3D(float Gx, float Gy, float Gz, float dx, float dy, float dz, float distance); + +float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float ratio_px, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity); + +float _c_calculate_rgc_3d(int cM, int rM, int sM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float Gx_Gy_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSS, float sensitivity); + #endif diff --git a/src/nanopyx/core/transform/_interpolation.pyx b/src/nanopyx/core/transform/_interpolation.pyx index dc39126f..a426f990 100644 --- a/src/nanopyx/core/transform/_interpolation.pyx +++ b/src/nanopyx/core/transform/_interpolation.pyx @@ -5,6 +5,8 @@ cimport numpy as np import cython +from ._le_interpolation_catmull_rom import ShiftAndMagnify as ShiftMagnify_CR + cdef extern from "_c_interpolation_catmull_rom.h": float _c_cr_interpolate "_c_interpolate" (float *image, float row, float col, int rows, int cols) @@ -18,3 +20,37 @@ def cr_interpolate(img_stack, row, col): img_stack = np.array(img_stack, dtype=np.float32) return _cr_interpolate(img_stack, row, col) +def interpolate_3d(image, magnification_xy: int = 5, magnification_z: int = 5): + interpolator = ShiftMagnify_CR() + + xy_interpolated = interpolator.run(image, 0, 0, magnification_xy, magnification_xy) + + yz_interpolated = np.transpose(interpolator.run(np.transpose(xy_interpolated, axes=[1, 0, 2]).copy(), 0, 0, magnification_z, 1), axes=[1, 0, 2]).copy() + xz_interpolated = np.transpose(interpolator.run(np.transpose(xy_interpolated, axes=[2, 1, 0]).copy(), 0, 0, 1, magnification_z), axes=[2,1,0]).copy() + + return np.mean(np.array([yz_interpolated, xz_interpolated]), axis=0) + +def linear_interpolation_1D_z(image, magnification): + # linear interpolator that takes a 3D image and do linear interpolation in a 1D column in the chosen axis + + image_interpolated = np.zeros((image.shape[0] * magnification, image.shape[1], image.shape[2]), dtype=np.float32) + + z_coords = np.linspace(0, image.shape[0], image.shape[0]) + new_z_coords = np.linspace(0, image.shape[0], image.shape[0] * magnification) + + for r in range(image.shape[1]): + for c in range(image.shape[2]): + slc = image[:, r, c] + image_interpolated[:, r, c] = np.interp(new_z_coords, z_coords, slc) + + + return image_interpolated + + +def interpolate_3d_zlinear(image, magnification_xy: int = 5, magnification_z: int = 5): + interpolator_xy = ShiftMagnify_CR() + + xy_interpolated = interpolator_xy.run(np.ascontiguousarray(image), 0, 0, magnification_xy, magnification_xy) + z_interpolated = linear_interpolation_1D_z(xy_interpolated, magnification_z) + + return z_interpolated diff --git a/src/nanopyx/core/transform/_le_esrrf3d.pyx b/src/nanopyx/core/transform/_le_esrrf3d.pyx new file mode 100644 index 00000000..77ffffd4 --- /dev/null +++ b/src/nanopyx/core/transform/_le_esrrf3d.pyx @@ -0,0 +1,191 @@ +import numpy as np +import math + +cimport numpy as np +from libc.math cimport floor + +from cython.parallel import prange + +from .sr_temporal_correlations import calculate_eSRRF_temporal_correlations + +from ._interpolation import interpolate_3d, interpolate_3d_zlinear +from ._le_interpolation_catmull_rom import ShiftAndMagnify +from ...__liquid_engine__ import LiquidEngine + +cdef extern from "_c_gradients.h": + void _c_gradient_3d(float* image, float* imGc, float* imGr, float* imGs, int slices, int rows, int cols) nogil + +cdef extern from "_c_sr_radial_gradient_convergence.h": + float _c_calculate_rgc3D(int xM, int yM, int sliceM, float* imIntGx, float* imIntGy, float* imIntGz, int colsM, int rowsM, int slicesM, int magnification_xy, int magnification_z, float ratio_px, float Gx_Gy_MAGNIFICATION, float Gz_MAGNIFICATION, float fwhm, float fwhm_z, float tSO, float tSO_z, float tSS, float tSS_z, float sensitivity) nogil + +class eSRRF3D(LiquidEngine): + """ + eSRRF 3D using the NanoPyx Liquid Engine and running as a single task. + """ + + def __init__(self, clear_benchmarks=False, testing=False): + self._designation = "eSRRF_3D" + super().__init__(clear_benchmarks=clear_benchmarks, testing=testing, + opencl_=False, unthreaded_=True, threaded_=True, threaded_static_=False, + threaded_dynamic_=False, threaded_guided_=False) + self._default_benchmarks = {'OpenCL': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 0.6182407079995755, 0.6122367919997487, 0.6093217500001629], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 0.3028541249987029, 0.2802749999991647, 0.2996904169995105]}, 'Threaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.06756008299999, 11.480632083001183, 11.368770667000717], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.490110000000641, 2.6822768330002873, 2.5428189579997706]}, 'Threaded_dynamic': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.366981125000166, 9.478710332999981, 10.355995709000126], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.020473291999224, 2.0464198749996285, 2.1126812500006054]}, 'Threaded_guided': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 9.59399004199986, 9.394610874998762, 10.42694429200128], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.1240765410002496, 2.1175940839984833, 2.127043415999651]}, 'Threaded_static': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 11.325379959000202, 11.439641291000953, 12.059574375000011], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 2.4486127919990395, 2.5282963329991617, 2.7061019579996355]}, 'Unthreaded': {"(['shape(100, 150, 150)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [16875000.0, 50.56610608399933, 50.84249891699983, 51.47774041699995], "(['shape(50, 100, 100)'], {'magnification': 5, 'radius': 1.5, 'sensitivity': 1.0, 'doIntensityWeighting': True})": [3750000.0, 10.916643833001217, 11.070652250000421, 11.099240584000654]}} + self._gradients_s_interpolated = None + self._gradients_r_interpolated = None + self._gradients_c_interpolated = None + self.keep_gradients = False + self.keep_interpolated = False + self._img_interpolated = None + + def run(self, image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type=None, keep_gradients=False, keep_interpolated = False): + self.keep_gradients = keep_gradients + self.keep_interpolated = keep_interpolated + # TODO: complete and check _run inputs, need to complete variables? + if image.dtype != np.float32: + image = image.astype(np.float32) + if len(image.shape) == 4: + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + elif len(image.shape) == 3: + image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) + return self._run(image, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, sensitivity=sensitivity, doIntensityWeighting=doIntensityWeighting, run_type=run_type) + + def _run_unthreaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Unthreaded"): + + interpolator = ShiftAndMagnify() + + cdef float sigma = radius / 2.355 + cdef float fwhm = radius + cdef float tSS = 2 * sigma * sigma + cdef float tSO = 2 * sigma + 1 + cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account + cdef float fwhm_z = radius * ratio_px + cdef float tSS_z = 2 * sigma_z * sigma_z + cdef float tSO_z = 2 * sigma_z + 1 + cdef int Gx_Gy_MAGNIFICATION = 2 + cdef int _magnification_xy = magnification_xy + cdef int _magnification_z = magnification_z + cdef int _doIntensityWeighting = doIntensityWeighting + + cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum + n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] + + cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum + + cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 + + cdef float rgc_val, zcof + + for f in range(n_frames): + image_interpolated = interpolate_3d(image[f], _magnification_xy, _magnification_z) + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] + + gradients_c = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_r = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + gradients_s = np.zeros((n_slices, n_rows*Gx_Gy_MAGNIFICATION, n_cols*Gx_Gy_MAGNIFICATION), dtype=np.float32) + + img_dum = interpolator.run(image[f], 0, 0, Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] + + with nogil: + _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices, n_rows_mag_dum, n_cols_mag_dum) + + gradients_s_interpolated = interpolate_3d(gradients_s, _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d(gradients_r, _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d(gradients_c, _magnification_xy, _magnification_z) + + if self.keep_gradients: + self._gradients_s_interpolated = gradients_s_interpolated.copy() + self._gradients_r_interpolated = gradients_r_interpolated.copy() + self._gradients_c_interpolated = gradients_c_interpolated.copy() + + if self.keep_interpolated: + self._img_interpolated = img_dum.copy() + + with nogil: + for sM in range(0, n_slices_mag): + for rM in range(0, n_rows_mag): + for cM in range(0, n_cols_mag): + if _doIntensityWeighting: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] + else: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + + rgc_map[f, sM, rM, cM] = rgc_val + + return np.asarray(rgc_map) + + def _run_threaded(self, float[:,:,:,:] image, magnification_xy: int = 5, magnification_z: int = 5, radius: float = 1.5, radius_z: float = 1.5, ratio_px: float = 4.0, sensitivity: float = 1, doIntensityWeighting: bool = True, run_type="Threaded"): + + cdef float sigma = radius / 2.355 + cdef float fwhm = radius + cdef float tSS = 2 * sigma * sigma + cdef float tSO = 2 * sigma + 1 + cdef float sigma_z = radius * ratio_px / 2.355 # Taking voxel size into account + cdef float fwhm_z = radius * ratio_px + cdef float tSS_z = 2 * sigma_z * sigma_z + cdef float tSO_z = 2 * sigma_z + 1 + cdef int Gx_Gy_MAGNIFICATION = 2 + cdef int _magnification_xy = magnification_xy + cdef int _magnification_z = magnification_z + cdef int _doIntensityWeighting = doIntensityWeighting + + cdef int n_frames, n_slices, n_rows, n_cols, n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum + n_frames, n_slices, n_rows, n_cols = image.shape[0], image.shape[1], image.shape[2], image.shape[3] + + cdef float[:, :, :, :] rgc_map = np.zeros((n_frames, n_slices*magnification_z, n_rows*magnification_xy, n_cols*magnification_xy), dtype=np.float32) + + cdef float[:, :, :] image_interpolated, gradients_s, gradients_r, gradients_c, gradients_s_interpolated, gradients_r_interpolated, gradients_c_interpolated, padded, img_dum + + cdef int f, n_slices_mag, n_rows_mag, n_cols_mag, sM, rM, cM, z0 + + cdef float rgc_val, zcof + + for f in range(n_frames): + image_interpolated = interpolate_3d_zlinear(image[f,:,:,:], _magnification_xy, _magnification_z) + + n_slices_mag, n_rows_mag, n_cols_mag = image_interpolated.shape[0], image_interpolated.shape[1], image_interpolated.shape[2] + + img_dum = interpolate_3d_zlinear(image[f], Gx_Gy_MAGNIFICATION, Gx_Gy_MAGNIFICATION) + n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum = img_dum.shape[0], img_dum.shape[1], img_dum.shape[2] + + gradients_c = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) + gradients_r = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) + gradients_s = np.zeros((n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum), dtype=np.float32) + with nogil: + _c_gradient_3d(&img_dum[0, 0, 0], &gradients_c[0, 0, 0], &gradients_r[0, 0, 0], &gradients_s[0, 0, 0], n_slices_mag_dum, n_rows_mag_dum, n_cols_mag_dum) + + gradients_s_interpolated = interpolate_3d_zlinear(gradients_s, _magnification_xy, _magnification_z) + gradients_r_interpolated = interpolate_3d_zlinear(gradients_r, _magnification_xy, _magnification_z) + gradients_c_interpolated = interpolate_3d_zlinear(gradients_c, _magnification_xy, _magnification_z) + + if self.keep_gradients: + self._gradients_s_interpolated = gradients_s_interpolated.copy() + self._gradients_r_interpolated = gradients_r_interpolated.copy() + self._gradients_c_interpolated = gradients_c_interpolated.copy() + + if self.keep_interpolated: + self._img_interpolated = img_dum.copy() + + with nogil: + for sM in range(0, n_slices_mag): + for rM in prange(0, n_rows_mag): + for cM in range(0, n_cols_mag): + if _doIntensityWeighting: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_map[f, sM, rM, cM] = rgc_val * image_interpolated[sM, rM, cM] + else: + rgc_val = _c_calculate_rgc3D(cM, rM, sM, &gradients_c_interpolated[0,0,0], &gradients_r_interpolated[0,0,0], &gradients_s_interpolated[0,0,0], n_cols_mag, n_rows_mag, n_slices_mag, _magnification_xy, _magnification_z, ratio_px, Gx_Gy_MAGNIFICATION, 1, fwhm, fwhm_z, tSO, tSO_z, tSS, tSS_z, sensitivity) + rgc_map[f, sM, rM, cM] = rgc_val + + return np.asarray(rgc_map) + + def get_gradients(self): + if self._gradients_c_interpolated is None or self._gradients_r_interpolated is None or self._gradients_s_interpolated is None: + print("Gradients not yet calculated") + else: + return self._gradients_c_interpolated, self._gradients_r_interpolated, self._gradients_s_interpolated + + def get_interpolated_image(self): + return self._img_interpolated diff --git a/src/nanopyx/core/transform/sr_temporal_correlations.py b/src/nanopyx/core/transform/sr_temporal_correlations.py index 8496186c..f6560407 100644 --- a/src/nanopyx/core/transform/sr_temporal_correlations.py +++ b/src/nanopyx/core/transform/sr_temporal_correlations.py @@ -219,3 +219,30 @@ def calculate_tac2(rad_array): out_array = np.mean(centered[:-nlag] * centered[nlag:], axis=0) return out_array + +def calculate_eSRRF3d_temporal_correlations(rgc_map, correlation: str = "AVG", framewindow: float = 5, rollingoverlap: float = 2): + # correlation (str): Type of correlation to calculate. Should be "AVG", "VAR", or "TAC2" + n_frames, n_slices, n_rows, n_cols = rgc_map.shape[0], rgc_map.shape[1], rgc_map.shape[2], rgc_map.shape[3] + + if n_frames == 1: + print("Only one frame, no temporal correlations can be calculated") + return rgc_map + + else: + if framewindow > 0: + if rollingoverlap: + n_windows = int((n_frames - framewindow) / rollingoverlap) + 1 + else: + n_windows = int(n_frames / framewindow) + else: + n_windows = 1 + framewindow = n_frames - 1 + + avg_rgc_map = np.zeros((n_windows, n_slices, n_rows, n_cols), dtype=np.float32) + + for w in range(n_windows): + start_frame = w * (int(framewindow) - int(rollingoverlap)) + end_frame = start_frame + int(framewindow) + avg_rgc_map[w,:,:,:] = calculate_eSRRF_temporal_correlations(rgc_map[start_frame:end_frame,:,:,:], correlation) + + return avg_rgc_map \ No newline at end of file diff --git a/src/nanopyx/methods/esrrf_3d/__init__.py b/src/nanopyx/methods/esrrf_3d/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/nanopyx/methods/esrrf_3d/run.py b/src/nanopyx/methods/esrrf_3d/run.py new file mode 100644 index 00000000..ab6c63d6 --- /dev/null +++ b/src/nanopyx/methods/esrrf_3d/run.py @@ -0,0 +1,27 @@ +from ...core.transform._le_esrrf3d import eSRRF3D +from ...core.transform.sr_temporal_correlations import calculate_eSRRF3d_temporal_correlations + +def run_esrrf3d(img,correlation="AVG", framewindow=5, rollingoverlap=2, **kwargs): + """ + Calculate the eSRRF3D temporal correlations for the given image. + + Args: + img: The input 3D image. + magnification_xy: The magnification factor for the x and y axes. + magnification_z: The magnification factor for the z axis. + radius: The radius for the xy plane. + radius_z: The radius for the z axis. + sensitivity: The sensitivity for the calculation. + doIntensityWeighting: Whether to perform intensity weighting. + run_type: The type of the run. + keep_gradients: Whether to keep the gradients. + keep_interpolated: Whether to keep the interpolated values. + correlation: The type of correlation to use. + framewindow: The window size for frame. + rollingoverlap: The overlap size for rolling. + + Returns: + The calculated eSRRF3D temporal correlations. + """ + esrrf_calculator = eSRRF3D() + return calculate_eSRRF3d_temporal_correlations(esrrf_calculator.run(img, **kwargs), correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap) \ No newline at end of file diff --git a/tests/notebooks/esrrf3d.ipynb b/tests/notebooks/esrrf3d.ipynb new file mode 100644 index 00000000..7f7537c0 --- /dev/null +++ b/tests/notebooks/esrrf3d.ipynb @@ -0,0 +1,824 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "import stackview\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from tifffile import imread\n", + "from nanopyx.methods.esrrf_3d.run import run_esrrf3d\n", + "\n", + "from nanopyx.core.transform._le_esrrf3d import eSRRF3D" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# img = imread(\"/Users/avesga/Code/NanoPyx/3D_test_image/sphere_9planes.tif\").astype(np.float32)\n", + "path = \"/Users/avesga/Desktop/3DeSRRF/blinking_test.tif\"\n", + "img = imread(path).astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(21, 9, 50, 50)" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "img.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41f8b80c99734713ae8542d94f34a908", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=50, width=50),)),)), IntSlider(value=2, descri…" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# img to analize\n", + "\n", + "# planes = [0, 2, 4, 6, 8]\n", + "# planes = [1, 3, 5, 7]\n", + "# planes = [0, 4, 8]\n", + "planes = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n", + "planes = [2, 3, 4, 5, 6]\n", + "img4ana = img[:, planes, :, :]\n", + "\n", + "name_save = \"penta_planes\"\n", + "\n", + "stackview.slice(img4ana[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# Define variables\n", + "\n", + "magnification_xy=1\n", + "magnification_z=1\n", + "radius=2\n", + "radius_z = 1\n", + "ratio_px = 4\n", + "sensitivity=2\n", + "run_type=\"Threaded\"\n", + "correlation=\"AVG\"\n", + "framewindow=4\n", + "rollingoverlap=2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011618374999997627 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.7876394100629203, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011809249999998883 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.196533371003347, Delay probability: 0.3408309241242591\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011255499999990093 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01049608399999613 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012502040999990527 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1659572654757324, Delay probability: 0.38101316068177127\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006515875000005167 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009240916999999627 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010658249999991654 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009616374999993127 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01197137499998746 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1218511801736744, Delay probability: 0.29834919892019013\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0066248749999999745 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00923270799999898 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011078333000000384 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.016503666999994948 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.544868640175262, Delay probability: 0.2983491989201902\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01035854100000222 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006259833000001436 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010261416000005852 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010076916999992136 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010106750000005604 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010182833000001779 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0068042500000018435 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0099728339999956 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009371125000001257 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011112291999992863 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009568208999993999 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0061983749999967586 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009718000000006555 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010413582999987625 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01075566699999797 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009886375000007774 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006634583999996835 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010288708000004476 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009826000000003887 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01008716700000889 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009487999999990393 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00685729200000651 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010703500000005306 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010051625000002673 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010480540999992627 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010506792000001042 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00644358300000647 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009311291000003052 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009785499999992453 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010117250000007516 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010544667000004893 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006225083000003906 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010572874999994042 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011251583999992931 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009949417000001404 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011891250000005016 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1721747575417882, Delay probability: 0.31805424426260626\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007157417000001942 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01190862500000378 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1965927818048916, Delay probability: 0.15240456203671085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010140958000008027 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01101308399999823 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011847791000008101 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1702777900103836, Delay probability: 0.14370002496050244\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007982166000005009 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2251743428895232, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011950166000005424 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1964255873434486, Delay probability: 0.21949640760962807\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010167999999993071 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009515416999988702 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009628374999991252 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007010665999999333 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010242375000004245 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010686250000006225 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01148866600000531 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1449637985394634, Delay probability: 0.09538048989205275\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010850666999999703 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006503917000003412 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009681916999994655 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010692250000005288 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011679208000003882 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1639532697365171, Delay probability: 0.0953804898920527\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010220541999999 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006419917000002329 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009971375000006333 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01365233299999602 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3621969575326864, Delay probability: 0.09906174404462277\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012366624999998521 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2339121049823907, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010759375000006344 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.0074462919999973565 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009730165999997098 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010948666000004437 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011124666000000616 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011276583000011442 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.006469042000006198 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.009891666999990889 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010416167000002474 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.035910791999995695 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 3.5845046020251647, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010586583999995014 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007262166999993269 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01254154199999391 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.262301299604511, Delay probability: 0.21212683069525057\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010822333999996658 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01018799999999942 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011359999999996262 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1353167255229482, Delay probability: 0.15362317783003085\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.007604958000001716 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.1546549809005582, Delay probability: 0.19059030028256213\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012101541000006932 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2119546622599162, Delay probability: 0.2672640572327181\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010868874999999889 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012123750000000655 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2071660735640684, Delay probability: 0.14522852731264677\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011626875000004588 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.157692054156099, Delay probability: 0.21212683069525057\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.008129708999987884 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2343275255571415, Delay probability: 0.24255070001316215\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.015464417000004005 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.5407957129639682, Delay probability: 0.3172827755903742\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011209042000004388 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.01095458400000382 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00973195800000326 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.00897650000000283 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.3622825893205066, Delay probability: 0.29031687843932275\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.011002417000000264 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.012095250000001556 seconds\n", + "Run type OpenCL_Apple M1 Pro was delayed in the previous run. Delay factor: 1.2048893808895609, Delay probability: 0.21212683069525048\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010946042000000489 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using OpenCL_Apple M1 Pro ran in 0.010915374999996175 seconds\n", + "Agent: eSRRF_3D using Threaded ran in 5.559033249999999 seconds\n" + ] + } + ], + "source": [ + "esrrf = eSRRF3D()\n", + "# int_img, grad_r_int, grad_c_int, grad_s_int = esrrf.run(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type)\n", + "# int_img = esrrf.run(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type)\n", + "\n", + "# rgc_img = esrrf.run(img, magnification_xy=2, magnification_z=2, radius=3, sensitivity=2, run_type=\"Threaded\", doIntensityWeighting=True)\n", + "\n", + "# rgc_img = run_esrrf3d(img, magnification_xy=2, magnification_z=2, radius=3, sensitivity=2, run_type=\"Threaded\", correlation=\"AVG\", framewindow=0, rollingoverlap=1)\n", + "rgc_img = run_esrrf3d(img4ana, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "# grad_s_int[:,:]" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "# stackview.slice(grad_s_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(9, 5, 50, 50)" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rgc_img.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "from tifffile import imwrite\n", + "\n", + "rgc_img_fiji = rgc_img.squeeze()\n", + "imwrite('/Users/avesga/Desktop/3DeSRRF/test/' + name_save + '.tif', rgc_img_fiji)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "# From https://imagej.net/plugins/trackmate/scripting/scripting\n", + "# they claim that the default order of the hyperstacks in ImageJ is XYCZT\n", + "\n", + "# The RGC has dimensions (T, Z, X, Y)\n", + "# Found that, to use imwrite('image.tif', rgc_img_fiji, imagej=True), the dimensions have to be (T, Z, C, X, Y)\n", + "\n", + "rgc_img.shape\n", + "\n", + "rgc_img_fiji = np.expand_dims(rgc_img, axis=4)\n", + "rgc_img_fiji = np.transpose(rgc_img_fiji, (0, 1, 4, 2, 3))\n", + "\n", + "# rgc_img_fiji = np.transpose(rgc_img, (0, 1, 3, 2))\n", + "# rgc_img_fiji = rgc_img\n", + "# save the 4D array as a tiff file\n", + "\n", + "from tifffile import imwrite\n", + "\n", + "# # write OME-TIFF\n", + "# imwrite('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img)\n", + "\n", + "# write ImageJ hyperstack\n", + "imwrite('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img_fiji, imagej=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "ename": "NotImplementedError", + "evalue": "Only 2D images are supported(5, 50, 50)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNotImplementedError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[45], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m rgc_img\u001b[38;5;241m.\u001b[39mshape\n\u001b[0;32m----> 2\u001b[0m \u001b[43mstackview\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mslice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrgc_img\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice.py:53\u001b[0m, in \u001b[0;36mslice\u001b[0;34m(image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 50\u001b[0m image \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mget()\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mipywidgets\u001b[39;00m\n\u001b[0;32m---> 53\u001b[0m viewer \u001b[38;5;241m=\u001b[39m \u001b[43m_SliceViewer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43mslice_number\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_width\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 57\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_height\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 58\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontinuous_update\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[43m \u001b[49m\u001b[43mslider_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 61\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_spline_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_spline_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 62\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolormap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolormap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 63\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_min\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_min\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 64\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_max\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m view \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mview\n\u001b[1;32m 67\u001b[0m slice_slider \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mslice_slider\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice_viewer.py:30\u001b[0m, in \u001b[0;36m_SliceViewer.__init__\u001b[0;34m(self, image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 29\u001b[0m sliced_image \u001b[38;5;241m=\u001b[39m image\n\u001b[0;32m---> 30\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mview \u001b[38;5;241m=\u001b[39m \u001b[43mImageWidget\u001b[49m\u001b[43m(\u001b[49m\u001b[43msliced_image\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 31\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 32\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_spline_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_spline_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 33\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolormap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolormap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 34\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_min\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_min\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_max\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 37\u001b[0m \u001b[38;5;66;03m# setup user interface for changing the slice\u001b[39;00m\n\u001b[1;32m 38\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mslice_slider \u001b[38;5;241m=\u001b[39m ipywidgets\u001b[38;5;241m.\u001b[39mIntSlider(\n\u001b[1;32m 39\u001b[0m value\u001b[38;5;241m=\u001b[39mslice_number,\n\u001b[1;32m 40\u001b[0m \u001b[38;5;28mmin\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 43\u001b[0m description\u001b[38;5;241m=\u001b[39mslider_text,\n\u001b[1;32m 44\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_image_widget.py:8\u001b[0m, in \u001b[0;36mImageWidget.__init__\u001b[0;34m(self, image, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, image, zoom_factor:\u001b[38;5;28mfloat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0\u001b[39m, zoom_spline_order:\u001b[38;5;28mint\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m, colormap:\u001b[38;5;28mstr\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, display_min:\u001b[38;5;28mfloat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, display_max:\u001b[38;5;28mfloat\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m ((\u001b[38;5;28mlen\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\u001b[38;5;28mlen\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;129;01min\u001b[39;00m [\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m] \u001b[38;5;129;01mand\u001b[39;00m image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m3\u001b[39m)):\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOnly 2D images are supported\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape))\n\u001b[1;32m 9\u001b[0m height \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m*\u001b[39m zoom_factor\n\u001b[1;32m 10\u001b[0m width \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m] \u001b[38;5;241m*\u001b[39m zoom_factor\n", + "\u001b[0;31mNotImplementedError\u001b[0m: Only 2D images are supported(5, 50, 50)" + ] + } + ], + "source": [ + "rgc_img.shape\n", + "stackview.slice(rgc_img)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gradients not yet calculated\n" + ] + } + ], + "source": [ + "esrrf.get_gradients()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'grad_r_int' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[24], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m stackview\u001b[38;5;241m.\u001b[39mslice(\u001b[43mgrad_r_int\u001b[49m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'grad_r_int' is not defined" + ] + } + ], + "source": [ + "stackview.slice(grad_r_int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b6b3bdb0b12448b28fb86947d3decfce", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=342, width=342),)),)), IntSlider(value=4, desc…" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(grad_c_int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4bba6b7200944fba8da756cca12ea824", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=342, width=342),)),)), IntSlider(value=4, desc…" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(grad_s_int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(9, 342, 342)" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grad_r_int.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(9, 171, 171)" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "int_img.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rgc_img\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "cannot do a non-empty take from an empty axes.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mstackview\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mslice\u001b[49m\u001b[43m(\u001b[49m\u001b[43mA\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# # save rgc_img[0] as tiff\u001b[39;00m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# from tifffile import imsave\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# imsave('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img[0])\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice.py:53\u001b[0m, in \u001b[0;36mslice\u001b[0;34m(image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 50\u001b[0m image \u001b[38;5;241m=\u001b[39m image\u001b[38;5;241m.\u001b[39mget()\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mipywidgets\u001b[39;00m\n\u001b[0;32m---> 53\u001b[0m viewer \u001b[38;5;241m=\u001b[39m \u001b[43m_SliceViewer\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[43m \u001b[49m\u001b[43mslice_number\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_width\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 57\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_height\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 58\u001b[0m \u001b[43m \u001b[49m\u001b[43mcontinuous_update\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 59\u001b[0m \u001b[43m \u001b[49m\u001b[43mslider_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_factor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_factor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 61\u001b[0m \u001b[43m \u001b[49m\u001b[43mzoom_spline_order\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mzoom_spline_order\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 62\u001b[0m \u001b[43m \u001b[49m\u001b[43mcolormap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcolormap\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 63\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_min\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_min\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 64\u001b[0m \u001b[43m \u001b[49m\u001b[43mdisplay_max\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdisplay_max\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m view \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mview\n\u001b[1;32m 67\u001b[0m slice_slider \u001b[38;5;241m=\u001b[39m viewer\u001b[38;5;241m.\u001b[39mslice_slider\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/stackview/_slice_viewer.py:27\u001b[0m, in \u001b[0;36m_SliceViewer.__init__\u001b[0;34m(self, image, slice_number, axis, display_width, display_height, continuous_update, slider_text, zoom_factor, zoom_spline_order, colormap, display_min, display_max)\u001b[0m\n\u001b[1;32m 24\u001b[0m slice_number \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(image\u001b[38;5;241m.\u001b[39mshape[axis] \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m 26\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mimage\u001b[38;5;241m.\u001b[39mshape) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m2\u001b[39m: \u001b[38;5;66;03m# and self.image.shape[-1] != 3:\u001b[39;00m\n\u001b[0;32m---> 27\u001b[0m sliced_image \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtake\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mslice_number\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 28\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 29\u001b[0m sliced_image \u001b[38;5;241m=\u001b[39m image\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/numpy/core/fromnumeric.py:192\u001b[0m, in \u001b[0;36mtake\u001b[0;34m(a, indices, axis, out, mode)\u001b[0m\n\u001b[1;32m 95\u001b[0m \u001b[38;5;129m@array_function_dispatch\u001b[39m(_take_dispatcher)\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtake\u001b[39m(a, indices, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, out\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mraise\u001b[39m\u001b[38;5;124m'\u001b[39m):\n\u001b[1;32m 97\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 98\u001b[0m \u001b[38;5;124;03m Take elements from an array along an axis.\u001b[39;00m\n\u001b[1;32m 99\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 190\u001b[0m \u001b[38;5;124;03m [5, 7]])\u001b[39;00m\n\u001b[1;32m 191\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 192\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_wrapfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtake\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mindices\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/nanopyxdev/lib/python3.9/site-packages/numpy/core/fromnumeric.py:59\u001b[0m, in \u001b[0;36m_wrapfunc\u001b[0;34m(obj, method, *args, **kwds)\u001b[0m\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _wrapit(obj, method, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n\u001b[1;32m 58\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 59\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mbound\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 61\u001b[0m \u001b[38;5;66;03m# A TypeError occurs if the object does have such a method in its\u001b[39;00m\n\u001b[1;32m 62\u001b[0m \u001b[38;5;66;03m# class, but its signature is not identical to that of NumPy's. This\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[38;5;66;03m# Call _wrapit from within the except clause to ensure a potential\u001b[39;00m\n\u001b[1;32m 67\u001b[0m \u001b[38;5;66;03m# exception has a traceback chain.\u001b[39;00m\n\u001b[1;32m 68\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m _wrapit(obj, method, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n", + "\u001b[0;31mIndexError\u001b[0m: cannot do a non-empty take from an empty axes." + ] + } + ], + "source": [ + "stackview.slice(A)\n", + "# # save rgc_img[0] as tiff\n", + "# from tifffile import imsave\n", + "# imsave('/Users/avesga/Desktop/rgc_img_0.tif', rgc_img[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "421ef57539b44747801395a886b68c99", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=171, width=171),)),)), IntSlider(value=4, desc…" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(np.mean(rgc_img, axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1b99a04beeaa4488bfadc2fbd5b184f7", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(VBox(children=(ImageWidget(height=171, width=171),)),)), IntSlider(value=4, desc…" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stackview.slice(int_img)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nanopyxdev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tests/test_3D_eSRRF/load_analyse.ipynb b/tests/test_3D_eSRRF/load_analyse.ipynb new file mode 100644 index 00000000..c613c9b4 --- /dev/null +++ b/tests/test_3D_eSRRF/load_analyse.ipynb @@ -0,0 +1,349 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# This script loads the images from /Users/avesga/Code/radialsym and analyzes them with eSRRF3D\n", + "# test version to have everything working, later on we will use an automatic python script\n", + "\n", + "# agv, 19Mar2023\n", + "\n", + "import os\n", + "\n", + "import matplotlib as mpl\n", + "import stackview\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from tifffile import imread\n", + "from nanopyx.methods.esrrf_3d.run import run_esrrf3d\n", + "\n", + "from scipy.signal import find_peaks\n", + "\n", + "from nanopyx.core.transform._le_esrrf3d import eSRRF3D" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.set_cmap(\"gray\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PLANES_num_planes_5_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\n", + "5 1.0\n" + ] + } + ], + "source": [ + "# set parameters\n", + "\n", + "path = \"/Users/avesga/Code/radialsym/simulations/PLANES_num_planes_5_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "path_full = \"/Users/avesga/Code/radialsym/simulations/FULL_distance_emitters_1_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "\n", + "# path = \"/Users/avesga/Code/radialsym/simulations_below_500nm/PLANES_num_planes_5_distance_planes_[3, 3, 2]_distance_emitters_0.4_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "# path_full = \"/Users/avesga/Code/radialsym/simulations_below_500nm/PLANES_num_planes_5_distance_planes_[3, 3, 2]_distance_emitters_0.4_px_size_0.02_int_f_3000_offset_200_int_noise_100.tiff\"\n", + "\n", + "# from the last part of the path, get the number of planes, the separation between planes, and the pixel size\n", + "last_part = os.path.basename(path).split('/')[-1]\n", + "print(last_part)\n", + "\n", + "num_planes = int(last_part.split('num_planes_')[1].split('_')[0])\n", + "distance_emitters = float(last_part.split('distance_emitters_')[1].split('_')[0])\n", + "\n", + "print(num_planes, distance_emitters)\n", + "\n", + "pixel_size = 0.120\n", + "separation_planes = 4" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Load file\n", + "\n", + "img = imread(path).astype(np.float32)\n", + "img_full = imread(path_full).astype(np.float32)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Define variables for eSRRF\n", + "\n", + "magnification_xy=2\n", + "magnification_z=2\n", + "radius=1\n", + "radius_z = 1\n", + "ratio_px = 4\n", + "sensitivity=1\n", + "run_type=\"Threaded\"\n", + "correlation=\"AVG\"\n", + "framewindow=0\n", + "rollingoverlap=2" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.002717999999999776 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Querying the Agent...\n", + "Agent: ShiftMagnify_CR using Threaded_guided ran in 0.0023541250000000957 seconds\n", + "Consider adding default arguments to the njit implementation to trigger early compilation\n", + "Unexpected error while trying to run Threaded\n", + "while scanning a simple key\n", + " in \"/Users/avesga/.nanopyx/liquid/_le_interpolation_catmull_rom.cpython-39-darwin/ShiftAndMagnify.yml\", line 1510, column 1\n", + "could not find expected ':'\n", + " in \"/Users/avesga/.nanopyx/liquid/_le_interpolation_catmull_rom.cpython-39-darwin/ShiftAndMagnify.yml\", line 1521, column 87\n", + "Please try again with another run type\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'NoneType' object has no attribute 'shape'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# esrrf3d\u001b[39;00m\n\u001b[1;32m 2\u001b[0m esrrf \u001b[38;5;241m=\u001b[39m eSRRF3D()\n\u001b[0;32m----> 4\u001b[0m rgc_img \u001b[38;5;241m=\u001b[39m \u001b[43mrun_esrrf3d\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmagnification_xy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmagnification_xy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmagnification_z\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmagnification_z\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mradius\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mradius_z\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mradius_z\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mratio_px\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mratio_px\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msensitivity\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msensitivity\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrun_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrun_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcorrelation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcorrelation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframewindow\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mframewindow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrollingoverlap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrollingoverlap\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6\u001b[0m rgc_img \u001b[38;5;241m=\u001b[39m rgc_img\u001b[38;5;241m.\u001b[39msqueeze()\n", + "File \u001b[0;32m~/Code/NanoPyx/src/nanopyx/methods/esrrf_3d/run.py:27\u001b[0m, in \u001b[0;36mrun_esrrf3d\u001b[0;34m(img, correlation, framewindow, rollingoverlap, **kwargs)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;124;03mCalculate the eSRRF3D temporal correlations for the given image.\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;124;03m The calculated eSRRF3D temporal correlations.\u001b[39;00m\n\u001b[1;32m 25\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 26\u001b[0m esrrf_calculator \u001b[38;5;241m=\u001b[39m eSRRF3D()\n\u001b[0;32m---> 27\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcalculate_eSRRF3d_temporal_correlations\u001b[49m\u001b[43m(\u001b[49m\u001b[43mesrrf_calculator\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcorrelation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcorrelation\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mframewindow\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mframewindow\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrollingoverlap\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrollingoverlap\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/Code/NanoPyx/src/nanopyx/core/transform/sr_temporal_correlations.py:225\u001b[0m, in \u001b[0;36mcalculate_eSRRF3d_temporal_correlations\u001b[0;34m(rgc_map, correlation, framewindow, rollingoverlap)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcalculate_eSRRF3d_temporal_correlations\u001b[39m(rgc_map, correlation: \u001b[38;5;28mstr\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAVG\u001b[39m\u001b[38;5;124m\"\u001b[39m, framewindow: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m, rollingoverlap: \u001b[38;5;28mfloat\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m):\n\u001b[1;32m 224\u001b[0m \u001b[38;5;66;03m# correlation (str): Type of correlation to calculate. Should be \"AVG\", \"VAR\", or \"TAC2\"\u001b[39;00m\n\u001b[0;32m--> 225\u001b[0m n_frames, n_slices, n_rows, n_cols \u001b[38;5;241m=\u001b[39m \u001b[43mrgc_map\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m[\u001b[38;5;241m0\u001b[39m], rgc_map\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m], rgc_map\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m2\u001b[39m], rgc_map\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m3\u001b[39m]\n\u001b[1;32m 227\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m n_frames \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 228\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mOnly one frame, no temporal correlations can be calculated\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'shape'" + ] + } + ], + "source": [ + "# esrrf3d\n", + "esrrf = eSRRF3D()\n", + "\n", + "rgc_img = run_esrrf3d(img, magnification_xy=magnification_xy, magnification_z=magnification_z, radius=radius, radius_z =radius_z, ratio_px = ratio_px, sensitivity=sensitivity, run_type=run_type, correlation=correlation, framewindow=framewindow, rollingoverlap=rollingoverlap)\n", + "\n", + "rgc_img = rgc_img.squeeze()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'XZ intensity at the center')" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 4, figsize=(12, 3))\n", + "\n", + "ax[0].matshow(img[img.shape[0]//2, :, : ])\n", + "ax[1].plot(img[img.shape[0]//2, img.shape[1]//2, : ])\n", + "ax[2].matshow(img[:,:, img.shape[2]//2])\n", + "ax[3].plot(img[:,img.shape[1]//2, img.shape[2]//2])\n", + "\n", + "ax[0].set_title(\"XY subsampled PSF\")\n", + "ax[1].set_title(\"XY intensity at the center\")\n", + "ax[2].set_title(\"XZ subsampled PSF\")\n", + "ax[3].set_title(\"XZ intensity at the center\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def render_z(rgc_img, separation_planes, magnification_z):\n", + "\n", + " z_section = np.zeros((rgc_img.shape[1], rgc_img.shape[1], rgc_img.shape[1]))\n", + "\n", + " num_planes = rgc_img.shape[0] // magnification_z\n", + "\n", + " if num_planes % 2 == 1:\n", + " planes = np.arange(num_planes) * separation_planes * magnification_z\n", + " planes = planes + (rgc_img.shape[1]//2 - planes[planes.shape[0]//2])\n", + " else:\n", + " # check if separation_planes is even\n", + " if separation_planes % 2 == 0:\n", + " planes = np.arange(num_planes) * separation_planes * magnification_z\n", + " planes = planes + (rgc_img.shape[1]//2 - planes[planes.shape[0]//2]) + 1*magnification_z*separation_planes\n", + " else:\n", + " # print a warning, saying that the planes are not evenly distributed\n", + " print(\"Warning: the planes are not evenly distributed. Use even separation for even number of planes.\")\n", + "\n", + " # TODO: check the shift of the planes, is almost perfect, but maybe not\n", + "\n", + " for p in range(num_planes):\n", + " for m in range(magnification_z):\n", + " z_section[planes[p]-m, :, :] = rgc_img[p*magnification_z+m, :, :]\n", + "\n", + " return z_section" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "separation_planes = 4\n", + "\n", + "rgc_img_Z = render_z(rgc_img, separation_planes, magnification_z)\n", + "img_Z = render_z(img, separation_planes, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2.04]\n", + "[]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the profiles\n", + "\n", + "fig, ax = plt.subplots(2, 4, figsize=(12, 9))\n", + "\n", + "gam = 0.3\n", + "\n", + "ax[0,0].matshow(rgc_img[rgc_img.shape[0]//2, :, : ], norm=mpl.colors.PowerNorm(gam))\n", + "ax[0,0].axhline(rgc_img.shape[1]//2, color='blue', linewidth=4, alpha=0.5)\n", + "\n", + "ax[0,1].plot(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ])\n", + "\n", + "ax[0,2].matshow(rgc_img[:,:, rgc_img.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "ax[0,2].axvline(rgc_img.shape[2]//2, color='blue', linewidth=4, alpha=0.5)\n", + "\n", + "ax[0,3].plot(rgc_img[:,rgc_img.shape[1]//2, rgc_img.shape[2]//2])\n", + "\n", + "ax[1,0].matshow(rgc_img_Z[:,:, rgc_img_Z.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "\n", + "ax[1,1].matshow(img_Z[:,:, img_Z.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "\n", + "ax[1,2].matshow(img_full[:,:, img_full.shape[2]//2], norm=mpl.colors.PowerNorm(gam))\n", + "ax[1,3].plot(img_full[:,img_full.shape[1]//2, img_full.shape[2]//2])\n", + "\n", + "ax[0,0].set_title(\"XY subsampled PSF\")\n", + "\n", + "ax[0,2].set_title(\"eSRRF XZ \\n subsampled PSF \\n (squeezed)\")\n", + "\n", + "ax[1,0].set_title(\"eSRRF XZ subsampled \\n right dimensions PSF\")\n", + "ax[1,1].set_title(\"Raw XZ subsampled \\n right dimensions PSF\")\n", + "ax[1,2].set_title(\"Full Raw XZ subsampled \\n right dimensions PSF\")\n", + "ax[1,3].set_title(\"Full Raw XZ intensity \\n at the center\")\n", + "\n", + "# get the distance between peaks in the first plot\n", + "peaks_indices_XY, _ = find_peaks(rgc_img[rgc_img.shape[0]//2, rgc_img.shape[1]//2, : ], height=0.5*rgc_img[rgc_img.shape[0]//2, :].max())\n", + "print((peaks_indices_XY[1:] - peaks_indices_XY[:-1])*pixel_size/magnification_xy)\n", + "\n", + "# get the distance between peaks in the second plot\n", + "peaks_indices_XZ, _ = find_peaks(rgc_img[:,rgc_img.shape[1]//2, rgc_img.shape[2]//2], height=0.1*rgc_img[:, :].max())\n", + "print((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z)\n", + "\n", + "# write the distance between peaks the second and forth plot\n", + "ax[0,1].set_title(\"Full Raw XZ subsampled \\n right dimensions PSF \\n (Peaks distance: {}um)\".format((peaks_indices_XY[1:] - peaks_indices_XY[:-1]) * pixel_size/magnification_z))\n", + "ax[0,3].set_title(\"Full Raw XZ intensity \\n at the center \\n (Peaks distance: {}um)\".format((peaks_indices_XZ[1:] - peaks_indices_XZ[:-1]) * pixel_size*separation_planes/magnification_z))\n", + "\n", + "\n", + "# elliminate ticks\n", + "for a in ax:\n", + " for b in a:\n", + " b.set_xticks([])\n", + " b.set_yticks([])\n", + "\n", + "fig.tight_layout()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nanopyxdev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}