def test_spatiotemporalbufferanalysis_dataframes(self):
stba = pls.SpatioTemporalBufferAnalysis(self.landscape_fps,
self.base_mask,
self.buffer_dists,
dates=self.dates)
# test that the data frames that result from `compute_class_metrics_df`
# and `compute_landscape_metrics_df` are well constructed
class_metrics_df = stba.compute_class_metrics_df()
self.assertTrue(
np.all(class_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.present_classes, stba.dates])))
landscape_metrics_df = stba.compute_landscape_metrics_df()
self.assertTrue(
np.all(landscape_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.dates])))
# now test the same but with an analysis that only considers a
# subset of metrics and a subset of classes
metrics = ['total_area', 'edge_density', 'proportion_of_landscape']
classes = stba.present_classes[:2]
class_metrics_df = stba.compute_class_metrics_df(metrics=metrics,
classes=classes)
self.assertTrue(
np.all(class_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, classes, stba.dates])))
# 'proportion_of_landscape' cannot be computed at the landscape level
# (TODO: test for that elsewhere)
landscape_metrics = metrics[:2]
landscape_metrics_df = stba.compute_landscape_metrics_df(
metrics=landscape_metrics)
self.assertTrue(
np.all(landscape_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.dates])))
def test_spatiotemporalbufferanalysis_init(self):
# we will just test the base init, the rest of functionalities have
# already been tested above (in `TestSpatioTemporalAnalysis` and
# `TestGradientAnalysis`)
stba = pls.SpatioTemporalBufferAnalysis(
self.landscape_fps, self.base_mask, self.buffer_dists,
dates=self.dates)
self.assertEqual(len(stba.buffer_dists), len(stba.stas))
for sta in stba.stas:
self.assertEqual(sta.dates, self.dates)
def test_spatiotemporalbufferanalysis_plot_metric(self):
stba = pls.SpatioTemporalBufferAnalysis(
self.landscape_fps, self.base_mask, self.buffer_dists)
# test for `None` (landscape-level) and an existing class (class-level)
for class_val in [None, stba.stas[0].classes[0]]:
ax = stba.plot_metric('patch_density', class_val=class_val)
# test that there is a line for each buffer distance
self.assertEqual(len(ax.lines), len(self.buffer_dists))
# test that there is a legend label for each buffer distance
handles, labels = ax.get_legend_handles_labels()
self.assertEqual(len(labels), len(self.buffer_dists))
def test_spatiotemporalbufferanalysis_dataframes(self):
stba = pls.SpatioTemporalBufferAnalysis(self.landscape_fps,
self.base_mask,
self.buffer_dists,
dates=self.dates)
# test that `class_metrics_df` and `landscape_metrics_df` are well
# constructed
class_metrics_df = stba.class_metrics_df
self.assertTrue(
np.all(class_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.classes, stba.dates])))
landscape_metrics_df = stba.landscape_metrics_df
self.assertTrue(
np.all(landscape_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.dates])))
# now test the same but with an analysis that only considers a
# subset of metrics and a subset of classes
stba_metrics = [
'total_area', 'edge_density', 'proportion_of_landscape'
]
stba_classes = stba.classes[:2]
stba = pls.SpatioTemporalBufferAnalysis(self.landscape_fps,
self.base_mask,
self.buffer_dists,
metrics=stba_metrics,
classes=stba_classes,
dates=self.dates)
class_metrics_df = stba.class_metrics_df
self.assertTrue(
np.all(class_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.classes, stba.dates])))
landscape_metrics_df = stba.landscape_metrics_df
self.assertTrue(
np.all(landscape_metrics_df.index == pd.MultiIndex.from_product(
[stba.buffer_dists, stba.dates])))
def test_plot_landscapes(self):
stba = pls.SpatioTemporalBufferAnalysis(self.landscape_fps,
self.base_mask,
self.buffer_dists)
fig = stba.plot_landscapes()
# there must be one column for each buffer distance and one row for
# each date
self.assertEqual(len(fig.axes),
len(stba.buffer_dists) * len(stba.dates))
# returned axes must be instances of matplotlib axes
for ax in fig.axes:
self.assertIsInstance(ax, plt.Axes)
# test that by default, the dimensions of the resulting will come from
# matplotlib's settings
rc_figwidth, rc_figheight = plt.rcParams['figure.figsize']
figwidth, figheight = fig.get_size_inches()
# the actual `figwidth` must be `len(stba.buffer_dists) * rc_figwidth`
# and `figheight` must be `len(stba.dates) * rc_figheight`
self.assertAlmostEqual(figwidth, len(stba.buffer_dists) * rc_figwidth)
self.assertAlmostEqual(figheight, len(stba.dates) * rc_figheight)
# if instead, we customize the figure size, the dimensions of the
# resulting figure must be the customized ones
custom_figsize = (10, 10)
fig = stba.plot_landscapes(subplots_kws={'figsize': custom_figsize})
figwidth, figheight = fig.get_size_inches()
self.assertAlmostEqual(custom_figsize[0], figwidth)
self.assertAlmostEqual(custom_figsize[1], figheight)
# first row has the date as title
for date, ax in zip(stba.dates, fig.axes):
self.assertEqual(str(date), ax.get_title())
# first column has the buffer distance as `ylabel`
for buffer_dist, i in zip(stba.buffer_dists,
range(0, len(fig.axes), len(stba.dates))):
self.assertEqual(str(buffer_dist), fig.axes[i].get_ylabel())
