def loads(self, obj, encoding="bytes"):
binary_parser = BinaryParser(obj)
spatial_parser_number = binary_parser.read_int()
spatial_parser = self.get_parser(spatial_parser_number)
parsed_row = spatial_parser.deserialize(binary_parser)
return parsed_row
def read_geometry_from_bytes(bin_parser: BinaryParser):
geom_data_length = bin_parser.read_int()
user_data_length = bin_parser.read_int()
geom = bin_parser.read_geometry(geom_data_length)
user_data = bin_parser.read_string(user_data_length)
return (geom, user_data)
def SpatialKnnQuery(self, spatialRDD: SpatialRDD,
originalQueryPoint: BaseGeometry, k: int,
useIndex: bool):
"""
:param spatialRDD: spatialRDD
:param originalQueryPoint: shapely.geometry.Point
:param k: int
:param useIndex: bool
:return: pyspark.RDD
"""
jvm = spatialRDD._jvm
jvm_geom = GeometryAdapter.create_jvm_geometry_from_base_geometry(
jvm, originalQueryPoint)
knn_neighbours = jvm.KNNQuery.SpatialKnnQuery(spatialRDD._srdd,
jvm_geom, k, useIndex)
srdd = JvmGeoSparkPythonConverter(
jvm).translate_geometry_seq_to_python(knn_neighbours)
geoms_data = []
for arr in srdd:
binary_parser = BinaryParser(arr)
geom = SpatialRDDParserData.deserialize(binary_parser)
geoms_data.append(geom)
return geoms_data
def geometry_from_bytes(cls, bin_parser: BinaryParser) -> BaseGeometry:
g_type = bin_parser.read_byte()
shape_type = ShapeEnum.get_name(g_type)
if shape_type == ShapeEnum.circle.name:
return CircleParser.deserialize(bin_parser)
elif shape_type == ShapeEnum.shape.name:
gm_type = bin_parser.read_byte()
if GeomEnum.has_value(gm_type):
name = GeomEnum.get_name(gm_type)
parser = PARSERS[name]
geom = parser.deserialize(bin_parser)
return geom
else:
raise GeometryUnavailableException(
f"Can not deserialize object")
def __setstate__(self, attributes):
bin_parser = BinaryParser(attributes["geom"])
is_circle = bin_parser.read_byte()
geom_bytes = attributes["geom"]
if is_circle:
radius = bin_parser.read_double()
geom = bin_parser.read_geometry(geom_bytes.__len__() - 9)
self._geom = Circle(geom, radius)
else:
self._geom = bin_parser.read_geometry(geom_bytes.__len__() - 1)
self._userData = attributes["userData"]
def deserialize(self, datum):
bin_parser = BinaryParser(datum)
geom = GeometryFactory.geometry_from_bytes(bin_parser)
return geom
def geom_from_bytes_data(cls, bin_data: List):
bin_parser = BinaryParser(bin_data)
return cls.geometry_from_bytes(bin_parser)
def geometry_from_bytes(cls, bin_parser: BinaryParser) -> GeoData:
geom, user_data = read_geometry_from_bytes(bin_parser)
radius = bin_parser.read_double()
geo_data = GeoData(geom=Circle(geom, radius), userData=user_data)
return geo_data