class TestZonalStatsUtil:
npobj = np.array([
[2600000.0, 5630000.0],
[2600000.0, 5630100.0],
[2600100.0, 5630100.0],
[2600100.0, 5630000.0],
[2600000.0, 5630000.0],
])
ogrobj = georef.numpy_to_ogr(npobj, "Polygon")
def test_angle_between(self):
assert zonalstats.angle_between(355.0, 5.0) == pytest.approx(10.0)
assert zonalstats.angle_between(5.0, 355.0) == pytest.approx(-10.0)
def test_get_clip_mask(self):
proj_gk = osr.SpatialReference()
proj_gk.ImportFromEPSG(31466)
coords = np.array([
[2600020.0, 5630020.0],
[2600030.0, 5630030.0],
[2600040.0, 5630040.0],
[2700100.0, 5630030.0],
[2600040.0, 5640000.0],
])
mask = zonalstats.get_clip_mask(coords, self.npobj, proj_gk)
out = np.array([True, True, True, False, False])
np.testing.assert_array_equal(mask, out)
def setUp(self):
self.proj = osr.SpatialReference()
self.proj.ImportFromEPSG(31466)
self.wgs84 = georef.get_default_projection()
self.npobj = np.array([[2600000., 5630000.], [2600000., 5630100.],
[2600100., 5630100.], [2600100., 5630000.],
[2600000., 5630000.]])
self.lonlat = np.array([[7.41779154, 50.79679579],
[7.41781875, 50.79769443],
[7.4192367, 50.79767718],
[7.41920947, 50.79677854],
[7.41779154, 50.79679579]])
self.ogrobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.ogrobj.AssignSpatialReference(None)
self.projobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.projobj.AssignSpatialReference(self.proj)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
self.ds, self.layer = open_vector(filename)
def setUp(self):
self.proj = osr.SpatialReference()
self.proj.ImportFromEPSG(31466)
self.wgs84 = georef.get_default_projection()
self.npobj = np.array([[2600000., 5630000.], [2600000., 5630100.],
[2600100., 5630100.], [2600100., 5630000.],
[2600000., 5630000.]])
self.lonlat = np.array([[7.41779154, 50.79679579],
[7.41781875, 50.79769443],
[7.4192367, 50.79767718],
[7.41920947, 50.79677854],
[7.41779154, 50.79679579]])
self.ogrobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.ogrobj.AssignSpatialReference(None)
self.projobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
self.projobj.AssignSpatialReference(self.proj)
filename = util.get_wradlib_data_file('shapefiles/agger/'
'agger_merge.shp')
self.ds, self.layer = open_vector(filename)
def _create_dst_features(self, dst, trg, **kwargs):
""" Create needed OGR.Features in dst OGR.Layer
Parameters
----------
dst : OGR.Layer
destination layer
trg : OGR.Geometry
target polygon
"""
# TODO: kwargs necessary?
# claim and reset source ogr layer
layer = self.src.ds.GetLayerByName('src')
layer.ResetReading()
# if given, we apply a buffer value to the target polygon filter
trg_index = trg.GetField('index')
trg = trg.GetGeometryRef()
trg = trg.Buffer(self._buffer)
layer.SetSpatialFilter(trg)
# iterate over layer features
for ogr_src in layer:
geom = ogr_src.GetGeometryRef()
# calculate intersection, if not fully contained
if not trg.Contains(geom):
geom = trg.Intersection(geom)
# checking GeometryCollection, convert to only Polygons,
# Multipolygons
if geom.GetGeometryType() in [7]:
geocol = georef.ogr_geocol_to_numpy(geom)
geom = georef.numpy_to_ogr(geocol, 'MultiPolygon')
# only geometries containing points
if geom.IsEmpty():
continue
if geom.GetGeometryType() in [3, 6, 12]:
idx = ogr_src.GetField('index')
georef.ogr_add_geometry(dst, geom, [idx, trg_index])
def _get_intersection(self, trg=None, idx=None, buf=0.):
"""Just a toy function if you want to inspect the intersection
points/polygons of an arbitrary target or an target by index.
"""
# TODO: kwargs necessary?
# check wether idx is given
if idx is not None:
if self.trg:
try:
lyr = self.trg.ds.GetLayerByName('trg')
feat = lyr.GetFeature(idx)
trg = feat.GetGeometryRef()
except Exception:
raise TypeError(
"No target polygon found at index {0}".format(idx))
else:
raise TypeError('No target polygons found in object!')
# check for trg
if trg is None:
raise TypeError('Either *trg* or *idx* keywords must be given!')
# check for geometry
if not type(trg) == ogr.Geometry:
trg = georef.numpy_to_ogr(trg, 'Polygon')
# apply Buffer value
trg = trg.Buffer(buf)
if idx is None:
intersecs = self.src.get_data_by_geom(trg)
else:
intersecs = self.dst.get_data_by_att('trg_index', idx)
return intersecs
def setUp(self):
self.npobj = np.array([[2600000., 5630000.], [2600000., 5630100.],
[2600100., 5630100.], [2600100., 5630000.],
[2600000., 5630000.]])
self.ogrobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
class TestVector:
proj = osr.SpatialReference()
proj.ImportFromEPSG(31466)
wgs84 = georef.get_default_projection()
npobj = np.array(
[
[2600000.0, 5630000.0],
[2600000.0, 5630100.0],
[2600100.0, 5630100.0],
[2600100.0, 5630000.0],
[2600000.0, 5630000.0],
]
)
lonlat = np.array(
[
[7.41779154, 50.79679579],
[7.41781875, 50.79769443],
[7.4192367, 50.79767718],
[7.41920947, 50.79677854],
[7.41779154, 50.79679579],
]
)
ogrobj = georef.numpy_to_ogr(npobj, "Polygon")
ogrobj.AssignSpatialReference(None)
projobj = georef.numpy_to_ogr(npobj, "Polygon")
projobj.AssignSpatialReference(proj)
filename = util.get_wradlib_data_file("shapefiles/agger/" "agger_merge.shp")
ds, layer = wradlib.io.open_vector(filename)
def test_ogr_create_layer(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
with pytest.raises(TypeError):
georef.ogr_create_layer(ds, "test")
lyr = georef.ogr_create_layer(
ds, "test", geom_type=ogr.wkbPoint, fields=[("test", ogr.OFTReal)]
)
assert isinstance(lyr, ogr.Layer)
def test_ogr_to_numpy(self):
np.testing.assert_allclose(georef.ogr_to_numpy(self.ogrobj), self.npobj)
def test_get_vector_points(self):
# this also tests equality with `ogr_to_numpy`
x = np.array(list(georef.get_vector_points(self.ogrobj))[0])
y = georef.ogr_to_numpy(self.ogrobj)
np.testing.assert_allclose(x, y)
def test_get_vector_points_warning(self):
point_wkt = "POINT (1198054.34 648493.09)"
point = ogr.CreateGeometryFromWkt(point_wkt)
with pytest.warns(UserWarning):
list(georef.get_vector_points(point))
def test_get_vector_coordinates(self):
# this also tests equality with `ogr_to_numpy`
x, attrs = georef.get_vector_coordinates(self.layer, key="FID")
assert attrs == list(range(13))
x, attrs = georef.get_vector_coordinates(self.layer)
y = []
self.layer.ResetReading()
for i in range(self.layer.GetFeatureCount()):
feature = self.layer.GetNextFeature()
if feature:
geom = feature.GetGeometryRef()
y.append(georef.ogr_to_numpy(geom))
y = np.array(y)
for x1, y1 in zip(x, y):
np.testing.assert_allclose(x1, y1)
self.layer.ResetReading()
x, attrs = georef.get_vector_coordinates(
self.layer, source_srs=self.proj, dest_srs=self.wgs84
)
self.layer.ResetReading()
x, attrs = georef.get_vector_coordinates(self.layer, dest_srs=self.wgs84)
def test_transform_geometry(self):
geom = georef.transform_geometry(self.projobj, dest_srs=self.wgs84)
x = list(georef.get_vector_points(geom))[0]
np.testing.assert_allclose(x, self.lonlat, rtol=1e-05)
def test_transform_geometry_warning(self):
with pytest.warns(UserWarning):
georef.transform_geometry(self.ogrobj, dest_srs=self.wgs84)
def test_ogr_copy_layer(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer(self.ds, 0, ds)
assert isinstance(ds.GetLayer(), ogr.Layer)
def test_ogr_copy_layer_by_name(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer_by_name(self.ds, "agger_merge", ds)
assert isinstance(ds.GetLayer(), ogr.Layer)
with pytest.raises(ValueError):
georef.ogr_copy_layer_by_name(self.ds, "agger_merge1", ds)
def test_ogr_add_feature(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
georef.ogr_create_layer(
ds, "test", geom_type=ogr.wkbPoint, fields=[("index", ogr.OFTReal)]
)
point = np.array([1198054.34, 648493.09])
parr = np.array([point, point, point])
georef.ogr_add_feature(ds, parr)
georef.ogr_add_feature(ds, parr, name="test")
def test_ogr_add_geometry(self):
ds = wradlib.io.gdal_create_dataset("Memory", "test", gdal_type=gdal.OF_VECTOR)
lyr = georef.ogr_create_layer(
ds, "test", geom_type=ogr.wkbPoint, fields=[("test", ogr.OFTReal)]
)
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(1198054.34, 648493.09)
georef.ogr_add_geometry(lyr, point, [42.42])
def test_geocol_to_numpy(self):
# Create a geometry collection
geomcol = ogr.Geometry(ogr.wkbGeometryCollection)
# Create polygon
ring = ogr.Geometry(ogr.wkbLinearRing)
ring.AddPoint(1179091.1646903288, 712782.8838459781)
ring.AddPoint(1161053.0218226474, 667456.2684348812)
ring.AddPoint(1214704.933941905, 641092.8288590391)
ring.AddPoint(1228580.428455506, 682719.3123998424)
ring.AddPoint(1218405.0658121984, 721108.1805541387)
ring.AddPoint(1179091.1646903288, 712782.8838459781)
poly = ogr.Geometry(ogr.wkbPolygon)
poly.AddGeometry(ring)
geomcol.AddGeometry(poly)
# Add a point
point = ogr.Geometry(ogr.wkbPoint)
point.AddPoint(-122.23, 47.09)
geomcol.AddGeometry(point)
# Add a line
line = ogr.Geometry(ogr.wkbLineString)
line.AddPoint(-122.60, 47.14)
line.AddPoint(-122.48, 47.23)
geomcol.AddGeometry(line)
arr = georef.ogr_geocol_to_numpy(geomcol)[..., 0:2]
res = np.array(
[
[1179091.1646903288, 712782.8838459781],
[1161053.0218226474, 667456.2684348812],
[1214704.933941905, 641092.8288590391],
[1228580.428455506, 682719.3123998424],
[1218405.0658121984, 721108.1805541387],
[1179091.1646903288, 712782.8838459781],
]
)
np.testing.assert_allclose(arr, res)
def test_get_centroid(self):
cent1 = georef.get_centroid(self.npobj)
cent2 = georef.get_centroid(self.ogrobj)
assert cent1 == (2600050.0, 5630050.0)
assert cent2 == (2600050.0, 5630050.0)
def setUp(self):
self.npobj = np.array([[2600000., 5630000.], [2600000., 5630100.],
[2600100., 5630100.], [2600100., 5630000.],
[2600000., 5630000.]])
self.ogrobj = georef.numpy_to_ogr(self.npobj, 'Polygon')
