nabu 2024.1.8__py3-none-any.whl → 2024.1.9__py3-none-any.whl

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.1.8"
+__version__ = "2024.1.9"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/pipeline/fullfield/chunked.py

@@ -577,9 +577,11 @@ class ChunkedPipeline:
                 sample_detector_dist,
                 angles=-options["angles"],
                 rot_center=options["rotation_axis_position"],
-                axis_correction=-options["axis_correction"],
+                axis_correction=(-options["axis_correction"] if options["axis_correction"] is not None else None),
                 pixel_size=1,
                 scale_factor=1.0 / options["voxel_size_cm"][0],
+                padding_mode=options["padding_type"],
+                slice_roi=self.process_config.rec_roi,
             )
 
         self._allocate_recs(*self.process_config.rec_shape, n_slices=n_slices)

nabu/pipeline/fullfield/computations.py

@@ -128,7 +128,13 @@ def estimate_required_memory(
         if process_config.rec_params["method"] == "cone":
             # In cone-beam reconstruction, need both sinograms and reconstruction inside GPU.
             # That's big!
-            total_memory_needed += 2 * data_volume_size
+            # Even more if padding is done at the nabu side.
+            if rec_config["padding_type"] == "zeros":
+                total_memory_needed += 2 * data_volume_size
+            else:
+                total_memory_needed += (
+                    data_volume_size + get_next_power(2 * Nx) * Na * Nz * 4 * 4
+                )  # no idea why the last *4 is necessary
 
     if debug:
         print(

nabu/reconstruction/cone.py

@@ -1,4 +1,5 @@
 import numpy as np
+from ..utils import calc_padding_lengths1D, nextpow2
 
 try:
     import astra
@@ -7,6 +8,7 @@ try:
 except ImportError:
     __have_astra__ = False
 from ..cuda.processing import CudaProcessing
+from ..processing.padding_cuda import CudaPadding
 
 
 class ConebeamReconstructor:
@@ -26,6 +28,8 @@ class ConebeamReconstructor:
         axis_correction=None,
         pixel_size=None,
         scale_factor=None,
+        padding_mode="zeros",
+        slice_roi=None,
         cuda_options=None,
     ):
         """
@@ -53,6 +57,8 @@ class ConebeamReconstructor:
         relative_z_position: float, optional
             Position of the central slice of the slab, with respect to the full stack of slices.
             By default it is set to zero, meaning that the current slab is assumed in the middle of the stack
+        axis_correction: array, optional
+            Array of the same size as the number of projections. Each corresponds to a horizontal displacement.
         pixel_size: float or tuple, optional
             Size of the pixel. Possible options:
               - Nothing is provided (default): in this case, all lengths are normalized with respect to the pixel size,
@@ -60,7 +66,18 @@ class ConebeamReconstructor:
               - A scalar number is provided: in this case it is the spacing between two pixels (in each dimension)
               - A tuple is provided: in this case it is the spacing between two pixels in both dimensions,
                 vertically then horizontally, i.e (detector_spacing_y, detector_spacing_x)
-
+        scale_factor: float, optional
+            Post-reconstruction scale factor.
+        padding_mode: str, optional
+            How to pad the data before applying FDK. By default this is done by astra with zero-padding.
+            If padding_mode is other than "zeros", it will be done by nabu and the padded data is passed to astra
+            where no additional padding is done.
+            Beware that in its current implementation, this option almost doubles the memory needed.
+        slice_roi:
+            Whether to reconstruct only a region of interest for each horizontal slice.
+            This parameter must be in the form (start_x, end_x, start_y, end_y) with no negative values.
+            Note that the current implementation just crops the final reconstructed volume,
+            i.e there is no speed or memory benefit.
 
         Notes
         ------
@@ -91,8 +108,9 @@ class ConebeamReconstructor:
         """
         self._init_cuda(cuda_options)
         self.scale_factor = scale_factor
+        self._set_sino_shape(sinos_shape)
+        self._init_padding(padding_mode)
         self._init_geometry(
-            sinos_shape,
             source_origin_dist,
             origin_detector_dist,
             pixel_size,
@@ -101,6 +119,7 @@ class ConebeamReconstructor:
             rot_center,
             relative_z_position,
             axis_correction,
+            slice_roi,
         )
         self._alg_id = None
         self._vol_id = None
@@ -116,6 +135,20 @@ class ConebeamReconstructor:
         self.sinos_shape = sinos_shape
         self.n_sinos, self.n_angles, self.prj_width = sinos_shape
 
+    def _init_padding(self, padding_mode):
+        self._pad_data = False
+        self.padding_mode = padding_mode
+        if padding_mode == "zeros":
+            return
+        self._pad_data = True
+        n_x = self.prj_width
+        x_pad_lens = calc_padding_lengths1D(n_x, nextpow2(n_x * 2))
+        self.padder = CudaPadding(
+            (self.n_angles, n_x), ((0, 0),) + (x_pad_lens,), mode=padding_mode, cuda_options={"ctx": self.cuda.ctx}
+        )
+        self._sinos_padded_shape = (self.n_sinos, self.n_angles, self.padder.padded_shape[-1])
+        self.prj_width = self.padder.padded_shape[-1]  # will impact translations
+
     def _set_pixel_size(self, pixel_size):
         if pixel_size is None:
             det_spacing_y = det_spacing_x = 1
@@ -127,9 +160,32 @@ class ConebeamReconstructor:
         self._det_spacing_y = det_spacing_y
         self._det_spacing_x = det_spacing_x
 
+    def _set_slice_roi(self, slice_roi):
+        self.slice_roi = slice_roi
+        self._vol_geom_n_x = self.n_x
+        self._vol_geom_n_y = self.n_y
+        self._crop_data = True
+        if slice_roi is None:
+            return
+        start_x, end_x, start_y, end_y = slice_roi
+        if roi_is_centered(self.volume_shape[1:], (slice(start_y, end_y), slice(start_x, end_x))):
+            # For FDK, astra can only reconstruct subregion centered around the origin
+            self._vol_geom_n_x = self.n_x - start_x * 2
+            self._vol_geom_n_y = self.n_y - start_y * 2
+        else:
+            # self._crop_data = True
+            # self._output_cropped_shape = (
+            #     self.n_z,
+            #     np.arange(self.n_y)[start_x:end_x].size,
+            #     np.arange(self.n_x)[start_y:end_y].size,
+            # )
+            raise NotImplementedError(
+                "Cone-beam geometry supports only slice_roi centered around origin (got slice_roi=%s with n_x=%d, n_y=%d)"
+                % (str(slice_roi), self.n_x, self.n_y)
+            )
+
     def _init_geometry(
         self,
-        sinos_shape,
         source_origin_dist,
         origin_detector_dist,
         pixel_size,
@@ -138,8 +194,8 @@ class ConebeamReconstructor:
         rot_center,
         relative_z_position,
         axis_correction,
+        slice_roi,
     ):
-        self._set_sino_shape(sinos_shape)
         if angles is None:
             self.angles = np.linspace(0, 2 * np.pi, self.n_angles, endpoint=True)
         else:
@@ -151,12 +207,13 @@ class ConebeamReconstructor:
         self.source_origin_dist = source_origin_dist
         self.origin_detector_dist = origin_detector_dist
         self.magnification = 1 + origin_detector_dist / source_origin_dist
-        self.vol_geom = astra.create_vol_geom(self.n_y, self.n_x, self.n_z)
+        self._set_slice_roi(slice_roi)
+        self.vol_geom = astra.create_vol_geom(self._vol_geom_n_y, self._vol_geom_n_x, self.n_z)
         self.vol_shape = astra.geom_size(self.vol_geom)
         self._cor_shift = 0.0
         self.rot_center = rot_center
         if rot_center is not None:
-            self._cor_shift = (self.prj_width - 1) / 2.0 - rot_center
+            self._cor_shift = (self.sinos_shape[-1] - 1) / 2.0 - rot_center
         self._set_pixel_size(pixel_size)
         self._axis_corrections = axis_correction
         self._create_astra_proj_geometry(relative_z_position)
@@ -200,7 +257,8 @@ class ConebeamReconstructor:
 
     def _set_output(self, volume):
         if volume is not None:
-            self.cuda.check_array(volume, self.vol_shape)
+            expected_shape = self.vol_shape  # if not (self._crop_data) else self._output_cropped_shape
+            self.cuda.check_array(volume, expected_shape)
             self.cuda.set_array("output", volume)
         if volume is None:
             self.cuda.allocate_array("output", self.vol_shape)
@@ -215,9 +273,16 @@ class ConebeamReconstructor:
         # TODO don't create new link/proj_id if ptr is the same ?
         # But it seems Astra modifies the input sinogram while doing FDK, so this might be not relevant
         d_sinos = self.cuda.get_array("sinos")
+
+        if self._pad_data:
+            sinos_padded = self.cuda.allocate_array("sinos_padded", self._sinos_padded_shape, dtype="f")
+            for i in range(self.n_sinos):
+                self.padder.pad(self.cuda.sinos[i], output=sinos_padded[i])
+            d_sinos = sinos_padded
+
         # self._proj_data_link = astra.data3d.GPULink(d_sinos.ptr, self.prj_width, self.n_angles, self.n_z, sinos.strides[-2])
         self._proj_data_link = astra.data3d.GPULink(
-            d_sinos.ptr, self.prj_width, self.n_angles, self.n_sinos, sinos.strides[-2]
+            d_sinos.ptr, self.prj_width, self.n_angles, self.n_sinos, d_sinos.strides[-2]
         )
         self._proj_id = astra.data3d.link("-sino", self.proj_geom, self._proj_data_link)
 
@@ -250,13 +315,33 @@ class ConebeamReconstructor:
             result = result.get()
         if self.scale_factor is not None:
             result *= np.float32(self.scale_factor)  # in-place for pycuda
+        # if self._crop_data:
+        #     self.cuda.allocate_array("output_cropped", self._output_cropped_shape, dtype=np.float32)
+        #     for i in range(self.n_z):
+        #         output
         self.cuda.recover_arrays_references(["sinos", "output"])
         return result
 
     def __del__(self):
-        if self._alg_id is not None:
+        if getattr(self, "_alg_id", None) is not None:
             astra.algorithm.delete(self._alg_id)
-        if self._vol_id is not None:
+        if getattr(self, "_vol_id", None) is not None:
             astra.data3d.delete(self._vol_id)
-        if self._proj_id is not None:
+        if getattr(self, "_proj_id", None) is not None:
             astra.data3d.delete(self._proj_id)
+
+
+def selection_is_centered(size, start, stop):
+    """
+    Return True if (start, stop) define a selection that is centered on the middle of the array.
+    """
+    if stop > 0:
+        stop -= size
+    return stop == -start
+
+
+def roi_is_centered(shape, slice_):
+    """
+    Return True if "slice_" define a selection that is centered on the middle of the array.
+    """
+    return all([selection_is_centered(shp, s.start, s.stop) for shp, s in zip(shape, slice_)])

nabu/reconstruction/tests/test_cone.py

@@ -281,7 +281,7 @@ class TestCone:
             # Reconstruct with horizontal shifts
             cone_reconstructor_with_correction = ConebeamReconstructor(
                 *reconstructor_args,
-                axis_corrections=shifts,
+                axis_correction=shifts,
                 **reconstructor_kwargs,
             )
 
@@ -297,9 +297,100 @@ class TestCone:
             # plt.legend([shift_type])
             # plt.show()
 
+    def test_padding_mode(self):
+        n_z = n_y = n_x = 256
+        n_a = 500
+        src_orig_dist = 1000
+        orig_det_dist = 50
+
+        volume, cone_data = generate_hollow_cube_cone_sinograms(
+            vol_shape=(n_z, n_y, n_x),
+            n_angles=n_a,
+            src_orig_dist=src_orig_dist,
+            orig_det_dist=orig_det_dist,
+            apply_filter=False,
+        )
+        reconstructor_args = [
+            cone_data.shape,
+            src_orig_dist,
+            orig_det_dist,
+        ]
+        reconstructor_kwargs = {
+            "volume_shape": volume.shape,
+            "cuda_options": {"ctx": self.ctx},
+        }
+        cone_reconstructor_zero_padding = ConebeamReconstructor(*reconstructor_args, **reconstructor_kwargs)
+        rec_z = cone_reconstructor_zero_padding.reconstruct(cone_data)
+
+        for padding_mode in ["edges"]:
+            cone_reconstructor = ConebeamReconstructor(
+                *reconstructor_args, padding_mode=padding_mode, **reconstructor_kwargs
+            )
+            rec = cone_reconstructor.reconstruct(cone_data)
+
+            metric = lambda img: np.max(np.abs(clip_circle(img, radius=int(0.85 * 128))))
+            error_profile = np.array([metric(rec[i] - rec_z[i]) for i in range(n_z)])
+            assert error_profile.max() < 3e-2, "Max error for padding=%s is too high" % padding_mode
+
+            # import matplotlib.pyplot as plt
+            # plt.figure()
+            # plt.plot(np.arange(n_z), error_profile)
+            # plt.legend([padding_mode])
+            # plt.show()
+
+    def test_roi(self):
+        n_z = n_y = n_x = 256
+        n_a = 500
+        src_orig_dist = 1000
+        orig_det_dist = 50
+
+        volume, cone_data = generate_hollow_cube_cone_sinograms(
+            vol_shape=(n_z, n_y, n_x),
+            n_angles=n_a,
+            src_orig_dist=src_orig_dist,
+            orig_det_dist=orig_det_dist,
+            apply_filter=False,
+            rot_center_shift=10,
+        )
+
+        reconstructor_args = [
+            cone_data.shape,
+            src_orig_dist,
+            orig_det_dist,
+        ]
+        reconstructor_kwargs = {
+            "volume_shape": volume.shape,
+            "rot_center": (n_x - 1) / 2 + 10,
+            "cuda_options": {"ctx": self.ctx},
+        }
+        cone_reconstructor_full = ConebeamReconstructor(*reconstructor_args, **reconstructor_kwargs)
+        ref = cone_reconstructor_full.reconstruct(cone_data)
+
+        # roi is in the form (start_x, end_x, start_y, end_y)
+        for roi in ((20, -20, 10, -10), (0, n_x, 0, n_y), (15, -15, 15, -15)):
+            # convert negative indices
+            start_x, end_x, start_y, end_y = roi
+            if start_y < 0:
+                start_y += n_y
+            if start_x < 0:
+                start_x += n_x
+
+            cone_reconstructor = ConebeamReconstructor(*reconstructor_args, slice_roi=roi, **reconstructor_kwargs)
+            rec = cone_reconstructor.reconstruct(cone_data)
+
+            assert np.allclose(rec, ref[:, roi[2] : roi[3], roi[0] : roi[1]]), "Something wrong with roi=%s" % (
+                str(roi)
+            )
+
 
 def generate_hollow_cube_cone_sinograms(
-    vol_shape, n_angles, src_orig_dist, orig_det_dist, prj_width=None, apply_filter=True
+    vol_shape,
+    n_angles,
+    src_orig_dist,
+    orig_det_dist,
+    prj_width=None,
+    apply_filter=True,
+    rot_center_shift=None,
 ):
     # Adapted from Astra toolbox python samples
 
@@ -311,6 +402,8 @@ def generate_hollow_cube_cone_sinograms(
     angles = np.linspace(0, 2 * np.pi, n_angles, True)
 
     proj_geom = astra.create_proj_geom("cone", 1.0, 1.0, prj_width, prj_width, angles, src_orig_dist, orig_det_dist)
+    if rot_center_shift is not None:
+        proj_geom = astra.geom_postalignment(proj_geom, (-rot_center_shift, 0))
     magnification = 1 + orig_det_dist / src_orig_dist
 
     # hollow cube

nabu/stitching/overlap.py

@@ -301,7 +301,7 @@ def check_overlaps(frames: Union[tuple, numpy.ndarray], positions: tuple, axis:
         if raise_error:
             raise ValueError(error_msg)
         else:
-            _logger.error(raise_error)
+            _logger.error(error_msg)
 
     # convert each frame to appropriate bounding box according to the axis
     def convert_to_bb(frame: numpy.ndarray, position: tuple, axis: int):

{nabu-2024.1.8.dist-info → nabu-2024.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.8
+Version: 2024.1.9
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>

{nabu-2024.1.8.dist-info → nabu-2024.1.9.dist-info}/RECORD

@@ -1,8 +1,7 @@
 doc/conf.py,sha256=3xtCarCHrXPr50GbeRDuH-o3Jzojw7mpr7vpGfZPLAE,3787
 doc/create_conf_doc.py,sha256=IVOdP70KvbW9WS_UQu3Iyd0YfS60E2fJ5IDtQ_s4cDw,1143
-doc/doc_config.py,sha256=anqeOVjqE2e7eVzg7yuh9dvIneTkrA5doGl1cVBqT7Q,730
 doc/get_mathjax.py,sha256=VIvKRCdDuF2VoY8JD3mSey9XX13AZMmwTJBHdt1tUs4,1012
-nabu/__init__.py,sha256=DO4fHjlr5q2r3IDpkSpuzsOIMuHK5R3I2w91UQaUEdY,270
+nabu/__init__.py,sha256=hocwYzVbHilZVlwb2HfL232A1uxBLouRbjQWv0nq_Ng,270
 nabu/tests.py,sha256=cew9OY2uTyncHI_HM32W8CP6B1GTGKaOW65XtMEqs7o,1417
 nabu/testutils.py,sha256=qqtGgkIhpOpXhgeoXlqCb91Rx-JlI4ALaDF6nt8YRRk,13298
 nabu/utils.py,sha256=w-xfRb6TFQpS-tao6nlvfmr962pmeec-WH1GltSUCrk,23767
@@ -32,6 +31,7 @@ nabu/app/shrink_dataset.py,sha256=P9dorO0Q-gPAWgSHyZi3XQp4jkMTJacDYzNvJY4oh98,35
 nabu/app/stitching.py,sha256=Ibp1oVokLVMz-VX762j1C0E88Di0YJvRt-b8NjGoe7g,3310
 nabu/app/utils.py,sha256=XUBRWDmth4i3BZHd27rfarFAUP7OEcsMeVmDJ6T4EXA,1178
 nabu/app/validator.py,sha256=IR-DcUV5h1Fc5CChBfBIaglrGpfKNICX7tGirAroMiw,3368
+nabu/app/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/app/tests/test_reduce_dark_flat.py,sha256=T-_zyzD0-f2c5Z-tlzmRF5p3vPtyL2RFb-D5fIYYEoM,2641
 nabu/cuda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/cuda/convolution.py,sha256=n8KsJ7IZdPOs_K5QZC6qblnOvIKYwxtdt03oNa0GiMU,241
@@ -136,9 +136,9 @@ nabu/pipeline/processconfig.py,sha256=O0phgvfWtL9bg3_GE3cw9MZXS8PUy8z2rzhpoqP9U8
 nabu/pipeline/utils.py,sha256=NONAgBfTfUYvBNfoTqD33MAYaPZyCJL10SnR6B0lLec,3462
 nabu/pipeline/writer.py,sha256=0ts40VNN3RiRURvZ2gNqsigsAJuwcjnYF4RJ15qaMpI,7558
 nabu/pipeline/fullfield/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/pipeline/fullfield/chunked.py,sha256=IElD8g_KtYS7VOXuIEsRbdb9fMmtpB_AK7mAyejbEs0,37125
+nabu/pipeline/fullfield/chunked.py,sha256=O6Wnw6B1nhA2yOdbOxqpEAdGnNdDGRYI2z0bBCB-yk0,37288
 nabu/pipeline/fullfield/chunked_cuda.py,sha256=aGzjY8MX6OL8auEj6Y0RfOGCmFnczsdfj6-8Net5AbQ,5645
-nabu/pipeline/fullfield/computations.py,sha256=VpIURVXh8EpNSfait_AIFM4Ci-GK_546Wkb-Wn9r31Y,9935
+nabu/pipeline/fullfield/computations.py,sha256=eWbqtlXWKgcmCsKL1GgtaTVXBScY6MSrmtLd8h5dLng,10251
 nabu/pipeline/fullfield/dataset_validator.py,sha256=8B2lB9j7elF_NmOOOyr8UADVfC15Oofzy2AyWoPufQM,3265
 nabu/pipeline/fullfield/nabu_config.py,sha256=a0mMoLkvlvHgX6RmUS1m1UhJS-XB3O6wBCnkNoI90Cs,30358
 nabu/pipeline/fullfield/processconfig.py,sha256=qSVeUvpt9BS2kR3zNk95_MGoLV4idiSJyYHlAPXbgTs,36405
@@ -223,7 +223,7 @@ nabu/processing/tests/test_rotation.py,sha256=vedRXV9RePJywBKoyBkGANP1dhZCjphbYO
 nabu/processing/tests/test_transpose.py,sha256=hTG17wTaB5Wv6twbW3ZFhBv6BYfqJY7DTQPoO0-KdkM,2760
 nabu/processing/tests/test_unsharp.py,sha256=R3ovbwDDp3ccy2A8t6CcUVELXRWkED5EnQdN2FQOfQM,4391
 nabu/reconstruction/__init__.py,sha256=EmKVvx_-FJvzJngG4ielIC7FhMCpI1Waaflg_lF44tk,163
-nabu/reconstruction/cone.py,sha256=ET0xCoFRt5oD7IpzHNmlm-bX4eanBenH186VGTgLAj0,12159
+nabu/reconstruction/cone.py,sha256=1Wq2XJuVTjHTjTsUng1Z9VE8IPV_4xLGkD6TtBGzHrs,16234
 nabu/reconstruction/fbp.py,sha256=5GB7XCnxftSHq1ZBLjWi-7OTiyCU4qe-M4EPzvsoxLg,4829
 nabu/reconstruction/fbp_base.py,sha256=igY--_GiKGAcephOU1I8O1GjVcryJnReyywlgtROXW4,16833
 nabu/reconstruction/fbp_opencl.py,sha256=coEGLq65PCuvWnhAbIyLPHACkWjMB0XOceMp9ZIDWtc,3274
@@ -239,7 +239,7 @@ nabu/reconstruction/sinogram.py,sha256=KTSGP_JJABf4Yr9l628HPbyWsBnpbnyGKyPEq3ZrP
 nabu/reconstruction/sinogram_cuda.py,sha256=wS84AIy3T00d1kTtuJOQmA3hktbDVs4ybwB9haiBcoY,10623
 nabu/reconstruction/sinogram_opencl.py,sha256=p793N26VknU8KIZLtDgFY6HNx0TylemZ1YL4WKD3fHs,1403
 nabu/reconstruction/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-nabu/reconstruction/tests/test_cone.py,sha256=xrFsIFGmpE9txpR3d93upF2S4yS_53IjZdZEKaaYspg,14313
+nabu/reconstruction/tests/test_cone.py,sha256=88n0vKrKJg26DbvH3ZtHtmOtqHFkjJxmELlBLLL5qMA,17594
 nabu/reconstruction/tests/test_deringer.py,sha256=C5wj6RNzmpt_Cry4fonC8KXWvgPpcXfRbG8Bex_30S4,8380
 nabu/reconstruction/tests/test_fbp.py,sha256=p80zPCZkgJpERpqG5HHfbtbHBeqJUT8WY-q6FXOJJ7M,10053
 nabu/reconstruction/tests/test_filtering.py,sha256=PFJLQMDBQo-UuS_CfKrWZ_DdHarmVlcbsiZ_kmToWXY,4782
@@ -268,7 +268,7 @@ nabu/stitching/alignment.py,sha256=MSj-6npGfUnD3C5R5rqKwTogVRUDPmJuEZkPG9hMiUY,6
 nabu/stitching/config.py,sha256=t7mkRrkdHKMz0x-lg0f5-IOAO829A6BvKH8WUAuSAps,51333
 nabu/stitching/definitions.py,sha256=RyqzZY3KLwN4j0SkOFA-T1aicPbO2jBrqfWdz-1djxk,130
 nabu/stitching/frame_composition.py,sha256=OGM9cLrLfEP5_hvhDbNq_zr2wdMeAuTTNlVqZk-qVBU,5889
-nabu/stitching/overlap.py,sha256=eXAKsILS5jwqFY62JhDijeNW8H50rP-yjdUUGqjj0aY,15700
+nabu/stitching/overlap.py,sha256=YbPon4_n4lT678F1aFSHx-ButcSYYqlBFjDqfNA77T4,15698
 nabu/stitching/sample_normalization.py,sha256=_radin_wxnuD3MMmZNAOKA__aPa2z3ss4TFbZeocpXc,2069
 nabu/stitching/slurm_utils.py,sha256=sZ-VQPh_YlJ1Lkh7ap8qxII0rBpZryMyoxE5Xn557t8,8906
 nabu/stitching/utils.py,sha256=kMn2JEMDhcBQMweSlM0rUd-037H7iNUURTFMhXOTzC8,23651
@@ -288,9 +288,9 @@ nabu/thirdparty/pore3d_deringer_munch.py,sha256=o4bisnFc-wMjuohWBT8wgWmfNehPQGtC
 nabu/thirdparty/tomocupy_remove_stripe.py,sha256=VgXHr2tzTAAGZix5pwhFfbPxj4tt3yXBcjCPNQSLPAg,22810
 nabu/thirdparty/tomopy_phase.py,sha256=hK4oPpkogLOhv23XzzEXQY2u3r8fJvASY_bINVs6ERE,8634
 nabu/thirdparty/tomwer_load_flats_darks.py,sha256=ZNoVAinUb_wGYbfvs_4BVnWsjsQmNxSvCh1bWhR2WWg,5611
-nabu-2024.1.8.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
-nabu-2024.1.8.dist-info/METADATA,sha256=qlqJl5Qy-ajxs4_j-PfKcIvwds6vYOT9j8V21egtvQs,5237
-nabu-2024.1.8.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-nabu-2024.1.8.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
-nabu-2024.1.8.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
-nabu-2024.1.8.dist-info/RECORD,,
+nabu-2024.1.9.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2024.1.9.dist-info/METADATA,sha256=SE80zwpzgCSLc4Fsw_DNJtDcUs8_74dQTjrACHcQjkE,5237
+nabu-2024.1.9.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
+nabu-2024.1.9.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
+nabu-2024.1.9.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2024.1.9.dist-info/RECORD,,

{nabu-2024.1.8.dist-info → nabu-2024.1.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.41.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

doc/doc_config.py

@@ -1,32 +0,0 @@
-#!/usr/bin/env python
-
-from nabu.resources.nabu_config import nabu_config
-
-
-def generate(file_):
-    def write(content):
-        print(content, file=file_)
-    for section, values in nabu_config.items():
-        if section == "about":
-            continue
-        write("## %s\n" % section)
-        for key, val in values.items():
-            if val["type"] == "unsupported":
-                continue
-            write(val["help"] + "\n")
-            write(
-                "```ini\n%s = %s\n```"
-                % (key, val["default"])
-            )
-
-
-
-if __name__ == "__main__":
-
-    import sys, os
-    print(os.path.abspath(__file__))
-    exit(0)
-
-    fname = "/tmp/test.md"
-    with open(fname, "w") as f:
-        generate(f)