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