def main():
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if rank == 0:
procfile = sys.argv[1].strip()
para_list = ut.readProc(procfile)
ice_model_file = para_list.get("ice_model").strip() ### load model
ice_model_col = int(para_list.get("ice_model_col").strip())
grid_size = float(
para_list.get("grid_size").strip()) ### grid size in m
r = float(para_list.get("r").strip()) ### density
v = float(para_list.get("v").strip()) ### Poisson's ratio
E = int(para_list.get("E").strip()) ### Young's modulus
E_unit = para_list.get("E_unit").strip()
if E_unit == 'MPa':
E = E * (10**6)
elif E_unit == 'GPa':
E = E * (10**9)
else:
print "Unit of Young's modulus should be either MPa or GPa!\n"
exit(1)
print "Young's modulus is: ", E
angle_az = float(para_list.get("angle_az").strip())
angle_inc = float(para_list.get("angle_inc").strip())
ice_model_data = np.fromfile(ice_model_file, dtype=np.float32)
ice_model_lin = ice_model_data.size / ice_model_col
dis_model_v = np.zeros((ice_model_data.size), dtype=np.float32)
#dis_model_e = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
#dis_model_n = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
g = 9.81
vec_col = np.linspace(0, ice_model_col - 1, ice_model_col)
vec_lin = np.linspace(0, ice_model_lin - 1, ice_model_lin)
x1, y1 = np.meshgrid(vec_col, vec_lin)
x2, y2 = x1, y1
x1 = x1.reshape(x1.size)
y1 = y1.reshape(y1.size)
x2 = x2.reshape(ice_model_data.size)[np.abs(ice_model_data) > 0.00001]
y2 = y2.reshape(ice_model_data.size)[np.abs(ice_model_data) > 0.00001]
ice_model_data = ice_model_data[np.abs(ice_model_data) > 0.00001]
const_v = grid_size**2 * r * g * (1 - v**2) / E / np.pi
const_r = grid_size**2 * r * g * (1 + v) * (1 - 2 * v) / E / 2 / np.pi
print "2 constants are: ", const_v, " and ", const_r
dis_model_v_batch = np.array_split(dis_model_v, comm.size)
dis_model_v = None
dis_model_e_batch = dis_model_v_batch
dis_model_n_batch = dis_model_v_batch
x1_batch = np.array_split(x1, size)
y1_batch = np.array_split(y1, size)
else:
ice_model_data = None
dis_model_v_batch = None
dis_model_e_batch = None
dis_model_n_batch = None
x2 = None
y2 = None
const_v = None
const_r = None
x1_batch = None
y1_batch = None
grid_size = None
const_v = comm.bcast(const_v, root=0)
const_r = comm.bcast(const_r, root=0)
x2 = comm.bcast(x2, root=0)
y2 = comm.bcast(y2, root=0)
grid_size = comm.bcast(grid_size, root=0)
ice_model_data = comm.bcast(ice_model_data, root=0)
dis_model_v_batch = comm.scatter(dis_model_v_batch, root=0)
dis_model_e_batch = comm.scatter(dis_model_e_batch, root=0)
dis_model_n_batch = comm.scatter(dis_model_n_batch, root=0)
x1_batch = comm.scatter(x1_batch, root=0)
y1_batch = comm.scatter(y1_batch, root=0)
N_pix = len(x1_batch)
print N_pix, " data received!\n"
print "Shape of dis_model_v_batch is: ", dis_model_v_batch.shape
for ni in range(N_pix):
line1 = y1_batch[ni]
col1 = x1_batch[ni]
dis_y = line1 - y2
dis_x = col1 - x2
distance = np.power(np.power(dis_y, 2) + np.power(dis_x, 2), 0.5)
distance[distance < 1] = 10000000.
sin_ang = dis_x / distance
cos_ang = -1 * dis_y / distance
distance = distance * grid_size
dis_model_v_batch[ni] = np.sum(const_v * (1 / distance) *
ice_model_data)
dis_model_e_batch[ni] = np.sum(const_r * (1 / distance) *
ice_model_data * sin_ang)
dis_model_e_batch[ni] = np.sum(const_r * (1 / distance) *
ice_model_data * cos_ang)
dis_model_v_batch = comm.gather(dis_model_v_batch, root=0)
dis_model_e_batch = comm.gather(dis_model_e_batch, root=0)
dis_model_n_batch = comm.gather(dis_model_n_batch, root=0)
if rank == 0:
dis_model_v = dis_model_v_batch[0]
dis_model_e = dis_model_e_batch[0]
dis_model_n = dis_model_n_batch[0]
for ni in range(size - 1):
dis_model_v = np.hstack((dis_model_v, dis_model_v_batch[ni + 1]))
dis_model_e = np.hstack((dis_model_e, dis_model_e_batch[ni + 1]))
dis_model_n = np.hstack((dis_model_n, dis_model_n_batch[ni + 1]))
dis_model_los = dis_model_v * np.cos(angle_inc/180*np.pi) - \
dis_model_e * np.sin(angle_inc/180*np.pi) * np.cos(angle_az/180*np.pi) + \
dis_model_n * np.sin(angle_inc/180*np.pi) * np.sin(angle_az/180*np.pi)
dis_model_los.astype('float32').tofile(
'elastic_half_space_load_los_model')
def main():
para_list = ut.readProc(sys.argv[1])
interf_folder = para_list.get("interf").strip()
pattern = para_list.get("pattern").strip()
maskfile = para_list.get("mask").strip()
th_d = para_list.get("th_d")
if isinstance(th_d, str):
th_d = [th_d]
for ni in range(len(th_d)):
th_d[ni] = th_d[ni].strip()
th_c = para_list.get("th_c").strip()
iteration = len(th_d)
method = para_list.get("method").strip()
solution = para_list.get("solution").strip()
plane_type = para_list.get("plane_type").strip()
APS_type = para_list.get("APS_type").strip()
demfile = para_list.get("dem").strip()
step = para_list.get("step")
if isinstance(step, str):
step = [step]
for ni in range(len(step)):
step[ni] = step[ni].strip()
if para_list.get("software")=="RSMAS":
int_list = glob.glob(interf_folder+"/PO*")
else:
int_list = glob.glob(interf_folder+"/int_*")
N_line = 0
for f in int_list:
print "f is: ", f, "\n"
intfile = glob.glob(f+"/*"+pattern)[0]
intfile_rsc = intfile + ".rsc"
para_list1 = ut.readRsc(intfile_rsc)
temp_line = int(para_list1.get("FILE_LENGTH").strip())
if N_line < temp_line:
N_line = temp_line
print "maskfile is: ",bool(maskfile=='1'), "\n"
if maskfile == '1':
print "The maximum line is: ", N_line, "\n"
else:
Joblist = interf_folder + "/run_remove_ramp_aps"
for ni in range(iteration):
if ni < 2:
method = "0"
else:
method = "1"
k = 1
IN = open(Joblist, 'w')
for f in int_list:
intfile = glob.glob(f+"/*"+pattern)[0]
corfile = intfile[:-3]+"cor"
if ni>5:
APS_type == "2"
if ni % 2 == 0:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + plane_type + " " + "0" + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(ni+1) + " " + step[ni]
else:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + "0" + " " + APS_type + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(2) + " " + step[ni]
IN.write(temp_str)
if k<len(int_list):
IN.write("\n")
k = k+1
IN.close()
WT = "0:30"
temp_str = os.getenv("INT_SCR").strip() + "/createBatch_8.pl --workdir " + interf_folder + " --infile " + Joblist + " walltime=" + WT
temp_list = [os.getenv("INT_SCR").strip()+"/createBatch_8.pl","--workdir",interf_folder,"--infile",Joblist,"walltime="+WT]
sys.stderr.write(temp_str+"\n")
output = subprocess.Popen(temp_list).wait()
if output == 0:
print "Iteration ", str(ni+1), " has been done!\n"
else:
print "There is error happened. Check code again!\n"
exit(1)
print "All the jobs are done! Good luck!\n"
exit(0)
'''
Created on Sun Aug 17 18:14:13 2014
code used for layered elastic model of surface loading
Wenliang Zhao
'''
import os, sys, re, glob, subprocess, math, time
import Rsmas_Utilib as ut
import ElasticSAR as es
import numpy as np
from osgeo import gdal
import time
para_list = ut.readProc(sys.argv[1])
processdir = para_list.get("processdir").strip()
disp_dir = processdir + "/InSAR"
line_insar = int(para_list.get("line_insar").strip())
col_insar = int(para_list.get("col_insar").strip())
left_lon_insar = float(para_list.get("left_lon_insar").strip())
top_lat_insar = float(para_list.get("top_lat_insar").strip())
res_lon_insar = float(para_list.get("res_lon_insar").strip())
res_lat_insar = float(para_list.get("res_lat_insar").strip())
lookAng_insar = float(para_list.get("lookAng").strip())
azimuth_insar = float(para_list.get("azimuth").strip())
utmZone = para_list.get("utmZone").strip()
res_x_utm = int(para_list.get("spacing").strip())
res_y_utm = res_x_utm
box = para_list.get("box")
method = para_list.get("method").strip()
def main():
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if rank == 0:
procfile = sys.argv[1].strip()
para_list = ut.readProc(procfile)
ice_model_file = para_list.get("ice_model").strip() ### load model
ice_model_col = int(para_list.get("ice_model_col").strip())
grid_size = float(para_list.get("grid_size").strip()) ### grid size in m
r = float(para_list.get("r").strip()) ### density
v = float(para_list.get("v").strip()) ### Poisson's ratio
E = int(para_list.get("E").strip()) ### Young's modulus
E_unit = para_list.get("E_unit").strip()
if E_unit == 'MPa':
E = E * (10 ** 6)
elif E_unit == 'GPa':
E = E * (10 ** 9)
else:
print "Unit of Young's modulus should be either MPa or GPa!\n"
exit(1)
print "Young's modulus is: ", E
angle_az = float(para_list.get("angle_az").strip())
angle_inc = float(para_list.get("angle_inc").strip())
ice_model_data = np.fromfile(ice_model_file,dtype=np.float32)
ice_model_lin = ice_model_data.size / ice_model_col
dis_model_v = np.zeros((ice_model_data.size),dtype=np.float32)
#dis_model_e = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
#dis_model_n = np.zeros((ice_model_data.size),dtype=np.float32).reshape(ice_model_lin,ice_model_col)
g = 9.81
vec_col = np.linspace(0,ice_model_col-1, ice_model_col)
vec_lin = np.linspace(0,ice_model_lin-1, ice_model_lin)
x1, y1 = np.meshgrid(vec_col, vec_lin)
x2, y2 = x1, y1
x1 = x1.reshape(x1.size)
y1 = y1.reshape(y1.size)
x2 = x2.reshape(ice_model_data.size)[np.abs(ice_model_data)>0.00001]
y2 = y2.reshape(ice_model_data.size)[np.abs(ice_model_data)>0.00001]
ice_model_data = ice_model_data[np.abs(ice_model_data)>0.00001]
const_v = grid_size ** 2 * r * g * (1-v**2) / E / np.pi
const_r = grid_size ** 2 * r * g * (1+v) * (1-2*v) / E / 2 / np.pi
print "2 constants are: ", const_v, " and ", const_r
dis_model_v_batch = np.array_split(dis_model_v,comm.size)
dis_model_v = None
dis_model_e_batch = dis_model_v_batch
dis_model_n_batch = dis_model_v_batch
x1_batch = np.array_split(x1,size)
y1_batch = np.array_split(y1,size)
else:
ice_model_data = None
dis_model_v_batch = None
dis_model_e_batch = None
dis_model_n_batch = None
x2 = None
y2 = None
const_v = None
const_r = None
x1_batch = None
y1_batch = None
grid_size = None
const_v = comm.bcast(const_v, root=0)
const_r = comm.bcast(const_r, root=0)
x2 = comm.bcast(x2, root=0)
y2 = comm.bcast(y2, root=0)
grid_size = comm.bcast(grid_size, root=0)
ice_model_data = comm.bcast(ice_model_data, root=0)
dis_model_v_batch = comm.scatter(dis_model_v_batch, root=0)
dis_model_e_batch = comm.scatter(dis_model_e_batch, root=0)
dis_model_n_batch = comm.scatter(dis_model_n_batch, root=0)
x1_batch = comm.scatter(x1_batch, root=0)
y1_batch = comm.scatter(y1_batch, root=0)
N_pix = len(x1_batch)
print N_pix, " data received!\n"
print "Shape of dis_model_v_batch is: ", dis_model_v_batch.shape
for ni in range(N_pix):
line1 = y1_batch[ni]
col1 = x1_batch[ni]
dis_y = line1 - y2
dis_x = col1 - x2
distance = np.power(np.power(dis_y,2) + np.power(dis_x,2), 0.5)
distance[distance<1] = 10000000.
sin_ang = dis_x / distance
cos_ang = -1 * dis_y / distance
distance = distance * grid_size
dis_model_v_batch[ni] = np.sum(const_v * (1 / distance) * ice_model_data)
dis_model_e_batch[ni] = np.sum(const_r * (1 /distance) * ice_model_data * sin_ang)
dis_model_e_batch[ni] = np.sum(const_r * (1 /distance) * ice_model_data * cos_ang)
dis_model_v_batch = comm.gather(dis_model_v_batch, root=0)
dis_model_e_batch = comm.gather(dis_model_e_batch, root=0)
dis_model_n_batch = comm.gather(dis_model_n_batch, root=0)
if rank == 0:
dis_model_v = dis_model_v_batch[0]
dis_model_e = dis_model_e_batch[0]
dis_model_n = dis_model_n_batch[0]
for ni in range(size-1):
dis_model_v = np.hstack((dis_model_v, dis_model_v_batch[ni+1]))
dis_model_e = np.hstack((dis_model_e, dis_model_e_batch[ni+1]))
dis_model_n = np.hstack((dis_model_n, dis_model_n_batch[ni+1]))
dis_model_los = dis_model_v * np.cos(angle_inc/180*np.pi) - \
dis_model_e * np.sin(angle_inc/180*np.pi) * np.cos(angle_az/180*np.pi) + \
dis_model_n * np.sin(angle_inc/180*np.pi) * np.sin(angle_az/180*np.pi)
dis_model_los.astype('float32').tofile('elastic_half_space_load_los_model')
import os
import re
import sys
import Rsmas_Utilib as ut
import glob
import subprocess
if len(sys.argv) != 2:
print '''
Usage: sparse_snaphu.py *.template
template must include path to interferogram
'''
exit(0)
para_list = ut.readProc(sys.argv[1])
int_str = para_list.get("unwrap_str")
#snaphu_def = os.getenv("INT_SCR").strip() + "/snaphu.default"
#para_snaphu1 = ut.readProc(snaphu_def)
if not para_list.get("method"):
method = "RSMAS"
else:
method = para_list.get("method").strip()
if method == "RSMAS":
processdir = os.getenv("PROCESSDIR")
#WDIR = processdir
processdir = processdir + "/" + sys.argv[1].partition('.')[0].strip()
folder_list = glob.glob(processdir + "/PO*")
elif method == "NSBAS":
processdir = para_list.get("processdir").strip()
#WDIR = processdir
def main():
para_list = ut.readProc(sys.argv[1])
interf_folder = para_list.get("interf").strip()
pattern = para_list.get("pattern").strip()
maskfile = para_list.get("mask").strip()
th_d = para_list.get("th_d")
if isinstance(th_d, str):
th_d = [th_d]
for ni in range(len(th_d)):
th_d[ni] = th_d[ni].strip()
th_c = para_list.get("th_c").strip()
iteration = len(th_d)
method = para_list.get("method").strip()
solution = para_list.get("solution").strip()
plane_type = para_list.get("plane_type").strip()
APS_type = para_list.get("APS_type").strip()
demfile = para_list.get("dem").strip()
step = para_list.get("step")
if isinstance(step, str):
step = [step]
for ni in range(len(step)):
step[ni] = step[ni].strip()
if para_list.get("software") == "RSMAS":
int_list = glob.glob(interf_folder + "/PO*")
else:
int_list = glob.glob(interf_folder + "/int_*")
N_line = 0
for f in int_list:
print "f is: ", f, "\n"
intfile = glob.glob(f + "/*" + pattern)[0]
intfile_rsc = intfile + ".rsc"
para_list1 = ut.readRsc(intfile_rsc)
temp_line = int(para_list1.get("FILE_LENGTH").strip())
if N_line < temp_line:
N_line = temp_line
print "maskfile is: ", bool(maskfile == '1'), "\n"
if maskfile == '1':
print "The maximum line is: ", N_line, "\n"
else:
Joblist = interf_folder + "/run_remove_ramp_aps"
for ni in range(iteration):
if ni < 2:
method = "0"
else:
method = "1"
k = 1
IN = open(Joblist, 'w')
for f in int_list:
intfile = glob.glob(f + "/*" + pattern)[0]
corfile = intfile[:-3] + "cor"
if ni > 5:
APS_type == "2"
if ni % 2 == 0:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + plane_type + " " + "0" + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(ni+1) + " " + step[ni]
else:
temp_str = "/nethome/wlzhao/python_code/remove_aps_wrap.py " + intfile + " " + corfile + " " + maskfile + " " + demfile + \
" " + "0" + " " + APS_type + " " + th_d[ni] + " " + th_c + " " + method + " " + \
solution + " " + str(2) + " " + step[ni]
IN.write(temp_str)
if k < len(int_list):
IN.write("\n")
k = k + 1
IN.close()
WT = "0:30"
temp_str = os.getenv("INT_SCR").strip(
) + "/createBatch_8.pl --workdir " + interf_folder + " --infile " + Joblist + " walltime=" + WT
temp_list = [
os.getenv("INT_SCR").strip() + "/createBatch_8.pl",
"--workdir", interf_folder, "--infile", Joblist,
"walltime=" + WT
]
sys.stderr.write(temp_str + "\n")
output = subprocess.Popen(temp_list).wait()
if output == 0:
print "Iteration ", str(ni + 1), " has been done!\n"
else:
print "There is error happened. Check code again!\n"
exit(1)
print "All the jobs are done! Good luck!\n"
exit(0)
import os
import re
import sys
import Rsmas_Utilib as ut
import glob
import subprocess
if len(sys.argv) != 2:
print '''
Usage: sparse_snaphu.py *.template
template must include path to interferogram
'''
exit(0)
para_list = ut.readProc(sys.argv[1])
int_str = para_list.get("unwrap_str")
#snaphu_def = os.getenv("INT_SCR").strip() + "/snaphu.default"
#para_snaphu1 = ut.readProc(snaphu_def)
if not para_list.get("method"):
method = "RSMAS"
else:
method = para_list.get("method").strip()
if method == "RSMAS":
processdir = os.getenv("PROCESSDIR")
#WDIR = processdir
processdir = processdir + "/" + sys.argv[1].partition('.')[0].strip()
folder_list = glob.glob(processdir+"/PO*")
elif method == "NSBAS":
processdir = para_list.get("processdir").strip()
#WDIR = processdir
import glob
if len(sys.argv) != 2:
print '''
Usage: sparse_snaphu.py int_folder
template must include path to interferogram
'''
exit(0)
int_folder = sys.argv[1].strip()
os.system("cd " + int_folder)
procfile = int_folder + "/sparse_para"
procfile1 = int_folder + "/snaphu_para"
para_list = ut.readProc(procfile)
para_list1 = ut.readProc(procfile1)
if para_list.get("interferogram"):
intfile = para_list.get("interferogram").strip()
else:
print "Must have path to interferogram!\n"
exit(0)
if para_list.get("coherence"):
corfile = para_list.get("coherence").strip()
else:
print "Must have path to coherence!\n"
exit(0)
def main():
global th_d, l_M, w_M, method, line1, col1, step
intfile = sys.argv[1].strip()
corfile = sys.argv[2].strip()
maskfile = sys.argv[3].strip()
demfile = sys.argv[4].strip()
plane_type = int(sys.argv[5].strip())
APS_type = int(sys.argv[6].strip())
th_d = float(sys.argv[7].strip())
th_c = float(sys.argv[8].strip())
method = int(sys.argv[9].strip())
solution = int(sys.argv[10].strip())
iteration = int(sys.argv[11].strip())
step = int(sys.argv[12].strip())
print "All the parameters obtained!\n"
print "Iteration is: ", str(iteration),"\n"
### read in mask file
print "Reading maskfile\n"
[phase_M, rscContent_M,l_M,w_M] = ut.read_float(maskfile)
### read in intfile corfile and demfile
print "Reading interferogram and coherence!\n"
print "intfile is: ", intfile
N_looks = re.findall('\d+rlks',intfile)[0].strip()
if len(N_looks) == 5:
newName = intfile[:-9] + "ramp_aps_" + intfile[-9:]
elif len(N_looks) == 6:
newName = intfile[:-10] + "ramp_aps_" + intfile[-10:]
if iteration != 1:
intfile = newName
[amplitude_int, phase_int, rscContent_int,l_int_temp,w_int] = ut.readInt(intfile)
if l_M>l_int_temp:
temp_array = np.zeros((l_M-l_int_temp,w_M),dtype=np.float)
phase_int = np.vstack((phase_int,temp_array))
print "Coherence file is: ", corfile, "\n"
[amplitude_cor, phase_cor, rscContent_cor,l_cor,w_cor] = ut.read_bifloat(corfile)
print "Coherence size is: ", phase_cor.shape, "\n"
if l_M>l_cor:
temp_array = np.zeros((l_M-l_cor,w_M),dtype=np.float)
phase_cor = np.vstack((phase_cor,temp_array))
if l_M<l_cor:
phase_cor = phase_cor[:l_M,:]
#[phase_dem, rscContent_dem,l_dem,w_dem] = ut.read_float(demfile)
[phase_dem, rscContent_dem,l_dem,w_dem] = ut.readDEM(demfile)
if l_M>l_dem:
temp_array = np.zeros((l_M-l_dem,w_M),dtype=np.float)
phase_dem = np.vstack((phase_dem,temp_array))
phase_temp = np.copy(phase_int)
folder = os.path.dirname(intfile)
os.chdir(folder)
temp_dir = os.getcwd()
print "Current dir is: ", temp_dir,"\n"
temp_rsc = "temp.int.rsc"
rscContent_int["FILE_LENGTH"] = str(l_M)
IN = open(temp_rsc, 'w')
for k,v in rscContent_int.iteritems():
IN.write(k.ljust(41)+v+"\n")
IN.close()
temp_list = ["cp","-f",intfile+".rsc", "temp.int.rsc"]
print temp_list, "\n"
output = subprocess.Popen(temp_list).wait()
temp_list = ["SWfilter_casc",intfile,corfile,"temp.int",str(w_M),str(l_int_temp),"0.01"]
print temp_list, "\n"
output = subprocess.Popen(temp_list).wait()
if output == 0:
print "success!\n"
else:
print "failed!\n"
exit(0)
intfile = "temp.int"
[amplitude_int, phase_int, rscContent_int,l_int,w_int] = ut.readInt(intfile)
if l_M>l_int:
temp_array = np.zeros((l_M-l_int,w_M),dtype=np.float)
phase_int = np.vstack((phase_int,temp_array))
if l_M<l_int:
phase_int = phase_int[:l_M,:]
### mask phase and reshape files
inData = np.copy(phase_int)
phase_int = None
inData[np.isnan(phase_M)] = np.nan
inData[phase_cor<th_c] = np.nan
inData[inData==0] = np.nan
inData = inData.reshape(l_M,w_M)
#phase_cor = None
phase_dem = phase_dem.reshape(l_M,w_M)
### differentiation in range and azimuth
line1 = l_M - step
col1 = w_M - step
temp_x = np.linspace(0, w_M, w_M)
temp_y = np.linspace(0, l_M, l_M)
ran, azi = np.meshgrid(temp_x,temp_y)
data1 = inData[:,step:] - inData[:,:(-1*step)]
data11 = data1[:,step:] - data1[:,:(-1*step)]
data2 = inData[step:,:] - inData[:(-1*step),:]
data_r = np.vstack((data1.reshape(l_M*col1,1),data2.reshape(line1*w_M,1)))
data_r[np.abs(data_r)>th_d] = np.nan
length_r = data_r.size
ran1 = ran[:,step:] - ran[:,:(-1*step)]
ran2 = ran[step:,:] - ran[:(-1*step),:]
range_t = ran.reshape(l_M*w_M,1)
azi1 = azi[:,step:] - azi[:,:(-1*step)]
azi2 = azi[step:,:] - azi[:(-1*step),:]
azimuth_t = azi.reshape(l_M*w_M,1)
azi2_sum = azi[step:,:] + azi[:(-1*step),:]
phase_dem = phase_dem.astype('float')
phase_dem[np.abs(phase_dem)>10000] = np.nan
phase_dem[np.abs(phase_dem)<0.001] = np.nan
dem1 = phase_dem[:,step:] - phase_dem[:,:(-1*step)]
dem1[np.abs(dem1)>800] = np.nan
#dem11 = dem1[:,step1:] - dem1[:,:(-1*step1)]
#dem11[np.abs(dem11)>800] = np.nan
#data11[np.isnan(dem11)] = np.nan
#data11[np.abs(data11)>th_d] = np.nan
#temp = data11 / dem11
#temp[np.isinf(temp)] = np.nan
#temp[np.abs(temp)>0.1] = np.nan
#rate2 = np.mean(temp[~np.isnan(temp)])
#data11 = None
#dem11 = None
#temp = None
dem2 = phase_dem[step:,:] - phase_dem[:(-1*step),:]
dem2[np.abs(dem2)>800] = np.nan
height = phase_dem.reshape(l_M*w_M,1)
dem1_sum = phase_dem[:,step:] + phase_dem[:,:(-1*step)]
dem2_sum = phase_dem[step:,:] + phase_dem[:(-1*step),:];
dem_r = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
mask1 = np.ones((length_r,1))
mask1[np.isnan(data_r)] = np.nan
mask1[np.isnan(dem_r)] = np.nan
data_r[np.isnan(mask1)] = np.nan
#### initial original design matrix
if plane_type == 1:
POINTS_ori = np.copy(range_t)
if APS_type == 1:
POINTS_ori = np.hstack((POINTS_ori,height))
elif APS_type == 2:
POINTS_ori = np.hstack((POINTS_ori,height))
POINTS_ori = np.hstack((POINTS_ori,np.power(height,2)))
elif plane_type == 2:
POINTS_ori = np.copy(range_t)
POINTS_ori = np.hstack((POINTS_ori,azimuth_t))
if APS_type == 1:
POINTS_ori = np.hstack((POINTS_ori,height))
elif APS_type == 2:
POINTS_ori = np.hstack((POINTS_ori,height))
POINTS_ori = np.hstack((POINTS_ori,np.power(height,2)))
elif plane_type == 3:
POINTS_ori = np.copy(range_t)
POINTS_ori = np.hstack((POINTS_ori,azimuth_t))
POINTS_ori = np.hstack((POINTS_ori,np.power(azimuth_t,2)))
if APS_type == 1:
POINTS_ori = np.hstack((POINTS_ori,height))
elif APS_type == 2:
POINTS_ori = np.hstack((POINTS_ori,height))
POINTS_ori = np.hstack((POINTS_ori,np.power(height,2)))
else:
if APS_type == 1:
POINTS_ori = np.copy(height)
elif APS_type == 2:
POINTS_ori = np.copy(height)
POINTS_ori = np.hstack((POINTS_ori,np.power(height,2)))
azimuth_t = None
range_t = None
ran = None
azi = None
height = None
### initial design matrix
if solution == 1:
if plane_type == 1:
POINTS = ran1.reshape((l_M*col1,1))
data_r_temp = np.copy(data_r_temp[:ran1.size])
mask1_temp = np.copy(mask1[:ran1.size])
if APS_type == 1:
POINTS = np.hstack((POINTS,dem1.reshape(l_M*col1,1)))
elif APS_type == 2:
POINTS = np.hstack((POINTS,dem1.reshape(l_M*col1,1)))
POINTS = np.stack((POINTS,(dem1*dem1_sum).reshape(l_M*col1,1)))
plane,APS,par = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,solution)
elif plane_type == 2:
POINTS = np.copy(ran1.reshape((l_M*col1,1)))
data_r_temp = np.copy(data_r[:ran1.size])
mask1_temp = np.copy(mask1[:ran1.size])
if APS_type == 1:
POINTS = np.hstack((POINTS,dem1.reshape(l_M*col1,1)))
elif APS_type == 2:
POINTS = np.hstack((POINTS,dem1.reshape(l_M*col1,1)))
POINTS = np.hstack((POINTS,(dem1*dem1_sum).reshape(l_M*col1,1)))
if POINTS[0,:].size > 2:
plane1,APS,par1 = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
else:
if method == 0:
par1 = np.mean(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
else:
par1 = np.median(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
plane1 = POINTS_ori[:,0] * par1
APS = np.array([])
if POINTS[0,:].size > 2:
APS = APS.reshape(l_M,w_l)
TT2 = APS[step:,:] - APS[:(-1*step),:]
data_r_temp = data_r[ran1.size:] - TT2.reshape(line1*w_M,1)
data_r_temp[np.abs(data_r_temp)>th_d] = np.nan
if method == 0:
par2 = np.mean(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
else:
par2 = np.median(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
plane2 = POINTS_ori[:,1] * par2
par = np.array([[par1[0]],[par2],[par1[1:]]])
else:
data_r_temp = np.copy(data_r[ran1.size:])
if method == 0:
par2 = np.mean(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
else:
par2 = np.median(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
plane2 = POINTS_ori[:,1] * par2
par = np.array([[par1],[par2]])
plane = (plane1 + plane2).reshape(l_M,w_M)
elif plane_type == 3:
POINTS = np.copy(ran1.reshape(l_M*col1,1))
data_r_temp = np.copy(data_r)
data_r_temp = np.copy(data_r_temp[:ran1.size])
mask1_temp = np.copy(mask1[:ran1.size])
if APS_type == 1:
POINTS = np.hstack((POINTS,dem1.reshape(l_M,col1)))
elif APS_type == 2:
POINTS = np.hstack((POINTS,dem1.reshape(l_M,col1)))
POINTS = np.hstack((POINTS,(dem1*dem1_sum).reshape(l_M,col1)))
plane_type = 4
plane1,APS1,par1 = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
POINTS = np.copy(azi2.reshape(line1*w_M,1))
POINTS = np.hstack((POINTS,(azi2*azi2_sum).reshape(line1*w_M,1)))
data_r_temp = np.copy(data_r[ran1.size:])
mask1_temp = np.copy(mask1[ran1.size:])
if APS_type == 1:
POINTS = np.hstack((POINTS,dem2.reshape(line1*w_M,1)))
elif APS_type == 2:
POINTS = np.hstack((POINTS,dem2.reshape(line1*w_M,1)))
POINTS = np.hstack((POINTS,(dem2*dem2_sum).reshape(line1*w_M,1)))
plane2,APS2,par2 = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
if APS_type == 1:
par = np.array([[par1[0]],[par2[0]],[par2[1]],[(par1[1]+par2[2])/2]])
plane = (plane1 + plane2).reshape(l_M,w_M)
APS = ((APS1 + APS2) / 2).reshape(l_M,w_M)
elif APS_type == 2:
par = np.array([[par1[0]],[par2[0] ],[par2[1]],[(par1[1]+par2[2])/2],[(par1[2]+par2[3])/2]])
plane = (plane1 + plane2).reshape(l_M,w_M)
APS = ((APS1 + APS2) / 2).reshape(l_M,w_M)
else:
par = np.array([[par1],[par2]])
plane = (plane1 + plane2).reshape(l_M,w_M)
APS = np.array([])
elif solution == 2:
if plane_type == 1:
data_r_temp = np.copy(data_r)
mask1_temp = np.copy(mask1)
if APS_type == 1:
POINTS = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
elif APS_type == 2:
POINTS = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
POINTS = np.hstack((POINTS,np.vstack(((dem1*dem1_sum).reshape(l_M*col1,1),(dem2*dem2_sum).reshape(line1*w_M,1)))))
if APS_type > 0:
plane,APS,par = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
plane = plane.reshape(l_M,w_M)
else:
if method == 0:
par = np.mean(data_r[:ran1.size]/step)
plane = POINTS_ori[:,0] * par
APS = np.array([])
else:
par = np.median(data_r[:ran1.size]/step)
plane = (POINTS_ori[:,0] * par).reshape(l_M,w_M)
APS = np.array([])
elif plane_type == 2:
data_r_temp = np.copy(data_r)
mask1_temp = np.copy(mask1)
if APS_type == 1:
POINTS = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
elif APS_type == 2:
POINTS = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
POINTS = np.hstack((POINTS,np.vstack(((dem1*dem1_sum).reshape(l_M*col1,1),(dem2*dem2_sum).reshape(line1*w_M,1)))))
if APS_type > 0:
print "size of POINTS: ", POINTS.size, ",data", data_r_temp.size,",mask", mask1_temp.size, ",plane_type",plane_type,",APS_type",APS_type,",solution",solution,"\n"
plane1,APS,par1 = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
else:
data_r_temp = data_r_temp[:ran1.size]
if method == 0:
par1 = np.mean(data_r_temp[~np.isnan(data_r_temp)]/step)
else:
par1 = np.median(data_r_temp[~np.isnan(data_r_temp)]/step)
print "par1 is: ", par1, "\n"
plane1 = POINTS_ori[:,0] * par1
APS = np.array([])
if APS_type > 0:
APS = APS.reshape(l_M,w_M)
TT2 = APS[step:,:] - APS[:(-1*step),:]
data_r_temp = data_r[ran1.size:] - TT2.reshape(line1*w_M,1)
data_r_temp[np.abs(data_r_temp)>th_d] = np.nan
if method == 0:
par2 = np.mean(data_r_temp[~np.isnan(data_r_temp)]/step)
else:
par2 = np.median(data_r_temp[~np.isnan(data_r_temp)]/step)
plane2 = POINTS_ori[:,1] * par2
print "term1 is: ", par1[0],", term2 is: ", par2, ", term3 is: ", par1[1:],"\n"
par = np.array([[par1[0]],[par2],[par1[1:]]])
else:
data_r_temp = np.copy(data_r[ran1.size:])
if method == 0:
par2 = np.mean(data_r_temp[~np.isnan(data_r_temp)]/step)
else:
par2 = np.median(data_r_temp[~np.isnan(data_r_temp)]/step)
print "par2 is: ", par2,"\n"
plane2 = POINTS_ori[:,1] * par2
par = np.array([[par1],[par2]])
plane = plane1 + plane2
elif plane_type == 3:
data_r_temp = np.copy(data_r)
mask1_temp = np.copy(mask1)
if APS_type == 1:
POINTS = np.copy(dem1.reshape(l_M,col1))
elif APS_type == 2:
POINTS = np.copy(dem1.reshape(l_M,col1))
POINTS = np.hstack((POINTS,(dem1*dem1_sum).reshape(l_M,col1)))
if APS_type > 0:
plane1,APS,par1 = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
APS = APS.reshape(l_M,w_M)
TT2 = APS[1:,:] - APS[0:-1,:]
data_r_temp = np.copy(data_r[ran1.size:])
POINTS = (azi2*azi2_sum).reshape(line1*w_M,1)
APS_type = 0
plane2,APS2,par2 = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
par = np.array[[par1[0]],[par2],[par1[1]]]
else:
data_r_temp = np.copy(data_r[:ran1.size])
if method == 0:
par1 = np.mean(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
else:
par1 = np.median(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
plane1 = POINTS_ori[:,0] * par1
APS = np.array([])
data_r_temp = np.copy(data_r[ran1.size:])
if method == 0:
par2 = np.mean(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
else:
par2 = np.median(data_r_temp[np.invert(np.isnan(data_r_temp))]/step)
plane2 = POINTS_ori[:,0] * par2
par = np.array[[par1],[par2]]
plane = (plane1 + plane2).reshape(l_M,w_M)
elif plane_type == 0:
data_r_temp = np.copy(data_r)
mask1_temp = np.copy(mask1)
if APS_type == 1:
POINTS = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
elif APS_type == 2:
POINTS = np.vstack((dem1.reshape(l_M*col1,1),dem2.reshape(line1*w_M,1)))
POINTS = np.hstack((POINTS,np.vstack(((dem1*dem1_sum).reshape(l_M*col1,1),(dem2*dem2_sum).reshape(line1*w_M,1)))))
plane,APS,par = inverse_mat(POINTS,data_r_temp,mask1_temp,POINTS_ori,plane_type,APS_type,solution)
##### finalize the results
TT = np.zeros((l_M,w_M))
if plane.size:
plane = plane.reshape(l_M,w_M)
TT = TT + plane
if APS.size:
APS = APS.reshape(l_M,w_M)
TT = TT + APS
ramp_file = "temp_ramp"+N_looks+".unw"
if os.path.isfile(ramp_file):
[amplitude_ramp, phase_ramp, rscContent_ramp,l_ramp,w_ramp] = ut.read_bifloat(ramp_file)
phase_ramp = phase_ramp + TT[:l_int_temp,:]
temp_array = np.zeros((l_ramp*2,w_ramp),dtype=np.float32)
temp_array[::2] = amplitude_ramp
temp_array[1::2] = phase_ramp
temp_array.astype('float32').tofile(ramp_file)
temp_array = None
else:
amplitude_ramp = amplitude_int
phase_ramp = np.copy(TT[:l_int_temp,:])
temp_array = np.zeros((l_int_temp*2,w_int),dtype=np.float32)
temp_array[::2] = amplitude_ramp
temp_array[1::2] = phase_ramp
temp_array.astype('float32').tofile(ramp_file)
temp_array = None
TT = np.fmod(TT,2*np.pi)
TT[TT<(-1*np.pi)] = TT[TT<(-1*np.pi)] + np.pi*2
TT[TT>np.pi] = TT[TT>np.pi] - np.pi*2
phase_temp[np.where(phase_temp==0)] = np.nan
phase = np.fmod(phase_temp-TT,2*np.pi)
phase[phase<(-1*np.pi)] = phase[phase<(-1*np.pi)] + np.pi*2
phase[phase>np.pi] = phase[phase>np.pi] - np.pi*2
phase = phase[:l_int_temp,:]
phase[np.isnan(phase)] = 0
#im = plt.imshow(phase,cmap=plt.cm.jet, vmin=-3.14, vmax=3.14)
#plt.show()
if l_M>l_int_temp:
phase_cor = phase_cor[:l_int_temp,:]
temp_array = np.zeros((l_int_temp*2,w_int))
temp_array[::2,:] = amplitude_int
print "Size of phase_cor is: ", phase_cor.shape, ", Size of temp_array is: ", temp_array.shape, "\n"
temp_array[1::2,:] = np.copy(phase_cor[:l_int_temp,:])
rscContent_cor["FILE_LENGTH"] = str(l_int_temp)
corfile_rsc = corfile + ".rsc"
os.system("rm -f "+corfile_rsc)
IN = open(corfile_rsc, 'w')
for k,v in rscContent_cor.iteritems():
IN.write(k.ljust(41)+v+"\n")
IN.close()
os.system("rm -f "+corfile)
temp_array.astype('float32').tofile(corfile)
elif l_M<l_int_temp:
temp = np.zeros((l_int_temp-l_M,w_int),np.float32)
phase_cor = np.vstack((phase_cor,temp))
temp_array = np.zeros((l_int_temp*2,w_int))
temp_array[::2,:] = amplitude_int
print "Size of phase_cor is: ", phase_cor.shape, ", Size of temp_array is: ", temp_array.shape, "\n"
temp_array[1::2,:] = np.copy(phase_cor[:l_int_temp,:])
rscContent_cor["FILE_LENGTH"] = str(l_int_temp)
corfile_rsc = corfile + ".rsc"
os.system("rm -f "+corfile_rsc)
IN = open(corfile_rsc, 'w')
for k,v in rscContent_cor.iteritems():
IN.write(k.ljust(41)+v+"\n")
IN.close()
os.system("rm -f "+corfile)
temp_array.astype('float32').tofile(corfile)
temp_array = amplitude_int * np.exp(1j*phase)
print "newName is: ", newName, "\n"
temp_array.astype('complex64').tofile(newName)
newName_rsc = newName + ".rsc"
intfile_rsc = intfile + ".rsc"
ramp_file_rsc = ramp_file + ".rsc"
os.system("cp -f "+intfile_rsc+" "+newName_rsc)
os.system("cp -f "+intfile_rsc+" "+ramp_file_rsc)
temp_dir = os.getcwd()
print "Current dir is: ", temp_dir,"\n"
temp_str = "rm -f temp.int*"
print temp_str,"\n"
os.system(temp_str)
'''
Created on Sun Aug 17 18:14:13 2014
code used for layered elastic model of surface loading
Wenliang Zhao
'''
import os,sys,re,glob,subprocess,math,time
import Rsmas_Utilib as ut
import ElasticSAR as es
import numpy as np
from osgeo import gdal
import time
para_list = ut.readProc(sys.argv[1])
processdir = para_list.get("processdir").strip()
disp_dir = processdir + "/InSAR"
line_insar = int(para_list.get("line_insar").strip())
col_insar = int(para_list.get("col_insar").strip())
left_lon_insar = float(para_list.get("left_lon_insar").strip())
top_lat_insar = float(para_list.get("top_lat_insar").strip())
res_lon_insar = float(para_list.get("res_lon_insar").strip())
res_lat_insar = float(para_list.get("res_lat_insar").strip())
lookAng_insar = float(para_list.get("lookAng").strip())
azimuth_insar = float(para_list.get("azimuth").strip())
utmZone = para_list.get("utmZone").strip()
res_x_utm = int(para_list.get("spacing").strip())
res_y_utm = res_x_utm
box = para_list.get("box")
method = para_list.get("method").strip()
