1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223 | # This Python module is part of the PyRate software package.
#
# Copyright 2022 Geoscience Australia
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
This Python module contains tests for the APS PyRate module.
"""
import os
import shutil
import pytest
import numpy as np
from os.path import join
from scipy.ndimage import gaussian_filter1d, gaussian_filter
from numpy.testing import assert_array_almost_equal
import pyrate.constants as C
from pyrate import conv2tif, prepifg, correct
from pyrate.configuration import Configuration, MultiplePaths
from pyrate.core import shared
from pyrate.core.aps import spatio_temporal_filter, _interpolate_nans_2d, _kernel
from pyrate.core.aps import gaussian_temporal_filter as tlpfilter, gaussian_spatial_filter as slpfilter
from pyrate.core.shared import Ifg
from pyrate.core.ifgconstants import DAYS_PER_YEAR
from tests import common
from tests.common import BASE_TEST, PY37GDAL304
@pytest.fixture(params=["linear", "nearest", "cubic"])
def slpnanfill_method(request):
return request.param
@pytest.fixture(params=[0.1, 0.5, 1, 5])
def slpfcutoff_method(request):
return request.param
@pytest.fixture(params=[0.001, 0.01])
def slpfcutoff(request):
return request.param
def test_interpolate_nans_2d(slpnanfill_method):
arr = np.random.rand(200, 100)
arr[arr < 0.1] = np.nan # insert some nans
assert np.sum(np.isnan(arr)) != 0 # some nans present
_interpolate_nans_2d(arr, method=slpnanfill_method)
assert np.sum(np.isnan(arr)) == 0 # should not be any nans
class TestSpatialFilter:
"""
Test the implementation of Gaussian spatial filter
"""
def setup_method(self):
ifg_path = join(str(BASE_TEST), 'cropB', '20180106-20180130_ifg.tif')
ifg = Ifg(ifg_path)
ifg.open()
p = ifg.phase_data
self.x_size = ifg.x_size
self.y_size = ifg.y_size
# convert zeros to NaNs
p[p == 0] = np.nan
self.phase = p
def test_gaussian_filter(self, slpfcutoff_method):
"""
Compare against scipy.ndimage.gaussian_filter,
that operates in the spatial domain on data with equal resolution in x and y
"""
e = gaussian_filter(self.phase, sigma=slpfcutoff_method)
r = slpfilter(self.phase, cutoff=slpfcutoff_method,
x_size=self.x_size, y_size=self.y_size)
# pull data from middle of images; away from potential edge effects
exp = e[50:150, 50:150]
res = r[50:150, 50:150]
assert_array_almost_equal(res, exp, 0)
def test_gaussian_kernel():
"""
Test the Gaussian smoothing kernel
"""
x = np.arange(1, 10, 2)
res = _kernel(x, 3)
exp = np.array([0.94595947, 0.60653066, 0.24935221, 0.06572853, 0.011109])
np.testing.assert_array_almost_equal(res, exp, decimal=6)
res = _kernel(x, 4)
exp = np.array([0.96923323, 0.7548396, 0.45783336, 0.21626517, 0.07955951])
np.testing.assert_array_almost_equal(res, exp, decimal=6)
res = _kernel(x, 0.001)
exp = np.array([0, 0, 0, 0, 0])
np.testing.assert_array_equal(res, exp)
class TestTemporalFilter:
"""
Tests for the temporal filter with synthetic data for a single pixel
"""
def setup_method(self):
self.thr = 1 # no nans in these test cases, threshold = 1
# instance of normally distributed noise
n = np.array([-0.36427456, 0.69539061, 0.42181139, -2.56306134,
0.55844095, -0.65562626, 0.65607911, 1.19431637,
-1.43837395, -0.91656358])
# synthetic incremental displacement
d = np.array([1., 1., 0.7, 0.3, 0., 0.1, 0.2, 0.6, 1., 1.])
# incremental displacement + noise
self.tsincr = d * 2 + n
# regular time series, every 12 days
self.interval = 12 / DAYS_PER_YEAR # 0.03285 years
intv = np.ones(d.shape, dtype=np.float32) * self.interval
self.span = np.cumsum(intv)
def test_tlpfilter_repeatability(self):
"""
TEST 1: check for repeatability against expected result from
tlpfilter. Cutoff equal to sampling interval (sigma=1)
"""
res = tlpfilter(self.tsincr, self.interval, self.span, self.thr)
exp = np.array([1.9936507, 1.9208364, 1.0252733, -0.07402889,
-0.1842336, 0.24325351, 0.94737214, 1.3890865,
1.1903466, 1.0036403])
np.testing.assert_array_almost_equal(res, exp, decimal=6)
def test_tlpfilter_scipy_sig1(self):
"""
TEST 2: compare tlpfilter to scipy.ndimage.gaussian_filter1d. Works for
regularly sampled data. Cutoff equal to sampling interval (sigma=1)
"""
res = tlpfilter(self.tsincr, self.interval, self.span, self.thr)
exp = gaussian_filter1d(self.tsincr, sigma=1)
np.testing.assert_array_almost_equal(res, exp, decimal=1)
def test_tlpfilter_scipy_sig2(self):
"""
TEST 3: compare tlpfilter to scipy.ndimage.gaussian_filter1d. Works for
regularly sampled data. Cutoff equal to twice the sampling interval (sigma=2)
"""
res = tlpfilter(self.tsincr, self.interval * 2, self.span, self.thr)
exp = gaussian_filter1d(self.tsincr, sigma=2)
np.testing.assert_array_almost_equal(res, exp, decimal=1)
def test_tlpfilter_scipy_sig05(self):
"""
TEST 4: compare tlpfilter to scipy.ndimage.gaussian_filter1d. Works for
regularly sampled data. Cutoff equal to half the sampling interval (sigma=0.5)
"""
res = tlpfilter(self.tsincr, self.interval * 0.5, self.span, self.thr)
exp = gaussian_filter1d(self.tsincr, sigma=0.5)
np.testing.assert_array_almost_equal(res, exp, decimal=2)
@pytest.mark.slow
@pytest.mark.skipif(not PY37GDAL304, reason="Only run in one CI env")
class TestAPSErrorCorrectionsOnDiscReused:
@classmethod
def setup_method(cls):
cls.conf = common.TEST_CONF_GAMMA
params = Configuration(cls.conf).__dict__
conv2tif.main(params)
params = Configuration(cls.conf).__dict__
prepifg.main(params)
cls.params = Configuration(cls.conf).__dict__
correct._copy_mlooked(cls.params)
correct._update_params_with_tiles(cls.params)
correct._create_ifg_dict(cls.params)
multi_paths = cls.params[C.INTERFEROGRAM_FILES]
cls.ifg_paths = [p.tmp_sampled_path for p in multi_paths]
cls.ifgs = [shared.Ifg(i) for i in cls.ifg_paths]
for i in cls.ifgs:
i.open()
shared.save_numpy_phase(cls.ifg_paths, cls.params)
correct.mst_calc_wrapper(cls.params)
@classmethod
def teardown_method(cls):
shutil.rmtree(cls.params[C.OUT_DIR])
def test_aps_error_files_on_disc(self, slpnanfill_method, slpfcutoff):
self.params[C.SLPF_NANFILL_METHOD] = slpnanfill_method
self.params[C.SLPF_CUTOFF] = slpfcutoff
spatio_temporal_filter(self.params)
# test_orb_errors_written
aps_error_files = [MultiplePaths.aps_error_path(i, self.params) for i in self.ifg_paths]
assert all(p.exists() for p in aps_error_files)
last_mod_times = [os.stat(o).st_mtime for o in aps_error_files]
phase_prev = [i.phase_data for i in self.ifgs]
# run aps error removal again
spatio_temporal_filter(self.params)
aps_error_files2 = [MultiplePaths.aps_error_path(i, self.params) for i in self.ifg_paths]
# if files are written again - times will change
last_mod_times_2 = [os.stat(o).st_mtime for o in aps_error_files2]
# test_aps_error_reused_if_params_unchanged
assert all(a == b for a, b in zip(last_mod_times, last_mod_times_2))
phase_now = [i.phase_data for i in self.ifgs]
# run aps error correction once mroe
spatio_temporal_filter(self.params)
aps_error_files3 = [MultiplePaths.aps_error_path(i, self.params) for i in self.ifg_paths]
last_mod_times_3 = [os.stat(o).st_mtime for o in aps_error_files3]
assert all(a == b for a, b in zip(last_mod_times, last_mod_times_3))
phase_again = [i.phase_data for i in self.ifgs]
np.testing.assert_array_equal(phase_prev, phase_now)
np.testing.assert_array_equal(phase_prev, phase_again)
|