def surface_S(self, az_deg=0):
""" This function generates a (short) time series of surface realizations.
:param az_deg: azimuth angle, in degree
:param ntimes: number of time samples generated.
:param t_step: spacing between time samples. This can be interpreted as the Pulse Repetition Interval
:returns: a tuple with the configuration object, the surfaces, the radial velocities for each grid point,
and the complex scattering coefficients
"""
if not self.inc_is_set:
print("Set the incident angle first")
return
cfg = self.cfg
use_hmtf = cfg.srg.use_hmtf
scat_spec_enable = cfg.srg.scat_spec_enable
scat_spec_mode = cfg.srg.scat_spec_mode
scat_bragg_enable = cfg.srg.scat_bragg_enable
scat_bragg_model = cfg.srg.scat_bragg_model
scat_bragg_d = cfg.srg.scat_bragg_d
scat_bragg_spec = cfg.srg.scat_bragg_spec
scat_bragg_spread = cfg.srg.scat_bragg_spread
# SAR
alt = cfg.sar.alt
f0 = cfg.sar.f0
prf = cfg.sar.prf
pol = self.pol
l0 = const.c / f0
k0 = 2. * np.pi * self.f0 / const.c
do_hh = self.do_hh
do_vv = self.do_vv
# OCEAN / OTHERS
ocean_dt = cfg.ocean.dt
# Get a surface realization calculated
# self.surface.t = 0
inc_angle = self.inc_angle
sr0 = geosar.inc_to_sr(inc_angle, alt)
gr0 = geosar.inc_to_gr(inc_angle, alt)
gr = self.surface.x + gr0
sr, inc, _ = geosar.gr_to_geo(gr, alt)
sr -= np.min(sr)
inc = inc.reshape(1, inc.size)
sr = sr.reshape(1, sr.size)
gr = gr.reshape(1, gr.size)
sin_inc = np.sin(inc)
cos_inc = np.cos(inc)
az_rad = np.radians(az_deg)
cos_az = np.cos(az_rad)
sin_az = np.sin(az_rad)
t_last_rcs_bragg = -1.
last_progress = -1
ntimes = self.ntimes
NRCS_avg_vv = np.zeros(ntimes, dtype=np.float)
NRCS_avg_hh = np.zeros(ntimes, dtype=np.float)
# RCS MODELS
# Specular
if scat_spec_enable:
if scat_spec_mode == 'kodis':
rcs_spec = rcs.RCSKodis(inc, k0, self.surface.dx,
self.surface.dy)
elif scat_spec_mode == 'fa' or scat_spec_mode == 'spa':
spec_ph0 = np.random.uniform(
0., 2. * np.pi, size=[self.surface.Ny, self.surface.Nx])
rcs_spec = rcs.RCSKA(scat_spec_mode, k0, self.surface.x,
self.surface.y, self.surface.dx,
self.surface.dy)
else:
raise NotImplementedError(
'RCS mode %s for specular scattering not implemented' %
scat_spec_mode)
# Bragg
if scat_bragg_enable:
phase_bragg = np.zeros([2, self.surface.Ny, self.surface.Nx])
bragg_scats = np.zeros([2, self.surface.Ny, self.surface.Nx],
dtype=np.complex)
tau_c = closure.grid_coherence(cfg.ocean.wind_U, self.surface.dx,
f0)
rndscat_p = closure.randomscat_ts(
tau_c, (self.surface.Ny, self.surface.Nx), prf)
rndscat_m = closure.randomscat_ts(
tau_c, (self.surface.Ny, self.surface.Nx), prf)
# NOTE: This ignores slope, may be changed
k_b = 2. * k0 * sin_inc
c_b = sin_inc * np.sqrt(const.g / k_b + 0.072e-3 * k_b)
surface_area = self.surface.dx * self.surface.dy * self.surface.Nx * self.surface.Ny
if do_hh:
scene_hh = np.zeros([ntimes, self.surface.Ny, self.surface.Nx],
dtype=np.complex)
if do_vv:
scene_vv = np.zeros([ntimes, self.surface.Ny, self.surface.Nx],
dtype=np.complex)
for az_step in range(ntimes):
# AZIMUTH & SURFACE UPDATE
t_now = az_step * self.t_step
## COMPUTE RCS FOR EACH MODEL
# Note: SAR processing is range independent as slant range is fixed
# sin_az = az / sr0
# az_proj_angle = np.arcsin(az / gr0)
# Note: Projected displacements are added to slant range
sr_surface = (
sr - cos_inc * self.dz[az_step] + sin_inc *
(self.dx[az_step] * cos_az + self.dy[az_step] * sin_az))
# Specular
if scat_spec_enable:
if scat_spec_mode == 'kodis':
Esn_sp = np.sqrt(4. * np.pi) * rcs_spec.field(
az_rad, sr_surface, self.diffx[az_step],
self.diffy[az_step], self.diffxx[az_step],
self.diffyy[az_step], self.diffxy[az_step])
if do_hh:
scene_hh[az_step] += Esn_sp
if do_vv:
scene_vv[az_step] += Esn_sp
else:
# FIXME
if do_hh:
pol_tmp = 'hh'
Esn_sp = (
np.exp(-1j * (2. * k0 * sr_surface)) *
(4. * np.pi)**1.5 * rcs_spec.field(
1, 1, pol_tmp[0], pol_tmp[1], inc, inc, az_rad,
az_rad + np.pi, self.dz[az_step],
self.diffx[az_step], self.diffy[az_step],
self.diffxx[az_step], self.diffyy[az_step],
self.diffxy[az_step]))
scene_hh[az_step] += Esn_sp
if do_vv:
pol_tmp = 'vv'
Esn_sp = (
np.exp(-1j * (2. * k0 * sr_surface)) *
(4. * np.pi)**1.5 * rcs_spec.field(
1, 1, pol_tmp[0], pol_tmp[1], inc, inc, az_rad,
az_rad + np.pi, self.dz[az_step],
self.diffx[az_step], self.diffy[az_step],
self.diffxx[az_step], self.diffyy[az_step],
self.diffxy[az_step]))
scene_vv[az_step] += Esn_sp
NRCS_avg_hh[az_step] += (np.sum(np.abs(Esn_sp)**2) /
surface_area)
NRCS_avg_vv[az_step] += NRCS_avg_hh[az_step]
# Bragg
if scat_bragg_enable:
if (t_now - t_last_rcs_bragg) > ocean_dt:
if scat_bragg_model == 'romeiser97':
if pol == 'DP':
RCS_bragg_hh, RCS_bragg_vv = self.rcs_bragg.rcs(
az_rad, self.diffx[az_step],
self.diffy[az_step])
elif pol == 'hh':
RCS_bragg_hh = self.rcs_bragg.rcs(
az_rad, self.diffx[az_step],
self.diffy[az_step])
else:
RCS_bragg_vv = self.rcs_bragg.rcs(
az_rad, self.diffx[az_step],
self.diffy[az_step])
if use_hmtf:
# Fix Bad MTF points
(self.h_mtf[az_step])[np.where(
self.surface.hMTF < -1)] = -1
if do_hh:
RCS_bragg_hh[0] *= (1 + self.h_mtf[az_step])
RCS_bragg_hh[1] *= (1 + self.h_mtf[az_step])
if do_vv:
RCS_bragg_vv[0] *= (1 + self.h_mtf[az_step])
RCS_bragg_vv[1] *= (1 + self.h_mtf[az_step])
t_last_rcs_bragg = t_now
if do_hh:
scat_bragg_hh = np.sqrt(RCS_bragg_hh)
NRCS_bragg_hh_instant_avg = np.sum(
RCS_bragg_hh) / surface_area
NRCS_avg_hh[az_step] += NRCS_bragg_hh_instant_avg
if do_vv:
scat_bragg_vv = np.sqrt(RCS_bragg_vv)
NRCS_bragg_vv_instant_avg = np.sum(
RCS_bragg_vv) / surface_area
NRCS_avg_vv[az_step] += NRCS_bragg_vv_instant_avg
# Doppler phases (Note: Bragg radial velocity taken constant!)
surf_phase = -(2 * k0) * sr_surface
cap_phase = (2 * k0) * self.t_step * c_b * (az_step + 1)
phase_bragg[0] = surf_phase - cap_phase # + dop_phase_p
phase_bragg[1] = surf_phase + cap_phase # + dop_phase_m
bragg_scats[0] = rndscat_m.scats(t_now)
bragg_scats[1] = rndscat_p.scats(t_now)
if do_hh:
scene_hh[az_step] += ne.evaluate(
'sum(scat_bragg_hh * exp(1j*phase_bragg) * bragg_scats, axis=0)'
)
if do_vv:
scene_vv[az_step] += ne.evaluate(
'sum(scat_bragg_vv * exp(1j*phase_bragg) * bragg_scats, axis=0)'
)
v_r = (self.surface.Vx * np.sin(inc) * np.cos(az_rad) +
self.surface.Vy * np.sin(inc) * np.sin(az_rad) -
self.surface.Vz * np.cos(inc))
# Some stats
if do_hh:
w = np.abs(scene_hh[0])**2
v_r_whh = np.sum(v_r * w) / np.sum(w)
# FIXME, for now just one lag
v_ati_hh = -(np.angle(np.mean(scene_hh[1] * np.conj(scene_hh[0])))
/ self.t_step * const.c / 2 / self.f0 / 2 / np.pi)
if do_vv:
w = np.abs(scene_vv[0])**2
v_r_wvv = np.sum(v_r * w) / np.sum(w)
v_ati_vv = -(np.angle(np.mean(scene_vv[1] * np.conj(scene_vv[0])))
/ self.t_step * const.c / 2 / self.f0 / 2 / np.pi)
if do_hh and do_vv:
return {
'v_r': v_r,
'scene_hh': scene_hh,
'scene_vv': scene_vv,
'NRCS_hh': NRCS_avg_hh,
'NRCS_vv': NRCS_avg_vv,
'v_r_whh': v_r_whh,
'v_r_wvv': v_r_wvv,
'v_ATI_hh': v_ati_hh,
'v_ATI_vv': v_ati_vv
}
# return (cfg, self.surface.Dz, v_r, scene_hh, scene_vv)
elif do_hh:
return {
'v_r': v_r,
'scene_hh': scene_hh,
'scene_vv': None,
'NRCS_hh': NRCS_avg_hh,
'NRCS_vv': None,
'v_r_whh': v_r_whh,
'v_r_wvv': None,
'v_ATI_hh': v_ati_hh,
'v_ATI_vv': None
}
# return (cfg, self.surface.Dz, v_r, scene_hh)
else:
return {
'v_r': v_r,
'scene_hh': None,
'scene_vv': scene_vv,
'NRCS_hh': None,
'NRCS_vv': NRCS_avg_vv,
'v_r_whh': None,
'v_r_wvv': v_r_wvv,
'v_ATI_hh': None,
'v_ATI_vv': v_ati_vv
}
def ati_process(cfg_file, proc_output_file, ocean_file, output_file):
print('-------------------------------------------------------------------')
print(time.strftime("- OCEANSAR ATI Processor: [%Y-%m-%d %H:%M:%S]", time.localtime()))
print('-------------------------------------------------------------------')
print('Initializing...')
## CONFIGURATION FILE
cfg = tpio.ConfigFile(cfg_file)
# SAR
inc_angle = np.deg2rad(cfg.sar.inc_angle)
f0 = cfg.sar.f0
prf = cfg.sar.prf
num_ch = cfg.sar.num_ch
ant_L = cfg.sar.ant_L
alt = cfg.sar.alt
v_ground = cfg.sar.v_ground
rg_bw = cfg.sar.rg_bw
over_fs = cfg.sar.over_fs
pol = cfg.sar.pol
if pol == 'DP':
polt = ['hh', 'vv']
elif pol == 'hh':
polt = ['hh']
else:
polt = ['vv']
# ATI
rg_ml = cfg.ati.rg_ml
az_ml = cfg.ati.az_ml
ml_win = cfg.ati.ml_win
plot_save = cfg.ati.plot_save
plot_path = cfg.ati.plot_path
plot_format = cfg.ati.plot_format
plot_tex = cfg.ati.plot_tex
plot_surface = cfg.ati.plot_surface
plot_proc_ampl = cfg.ati.plot_proc_ampl
plot_coh = cfg.ati.plot_coh
plot_coh_all = cfg.ati.plot_coh_all
plot_ati_phase = cfg.ati.plot_ati_phase
plot_ati_phase_all = cfg.ati.plot_ati_phase_all
plot_vel_hist = cfg.ati.plot_vel_hist
plot_vel = cfg.ati.plot_vel
## CALCULATE PARAMETERS
if v_ground == 'auto': v_ground = geosar.orbit_to_vel(alt, ground=True)
k0 = 2.*np.pi*f0/const.c
rg_sampling = rg_bw*over_fs
# PROCESSED RAW DATA
proc_content = tpio.ProcFile(proc_output_file, 'r')
proc_data = proc_content.get('slc*')
proc_content.close()
# OCEAN SURFACE
surface = OceanSurface()
surface.load(ocean_file, compute=['D', 'V'])
surface.t = 0.
# OUTPUT FILE
output = open(output_file, 'w')
# OTHER INITIALIZATIONS
# Enable TeX
if plot_tex:
plt.rc('font', family='serif')
plt.rc('text', usetex=True)
# Create plots directory
plot_path = os.path.dirname(output_file) + os.sep + plot_path
if plot_save:
if not os.path.exists(plot_path):
os.makedirs(plot_path)
# SURFACE VELOCITIES
grg_grid_spacing = (const.c/2./rg_sampling/np.sin(inc_angle))
rg_res_fact = grg_grid_spacing / surface.dx
az_grid_spacing = (v_ground/prf)
az_res_fact = az_grid_spacing / surface.dy
res_fact = np.ceil(np.sqrt(rg_res_fact*az_res_fact))
# SURFACE RADIAL VELOCITY
v_radial_surf = surface.Vx*np.sin(inc_angle) - surface.Vz*np.cos(inc_angle)
v_radial_surf_ml = utils.smooth(utils.smooth(v_radial_surf, res_fact * rg_ml, axis=1), res_fact * az_ml, axis=0)
v_radial_surf_mean = np.mean(v_radial_surf)
v_radial_surf_std = np.std(v_radial_surf)
v_radial_surf_ml_std = np.std(v_radial_surf_ml)
# SURFACE HORIZONTAL VELOCITY
v_horizo_surf = surface.Vx
v_horizo_surf_ml = utils.smooth(utils.smooth(v_horizo_surf, res_fact * rg_ml, axis=1), res_fact * az_ml, axis=0)
v_horizo_surf_mean = np.mean(v_horizo_surf)
v_horizo_surf_std = np.std(v_horizo_surf)
v_horizo_surf_ml_std = np.std(v_horizo_surf_ml)
# Expected mean azimuth shift
sr0 = geosar.inc_to_sr(inc_angle, alt)
avg_az_shift = - v_radial_surf_mean / v_ground * sr0
std_az_shift = v_radial_surf_std / v_ground * sr0
##################
# ATI PROCESSING #
##################
print('Starting ATI processing...')
# Get dimensions & calculate region of interest
rg_span = surface.Lx
az_span = surface.Ly
rg_size = proc_data[0].shape[2]
az_size = proc_data[0].shape[1]
# Note: RG is projected, so plots are Ground Range
rg_min = 0
rg_max = np.int(rg_span/(const.c/2./rg_sampling/np.sin(inc_angle)))
az_min = np.int(az_size/2. + (-az_span/2. + avg_az_shift)/(v_ground/prf))
az_max = np.int(az_size/2. + (az_span/2. + avg_az_shift)/(v_ground/prf))
az_guard = np.int(std_az_shift / (v_ground / prf))
if (az_max - az_min) < (2 * az_guard - 10):
print('Not enough edge-effect free image')
return
# Adaptive coregistration
if cfg.sar.L_total:
ant_L = ant_L/np.float(num_ch)
dist_chan = ant_L/2
else:
if np.float(cfg.sar.Spacing) != 0:
dist_chan = np.float(cfg.sar.Spacing)/2
else:
dist_chan = ant_L/2
# dist_chan = ant_L/num_ch/2.
print('ATI Spacing: %f' % dist_chan)
inter_chan_shift_dist = dist_chan/(v_ground/prf)
# Subsample shift in azimuth
for chind in range(proc_data.shape[0]):
shift_dist = - chind * inter_chan_shift_dist
shift_arr = np.exp(-2j * np.pi * shift_dist *
np.roll(np.arange(az_size) - az_size/2,
int(-az_size / 2)) / az_size)
shift_arr = shift_arr.reshape((1, az_size, 1))
proc_data[chind] = np.fft.ifft(np.fft.fft(proc_data[chind], axis=1) *
shift_arr, axis=1)
# First dimension is number of channels, second is number of pols
ch_dim = proc_data.shape[0:2]
npol = ch_dim[1]
proc_data_rshp = [np.prod(ch_dim), proc_data.shape[2], proc_data.shape[3]]
# Compute extended covariance matrices...
proc_data = proc_data.reshape(proc_data_rshp)
# Intensities
i_all = []
for chind in range(proc_data.shape[0]):
this_i = utils.smooth(utils.smooth(np.abs(proc_data[chind])**2., rg_ml, axis=1, window=ml_win),
az_ml, axis=0, window=ml_win)
i_all.append(this_i[az_min:az_max, rg_min:rg_max])
i_all = np.array(i_all)
# .reshape((ch_dim) + (az_max - az_min, rg_max - rg_min))
interfs = []
cohs = []
tind = 0
coh_lut = np.zeros((proc_data.shape[0], proc_data.shape[0]), dtype=int)
for chind1 in range(proc_data.shape[0]):
for chind2 in range(chind1 + 1, proc_data.shape[0]):
coh_lut[chind1, chind2] = tind
tind = tind + 1
t_interf = utils.smooth(utils.smooth(proc_data[chind2] *
np.conj(proc_data[chind1]),
rg_ml, axis=1, window=ml_win),
az_ml, axis=0, window=ml_win)
interfs.append(t_interf[az_min:az_max, rg_min:rg_max])
cohs.append(t_interf[az_min:az_max, rg_min:rg_max] /
np.sqrt(i_all[chind1] * i_all[chind2]))
print('Generating plots and estimating values...')
# SURFACE HEIGHT
if plot_surface:
plt.figure()
plt.imshow(surface.Dz, cmap="ocean",
extent=[0, surface.Lx, 0, surface.Ly], origin='lower')
plt.title('Surface Height')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
cbar = plt.colorbar()
cbar.ax.set_xlabel('[m]')
if plot_save:
plt.savefig(plot_path + os.sep + 'plot_surface.' + plot_format,
bbox_inches='tight')
plt.close()
else:
plt.show()
# PROCESSED AMPLITUDE
if plot_proc_ampl:
for pind in range(npol):
save_path = (plot_path + os.sep + 'amp_dB_' + polt[pind]+
'.' + plot_format)
plt.figure()
plt.imshow(utils.db(i_all[pind]), aspect='equal',
origin='lower',
vmin=utils.db(np.max(i_all[pind]))-20,
extent=[0., rg_span, 0., az_span], interpolation='nearest',
cmap='viridis')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Amplitude")
plt.colorbar()
plt.savefig(save_path)
save_path = (plot_path + os.sep + 'amp_' + polt[pind]+
'.' + plot_format)
int_img = (i_all[pind])**0.5
vmin = np.mean(int_img) - 3 * np.std(int_img)
vmax = np.mean(int_img) + 3 * np.std(int_img)
plt.figure()
plt.imshow(int_img, aspect='equal',
origin='lower',
vmin=vmin, vmax=vmax,
extent=[0., rg_span, 0., az_span], interpolation='nearest',
cmap='viridis')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Amplitude")
plt.colorbar()
plt.savefig(save_path)
if plot_coh and ch_dim[0] > 1:
for pind in range(npol):
save_path = (plot_path + os.sep + 'ATI_coh_' +
polt[pind] + polt[pind] +
'.' + plot_format)
coh_ind = coh_lut[(pind, pind + npol)]
plt.figure()
plt.imshow(np.abs(cohs[coh_ind]), aspect='equal',
origin='lower',
vmin=0, vmax=1,
extent=[0., rg_span, 0., az_span],
cmap='bone')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("ATI Coherence")
# plt.colorbar()
plt.savefig(save_path)
# ATI PHASE
tau_ati = dist_chan/v_ground
ati_phases = []
# Hack to avoid interferogram computation if there are no interferometric channels
if num_ch > 1:
npol_ = npol
else:
npol_ = 0
for pind in range(npol_):
save_path = (plot_path + os.sep + 'ATI_pha_' +
polt[pind] + polt[pind] +
'.' + plot_format)
coh_ind = coh_lut[(pind, pind + npol)]
ati_phase = uwphase(cohs[coh_ind])
ati_phases.append(ati_phase)
v_radial_est = -ati_phase / tau_ati / (k0 * 2.)
if plot_ati_phase:
phase_mean = np.mean(ati_phase)
phase_std = np.std(ati_phase)
vmin = np.max([-np.abs(phase_mean) - 4*phase_std,
-np.abs(ati_phase).max()])
vmax = np.min([np.abs(phase_mean) + 4*phase_std,
np.abs(ati_phase).max()])
plt.figure()
plt.imshow(ati_phase, aspect='equal',
origin='lower',
vmin=vmin, vmax=vmax,
extent=[0., rg_span, 0., az_span],
cmap='hsv')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("ATI Phase")
plt.colorbar()
plt.savefig(save_path)
save_path = (plot_path + os.sep + 'ATI_rvel_' +
polt[pind] + polt[pind] +
'.' + plot_format)
vmin = -np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std
vmax = np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std
plt.figure()
plt.imshow(v_radial_est, aspect='equal',
origin='lower',
vmin=vmin, vmax=vmax,
extent=[0., rg_span, 0., az_span],
cmap='bwr')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Estimated Radial Velocity " + polt[pind])
plt.colorbar()
plt.savefig(save_path)
if npol_ == 4: # Bypass this for now
# Cross pol interferogram
coh_ind = coh_lut[(0, 1)]
save_path = (plot_path + os.sep + 'POL_coh_' +
polt[0] + polt[1] +
'.' + plot_format)
utils.image(np.abs(cohs[coh_ind]), max=1, min=0, aspect='equal',
cmap='gray', extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]', ylabel='Azimuth [m]',
title='XPOL Coherence',
usetex=plot_tex, save=plot_save, save_path=save_path)
save_path = (plot_path + os.sep + 'POL_pha_' +
polt[0] + polt[1] +
'.' + plot_format)
ati_phase = uwphase(cohs[coh_ind])
phase_mean = np.mean(ati_phase)
phase_std = np.std(ati_phase)
vmin = np.max([-np.abs(phase_mean) - 4*phase_std, -np.pi])
vmax = np.min([np.abs(phase_mean) + 4*phase_std, np.pi])
utils.image(ati_phase, aspect='equal',
min=vmin, max=vmax,
cmap=utils.bwr_cmap, extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]', ylabel='Azimuth [m]',
title='XPOL Phase', cbar_xlabel='[rad]',
usetex=plot_tex, save=plot_save, save_path=save_path)
if num_ch > 1:
ati_phases = np.array(ati_phases)
output.write('--------------------------------------------\n')
output.write('SURFACE RADIAL VELOCITY - NO SMOOTHING\n')
output.write('MEAN(SURF. V) = %.4f\n' % v_radial_surf_mean)
output.write('STD(SURF. V) = %.4f\n' % v_radial_surf_std)
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write('SURFACE RADIAL VELOCITY - SMOOTHING (WIN. SIZE=%dx%d)\n' % (az_ml, rg_ml))
output.write('MEAN(SURF. V) = %.4f\n' % v_radial_surf_mean)
output.write('STD(SURF. V) = %.4f\n' % v_radial_surf_ml_std)
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write('SURFACE HORIZONTAL VELOCITY - NO SMOOTHING\n')
output.write('MEAN(SURF. V) = %.4f\n' % v_horizo_surf_mean)
output.write('STD(SURF. V) = %.4f\n' % v_horizo_surf_std)
output.write('--------------------------------------------\n\n')
if plot_vel_hist:
# PLOT RADIAL VELOCITY
plt.figure()
plt.hist(v_radial_surf.flatten(), 200, normed=True, histtype='step')
#plt.hist(v_radial_surf_ml.flatten(), 500, normed=True, histtype='step')
plt.grid(True)
plt.xlim([-np.abs(v_radial_surf_mean) - 4.*v_radial_surf_std, np.abs(v_radial_surf_mean) + 4.* v_radial_surf_std])
plt.xlabel('Radial velocity [m/s]')
plt.ylabel('PDF')
plt.title('Surface velocity')
if plot_save:
plt.savefig(plot_path + os.sep + 'TRUE_radial_vel_hist.' + plot_format)
plt.close()
else:
plt.show()
plt.figure()
plt.hist(v_radial_surf_ml.flatten(), 200, normed=True, histtype='step')
#plt.hist(v_radial_surf_ml.flatten(), 500, normed=True, histtype='step')
plt.grid(True)
plt.xlim([-np.abs(v_radial_surf_mean) - 4.*v_radial_surf_std, np.abs(v_radial_surf_mean) + 4.* v_radial_surf_std])
plt.xlabel('Radial velocity [m/s]')
plt.ylabel('PDF')
plt.title('Surface velocity (low pass filtered)')
if plot_save:
plt.savefig(plot_path + os.sep + 'TRUE_radial_vel_ml_hist.' + plot_format)
plt.close()
else:
plt.show()
if plot_vel:
utils.image(v_radial_surf, aspect='equal', cmap=utils.bwr_cmap, extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]', ylabel='Azimuth [m]', title='Surface Radial Velocity', cbar_xlabel='[m/s]',
min=-np.abs(v_radial_surf_mean) - 4.*v_radial_surf_std, max=np.abs(v_radial_surf_mean) + 4.*v_radial_surf_std,
usetex=plot_tex, save=plot_save, save_path=plot_path + os.sep + 'TRUE_radial_vel.' + plot_format)
utils.image(v_radial_surf_ml, aspect='equal', cmap=utils.bwr_cmap, extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]', ylabel='Azimuth [m]', title='Surface Radial Velocity', cbar_xlabel='[m/s]',
min=-np.abs(v_radial_surf_mean) - 4.*v_radial_surf_std, max=np.abs(v_radial_surf_mean) + 4.*v_radial_surf_std,
usetex=plot_tex, save=plot_save, save_path=plot_path + os.sep + 'TRUE_radial_vel_ml.' + plot_format)
## ESTIMATED VELOCITIES
# Note: plot limits are taken from surface calculations to keep the same ranges
# ESTIMATE RADIAL VELOCITY
v_radial_ests = -ati_phases/tau_ati/(k0*2.)
# ESTIMATE HORIZONTAL VELOCITY
v_horizo_ests = -ati_phases/tau_ati/(k0*2.)/np.sin(inc_angle)
#Trim edges
v_radial_ests = v_radial_ests[:, az_guard:-az_guard, 5:-5]
v_horizo_ests = v_horizo_ests[:, az_guard:-az_guard, 5:-5]
output.write('--------------------------------------------\n')
output.write('ESTIMATED RADIAL VELOCITY - NO SMOOTHING\n')
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('MEAN(EST. V) = %.4f\n' % np.mean(v_radial_ests[pind]))
output.write('STD(EST. V) = %.4f\n' % np.std(v_radial_ests[pind]))
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write('ESTIMATED RADIAL VELOCITY - SMOOTHING (WIN. SIZE=%dx%d)\n' % (az_ml, rg_ml))
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('MEAN(EST. V) = %.4f\n' % np.mean(utils.smooth(utils.smooth(v_radial_ests[pind],
rg_ml, axis=1),
az_ml, axis=0)))
output.write('STD(EST. V) = %.4f\n' % np.std(utils.smooth(utils.smooth(v_radial_ests[pind],
rg_ml, axis=1),
az_ml, axis=0)))
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write('ESTIMATED HORIZONTAL VELOCITY - NO SMOOTHING\n')
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('MEAN(EST. V) = %.4f\n' % np.mean(v_horizo_ests[pind]))
output.write('STD(EST. V) = %.4f\n' % np.std(v_horizo_ests[pind]))
output.write('--------------------------------------------\n\n')
# Processed NRCS
NRCS_est_avg = 10*np.log10(np.mean(np.mean(i_all[:, az_guard:-az_guard, 5:-5], axis=-1), axis=-1))
output.write('--------------------------------------------\n')
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('Estimated mean NRCS = %5.2f\n' % NRCS_est_avg[pind])
output.write('--------------------------------------------\n\n')
# Some bookkeeping information
output.write('--------------------------------------------\n')
output.write('GROUND RANGE GRID SPACING = %.4f\n' % grg_grid_spacing)
output.write('AZIMUTH GRID SPACING = %.4f\n' % az_grid_spacing)
output.write('--------------------------------------------\n\n')
output.close()
if plot_vel_hist and num_ch > 1:
# PLOT RADIAL VELOCITY
plt.figure()
plt.hist(v_radial_surf.flatten(), 200, normed=True, histtype='step',
label='True')
for pind in range(npol):
plt.hist(v_radial_ests[pind].flatten(), 200, normed=True,
histtype='step', label=polt[pind])
plt.grid(True)
plt.xlim([-np.abs(v_radial_surf_mean) - 4.*v_radial_surf_std,
np.abs(v_radial_surf_mean) + 4.*v_radial_surf_std])
plt.xlabel('Radial velocity [m/s]')
plt.ylabel('PDF')
plt.title('Estimated velocity')
plt.legend()
if plot_save:
plt.savefig(plot_path + os.sep + 'ATI_radial_vel_hist.' + plot_format)
plt.close()
else:
plt.show()
print('----------------------------------------')
print(time.strftime("ATI Processing finished [%Y-%m-%d %H:%M:%S]", time.localtime()))
print('----------------------------------------')
def sarraw(cfg_file,
output_file,
ocean_file,
reuse_ocean_file,
errors_file,
reuse_errors_file,
plot_save=True):
###################
# INITIALIZATIONS #
###################
## MPI SETUP
comm = MPI.COMM_WORLD
size, rank = comm.Get_size(), comm.Get_rank()
## WELCOME
if rank == 0:
print(
'-------------------------------------------------------------------'
)
print(
time.strftime("- OCEANSAR SAR RAW GENERATOR: %Y-%m-%d %H:%M:%S",
time.localtime()))
print('- Copyright (c) Gerard Marull Paretas, Paco Lopez Dekker')
print(
'-------------------------------------------------------------------'
)
## CONFIGURATION FILE
# Note: variables are 'copied' to reduce code verbosity
cfg = tpio.ConfigFile(cfg_file)
# RAW
wh_tol = cfg.srg.wh_tol
nesz = cfg.srg.nesz
use_hmtf = cfg.srg.use_hmtf
scat_spec_enable = cfg.srg.scat_spec_enable
scat_spec_mode = cfg.srg.scat_spec_mode
scat_bragg_enable = cfg.srg.scat_bragg_enable
scat_bragg_model = cfg.srg.scat_bragg_model
scat_bragg_d = cfg.srg.scat_bragg_d
scat_bragg_spec = cfg.srg.scat_bragg_spec
scat_bragg_spread = cfg.srg.scat_bragg_spread
# SAR
inc_angle = np.deg2rad(cfg.sar.inc_angle)
f0 = cfg.sar.f0
pol = cfg.sar.pol
squint_r = np.degrees(cfg.sar.squint)
if pol == 'DP':
do_hh = True
do_vv = True
elif pol == 'hh':
do_hh = True
do_vv = False
else:
do_hh = False
do_vv = True
prf = cfg.sar.prf
num_ch = int(cfg.sar.num_ch)
ant_L = cfg.sar.ant_L
alt = cfg.sar.alt
v_ground = cfg.sar.v_ground
rg_bw = cfg.sar.rg_bw
over_fs = cfg.sar.over_fs
sigma_n_tx = cfg.sar.sigma_n_tx
phase_n_tx = np.deg2rad(cfg.sar.phase_n_tx)
sigma_beta_tx = cfg.sar.sigma_beta_tx
phase_beta_tx = np.deg2rad(cfg.sar.phase_beta_tx)
sigma_n_rx = cfg.sar.sigma_n_rx
phase_n_rx = np.deg2rad(cfg.sar.phase_n_rx)
sigma_beta_rx = cfg.sar.sigma_beta_rx
phase_beta_rx = np.deg2rad(cfg.sar.phase_beta_rx)
# OCEAN / OTHERS
ocean_dt = cfg.ocean.dt
add_point_target = False
use_numba = True
n_sinc_samples = 8
sinc_ovs = 20
chan_sinc_vec = raw.calc_sinc_vec(n_sinc_samples, sinc_ovs, Fs=over_fs)
# OCEAN SURFACE
if rank == 0:
print('Initializing ocean surface...')
surface_full = OceanSurface()
# Setup compute values
compute = ['D', 'Diff', 'Diff2']
if use_hmtf:
compute.append('hMTF')
# Try to reuse initialized surface
if reuse_ocean_file:
try:
surface_full.load(ocean_file, compute)
except RuntimeError:
pass
if (not reuse_ocean_file) or (not surface_full.initialized):
if hasattr(cfg.ocean, 'use_buoy_data'):
if cfg.ocean.use_buoy_data:
bdataf = cfg.ocean.buoy_data_file
date = datetime.datetime(np.int(cfg.ocean.year),
np.int(cfg.ocean.month),
np.int(cfg.ocean.day),
np.int(cfg.ocean.hour),
np.int(cfg.ocean.minute), 0)
date, bdata = tpio.load_buoydata(bdataf, date)
buoy_spec = tpio.BuoySpectra(bdata,
heading=cfg.sar.heading,
depth=cfg.ocean.depth)
dirspectrum_func = buoy_spec.Sk2
# Since the wind direction is included in the buoy data
wind_dir = 0
else:
dirspectrum_func = None
wind_dir = np.deg2rad(cfg.ocean.wind_dir)
else:
dirspectrum_func = None
wind_dir = np.deg2rad(cfg.ocean.wind_dir)
surface_full.init(cfg.ocean.Lx,
cfg.ocean.Ly,
cfg.ocean.dx,
cfg.ocean.dy,
cfg.ocean.cutoff_wl,
cfg.ocean.spec_model,
cfg.ocean.spread_model,
wind_dir,
cfg.ocean.wind_fetch,
cfg.ocean.wind_U,
cfg.ocean.current_mag,
np.deg2rad(cfg.ocean.current_dir),
cfg.ocean.swell_enable,
cfg.ocean.swell_ampl,
np.deg2rad(cfg.ocean.swell_dir),
cfg.ocean.swell_wl,
compute,
cfg.ocean.opt_res,
cfg.ocean.fft_max_prime,
choppy_enable=cfg.ocean.choppy_enable,
depth=cfg.ocean.depth,
dirspectrum_func=dirspectrum_func)
surface_full.save(ocean_file)
# Now we plot the directional spectrum
# self.wave_dirspec[good_k] = dirspectrum_func(self.kx[good_k], self.ky[good_k])
plt.figure()
plt.imshow(np.fft.fftshift(surface_full.wave_dirspec),
extent=[
surface_full.kx.min(),
surface_full.kx.max(),
surface_full.ky.min(),
surface_full.ky.max()
],
origin='lower',
cmap='inferno_r')
plt.grid(True)
pltax = plt.gca()
pltax.set_xlim((-0.1, 0.1))
pltax.set_ylim((-0.1, 0.1))
Narr_length = 0.08 # np.min([surface_full.kx.max(), surface_full.ky.max()])
pltax.arrow(0,
0,
-Narr_length * np.sin(np.radians(cfg.sar.heading)),
Narr_length * np.cos(np.radians(cfg.sar.heading)),
fc="k",
ec="k")
plt.xlabel('$k_x$ [rad/m]')
plt.ylabel('$k_y$ [rad/m]')
plt.colorbar()
#plt.show()
# Create plots directory
plot_path = os.path.dirname(output_file) + os.sep + 'raw_plots'
if plot_save:
if not os.path.exists(plot_path):
os.makedirs(plot_path)
plt.savefig(os.path.join(plot_path, 'input_dirspectrum.png'))
plt.close()
else:
surface_full = None
# Initialize surface balancer
surface = OceanSurfaceBalancer(surface_full, ocean_dt)
# CALCULATE PARAMETERS
if rank == 0:
print('Initializing simulation parameters...')
# SR/GR/INC Matrixes
sr0 = geosar.inc_to_sr(inc_angle, alt)
gr0 = geosar.inc_to_gr(inc_angle, alt)
gr = surface.x + gr0
sr, inc, _ = geosar.gr_to_geo(gr, alt)
sr -= np.min(sr)
#inc = np.repeat(inc[np.newaxis, :], surface.Ny, axis=0)
#sr = np.repeat(sr[np.newaxis, :], surface.Ny, axis=0)
#gr = np.repeat(gr[np.newaxis, :], surface.Ny, axis=0)
#Let's try to safe some memory and some operations
inc = inc.reshape(1, inc.size)
sr = sr.reshape(1, sr.size)
gr = gr.reshape(1, gr.size)
sin_inc = np.sin(inc)
cos_inc = np.cos(inc)
# lambda, K, resolution, time, etc.
l0 = const.c / f0
k0 = 2. * np.pi * f0 / const.c
sr_res = const.c / (2. * rg_bw)
if cfg.sar.L_total:
ant_L = ant_L / np.float(num_ch)
d_chan = ant_L
else:
if np.float(cfg.sar.Spacing) != 0:
d_chan = np.float(cfg.sar.Spacing)
else:
d_chan = ant_L
if v_ground == 'auto':
v_ground = geosar.orbit_to_vel(alt, ground=True)
t_step = 1. / prf
t_span = (1.5 * (sr0 * l0 / ant_L) + surface.Ly) / v_ground
az_steps = np.int(np.floor(t_span / t_step))
# Number of RG samples
max_sr = np.max(sr) + wh_tol + (np.max(surface.y_full) +
(t_span / 2.) * v_ground)**2. / (2. * sr0)
min_sr = np.min(sr) - wh_tol
rg_samp_orig = np.int(np.ceil(((max_sr - min_sr) / sr_res) * over_fs))
rg_samp = np.int(utils.optimize_fftsize(rg_samp_orig))
# Other initializations
if do_hh:
proc_raw_hh = np.zeros([num_ch, az_steps, rg_samp], dtype=np.complex)
if do_vv:
proc_raw_vv = np.zeros([num_ch, az_steps, rg_samp], dtype=np.complex)
t_last_rcs_bragg = -1.
last_progress = -1
NRCS_avg_vv = np.zeros(az_steps, dtype=np.float)
NRCS_avg_hh = np.zeros(az_steps, dtype=np.float)
## RCS MODELS
# Specular
if scat_spec_enable:
if scat_spec_mode == 'kodis':
rcs_spec = rcs.RCSKodis(inc, k0, surface.dx, surface.dy)
elif scat_spec_mode == 'fa' or scat_spec_mode == 'spa':
spec_ph0 = np.random.uniform(0.,
2. * np.pi,
size=[surface.Ny, surface.Nx])
rcs_spec = rcs.RCSKA(scat_spec_mode, k0, surface.x, surface.y,
surface.dx, surface.dy)
else:
raise NotImplementedError(
'RCS mode %s for specular scattering not implemented' %
scat_spec_mode)
# Bragg
if scat_bragg_enable:
phase_bragg = np.zeros([2, surface.Ny, surface.Nx])
bragg_scats = np.zeros([2, surface.Ny, surface.Nx], dtype=np.complex)
# dop_phase_p = np.random.uniform(0., 2.*np.pi, size=[surface.Ny, surface.Nx])
# dop_phase_m = np.random.uniform(0., 2.*np.pi, size=[surface.Ny, surface.Nx])
tau_c = closure.grid_coherence(cfg.ocean.wind_U, surface.dx, f0)
rndscat_p = closure.randomscat_ts(tau_c, (surface.Ny, surface.Nx), prf)
rndscat_m = closure.randomscat_ts(tau_c, (surface.Ny, surface.Nx), prf)
# NOTE: This ignores slope, may be changed
k_b = 2. * k0 * sin_inc
c_b = sin_inc * np.sqrt(const.g / k_b + 0.072e-3 * k_b)
if scat_bragg_model == 'romeiser97':
current_dir = np.deg2rad(cfg.ocean.current_dir)
current_vec = (cfg.ocean.current_mag * np.array(
[np.cos(current_dir), np.sin(current_dir)]))
U_dir = np.deg2rad(cfg.ocean.wind_dir)
U_vec = (cfg.ocean.wind_U *
np.array([np.cos(U_dir), np.sin(U_dir)]))
U_eff_vec = U_vec - current_vec
rcs_bragg = rcs.RCSRomeiser97(
k0, inc, pol, surface.dx, surface.dy, linalg.norm(U_eff_vec),
np.arctan2(U_eff_vec[1], U_eff_vec[0]), surface.wind_fetch,
scat_bragg_spec, scat_bragg_spread, scat_bragg_d)
else:
raise NotImplementedError(
'RCS model %s for Bragg scattering not implemented' %
scat_bragg_model)
surface_area = surface.dx * surface.dy * surface.Nx * surface.Ny
###################
# SIMULATION LOOP #
###################
if rank == 0:
print('Computing profiles...')
for az_step in np.arange(az_steps, dtype=np.int):
## AZIMUTH & SURFACE UPDATE
t_now = az_step * t_step
az_now = (t_now - t_span / 2.) * v_ground
# az = np.repeat((surface.y - az_now)[:, np.newaxis], surface.Nx, axis=1)
az = (surface.y - az_now).reshape((surface.Ny, 1))
surface.t = t_now
## COMPUTE RCS FOR EACH MODEL
# Note: SAR processing is range independent as slant range is fixed
sin_az = az / sr0
az_proj_angle = np.arcsin(az / gr0)
# Note: Projected displacements are added to slant range
sr_surface = (sr - cos_inc * surface.Dz + az / 2 * sin_az +
surface.Dx * sin_inc + surface.Dy * sin_az)
if do_hh:
scene_hh = np.zeros(
[int(surface.Ny), int(surface.Nx)], dtype=np.complex)
if do_vv:
scene_vv = np.zeros(
[int(surface.Ny), int(surface.Nx)], dtype=np.complex)
# Point target
if add_point_target and rank == 0:
sr_pt = (sr[0, surface.Nx / 2] + az[surface.Ny / 2, 0] / 2 *
sin_az[surface.Ny / 2, surface.Nx / 2])
pt_scat = (100. * np.exp(-1j * 2. * k0 * sr_pt))
if do_hh:
scene_hh[surface.Ny / 2, surface.Nx / 2] = pt_scat
if do_vv:
scene_vv[surface.Ny / 2, surface.Nx / 2] = pt_scat
sr_surface[surface.Ny / 2, surface.Nx / 2] = sr_pt
# Specular
if scat_spec_enable:
if scat_spec_mode == 'kodis':
Esn_sp = np.sqrt(4. * np.pi) * rcs_spec.field(
az_proj_angle, sr_surface, surface.Diffx, surface.Diffy,
surface.Diffxx, surface.Diffyy, surface.Diffxy)
if do_hh:
scene_hh += Esn_sp
if do_vv:
scene_vv += Esn_sp
else:
# FIXME
if do_hh:
pol_tmp = 'hh'
Esn_sp = (
np.exp(-1j * (2. * k0 * sr_surface)) *
(4. * np.pi)**1.5 * rcs_spec.field(
1, 1, pol_tmp[0], pol_tmp[1], inc, inc,
az_proj_angle, az_proj_angle + np.pi, surface.Dz,
surface.Diffx, surface.Diffy, surface.Diffxx,
surface.Diffyy, surface.Diffxy))
scene_hh += Esn_sp
if do_vv:
pol_tmp = 'vv'
Esn_sp = (
np.exp(-1j * (2. * k0 * sr_surface)) *
(4. * np.pi)**1.5 * rcs_spec.field(
1, 1, pol_tmp[0], pol_tmp[1], inc, inc,
az_proj_angle, az_proj_angle + np.pi, surface.Dz,
surface.Diffx, surface.Diffy, surface.Diffxx,
surface.Diffyy, surface.Diffxy))
scene_vv += Esn_sp
NRCS_avg_hh[az_step] += (np.sum(np.abs(Esn_sp)**2) / surface_area)
NRCS_avg_vv[az_step] += NRCS_avg_hh[az_step]
# Bragg
if scat_bragg_enable:
if (t_now - t_last_rcs_bragg) > ocean_dt:
if scat_bragg_model == 'romeiser97':
if pol == 'DP':
RCS_bragg_hh, RCS_bragg_vv = rcs_bragg.rcs(
az_proj_angle, surface.Diffx, surface.Diffy)
elif pol == 'hh':
RCS_bragg_hh = rcs_bragg.rcs(az_proj_angle,
surface.Diffx,
surface.Diffy)
else:
RCS_bragg_vv = rcs_bragg.rcs(az_proj_angle,
surface.Diffx,
surface.Diffy)
if use_hmtf:
# Fix Bad MTF points
surface.hMTF[np.where(surface.hMTF < -1)] = -1
if do_hh:
RCS_bragg_hh[0] *= (1 + surface.hMTF)
RCS_bragg_hh[1] *= (1 + surface.hMTF)
if do_vv:
RCS_bragg_vv[0] *= (1 + surface.hMTF)
RCS_bragg_vv[1] *= (1 + surface.hMTF)
t_last_rcs_bragg = t_now
if do_hh:
scat_bragg_hh = np.sqrt(RCS_bragg_hh)
NRCS_bragg_hh_instant_avg = np.sum(RCS_bragg_hh) / surface_area
NRCS_avg_hh[az_step] += NRCS_bragg_hh_instant_avg
if do_vv:
scat_bragg_vv = np.sqrt(RCS_bragg_vv)
NRCS_bragg_vv_instant_avg = np.sum(RCS_bragg_vv) / surface_area
NRCS_avg_vv[az_step] += NRCS_bragg_vv_instant_avg
# Doppler phases (Note: Bragg radial velocity taken constant!)
surf_phase = -(2 * k0) * sr_surface
cap_phase = (2 * k0) * t_step * c_b * (az_step + 1)
phase_bragg[0] = surf_phase - cap_phase # + dop_phase_p
phase_bragg[1] = surf_phase + cap_phase # + dop_phase_m
bragg_scats[0] = rndscat_m.scats(t_now)
bragg_scats[1] = rndscat_p.scats(t_now)
if do_hh:
scene_hh += ne.evaluate(
'sum(scat_bragg_hh * exp(1j*phase_bragg) * bragg_scats, axis=0)'
)
if do_vv:
scene_vv += ne.evaluate(
'sum(scat_bragg_vv * exp(1j*phase_bragg) * bragg_scats, axis=0)'
)
## ANTENNA PATTERN
## FIXME: this assume co-located Tx and Tx, so it will not work for true bistatic configurations
if cfg.sar.L_total:
beam_pattern = sinc_1tx_nrx(sin_az,
ant_L * num_ch,
f0,
num_ch,
field=True)
else:
beam_pattern = sinc_1tx_nrx(sin_az, ant_L, f0, 1, field=True)
## GENERATE CHANEL PROFILES
for ch in np.arange(num_ch, dtype=np.int):
if do_hh:
scene_bp = scene_hh * beam_pattern
# Add channel phase & compute profile
scene_bp *= np.exp(-1j * k0 * d_chan * ch * sin_az)
if use_numba:
raw.chan_profile_numba(sr_surface.flatten(),
scene_bp.flatten(),
sr_res / (over_fs), min_sr,
chan_sinc_vec, n_sinc_samples,
sinc_ovs, proc_raw_hh[ch][az_step])
else:
raw.chan_profile_weave(sr_surface.flatten(),
scene_bp.flatten(),
sr_res / (over_fs), min_sr,
chan_sinc_vec, n_sinc_samples,
sinc_ovs, proc_raw_hh[ch][az_step])
if do_vv:
scene_bp = scene_vv * beam_pattern
# Add channel phase & compute profile
scene_bp *= np.exp(-1j * k0 * d_chan * ch * sin_az)
if use_numba:
raw.chan_profile_numba(sr_surface.flatten(),
scene_bp.flatten(),
sr_res / (over_fs), min_sr,
chan_sinc_vec, n_sinc_samples,
sinc_ovs, proc_raw_vv[ch][az_step])
else:
raw.chan_profile_weave(sr_surface.flatten(),
scene_bp.flatten(),
sr_res / (over_fs), min_sr,
chan_sinc_vec, n_sinc_samples,
sinc_ovs, proc_raw_vv[ch][az_step])
# SHOW PROGRESS (%)
current_progress = np.int((100 * az_step) / az_steps)
if current_progress != last_progress:
last_progress = current_progress
print('SP,%d,%d,%d' % (rank, size, current_progress))
# MERGE RESULTS
if do_hh:
total_raw_hh = np.empty_like(proc_raw_hh) if rank == 0 else None
comm.Reduce(proc_raw_hh, total_raw_hh, op=MPI.SUM, root=0)
if do_vv:
total_raw_vv = np.empty_like(proc_raw_vv) if rank == 0 else None
comm.Reduce(proc_raw_vv, total_raw_vv, op=MPI.SUM, root=0)
## PROCESS REDUCED RAW DATA & SAVE (ROOT)
if rank == 0:
print('Processing and saving results...')
# Filter and decimate
#range_filter = np.ones_like(total_raw)
#range_filter[:, :, rg_samp/(2*2*cfg.sar.over_fs):-rg_samp/(2*2*cfg.sar.over_fs)] = 0
#total_raw = np.fft.ifft(range_filter*np.fft.fft(total_raw))
if do_hh:
total_raw_hh = total_raw_hh[:, :, :rg_samp_orig]
if do_vv:
total_raw_vv = total_raw_vv[:, :, :rg_samp_orig]
# Calibration factor (projected antenna pattern integrated in azimuth)
az_axis = np.arange(-t_span / 2. * v_ground, t_span / 2. * v_ground,
sr0 * const.c / (np.pi * f0 * ant_L * 10.))
if cfg.sar.L_total:
pattern = sinc_1tx_nrx(az_axis / sr0,
ant_L * num_ch,
f0,
num_ch,
field=True)
else:
pattern = sinc_1tx_nrx(az_axis / sr0, ant_L, f0, 1, field=True)
cal_factor = (1. / np.sqrt(
np.trapz(np.abs(pattern)**2., az_axis) * sr_res /
np.sin(inc_angle)))
if do_hh:
noise = (utils.db2lin(nesz, amplitude=True) / np.sqrt(2.) *
(np.random.normal(size=total_raw_hh.shape) +
1j * np.random.normal(size=total_raw_hh.shape)))
total_raw_hh = total_raw_hh * cal_factor + noise
if do_vv:
noise = (utils.db2lin(nesz, amplitude=True) / np.sqrt(2.) *
(np.random.normal(size=total_raw_vv.shape) +
1j * np.random.normal(size=total_raw_vv.shape)))
total_raw_vv = total_raw_vv * cal_factor + noise
# Add slow-time error
# if use_errors:
# if do_hh:
# total_raw_hh *= errors.beta_noise
# if do_vv:
# total_raw_vv *= errors.beta_noise
# Save RAW data (and other properties, used by 3rd party software)
if do_hh and do_vv:
rshp = (1, ) + total_raw_hh.shape
total_raw = np.concatenate(
(total_raw_hh.reshape(rshp), total_raw_vv.reshape(rshp)))
rshp = (1, ) + NRCS_avg_hh.shape
NRCS_avg = np.concatenate(
(NRCS_avg_hh.reshape(rshp), NRCS_avg_vv.reshape(rshp)))
elif do_hh:
rshp = (1, ) + total_raw_hh.shape
total_raw = total_raw_hh.reshape(rshp)
rshp = (1, ) + NRCS_avg_hh.shape
NRCS_avg = NRCS_avg_hh.reshape(rshp)
else:
rshp = (1, ) + total_raw_vv.shape
total_raw = total_raw_vv.reshape(rshp)
rshp = (1, ) + NRCS_avg_vv.shape
NRCS_avg = NRCS_avg_vv.reshape(rshp)
raw_file = tpio.RawFile(output_file, 'w', total_raw.shape)
raw_file.set('inc_angle', np.rad2deg(inc_angle))
raw_file.set('f0', f0)
raw_file.set('num_ch', num_ch)
raw_file.set('ant_L', ant_L)
raw_file.set('prf', prf)
raw_file.set('v_ground', v_ground)
raw_file.set('orbit_alt', alt)
raw_file.set('sr0', sr0)
raw_file.set('rg_sampling', rg_bw * over_fs)
raw_file.set('rg_bw', rg_bw)
raw_file.set('raw_data*', total_raw)
raw_file.set('NRCS_avg', NRCS_avg)
raw_file.close()
print(time.strftime("Finished [%Y-%m-%d %H:%M:%S]", time.localtime()))
def l2_wavespectrum(cfg_file, proc_output_file, ocean_file, output_file):
print(
'-------------------------------------------------------------------')
print(
time.strftime("- OCEANSAR L2 Wavespectra: [%Y-%m-%d %H:%M:%S]",
time.localtime()))
print(
'-------------------------------------------------------------------')
print('Initializing...')
## CONFIGURATION FILE
cfg = tpio.ConfigFile(cfg_file)
# SAR
inc_angle = np.deg2rad(cfg.sar.inc_angle)
f0 = cfg.sar.f0
prf = cfg.sar.prf
num_ch = cfg.sar.num_ch
ant_L = cfg.sar.ant_L
alt = cfg.sar.alt
v_ground = cfg.sar.v_ground
rg_bw = cfg.sar.rg_bw
over_fs = cfg.sar.over_fs
pol = cfg.sar.pol
if pol == 'DP':
polt = ['hh', 'vv']
elif pol == 'hh':
polt = ['hh']
else:
polt = ['vv']
# L2 wavespectrum
rg_ml = cfg.L2_wavespectrum.rg_ml
az_ml = cfg.L2_wavespectrum.az_ml
krg_ml = cfg.L2_wavespectrum.krg_ml
kaz_ml = cfg.L2_wavespectrum.kaz_ml
ml_win = cfg.L2_wavespectrum.ml_win
plot_save = cfg.L2_wavespectrum.plot_save
plot_path = cfg.L2_wavespectrum.plot_path
plot_format = cfg.L2_wavespectrum.plot_format
plot_tex = cfg.L2_wavespectrum.plot_tex
plot_surface = cfg.L2_wavespectrum.plot_surface
plot_proc_ampl = cfg.L2_wavespectrum.plot_proc_ampl
plot_spectrum = cfg.L2_wavespectrum.plot_spectrum
n_sublook = cfg.L2_wavespectrum.n_sublook
sublook_weighting = cfg.L2_wavespectrum.sublook_az_weighting
## CALCULATE PARAMETERS
if v_ground == 'auto': v_ground = geosar.orbit_to_vel(alt, ground=True)
k0 = 2. * np.pi * f0 / const.c
rg_sampling = rg_bw * over_fs
# PROCESSED RAW DATA
proc_content = tpio.ProcFile(proc_output_file, 'r')
proc_data = proc_content.get('slc*')
proc_content.close()
# OCEAN SURFACE
surface = OceanSurface()
surface.load(ocean_file, compute=['D', 'V'])
surface.t = 0.
# OUTPUT FILE
output = open(output_file, 'w')
# OTHER INITIALIZATIONS
# Enable TeX
if plot_tex:
plt.rc('font', family='serif')
plt.rc('text', usetex=True)
# Create plots directory
plot_path = os.path.dirname(output_file) + os.sep + plot_path
if plot_save:
if not os.path.exists(plot_path):
os.makedirs(plot_path)
# SURFACE VELOCITIES
grg_grid_spacing = (const.c / 2. / rg_sampling / np.sin(inc_angle))
rg_res_fact = grg_grid_spacing / surface.dx
az_grid_spacing = (v_ground / prf)
az_res_fact = az_grid_spacing / surface.dy
res_fact = np.ceil(np.sqrt(rg_res_fact * az_res_fact))
# SURFACE RADIAL VELOCITY
v_radial_surf = surface.Vx * np.sin(inc_angle) - surface.Vz * np.cos(
inc_angle)
v_radial_surf_ml = utils.smooth(utils.smooth(v_radial_surf,
res_fact * rg_ml,
axis=1),
res_fact * az_ml,
axis=0)
v_radial_surf_mean = np.mean(v_radial_surf)
v_radial_surf_std = np.std(v_radial_surf)
v_radial_surf_ml_std = np.std(v_radial_surf_ml)
# Expected mean azimuth shift
sr0 = geosar.inc_to_sr(inc_angle, alt)
avg_az_shift = -v_radial_surf_mean / v_ground * sr0
std_az_shift = v_radial_surf_std / v_ground * sr0
print('Starting Wavespectrum processing...')
# Get dimensions & calculate region of interest
rg_span = surface.Lx
az_span = surface.Ly
rg_size = proc_data[0].shape[2]
az_size = proc_data[0].shape[1]
# Note: RG is projected, so plots are Ground Range
rg_min = 0
rg_max = np.int(rg_span / (const.c / 2. / rg_sampling / np.sin(inc_angle)))
az_min = np.int(az_size / 2. + (-az_span / 2. + avg_az_shift) /
(v_ground / prf))
az_max = np.int(az_size / 2. + (az_span / 2. + avg_az_shift) /
(v_ground / prf))
az_guard = np.int(std_az_shift / (v_ground / prf))
az_min = az_min + az_guard
az_max = az_max - az_guard
if (az_max - az_min) < (2 * az_guard - 10):
print('Not enough edge-effect free image')
return
# Adaptive coregistration
if cfg.sar.L_total:
ant_L = ant_L / np.float(num_ch)
dist_chan = ant_L / 2
else:
if np.float(cfg.sar.Spacing) != 0:
dist_chan = np.float(cfg.sar.Spacing) / 2
else:
dist_chan = ant_L / 2
# dist_chan = ant_L/num_ch/2.
print('ATI Spacing: %f' % dist_chan)
inter_chan_shift_dist = dist_chan / (v_ground / prf)
# Subsample shift in azimuth
for chind in range(proc_data.shape[0]):
shift_dist = -chind * inter_chan_shift_dist
shift_arr = np.exp(
-2j * np.pi * shift_dist *
np.roll(np.arange(az_size) - az_size / 2, int(-az_size / 2)) /
az_size)
shift_arr = shift_arr.reshape((1, az_size, 1))
proc_data[chind] = np.fft.ifft(np.fft.fft(proc_data[chind], axis=1) *
shift_arr,
axis=1)
# First dimension is number of channels, second is number of pols
ch_dim = proc_data.shape[0:2]
npol = ch_dim[1]
proc_data_rshp = [np.prod(ch_dim), proc_data.shape[2], proc_data.shape[3]]
# Compute extended covariance matrices...
proc_data = proc_data.reshape(proc_data_rshp)
# Intensities
i_all = []
for chind in range(proc_data.shape[0]):
this_i = utils.smooth(utils.smooth(np.abs(proc_data[chind])**2.,
rg_ml,
axis=1,
window=ml_win),
az_ml,
axis=0,
window=ml_win)
i_all.append(this_i[az_min:az_max, rg_min:rg_max])
i_all = np.array(i_all)
## Wave spectra computation
## Processed Doppler bandwidth
proc_bw = cfg.processing.doppler_bw
PRF = cfg.sar.prf
fa = np.fft.fftfreq(proc_data_rshp[1], 1 / PRF)
# Filters
sublook_filt = []
sublook_bw = proc_bw / n_sublook
for i_sbl in range(n_sublook):
fa_min = -1 * proc_bw / 2 + i_sbl * sublook_bw
fa_max = fa_min + sublook_bw
fa_c = (fa_max + fa_min) / 2
win = np.where(
np.logical_and(fa > fa_min, fa < fa_max),
(sublook_weighting -
(1 - sublook_weighting) * np.cos(2 * np.pi *
(fa - fa_min) / sublook_bw)), 0)
sublook_filt.append(win)
# Apply sublooks
az_downsmp = int(np.floor(az_ml / 2))
rg_downsmp = int(np.floor(rg_ml / 2))
sublooks = []
sublooks_f = []
for i_sbl in range(n_sublook):
# Go to frequency domain
sublook_data = np.fft.ifft(np.fft.fft(proc_data, axis=1) *
sublook_filt[i_sbl].reshape(
(1, proc_data_rshp[1], 1)),
axis=1)
# Get intensities
sublook_data = np.abs(sublook_data)**2
# Multilook
for chind in range(proc_data.shape[0]):
sublook_data[chind] = utils.smooth(utils.smooth(
sublook_data[chind], rg_ml, axis=1),
az_ml,
axis=0)
# Keep only valid part and down sample
sublook_data = sublook_data[:, az_min:az_max:az_downsmp,
rg_min:rg_max:rg_downsmp]
sublooks.append(sublook_data)
sublooks_f.append(
np.fft.fft(np.fft.fft(sublook_data - np.mean(sublook_data),
axis=1),
axis=2))
kaz = 2 * np.pi * np.fft.fftfreq(sublook_data.shape[1],
az_downsmp * az_grid_spacing)
kgrg = 2 * np.pi * np.fft.fftfreq(sublook_data.shape[2],
rg_downsmp * grg_grid_spacing)
xspecs = []
tind = 0
xspec_lut = np.zeros((len(sublooks), len(sublooks)), dtype=int)
for ind1 in range(len(sublooks)):
for ind2 in range(ind1 + 1, len(sublooks)):
xspec_lut[ind1, ind2] = tind
tind = tind + 1
xspec = sublooks_f[ind1] * np.conj(sublooks_f[ind2])
xspecs.append(xspec)
with open(output_file, 'wb') as output:
pickle.dump(xspecs, output, pickle.HIGHEST_PROTOCOL)
pickle.dump([kaz, kgrg], output, pickle.HIGHEST_PROTOCOL)
# PROCESSED AMPLITUDE
if plot_proc_ampl:
for pind in range(npol):
save_path = (plot_path + os.sep + 'amp_dB_' + polt[pind] + '.' +
plot_format)
plt.figure()
plt.imshow(utils.db(i_all[pind]),
aspect='equal',
origin='lower',
vmin=utils.db(np.max(i_all[pind])) - 20,
extent=[0., rg_span, 0., az_span],
interpolation='nearest',
cmap='viridis')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Amplitude")
plt.colorbar()
plt.savefig(save_path)
save_path = (plot_path + os.sep + 'amp_' + polt[pind] + '.' +
plot_format)
int_img = (i_all[pind])**0.5
vmin = np.mean(int_img) - 3 * np.std(int_img)
vmax = np.mean(int_img) + 3 * np.std(int_img)
plt.figure()
plt.imshow(int_img,
aspect='equal',
origin='lower',
vmin=vmin,
vmax=vmax,
extent=[0., rg_span, 0., az_span],
interpolation='nearest',
cmap='viridis')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Amplitude")
plt.colorbar()
plt.savefig(save_path)
## FIXME: I am plotting the cross spectrum for the first polarization and the first channel only, which is not
## very nice. To be fixed, in particular por multiple polarizations
for ind1 in range(len(sublooks)):
for ind2 in range(ind1 + 1, len(sublooks)):
save_path_abs = os.path.join(plot_path,
('xspec_abs_%i%i.%s' %
(ind1 + 1, ind2 + 1, plot_format)))
save_path_pha = os.path.join(plot_path,
('xspec_pha_%i%i.%s' %
(ind1 + 1, ind2 + 1, plot_format)))
save_path_im = os.path.join(plot_path,
('xspec_im_%i%i.%s' %
(ind1 + 1, ind2 + 1, plot_format)))
ml_xspec = utils.smooth(utils.smooth(np.fft.fftshift(
xspecs[xspec_lut[ind1, ind2]][0]),
krg_ml,
axis=1),
kaz_ml,
axis=0)
plt.figure()
plt.imshow(np.abs(ml_xspec),
origin='lower',
cmap='inferno_r',
extent=[kgrg.min(),
kgrg.max(),
kaz.min(),
kaz.max()],
interpolation='nearest')
plt.grid(True)
pltax = plt.gca()
pltax.set_xlim((-0.1, 0.1))
pltax.set_ylim((-0.1, 0.1))
northarr_length = 0.075 # np.min([surface_full.kx.max(), surface_full.ky.max()])
pltax.arrow(0,
0,
-northarr_length * np.sin(np.radians(cfg.sar.heading)),
northarr_length * np.cos(np.radians(cfg.sar.heading)),
fc="k",
ec="k")
plt.xlabel('$k_x$ [rad/m]')
plt.ylabel('$k_y$ [rad/m]')
plt.colorbar()
plt.savefig(save_path_abs)
plt.close()
plt.figure()
ml_xspec_pha = np.angle(ml_xspec)
ml_xspec_im = np.imag(ml_xspec)
immax = np.abs(ml_xspec_im).max()
whimmax = np.abs(ml_xspec_im).flatten().argmax()
phmax = np.abs(ml_xspec_pha.flatten()[whimmax])
plt.imshow(ml_xspec_pha,
origin='lower',
cmap='bwr',
extent=[kgrg.min(),
kgrg.max(),
kaz.min(),
kaz.max()],
interpolation='nearest',
vmin=-2 * phmax,
vmax=2 * phmax)
plt.grid(True)
pltax = plt.gca()
pltax.set_xlim((-0.1, 0.1))
pltax.set_ylim((-0.1, 0.1))
northarr_length = 0.075 # np.min([surface_full.kx.max(), surface_full.ky.max()])
pltax.arrow(0,
0,
-northarr_length * np.sin(np.radians(cfg.sar.heading)),
northarr_length * np.cos(np.radians(cfg.sar.heading)),
fc="k",
ec="k")
plt.xlabel('$k_x$ [rad/m]')
plt.ylabel('$k_y$ [rad/m]')
plt.colorbar()
plt.savefig(save_path_pha)
plt.close()
plt.figure()
plt.imshow(ml_xspec_im,
origin='lower',
cmap='bwr',
extent=[kgrg.min(),
kgrg.max(),
kaz.min(),
kaz.max()],
interpolation='nearest',
vmin=-2 * immax,
vmax=2 * immax)
plt.grid(True)
pltax = plt.gca()
pltax.set_xlim((-0.1, 0.1))
pltax.set_ylim((-0.1, 0.1))
northarr_length = 0.075 # np.min([surface_full.kx.max(), surface_full.ky.max()])
pltax.arrow(0,
0,
-northarr_length * np.sin(np.radians(cfg.sar.heading)),
northarr_length * np.cos(np.radians(cfg.sar.heading)),
fc="k",
ec="k")
plt.xlabel('$k_x$ [rad/m]')
plt.ylabel('$k_y$ [rad/m]')
plt.colorbar()
plt.savefig(save_path_im)
plt.close()
def ati_process(cfg_file, insar_output_file, ocean_file, output_file):
print(
'-------------------------------------------------------------------')
print(
time.strftime("- OCEANSAR ATI Processor: [%Y-%m-%d %H:%M:%S]",
time.localtime()))
print(
'-------------------------------------------------------------------')
print('Initializing...')
## CONFIGURATION FILE
cfg = tpio.ConfigFile(cfg_file)
# SAR
pol = cfg.sar.pol
if pol == 'DP':
polt = ['hh', 'vv']
elif pol == 'hh':
polt = ['hh']
else:
polt = ['vv']
# ATI
ml_win = cfg.ati.ml_win
plot_save = cfg.ati.plot_save
plot_path = cfg.ati.plot_path
plot_format = cfg.ati.plot_format
plot_tex = cfg.ati.plot_tex
plot_surface = cfg.ati.plot_surface
plot_proc_ampl = cfg.ati.plot_proc_ampl
plot_coh = cfg.ati.plot_coh
plot_coh_all = cfg.ati.plot_coh_all
plot_ati_phase = cfg.ati.plot_ati_phase
plot_ati_phase_all = cfg.ati.plot_ati_phase_all
plot_vel_hist = cfg.ati.plot_vel_hist
plot_vel = cfg.ati.plot_vel
# PROCESSED InSAR L1b DATA
insar_data = tpio.L1bFile(insar_output_file, 'r')
i_all = insar_data.get('ml_intensity')
cohs = insar_data.get('ml_coherence') * np.exp(
1j * insar_data.get('ml_phase'))
coh_lut = insar_data.get('coh_lut')
sr0 = insar_data.get('sr0')
inc_angle = insar_data.get('inc_angle')
b_ati = insar_data.get('b_ati')
b_xti = insar_data.get('b_xti')
f0 = insar_data.get('f0')
az_sampling = insar_data.get('az_sampling')
num_ch = insar_data.get('num_ch')
rg_sampling = insar_data.get('rg_sampling')
v_ground = insar_data.get('v_ground')
alt = insar_data.get('orbit_alt')
inc_angle = np.deg2rad(insar_data.get('inc_angle'))
rg_ml = insar_data.get('rg_ml')
az_ml = insar_data.get('az_ml')
insar_data.close()
# CALCULATE PARAMETERS
k0 = 2. * np.pi * f0 / const.c
# OCEAN SURFACE
surface = OceanSurface()
surface.load(ocean_file, compute=['D', 'V'])
surface.t = 0.
# OUTPUT FILE
output = open(output_file, 'w')
# OTHER INITIALIZATIONS
# Enable TeX
if plot_tex:
plt.rc('font', family='serif')
plt.rc('text', usetex=True)
# Create plots directory
plot_path = os.path.dirname(output_file) + os.sep + plot_path
if plot_save:
if not os.path.exists(plot_path):
os.makedirs(plot_path)
# SURFACE VELOCITIES
grg_grid_spacing = (const.c / 2. / rg_sampling / np.sin(inc_angle))
rg_res_fact = grg_grid_spacing / surface.dx
az_grid_spacing = (v_ground / az_sampling)
az_res_fact = az_grid_spacing / surface.dy
res_fact = np.ceil(np.sqrt(rg_res_fact * az_res_fact))
# SURFACE RADIAL VELOCITY
v_radial_surf = surface.Vx * np.sin(inc_angle) - surface.Vz * np.cos(
inc_angle)
v_radial_surf_ml = utils.smooth(utils.smooth(v_radial_surf,
res_fact * rg_ml,
axis=1),
res_fact * az_ml,
axis=0)
v_radial_surf_mean = np.mean(v_radial_surf)
v_radial_surf_std = np.std(v_radial_surf)
v_radial_surf_ml_std = np.std(v_radial_surf_ml)
# SURFACE HORIZONTAL VELOCITY
v_horizo_surf = surface.Vx
v_horizo_surf_ml = utils.smooth(utils.smooth(v_horizo_surf,
res_fact * rg_ml,
axis=1),
res_fact * az_ml,
axis=0)
v_horizo_surf_mean = np.mean(v_horizo_surf)
v_horizo_surf_std = np.std(v_horizo_surf)
v_horizo_surf_ml_std = np.std(v_horizo_surf_ml)
# Expected mean azimuth shift
sr0 = geosar.inc_to_sr(inc_angle, alt)
avg_az_shift = -v_radial_surf_mean / v_ground * sr0
std_az_shift = v_radial_surf_std / v_ground * sr0
az_guard = np.int(std_az_shift / (v_ground / az_sampling))
##################
# ATI PROCESSING #
##################
print('Starting ATI processing...')
# Get dimensions & calculate region of interest
rg_span = surface.Lx
az_span = surface.Ly
# First dimension is number of channels, second is number of pols
ch_dim = i_all.shape[0:2]
npol = ch_dim[1]
print('Generating plots and estimating values...')
# SURFACE HEIGHT
if plot_surface:
plt.figure()
plt.imshow(surface.Dz,
cmap="ocean",
extent=[0, surface.Lx, 0, surface.Ly],
origin='lower')
plt.title('Surface Height')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
cbar = plt.colorbar()
cbar.ax.set_xlabel('[m]')
if plot_save:
plt.savefig(plot_path + os.sep + 'plot_surface.' + plot_format,
bbox_inches='tight')
plt.close()
else:
plt.show()
# PROCESSED AMPLITUDE
if plot_proc_ampl:
for pind in range(npol):
save_path = (plot_path + os.sep + 'amp_dB_' + polt[pind] + '.' +
plot_format)
plt.figure()
plt.imshow(utils.db(i_all[0, pind]),
aspect='equal',
origin='lower',
vmin=utils.db(np.max(i_all[pind])) - 20,
extent=[0., rg_span, 0., az_span],
interpolation='nearest',
cmap='viridis')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Amplitude")
plt.colorbar()
plt.savefig(save_path)
plt.close()
save_path = (plot_path + os.sep + 'amp_' + polt[pind] + '.' +
plot_format)
int_img = (i_all[0, pind])**0.5
vmin = np.mean(int_img) - 3 * np.std(int_img)
vmax = np.mean(int_img) + 3 * np.std(int_img)
plt.figure()
plt.imshow(int_img,
aspect='equal',
origin='lower',
vmin=vmin,
vmax=vmax,
extent=[0., rg_span, 0., az_span],
interpolation='nearest',
cmap='viridis')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Amplitude")
plt.colorbar()
plt.savefig(save_path)
plt.close()
if plot_coh and ch_dim[0] > 1:
for pind in range(npol):
save_path = (plot_path + os.sep + 'ATI_coh_' + polt[pind] +
polt[pind] + '.' + plot_format)
coh_ind = coh_lut[0, pind, 1, pind]
plt.figure()
plt.imshow(np.abs(cohs[coh_ind]),
aspect='equal',
origin='lower',
vmin=0,
vmax=1,
extent=[0., rg_span, 0., az_span],
cmap='bone')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("ATI Coherence")
# plt.colorbar()
plt.savefig(save_path)
# ATI PHASE
tau_ati = b_ati / v_ground
ati_phases = []
# Hack to avoid interferogram computation if there are no interferometric channels
if num_ch > 1:
npol_ = npol
else:
npol_ = 0
for pind in range(npol_):
save_path = (plot_path + os.sep + 'ATI_pha_' + polt[pind] +
polt[pind] + '.' + plot_format)
coh_ind = coh_lut[(0, pind, 1, pind)]
ati_phase = uwphase(cohs[coh_ind])
ati_phases.append(ati_phase)
v_radial_est = -ati_phase / tau_ati[1] / (k0 * 2.)
if plot_ati_phase:
phase_mean = np.mean(ati_phase)
phase_std = np.std(ati_phase)
vmin = np.max([
-np.abs(phase_mean) - 4 * phase_std, -np.abs(ati_phase).max()
])
vmax = np.min(
[np.abs(phase_mean) + 4 * phase_std,
np.abs(ati_phase).max()])
plt.figure()
plt.imshow(ati_phase,
aspect='equal',
origin='lower',
vmin=vmin,
vmax=vmax,
extent=[0., rg_span, 0., az_span],
cmap='hsv')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("ATI Phase")
plt.colorbar()
plt.savefig(save_path)
save_path = (plot_path + os.sep + 'ATI_rvel_' + polt[pind] +
polt[pind] + '.' + plot_format)
vmin = -np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std
vmax = np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std
plt.figure()
plt.imshow(v_radial_est,
aspect='equal',
origin='lower',
vmin=vmin,
vmax=vmax,
extent=[0., rg_span, 0., az_span],
cmap='bwr')
plt.xlabel('Ground range [m]')
plt.ylabel('Azimuth [m]')
plt.title("Estimated Radial Velocity " + polt[pind])
plt.colorbar()
plt.savefig(save_path)
if npol_ == 4: # Bypass this for now
# Cross pol interferogram
coh_ind = coh_lut[(0, 1)]
save_path = (plot_path + os.sep + 'POL_coh_' + polt[0] + polt[1] +
'.' + plot_format)
utils.image(np.abs(cohs[coh_ind]),
max=1,
min=0,
aspect='equal',
cmap='gray',
extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]',
ylabel='Azimuth [m]',
title='XPOL Coherence',
usetex=plot_tex,
save=plot_save,
save_path=save_path)
save_path = (plot_path + os.sep + 'POL_pha_' + polt[0] + polt[1] +
'.' + plot_format)
ati_phase = uwphase(cohs[coh_ind])
phase_mean = np.mean(ati_phase)
phase_std = np.std(ati_phase)
vmin = np.max([-np.abs(phase_mean) - 4 * phase_std, -np.pi])
vmax = np.min([np.abs(phase_mean) + 4 * phase_std, np.pi])
utils.image(ati_phase,
aspect='equal',
min=vmin,
max=vmax,
cmap=utils.bwr_cmap,
extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]',
ylabel='Azimuth [m]',
title='XPOL Phase',
cbar_xlabel='[rad]',
usetex=plot_tex,
save=plot_save,
save_path=save_path)
if num_ch > 1:
ati_phases = np.array(ati_phases)
output.write('--------------------------------------------\n')
output.write('SURFACE RADIAL VELOCITY - NO SMOOTHING\n')
output.write('MEAN(SURF. V) = %.4f\n' % v_radial_surf_mean)
output.write('STD(SURF. V) = %.4f\n' % v_radial_surf_std)
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write(
'SURFACE RADIAL VELOCITY - SMOOTHING (WIN. SIZE=%dx%d)\n' %
(az_ml, rg_ml))
output.write('MEAN(SURF. V) = %.4f\n' % v_radial_surf_mean)
output.write('STD(SURF. V) = %.4f\n' % v_radial_surf_ml_std)
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write('SURFACE HORIZONTAL VELOCITY - NO SMOOTHING\n')
output.write('MEAN(SURF. V) = %.4f\n' % v_horizo_surf_mean)
output.write('STD(SURF. V) = %.4f\n' % v_horizo_surf_std)
output.write('--------------------------------------------\n\n')
if plot_vel_hist:
# PLOT RADIAL VELOCITY
plt.figure()
plt.hist(v_radial_surf.flatten(),
200,
density=True,
histtype='step')
#plt.hist(v_radial_surf_ml.flatten(), 500, density=True, histtype='step')
plt.grid(True)
plt.xlim([
-np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std,
np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std
])
plt.xlabel('Radial velocity [m/s]')
plt.ylabel('PDF')
plt.title('Surface velocity')
if plot_save:
plt.savefig(plot_path + os.sep + 'TRUE_radial_vel_hist.' +
plot_format)
plt.close()
else:
plt.show()
plt.figure()
plt.hist(v_radial_surf_ml.flatten(),
200,
density=True,
histtype='step')
#plt.hist(v_radial_surf_ml.flatten(), 500, density=True, histtype='step')
plt.grid(True)
plt.xlim([
-np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std,
np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std
])
plt.xlabel('Radial velocity [m/s]')
plt.ylabel('PDF')
plt.title('Surface velocity (low pass filtered)')
if plot_save:
plt.savefig(plot_path + os.sep + 'TRUE_radial_vel_ml_hist.' +
plot_format)
plt.close()
else:
plt.show()
if plot_vel:
utils.image(
v_radial_surf,
aspect='equal',
cmap=utils.bwr_cmap,
extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]',
ylabel='Azimuth [m]',
title='Surface Radial Velocity',
cbar_xlabel='[m/s]',
min=-np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std,
max=np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std,
usetex=plot_tex,
save=plot_save,
save_path=plot_path + os.sep + 'TRUE_radial_vel.' +
plot_format)
utils.image(
v_radial_surf_ml,
aspect='equal',
cmap=utils.bwr_cmap,
extent=[0., rg_span, 0., az_span],
xlabel='Ground range [m]',
ylabel='Azimuth [m]',
title='Surface Radial Velocity',
cbar_xlabel='[m/s]',
min=-np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std,
max=np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std,
usetex=plot_tex,
save=plot_save,
save_path=plot_path + os.sep + 'TRUE_radial_vel_ml.' +
plot_format)
## ESTIMATED VELOCITIES
# Note: plot limits are taken from surface calculations to keep the same ranges
# ESTIMATE RADIAL VELOCITY
v_radial_ests = -ati_phases / tau_ati[1] / (k0 * 2.)
# ESTIMATE HORIZONTAL VELOCITY
v_horizo_ests = -ati_phases / tau_ati[1] / (k0 *
2.) / np.sin(inc_angle)
#Trim edges
v_radial_ests = v_radial_ests[:, az_guard:-az_guard, 5:-5]
v_horizo_ests = v_horizo_ests[:, az_guard:-az_guard, 5:-5]
output.write('--------------------------------------------\n')
output.write('ESTIMATED RADIAL VELOCITY - NO SMOOTHING\n')
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('MEAN(EST. V) = %.4f\n' %
np.mean(v_radial_ests[pind]))
output.write('STD(EST. V) = %.4f\n' % np.std(v_radial_ests[pind]))
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write(
'ESTIMATED RADIAL VELOCITY - SMOOTHING (WIN. SIZE=%dx%d)\n' %
(az_ml, rg_ml))
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('MEAN(EST. V) = %.4f\n' % np.mean(
utils.smooth(utils.smooth(v_radial_ests[pind], rg_ml, axis=1),
az_ml,
axis=0)))
output.write('STD(EST. V) = %.4f\n' % np.std(
utils.smooth(utils.smooth(v_radial_ests[pind], rg_ml, axis=1),
az_ml,
axis=0)))
output.write('--------------------------------------------\n\n')
output.write('--------------------------------------------\n')
output.write('ESTIMATED HORIZONTAL VELOCITY - NO SMOOTHING\n')
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('MEAN(EST. V) = %.4f\n' %
np.mean(v_horizo_ests[pind]))
output.write('STD(EST. V) = %.4f\n' % np.std(v_horizo_ests[pind]))
output.write('--------------------------------------------\n\n')
# Processed NRCS
NRCS_est_avg = 10 * np.log10(
np.mean(np.mean(i_all[:, :, az_guard:-az_guard, 5:-5], axis=-1),
axis=-1))
output.write('--------------------------------------------\n')
for pind in range(npol):
output.write("%s Polarization\n" % polt[pind])
output.write('Estimated mean NRCS = %5.2f\n' % NRCS_est_avg[0, pind])
output.write('--------------------------------------------\n\n')
# Some bookkeeping information
output.write('--------------------------------------------\n')
output.write('GROUND RANGE GRID SPACING = %.4f\n' % grg_grid_spacing)
output.write('AZIMUTH GRID SPACING = %.4f\n' % az_grid_spacing)
output.write('--------------------------------------------\n\n')
output.close()
if plot_vel_hist and num_ch > 1:
# PLOT RADIAL VELOCITY
plt.figure()
plt.hist(v_radial_surf.flatten(),
200,
density=True,
histtype='step',
label='True')
for pind in range(npol):
plt.hist(v_radial_ests[pind].flatten(),
200,
density=True,
histtype='step',
label=polt[pind])
plt.grid(True)
plt.xlim([
-np.abs(v_radial_surf_mean) - 4. * v_radial_surf_std,
np.abs(v_radial_surf_mean) + 4. * v_radial_surf_std
])
plt.xlabel('Radial velocity [m/s]')
plt.ylabel('PDF')
plt.title('Estimated velocity')
plt.legend()
if plot_save:
plt.savefig(plot_path + os.sep + 'ATI_radial_vel_hist.' +
plot_format)
plt.close()
else:
plt.show()
# Save some statistics to npz file
#
if num_ch > 1:
filenpz = os.path.join(os.path.dirname(output_file), 'ati_stats.npz')
# Mean coh
cohs = np.array(cohs)[:, az_guard:-az_guard, 5:-5]
np.savez(filenpz,
nrcs=NRCS_est_avg,
v_r_dop=np.mean(np.mean(v_radial_ests, axis=-1), axis=-1),
v_r_surf=v_radial_surf_mean,
v_r_surf_std=v_radial_surf_std,
coh_mean=np.mean(np.mean(cohs, axis=-1), axis=-1),
abscoh_mean=np.mean(np.mean(np.abs(cohs), axis=-1), axis=-1),
coh_lut=coh_lut,
pols=polt)
print('----------------------------------------')
print(
time.strftime("ATI Processing finished [%Y-%m-%d %H:%M:%S]",
time.localtime()))
print('----------------------------------------')