def create_spatial_layer(tile):
layer = [(ProjectedExtent(e_1, proj4=crs), tile),
(ProjectedExtent(e_2, proj4=crs), tile),
(ProjectedExtent(e_3, proj4=crs), tile),
(ProjectedExtent(e_4, proj4=crs), tile)]
return layer
def test_to_spatial_raster_layer(self):
actual = [k for k, v in self.raster_rdd.to_spatial_layer().to_numpy_rdd().collect()]
expected = [
ProjectedExtent(Extent(0, 0, 1, 1), 3857),
ProjectedExtent(Extent(1, 0, 2, 1), 3857),
ProjectedExtent(Extent(0, 1, 1, 2), 3857),
ProjectedExtent(Extent(1, 1, 2, 2), 3857)
]
for a, e in zip(actual, expected):
self.assertEqual(a, e)
def test_to_spatial_raster_layer(self):
actual = self.raster_rdd.to_spatial_layer().to_numpy_rdd().keys(
).collect()
expected = [
ProjectedExtent(Extent(0, 0, 1, 1), 3857),
ProjectedExtent(Extent(1, 0, 2, 1), 3857),
ProjectedExtent(Extent(0, 1, 1, 2), 3857),
ProjectedExtent(Extent(1, 1, 2, 2), 3857)
]
for x in actual:
self.assertTrue(x in expected)
def test_local_pyramid(self):
arr = np.zeros((1, 250, 250))
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
tile = Tile(arr, 'FLOAT', None)
projected_extent = ProjectedExtent(extent, epsg_code)
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
laid_out = raster_rdd.tile_to_layout(LocalLayout(250))
# Single tile is at level 0
result = laid_out.pyramid()
assert result.max_zoom == 0
laid_out = raster_rdd.tile_to_layout(LocalLayout(25))
result = laid_out.pyramid()
assert result.max_zoom == 4
assert result.levels[4].layer_metadata.tile_layout.layoutCols == 10
assert result.levels[3].layer_metadata.tile_layout.layoutCols == 5
assert result.levels[2].layer_metadata.tile_layout.layoutCols == 3
assert result.levels[1].layer_metadata.tile_layout.layoutCols == 2
assert result.levels[0].layer_metadata.tile_layout.layoutCols == 1
def from_pb_projected_extent(pb_projected_extent):
"""Creates a ``ProjectedExtent`` from a ``ProtoProjectedExtent``.
Args:
pb_projected_extent (ProtoProjectedExtent): An instance of ``ProtoProjectedExtent``.
Returns:
:class:`~geopyspark.geotrellis.ProjectedExtent`
"""
if pb_projected_extent.crs.epsg is not 0:
return ProjectedExtent(extent=from_pb_extent(pb_projected_extent.extent),
epsg=pb_projected_extent.crs.epsg)
else:
return ProjectedExtent(extent=from_pb_extent(pb_projected_extent.extent),
proj4=pb_projected_extent.crs.proj4)
def test_projected_extent(self):
pes = [
ProjectedExtent(extent=self.extents[0], epsg=self.crs),
ProjectedExtent(extent=self.extents[1], epsg=self.crs),
ProjectedExtent(extent=self.extents[2], epsg=self.crs),
ProjectedExtent(extent=self.extents[3], epsg=self.crs)
]
pe_layer = [(pes[0], self.tile), (pes[1], self.tile),
(pes[2], self.tile), (pes[3], self.tile)]
rdd = self.pysc.parallelize(pe_layer)
layer = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
actual = layer.collect_keys()
for x in actual:
self.assertTrue(x in pes)
def test_projected_extent(self):
pes = [
ProjectedExtent(extent=self.extents[0], epsg=self.crs),
ProjectedExtent(extent=self.extents[1], epsg=self.crs),
]
pe_layer = [(pes[0], self.tile_1), (pes[0], self.tile_2),
(pes[1], self.tile_1), (pes[1], self.tile_2)]
rdd = self.pysc.parallelize(pe_layer)
layer = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
actual = layer.merge()
self.assertEqual(actual.srdd.rdd().count(), 2)
for k, v in actual.to_numpy_rdd().collect():
self.assertTrue((v.cells == self.arr_2).all())
def test_to_spatial_target_time_raster_layer(self):
converted = self.raster_rdd.to_spatial_layer(target_time=self.time_1)
keys = converted.to_numpy_rdd().keys().collect()
values = converted.to_numpy_rdd().values().collect()
expected = [
ProjectedExtent(Extent(0, 0, 1, 1), 3857),
ProjectedExtent(Extent(1, 0, 2, 1), 3857),
ProjectedExtent(Extent(0, 1, 1, 2), 3857),
ProjectedExtent(Extent(1, 1, 2, 2), 3857)
]
for x in keys:
self.assertTrue(x in expected)
for x in values:
self.assertEqual(x.cells.shape, self.tile_1.cells.shape)
self.assertTrue((x.cells == 1.0).all())
class UnionSpatialTest(BaseTestClass):
projected_extent_1 = ProjectedExtent(extent, epsg_code)
projected_extent_2 = ProjectedExtent(extent_2, epsg_code)
arr = np.zeros((1, 16, 16))
tile = Tile(arr, 'FLOAT', -500.0)
rdd_1 = BaseTestClass.pysc.parallelize([(projected_extent_1, tile)])
rdd_2 = BaseTestClass.pysc.parallelize([(projected_extent_2, tile)])
layer_1 = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd_1)
layer_2 = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd_2)
tiled_layer_1 = layer_1.tile_to_layout(GlobalLayout())
tiled_layer_2 = layer_2.tile_to_layout(GlobalLayout())
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_union_of_raster_layers(self):
result = union(self.layer_1, self.layer_2)
self.assertTrue(result.srdd.rdd().count(), 2)
def test_union_of_tiled_raster_layers(self):
result = union(self.tiled_layer_1, self.tiled_layer_2)
bounds_1 = self.tiled_layer_1.layer_metadata.bounds
bounds_2 = self.tiled_layer_2.layer_metadata.bounds
min_col = min(bounds_1.minKey.col, bounds_2.minKey.col)
min_row = min(bounds_1.minKey.row, bounds_2.minKey.row)
max_col = max(bounds_1.maxKey.col, bounds_2.maxKey.col)
max_row = max(bounds_1.maxKey.row, bounds_2.maxKey.row)
min_key = SpatialKey(min_col, min_row)
max_key = SpatialKey(max_col, max_row)
self.assertTrue(result.srdd.rdd().count(), 2)
self.assertEqual(result.layer_metadata.bounds,
Bounds(min_key, max_key))
def test_encoded_pextents(self):
actual_encoded = [projected_extent_encoder(x) for x in self.rdd.collect()]
for x in range(0, len(self.projected_extents)):
self.projected_extents[x]['extent'] = Extent(**self.projected_extents[x]['extent'])
expected_encoded = [
to_pb_projected_extent(ProjectedExtent(**ex)).SerializeToString() for ex in self.projected_extents
]
for actual, expected in zip(actual_encoded, expected_encoded):
self.assertEqual(actual, expected)
def test_encoded_tuples(self):
proto_tuple = tupleMessages_pb2.ProtoTuple()
self.extent['extent'] = Extent(**self.extent['extent'])
proto_extent = to_pb_projected_extent(ProjectedExtent(**self.extent))
proto_multiband = to_pb_multibandtile(self.multiband_dict)
proto_tuple.projectedExtent.CopyFrom(proto_extent)
proto_tuple.tiles.CopyFrom(proto_multiband)
bs = proto_tuple.SerializeToString()
expected_encoded = [self.ser.dumps(x) for x in self.collected]
for expected in expected_encoded:
self.assertEqual(bs, expected)
def test_to_ud_ubyte(self):
arr = np.array([[0.4324323432124, 0.0, 0.0], [1.0, 1.0, 1.0]],
dtype=float)
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
projected_extent = ProjectedExtent(extent, epsg_code)
tile = Tile(arr, 'FLOAT', float('nan'))
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
converted = raster_rdd.convert_data_type(CellType.UINT8,
no_data_value=-1)
tile = converted.to_numpy_rdd().first()
no_data = tile[1].no_data_value
self.assertEqual(no_data, -1)
def test_correct_base(self):
arr = np.zeros((1, 16, 16))
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
tile = Tile(arr, 'FLOAT', False)
projected_extent = ProjectedExtent(extent, epsg_code)
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
tile_layout = TileLayout(32, 32, 16, 16)
new_extent = Extent(-20037508.342789244, -20037508.342789244,
20037508.342789244, 20037508.342789244)
layout_def = LayoutDefinition(new_extent, tile_layout)
laid_out = raster_rdd.tile_to_layout(GlobalLayout(tile_size=16))
result = laid_out.pyramid()
self.pyramid_building_check(result)
def test_no_data_deserialization(self):
arr = np.int16([[[-32768, -32768, -32768, -32768],
[-32768, -32768, -32768, -32768],
[-32768, -32768, -32768, -32768],
[-32768, -32768, -32768, -32768]]])
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
projected_extent = ProjectedExtent(extent, epsg_code)
tile = Tile(arr, 'SHORT', -32768)
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
raster_layer = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
actual_tile = raster_layer.to_numpy_rdd().first()[1]
self.assertEqual(actual_tile.cell_type, tile.cell_type)
self.assertEqual(actual_tile.no_data_value, tile.no_data_value)
self.assertTrue((actual_tile.cells == tile.cells).all())
class MinMaxTest(BaseTestClass):
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
projected_extent = ProjectedExtent(extent, epsg_code)
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_all_zeros(self):
arr = np.zeros((1, 16, 16)).astype('int')
tile = Tile(arr, 'INT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
min_max = raster_rdd.get_min_max()
self.assertEqual((0.0, 0.0), min_max)
def test_multibands(self):
arr = np.array(
[[[1, 1, 1, 1]], [[2, 2, 2, 2]], [[3, 3, 3, 3]], [[4, 4, 4, 4]]],
dtype=int)
tile = Tile(arr, 'INT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
min_max = raster_rdd.get_min_max()
self.assertEqual((1.0, 4.0), min_max)
def test_floating(self):
arr = np.array([[[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0],
[1.5, 1.5, 1.5, 1.5], [2.0, 2.0, 2.0, 2.0]]],
dtype=float)
tile = Tile(arr, 'FLOAT', float('nan'))
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
min_max = raster_rdd.get_min_max()
self.assertEqual((0.0, 2.0), min_max)
def test_pyramid_class(self):
arr = np.zeros((1, 16, 16))
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
tile = Tile(arr, 'FLOAT', False)
projected_extent = ProjectedExtent(extent, epsg_code)
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
tile_layout = TileLayout(1, 1, 16, 16)
reprojected = raster_rdd.tile_to_layout(layout=GlobalLayout(tile_size=16), target_crs=3857)
result = reprojected.pyramid()
hist = result.get_histogram()
self.assertEqual(result.max_zoom, reprojected.zoom_level)
self.assertTrue(set(result.levels.keys()).issuperset(range(1, 13)))
self.assertEqual(hist.mean(), 0.0)
self.assertEqual(hist.min_max(), (0.0, 0.0))
def test_pyraminding_with_partitioner(self):
arr = np.zeros((1, 16, 16))
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
tile = Tile(arr, 'FLOAT', False)
projected_extent = ProjectedExtent(extent, epsg_code)
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
tile_layout = TileLayout(32, 32, 16, 16)
new_extent = Extent(-20037508.342789244, -20037508.342789244, 20037508.342789244,
20037508.342789244)
layout_def = LayoutDefinition(new_extent, tile_layout)
laid_out = raster_rdd.tile_to_layout(GlobalLayout(tile_size=16))
strategy = SpatialPartitionStrategy(4)
pyramided = laid_out.pyramid(partition_strategy=strategy)
self.assertEqual(pyramided.levels[0].get_partition_strategy(), strategy)
class WithNoDataTest(BaseTestClass):
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
projected_extent = ProjectedExtent(extent, epsg_code)
arr = np.zeros((1, 16, 16))
tile = Tile(arr, 'FLOAT', -500.0)
rdd = BaseTestClass.pysc.parallelize([(projected_extent, tile)])
layer = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
tiled_layer = layer.tile_to_layout()
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_with_no_data_raster_layers(self):
no_data_layer = self.layer.with_no_data(-10)
tile = no_data_layer.to_numpy_rdd().first()[1]
self.assertEqual(tile.no_data_value, -10)
metadata = no_data_layer.collect_metadata()
self.assertEqual(metadata.cell_type, "float32ud-10.0")
self.assertEqual(metadata.no_data_value, -10)
def test_with_no_data_tiled_raster_layers(self):
no_data_layer = self.tiled_layer.with_no_data(18)
tile = no_data_layer.to_numpy_rdd().first()[1]
self.assertEqual(tile.no_data_value, 18)
metadata = no_data_layer.layer_metadata
self.assertEqual(metadata.cell_type, "float32ud18.0")
self.assertEqual(metadata.no_data_value, 18)
class ReclassifyTest(BaseTestClass):
epsg_code = 3857
extent = Extent(0.0, 0.0, 10.0, 10.0)
projected_extent = ProjectedExtent(extent, epsg_code)
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_tuple_key(self):
arr = np.zeros((1, 16, 16))
tile = Tile(arr, 'FLOAT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {(0, 1): 1}
result = raster_rdd.reclassify(value_map,
int).to_numpy_rdd().first()[1].cells
self.assertTrue((result == 1).all())
def test_list_bad(self):
arr = np.zeros((1, 16, 16))
tile = Tile(arr, 'FLOAT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {'apple, orange, banana': 1}
with pytest.raises(TypeError):
result = raster_rdd.reclassify(value_map,
int).to_numpy_rdd().first()[1].cells
def test_all_zeros(self):
arr = np.zeros((1, 16, 16))
tile = Tile(arr, 'FLOAT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {0: 1}
result = raster_rdd.reclassify(value_map,
int).to_numpy_rdd().first()[1].cells
self.assertTrue((result == 1).all())
def test_various_values(self):
arr = np.array(
[[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]],
dtype=int)
tile = Tile(arr, 'INT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {1: 10, 3: 17}
result = raster_rdd.reclassify(value_map,
int).to_numpy_rdd().first()[1].cells
expected = np.array([[[10, 10, 10, 10], [17, 17, 17, 17],
[17, 17, 17, 17], [-500, -500, -500, -500]]],
dtype=int)
self.assertTrue((result == expected).all())
def test_ranges(self):
arr = np.array(
[[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3], [4, 4, 4, 4]]],
dtype=int)
tile = Tile(arr, 'INT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {2: 20}
result = raster_rdd.reclassify(value_map, int,
ClassificationStrategy.GREATER_THAN
).to_numpy_rdd().first()[1].cells
expected = np.array(
[[[-500, -500, -500, -500], [-500, -500, -500, -500],
[20, 20, 20, 20], [20, 20, 20, 20]]],
dtype=int)
self.assertTrue((result == expected).all())
def test_multibands(self):
arr = np.array(
[[[1, 1, 1, 1]], [[2, 2, 2, 2]], [[3, 3, 3, 3]], [[4, 4, 4, 4]]],
dtype=int)
tile = Tile(arr, 'INT', -500)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {3: 10, 4: 20}
result = raster_rdd.reclassify(value_map,
int).to_numpy_rdd().first()[1].cells
expected = np.array([[[10, 10, 10, 10]], [[10, 10, 10, 10]],
[[10, 10, 10, 10]], [[20, 20, 20, 20]]],
dtype=int)
self.assertTrue((result == expected).all())
def test_floating_voint_ranges(self):
arr = np.array([[[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0],
[1.5, 1.5, 1.5, 1.5], [2.0, 2.0, 2.0, 2.0]]],
dtype=float)
tile = Tile(arr, 'FLOAT', float('nan'))
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {2.0: 5.0}
result = raster_rdd.reclassify(
value_map, float,
ClassificationStrategy.LESS_THAN).to_numpy_rdd().first()[1].cells
expected = np.array([[[5.0, 5.0, 5.0, 5.0], [5.0, 5.0, 5.0, 5.0],
[5.0, 5.0, 5.0, 5.0]]],
dtype=float)
self.assertTrue((result[0, 2, ] == expected).all())
for x in result[0, 3, ]:
self.assertTrue(math.isnan(x))
def test_no_data_ints(self):
arr = np.zeros((1, 16, 16), dtype=int)
tile = Tile(arr, 'INT', NO_DATA_INT)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {0: NO_DATA_INT}
result = raster_rdd.reclassify(value_map,
int).to_numpy_rdd().first()[1].cells
self.assertTrue((result == NO_DATA_INT).all())
def test_no_data_floats(self):
arr = np.array([[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]],
dtype=float)
tile = Tile(arr, 'FLOAT', float('nan'))
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {0.0: float('nan')}
result = raster_rdd.reclassify(value_map,
float).to_numpy_rdd().first()[1].cells
for x in list(result.flatten()):
self.assertTrue(math.isnan(x))
@pytest.mark.skipif(
'TRAVIS' in os.environ,
reason="Encoding using methods in Main causes issues on Travis")
def test_ignore_no_data_ints(self):
arr = np.ones((1, 16, 16), int)
np.fill_diagonal(arr[0], NO_DATA_INT)
tile = Tile(arr, 'INT', NO_DATA_INT)
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {1: 0}
result = raster_rdd.reclassify(
value_map, int,
replace_nodata_with=1).to_numpy_rdd().first()[1].cells
self.assertTrue((result == np.identity(16, int)).all())
@pytest.mark.skipif(
'TRAVIS' in os.environ,
reason="Encoding using methods in Main causes issues on Travis")
def test_ignore_no_data_floats(self):
arr = np.ones((1, 4, 4))
np.fill_diagonal(arr[0], float('nan'))
tile = Tile(arr, 'FLOAT', float('nan'))
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {1.0: 0.0}
result = raster_rdd.reclassify(
value_map, float,
replace_nodata_with=1.0).to_numpy_rdd().first()[1].cells
self.assertTrue((result == np.identity(4)).all())
class BandSelectionTest(BaseTestClass):
band_1 = np.array([
[1.0, 1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0],
[1.0, 1.0, 1.0, 1.0, 1.0]])
band_2 = np.array([
[2.0, 2.0, 2.0, 2.0, 2.0],
[2.0, 2.0, 2.0, 2.0, 2.0],
[2.0, 2.0, 2.0, 2.0, 2.0],
[2.0, 2.0, 2.0, 2.0, 2.0],
[2.0, 2.0, 2.0, 2.0, 2.0]])
band_3 = np.array([
[3.0, 3.0, 3.0, 3.0, 3.0],
[3.0, 3.0, 3.0, 3.0, 3.0],
[3.0, 3.0, 3.0, 3.0, 3.0],
[3.0, 3.0, 3.0, 3.0, 3.0],
[3.0, 3.0, 3.0, 3.0, 3.0]])
bands = np.array([band_1, band_2, band_3])
layer = [(SpatialKey(0, 0), Tile(bands, 'FLOAT', -1.0)),
(SpatialKey(1, 0), Tile(bands, 'FLOAT', -1.0,)),
(SpatialKey(0, 1), Tile(bands, 'FLOAT', -1.0,)),
(SpatialKey(1, 1), Tile(bands, 'FLOAT', -1.0,))]
rdd = BaseTestClass.pysc.parallelize(layer)
extent = {'xmin': 0.0, 'ymin': 0.0, 'xmax': 33.0, 'ymax': 33.0}
layout = {'layoutCols': 2, 'layoutRows': 2, 'tileCols': 5, 'tileRows': 5}
metadata = {'cellType': 'float32ud-1.0',
'extent': extent,
'crs': '+proj=longlat +datum=WGS84 +no_defs ',
'bounds': {
'minKey': {'col': 0, 'row': 0},
'maxKey': {'col': 1, 'row': 1}},
'layoutDefinition': {
'extent': extent,
'tileLayout': {'tileCols': 5, 'tileRows': 5, 'layoutCols': 2, 'layoutRows': 2}}}
tiled_raster_rdd = TiledRasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd, metadata, 5)
layer2 = [(ProjectedExtent(Extent(0, 0, 1, 1), 3857), Tile(bands, 'FLOAT', -1.0)),
(ProjectedExtent(Extent(1, 0, 2, 1), 3857), Tile(bands, 'FLOAT', -1.0)),
(ProjectedExtent(Extent(0, 1, 1, 2), 3857), Tile(bands, 'FLOAT', -1.0)),
(ProjectedExtent(Extent(1, 1, 2, 2), 3857), Tile(bands, 'FLOAT', -1.0))]
rdd2 = BaseTestClass.pysc.parallelize(layer2)
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd2)
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_bands_invalid(self):
with pytest.raises(TypeError):
self.tiled_raster_rdd.bands("hello").to_numpy_rdd().first()[1]
def test_bands_int_tiled(self):
actual = self.tiled_raster_rdd.bands(1).to_numpy_rdd().first()[1]
expected = np.array(self.band_2)
self.assertTrue((expected == actual.cells).all())
def test_bands_int_raster(self):
actual = self.raster_rdd.bands(1).to_numpy_rdd().first()[1]
expected = np.array(self.band_2)
self.assertTrue((expected == actual.cells).all())
def test_bands_tuple_tiled(self):
actual = self.tiled_raster_rdd.bands((1, 2)).to_numpy_rdd().first()[1]
expected = np.array([self.band_2, self.band_3])
self.assertTrue((expected == actual.cells).all())
def test_bands_tuple_raster(self):
actual = self.raster_rdd.bands((1, 2)).to_numpy_rdd().first()[1]
expected = np.array([self.band_2, self.band_3])
self.assertTrue((expected == actual.cells).all())
def test_bands_list_tiled(self):
actual = self.tiled_raster_rdd.bands([0, 2]).to_numpy_rdd().first()[1]
expected = np.array([self.band_1, self.band_3])
self.assertTrue((expected == actual.cells).all())
def test_bands_list_raster(self):
actual = self.raster_rdd.bands([0, 2]).to_numpy_rdd().first()[1]
expected = np.array([self.band_1, self.band_3])
self.assertTrue((expected == actual.cells).all())
def test_band_range_tiled(self):
actual = self.tiled_raster_rdd.bands(range(0, 3)).to_numpy_rdd().first()[1]
expected = np.array([self.band_1, self.band_2, self.band_3])
self.assertTrue((expected == actual.cells).all())
def test_band_range_raster(self):
actual = self.raster_rdd.bands(range(0, 3)).to_numpy_rdd().first()[1]
expected = np.array([self.band_1, self.band_2, self.band_3])
self.assertTrue((expected == actual.cells).all())
def test_map_tiles_func_tiled(self):
def test_func(tile):
cells = tile.cells
return Tile((cells[0] + cells[1]) / cells[2], tile.cell_type, tile.no_data_value)
actual = self.tiled_raster_rdd.map_tiles(test_func).to_numpy_rdd().first()[1]
expected = np.array([self.band_1])
self.assertTrue((expected == actual.cells).all())
def test_map_tiles_lambda_tiled(self):
mapped_layer = self.tiled_raster_rdd.map_tiles(lambda tile: Tile(tile.cells[0], tile.cell_type, tile.no_data_value))
actual = mapped_layer.to_numpy_rdd().first()[1]
expected = np.array([self.band_1])
self.assertEqual(mapped_layer.zoom_level, self.tiled_raster_rdd.zoom_level)
self.assertTrue((expected == actual.cells).all())
def test_map_cells_func_raster(self):
def test_func(cells, nd):
cells[cells >= 3.0] = nd
return cells
actual = self.raster_rdd.map_cells(test_func).to_numpy_rdd().first()[1]
negative_band = np.array([
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0]])
expected = np.array([self.band_1, self.band_2, negative_band])
self.assertTrue((expected == actual.cells).all())
def test_map_cells_lambda_raster(self):
actual = self.raster_rdd.map_cells(lambda cells, nd: cells + nd).to_numpy_rdd().first()[1]
self.assertTrue((0.0 == actual.cells[0, :]).all())
self.assertTrue((self.band_1 == actual.cells[1, :]).all())
self.assertTrue((self.band_2 == actual.cells[2, :]).all())
def test_map_cells_func_tiled(self):
def test_func(cells, nd):
cells[cells >= 3.0] = nd
return cells
actual = self.tiled_raster_rdd.map_cells(test_func).to_numpy_rdd().first()[1]
negative_band = np.array([
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0],
[-1.0, -1.0, -1.0, -1.0, -1.0]])
expected = np.array([self.band_1, self.band_2, negative_band])
self.assertTrue((expected == actual.cells).all())
def test_map_cells_lambda_tiled(self):
mapped_layer = self.tiled_raster_rdd.map_cells(lambda cells, nd: cells + nd)
actual = mapped_layer.to_numpy_rdd().first()[1]
self.assertTrue((0.0 == actual.cells[0, :]).all())
self.assertTrue((self.band_1 == actual.cells[1, :]).all())
self.assertTrue((self.band_2 == actual.cells[2, :]).all())
self.assertEqual(mapped_layer.zoom_level, self.tiled_raster_rdd.zoom_level)
def make_raster(x, y, v, cols=4, rows=4, ct=CellType.FLOAT32, crs=4326):
cells = np.zeros((1, rows, cols))
cells.fill(v)
# extent of a single cell is 1, no fence-post here
extent = ProjectedExtent(Extent(x, y, x + cols, y + rows), crs)
return (extent, Tile(cells, ct, None))
def projected_extent_decoder(schema_dict):
return ProjectedExtent(Extent(**schema_dict['extent']),
schema_dict.get('epsg'),
schema_dict.get('proj4'))