# Source code for tomopy.prep.normalize

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# #########################################################################
#                                                                         #
# 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 data normalization.
"""

from __future__ import (absolute_import, division, print_function,
unicode_literals)

import numpy as np
import tomopy.util.mproc as mproc
import tomopy.util.extern as extern
import tomopy.util.dtype as dtype
import logging
import numexpr as ne

logger = logging.getLogger(__name__)

__author__ = "Doga Gursoy, Luis Barroso-Luque"
__credits__ = "Mark Rivers"
__docformat__ = 'restructuredtext en'
__all__ = ['minus_log',
'normalize',
'normalize_bg',
'normalize_roi',
'normalize_nf']

[docs]def minus_log(arr, ncore=None, out=None):
"""
Computation of the minus log of a given array.

Parameters
----------
arr : ndarray
3D stack of projections.
ncore : int, optional
Number of cores that will be assigned to jobs.
out : ndarray, optional
Output array for result. If same as arr, process
will be done in-place.

Returns
-------
ndarray
Minus-log of the input data.
"""
arr = dtype.as_float32(arr)

out = ne.evaluate('-log(arr)', out=out)
return out

[docs]def normalize(arr, flat, dark, cutoff=None, ncore=None, out=None):
"""
Normalize raw projection data using the flat and dark field projections.

Parameters
----------
arr : ndarray
3D stack of projections.
flat : ndarray
3D flat field data.
dark : ndarray
3D dark field data.
cutoff : float, optional
Permitted maximum vaue for the normalized data.
ncore : int, optional
Number of cores that will be assigned to jobs.
out : ndarray, optional
Output array for result. If same as arr,
process will be done in-place.

Returns
-------
ndarray
Normalized 3D tomographic data.
"""
arr = dtype.as_float32(arr)
l = np.float32(1e-6)
flat = np.mean(flat, axis=0, dtype=np.float32)
dark = np.mean(dark, axis=0, dtype=np.float32)

denom = ne.evaluate('flat-dark')
ne.evaluate('where(denom<l,l,denom)', out=denom)
out = ne.evaluate('arr-dark', out=out)
ne.evaluate('out/denom', out=out, truediv=True)
if cutoff is not None:
cutoff = np.float32(cutoff)
ne.evaluate('where(out>cutoff,cutoff,out)', out=out)
return out

# TODO: replace roi indexes with slc object
[docs]def normalize_roi(arr, roi=[0, 0, 10, 10], ncore=None):
"""
Normalize raw projection data using an average of a selected window
on projection images.

Parameters
----------
arr : ndarray
3D tomographic data.
roi: list of int, optional
[top-left, top-right, bottom-left, bottom-right] pixel coordinates.
ncore : int, optional
Number of cores that will be assigned to jobs.

Returns
-------
ndarray
Normalized 3D tomographic data.
"""
arr = dtype.as_float32(arr)

arr = mproc.distribute_jobs(
arr,
func=_normalize_roi,
args=(roi, ),
axis=0,
ncore=ncore,
nchunk=0)
return arr

def _normalize_roi(proj, roi):
bg = proj[roi[0]:roi[2], roi[1]:roi[3]].mean()
# avoid divide by zero
if bg != 0:
np.true_divide(proj, bg, proj)

[docs]def normalize_bg(tomo, air=1, ncore=None, nchunk=None):
"""
Normalize 3D tomgraphy data based on background intensity.

Weight sinogram such that the left and right image boundaries
(i.e., typically the air region around the object) are set to one
and all intermediate values are scaled linearly.

Parameters
----------
tomo : ndarray
3D tomographic data.
air : int, optional
Number of pixels at each boundary to calculate the scaling factor.
ncore : int, optional
Number of cores that will be assigned to jobs.
nchunk : int, optional
Chunk size for each core.

Returns
-------
ndarray
Corrected 3D tomographic data.
"""
tomo = dtype.as_float32(tomo)
air = dtype.as_int32(air)

arr = mproc.distribute_jobs(
tomo,
func=extern.c_normalize_bg,
args=(air,),
axis=0,
ncore=ncore,
nchunk=nchunk)
return arr

[docs]def normalize_nf(tomo, flats, dark, flat_loc,
cutoff=None, ncore=None, out=None):
"""
Normalize raw 3D projection data with flats taken more than once during
tomography. Normalization for each projection is done with the mean of the
nearest set of flat fields (nearest flat fields).

Parameters
----------
tomo : ndarray
3D tomographic data.
flats : ndarray
3D flat field data.
dark : ndarray
3D dark field data.
flat_loc : list of int
Indices of flat field data within tomography
ncore : int, optional
Number of cores that will be assigned to jobs.
out : ndarray, optional
Output array for result. If same as arr, process
will be done in-place.

Returns
-------
ndarray
Normalized 3D tomographic data.
"""

tomo = dtype.as_float32(tomo)
flats = dtype.as_float32(flats)
dark = dtype.as_float32(dark)
l = np.float32(1e-6)
if cutoff is not None:
cutoff = np.float32(cutoff)
if out is None:
out = np.empty_like(tomo)

dark = np.median(dark, axis=0)
denom = np.empty_like(dark)

num_flats = len(flat_loc)
total_flats = flats.shape[0]
total_tomo = tomo.shape[0]

num_per_flat = total_flats//num_flats
tend = 0

for m, loc in enumerate(flat_loc):
fstart = m*num_per_flat
fend = (m + 1)*num_per_flat
flat = np.median(flats[fstart:fend], axis=0)

# Normalization can be parallelized much more efficiently outside this
# for loop accounting for the nested parallelism arising from
# chunking the total normalization and each chunked normalization
tstart = 0 if m == 0 else tend
tend = total_tomo if m >= num_flats-1 \
else int(np.round((flat_loc[m+1]-loc)/2)) + loc
tomo_l = tomo[tstart:tend]
out_l = out[tstart:tend]