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'
