nabu 2024.1.0rc3__tar.gz → 2024.1.1__tar.gz

{nabu-2024.1.0rc3/nabu.egg-info → nabu-2024.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.0rc3
+Version: 2024.1.1
 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.0rc3 → nabu-2024.1.1}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.1.0-rc3"
+__version__ = "2024.1.1"
 __nabu_modules__ = [
     "app",
     "cuda",

{nabu-2024.1.0rc3 → nabu-2024.1.1}/nabu/estimation/cor.py

@@ -285,13 +285,13 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
             abs_pos = near_pos + img_shape[-1] // 2
             offset = min(img_shape[-1] - abs_pos, abs_pos)  # distance to closest edge.
 
-            window_fraction = 0.8  # Hard-coded ?
+            window_fraction = 0.4  # Hard-coded ?
             window_shift = int(np.floor(offset * window_fraction))
             window_width = 2 * window_shift + 1
 
             sliding_shift = int(np.floor(offset * (1 - window_fraction))) - 1
             n = 2 * sliding_shift + 1
-            win_1_start_seed = abs_pos - window_shift - sliding_shift
+            win_1_start_seed = 2 * near_pos - sliding_shift
 
         if side.lower() == "right":
             win_2_start = 0

{nabu-2024.1.0rc3 → nabu-2024.1.1}/nabu/io/cast_volume.py

@@ -167,6 +167,12 @@ def cast_volume(
     if not isinstance(output_volume, VolumeBase):
         raise TypeError(f"output_volume is expected to be a {VolumeBase}. {type(output_volume)} provided")
 
+    try:
+        output_data_type = numpy.dtype(
+            output_data_type
+        )  # User friendly API in case user provides np.uint16 e.g. (see issue #482)
+    except Exception:
+        pass
     if not isinstance(output_data_type, numpy.dtype):
         raise TypeError(f"output_data_type is expected to be a {numpy.dtype}. {type(output_data_type)} provided")
 
@@ -326,7 +332,7 @@ def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> O
             )
 
 
-def _get_hst_saturations(hist, bins, rescale_min_percentile, rescale_max_percentile):
+def _get_hst_saturations(hist, bins, rescale_min_percentile: numpy.float32, rescale_max_percentile: numpy.float32):
     hist_cum = numpy.cumsum(hist)
     bin_index_min = numpy.searchsorted(hist_cum, numpy.percentile(hist_cum, rescale_min_percentile))
     bin_index_max = numpy.searchsorted(hist_cum, numpy.percentile(hist_cum, rescale_max_percentile))
@@ -360,4 +366,6 @@ def _min_max_from_histo(url: DataUrl, rescale_min_percentile: int, rescale_max_p
     else:
         bins = histogram[1]
         hist = histogram[0]
-        return _get_hst_saturations(hist, bins, rescale_min_percentile, rescale_max_percentile)
+        return _get_hst_saturations(
+            hist, bins, numpy.float32(rescale_min_percentile), numpy.float32(rescale_max_percentile)
+        )

{nabu-2024.1.0rc3 → nabu-2024.1.1}/nabu/pipeline/estimators.py

@@ -27,7 +27,7 @@ from ..resources.logger import LoggerOrPrint
 from ..resources.utils import extract_parameters
 from ..utils import check_supported, is_int
 from .params import tilt_methods
-from ..resources.dataset_analyzer import get_0_180_radios
+from ..resources.dataset_analyzer import get_radio_pair
 from ..processing.rotation import Rotation
 from ..io.reader import ChunkReader
 from ..preproc.ccd import Log, CCDFilter
@@ -148,7 +148,7 @@ class CORFinderBase:
                 )
                 near_init = default_lookup_side
         elif isinstance(near_init, Real):
-            self.cor_options.update({"near_pos": near_init})
+            self.cor_options.update({"near_pos": int(near_init)})
             near_init = "near"  # ???
         elif near_init == "near":  # Legacy
             if not isinstance(self.cor_options["near_pos"], Real):
@@ -201,8 +201,8 @@ class CORFinderBase:
         lookup_side = self.cor_options.get("side", default_lookup_side)
 
         # OctaveAccurate
-        if cor_class == CenterOfRotationOctaveAccurate:
-            lookup_side = "center"
+        # if cor_class == CenterOfRotationOctaveAccurate:
+        #    lookup_side = "center"
         angles = self.dataset_info.rotation_angles
 
         self.cor_exec_args = []
@@ -246,7 +246,9 @@ class CORFinder(CORFinderBase):
         },
     }
 
