def __init__(self,
reader,
dimension=1,
index=0,
apply_deskew=True,
apply_deweighting=False):
"""
Parameters
----------
reader : SICDTypeReader
dimension : int
index : int
apply_deskew : bool
apply_deweighting : bool
"""
self._normalized_phase_history = None
self._deskew_calculator = DeskewCalculator(
reader,
dimension=dimension,
index=index,
apply_deskew=apply_deskew,
apply_deweighting=apply_deweighting)
self._sub_image_bounds = None
def create_deskewed_transform(reader, dimension=0, suffix='.sarpy.cache'):
"""
Performs the Fourier transform of the deskewed entirety of the given
ComplexImageReader contents.
Parameters
----------
reader : SICDTypeCanvasImageReader
The reader object.
dimension : int
One of [0, 1], which dimension to deskew along.
suffix : None|str
The suffix for the created file name (created using the tempfile module).
Returns
-------
(str, numpy.ndarray, numpy.ndarray)
A file name, numpy memmap of the given object, and mean along the given dimension.
Care should be taken to ensure that the file is deleted when the usage is complete.
"""
# set up a true file for the memmap
# NB: it should be noted that the tempfile usage which clean themselves up
# cannot (as of 2021-04-23) be opened multiple times on Windows, which
# means that such a "file" cannot be used in conjunction with a numpy
# memmap.
data_size = reader.data_size
sicd = reader.get_sicd()
_, file_name = mkstemp(suffix=suffix, text=False)
logger.debug('Creating temp file % s' % file_name)
# set up the memmap
memmap = numpy.memmap(file_name, dtype='complex64', mode='r+', offset=0, shape=data_size)
calculator = DeskewCalculator(
reader.base_reader, dimension=dimension, index=reader.index,
apply_deskew=True, apply_deweighting=False, apply_off_axis=False)
mean_value = numpy.zeros((data_size[0], ), dtype='float64') if dimension == 0 else \
numpy.zeros((data_size[1],), dtype='float64')
# we'll proceed in blocks of approximately this number of pixels
pixels_threshold = 2**20
# is our whole reader sufficiently small to just do it all in one fell-swoop?
if data_size[0]*data_size[1] <= 4*pixels_threshold:
data = fftshift(fft2_sicd(calculator[:, :], sicd))
memmap[:, :] = data
mean_value[:] = numpy.mean(numpy.abs(data), axis=1-dimension)
return file_name, memmap, mean_value
# fetch full rows, and transform then shift along the row direction
block_size = int(numpy.ceil(pixels_threshold/data_size[1]))
start_col = 0
while start_col < data_size[1]:
end_col = min(start_col+block_size, data_size[1])
data = fftshift(fft_sicd(calculator[:, start_col:end_col], 0, sicd), axes=0)
memmap[:, start_col:end_col] = data
if dimension == 0:
mean_value += numpy.sum(numpy.abs(data), axis=1)
start_col = end_col
# fetch full columns, and transform then shift along the column direction
block_size = int(numpy.ceil(pixels_threshold/data_size[0]))
start_row = 0
while start_row < data_size[0]:
end_row = min(start_row+block_size, data_size[0])
data = fftshift(fft_sicd(memmap[start_row:end_row, :], 1, sicd), axes=1)
memmap[start_row:end_row, :] = data
if dimension == 1:
mean_value += numpy.sum(numpy.abs(data), axis=0)
start_row = end_row
if dimension == 0:
mean_value /= data_size[1]
else:
mean_value /= data_size[0]
return file_name, memmap, mean_value