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
disMat = np.sqrt(
np.square(ttMat) +
np.square(ppMat)) # 2D distance matrix in temp/perp domain
# 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; otherwise, choose the closest pair
among all pairs as master interferogram.
Example:
master_date12 = pnet.select_master_ifgram(date12_list, date_list, pbase_list)
'''
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):
'''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
weightMat = np.sqrt(
np.square(ttMat) +
np.square(ppMat)) # 2D distance matrix in temp/perp domain
weightMat = csr_matrix(weightMat) # compress sparse row matrix
# MST path based on weight matrix
mstMat = 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 find(mstMat)[0:2]]
date12_list = [
date6_list[m_idx_list[i]] + '-' + date6_list[s_idx_list[i]]
for i in range(len(m_idx_list))
]
return date12_list
def select_pairs_delaunay(date_list, pbase_list, norm=True):
'''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
]
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 main(argv):
try:
timeseries_file = argv[0]
except:
usage() ; sys.exit(1)
# Basic info
atr = readfile.read_attribute(timeseries_file)
k = atr['FILE_TYPE']
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
##### Read time-series
print("loading time series: " + timeseries_file)
h5 = h5py.File(timeseries_file)
date_list = sorted(h5[k].keys())
date_num = len(date_list)
pixel_num = length*width
tbase = np.array(ptime.date_list2tbase(date_list)[0], np.float32)
prog_bar = ptime.progress_bar(maxValue=date_num)
timeseries = np.zeros((date_num, pixel_num),np.float32)
for i in range(date_num):
date = date_list[i]
d = h5[k].get(date)[:]
timeseries[i,:] = d.flatten(0)
prog_bar.update(i+1, suffix=date)
prog_bar.close()
del d
h5.close()
##### Calculate 1st and 2nd temporal derivatives
print("calculating temporal 1st derivative ... ")
timeseries_1st = np.zeros((date_num-1,pixel_num),np.float32)
for i in range(date_num-1):
timeseries_1st[i][:] = timeseries[i+1][:] - timeseries[i][:]
print("calculating temporal 2nd derivative")
timeseries_2nd = np.zeros((date_num-2,pixel_num),np.float32)
for i in range(date_num-2):
timeseries_2nd[i][:] = timeseries_1st[i+1][:] - timeseries_1st[i][:]
##### Write 1st and 2nd temporal derivatives
outfile1 = os.path.splitext(timeseries_file)[0]+'_1stDerivative.h5'
print('writing >>> '+outfile1)
h5out = h5py.File(outfile1, 'w')
group = h5out.create_group(k)
prog_bar = ptime.progress_bar(maxValue=date_num-1)
for i in range(date_num-1):
date = date_list[i+1]
dset = group.create_dataset(date, data=np.reshape(timeseries_1st[i][:],[length,width]), compression='gzip')
prog_bar.update(i+1, suffix=date)
for key,value in atr.items():
group.attrs[key] = value
prog_bar.close()
h5out.close()
outfile2 = os.path.splitext(timeseries_file)[0]+'_2ndDerivative.h5'
print('writing >>> '+outfile2)
h5out = h5py.File(outfile2, 'w')
group = h5out.create_group(k)
prog_bar = ptime.progress_bar(maxValue=date_num-2)
for i in range(date_num-2):
date = date_list[i+2]
dset = group.create_dataset(date, data=np.reshape(timeseries_2nd[i][:],[length,width]), compression='gzip')
prog_bar.update(i+1, suffix=date)
for key,value in atr.items():
group.attrs[key] = value
prog_bar.close()
h5out.close()
print('Done.')
return outfile1, outfile2
def main(argv):
##### Read Inputs
inps = cmdLineParse()
inps.file = ut.get_file_list(inps.file)
date12_orig = pnet.get_date12_list(inps.file[0])
print('input file(s) to be modified: ' + str(inps.file))
print('number of interferograms: ' + str(len(date12_orig)))
atr = readfile.read_attribute(inps.file[0])
# Update inps if template is input
if inps.template_file:
inps = read_template2inps(inps.template_file, inps)
if inps.reset:
print(
'----------------------------------------------------------------------------'
)
for file in inps.file:
reset_pairs(file)
mean_coh_txt_file = os.path.splitext(
inps.coherence_file)[0] + '_spatialAverage.txt'
if os.path.isfile(mean_coh_txt_file):
rmCmd = 'rm ' + mean_coh_txt_file
print(rmCmd)
os.system(rmCmd)
return
if all(not i for i in [inps.reference_file, inps.max_temp_baseline, inps.max_perp_baseline,\
inps.exclude_ifg_index, inps.exclude_date, inps.coherence_based, inps.start_date, inps.end_date]):
# Display network for manually modification when there is no other modification input.
print('No input option found to remove interferogram')
print('To manually modify network, please use --manual option ')
return
# Convert index : input to continous index list
if inps.exclude_ifg_index:
ifg_index = list(inps.exclude_ifg_index)
inps.exclude_ifg_index = []
for index in ifg_index:
index_temp = [int(i) for i in index.split(':')]
index_temp.sort()
if len(index_temp) == 2:
for j in range(index_temp[0], index_temp[1] + 1):
inps.exclude_ifg_index.append(j)
elif len(index_temp) == 1:
inps.exclude_ifg_index.append(int(index))
else:
print('Unrecoganized input: ' + index)
inps.exclude_ifg_index = sorted(inps.exclude_ifg_index)
if max(inps.exclude_ifg_index) > len(date12_orig):
raise Exception('Input index out of range!\n'+\
'input index:'+str(inps.exclude_ifg_index)+'\n'+\
'index range of file: '+str(len(date12_orig)))
##### Get date12_to_rmv
date12_to_rmv = []
# 1. Update date12_to_rmv from reference file
if inps.reference_file:
date12_to_keep = pnet.get_date12_list(inps.reference_file)
print(
'----------------------------------------------------------------------------'
)
print('use reference pairs info from file: ' + inps.reference_file)
print('number of interferograms in reference: ' +
str(len(date12_to_keep)))
print('date12 not in reference file:')
for date12 in date12_orig:
if date12 not in date12_to_keep:
date12_to_rmv.append(date12)
print(date12)
# 2.1 Update date12_to_rmv from coherence file
if inps.coherence_based and os.path.isfile(inps.coherence_file):
print(
'----------------------------------------------------------------------------'
)
print(
'use coherence-based network modification from coherence file: ' +
inps.coherence_file)
# check mask AOI in lalo
if inps.aoi_geo_box and inps.trans_file:
print('input AOI in (lon0, lat1, lon1, lat0): ' +
str(inps.aoi_geo_box))
inps.aoi_pix_box = subset.bbox_geo2radar(inps.aoi_geo_box, atr,
inps.trans_file)
if inps.aoi_pix_box:
# check mask AOI within the data coverage
inps.aoi_pix_box = subset.check_box_within_data_coverage(
inps.aoi_pix_box, atr)
print('input AOI in (x0,y0,x1,y1): ' + str(inps.aoi_pix_box))
# Calculate spatial average coherence
coh_list, coh_date12_list = ut.spatial_average(inps.coherence_file, inps.mask_file,\
inps.aoi_pix_box, saveList=True)
# MST network
if inps.keep_mst:
print(
'Get minimum spanning tree (MST) of interferograms with inverse of coherence.'
)
print('date12 with 1) average coherence < ' +
str(inps.min_coherence) + ' AND 2) not in MST network: ')
mst_date12_list = pnet.threshold_coherence_based_mst(
coh_date12_list, coh_list)
else:
print('date12 with average coherence < ' + str(inps.min_coherence))
mst_date12_list = []
for i in range(len(coh_date12_list)):
date12 = coh_date12_list[i]
if coh_list[
i] < inps.min_coherence and date12 not in mst_date12_list:
date12_to_rmv.append(date12)
print(date12)
# 2.2 Update date12_to_rmv from perp baseline threshold
if inps.max_perp_baseline:
print(
'----------------------------------------------------------------------------'
)
print('Drop pairs with perpendicular spatial baseline > ' +
str(inps.max_perp_baseline) + ' meters')
ifg_bperp_list = pnet.igram_perp_baseline_list(inps.file[0])
for i in range(len(ifg_bperp_list)):
if ifg_bperp_list[i] > inps.max_perp_baseline:
date12 = date12_orig[i]
date12_to_rmv.append(date12)
print(date12)
# 2.3 Update date12_to_rmv from temp baseline threshold
if inps.max_temp_baseline:
print(
'----------------------------------------------------------------------------'
)
print('Drop pairs with temporal baseline > ' +
str(inps.max_temp_baseline) + ' days')
date8_list = ptime.ifgram_date_list(inps.file[0])
date6_list = ptime.yymmdd(date8_list)
tbase_list = ptime.date_list2tbase(date8_list)[0]
for i in range(len(date12_orig)):
date1, date2 = date12_orig[i].split('-')
idx1 = date6_list.index(date1)
idx2 = date6_list.index(date2)
t_diff = tbase_list[idx2] - tbase_list[idx1]
if t_diff > inps.max_temp_baseline:
date12 = date12_orig[i]
date12_to_rmv.append(date12)
print(date12)
# 2.4 Update date12_to_rmv from exclude_ifg_index
if inps.exclude_ifg_index:
print(
'----------------------------------------------------------------------------'
)
print('drop date12/pair with the following index number:')
for index in inps.exclude_ifg_index:
date12 = date12_orig[index - 1]
date12_to_rmv.append(date12)
print(str(index) + ' ' + date12)
# 2.5 Update date12_to_rmv from exclude_date
if inps.exclude_date:
inps.exclude_date = ptime.yymmdd(inps.exclude_date)
print(
'----------------------------------------------------------------------------'
)
print('Drop pairs including the following dates: \n' +
str(inps.exclude_date))
for i in range(len(date12_orig)):
date1, date2 = date12_orig[i].split('-')
if (date1 in inps.exclude_date) or (date2 in inps.exclude_date):
date12 = date12_orig[i]
date12_to_rmv.append(date12)
print(date12)
# 2.6 Update date12_to_rmv from start_date
if inps.start_date:
inps.start_date = ptime.yymmdd(inps.start_date)
print(
'----------------------------------------------------------------------------'
)
print('Drop pairs with date earlier than start-date: ' +
inps.start_date)
min_date = int(ptime.yyyymmdd(inps.start_date))
for i in range(len(date12_orig)):
date12 = date12_orig[i]
if any(
int(j) < min_date
for j in ptime.yyyymmdd(date12.split('-'))):
date12_to_rmv.append(date12)
print(date12)
# 2.7 Update date12_to_rmv from end_date
if inps.end_date:
inps.end_date = ptime.yymmdd(inps.end_date)
print(
'----------------------------------------------------------------------------'
)
print('Drop pairs with date earlier than end-date: ' + inps.end_date)
max_date = int(ptime.yyyymmdd(inps.end_date))
for i in range(len(date12_orig)):
date12 = date12_orig[i]
if any(
int(j) > max_date
for j in ptime.yyyymmdd(date12.split('-'))):
date12_to_rmv.append(date12)
print(date12)
# 3. Manually drop pairs
if inps.disp_network:
date12_click = manual_select_pairs_to_remove(inps.file[0])
for date12 in list(date12_click):
if date12 not in date12_orig:
date12_click.remove(date12)
print('date12 selected to remove:')
print(date12_click)
date12_to_rmv += date12_click
# 4. drop duplicate date12 and sort in order
date12_to_rmv = list(set(date12_to_rmv))
date12_to_rmv = sorted(date12_to_rmv)
print(
'----------------------------------------------------------------------------'
)
print('number of interferograms to remove: ' + str(len(date12_to_rmv)))
print('list of interferograms to remove:')
print(date12_to_rmv)
##### Calculated date12_to_drop v.s. existing date12_to_drop
# Get list of date12 of interferograms already been marked to drop
k = readfile.read_attribute(inps.file[0])['FILE_TYPE']
h5 = h5py.File(inps.file[0], 'r')
ifgram_list_all = sorted(h5[k].keys())
ifgram_list_keep = ut.check_drop_ifgram(h5,
atr,
ifgram_list_all,
print_msg=False)
ifgram_list_dropped = sorted(
list(set(ifgram_list_all) - set(ifgram_list_keep)))
date12_list_dropped = ptime.list_ifgram2date12(ifgram_list_dropped)
h5.close()
if date12_to_rmv == date12_list_dropped and inps.mark_attribute:
print(
'Calculated date12 to drop is the same as exsiting marked input file, skip update file attributes.'
)
return
##### Update date12 to drop
if date12_to_rmv:
##### Update Input Files with date12_to_rmv
Modified_CoherenceFile = 'Modified_coherence.h5'
for File in inps.file:
Modified_File = modify_file_date12_list(File, date12_to_rmv,
inps.mark_attribute)
k = readfile.read_attribute(File)['FILE_TYPE']
# Update Mask File
if k == 'interferograms':
print('update mask file for input ' + k + ' file based on ' +
Modified_File)
inps.mask_file = 'mask.h5'
print('writing >>> ' + inps.mask_file)
ut.nonzero_mask(Modified_File, inps.mask_file)
elif k == 'coherence':
print('update average spatial coherence for input ' + k +
' file based on: ' + Modified_File)
outFile = 'averageSpatialCoherence.h5'
print('writing >>> ' + outFile)
ut.temporal_average(Modified_File, outFile)
Modified_CoherenceFile = Modified_File
# Plot result
if inps.plot:
print('\nplot modified network and save to file.')
plotCmd = 'plot_network.py ' + Modified_File + ' --coherence ' + Modified_CoherenceFile + ' --nodisplay'
if inps.mask_file:
plotCmd += ' --mask ' + inps.mask_file
print(plotCmd)
os.system(plotCmd)
print('Done.')
return
else:
print('No new interferograms to drop, skip update.')
return
def main(argv):
# Read inputs
inps = cmdLineParse()
inps = read_template2inps(inps.template_file, inps)
log(os.path.basename(sys.argv[0])+' '+inps.template_file)
project_name = os.path.splitext(os.path.basename(inps.template_file))[0]
print('project name: '+project_name)
if not inps.sensor:
inps.sensor = project_name2sensor(project_name)
# Pair selection from reference
if inps.reference_file:
print('Use pairs info from reference file: '+inps.reference_file)
date12_list = pnet.get_date12_list(inps.reference_file)
# Pair selection from temp/perp/dop baseline info
else:
# Auto path setting for Miami user
if not inps.baseline_file and pysar.miami_path and 'SCRATCHDIR' in os.environ:
if pysar.miami_path and 'SCRATCHDIR' in os.environ:
try: inps.baseline_file = glob.glob(os.getenv('SCRATCHDIR')+'/'+project_name+'/SLC/bl_list.txt')[0]
except: inps.baseline_file = None
if not inps.baseline_file:
raise Exception('ERROR: No baseline file found!')
# Check start/end/exclude date
date8_list = pnet.read_baseline_file(inps.baseline_file)[0]
inps.exclude_date = ptime.yyyymmdd(inps.exclude_date)
if not inps.exclude_date:
inps.exclude_date = []
else:
print('input exclude dates: '+str(inps.exclude_date))
if inps.start_date:
print('input start date: '+inps.start_date)
inps.exclude_date += [i for i in date8_list if float(i) < float(ptime.yyyymmdd(inps.start_date))]
inps.exclude_date = sorted(inps.exclude_date)
if inps.end_date:
print('input end date: '+inps.end_date)
inps.exclude_date += [i for i in date8_list if float(i) > float(ptime.yyyymmdd(inps.end_date))]
inps.exclude_date = sorted(inps.exclude_date)
if inps.exclude_date:
print('exclude dates: ')
print(inps.exclude_date)
# Read baseline list file: bl_list.txt
inps.exclude_date = ptime.yymmdd(inps.exclude_date)
date8_list, pbase_list, dop_list = pnet.read_baseline_file(inps.baseline_file, inps.exclude_date)[0:3]
date6_list = ptime.yymmdd(date8_list)
tbase_list = ptime.date_list2tbase(date8_list)[0]
# Initial network using input methods
inps.method = inps.method.lower().replace('-','_')
if inps.method in ['star','ps']: inps.method = 'star'
elif inps.method.startswith('seq'): inps.method = 'sequential'
elif inps.method.startswith('hierar'): inps.method = 'hierarchical'
elif inps.method in ['mst','min_spanning_tree','minimum_spanning_tree']: inps.method = 'mst'
print('select method: '+inps.method)
if inps.method == 'all':
date12_list = pnet.select_pairs_all(date6_list)
elif inps.method == 'delaunay':
date12_list = pnet.select_pairs_delaunay(date6_list, pbase_list, inps.norm)
elif inps.method == 'star':
date12_list = pnet.select_pairs_star(date6_list)
elif inps.method == 'sequential':
date12_list = pnet.select_pairs_sequential(date6_list, inps.increment_num)
elif inps.method == 'hierarchical':
date12_list = pnet.select_pairs_hierarchical(date6_list, pbase_list, inps.temp_perp_list)
elif inps.method == 'mst':
date12_list = pnet.select_pairs_mst(date6_list, pbase_list)
else:
raise Exception('Unrecoganized select method: '+inps.method)
print('initial number of interferograms: '+str(len(date12_list)))
# Filter pairs (optional) using temp/perp/doppler baseline threshold
if inps.method in ['star','hierarchical','mst']:
inps.threshold = False
if inps.threshold:
# Temporal baseline
date12_list = pnet.threshold_temporal_baseline(date12_list, inps.temp_base_max,\
inps.keep_seasonal, inps.temp_base_min)
print('number of interferograms after filtering of <%d, %d> days in temporal baseline: %d'\
% (inps.temp_base_min, inps.temp_base_max, len(date12_list)))
if inps.keep_seasonal:
print('\tkeep seasonal pairs, i.e. pairs with temporal baseline == N*years +/- one month')
# Perpendicular spatial baseline
date12_list = pnet.threshold_perp_baseline(date12_list, date6_list, pbase_list, inps.perp_base_max)
print('number of interferograms after filtering of max %d meters in perpendicular baseline: %d'\
% (inps.perp_base_max, len(date12_list)))
# Doppler Overlap Percentage
if inps.sensor:
bandwidth_az = pnet.azimuth_bandwidth(inps.sensor)
date12_list = pnet.threshold_doppler_overlap(date12_list, date6_list, dop_list,\
bandwidth_az, inps.dop_overlap_min/100.0)
print('number of interferograms after filtering of min '+str(inps.dop_overlap_min)+'%'+\
' overlap in azimuth Doppler frequency: '+str(len(date12_list)))
# Write ifgram_list.txt
if not date12_list:
print('WARNING: No interferogram selected!')
return None
# date12_list to date_list
m_dates = [date12.split('-')[0] for date12 in date12_list]
s_dates = [date12.split('-')[1] for date12 in date12_list]
print('number of acquisitions input : '+str(len(date6_list)))
print('number of acquisitions selected: '+str(len(list(set(m_dates + s_dates)))))
print('number of interferograms selected: '+str(len(date12_list)))
# Output directory/filename
if not inps.outfile:
if pysar.miami_path and 'SCRATCHDIR' in os.environ:
inps.out_dir = os.getenv('SCRATCHDIR')+'/'+project_name+'/PROCESS'
else:
try: inps.out_dir = os.path.dirname(os.path.abspath(inps.reference_file))
except: inps.out_dir = os.path.dirname(os.path.abspath(inps.baseline_file))
inps.outfile = inps.out_dir+'/ifgram_list.txt'
inps.outfile = os.path.abspath(inps.outfile)
inps.out_dir = os.path.dirname(inps.outfile)
if not os.path.isdir(inps.out_dir):
os.makedirs(inps.out_dir)
# Write txt file
print('writing >>> '+inps.outfile)
np.savetxt(inps.outfile, date12_list, fmt='%s')
# Plot network info
if not inps.disp_fig:
plt.switch_backend('Agg')
out_fig_name = 'BperpHistory.pdf'
print('plotting baseline history in temp/perp baseline domain to file: '+out_fig_name)
fig2, ax2 = plt.subplots()
ax2 = pnet.plot_perp_baseline_hist(ax2, date8_list, pbase_list)
plt.savefig(inps.out_dir+'/'+out_fig_name, bbox_inches='tight')
out_fig_name = 'Network.pdf'
print('plotting network / pairs in temp/perp baseline domain to file: '+out_fig_name)
fig1, ax1 = plt.subplots()
ax1 = pnet.plot_network(ax1, date12_list, date8_list, pbase_list)
plt.savefig(inps.out_dir+'/'+out_fig_name, bbox_inches='tight')
if inps.disp_fig:
plt.show()
return inps.outfile
def main(argv):
inps = cmdLineParse()
suffix = '_demErr'
if not inps.outfile:
inps.outfile = os.path.splitext(
inps.timeseries_file)[0] + suffix + os.path.splitext(
inps.timeseries_file)[1]
# 1. template_file
if inps.template_file:
print('read option from template file: ' + inps.template_file)
inps = read_template2inps(inps.template_file, inps)
# Read Time Series
print("loading time series: " + inps.timeseries_file)
atr = readfile.read_attribute(inps.timeseries_file)
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
h5 = h5py.File(inps.timeseries_file)
date_list = sorted(h5['timeseries'].keys())
date_num = len(date_list)
print('number of acquisitions: ' + str(date_num))
# Exclude date info
#inps.ex_date = ['20070115','20100310']
if inps.ex_date:
inps = get_exclude_date(inps, date_list)
if inps.ex_date:
inps.ex_flag = np.array([i not in inps.ex_date for i in date_list])
timeseries = np.zeros((len(date_list), length * width), np.float32)
prog_bar = ptime.progress_bar(maxValue=date_num, prefix='loading: ')
for i in range(date_num):
date = date_list[i]
d = h5['timeseries'].get(date)[:]
timeseries[i][:] = d.flatten('F')
prog_bar.update(i + 1, suffix=date)
del d
h5.close()
prog_bar.close()
# Perpendicular Baseline
print('read perpendicular baseline')
try:
inps.pbase = ut.perp_baseline_timeseries(atr, dimension=0)
if inps.pbase.shape[1] > 1:
print('\tconsider P_BASELINE variation in azimuth direction')
else:
pbase = inps.pbase
except:
print('\tCannot find P_BASELINE_TIMESERIES from timeseries file.')
print('\tTrying to calculate it from interferograms file')
if inps.ifgram_file:
inps.pbase = np.array(
ut.perp_baseline_ifgram2timeseries(
inps.ifgram_file)[0]).reshape(date_num, 1)
else:
message = 'No interferogram file input!\n'+\
'Can not correct for DEM residula without perpendicular base info!'
raise Exception(message)
# Temporal Baseline
print('read temporal baseline')
inps.tbase = np.array(ptime.date_list2tbase(date_list)[0]).reshape(
date_num, 1)
# Incidence angle (look angle in the paper)
if inps.incidence_angle:
if os.path.isfile(inps.incidence_angle):
print('reading incidence angle from file: ' + inps.incidence_angle)
inps.incidence_angle = readfile.read(inps.incidence_angle)[0]
else:
try:
inps.incidence_angle = np.array(float(inps.incidence_angle))
print('use input incidence angle : ' +
str(inps.incidence_angle))
except:
raise ValueError('Can not read input incidence angle: ' +
str(inps.incidence_angle))
else:
print('calculate incidence angle using attributes of time series file')
if inps.pbase.shape[1] > 1:
inps.incidence_angle = ut.incidence_angle(atr, dimension=2)
else:
inps.incidence_angle = ut.incidence_angle(atr, dimension=1)
inps.incidence_angle *= np.pi / 180.0
# Range distance
if inps.range_dis:
if os.path.isfile(inps.range_dis):
print('reading range distance from file: ' + inps.range_dis)
inps.range_dis = readfile.read(inps.range_dis)[0]
else:
try:
inps.range_dis = np.array(float(inps.range_dis))
print('use input range distance : ' + str(inps.range_dis))
except:
raise ValueError('Can not read input incidence angle: ' +
str(inps.range_dis))
else:
print(
'calculate range distance using attributes from time series file')
if inps.pbase.shape[1] > 1:
inps.range_dis = ut.range_distance(atr, dimension=2)
else:
inps.range_dis = ut.range_distance(atr, dimension=1)
# Design matrix - temporal deformation model using tbase
print('-------------------------------------------------')
if inps.phase_velocity:
print('using phase velocity history')
A1 = np.ones((date_num - 1, 1))
A2 = (inps.tbase[1:date_num] + inps.tbase[0:date_num - 1]) / 2.0
A3 = (inps.tbase[1:date_num]**3 - inps.tbase[0:date_num - 1]**
3) / np.diff(inps.tbase, axis=0) / 6.0
#A3 = (inps.tbase[1:date_num]**2 + inps.tbase[1:date_num]*inps.tbase[0:date_num-1] +\
# inps.tbase[0:date_num-1]**2) / 6.0
else:
print('using phase history')
A1 = np.hstack((np.ones((date_num, 1)), inps.tbase))
A2 = inps.tbase**2 / 2.0
A3 = inps.tbase**3 / 6.0
# Polynomial order of model
print("temporal deformation model's polynomial order = " +
str(inps.poly_order))
if inps.poly_order == 1: A_def = A1
elif inps.poly_order == 2: A_def = np.hstack((A1, A2))
elif inps.poly_order == 3: A_def = np.hstack((A1, A2, A3))
# step function
if inps.step_date:
print("temporal deformation model's step function step at " +
inps.step_date)
step_yy = ptime.yyyymmdd2years(inps.step_date)
yy_list = ptime.yyyymmdd2years(date_list)
flag_array = np.array(yy_list) >= step_yy
A_step = np.zeros((date_num, 1))
A_step[flag_array] = 1.0
A_def = np.hstack((A_def, A_step))
# Heresh's original code for phase history approach
#A_def = np.hstack((A2,A1,np.ones((date_num,1))))
print('-------------------------------------------------')
##---------------------------------------- Loop for L2-norm inversion -----------------------------------##
delta_z_mat = np.zeros([length, width], dtype=np.float32)
resid_n = np.zeros([A_def.shape[0], length * width], dtype=np.float32)
constC = np.zeros([length, width], dtype=np.float32)
#delta_a_mat = np.zeros([length, width])
if inps.incidence_angle.ndim == 2 and inps.range_dis.ndim == 2:
print('inversing using L2-norm minimization (unweighted least squares)'\
' pixel by pixel: %d loops in total' % (length*width))
prog_bar = ptime.progress_bar(maxValue=length * width,
prefix='calculating: ')
for i in range(length * width):
row = i % length
col = i / length
range_dis = inps.range_dis[row, col]
inc_angle = inps.incidence_angle[row, col]
# Consider P_BASELINE variation within one interferogram
if inps.pbase.shape[1] > 1:
pbase = inps.pbase[:, row].reshape(date_num, 1)
# Design matrix - DEM error using pbase, range distance and incidence angle
A_delta_z = pbase / (range_dis * np.sin(inc_angle))
if inps.phase_velocity:
pbase_v = np.diff(pbase, axis=0) / np.diff(inps.tbase, axis=0)
A_delta_z_v = pbase_v / (range_dis * np.sin(inc_angle))
A = np.hstack((A_delta_z_v, A_def))
else:
A = np.hstack((A_delta_z, A_def))
# L-2 norm inversion
if inps.ex_date:
A_inv = np.linalg.pinv(A[inps.ex_flag, :])
else:
A_inv = np.linalg.pinv(A)
# Get unknown parameters X = [delta_z, vel, acc, delta_acc, ...]
ts_dis = timeseries[:, i]
if inps.phase_velocity:
ts_dis = np.diff(ts_dis, axis=0) / np.diff(inps.tbase, axis=0)
if inps.ex_date:
X = np.dot(A_inv, ts_dis[inps.ex_flag])
else:
X = np.dot(A_inv, ts_dis)
# Residual vector n
resid_n[:, i] = ts_dis - np.dot(A, X)
# Update DEM error / timeseries matrix
delta_z = X[0]
delta_z_mat[row, col] = delta_z
if inps.update_timeseries:
timeseries[:, i] -= np.dot(A_delta_z, delta_z).flatten()
prog_bar.update(i + 1, every=length * width / 100)
prog_bar.close()
elif inps.incidence_angle.ndim == 1 and inps.range_dis.ndim == 1:
print('inversing using L2-norm minimization (unweighted least squares)'\
' column by column: %d loops in total' % (width))
prog_bar = ptime.progress_bar(maxValue=width, prefix='calculating: ')
for i in range(width):
range_dis = inps.range_dis[i]
inc_angle = inps.incidence_angle[i]
# Design matrix - DEM error using pbase, range distance and incidence angle
A_delta_z = pbase / (range_dis * np.sin(inc_angle))
if inps.phase_velocity:
pbase_v = np.diff(pbase, axis=0) / np.diff(inps.tbase, axis=0)
A_delta_z_v = pbase_v / (range_dis * np.sin(inc_angle))
A = np.hstack((A_delta_z_v, A_def))
else:
A = np.hstack((A_delta_z, A_def))
# L-2 norm inversion
if inps.ex_date:
A_inv = np.linalg.pinv(A[inps.ex_flag, :])
else:
A_inv = np.linalg.pinv(A)
# Get unknown parameters X = [delta_z, vel, acc, delta_acc, ...]
ts_dis = timeseries[:, i * length:(i + 1) * length]
if inps.phase_velocity:
ts_dis = np.diff(ts_dis, axis=0) / np.diff(inps.tbase, axis=0)
if inps.ex_date:
X = np.dot(A_inv, ts_dis[inps.ex_flag, :])
else:
X = np.dot(A_inv, ts_dis)
# Residual vector n
resid_n[:, i * length:(i + 1) * length] = ts_dis - np.dot(A, X)
constC[:, i] = X[1].reshape((1, length))
# Update DEM error / timeseries matrix
delta_z = X[0].reshape((1, length))
delta_z_mat[:, i] = delta_z
if inps.update_timeseries:
timeseries[:, i * length:(i + 1) * length] -= np.dot(
A_delta_z, delta_z)
prog_bar.update(i + 1, every=width / 100)
prog_bar.close()
elif inps.incidence_angle.ndim == 0 and inps.range_dis.ndim == 0:
print(
'inversing using L2-norm minimization (unweighted least squares) for the whole area'
)
# Design matrix - DEM error using pbase, range distance and incidence angle
A_delta_z = pbase / (inps.range_dis * np.sin(inps.incidence_angle))
if inps.phase_velocity:
pbase_v = np.diff(pbase, axis=0) / np.diff(inps.tbase, axis=0)
A_delta_z_v = pbase_v / (inps.range_dis *
np.sin(inps.incidence_angle))
A = np.hstack((A_delta_z_v, A_def))
else:
A = np.hstack((A_delta_z, A_def))
# L-2 norm inversion
if inps.ex_date:
A_inv = np.linalg.pinv(A[inps.ex_flag, :])
else:
A_inv = np.linalg.pinv(A)
# Get unknown parameters X = [delta_z, vel, acc, delta_acc, ...]
if inps.phase_velocity:
timeseries = np.diff(timeseries, axis=0) / np.diff(inps.tbase,
axis=0)
if inps.ex_date:
X = np.dot(A_inv, timeseries[inps.ex_flag, :])
else:
X = np.dot(A_inv, timeseries)
# Residual vector n
resid_n = ts_dis - np.dot(A, X)
# Update DEM error / timeseries matrix
delta_z_mat = X[0].reshape((1, length * width))
if inps.update_timeseries:
timeseries -= np.dot(A_delta_z, delta_z_mat)
delta_z_mat = np.reshape(delta_z_mat, [length, width], order='F')
else:
print(
'ERROR: Script only support same dimension for both incidence angle and range distance matrix.'
)
print('dimension of incidence angle: ' +
str(inps.incidence_angle.ndim))
print('dimension of range distance: ' + str(inps.range_dis.ndim))
sys.exit(1)
##------------------------------------------------ Output --------------------------------------------##
# DEM error file
if 'Y_FIRST' in list(atr.keys()):
dem_error_file = 'demGeo_error.h5'
else:
dem_error_file = 'demRadar_error.h5'
#if inps.phase_velocity: suffix = '_pha_poly'+str(inps.poly_order)
#else: suffix = '_vel_poly'+str(inps.poly_order)
#dem_error_file = os.path.splitext(dem_error_file)[0]+suffix+os.path.splitext(dem_error_file)[1]
print('writing >>> ' + dem_error_file)
atr_dem_error = atr.copy()
atr_dem_error['FILE_TYPE'] = 'dem'
atr_dem_error['UNIT'] = 'm'
writefile.write(delta_z_mat, atr_dem_error, dem_error_file)
## Phase Constant C = resid_n[0,:]
#atrC = atr.copy()
#atrC['FILE_TYPE'] = 'mask'
#atrC['UNIT'] = 'm'
#writefile.write(constC, atrC, 'constD.h5')
## Corrected DEM file
#if inps.dem_file:
# inps.dem_outfile = os.path.splitext(inps.dem_file)[0]+suffix+os.path.splitext(inps.dem_file)[1]
# print '--------------------------------------'
# print 'writing >>> '+inps.dem_outfile
# dem, atr_dem = readfile.read(inps.dem_file)
# writefile.write(dem+delta_z_mat, atr_dem, inps.dem_outfile)
#outfile = 'delta_acc.h5'
#print 'writing >>> '+outfile
#atr_dem_error = atr.copy()
#atr_dem_error['FILE_TYPE'] = 'velocity'
#atr_dem_error['UNIT'] = 'm/s'
#writefile.write(delta_a_mat, atr_dem_error, outfile)
#print '**************************************'
# Corrected Time Series
if inps.update_timeseries:
print('writing >>> ' + inps.outfile)
print('number of dates: ' + str(len(date_list)))
h5out = h5py.File(inps.outfile, 'w')
group = h5out.create_group('timeseries')
prog_bar = ptime.progress_bar(maxValue=date_num, prefix='writing: ')
for i in range(date_num):
date = date_list[i]
d = np.reshape(timeseries[i][:], [length, width], order='F')
dset = group.create_dataset(date, data=d, compression='gzip')
prog_bar.update(i + 1, suffix=date)
prog_bar.close()
for key, value in atr.items():
group.attrs[key] = value
h5out.close()
outFile = os.path.splitext(inps.outfile)[0] + 'InvResid.h5'
print('writing >>> ' + outFile)
print('number of dates: ' + str(A_def.shape[0]))
h5out = h5py.File(outFile, 'w')
group = h5out.create_group('timeseries')
prog_bar = ptime.progress_bar(maxValue=A_def.shape[0], prefix='writing: ')
for i in range(A_def.shape[0]):
date = date_list[i]
d = np.reshape(resid_n[i][:], [length, width], order='F')
dset = group.create_dataset(date, data=d, compression='gzip')
prog_bar.update(i + 1, suffix=date)
prog_bar.close()
# Attribute
for key, value in atr.items():
group.attrs[key] = value
if A_def.shape[0] == date_num:
group.attrs['UNIT'] = 'm'
else:
group.attrs['UNIT'] = 'm/yr'
h5out.close()
return
def main(argv):
inps = cmdLineParse()
# Basic info
atr = readfile.read_attribute(inps.timeseries_file)
k = atr['FILE_TYPE']
if k not in ['timeseries']:
sys.exit('ERROR: only timeseries file supported, input is ' + k +
' file!')
h5 = h5py.File(inps.timeseries_file, 'r')
date_list = sorted(h5[k].keys())
date_num = len(date_list)
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
pixel_num = length * width
tbase = np.array(ptime.date_list2tbase(date_list)[0], np.float32).reshape(
(date_num, 1))
tbase /= 365.25
# Read timeseries
print('loading time-series ...')
timeseries = np.zeros((date_num, pixel_num))
prog_bar = ptime.progress_bar(maxValue=date_num)
for i in range(date_num):
date = date_list[i]
d = h5[k].get(date)[:]
timeseries[i, :] = d.flatten(0)
prog_bar.update(i + 1, suffix=date)
del d
h5.close()
prog_bar.close()
# Smooth timeseries with moving window in time
print(
'smoothing time-series using moving gaussian window with size of %.1f years'
% inps.time_win)
timeseries_filt = np.zeros((date_num, pixel_num))
prog_bar = ptime.progress_bar(maxValue=date_num)
for i in range(date_num):
date = date_list[i]
# Weight from Gaussian (normal) distribution in time
t_diff = tbase[i] - tbase
weight = np.exp(-0.5 * (t_diff**2) / (inps.time_win**2))
weight /= np.sum(weight)
weightMat = np.tile(weight, (1, pixel_num))
# Smooth the current acquisition - moving window in time one by one
timeseries_filt[i, :] = np.sum(timeseries * weightMat, 0)
prog_bar.update(i + 1, suffix=date)
del weightMat
del timeseries
prog_bar.close()
# Write smoothed timeseries file
try:
ref_date = atr['ref_date']
except:
ref_date = date_list[0]
ref_date_idx = date_list.index(ref_date)
print('reference date: ' + ref_date)
print('reference date index: ' + str(ref_date_idx))
ref_data = np.reshape(timeseries_filt[ref_date_idx, :], [length, width])
if not inps.outfile:
inps.outfile = os.path.splitext(inps.timeseries_file)[0] + '_smooth.h5'
print('writing >>> ' + inps.outfile)
print('number of acquisitions: ' + str(date_num))
h5out = h5py.File(inps.outfile, 'w')
group = h5out.create_group(k)
prog_bar = ptime.progress_bar(maxValue=date_num)
for i in range(date_num):
date = date_list[i]
data = np.reshape(timeseries_filt[i, :], [length, width])
dset = group.create_dataset(date,
data=data - ref_data,
compression='gzip')
prog_bar.update(i + 1, suffix=date)
for key, value in atr.items():
group.attrs[key] = value
h5out.close()
prog_bar.close()
print('Done.')
return inps.outfile
