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())