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

build/lib/build/lib/build/lib/nabu/thirdparty/tomopy_phase.py

@@ -1,239 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# #########################################################################
-# Copyright (c) 2015-2019, UChicago Argonne, LLC. All rights reserved.    #
-#                                                                         #
-# Copyright 2015-2019. UChicago Argonne, LLC. This software was produced  #
-# under U.S. Government contract DE-AC02-06CH11357 for Argonne National   #
-# Laboratory (ANL), which is operated by UChicago Argonne, LLC for the    #
-# U.S. Department of Energy. The U.S. Government has rights to use,       #
-# reproduce, and distribute this software.  NEITHER THE GOVERNMENT NOR    #
-# UChicago Argonne, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR        #
-# ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE.  If software is     #
-# modified to produce derivative works, such modified software should     #
-# be clearly marked, so as not to confuse it with the version available   #
-# from ANL.                                                               #
-#                                                                         #
-# Additionally, redistribution and use in source and binary forms, with   #
-# or without modification, are permitted provided that the following      #
-# conditions are met:                                                     #
-#                                                                         #
-#     * Redistributions of source code must retain the above copyright    #
-#       notice, this list of conditions and the following disclaimer.     #
-#                                                                         #
-#     * Redistributions in binary form must reproduce the above copyright #
-#       notice, this list of conditions and the following disclaimer in   #
-#       the documentation and/or other materials provided with the        #
-#       distribution.                                                     #
-#                                                                         #
-#     * Neither the name of UChicago Argonne, LLC, Argonne National       #
-#       Laboratory, ANL, the U.S. Government, nor the names of its        #
-#       contributors may be used to endorse or promote products derived   #
-#       from this software without specific prior written permission.     #
-#                                                                         #
-# THIS SOFTWARE IS PROVIDED BY UChicago Argonne, LLC AND CONTRIBUTORS     #
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT       #
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS       #
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL UChicago     #
-# Argonne, LLC OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,        #
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,    #
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;        #
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER        #
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT      #
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN       #
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         #
-# POSSIBILITY OF SUCH DAMAGE.                                             #
-# #########################################################################
-
-"""
-Module for phase retrieval.
-
-This code is part of tomopy: https://github.com/tomopy/tomopy
-It was adapted for being stand-alone, without job distribution.
-See the license above for more information.
-"""
-
-import numpy as np
-fft2 = np.fft.fft2
-ifft2 = np.fft.ifft2
-
-__author__ = "Doga Gursoy"
-__credits__ = "Mark Rivers, Xianghui Xiao"
-__copyright__ = "Copyright (c) 2015, UChicago Argonne, LLC."
-__docformat__ = 'restructuredtext en'
-__all__ = ['retrieve_phase']
-
-
-BOLTZMANN_CONSTANT = 1.3806488e-16  # [erg/k]
-SPEED_OF_LIGHT = 299792458e+2  # [cm/s]
-PI = 3.14159265359
-PLANCK_CONSTANT = 6.58211928e-19  # [keV*s]
-
-
-def _wavelength(energy):
-    return 2 * PI * PLANCK_CONSTANT * SPEED_OF_LIGHT / energy
-
-
-def retrieve_phase(
-        tomo, pixel_size=1e-4, dist=50, energy=20,
-        alpha=1e-3, pad=True, ncore=None, nchunk=None):
-    """
-    Perform single-step phase retrieval from phase-contrast measurements.
-
-    Parameters
-    ----------
-    tomo : ndarray
-        3D tomographic data.
-    pixel_size : float, optional
-        Detector pixel size in cm.
-    dist : float, optional
-        Propagation distance of the wavefront in cm.
-    energy : float, optional
-        Energy of incident wave in keV.
-    alpha : float, optional
-        Regularization parameter.
-    pad : bool, optional
-        If True, extend the size of the projections by padding with zeros.
-    ncore : int, optional
-        Number of cores that will be assigned to jobs.
-    nchunk : int, optional
-        Chunk size for each core.
-
-    Returns
-    -------
-    ndarray
-        Approximated 3D tomographic phase data.
-    """
-    # New dimensions and pad value after padding.
-    py, pz, val = _calc_pad(tomo, pixel_size, dist, energy, pad)
-
-    # Compute the reciprocal grid.
-    dx, dy, dz = tomo.shape
-    w2 = _reciprocal_grid(pixel_size, dy + 2 * py, dz + 2 * pz)
-
-    # Filter in Fourier space.
-    phase_filter = np.fft.fftshift(
-        _paganin_filter_factor(energy, dist, alpha, w2))
-
-    prj = np.full((dy + 2 * py, dz + 2 * pz), val, dtype='float32')
-    arr = _retrieve_phase(tomo, phase_filter, py, pz, prj, pad)
-    return arr
-
-
-def _retrieve_phase(tomo, phase_filter, px, py, prj, pad):
-    dx, dy, dz = tomo.shape
-    num_jobs = tomo.shape[0]
-    normalized_phase_filter = phase_filter / phase_filter.max()
-    for m in range(num_jobs):
-        # Padding "constant" with border value
-        # prj is initially filled with "val"
-        prj[px:dy + px, py:dz + py] = tomo[m]
-        prj[:px] = prj[px]
-        prj[-px:] = prj[-px-1]
-        prj[:, :py] = prj[:, py][:, np.newaxis]
-        prj[:, -py:] = prj[:, -py-1][:, np.newaxis]
-        fproj = fft2(prj)
-        fproj *= normalized_phase_filter
-        proj = np.real(ifft2(fproj))
-        if pad:
-            proj = proj[px:dy + px, py:dz + py]
-        tomo[m] = proj
-    return tomo
-
-
-def _calc_pad(tomo, pixel_size, dist, energy, pad):
-    """
-    Calculate new dimensions and pad value after padding.
-
-    Parameters
-    ----------
-    tomo : ndarray
-        3D tomographic data.
-    pixel_size : float
-        Detector pixel size in cm.
-    dist : float
-        Propagation distance of the wavefront in cm.
-    energy : float
-        Energy of incident wave in keV.
-    pad : bool
-        If True, extend the size of the projections by padding with zeros.
-
-    Returns
-    -------
-    int
-        Pad amount in projection axis.
-    int
-        Pad amount in sinogram axis.
-    float
-        Pad value.
-    """
-    dx, dy, dz = tomo.shape
-    wavelength = _wavelength(energy)
-    py, pz, val = 0, 0, 0
-    if pad:
-        val = _calc_pad_val(tomo)
-        py = _calc_pad_width(dy, pixel_size, wavelength, dist)
-        pz = _calc_pad_width(dz, pixel_size, wavelength, dist)
-    return py, pz, val
-
-
-def _paganin_filter_factor(energy, dist, alpha, w2):
-    return 1 / (_wavelength(energy) * dist * w2 / (4 * PI) + alpha)
-
-
-def _calc_pad_width(dim, pixel_size, wavelength, dist):
-    pad_pix = np.ceil(PI * wavelength * dist / pixel_size ** 2)
-    return int((pow(2, np.ceil(np.log2(dim + pad_pix))) - dim) * 0.5)
-
-
-def _calc_pad_val(tomo):
-    # mean of [(column 0 of radio) +  (column -1 of radio)]/2.
-    return np.mean((tomo[..., 0] + tomo[..., -1]) * 0.5)
-
-
-def _reciprocal_grid(pixel_size, nx, ny):
-    """
-    Calculate reciprocal grid.
-
-    Parameters
-    ----------
-    pixel_size : float
-        Detector pixel size in cm.
-    nx, ny : int
-        Size of the reciprocal grid along x and y axes.
-
-    Returns
-    -------
-    ndarray
-        Grid coordinates.
-    """
-    # Sampling in reciprocal space.
-    indx = _reciprocal_coord(pixel_size, nx)
-    indy = _reciprocal_coord(pixel_size, ny)
-    np.square(indx, out=indx)
-    np.square(indy, out=indy)
-    return np.add.outer(indx, indy)
-
-
-def _reciprocal_coord(pixel_size, num_grid):
-    """
-    Calculate reciprocal grid coordinates for a given pixel size
-    and discretization.
-
-    Parameters
-    ----------
-    pixel_size : float
-        Detector pixel size in cm.
-    num_grid : int
-        Size of the reciprocal grid.
-
-    Returns
-    -------
-    ndarray
-        Grid coordinates.
-    """
-    n = num_grid - 1
-    rc = np.arange(-n, num_grid, 2, dtype = np.float32)
-    rc *= 0.5 / (n * pixel_size)
-    return  rc

