def xyz2ogr(src_xyz, dst_ogr, xloc = 0, yloc = 1, zloc = 2, dst_fmt = 'ESRI Shapefile',\ overwrite = True, verbose = False): '''Make a point vector OGR file from a src_xyz table data''' driver = ogr.GetDriverByName(dst_fmt) if os.path.exists(dst_ogr): driver.DeleteDataSource(dst_ogr) ds = driver.CreateDataSource(dst_ogr) layer = ds.CreateLayer(dst_ogr, geom_type=ogr.wkbPoint25D) oft_title = "Longitude" oft_string = ogr.OFTReal fdw = 12 fdp = 8 fd = ogr.FieldDefn(oft_title, oft_string) fd.SetWidth(fdw) fd.SetPrecision(fdp) layer.CreateField(fd) oft_title = "Latitude" fd = ogr.FieldDefn(oft_title, oft_string) fd.SetWidth(fdw) fd.SetPrecision(fdp) layer.CreateField(fd) oft_title = "Elevation" fd = ogr.FieldDefn(oft_title, oft_string) fd.SetWidth(fdw) fd.SetPrecision(fdp) layer.CreateField(fd) f = ogr.Feature(feature_def=layer.GetLayerDefn()) #for this_xyz in xyz_parse(src_xyz): for this_xyz in src_xyz: x = this_xyz[xloc] y = this_xyz[yloc] z = this_xyz[zloc] f.SetField(0, x) f.SetField(1, y) f.SetField(2, z) wkt = 'POINT(%f %f %f)' % (x, y, z) g = ogr.CreateGeometryFromWkt(wkt) f.SetGeometryDirectly(g) layer.CreateFeature(f)
def writeVectorFile(self, scaledPredPolygons): """ 将带有地理信息的多边形对象列表,转化为矢量文件并保存 :param scaledPredPolygons: list 类型。带有地理信息的多边形对象列表 :return: """ gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") gdal.SetConfigOption("SHAPE_ENCODING", "") strVectorFile = self.outPath ogr.RegisterAll() strDriverName = "ESRI Shapefile" oDriver = ogr.GetDriverByName(strDriverName) if oDriver is None: print("%s 驱动不可用!\n", strDriverName) oDS = oDriver.CreateDataSource(strVectorFile) if oDS is None: print("创建文件【%s】失败!", strVectorFile) papszLCO = [] oLayer = oDS.CreateLayer("TestPolygon", None, ogr.wkbPolygon, papszLCO) if oLayer is None: print("图层创建失败!\n") oFieldID = ogr.FieldDefn("FieldID", ogr.OFTInteger) oLayer.CreateField(oFieldID, 1) oFieldName = ogr.FieldDefn("FieldName", ogr.OFTString) oFieldName.SetWidth(100) oLayer.CreateField(oFieldName, 1) oDefn = oLayer.GetLayerDefn() i = 0 for poly in scaledPredPolygons: oFeatureTriangle = ogr.Feature(oDefn) oFeatureTriangle.SetField(0, i) oFeatureTriangle.SetField(1, "bianhua") geomTriangle = ogr.CreateGeometryFromWkt(poly.to_wkt()) oFeatureTriangle.SetGeometry(geomTriangle) oLayer.CreateFeature(oFeatureTriangle) i = i + 1 oDS.Destroy() print("数据集创建完成!")
def main(inzscoreimg, outshapefile): if not os.path.exists(inzscoreimg): print("File %s does not exist. Quitting." % (inzscoreimg)) sys.exit(0) inDS = gdal.Open(inzscoreimg, gdal.GA_ReadOnly) gt = inDS.GetGeoTransform() proj = inDS.GetProjection() data = inDS.GetRasterBand(1).ReadAsArray() inDS = None highvals = np.greater_equal(data, 1.0) lin, pix = np.nonzero(highvals) ycoords = gt[3] + (lin * gt[5]) xcoords = gt[0] + (pix * gt[1]) spatialReference = osr.SpatialReference() spatialReference.ImportFromEPSG(3857) drv = ogr.GetDriverByName('ESRI Shapefile') shapeData = drv.CreateDataSource(outshapefile) layer = shapeData.CreateLayer('zscore', spatialReference, ogr.wkbPoint) layer_defn = layer.GetLayerDefn( ) # gets parameters of the current shapefile pointidDefn = ogr.FieldDefn('pointid', ogr.OFTInteger) zscoreDefn = ogr.FieldDefn('zscore', ogr.OFTReal) zscoreDefn.SetWidth(8) zscoreDefn.SetPrecision(2) layer.CreateField(pointidDefn) layer.CreateField(zscoreDefn) featureIndex = 0 #this will be the second polygon in our dataset for j in range(ycoords.shape[0]): pnt = ogr.Geometry(ogr.wkbPoint) pnt.AddPoint(xcoords[j], ycoords[j]) feature = ogr.Feature(layer_defn) feature.SetGeometry(pnt) feature.SetFID(featureIndex) feature.SetField('pointid', j + 1) feature.SetField('zscore', float(data[lin[j], pix[j]])) layer.CreateFeature(feature) featureIndex += 1 pnt = None feature = None shapeData.Destroy() #lets close the shapefile
def add_field(shp_path, field_name, field_type=ogr.OFTString, field_value_list=None): """给 shp 增加一个 field""" ds = ogr.Open(shp_path, gdal.GA_Update) lyr = ds.GetLayer() # 当前字段不存在,可以创建 if lyr.FindFieldIndex(field_name, 1) == -1: new_field = ogr.FieldDefn(field_name, field_type) # 创建字段 lyr.CreateField(new_field) # 增加字段 else: # print('the field have exist') return # 编辑字段中的元素 length = len(field_value_list) for feature_index, each_feature in enumerate(lyr): if length > feature_index: each_feature.SetField(field_name, field_value_list[feature_index]) lyr.SetFeature(each_feature) # 这一句话不加的话,属性是设置不了的 else: break # 退出循环,有多少值就设置多少个 ds.FlushCache() ds.Destroy()
def createOutputFile( self, pathname, image ): """ create output vector to write boundary footprint polygon geometries """ # overwrite existing file centroids = None driver = ogr.GetDriverByName('Esri Shapefile') if os.path.exists( pathname ): driver.DeleteDataSource( pathname ) # create shapefile ds = driver.CreateDataSource( pathname ) if ds is not None: # add row number id attribute srs = osr.SpatialReference(wkt=image[ 'projection' ] ) layer = ds.CreateLayer('', srs, ogr.wkbPoint) layer.CreateField(ogr.FieldDefn('id', ogr.OFTInteger)) # package up details into dictionary centroids = { 'ds': ds, 'layer' : layer, 'srs' : srs, 'defn' : layer.GetLayerDefn() } return centroids
def convert_field(self, layer_name, field): fieldname = '{0}_as_date'.format(field) target_layer = self.data.GetLayerByName(layer_name) while target_layer.GetLayerDefn().GetFieldIndex(fieldname) >= 0: fieldname = increment(fieldname) target_layer.CreateField(ogr.FieldDefn(fieldname, ogr.OFTDateTime)) field_index = target_layer.GetLayerDefn().GetFieldIndex(fieldname) for feat in target_layer: if not feat: continue string_field = feat[str(field)] if string_field: pars = parse(str(string_field)) feat.SetField(field_index, pars.year, pars.month, pars.day, pars.hour, pars.minute, pars.second, pars.microsecond) target_layer.SetFeature(feat) feat = None return fieldname
def create_temp_shp(self, name): """Cretes a shapefile with a vector layer named "geometry" containing a 100mx100m square , top left corner being at wgs coords 10,10. This polygon has a field, 'class' with a value of 3.""" # TODO Generalise this vector_file = os.path.join(self.temp_dir.name, name) shape_driver = ogr.GetDriverByName( "ESRI Shapefile") # Depreciated; replace at some point vector_data_source = shape_driver.CreateDataSource(vector_file) vector_layer = vector_data_source.CreateLayer("geometry", self.srs, geom_type=ogr.wkbPolygon) ring = ogr.Geometry(ogr.wkbLinearRing) ring.AddPoint(10.0, 10.0) ring.AddPoint(10.0, 110.0) ring.AddPoint(110.0, 110.0) ring.AddPoint(110.0, 10.0) ring.AddPoint(10.0, 10.0) poly = ogr.Geometry(ogr.wkbPolygon) poly.AddGeometry(ring) vector_feature_definition = vector_layer.GetLayerDefn() vector_feature = ogr.Feature(vector_feature_definition) vector_feature.SetGeometry(poly) vector_layer.CreateFeature(vector_feature) vector_layer.CreateField(ogr.FieldDefn("class", ogr.OFTInteger)) feature = ogr.Feature(vector_layer.GetLayerDefn()) feature.SetField("class", 3) vector_data_source.FlushCache() self.vectors.append( vector_data_source ) # Check this is the right thing to be saving here self.vector_paths.append(vector_file)
def mask_to_polygon_in_memory(original_data, array, field_name='label'): geotrans = original_data.GetGeoTransform() proj = original_data.GetProjection() driver = gdal.GetDriverByName('MEM') dataset = driver.Create('', array.shape[1], array.shape[0], 1, gdal.GDT_Float32) dataset.GetRasterBand(1).WriteArray(array) dataset.SetProjection(proj) dataset.SetGeoTransform(geotrans) band = dataset.GetRasterBand(1) driver_mask = gdal.GetDriverByName('MEM') ds_mask = driver_mask.Create('', array.shape[1], array.shape[0], 1, gdal.GDT_Float32) ds_mask.SetGeoTransform(geotrans) ds_mask.SetProjection(proj) ds_mask_array = (array > 0).astype(np.int32) ds_mask.GetRasterBand(1).WriteArray(ds_mask_array) mask_band = ds_mask.GetRasterBand(1) srs = osr.SpatialReference(wkt=proj) driver = gdal.GetDriverByName("Memory") outDatasource = driver.Create('', 0, 0, 0, gdal.GDT_Float32) # outDatasource = driver.CreateDataSource('') outLayer = outDatasource.CreateLayer("polygonized", srs=srs) if field_name is None: field_name = 'MyFLD' newField = ogr.FieldDefn(field_name, ogr.OFTInteger) outLayer.CreateField(newField) gdal.Polygonize(band, mask_band, outLayer, 0, [], callback=None) return outDatasource
def buffer(infile, outfile, buffdist): #try: ds_in=ogr.Open( infile ) lyr_in=ds_in.GetLayer( 0 ) drv=ds_in.GetDriver() if os.path.exists( outfile ): drv.DeleteDataSource(outfile) ds_out = drv.CreateDataSource( outfile ) layer = ds_out.CreateLayer( lyr_in.GetLayerDefn().GetName(), \ lyr_in.GetSpatialRef(), ogr.wkbPolygon) for i in range ( lyr_in.GetLayerDefn().GetFieldCount() ): field_in = lyr_in.GetLayerDefn().GetFieldDefn( i ) fielddef = ogr.FieldDefn( field_in.GetName(), field_in.GetType() ) layer.CreateField ( fielddef ) for feat in lyr_in: geom = feat.GetGeometryRef() feature = feat.Clone() feature.SetGeometry(geom.Buffer(float(buffdist))) layer.CreateFeature(feature) del geom ds_out.Destroy() print(ds_out)
def write_stops_shp(stops): # Define filename input path = 'export/shp/' # Shape file definitions spatialReference = osr.SpatialReference() spatialReference.ImportFromProj4( '+proj=utm +zone=48N +ellps=WGS84 +datum=WGS84 +units=m ') driver = ogr.GetDriverByName('ESRI Shapefile') # Create shapefile for stops shapeData = driver.CreateDataSource(path) layer = shapeData.CreateLayer("mapanica-stops", spatialReference, ogr.wkbPoint) layer_defn = layer.GetLayerDefn() layer.CreateField(ogr.FieldDefn('name', ogr.OFTString)) for stop in stops: # Adding data featDef = ogr.Feature(layer_defn) featDef.SetGeometry(stop.GetGeometryRef()) featDef.SetField('name', stop.GetField('name')) # Create file layer.CreateFeature(featDef) return
def test_add_singlepart_geometry(): # get random geom_typ and spatial ref output_geom_type = 3 in_spatial_ref = SHP_IN_LAYER.GetSpatialRef() # create memory layer mem_datasource = create_mem_ds() mem_layer = mem_datasource.CreateLayer("test", in_spatial_ref, output_geom_type) layer_field = ogr.FieldDefn("name", ogr.OFTString) mem_layer.CreateField(layer_field) # Create ring ring = ogr.Geometry(ogr.wkbLinearRing) ring.AddPoint_2D(1, 1) ring.AddPoint_2D(1, -1) ring.AddPoint_2D(-1, 1) ring.AddPoint_2D(-1, -1) ring.AddPoint_2D(1, 1) # Create polygon poly = ogr.Geometry(ogr.wkbPolygon) poly.AddGeometry(ring) content = {"name": "my_polygon"} add_singlepart_geometry(poly.ExportToWkb(), content, mem_layer) test_dump = mem_layer.GetFeature(0).ExportToJson() assert "my_polygon" in test_dump assert "[[[1.0, 1.0], [1.0, -1.0]," in test_dump
def write_shp(busnumber, busline, busstops): # Define filename input path = 'export/shp/' if os.path.isfile(path + busnumber + "-1" + "-stops.shp"): route_direction = "2" else: route_direction = "1" # Shape file definitions spatialReference = osr.SpatialReference() #will create a spatial reference locally to tell the system what the reference will be spatialReference.ImportFromProj4( '+proj=utm +zone=48N +ellps=WGS84 +datum=WGS84 +units=m') #here we define this reference to be utm Zone 48N with wgs84... driver = ogr.GetDriverByName('ESRI Shapefile') # will select the driver foir our shp-file creation. # Create shapefile for stops shapeData = driver.CreateDataSource(path) #so there we will store our data layer = shapeData.CreateLayer(busnumber + "-" + route_direction + "-stops", spatialReference, ogr.wkbPoint) #this will create a corresponding layer for our data with given spatial information. layer_defn = layer.GetLayerDefn() # gets parameters of the current shapefile fd = ogr.FieldDefn('name', ogr.OFTString) layer.CreateField(fd) # Adding elements feat = busstops.GetNextFeature() while feat is not None: featDef = ogr.Feature(layer_defn) featDef.SetGeometry(feat.GetGeometryRef()) featDef.SetField('name', feat.name) layer.CreateFeature(featDef) feat.Destroy() feat = busstops.GetNextFeature() # Create shapefile for route shapeData = driver.CreateDataSource(path) #so there we will store our data layer = shapeData.CreateLayer(busnumber + "-" + route_direction + "-route", spatialReference, ogr.wkbLineString) #this will create a corresponding layer for our data with given spatial information. layer_defn = layer.GetLayerDefn() # gets parameters of the current shapefile # Adding elements feat = busline.GetNextFeature() while feat is not None: featDef = ogr.Feature(layer_defn) featDef.SetGeometry(feat.GetGeometryRef()) layer.CreateFeature(featDef) feat.Destroy() feat = busline.GetNextFeature() shapeData.Destroy() #lets close the shapefile return
def main(): args = getArgs() if args.verbose: print args raster = gdal.Open(args.input, GA_ReadOnly) if args.band: band = raster.GetRasterBand(args.band) else: band = raster.GetRasterBand(1) driver = ogr.GetDriverByName("ESRI Shapefile") vector = driver.CreateDataSource(args.output) projection = osr.SpatialReference() projection.ImportFromWkt(raster.GetProjectionRef()) layer = vector.CreateLayer("out", srs=projection) field = "class" field_def = ogr.FieldDefn(field, ogr.OFTInteger) layer.CreateField(field_def) field_type_example = 0 maskband = None options = [] output = gdal.Polygonize(band, maskband, layer, field_type_example, options) band = None raster = None shapefile = None
def polygonize(input_tif, band, epsg): epsg_code = epsg.split(':')[1] srs = osr.SpatialReference() srs.ImportFromEPSG(int(epsg_code)) source_raster = gdal.Open(input_tif) band = source_raster.GetRasterBand(band) band_array = band.ReadAsArray() out_vector_file = "polygonized.json" driver = ogr.GetDriverByName('GeoJSON') out_data_source = driver.CreateDataSource(out_vector_file + "") out_layer = out_data_source.CreateLayer(out_vector_file, srs=srs) new_field = ogr.FieldDefn('change_detection', ogr.OFTInteger) out_layer.CreateField(new_field) gdal.Polygonize(band, None, out_layer, 0, [], callback=None) out_data_source = None source_raster = None data = json.loads(open(out_vector_file).read()) gdf = gp.GeoDataFrame.from_features(data['features']) gdf.crs = {'init': 'epsg:{}'.format(epsg_code)} gdf = gdf.to_crs(epsg=epsg_code) os.remove(out_vector_file) return gdf
def pcr2Shapefile(srcMap, dstShape, fieldName): """ polygonize a pcraster map into a shapefile srcMap: string, path to PCRaster map dstShape: string, path to shapefile fieldName: string, name of the item in the shapefile """ gdal.UseExceptions() #-create a new shapefile driver = ogr.GetDriverByName("ESRI Shapefile") if os.path.exists(dstShape): driver.DeleteDataSource(dstShape) destinationDataSet = driver.CreateDataSource(dstShape) destinationLayer = destinationDataSet.CreateLayer('TEMP', srs=None) newField = ogr.FieldDefn(fieldName, ogr.OFTInteger) destinationLayer.CreateField(newField) #-open the source data and polygonize into new field sourceDataSet = gdal.Open(srcMap) sourceBand = sourceDataSet.GetRasterBand(1) gdal.Polygonize(sourceBand, None, destinationLayer, 0, [], callback=None) #-Destroy the destination dataset destinationDataSet.Destroy()
def create_temp_shape(self, name, point_list): vector_file = os.path.join(self.temp_dir.name, name) shape_driver = ogr.GetDriverByName( "ESRI Shapefile") # Depreciated; replace at some point vector_data_source = shape_driver.CreateDataSource(vector_file) vector_layer = vector_data_source.CreateLayer("geometry", self.srs, geom_type=ogr.wkbPolygon) ring = ogr.Geometry(ogr.wkbLinearRing) for point in point_list: ring.AddPoint(point[0], point[1]) poly = ogr.Geometry(ogr.wkbPolygon) poly.AddGeometry(ring) vector_feature_definition = vector_layer.GetLayerDefn() vector_feature = ogr.Feature(vector_feature_definition) vector_feature.SetGeometry(poly) vector_layer.CreateFeature(vector_feature) vector_layer.CreateField(ogr.FieldDefn("class", ogr.OFTInteger)) feature = ogr.Feature(vector_layer.GetLayerDefn()) feature.SetField("class", 3) vector_data_source.FlushCache() self.vectors.append( vector_data_source ) # Check this is the right thing to be saving here self.vector_paths.append(vector_file)
def createOutputFile(self, pathname, wkt): """ create output file to store filtered footprints """ # overwrite existing file footprint = None driver = ogr.GetDriverByName('Esri Shapefile') if os.path.exists(pathname): driver.DeleteDataSource(pathname) # create shapefile ds = driver.CreateDataSource(pathname) if ds is not None: # add row number id attribute srs = osr.SpatialReference(wkt=wkt) layer = ds.CreateLayer('', srs, ogr.wkbPolygon) layer.CreateField(ogr.FieldDefn('id', ogr.OFTInteger)) # package up details into dictionary footprint = { 'ds': ds, 'layer': layer, 'srs': srs, 'defn': layer.GetLayerDefn() } return footprint
def write_polylines(poly, out_file): """Write polyline shapefile to file path. :param poly: input polyline :type poly: shapely polyline object :param out_file: file path to restore polyline :type out_file: str """ driver = ogr.GetDriverByName("Esri Shapefile") ds = driver.CreateDataSource(out_file) layer = ds.CreateLayer("", None, ogr.wkbLineString) # Add one attribute layer.CreateField(ogr.FieldDefn("id", ogr.OFTInteger)) defn = layer.GetLayerDefn() # Create a new feature (attribute and geometry) feat = ogr.Feature(defn) feat.SetField("id", 1) # Make a geometry, from Shapely object geom = ogr.CreateGeometryFromWkb(poly.wkb) feat.SetGeometry(geom) layer.CreateFeature(feat) # Save and close everything ds = layer = feat = geom = None
def _build_attribute_table(self, path, nodata_value): if not os.path.exists(path): raise IOError("File not found: {}".format(path)) shapefile = ogr.Open(path, 1) layer = shapefile.GetLayer(0) layer.CreateField(ogr.FieldDefn(self._id_attribute, ogr.OFTInteger)) next_value_id = 1 for feature in self._get_features(layer): attribute_values = tuple( attr.sub(feature[attr.name]) if attr.filter(feature[attr.name] ) else None for attr in self._attributes) value_id = nodata_value if None not in attribute_values: existing_key = [ item[0] for item in self._attribute_table.items() if item[1] == attribute_values ] if existing_key: value_id = existing_key[0] else: value_id = next_value_id self._attribute_table[value_id] = attribute_values next_value_id += 1 feature[self._id_attribute] = value_id layer.SetFeature(feature)
def setRandomDates(fc): feat_count = 0 # open vector layer drv = ogr.GetDriverByName('ESRI Shapefile') # assuming shapefile? ds = drv.Open(fc, 1) # open for editing lyr = ds.GetLayer(0) date_field = ogr.FieldDefn("DATE", ogr.OFTDate) lyr.CreateField(date_field) format = "%Y/%m/%d" beg_date = datetime.strptime("2007/01/01", format).date() end_date = datetime.strptime("2016/09/30", format).date() elapse = (end_date - beg_date).days for feat in lyr: random_day = randint(0, elapse) date = beg_date + timedelta(days=random_day) date_str = datetime.strftime(date, "%Y/%m/%d") feat.SetField("DATE", date_str) lyr.SetFeature(feat) feat_count += 1 if feat_count % 100 == 0: print(feat_count)
def polygonize_scene(f_img, f_vct): #-------------- generate original shaplefile, complex polygon and in a UTM projection f_temp = os.path.split(f_vct)[0] + '/lakes_ori.shp' ds_img = gdal.Open(f_img) band = ds_img.GetRasterBand(1) projection = ds_img.GetProjection() geo_transform = ds_img.GetGeoTransform() driver = ogr.GetDriverByName("ESRI Shapefile") if os.path.exists(f_temp): driver.DeleteDataSource(f_temp) ds_out = driver.CreateDataSource(f_temp) layer_out = ds_out.CreateLayer("polygonized", srs=None) field_new = ogr.FieldDefn('Code_uniq', ogr.OFTInteger) layer_out.CreateField(field_new) gdal.Polygonize(band, None, layer_out, 0, [], callback=None) ds_out.Destroy() del ds_img f_prj = f_temp[:-3] + 'prj' fo_prj = open(f_prj, 'w') fo_prj.write(projection) fo_prj.close() #-------------- simplify and reprojct cmd_ogr = 'ogr2ogr -overwrite -simplify 30 -where \"Code_uniq>0\" -t_srs "+proj=aea +lat_1=25.0 +lat_2=47.0 +lon_0=105.0 +x_0=0 +y_0=0 +datum=WGS84" ' + f_vct + ' ' + f_temp _rs = lib_IO.run_exe(cmd_ogr) print f_vct driver = ogr.GetDriverByName("ESRI Shapefile") driver.DeleteDataSource(f_temp)
def polygonize_raster(img_path, outShp): """ Generates a shapefile (outShp) from the input image (img_path). """ try: sourceRaster = gdal.Open(img_path) band = sourceRaster.GetRasterBand(1) driver = ogr.GetDriverByName("ESRI Shapefile") # If shapefile already exist, delete it if os.path.exists(outShp): driver.DeleteDataSource(outShp) outDatasource = driver.CreateDataSource(outShp) # get proj from raster srs = osr.SpatialReference() srs.ImportFromWkt(sourceRaster.GetProjectionRef()) # create layer with proj outLayer = outDatasource.CreateLayer(outShp, srs) # Add class column to shapefile newField = ogr.FieldDefn('DN', ogr.OFTInteger) outLayer.CreateField(newField) gdal.Polygonize(band, None, outLayer, 0, [], callback=None) outDatasource.Destroy() sourceRaster = None except Exception as e: print('gdal Polygonize Error: ' + str(e))
def load_schema(self, layer): """Create fields definitions in the layer.""" for c in self.table.columns: if c.name.lower() in ('wkt', 'wkb', 'geometry'): continue dt = c.datatype size = c.size if self.format == 'shapefile': if dt == Column.DATATYPE_TIME: dt = Column.DATATYPE_TEXT size = 8 fdfn = ogr.FieldDefn(str(c.name), ogr_type_map[dt]) if self.format == 'shapefile': if dt == Column.DATATYPE_TEXT: if not size: raise ConfigurationError( "Column {} must specify a size for shapefile output" .format(c.name)) fdfn.SetWidth(size) layer.CreateField(fdfn)
def write_text_field(inShape, fieldName, attribute): """ Write a string to a ogr vector file Parameters ---------- inShape : string input OGR vecotr file fieldName : string name of field being written attribute : string 'text to enter in each entry of column' """ vds = ogr.Open(inShape, 1) # TODO maybe open update if we want to write stats #assert(vds) vlyr = vds.GetLayer(0) vlyr.CreateField(ogr.FieldDefn(fieldName, ogr.OFTString)) feat = vlyr.GetNextFeature() features = np.arange(vlyr.GetFeatureCount()) for label in tqdm(features): feat.SetField(fieldName, attribute) vlyr.SetFeature(feat) feat = vlyr.GetNextFeature() vlyr.SyncToDisk() vds = None
def ogr_csv_26(): ds = ogr.Open('tmp/csvwrk', update=1) lyr = ds.CreateLayer('num_padding', options=['LINEFORMAT=LF']) # just in case tests are run on windows... field = ogr.FieldDefn('foo', ogr.OFTReal) field.SetWidth(50) field.SetPrecision(25) lyr.CreateField(field) feature = ogr.Feature(lyr.GetLayerDefn()) feature.SetField('foo', 10.5) feat = ogr.Feature(lyr.GetLayerDefn()) feat.SetField('foo', 10.5) lyr.CreateFeature(feat) feat = None lyr = None ds = None EXPECTED = 'foo,\n10.5000000000000000000000000\n' data = open('tmp/csvwrk/num_padding.csv', 'rb').read() if data != EXPECTED: gdaltest.post_reason("expected=%s got= %s" % (repr(EXPECTED), repr(data))) return 'fail' return 'success'
def evalDem(in_path_shp, out_path_shp, input_ref, target_ref_dem, in_path_dem): # reproject shapefile reprojectShapefile(in_path_shp, out_path_shp, input_ref, target_ref_dem) # read DEM values raster = gdal.Open(in_path_dem) raster_band = raster.GetRasterBand(1) raster_spat = raster.GetProjection() print 'raster spat is {}'.format(raster_spat) geotransform = raster.GetGeoTransform() print 'geotransform: {}'.format(geotransform) driver = ogr.GetDriverByName('ESRI Shapefile') shp = driver.Open(out_path_shp, 1) layer = shp.GetLayer(0) print 'evalDem ref is {}'.format(layer.GetSpatialRef()) dem_field_name = ogr.FieldDefn('DEM_elev', ogr.OFTReal) layer.CreateField(dem_field_name) # add values to features for feat in layer: pt = feat.geometry() x = pt.GetX() y = pt.GetY() px = int((x - geotransform[0]) / geotransform[1]) py = int((y - geotransform[3]) / geotransform[5]) val_tmp = raster_band.ReadAsArray(px, py, 1, 1) val = float(val_tmp[0][0]) feat.SetField('DEM_elev', val) layer.SetFeature(feat) del shp
def export_to_shp(self, path2shp): driver = ogr.GetDriverByName("ESRI Shapefile") data_source = driver.CreateDataSource(path2shp) srs = osr.SpatialReference() srs.ImportFromEPSG(self.epsg) lyr = data_source.CreateLayer('Layer', srs, globals()['wkt2ogr'][self.geomtype]) l = attr_len(attr_dict) for key in self.a: dtype = col_dict[key] field = ogr.FieldDefn(key, dtype) if dtype == ogr.OFTString: if width is None: width = list_max_len(attr_dict[key]) field.SetWidth(width) lyr.CreateField(field) for i in range(l): feat = ogr.Feature(lyr.GetLayerDefn()) for key in col_dict: feat.SetField(key, attr_dict[key][0, i]) if x_coord is not None and y_coord is not None: if (x_coord in attr_dict) and (y_coord in attr_dict): x = attr_dict[x_coord][0, i] y = attr_dict[y_coord][0, i] wkt = "POINT(%f %f)" % (np.single(x), np.single(y)) point = ogr.CreateGeometryFromWkt(wkt) feat.SetGeometry(point) lyr.CreateFeature(feat) feat = None data_source = None return None
def ogr_sql_22(): mem_ds = ogr.GetDriverByName("Memory").CreateDataSource("my_ds") mem_lyr = mem_ds.CreateLayer("my_layer") mem_lyr.CreateField(ogr.FieldDefn("test", ogr.OFTString)) feat = ogr.Feature(mem_lyr.GetLayerDefn()) feat.SetGeometry(ogr.CreateGeometryFromWkt("POINT(0 1)")) mem_lyr.CreateFeature(feat) sql_lyr = mem_ds.ExecuteSQL("SELECT *, fid, *, my_layer.* from my_layer") if sql_lyr.GetLayerDefn().GetFieldCount() != 4: return 'fail' if sql_lyr.GetLayerDefn().GetFieldDefn(0).GetName() != 'test': return 'fail' if sql_lyr.GetLayerDefn().GetFieldDefn(1).GetName() != 'fid': return 'fail' if sql_lyr.GetLayerDefn().GetFieldDefn(2).GetName() != 'test': return 'fail' if sql_lyr.GetLayerDefn().GetFieldDefn(3).GetName() != 'my_layer.test': return 'fail' mem_ds.ReleaseResultSet(sql_lyr) mem_ds = None return 'success'
def Add_Field(input_lyr, field_name, ogr_field_type): """ Add a field to a layer using the following ogr field types: 0 = ogr.OFTInteger 1 = ogr.OFTIntegerList 2 = ogr.OFTReal 3 = ogr.OFTRealList 4 = ogr.OFTString 5 = ogr.OFTStringList 6 = ogr.OFTWideString 7 = ogr.OFTWideStringList 8 = ogr.OFTBinary 9 = ogr.OFTDate 10 = ogr.OFTTime 11 = ogr.OFTDateTime """ # List fields fields_ls = List_Fields(input_lyr) # Check if field exist if field_name in fields_ls: raise Exception('Field: "{0}" already exists'.format(field_name)) # Create field inp_field = ogr.FieldDefn(field_name, ogr_field_type) input_lyr.CreateField(inp_field) return inp_field
def ogr_sql_25(): mem_ds = ogr.GetDriverByName("Memory").CreateDataSource("my_ds") mem_lyr = mem_ds.CreateLayer("my_layer") mem_lyr.CreateField(ogr.FieldDefn("test", ogr.OFTString)) feat = ogr.Feature(mem_lyr.GetLayerDefn()) feat.SetField("test", 0) feat.SetGeometry( ogr.CreateGeometryFromWkt("POLYGON((0 0,0 1,1 1,1 0,0 0))")) mem_lyr.CreateFeature(feat) feat = ogr.Feature(mem_lyr.GetLayerDefn()) feat.SetField("test", 1) feat.SetGeometry( ogr.CreateGeometryFromWkt("POLYGON((0 0,0 0.5,0.5 0.5,0.5 0,0 0))")) mem_lyr.CreateFeature(feat) sql_lyr = mem_ds.ExecuteSQL( "SELECT test, OGR_GEOM_AREA from my_layer WHERE OGR_GEOM_AREA > 0.9") if sql_lyr.GetFeatureCount() != 1: return 'fail' feat = sql_lyr.GetNextFeature() if feat.GetFieldAsDouble('OGR_GEOM_AREA') != 1.0: return 'fail' if feat.GetFieldAsString('test') != '0': return 'fail' mem_ds.ReleaseResultSet(sql_lyr) mem_ds = None return 'success'