def get_number_of_nonzero_closure_phase(ifgram_file,
dsName='unwrapPhase',
step=100):
# read ifgramStack file
stack_obj = ifgramStack(ifgram_file)
stack_obj.open()
length, width = stack_obj.length, stack_obj.width
date12_list = stack_obj.get_date12_list(dropIfgram=True)
num_ifgram = len(date12_list)
C = stack_obj.get_design_matrix4triplet(date12_list)
ref_phase = stack_obj.get_reference_phase(unwDatasetName=dsName,
dropIfgram=True).reshape(
num_ifgram, -1)
# calculate number of nonzero closure phase
closure_int = np.zeros((length, width), np.int16)
num_loop = int(np.ceil(length / step))
prog_bar = ptime.progressBar(maxValue=num_loop)
for i in range(num_loop):
r0 = i * step
r1 = min((r0 + step), stack_obj.length)
box = (0, r0, stack_obj.width, r1)
unw = ifginv.read_unwrap_phase(stack_obj,
box=box,
ref_phase=ref_phase,
unwDatasetName=dsName,
dropIfgram=True,
print_msg=False).reshape(
num_ifgram, -1)
closure_pha = np.dot(C, unw)
cint = np.round((closure_pha - ut.wrap(closure_pha)) / (2. * np.pi))
closure_int[r0:r1, :] = np.sum(cint != 0, axis=0).reshape(-1, width)
prog_bar.update(i + 1, every=1)
prog_bar.close()
return closure_int
def plot_init_image(self, img_data):
"""Plot the initial 2D image."""
# prepare data
if self.wrap:
if self.disp_unit_img == 'radian':
img_data *= self.range2phase
img_data = ut.wrap(img_data, wrap_range=self.wrap_range)
# Title and Axis Label
self.disp_date_format = ptime.get_compact_isoformat(self.date_list[0])
disp_date = self.dates[self.idx].strftime(self.disp_date_format)
self.fig_title = 'N = {}, Time = {}'.format(self.idx, disp_date)
# Initial Pixel of interest
self.pts_yx = None
self.pts_lalo = None
if self.yx and self.yx != self.ref_yx:
self.pts_yx = np.array(self.yx).reshape(-1, 2)
if self.lalo:
self.pts_lalo = np.array(self.lalo).reshape(-1, 2)
# call view.py to plot
self.img, self.cbar_img = view.plot_slice(self.ax_img, img_data,
self.atr, self)[2:4]
self.fig_img.canvas.set_window_title(self.figname_img)
self.fig_img.tight_layout(rect=(0, 0, 1, 0.97))
return self.img, self.cbar_img
def on_key_event(self, event):
"""Slide images with left/right key on keyboard"""
if event.inaxes and event.inaxes.figure == self.fig_img:
idx = None
if event.key == 'left':
idx = max(self.idx - 1, 0)
elif event.key == 'right':
idx = min(self.idx + 1, self.num_date - 1)
if idx is not None and idx != self.idx:
# update title
disp_date = self.dates[idx].strftime('%Y-%m-%d')
sub_title = 'N = {n}, Time = {t}'.format(n=idx, t=disp_date)
self.ax_img.set_title(sub_title, fontsize=self.font_size)
# read data
data_img = np.array(self.ts_data[0][idx, :, :])
data_img[self.mask == 0] = np.nan
if self.wrap:
if self.disp_unit_img == 'radian':
data_img *= self.range2phase
data_img = ut.wrap(data_img, wrap_range=self.wrap_range)
# update
self.tslider.set_val(self.yearList[idx]) # update slider
self.img.set_data(data_img) # update image
self.idx = idx
self.fig_img.canvas.draw()
return
def get_number_of_nonzero_closure_phase(ifgram_file, dsName='unwrapPhase', step=100):
# read ifgramStack file
stack_obj = ifgramStack(ifgram_file)
stack_obj.open()
length, width = stack_obj.length, stack_obj.width
date12_list = stack_obj.get_date12_list(dropIfgram=True)
num_ifgram = len(date12_list)
C = stack_obj.get_design_matrix4triplet(date12_list)
ref_phase = stack_obj.get_reference_phase(unwDatasetName=dsName, dropIfgram=True).reshape(num_ifgram, -1)
# calculate number of nonzero closure phase
closure_int = np.zeros((length, width), np.int16)
num_loop = int(np.ceil(length / step))
prog_bar = ptime.progressBar(maxValue=num_loop)
for i in range(num_loop):
r0 = i * step
r1 = min((r0+step), stack_obj.length)
box = (0, r0, stack_obj.width, r1)
unw = ifginv.read_unwrap_phase(stack_obj, box=box,
ref_phase=ref_phase,
unwDatasetName=dsName,
dropIfgram=True,
print_msg=False).reshape(num_ifgram, -1)
closure_pha = np.dot(C, unw)
cint = np.round((closure_pha - ut.wrap(closure_pha)) / (2.*np.pi))
closure_int[r0:r1, :] = np.sum(cint != 0, axis=0).reshape(-1, width)
prog_bar.update(i+1, every=1)
prog_bar.close()
return closure_int
def get_nonzero_phase_closure(ifgram_file,
out_file=None,
thres=0.1,
unwDatasetName='unwrapPhase'):
"""Calculate/Read number of non-zero phase closure
Parameters: ifgram_file : string, path of ifgram stack file
out_file : string, path of num non-zero phase closure file
Returns: num_nonzero_closure : 2D np.array in size of (length, width)
"""
if not out_file:
out_file = 'numNonzeroPhaseClosure_{}.h5'.format(unwDatasetName)
if os.path.isfile(out_file) and readfile.read_attribute(out_file):
print('1. read number of nonzero phase closure from file: {}'.format(
out_file))
num_nonzero_closure = readfile.read(out_file)[0]
else:
obj = ifgramStack(ifgram_file)
obj.open(print_msg=False)
length, width = obj.length, obj.width
ref_phase = obj.get_reference_phase(unwDatasetName=unwDatasetName,
dropIfgram=False)
C = obj.get_design_matrix4triplet(
obj.get_date12_list(dropIfgram=False))
# calculate phase closure line by line to save memory usage
num_nonzero_closure = np.zeros((length, width), np.float32)
print(
'1. calculating phase closure of all pixels from dataset - {} ...'.
format(unwDatasetName))
line_step = 10
num_loop = int(np.ceil(length / line_step))
prog_bar = ptime.progressBar(maxValue=num_loop)
for i in range(num_loop):
# read phase
i0, i1 = i * line_step, min(length, (i + 1) * line_step)
box = (0, i0, width, i1)
pha_data = ifginv.read_unwrap_phase(obj,
box,
ref_phase,
unwDatasetName=unwDatasetName,
dropIfgram=False,
print_msg=False)
# calculate phase closure
pha_closure = np.dot(C, pha_data)
pha_closure = np.abs(pha_closure - ut.wrap(pha_closure))
# get number of non-zero phase closure
num_nonzero = np.sum(pha_closure >= thres, axis=0)
num_nonzero_closure[i0:i1, :] = num_nonzero.reshape(i1 - i0, width)
prog_bar.update(i + 1,
every=1,
suffix='{}/{} lines'.format((i + 1) * line_step,
length))
prog_bar.close()
atr = dict(obj.metadata)
atr['FILE_TYPE'] = 'mask'
atr['UNIT'] = 1
writefile.write(num_nonzero_closure, out_file=out_file, metadata=atr)
return num_nonzero_closure
def get_nonzero_phase_closure(ifgram_file, out_file=None, thres=0.1, unwDatasetName='unwrapPhase'):
"""Calculate/Read number of non-zero phase closure
Parameters: ifgram_file : string, path of ifgram stack file
out_file : string, path of num non-zero phase closure file
Returns: num_nonzero_closure : 2D np.array in size of (length, width)
"""
if not out_file:
out_file = 'numNonzeroPhaseClosure_{}.h5'.format(unwDatasetName)
if os.path.isfile(out_file) and readfile.read_attribute(out_file):
print('1. read number of nonzero phase closure from file: {}'.format(out_file))
num_nonzero_closure = readfile.read(out_file)[0]
else:
obj = ifgramStack(ifgram_file)
obj.open(print_msg=False)
length, width = obj.length, obj.width
ref_phase = obj.get_reference_phase(unwDatasetName=unwDatasetName, dropIfgram=False)
C = obj.get_design_matrix4triplet(obj.get_date12_list(dropIfgram=False))
# calculate phase closure line by line to save memory usage
num_nonzero_closure = np.zeros((length, width), np.float32)
print('1. calculating phase closure of all pixels from dataset - {} ...'.format(unwDatasetName))
line_step = 10
num_loop = int(np.ceil(length / line_step))
prog_bar = ptime.progressBar(maxValue=num_loop)
for i in range(num_loop):
# read phase
i0, i1 = i*line_step, min(length, (i+1)*line_step)
box = (0, i0, width, i1)
pha_data = ifginv.read_unwrap_phase(obj,
box,
ref_phase,
unwDatasetName=unwDatasetName,
dropIfgram=False,
print_msg=False)
# calculate phase closure
pha_closure = np.dot(C, pha_data)
pha_closure = np.abs(pha_closure - ut.wrap(pha_closure))
# get number of non-zero phase closure
num_nonzero = np.sum(pha_closure >= thres, axis=0)
num_nonzero_closure[i0:i1, :] = num_nonzero.reshape(i1-i0, width)
prog_bar.update(i+1, every=1, suffix='{}/{} lines'.format((i+1)*line_step, length))
prog_bar.close()
atr = dict(obj.metadata)
atr['FILE_TYPE'] = 'mask'
atr['UNIT'] = 1
writefile.write(num_nonzero_closure, out_file=out_file, metadata=atr)
return num_nonzero_closure
def update_time_slider(self, val):
"""Update Displacement Map using Slider"""
idx = np.argmin(np.abs(np.array(self.yearList) - self.tslider.val))
# update title
disp_date = self.dates[idx].strftime('%Y-%m-%d')
self.ax_img.set_title('N = {n}, Time = {t}'.format(n=idx, t=disp_date), fontsize=self.font_size)
# read data
data_img = np.array(self.ts_data[0][idx, :, :])
data_img[self.mask == 0] = np.nan
if self.wrap:
if self.disp_unit_img == 'radian':
data_img *= self.range2phase
data_img = ut.wrap(data_img, wrap_range=self.wrap_range)
# update data
self.img.set_data(data_img)
self.fig_img.canvas.draw()
return
def plot_init_image(self, img_data):
# prepare data
if self.wrap:
if self.disp_unit_img == 'radian':
img_data *= self.range2phase
img_data = ut.wrap(img_data, wrap_range=self.wrap_range)
# Title and Axis Label
disp_date = self.dates[self.idx].strftime('%Y-%m-%d')
self.fig_title = 'N = {}, Time = {}'.format(self.idx, disp_date)
# Initial Pixel of interest
self.pts_yx = None
self.pts_lalo = None
if self.yx and self.yx != self.ref_yx:
self.pts_yx = np.array(self.yx).reshape(-1, 2)
if self.lalo:
self.pts_lalo = np.array(self.lalo).reshape(-1, 2)
# call view.py to plot
self.img, self.cbar_img = view.plot_slice(self.ax_img, img_data, self.atr, self)[2:4]
return self.img, self.cbar_img
def update_time_slider(self, val):
"""Update Displacement Map using Slider"""
self.idx = self.tslider.val
# update title
disp_date = self.dates[self.idx].strftime(self.disp_date_format)
sub_title = 'N = {n}, Time = {t}'.format(n=self.idx, t=disp_date)
self.ax_img.set_title(sub_title, fontsize=self.font_size)
# read/update 2D image data
data_img = np.array(self.ts_data[0][self.idx, :, :])
data_img[self.mask == 0] = np.nan
if self.wrap:
if self.disp_unit_img == 'radian':
data_img *= self.range2phase
data_img = ut.wrap(data_img, wrap_range=self.wrap_range)
self.img.set_data(data_img)
# update figure
self.fig_img.canvas.draw_idle()
self.fig_img.canvas.flush_events()
return
def get_common_region_int_ambiguity(ifgram_file,
cc_mask_file,
water_mask_file=None,
num_sample=100,
dsNameIn='unwrapPhase'):
"""Solve the phase unwrapping integer ambiguity for the common regions among all interferograms
Parameters: ifgram_file : str, path of interferogram stack file
cc_mask_file : str, path of common connected components file
water_mask_file : str, path of water mask file
num_sample : int, number of pixel sampled for each region
dsNameIn : str, dataset name of the unwrap phase to be corrected
Returns: common_regions : list of skimage.measure._regionprops._RegionProperties object
modified by adding two more variables:
sample_coords : 2D np.ndarray in size of (num_sample, 2) in int64 format
int_ambiguity : 1D np.ndarray in size of (num_ifgram,) in int format
"""
print('-' * 50)
print(
'calculating the integer ambiguity for the common regions defined in',
cc_mask_file)
# stack info
stack_obj = ifgramStack(ifgram_file)
stack_obj.open()
date12_list = stack_obj.get_date12_list(dropIfgram=True)
num_ifgram = len(date12_list)
C = matrix(
ifgramStack.get_design_matrix4triplet(date12_list).astype(float))
ref_phase = stack_obj.get_reference_phase(unwDatasetName=dsNameIn,
dropIfgram=True).reshape(
num_ifgram, -1)
# prepare common label
print('read common mask from', cc_mask_file)
cc_mask = readfile.read(cc_mask_file)[0]
if water_mask_file is not None and os.path.isfile(water_mask_file):
water_mask = readfile.read(water_mask_file)[0]
print('refine common mask based on water mask file', water_mask_file)
cc_mask[water_mask == 0] = 0
label_img, num_label = connectComponent.get_large_label(cc_mask,
min_area=2.5e3,
print_msg=True)
common_regions = measure.regionprops(label_img)
print('number of common regions:', num_label)
# add sample_coords / int_ambiguity
print('number of samples per region:', num_sample)
print('solving the phase-unwrapping integer ambiguity for {}'.format(
dsNameIn))
print(
'\tbased on the closure phase of interferograms triplets (Yunjun et al., 2019)'
)
print(
'\tusing the L1-norm regularzed least squares approximation (LASSO) ...'
)
for i in range(num_label):
common_reg = common_regions[i]
# sample_coords
idx = sorted(
np.random.choice(common_reg.area, num_sample, replace=False))
common_reg.sample_coords = common_reg.coords[idx, :].astype(int)
# solve for int_ambiguity
U = np.zeros((num_ifgram, num_sample))
if common_reg.label == label_img[stack_obj.refY, stack_obj.refX]:
print('{}/{} skip calculation for the reference region'.format(
i + 1, num_label))
else:
prog_bar = ptime.progressBar(maxValue=num_sample,
prefix='{}/{}'.format(
i + 1, num_label))
for j in range(num_sample):
# read unwrap phase
y, x = common_reg.sample_coords[j, :]
unw = ifginv.read_unwrap_phase(stack_obj,
box=(x, y, x + 1, y + 1),
ref_phase=ref_phase,
unwDatasetName=dsNameIn,
dropIfgram=True,
print_msg=False).reshape(
num_ifgram, -1)
# calculate closure_int
closure_pha = np.dot(C, unw)
closure_int = matrix(
np.round(
(closure_pha - ut.wrap(closure_pha)) / (2. * np.pi)))
# solve for U
U[:, j] = np.round(
l1regls(-C, closure_int, alpha=1e-2,
show_progress=0)).flatten()
prog_bar.update(j + 1, every=5)
prog_bar.close()
# add int_ambiguity
common_reg.int_ambiguity = np.median(U, axis=1)
common_reg.date12_list = date12_list
#sort regions by size to facilitate the region matching later
common_regions.sort(key=lambda x: x.area, reverse=True)
# plot sample result
fig_size = pp.auto_figure_size(label_img.shape, disp_cbar=False)
fig, ax = plt.subplots(figsize=fig_size)
ax.imshow(label_img, cmap='jet')
for common_reg in common_regions:
ax.plot(common_reg.sample_coords[:, 1],
common_reg.sample_coords[:, 0],
'k.',
ms=2)
pp.auto_flip_direction(stack_obj.metadata, ax, print_msg=False)
out_img = 'common_region_sample.png'
fig.savefig(out_img, bbox_inches='tight', transparent=True, dpi=300)
print('saved common regions and sample pixels to file', out_img)
return common_regions
def calc_num_nonzero_integer_closure_phase(ifgram_file,
mask_file=None,
dsName='unwrapPhase',
out_file=None,
step=50,
update_mode=True):
"""Calculate the number of non-zero integer ambiguity of closure phase.
T_int as shown in equation (8-9) and inline in Yunjun et al. (2019, CAGEO).
Parameters: ifgram_file - str, path of interferogram stack file
mask_file - str, path of mask file
dsName - str, unwrapped phase dataset name used to calculate the closure phase
out_file - str, custom output filename
step - int, number of row in each block to calculate T_int
update_mode - bool
Returns: out_file - str, custom output filename
Example: calc_num_nonzero_integer_closure_phase('inputs/ifgramStack.h5', mask_file='waterMask.h5')
"""
# default output file path
if out_file is None:
out_dir = os.path.dirname(os.path.dirname(ifgram_file))
if dsName == 'unwrapPhase':
# skip the default dsName in output filename
out_file = 'numNonzeroIntClosure.h5'
else:
out_file = 'numNonzeroIntClosure4{}.h5'.format(dsName)
out_file = os.path.join(out_dir, out_file)
if update_mode and os.path.isfile(out_file):
print('output file "{}" already exists, skip re-calculating.'.format(
out_file))
return out_file
# read ifgramStack file
stack_obj = ifgramStack(ifgram_file)
stack_obj.open()
length, width = stack_obj.length, stack_obj.width
date12_list = stack_obj.get_date12_list(dropIfgram=True)
num_ifgram = len(date12_list)
C = stack_obj.get_design_matrix4triplet(date12_list)
ref_phase = stack_obj.get_reference_phase(unwDatasetName=dsName,
dropIfgram=True).reshape(
num_ifgram, -1)
print('get design matrix for the interferogram triplets in size of {}'.
format(C.shape))
# calculate number of nonzero closure phase
num_loop = int(np.ceil(length / step))
num_nonzero_closure = np.zeros((length, width), dtype=np.float32)
msg = 'calcualting the number of triplets with non-zero integer ambiguity of closure phase ...'
msg += '\n block by block with size up to {}, {} blocks in total'.format(
(step, width), num_loop)
print(msg)
prog_bar = ptime.progressBar(maxValue=num_loop)
for i in range(num_loop):
# box
r0 = i * step
r1 = min((r0 + step), stack_obj.length)
box = (0, r0, stack_obj.width, r1)
# read data
unw = ifginv.read_unwrap_phase(stack_obj,
box=box,
ref_phase=ref_phase,
obsDatasetName=dsName,
dropIfgram=True,
print_msg=False).reshape(
num_ifgram, -1)
# calculate based on equation (8-9) and T_int equation inline.
closure_pha = np.dot(C, unw)
closure_int = np.round(
(closure_pha - ut.wrap(closure_pha)) / (2. * np.pi))
num_nonzero_closure[r0:r1, :] = np.sum(closure_int != 0,
axis=0).reshape(-1, width)
prog_bar.update(i + 1, every=1)
prog_bar.close()
# mask
if mask_file is not None:
print('masking with file', mask_file)
mask = readfile.read(mask_file)[0]
num_nonzero_closure[mask == 0] = np.nan
# write to disk
print('write to file', out_file)
meta = dict(stack_obj.metadata)
meta['FILE_TYPE'] = 'mask'
meta['UNIT'] = '1'
writefile.write(num_nonzero_closure, out_file, meta)
# plot
plot_num_nonzero_integer_closure_phase(out_file)
return out_file
def calc_num_triplet_with_nonzero_integer_ambiguity(ifgram_file,
mask_file=None,
dsName='unwrapPhase',
out_file=None,
max_memory=4,
update_mode=True):
"""Calculate the number of triplets with non-zero integer ambiguity of closure phase.
T_int as shown in equation (8-9) and inline in Yunjun et al. (2019, CAGEO).
Parameters: ifgram_file - str, path of interferogram stack file
mask_file - str, path of mask file
dsName - str, unwrapped phase dataset name used to calculate the closure phase
out_file - str, custom output filename
update_mode - bool
Returns: out_file - str, custom output filename
Example: calc_num_triplet_with_nonzero_integer_ambiguity('inputs/ifgramStack.h5', mask_file='waterMask.h5')
"""
# default output file path
out_dir = os.path.dirname(os.path.dirname(ifgram_file))
if out_file is None:
if dsName == 'unwrapPhase':
# skip the default dsName in output filename
out_file = 'numTriNonzeroIntAmbiguity.h5'
else:
out_file = 'numTriNonzeroIntAmbiguity4{}.h5'.format(dsName)
out_file = os.path.join(out_dir, out_file)
# update mode
if update_mode and os.path.isfile(out_file):
print('update mode: ON')
print('1) output file "{}" already exists'.format(out_file))
flag = 'skip'
# check modification time
with h5py.File(ifgram_file, 'r') as f:
ti = float(f[dsName].attrs.get('MODIFICATION_TIME',
os.path.getmtime(ifgram_file)))
to = os.path.getmtime(out_file)
if ti > to:
print('2) output file is NOT newer than input dataset')
flag = 'run'
else:
print('2) output file is newer than input dataset')
# check REF_Y/X
key_list = ['REF_Y', 'REF_X']
atri = readfile.read_attribute(ifgram_file)
atro = readfile.read_attribute(out_file)
if not all(atri[i] == atro[i] for i in key_list):
print('3) NOT all key configurations are the same: {}'.format(
key_list))
flag = 'run'
else:
print(
'3) all key configurations are the same: {}'.format(key_list))
print('run or skip: {}.'.format(flag))
if flag == 'skip':
return out_file
# read ifgramStack file
stack_obj = ifgramStack(ifgram_file)
stack_obj.open()
length, width = stack_obj.length, stack_obj.width
date12_list = stack_obj.get_date12_list(dropIfgram=True)
num_ifgram = len(date12_list)
C = stack_obj.get_design_matrix4triplet(date12_list)
if C is None:
msg = 'No triangles found from ifgramStack file: {}!'.format(
ifgram_file)
msg += '\n Skip calculating the number of triplets with non-zero integer ambiguity.'
print(msg)
return None
else:
print('get design matrix for the interferogram triplets in size of {}'.
format(C.shape))
# calculate number of nonzero closure phase
ds_size = (C.shape[0] * 2 + C.shape[1]) * length * width * 4
num_loop = int(np.ceil(ds_size * 2 / (max_memory * 1024**3)))
step = int(np.rint(length / num_loop / 10) * 10)
num_loop = int(np.ceil(length / step))
num_nonzero_closure = np.zeros((length, width), dtype=np.float32)
msg = 'calculating the number of triplets with non-zero integer ambiguity of closure phase ...'
msg += '\n block by block with size up to {}, {} blocks in total'.format(
(step, width), num_loop)
print(msg)
ref_phase = stack_obj.get_reference_phase(unwDatasetName=dsName,
dropIfgram=True).reshape(
num_ifgram, -1)
prog_bar = ptime.progressBar(maxValue=num_loop)
for i in range(num_loop):
# box
r0 = i * step
r1 = min((r0 + step), stack_obj.length)
box = (0, r0, stack_obj.width, r1)
# read data
unw = ifginv.read_unwrap_phase(stack_obj,
box=box,
ref_phase=ref_phase,
obs_ds_name=dsName,
dropIfgram=True,
print_msg=False).reshape(
num_ifgram, -1)
# calculate based on equation (8-9) and T_int equation inline.
closure_pha = np.dot(C, unw)
closure_int = np.round(
(closure_pha - ut.wrap(closure_pha)) / (2. * np.pi))
num_nonzero_closure[r0:r1, :] = np.sum(closure_int != 0,
axis=0).reshape(-1, width)
prog_bar.update(i + 1,
every=1,
suffix='line {} / {}'.format(r0, length))
prog_bar.close()
# mask
if mask_file is not None:
mask = readfile.read(mask_file)[0]
num_nonzero_closure[mask == 0] = np.nan
print('mask out pixels with zero in file:', mask_file)
coh_file = os.path.join(out_dir, 'avgSpatialCoh.h5')
if os.path.isfile(coh_file):
coh = readfile.read(coh_file)[0]
num_nonzero_closure[coh == 0] = np.nan
print('mask out pixels with zero in file:', coh_file)
# write to disk
print('write to file', out_file)
meta = dict(stack_obj.metadata)
meta['FILE_TYPE'] = 'mask'
meta['UNIT'] = '1'
writefile.write(num_nonzero_closure, out_file, meta)
# plot
plot_num_triplet_with_nonzero_integer_ambiguity(out_file)
return out_file
def get_common_region_int_ambiguity(ifgram_file, cc_mask_file, water_mask_file=None, num_sample=100,
dsNameIn='unwrapPhase'):
"""Solve the phase unwrapping integer ambiguity for the common regions among all interferograms
Parameters: ifgram_file : str, path of interferogram stack file
cc_mask_file : str, path of common connected components file
water_mask_file : str, path of water mask file
num_sample : int, number of pixel sampled for each region
dsNameIn : str, dataset name of the unwrap phase to be corrected
Returns: common_regions : list of skimage.measure._regionprops._RegionProperties object
modified by adding two more variables:
sample_coords : 2D np.ndarray in size of (num_sample, 2) in int64 format
int_ambiguity : 1D np.ndarray in size of (num_ifgram,) in int format
"""
print('-'*50)
print('calculating the integer ambiguity for the common regions defined in', cc_mask_file)
# stack info
stack_obj = ifgramStack(ifgram_file)
stack_obj.open()
date12_list = stack_obj.get_date12_list(dropIfgram=True)
num_ifgram = len(date12_list)
C = matrix(ifgramStack.get_design_matrix4triplet(date12_list).astype(float))
ref_phase = stack_obj.get_reference_phase(unwDatasetName=dsNameIn, dropIfgram=True).reshape(num_ifgram, -1)
# prepare common label
print('read common mask from', cc_mask_file)
cc_mask = readfile.read(cc_mask_file)[0]
if water_mask_file is not None and os.path.isfile(water_mask_file):
water_mask = readfile.read(water_mask_file)[0]
print('refine common mask based on water mask file', water_mask_file)
cc_mask[water_mask == 0] = 0
label_img, num_label = connectComponent.get_large_label(cc_mask, min_area=2.5e3, print_msg=True)
common_regions = measure.regionprops(label_img)
print('number of common regions:', num_label)
# add sample_coords / int_ambiguity
print('number of samples per region:', num_sample)
print('solving the phase-unwrapping integer ambiguity for {}'.format(dsNameIn))
print('\tbased on the closure phase of interferograms triplets (Yunjun et al., 2019)')
print('\tusing the L1-norm regularzed least squares approximation (LASSO) ...')
for i in range(num_label):
common_reg = common_regions[i]
# sample_coords
idx = sorted(np.random.choice(common_reg.area, num_sample, replace=False))
common_reg.sample_coords = common_reg.coords[idx, :].astype(int)
# solve for int_ambiguity
U = np.zeros((num_ifgram, num_sample))
if common_reg.label == label_img[stack_obj.refY, stack_obj.refX]:
print('{}/{} skip calculation for the reference region'.format(i+1, num_label))
else:
prog_bar = ptime.progressBar(maxValue=num_sample, prefix='{}/{}'.format(i+1, num_label))
for j in range(num_sample):
# read unwrap phase
y, x = common_reg.sample_coords[j, :]
unw = ifginv.read_unwrap_phase(stack_obj,
box=(x, y, x+1, y+1),
ref_phase=ref_phase,
unwDatasetName=dsNameIn,
dropIfgram=True,
print_msg=False).reshape(num_ifgram, -1)
# calculate closure_int
closure_pha = np.dot(C, unw)
closure_int = matrix(np.round((closure_pha - ut.wrap(closure_pha)) / (2.*np.pi)))
# solve for U
U[:,j] = np.round(l1regls(-C, closure_int, alpha=1e-2, show_progress=0)).flatten()
prog_bar.update(j+1, every=5)
prog_bar.close()
# add int_ambiguity
common_reg.int_ambiguity = np.median(U, axis=1)
common_reg.date12_list = date12_list
#sort regions by size to facilitate the region matching later
common_regions.sort(key=lambda x: x.area, reverse=True)
# plot sample result
fig_size = pp.auto_figure_size(label_img.shape, disp_cbar=False)
fig, ax = plt.subplots(figsize=fig_size)
ax.imshow(label_img, cmap='jet')
for common_reg in common_regions:
ax.plot(common_reg.sample_coords[:,1],
common_reg.sample_coords[:,0], 'k.', ms=2)
pp.auto_flip_direction(stack_obj.metadata, ax, print_msg=False)
out_img = 'common_region_sample.png'
fig.savefig(out_img, bbox_inches='tight', transparent=True, dpi=300)
print('saved common regions and sample pixels to file', out_img)
return common_regions
