def ps_topofit_fun(phase: np.ndarray, bperp_meaned: np.ndarray, nr_trial_wraps: float):
# To make sure that the results are correct we transform bperp_meaned into column matrix
if (len(bperp_meaned.shape) == 1):
bperp_meaned = ArrayUtils.to_col_matrix(bperp_meaned)
# The result of get_nr_trial_wraps is not correct in this case, so we need to find it again
bperp_range = np.amax(bperp_meaned) - np.amin(bperp_meaned)
CONST = 8 * nr_trial_wraps # todo what const? Why 8
trial_multi_start = -np.ceil(CONST)
trial_multi_end = np.ceil(CONST)
trial_multi = ArrayUtils.arange_include_last(trial_multi_start, trial_multi_end, 1)
trial_phase = bperp_meaned / bperp_range * math.pi / 4
trial_phase = np.exp(np.outer(-1j * trial_phase, trial_multi))
# In order to successfully multiply, we need to transform 'phase' array to column matrix
phase = ArrayUtils.to_col_matrix(phase)
phase_tile = np.tile(phase, (1, len(trial_multi)))
phaser = np.multiply(trial_phase, phase_tile)
phaser_sum = MatlabUtils.sum(phaser)
phase_abs_sum = MatlabUtils.sum(np.abs(phase))
trial_coherence = np.abs(phaser_sum) / phase_abs_sum
trial_coherence_max_ind = np.where(trial_coherence == MatlabUtils.max(trial_coherence))
k_0 = (math.pi / 4 / bperp_range) * trial_multi[trial_coherence_max_ind][0]
re_phase = np.multiply(phase, np.exp(-1j * (k_0 * bperp_meaned)))
phase_offset = MatlabUtils.sum(re_phase)
re_phase = np.angle(re_phase * phase_offset.conjugate())
weigth = np.abs(phase)
bperp_meaned_weighted = weigth * bperp_meaned
re_phase_weighted = weigth * re_phase
# Numpy linalg functions work only with 2d array
if len(bperp_meaned_weighted.shape) > 2:
bperp_meaned_weighted = bperp_meaned_weighted[0]
if len(re_phase_weighted.shape) > 2:
re_phase_weighted = re_phase_weighted[0]
mopt = np.linalg.lstsq(bperp_meaned_weighted, re_phase_weighted)[0][0]
# In StaMPS k0
k_0 = k_0 + mopt
phase_residual = np.multiply(phase, np.exp(-1j * (k_0 * bperp_meaned)))
phase_residual_sum = MatlabUtils.sum(phase_residual)
# In StaMPS c0
static_offset = np.angle(phase_residual_sum)
# In StaMPS coh0
coherence_0 = np.abs(phase_residual_sum) / MatlabUtils.sum(np.abs(phase_residual))
return phase_residual, coherence_0, static_offset, k_0
def test_load_files(self):
self.__start_process()
ps1_mat = scipy.io.loadmat(os.path.join(self._PATCH_1_FOLDER, 'ps1.mat'))
# These are saved using Matlab 7.3
ph1 = self.__load_mat73(os.path.join(self._PATCH_1_FOLDER, 'ph1.mat'), 'ph')
bp1 = self.__load_mat73(os.path.join(self._PATCH_1_FOLDER, 'bp1.mat'), 'bperp_mat')
da1 = self.__load_mat73(os.path.join(self._PATCH_1_FOLDER, 'da1.mat'), 'D_A')
la1 = self.__load_mat73(os.path.join(self._PATCH_1_FOLDER, 'la1.mat'), 'la')
hgt1 = self.__load_mat73(os.path.join(self._PATCH_1_FOLDER, 'hgt1.mat'), 'hgt')
self.assertEqual(len(self._ps_files.bperp), len(bp1))
np.testing.assert_allclose(self._ps_files.bperp, bp1)
self.assertEqual(len(self._ps_files.da), len(da1))
# Loadmat results are array of arrays
np.testing.assert_allclose(np.reshape(self._ps_files.da, (len(self._ps_files.da), 1)), da1)
ps1_mat_bperp = np.reshape(ps1_mat['bperp'], len(ps1_mat['bperp']))
np.testing.assert_allclose(self._ps_files.bperp_meaned, ps1_mat_bperp)
np.testing.assert_allclose(self._ps_files.pscands_ij.view(np.ndarray), ps1_mat['ij'])
# In our process there isn't first column. That's why we take last two
np.testing.assert_allclose(self._ps_files.xy, ps1_mat['xy'][:, 1:])
self.assertAlmostEqual(self._ps_files.mean_range, ps1_mat['mean_range'])
np.testing.assert_allclose(self._ps_files.mean_incidence.view(np.ndarray),
ps1_mat['mean_incidence'])
np.testing.assert_allclose(self._ps_files.ll, ps1_mat['ll0'])
np.testing.assert_allclose(self._ps_files.lonlat, ps1_mat['lonlat'])
# Because those values aren't added to .mat files so we can only check if these are filled
self.assertNotEqual(self._ps_files.wavelength, 0)
self.assertIsNotNone(self._ps_files.heading)
master_date_days = date.toordinal(self._ps_files.master_date) + 366
self.assertEqual(master_date_days, ps1_mat['master_day'][0])
self.assertEqual(self._ps_files.master_nr, ps1_mat['master_ix'])
ifg_date_days = ArrayUtils.to_col_matrix(
np.array([date.toordinal(x) + 366 for x in self._ps_files.ifg_dates]))
np.testing.assert_array_equal(ifg_date_days, ps1_mat['day'])
np.testing.assert_allclose(self._ps_files.sort_ind.view(np.ndarray), la1)
self.assertEqual(len(self._ps_files.ifgs), ps1_mat['n_ifg'])
self.assertEqual(len(self._ps_files.pscands_ij), ps1_mat['n_ps'])
# hgt1 is array of arrays, need to reshape
np.testing.assert_allclose(self._ps_files.hgt, np.reshape(hgt1, len(hgt1)))
self.assertEqual(len(self._ps_files.ph), len(ph1))
self.assert_ph(self._ps_files.ph, ph1)
def test_start_process_with_matlab_data(self):
def get_keep_ix():
"""Used to get keep_ix array to use in Numpy arrys.
This conversion is needed because in Numpy there is boolean indexing, but on Matlab
there are 1/ 0. For that we make array of boolean using np.where."""
keep_ix = select1_mat['keep_ix']
keep_ix = np.reshape(keep_ix, len(select1_mat['keep_ix']))
keep_ix = np.where(keep_ix == 1)
return keep_ix[0]
self.__fill_est_gamma_with_matlab_data()
self.__start_process()
select1_mat = scipy.io.loadmat(
os.path.join(self._PATCH_1_FOLDER, 'select1.mat'))
# Matlab indexes begin from zero and Numpy arrays from one.
# So we need to add one to Numpy's array
np.testing.assert_array_almost_equal(
np.add(self._ps_select.ifg_ind, 1), select1_mat['ifg_index'][0])
# Reshape because Matlab's array is col-array
np.testing.assert_array_almost_equal(
np.add(self._ps_select.coh_thresh_ind, 1),
select1_mat['ix'].reshape(len(select1_mat['ix'])))
np.testing.assert_array_almost_equal(self._ps_select.ph_patch,
select1_mat['ph_patch2'],
decimal=self._PLACES)
np.testing.assert_array_almost_equal(self._ps_select.k_ps,
select1_mat['K_ps2'])
np.testing.assert_array_almost_equal(self._ps_select.ph_res,
select1_mat['ph_res2'])
np.testing.assert_array_almost_equal(self._ps_select.coh_ps2,
select1_mat['coh_ps2'])
coh_thresh = select1_mat['coh_thresh']
np.testing.assert_array_almost_equal(
ArrayUtils.to_col_matrix(self._ps_select.coh_thresh), coh_thresh)
keep_ix = get_keep_ix()
np.testing.assert_array_almost_equal(self._ps_select.keep_ind,
keep_ix,
decimal=self._PLACES)
def __get_weights(self, da: np.ndarray):
return ArrayUtils.to_col_matrix(np.divide(1, da))
def __drop_noisy(self, data: __DataDTO, selectable_ps: np.ndarray,
ifg_ind: np.ndarray,
edges: np.ndarray) -> (np.ndarray, np.ndarray):
def get_ph_weed(bperp: np.ndarray, k_ps: np.ndarray, ph: np.ndarray,
c_ps: np.ndarray, master_nr: int):
exped = np.exp(-1j * (k_ps * bperp.conj().transpose()))
ph_weed = np.multiply(ph, exped)
ph_weed = np.divide(ph_weed, np.abs(ph_weed))
# Adding master noise. It is done when small_baseline_flag != 'y'. Reshape is needed
# because 'c_ps' is array of array's
ph_weed[:,
(master_nr - 1)] = np.exp(1j * c_ps).reshape(len(ph_weed))
return ph_weed
def get_time_deltas_in_days(index: int) -> np.ndarray:
"""For getting days in ints from date object"""
return np.array([(ifg_dates[index] - ifg_dates[x]).days
for x in np.nditer(ifg_ind)])
def get_dph_mean(dph_space, edges_len, weight_factor):
repmat = np.matlib.repmat(weight_factor, edges_len, 1)
dph_mean = np.sum(np.multiply(dph_space, repmat), axis=1)
return dph_mean
ph_filtered = data.ph[selectable_ps]
k_ps_filtered = data.k_ps[selectable_ps]
c_ps_filtered = data.c_ps[selectable_ps]
bperp_meaned = data.bperp_meaned
master_nr = data.master_nr
ifg_dates = data.ifg_dates
ph_weed = get_ph_weed(bperp_meaned, k_ps_filtered, ph_filtered,
c_ps_filtered, master_nr)
dph_space = np.multiply(ph_weed[edges[:, 2] - 1],
ph_weed[edges[:, 1] - 1].conj())
dph_space = dph_space[:, ifg_ind]
#todo drop_ifg_index logic
# This all is made when small_baseline_flag != 'y'
dph_shape = (len(edges), len(ifg_ind))
dph_smooth = np.zeros(dph_shape).astype(np.complex128)
dph_smooth2 = np.zeros(dph_shape).astype(np.complex128)
for i in range(len(ifg_ind)):
time_delta = get_time_deltas_in_days(i)
weight_factor = np.exp(-(np.power(time_delta, 2)) / 2 /
math.pow(self.__time_win, 2))
weight_factor = weight_factor / np.sum(weight_factor)
dph_mean = get_dph_mean(dph_space, len(edges), weight_factor)
repmat = np.matlib.repmat(
ArrayUtils.to_col_matrix(dph_mean).conj(), 1, len(ifg_ind))
dph_mean_adj = np.angle(np.multiply(dph_space, repmat))
G = np.array([np.ones(len(ifg_ind)), time_delta]).transpose()
# 'm' in Stamps
weighted_least_sqrt = MatlabUtils.lscov(
G,
dph_mean_adj.conj().transpose(), weight_factor)
#todo Find better name
least_sqrt_G = np.asarray(
(np.asmatrix(G) *
np.asmatrix(weighted_least_sqrt)).conj().transpose())
dph_mean_adj = np.angle(np.exp(1j * (dph_mean_adj - least_sqrt_G)))
# 'm2' in Stamps
weighted_least_sqrt2 = MatlabUtils.lscov(
G,
dph_mean_adj.conj().transpose(), weight_factor)
# We don't make transpose for weighted_least_sqrt because it doesn't
# do anything in this case
dph_smooth_val_exp = np.exp(
1j * (weighted_least_sqrt[0, :] + weighted_least_sqrt2[0, :]))
dph_smooth[:, i] = np.multiply(dph_mean, dph_smooth_val_exp)
weight_factor[i] = 0 # Let's make ourselves as zero
dph_smooth2[:, i] = get_dph_mean(dph_space, len(edges),
weight_factor)
dph_noise = np.angle(np.multiply(dph_space, dph_smooth2.conj()))
ifg_var = np.var(dph_noise, 0)
dph_noise = np.angle(np.multiply(dph_space, dph_smooth.conj()))
K_weights = np.divide(1, ifg_var)
K = MatlabUtils.lscov(bperp_meaned,
dph_noise.conj().transpose(),
K_weights).conj().transpose()
dph_noise -= K * bperp_meaned.transpose()
edge_std = MatlabUtils.std(dph_noise, axis=1)
edge_max = np.max(np.abs(dph_noise), axis=1)
return edge_std, edge_max