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

nabu/__init__.py

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

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/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/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/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/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/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.dist-info → nabu-2024.1.1.dist-info}/METADATA

@@ -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>