def stacking(File):
## Stack multi-temporal dataset into one
## equivalent to temporal sum
## File Info
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
## Calculation
stack = np.zeros([length,width])
if k in ['timeseries','interferograms','wrapped','coherence']:
##### Input File Info
h5file = h5py.File(File,'r')
epochList = h5file[k].keys()
epochList = sorted(epochList)
epochNum = len(epochList)
for i in range(epochNum):
epoch = epochList[i]
if k == 'timeseries': data = h5file[k].get(epoch)[:]
else: data = h5file[k][epoch].get(epoch)[:]
stack += data
printProgress(i+1,epochNum)
h5file.close()
else:
try: stack, atrStack = readfile.read(File)
except: print 'Cannot read file: '+File; sys.exit(1)
return stack
def main(argv):
try: timeSeriesFile=argv[0]
except: Usage() ; sys.exit(1)
try: outname=argv[1]
except: outname='sum_'+timeSeriesFile
##################################################
print "\n*************** Calculating Sum of Epochs ****************"
atr = readfile.read_attributes(timeSeriesFile)
k = atr['FILE_TYPE']
print "Loading time series: " + timeSeriesFile
h5timeseries=h5py.File(timeSeriesFile)
dateList = h5timeseries['timeseries'].keys()
dateList = sorted(dateList)
dateIndex={}
for ni in range(len(dateList)):
dateIndex[dateList[ni]]=ni
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
D = np.zeros((len(dateList),length*width),np.float32)
for date in dateList:
print date
d = h5timeseries['timeseries'].get(date)[:]
D[dateIndex[date]][:]=d.flatten(0)
##################################################
## Calculate Sum
lt=len(dateList)
sumD=np.zeros(D.shape)
print 'calculating epochs sum ...'
for j in range(lt):
print j
sumD[j,:] = np.sum(np.abs(D-D[j,:]),0)/lt
## Normalize to 0 and 1
## with high atmosphere equal to 0 and no atmosphere equal to 1
sumD -= np.max(sumD,0)
sumD *= -1
sumD /= np.max(sumD,0)
sumD[np.isnan(sumD)] = 1
##################################################
print 'writing to >>> '+outname
h5sum = h5py.File(outname,'w')
group = h5sum.create_group('timeseries')
for date in dateList:
print date
d = np.reshape(sumD[dateIndex[date]][:],[length,width])
dset = group.create_dataset(date, data=d, compression='gzip')
for key,value in atr.iteritems():
group.attrs[key] = value
print 'Done.'
def main(argv):
inversion_method = 'l2'
#maskFile = 'Mask.h5'
if len(sys.argv)>2:
try: opts, args = getopt.getopt(argv,"h:f:l:o:")
except getopt.GetoptError:
Usage() ; sys.exit(1)
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': igramsFile = arg
elif opt == '-l': inversion_method = arg.lower()
elif opt == '-o': timeseriesFile = arg
elif len(sys.argv)==2:
if os.path.isfile(argv[0]): igramsFile = argv[0]
else: Usage(); sys.exit(1)
else: Usage(); sys.exit(1)
#try: igramsFile = argv[0]
#except: Usage() ; sys.exit(1)
#try: inversion_method = argv[1]
#except: inversion_method = 'L2'
try: timeseriesFile
except: timeseriesFile = 'timeseries.h5'
#h5file = h5py.File(igramsFile,'r')
atr = readfile.read_attributes(igramsFile)
if not atr['FILE_TYPE'] == 'interferograms':
print '**********************************************************************'
print 'ERROR:'
print ' '+igramsFile+ ' was not found or the file is not readable!'
print '**********************************************************************'
Usage();sys.exit(1)
#numIfgrams = len(h5file['interferograms'].keys())
#if numIfgrams == 0.:
# print "load interferograms first by running: load_data.py TEMPLATEFILE"
# sys.exit(1)
#h5timeseries = h5py.File(timeseriesFile,'w')
print '\n************** Inverse Time Series ****************'
if not inversion_method == 'l1':
print 'Inverse time series using L2 norm minimization'
ut.timeseries_inversion(igramsFile,timeseriesFile)
else:
print 'Inverse time series using L1 norm minimization'
ut.timeseries_inversion_L1(igramsFile,timeseriesFile)
def main(argv):
try:
File = argv[0]
atr = readfile.read_attributes(File)
except: Usage(); sys.exit(1)
try: outName = argv[1]
except: outName = 'tempMean_'+File
#except: outName = 'average_spatial_coherence.h5'
print '\n*************** Temporal Average ******************'
##### Input File Info
k = atr['FILE_TYPE']
print 'Input file is '+k
width = int(atr['WIDTH'])
length = int(atr['FILE_LENGTH'])
h5file = h5py.File(File)
epochList = h5file[k].keys()
epochList = sorted(epochList)
print 'number of epoch: '+str(len(epochList))
##### Calculation
dMean = np.zeros((length,width))
print 'calculating ...'
for epoch in epochList:
print epoch
if k in ['interferogram','coherence','wrapped']:
d = h5file[k][epoch].get(epoch)[:]
elif k in ['timeseries']:
d = h5file[k].get(epoch)[:]
else: print k+' type is not supported currently.'; sys.exit(1)
dMean += d
dMean /= len(epochList)
del d
h5file.close()
##### Output
print 'writing >>> '+outName
h5mean = h5py.File(outName,'w')
group = h5mean.create_group('mask')
dset = group.create_dataset(os.path.basename('mask'), data=dMean, compression='gzip')
for key,value in atr.iteritems():
group.attrs[key] = value
h5mean.close()
def remove_multiple_surface(File, surf_type, Mask, ysub, outName):
start = time.time()
##### Output File Name
if outName == "":
ext = os.path.splitext(File)[1].lower()
outName = os.path.basename(File).split(ext)[0] + "_" + surf_type + ext
atr = readfile.read_attributes(File)
k = atr["FILE_TYPE"]
print "Input file is " + atr["PROCESSOR"] + " " + k
if k == "timeseries":
h5file = h5py.File(File, "r")
ifgramList = h5file[k].keys()
ifgramList = sorted(ifgramList)
print "number of epochs: " + str(len(ifgramList))
h5flat = h5py.File(outName, "w")
group = h5flat.create_group(k)
print "writing >>> " + outName
for ifgram in ifgramList:
print "Removing " + surf_type + " from " + ifgram
dataIn = h5file[k].get(ifgram)[:]
dataOut = remove_data_multiple_surface(dataIn, surf_type, Mask, ysub)
dset = group.create_dataset(ifgram, data=dataOut, compression="gzip")
for key, value in h5file[k].attrs.iteritems():
group.attrs[key] = value
else:
try:
dataIn, atr = readfile.read(File)
except:
print "Input file type is not supported: " + atr["FILE_TYPE"]
dataOut = remove_data_multiple_surface(dataIn, surf_type, Mask, ysub)
ramp = dataIn - dataOut
writefile.write(dataOut, atr, outName)
# atr['FILE_TYPE']='mask'
# writefile.write(ramp,atr,'2quadratic.h5')
print "Remove " + surf_type + " took " + str(time.time() - start) + " secs"
def main(argv):
try: opts, args = getopt.getopt(argv,"f:h")
except getopt.GetoptError: Usage() ; sys.exit(1)
if opts==[]: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': File = arg
##### Read attributes
atr = readfile.read_attributes(File)
print '\n*************** Generate Incidence Angle *****************'
##### Calculate look angle
angle = look_angle(atr)
##### Output
atr['FILE_TYPE'] = 'mask'
outName = 'incidence_angle.h5'
writefile.write(angle,atr,outName)
def seed_xy(File,x,y,outName=''):
## Seed Input File with reference on point (y,x)
print 'Referencing input file to pixel: (%d, %d)'%(y,x)
##4-tuple defining the left, upper, right, and lower pixel coordinate [optional]
box = (x,y,x+1,y+1)
##### IO Info
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
if outName == '': outName = 'Seeded_'+os.path.basename(File)
##### Mask
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
mask = np.ones((length,width))
## Read refernce value
refList = ut.spatial_mean(File,mask,box)
## Seeding
seed_file(File,outName,refList,x,y)
return 1
def main(argv):
## Default value
phase_velocity = "no" # 'no' means use 'phase history'
update_timeseries = "yes"
if len(sys.argv) > 2:
try:
opts, args = getopt.getopt(argv, "h:f:F:o:v:", ["phase-velocity", "no-timeseries-update"])
except getopt.GetoptError:
print "Error in reading input options!"
Usage()
sys.exit(1)
for opt, arg in opts:
if opt in ["-h", "--help"]:
Usage()
sys.exit()
elif opt == "-f":
timeSeriesFile = arg
elif opt == "-F":
igramsFile = arg
elif opt == "-o":
outname = arg
elif opt == "--phase-velocity":
phase_velocity = "yes"
elif opt == "--no-timeseries-update":
update_timeseries = "no"
elif len(sys.argv) == 2:
if argv[0] in ["-h", "--help"]:
Usage()
sys.exit(1)
else:
timeSeriesFile = argv[0]
else:
Usage()
sys.exit(1)
try:
outname
except:
outname = timeSeriesFile.replace(".h5", "") + "_demCor.h5"
##### Read Time Series
print "\n*************** Topographic Error Correction ****************"
print "Loading time series: " + timeSeriesFile
atr = readfile.read_attributes(timeSeriesFile)
h5timeseries = h5py.File(timeSeriesFile)
dateList = h5timeseries["timeseries"].keys()
dateList = sorted(dateList)
lt = len(dateList)
print "number of epochs: " + str(lt)
dateIndex = {}
for ni in range(len(dateList)):
dateIndex[dateList[ni]] = ni
nrows = int(atr["FILE_LENGTH"])
ncols = int(atr["WIDTH"])
timeseries = np.zeros((len(dateList), nrows * ncols), np.float32)
for date in dateList:
print date
d = h5timeseries["timeseries"].get(date)[:]
timeseries[dateIndex[date]][:] = d.flatten("F")
del d
h5timeseries.close()
print "**************************************"
##### Temporal Baseline
print "read temporal baseline"
tbase, date_dict = ptime.date_list2tbase(dateList)
tbase = np.array(tbase).reshape(lt, 1)
##### Perpendicular Baseline
try:
Bp = [float(i) for i in atr["P_BASELINE_TIMESERIES"].split()]
Bp = np.array(Bp).reshape(lt, 1)
except:
print "Cannot find P_BASELINE_TIMESERIES from timeseries file."
print "Trying to calculate it from interferograms file"
try:
Bp = ut.Baseline_timeseries(igramsFile)
Bp = np.array(Bp).reshape(lt, 1)
except:
print "Error in calculating baseline time series!"
sys.exit(1)
Bp_v = (Bp[1:lt] - Bp[0 : lt - 1]) / (tbase[1:lt] - tbase[0 : lt - 1])
##### Cubic Temporal Deformation Model
## Formula (10) in (Fattahi and Amelung, 2013, TGRS)
if phase_velocity == "yes":
print "using phase velocity history"
M1 = np.ones((lt - 1, 1))
M2 = (tbase[1:lt] + tbase[0 : lt - 1]) / 2
M3 = (tbase[1:lt] ** 2 + tbase[1:lt] * tbase[0 : lt - 1] + tbase[0 : lt - 1] ** 2) / 6
M = np.hstack((M1, M2, M3))
else:
print "using phase history"
M = np.hstack((0.5 * tbase ** 2, tbase, np.ones((lt, 1))))
## Testing
# teta = (tetaN+tetaF)/2
# r = (rN+rF)/2
# teta=19.658799999999999*np.pi/180
# r=846848.2
# Bperp=1000*np.random.random((lt,1))
##### Range and Look Angle
near_range = float(atr["STARTING_RANGE1"])
dR = float(atr["RANGE_PIXEL_SIZE"])
r = float(atr["EARTH_RADIUS"])
H = float(atr["HEIGHT"])
far_range = near_range + dR * (ncols - 1)
incidence_n = np.pi - np.arccos((r ** 2 + near_range ** 2 - (r + H) ** 2) / (2 * r * near_range))
incidence_f = np.pi - np.arccos((r ** 2 + far_range ** 2 - (r + H) ** 2) / (2 * r * far_range))
various_range = "yes"
if various_range == "yes":
range_x = np.linspace(near_range, far_range, num=ncols, endpoint="FALSE")
look_angle_x = np.linspace(incidence_n, incidence_f, num=ncols, endpoint="FALSE")
else:
print "using center range and look angle to represent the whole area"
center_range = (near_range + far_range) / 2
center_look_angle = np.pi - np.arccos((r ** 2 + center_range ** 2 - (r + H) ** 2) / (2 * r * center_range))
range_x = np.tile(center_range, ncols)
look_angle_x = np.tile(center_look_angle, ncols)
# C1_v = Bp_v / (center_range * np.sin(center_look_angle))
# C1 = Bp / (center_range * np.sin(center_look_angle))
# timeseries_v = (timeseries[1:lt,:] - timeseries[0:lt-1,:]) / (tbase[1:lt] - tbase[0:lt-1])
##### Inversion column by column
print "inversing using L2-norm minimization (unweighted least squares)..."
dz = np.zeros([1, nrows * ncols])
for i in range(ncols):
## Design Matrix Inversion
C1_v = Bp_v / (range_x[i] * np.sin(look_angle_x[i]))
C1 = Bp / (range_x[i] * np.sin(look_angle_x[i]))
if phase_velocity == "yes":
C = np.hstack((M, C1_v))
else:
C = np.hstack((M, C1))
# print ' rank of the design matrix : '+str(np.linalg.matrix_rank(C))
# if np.linalg.matrix_rank(C) == 4: print ' design matrix has full rank'
Cinv = np.linalg.pinv(C)
## (Phase) Velocity History
ts_x = timeseries[:, i * nrows : (i + 1) * nrows]
ts_xv = (ts_x[1:lt, :] - ts_x[0 : lt - 1, :]) / (tbase[1:lt] - tbase[0 : lt - 1])
## DEM error
if phase_velocity == "yes":
par = np.dot(Cinv, ts_xv)
else:
par = np.dot(Cinv, ts_x)
dz_x = par[3].reshape((1, nrows))
## Update DEM error matrix and timeseries matrix
dz[0][i * nrows : (i + 1) * nrows] = dz_x
timeseries[:, i * nrows : (i + 1) * nrows] -= np.dot(C1, dz_x)
ut.printProgress(i + 1, ncols)
# dz[0][:] = par[3][:]
dz = np.reshape(dz, [nrows, ncols], order="F")
########## Output - DEM error #######################
# print '**************************************'
# print 'writing DEM_error.hgt'
# writefile.write_float32(dz,'DEM_error.hgt')
# f = open('DEM_error.hgt.rsc','w')
# f.write('FILE_LENGTH '+str(int(nrows))+'\n')
# f.write('WIDTH '+str(int(ncols))+'\n')
# print '**************************************'
h5fileDEM = "DEM_error.h5"
print "writing >>> " + h5fileDEM
h5rmse = h5py.File(h5fileDEM, "w")
group = h5rmse.create_group("dem")
dset = group.create_dataset(os.path.basename("dem"), data=dz, compression="gzip")
for key, value in atr.iteritems():
group.attrs[key] = value
group.attrs["UNIT"] = "m"
print "**************************************"
########### Output - Corrected Time Series ##########
if update_timeseries == "yes":
print "writing >>> " + outname
print "number of dates: " + str(len(dateList))
h5timeseriesDEMcor = h5py.File(outname, "w")
group = h5timeseriesDEMcor.create_group("timeseries")
for i in range(len(dateList)):
print dateList[i]
d = np.reshape(timeseries[i][:], [nrows, ncols], order="F")
dset = group.create_dataset(dateList[i], data=d, compression="gzip")
# for date in dateList:
# print date
# if not date in h5timeseriesDEMcor['timeseries']:
# d = np.reshape(timeseries[dateIndex[date]][:],[nrows,ncols],order='F')
# dset = group.create_dataset(date, data=d, compression='gzip')
for key, value in atr.iteritems():
group.attrs[key] = value
h5timeseriesDEMcor.close()
def main(argv):
## Global Variables
global fontSize, lineWidth, markerColor, markerSize
## Default Values
fontSize = 12
lineWidth = 2
markerColor = "orange"
markerSize = 16
saveFig = "no"
dispFig = "yes"
saveList = "no"
if len(sys.argv) > 2:
try:
opts, args = getopt.getopt(argv, "h:b:f:s:w:l:m:c:o:", ["save", "nodisplay", "list"])
except getopt.GetoptError:
Usage()
sys.exit(1)
for opt, arg in opts:
if opt in ("-h", "--help"):
Usage()
sys.exit()
elif opt == "-b":
baselineFile = arg
elif opt == "-f":
igramsFile = arg
elif opt == "-l":
listFile = arg
elif opt == "-s":
fontSize = int(arg)
elif opt == "-w":
lineWidth = int(arg)
elif opt == "-m":
markerSize = int(arg)
elif opt == "-c":
markerColor = arg
# elif opt == '-o': figName2 = arg; saveFig = 'yes'
elif opt == "--save":
saveFig = "yes"
elif opt == "--nodisplay":
dispFig = "no"
saveFig = "yes"
elif opt == "--list":
saveList = "yes"
try:
igramsFile
except:
try:
baselineFile
except:
Usage()
sys.exit(1)
elif len(sys.argv) == 2:
igramsFile = argv[0]
else:
Usage()
sys.exit(1)
##### Output figure name
figName1 = "BperpHist.pdf"
figName2 = "Network.pdf"
try:
igramsFile
if "Modified" in igramsFile:
figName1 = "BperpHist_Modified.pdf"
figName2 = "Network_Modified.pdf"
except:
pass
############# Read Time and Bperp ################
print "\n******************** Plot Network **********************"
try:
igramsFile
atr = readfile.read_attributes(igramsFile)
k = atr["FILE_TYPE"]
if k not in ["interferograms", "coherence", "wrapped"]:
print "Only interferograms / coherence / wrapped are supported."
sys.exit(1)
print "reading date and perpendicular baseline from " + k
dateList = ptime.date_list(igramsFile)
dateList6 = ptime.yymmdd(dateList)
print "number of acquisitions: " + str(len(dateList))
Bp = ut.Baseline_timeseries(igramsFile)
except:
baselineFile
print "reading date and perpendicular baseline from " + baselineFile
dateList, Bp = pnet.read_baseline_file(baselineFile)[0:2]
dateList6 = ptime.yymmdd(dateList)
############# Read Pairs Info ####################
print "reading pairs info"
try:
listFile
pairs = pnet.read_pairs_list(listFile, dateList)
except:
pairs = pnet.read_igram_pairs(igramsFile)
print "number of pairs : " + str(len(pairs))
if saveList == "yes":
pnet.write_pairs_list(pairs, dateList, "Pairs.list")
print "save pairs info to Pairs.list"
############# Read Unwrapping Error Info #######################
## For simulated interferograms only
## To plot the interferograms with unwrapping errors with a different color
# N_unw_err=0
# try:
# for ifgram in ifgramList:
# if h5file[k[0]][ifgram].attrs['unwrap_error']=='yes':
# N_unw_err=N_unw_err+1
# except: pass
#
# if N_unw_err>0:
# pairs_ue=np.zeros([N_unw_err,2],np.int)
# i=0
# for ifgram in ifgramList:
# if h5file[k[0]][ifgram].attrs['unwrap_error']=='yes':
# date1,date2 = h5file[k[0]][ifgram].attrs['DATE12'].split('-')
# pairs_ue[i][0]=dateList6.index(date1)
# pairs_ue[i][1]=dateList6.index(date2)
# i=i+1
#
############### Fig 1 - Interferogram Network ##################
fig1 = plt.figure(1)
fig1 = plot_network(fig1, pairs, dateList, Bp)
if saveFig == "yes":
plt.savefig(figName2, bbox_inches="tight")
print "save figure to " + figName2
############## Fig 2 - Baseline History ###################
fig2 = plt.figure(2)
fig2 = plot_bperp_hist(fig2, dateList, Bp)
if saveFig == "yes":
plt.savefig(figName1, bbox_inches="tight")
print "save figure to " + figName1
if dispFig == "yes":
plt.show()
def main(argv):
cbar_bin_num = 9
cbar_label = 'Mean LOS velocity'
color_map = 'jet'
data_alpha = 0.7
disp_opposite = 'no'
disp_colorbar = 'yes'
rewrapping = 'no'
fig_dpi = 500
#fig_size = [6.0,9.0]
fig_unit = 'mm/yr'
disp_ref = 'yes'
ref_size = 5
dispDisplacement = 'no'
if len(sys.argv)>2:
try: opts, args = getopt.getopt(argv,"f:m:M:d:c:w:i:r:",['noreference','fig-size',\
'ref-size=','cbar-label=','displacement','cbar-bin-num='])
except getopt.GetoptError: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt == '-f': File = arg
elif opt == '-m': Vmin = float(arg)
elif opt == '-M': Vmax = float(arg)
elif opt == '-d': epoch_date = arg
elif opt == '-c': color_map = arg
elif opt == '-i': disp_opposite = arg
elif opt == '-w': rewrapping = arg
elif opt == '-r': fig_dpi = int(arg)
elif opt == '--cbar-bin-num' : cbar_bin_num = int(arg)
elif opt == '--cbar-label' : cbar_label = arg
elif opt == '--displacement' : dispDisplacement = 'yes'
elif opt == '--fig-size' : fig_size = [float(i) for i in arg.split(',')][0:2]
elif opt == '--ref-size' : ref_size = int(arg)
elif opt == '--noreference' : disp_ref = 'no'
elif len(sys.argv)==2:
if argv[0]=='-h': Usage(); sys.exit(1)
elif os.path.isfile(argv[0]): File = argv[0]
else: Usage(); sys.exit(1)
else: Usage(); sys.exit(1)
#######################################################
################### Prepare Data ####################
## prepare: data, North, East, South, West
ext = os.path.splitext(File)[1].lower()
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
print '\n*************** Output to KMZ file ****************'
print 'Input file is '+k
if ext == '.h5':
try: h5file=h5py.File(File,'r')
except: Usage() ; sys.exit(1)
outName=File.split('.')[0]
if k in ('interferograms','wrapped','coherence'):
ifgramList=h5file[k].keys()
for i in range(len(ifgramList)):
if epoch_date in ifgramList[i]:
epoch_number = i
print ifgramList[epoch_number]
outName = ifgramList[epoch_number]
#outName=epoch_date
dset = h5file[k][ifgramList[epoch_number]].get(ifgramList[epoch_number])
data = dset[0:dset.shape[0],0:dset.shape[1]]
if k == 'wrapped':
print 'No wrapping for wrapped interferograms. Set rewrapping=no'
rewrapping = 'no'
Vmin = -np.pi
Vmax = np.pi
elif 'timeseries' in k:
epochList=h5file['timeseries'].keys()
for i in range(len(epochList)):
if epoch_date in epochList[i]:
epoch_number = i
#### Out name
try: ref_date = atr['ref_date']
except: ref_date = ut.yyyymmdd(atr['DATE'])[0]
#ref_date=h5file['timeseries'].attrs['ref_date']
if len(epoch_date)==8: outName=ref_date[2:]+'-'+epoch_date[2:]
else: outName=ref_date[2:]+'-'+epoch_date
dset = h5file['timeseries'].get(epochList[epoch_number])
data = dset[0:dset.shape[0],0:dset.shape[1]]
### one dataset format: velocity, mask, temporal_coherence, rmse, std, etc.
else:
dset = h5file[k].get(k)
data=dset[0:dset.shape[0],0:dset.shape[1]]
if disp_opposite in('yes','Yes','Y','y','YES'):
data=-1*data
try:
xref=h5file[k].attrs['ref_x']
yref=h5file[k].attrs['ref_y']
except: pass
elif ext in ['.unw','.cor','.hgt','.trans','.dem']:
if ext in ['.unw','.cor','.hgt','.trans']:
a,data,atr = readfile.read_float32(File)
outName = File
if ext in ['.unw']:
if dispDisplacement == 'yes':
print 'show displacement'
phase2range = -float(atr['WAVELENGTH']) / (4*np.pi)
data *= phase2range
atr['UNIT'] = 'm'
rewrapping == 'no'
fig_unit = 'mm'
if rewrapping == 'yes':
data = rewrap(data,atr)
fig_unit = 'radian'
elif ext == '.dem':
data,atr = readfile.read_real_int16(File)
outName = File
if ext in ['.hgt','.dem']: fig_unit = 'm'
elif ext in ['.cor','.trans']: fig_unit = ' '
else: sys.exit('Do not support '+ext+' file!')
########################################################
if rewrapping=='yes':
data=rewrap(data)
Vmin = -np.pi #[-pi,pi] for wrapped interferograms
Vmax = np.pi
else:
try: Vmin
except: Vmin = np.nanmin(data)
try: Vmax
except: Vmax = np.nanmax(data)
try:
lon_step = float(atr['X_STEP'])
lat_step = float(atr['Y_STEP'])
lon_unit = atr['Y_UNIT']
lat_unit = atr['X_UNIT']
West = float(atr['X_FIRST'])
North = float(atr['Y_FIRST'])
South = North+lat_step*(data.shape[0]-1)
East = West +lon_step*(data.shape[1]-1)
geocoord = 'yes'
print 'Geocoded'
except:
print '%%%%%%%%%%'
print 'Error:\nThe input file is not geocoded\n'
print '%%%%%%%%%%'
Usage();sys.exit(1)
#######################################################
################### Output KMZ ######################
############### Make PNG file
print 'Making png file ...'
length = data.shape[0]
width = data.shape[1]
try:fig_size
except:
fig_size_0 = 6.0 ## min figure dimension: 6.0
ratio = float(length)/float(width)
fig_size = [fig_size_0,fig_size_0*ratio]
print 'figure size: %.1f, %.1f'%(fig_size[0],fig_size[1])
ccmap = plt.get_cmap(color_map)
fig = plt.figure(figsize=fig_size,frameon=False)
ax = fig.add_axes([0., 0., 1., 1.])
ax.set_axis_off()
aspect = width/(length*1.0)
try: ax.imshow(data,aspect='auto',cmap=ccmap,vmax=Vmax,vmin=Vmin)
except: ax.imshow(data,aspect='auto',cmap=ccmap)
if disp_ref == 'yes':
try:
xref = int(atr['ref_x'])
yref = int(atr['ref_y'])
ax.plot(xref,yref,'ks',ms=ref_size)
print 'show reference point'
except: print 'Cannot find reference point info!'
ax.set_xlim([0,width])
ax.set_ylim([length,0])
figName = outName + '.png'
print 'writing '+figName
plt.savefig(figName, pad_inches=0.0, transparent=True, dpi=fig_dpi)
############### Making colorbar
pc = plt.figure(figsize=(1,8))
axc = pc.add_subplot(111)
if fig_unit in ['mm','mm/yr']: v_scale = 1000
elif fig_unit in ['cm','cm/yr']: v_scale = 100
elif fig_unit in ['m', 'm/yr']: v_scale = 1
norm = mpl.colors.Normalize(vmin=Vmin*v_scale, vmax=Vmax*v_scale)
clb = mpl.colorbar.ColorbarBase(axc,cmap=ccmap,norm=norm, orientation='vertical')
#clb.set_label(fig_unit)
clb.set_label(cbar_label+' ['+fig_unit+']')
clb.locator = ticker.MaxNLocator(nbins=cbar_bin_num)
clb.update_ticks()
pc.subplots_adjust(left=0.2,bottom=0.3,right=0.4,top=0.7)
pc.patch.set_facecolor('white')
pc.patch.set_alpha(0.7)
pc.savefig('colorbar.png',bbox_inches='tight',facecolor=pc.get_facecolor(),dpi=300)
############## Generate KMZ file
print 'generating kml file ...'
try: doc = KML.kml(KML.Folder(KML.name(atr['PROJECT_NAME'])))
except: doc = KML.kml(KML.Folder(KML.name('PySAR product')))
slc = KML.GroundOverlay(KML.name(figName),KML.Icon(KML.href(figName)),\
KML.altitudeMode('clampToGround'),\
KML.LatLonBox(KML.north(str(North)),KML.south(str(South)),\
KML.east( str(East)), KML.west( str(West))))
doc.Folder.append(slc)
#############################
print 'adding colorscale ...'
cb_rg = min(North-South, East-West)
cb_N = (North+South)/2.0 + 0.5*0.5*cb_rg
cb_W = East + 0.1*cb_rg
slc1 = KML.GroundOverlay(KML.name('colorbar'),KML.Icon(KML.href('colorbar.png')),\
KML.altitude('2000'),KML.altitudeMode('absolute'),\
KML.LatLonBox(KML.north(str(cb_N)),KML.south(str(cb_N-0.5*cb_rg)),\
KML.west( str(cb_W)),KML.east( str(cb_W+0.14*cb_rg))))
doc.Folder.append(slc1)
#############################
kmlstr = etree.tostring(doc, pretty_print=True)
kmlname = outName + '.kml'
print 'writing '+kmlname
kmlfile = open(kmlname,'w')
kmlfile.write(kmlstr)
kmlfile.close()
kmzName = outName + '.kmz'
print 'writing '+kmzName
cmdKMZ = 'zip ' + kmzName +' '+ kmlname +' ' + figName + ' colorbar.png'
os.system(cmdKMZ)
cmdClean = 'rm '+kmlname; print cmdClean; os.system(cmdClean)
cmdClean = 'rm '+figName; print cmdClean; os.system(cmdClean)
cmdClean = 'rm colorbar.png'; print cmdClean; os.system(cmdClean)
def main(argv):
## Default settings
contour_step = 200.0
contour_sigma = 3.0
demShade = "yes"
demContour = "yes"
global markerSize, markderSize2, markerColor, markerColor2, rectColor
global lineWidth, lineWidth2, edgeWidth, fontSize
# global markerColor_ref, markerColor_ref2
markerSize = 16
markerSize2 = 16
markerColor = "crimson" # g
markerColor2 = "lightgray"
markerColor_ref = "white"
markerColor_ref2 = "lightgray"
rectColor = "black"
lineWidth = 0
lineWidth2 = 0
edgeWidth = 1.5
fontSize = 16
global unit, radius, saveFig, dispFig, fig_dpi
fig_dpi = 300
radius = 0
saveFig = "no"
dispFig = "yes"
unit = "cm"
dispDisplacement = "no"
dispOpposite = "no"
dispContour = "only"
smoothContour = "no"
contour_step = 200
showRef = "yes"
vel_alpha = 1.0
zero_start = "yes"
global ref_xsub, ref_ysub, ref_date
global h5timeseries_2, dates_2, dateList_2
global lbound, hbound
############### Check Inputs ##################
if len(sys.argv) < 2:
Usage()
sys.exit(1)
elif len(sys.argv) == 2:
if argv[0] == "-h":
Usage()
sys.exit(1)
elif os.path.isfile(argv[0]):
timeSeriesFile = argv[0]
h5timeseries = h5py.File(timeSeriesFile)
k = h5timeseries.keys()
if not "timeseries" in k:
print "ERROR: Input file is " + k[0] + ".\n\tOnly timeseries is supported.\n"
sys.exit(1)
else:
Usage()
sys.exit(1)
elif len(sys.argv) > 2:
try:
opts, args = getopt.getopt(
argv,
"f:F:v:a:b:s:m:c:w:u:l:h:D:V:t:T:d:r:x:y:X:Y:o:E:",
[
"save",
"nodisplay",
"unit=",
"exclude=",
"ref-date=",
"rect-color=",
"zero-start=",
"zoom-x=",
"zoom-y=",
"zoom-lon",
"zoom-lat",
"lalo=",
"opposite",
"dem-nocontour",
"dem-noshade",
"displacement",
"contour-step=",
"contour-smooth=",
"LALO=",
],
)
except getopt.GetoptError:
Usage()
sys.exit(1)
for opt, arg in opts:
if opt == "-f":
timeSeriesFile = arg
elif opt == "-F":
timeSeriesFile_2 = arg
elif opt == "-v":
velocityFile = arg
elif opt == "-a":
vmin = float(arg)
elif opt == "-b":
vmax = float(arg)
elif opt == "-s":
fontSize = int(arg)
elif opt == "-m":
markerSize = int(arg)
markerSize2 = int(arg)
elif opt == "-c":
markerColor = arg
elif opt == "-w":
lineWidth = int(arg)
elif opt == "-u":
unit = arg
elif opt == "-l":
lbound = float(arg)
elif opt == "-h":
hbound = float(arg)
elif opt == "-D":
demFile = arg
elif opt == "-V":
contour_step = float(arg)
elif opt == "-t":
minDate = arg
elif opt == "-T":
maxDate = arg
elif opt == "-r":
radius = abs(int(arg))
elif opt == "-x":
xsub = [int(i) for i in arg.split(":")]
xsub.sort()
# dispVelFig='no'
elif opt == "-y":
ysub = [int(i) for i in arg.split(":")]
ysub.sort()
# dispVelFig='no'
elif opt == "-X":
ref_xsub = [int(i) for i in arg.split(":")]
ref_xsub.sort()
elif opt == "-Y":
ref_ysub = [int(i) for i in arg.split(":")]
ref_ysub.sort()
# dispVelFig='no'
elif opt == "--contour-step":
contour_step = float(arg)
elif opt == "--contour-smooth":
contour_sigma = float(arg)
elif opt == "--dem-nocontour":
demContour = "no"
elif opt == "--dem-noshade":
demShade = "no"
elif opt == "--displacement":
dispDisplacement = "yes"
elif opt in ["-E", "--exclude"]:
datesNot2show = arg.split(",")
elif opt in "--lalo":
lalosub = [float(i) for i in arg.split(",")]
elif opt in "--LALO":
ref_lalosub = [float(i) for i in arg.split(",")]
elif opt in ["--rect-color"]:
rectColor = arg
elif opt in ["--ref-date"]:
ref_date = ptime.yyyymmdd(arg)
elif opt in ["-u", "--unit"]:
unit = arg.lower()
elif opt == "--save":
saveFig = "yes"
elif opt == "--nodisplay":
dispFig = "no"
saveFig = "yes"
elif opt == "--opposite":
dispOpposite = "yes"
elif opt == "--zero-start":
zero_start = arg.lower()
elif opt == "--zoom-x":
win_x = [int(i) for i in arg.split(":")]
win_x.sort()
elif opt == "--zoom-y":
win_y = [int(i) for i in arg.split(":")]
win_y.sort()
elif opt == "--zoom-lon":
win_lon = [float(i) for i in arg.split(":")]
win_lon.sort()
elif opt == "--zoom-lat":
win_lat = [float(i) for i in arg.split(":")]
win_lat.sort()
##############################################################
## Read time series file info
if not os.path.isfile(timeSeriesFile):
print "\nERROR: Input time series file does not exist: " + timeSeriesFile + "\n"
sys.exit(1)
h5timeseries = h5py.File(timeSeriesFile)
k = h5timeseries.keys()
# read h5 file and its group type
if not "timeseries" in k:
print "ERROR: Input file is " + k[0] + ".\n\tOnly timeseries is supported.\n"
sys.exit(1)
atr = readfile.read_attributes(timeSeriesFile)
dateList1 = h5timeseries["timeseries"].keys()
dateList1 = sorted(dateList1)
dates1, datevector1 = ptime.date_list2vector(dateList1)
print "\n************ Time Series Display - Point *************"
##### Select Check
try:
lalosub
xsub = subset.coord_geo2radar([lalosub[1]], atr, "longitude")
ysub = subset.coord_geo2radar([lalosub[0]], atr, "latitude")
xsub = [xsub]
ysub = [ysub]
if radius == 0:
radius = 3
except:
pass
try:
ref_lalosub
ref_xsub = subset.coord_geo2radar([ref_lalosub[1]], atr, "longitude")
ref_ysub = subset.coord_geo2radar([ref_lalosub[0]], atr, "latitude")
ref_xsub = [ref_xsub]
ref_ysub = [ref_ysub]
if radius == 0:
radius = 3
except:
pass
##############################################################
global dates, dateList, datevector_all, dateListMinMax
print "*******************"
print "All dates existed:"
print dateList1
print "*******************"
## Check exclude date input
try:
datesNot2show
if os.path.isfile(datesNot2show[0]):
try:
datesNot2show = ptime.read_date_list(datesNot2show[0])
except:
print "Can not read date list file: " + datesNot2show[0]
print "dates not to show: " + str(datesNot2show)
except:
datesNot2show = []
## Check Min / Max Date
dateListMinMax = []
try:
minDate
minDate = ptime.yyyymmdd(minDate)
dateListMinMax.append(minDate)
minDateyy = ptime.yyyymmdd2years(minDate)
print "minimum date: " + minDate
for date in dateList1:
yy = ptime.yyyymmdd2years(date)
if yy < minDateyy:
datesNot2show.append(date)
except:
pass
try:
maxDate
maxDate = ptime.yyyymmdd(maxDate)
dateListMinMax.append(maxDate)
maxDateyy = ptime.yyyymmdd2years(maxDate)
print "maximum date: " + maxDate
for date in dateList1:
yy = ptime.yyyymmdd2years(date)
if yy > maxDateyy:
datesNot2show.append(date)
except:
pass
dateListMinMax = sorted(dateListMinMax)
if not dateListMinMax:
print "no min/max date input."
else:
datesMinMax, dateVecMinMax = ptime.date_list2vector(dateListMinMax)
## Finalize Date List
try:
dateList = []
for date in dateList1:
if date not in datesNot2show:
dateList.append(date)
print "--------------------------------------------"
print "dates used to show time series displacements:"
print dateList
print "--------------------------------------------"
except:
dateList = dateList1
print "using all dates to show time series displacement"
## Read Date Info (x axis for time series display)
dates, datevector = ptime.date_list2vector(dateList)
datevector_all = list(datevector)
## Check reference date input
try:
ref_date
if not ref_date in dateList:
print "Reference date - " + ref_date + " - is not included in date list to show."
sys.exit(1)
else:
print "reference date: " + ref_date
except:
if zero_start == "yes":
ref_date = dateList[0]
print "set the 1st date as reference for displacement display."
else:
pass
##############################################################
##### Plot Fig 1 - Velocity / last epoch of time series / DEM
fig = plt.figure(1)
ax = fig.add_subplot(111)
##### Check subset range
width = int(atr["WIDTH"])
length = int(atr["FILE_LENGTH"])
print "file size: " + str(length) + ", " + str(width)
try:
win_y = subset.coord_geo2radar(win_lat, atr, "latitude")
except:
try:
win_y
except:
win_y = [0, length]
try:
win_x = subset.coord_geo2radar(win_lon, atr, "longitude")
except:
try:
win_x
except:
win_x = [0, width]
win_y, win_x = subset.check_subset_range(win_y, win_x, atr)
try:
velocityFile
try:
vel, vel_atr = readfile.read(velocityFile)
except:
vel, vel_atr = readfile.read(timeSeriesFile, velocityFile)
ax.set_title(velocityFile)
print "display: " + velocityFile
except:
vel, vel_atr = readfile.read(timeSeriesFile, dateList1[-1])
ax.set_title("epoch: " + dateList1[-1])
print "display last epoch"
##### show displacement instead of phase
if vel_atr["FILE_TYPE"] in ["interferograms", ".unw"] and dispDisplacement == "yes":
print "show displacement"
phase2range = -float(vel_atr["WAVELENGTH"]) / (4 * np.pi)
vel *= phase2range
else:
dispDisplacement = "no"
## Reference Point
if showRef == "yes":
try:
ax.plot(int(atr["ref_x"]), int(atr["ref_y"]), "ks", ms=6)
except:
pass
if dispOpposite == "yes":
print "show opposite value in figure/map 1"
vel *= -1
## Flip
try:
flip_lr
except:
try:
flip_ud
except:
flip_lr, flip_ud = view.auto_flip_check(atr)
## Status bar
## Geo coordinate
try:
ullon = float(atr["X_FIRST"])
ullat = float(atr["Y_FIRST"])
lon_step = float(atr["X_STEP"])
lat_step = float(atr["Y_STEP"])
lon_unit = atr["Y_UNIT"]
lat_unit = atr["X_UNIT"]
geocoord = "yes"
print "Input file is Geocoded"
except:
geocoord = "no"
def format_coord(x, y):
col = int(x + 0.5)
row = int(y + 0.5)
if col >= 0 and col <= width and row >= 0 and row <= length:
z = vel[row, col]
try:
lon = ullon + x * lon_step
lat = ullat + y * lat_step
return "x=%.1f, y=%.1f, value=%.4f, lon=%.4f, lat=%.4f" % (x, y, z, lon, lat)
except:
return "x=%.1f, y=%.1f, value=%.4f" % (x, y, z)
ax.format_coord = format_coord
## DEM
try:
demFile
dem, demRsc = readfile.read(demFile)
ax = view.plot_dem_yx(ax, dem, demShade, demContour, contour_step, contour_sigma)
vel_alpha = 0.8
except:
print "No DEM file"
try:
img = ax.imshow(vel, vmin=vmin, vmax=vmax, alpha=vel_alpha)
except:
img = ax.imshow(vel, alpha=vel_alpha)
plt.colorbar(img)
## Zoom In (subset)
if flip_lr == "yes":
ax.set_xlim(win_x[1], win_x[0])
else:
ax.set_xlim(win_x[0], win_x[1])
if flip_ud == "yes":
ax.set_ylim(win_y[0], win_y[1])
else:
ax.set_ylim(win_y[1], win_y[0])
## Flip
# if flip_lr == 'yes': fig.gca().invert_xaxis()
# if flip_ud == 'yes': fig.gca().invert_yaxis()
##########################################
##### Plot Fig 2 - Time series plot
# fig2 = plt.figure(num=2,figsize=(12,6))
fig2 = plt.figure(2, figsize=(12, 6))
ax2 = fig2.add_subplot(111)
try:
timeSeriesFile_2
h5timeseries_2 = h5py.File(timeSeriesFile_2)
dateList_2 = h5timeseries_2["timeseries"].keys()
dateList_2 = sorted(dateList_2)
dates_2, datevector_2 = ptime.date_list2vector(dateList_2)
datevector_all += list(set(datevector_2) - set(datevector_all))
datevector_all = sorted(datevector_all)
except:
pass
################################ Plot Code Package <start> #################################
def plot_ts(ax, ax2, fig2, xsub, ysub, h5timeseries):
ax2.cla()
print "\n-------------------------------------------------------------------------------"
disp_min = 0
disp_max = 0
############################# Plot Time Series ##############################
global ref_xsub, ref_ysub
##### 1.1 Plot Reference time series
try:
ref_xsub
ref_ysub
ref_xsub, ref_ysub = check_yx(ref_xsub, ref_ysub, radius, ax, rectColor)
print "----------------------------------------------------"
print "Reference Point:"
print "ref_x=" + str(ref_xsub[0]) + ":" + str(ref_xsub[1])
print "ref_y=" + str(ref_ysub[0]) + ":" + str(ref_ysub[1])
print "-----------------------------"
print "Time series with all dates:"
dis1, dis1_mean, dis1_std, dis1_vel = read_dis(ref_xsub, ref_ysub, dateList1, h5timeseries, unit)
(_, caps, _) = ax2.errorbar(
dates1,
dis1_mean,
yerr=dis1_std,
fmt="-ks",
ms=markerSize2,
lw=0,
alpha=1,
mfc=markerColor_ref,
mew=edgeWidth,
elinewidth=edgeWidth,
ecolor="black",
capsize=markerSize * 0.5,
)
for cap in caps:
cap.set_markeredgewidth(edgeWidth)
disp_min, disp_max = update_lim(disp_min, disp_max, dis1_mean, dis1_std)
if not len(dateList) == len(dateList1):
print "-----------------------------"
print "Time series with dates of interest:"
dis12, dis12_mean, dis12_std, dis12_vel = read_dis(ref_xsub, ref_ysub, dateList, h5timeseries, unit)
(_, caps, _) = ax2.errorbar(
dates,
dis12_mean,
yerr=dis12_std,
fmt="-ks",
ms=markerSize2,
lw=0,
alpha=1,
mfc=markerColor_ref2,
mew=edgeWidth,
elinewidth=edgeWidth,
ecolor="black",
capsize=markerSize * 0.5,
)
for cap in caps:
cap.set_markeredgewidth(edgeWidth)
disp_min, disp_max = update_lim(disp_min, disp_max, dis12_mean, dis12_std)
except:
pass
##### 1.2.0 Read y/x
print "\n----------------------------------------------------"
print "Point of Interest:"
xsub, ysub = check_yx(xsub, ysub, radius, ax, rectColor)
print "x=" + str(xsub[0]) + ":" + str(xsub[1])
print "y=" + str(ysub[0]) + ":" + str(ysub[1])
##### 1.2.1 Plot 2nd time series
try:
timeSeriesFile_2
print "-----------------------------"
print "2nd Time Series:"
dis2, dis2_mean, dis2_std, dis2_vel = read_dis(xsub, ysub, dateList_2, h5timeseries_2, unit)
(_, caps, _) = ax2.errorbar(
dates_2,
dis2_mean,
yerr=dis2_std,
fmt="-ko",
ms=markerSize2,
lw=0,
alpha=1,
mfc=markerColor2,
elinewidth=0,
ecolor="black",
capsize=0,
)
for cap in caps:
cap.set_markeredgewidth(edgeWidth)
disp_min, disp_max = update_lim(disp_min, disp_max, dis2_mean, dis2_std)
except:
pass
##### 1.2.2 Plot 1st time series
print "-----------------------------"
print "Time Series:"
dis, dis_mean, dis_std, dis_vel = read_dis(xsub, ysub, dateList, h5timeseries, unit)
(_, caps, _) = ax2.errorbar(
dates,
dis_mean,
yerr=dis_std,
fmt="-ko",
ms=markerSize,
lw=lineWidth,
alpha=1,
mfc=markerColor,
elinewidth=edgeWidth,
ecolor="black",
capsize=markerSize * 0.5,
)
for cap in caps:
cap.set_markeredgewidth(edgeWidth)
disp_min, disp_max = update_lim(disp_min, disp_max, dis_mean, dis_std)
####################### Figure Format #######################
## x axis format
try:
ax2 = ptime.adjust_xaxis_date(ax2, dateVecMinMax, fontSize)
except:
ax2 = ptime.adjust_xaxis_date(ax2, datevector_all, fontSize)
## y axis format
ax2.set_ylabel("Displacement [" + unit + "]", fontsize=fontSize)
try:
lbound
hbound
ax2.set_ylim(lbound, hbound)
except:
disp_buf = 0.2 * (disp_max - disp_min)
ax2.set_ylim(disp_min - disp_buf, disp_max + disp_buf)
for tick in ax2.yaxis.get_major_ticks():
tick.label.set_fontsize(fontSize)
## title
figTitle = "x=" + str(xsub[0]) + ":" + str(xsub[1]) + ", y=" + str(ysub[0]) + ":" + str(ysub[1])
try:
lonc = ullon + (xsub[0] + xsub[1]) / 2.0 * lon_step
latc = ullat + (ysub[0] + ysub[1]) / 2.0 * lat_step
figTitle += ", lalo=" + "%.4f,%.4f" % (latc, lonc)
except:
pass
ax2.set_title(figTitle)
################## Save and Output #####################
if saveFig == "yes":
print "-----------------------------"
Delay = {}
Delay["displacement"] = dis
Delay["unit"] = unit
Delay["time"] = datevector
Delay["velocity"] = dis_vel[0]
Delay["velocity_unit"] = unit + "/yr"
Delay["velocity_std"] = dis_vel[4]
figBase = "x" + str(xsub[0]) + "_" + str(xsub[1] - 1) + "y" + str(ysub[0]) + "_" + str(ysub[1] - 1)
sio.savemat(figBase + "_ts.mat", {"displacement": Delay})
print "saved " + figBase + "_ts.mat"
fig2.savefig(figBase + "_ts.pdf", bbox_inches="tight", transparent=True, dpi=fig_dpi)
print "saved " + figBase + "_ts.pdf"
if dispFig == "no":
fig.savefig(figBase + "_vel.png", bbox_inches="tight", transparent=True, dpi=fig_dpi)
print "saved " + figBase + "_vel.png"
################################ Plot Code Package <end> #################################
########### 1. Plot Time Series with x/y ##########
try:
xsub
ysub
plot_ts(ax, ax2, fig2, xsub, ysub, h5timeseries)
except:
print "No x/y input"
pass
########### 2. Plot Time Series with Click ##########
## similar to 1. Plot Time Series with x/y
def onclick(event):
ax2.cla()
xsub = [int(event.xdata)]
ysub = [int(event.ydata)]
plot_ts(ax, ax2, fig2, xsub, ysub, h5timeseries)
if dispFig == "yes":
plt.show()
try:
cid = fig.canvas.mpl_connect("button_press_event", onclick)
except:
pass
if dispFig == "yes":
plt.show()
def main(argv):
try:
file=argv[0]
geomap=argv[1]
except:
Usage();sys.exit(1)
######################################################################################
fileName=os.path.basename(file).split('.')[0]
h5file=h5py.File(file,'r')
atr = readfile.read_attributes(file)
k = atr['FILE_TYPE']
print '\n***************** Geocoding *******************'
print 'input file: '+k
#### Subsetted radar coded file
try:
x0 = float(atr['subset_x0'])
y0 = float(atr['subset_y0'])
print '\nSubsetted radar coded file:\n creating temporary geomap file for it...'
rg,az,rsc = readfile.read_float32(geomap)
rg = rg - x0
az = az - y0
geomap = 'temp_'+geomap
print ' writing '+geomap+'\n'
writefile.write_float32(rg,az,geomap)
fg = open(geomap+'.rsc','w')
for kg in rsc.keys(): fg.write(kg+' '+rsc[kg]+'\n')
fg.close()
except: pass
######################################################################################
if k in ['timeseries']:
outname='epoch_temp.unw'
f = h5py.File('geo_'+file,'w')
group = f.create_group('timeseries')
epochList = h5file['timeseries'].keys()
epochList = sorted(epochList)
for epoch in epochList:
print 'geocoding '+epoch
data = h5file['timeseries'].get(epoch)[:]
amp,unw,unwrsc = geocode_one(data,geomap,outname)
dset = group.create_dataset(epoch, data=unw, compression='gzip')
atr = geocode_attributes(atr,unwrsc)
for key,value in atr.iteritems():
group.attrs[key] = value
######################################################################################
elif k in ['interferograms','coherence','wrapped']:
if k == 'interferograms': outname = k[0]+'_temp.unw'
elif k == 'coherence' : outname = k[0]+'_temp.cor'
else: outname = k[0]+'_temp.int'
f = h5py.File('geo_'+file,'w')
gg = f.create_group('interferograms')
igramList = h5file[k].keys()
igramList = sorted(igramList)
for igram in igramList:
print 'geocoding '+igram
data = h5file[k][igram].get(igram)[:]
amp,unw,unwrsc = geocode_one(data,geomap,outname)
group = gg.create_group('geo_'+igram)
dset = group.create_dataset('geo_'+igram, data=unw, compression='gzip')
atr = geocode_attributes(h5file[k][igram].attrs, unwrsc)
for key,value in atr.iteritems():
group.attrs[key] = value
####################### support of old format #######################
### mask
try:
data = h5file['mask'].get('mask')[:]
amp,unw,unwrsc = geocode_one(data,geomap,'mask_'+outname)
gm = f.create_group('mask')
dset = gm.create_dataset('mask', data=unw, compression='gzip')
except: print 'No group for mask found in the file.'
### meanCoherence
try:
data = h5file['meanCoherence'].get('meanCoherence')[:]
amp,unw,unwrsc = geocode_one(data,geomap,'meanCoherence_'+outname)
gm = f.create_group('meanCoherence')
dset = gm.create_dataset('meanCoherence', data=unw, compression='gzip')
except: print 'No group for meanCoherence found in the file'
######################################################################################
else:
data,atr = readfile.read(file)
outname=fileName+'.unw'
amp,unw,unwrsc = geocode_one(data,geomap,outname)
atr = geocode_attributes(atr,unwrsc)
writefile.write(unw,atr,'geo_'+file)
######################################################################################
try:
atr['subset_x0']
rmCmd='rm '+geomap; os.system(rmCmd); print rmCmd
rmCmd='rm '+geomap+'.rsc'; os.system(rmCmd); print rmCmd
except: pass
try:
f.close()
h5file.close()
except: pass
def main(argv):
outName = 'mask.h5'
method = 'threshold'
##### Check Inputs
if len(sys.argv)>2:
try: opts, args = getopt.getopt(argv,'h:f:m:M:x:y:o:d:e:',['nonzero'])
except getopt.GetoptError: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': File = arg
elif opt == '-m': minV = float(arg)
elif opt == '-M': maxV = float(arg)
elif opt == '-y': ysub = [int(i) for i in arg.split(':')]; ysub.sort()
elif opt == '-x': xsub = [int(i) for i in arg.split(':')]; xsub.sort()
elif opt == '-o': outName = arg
elif opt == '-d': epoch_date = arg
elif opt == '-e': epoch_num = int(arg) - 1
elif opt == '--nonzero': method = 'nonzero'
elif len(sys.argv)==2:
if argv[0] in ['-h','--help']: Usage(); sys.exit(1)
elif os.path.isfile(argv[0]): File = argv[0]
else: print 'Input file does not existed: '+argv[0]; sys.exit(1)
else: Usage(); sys.exit(1)
##### Input File Info
atr = readfile.read_attributes(File)
print '\n****************** Generate Mask *******************'
print 'Input file is '+atr['PROCESSOR']+' '+atr['FILE_TYPE']+': '+File
mask = np.ones([int(atr['FILE_LENGTH']),int(atr['WIDTH'])])
print 'Create initial mask with the same size as the input file and all = 1'
##### Non-zero Mask #######
if method == 'nonzero':
k = atr['FILE_TYPE']
MaskZero = np.ones([int(atr['FILE_LENGTH']),int(atr['WIDTH'])])
ext = os.path.splitext(File)[1].lower()
if ext == '.h5' and k in ['interferograms','coherence','wrapped','timeseries']:
h5file = h5py.File(File,'r')
epochList = h5file[k].keys()
for epoch in epochList:
print epoch
if k in ['interferograms','coherence','wrapped']:
data = h5file[k][epoch].get(epoch)[:]
elif k in ['timeseries']:
data = h5file[k].get(epoch)
MaskZero *= data
MaskZero[np.isnan(data)] = 0
h5file.close()
else:
data,atr = readfile.read(File)
MaskZero *= data
MaskZero[np.isnan(data)] = 0
mask = np.ones([int(atr['FILE_LENGTH']),int(atr['WIDTH'])])
mask[MaskZero==0] = 0
##### Threshold ##########
else:
##### Read and Initiate Mask
try: V, atr = readfile.read(File,epoch_date)
except:
try: V, atr = readfile.read(File,epoch_num)
except: V, atr = readfile.read(File)
##### Calculating Mask
## threshold
try:
mask[V<minV]=0
print 'all value < '+str(minV)+' = 0'
except: print 'No min threshold'
try:
mask[V>maxV]=0
print 'all value > '+str(maxV)+' = 0'
except: print 'No max threshold'
## nan value
mask[np.isnan(V)]=0
## subset
try:
mask[0:ysub[0],:]=0
mask[ysub[1]:mask.shape[0],:]=0
print 'all y in [0,'+str(ysub[0])+'] and ['+str(ysub[1])+',end] = 0'
except: print 'No subset in y direction'
try:
mask[:,0:xsub[0]]=0
mask[:,xsub[1]:mask.shape[1]]=0
print 'all x in [0,'+str(xsub[0])+'] and ['+str(xsub[1])+',end] = 0'
except: print 'No subset in x direction'
##### Writing mask file
atr['FILE_TYPE'] = 'mask'
writefile.write(mask,atr,outName)
def main(argv):
####################### Inputs Check ########################
try: opts, args = getopt.getopt(argv,"h:f:o:",['help'])
except getopt.GetoptError: Usage() ; sys.exit(1)
if len(sys.argv) > 4:
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': fileList = arg.split(',')
elif opt == '-o': outName = arg
elif len(sys.argv) <= 4 and len(sys.argv) >= 3:
fileList = [sys.argv[1],sys.argv[2]]
try: outName = sys.argv[3]
except: pass
else: Usage(); sys.exit(1)
print '\n****************** Add **********************'
print 'Input files: '
print fileList
ext = os.path.splitext(fileList[0])[1].lower()
try: outName
except: outName = File1.split('.')[0]+'_plus_'+File2.split('.')[0]+ext
##### Read File Info / Attributes
atr = readfile.read_attributes(fileList[0])
print 'Input file is '+atr['PROCESSOR']+' '+atr['FILE_TYPE']
k = atr['FILE_TYPE']
##### File Type Check
if k in ['timeseries','interferograms','coherence','wrapped']:
for i in range(1,len(fileList)):
File = fileList[i]
r = readfile.read_attributes(File)
if not r['FILE_TYPE'] == k:
print 'Input file type is not the same: '+r['FILE_TYPE']
sys.exit(1)
h5out = h5py.File(outName,'w')
group = h5out.create_group(k)
h5in = h5py.File(fileList[0])
epochList = h5in[k].keys()
########################### Add file by file ########################
if k in ['timeseries']:
for epoch in epochList:
print epoch
data = np.zeros((int(atr['FILE_LENGTH']),int(atr['WIDTH'])))
for File in fileList:
print File
h5file = h5py.File(File,'r')
d = h5file[k].get(epoch)[:]
data = add(data,d)
dset = group.create_dataset(epoch, data=data, compression='gzip')
for key,value in atr.iteritems(): group.attrs[key] = value
h5out.close()
h5in.close()
elif k in ['timeseries','interferograms','coherence','wrapped']:
for epoch in epochList:
print epoch
data = np.zeros((int(atr['FILE_LENGTH']),int(atr['WIDTH'])))
for File in fileList:
print File
h5file = h5py.File(File,'r')
d = h5file[k][epoch].get(epoch)[:]
data = add(data,d)
gg = group.create_group(epoch)
dset = gg.create_dataset(epoch, data=data, compression='gzip')
for key, value in h5in[k][epoch].attrs.iteritems():
gg.attrs[key] = value
h5out.close()
h5in.close()
## All the other file types
else:
data = np.zeros((int(atr['FILE_LENGTH']),int(atr['WIDTH'])))
for File in fileList:
print 'loading '+File
d,r = readfile.read(File)
data = add(data,d)
writefile.write(data,atr,outName)
def spatial_mean(File,mask_orig,box):
## Calculate the Spatial Average of all non-nan pixels for each epoch
## and return the mean value.
##
## Inputs:
## File :
## mask_orig : mask, same size as File
## box : 4-tuple defining the left, upper, right, and lower pixel coordinate [optional]
## Output: list for multi-dataset file, and float for single-dataset file
print 'calculating spatial average of '+File+' within '+str(box)+' ...'
##### Input File Info
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
width = int(atr['WIDTH'])
length = int(atr['FILE_LENGTH'])
##### Bounding Box
#if box == None: box = [0,0,width,length]
##### Mask Info
#if mask_orig == None: mask_orig = np.ones((length,width))
mask = mask_orig[box[1]:box[3],box[0]:box[2]]
idx = mask != 0
##### Calculation
if k in ['timeseries','interferograms','coherence','wrapped']:
h5file = h5py.File(File,'r')
epochList = h5file[k].keys();
epochList = sorted(epochList)
epochNum = len(epochList)
#print 'number of epoch: '+str(epochNum)
meanList = np.zeros(epochNum)
for i in range(epochNum):
epoch = epochList[i]
if k in ['interferograms','coherence','wrapped']:
dset = h5file[k][epoch].get(epoch)
elif k == 'timeseries':
dset = h5file[k].get(epoch)
else: print 'Unrecognized group type: '+k
d = dset[box[1]:box[3],box[0]:box[2]]
## supress warning
## url - http://stackoverflow.com/questions/29688168/mean-nanmean-and-warning-mean-of-empty-slice
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
meanList[i] = np.nanmean(d[idx])
printProgress(i+1,epochNum)
del d
h5file.close()
if epochNum == 1: meanList = float(meanList)
else:
data,atr = readfile.read(File,box)
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
meanList = np.nanmean(data[idx])
return meanList
def mask_file(in_file,M,out_file=''):
## Mask input file with mask matrix M
atr = readfile.read_attributes(in_file)
k = atr['FILE_TYPE']
print 'file type: '+k
if out_file == '':
ext = os.path.splitext(in_file)[1]
out_file = os.path.basename(in_file).split('.')[0]+'_masked'+ext
if k in ['timeseries','interferograms','wrapped','coherence']:
h5file = h5py.File(in_file,'r')
epochList = h5file[k].keys()
epochList = sorted(epochList)
print 'number of epochs: '+str(len(epochList))
h5out = h5py.File(out_file,'w')
print 'writing >>> '+out_file
##### Multiple Dataset File
if k == 'timeseries':
group = h5out.create_group(k)
for d in epochList:
print d
unwset = h5file[k].get(d)
unw=unwset[0:unwset.shape[0],0:unwset.shape[1]]
unw = mask_data(unw,M)
dset = group.create_dataset(d, data=unw, compression='gzip')
for key,value in atr.iteritems(): group.attrs[key] = value
elif k in ['interferograms','wrapped','coherence']:
gg = h5out.create_group(k)
for igram in epochList:
print igram
unwset = h5file[kf[0]][igram].get(igram)
unw=unwset[0:unwset.shape[0],0:unwset.shape[1]]
unw = mask_data(unw,M)
group = gg.create_group(igram)
dset = group.create_dataset(igram, data=unw, compression='gzip')
for key, value in h5file[k][igram].attrs.iteritems():
group.attrs[key] = value
try:
mask = h5file['mask'].get('mask')
gm = h5out.create_group('mask')
dset = gm.create_dataset('mask', data=mask, compression='gzip')
except: print 'no mask group found.'
##### Single Dataset File
else:
import pysar._writefile as writefile
unw,atr = readfile.read(in_file)
unw = mask_data(unw,M)
writefile.write(unw,atr,out_file)
try:
h5file.close()
h5out.close()
except: pass
def main(argv):
if len(sys.argv)>2:
try: opts, args = getopt.getopt(argv,"f:E:m:M:h:o:t:")
except getopt.GetoptError: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt == '-f': timeSeriesFile = arg
elif opt == '-E': datesNot2include = arg.replace(' ','').split(',')
elif opt == '-m': minDate = arg
elif opt == '-M': maxDate = arg
elif opt == '-o': outName = arg
elif opt == '-t': templateFile = arg
elif len(sys.argv)==2:
if argv[0]=='-h': Usage(); sys.exit(1)
elif os.path.isfile(argv[0]): timeSeriesFile = argv[0]
else: Usage(); sys.exit(1)
else: Usage(); sys.exit(1)
##### Read excluded date list Input
try: datesNot2include
except:
try:
templateFile
templateContents = readfile.read_template(templateFile)
datesNot2include = templateContents['pysar.drop.date'].replace(' ','').split(',')
except: pass
##############################################################
print '\n********** Inversion: Time Series to Velocity ***********'
atr = readfile.read_attributes(timeSeriesFile)
k = atr['FILE_TYPE']
print 'input file: '+k
if not k == 'timeseries': print 'Input file is not timeseries!'; sys.exit(1)
print "Loading time series file: " + timeSeriesFile
h5timeseries = h5py.File(timeSeriesFile)
dateList1 = h5timeseries[k].keys()
dateList1 = sorted(dateList1)
##############################################################
print '--------------------------------------------'
print 'Dates from input file: '+str(len(dateList1))
print dateList1
try:
datesNot2include
if os.path.isfile(datesNot2include[0]):
try: datesNot2include = ptime.read_date_list(datesNot2include[0])
except: print 'Can not read date list file: '+datesNot2include[0]
print '--------------------------------------------'
print 'Date excluded: '+str(len(datesNot2include))
print datesNot2include
except:
datesNot2include=[]
try:
minDate
minDateyy=yyyymmdd2years(minDate)
print 'minimum date: '+minDate
for date in dateList1:
yy=yyyymmdd2years(date)
if yy < minDateyy:
print ' remove date: '+date
datesNot2include.append(date)
except: pass
try:
maxDate
maxDateyy=yyyymmdd2years(maxDate)
print 'maximum date: '+maxDate
for date in dateList1:
yy=yyyymmdd2years(date)
if yy > maxDateyy:
print ' remove date: '+date
datesNot2include.append(date)
except: pass
try:
dateList=[]
for date in dateList1:
if date not in datesNot2include:
dateList.append(date)
except: pass
print '--------------------------------------------'
if len(dateList) == len(dateList1):
print 'using all dates to calculate the vlocity'
else:
print 'Dates used to estimate the velocity: '+str(len(dateList))
print dateList
print '--------------------------------------------'
##############################################################
dateIndex={}
for ni in range(len(dateList)):
dateIndex[dateList[ni]]=ni
tbase=[]
d1 = datetime.datetime(*time.strptime(dateList[0],"%Y%m%d")[0:5])
for ni in range(len(dateList)):
d2 = datetime.datetime(*time.strptime(dateList[ni],"%Y%m%d")[0:5])
diff = d2-d1
tbase.append(diff.days)
dates=[]
for ni in range(len(dateList)):
d = datetime.datetime(*time.strptime(dateList[ni],"%Y%m%d")[0:5])
dates.append(d)
###########################################
print 'Calculating Velocity'
datevector=[]
for i in range(len(dates)):
datevector.append(np.float(dates[i].year) + np.float(dates[i].month-1)/12 + np.float(dates[i].day-1)/365)
B=np.ones([len(datevector),2])
B[:,0]=datevector
#B1 = np.linalg.pinv(B)
B1 = np.dot(np.linalg.inv(np.dot(B.T,B)),B.T)
B1 = np.array(B1,np.float32)
#########################################
width = int(atr['WIDTH'])
length = int(atr['FILE_LENGTH'])
lt = len(dateList)
timeseries = np.zeros((lt,length,width),np.float32)
for date in dateList:
timeseries[dateIndex[date]] = h5timeseries[k].get(date)
numpixels=length*width
Data=np.zeros([lt,numpixels])
for i in range(lt):
Data[i,:]=np.reshape(timeseries[i],[1,numpixels])
x=np.dot(B1,Data)
velocity=np.reshape(x[0,:],[length,width])
#####################################################
print 'Calculating rmse'
Data_linear=np.dot(B,x)
rmse=np.reshape(np.sqrt((np.sum((Data_linear-Data)**2,0))/lt),[length,width])
# se=np.reshape((np.sum(np.abs(Data_linear-Data),0)/lt),[length,width])
# rmse=np.reshape((np.sum((Data_linear-Data)**2,0))/lt,[length,width])
######################################################
print 'Calculating the standard deviation of the estimated velocities'
residual=Data_linear-Data
s1=np.sqrt(np.sum(residual**2,0)/(lt-2))
s2=np.sqrt(np.sum((datevector-np.mean(datevector))**2))
se=np.reshape(s1/s2,[length,width])
######################################################
# SSt=np.sum((Data-np.mean(Data,0))**2,0)
# SSres=np.sum(residual**2,0)
# SS_REG=SSt-SSres
# Rsquared=np.reshape(SS_REG/SSt,[length,width])
######################################################
# covariance of the velocities
##### Output File Name
try: outName
except:
if not datesNot2include == []: outName = 'velocity_ex.h5'
else: outName = 'velocity.h5'
outName_rmse='rmse_'+outName
outName_se='std_'+outName
outName_Rsquared='R2_'+outName
#####################################
print '--------------------------------------'
print 'writing to '+outName
h5velocity = h5py.File(outName,'w')
group=h5velocity.create_group('velocity')
dset = group.create_dataset('velocity', data=velocity, compression='gzip')
group.attrs['date1'] = datevector[0]
group.attrs['date2'] = datevector[lt-1]
for key , value in atr.iteritems():
group.attrs[key]=value
h5velocity.close()
#####################################
print 'writing to '+outName_rmse
h5file = outName_rmse
h5rmse = h5py.File(h5file,'w')
group=h5rmse.create_group('rmse')
dset = group.create_dataset(os.path.basename('rmse'), data=rmse, compression='gzip')
group.attrs['date1'] = datevector[0]
group.attrs['date2'] = datevector[lt-1]
for key , value in atr.iteritems():
group.attrs[key]=value
#####################################
print 'writing to '+outName_se
h5se = h5py.File(outName_se,'w')
group=h5se.create_group('rmse')
dset = group.create_dataset('rmse', data=se, compression='gzip')
group.attrs['date1'] = datevector[0]
group.attrs['date2'] = datevector[lt-1]
for key , value in atr.iteritems():
group.attrs[key]=value
# print 'writing to '+outName_Rsquared
# h5rsquared = h5py.File(outName_Rsquared,'w')
# group=h5rsquared.create_group('rmse')
# dset = group.create_dataset('rmse', data=Rsquared, compression='gzip')
# group.attrs['date1'] = datevector[0]
# group.attrs['date2'] = datevector[lt-1]
# h5rsquared.close()
h5se.close()
h5rmse.close()
h5timeseries.close()
print 'Done.'
def main(argv):
global xsub, ysub, thr
parallel = 'yes' ## Use parallel by default for multiple input files
######################################
try: opts, args = getopt.getopt(argv,"h:f:m:t:x:y:o:",['no-parallel'])
except getopt.GetoptError: Usage() ; sys.exit(1)
if len(sys.argv) > 3:
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': File = arg.split(',')
elif opt == '-m': maskFile = arg
elif opt == '-t': thr = float(arg)
elif opt == '-y': ysub = [int(i) for i in arg.split(':')]; ysub.sort()
elif opt == '-x': xsub = [int(i) for i in arg.split(':')]; xsub.sort()
elif opt == '-o': outFile = arg
elif opt == '--no-parallel': parallel = 'no'
elif len(sys.argv)==3:
if os.path.isfile(argv[0]) and os.path.isfile(argv[1]):
File = argv[0].split(',')
maskFile = argv[1]
else: print 'Input file does not existed: '+argv[0]+' / '+argv[1]; sys.exit(1)
else: Usage(); sys.exit(1)
try:
File
maskFile
except: Usage() ; sys.exit(1)
##### Check Input File List
print '\n****************** Masking *********************'
fileList = ut.get_file_list(File)
print 'number of file to mask: '+str(len(fileList))
print fileList
if len(fileList) == 1:
parallel = 'no'
try: outFile ## Customized output file name for one input file only
except:
ext = os.path.splitext(fileList[0])[1]
outFile = os.path.basename(fileList[0]).split('.')[0]+'_masked'+ext
elif len(fileList) > 1:
try:
del outFile
print 'Disabled customized output name for multiple input files, continue with automatic naming insread.'
except: pass
else: print 'ERROR: No input file!'; sys.exit(1)
##### Check parallel computing requirement
if parallel == 'yes':
try:
from joblib import Parallel, delayed
import multiprocessing
except:
print '/nCannot import joblib or multiprocessing!'
print 'Disabled parallel masking.'
print 'Continue with masking file by file ...'
###### Read Mask File
atr_mask = readfile.read_attributes(maskFile)
k_mask = atr_mask['FILE_TYPE']
if not k_mask == 'coherence': ## Read mask file once
M,Matr = readfile.read(maskFile)
print 'mask file: '+maskFile
##### Masking - file by file
if parallel == 'no':
##### Single Mask
if not k_mask == 'coherence':
for in_file in fileList:
print '-------------------------------------------'
print 'masking : '+in_file
try: mask_file(in_file,M,outFile)
except: mask_file(in_file,M)
##### Multiple Mask
else:
try: mask_with_multi_masks(fileList[0],maskFile,outFile)
except: mask_with_multi_masks(fileList[0],maskFile)
##### Masking - parallel
else:
print '-----------------------'
print 'parallel masking ...'
print '-----------------------'
num_cores = multiprocessing.cpu_count()
Parallel(n_jobs=num_cores)(delayed(mask_file)(in_file,M) for in_file in fileList)
def main(argv):
try: File=argv[0]
except: Usage();sys.exit(1)
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
h5file=h5py.File(File,'r')
print '\n************* Output to ROI_PAC format ***************'
if k == 'velocity':
dset = h5file['velocity'].get('velocity')
data = dset[0:dset.shape[0],0:dset.shape[1]]
print "converting velocity to a 1 year interferogram."
wvl=float(h5file[k].attrs['WAVELENGTH'])
data=(-4*pi/wvl)*data
outname=File.split('.')[0]+'.unw'
writefile.write(data,atr,outname)
elif k == 'timeseries':
dateList=h5file['timeseries'].keys()
## Input
if len(sys.argv)==2:
print 'No input date specified >>> continue with the last date'
dateList=h5file['timeseries'].keys()
d=dateList[-1]
elif len(sys.argv)==3:
d=sys.argv[2]
elif len(sys.argv)==4:
ds=sys.argv[2:4]; ds.sort()
d_ref = ds[0]
d = ds[1]
else: Usage(); sys.exit(1)
d = ptime.yyyymmdd(d)
try: d_ref = ptime.yyyymmdd(d_ref)
except: pass
## Data
print 'reading '+d+' ... '
data = h5file['timeseries'].get(d)[:]
try:
print 'reading '+d_ref+' ... '
data_ref = h5file['timeseries'].get(d_ref)[:]
data = data - data_ref
except: pass
wvl=float(atr['WAVELENGTH'])
data *= -4*pi/wvl
## outName
try: master_d = d_ref
except:
try: master_d = atr['ref_date']
except: master_d = atr['DATE']
if len(master_d)==8: master_d=master_d[2:8]
if len(d)==8: d=d[2:8]
outname = master_d+'_'+d+'.unw'
## Attributes
atr['FILE_TYPE'] = '.unw'
atr['P_BASELINE_TIMESERIES'] = '0.0'
atr['UNIT'] = 'radian'
atr['DATE'] = master_d
atr['DATE12'] = master_d+'-'+d
## Writing
writefile.write(data,atr,outname)
elif k in ['interferograms','coherence','wrapped']:
## Check input
igramList=h5file[k].keys()
try:
d = sys.argv[2]
for i in range(len(igramList)):
if d in igramList[i]:
igram = igramList[i]
except:
igram = igramList[-1]; print 'No input date specified >>> continue with the last date'
## Read and Write
print 'reading '+igram+' ... '
dset = h5file[k][igram].get(igram)
data = dset[0:dset.shape[0],0:dset.shape[1]]
outname = igram
print 'writing >>> '+ outname
writefile.write_float32(data,outname)
f = open(outname+'.rsc','w')
for key , value in h5file[k][igram].attrs.iteritems():
f.write(key+' '+str(value)+'\n')
f.close()
else:
dset = h5file[k].get(k)
data = dset[0:dset.shape[0],0:dset.shape[1]]
if k == 'temporal_coherence': outname=File.split('.')[0]+'.cor'
else: outname=File.split('.')[0]+'.unw'
writefile.write(data,atr,outname)
h5file.close()
def main(argv):
lineWidth = 2
fontSize = 12
markerColor = 'orange'
markerSize = 16
networkDisplay = 'no'
if len(sys.argv)>2:
try: opts, args = getopt.getopt(argv,"h:f:C:s:w:m:c:t:b:d:l:n:N:T:l:")
except getopt.GetoptError: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': File = arg
elif opt == '-C': corFile = arg
elif opt == '-s': fontSize = int(arg)
elif opt == '-w': lineWidth = int(arg)
elif opt == '-m': markerSize = int(arg)
elif opt == '-c': markerColor = arg
elif opt == '-t': temp_thr = float(arg)
elif opt == '-b': base_thr = float(arg)
elif opt == '-d': dates2Rmv = arg
elif opt == '-l': ifgrams_to_rmv = arg
elif opt == '-n': networkDisplay = arg
elif opt == '-N': ifgrams_Number_to_rmv = arg.split()
elif opt == '-T': templateFile = arg
elif opt == '-l': list_fileList = arg.split(',')
try: File
except: Usage() ; sys.exit(1)
elif len(sys.argv)==2:
File = argv[0]
networkDisplay = 'yes'
else: Usage() ; sys.exit(1)
## display network for modification, if no other limit setted
try:
temp_thr
base_trh
dates2Rmv
ifgrams_to_rmv
ifgrams_Number_to_rmv
networkDisplay = 'yes'
except: pass
###########################################################
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
print '\n*************** Modify Network ****************'
print 'Input file is '+k
#if h5file.keys()[0] != 'interferograms':
# print 'Input file should be interferograms'; sys.exit(1)
h5file = h5py.File(File)
ifgramList = h5file[k].keys()
ifgramList = sorted(ifgramList)
try: ifgrams_to_rmv
except: ifgrams_to_rmv=[]
###########################################################
##### L - list file of interferograms
try: ifgrams_to_rmv = list_file.read()
except: pass
##### T - templateFile, pysar.dropIfgIndex
try:
templateFile
template = readfile.read_template(templateFile)
drop_ifg_index = template['pysar.drop.ifgIndex'].split(',')
print 'drop interferogram index:'
print drop_ifg_index
try: ifgrams_Number_to_rmv
except: ifgrams_Number_to_rmv = []
for index in drop_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): ifgrams_Number_to_rmv.append(str(j))
elif len(index_temp)==1: ifgrams_Number_to_rmv.append(index)
else: print 'Unrecoganized input: '+index
except: pass
##### N - interferogram number list
try:
for i in ifgrams_Number_to_rmv:
print i+' '+ifgramList[int(i)-1]
ifgrams_to_rmv.append(ifgramList[int(i)-1])
except: pass
##### b - perpendicular baseline limit
try:
base_thr
print 'interferograms with the spatial baseline longer than '+ str(base_thr)+' m is removed'
for ifgram in ifgramList:
Baseline = (float(h5file[k][ifgram].attrs['P_BASELINE_BOTTOM_HDR'])+\
float(h5file[k][ifgram].attrs['P_BASELINE_TOP_HDR']))/2
if abs(Baseline) > base_thr:
if not ifgram in ifgrams_to_rmv: ifgrams_to_rmv.append(ifgram)
except: print 'No Spatial Baseline threshold applied'
##### d - dates to remove
try:
dates2Rmv
print 'interferograms with any of following dates will be removed: '+ dates2Rmv
for ifgram in ifgramList:
date1,date2 = h5file[k][ifgram].attrs['DATE12'].split('-')
if (date1 in dates2Rmv) or (date2 in dates2Rmv):
if not ifgram in ifgrams_to_rmv: ifgrams_to_rmv.append(ifgram)
except: print 'No specific dates selected to remove'
##### t - temporal baseline limit
tbase,dateList,dateDict,dateList6=ut.date_list(h5file)
try:
temp_thr
print 'Applying the temporal baseline threshold with threshold of '+str(temp_thr)+' days'
for ifgram in ifgramList:
date1,date2 = h5file[k][ifgram].attrs['DATE12'].split('-')
ind1 = dateList6.index(date1)
ind2 = dateList6.index(date2)
dt=tbase[ind2]-tbase[ind1]
if dt>temp_thr:
if not ifgram in ifgrams_to_rmv:
ifgrams_to_rmv.append(ifgram)
except:
print 'No Temporal Baseline threshold applied'
############################################################
############################################################
if networkDisplay=='yes':
dates,datevector = ptime.date_list2vector(dateList)
##################################################
Bp = ut.Baseline_timeseries(File)
#############################################################
ifgramList = h5file[k].keys()
igram_pairs=np.zeros([len(ifgramList),2],np.int)
i=0
for ifgram in ifgramList:
date1,date2 = h5file[k][ifgram].attrs['DATE12'].split('-')
igram_pairs[i][0]=dateList6.index(date1)
igram_pairs[i][1]=dateList6.index(date2)
i=i+1
############################################################
import matplotlib.pyplot as plt
fig1 = plt.figure(1)
ax1=fig1.add_subplot(111)
ax1.cla()
# ax1.plot(dates,Bp, 'o',ms=markerSize, lw=lineWidth, alpha=0.7, mfc=markerColor)
print tbase
ax1.plot(tbase,Bp, 'o',ms=markerSize, lw=lineWidth, alpha=0.7, mfc=markerColor)
for ni in range(len(ifgramList)):
ax1.plot(array([tbase[igram_pairs[ni][0]],tbase[igram_pairs[ni][1]]]),\
array([Bp[igram_pairs[ni][0]],Bp[igram_pairs[ni][1]]]),'k',lw=4)
# ax1.fmt_xdata = DateFormatter('%Y-%m-%d %H:%M:%S')
ax1.set_ylabel('Bperp [m]',fontsize=fontSize)
ax1.set_xlabel('Time [years]',fontsize=fontSize)
ts=datevector[0]+0.2
te=datevector[-1]+0.2
ys=int(ts)
ye=int(te)
ms=int((ts-ys)*12)
me=int((te-ye)*12)
if ms>12: ys =ys+1; ms=1
if me>12: ye =ye+1; me=1
if ms<1: ys =ys-1; ms=12
if me<1: ye =ye-1; me=12
dss=datetime.datetime(ys,ms,1,0,0)
dee=datetime.datetime(ye,me,1,0,0)
ax1.set_ylim(min(Bp)-0.4*abs(min(Bp)),max(Bp)+0.4*max(Bp))
xticklabels = getp(gca(), 'xticklabels')
yticklabels = getp(gca(), 'yticklabels')
setp(yticklabels, 'color', 'k', fontsize=fontSize)
setp(xticklabels, 'color', 'k', fontsize=fontSize)
##########################################
x=[]
y=[]
Master_index_torremove=[]
Slave_index_torremove=[]
a_tbase=array(tbase)
a_Bp=array(Bp)
def onclick(event):
if event.button==1:
print 'click'
xClick = event.xdata
yClick = event.ydata
idx=nearest_neighbor(xClick,yClick, a_tbase, a_Bp)
xr = a_tbase[idx]
yr = a_Bp[idx]
ix=tbase.index(xr)+1
print ix
x.append(xr)
y.append(yr)
if mod(len(x),2)==0:
Master_index_torremove.append(tbase.index(xr))
ax1.plot([x[len(x)-1],x[len(x)-2]],[y[len(x)-1],y[len(x)-2]],'r',lw=4)
else:
Slave_index_torremove.append(tbase.index(xr))
plt.show()
cid = fig1.canvas.mpl_connect('button_press_event', onclick)
plt.show()
print Master_index_torremove
print Slave_index_torremove
if len(Master_index_torremove) == len(Slave_index_torremove):
R=np.vstack((Master_index_torremove,Slave_index_torremove))
else:
R=np.vstack((Master_index_torremove[:-1],Slave_index_torremove))
R=np.vstack((Master_index_torremove,Slave_index_torremove))
R.sort(0)
print R
print dateList6
numIgrams_rmv=np.shape(R)[1]
for ifgram in ifgramList:
date1,date2 = h5file[k][ifgram].attrs['DATE12'].split('-')
for i in range(numIgrams_rmv):
if dateList6[R[0][i]]==date1 and dateList6[R[1][i]]==date2:
ifgrams_to_rmv.append(ifgram)
else:
print 'No network display.'
############################################################
############################################################
print 'Number of interferograms to remove: '+str(len(ifgrams_to_rmv))
print 'List of interferograms to remove:'
print ifgrams_to_rmv
file_modified='Modified_'+File
h5filem = h5py.File(file_modified,'w')
gg = h5filem.create_group(k)
ifgram=ifgramList[0]
unw = h5file[k][ifgram].get(ifgram)
MaskZero=np.ones([unw.shape[0],unw.shape[1]])
print 'writing >>> modified interferogram file ...'
print 'Number of interferograms: '+str(len(ifgramList)-len(ifgrams_to_rmv))
for ifgram in ifgramList:
if not ifgram in ifgrams_to_rmv:
print ifgram
unwSet = h5file[k][ifgram].get(ifgram)
unw = unwSet[0:unwSet.shape[0],0:unwSet.shape[1]]
MaskZero=unw*MaskZero
group = gg.create_group(ifgram)
dset = group.create_dataset(ifgram, data=unw, compression='gzip')
for key, value in h5file[k][ifgram].attrs.iteritems():
group.attrs[key] = value
Mask=np.ones([unwSet.shape[0],unwSet.shape[1]])
Mask[MaskZero==0]=0
h5file.close()
h5filem.close()
####################### Coherence ########################
# updating Coherence file
# convert ifgrams_to_rmv to cor_to_rmv
date12_to_rmv=[]
for igram in ifgrams_to_rmv:
date12_to_rmv.append(igram.split('-sim')[0].split('filt_')[-1])
try:
corFile
h5fileCor=h5py.File(corFile)
corList=h5fileCor['coherence'].keys()
corFile_modified='Modified_'+corFile
h5fileCorm=h5py.File(corFile_modified,'w')
gc = h5fileCorm.create_group('coherence')
print 'writing >>> modified coherence file ...'
for cor in corList:
date12=cor.split('-sim')[0].split('filt_')[-1]
if not date12 in date12_to_rmv:
print cor
unwSet = h5fileCor['coherence'][cor].get(cor)
unw = unwSet[0:unwSet.shape[0],0:unwSet.shape[1]]
group = gc.create_group(cor)
dset = group.create_dataset(cor, data=unw, compression='gzip')
for key, value in h5fileCor['coherence'][cor].attrs.iteritems():
group.attrs[key] = value
h5fileCor.close()
h5fileCorm.close()
except:
print 'No coherence file to be updated.'
############################################################
print 'writing >>> Modified_Mask.h5'
h5mask = h5py.File('Modified_Mask.h5','w')
group = h5mask.create_group('mask')
dset = group.create_dataset(os.path.basename('mask'), data=Mask, compression='gzip')
for key, value in atr.iteritems():
group.attrs[key] = value
h5mask.close()
def remove_surface(File, surf_type, Mask, outName=""):
start = time.time()
##### Output File Name
if outName == "":
ext = os.path.splitext(File)[1].lower()
outName = os.path.basename(File).split(ext)[0] + "_" + surf_type + ext
##### Input File Info
atr = readfile.read_attributes(File)
k = atr["FILE_TYPE"]
print "Input file is " + atr["PROCESSOR"] + " " + k
## Multiple Datasets File
if k in ["interferograms", "coherence", "wrapped", "timeseries"]:
h5file = h5py.File(File, "r")
ifgramList = h5file[k].keys()
ifgramList = sorted(ifgramList)
print "number of epochs: " + str(len(ifgramList))
h5flat = h5py.File(outName, "w")
group = h5flat.create_group(k)
print "writing >>> " + outName
if k in ["timeseries"]:
for ifgram in ifgramList:
print "Removing " + surf_type + " from " + ifgram
data = h5file[k].get(ifgram)[:]
data_n, ramp = remove_data_surface(data, Mask, surf_type)
dset = group.create_dataset(ifgram, data=data_n, compression="gzip")
for key, value in h5file[k].attrs.iteritems():
group.attrs[key] = value
elif k in ["interferograms", "wrapped", "coherence"]:
for ifgram in ifgramList:
print "Removing " + surf_type + " from " + ifgram
data = h5file[k][ifgram].get(ifgram)[:]
data_n, ramp = remove_data_surface(data, Mask, surf_type)
gg = group.create_group(ifgram)
dset = gg.create_dataset(ifgram, data=data_n, compression="gzip")
for key, value in h5file[k][ifgram].attrs.iteritems():
gg.attrs[key] = value
## Single Dataset File
else:
try:
data, atr = readfile.read(File)
except:
pass
print "Removing " + surf_type + " from " + k
data_n, ramp = remove_data_surface(data, Mask, surf_type)
writefile.write(data_n, atr, outName)
try:
h5file.close()
h5flat.close()
except:
pass
print "Remove " + surf_type + " took " + str(time.time() - start) + " secs"
def main(argv):
##### Default
fontSize = 12
lineWidth = 2
markerColor = 'crimson'
markerSize = 16
disp_fig = 'no'
save_fig = 'yes'
save_list = 'yes'
ref_file = 'reference_date.txt'
drop_file = 'drop_date.txt'
##### Check Inputs
if len(sys.argv)>3:
try:
opts, args = getopt.getopt(argv,'h:f:m:o:x:y:',['help','circle='])
except getopt.GetoptError:
print 'Error in reading input options!'; Usage() ; sys.exit(1)
for opt,arg in opts:
if opt in ("-h","--help"): Usage() ; sys.exit()
elif opt == '-f': File = arg
elif opt == '-m': maskFile = arg
elif opt == '-x': xsub = [int(i) for i in arg.split(':')]; xsub.sort()
elif opt == '-y': ysub = [int(i) for i in arg.split(':')]; ysub.sort()
elif opt == '--circle' : cir_par = [i for i in arg.split(';')]
#elif opt == '-o': outName = arg
else:
try: File = argv[0]
except: Usage(); sys.exit(1)
try: maskFile = argv[1]
except: pass
try: atr = readfile.read_attributes(File)
except: Usage(); sys.exit(1)
ext = os.path.splitext(File)[1].lower()
FileBase = os.path.basename(File).split(ext)[0]
outNameBase = 'spatialMean_'+FileBase
print '\n*************** Spatial Average ******************'
##### Input File Info
k = atr['FILE_TYPE']
print 'Input file is '+k
width = int(atr['WIDTH'])
length = int(atr['FILE_LENGTH'])
h5file = h5py.File(File)
epochList = h5file[k].keys();
epochList = sorted(epochList)
epochNum = len(epochList)
print 'number of epoch: '+str(epochNum)
dates,datevector = ptime.date_list2vector(epochList)
##### Mask Info
try:
Mask_orig,Matr = readfile.read(maskFile)
print 'mask file: '+maskFile
Masking = 'yes'
except:
print 'No mask. Use the whole area for ramp estimation.'
Masking = 'no'
Mask_orig=np.ones((length,width))
Mask = np.zeros((length,width))
Mask[:] = Mask_orig[:]
## Bounding Subset
try:
xsub
ysub
ysub,xsub = subset.check_subset_range(ysub,xsub,atr)
Mask[ysub[0]:ysub[1],xsub[0]:xsub[1]] = Mask_orig[ysub[0]:ysub[1],xsub[0]:xsub[1]]*2
#Mask[0:ysub[0],:] = 0
#Mask[ysub[1]:length,:] = 0
#Mask[:,0:xsub[0]] = 0
#Mask[:,xsub[1]:width] = 0
except:
Mask = Mask_orig*2
print 'No subset input.'
## Circle Inputs
try:
cir_par
for i in range(len(cir_par)):
cir_idx = circle_index(atr,cir_par[i])
Mask[cir_idx] = Mask_orig[cir_idx]
print 'Circle '+str(i)+': '+cir_par[i]
except: print 'No circle of interest input.'
## Mask output
idx = Mask == 2
idxNum = float(sum(sum(idx)))
fig = plt.figure()
plt.imshow(Mask,cmap='gray')
plt.savefig(outNameBase+'_mask.png',bbox_inches='tight')
print 'save mask to '+outNameBase+'_mask.png'
#fig.clf()
##### Calculation
meanList = np.zeros(epochNum)
pixPercent = np.zeros(epochNum)
pixT = 0.7
print 'calculating ...'
print ' Date Mean Percentage'
for i in range(epochNum):
epoch = epochList[i]
d = h5file[k].get(epoch)[:]
#d[Mask==0] = np.nan
meanList[i] = np.nanmean(d[idx])
pixPercent[i] = np.sum(d[idx] >= pixT)/idxNum
print epoch+' : %.2f %.1f%%'%(meanList[i],pixPercent[i]*100)
del d
h5file.close()
##### Reference date - Max Value
top3 = sorted(zip(meanList,epochList), reverse=True)[:3]
print '------------ Top 3 Mean ------------------'
print top3
## Write to txt file
fref = open(ref_file,'w')
fref.write(str(top3[0][1])+'\n')
fref.close()
print 'write optimal reference date to '+ref_file
idxMean = meanList == np.nanmax(meanList)
##### Drop dates - mean threshold
#meanT = 0.7
#idxMean = meanList < meanT
#print '------------ Mean Value < '+str(meanT)+' --------'
#print np.array(epochList)[idxMean]
#print meanList[idxMean]
##### Drop dates - good pixel percentage
pixNumT = 0.7
print '------------ Good Pixel Percentage < %.0f%% -------'%(pixNumT*100)
idxPix = pixPercent < pixNumT
dropEpochList = np.array(epochList)[idxPix]
print dropEpochList
print pixPercent[idxPix]
## Write to txt file
fdrop = open(drop_file,'w')
for i in range(len(dropEpochList)):
fdrop.write(str(dropEpochList[i])+'\n')
fdrop.close()
print 'write drop dates to '+drop_file
print '-------------------------------------------'
##### Display
fig = plt.figure(figsize=(12,12))
ax = fig.add_subplot(211)
ax.plot(dates, meanList, '-ko', ms=markerSize, lw=lineWidth, alpha=0.7, mfc=markerColor)
#ax.plot([dates[0],dates[-1]],[meanT,meanT], '--b', lw=lineWidth)
#sc = ax.scatter(dates, np.tile(0.5,epochNum), c=meanList, s=22**2, alpha=0.3, vmin=0.0, vmax=1.0)
#ax.scatter(np.array(dates)[idxMean], 0.5, c=meanList[idxMean], s=22**2, alpha=1.0, vmin=0.0, vmax=1.0)
ax = ptime.adjust_xaxis_date(ax,datevector)
ax.set_ylim(0,1)
ax.set_title('Spatial Average Value', fontsize=fontSize)
ax.set_xlabel('Time [years]', fontsize=fontSize)
#cbar = plt.colorbar(sc)
#cbar.set_label('Spatial Mean of Normalized Sum Epochs')
ax = fig.add_subplot(212)
ax.plot(dates, pixPercent, '-ko', ms=markerSize, lw=lineWidth, alpha=0.7, mfc=markerColor)
ax.plot([dates[0],dates[-1]],[pixNumT,pixNumT], '--b', lw=lineWidth)
ax = ptime.adjust_xaxis_date(ax,datevector)
ax.set_ylim(0,1)
ax.set_title('Percenrage of Pixels with Value > '+str(pixNumT), fontsize=fontSize)
ax.set_xlabel('Time [years]', fontsize=fontSize)
vals = ax.get_yticks()
ax.set_yticklabels(['{:3.0f}%'.format(i*100) for i in vals])
if save_fig == 'yes':
plt.savefig(outNameBase+'.png',bbox_inches='tight')
print 'save figure to '+outNameBase+'.png'
if disp_fig == 'yes':
plt.show()
##### Output
if save_list == 'yes':
epochList6 = ptime.yymmdd(epochList)
fl = open(outNameBase+'.txt','w')
for i in range(epochNum):
str_line = epochList6[i]+' %.2f %.2f\n'%(meanList[i],pixPercent[i])
fl.write(str_line)
fl.close()
print 'write data to '+outNameBase+'.txt\n'
def timeseries_inversion(igramsFile,timeseriesFile):
## modified from sbas.py written by scott baker, 2012
'''Implementation of the SBAS algorithm.
Usage:
timeseries_inversion(h5flat,h5timeseries)
h5flat: hdf5 file with the interferograms
h5timeseries: hdf5 file with the output from the inversion
'''
total = time.time()
global B1, dt, numDates
h5flat = h5py.File(igramsFile,'r')
A,B = design_matrix(h5flat)
tbase,dateList,dateDict,dateDict2 = date_list(h5flat)
dt = np.diff(tbase)
B1 = np.linalg.pinv(B)
B1 = np.array(B1,np.float32)
numDates = len(dateList)
##### Basic Info
ifgramList = h5flat['interferograms'].keys()
numIfgrams = len(ifgramList)
atr = readfile.read_attributes(igramsFile)
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
numPixels = length * width
print 'number of interferograms: '+str(numIfgrams)
print 'number of pixels : '+str(numPixels)
#numPixels_step = int(numPixels/10)
##### Inversion Function
def ts_inverse_point(dataPoint):
nan_ndx = dataPoint == 0.
fin_ndx = dataPoint != 0.
nan_fin = dataPoint.copy()
nan_fin[nan_ndx] = 1
if not nan_fin.sum() == len(nan_fin):
B1tmp = np.dot(B1,np.diag(fin_ndx))
tmp_rate = np.dot(B1tmp,dataPoint)
zero = np.array([0.],np.float32)
defo = np.concatenate((zero,np.cumsum([tmp_rate*dt])))
else: defo = np.zeros((modelDimension+1,1),np.float32)
return defo
def ts_inverse(dataLine):
numPoint = dataLine.shape[1]
tmp_rate = np.dot(B1,dataLine)
defo1 = tmp_rate * np.tile(dt.reshape((numDates-1,1)),(1,numPoint))
defo0 = np.array([0.]*numPoint,np.float32)
defo = np.vstack((defo0, np.cumsum(defo1,axis=0)))
return defo
##### Read Interferograms
print 'Reading interferograms ...'
data = np.zeros((numIfgrams,numPixels),np.float32)
for j in range(numIfgrams):
print ifgramList[j]+' '+str(j+1)
d = h5flat['interferograms'][ifgramList[j]].get(ifgramList[j])[:]
data[j] = d.flatten(1)
h5flat.close()
##### Inversion
print 'Inversing time series ...'
dataPoint = np.zeros((numIfgrams,1),np.float32)
dataLine = np.zeros((numIfgrams,width),np.float32)
modelDimension = np.shape(B)[1]
tempDeformation = np.zeros((modelDimension+1,numPixels),np.float32)
for i in range(length):
dataLine = data[:,i*width:(i+1)*width]
defoLine = ts_inverse(dataLine)
tempDeformation[:,i*width:(i+1)*width] = defoLine
#for j in range(width):
# dataPoint = data[:,j]
# try: tempDeformation[:,i*length+j] = point_inverse(dataPoint)
# except: pass
printProgress(i+1,length,prefix='calculating:')
del data
##### Time Series Data Preparation
print 'converting phase to range'
timeseries = np.zeros((modelDimension+1,length,width),np.float32)
phase2range = -1*float(atr['WAVELENGTH'])/(4.*np.pi)
for ni in range(modelDimension+1):
timeseries[ni] = tempDeformation[ni].reshape(width,length).T
timeseries[ni] = timeseries[ni]*phase2range
del tempDeformation
##### Output Time Series File
print 'writing >>> '+timeseriesFile
print 'number of dates: '+str(numDates)
h5timeseries = h5py.File(timeseriesFile,'w')
group = h5timeseries.create_group('timeseries')
dateIndex = ptime.date_index(dateList)
for date in dateList:
if not date in h5timeseries['timeseries']:
print date
dset = group.create_dataset(date, data=timeseries[dateIndex[date]], compression='gzip')
## Attributes
print 'calculating perpendicular baseline timeseries'
Bperp = Baseline_timeseries(igramsFile)
Bperp = str(Bperp.tolist()).translate(None,'[],')
atr['P_BASELINE_TIMESERIES'] = Bperp
for key,value in atr.iteritems(): group.attrs[key] = value
h5timeseries.close()
print 'Done.\nTime series inversion took ' + str(time.time()-total) +' secs'
def main(argv):
########################## Check Inputs ################################################
## Default value
Masking = 'no'
save_mask = 'no'
if len(sys.argv) > 4:
try: opts, args = getopt.getopt(argv,'h:f:m:o:s:t:y:',['help','save-mask'])
except getopt.GetoptError: print 'Error while getting args!\n'; Usage(); sys.exit(1)
for opt,arg in opts:
if opt in ['-h','--help']: Usage(); sys.exit()
elif opt in '-f': File = arg
elif opt in '-m': maskFile = arg
elif opt in '-o': outName = arg
elif opt in '-s': surfType = arg.lower()
elif opt in '-t': templateFile = arg
elif opt in '-y': ysub = [int(i) for i in arg.split(',')]
elif opt in '--save-mask' : save_mask = 'yes'
elif len(sys.argv) in [3,4]:
File = argv[0]
surfType = argv[1].lower()
try: maskFile = argv[2]
except: pass
else: Usage(); sys.exit(1)
print '\n*************** Phase Ramp Removal ***********************'
## Multiple Surfaces
try:
ysub
if not len(ysub)%2 == 0:
print 'ERROR: -y input has to have even length!'
sys.exit(1)
surfNum = len(ysub)/2
except:
surfNum = 1
print 'phase ramp number: '+str(surfNum)
## Tempate File
try:
templateFile
templateContents = readfile.read_template(templateFile)
except: pass
try: surfType
except:
try: surfType = templateContents['pysar.orbitError.method']
except: surfType = 'plane'; print 'No ramp type input, use plane as default'
print 'phase ramp type : '+surfType
## Input File(s)
fileList = glob.glob(File)
fileList = sorted(fileList)
print 'input file(s): '+str(len(fileList))
print fileList
atr = readfile.read_attributes(fileList[0])
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
## Output File(s)
if len(fileList) > 1: outName = ''
elif len(fileList) == 0: print 'ERROR: Cannot find input file(s)!'; sys.exit(1)
else: ## Customized output name only works for single file input
def main(argv):
global method_default
##### Referencing methods
method_default = 'max_coherence'
#method = 'manual'
#method = 'max_coherence' ## Use phase on point with max coherence [default]
#method = 'global_average' ## Use Nan Mean of phase on all pixels
#method = 'random'
#maskFile = 'Mask.h5'
global SeedingDone
############################## Check Inputs ##############################
if len(sys.argv) > 2:
try: opts, args = getopt.getopt(argv,"h:c:f:m:y:x:l:L:t:o:r:",\
['manual','max-coherence','global-average','random'])
except getopt.GetoptError: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt in ("-h","--help"): Usage(); sys.exit()
elif opt == '-f': File = arg
elif opt == '-m': maskFile = arg
elif opt == '-c': corFile = arg
elif opt == '-o': outFile = arg
elif opt == '-y': ry = int(arg)
elif opt == '-x': rx = int(arg)
elif opt == '-l': rlat = float(arg)
elif opt == '-L': rlon = float(arg)
elif opt == '-r': refFile = arg
elif opt == '-t': templateFile = arg
elif opt == '--global-average' : method = 'global_average'
elif opt == '--manual' : method = 'manual'
elif opt == '--max-coherence' : method = 'max_coherence'
elif opt == '--random' : method = 'random'
elif len(sys.argv)==2:
if argv[0]=='-h': Usage(); sys.exit(1)
elif os.path.isfile(argv[0]): File = argv[0]
else: print 'Input file does not existed: '+argv[0]; sys.exit(1)
elif len(sys.argv)<2: Usage(); sys.exit(1)
##### Input File Info
try:
File
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
length = int(atr['FILE_LENGTH'])
width = int(atr['WIDTH'])
except: Usage() ; sys.exit(1)
ext = os.path.splitext(File)[1].lower()
try: outFile
except: outFile = 'Seeded_'+File
############################## Reference Point Input ####################
try:
refFile
atr_ref = readfile.read_attributes(refFile)
except: pass
try:
templateFile
templateContents = readfile.read_template(templateFile)
except: pass
### Priority
## lat/lon > y/x
## Direct Input > Reference File > Template File
try:
rlat
rlon
except:
try:
rlat = float(atr_ref['ref_lat'])
rlon = float(atr_ref['ref_lon'])
except:
try: rlat,rlon = [float(i) for i in templateContents['pysar.seed.lalo'].split(',')]
except: pass
try:
ry
rx
except:
try:
ry = int(atr_ref['ref_y'])
rx = int(atr_ref['ref_x'])
except:
try: ry,rx = [int(i) for i in templateContents['pysar.seed.yx'].split(',')]
except: pass
##### Check lalo / YX
print '\n************** Reference Point ******************'
try:
rlat
rlon
y = sub.coord_geo2radar(rlat,atr,'lat')
x = sub.coord_geo2radar(rlon,atr,'lon')
0<= x <= width
0<= y <= length
rx = x
ry = y
print 'Reference point: lat = %.4f, lon = %.4f'%(rlat,rlon)
print ' y = %d, x = %d'%(ry,rx)
except:
print 'Skip input lat/lon reference point.'
print 'Continue with the y/x reference point.'
######################### a. Read Mask File #########################
## Priority: Input mask file > pysar.mask.file
try: maskFile
except:
try: maskFile = templateContents['pysar.mask.file']
except: print 'No mask found!';
try:
M,Matr = readfile.read(maskFile);
print 'mask: '+maskFile
except:
print '---------------------------------------------------------'
print 'WARNING: No mask, use the whole area as mask'
print '---------------------------------------------------------'
M = np.ones((length,width))
## Message
try:
rx
ry
0<= rx <= width
0<= ry <= length
if M[ry,rx] == 0:
print 'Input point has 0 value in mask.'
except: pass
######################### b. Stack ##################################
stackFile = os.path.basename(File).split(ext)[0] + '_stack.h5'
stack_file_exist = 'no'
try:
os.path.isfile(stackFile)
stack,atrStack = readfile.read(stackFile)
if width == int(atrStack['WIDTH']) and length == int(atrStack['FILE_LENGTH']):
stack_file_exist = 'yes'
print 'read stack from file: '+stackFile
except: pass
if stack_file_exist == 'no':
print 'calculating stack of input file ...'
stack = ut.stacking(File)
atrStack = atr.copy()
atrStack['FILE_TYPE'] = 'mask'
writefile.write(stack,atrStack,stackFile)
## Message
try:
rx
ry
if stack[ry,rx] == 0:
print 'Input point has nan value in data.'
except: pass
stack[M==0] = 0
if np.nansum(M) == 0.0:
print '\n*****************************************************'
print 'ERROR:'
print 'There is no pixel that has valid phase value in all datasets.'
print 'Check the file!'
print 'Seeding failed'
sys.exit(1)
######################### Check Method ##############################
try:
not stack[ry,rx] == 0
method = 'input_coord'
except:
try: method
except: method = method_default
print 'Skip input y/x reference point.'
print 'Continue with '+method
#h5file = h5py.File(File)
######################### Seeding ###################################
##### Sub-function
def seed_method(method,File,stack,outFile,corFile=''):
SeedingDone = 'no'
next_method = method_default
M = stack != 0
if method == 'manual':
SeedingDone = seed_manual(File,stack,outFile)
if SeedingDone == 'no':
next_method = method_default
print_warning(next_method)
elif method == 'max_coherence':
try: SeedingDone = seed_max_coherence(File,M,outFile,corFile)
except: SeedingDone = seed_max_coherence(File,M,outFile)
if SeedingDone == 'no':
next_method = 'random'
print_warning(next_method)
elif method == 'random':
y,x = random_selection(stack)
seed_xy(File,x,y,outFile)
SeedingDone = 'yes'
elif method == 'global_average':
print '\n---------------------------------------------------------'
print 'Automatically Seeding using Global Spatial Average Value '
print '---------------------------------------------------------'
print 'Calculating the global spatial average value for each epoch'+\
' of all valid pixels ...'
box = (0,0,width,length)
meanList = ut.spatial_mean(File,M,box)
seed_file(File,outFile,meanList,'','')
SeedingDone = 'yes'
return SeedingDone, next_method
##### Seeding
SeedingDone = 'no'
if method == 'input_coord':
seed_xy(File,rx,ry,outFile)
SeedingDone = 'yes'
else:
i = 0
while SeedingDone == 'no' and i < 5:
try: SeedingDone,method = seed_method(method,File,stack,outFile,corFile)
except: SeedingDone,method = seed_method(method,File,stack,outFile)
i += 1
if i >= 5:
print 'ERROR: Seeding failed after more than '+str(i)+' times try ...'
sys.exit(1)
def main(argv):
try:
igramsFile = argv[0]
timeSeriesFile = argv[1]
except:
Usage()
sys.exit(1)
try:
tempCohFile = argv[2]
except:
tempCohFile = "temporal_coherence.h5"
########################################################
print "\n********** Temporal Coherence ****************"
print "load time series: " + timeSeriesFile
atr_ts = readfile.read_attributes(timeSeriesFile)
h5timeseries = h5py.File(timeSeriesFile)
dateList = h5timeseries["timeseries"].keys()
numDates = len(dateList)
print "number of epoch: " + str(numDates)
dateIndex = {}
for ni in range(numDates):
dateIndex[dateList[ni]] = ni
dset = h5timeseries["timeseries"].get(h5timeseries["timeseries"].keys()[0])
nrows, ncols = np.shape(dset)
timeseries = np.zeros((len(h5timeseries["timeseries"].keys()), np.shape(dset)[0] * np.shape(dset)[1]), np.float32)
for i in range(numDates):
date = dateList[i]
dset = h5timeseries["timeseries"].get(date)
d = dset[0 : dset.shape[0], 0 : dset.shape[1]]
timeseries[dateIndex[date]][:] = d.flatten(0)
ut.printProgress(i + 1, numDates, "loading:", date)
del d
h5timeseries.close()
lt, numpixels = np.shape(timeseries)
range2phase = -4 * np.pi / float(atr_ts["WAVELENGTH"])
timeseries = range2phase * timeseries
######################################################
print "load interferograms: " + igramsFile
h5igrams = h5py.File(igramsFile)
ifgramList = h5igrams["interferograms"].keys()
numIfgrams = len(ifgramList)
print "number of epochs: " + str(numIfgrams)
A, B = design_matrix(h5igrams)
p = -1 * np.ones([A.shape[0], 1])
Ap = np.hstack((p, A))
print "calculating temporal coherence ..."
# data = np.zeros((numIfgrams,numpixels),np.float32)
qq = np.zeros(numpixels) + 0j
for ni in range(numIfgrams):
## read interferogram
igram = ifgramList[ni]
dset = h5igrams["interferograms"][igram].get(igram)
data = dset[0 : dset.shape[0], 0 : dset.shape[1]]
data = data.flatten(0)
## calculate difference between observed and estimated data
## interferogram by interferogram, less memory, Yunjun - 2016.06.10
dataEst = np.dot(Ap[ni, :], timeseries)
dataDiff = data - dataEst
qq += np.exp(1j * dataDiff)
## progress bar
ut.printProgress(ni + 1, numIfgrams, "calculating:", igram)
del timeseries, data, dataEst, dataDiff
h5igrams.close()
# qq=np.absolute(np.sum(np.exp(1j*dataDiff),0))/numIfgrams
qq = np.absolute(qq) / numIfgrams
Temp_Coh = np.reshape(qq, [nrows, ncols])
##### write temporal coherence file ####################
print "writing >>> " + tempCohFile
h5TempCoh = h5py.File(tempCohFile, "w")
group = h5TempCoh.create_group("temporal_coherence")
dset = group.create_dataset(os.path.basename("temporal_coherence"), data=Temp_Coh, compression="gzip")
for key, value in atr_ts.iteritems():
group.attrs[key] = value
group.attrs["UNIT"] = "1"
h5TempCoh.close()
def main(argv):
dp = 1.0
ntrans = 1
save_to_mat = 'off'
flip_profile = 'no'
which_gps = 'all'
flip_updown = 'yes'
incidence_file ='incidence_file'
display_InSAR = 'on'
display_Average = 'on'
disp_std = 'on'
##### Input Args
try: opts, args = getopt.getopt(argv,"f:s:e:n:d:g:l:h:r:L:F:p:u:G:S:i:I:A:U:E:")
except getopt.GetoptError: Usage() ; sys.exit(1)
for opt,arg in opts:
if opt == '-f': velocityFile = arg
elif opt == '-s': y0,x0 = [int(i) for i in arg.split(',')]
elif opt == '-e': y1,x1 = [int(i) for i in arg.split(',')]
elif opt == '-n': ntrans = int(arg)
elif opt == '-d': dp = float(arg)
elif opt == '-g': gpsFile=arg
elif opt == '-r': refStation=arg
elif opt == '-i': incidence_file=arg
elif opt == '-L': stationsList = arg.split(',')
elif opt == '-F': FaultCoords = arg.split(',')
elif opt == '-p': flip_profile = arg
elif opt == '-u': flip_updown = arg; print flip_updown
elif opt == '-G': which_gps =arg
elif opt == '-S': gps_source=arg
elif opt == '-h': hbound=float(arg)
elif opt == '-l': lbound=float(arg)
elif opt == '-I': display_InSAR = arg
elif opt == '-A': display_Average = arg
elif opt == '-U': disp_std = arg
elif opt == '-E': save_to_mat = arg
##### Input File Info
try: atr = readfile.read_attributes(velocityFile)
except: Usage(); sys.exit(1)
k = atr['FILE_TYPE']
print 'input file is '+k
h5file = h5py.File(velocityFile,'r')
z= h5file[k].get(k)[:]
width = int(atr['WIDTH'])
length = int(atr['FILE_LENGTH'])
try: lat,lon,lat_step,lon_step,lat_all,lon_all = get_lat_lon(atr)
except: print 'radar coordinate'
##### Fault Coordinates
try:
Lat0 = dms2d(FaultCoords[0]); Lon0 = dms2d(FaultCoords[1])
Lat1 = dms2d(FaultCoords[2]); Lon1 = dms2d(FaultCoords[3])
Length,Width=np.shape(z)
Yf0,Xf0=find_row_column(Lon0,Lat0,lon,lat,lon_step,lat_step)
Yf1,Xf1=find_row_column(Lon1,Lat1,lon,lat,lon_step,lat_step)
print '*********************************************'
print ' Fault Coordinates:'
print ' -------------------------- '
print ' Lat Lon'
print str(Lat0) + ' , ' +str(Lon0)
print str(Lat1) + ' , ' +str(Lon1)
print ' -------------------------- '
print ' row column'
print str(Yf0) + ' , ' +str(Xf0)
print str(Yf1) + ' , ' +str(Xf1)
print '*********************************************'
#mf=float(Yf1-Yf0)/float((Xf1-Xf0)) # slope of the fault line
#cf=float(Yf0-mf*Xf0) # intercept of the fault line
#df0=dist_point_from_line(mf,cf,x0,y0,1,1) #distance of the profile start point from the Fault line
#df1=dist_point_from_line(mf,cf,x1,y1,1,1) #distance of the profile end point from the Fault line
#mp=-1./mf # slope of profile which is perpendicualr to the fault line
#x1=int((df0+df1)/np.sqrt(1+mp**2)+x0) # correcting the end point of the profile to be on a line perpendicular to the Fault
#y1=int(mp*(x1-x0)+y0)
except:
print '*********************************************'
print 'No information about the Fault coordinates!'
print '*********************************************'
#############################################################################
try:
x0;y0;x1;y1
except:
fig = plt.figure()
ax=fig.add_subplot(111)
ax.imshow(z)
try: ax.plot([Xf0,Xf1],[Yf0,Yf1],'k-')
except: print 'Fault line is not specified'
xc=[]
yc=[]
print 'please click on start and end point of the desired profile'
def onclick(event):
if event.button==1:
print 'click'
xc.append(int(event.xdata))
yc.append(int(event.ydata))
cid = fig.canvas.mpl_connect('button_press_event', onclick)
plt.show();
x0=xc[0];x1=xc[1]
y0=yc[0];y1=yc[1]
##############################################################################
try:
mf=float(Yf1-Yf0)/float((Xf1-Xf0)) # slope of the fault line
cf=float(Yf0-mf*Xf0) # intercept of the fault line
df0=dist_point_from_line(mf,cf,x0,y0,1,1) #distance of the profile start point from the Fault line
df1=dist_point_from_line(mf,cf,x1,y1,1,1) #distance of the profile end point from the Fault line
mp=-1./mf # slope of profile which is perpendicualr to the fault line
x1=int((df0+df1)/np.sqrt(1+mp**2)+x0) # correcting the end point of the profile to be on a line perpendicular to the Fault
y1=int(mp*(x1-x0)+y0)
except:
Info_aboutFault='No'
##############################################################################
print '******************************************************'
print 'First profile coordinates:'
print 'Start point: y = '+str(y0)+', x = '+str(x0)
print 'End point: y = '+str(y1)+', x = '+str(x1)
print '******************************************************'
length = int(np.hypot(x1-x0, y1-y0))
x, y = np.linspace(x0, x1, length), np.linspace(y0, y1, length)
zi = z[y.astype(np.int), x.astype(np.int)]
try:
lat_transect=lat_all[y.astype(np.int), x.astype(np.int)]
lon_transect=lon_all[y.astype(np.int), x.astype(np.int)]
except:
lat_transect='Nan'
lon_transect='Nan'
earth_radius = 6371e3; # in meter
try:
dx=float(atr['X_STEP'])*np.pi/180.0*earth_radius*np.sin(np.mean(lat)*np.pi/180)
dy=float(atr['Y_STEP'])*np.pi/180.0*earth_radius
DX=(x-x0)*dx
DY=(y-y0)*dy
D =np.hypot(DX, DY)
print 'geo coordinate:'
print 'profile length = ' +str(D[-1]/1000.0) + ' km'
# df0_km=dist_point_from_line(mf,cf,x0,y0,dx,dy)
except:
dx=float(atr['RANGE_PIXEL_SIZE'])
dy=float(atr['AZIMUTH_PIXEL_SIZE'])
DX=(x-x0)*dx
DY=(y-y0)*dy
D=np.hypot(DX, DY)
print 'radar coordinate:'
print 'profile length = ' +str(D[-1]/1000.0) + ' km'
# df0_km=dist_point_from_line(mf,cf,x0,y0,dx,dy)
try: df0_km=dist_point_from_line(mf,cf,x0,y0,dx,dy)
except: print 'Fault line is not specified'
import pdb; pdb.set_trace()
transect = np.zeros([len(D),ntrans])
transect[:,0] = zi
XX0=[];XX1=[]
YY0=[];YY1=[]
XX0.append(x0);XX1.append(x1)
YY0.append(y0);YY1.append(y1)
if ntrans >1:
m = float(y1-y0)/float((x1-x0))
c = float(y0-m*x0)
m1 = -1.0/m
if lat_transect=='Nan':
for i in range(1,ntrans):
X0=i*dp/np.sqrt(1+m1**2)+x0
Y0=m1*(X0-x0)+y0
X1=i*dp/np.sqrt(1+m1**2)+x1
Y1=m1*(X1-x1)+y1
zi=get_transect(z,X0,Y0,X1,Y1)
transect[:,i]=zi
XX0.append(X0);XX1.append(X1);
YY0.append(Y0);YY1.append(Y1);
else:
transect_lat = np.zeros([len(D),ntrans])
transect_lat[:,0] = lat_transect
transect_lon = np.zeros([len(D),ntrans])
transect_lon[:,0] = lon_transect
for i in range(1,ntrans):
X0=i*dp/np.sqrt(1+m1**2)+x0
Y0=m1*(X0-x0)+y0
X1=i*dp/np.sqrt(1+m1**2)+x1
Y1=m1*(X1-x1)+y1
zi=get_transect(z,X0,Y0,X1,Y1)
lat_transect=get_transect(lat_all,X0,Y0,X1,Y1)
lon_transect=get_transect(lon_all,X0,Y0,X1,Y1)
transect[:,i]=zi
transect_lat[:,i]=lat_transect
transect_lon[:,i]=lon_transect
XX0.append(X0);XX1.append(X1);
YY0.append(Y0);YY1.append(Y1);
#############################################
try: m_prof_edge,c_prof_edge=line(XX0[0],YY0[0],XX0[-1],YY0[-1])
except: print 'Plotting one profile'
###############################################################################
if flip_profile=='yes':
transect=np.flipud(transect);
try: df0_km=np.max(D)-df0_km;
except: print '';
print '******************************************************'
try: gpsFile
except: gpsFile='Nogps'
print 'GPS velocity file:'
print gpsFile
print '*******************************************************'
if os.path.isfile(gpsFile):
insarData=z
del z
fileName, fileExtension = os.path.splitext(gpsFile)
# print fileExtension
# if fileExtension =='.cmm4':
# print 'reading cmm4 velocities'
# Stations, gpsData = redGPSfile_cmm4(gpsFile)
# idxRef=Stations.index(refStation)
# Lon,Lat,Ve,Vn,Se,Sn,Corr,Hrate,H12=gpsData[idxRef,:]
# Lon=Lon-360.0
# Lat,Lon,Ve,Se,Vn,Sn,Corr,NumEpochs,timeSpan,AvgEpochTimes = gpsData[idxRef,:]
# Vu=0
# else:
# Stations, gpsData = redGPSfile(gpsFile)
# idxRef=Stations.index(refStation)
# Lat,Lon,Vn,Ve,Sn,Se,Corr,Vu,Su = gpsData[idxRef,:]
Stations,Lat,Lon,Ve,Se,Vn,Sn=readGPSfile(gpsFile,gps_source)
idxRef=Stations.index(refStation)
Length,Width=np.shape(insarData)
# lat,lon,lat_step,lon_step = get_lat_lon(h5file,Length,Width)
lat,lon,lat_step,lon_step,lat_all,lon_all=get_lat_lon(h5file)
IDYref,IDXref=find_row_column(Lon[idxRef],Lat[idxRef],lon,lat,lon_step,lat_step)
if (not np.isnan(IDYref)) and (not np.isnan(IDXref)):
print 'referencing InSAR data to the GPS station at : ' + str(IDYref) + ' , '+ str(IDXref)
if not np.isnan(insarData[IDYref][IDXref]):
transect = transect - insarData[IDYref][IDXref]
insarData=insarData - insarData[IDYref][IDXref]
else:
print '''
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
WARNING: nan value for InSAR data at the refernce pixel!
reference station should be a pixel with valid value in InSAR data.
please select another GPS station as the reference station.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
'''
sys.exit(1)
else:
print 'WARNING:'
print 'Reference GPS station is out of the area covered by InSAR data'
print 'please select another GPS station as the reference station.'
sys.exit(1)
try:
stationsList
except:
stationsList = Stations
# theta=23.0*np.pi/180.0
if os.path.isfile(incidence_file):
print 'Using exact look angle for each pixel'
h5file_theta=h5py.File(incidence_file,'r')
dset=h5file_theta['mask'].get('mask')
theta=dset[0:dset.shape[0],0:dset.shape[1]]
theta=theta*np.pi/180.0
else:
print 'Using average look angle'
theta=np.ones(np.shape(insarData))*23.0*np.pi/180.0
heading=193.0*np.pi/180.0
# unitVec=[-np.sin(theta)*np.sin(heading),-np.cos(heading)*np.sin(theta),-np.cos(theta)]
unitVec=[np.cos(heading)*np.sin(theta),-np.sin(theta)*np.sin(heading),0]#-np.cos(theta)]
# [0.0806152480932643, 0.34918300221540616, -0.93358042649720174]
# print unitVec
# unitVec=[0.3,-0.09,0.9]
# unitVec=[-0.3,0.09,-0.9]
# unitVec=[-0.3,0.09,0]
# print '*******************************************'
# print 'unit vector to project GPS to InSAR LOS:'
# print unitVec
# print '*******************************************'
# gpsLOS_ref=unitVec[0]*Ve[idxRef]+unitVec[1]*Vn[idxRef]#+unitVec[2]*Vu[idxRef]
# print np.shape(theta)
# print IDYref
# print IDXref
# print theta[IDYref,IDXref]
gpsLOS_ref = gps_to_LOS(Ve[idxRef],Vn[idxRef],theta[IDYref,IDXref],heading)
print '%%%%%%^^^^^^^%%%%%%%%'
print gpsLOS_ref/1000.0
# insarData=insarData -gpsLOS_ref/1000.0
# transect = transect -gpsLOS_ref/1000.0
GPS=[]
GPS_station=[]
GPSx=[]
GPSy=[]
GPS_lat=[]
GPS_lon=[]
for st in stationsList:
try :
idx=Stations.index(st)
# gpsLOS = unitVec[0]*Ve[idx]+unitVec[1]*Vn[idx]#+unitVec[2]*Vu[idx]
# gpsLOS = gps_to_LOS(Ve[idx],Vn[idx],theta[idx],heading)
# gpsLOS=gpsLOS-gpsLOS_ref
IDY,IDX=find_row_column(Lon[idx],Lat[idx],lon,lat,lon_step,lat_step)
print theta[IDY,IDX]
gpsLOS = gps_to_LOS(Ve[idx],Vn[idx],theta[IDY,IDX],heading)
# gpsLOS = gpsLOS-gpsLOS_ref
if which_gps =='all':
if theta[IDY,IDX]!=0.0:
GPS.append(gpsLOS-gpsLOS_ref)
GPS_station.append(st)
GPSx.append(IDX)
GPSy.append(IDY)
GPS_lat.append(Lat[idx])
GPS_lon.append(Lon[idx])
elif not np.isnan(insarData[IDY][IDX]):
if theta[IDY,IDX]!=0.0:
GPS.append(gpsLOS-gpsLOS_ref)
GPS_station.append(st)
GPSx.append(IDX)
GPSy.append(IDY)
GPS_lat.append(Lat[idx])
GPS_lon.append(Lon[idx])
except:
NoInSAR='yes'
# print GPS_station
# print gpsLOS
DistGPS=[]
GPS_in_bound=[]
GPS_in_bound_st=[]
GPSxx=[]
GPSyy=[]
for i in range(len(GPS_station)):
gx=GPSx[i]
gy=GPSy[i]
# print '******************'
# print gx
# print gy
if which_gps in ['all','insar']:
check_result = 'True'
else:
check_result=check_st_in_box(gx,gy,x0,y0,x1,y1,X0,Y0,X1,Y1)
if check_result=='True':
check_result2=check_st_in_box2(gx,gy,x0,y0,x1,y1,X0,Y0,X1,Y1)
GPS_in_bound_st.append(GPS_station[i])
GPS_in_bound.append(GPS[i])
GPSxx.append(GPSx[i])
GPSyy.append(GPSy[i])
# gy=y0+1
# gx=x0+1
# gxp,gyp=get_intersect(m,c,gx,gy)
# Dx=dx*(gx-gxp);Dy=dy*(gy-gyp)
# print gxp
# print gyp
dg = dist_point_from_line(m,c,gx,gy,1,1) # distance of GPS station from the first profile line
# DistGPS.append(np.hypot(Dx,Dy))
# X0=dg/np.sqrt(1+m1**2)+x0
# Y0=m1*(X0-x0)+y0
# DistGPS.append(np.hypot(dx*(gx-X0), dy*(gy-Y0)))
DistGPS.append(dist_point_from_line(m_prof_edge,c_prof_edge,GPSx[i],GPSy[i],dx,dy))
print '****************************************************'
print 'GPS stations in the profile area:'
print GPS_in_bound_st
print '****************************************************'
GPS_in_bound = np.array(GPS_in_bound)
DistGPS = np.array(DistGPS)
# axes[1].plot(DistGPS/1000.0, -1*GPS_in_bound/1000, 'bo')
if gpsFile=='Nogps':
insarData=z
GPSxx=[]
GPSyy=[]
GPSx=[];GPSy=[]
GPS=[]
XX0[0]=x0;XX1[0]=x1;YY0[0]=y0;YY1[0]=y1
# else:
print '****************'
print 'flip up-down'
print flip_updown
if flip_updown=='yes' and gpsFile!='Nogps':
print 'Flipping up-down'
transect=-1*transect
GPS_in_bound=-1*GPS_in_bound
elif flip_updown=='yes':
print 'Flipping up-down'
transect=-1*transect
if flip_profile=='yes' and gpsFile!='Nogps':
GPS=np.flipud(GPS)
GPS_in_bound=np.flipud(GPS_in_bound)
DistGPS=np.flipud(max(D)-DistGPS)
fig, axes = plt.subplots(nrows=2)
axes[0].imshow(insarData)
for i in range(ntrans):
axes[0].plot([XX0[i], XX1[i]], [YY0[i], YY1[i]], 'r-')
axes[0].plot(GPSx,GPSy,'b^')
axes[0].plot(GPSxx,GPSyy,'k^')
if gpsFile!='Nogps':
axes[0].plot(IDXref,IDYref,'r^')
axes[0].axis('image')
axes[1].plot(D/1000.0,transect,'ko',ms=1)
avgInSAR=np.array(nanmean(transect,axis=1))
stdInSAR=np.array(nanstd(transect,axis=1))
# print avgInSAR
# print stdInSAR
#std=np.std(transect,1)
# axes[1].plot(D/1000.0, avgInSAR, 'r-')
try:
axes[1].plot(DistGPS/1000.0, -1*GPS_in_bound/1000, 'b^',ms=10)
except:
print ''
# pl.fill_between(x, y-error, y+error,alpha=0.6, facecolor='0.20')
# print transect
#############################################################################
fig2, axes2 = plt.subplots(nrows=1)
axes2.imshow(insarData)
#for i in range(ntrans):
axes2.plot([XX0[0], XX1[0]], [YY0[0], YY1[0]], 'k-')
axes2.plot([XX0[-1], XX1[-1]], [YY0[-1], YY1[-1]], 'k-')
axes2.plot([XX0[0], XX0[-1]], [YY0[0], YY0[-1]], 'k-')
axes2.plot([XX1[0], XX1[-1]], [YY1[0], YY1[-1]], 'k-')
try:
axes2.plot([Xf0,Xf1],[Yf0,Yf1], 'k-')
except:
FaultLine='None'
axes2.plot(GPSx,GPSy,'b^')
axes2.plot(GPSxx,GPSyy,'k^')
if gpsFile!='Nogps':
axes2.plot(IDXref,IDYref,'r^')
axes2.axis('image')
figName = 'transect_area.png'
print 'writing '+figName
plt.savefig(figName)
#############################################################################
fig = plt.figure()
fig.set_size_inches(10,4)
ax = plt.Axes(fig, [0., 0., 1., 1.], )
ax=fig.add_subplot(111)
if display_InSAR in ['on','On','ON']:
ax.plot(D/1000.0,transect*1000,'o',ms=1,mfc='Black', linewidth='0')
############################################################################
# save the profile data:
if save_to_mat in ['ON','on','On','yes','y','YES','Yes']:
import scipy.io as sio
matFile='transect.mat'
dataset={}
dataset['datavec']=transect
try:
dataset['lat']=transect_lat
dataset['lon']=transect_lon
except:
dataset['lat']='Nan'
dataset['lon']='Nan'
dataset['Unit']='m'
dataset['Distance_along_profile']=D
print '*****************************************'
print ''
print 'writing transect to >>> '+matFile
sio.savemat(matFile, {'dataset': dataset})
print ''
print '*****************************************'
############################################################################
# ax.plot(D/1000.0, avgInSAR*1000, 'r-')
# ax.plot(D/1000.0,transect*1000/(np.sin(23.*np.pi/180.)*np.cos(38.*np.pi/180.0)),'o',ms=1,mfc='Black', linewidth='0')
# ax.plot(D/1000.0, avgInSAR*1000/(np.sin(23.*np.pi/180.)*np.cos(38.*np.pi/180.0)), 'r-')
#############################################################################
if disp_std in ['on','On','ON']:
for i in np.arange(0.0,1.01,0.01):
ax.plot(D/1000.0, (avgInSAR-i*stdInSAR)*1000, '-',color='#DCDCDC',alpha=0.5)#,color='#DCDCDC')#'LightGrey')
for i in np.arange(0.0,1.01,0.01):
ax.plot(D/1000.0, (avgInSAR+i*stdInSAR)*1000, '-',color='#DCDCDC',alpha=0.5)#'LightGrey')
#############################################################################
if display_Average in ['on','On','ON']:
ax.plot(D/1000.0, avgInSAR*1000, 'r-')
###########
# ax.fill_between(D/1000.0, (avgInSAR-stdInSAR)*1000, (avgInSAR+stdInSAR)*1000,where=(avgInSAR+stdInSAR)*1000>=(avgInSAR-stdInSAR)*1000,alpha=1, facecolor='Red')
try:
ax.plot(DistGPS/1000.0, -1*GPS_in_bound, '^',ms=10,mfc='Cyan')
except:
print ''
ax.set_ylabel('LOS velocity [mm/yr]',fontsize=26)
ax.set_xlabel('Distance along profile [km]',fontsize=26)
# print '******************'
# print 'Dsitance of fault from the beginig of profile(km):'
# print df0_km/1000.0
###################################################################
#lower and higher bounds for diplaying the profile
try:
lbound
hbound
except:
lbound=np.nanmin(transect)*1000
hbound=np.nanmax(transect)*1000
###################################################################
#To plot the Fault location on the profile
try:
ax.plot([df0_km/1000.0,df0_km/1000.0], [lbound,hbound], '--',color='black',linewidth='2')
except:
fault_loc='None'
###################################################################
try:
ax.set_ylim(lbound,hbound)
except:
ylim='no'
# try:
# ax.set_xlim(-10,300)
# except:
# xlim='no'
##########
#Temporary To plot DEM
# try:
# majorLocator = MultipleLocator(5)
# ax.yaxis.set_major_locator(majorLocator)
# minorLocator = MultipleLocator(1)
# ax.yaxis.set_minor_locator(minorLocator)
# plt.tick_params(which='major', length=15,width=2)
# plt.tick_params(which='minor', length=6,width=2)
# try:
# for tick in ax.xaxis.get_major_ticks():
# tick.label.set_fontsize(26)
# for tick in ax.yaxis.get_major_ticks():
# tick.label.set_fontsize(26)
#
# plt.tick_params(which='major', length=15,width=2)
# plt.tick_params(which='minor', length=6,width=2)
# except:
# print 'couldn not fix the ticks! '
figName = 'transect.png'
print 'writing '+figName
plt.savefig(figName)
print ''
print '________________________________'
#############################################################################
plt.show()
def seed_file(File,outName,refList,ref_x='',ref_y=''):
## Seed Input File with reference value in refList
print 'Reference value: '
print refList
##### IO Info
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
print 'file type: '+k
##### Multiple Dataset File
if k in ['timeseries','interferograms','wrapped','coherence']:
##### Input File Info
h5file = h5py.File(File,'r')
epochList = h5file[k].keys()
epochList = sorted(epochList)
epochNum = len(epochList)
print 'number of epochs: '+str(epochNum)
##### Check Epoch Number
if not epochNum == len(refList):
print '\nERROR: Reference value has different epoch number'+\
'from input file.'
print 'Reference List epoch number: '+str(refList)
print 'Input file epoch number: '+str(epochNum)
sys.exit(1)
##### Output File Info
h5out = h5py.File(outName,'w')
group = h5out.create_group(k)
print 'writing >>> '+outName
## Loop
if k == 'timeseries':
for i in range(epochNum):
epoch = epochList[i]
print epoch
data = h5file[k].get(epoch)[:]
data -= refList[i]
dset = group.create_dataset(epoch, data=data, compression='gzip')
atr = seed_attributes(atr,ref_x,ref_y)
for key,value in atr.iteritems(): group.attrs[key] = value
elif k in ['interferograms','wrapped','coherence']:
for i in range(epochNum):
epoch = epochList[i]
#print epoch
data = h5file[k][epoch].get(epoch)[:]
atr = h5file[k][epoch].attrs
data -= refList[i]
atr = seed_attributes(atr,ref_x,ref_y)
gg = group.create_group(epoch)
dset = gg.create_dataset(epoch, data=data, compression='gzip')
for key, value in atr.iteritems(): gg.attrs[key] = value
ut.printProgress(i+1,epochNum,'seeding:',epoch)
##### Single Dataset File
else:
data,atr = readfile.read(File)
data -= refList
atr = seed_attributes(atr,ref_x,ref_y)
writefile.write(data,atr,outName)
##### End & Cleaning
try:
h5file.close()
h5out.close()
except: pass
return 1
def main(argv):
try:
File = argv[0]
alks = int(argv[1])
rlks = int(argv[2])
except:
Usage();sys.exit(1)
ext = os.path.splitext(File)[1]
try: outName = argv[3]
except: outName = File.split('.')[0]+'_a'+str(int(alks))+'lks_r'+str(int(rlks))+'lks'+ext
################################################################################
atr = readfile.read_attributes(File)
k = atr['FILE_TYPE']
print '\n***************** Multilooking *********************'
print 'number of multilooking in azimuth / latitude direction: '+str(alks)
print 'number of multilooking in range / longitude direction: '+str(rlks)
print 'input file: '+k
if k in ['interferograms','coherence','wrapped','timeseries']:
h5file = h5py.File(File,'r')
h5file_mli = h5py.File(outName,'w')
print 'writing >>> '+outName
if k in ['interferograms','coherence','wrapped']:
gg = h5file_mli.create_group(k)
igramList = h5file[k].keys()
igramList = sorted(igramList)
for igram in igramList:
print igram
unw = h5file[k][igram].get(igram)[:]
unwlks = multilook(unw,alks,rlks)
group = gg.create_group(igram)
dset = group.create_dataset(igram, data=unwlks, compression='gzip')
atr = h5file[k][igram].attrs
atr = multilook_attributes(atr,alks,rlks)
for key, value in atr.iteritems(): group.attrs[key] = value
elif k == 'timeseries':
dateList=h5file[k].keys()
dateList = sorted(dateList)
group = h5file_mli.create_group(k)
for d in dateList:
print d
unw = h5file[k].get(d)[:]
unwlks=multilook(unw,alks,rlks)
dset = group.create_dataset(d, data=unwlks, compression='gzip')
## Update attributes
atr = h5file[k].attrs
atr = multilook_attributes(atr,alks,rlks)
for key, value in atr.iteritems(): group.attrs[key] = value
h5file.close()
h5file_mli.close()
################################################################################
else:
####### To multi_look geomap*.trans file, both its file size and value need to be reduced.
if k == '.trans':
rg,az,atr = readfile.read(File)
rgmli = multilook(rg,alks,rlks); #rgmli = rgmli/float(rlks)
azmli = multilook(az,alks,rlks); #azmli = azmli/float(alks)
atr = multilook_attributes(atr,alks,rlks)
writefile.write(rgmli,azmli,atr,outName)
else:
data,atr = readfile.read(File)
data_mli = multilook(data,alks,rlks)
atr = multilook_attributes(atr,alks,rlks)
writefile.write(data_mli,atr,outName)
def main(argv):
global outName
parallel = 'no'
############### Check Inputs ###############
if len(sys.argv)>3:
try:
opts, args = getopt.getopt(argv,'f:l:L:o:t:x:y:r:',['lat=','lon=','row=','col=',\
'parallel','outfill=','outfill-nan','outfill-zero'])
except getopt.GetoptError:
print 'Error while getting args'
Usage() ; sys.exit(1)
for opt,arg in opts:
if opt == '-f': File = arg.split(',')
elif opt == '-o': outName = arg
elif opt == '-t': templateFile = arg
elif opt == '-r': refFile = arg
elif opt in ['-x','--col'] : sub_x = [int(i) for i in arg.split(':')]; sub_x.sort()
elif opt in ['-y','--row'] : sub_y = [int(i) for i in arg.split(':')]; sub_y.sort()
elif opt in ['-l','--lat'] : sub_lat = [float(i) for i in arg.split(':')]; sub_lat.sort()
elif opt in ['-L','--lon'] : sub_lon = [float(i) for i in arg.split(':')]; sub_lon.sort()
elif opt in '--parallel' : parallel = 'yes'
elif opt in '--outfill' : out_fill = float(arg)
elif opt in '--outfill-nan' : out_fill = np.nan
elif opt in '--outfill-zero': out_fill = 0.0
elif len(sys.argv)==3:
File = argv[0].split(',')
templateFile = argv[1]
elif len(sys.argv)==2:
if argv[0] in ['-h','--help']: Usage(); sys.exit()
else: print '\nERROR: A minimum of 3 inputs is needed.\n'; Usage(); sys.exit()
else: Usage(); sys.exit(1)
##### Check Input file Info
print '\n**************** Subset *********************'
fileList = ut.get_file_list(File)
print 'number of file: '+str(len(fileList))
print fileList
atr = readfile.read_attributes(fileList[0])
if len(fileList) == 1 and parallel == 'yes':
print 'parallel is disabled for one input file.'
parallel = 'no'
################## Subset Setting ###########
try:
atr['X_FIRST']
print 'geo coordinate'
except:
print 'radar coordinate'
## Read Subset Inputs
try:
templateFile
template = readfile.read_template(templateFile)
except: pass
try:
refFile
atr_ref = readfile.read_attributes(refFile)
box_ref = geo_box(atr_ref)
lat_ref = [box_ref[3],box_ref[1]]
lon_ref = [box_ref[0],box_ref[2]]
except: pass
try:
sub_lat
sub_lon
except:
try:
sub_lat = lat_ref
sub_lon = lon_ref
except:
try:
sub = template['pysar.subset.lalo'].split(',')
sub_lat = [float(i) for i in sub[0].split(':')]; sub_lat.sort()
sub_lon = [float(i) for i in sub[1].split(':')]; sub_lon.sort()
except: pass; #print 'No pysar.subset.lalo option found in template file!'
try:
sub_y
sub_x
except:
try:
sub = template['pysar.subset.yx'].split(',')
sub_y = [int(i) for i in sub[0].split(':')]; sub_y.sort()
sub_x = [int(i) for i in sub[1].split(':')]; sub_x.sort()
except: pass; #print 'No pysar.subset.yx option found in template file!'
## Check Subset Inputs Existed or not
try: sub_y
except:
try: sub_x
except:
try: sub_lat
except:
try: sub_lon
except: print 'ERROR: no subset is setted.'; Usage(); sys.exit(1)
##### Subset range radar to geo
width = int(atr['WIDTH'])
length = int(atr['FILE_LENGTH'])
print 'input file length: '+str(length)
print 'input file width : '+str(width)
try: sub_y = coord_geo2radar(sub_lat,atr,'latitude')
except:
try: sub_y
except: sub_y = [0,length]
try: sub_x = coord_geo2radar(sub_lon,atr,'longitude')
except:
try: sub_x
except: sub_x = [0,width]
##### Check subset range
try:
out_fill
except:
sub_y,sub_x = check_subset_range(sub_y,sub_x,atr)
out_fill = np.nan
if sub_y[1]-sub_y[0] == length and sub_x[1]-sub_x[0] == width:
print 'Input subset range == data size, no need to subset.'
sys.exit(0)
################### Subset #######################
if parallel == 'no':
for file in fileList:
print '-------------------------------------------'
print 'subseting : '+file
try: subset_file(file,sub_x,sub_y,out_fill,outName)
except: subset_file(file,sub_x,sub_y,out_fill)
else:
print '-------------------------'
print 'parallel subseting ...'
print '-------------------------'
from joblib import Parallel, delayed
import multiprocessing
num_cores = multiprocessing.cpu_count()
Parallel(n_jobs=num_cores)(delayed(subset_file)(file,sub_x,sub_y,out_fill) for file in fileList)
print 'Done.'