-    def __init__(self, method, dataset_info, do_flatfield=True, cor_options=None, logger=None):
+    def __init__(
+        self, method, dataset_info, do_flatfield=True, cor_options=None, logger=None, radio_angles: tuple = (0.0, np.pi)
+    ):
         """
         Initialize a CORFinder object.
 
@@ -254,15 +256,19 @@ class CORFinder(CORFinderBase):
         ----------
         dataset_info: `nabu.resources.dataset_analyzer.DatasetAnalyzer`
             Dataset information structure
+        radio_angles: angles to use to find the cor
         """
         super().__init__(method, dataset_info, do_flatfield=do_flatfield, cor_options=cor_options, logger=logger)
+        self._radio_angles = radio_angles
         self._init_radios()
         self._init_flatfield()
         self._apply_flatfield()
         self._apply_tilt()
 
     def _init_radios(self):
-        self.radios, self._radios_indices = get_0_180_radios(self.dataset_info, return_indices=True)
+        self.radios, self._radios_indices = get_radio_pair(
+            self.dataset_info, radio_angles=self._radio_angles, return_indices=True
+        )
 
     def _init_flatfield(self):
         if not (self.do_flatfield):
@@ -919,7 +925,7 @@ class DetectorTiltEstimator:
             named arguments to pass to the detector tilt estimator class.
         """
         self._set_params(dataset_info, do_flatfield, logger, autotilt_options)
-        self.radios, self.radios_indices = get_0_180_radios(dataset_info, return_indices=True)
+        self.radios, self.radios_indices = get_radio_pair(dataset_info, radio_angles=(0.0, np.pi), return_indices=True)
         self._init_flatfield()
         self._apply_flatfield()
 

{nabu-2024.1.0rc3 → nabu-2024.1.1}/nabu/resources/dataset_analyzer.py

@@ -424,14 +424,17 @@ def analyze_dataset(dataset_path, extra_options=None, logger=None):
     return dataset_structure
 
 
-def get_0_180_radios(dataset_info, return_indices=False):
+def get_radio_pair(dataset_info, radio_angles: tuple, return_indices=False):
     """
-    Get the radios at 0 degres and 180 degrees.
+    Get closest radios at radio_angles[0] and radio_angles[1]
+    angles must be in angles
 
     Parameters
     ----------
     dataset_info: `DatasetAnalyzer` instance
         Data structure with the dataset information
+    radio_angles: tuple
+        tuple of two elements: angles (in radian) to get
     return_indices: bool, optional
         Whether to return radios indices along with the radios array.
 
