nabu 2024.1.2__tar.gz → 2024.1.4__tar.gz

{nabu-2024.1.2/nabu.egg-info → nabu-2024.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.2
+Version: 2024.1.4
 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>
@@ -48,9 +48,29 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>1.9.0
+Requires-Dist: scipy
+Requires-Dist: h5py>=3.0
+Requires-Dist: silx>=0.15.0
+Requires-Dist: tomoscan>=2.0.4
+Requires-Dist: psutil
+Requires-Dist: pytest
+Requires-Dist: tifffile
 Provides-Extra: full
+Requires-Dist: scikit-image; extra == "full"
+Requires-Dist: PyWavelets; extra == "full"
+Requires-Dist: glymur; extra == "full"
+Requires-Dist: pycuda; extra == "full"
+Requires-Dist: scikit-cuda; extra == "full"
+Requires-Dist: pycudwt; extra == "full"
+Requires-Dist: sluurp>=0.3; extra == "full"
+Requires-Dist: pyvkfft; extra == "full"
 Provides-Extra: doc
-License-File: LICENSE
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: cloud_sptheme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
 
 # Nabu
 

nabu-2024.1.4/doc/doc_config.py

@@ -0,0 +1,32 @@
+#!/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.2 → nabu-2024.1.4}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.1.2"
+__version__ = "2024.1.4"
 __nabu_modules__ = [
     "app",
     "cuda",

{nabu-2024.1.2 → nabu-2024.1.4}/nabu/pipeline/dataset_validator.py

@@ -157,8 +157,9 @@ class DatasetValidatorBase:
         """
         dataset_cfg = self.nabu_config["dataset"]
         self.binning = (dataset_cfg["binning"], dataset_cfg["binning_z"])
-        subsampling_factor, subsampling_begin = dataset_cfg["projections_subsampling"]
+        subsampling_factor, subsampling_start = dataset_cfg["projections_subsampling"]
         self.subsampling_factor = subsampling_factor or 1
+        self.subsampling_start = subsampling_start or 0
 
         if self.binning != (1, 1):
             bin_x, bin_z = self.binning

{nabu-2024.1.2 → nabu-2024.1.4}/nabu/pipeline/fullfield/processconfig.py

@@ -83,6 +83,10 @@ class ProcessConfig(ProcessConfigBase):
             )
         self.rec_params = self.nabu_config["reconstruction"]
 
+        subsampling_factor, subsampling_start = self.nabu_config["dataset"]["projections_subsampling"]
+        self.subsampling_factor = subsampling_factor or 1
+        self.subsampling_start = subsampling_start or 0
+
         self._update_dataset_with_user_overwrites()
         self._get_rotation_axis_position()
         self._update_rotation_angles()
@@ -118,8 +122,9 @@ class ProcessConfig(ProcessConfigBase):
         if transl_file is not None and "://" not in transl_file:
             try:
                 translations = get_values_from_file(
-                    transl_file, shape=(self.dataset_info.n_angles, last_dim), any_size=True
+                    transl_file, shape=(self.n_angles(subsampling=False), last_dim), any_size=True
                 ).astype(np.float32)
+                translations = translations[self.subsampling_start :: self.subsampling_factor]
             except ValueError:
                 print("Something wrong with translation_movements_file %s" % transl_file)
                 raise
@@ -145,9 +150,10 @@ class ProcessConfig(ProcessConfigBase):
             try:
                 axis_correction = get_values_from_file(
                     axis_correction_file,
-                    n_values=self.dataset_info.n_angles,
+                    n_values=self.n_angles(subsampling=False),
                     any_size=True,
                 ).astype(np.float32)
+                axis_correction = axis_correction[self.subsampling_start :: self.subsampling_factor]
             except ValueError:
                 print("Something wrong with axis correction file %s" % axis_correction_file)
                 raise
@@ -225,7 +231,7 @@ class ProcessConfig(ProcessConfigBase):
         self.logger.debug("Doing coupled validation")
         self._dataset_validator = FullFieldDatasetValidator(self.nabu_config, self.dataset_info)
         # Not so ideal to propagate fields like this
-        for what in ["rec_params", "rec_region", "binning", "subsampling_factor"]:
+        for what in ["rec_params", "rec_region", "binning"]:
             setattr(self, what, getattr(self._dataset_validator, what))
 
     #
@@ -255,7 +261,7 @@ class ProcessConfig(ProcessConfigBase):
     def n_angles(self, subsampling=False):
         rot_angles = self.dataset_info.rotation_angles
         if subsampling:
-            rot_angles = rot_angles[:: (self.subsampling or 1)]
+            rot_angles = rot_angles[self.subsampling_start :: self.subsampling_factor]
         return len(rot_angles)
 
     def radios_shape(self, binning=False, subsampling=False):
@@ -300,10 +306,12 @@ class ProcessConfig(ProcessConfigBase):
         return sorted(self.dataset_info.projections.keys())[::step]
 
     def rotation_angles(self, subsampling=False):
+        start = 0
         step = 1
         if subsampling:
-            step = self.subsampling or 1
-        return self.dataset_info.rotation_angles[::step]
+            start = self.subsampling_start
+            step = self.subsampling_factor
+        return self.dataset_info.rotation_angles[start::step]
 
     @property
     def rec_roi(self):
@@ -512,7 +520,7 @@ class ProcessConfig(ProcessConfigBase):
         translations = dataset_info.translations
         if translations is not None:
             tasks.append("radios_movements")
-            options["radios_movements"] = {"translation_movements": dataset_info.translations[:: self.binning_z]}
+            options["radios_movements"] = {"translation_movements": dataset_info.translations}
         #
         # Sinogram normalization (before half-tomo)
         #
@@ -562,7 +570,8 @@ class ProcessConfig(ProcessConfigBase):
             rec_options["enable_halftomo"] = self.do_halftomo
             rec_options["axis_correction"] = dataset_info.axis_correction
             if dataset_info.axis_correction is not None:
-                rec_options["axis_correction"] = rec_options["axis_correction"][:: self.subsampling_factor]
+                rec_options["axis_correction"] = rec_options["axis_correction"]
+
             rec_options["angles"] = np.array(self.rotation_angles(subsampling=True))
             rec_options["angles"] += np.deg2rad(nabu_config["reconstruction"]["angle_offset"])
             voxel_size = dataset_info.pixel_size * 1e-4

{nabu-2024.1.2 → nabu-2024.1.4}/nabu/pipeline/tests/test_chunk_reader.py

@@ -55,10 +55,6 @@ class TestChunkReader:
         first_sino_odd = reader.data[:, 0, :].copy()
         compacted_dataslices_odd = get_compacted_dataslices_as_sorted_tuples(reader)
 
-        # from spire.utils import ims
-        # ims([first_sino_all[::2], first_sino_even, first_sino_all[::2]*1. - first_sino_even])
-        # ims([first_sino_all[::2], first_sino_even, first_sino_all[1::2]*1. - first_sino_odd])
-
         # Check that the compacted data slices are correct
         assert len(compacted_dataslices_all) == len(compacted_dataslices_even) == len(compacted_dataslices_odd)
         for data_slice_all, data_slice_even, data_slice_odd in zip(

{nabu-2024.1.2 → nabu-2024.1.4}/nabu/reconstruction/rings_cuda.py

@@ -174,10 +174,15 @@ class CudaMunchDeringer(MunchDeringer):
             self._fft_plans[level].ifft(d_coeffs_f, output=d_coeffs)
 
     def _destripe_2D(self, d_sino, output):
+        if not (d_sino.flags.c_contiguous):
+            sino = self.cuda_processing.allocate_array("_d_sino", d_sino.shape, np.float32)
+            sino[:] = d_sino[:]
+        else:
+            sino = d_sino
         if self.padding is not None:
-            d_sino = self.padder.pad(d_sino)
+            sino = self.padder.pad(sino)
         # set the "image" for DWT (memcpy D2D)
-        self._d_sino.set(d_sino)
+        self._d_sino.set(sino)
         # perform forward DWT
         self.cudwt.forward()
         for i in range(self.cudwt.levels):
@@ -256,9 +261,10 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             filename=get_cuda_srcfile("normalization.cu"),
             signature="PPiii",
         )
-        self._mean_kernel_block = (32, 1, 32)
-        self._mean_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._mean_kernel_block)]
-        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
+        self._mean_kernel_block = (32, 1, 1)
+        self._mean_kernel_grid = [updiv(self.sinos_shape[-1], self._mean_kernel_block[0]), 1, 1]
+        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(1)]
+
         self._mean_kernel_kwargs = {
             "grid": self._mean_kernel_grid,
             "block": self._mean_kernel_block,
@@ -270,9 +276,11 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             signature="PPiii",
             options=["-DGENERIC_OP=%d" % (3 if self.mode == "divide" else 1)],
         )
-        self._op_kernel_block = (16, 16, 4)
-        self._op_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._op_kernel_block)]
-        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
+        self._op_kernel_block = (16, 16, 1)
+        self._op_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[1:][::-1], self._op_kernel_block[:-1])] + [
+            1
+        ]
+        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(1)]
         self._op_kernel_kwargs = {
             "grid": self._op_kernel_grid,
             "block": self._op_kernel_block,
@@ -312,9 +320,16 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
         if output is not None:
             raise NotImplementedError
         #
-        self._mean_kernel(sino, *self._mean_kernel_args, **self._mean_kernel_kwargs)
+        if not (sino.flags.c_contiguous):
+            d_sino = self.processing.allocate_array("d_sino", sino.shape, np.float32)
+            d_sino[:] = sino[:]
+        else:
+            d_sino = sino
+        self._mean_kernel(d_sino, *self._mean_kernel_args, **self._mean_kernel_kwargs)
         self._apply_filter(self.d_sino_profile)
-        self._op_kernel(sino, *self._op_kernel_args, **self._op_kernel_kwargs)
+        self._op_kernel(d_sino, *self._op_kernel_args, **self._op_kernel_kwargs)
+        if not (sino.flags.c_contiguous):
+            sino[:] = self.processing.d_sino[:]
         return sino
 
     def remove_rings_sinograms(self, sinograms):

{nabu-2024.1.2 → nabu-2024.1.4}/nabu/utils.py

@@ -422,19 +422,6 @@ def copy_dict_items(dict_, keys):
     return res
 
 
-def remove_first_dict_items(dict_, n_items, sort_func=None, inplace=True):
-    """
-    Remove the first items of a dictionary. The keys have to be sortable
-    """
-    sorted_keys = sorted(dict_.keys(), key=sort_func)
-    if inplace:
-        for key in sorted_keys[:n_items]:
-            dict_.pop(key)
-        return dict_
-    else:
-        return copy_dict_items(dict_, sorted_keys[n_items:])
-
-
 def recursive_copy_dict(dict_):
     """
     Perform a shallow copy of a dictionary of dictionaries.

{nabu-2024.1.2 → nabu-2024.1.4/nabu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.1.2
+Version: 2024.1.4
 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>
@@ -48,9 +48,29 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>1.9.0
+Requires-Dist: scipy
+Requires-Dist: h5py>=3.0
+Requires-Dist: silx>=0.15.0
+Requires-Dist: tomoscan>=2.0.4
+Requires-Dist: psutil
+Requires-Dist: pytest
+Requires-Dist: tifffile
 Provides-Extra: full
+Requires-Dist: scikit-image; extra == "full"
+Requires-Dist: PyWavelets; extra == "full"
+Requires-Dist: glymur; extra == "full"
+Requires-Dist: pycuda; extra == "full"
+Requires-Dist: scikit-cuda; extra == "full"
+Requires-Dist: pycudwt; extra == "full"
+Requires-Dist: sluurp>=0.3; extra == "full"
+Requires-Dist: pyvkfft; extra == "full"
 Provides-Extra: doc
-License-File: LICENSE
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: cloud_sptheme; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: nbsphinx; extra == "doc"
 
 # Nabu
 

{nabu-2024.1.2 → nabu-2024.1.4}/nabu.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ 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
@@ -40,7 +41,6 @@ nabu/app/shrink_dataset.py
 nabu/app/stitching.py
 nabu/app/utils.py
 nabu/app/validator.py
-nabu/app/tests/__init__.py
 nabu/app/tests/test_reduce_dark_flat.py
 nabu/cuda/__init__.py
 nabu/cuda/convolution.py
@@ -296,4 +296,35 @@ 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
+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-2024.1.2 → nabu-2024.1.4}/nabu.egg-info/top_level.txt

@@ -1,5 +1,3 @@
-build
 dist
 doc
 nabu
-scripts

nabu-2024.1.4/sandbox/align_test.py

@@ -0,0 +1,61 @@
+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.4/sandbox/app.py

@@ -0,0 +1,123 @@
+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.4/sandbox/binning_cython.py

@@ -0,0 +1,37 @@
+%%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)