def long2ShortName(self, longName):
if longName == '':
return ''
if longName in self.dict_long2shortName:
return self.dict_long2shortName[longName]
# first get the GDAL driver manager
if gdal.GetDriverCount() == 0:
gdal.AllRegister()
shortName = ''
# for each loaded GDAL driver
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
if driver == None:
continue
# if this is the driver we searched for then return its short name
if FileFilter.getFilterName(driver.LongName) == longName:
shortName = FileFilter.getFilterName(driver.ShortName)
self.dict_long2shortName[longName] = shortName
break
return shortName
def misc_5():
gdal.PushErrorHandler('CPLQuietErrorHandler')
try:
shutil.rmtree('tmp/tmp')
except:
pass
try:
os.mkdir('tmp/tmp')
except:
try:
os.stat(dirname)
# Hum the directory already exists... Not expected, but let's try to go on
except:
gdaltest.post_reason('Cannot create tmp/tmp')
return 'fail'
# This is to speed-up the runtime of tests on EXT4 filesystems
# Do not use this for production environment if you care about data safety
# w.r.t system/OS crashes, unless you know what you are doing.
gdal.SetConfigOption('OGR_SQLITE_SYNCHRONOUS', 'OFF')
ret = 'success'
# Test Create() with various band numbers, including 0
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
md = drv.GetMetadata()
if 'DCAP_CREATE' in md:
datatype = gdal.GDT_Byte
for nBands in range(6):
if misc_5_internal(drv, datatype, nBands) < 0:
ret = 'fail'
for nBands in [1,3]:
for datatype in (gdal.GDT_UInt16,
gdal.GDT_Int16,
gdal.GDT_UInt32,
gdal.GDT_Int32,
gdal.GDT_Float32,
gdal.GDT_Float64,
gdal.GDT_CInt16,
gdal.GDT_CInt32,
gdal.GDT_CFloat32,
gdal.GDT_CFloat64):
if misc_5_internal(drv, datatype, nBands) < 0:
ret = 'fail'
gdal.PopErrorHandler()
return ret
def gdal_driver_list():
"""
Get _gdal drivers dictionary
OUTPUT
drivers [dict] drivers and file extension
"""
drivers = {}
for i in range(_gdal.GetDriverCount()):
drv = _gdal.GetDriver(i)
if drv.GetMetadataItem(_gdal.DCAP_RASTER):
drivers[drv.ShortName] = drv.GetMetadataItem(_gdal.DMD_EXTENSIONS)
return(drivers) # gdal_driver_list()
def getDriverType(filename):
'''Get the writer or reader type basing on
extension of filename or if it can be opne
by gdal.'''
if not filename:
return None
if os.path.exists(filename):
dataset = gdal.Open(filename, gdal.GA_ReadOnly)
if dataset is not None:
# clsoe dataset
dataset = None
return 'gdal'
# try to get driver by extension
extension = os.path.splitext(filename)[1]
if not extension:
raise QgsProcessingException(
"Cannot state file type by extension for {}".format(filename))
extension = extension[1:]
# check if managed by gdal
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
if drv.GetMetadataItem(gdal.DCAP_RASTER):
extensions = drv.GetMetadataItem(gdal.DMD_EXTENSIONS)
if extensions:
extensions = extensions.split()
extensions = [
extension.lower() for extension in extensions
]
if extension.lower() in extensions:
return 'gdal'
if extension in ['las', 'laz']:
return 'las'
# I can't determine the driver to use
# then use the default "las"
return 'las'
def formats():
"""
Create a data frame with available GDAL formats
"""
# Lists to create data frame
ID = []
ShortName = []
LongName = []
Extension = []
driver_dict = OrderedDict({})
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
driver_metadata = driver.GetMetadata()
if 'DMD_EXTENSION' in driver_metadata:
ID.append(i)
ShortName.append(driver.ShortName)
LongName.append(driver.LongName)
Extension.append(driver_metadata['DMD_EXTENSION'])
elif 'DMD_EXTENSIONS' in driver_metadata:
ID.append(i)
ShortName.append(driver.ShortName)
LongName.append(driver.LongName)
Extension.append(driver_metadata['DMD_EXTENSIONS'])
else:
continue
# Update dictionary
driver_dict.update({'ID' : ID,
'short_name' : ShortName,
'long_name' : LongName,
'extension' : Extension})
df = pd.DataFrame(data = driver_dict)
return df
def getSupportedRasters():
'''this has been adapted from GdalTools plugin'''
if GdalUtils.supportedRasters != None:
return GdalUtils.supportedRasters
if gdal.GetDriverCount() == 0:
gdal.AllRegister()
GdalUtils.supportedRasters = {}
GdalUtils.supportedRasters["GTiff"] = ["tif"]
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
if driver == None:
continue
shortName = str(
QString(driver.ShortName).remove(QRegExp('\(.*$')).trimmed())
metadata = driver.GetMetadata()
if metadata.has_key(gdal.DMD_EXTENSION):
extensions = metadata[gdal.DMD_EXTENSION].split("/")
if extensions:
GdalUtils.supportedRasters[shortName] = extensions
return GdalUtils.supportedRasters
def misc_12():
if int(gdal.VersionInfo('VERSION_NUM')) < 1900:
gdaltest.post_reason('would crash')
return 'skip'
import test_cli_utilities
gdal_translate_path = test_cli_utilities.get_gdal_translate_path()
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
#if drv.ShortName == 'ECW' or drv.ShortName == 'JP2ECW':
# continue
md = drv.GetMetadata()
if 'DCAP_CREATECOPY' in md or 'DCAP_CREATE' in md:
ext = ''
if drv.ShortName == 'GTX':
ext = '.gtx'
elif drv.ShortName == 'RST':
ext = '.rst'
elif drv.ShortName == 'SAGA':
ext = '.sdat'
elif drv.ShortName == 'ECW':
ext = '.ecw'
elif drv.ShortName == 'KMLSUPEROVERLAY':
ext = '.kmz'
elif drv.ShortName == 'ADRG':
ext = '/ABCDEF01.GEN'
elif drv.ShortName == 'SRTMHGT':
ext = '/N48E002.HGT'
nbands = 1
if drv.ShortName == 'WEBP' or drv.ShortName == 'ADRG':
nbands = 3
datatype = gdal.GDT_Byte
if drv.ShortName == 'BT' or drv.ShortName == 'BLX':
datatype = gdal.GDT_Int16
elif drv.ShortName == 'GTX' or drv.ShortName == 'NTv2' or drv.ShortName == 'Leveller':
datatype = gdal.GDT_Float32
size = 1201
if drv.ShortName == 'BLX':
size = 128
src_ds = gdal.GetDriverByName('GTiff').Create(
'/vsimem/misc_12_src.tif', size, size, nbands, datatype)
set_gt = (2, 1.0 / size, 0, 49, 0, -1.0 / size)
src_ds.SetGeoTransform(set_gt)
src_ds.SetProjection(
'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["degree",0.01745329251994328]]'
)
# Test to detect crashes
gdal.PushErrorHandler('CPLQuietErrorHandler')
ds = drv.CreateCopy('/nonexistingpath/nonexistingfile' + ext,
src_ds)
gdal.PopErrorHandler()
ds = None
if gdal_translate_path is not None:
# Test to detect memleaks
ds = gdal.GetDriverByName('VRT').CreateCopy(
'tmp/misc_12.vrt', src_ds)
(out, err) = gdaltest.runexternal_out_and_err(
gdal_translate_path + ' -of ' + drv.ShortName +
' tmp/misc_12.vrt /nonexistingpath/nonexistingfile' + ext,
check_memleak=False)
ds = None
gdal.Unlink('tmp/misc_12.vrt')
# If DEBUG_VSIMALLOC_STATS is defined, this is an easy way
# to catch some memory leaks
if out.find('VSIMalloc + VSICalloc - VSIFree') != -1 and \
out.find('VSIMalloc + VSICalloc - VSIFree : 0') == -1:
if drv.ShortName == 'Rasterlite' and out.find(
'VSIMalloc + VSICalloc - VSIFree : 1') != -1:
pass
else:
print('memleak detected for driver %s' % drv.ShortName)
src_ds = None
gdal.Unlink('/vsimem/misc_12_src.tif')
return 'success'
def misc_6_internal(datatype, nBands):
if nBands == 0:
ds = gdal.GetDriverByName('ILWIS').Create('tmp/tmp.mpl', 100, 100,
nBands, datatype)
else:
ds = gdal.GetDriverByName('GTiff').Create('tmp/tmp.tif', 10, 10,
nBands, datatype)
ds.GetRasterBand(1).Fill(255)
ds.SetGeoTransform([2, 1.0 / 10, 0, 49, 0, -1.0 / 10])
ds.SetProjection(
'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["degree",0.01745329251994328]]'
)
ds = None
ds = gdal.Open('tmp/tmp.tif')
if ds is not None:
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
md = drv.GetMetadata()
if 'DCAP_CREATECOPY' in md or 'DCAP_CREATE' in md:
print('drv = %s, nBands = %d, datatype = %s' %
(drv.ShortName, nBands, gdal.GetDataTypeName(datatype)))
skip = False
# FIXME: A few cases that crashes and should be investigated
if drv.ShortName == 'JPEG2000':
if (nBands == 2 or nBands >= 5) or \
not (datatype == gdal.GDT_Byte or datatype == gdal.GDT_Int16 or datatype == gdal.GDT_UInt16):
skip = True
if drv.ShortName == 'JP2ECW' and datatype == gdal.GDT_Float64:
skip = True
if skip is False:
dirname = 'tmp/tmp/tmp_%s_%d_%s' % (
drv.ShortName, nBands, gdal.GetDataTypeName(datatype))
try:
os.mkdir(dirname)
except:
try:
os.stat(dirname)
# Hum the directory already exists... Not expected, but let's try to go on
except:
reason = 'Cannot create %s before drv = %s, nBands = %d, datatype = %s' % (
dirname, drv.ShortName, nBands,
gdal.GetDataTypeName(datatype))
gdaltest.post_reason(reason)
return 'fail'
filename = '%s/foo' % dirname
if drv.ShortName == 'GTX':
filename = filename + '.gtx'
elif drv.ShortName == 'RST':
filename = filename + '.rst'
elif drv.ShortName == 'SAGA':
filename = filename + '.sdat'
elif drv.ShortName == 'ADRG':
filename = '%s/ABCDEF01.GEN' % dirname
elif drv.ShortName == 'SRTMHGT':
filename = '%s/N48E002.HGT' % dirname
elif drv.ShortName == 'ECW':
filename = filename + '.ecw'
elif drv.ShortName == 'KMLSUPEROVERLAY':
filename = filename + '.kmz'
dst_ds = drv.CreateCopy(filename, ds)
has_succeeded = dst_ds is not None
dst_ds = None
try:
shutil.rmtree(dirname)
except:
reason = 'Cannot remove %s after drv = %s, nBands = %d, datatype = %s' % (
dirname, drv.ShortName, nBands,
gdal.GetDataTypeName(datatype))
gdaltest.post_reason(reason)
return 'fail'
if has_succeeded and not drv.ShortName in [
'ECW', 'JP2ECW', 'VRT', 'XPM', 'JPEG2000', 'FIT',
'RST', 'INGR', 'USGSDEM', 'KMLSUPEROVERLAY', 'GMT'
]:
dst_ds = drv.CreateCopy(
filename, ds, callback=misc_6_interrupt_callback)
if dst_ds is not None:
gdaltest.post_reason(
'interruption did not work with drv = %s, nBands = %d, datatype = %s'
% (drv.ShortName, nBands,
gdal.GetDataTypeName(datatype)))
dst_ds = None
try:
shutil.rmtree(dirname)
except:
pass
return 'fail'
dst_ds = None
try:
shutil.rmtree(dirname)
except:
pass
try:
os.mkdir(dirname)
except:
reason = 'Cannot create %s before drv = %s, nBands = %d, datatype = %s' % (
dirname, drv.ShortName, nBands,
gdal.GetDataTypeName(datatype))
gdaltest.post_reason(reason)
return 'fail'
ds = None
if nBands == 0:
gdal.GetDriverByName('ILWIS').Delete('tmp/tmp.mpl')
else:
gdal.GetDriverByName('GTiff').Delete('tmp/tmp.tif')
return 'success'
"IDB":"@DB",
}
VDSFormatMap = {}
vdcount = ogr.GetDriverCount()
for i in range(vdcount):
name = ogr.GetDriver(i).GetName()
if name in vextmap:
ext = vextmap[name]
else:
ext = '*'
VDSFormatMap[name] = ext
RDSFormatMap = {}
try:
dlist = [gdal.GetDriver(i) for i in range(gdal.GetDriverCount())]
except:
dlist = gdal.GetDriverList()
for driver in dlist:
name = driver.ShortName
meta = driver.GetMetadata()
if "DMD_EXTENSION" in meta:
ext = meta["DMD_EXTENSION"]
else:
ext = "*"
RDSFormatMap[name] = ext
#DSFormatMap = {
# "GeoTIFF": "tif/tiff",
# "Shape file": "shp",
# "Mapinfo file": "tab/mif",
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###############################################################################
import gdal
###############################################################################
from osgeo import gdal
###############################################################################
import gdal
###############################################################################
try:
import gdal
except:
from osgeo import gdal
###############################################################################
from osgeo.gdalconst import *
###############################################################################
gdal.AllRegister()
###############################################################################
driver = gdal.GetDriverByName('HFA')
driver.Register()
###############################################################################
driver = gdal.GetDriverByName('GeoTiff')
driver == None
###############################################################################
drv_count = gdal.GetDriverCount()
drv_count
###############################################################################
for idx in range(10):
driver = gdal.GetDriver(idx)
print("%10s: %s" % (driver.ShortName, driver.LongName))
def getSupportedRasters(self):
if self.supportedRasters != None:
return self.supportedRasters
# first get the GDAL driver manager
if gdal.GetDriverCount() == 0:
gdal.AllRegister()
self.supportedRasters = dict()
jp2Driver = None
# for each loaded GDAL driver
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
if driver == None:
QgsLogger.warning("unable to get driver " + str(i))
continue
# now we need to see if the driver is for something currently
# supported; if not, we give it a miss for the next driver
longName = string.strip(re.sub('\(.*$', '', driver.LongName))
shortName = string.strip(re.sub('\(.*$', '', driver.ShortName))
extensions = ''
description = driver.GetDescription()
glob = []
metadata = driver.GetMetadata()
if gdal.DMD_EXTENSION in metadata:
extensions = str(metadata[gdal.DMD_EXTENSION])
if longName != '':
if extensions != '':
# XXX add check for SDTS; in that case we want (*CATD.DDF)
# TODO fix and test
# glob.append( QString("*." + extensions.replace("/", " *.")).split(" "))
glob.append(
string.split("*." +
string.replace(extensions, "/", " *."),
sep=(" ")))
# Add only the first JP2 driver found to the filter list (it's the one GDAL uses)
if description == "JPEG2000" or description.startswith(
"JP2"): # JP2ECW, JP2KAK, JP2MrSID
if jp2Driver != None:
continue # skip if already found a JP2 driver
jp2Driver = driver # first JP2 driver found
glob.append("*.j2k") # add alternate extension
elif description == "GTiff":
glob.append("*.tiff")
elif description == "JPEG":
glob.append("*.jpeg")
else:
# USGS DEMs use "*.dem"
if description.startswith("USGSDEM"):
glob.append("*.dem")
elif description.startswith("DTED"):
# DTED use "*.dt0"
glob.append("*.dt0")
elif description.startswith("MrSID"):
# MrSID use "*.sid"
glob.append("*.sid")
else:
continue
self.supportedRasters[longName] = {
'EXTENSIONS': glob,
'LONGNAME': longName,
'SHORTNAME': shortName,
'DESCRIPTION': description
}
return self.supportedRasters
import gdal
# instantiate driver count object (iterable numeric)
driver_list = []
for i in range(gdal.GetDriverCount()):
driver_list.append(str(gdal.GetDriver(i).ShortName))
# sort driver list alphabetically
driver_list.sort()
# print driver list (comma separated list)
print(", ".join(driver_list))
#lyr = iface.activeLayer()
#ras_prov = lyr.dataProvider()
#QgsRasterDataProvider.fileRasterFilters(ras_prov)
#
import gdal
#gdal.AllRegister()
#print(gdal.AllRegister())
for i in range(0, gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
#print(drv)
drv_meta = drv.GetMetadata()
if 'DMD_EXTENSION' in drv_meta:
#print ("{}: .{}".format(drv_meta['DMD_LONGNAME'], drv_meta['DMD_EXTENSION']))
print ("{}: .{}".format(drv.LongName, drv_meta['DMD_EXTENSION']))
#for i in range(gdal.GetDriverCount()):
# drv = gdal.GetDriver(i)
# if drv.GetMetadataItem(gdal.DCAP_RASTER):
# print(drv.GetMetadataItem(gdal.DMD_LONGNAME), drv.GetMetadataItem(gdal.DMD_EXTENSIONS))
import osgeo
import gdal
import gdalconst
import ogr
import osr
import urllib2
print( "OGR Vector drivers")
print("==================")
cnt = ogr.GetDriverCount()
for i in range(cnt):
print(ogr.GetDriver(i).GetName())
print ("GDAL Raster drivers")
print ("===================")
cnt = gdal.GetDriverCount()
for i in xrange(cnt):
print (gdal.GetDriver(i).LongName)
print ("Total number of vector drivers: %d" % ogr.GetDriverCount())
print ("Total number of vector drivers: %d" % gdal.GetDriverCount())
print ("Testing opening a MODIS file...")
fp = open ( "MCD45A1.A2006213.h17v04.051.2013060204001.hdf", 'w')
fp.write ( urllib2.urlopen("http://e4ftl01.cr.usgs.gov/MOTA/MCD45A1.051/2006.08.01/MCD45A1.A2006213.h17v04.051.2013060204001.hdf").read() )
fp.close()
g = gdal.Open ( "MCD45A1.A2006213.h17v04.051.2013060204001.hdf" )
print ( g.GetSubDatasets() )
import os1_hw
