def Open_array_info(filename=''):
f = gdal.Open(r"%s" %filename)
if f is None:
print '%s does not exists' %filename
else:
geo_out = f.GetGeoTransform()
proj = f.GetProjection()
size_X = f.RasterXSize
size_Y = f.RasterYSize
f = None
return(geo_out, proj, size_X, size_Y)
python类Open()的实例源码
def Open_tiff_array(filename='', band=''):
f = gdal.Open(filename)
if f is None:
print '%s does not exists' %filename
else:
if band is '':
band = 1
Data = f.GetRasterBand(band).ReadAsArray()
return(Data)
def clip_data(input_file, latlim, lonlim):
"""
Clip the data to the defined extend of the user (latlim, lonlim) or to the
extend of the DEM tile
Keyword Arguments:
input_file -- output data, output of the clipped dataset
latlim -- [ymin, ymax]
lonlim -- [xmin, xmax]
"""
try:
if input_file.split('.')[-1] == 'tif':
dest_in = gdal.Open(input_file)
else:
dest_in = input_file
except:
dest_in = input_file
# Open Array
data_in = dest_in.GetRasterBand(1).ReadAsArray()
# Define the array that must remain
Geo_in = dest_in.GetGeoTransform()
Geo_in = list(Geo_in)
Start_x = np.max([int(np.ceil(((lonlim[0]) - Geo_in[0])/ Geo_in[1])),0])
End_x = np.min([int(np.floor(((lonlim[1]) - Geo_in[0])/ Geo_in[1])),int(dest_in.RasterXSize)])
Start_y = np.max([int(np.floor((Geo_in[3] - latlim[1])/ -Geo_in[5])),0])
End_y = np.min([int(np.ceil(((latlim[0]) - Geo_in[3])/Geo_in[5])), int(dest_in.RasterYSize)])
#Create new GeoTransform
Geo_in[0] = Geo_in[0] + Start_x * Geo_in[1]
Geo_in[3] = Geo_in[3] + Start_y * Geo_in[5]
Geo_out = tuple(Geo_in)
data = np.zeros([End_y - Start_y, End_x - Start_x])
data = data_in[Start_y:End_y,Start_x:End_x]
dest_in = None
return(data, Geo_out)
def __init__(self,inShape,inField,outValidation,outTrain,number=50,percent=True):
"""
inShape : str path file (e.g. '/doc/ref.shp')
inField : string column name (e.g. 'class')
outValidation : str path of shp output file (e.g. '/tmp/valid.shp')
outTrain : str path of shp output file (e.g. '/tmp/train.shp')
"""
if percent:
number = number / 100.0
else:
number = int(number)
lyr = ogr.Open(inShape)
lyr1 = lyr.GetLayer()
FIDs= sp.zeros(lyr1.GetFeatureCount(),dtype=int)
Features = []
#unselFeat = []
#current = 0
for i,j in enumerate(lyr1):
#print j.GetField(inField)
FIDs[i] = j.GetField(inField)
Features.append(j)
#current += 1
srs = lyr1.GetSpatialRef()
lyr1.ResetReading()
##
if percent:
validation,train = train_test_split(Features,test_size=number,train_size=1-number,stratify=FIDs)
else:
validation,train = train_test_split(Features,test_size=number,stratify=FIDs)
self.saveToShape(validation,srs,outValidation)
self.saveToShape(train,srs,outTrain)
def saveConfusion(self):
"""
Open window and save confusion shown in qtableview
"""
fileName = QFileDialog.getSaveFileName(self.dockwidget, "Select output file",self.lastSaveDir,"CSV (*.csv)")
self.rememberLastSaveDir(fileName)
fileName,fileExtension=os.path.splitext(fileName)
if fileExtension != '.csv':
fileName=fileName+'.csv'
# save to CSV
try :
sp.savetxt(fileName,self.lastConfusionMatrix ,delimiter=',',fmt='%1.4d')
except :
QtGui.QMessageBox.warning(self, 'Missing confusion matrix ? ', 'Cannot save confusion matrix. Are you sure to have generated it before ?', QtGui.QMessageBox.Ok)
def open_vector(filename, layer=''):
""" Fetch wfs features within bounding box """
logger.info('Opening %s as vector file' % filename, action='Open file', actee=filename, actor=__name__)
ds = ogr.Open(filename)
if layer == '':
layer = ds.GetLayer(0)
else:
layer = ds.GetLayer(layer)
return (ds, layer)
def importBygg(to_cur, filename):
print("Importing:", filename)
dataSource = ogr.Open(filename)
dataLayer = dataSource.GetLayer(0)
print("dataLayer")
print(dataLayer)
#Genererer id'er fortloopende
for id, feature in enumerate(dataLayer):
geom = feature.GetGeometryRef()
if not geom:
continue
geom.FlattenTo2D()
print("Feature")
print(feature)
for i in range(1, feature.GetFieldCount()):
field = feature.GetDefnRef().GetFieldDefn(i).GetName()
if( i == 4):
continue
#print(field.encode('utf-8'))
byggtyp = feature.GetField("BYGGTYP_NB")
#poly_id = feature.GetField("LOKALID ")
objtype = feature.GetField("OBJTYPE")
to_tuple = (id, objtype, byggtyp, 'SRID=25832;' + geom.ExportToWkt())
to_cur.execute("""INSERT into ar_bygg (id, objtype, byggtyp, geom)
SELECT %s, %s, %s, ST_GeometryFromText(%s);""",
to_tuple)
to_conn.commit()
dataSource.Destroy()
# to_conn = psycopg2.connect("host=localhost port=5433 dbname=ar-bygg-ostfold user=postgres password=24Pils")
def pixelToGeoCoord(xPix, yPix, inputRaster, sourceSR='', geomTransform='', targetSR=''):
# If you want to garuntee lon lat output, specify TargetSR otherwise, geocoords will be in image geo reference
# targetSR = osr.SpatialReference()
# targetSR.ImportFromEPSG(4326)
# Transform can be performed at the polygon level instead of pixel level
if targetSR =='':
performReprojection=False
targetSR = osr.SpatialReference()
targetSR.ImportFromEPSG(4326)
else:
performReprojection=True
if geomTransform=='':
srcRaster = gdal.Open(inputRaster)
geomTransform = srcRaster.GetGeoTransform()
source_sr = osr.SpatialReference()
source_sr.ImportFromWkt(srcRaster.GetProjectionRef())
geom = ogr.Geometry(ogr.wkbPoint)
xOrigin = geomTransform[0]
yOrigin = geomTransform[3]
pixelWidth = geomTransform[1]
pixelHeight = geomTransform[5]
xCoord = (xPix * pixelWidth) + xOrigin
yCoord = (yPix * pixelHeight) + yOrigin
geom.AddPoint(xCoord, yCoord)
if performReprojection:
if sourceSR=='':
srcRaster = gdal.Open(inputRaster)
sourceSR = osr.SpatialReference()
sourceSR.ImportFromWkt(srcRaster.GetProjectionRef())
coord_trans = osr.CoordinateTransformation(sourceSR, targetSR)
geom.Transform(coord_trans)
return (geom.GetX(), geom.GetY())
def convertLabelStringToPoly(shapeFileSrc, outGeoJSon, labelType='Airplane'):
shapeSrc = ogr.Open(shapeFileSrc)
source_layer = shapeSrc.GetLayer()
source_srs = source_layer.GetSpatialRef()
# Create the output Layer
outDriver = ogr.GetDriverByName("geojson")
if os.path.exists(outGeoJSon):
outDriver.DeleteDataSource(outGeoJSon)
outDataSource = outDriver.CreateDataSource(outGeoJSon)
outLayer = outDataSource.CreateLayer("groundTruth", source_srs, geom_type=ogr.wkbPolygon)
# Add input Layer Fields to the output Layer
inLayerDefn = source_layer.GetLayerDefn()
for i in range(0, inLayerDefn.GetFieldCount()):
fieldDefn = inLayerDefn.GetFieldDefn(i)
outLayer.CreateField(fieldDefn)
outLayer.CreateField(ogr.FieldDefn("Length_m", ogr.OFTReal))
outLayer.CreateField(ogr.FieldDefn("Width_m", ogr.OFTReal))
outLayer.CreateField(ogr.FieldDefn("Aspect(L/W)", ogr.OFTReal))
outLayer.CreateField(ogr.FieldDefn("compassDeg", ogr.OFTReal))
outLayerDefn = outLayer.GetLayerDefn()
for inFeature in source_layer:
outFeature = ogr.Feature(outLayerDefn)
for i in range(0, inLayerDefn.GetFieldCount()):
outFeature.SetField(inLayerDefn.GetFieldDefn(i).GetNameRef(), inFeature.GetField(i))
geom = inFeature.GetGeometryRef()
if labelType == 'Airplane':
poly, Length, Width, Aspect, Direction = evaluateLineStringPlane(geom, label='Airplane')
elif labelType == 'Boat':
poly, Length, Width, Aspect, Direction = evaluateLineStringBoat(geom, label='Boat')
outFeature.SetGeometry(poly)
outFeature.SetField("Length_m", Length)
outFeature.SetField("Width_m", Width)
outFeature.SetField("Aspect(L/W)", Aspect)
outFeature.SetField("compassDeg", Direction)
outLayer.CreateFeature(outFeature)
def geoJsonToSBD(annotationName_cls, annotationName_inst, geoJson, rasterSource):
#Print raster file name
my_raster_source = rasterSource
print("Raster directory : ",my_raster_source)
srcRaster = gdal.Open(my_raster_source)
my_vector_source = geoJson
print("Vector directory : ",my_vector_source)
#Call main functions to create label datafor cls
my_cls_segmentation = createClassSegmentation(my_raster_source, my_vector_source, npDistFileName='', units='pixels')
my_cls_boundaries = createClassBoundaries(my_raster_source, my_vector_source, npDistFileName='', units='pixels')
my_cls_categories = createClassCategoriesPresent(my_vector_source)
#Call main functions to create label datafor inst
my_inst_segmentation = createInstanceSegmentation(my_raster_source, my_vector_source)
my_inst_boundaries = createInstanceBoundaries(my_raster_source, my_vector_source)
my_inst_categories = createInstanceCategories(my_vector_source)
#Wraps for cls struct
cls_boundaries_wrap = np.array([my_cls_boundaries])
cls_categories_wrap = my_cls_categories
#Wraps for inst struct
inst_boundaries_wrap = np.array([my_inst_boundaries])
inst_categories_wrap = my_inst_categories
#Create a class struct
GTcls = {'Segmentation': my_cls_segmentation , 'Boundaries': cls_boundaries_wrap, 'CategoriesPresent': cls_categories_wrap}
#Create the instance struct
GTinst = {'Segmentation': my_inst_segmentation , 'Boundaries': inst_boundaries_wrap, 'Categories': inst_categories_wrap}
#Save the files
scipy.io.savemat(annotationName_cls,{'GTcls': GTcls})
scipy.io.savemat(annotationName_inst,{'GTinst': GTinst})
print("Done with "+str())
entry = {'rasterFileName': my_raster_source,
'geoJsonFileName': geoJson,
'annotationName' : annotationName_cls,
'annotationName_cls': annotationName_cls,
'annotationName_inst':annotationName_inst,
'width': srcRaster.RasterXSize,
'height': srcRaster.RasterYSize,
'depth' : srcRaster.RasterCount,
'basename': os.path.splitext(os.path.basename(my_raster_source))[0]
}
return entry
def __init__(self, fname):
ds = ogr.Open(fname)
assert ds is not None, "Couldn't open %s" % fname
layer = ds.GetLayer()
assert layer is not None
WGS84_SR = osr.SpatialReference()
WGS84_SR.ImportFromEPSG(4326)
shape_sr = osr.SpatialReference()
shape_sr.ImportFromWkt(layer.GetSpatialRef().ExportToWkt())
transform = osr.CoordinateTransformation(shape_sr, WGS84_SR)
# http://geoinformaticstutorial.blogspot.ch/2012/10/accessing-vertices-from-polygon-with.html
polygons = {}
for feature in layer:
attr = feature.items()
newattr = {}
# some attributes contains unicode character. ASCIIfy everything
# TODO: A bit brutal, but easy...
for k, v in attr.items():
newk = k.decode('ascii', errors='ignore')
newattr[newk] = v
attr = newattr
geometry = feature.GetGeometryRef()
assert geometry.GetGeometryName() == 'POLYGON'
# A ring is a polygon in shapefiles
ring = geometry.GetGeometryRef(0)
assert ring.GetGeometryName() == 'LINEARRING'
# The ring duplicates the last point, so for the polygon to be
# closed, last point should equal first point
npoints = ring.GetPointCount()
points = [ring.GetPoint(i) for i in xrange(npoints)]
points = [transform.TransformPoint(*p) for p in points]
# third column is elevation - discard
points = np.array(points)[:, :2]
# swap (lng, lat) to (lat, lng)
points = points[:, ::-1]
assert np.allclose(points[-1], points[0])
name = attr['name']
polygons[name] = points
self.polygons = polygons
def load_polygons_from_shapefile(filename, target_sr):
"""
Loads the given shapefiles, reprojects the polygons it contains in the
given target spatialreference.
Returns:
polygons: A list of polygons (list of points)
attributes: A list of attributes (dict of strings)
"""
shape = ogr.Open(filename)
assert shape, "Couldn't open %s" % filename
assert shape.GetLayerCount() == 1
layer = shape.GetLayer()
nfeatures = layer.GetFeatureCount()
shape_sr = osr.SpatialReference()
shape_sr.ImportFromWkt(layer.GetSpatialRef().ExportToWkt())
# Transform from shape to image coordinates
transform = osr.CoordinateTransformation(shape_sr, target_sr)
# http://geoinformaticstutorial.blogspot.ch/2012/10/accessing-vertices-from-polygon-with.html
polygons = []
attributes = []
for i in xrange(nfeatures):
feature = layer.GetFeature(i)
attr = feature.items()
newattr = {}
# some attributes contains unicode character. ASCIIfy everything
# TODO: A bit brutal, but easy...
for k, v in attr.items():
newk = k.decode('ascii', errors='ignore')
newattr[newk] = v
attr = newattr
geometry = feature.GetGeometryRef()
assert geometry.GetGeometryName() == 'POLYGON'
# A ring is a polygon in shapefiles
ring = geometry.GetGeometryRef(0)
assert ring.GetGeometryName() == 'LINEARRING'
# The ring duplicates the last point, so for the polygon to be closed,
# last point should equal first point
npoints = ring.GetPointCount()
points = [ring.GetPoint(i) for i in xrange(npoints)]
points = [transform.TransformPoint(*p) for p in points]
points = np.array(points)[:, :2] # third column is elevation - discard
# swap (lng, lat) to (lat, lng)
points = points[:, ::-1]
assert np.allclose(points[-1], points[0])
polygons.append(points)
attributes.append(attr)
return polygons, attributes
def rasterize_shapefile_like(shpfile, model_raster_fname, dtype, options,
nodata_val=0,):
"""
Given a shapefile, rasterizes it so it has
the exact same extent as the given model_raster
`dtype` is a gdal type like gdal.GDT_Byte
`options` should be a list that will be passed to GDALRasterizeLayers
papszOptions, like ["ATTRIBUTE=vegetation","ALL_TOUCHED=TRUE"]
"""
model_dataset = gdal.Open(model_raster_fname)
shape_dataset = ogr.Open(shpfile)
shape_layer = shape_dataset.GetLayer()
mem_drv = gdal.GetDriverByName('MEM')
mem_raster = mem_drv.Create(
'',
model_dataset.RasterXSize,
model_dataset.RasterYSize,
1,
dtype
)
mem_raster.SetProjection(model_dataset.GetProjection())
mem_raster.SetGeoTransform(model_dataset.GetGeoTransform())
mem_band = mem_raster.GetRasterBand(1)
mem_band.Fill(nodata_val)
mem_band.SetNoDataValue(nodata_val)
# http://gdal.org/gdal__alg_8h.html#adfe5e5d287d6c184aab03acbfa567cb1
# http://gis.stackexchange.com/questions/31568/gdal-rasterizelayer-doesnt-burn-all-polygons-to-raster
err = gdal.RasterizeLayer(
mem_raster,
[1],
shape_layer,
None,
None,
[1],
options
)
assert err == gdal.CE_None
return mem_raster.ReadAsArray()
def makeDensityRaster(speciesOcc, inVector, pixelSize, outRas, noData):
srcVector = ogr.Open(inVector)
srcLayer = srcVector.GetLayer()
srs = srcLayer.GetSpatialRef()
# if the layer is not wgs84
if srs.GetAttrValue("AUTHORITY", 1) != '4326':
print('Layer projection should be WGS84!')
return
xMin, xMax, yMin, yMax = srcLayer.GetExtent()
# Create the destination data source
xRes = int((xMax - xMin) / pixelSize)
yRes = int((yMax - yMin) / pixelSize)
targetRas = gdal.GetDriverByName('GTiff').Create(outRas, xRes, yRes, 1, 6) # 6 == float
targetRas.SetGeoTransform((xMin, pixelSize, 0, yMax, 0, -pixelSize))
band = targetRas.GetRasterBand(1)
band.SetNoDataValue(noData)
# Rasterize clips the raster band
gdal.RasterizeLayer(targetRas, [1], srcLayer, None, None, [0], ['ALL_TOUCHED=TRUE'])
#os.remove(outRas)
g = band.ReadAsArray()
for point in speciesOcc.iterrows():
xi = int((point[1]['x'] - xMin) / pixelSize)
yi = int((point[1]['y'] - yMax) / -pixelSize)
try:
if g[yi,xi] != noData:
g[yi,xi] += 1
else:
print('point ({}, {}) out of bounds'.format(point[1]['x'], point[1]['y']))
except:
print('point ({}, {}) out of bounds'.format(point[1]['x'], point[1]['y']))
pass
band.WriteArray(g)
targetRasSRS = osr.SpatialReference()
targetRasSRS.ImportFromWkt(srs.ExportToWkt())
targetRas.SetProjection(targetRasSRS.ExportToWkt())
band.FlushCache()
def getValuesAtPoint(indir, rasterfileList, pos, lon, lat, sp):
#gt(2) and gt(4) coefficients are zero, and the gt(1) is pixel width, and gt(5) is pixel height.
#The (gt(0),gt(3)) position is the top left corner of the top left pixel of the raster.
for i, rs in enumerate(rasterfileList):
print('processing {}'.format(rs))
presValues = []
gdata = gdal.Open('{}/{}.tif'.format(indir,rs))
gt = gdata.GetGeoTransform()
band = gdata.GetRasterBand(1)
nodata = band.GetNoDataValue()
x0, y0 , w , h = gt[0], gt[3], abs(gt[1]), abs(gt[5])
xmin, xmax, ymin, ymax = min(pos[lon]), max(pos[lon]), min(pos[lat]), max(pos[lat])
# Specify offset and rows and columns to read
xoff = int((xmin - x0)/w)
yoff = int((y0 - ymax)/h)
xcount = int(math.ceil((xmax - xmin)/w)+1)
ycount = int(math.ceil((ymax - ymin)/h)+1)
data = band.ReadAsArray(xoff, yoff, xcount, ycount).astype(numpy.float)
#free memory
del gdata
if i == 0:
#iterate through the points
for p in pos.iterrows():
x = int((p[1][lon] - x0)/w) - xoff
Xc = x0 + int((p[1][lon] - x0)/w)*w + w/2 #the cell center x
y = int((y0 - p[1][lat])/h) - yoff
Yc = y0 - int((y0 - p[1][lat])/h)*h - h/2 #the cell center y
try:
if data[y,x] != nodata:
value = data[y,x]
else:
value = numpy.nan
presVAL = [p[1][sp],p[1][lon],p[1][lat], '{:.6f}'.format(Xc), '{:.6f}'.format(Yc), value]
presValues.append(presVAL)
except:
pass
df = pandas.DataFrame(presValues, columns=['sp', 'x', 'y', 'Xc', 'Yc', rs])
else:
#iterate through the points
for p in pos.iterrows():
x = int((p[1][lon] - x0)/w) - xoff
y = int((y0 - p[1][lat])/h) - yoff
try:
if data[y,x] != nodata:
presValues.append(data[y,x])
else:
presValues.append(numpy.nan)
except:
pass
df[rs] = pandas.Series(presValues)
del data, band
print('extracted values written in dataframe')
return df
#### function to get all pixel center coordinates and corresponding values from rasters
def getRasterValues(indir, rasterfileList, skipNoData = True):
for i, rs in enumerate(rasterfileList):
if i == 0:
vList = []
gdata = gdal.Open('{}/{}.tif'.format(indir,rs))
gt = gdata.GetGeoTransform()
band = gdata.GetRasterBand(1)
nodata = band.GetNoDataValue()
data = band.ReadAsArray().astype(numpy.float)
#free memory
del gdata
x0, y0 , w , h = gt[0], gt[3], gt[1], gt[5]
for r, row in enumerate(data):
x = 0
for c, column in enumerate(row):
if skipNoData == True:
if column == nodata:
pass
else:
x = x0 + c*w + w/2
y = y0 + r*h + h/2
vList.append(['{:.6f}'.format(x),'{:.6f}'.format(y),column])
elif skipNoData == False:
x = x0 + c*w + w/2
y = y0 + r*h + h/2
vList.append(['{:.6f}'.format(x),'{:.6f}'.format(y),column])
df = pandas.DataFrame(vList, columns=['Xc', 'Yc', rs])
else:
gdata = gdal.Open('{}/{}.tif'.format(indir,rs))
gt = gdata.GetGeoTransform()
band = gdata.GetRasterBand(1)
nodata = band.GetNoDataValue()
data = band.ReadAsArray().astype(numpy.float)
#free memory
del gdata
if skipNoData == True:
vList = [c for r in data for c in r if c != nodata]
elif skipNoData == False:
vList = [c for r in data for c in r]
df[rs] = pandas.Series(vList)
del data, band
return(df)
# geo raster to numpy array
def filterByCoverage(vectorFile, rasterFile, covPerc):
srcVector = ogr.Open(vectorFile)
srcLayer = srcVector.GetLayer()
# merge all features in one geometry (multi polygone)
multi = ogr.Geometry(ogr.wkbMultiPolygon)
for feature in srcLayer:
geom = feature.GetGeometryRef()
multi.AddGeometry(geom)
#attributes of raster file
rasList = raster2array(rasterFile)
xsize = rasList[4][0]
ysize = abs(rasList[4][1])
pixel_area = xsize*ysize
rows = rasList[0].shape[0]
cols = rasList[0].shape[1]
x1 = rasList[2][0]
y1 = rasList[2][3]
#iterate over raster cells
for i in range(rows):
for j in range(cols):
ring = ogr.Geometry(ogr.wkbLinearRing)
ring.AddPoint(x1, y1)
ring.AddPoint(x1 + xsize, y1)
ring.AddPoint(x1 + xsize, y1 - ysize)
ring.AddPoint(x1, y1 - ysize)
ring.AddPoint(x1, y1)
poly = ogr.Geometry(ogr.wkbPolygon)
poly.AddGeometry(ring)
intersect = multi.Intersection(poly)
if intersect.ExportToWkt() != 'GEOMETRYCOLLECTION EMPTY':
perc = (intersect.GetArea()/pixel_area)*100
if perc > covPerc:
rasList[0][i][j] = numpy.nan
x1 += xsize
x1 = rasList[2][0]
y1 -= ysize
return(rasList[0]) #return the filtered array
# numpy array to geo raster
def Usage():
print( "Usage: ogr2ogr [--help-general] [-skipfailures] [-append] [-update] [-gt n]\n" + \
" [-select field_list] [-where restricted_where] \n" + \
" [-progress] [-sql <sql statement>] \n" + \
" [-spat xmin ymin xmax ymax] [-preserve_fid] [-fid FID]\n" + \
" [-a_srs srs_def] [-t_srs srs_def] [-s_srs srs_def]\n" + \
" [-f format_name] [-overwrite] [[-dsco NAME=VALUE] ...]\n" + \
" [-simplify tolerance]\n" + \
#// " [-segmentize max_dist] [-fieldTypeToString All|(type1[,type2]*)]\n" + \
" [-fieldTypeToString All|(type1[,type2]*)] [-explodecollections] \n" + \
" dst_datasource_name src_datasource_name\n" + \
" [-lco NAME=VALUE] [-nln name] [-nlt type] [-dim 2|3] [layer [layer ...]]\n" + \
"\n" + \
" -f format_name: output file format name, possible values are:")
for iDriver in range(ogr.GetDriverCount()):
poDriver = ogr.GetDriver(iDriver)
if poDriver.TestCapability( ogr.ODrCCreateDataSource ):
print( " -f \"" + poDriver.GetName() + "\"" )
print( " -append: Append to existing layer instead of creating new if it exists\n" + \
" -overwrite: delete the output layer and recreate it empty\n" + \
" -update: Open existing output datasource in update mode\n" + \
" -progress: Display progress on terminal. Only works if input layers have the \"fast feature count\" capability\n" + \
" -select field_list: Comma-delimited list of fields from input layer to\n" + \
" copy to the new layer (defaults to all)\n" + \
" -where restricted_where: Attribute query (like SQL WHERE)\n" + \
" -sql statement: Execute given SQL statement and save result.\n" + \
" -skipfailures: skip features or layers that fail to convert\n" + \
" -gt n: group n features per transaction (default 200)\n" + \
" -spat xmin ymin xmax ymax: spatial query extents\n" + \
" -simplify tolerance: distance tolerance for simplification.\n" + \
#//" -segmentize max_dist: maximum distance between 2 nodes.\n" + \
#//" Used to create intermediate points\n" + \
" -dsco NAME=VALUE: Dataset creation option (format specific)\n" + \
" -lco NAME=VALUE: Layer creation option (format specific)\n" + \
" -nln name: Assign an alternate name to the new layer\n" + \
" -nlt type: Force a geometry type for new layer. One of NONE, GEOMETRY,\n" + \
" POINT, LINESTRING, POLYGON, GEOMETRYCOLLECTION, MULTIPOINT,\n" + \
" MULTIPOLYGON, or MULTILINESTRING. Add \"25D\" for 3D layers.\n" + \
" Default is type of source layer.\n" + \
" -dim dimension: Force the coordinate dimension to the specified value.\n" + \
" -fieldTypeToString type1,...: Converts fields of specified types to\n" + \
" fields of type string in the new layer. Valid types are : \n" + \
" Integer, Real, String, Date, Time, DateTime, Binary, IntegerList, RealList,\n" + \
" StringList. Special value All can be used to convert all fields to strings.")
print(" -a_srs srs_def: Assign an output SRS\n"
" -t_srs srs_def: Reproject/transform to this SRS on output\n"
" -s_srs srs_def: Override source SRS\n"
"\n"
" Srs_def can be a full WKT definition (hard to escape properly),\n"
" or a well known definition (i.e. EPSG:4326) or a file with a WKT\n"
" definition." )
return False
