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()