def assign_cellvalues(feature):
tags = feature.properties.tags.values()
if 'water' in tags:
return Feature(feature.geometry, CellValue(4, 4))
elif "en:Zern's Farmer's Market" in tags:
return Feature(feature.geometry, CellValue(3, 3))
else:
return Feature(feature.geometry, CellValue(1, 1))
class FeatureCellValueSchemaTest(BaseTestClass):
sc = BaseTestClass.pysc._jsc.sc()
fw = BaseTestClass.pysc._jvm.geopyspark.vectorpipe.tests.schemas.FeatureCellValueWrapper
java_rdd = fw.testOut(sc)
ser = ProtoBufSerializer(feature_cellvalue_decoder,
feature_cellvalue_encoder)
rdd = RDD(java_rdd, BaseTestClass.pysc, AutoBatchedSerializer(ser))
point = Point(0, 2)
line_1 = LineString(
[point, Point(1, 3),
Point(2, 4),
Point(3, 5),
Point(4, 6)])
line_2 = LineString(
[Point(5, 7),
Point(6, 8),
Point(7, 9),
Point(8, 10),
Point(9, 11)])
multi_line = MultiLineString([line_1, line_2])
features = [
Feature(point, CellValue(2, 1)),
Feature(line_1, CellValue(1, 0)),
Feature(multi_line, CellValue(1, 0))
]
collected = [f for f in rdd.collect()]
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_decoder(self):
geoms = [g.geometry for g in self.collected]
ms = [m.properties for m in self.collected]
for x in self.features:
self.assertTrue(x.geometry in geoms)
self.assertTrue(x.properties in ms)
def test_encoder(self):
expected_encoded = [
to_pb_feature_cellvalue(f).SerializeToString()
for f in self.features
]
actual_encoded = [feature_cellvalue_encoder(f) for f in self.collected]
for x in expected_encoded:
self.assertTrue(x in actual_encoded)
def test_rasterization_with_partitioner(self):
features = osm_reader.from_orc(file_path("zerns.orc"))
lines = features.get_line_features_rdd()
polys = features.get_polygon_features_rdd()
mapped_lines = lines.map(
lambda feature: Feature(feature.geometry, CellValue(1, 1)))
def assign_cellvalues(feature):
tags = feature.properties.tags.values()
if 'water' in tags:
return Feature(feature.geometry, CellValue(4, 4))
elif "en:Zern's Farmer's Market" in tags:
return Feature(feature.geometry, CellValue(3, 3))
else:
return Feature(feature.geometry, CellValue(2, 2))
mapped_polys = polys.map(lambda feature: assign_cellvalues(feature))
unioned = BaseTestClass.pysc.union((mapped_lines, mapped_polys))
result = rasterize_features(
unioned,
4326,
12,
cell_type=CellType.INT8,
partition_strategy=SpatialPartitionStrategy())
self.assertEqual(result.get_min_max(), (1, 4))
self.assertEqual(result.count(), 1)
def from_pb_feature(pb_feature):
"""Creates a ``Feature`` with ``properties`` of ``Properties``
from ``ProtoSimpleFeature``.
Args:
pb_feature (ProtoSimpleFeature): The ``ProtoSimpleFeature`` instance to be converted.
Returns:
:class:`~geopyspark.vector_pipe.Feature`
"""
metadata = dict(pb_feature.metadata)
geometry = loads(pb_feature.geom)
return Feature(geometry=geometry, properties=metadata)
def from_pb_feature_cellvalue(pb_feature_cellvalue):
"""Creates a ``Feature`` with ``properties`` of ``CellValue``
from ``ProtoFeature``.
Args:
pb_feature_cellvalue (ProtoFeatureCellValue): The ``ProtoFeatureCellValue`` instance
to be converted.
Returns:
:class:`~geopyspark.vector_pipe.Feature`
"""
geometry = loads(pb_feature_cellvalue.geom)
cellvalue = CellValue(pb_feature_cellvalue.cellValue.value,
pb_feature_cellvalue.cellValue.zindex)
return Feature(geometry, cellvalue)
class FeatureSchemaTest(BaseTestClass):
sc = BaseTestClass.pysc._jsc.sc()
fw = BaseTestClass.pysc._jvm.geopyspark.vectorpipe.tests.schemas.FeatureWrapper
java_rdd = fw.testOut(sc)
ser = ProtoBufSerializer(feature_decoder, feature_encoder)
rdd = RDD(java_rdd, BaseTestClass.pysc, AutoBatchedSerializer(ser))
metadata = Properties(element_id=1993,
user="******",
uid=19144,
changeset=10,
version=24,
minor_version=5,
timestamp=parser.parse("2012-06-05T07:00:00UTC"),
visible=True,
tags={
'amenity': 'embassy',
'diplomatic': 'embassy',
'country': 'azavea'
})
point = Point(0, 2)
line_1 = LineString(
[point, Point(1, 3),
Point(2, 4),
Point(3, 5),
Point(4, 6)])
line_2 = LineString(
[Point(5, 7),
Point(6, 8),
Point(7, 9),
Point(8, 10),
Point(9, 11)])
multi_line = MultiLineString([line_1, line_2])
features = [
Feature(point, metadata),
Feature(line_1, metadata),
Feature(multi_line, metadata)
]
collected = [f for f in rdd.collect()]
@pytest.fixture(autouse=True)
def tearDown(self):
yield
BaseTestClass.pysc._gateway.close()
def test_decoder(self):
geoms = [g.geometry for g in self.collected]
ms = [m.properties for m in self.collected]
for x in self.features:
self.assertTrue(x.geometry in geoms)
self.assertTrue(x.properties in ms)
def test_encoder(self):
expected_encoded = [
to_pb_feature(f).SerializeToString() for f in self.features
]
actual_encoded = [feature_encoder(f) for f in self.collected]
for x in expected_encoded:
self.assertTrue(x in actual_encoded)