build/lib/build/lib/build/lib/nabu/thirdparty/tomwer_load_flats_darks.py

@@ -1,162 +0,0 @@
-"""
-script embedding all function needed to read flats and darks.
-
-For information calculation method is stored in the results/configuration
-dictionary
-"""
-
-
-"""
-IMPORTANT: this script is used as long as flat-fielding with "raw" flats/daks
-is not implemented in nabu.
-For now we load results from tomwer.
-"""
-
-import typing
-import h5py
-from silx.io.url import DataUrl
-from tomoscan.io import HDF5File
-from silx.io.utils import h5py_read_dataset
-import logging
-
-MAX_DEPTH = 2
-
-logger = logging.getLogger(__name__)
-
-def get_process_entries(root_node: h5py.Group, depth: int) -> tuple:
-    """
-    return the list of 'Nxtomo' entries at the root level
-
-    :param str file_path:
-    :return: list of valid Nxtomo node (ordered alphabetically)
-    :rtype: tuple
-
-    ..note: entries are sorted to insure consistency
-    """
-    def _get_entries(node, depth_):
-        if isinstance(node, h5py.Dataset):
-            return {}
-        res_buf = {}
-        if is_process_node(node) is True:
-            res_buf[node.name] = int(node['sequence_index'][()])
-        assert isinstance(node, h5py.Group)
-        if depth_ >= 1:
-            for sub_node in node.values():
-                res_buf[node.name] = _get_entries(node=sub_node, depth_=depth_-1)
-        return res_buf
-
-    res = {}
-    for node in root_node.values():
-        res.update(_get_entries(node=node, depth_=depth-1))
-
-    return res
-
-
-def is_process_node(node):
-    return (node.name.split('/')[-1].startswith('tomwer_process_') and
-            'NX_class' in node.attrs and
-            node.attrs['NX_class'] == "NXprocess" and
-            'program' in node and
-            h5py_read_dataset(node['program']) == 'tomwer_dark_refs' and
-            'version' in node and
-            'sequence_index' in node)
-
-
-def get_darks_frm_process_file(process_file, entry) -> typing.Union[None, dict]:
-    """
-
-    :param process_file:
-    :return:
-    """
-    if entry is None:
-        with HDF5File(process_file, 'r', swmr=True) as h5f:
-            entries = get_process_entries(root_node=h5f, depth=MAX_DEPTH)
-            if len(entries) == 0:
-                logger.info(
-                    'unable to find a DarkRef process in %s' % process_file)
-                return None
-            elif len(entries) > 0:
-                raise ValueError('several entry found, entry should be '
-                                 'specify')
-            else:
-                entry = list(entries.keys())[0]
-                logger.info('take %s as default entry' % entry)
-
-    with HDF5File(process_file, 'r', swmr=True) as h5f:
-        dark_nodes = get_process_entries(root_node=h5f[entry],
-                                          depth=MAX_DEPTH-1)
-        index_to_path = {}
-        for key, value in dark_nodes.items():
-            index_to_path[key] = key
-
-        if len(dark_nodes) == 0:
-            return {}
-        # take the last processed dark ref
-        last_process_index = sorted(dark_nodes.keys())[-1]
-        last_process_dark = index_to_path[last_process_index]
-        if(len(index_to_path)) > 1:
-            logger.warning('several processing found for dark-ref,'
-                           'take the last one: %s' % last_process_dark)
-
-        res = {}
-        if 'results' in h5f[last_process_dark].keys():
-            results_node = h5f[last_process_dark]['results']
-            if 'darks' in results_node.keys():
-                darks = results_node['darks']
-                for index in darks:
-                    res[int(index)] = DataUrl(
-                        file_path=process_file,
-                        data_path=darks[index].name,
-                        scheme="silx"
-                    )
-        return res
-
-
-def get_flats_frm_process_file(process_file, entry) -> typing.Union[None, dict]:
-    """
-
-    :param process_file:
-    :return:
-    """
-    if entry is None:
-        with HDF5File(process_file, 'r', swmr=True) as h5f:
-            entries = get_process_entries(root_node=h5f, depth=MAX_DEPTH)
-            if len(entries) == 0:
-                logger.info(
-                    'unable to find a DarkRef process in %s' % process_file)
-                return None
-            elif len(entries) > 0:
-                raise ValueError('several entry found, entry should be '
-                                 'specify')
-            else:
-                entry = list(entries.keys())[0]
-                logger.info('take %s as default entry' % entry)
-
-    with HDF5File(process_file, 'r', swmr=True) as h5f:
-        dkref_nodes = get_process_entries(root_node=h5f[entry],
-                                          depth=MAX_DEPTH-1)
-        if len(dkref_nodes) == 0:
-            return {}
-        index_to_path = {}
-        for key, value in dkref_nodes.items():
-            index_to_path[key] = key
-
-        # take the last processed dark ref
-        last_process_index = sorted(dkref_nodes.keys())[-1]
-        last_process_dkrf = index_to_path[last_process_index]
-        if(len(index_to_path)) > 1:
-            logger.warning('several processing found for dark-ref,'
-                           'take the last one: %s' % last_process_dkrf)
-
-        res = {}
-        if 'results' in h5f[last_process_dkrf].keys():
-            results_node = h5f[last_process_dkrf]['results']
-            if 'flats' in results_node.keys():
-                flats = results_node['flats']
-                for index in flats:
-                    res[int(index)] = DataUrl(
-                        file_path=process_file,
-                        data_path=flats[index].name,
-                        scheme="silx"
-                    )
-        return res