def load_vector(self, filename):
""" Load source/target grid points/polygons into in-memory Shapefile
Parameters
----------
filename : string
path to vector file
"""
# get input file handles
ds_in, tmp = io.open_shape(filename)
# create all DataSources
self.src = DataSource(name='src')
self.src.ds = io.gdal_create_dataset('Memory', 'src',
gdal_type=gdal.OF_VECTOR)
self.trg = DataSource(name='trg')
self.trg.ds = io.gdal_create_dataset('Memory', 'trg',
gdal_type=gdal.OF_VECTOR)
self.dst = DataSource(name='dst')
self.dst.ds = io.gdal_create_dataset('Memory', 'dst',
gdal_type=gdal.OF_VECTOR)
# copy all layers
georef.ogr_copy_layer_by_name(ds_in, "src", self.src.ds)
georef.ogr_copy_layer_by_name(ds_in, "trg", self.trg.ds)
georef.ogr_copy_layer_by_name(ds_in, "dst", self.dst.ds)
# get spatial reference object
self._srs = self.src.ds.GetLayer().GetSpatialRef()
self.src._srs = self.src.ds.GetLayer().GetSpatialRef()
self.trg._srs = self.trg.ds.GetLayer().GetSpatialRef()
self.dst._srs = self.trg.ds.GetLayer().GetSpatialRef()
# flush everything
del ds_in
def test_ogr_add_geometry(self):
ds = 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_ogr_create_layer(self):
ds = gdal_create_dataset('Memory', 'test',
gdal_type=gdal.OF_VECTOR)
self.assertRaises(TypeError,
lambda: georef.ogr_create_layer(ds, 'test'))
lyr = georef.ogr_create_layer(ds, 'test', geom_type=ogr.wkbPoint,
fields=[('test', ogr.OFTReal)])
self.assertTrue(isinstance(lyr, ogr.Layer))
def test_ogr_copy_layer_by_name(self):
ds = gdal_create_dataset('Memory', 'test', gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer_by_name(self.ds, 'agger_merge', ds)
self.assertTrue(isinstance(ds.GetLayer(), ogr.Layer))
self.assertRaises(
ValueError,
lambda: georef.ogr_copy_layer_by_name(self.ds, 'agger_merge1', ds))
def test_ogr_create_layer(self):
ds = gdal_create_dataset('Memory', 'test',
gdal_type=gdal.OF_VECTOR)
self.assertRaises(TypeError,
lambda: georef.ogr_create_layer(ds, 'test'))
lyr = georef.ogr_create_layer(ds, 'test', geom_type=ogr.wkbPoint,
fields=[('test', ogr.OFTReal)])
self.assertTrue(isinstance(lyr, ogr.Layer))
def test_ogr_add_geometry(self):
ds = 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_ogr_add_feature(self):
ds = 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_copy_layer_by_name(self):
ds = gdal_create_dataset('Memory', 'test',
gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer_by_name(self.ds, 'agger_merge', ds)
self.assertTrue(isinstance(ds.GetLayer(), ogr.Layer))
self.assertRaises(ValueError,
lambda: georef.ogr_copy_layer_by_name(self.ds,
'agger_merge1',
ds))
def test_ogr_add_feature(self):
ds = 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 dump_raster(self, filename, driver='GTiff', attr=None,
pixel_size=1., remove=True):
""" Output layer to GDAL Rasterfile
Parameters
----------
filename : string
path to shape-filename
driver : string
GDAL Raster Driver
attr : string
attribute to burn into raster
pixel_size : float
pixel Size in source units
remove : bool
if True removes existing output file
"""
layer = self.ds.GetLayer()
layer.ResetReading()
x_min, x_max, y_min, y_max = layer.GetExtent()
cols = int((x_max - x_min) / pixel_size)
rows = int((y_max - y_min) / pixel_size)
# Todo: at the moment, always writing floats
ds_out = io.gdal_create_dataset('MEM', '', cols, rows, 1,
gdal_type=gdal.GDT_Float32)
ds_out.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
proj = layer.GetSpatialRef()
if proj is None:
proj = self._srs
ds_out.SetProjection(proj.ExportToWkt())
band = ds_out.GetRasterBand(1)
band.FlushCache()
print("Rasterize layers")
if attr is not None:
gdal.RasterizeLayer(ds_out, [1], layer, burn_values=[0],
options=["ATTRIBUTE={0}".format(attr),
"ALL_TOUCHED=TRUE"],
callback=gdal.TermProgress)
else:
gdal.RasterizeLayer(ds_out, [1], layer, burn_values=[1],
options=["ALL_TOUCHED=TRUE"],
callback=gdal.TermProgress)
io.write_raster_dataset(filename, ds_out, driver, remove=remove)
del ds_out
def dump_vector(self, filename, driver='ESRI Shapefile', remove=True):
""" Output layer to OGR Vector File
Parameters
----------
filename : string
path to shape-filename
driver : string
driver string
remove : bool
if True removes existing output file
"""
ds_out = io.gdal_create_dataset(driver, filename,
gdal_type=gdal.OF_VECTOR,
remove=remove)
georef.ogr_copy_layer(self.ds, 0, ds_out)
# flush everything
del ds_out
def _check_src(self, src):
""" Basic check of source elements (sequence of points or polygons).
- array cast of source elements
- create ogr_src datasource/layer holding src points/polygons
- transforming source grid points/polygons to ogr.geometries
on ogr.layer
"""
ogr_src = io.gdal_create_dataset('Memory',
'out',
gdal_type=gdal.OF_VECTOR)
try:
# is it ESRI Shapefile?
ds_in, tmp_lyr = io.open_shape(
src, driver=ogr.GetDriverByName('ESRI Shapefile'))
ogr_src_lyr = ogr_src.CopyLayer(tmp_lyr, self._name)
if self._srs is None:
self._srs = ogr_src_lyr.GetSpatialRef()
except IOError:
# no ESRI shape file
raise
# all failed? then it should be sequence or numpy array
except RuntimeError:
src = np.array(src)
# create memory datasource, layer and create features
if src.ndim == 2:
geom_type = ogr.wkbPoint
# no Polygons, just Points
else:
geom_type = ogr.wkbPolygon
fields = [('index', ogr.OFTInteger)]
georef.ogr_create_layer(ogr_src,
self._name,
srs=self._srs,
geom_type=geom_type,
fields=fields)
georef.ogr_add_feature(ogr_src, src, name=self._name)
return ogr_src
def test_ogr_copy_layer(self):
ds = gdal_create_dataset('Memory', 'test',
gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer(self.ds, 0, ds)
self.assertTrue(isinstance(ds.GetLayer(), ogr.Layer))
def _create_dst_datasource(self, **kwargs):
""" Create destination target gdal.Dataset
Creates one layer for each target polygon, consisting of
the needed source data attributed with index and weights fields
Returns
-------
ds_mem : gdal.Dataset object
"""
# TODO: kwargs necessary?
# create intermediate mem dataset
ds_mem = io.gdal_create_dataset('Memory',
'dst',
gdal_type=gdal.OF_VECTOR)
# get src geometry layer
src_lyr = self.src.ds.GetLayerByName('src')
src_lyr.ResetReading()
src_lyr.SetSpatialFilter(None)
geom_type = src_lyr.GetGeomType()
# create temp Buffer layer (time consuming)
ds_tmp = io.gdal_create_dataset('Memory',
'tmp',
gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer(self.trg.ds, 0, ds_tmp)
tmp_trg_lyr = ds_tmp.GetLayer()
for i in range(tmp_trg_lyr.GetFeatureCount()):
feat = tmp_trg_lyr.GetFeature(i)
feat.SetGeometryDirectly(feat.GetGeometryRef().Buffer(
self._buffer))
tmp_trg_lyr.SetFeature(feat)
# get target layer, iterate over polygons and calculate intersections
tmp_trg_lyr.ResetReading()
self.tmp_lyr = georef.ogr_create_layer(ds_mem,
'dst',
srs=self._srs,
geom_type=geom_type)
print("Calculate Intersection source/target-layers")
try:
tmp_trg_lyr.Intersection(src_lyr,
self.tmp_lyr,
options=[
'SKIP_FAILURES=YES',
'INPUT_PREFIX=trg_',
'METHOD_PREFIX=src_',
'PROMOTE_TO_MULTI=YES',
'PRETEST_CONTAINMENT=YES'
],
callback=gdal.TermProgress)
except RuntimeError:
# Catch RuntimeError that was reported on gdal 1.11.1
# on Windows systems
tmp_trg_lyr.Intersection(src_lyr,
self.tmp_lyr,
options=[
'SKIP_FAILURES=YES',
'INPUT_PREFIX=trg_',
'METHOD_PREFIX=src_',
'PROMOTE_TO_MULTI=YES',
'PRETEST_CONTAINMENT=YES'
])
return ds_mem
def test_ogr_copy_layer(self):
ds = gdal_create_dataset('Memory', 'test', gdal_type=gdal.OF_VECTOR)
georef.ogr_copy_layer(self.ds, 0, ds)
self.assertTrue(isinstance(ds.GetLayer(), ogr.Layer))