@@ -441,14 +444,20 @@ def get_0_180_radios(dataset_info, return_indices=False):
         If return_indices is True, return a tuple (radios, indices).
         Otherwise, return an array with the radios.
     """
+    if not (isinstance(radio_angles, tuple) and len(radio_angles) == 2):
+        raise TypeError("radio_angles should be a tuple of two elements.")
+    if not isinstance(radio_angles[0], (np.floating, float)) or not isinstance(radio_angles[1], (np.floating, float)):
+        raise TypeError(
+            f"radio_angles should be float. Get {type(radio_angles[0])} and {type(radio_angles[1])} instead"
+        )
+
     radios_indices = []
     radios_indices = sorted(dataset_info.projections.keys())
     angles = dataset_info.rotation_angles
     angles = angles - angles.min()
-    i_0 = np.argmin(np.abs(angles))
-    i_180 = np.argmin(np.abs(angles - np.pi))
-    _min_indices = [i_0, i_180]
-    radios_indices = [radios_indices[i_0], radios_indices[i_180]]
+    i_radio_1 = np.argmin(np.abs(angles - radio_angles[0]))
+    i_radio_2 = np.argmin(np.abs(angles - radio_angles[1]))
+    radios_indices = [radios_indices[i_radio_1], radios_indices[i_radio_2]]
     n_radios = 2
     radios = np.zeros((n_radios,) + dataset_info.radio_dims[::-1], "f")
     for i in range(n_radios):

{nabu-2024.1.0rc3 → nabu-2024.1.1}/nabu/stitching/config.py

@@ -710,12 +710,12 @@ class StitchingConfiguration:
                     "type": "optional",
                 },
                 SLURM_PREPROCESSING_COMMAND: {
-                    "default": "'/scisoft/tomotools_env/activate.sh stable'",
+                    "default": "",
                     "help": "python virtual environment to use",
                     "type": "optional",
                 },
                 SLURM_MODULES_TO_LOADS: {
-                    "default": "",
+                    "default": "tomotools/stable",
                     "help": "module to load",
                     "type": "optional",
                 },

{nabu-2024.1.0rc3 → nabu-2024.1.1}/nabu/stitching/z_stitching.py

@@ -1223,7 +1223,9 @@ class PreProcessZStitcher(ZStitcher):
 
         # first save the NXtomo entry without the frame
         # dicttonx will fail if the folder does not exists
-        os.makedirs(os.path.dirname(self.configuration.output_file_path), exist_ok=True)
+        dir_name = os.path.dirname(self.configuration.output_file_path)
+        if dir_name not in (None, ""):
+            os.makedirs(dir_name, exist_ok=True)
         nx_tomo.save(
             file_path=self.configuration.output_file_path,
             data_path=self.configuration.output_data_path,

{nabu-2024.1.0rc3 → nabu-2024.1.1/nabu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.0rc3
+Version: 2024.1.1
 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.0rc3 → nabu-2024.1.1}/nabu.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 pyproject.toml
 doc/conf.py
 doc/create_conf_doc.py
-doc/doc_config.py
 doc/get_mathjax.py
 nabu/__init__.py
 nabu/tests.py
@@ -296,35 +295,4 @@ nabu/thirdparty/algotom_convert_sino.py
 nabu/thirdparty/pore3d_deringer_munch.py
 nabu/thirdparty/tomocupy_remove_stripe.py
 nabu/thirdparty/tomopy_phase.py
-nabu/thirdparty/tomwer_load_flats_darks.py
-sandbox/align_test.py
-sandbox/app.py
-sandbox/binning_cython.py
-sandbox/circ_sm.py
-sandbox/composite_image.py
-sandbox/convert_id15.py
-sandbox/do_test_ctf.py
-sandbox/esrf_envs.py
-sandbox/fbp_polar.py
-sandbox/fbp_tilt.py
-sandbox/interleaved.py
-sandbox/interp_sinos_halftomo.py
-sandbox/linear_interp.py
-sandbox/merge_recs.py
-sandbox/moduleutils.py
-sandbox/nbreconstruct.py
-sandbox/pag_margin.py
-sandbox/parse.py
-sandbox/plot.py
-sandbox/proj3D.py
-sandbox/rec_bm05.py
-sandbox/rec_thread.py
-sandbox/shift_bilinear2.py
-sandbox/sinotilt.py
-sandbox/sysutils.py
-sandbox/test_mp_queue.py
-sandbox/tilt.py
-sandbox/utils.py
-sandbox/vo.py
-sandbox/workers.py
-sandbox/xrdrec_pyFAI_data.py
+nabu/thirdparty/tomwer_load_flats_darks.py

nabu-2024.1.0rc3/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)

nabu-2024.1.0rc3/sandbox/align_test.py

@@ -1,61 +0,0 @@
-import numpy as np
-from nabu.estimation.translation import DetectorTranslationAlongBeam
-from tomoscan.io import HDF5File
-
-
-def get_data(fname, h5_paths):
-    with HDF5File(fname, "r") as f:
-        align_data = f[h5_paths["align_data"]][()]
-        dark = f[h5_paths["dark"]][0]
-        pixel_size_um = f[h5_paths["pixel_size"]][()]
-        positions_mm = f[h5_paths["positions"]][()]
-
-    # Dark subtraction
-    align_data = align_data - dark.astype("f")
-
-    return align_data, pixel_size_um, positions_mm
-
-
-
-def get_alignment(align_data, pixel_size_um, positions_mm, plot=True):
-
-    tr_calc = DetectorTranslationAlongBeam()
-    if plot == True:
-        tr_calc.verbose=True
-
-    shifts_v, shifts_h = tr_calc.find_shift(align_data, positions_mm)
-
-    # pixel_size is in microns, motor position is in mm
-    tilt_v_deg = np.rad2deg(np.arctan(shifts_v * pixel_size_um / 1e3))
-    tilt_h_deg = np.rad2deg(np.arctan(shifts_h * pixel_size_um / 1e3))
-    print (f"\nVertical tilt  to be applied in deg (thy): {tilt_v_deg}")
-    print (f"Horizontal tilt to be applied in deg (thz): {tilt_h_deg}\n")
-
-    return align_data, shifts_v, shifts_h, positions_mm
-
-
-
-
-
-
-if __name__ == "__main__":
-    fname = "/data/id19/inhouse/id192201/id19/sample/sample_0001/sample_0001.h5"
-    h5_paths = {
-        "align_data": "11.1/measurement/pcolinux",
-        "dark": "12.1/measurement/pcolinux",
-        "pixel_size": "11.1/instrument/pcolinux/x_pixel_size",
-        "positions": "11.1/measurement/hrxc"
-    }
-    align_data, pixel_size_um, positions_mm = get_data(fname, h5_paths)
-    # align_data, shifts_v, shifts_h, positions_mm = get_alignment(align_data, pixel_size_um, positions_mm)
-
-    D = DetectorTranslationAlongBeam()
-    D. verbose = True
-    sv, sh = D.find_shift(align_data, positions_mm)
-    D.verbose = False
-    sv, sh = D.find_shift(align_data, positions_mm)
-    D.verbose = True
-    sv, sh = D.find_shift(align_data, positions_mm)
-
-
-

nabu-2024.1.0rc3/sandbox/app.py

@@ -1,123 +0,0 @@
-from time import sleep
-import pycuda.autoinit
-import pycuda.gpuarray as garray
-from nabu.resources.processconfig import ProcessConfig
-from nabu.resources.tasks import build_processing_steps
-
-from nabu.app.logger import Logger
-
-from nabu.app.chunkreader import ChunkReaderComponent
-from nabu.app.flatfield import FlatFieldComponent
-from nabu.app.phase import PhaseRetrievalComponent
-from nabu.app.opmap import NegativeLogComponent
-from nabu.app.ccdfilter import CCDFilterComponent
-from nabu.app.unsharp import UnsharpMaskComponent
-from nabu.app.reconstructor import ReconstructorComponent
-
-
-if __name__ == "__main__":
-
-    conf = ProcessConfig("/home/pierre/workspace/data/nabu.conf")
-    steps, options = build_processing_steps(conf)
-    dataset_infos = conf.dataset_infos
-    SUB_REGION = (None, None, None, 50)
-
-    logger = Logger("nabu_processing", console=True)
-
-    # Read chunk
-    options["read_chunk"]["sub_region"] = SUB_REGION
-    options["read_chunk"]["convert_float"] = True
-    Ch = ChunkReaderComponent(options["read_chunk"], dataset_infos, logger=logger)
-    Ch.execute()
-    radios = Ch.chunk_reader.files_data
-    d_radios = garray.to_gpu(radios)
-
-    # Flat-field
-    options["flatfield"]["sub_region"] = SUB_REGION
-    options["flatfield"]["use_opencl"] = False
-    options["flatfield"]["use_cuda"] = True
-    F = FlatFieldComponent(d_radios, options["flatfield"], dataset_infos, logger=logger)
-    F.execute()
-
-    # CCD filter
-    options["ccd_correction"]["use_cuda"] = True
-    options["ccd_correction"]["use_opencl"] = False
-    CCD = CCDFilterComponent(d_radios, options["ccd_correction"], dataset_infos, logger=logger)
-    CCD.execute()
-
-
-    # Phase retrieval
-    options["phase"]["use_cuda"] = True
-    options["phase"]["use_opencl"] = False
-    P = PhaseRetrievalComponent(radios[0].shape, options["phase"], dataset_infos, logger=logger)
-    P.execute(d_radios)
-
-    # Unsharp
-    # ~ options["unsharp_mask"]["use_cuda"] = True
-    # ~ options["unsharp_mask"]["use_opencl"] = False
-    # ~ U = UnsharpMaskComponent(radios[0].shape, options["unsharp_mask"], dataset_infos, logger=logger)
-    # ~ U.execute(d_radios)
-
-    # -log()
-    options["take_log"]["use_cuda"] = True
-    options["take_log"]["use_opencl"] = False
-    L = NegativeLogComponent(d_radios, options["take_log"], dataset_infos, logger=logger)
-    L.execute()
-
-
-    # Test
-    # ~ from spire.utils import ims
-    # ~ r = d_radios.get()
-    # ~ ims(r[:, 10, :])
-
-
-    # Reconstruction
-    options["reconstruction"]["use_cuda"] = True
-
-    # Test ...
-    if 1:
-        options["reconstruction"]["start_x"] = 100
-        options["reconstruction"]["end_x"] = -100
-        options["reconstruction"]["start_y"] = 100
-        options["reconstruction"]["end_y"] = -100
-        options["reconstruction"]["start_z"] = 0
-        options["reconstruction"]["end_z"] = SUB_REGION[-1]-1
-        d_rec = garray.zeros((50, 1849, 1849), "f") # y
-    #
-    else:
-        d_rec = garray.zeros((SUB_REGION[-1], 2048, 2048), "f")
-    R = ReconstructorComponent(d_radios.shape, options["reconstruction"], dataset_infos, logger=logger)
-    R.execute(d_radios, output=d_rec)
-
-
-    # Write to file
-    rec = d_rec.get()
-    import numpy as np
-    np.save("/home/pierre/tmp/crayon/recs_nabu_vertical.npy", rec)
-
-    """from nabu.reconstruction.reconstructor_cuda import CudaReconstructor
-    R = CudaReconstructor(
-        radios.shape,
-        [0, 1],
-        vol_type="projections",
-        extra_options={"padding_mode": conf.nabu_config["reconstruction"]["padding_type"]}
-    )
-    d_recs = garray.zeros((1, 2048, 2048), "f")
-    R.reconstruct(d_radios, output=d_recs)
-    recs = d_recs.get()
-    ims(recs[0], cmap="gray")
-    # save
-    import numpy as np
-    np.save("/tmp/rec0.npy", recs[0])
-    """
-
-
-"""
-Notes
-  - If the cuda backend is used at step N, it should also be used at step N+1,
-
-
-otherwise we have to get() the data
-
-"""
-

nabu-2024.1.0rc3/sandbox/binning_cython.py

@@ -1,37 +0,0 @@
-%%cython --compile-args=-fopenmp --link-args=-fopenmp -a
-#%%cython -a
-#cython: embedsignature=True, language_level=3, binding=True
-#cython: boundscheck=False, wraparound=False, cdivision=True, initializedcheck=False,
-## This is for developping:
-## cython: profile=True, warn.undeclared=True, warn.unused=True, warn.unused_result=False, warn.unused_arg=True
-
-import numpy as np
-from cython.parallel import prange
-"""
-def bin2_cython(float[:, ::1] img):
-    cdef:
-        float[:, ::1] res
-        int i, j, Ny, Nx
-          
-    shp = img.shape
-    Ny, Nx = (img.shape[0]//2, img.shape[1]//2)
-    res = np.zeros((Ny, Nx), dtype="f")
-    for i in prange(Ny, nogil=True): 
-        for j in range(Nx):
-            res[i, j] = 0.25 * (img[2*i, 2*j] + img[2*i+1, 2*j] + img[2*i, 2*j+1] + img[2*i+1, 2*j+1])
-    return np.asarray(res)
-"""
-
-
-def bin2_cython(unsigned short[:, ::1] img):
-    cdef:
-        float[:, ::1] res
-        int i, j, Ny, Nx
-          
-    shp = img.shape
-    Ny, Nx = (img.shape[0]//2, img.shape[1]//2)
-    res = np.zeros((Ny, Nx), dtype="f")
-    for i in prange(Ny, nogil=True): 
-        for j in range(Nx):
-            res[i, j] = 0.25 * (img[2*i, 2*j] + img[2*i+1, 2*j] + img[2*i, 2*j+1] + img[2*i+1, 2*j+1])
-    return np.asarray(res)