def test_enough_target_pixels_true(self):
data = np.zeros((10, 10, 1), dtype=np.uint8)
data[4:, 4:, :] = 1
null_class_id = 2
raster_source = MockRasterSource([0], 1)
raster_source.set_raster(data)
label_source = SemanticSegmentationLabelSource(raster_source,
null_class_id)
with label_source.activate():
extent = Box(0, 0, 10, 10)
self.assertTrue(label_source.enough_target_pixels(extent, 30, [1]))
def test_get_labels(self):
data = np.zeros((10, 10, 1), dtype=np.uint8)
data[7:, 7:, 0] = 1
null_class_id = 2
raster_source = MockRasterSource([0], 1)
raster_source.set_raster(data)
label_source = SemanticSegmentationLabelSource(raster_source,
null_class_id)
with label_source.activate():
window = Box.make_square(7, 7, 3)
labels = label_source.get_labels(window=window)
label_arr = labels.get_label_arr(window)
expected_label_arr = np.ones((3, 3))
np.testing.assert_array_equal(label_arr, expected_label_arr)
def test_compute_ignore_class(self):
class_config = ClassConfig(names=['one', 'two'])
class_config.update()
class_config.ensure_null_class()
null_class_id = class_config.get_null_class_id()
gt_array = np.zeros((4, 4, 1), dtype=np.uint8)
gt_array[0, 0, 0] = 2
gt_raster = MockRasterSource([0], 1)
gt_raster.set_raster(gt_array)
gt_label_source = SemanticSegmentationLabelSource(
gt_raster, null_class_id)
pred_array = np.zeros((4, 4, 1), dtype=np.uint8)
pred_array[0, 0, 0] = 1
pred_raster = MockRasterSource([0], 1)
pred_raster.set_raster(pred_array)
pred_label_source = SemanticSegmentationLabelSource(
pred_raster, null_class_id)
eval = SemanticSegmentationEvaluation(class_config)
eval.compute(gt_label_source.get_labels(),
pred_label_source.get_labels())
self.assertAlmostEqual(1.0, eval.class_to_eval_item[0].f1)
self.assertAlmostEqual(1.0, eval.avg_item.f1)
def test_get_labels_rgb(self):
data = np.zeros((10, 10, 3), dtype=np.uint8)
data[7:, 7:, :] = [1, 1, 1]
null_class_id = 2
raster_source = MockRasterSource([0, 1, 2], 3)
raster_source.set_raster(data)
rgb_class_config = ClassConfig(names=['a'], colors=['#010101'])
rgb_class_config.ensure_null_class()
label_source = SemanticSegmentationLabelSource(
raster_source, null_class_id, rgb_class_config=rgb_class_config)
with label_source.activate():
window = Box.make_square(7, 7, 3)
labels = label_source.get_labels(window=window)
label_arr = labels.get_label_arr(window)
expected_label_arr = np.zeros((3, 3))
np.testing.assert_array_equal(label_arr, expected_label_arr)
def test_compute(self):
class_config = ClassConfig(names=['one', 'two'])
class_config.update()
class_config.ensure_null_class()
null_class_id = class_config.get_null_class_id()
gt_array = np.zeros((4, 4, 1), dtype=np.uint8)
gt_array[2, 2, 0] = 1
gt_array[0, 0, 0] = 2
gt_raster = MockRasterSource([0], 1)
gt_raster.set_raster(gt_array)
gt_label_source = SemanticSegmentationLabelSource(
gt_raster, null_class_id)
p_array = np.zeros((4, 4, 1), dtype=np.uint8)
p_array[1, 1, 0] = 1
p_raster = MockRasterSource([0], 1)
p_raster.set_raster(p_array)
p_label_source = SemanticSegmentationLabelSource(
p_raster, null_class_id)
eval = SemanticSegmentationEvaluation(class_config)
eval.compute(gt_label_source.get_labels(), p_label_source.get_labels())
tp0 = 16 - 3 # 4*4 - 3 true positives for class 0
fp0 = 1 # 1 false positive (2,2) and one don't care at (0,0)
fn0 = 1 # one false negative (1,1)
precision0 = float(tp0) / (tp0 + fp0)
recall0 = float(tp0) / (tp0 + fn0)
f10 = 2 * float(precision0 * recall0) / (precision0 + recall0)
tp1 = 0 # 0 true positives for class 1
fn1 = 1 # one false negative (2,2)
precision1 = 0 # float(tp1) / (tp1 + fp1) where fp1 == 1
recall1 = float(tp1) / (tp1 + fn1)
f11 = None
self.assertAlmostEqual(precision0,
eval.class_to_eval_item[0].precision)
self.assertAlmostEqual(recall0, eval.class_to_eval_item[0].recall)
self.assertAlmostEqual(f10, eval.class_to_eval_item[0].f1)
self.assertEqual(precision1, eval.class_to_eval_item[1].precision)
self.assertAlmostEqual(recall1, eval.class_to_eval_item[1].recall)
self.assertAlmostEqual(f11, eval.class_to_eval_item[1].f1)
avg_conf_mat = np.array([[0, 0, 0], [13., 1, 0], [1, 0, 0]])
avg_recall = (14 / 15) * recall0 + (1 / 15) * recall1
self.assertTrue(np.array_equal(avg_conf_mat, eval.avg_item.conf_mat))
self.assertEqual(avg_recall, eval.avg_item.recall)
def get_vector_scene(self, class_id, use_aoi=False):
gt_uri = data_file_path('{}-gt-polygons.geojson'.format(class_id))
pred_uri = data_file_path('{}-pred-polygons.geojson'.format(class_id))
scene_id = str(class_id)
rs = MockRasterSource(channel_order=[0, 1, 3], num_channels=3)
rs.set_raster(np.zeros((10, 10, 3)))
crs_transformer = IdentityCRSTransformer()
extent = Box.make_square(0, 0, 360)
config = RasterizedSourceConfig(
vector_source=GeoJSONVectorSourceConfig(uri=gt_uri,
default_class_id=0),
rasterizer_config=RasterizerConfig(background_class_id=1))
gt_rs = config.build(self.class_config, crs_transformer, extent)
gt_ls = SemanticSegmentationLabelSource(gt_rs, self.null_class_id)
config = RasterizedSourceConfig(
vector_source=GeoJSONVectorSourceConfig(uri=pred_uri,
default_class_id=0),
rasterizer_config=RasterizerConfig(background_class_id=1))
pred_rs = config.build(self.class_config, crs_transformer, extent)
pred_ls = SemanticSegmentationLabelSource(pred_rs, self.null_class_id)
pred_ls.vector_output = [
PolygonVectorOutputConfig(uri=pred_uri,
denoise=0,
class_id=class_id)
]
if use_aoi:
aoi_uri = data_file_path('{}-aoi.geojson'.format(class_id))
aoi_geojson = file_to_json(aoi_uri)
aoi_polygons = [shape(aoi_geojson['features'][0]['geometry'])]
return Scene(scene_id, rs, gt_ls, pred_ls, aoi_polygons)
return Scene(scene_id, rs, gt_ls, pred_ls)
def _test(self, is_random=False):
stats_uri = os.path.join(self.tmp_dir.name, 'stats.json')
scenes = []
raster_sources = []
imgs = []
sample_prob = 0.5
for i in range(3):
rs = MockRasterSource([0, 1, 2], 3)
img = np.zeros((600, 600, 3))
img[:, :, 0] = 1 + i
img[:, :, 1] = 2 + i
img[:, :, 2] = 3 + i
if not is_random:
img[300:, 300:, :] = np.nan
imgs.append(img)
rs.set_raster(img)
raster_sources.append(rs)
scenes.append(Scene(str(i), rs))
channel_vals = list(map(lambda x: np.expand_dims(x, axis=0), imgs))
channel_vals = np.concatenate(channel_vals, axis=0)
channel_vals = np.transpose(channel_vals, [3, 0, 1, 2])
channel_vals = np.reshape(channel_vals, (3, -1))
exp_means = np.nanmean(channel_vals, axis=1)
exp_stds = np.nanstd(channel_vals, axis=1)
analyzer_cfg = StatsAnalyzerConfig(output_uri=stats_uri,
sample_prob=None)
if is_random:
analyzer_cfg = StatsAnalyzerConfig(output_uri=stats_uri,
sample_prob=sample_prob)
analyzer = analyzer_cfg.build()
analyzer.process(scenes, self.tmp_dir.name)
stats = RasterStats.load(stats_uri)
np.testing.assert_array_almost_equal(stats.means, exp_means, decimal=3)
np.testing.assert_array_almost_equal(stats.stds, exp_stds, decimal=3)
if is_random:
for rs in raster_sources:
width = rs.get_extent().get_width()
height = rs.get_extent().get_height()
exp_num_chips = round(
((width * height) / (chip_sz**2)) * sample_prob)
self.assertEqual(rs.mock._get_chip.call_count, exp_num_chips)
def get_scene(self, class_id):
# Make scene where ground truth is all set to class_id
# and predictions are set to half 0's and half 1's
scene_id = str(class_id)
rs = MockRasterSource(channel_order=[0, 1, 2], num_channels=3)
rs.set_raster(np.zeros((10, 10, 3)))
gt_rs = MockRasterSource(channel_order=[0], num_channels=1)
gt_arr = np.full((10, 10, 1), class_id)
gt_rs.set_raster(gt_arr)
gt_ls = SemanticSegmentationLabelSource(gt_rs, self.null_class_id)
pred_rs = MockRasterSource(channel_order=[0], num_channels=1)
pred_arr = np.zeros((10, 10, 1))
pred_arr[5:10, :, :] = 1
pred_rs.set_raster(pred_arr)
pred_ls = SemanticSegmentationLabelSource(pred_rs, self.null_class_id)
return Scene(scene_id, rs, gt_ls, pred_ls)