nabu 2024.1.0rc3__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/tests/test_tilt.py

@@ -0,0 +1,41 @@
+import pytest
+import numpy as np
+from nabu.estimation.tilt import CameraTilt
+from nabu.estimation.tests.test_cor import bootstrap_cor
+
+try:
+    import skimage.transform as skt  # noqa: F401
+
+    __have_skimage__ = True
+except ImportError:
+    __have_skimage__ = False
+
+
+@pytest.mark.usefixtures("bootstrap_cor")
+class TestCameraTilt:
+    def test_1dcorrelation(self):
+        radio1 = self.data[0, :, :]
+        radio2 = np.fliplr(self.data[1, :, :])
+
+        tilt_calc = CameraTilt()
+        cor_position, camera_tilt = tilt_calc.compute_angle(radio1, radio2)
+
+        message = "Computed tilt %f " % camera_tilt + " and real tilt %f do not coincide" % self.tilt_deg
+        assert np.isclose(self.tilt_deg, camera_tilt, atol=self.abs_tol), message
+
+        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_hl_pix
+        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message
+
+    @pytest.mark.skipif(not (__have_skimage__), reason="need scikit-image for this test")
+    def test_fftpolar(self):
+        radio1 = self.data[0, :, :]
+        radio2 = np.fliplr(self.data[1, :, :])
+
+        tilt_calc = CameraTilt()
+        cor_position, camera_tilt = tilt_calc.compute_angle(radio1, radio2, method="fft-polar")
+
+        message = "Computed tilt %f " % camera_tilt + " and real tilt %f do not coincide" % self.tilt_deg
+        assert np.isclose(self.tilt_deg, camera_tilt, atol=self.abs_tol), message
+
+        message = "Computed CoR %f " % cor_position + " and real CoR %f do not coincide" % self.cor_hl_pix
+        assert np.isclose(self.cor_gl_pix, cor_position, atol=self.abs_tol), message

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/tests/test_translation.py

