def get_los_geometry(self, geom_obj, print_msg=False):
lat, lon = self.get_stat_lat_lon(print_msg=print_msg)
# get LOS geometry
if isinstance(geom_obj, str):
# geometry file
atr = readfile.read_attribute(geom_obj)
coord = ut.coordinate(atr, lookup_file=geom_obj)
y, x = coord.geo2radar(lat, lon, print_msg=print_msg)[0:2]
box = (x, y, x + 1, y + 1)
inc_angle = readfile.read(geom_obj,
datasetName='incidenceAngle',
box=box,
print_msg=print_msg)[0][0, 0]
az_angle = readfile.read(geom_obj,
datasetName='azimuthAngle',
box=box,
print_msg=print_msg)[0][0, 0]
head_angle = ut.azimuth2heading_angle(az_angle)
elif isinstance(geom_obj, dict):
# use mean inc/head_angle from metadata
inc_angle = ut.incidence_angle(geom_obj,
dimension=0,
print_msg=print_msg)
head_angle = float(geom_obj['HEADING'])
# for old reading of los.rdr band2 data into headingAngle directly
if (head_angle + 180.) > 45.:
head_angle = ut.azimuth2heading_angle(head_angle)
else:
raise ValueError(
'input geom_obj is neight str nor dict: {}'.format(geom_obj))
return inc_angle, head_angle
def LOS_calculation(azi_angle,inc_angle,simulation,NotNan):
"""calcualte simulated LOS deformation"""
# azi and inc are n*1 np.array
#read output file
inc = copy.deepcopy(inc_angle)
east_disp = simulation[:,3][NotNan]
north_disp = simulation[:,2][NotNan]
up_disp = -simulation[:,4][NotNan]
# calculate LOS
#Project displacement from LOS to Horizontal and Vertical components
# math for 3D: cos(theta)*Uz - cos(alpha)*sin(theta)*Ux + sin(alpha)*sin(theta)*Uy = Ulos
# math for 2D: cos(theta)*Uv - sin(alpha-az)*sin(theta)*Uh = Ulos #Uh_perp = 0.0
inc *= np.pi/180.
# heading angle
head_angle = ut.azimuth2heading_angle(azi_angle)
#if head_angle < 0.:
# head_angle += 360.
head_angle[head_angle<0.]+= 360.
head_angle *= np.pi/180.
# construct design matrix
A_up = np.cos(inc)
A_east = - np.sin(inc) * np.cos(head_angle)
A_north = np.sin(inc) * np.sin(head_angle)
# LOS simulated results. Note:the unit of RELAX displacement is meter.
los_sim = up_disp * A_up + north_disp * A_north + east_disp * A_east
return los_sim
def get_los_geometry(self, insar_obj, print_msg=False):
lat, lon = self.get_stat_lat_lon(print_msg=print_msg)
# get LOS geometry
if isinstance(insar_obj, str):
# geometry file
atr = readfile.read_attribute(insar_obj)
coord = ut.coordinate(atr, lookup_file=insar_obj)
y, x = coord.geo2radar(lat, lon, print_msg=print_msg)[0:2]
box = (x, y, x+1, y+1)
inc_angle = readfile.read(insar_obj, datasetName='incidenceAngle', box=box, print_msg=print_msg)[0][0,0]
az_angle = readfile.read(insar_obj, datasetName='azimuthAngle', box=box, print_msg=print_msg)[0][0,0]
head_angle = ut.azimuth2heading_angle(az_angle)
elif isinstance(insar_obj, dict):
# use mean inc/head_angle from metadata
inc_angle = ut.incidence_angle(insar_obj, dimension=0, print_msg=print_msg)
head_angle = float(insar_obj['HEADING'])
# for old reading of los.rdr band2 data into headingAngle directly
if (head_angle + 180.) > 45.:
head_angle = ut.azimuth2heading_angle(head_angle)
else:
raise ValueError('input insar_obj is neight str nor dict: {}'.format(insar_obj))
return inc_angle, head_angle
def prepare_los_geometry(geom_file):
"""Prepare LOS geometry data/info in geo-coordinates
Parameters: geom_file - str, path of geometry file
Returns: inc_angle - 2D np.ndarray, incidence angle in radians
head_angle - 2D np.ndarray, heading angle in radians
atr - dict, metadata in geo-coordinate
"""
print('read/prepare LOS geometry from file: {}'.format(geom_file))
atr = readfile.read_attribute(geom_file)
print('read incidence / azimuth angle')
inc_angle = readfile.read(geom_file, datasetName='incidenceAngle')[0]
az_angle = readfile.read(geom_file, datasetName='azimuthAngle')[0]
# geocode inc/az angle data if in radar-coord
if 'Y_FIRST' not in atr.keys():
print('-' * 50)
print('geocoding the incidence / azimuth angle ...')
res_obj = resample(lut_file=geom_file, src_file=geom_file)
res_obj.open()
res_obj.prepare()
# resample data
box = res_obj.src_box_list[0]
inc_angle = res_obj.run_resample(src_data=inc_angle[box[1]:box[3],
box[0]:box[2]])
az_angle = res_obj.run_resample(src_data=az_angle[box[1]:box[3],
box[0]:box[2]])
# update attribute
atr = attr.update_attribute4radar2geo(atr, res_obj=res_obj)
# azimuth angle --> heading angle
head_angle = ut.azimuth2heading_angle(az_angle)
# unit: degree to radian
inc_angle *= np.pi / 180.
head_angle *= np.pi / 180.
return inc_angle, head_angle, atr
def process_roi_pac(inps):
"""prepare data for kite using roi_pac format and calculate look anlge for 4 corners from incidence angle"""
# geometry data
geometryRadar = inps.geometry[0]
print('processing geometry data {}'.format(geometryRadar))
inc_angle = readfile.read(geometryRadar, datasetName='incidenceAngle')[0]
azi_angle = readfile.read(geometryRadar, datasetName='azimuthAngle')[0]
# heading angle
head_angle = ut.azimuth2heading_angle(azi_angle)
# displacement data
disp = inps.file[0]
print('processing displacement data {}'.format(disp))
disp_data, atr = readfile.read(disp)
# judge the unit of data, if it is not radian, change into radian
if atr['UNIT'] != 'radian':
range2phase = (-4 * np.pi) / float(atr['WAVELENGTH'])
disp_data *= range2phase
# change np.nan to 0
disp_data[np.isnan(disp_data)] = 0
inc_angle[np.isnan(inc_angle)] = 0
head_angle[np.isnan(head_angle)] = 0
# write displacement data as InSAMP required. Because we don't have the amplitude data we use phase as amplitude
outfile_unw = inps.outfile[0] + '.unw'
dsDict = dict()
dsDict['amplitude'] = disp_data
dsDict['phase'] = disp_data
writefile.write(datasetDict=dsDict, out_file=outfile_unw, metadata=atr)
# write angle data as InSAMP required.
outfile_los = inps.outfile[0] + '.los'
los_angle = np.vstack((inc_angle, head_angle)).flatten()
los_angle = np.array(los_angle, dtype=np.float32)
los_angle.tofile(outfile_los)
return
def prepare_los_geometry(geom_file):
"""Prepare LOS geometry data/info in geo-coordinates
Parameters: geom_file - str, path of geometry file
Returns: inc_angle - 2D np.ndarray, incidence angle in radians
head_angle - 2D np.ndarray, heading angle in radians
atr - dict, metadata in geo-coordinate
"""
print('prepare LOS geometry in geo-coordinates from file: {}'.format(
geom_file))
atr = readfile.read_attribute(geom_file)
print('read incidenceAngle from file: {}'.format(geom_file))
inc_angle = readfile.read(geom_file, datasetName='incidenceAngle')[0]
if 'azimuthAngle' in readfile.get_dataset_list(geom_file):
print('read azimuthAngle from file: {}'.format(geom_file))
print('convert azimuth angle to heading angle')
az_angle = readfile.read(geom_file, datasetName='azimuthAngle')[0]
head_angle = ut.azimuth2heading_angle(az_angle)
else:
print('use the HEADING attribute as the mean heading angle')
head_angle = np.ones(inc_angle.shape, dtype=np.float32) * float(
atr['HEADING'])
# geocode inc/az angle data if in radar-coord
if 'Y_FIRST' not in atr.keys():
print('-' * 50)
print('geocoding the incidence / heading angles ...')
res_obj = resample(lut_file=geom_file, src_file=geom_file)
res_obj.open()
res_obj.prepare()
# resample data
box = res_obj.src_box_list[0]
inc_angle = res_obj.run_resample(src_data=inc_angle[box[1]:box[3],
box[0]:box[2]])
head_angle = res_obj.run_resample(src_data=head_angle[box[1]:box[3],
box[0]:box[2]])
# update attribute
atr = attr.update_attribute4radar2geo(atr, res_obj=res_obj)
# for 'Y_FIRST' not in 'degree'
# e.g. meters for UTM projection from ASF HyP3
if not atr['Y_UNIT'].lower().startswith('deg'):
# get SNWE in meter
length, width = int(atr['LENGTH']), int(atr['WIDTH'])
N = float(atr['Y_FIRST'])
W = float(atr['X_FIRST'])
y_step = float(atr['Y_STEP'])
x_step = float(atr['X_STEP'])
S = N + y_step * length
E = W + x_step * width
# SNWE in meter --> degree
lat0, lon0 = ut.to_latlon(atr['OG_FILE_PATH'], W, N)
lat1, lon1 = ut.to_latlon(atr['OG_FILE_PATH'], E, S)
lat_step = (lat1 - lat0) / length
lon_step = (lon1 - lon0) / width
# update Y/X_FIRST/STEP/UNIT
atr['Y_FIRST'] = lat0
atr['X_FIRST'] = lon0
atr['Y_STEP'] = lat_step
atr['X_STEP'] = lon_step
atr['Y_UNIT'] = 'degrees'
atr['X_UNIT'] = 'degrees'
# unit: degree to radian
inc_angle *= np.pi / 180.
head_angle *= np.pi / 180.
return inc_angle, head_angle, atr
def save_kite(inps):
"""save kite"""
# read mintpy data
date1, date2, disp, disp_atr, incidence, azimuth = read_HDFEOS(inps)
# subset data based on bbox
if inps.SNWE:
print('Subset data based on bbox')
lat_user, lon_user, row, sample, rows,samples = extract_data_based_bbox(inps)
disp = disp[row: row+rows, sample: sample+samples]
incidence = incidence[row: row+rows, sample: sample+samples]
azimuth = azimuth[row: row+rows, sample: sample+samples]
# convert to head angle
print('convert azimuth angle to head angle')
head = ut.azimuth2heading_angle(azimuth)
phi = -head + 180
# convert degree to radian
incidence *= np.pi/180
phi *= np.pi/180
sc = Scene()
# flip up-down of displacement and angle matrix
sc.displacement = np.flipud(disp)
sc.theta = np.flipud(incidence)
sc.phi = np.flipud(phi)
# calculate the scene's frame lower left corner, in geographical coordinate
lon_ul = float(disp_atr['X_FIRST'])
lat_ul = float(disp_atr['Y_FIRST'])
lat_step = float(disp_atr['Y_STEP'])
length = int(disp_atr['LENGTH'])
lat_ll = lat_ul + lat_step * length
lon_ll = lon_ul
if inps.SNWE:
lat_ll = lat_user
lon_ll = lon_user
sc.frame.llLat = lat_ll
sc.frame.llLon = lon_ll
# the pixel spacing can be either 'meter' or 'degree'
sc.frame.spacing = disp_atr['X_UNIT'][:-1]
sc.frame.dN = float(disp_atr['Y_STEP']) * (-1)
sc.frame.dE = float(disp_atr['X_STEP'])
# Saving the scene
print('write Kite scene')
if inps.outfile is not None:
kite_outfile = inps.outfile[0]
else:
if inps.velocity:
data_type = 'vel'
else:
data_type = 'dis'
if inps.SNWE is not None:
kite_outfile = inps.input_HDFEOS[0].split('.')[0] + '_' + str(date1) + '_' + str(date2) + '_' + data_type + '_subset'
else:
kite_outfile = inps.input_HDFEOS[0].split('.')[0] + '_' + str(date1) + '_' + str(date2) + '_' + data_type
sc.save(kite_outfile)
def overlap2horz_vert(inps):
"""calculate horizontal and vertical component for overlapping region of two tracks"""
# master data
m_data, m_atr = readfile.read(inps.master[0])
# master geometry data
m_geometry = inps.mgeometry[0]
print('processing master geometry data {}'.format(m_geometry))
m_inc_angle = readfile.read(m_geometry, datasetName='incidenceAngle')[0]
m_azi_angle = readfile.read(m_geometry, datasetName='azimuthAngle')[0]
# heading angle
m_head_angle = ut.azimuth2heading_angle(m_azi_angle)
# slave data
s_data, s_atr = readfile.read(inps.slave[0])
# slave geometry data
s_geometry = inps.sgeometry[0]
print('processing slave geometry data {}'.format(s_geometry))
s_inc_angle = readfile.read(s_geometry, datasetName='incidenceAngle')[0]
s_azi_angle = readfile.read(s_geometry, datasetName='azimuthAngle')[0]
# heading angle
s_head_angle = ut.azimuth2heading_angle(s_azi_angle)
# calculate position of overlapping region
over_lat0, over_lon0, overlay_rows, overlay_colms, m_row0, m_colm0, s_row0, s_colm0 = latlon_overlay(
m_atr, s_atr)
# get master and slave overlay region data
m_data_overlay = m_data[m_row0:m_row0 + overlay_rows,
m_colm0:m_colm0 + overlay_colms]
s_data_overlay = s_data[s_row0:s_row0 + overlay_rows,
s_colm0:s_colm0 + overlay_colms]
m_inc_angle_overlay = m_inc_angle[m_row0:m_row0 + overlay_rows,
m_colm0:m_colm0 + overlay_colms]
m_inc_angle_overlay *= np.pi / 180
s_inc_angle_overlay = s_inc_angle[s_row0:s_row0 + overlay_rows,
s_colm0:s_colm0 + overlay_colms]
s_inc_angle_overlay *= np.pi / 180
# calculate horizontal and vertical component
A_horz_denominator, A_horz_numerator, A_vert_denominator, A_vert_numerator = A_design(
m_inc_angle_overlay, s_inc_angle_overlay)
data_horz = (m_data_overlay -
s_data_overlay * A_horz_numerator) / A_horz_denominator
data_vert = (m_data_overlay -
s_data_overlay * A_vert_numerator) / A_vert_denominator
overlay_atr = dict()
overlay_atr['LENGTH'] = overlay_rows
overlay_atr['WIDTH'] = overlay_colms
overlay_atr['X_FIRST'] = over_lon0
overlay_atr['Y_FIRST'] = over_lat0
overlay_atr['X_UNIT'] = m_atr['X_UNIT']
overlay_atr['Y_UNIT'] = m_atr['Y_UNIT']
overlay_atr['X_STEP'] = m_atr['X_STEP']
overlay_atr['Y_STEP'] = m_atr['Y_STEP']
overlay_atr['FILE_TYPE'] = m_atr['FILE_TYPE']
overlay_atr['UNIT'] = m_atr['UNIT']
overlay_atr['WAVELENGTH'] = m_atr['WAVELENGTH']
# write horzontal and vertical component
horz_name = inps.outfile[0] + '_hz.h5'
writefile.write(data_horz, out_file=horz_name, metadata=overlay_atr)
vert_name = inps.outfile[0] + '_up.h5'
writefile.write(data_vert, out_file=vert_name, metadata=overlay_atr)
return
