def read_baseline_info(baseline_file, reference_file):
"""Read date, bperp and/or DOP info
Parameters: baseline_file : str, path of bl_list.txt file
reference_file : str, path of ifgramStack.h5 file
Returns: date_list : list of str in YYMMDD format
tbase_list : list of int in days
pbase_list : list of float in meter
dop_list : None, list of 1D array in size of (3,)
"""
dop_list = None
if baseline_file:
date_list, pbase_list, dop_list = pnet.read_baseline_file(
baseline_file)[0:3]
date_list = ptime.yymmdd(date_list)
tbase_list = ptime.date_list2tbase(date_list)[0]
elif reference_file:
obj = ifgramStack(reference_file)
date12_list_all = obj.get_date12_list(dropIfgram=False)
date12_list_all = ptime.yymmdd_date12(date12_list_all)
m_dates = [i.split('-')[0] for i in date12_list_all]
s_dates = [i.split('-')[1] for i in date12_list_all]
date_list = sorted(list(set(m_dates + s_dates)))
tbase_list = ptime.date_list2tbase(date_list)[0]
pbase_list = obj.get_perp_baseline_timeseries(
dropIfgram=False).tolist()
return date_list, tbase_list, pbase_list, dop_list
def velocity2timeseries(date_list, vel=0.03, display=False):
'''Simulate displacement time-series from linear velocity
Inputs:
date_list - list of string in YYYYMMDD or YYMMDD format
vel - float, velocity in meter per year
display - bool, display simulation or not
Output:
ts - 2D np.array in size of (date_num,1), displacement time-series in m
Example:
date_list = pnet.read_baseline_file('bl_list.txt')[0]
ts0 = simulate_timeseries(date_list, vel=0.03, display=True)
'''
tbase_list = ptime.date_list2tbase(date_list)[0]
ts = vel / 365.25 * np.array(tbase_list)
ts = ts.reshape(-1, 1)
if display:
dates = ptime.date_list2vector(date_list)[0]
## Display
marker_size = 5
plt.figure()
plt.scatter(dates, ts * 100.0, s=marker_size**2)
plt.xlabel('Time (years)')
plt.ylabel('LOS Displacement (cm)')
plt.title('Displacement time-series with velocity = ' + str(vel) +
' m/yr')
plt.show()
return ts
def select_master_date(date_list, pbase_list=[]):
"""Select super master date based on input temporal and/or perpendicular baseline info.
Return master date in YYYYMMDD format.
"""
date8_list = ptime.yyyymmdd(date_list)
if not pbase_list:
# Choose date in the middle
m_date8 = date8_list[int(len(date8_list) / 2)]
else:
# Get temporal baseline list
tbase_list = ptime.date_list2tbase(date8_list)[0]
# Normalization (Pepe and Lanari, 2006, TGRS)
temp2perp_scale = (max(pbase_list) - min(pbase_list)) / (
max(tbase_list) - min(tbase_list))
tbase_list = [tbase * temp2perp_scale for tbase in tbase_list]
# Get distance matrix
ttMat1, ttMat2 = np.meshgrid(np.array(tbase_list),
np.array(tbase_list))
ppMat1, ppMat2 = np.meshgrid(np.array(pbase_list),
np.array(pbase_list))
ttMat = np.abs(ttMat1 - ttMat2) # temporal distance matrix
ppMat = np.abs(ppMat1 - ppMat2) # spatial distance matrix
# 2D distance matrix in temp/perp domain
disMat = np.sqrt(np.square(ttMat) + np.square(ppMat))
# Choose date minimize the total distance of temp/perp baseline
disMean = np.mean(disMat, 0)
m_idx = np.argmin(disMean)
m_date8 = date8_list[m_idx]
return m_date8
def select_master_interferogram(date12_list,
date_list,
pbase_list,
m_date=None):
"""Select reference interferogram based on input temp/perp baseline info
If master_date is specified, select its closest slave_date, which is newer than master_date;
otherwise, choose the closest pair among all pairs as master interferogram.
Example:
master_date12 = pnet.select_master_ifgram(date12_list, date_list, pbase_list)
'080211-080326' = pnet.select_master_ifgram(date12_list, date_list, pbase_list, m_date='080211')
"""
pbase_array = np.array(pbase_list, dtype='float64')
# Get temporal baseline
date8_list = ptime.yyyymmdd(date_list)
date6_list = ptime.yymmdd(date8_list)
tbase_array = np.array(ptime.date_list2tbase(date8_list)[0],
dtype='float64')
# Normalization (Pepe and Lanari, 2006, TGRS)
temp2perp_scale = (max(pbase_array) - min(pbase_array)) / (
max(tbase_array) - min(tbase_array))
tbase_array *= temp2perp_scale
# Calculate sqrt of temp/perp baseline for input pairs
idx1 = np.array(
[date6_list.index(date12.split('-')[0]) for date12 in date12_list])
idx2 = np.array(
[date6_list.index(date12.split('-')[1]) for date12 in date12_list])
base_distance = np.sqrt((tbase_array[idx2] - tbase_array[idx1])**2 +
(pbase_array[idx2] - pbase_array[idx1])**2)
# Get master interferogram index
if not m_date:
# Choose pair with shortest temp/perp baseline
m_date12_idx = np.argmin(base_distance)
else:
m_date = ptime.yymmdd(m_date)
# Choose pair contains m_date with shortest temp/perp baseline
m_date12_idx_array = np.array([
date12_list.index(date12) for date12 in date12_list
if m_date + '-' in date12
])
min_base_distance = np.min(base_distance[m_date12_idx_array])
m_date12_idx = np.where(base_distance == min_base_distance)[0][0]
m_date12 = date12_list[m_date12_idx]
return m_date12
def select_pairs_mst(date_list, pbase_list, date12_format='YYMMDD-YYMMDD'):
"""Select Pairs using Minimum Spanning Tree technique
Connection Cost is calculated using the baseline distance in perp and scaled temporal baseline (Pepe and Lanari,
2006, TGRS) plane.
Inputs:
date_list : list of date in YYMMDD/YYYYMMDD format
pbase_list : list of float, perpendicular spatial baseline
References:
Pepe, A., and R. Lanari (2006), On the extension of the minimum cost flow algorithm for phase unwrapping
of multitemporal differential SAR interferograms, IEEE TGRS, 44(9), 2374-2383.
Perissin D., Wang T. (2012), Repeat-pass SAR interferometry with partially coherent targets. IEEE TGRS. 271-280
"""
# Get temporal baseline in days
date6_list = ptime.yymmdd(date_list)
date8_list = ptime.yyyymmdd(date_list)
tbase_list = ptime.date_list2tbase(date8_list)[0]
# Normalization (Pepe and Lanari, 2006, TGRS)
temp2perp_scale = (max(pbase_list) - min(pbase_list)) / (max(tbase_list) -
min(tbase_list))
tbase_list = [tbase * temp2perp_scale for tbase in tbase_list]
# Get weight matrix
ttMat1, ttMat2 = np.meshgrid(np.array(tbase_list), np.array(tbase_list))
ppMat1, ppMat2 = np.meshgrid(np.array(pbase_list), np.array(pbase_list))
ttMat = np.abs(ttMat1 - ttMat2) # temporal distance matrix
ppMat = np.abs(ppMat1 - ppMat2) # spatial distance matrix
# 2D distance matrix in temp/perp domain
weightMat = np.sqrt(np.square(ttMat) + np.square(ppMat))
weightMat = sparse.csr_matrix(weightMat) # compress sparse row matrix
# MST path based on weight matrix
mstMat = sparse.csgraph.minimum_spanning_tree(weightMat)
# Convert MST index matrix into date12 list
[s_idx_list, m_idx_list] = [
date_idx_array.tolist() for date_idx_array in sparse.find(mstMat)[0:2]
]
date12_list = []
for i in range(len(m_idx_list)):
idx = sorted([m_idx_list[i], s_idx_list[i]])
date12 = date6_list[idx[0]] + '-' + date6_list[idx[1]]
date12_list.append(date12)
if date12_format == 'YYYYMMDD_YYYYMMDD':
date12_list = ptime.yyyymmdd_date12(date12_list)
return date12_list
def select_pairs_delaunay(date_list,
pbase_list,
norm=True,
date12_format='YYMMDD-YYMMDD'):
"""Select Pairs using Delaunay Triangulation based on temporal/perpendicular baselines
Inputs:
date_list : list of date in YYMMDD/YYYYMMDD format
pbase_list : list of float, perpendicular spatial baseline
norm : normalize temporal baseline to perpendicular baseline
Key points
1. Define a ratio between perpendicular and temporal baseline axis units (Pepe and Lanari, 2006, TGRS).
2. Pairs with too large perpendicular / temporal baseline or Doppler centroid difference should be removed
after this, using a threshold, to avoid strong decorrelations (Zebker and Villasenor, 1992, TGRS).
Reference:
Pepe, A., and R. Lanari (2006), On the extension of the minimum cost flow algorithm for phase unwrapping
of multitemporal differential SAR interferograms, IEEE TGRS, 44(9), 2374-2383.
Zebker, H. A., and J. Villasenor (1992), Decorrelation in interferometric radar echoes, IEEE TGRS, 30(5), 950-959.
"""
# Get temporal baseline in days
date6_list = ptime.yymmdd(date_list)
date8_list = ptime.yyyymmdd(date_list)
tbase_list = ptime.date_list2tbase(date8_list)[0]
# Normalization (Pepe and Lanari, 2006, TGRS)
if norm:
temp2perp_scale = (max(pbase_list) - min(pbase_list)) / (
max(tbase_list) - min(tbase_list))
tbase_list = [tbase * temp2perp_scale for tbase in tbase_list]
# Generate Delaunay Triangulation
date12_idx_list = Triangulation(tbase_list, pbase_list).edges.tolist()
date12_idx_list = [sorted(idx) for idx in sorted(date12_idx_list)]
# Convert index into date12
date12_list = [
date6_list[idx[0]] + '-' + date6_list[idx[1]]
for idx in date12_idx_list
]
if date12_format == 'YYYYMMDD_YYYYMMDD':
date12_list = ptime.yyyymmdd_date12(date12_list)
return date12_list
def threshold_temporal_baseline(date12_list,
btemp_max,
keep_seasonal=True,
btemp_min=0.0):
"""Remove pairs/interferograms out of min/max/seasonal temporal baseline limits
Inputs:
date12_list : list of string for date12 in YYMMDD-YYMMDD format
btemp_max : float, maximum temporal baseline
btemp_min : float, minimum temporal baseline
keep_seasonal : keep interferograms with seasonal temporal baseline
Output:
date12_list_out : list of string for date12 in YYMMDD-YYMMDD format
Example:
date12_list = threshold_temporal_baseline(date12_list, 200)
date12_list = threshold_temporal_baseline(date12_list, 200, False)
"""
if not date12_list:
return []
# Get date list and tbase list
m_dates = [date12.split('-')[0] for date12 in date12_list]
s_dates = [date12.split('-')[1] for date12 in date12_list]
date8_list = sorted(ptime.yyyymmdd(list(set(m_dates + s_dates))))
date6_list = ptime.yymmdd(date8_list)
tbase_list = ptime.date_list2tbase(date8_list)[0]
# Threshold
date12_list_out = []
for date12 in date12_list:
date1, date2 = date12.split('-')
idx1 = date6_list.index(date1)
idx2 = date6_list.index(date2)
tbase = int(abs(tbase_list[idx1] - tbase_list[idx2]))
if btemp_min <= tbase <= btemp_max:
date12_list_out.append(date12)
elif keep_seasonal and tbase / 30 in [11, 12]:
date12_list_out.append(date12)
return date12_list_out
def simulate_coherence(date12_list,
baseline_file='bl_list.txt',
sensor_name='Env',
inc_angle=22.8,
decor_time=200.0,
coh_resid=0.2,
display=False):
"""Simulate coherence for a given set of interferograms
Inputs:
date12_list - list of string in YYMMDD-YYMMDD format, indicating pairs configuration
baseline_file - string, path of baseline list text file
sensor_name - string, SAR sensor name
inc_angle - float, incidence angle
decor_time - float / 2D np.array in size of (1, pixel_num)
decorrelation rate in days, time for coherence to drop to 1/e of its initial value
coh_resid - float / 2D np.array in size of (1, pixel_num)
long-term coherence, minimum attainable coherence value
display - bool, display result as matrix or not
Output:
cohs - 2D np.array in size of (ifgram_num, pixel_num)
Example:
date12_list = pnet.get_date12_list('ifgram_list.txt')
cohs = simulate_coherences(date12_list, 'bl_list.txt', sensor_name='Tsx')
References:
Zebker, H. A., & Villasenor, J. (1992). Decorrelation in interferometric radar echoes.
IEEE-TGRS, 30(5), 950-959.
Hanssen, R. F. (2001). Radar interferometry: data interpretation and error analysis
(Vol. 2). Dordrecht, Netherlands: Kluwer Academic Pub.
Morishita, Y., & Hanssen, R. F. (2015). Temporal decorrelation in L-, C-, and X-band satellite
radar interferometry for pasture on drained peat soils. IEEE-TGRS, 53(2), 1096-1104.
Parizzi, A., Cong, X., & Eineder, M. (2009). First Results from Multifrequency Interferometry.
A comparison of different decorrelation time constants at L, C, and X Band. ESA Scientific
Publications(SP-677), 1-5.
"""
date_list, pbase_list, dop_list = read_baseline_file(baseline_file)[0:3]
tbase_list = ptime.date_list2tbase(date_list)[0]
# Thermal decorrelation (Zebker and Villasenor, 1992, Eq.4)
SNR = sensor.signal2noise_ratio(sensor_name)
coh_thermal = 1. / (1. + 1. / SNR)
pbase_c = critical_perp_baseline(sensor_name, inc_angle)
bandwidth_az = sensor.azimuth_bandwidth(sensor_name)
date12_list = ptime.yyyymmdd_date12(date12_list)
ifgram_num = len(date12_list)
if isinstance(decor_time, (int, float)):
pixel_num = 1
decor_time = float(decor_time)
else:
pixel_num = decor_time.shape[1]
if decor_time == 0.:
decor_time = 0.01
cohs = np.zeros((ifgram_num, pixel_num), np.float32)
for i in range(ifgram_num):
if display:
sys.stdout.write('\rinterferogram = %4d/%4d' % (i, ifgram_num))
sys.stdout.flush()
m_date, s_date = date12_list[i].split('_')
m_idx = date_list.index(m_date)
s_idx = date_list.index(s_date)
pbase = pbase_list[s_idx] - pbase_list[m_idx]
tbase = tbase_list[s_idx] - tbase_list[m_idx]
# Geometric decorrelation (Hanssen, 2001, Eq. 4.4.12)
coh_geom = (pbase_c - abs(pbase)) / pbase_c
if coh_geom < 0.:
coh_geom = 0.
# Doppler centroid decorrelation (Hanssen, 2001, Eq. 4.4.13)
if not dop_list:
coh_dc = 1.
else:
coh_dc = calculate_doppler_overlap(dop_list[m_idx],
dop_list[s_idx], bandwidth_az)
if coh_dc < 0.:
coh_dc = 0.
# Option 1: Temporal decorrelation - exponential delay model (Parizzi et al., 2009; Morishita and Hanssen, 2015)
coh_temp = np.multiply(
(coh_thermal - coh_resid), np.exp(
-1 * abs(tbase) / decor_time)) + coh_resid
coh = coh_geom * coh_dc * coh_temp
cohs[i, :] = coh
#epsilon = 1e-3
#cohs[cohs < epsilon] = epsilon
if display:
print('')
if display:
print(('critical perp baseline: %.f m' % pbase_c))
cohs_mat = coherence_matrix(date12_list, cohs)
plt.figure()
plt.imshow(cohs_mat, vmin=0.0, vmax=1.0, cmap='jet')
plt.xlabel('Image number')
plt.ylabel('Image number')
cbar = plt.colorbar()
cbar.set_label('Coherence')
plt.title('Coherence matrix')
plt.show()
return cohs
def plot_network(ax, date12List, dateList, pbaseList, plot_dict={}, date12List_drop=[], print_msg=True):
"""Plot Temporal-Perp baseline Network
Inputs
ax : matplotlib axes object
date12List : list of string for date12 in YYYYMMDD_YYYYMMDD format
dateList : list of string, for date in YYYYMMDD format
pbaseList : list of float, perp baseline, len=number of acquisition
plot_dict : dictionary with the following items:
fontsize
linewidth
markercolor
markersize
cohList : list of float, coherence value of each interferogram, len = number of ifgrams
disp_min/max : float, min/max range of the color display based on cohList
colormap : string, colormap name
coh_thres : float, coherence of where to cut the colormap for display
disp_title : bool, show figure title or not, default: True
disp_drop: bool, show dropped interferograms or not, default: True
Output
ax : matplotlib axes object
"""
# Figure Setting
if not 'fontsize' in plot_dict.keys(): plot_dict['fontsize'] = 12
if not 'linewidth' in plot_dict.keys(): plot_dict['linewidth'] = 2
if not 'markercolor' in plot_dict.keys(): plot_dict['markercolor'] = 'orange'
if not 'markersize' in plot_dict.keys(): plot_dict['markersize'] = 16
# For colorful display of coherence
if not 'cohList' in plot_dict.keys(): plot_dict['cohList'] = None
if not 'cbar_label' in plot_dict.keys(): plot_dict['cbar_label'] = 'Average Spatial Coherence'
if not 'disp_min' in plot_dict.keys(): plot_dict['disp_min'] = 0.2
if not 'disp_max' in plot_dict.keys(): plot_dict['disp_max'] = 1.0
if not 'colormap' in plot_dict.keys(): plot_dict['colormap'] = 'RdBu'
if not 'disp_title' in plot_dict.keys(): plot_dict['disp_title'] = True
if not 'coh_thres' in plot_dict.keys(): plot_dict['coh_thres'] = None
if not 'disp_drop' in plot_dict.keys(): plot_dict['disp_drop'] = True
if not 'every_year' in plot_dict.keys(): plot_dict['every_year'] = 1
cohList = plot_dict['cohList']
disp_min = plot_dict['disp_min']
disp_max = plot_dict['disp_max']
coh_thres = plot_dict['coh_thres']
transparency = 0.7
# Date Convert
dateList = ptime.yyyymmdd(sorted(dateList))
dates, datevector = ptime.date_list2vector(dateList)
tbaseList = ptime.date_list2tbase(dateList)[0]
## maxBperp and maxBtemp
date12List = ptime.yyyymmdd_date12(date12List)
ifgram_num = len(date12List)
pbase12 = np.zeros(ifgram_num)
tbase12 = np.zeros(ifgram_num)
for i in range(ifgram_num):
m_date, s_date = date12List[i].split('_')
m_idx = dateList.index(m_date)
s_idx = dateList.index(s_date)
pbase12[i] = pbaseList[s_idx] - pbaseList[m_idx]
tbase12[i] = tbaseList[s_idx] - tbaseList[m_idx]
if print_msg:
print('max perpendicular baseline: {:.2f} m'.format(np.max(np.abs(pbase12))))
print('max temporal baseline: {} days'.format(np.max(tbase12)))
## Keep/Drop - date12
date12List_keep = sorted(list(set(date12List) - set(date12List_drop)))
idx_date12_keep = [date12List.index(i) for i in date12List_keep]
idx_date12_drop = [date12List.index(i) for i in date12List_drop]
if not date12List_drop:
plot_dict['disp_drop'] = False
## Keep/Drop - date
m_dates = [i.split('_')[0] for i in date12List_keep]
s_dates = [i.split('_')[1] for i in date12List_keep]
dateList_keep = ptime.yyyymmdd(sorted(list(set(m_dates + s_dates))))
dateList_drop = sorted(list(set(dateList) - set(dateList_keep)))
idx_date_keep = [dateList.index(i) for i in dateList_keep]
idx_date_drop = [dateList.index(i) for i in dateList_drop]
# Ploting
# ax=fig.add_subplot(111)
# Colorbar when conherence is colored
if cohList is not None:
data_min = min(cohList)
data_max = max(cohList)
# Normalize
normalization = False
if normalization:
cohList = [(coh-data_min) / (data_min-data_min) for coh in cohList]
disp_min = data_min
disp_max = data_max
if print_msg:
print('showing coherence')
print(('colormap: '+plot_dict['colormap']))
print(('display range: '+str([disp_min, disp_max])))
print(('data range: '+str([data_min, data_max])))
splitColormap = True
if splitColormap:
# Use lower/upper part of colormap to emphasis dropped interferograms
if not coh_thres:
# Find proper cut percentage so that all keep pairs are blue and drop pairs are red
cohList_keep = [cohList[i] for i in idx_date12_keep]
cohList_drop = [cohList[i] for i in idx_date12_drop]
if cohList_drop:
coh_thres = max(cohList_drop)
else:
coh_thres = min(cohList_keep)
if coh_thres < disp_min:
disp_min = 0.0
if print_msg:
print('data range exceed orginal display range, set new display range to: [0.0, %f]' % (disp_max))
c1_num = np.ceil(200.0 * (coh_thres - disp_min) / (disp_max - disp_min)).astype('int')
coh_thres = c1_num / 200.0 * (disp_max-disp_min) + disp_min
cmap = plt.get_cmap(plot_dict['colormap'])
colors1 = cmap(np.linspace(0.0, 0.3, c1_num))
colors2 = cmap(np.linspace(0.6, 1.0, 200 - c1_num))
cmap = LinearSegmentedColormap.from_list('truncate_RdBu', np.vstack((colors1, colors2)))
if print_msg:
print(('color jump at '+str(coh_thres)))
else:
cmap = plt.get_cmap(plot_dict['colormap'])
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", "3%", pad="3%")
norm = mpl.colors.Normalize(vmin=disp_min, vmax=disp_max)
cbar = mpl.colorbar.ColorbarBase(cax, cmap=cmap, norm=norm)
cbar.set_label(plot_dict['cbar_label'], fontsize=plot_dict['fontsize'])
# plot low coherent ifgram first and high coherence ifgram later
cohList_keep = [cohList[date12List.index(i)] for i in date12List_keep]
date12List_keep = [x for _, x in sorted(zip(cohList_keep, date12List_keep))]
# Dot - SAR Acquisition
if idx_date_keep:
x_list = [dates[i] for i in idx_date_keep]
y_list = [pbaseList[i] for i in idx_date_keep]
ax.plot(x_list, y_list, 'ko', alpha=0.7,
ms=plot_dict['markersize'], mfc=plot_dict['markercolor'])
if idx_date_drop:
x_list = [dates[i] for i in idx_date_drop]
y_list = [pbaseList[i] for i in idx_date_drop]
ax.plot(x_list, y_list, 'ko', alpha=0.7,
ms=plot_dict['markersize'], mfc='gray')
## Line - Pair/Interferogram
# interferograms dropped
if plot_dict['disp_drop']:
for date12 in date12List_drop:
date1, date2 = date12.split('_')
idx1 = dateList.index(date1)
idx2 = dateList.index(date2)
x = np.array([dates[idx1], dates[idx2]])
y = np.array([pbaseList[idx1], pbaseList[idx2]])
if cohList is not None:
coh = cohList[date12List.index(date12)]
coh_idx = (coh - disp_min) / (disp_max - disp_min)
ax.plot(x, y, '--', lw=plot_dict['linewidth'],
alpha=transparency, c=cmap(coh_idx))
else:
ax.plot(x, y, '--', lw=plot_dict['linewidth'],
alpha=transparency, c='k')
# interferograms kept
for date12 in date12List_keep:
date1, date2 = date12.split('_')
idx1 = dateList.index(date1)
idx2 = dateList.index(date2)
x = np.array([dates[idx1], dates[idx2]])
y = np.array([pbaseList[idx1], pbaseList[idx2]])
if cohList is not None:
coh = cohList[date12List.index(date12)]
coh_idx = (coh - disp_min) / (disp_max - disp_min)
ax.plot(x, y, '-', lw=plot_dict['linewidth'],
alpha=transparency, c=cmap(coh_idx))
else:
ax.plot(x, y, '-', lw=plot_dict['linewidth'],
alpha=transparency, c='k')
if plot_dict['disp_title']:
ax.set_title('Interferogram Network', fontsize=plot_dict['fontsize'])
# axis format
ax = auto_adjust_xaxis_date(ax, datevector, plot_dict['fontsize'],
every_year=plot_dict['every_year'])[0]
ax = auto_adjust_yaxis(ax, pbaseList, plot_dict['fontsize'])
ax.set_xlabel('Time [years]', fontsize=plot_dict['fontsize'])
ax.set_ylabel('Perp Baseline [m]', fontsize=plot_dict['fontsize'])
# Legend
if plot_dict['disp_drop']:
solid_line = mlines.Line2D([], [], color='k', ls='solid', label='Interferograms')
dash_line = mlines.Line2D([], [], color='k', ls='dashed', label='Interferograms dropped')
ax.legend(handles=[solid_line, dash_line])
return ax
def ifgram_inversion_patch(ifgram_file,
box=None,
ref_phase=None,
weight_func='fim',
mask_dataset_name=None,
mask_threshold=0.4,
water_mask_file=None,
skip_zero_phase=True):
"""Invert one patch of an ifgram stack into timeseries.
Parameters: ifgram_file : str, interferograms stack HDF5 file, e.g. ./INPUTS/ifgramStack.h5
box : tuple of 4 int, indicating (x0, y0, x1, y1) pixel coordinate of area of interest
or None, to process the whole file and write output file
ref_phase : 1D array in size of (num_ifgram)
or None
weight_func : str, weight function, choose in ['sbas', 'fim', 'var', 'coh']
mask_dataset_name : str, dataset name in ifgram_file used to mask unwrapPhase pixelwisely
mask_threshold : float, min coherence of pixels if mask_dataset_name='coherence'
water_mask_file : str, water mask filename if available,
skip inversion on water to speed up the process
skip_zero_phase : bool, skip zero value of unwrapped phase or not, default yes, for comparison
Returns: ts : 3D array in size of (num_date, num_row, num_col)
temp_coh : 2D array in size of (num_row, num_col)
ts_std : 3D array in size of (num_date, num_row, num_col)
num_inv_ifgram : 2D array in size of (num_row, num_col)
Example: ifgram_inversion_patch('ifgramStack.h5', box=(0,200,1316,400), ref_phase=np.array(),
weight_func='fim', mask_dataset_name='coherence')
ifgram_inversion_patch('ifgramStack_001.h5', box=None, ref_phase=None,
weight_func='fim', mask_dataset_name='coherence')
"""
stack_obj = ifgramStack(ifgram_file)
stack_obj.open(print_msg=False)
# Size Info - Patch
if box:
print('processing %8d/%d lines ...' % (box[3], stack_obj.length))
num_row = box[3] - box[1]
num_col = box[2] - box[0]
else:
num_row = stack_obj.length
num_col = stack_obj.width
num_pixel = num_row * num_col
# Design matrix
date12_list = stack_obj.get_date12_list(dropIfgram=True)
A, B = stack_obj.get_design_matrix(date12_list=date12_list)
num_ifgram = len(date12_list)
num_date = A.shape[1] + 1
try:
ref_date = str(
np.loadtxt('reference_date.txt', dtype=bytes).astype(str))
except:
ref_date = stack_obj.dateList[0]
ref_idx = stack_obj.dateList.index(ref_date)
time_idx = [i for i in range(num_date)]
time_idx.remove(ref_idx)
Astd = stack_obj.get_design_matrix(refDate=ref_date, dropIfgram=True)[0]
# Initialization of output matrix
print('number of interferograms: {}'.format(num_ifgram))
print('number of acquisitions : {}'.format(num_date))
print('number of lines : {}'.format(stack_obj.length))
print('number of columns: {}'.format(stack_obj.width))
ts = np.zeros((num_date, num_pixel), np.float32)
ts_std = np.zeros((num_date, num_pixel), np.float32)
temp_coh = np.zeros(num_pixel, np.float32)
num_inv_ifgram = np.zeros(num_pixel, np.int16)
# Read/Mask unwrapPhase
pha_data = read_unwrap_phase(stack_obj,
box,
ref_phase,
skip_zero_phase=skip_zero_phase)
pha_data = mask_unwrap_phase(pha_data,
stack_obj,
box,
mask_ds_name=mask_dataset_name,
mask_threshold=mask_threshold)
# Mask for pixels to invert
mask = np.ones(num_pixel, np.bool_)
# 1 - Water Mask
if water_mask_file:
print(('skip pixels on water with mask from'
' file: {}').format(os.path.basename(water_mask_file)))
dsNames = readfile.get_dataset_list(water_mask_file)
dsName = [i for i in dsNames if i in ['waterMask', 'mask']][0]
waterMask = readfile.read(water_mask_file, datasetName=dsName,
box=box)[0].flatten()
mask *= np.array(waterMask, np.bool_)
del waterMask
# 2 - Mask for Zero Phase in ALL ifgrams
print('skip pixels with zero/nan value in all interferograms')
phase_stack = np.nanmean(pha_data, axis=0)
mask *= np.multiply(~np.isnan(phase_stack), phase_stack != 0.)
del phase_stack
# Invert pixels on mask 1+2
num_pixel2inv = int(np.sum(mask))
idx_pixel2inv = np.where(mask)[0]
print(('number of pixels to invert: {} out of {}'
' ({:.1f}%)').format(num_pixel2inv, num_pixel,
num_pixel2inv / num_pixel * 100))
if num_pixel2inv < 1:
ts = ts.reshape(num_date, num_row, num_col)
temp_coh = temp_coh.reshape(num_row, num_col)
ts_std = ts_std.reshape(num_date, num_row, num_col)
num_inv_ifgram = num_inv_ifgram.reshape(num_row, num_col)
return ts, temp_coh, ts_std, num_inv_ifgram
# Inversion - SBAS
if weight_func == 'sbas':
# get tbase_diff (for SBAS approach)
date_list = stack_obj.get_date_list(dropIfgram=True)
tbase = np.array(ptime.date_list2tbase(date_list)[0],
np.float32) / 365.25
tbase_diff = np.diff(tbase).reshape(-1, 1)
# Mask for Non-Zero Phase in ALL ifgrams (share one B in sbas inversion)
mask_all_net = np.all(pha_data, axis=0)
mask_all_net *= mask
mask_part_net = mask ^ mask_all_net
if np.sum(mask_all_net) > 0:
print(('inverting pixels with valid phase in all ifgrams'
' ({:.0f} pixels) ...').format(np.sum(mask_all_net)))
# num_all_net = int(np.sum(mask_all_net))
# pha_data_temp = pha_data[:, mask_all_net]
# ts1 = np.zeros((num_date-1, num_all_net))
# temp_coh1 = np.zeros(num_all_net)
# step = 1000
# loop_num = int(np.floor(num_all_net/step))
# prog_bar = ptime.progressBar(maxValue=loop_num)
# for i in range(loop_num):
# [i0, i1] = [i * step, min((i + 1) * step, num_all_net)]
# ts1[:, i0:i1], temp_coh1[i0:i1] = network_inversion_sbas(B,
# ifgram=pha_data_temp[:, i0:i1],
# tbase_diff=tbase_diff,
# skip_zero_phase=False)
# prog_bar.update(i+1, suffix=i0)
# prog_bar.close()
ts1, temp_coh1, ifg_num1 = network_inversion_sbas(
B,
ifgram=pha_data[:, mask_all_net],
tbase_diff=tbase_diff,
skip_zero_phase=False)
ts[1:, mask_all_net] = ts1
temp_coh[mask_all_net] = temp_coh1
num_inv_ifgram[mask_all_net] = ifg_num1
if np.sum(mask_part_net) > 0:
print(('inverting pixels with valid phase in some ifgrams'
' ({:.0f} pixels) ...').format(np.sum(mask_part_net)))
num_pixel2inv = int(np.sum(mask_part_net))
idx_pixel2inv = np.where(mask_part_net)[0]
prog_bar = ptime.progressBar(maxValue=num_pixel2inv)
for i in range(num_pixel2inv):
idx = idx_pixel2inv[i]
ts1, temp_coh1, ifg_num1 = network_inversion_sbas(
B,
ifgram=pha_data[:, idx],
tbase_diff=tbase_diff,
skip_zero_phase=skip_zero_phase)
ts[1:, idx] = ts1.flatten()
temp_coh[idx] = temp_coh1
num_inv_ifgram[idx] = ifg_num1
prog_bar.update(i + 1,
every=100,
suffix='{}/{} pixels'.format(
i + 1, num_pixel2inv))
prog_bar.close()
# Inversion - WLS
else:
weight = read_coherence2weight(stack_obj,
box=box,
weight_func=weight_func)
# Converting to 32 bit floats leads to 2X speedup
# (comment it out as we now convert it beforehand)
# A = np.array(A, np.float32)
# pha_data = np.array(pha_data, np.float32)
# weight = np.array(weight, np.float32)
# Astd = np.array(Astd, np.float32)
# Weighted Inversion pixel by pixel
print('inverting network of interferograms into time series ...')
prog_bar = ptime.progressBar(maxValue=num_pixel2inv)
for i in range(num_pixel2inv):
idx = idx_pixel2inv[i]
ts1, temp_coh1, ts_std1, ifg_numi = network_inversion_wls(
A,
ifgram=pha_data[:, idx],
weight=weight[:, idx],
skip_zero_phase=skip_zero_phase,
Astd=Astd)
ts[1:, idx] = ts1.flatten()
temp_coh[idx] = temp_coh1
ts_std[time_idx, idx] = ts_std1.flatten()
num_inv_ifgram[idx] = ifg_numi
prog_bar.update(i + 1,
every=100,
suffix='{}/{} pixels'.format(i + 1, num_pixel2inv))
prog_bar.close()
ts = ts.reshape(num_date, num_row, num_col)
ts_std = ts_std.reshape(num_date, num_row, num_col)
temp_coh = temp_coh.reshape(num_row, num_col)
num_inv_ifgram = num_inv_ifgram.reshape(num_row, num_col)
# write output files if input file is splitted (box == None)
if box is None:
# metadata
metadata = dict(stack_obj.metadata)
metadata[key_prefix + 'weightFunc'] = weight_func
suffix = re.findall('_\d{3}', ifgram_file)[0]
write2hdf5_file(ifgram_file, metadata, ts, temp_coh, ts_std,
num_inv_ifgram, suffix)
return
else:
return ts, temp_coh, ts_std, num_inv_ifgram
def ifgram_inversion_patch(ifgram_file,
box=None,
ref_phase=None,
unwDatasetName='unwrapPhase',
weight_func='var',
min_norm_velocity=True,
mask_dataset_name=None,
mask_threshold=0.4,
min_redundancy=1.0,
water_mask_file=None,
skip_zero_phase=True):
"""Invert one patch of an ifgram stack into timeseries.
Parameters: ifgram_file : str, interferograms stack HDF5 file, e.g. ./INPUTS/ifgramStack.h5
box : tuple of 4 int, indicating (x0, y0, x1, y1) pixel coordinate of area of interest
or None, to process the whole file and write output file
ref_phase : 1D array in size of (num_ifgram)
or None
weight_func : str, weight function, choose in ['no', 'fim', 'var', 'coh']
mask_dataset_name : str, dataset name in ifgram_file used to mask unwrapPhase pixelwisely
mask_threshold : float, min coherence of pixels if mask_dataset_name='coherence'
water_mask_file : str, water mask filename if available,
skip inversion on water to speed up the process
skip_zero_phase : bool, skip zero value of unwrapped phase or not, default yes, for comparison
Returns: ts : 3D array in size of (num_date, num_row, num_col)
temp_coh : 2D array in size of (num_row, num_col)
ts_std : 3D array in size of (num_date, num_row, num_col)
num_inv_ifg : 2D array in size of (num_row, num_col)
Example: ifgram_inversion_patch('ifgramStack.h5', box=(0,200,1316,400), ref_phase=np.array(),
weight_func='var', min_norm_velocity=True, mask_dataset_name='coherence')
ifgram_inversion_patch('ifgramStack_001.h5', box=None, ref_phase=None,
weight_func='var', min_norm_velocity=True, mask_dataset_name='coherence')
"""
stack_obj = ifgramStack(ifgram_file)
stack_obj.open(print_msg=False)
## debug
#y, x = 258, 454
#box = (x, y, x+1, y+1)
# Size Info - Patch
if box:
#print('processing \t %d-%d / %d lines ...' % (box[1], box[3], stack_obj.length))
num_row = box[3] - box[1]
num_col = box[2] - box[0]
else:
num_row = stack_obj.length
num_col = stack_obj.width
num_pixel = num_row * num_col
# get tbase_diff
date_list = stack_obj.get_date_list(dropIfgram=True)
num_date = len(date_list)
tbase = np.array(ptime.date_list2tbase(date_list)[0], np.float32) / 365.25
tbase_diff = np.diff(tbase).reshape(-1, 1)
# Design matrix
date12_list = stack_obj.get_date12_list(dropIfgram=True)
A, B = stack_obj.get_design_matrix4timeseries_estimation(
date12_list=date12_list)[0:2]
num_ifgram = len(date12_list)
# prep for decor std time-series
try:
ref_date = str(
np.loadtxt('reference_date.txt', dtype=bytes).astype(str))
except:
ref_date = date_list[0]
Astd = stack_obj.get_design_matrix4timeseries_estimation(
refDate=ref_date, dropIfgram=True)[0]
#ref_idx = date_list.index(ref_date)
#time_idx = [i for i in range(num_date)]
#time_idx.remove(ref_idx)
# Initialization of output matrix
ts = np.zeros((num_date, num_pixel), np.float32)
ts_std = np.zeros((num_date, num_pixel), np.float32)
temp_coh = np.zeros(num_pixel, np.float32)
num_inv_ifg = np.zeros(num_pixel, np.int16)
# Read/Mask unwrapPhase
pha_data = read_unwrap_phase(stack_obj,
box,
ref_phase,
unwDatasetName=unwDatasetName,
dropIfgram=True,
skip_zero_phase=skip_zero_phase)
pha_data = mask_unwrap_phase(pha_data,
stack_obj,
box,
dropIfgram=True,
mask_ds_name=mask_dataset_name,
mask_threshold=mask_threshold)
# Mask for pixels to invert
mask = np.ones(num_pixel, np.bool_)
# 1 - Water Mask
if water_mask_file:
print(('skip pixels on water with mask from'
' file: {}').format(os.path.basename(water_mask_file)))
atr_msk = readfile.read_attribute(water_mask_file)
if (int(atr_msk['LENGTH']), int(
atr_msk['WIDTH'])) != (stack_obj.length, stack_obj.width):
raise ValueError(
'Input water mask file has different size from ifgramStack file.'
)
del atr_msk
dsName = [
i for i in readfile.get_dataset_list(water_mask_file)
if i in ['waterMask', 'mask']
][0]
waterMask = readfile.read(water_mask_file, datasetName=dsName,
box=box)[0].flatten()
mask *= np.array(waterMask, np.bool_)
del waterMask
# 2 - Mask for Zero Phase in ALL ifgrams
print('skip pixels with zero/nan value in all interferograms')
phase_stack = np.nanmean(pha_data, axis=0)
mask *= np.multiply(~np.isnan(phase_stack), phase_stack != 0.)
del phase_stack
# Invert pixels on mask 1+2
num_pixel2inv = int(np.sum(mask))
idx_pixel2inv = np.where(mask)[0]
print(('number of pixels to invert: {} out of {}'
' ({:.1f}%)').format(num_pixel2inv, num_pixel,
num_pixel2inv / num_pixel * 100))
if num_pixel2inv < 1:
ts = ts.reshape(num_date, num_row, num_col)
ts_std = ts_std.reshape(num_date, num_row, num_col)
temp_coh = temp_coh.reshape(num_row, num_col)
num_inv_ifg = num_inv_ifg.reshape(num_row, num_col)
return ts, temp_coh, ts_std, num_inv_ifg
# Inversion - SBAS
if weight_func in ['no', 'sbas']:
# Mask for Non-Zero Phase in ALL ifgrams (share one B in sbas inversion)
mask_all_net = np.all(pha_data, axis=0)
mask_all_net *= mask
mask_part_net = mask ^ mask_all_net
if np.sum(mask_all_net) > 0:
print(('inverting pixels with valid phase in all ifgrams'
' ({:.0f} pixels) ...').format(np.sum(mask_all_net)))
tsi, tcohi, num_ifgi = estimate_timeseries(
A,
B,
tbase_diff,
ifgram=pha_data[:, mask_all_net],
weight_sqrt=None,
min_norm_velocity=min_norm_velocity,
skip_zero_phase=skip_zero_phase,
min_redundancy=min_redundancy)
ts[:, mask_all_net] = tsi
temp_coh[mask_all_net] = tcohi
num_inv_ifg[mask_all_net] = num_ifgi
if np.sum(mask_part_net) > 0:
print(('inverting pixels with valid phase in some ifgrams'
' ({:.0f} pixels) ...').format(np.sum(mask_part_net)))
num_pixel2inv = int(np.sum(mask_part_net))
idx_pixel2inv = np.where(mask_part_net)[0]
prog_bar = ptime.progressBar(maxValue=num_pixel2inv)
for i in range(num_pixel2inv):
idx = idx_pixel2inv[i]
tsi, tcohi, num_ifgi = estimate_timeseries(
A,
B,
tbase_diff,
ifgram=pha_data[:, idx],
weight_sqrt=None,
min_norm_velocity=min_norm_velocity,
skip_zero_phase=skip_zero_phase,
min_redundancy=min_redundancy)
ts[:, idx] = tsi.flatten()
temp_coh[idx] = tcohi
num_inv_ifg[idx] = num_ifgi
prog_bar.update(i + 1,
every=1000,
suffix='{}/{} pixels'.format(
i + 1, num_pixel2inv))
prog_bar.close()
# Inversion - WLS
else:
L = int(stack_obj.metadata['ALOOKS']) * int(
stack_obj.metadata['RLOOKS'])
weight = read_coherence(stack_obj, box=box, dropIfgram=True)
weight = coherence2weight(weight,
weight_func=weight_func,
L=L,
epsilon=5e-2)
weight = np.sqrt(weight)
# Weighted Inversion pixel by pixel
print('inverting network of interferograms into time-series ...')
prog_bar = ptime.progressBar(maxValue=num_pixel2inv)
for i in range(num_pixel2inv):
idx = idx_pixel2inv[i]
tsi, tcohi, num_ifgi = estimate_timeseries(
A,
B,
tbase_diff,
ifgram=pha_data[:, idx],
weight_sqrt=weight[:, idx],
min_norm_velocity=min_norm_velocity,
skip_zero_phase=skip_zero_phase,
min_redundancy=min_redundancy)
ts[:, idx] = tsi.flatten()
temp_coh[idx] = tcohi
num_inv_ifg[idx] = num_ifgi
prog_bar.update(i + 1,
every=1000,
suffix='{}/{} pixels'.format(i + 1, num_pixel2inv))
prog_bar.close()
ts = ts.reshape(num_date, num_row, num_col)
ts_std = ts_std.reshape(num_date, num_row, num_col)
temp_coh = temp_coh.reshape(num_row, num_col)
num_inv_ifg = num_inv_ifg.reshape(num_row, num_col)
# write output files if input file is splitted (box == None)
if box is None:
# metadata
metadata = dict(stack_obj.metadata)
metadata[key_prefix + 'weightFunc'] = weight_func
suffix = re.findall('_\d{3}', ifgram_file)[0]
write2hdf5_file(ifgram_file,
metadata,
ts,
temp_coh,
ts_std,
num_inv_ifg,
suffix,
inps=inps)
return
else:
return ts, temp_coh, ts_std, num_inv_ifg
