nabu 2024.1.1__py3-none-any.whl → 2024.1.2__py3-none-any.whl

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

@@ -1,41 +0,0 @@
-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/build/lib/build/lib/nabu/estimation/tests/test_translation.py

@@ -1,78 +0,0 @@
-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/build/lib/build/lib/nabu/estimation/tilt.py

@@ -1,214 +0,0 @@
-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/build/lib/build/lib/nabu/estimation/translation.py

@@ -1,193 +0,0 @@
-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/build/lib/build/lib/nabu/estimation/utils.py

@@ -1,39 +0,0 @@
-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/build/lib/build/lib/nabu/io/__init__.py

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