def remove_slivers(ogr_geometry, epsilon):
wkb_buffer = ogr_geometry.ExportToWkb()
shapely_geom = wkb.loads(wkb_buffer)
result = shapely_geom.buffer(epsilon, 1,
join_style=JOIN_STYLE.mitre).buffer(
-epsilon, 1, join_style=JOIN_STYLE.mitre)
#result = shapely_geom.buffer(epsilon, 1).buffer(-epsilon, 1)
result_wkb = wkb.dumps(result)
return ogr.CreateGeometryFromWkb(result_wkb)
def test_ogr_wkbwkt_test_import_bad_multipoint_wkb():
import struct
wkb = struct.pack('B' * 30, 0, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0)
gdal.PushErrorHandler('CPLQuietErrorHandler')
geom = ogr.CreateGeometryFromWkb(wkb)
gdal.PopErrorHandler()
assert geom is None
def segment(config, row):
segments = []
if len(row[1]) < 1 or len(row[2]) < 2:
return segments
(tags, way) = waysort(row)
(key, value) = type(config, tags)
if key == None or value == None:
return segments
osm_id = row[0]
class_id = int(config[key][value][0])
source = way[0][1]
length = 1
if (is_oneway(tags)):
reverse = -1
else:
reverse = 1
(maxspeed_forward, maxspeed_backward) = maxspeed(tags)
priority = float(config[key][value][1])
line = ogr.Geometry(ogr.wkbLineString)
point = ogr.CreateGeometryFromWkb(binascii.unhexlify(way[0][3]))
line.AddPoint(point.GetX(), point.GetY())
for i in range(1, len(way[:, 0])):
point = ogr.CreateGeometryFromWkb(binascii.unhexlify(way[i][3]))
line.AddPoint(point.GetX(), point.GetY())
if ((int(way[i][2]) >= 2) or (i == (len(way[:, 0]) - 1))):
line.FlattenTo2D()
segment = (osm_id, class_id, source, way[i][1], length, reverse,
maxspeed_forward, maxspeed_backward, priority,
line.ExportToWkt())
segments.append(segment)
source = way[i][1]
line = ogr.Geometry(ogr.wkbLineString)
point = ogr.CreateGeometryFromWkb(binascii.unhexlify(way[i][3]))
line.AddPoint(point.GetX(), point.GetY())
return segments
def _create_base_map(self, ):
'''
Deal with different types way to define the AOI, if none is specified, then the image bound is used.
'''
gdal.UseExceptions()
ogr.UseExceptions()
if self.aoi is not None:
if os.path.exists(self.aoi):
try:
g = gdal.Open(self.aoi)
subprocess.call([
'gdaltindex', '-f', 'GeoJSON', '-t_srs', 'EPSG:4326',
self.toa_dir + '/AOI.json', self.aoi
])
except:
try:
gr = ogr.Open(self.aoi)
l = gr.GetLayer(0)
f = l.GetFeature(0)
g = f.GetGeometryRef()
except:
raise IOError(
'AOI file cannot be opened by gdal, please check it or transform into format can be opened by gdal'
)
else:
try:
g = ogr.CreateGeometryFromJson(self.aoi)
except:
try:
g = ogr.CreateGeometryFromGML(self.aoi)
except:
try:
g = ogr.CreateGeometryFromWkt(self.aoi)
except:
try:
g = ogr.CreateGeometryFromWkb(self.aoi)
except:
raise IOError(
'The AOI has to be one of GeoJSON, GML, Wkt or Wkb.'
)
gjson_str = '''{"type":"FeatureCollection","features":[{"type":"Feature","properties":{},"geometry":%s}]}''' % g.ExportToJson(
)
with open(self.toa_dir + '/AOI.json', 'wb') as f:
f.write(gjson_str.encode())
ogr.DontUseExceptions()
gdal.DontUseExceptions()
if not os.path.exists(self.toa_dir + '/AOI.json'):
subprocess.call([
'gdaltindex', '-f', 'GeoJSON', '-t_srs', 'EPSG:4326',
self.toa_dir + '/AOI.json', self.toa_bands[0]
])
self.logger.warning(
'AOI is not created and full band extend is used')
self.aoi = self.toa_dir + '/AOI.json'
else:
self.aoi = self.toa_dir + '/AOI.json'
def coords_to_geovector(coords, epsg, path_export):
"""
Exports coordinates to a Point shapefile.
Parameters
----------
coords : list-like of list-likes
List or tuple of (x, y) coordinates to export.
epsg : int
EPSG code of the coordinate reference system of the coordinates.
path_export : str
Path with .shp extension where the shapefile should be saved.
Returns
-------
None.
"""
# TODO: This should be replaced by a geodataframe creation, but no use cases
# yet...
all_coords = []
for c in coords:
pt = ogr.Geometry(type=ogr.wkbPoint)
pt.AddPoint_2D(c[1], c[0])
all_coords.append(pt)
# Write the shapefile
driver = ogr.GetDriverByName('ESRI Shapefile')
datasource = driver.CreateDataSource(path_export)
srs = osr.SpatialReference()
srs.ImportFromEPSG(epsg)
layer = datasource.CreateLayer("Coords", srs, ogr.wkbPoint)
defn = layer.GetLayerDefn()
idField = ogr.FieldDefn('id', ogr.OFTInteger)
layer.CreateField(idField)
for i, p in enumerate(all_coords):
# Create a new feature (attribute and geometry)
feat = ogr.Feature(defn)
feat.SetField('id', int(i))
# Make a geometry
geom = ogr.CreateGeometryFromWkb(p.ExportToWkb())
feat.SetGeometry(geom)
layer.CreateFeature(feat)
feat = geom = None # destroy these
# Save and close everything
datasource = layer = feat = geom = None
def addPolygon(feat, simplePolygon, in_lyr, out_lyr):
featureDefn = in_lyr.GetLayerDefn()
polygon = ogr.CreateGeometryFromWkb(simplePolygon)
out_feat = ogr.Feature(featureDefn)
for field in field_name_list:
inValue = feat.GetField(field)
out_feat.SetField(field, inValue)
out_feat.SetGeometry(polygon)
out_lyr.CreateFeature(out_feat)
out_lyr.SetFeature(out_feat)
def shapelyReproject(shape, srsF, srsT):
from_srs = ogr.osr.SpatialReference()
from_srs.ImportFromEPSG(srsF)
to_srs = ogr.osr.SpatialReference()
to_srs.ImportFromEPSG(srsT)
ogr_geom = ogr.CreateGeometryFromWkb(shape.wkb)
ogr_geom.AssignSpatialReference(from_srs)
ogr_geom.TransformTo(to_srs)
return loads(ogr_geom.ExportToWkt())
def run(self):
"""Run method that performs all the real work"""
# show the dialog
#self.dlg.show()
# Run the dialog event loop
#Get the current selected feature
layer = self.iface.activeLayer()
selected_feature = layer.selectedFeatures()[0]
#Read its geometry
qgisgeom = selected_feature.geometry()
wkb = qgisgeom.asWkb()
#Convert to ogr
ogr_geom_wkb = ogr.CreateGeometryFromWkb(wkb)
#First Height Value
last_point = ogr_geom_wkb.GetPoint(0)
distance = 0
plot_x = [0]
plot_y = [last_point[2]]
for i in range(1,ogr_geom_wkb.GetPointCount()):
pt = ogr_geom_wkb.GetPoint(i)
#We had better be in EPSG:27700
#distance = distance + math.sqrt((pt[0] - last_point[0])**2 + (pt[1] - last_point[1])**2)
distance = distance + 20
#plot_points.append([distance,pt[2]])
plot_x.append(distance)
plot_y.append(pt[2])
self.scene = QtGui.QGraphicsScene(self.dlg)
figure = plt.figure()
ax = figure.add_subplot(111)
ax.hold(False)
ax.set_title("Dodgy Elevation Graph")
x_sm = np.array(plot_x)
y_sm = np.array(plot_y)
x_smooth = np.linspace(x_sm.min(), x_sm.max(), 400)
y_smooth = spline(plot_x, plot_y, x_smooth)
ax.plot(plot_x,plot_y,'*',x_smooth, y_smooth, 'red')
canvas = FigureCanvas(figure)
self.scene.addWidget(canvas)
self.dlg.graphicsView.setScene(self.scene)
self.dlg.show()
result = self.dlg.exec_()
# See if OK was pressed
if result:
pass
def shply_array_to_shp(arrayLike,
outfile,
geomType,
epsg=None,
fields=None,
crsObj=None):
"""
Convert a array with Shapely geometric data into a file
with geometry (GML, ESRI Shapefile or others).
Example of an array_like object:
data = [
{col_1: value, col_2: value, geom: geomObj},
{col_1: value, col_2: value, geom: geomObj},
]
"""
import os
from gasp.prop.ff import drv_name
from gasp.prop.prj import get_sref_from_epsg
# Create output file
shp = ogr.GetDriverByName(drv_name(outfile)).CreateDataSource(outfile)
lyr = shp.CreateLayer(
os.path.splitext(os.path.basename(outfile))[0],
get_sref_from_epsg(epsg) if epsg else crsObj if crsObj else \
None, geom_type=geomType
)
# Create fields of output file
# TODO: Automatic mapping of filters types needs further testing
if fields:
for f in fields:
lyr.CreateField(ogr.FieldDefn(f, fields[f]))
# Add features
defn = lyr.GetLayerDefn()
for feat in arrayLike:
newFeat = ogr.Feature(defn)
newFeat.SetGeometry(ogr.CreateGeometryFromWkb(feat['GEOM'].wkb))
if len(fields):
for f in fields:
newFeat.SetField(f, feat[f])
lyr.CreateFeature(newFeat)
newFeat = None
shp.Destroy()
return outfile
def addPolygon(simplePolygon, feature, out_lyr):
featureDefn = out_lyr.GetLayerDefn()
polygon = ogr.CreateGeometryFromWkb(simplePolygon)
out_feat = ogr.Feature(featureDefn)
out_feat.SetGeometry(polygon)
#Loop over each field from the source, and copy onto the new feature
for id in range(feature.GetFieldCount()):
data = feature.GetField(id)
out_feat.SetField(id, data)
out_feat.SetField(id + 1, str(uuid.uuid4().fields[-1])[:6])
out_lyr.CreateFeature(out_feat)
def addPolygon(simplePolygon, feature, layer):
featureDefn = layer.GetLayerDefn()
polygon = ogr.CreateGeometryFromWkb(simplePolygon)
new_feat = ogr.Feature(featureDefn)
new_feat.SetGeometry(polygon)
for id in range(feature.GetFieldCount()):
data = feature.GetField(id)
new_feat.SetField(id, data)
layer.CreateFeature(new_feat)
def add(self, **kwargs) -> dict:
'''
add a new row to the table, sets id if "fid" is passed
Parameters
----------
**kwargs
field values, field name as key and value of field as value
e.g. table.add(name='Thomas Müller')
Returns
-------
dict
added row with field names as keys, field values as values
Raises
------
Exception
ogr error code while creating
'''
geom = kwargs.pop(self.geom_field, None)
id = kwargs.pop(self.id_field, None)
feature = ogr.Feature(self._layer.GetLayerDefn())
if id is not None:
feature.SetFID(id)
for field, value in kwargs.items():
if field not in self.field_names:
continue
if isinstance(value, np.integer):
value = int(value)
if isinstance(value, np.float):
value = float(value)
ret = feature.SetField(field, value)
if geom:
if not isinstance(geom, ogr.Geometry):
# geometries as bytes are preferable
if hasattr(geom, 'asWkb'):
geom = geom.asWkb().data()
# some qgis geometries only support export to wkt
elif hasattr(geom, 'asWkt'):
geom = geom.asWkt()
if isinstance(geom, str):
geom = ogr.CreateGeometryFromWkt(geom)
elif isinstance(geom, bytes):
geom = ogr.CreateGeometryFromWkb(geom)
else:
raise Exception('unsupported geometry type')
feature.SetGeometry(geom)
ret = self._layer.CreateFeature(feature)
if ret != 0:
raise Exception(
f'Feature could not be created in table {self.name}. '
f'Ogr declined creation with error code {ret}')
return self._ogr_feat_to_row(feature)
def geotrans(g, ct): # transform a shapelyGeometry or gdalGeometry
is_base = isinstance(g, geometry.base.BaseGeometry) # test for shapelyGeometry
if is_base: # if shapelyGeometry, convert to a gdalGeometry
g = ogr.CreateGeometryFromWkb(g.wkb)
try:
assert g.Transform(ct) == 0
except:
raise IOError("Could not transform geometry: '%s'" % g.ExportToWkt())
if is_base: # if we originally had a shapelyGeometry, convert it back
g = wkb.loads(g.ExportToWkb())
return g
def ogr_wkbwkt_test_import_bad_multipoint_wkb():
import struct
wkb = struct.pack('B' * 30, 0, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, 0, 0 )
gdal.PushErrorHandler('CPLQuietErrorHandler')
geom = ogr.CreateGeometryFromWkb(wkb)
gdal.PopErrorHandler()
if geom is not None:
return 'fail'
return 'success'
def wkb_transform(wkb, src_sr, dst_sr):
"""
Return a shapely geometry transformed from src_sr to dst_sr.
:param wkb: wkb bytes
:param src_sr: source osr SpatialReference
:param dst_sr: destination osr SpatialReference
"""
result = ogr.CreateGeometryFromWkb(wkb, src_sr)
result.TransformTo(dst_sr)
return result.ExportToWkb()
def write_shapefile(blobs, georef_filename, out_shp):
"""
https://gis.stackexchange.com/a/52708/8104
"""
# load georeference information to use
img = rio.open(georef_filename)
geoinfo = img.crs
transform = img.transform
# convert blobs in polygons
polygons = []
ids = []
classnames = []
colors = []
for blob in blobs:
if blob.qpath_gitem.isVisible():
polygon = createPolygon(blob, transform)
ids.append(blob.id)
classnames.append(blob.class_name)
colors.append('#%02X%02X%02X' % tuple(blob.class_color))
polygons.append(polygon)
# Now convert them to a shapefile with OGR
outDriver = ogr.GetDriverByName('Esri Shapefile')
outDataSource = outDriver.CreateDataSource(out_shp)
srs = osr.SpatialReference()
if geoinfo is not None:
srs.ImportFromWkt(geoinfo.wkt)
outLayer = outDataSource.CreateLayer("polygon",
srs,
geom_type=ogr.wkbPolygon)
# Add id to polygon
outLayer.CreateField(ogr.FieldDefn('id', ogr.OFTInteger))
outLayer.CreateField(ogr.FieldDefn('class', ogr.OFTString))
defn = outLayer.GetLayerDefn()
## If there are multiple geometries, put the "for" loop here
for i in range(len(ids)):
# Create a new feature (attribute and geometry)
feat = ogr.Feature(defn)
feat.SetField('id', ids[i])
feat.SetField('class', classnames[i])
# Make a geometry, from Shapely object
geom = ogr.CreateGeometryFromWkb(polygons[i].wkb)
feat.SetGeometry(geom)
feat.SetStyleString('BRUSH(fc:' + colors[i] + ')')
outLayer.CreateFeature(feat)
feat = geom = None # destroy these
# Save and close everything
ds = layer = feat = geom = None
def Dissolve_polygons(gdb_path, output_file):
'''Dissolve polygons'''
multipoly = False
overwrite = True
# Deal with reading filegdb data
indriver = ogr.GetDriverByName('OpenFileGDB')
gdb = indriver.Open(gdb_path, 0)
# list to store layers'names
featsClassList = []
# parsing layers by index
for featsClass_idx in range(gdb.GetLayerCount()):
lyr = gdb.GetLayerByName("BENTHIC_filtered_separated_285000504")
outdriver = ogr.GetDriverByName('ESRI Shapefile')
output_datasource = outdriver.CreateDataSource(output_file)
out_name = output_file.replace('.shp', '')
if '\\' in out_name:
out_name = out_name.split('\\')[-1]
output_lyr = output_datasource.CreateLayer(
str(out_name.encode('utf-8')), lyr.GetSpatialRef(),
lyr.GetGeomType())
defn = output_lyr.GetLayerDefn()
multi = ogr.Geometry(ogr.wkbMultiPolygon)
for feat in lyr:
if feat.geometry():
feat.geometry().CloseRings(
) # this copies the first point to the end
wkt = feat.geometry().ExportToWkt()
multi.AddGeometryDirectly(ogr.CreateGeometryFromWkt(wkt))
union = multi.UnionCascaded()
if multipoly is False:
for geom in union:
poly = ogr.CreateGeometryFromWkb(geom.ExportToWkb())
feat = ogr.Feature(defn)
feat.SetGeometry(poly)
output_lyr.CreateFeature(feat)
else:
output_feat = ogr.Feature(defn)
output_feat.SetGeometry(union)
output_lyr.CreateFeature(output_feat)
gdb.Destroy()
output_datasource.Destroy()
return out_name
def save(targetPath,
sourceProj4,
shapelyGeometries,
fieldPacks=None,
fieldDefinitions=None,
driverName='ESRI Shapefile',
targetProj4=''):
'Save shapelyGeometries using the given proj4 and fields'
# Validate arguments
if not fieldPacks:
fieldPacks = []
if not fieldDefinitions:
fieldDefinitions = []
if fieldPacks and set(len(x)
for x in fieldPacks) != set([len(fieldDefinitions)]):
raise GeometryError('A field definition is required for each field')
# Make dataSource
if os.path.exists(targetPath):
os.remove(targetPath)
dataDriver = ogr.GetDriverByName(driverName)
if not dataDriver:
raise GeometryError('Could not load driver: {}'.format(driverName))
dataSource = dataDriver.CreateDataSource(targetPath)
# Make layer
layerName = os.path.splitext(os.path.basename(targetPath))[0]
spatialReference = get_spatialReference(targetProj4 or sourceProj4)
geometryType = get_geometryType(shapelyGeometries)
layer = dataSource.CreateLayer(layerName, spatialReference, geometryType)
# Make fieldDefinitions in featureDefinition
for fieldName, fieldType in fieldDefinitions:
layer.CreateField(ogr.FieldDefn(fieldName, fieldType))
featureDefinition = layer.GetLayerDefn()
# Save features
transform_geometry = get_transform_geometry(sourceProj4, targetProj4)
for shapelyGeometry, fieldPack in itertools.izip(
shapelyGeometries,
fieldPacks) if fieldPacks else ((x, [])
for x in shapelyGeometries):
# Prepare feature
feature = ogr.Feature(featureDefinition)
feature.SetGeometry(
transform_geometry(ogr.CreateGeometryFromWkb(shapelyGeometry.wkb)))
for fieldIndex, fieldValue in enumerate(fieldPack):
if (hasattr(feature, 'SetField2')):
feature.SetField2(fieldIndex, fieldValue)
else:
feature.SetField(fieldIndex, fieldValue)
# Save feature
layer.CreateFeature(feature)
# Clean up
feature.Destroy()
# Return
return targetPath
def reproj_shape_to_raster(path_in_shp, path_raster, path_out_shp):
# Opens the base raster
base_tiff = gdal.Open(path_raster)
# shapefile with the from projection
driver = ogr.GetDriverByName("ESRI Shapefile")
in_ds = driver.Open(path_in_shp, 1)
in_layer = in_ds.GetLayer()
# set spatial reference and transformation
sourceprj = in_layer.GetSpatialRef()
targetprj = osr.SpatialReference(wkt = base_tiff.GetProjection())
# create the CoordinateTransformation
coord_transform = osr.CoordinateTransformation(sourceprj, targetprj)
# create the output layer
out_driver = ogr.GetDriverByName("ESRI Shapefile")
if os.path.exists(path_out_shp):
out_driver.DeleteDataSource(path_out_shp)
out_ds = out_driver.CreateDataSource(path_out_shp)
out_layer = out_ds.CreateLayer('', targetprj, ogr.wkbPolygon)
# add fields
in_layerDefn = in_layer.GetLayerDefn()
for i in range(0, in_layerDefn.GetFieldCount()):
field_defn = in_layerDefn.GetFieldDefn(i)
out_layer.CreateField(field_defn)
# get the output layer's feature definition
out_layer_defn = out_layer.GetLayerDefn()
# loop through the input features
in_feature = in_layer.GetNextFeature()
while in_feature:
# get the input geometry
geom = in_feature.GetGeometryRef()
# reproject the geometry
geom.Transform(coord_transform)
geom = ogr.CreateGeometryFromWkb(geom.ExportToWkb())
# create a new feature
out_feature = ogr.Feature(out_layer_defn)
# set the geometry and attribute
out_feature.SetGeometry(geom)
for i in range(0, out_layer_defn.GetFieldCount()):
out_feature.SetField(out_layer_defn.GetFieldDefn(i).GetNameRef(), in_feature.GetField(i))
# add the feature to the shapefile
out_layer.CreateFeature(out_feature)
# dereference the features and get the next input feature
out_feature = None
in_feature = in_layer.GetNextFeature()
out_ds = None
in_ds = None
def output_ogr(self, output):
driver = ogr.GetDriverByName('ESRI Shapefile')
if os.path.exists(output['file_name']):
driver.DeleteDataSource(output['file_name'])
source = driver.CreateDataSource(output['file_name'])
layer = source.CreateLayer(self.layer_dfn.GetName(),
geom_type=self.layer_dfn.GetGeomType(),
srs=self.layer.GetSpatialRef())
for field in self.fields:
fd = ogr.FieldDefn(str(field['name']), field['type'])
fd.SetWidth(field['width'])
if 'precision' in field:
fd.SetPrecision(field['precision'])
layer.CreateField(fd)
for geometry in self.geometries:
if geometry.geom is not None:
feature = ogr.Feature(feature_def=layer.GetLayerDefn())
for index, field in enumerate(self.fields):
if field['name'] in geometry.properties:
feature.SetField(
index,
geometry.properties[field['name']].encode('utf-8'))
else:
feature.SetField(index, '')
feature.SetGeometryDirectly(
ogr.CreateGeometryFromWkb(shapely.wkb.dumps(
geometry.geom)))
layer.CreateFeature(feature)
feature.Destroy()
source.Destroy()
def get_geometries(self, exchange_item): # This method should work for both input and output
if isinstance(exchange_item, list):
igeoms = {}
for item in exchange_item:
name = item['name']
geoms = [ogr.CreateGeometryFromWkb(g) for g in item['geometry']['wkb']]
igeoms[name] = geoms
return igeoms
else:
elog.debug("Exchange item must be a list of dictionaries")
elog.debug("Exchange item may be None")
return {}
def to_ogr(self, layer_defn, fid=None):
ogr_feature = ogr.Feature(layer_defn)
ogr_feature.SetFID(self.id)
ogr_feature.SetGeometry(ogr.CreateGeometryFromWkb(self.geom.wkb))
for field in self.fields:
ogr_feature[field.encode("utf8")] = self.fields[field]
if fid is not None:
ogr_feature[fid.encode("utf8")] = self.id
return ogr_feature
def create_shp_file_from_tile_list_wrs(tile_list):
spatial_ref = osr.SpatialReference()
spatial_ref.ImportFromEPSG(4326)
# Create the output Driver
# out_driver = ogr.GetDriverByName("ESRI Shapefile")
# Create the output GeoJSON
out_datasource = shapefile_driver.CreateDataSource(
"intersecting_wrstiles.shp")
# out_layer = out_datasource.CreateLayer('wrs', geom_type=ogr.wkbPolygon )
out_layer = out_datasource.CreateLayer("wrs",
spatial_ref,
geom_type=ogr.wkbMultiPolygon)
# Add an ID field
idField = ogr.FieldDefn("id", ogr.OFTInteger)
out_layer.CreateField(idField)
pathrow_field = ogr.FieldDefn("pr", ogr.OFTString)
path_field = ogr.FieldDefn("path", ogr.OFTString)
row_field = ogr.FieldDefn("row", ogr.OFTString)
out_layer.CreateField(pathrow_field)
out_layer.CreateField(path_field)
out_layer.CreateField(row_field)
featureDefn = out_layer.GetLayerDefn()
for idx, feat in enumerate(intersect_list):
print("Tryng to create a feature.")
feature = ogr.Feature(featureDefn)
feature.SetField("id", idx + 1)
feature.SetField("pr", feat[0])
feature.SetField("path", feat[0][:3])
feature.SetField("row", feat[0][3:])
print("trying to set geometry")
feature.SetGeometry(ogr.CreateGeometryFromWkb(feat[1]))
# print(feat)
out_layer.CreateFeature(feature)
print("created feature")
feature = None
out_datasource = None
# all done!
grid_ds = None
input_ds = None
def _loadShapefile(FilePath, ExpectedFields, UnitsClass):
BoogieScape._printActionStarted(
"Opening input {} file".format(UnitsClass))
Source = BoogieScape._SHPDriver.Open(
FilePath, 0) # 0 means read-only. 1 means writeable.
if Source is None:
BoogieScape._printActionFailed(
"Failed (could not open {})".format(FilePath))
else:
BoogieScape._printActionDone()
BoogieScape._checkLayerFieldsTypes(Source, ExpectedFields)
BoogieScape._printActionStarted(
"Loading input {} file".format(UnitsClass))
UnitsData = dict()
Layer = Source.GetLayer(0)
Layer.ResetReading()
for Feature in Layer:
Unit = Data.SpatialUnit()
Unit.Geometry = ogr.CreateGeometryFromWkb(
Feature.GetGeometryRef().ExportToWkb())
for Field, Type in ExpectedFields.items():
if Field == "OFLD_ID":
Unit.Id = Feature.GetField(Field)
elif Field == "OFLD_PSORD":
Unit.PcsOrd = Feature.GetField(Field)
elif Field == "OFLD_TO":
ToStrList = Feature.GetField(Field)
if ToStrList:
Unit.To = BoogieScape.splitUnitsStrList(ToStrList)
elif Field == "OFLD_CHILD":
ChildStrList = Feature.GetField(Field)
if ChildStrList:
Unit.Child = BoogieScape.splitUnitsStrList(
ChildStrList)
else:
Unit.Attributes[Field] = Feature.GetField(Field)
if Unit.Id is None:
BoogieScape._printActionFailed("Failed (empty OFLD_ID field)")
UnitsData[Unit.Id] = Unit
BoogieScape._printActionDone()
return UnitsData
def addMultiPolygon(simplePolygon, feature, out_lyr):
"""
Link with multipart2singlepart (above)
"""
featureDefn = out_lyr.GetLayerDefn()
polygon = ogr.CreateGeometryFromWkb(simplePolygon)
out_feat = ogr.Feature(featureDefn)
out_feat.SetGeometry(polygon)
# Loop over each field from the source, and copy onto the new feature
for id in range(feature.GetFieldCount()):
data = feature.GetField(id)
out_feat.SetField(id, data)
out_lyr.CreateFeature(out_feat)
def addMultiPolygon(simplePolygon, valuesfields, out_lyr):
"""
Link with multipart2singlepart (above)
"""
featureDefn = out_lyr.GetLayerDefn()
polygon = ogr.CreateGeometryFromWkb(simplePolygon)
out_feat = ogr.Feature(featureDefn)
out_feat.SetGeometry(polygon)
# Loop over each field from the source, and copy onto the new feature
for idx in range(len(valuesfields)):
out_feat.SetField(idx, valuesfields[idx][2])
out_lyr.CreateFeature(out_feat)
def netgeometry(key, data):
if data.has_key('Wkb'):
geom = ogr.CreateGeometryFromWkb(data['Wkb'])
elif data.has_key('Wkt'):
geom = ogr.CreateGeometryFromWkt(data['Wkt'])
elif type(key[0]) == 'tuple': # edge keys are packed tuples
geom = ogr.Geometry(ogr.wkbLineString)
_from, _to = key[0], key[1]
geom.SetPoint(0, *_from)
geom.SetPoint(1, *_to)
else:
geom = ogr.Geometry(ogr.wkbPoint)
geom.SetPoint(0, *key)
return geom
def ogr_wkbwkt_test_geometrycollection_wkb_recursion():
import struct
wkb_repeat = struct.pack('B' * 9, 0, 0, 0, 0, 7, 0, 0, 0, 1)
wkb_end = struct.pack('B' * 9, 0, 0, 0, 0, 7, 0, 0, 0, 0)
wkb = wkb_repeat * 31 + wkb_end
geom = ogr.CreateGeometryFromWkb(wkb)
if geom is None:
gdaltest.post_reason('expected a geometry')
return 'fail'
wkb = struct.pack('B' * 0) + wkb_repeat * 32 + wkb_end
gdal.PushErrorHandler('CPLQuietErrorHandler')
geom = ogr.CreateGeometryFromWkb(wkb)
gdal.PopErrorHandler()
if geom is not None:
gdaltest.post_reason('expected None')
return 'fail'
return 'success'
def wktPolygonToShapefile(polygon):
poly = shapely.wkt.loads(polygon)
driver = ogr.GetDriverByName("Esri Shapefile")
ds = driver.CreateDataSource('scratch.shp')
layer = ds.CreateLayer('', None, ogr.wkbPolygon)
layer.CreateField(ogr.FieldDefn('id', ogr.OFTInteger))
defn = layer.GetLayerDefn()
feat = ogr.Feature(defn)
feat.SetField('id', 0)
geom = ogr.CreateGeometryFromWkb(poly.wkb)
feat.SetGeometry(geom)
layer.CreateFeature(feat)
feat = geom = None
ds = layer = feat = geom = None
def shapely_to_shp(obj, path, srs=None):
from osgeo import osr, ogr
# path = os.path.join('/tmp',outname+'.shp')
if srs is None:
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
if isinstance(obj, MultiPoint):
test = ogr.CreateGeometryFromWkb(obj[0].wkb)
ogr_geom = test.GetGeometryType()
else:
ogr_geom = 3
dr = ogr.GetDriverByName('ESRI Shapefile')
ds = dr.CreateDataSource(path)
try:
if ds is None:
raise IOError(
'Could not create file on disk. Does it already exist?')
layer = ds.CreateLayer('lyr', srs=srs, geom_type=ogr_geom)
try:
feature_def = layer.GetLayerDefn()
except:
import ipdb
ipdb.set_trace()
feat = ogr.Feature(feature_def)
try:
iterator = iter(obj)
except TypeError:
iterator = iter([obj])
for geom in iterator:
feat.SetGeometry(ogr.CreateGeometryFromWkb(geom.wkb))
layer.CreateFeature(feat)
finally:
ds.Destroy()
