def _hilbert(self, data):
pci1 = fft.fft2(fft.fftshift(np.float32(data)))
pci2 = fft.ifftshift(pci1) * self.filter1
fpci0 = fft.ifftshift(fft.ifft2(fft.fftshift(pci2)))
fpci = np.imag(fpci0)
result = fpci
return result
def _hilbert(self, data):
pci1 = fft.fft2(fft.fftshift(np.float32(data)))
pci2 = fft.ifftshift(pci1)*self.filter1
fpci0 = fft.ifftshift(fft.ifft2(fft.fftshift(pci2)))
fpci = np.imag(fpci0)
result = fpci
return result
def simcheck(data, nphases):
norients = data.shape[0]//nphases # need to use integer divide
# check user input before proceeding
assert nphases*norients == data.shape[0]
newshape = norients, nphases, data.shape[-2], data.shape[-1]
# FT data only along spatial dimensions
ft_data = fftshift(
fftn(ifftshift(
data, axes=(1, 2)),
axes=(1, 2)),
axes=(1, 2))
# average only along phase, **not** orientation
# This should be the equivalent of the FT of the average image per each
# phase (i.e it should be symmetric as the phases will have averaged out)
ft_data_avg = ft_data.reshape(newshape).mean(1)
# Do the same, but take the absolute value before averaging, in this case
# the signal should add up because the phase has been removed
ft_data_avg_abs = np.abs(ft_data).reshape(newshape).mean(1)
# Take the difference of the average power and the power of the average
ft_data_diff = ft_data_avg_abs-abs(ft_data_avg)
return ft_data_diff, ft_data_avg_abs, ft_data_avg
def psf_correction(self, mat, win, pad_width):
(nrow, ncol) = mat.shape
mat_pad = np.pad(mat, pad_width, mode="reflect")
win_pad = np.pad(win, pad_width, mode="constant", constant_values=1.0)
mat_dec = fft.ifft2(fft.fft2(mat_pad) / fft.ifftshift(win_pad))
return np.abs(mat_dec)[pad_width:pad_width + nrow,
pad_width:pad_width + ncol]
def process_frames(self, data):
sino = data[0]
sino2 = np.fliplr(sino[1:])
(Nrow, Ncol) = sino.shape
mask = self._create_mask(
2*Nrow-1, Ncol, 0.5*self.parameters['ratio']*Ncol)
FT1 = fft.fftshift(fft.fft2(np.vstack((sino, sino2))))
sino = fft.ifft2(fft.ifftshift(FT1 - FT1*mask))
return sino[0:Nrow].real
def sampling_op_adjoint(image, mask_as_image):
""" Adjoint of sampling operator
:param image: Assumed to be an array with shape [N,N]
:param mask_as_image:
:param mask_as_image: Mask of shape [N,N] where middle of the image
corresponds to zero frequency. Values should be 0,1 or
True/False.
:return: Array of shape [N, N] with the adjoint data.
"""
N = max(image.shape)
image_domain_data = fftw.ifft2(fftw.ifftshift(image)) * N
return image_domain_data
def fir_window_bp(delta, fl, fh):
"""
Finite impulse response, bandpass.
This filter doesn't work exactly like the matlab version due to some fourier transform imprecisions.
Consider replacing the transform calls to the FFTW versions.
"""
b = firwin(delta.shape[0]+1, (fl*2, fh*2), pass_zero=False)[:-1]
m = delta.shape[1]
batches = 20
batch_size = int(m / batches) + 1
temp = fft(ifftshift(b))
out = zeros(delta.shape, dtype=delta.dtype)
for i in range(batches):
indexes = (batch_size*i, min((batch_size*(i+1), m)))
freq = fft(delta[:,indexes[0]:indexes[1]], axis=0)*tile(temp, (delta.shape[2],indexes[1]-indexes[0], 1)).swapaxes(0,2)
out[:, indexes[0]:indexes[1]] = real(ifft(freq, axis=0))
return out
def spectral_whitening(tr,
smooth=None,
filter=None,
waterlevel=1e-8,
mask_again=True):
"""
Apply spectral whitening to data
Data is divided by its smoothed (Default: None) amplitude spectrum.
:param tr: trace to manipulate
:param smooth: length of smoothing window in Hz
(default None -> no smoothing)
:param filter: filter spectrum with bandpass after whitening
(tuple with min and max frequency)
:param waterlevel: waterlevel relative to mean of spectrum
:param mask_again: weather to mask array after this operation again and
set the corresponding data to 0
:return: whitened data
"""
sr = tr.stats.sampling_rate
data = tr.data
data = _fill_array(data, fill_value=0)
mask = np.ma.getmask(data)
nfft = next_fast_len(len(data))
spec = fft(data, nfft)
spec_ampl = np.abs(spec)
spec_ampl /= np.max(spec_ampl)
if smooth:
smooth = int(smooth * nfft / sr)
spec_ampl = ifftshift(smooth_func(fftshift(spec_ampl), smooth))
# save guard against division by 0
spec_ampl[spec_ampl < waterlevel] = waterlevel
spec /= spec_ampl
if filter is not None:
spec *= _filter_resp(*filter, sr=sr, N=len(spec), whole=True)[1]
ret = np.real(ifft(spec, nfft)[:len(data)])
if mask_again:
ret = _fill_array(ret, mask=mask, fill_value=0)
tr.data = ret
return tr
def apply_filter(self, mat, window, pattern, pad_width):
(nrow, ncol) = mat.shape
if pattern == "PROJECTION":
top_drop = 10 # To remove the time stamp at some data
mat_pad = np.pad(mat[top_drop:],
((pad_width + top_drop, pad_width),
(pad_width, pad_width)),
mode="edge")
win_pad = np.pad(window, pad_width, mode="edge")
mat_dec = fft.ifft2(
fft.fft2(-np.log(mat_pad)) / fft.ifftshift(win_pad))
mat_dec = np.abs(mat_dec[pad_width:pad_width + nrow,
pad_width:pad_width + ncol])
else:
mat_pad = np.pad(-np.log(mat), ((0, 0), (pad_width, pad_width)),
mode='edge')
win_pad = np.pad(window, ((0, 0), (pad_width, pad_width)),
mode="edge")
mat_fft = np.fft.fftshift(fft.fft(mat_pad), axes=1) / win_pad
mat_dec = fft.ifft(np.fft.ifftshift(mat_fft, axes=1))
mat_dec = np.abs(mat_dec[:, pad_width:pad_width + ncol])
return np.float32(np.exp(-mat_dec))
def cifftn(data,axes):
'''Centered ifft'''
return fftpack.fftshift(fftpack.ifftn(fftpack.ifftshift(data,axes),axes=axes))
def ifftshift(self, a, axes=None):
return scipy_fft.ifftshift(a, axes=axes)