@@ -0,0 +1,78 @@
+import os
+import numpy as np
+import pytest
+import h5py
+from nabu.testutils import utilstest
+from nabu.estimation.translation import DetectorTranslationAlongBeam
+import scipy.ndimage
+
+
+def get_alignxc_data(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    with h5py.File(dataset_downloaded_path, "r") as hf:
+        data = hf["/entry/instrument/detector/data"][()]
+        img_pos = hf["/entry/instrument/detector/distance"][()]
+
+        unit_length_shifts_vh = [
+            hf["/calibration/alignxc/y_pixel_shift_unit"][()],
+            hf["/calibration/alignxc/x_pixel_shift_unit"][()],
+        ]
+        all_shifts_vh = hf["/calibration/alignxc/yx_pixel_offsets"][()]
+
+    return data, img_pos, (unit_length_shifts_vh, all_shifts_vh)
+
+
+@pytest.fixture(scope="class")
+def bootstrap_dtr(request):
+    cls = request.cls
+    cls.abs_tol = 1e-1
+    cls.data, cls.img_pos, calib_data = get_alignxc_data("test_alignment_alignxc.h5")
+    cls.expected_shifts_vh, cls.all_shifts_vh = calib_data
+
+
+@pytest.mark.usefixtures("bootstrap_dtr")
+class TestDetectorTranslation:
+    def test_alignxc(self):
+        T_calc = DetectorTranslationAlongBeam()
+
+        shifts_v, shifts_h, found_shifts_list = T_calc.find_shift(self.data, self.img_pos, return_shifts=True)
+
+        message = "Computed shifts coefficients %s and expected %s do not coincide" % (
+            (shifts_v, shifts_h),
+            self.expected_shifts_vh,
+        )
+        assert np.all(np.isclose(self.expected_shifts_vh, [shifts_v, shifts_h], atol=self.abs_tol)), message
+
+        message = "Computed shifts %s and expected %s do not coincide" % (
+            found_shifts_list,
+            self.all_shifts_vh,
+        )
+        assert np.all(np.isclose(found_shifts_list, self.all_shifts_vh, atol=self.abs_tol)), message
+
+    def test_alignxc_synth(self):
+        T_calc = DetectorTranslationAlongBeam()
+
+        stack = np.zeros([4, 512, 512], "d")
+        for i in range(4):
+            stack[i, 200 - i * 10, 200 - i * 10] = 1
+        stack = scipy.ndimage.gaussian_filter(stack, [0, 10, 10.0]) * 100
+        x, y = np.meshgrid(np.arange(stack.shape[-1]), np.arange(stack.shape[-2]))
+        for i in range(4):
+            xc = x - (250 + i * 1.234)
+            yc = y - (250 + i * 1.234 * 2)
+            stack[i] += np.exp(-(xc * xc + yc * yc) * 0.5)
+        shifts_v, shifts_h, found_shifts_list = T_calc.find_shift(
+            stack, np.array([0.0, 1, 2, 3]), high_pass=1.0, return_shifts=True
+        )
+
+        message = "Found shifts per units %s and reference %s do not coincide" % (
+            (shifts_v, shifts_h),
+            (-1.234 * 2, -1.234),
+        )
+        assert np.all(np.isclose((shifts_v, shifts_h), (-1.234 * 2, -1.234), atol=self.abs_tol)), message

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/tilt.py

@@ -0,0 +1,214 @@
+import numpy as np
+from numpy.polynomial.polynomial import Polynomial, polyval
+from .alignment import medfilt2d, plt
+from .cor import CenterOfRotation
+
+try:
+    import skimage.transform as skt
+
+    __have_skimage__ = True
+except ImportError:
+    __have_skimage__ = False
+
+
+class CameraTilt(CenterOfRotation):
+    def compute_angle(
+        self,
+        img_1: np.ndarray,
+        img_2: np.ndarray,
+        method="1d-correlation",
+        roi_yxhw=None,
+        median_filt_shape=None,
+        padding_mode=None,
+        peak_fit_radius=1,
+        high_pass=None,
+        low_pass=None,
+    ):
+        """Find the camera tilt, given two opposite images.
+
+        This method finds the tilt between the camera pixel columns and the
+        rotation axis, by performing a 1-dimensional correlation between two
+        opposite images.
+
+        The output of this function, allows to compute motor movements for
+        aligning the camera tilt.
+
+        Parameters
+        ----------
+        img_1: numpy.ndarray
+            First image
+        img_2: numpy.ndarray
+            Second image, it needs to have been flipped already (e.g. using numpy.fliplr).
+        method: str
+            Tilt angle computation method. Default is "1d-correlation" (traditional).
+            All options are:
+              - "1d-correlation": fastest, but works best for small tilts
+              - "fft-polar": slower, but works well on all ranges of tilts
+        roi_yxhw: (2, ) or (4, ) numpy.ndarray, tuple, or array, optional
+            4 elements vector containing: vertical and horizontal coordinates
+            of first pixel, plus height and width of the Region of Interest (RoI).
+            Or a 2 elements vector containing: plus height and width of the
+            centered Region of Interest (RoI).
+            Default is None -> deactivated.
+        median_filt_shape: (2, ) numpy.ndarray, tuple, or array, optional
+            Shape of the median filter window. Default is None -> deactivated.
+        padding_mode: str in numpy.pad's mode list, optional
+            Padding mode, which determines the type of convolution. If None or
+            'wrap' are passed, this resorts to the traditional circular convolution.
+            If 'edge' or 'constant' are passed, it results in a linear convolution.
+            Default is the circular convolution.
+            All options are:
+                None | 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean'
+                | 'median' | 'minimum' | 'reflect' | 'symmetric' |'wrap'
+        peak_fit_radius: int, optional
+            Radius size around the max correlation pixel, for sub-pixel fitting.
+            Minimum and default value is 1.
+        low_pass: float or sequence of two floats
+            Low-pass filter properties, as described in `nabu.misc.fourier_filters`
+        high_pass: float or sequence of two floats
+            High-pass filter properties, as described in `nabu.misc.fourier_filters`
+
+        Raises
+        ------
+        ValueError
+            In case images are not 2-dimensional or have different sizes.
+
+        Returns
+        -------
+        cor_offset_pix: float
+            Estimated center of rotation position from the center of the RoI in pixels.
+        tilt_deg: float
+            Estimated camera tilt angle in degrees.
+
+        Examples
+        --------
+        The following code computes the center of rotation position for two
+        given images in a tomography scan, where the second image is taken at
+        180 degrees from the first.
+
+        >>> radio1 = data[0, :, :]
+        ... radio2 = np.fliplr(data[1, :, :])
+        ... tilt_calc = CameraTilt()
+        ... cor_offset, camera_tilt = tilt_calc.compute_angle(radio1, radio2)
+
+        Or for noisy images:
+
+        >>> cor_offset, camera_tilt = tilt_calc.compute_angle(radio1, radio2, median_filt_shape=(3, 3))
+        """
+        self._check_img_pair_sizes(img_1, img_2)
+
+        if peak_fit_radius < 1:
+            self.logger.warning("Parameter peak_fit_radius should be at least 1, given: %d instead." % peak_fit_radius)
+            peak_fit_radius = 1
+
+        img_shape = img_2.shape
+        roi_yxhw = self._determine_roi(img_shape, roi_yxhw)
+
+        img_1 = self._prepare_image(img_1, roi_yxhw=roi_yxhw, median_filt_shape=median_filt_shape)
+        img_2 = self._prepare_image(img_2, roi_yxhw=roi_yxhw, median_filt_shape=median_filt_shape)
+
+        if method.lower() == "1d-correlation":
+            return self._compute_angle_1dcorrelation(
+                img_1, img_2, padding_mode, peak_fit_radius=peak_fit_radius, high_pass=high_pass, low_pass=low_pass
+            )
+        elif method.lower() == "fft-polar":
+            if not __have_skimage__:
+                raise ValueError(
+                    'Camera tilt calculation using "fft-polar" is only available with scikit-image.'
+                    " Please install the package to use this option."
+                )
+
+            return self._compute_angle_fftpolar(
+                img_1, img_2, padding_mode, peak_fit_radius=peak_fit_radius, high_pass=high_pass, low_pass=low_pass
+            )
+        else:
+            raise ValueError('Invalid method: %s. Valid options are: "1d-correlation" | "fft-polar"' % method)
+
+    def _compute_angle_1dcorrelation(
+        self, img_1: np.ndarray, img_2: np.ndarray, padding_mode=None, peak_fit_radius=1, high_pass=None, low_pass=None
+    ):
+        cc = self._compute_correlation_fft(
+            img_1, img_2, padding_mode, axes=(-1,), high_pass=high_pass, low_pass=low_pass
+        )
+
+        img_shape = img_2.shape
+        cc_h_coords = np.fft.fftfreq(img_shape[-1], 1 / img_shape[-1])
+
+        (f_vals, fh) = self.extract_peak_regions_1d(cc, peak_radius=peak_fit_radius, cc_coords=cc_h_coords)
+        fitted_shifts_h = self.refine_max_position_1d(f_vals, return_all_coeffs=True)
+        fitted_shifts_h += fh[1, :]
+
+        # Computing tilt
+        fitted_shifts_h = medfilt2d(fitted_shifts_h, kernel_size=3)
+
+        half_img_size = (img_shape[-2] - 1) / 2
+        cc_v_coords = np.linspace(-half_img_size, half_img_size, img_shape[-2])
+        coeffs_h = Polynomial.fit(cc_v_coords, fitted_shifts_h, deg=1).convert().coef
+
+        tilt_deg = np.rad2deg(-coeffs_h[1] / 2)
+        cor_offset_pix = coeffs_h[0] / 2
+
+        if self.verbose:
+            self.logger.info(
+                "Fitted center of rotation (pixels):",
+                cor_offset_pix,
+                "and camera tilt (degrees):",
+                tilt_deg,
+            )
+            f, ax = plt.subplots(1, 1)
+            self._add_plot_window(f, ax=ax)
+            ax.plot(cc_v_coords, fitted_shifts_h)
+            ax.plot(cc_v_coords, polyval(cc_v_coords, coeffs_h), "-C1")
+            ax.set_title("Correlation peaks")
+            plt.show(block=self.extra_options["blocking_plots"])
+
+        return cor_offset_pix, tilt_deg
+
+    def _compute_angle_fftpolar(
+        self, img_1: np.ndarray, img_2: np.ndarray, padding_mode=None, peak_fit_radius=1, high_pass=None, low_pass=None
+    ):
+        img_shape = img_2.shape
+
+        img_fft_1, img_fft_2, filt, _ = self._transform_to_fft(
+            img_1, img_2, padding_mode=padding_mode, axes=(-2, -1), low_pass=low_pass, high_pass=high_pass
+        )
+        if filt is not None:
+            img_fft_1 *= filt
+            img_fft_2 *= filt
+
+        # abs removes the translation component
+        img_fft_1 = np.abs(np.fft.fftshift(img_fft_1, axes=(-2, -1)))
+        img_fft_2 = np.abs(np.fft.fftshift(img_fft_2, axes=(-2, -1)))
+
+        # transform to polar coordinates
+        img_fft_1 = skt.warp_polar(img_fft_1, scaling="linear", output_shape=img_shape)
+        img_fft_2 = skt.warp_polar(img_fft_2, scaling="linear", output_shape=img_shape)
+
+        # only use half of the fft domain
+        img_fft_1 = img_fft_1[..., : img_fft_1.shape[-2] // 2, :]
+        img_fft_2 = img_fft_2[..., : img_fft_2.shape[-2] // 2, :]
+
+        tilt_pix = self.find_shift(img_fft_1, img_fft_2, shift_axis=-2)
+        tilt_deg = -(360 / img_shape[0]) * tilt_pix
+
+        img_1 = skt.rotate(img_1, tilt_deg)
+        img_2 = skt.rotate(img_2, -tilt_deg)
+
+        cor_offset_pix = self.find_shift(
+            img_1,
+            img_2,
+            padding_mode=padding_mode,
+            peak_fit_radius=peak_fit_radius,
+            high_pass=high_pass,
+            low_pass=low_pass,
+        )
+
+        if self.verbose:
+            print(
+                "Fitted center of rotation (pixels):",
+                cor_offset_pix,
+                "and camera tilt (degrees):",
+                tilt_deg,
+            )
+
+        return cor_offset_pix, tilt_deg

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/translation.py

@@ -0,0 +1,193 @@
+import numpy as np
+from numpy.polynomial.polynomial import Polynomial, polyval
+from .alignment import AlignmentBase, plt
+
+
+class DetectorTranslationAlongBeam(AlignmentBase):
+    def find_shift(
+        self,
+        img_stack: np.ndarray,
+        img_pos: np.array,
+        roi_yxhw=None,
+        median_filt_shape=None,
+        padding_mode=None,
+        peak_fit_radius=1,
+        high_pass=None,
+        low_pass=None,
+        return_shifts=False,
+        use_adjacent_imgs=False,
+    ):
+        """Find the vertical and horizontal shifts for translations of the
+        detector along the beam direction.
+
+        These shifts are in pixels-per-unit-translation, and they are due to
+        the misalignment of the translation stage, with respect to the beam
+        propagation direction.
+
+        To compute the vertical and horizontal tilt angles from the obtained `shift_pix`:
+
+        >>> tilt_deg = np.rad2deg(np.arctan(shift_pix * pixel_size))
+
+        where `pixel_size` and and the input parameter `img_pos` have to be
+        expressed in the same units.
+
+        Parameters
+        ----------
+        img_stack: numpy.ndarray
+            A stack of images (usually 4) at different distances
+        img_pos: numpy.ndarray
+            Position of the images along the translation axis
+        roi_yxhw: (2, ) or (4, ) numpy.ndarray, tuple, or array, optional
+            4 elements vector containing: vertical and horizontal coordinates
+            of first pixel, plus height and width of the Region of Interest (RoI).
+            Or a 2 elements vector containing: plus height and width of the
+            centered Region of Interest (RoI).
+            Default is None -> deactivated.
+        median_filt_shape: (2, ) numpy.ndarray, tuple, or array, optional
+            Shape of the median filter window. Default is None -> deactivated.
+        padding_mode: str in numpy.pad's mode list, optional
+            Padding mode, which determines the type of convolution. If None or
+            'wrap' are passed, this resorts to the traditional circular convolution.
+            If 'edge' or 'constant' are passed, it results in a linear convolution.
+            Default is the circular convolution.
+            All options are:
+                None | 'constant' | 'edge' | 'linear_ramp' | 'maximum' | 'mean'
+                | 'median' | 'minimum' | 'reflect' | 'symmetric' |'wrap'
+        peak_fit_radius: int, optional
+            Radius size around the max correlation pixel, for sub-pixel fitting.
+            Minimum and default value is 1.
+        low_pass: float or sequence of two floats
+            Low-pass filter properties, as described in `nabu.misc.fourier_filters`.
+        high_pass: float or sequence of two floats
+            High-pass filter properties, as described in `nabu.misc.fourier_filters`.
+        return_shifts: boolean, optional
+            Adds a third returned argument, containing the pixel shifts of each
+            image with respect to the first one in the stack. Defaults to False.
+        use_adjacent_imgs: boolean, optional
+            Compute correlation between adjacent images.
+            It can be used when dealing with large shifts, to avoid overflowing the shift.
+            This option allows to replicate the behavior of the reference function `alignxc.m`
+            However, it is detrimental to shift fitting accuracy. Defaults to False.
+
+        Returns
+        -------
+        coeff_v: float
+            Estimated vertical shift in pixel per unit-distance of the detector translation.
+        coeff_h: float
+            Estimated horizontal shift in pixel per unit-distance of the detector translation.
+        shifts_vh: list, optional
+            The pixel shifts of each image with respect to the first image in the stack.
+            Activated if return_shifts is True.
+
+        Examples
+        --------
+        The following example creates a stack of shifted images, and retrieves the computed shift.
+        Here we use a high-pass filter, due to the presence of some low-frequency noise component.
+
+        >>> import numpy as np
+        ... import scipy as sp
+        ... import scipy.ndimage
+        ... from nabu.preproc.alignment import  DetectorTranslationAlongBeam
+        ...
+        ... tr_calc = DetectorTranslationAlongBeam()
+        ...
+        ... stack = np.zeros([4, 512, 512])
+        ...
+        ... # Add low frequency spurious component
+        ... for i in range(4):
+        ...     stack[i, 200 - i * 10, 200 - i * 10] = 1
+        ... stack = sp.ndimage.filters.gaussian_filter(stack, [0, 10, 10.0]) * 100
+        ...
+        ... # Add the feature
+        ... x, y = np.meshgrid(np.arange(stack.shape[-1]), np.arange(stack.shape[-2]))
+        ... for i in range(4):
+        ...     xc = x - (250 + i * 1.234)
+        ...     yc = y - (250 + i * 1.234 * 2)
+        ...     stack[i] += np.exp(-(xc * xc + yc * yc) * 0.5)
+        ...
+        ... # Image translation along the beam
+        ... img_pos = np.arange(4)
+        ...
+        ... # Find the shifts from the features
+        ... shifts_v, shifts_h = tr_calc.find_shift(stack, img_pos, high_pass=1.0)
+        ... print(shifts_v, shifts_h)
+        >>> ( -2.47 , -1.236 )
+
+        and the following commands convert the shifts in angular tilts:
+
+        >>> tilt_v_deg = np.rad2deg(np.arctan(shifts_v * pixel_size))
+        >>> tilt_h_deg = np.rad2deg(np.arctan(shifts_h * pixel_size))
+
+        To enable the legacy behavior of `alignxc.m` (correlation between adjacent images):
+
+        >>> shifts_v, shifts_h = tr_calc.find_shift(stack, img_pos, use_adjacent_imgs=True)
+
+        To plot the correlation shifts and the fitted straight lines for both directions:
+
+        >>> tr_calc = DetectorTranslationAlongBeam(verbose=True)
+        ... shifts_v, shifts_h = tr_calc.find_shift(stack, img_pos)
+        """
+        self._check_img_stack_size(img_stack, img_pos)
+
+        if peak_fit_radius < 1:
+            self.logger.warning("Parameter peak_fit_radius should be at least 1, given: %d instead." % peak_fit_radius)
+            peak_fit_radius = 1
+
+        num_imgs = img_stack.shape[0]
+        img_shape = img_stack.shape[-2:]
+        roi_yxhw = self._determine_roi(img_shape, roi_yxhw)
+
+        img_stack = self._prepare_image(img_stack, roi_yxhw=roi_yxhw, median_filt_shape=median_filt_shape)
+
+        # do correlations
+        ccs = [
+            self._compute_correlation_fft(
+                img_stack[ii - 1 if use_adjacent_imgs else 0, ...],
+                img_stack[ii, ...],
+                padding_mode,
+                high_pass=high_pass,
+                low_pass=low_pass,
+            )
+            for ii in range(1, num_imgs)
+        ]
+
+        img_shape = img_stack.shape[-2:]
+        cc_vs = np.fft.fftfreq(img_shape[-2], 1 / img_shape[-2])
+        cc_hs = np.fft.fftfreq(img_shape[-1], 1 / img_shape[-1])
+
+        shifts_vh = np.zeros((num_imgs, 2))
+        for ii, cc in enumerate(ccs):
+            (f_vals, fv, fh) = self.extract_peak_region_2d(cc, peak_radius=peak_fit_radius, cc_vs=cc_vs, cc_hs=cc_hs)
+            shifts_vh[ii + 1, :] = self.refine_max_position_2d(f_vals, fv, fh)
+
+        if use_adjacent_imgs:
+            shifts_vh = np.cumsum(shifts_vh, axis=0)
+
+        # Polynomial.fit is supposed to be more numerically stable than polyfit
+        # (according to numpy)
+        coeffs_v = Polynomial.fit(img_pos, shifts_vh[:, 0], deg=1).convert().coef
+        coeffs_h = Polynomial.fit(img_pos, shifts_vh[:, 1], deg=1).convert().coef
+        # In some cases (singular matrix ?) the output is [0] while in some other its [eps, eps].
+        if len(coeffs_v) == 1:
+            coeffs_v = np.array([coeffs_v[0], coeffs_v[0]])
+        if len(coeffs_h) == 1:
+            coeffs_h = np.array([coeffs_h[0], coeffs_h[0]])
+
+        if self.verbose:
+            self.logger.info(
+                "Fitted pixel shifts per unit-length: vertical = %f, horizontal = %f" % (coeffs_v[1], coeffs_h[1])
+            )
+            f, axs = plt.subplots(1, 2)
+            self._add_plot_window(f, ax=axs)
+            axs[0].scatter(img_pos, shifts_vh[:, 0])
+            axs[0].plot(img_pos, polyval(img_pos, coeffs_v), "-C1")
+            axs[0].set_title("Vertical shifts")
+            axs[1].scatter(img_pos, shifts_vh[:, 1])
+            axs[1].plot(img_pos, polyval(img_pos, coeffs_h), "-C1")
+            axs[1].set_title("Horizontal shifts")
+            plt.show(block=False)
+
+        if return_shifts:
+            return coeffs_v[1], coeffs_h[1], shifts_vh
+        else:
+            return coeffs_v[1], coeffs_h[1]

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/estimation/utils.py

@@ -0,0 +1,39 @@
+import numpy as np
+from scipy.signal import find_peaks
+
+
+def is_fullturn_scan(angles):
+    """
+    Return True if the angles correspond to a full-turn (360 degrees) scan.
+    """
+    angles = angles % (2 * np.pi)
+    angles -= angles.min()
+    sin_angles = np.sin(angles)
+    min_dist = 5  # TODO find a more robust angles-based min distance, though this should cover most of the cases
+    maxima = find_peaks(sin_angles, distance=min_dist)[0]
+    minima = find_peaks(-sin_angles, distance=min_dist)[0]
+    n_max = maxima.size
+    n_min = minima.size
+    # abs(n_max - n_min) actually means the following:
+    #  * 0: All turns are full (eg. 2pi, 4pi)
+    #  * 1: At least one half-turn remains (eg. pi, 3pi)
+    if abs(n_max - n_min) == 0:
+        return True
+    else:
+        return False
+
+
+def get_halfturn_indices(angles):
+    angles = angles % (2 * np.pi)
+    angles -= angles.min()
+    sin_angles = np.sin(angles)
+    min_dist = 5  # TODO find a more robust angles-based min distance, though this should cover most of the cases
+    maxima = find_peaks(sin_angles, distance=min_dist)[0]
+    minima = find_peaks(-sin_angles, distance=min_dist)[0]
+    extrema = np.sort(np.hstack([maxima, minima]))
+    extrema -= extrema.min()
+    extrema = np.hstack([extrema, [angles.size - 1]])
+    res = []
+    for i in range(extrema.size - 1):
+        res.append((extrema[i], extrema[i + 1]))
+    return res

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/io/__init__.py

@@ -0,0 +1,2 @@
+from .reader import NPReader, EDFReader, HDF5File, HDF5Loader, ChunkReader, Readers
+from .writer import NXProcessWriter, TIFFWriter, EDFWriter, JP2Writer, NPYWriter, NPZWriter