def getSupportedRasters():
if not gdalAvailable:
return {}
if GdalUtils.supportedRasters is not None:
return GdalUtils.supportedRasters
if gdal.GetDriverCount() == 0:
gdal.AllRegister()
GdalUtils.supportedRasters = {}
GdalUtils.supportedOutputRasters = {}
GdalUtils.supportedRasters['GTiff'] = ['tif']
GdalUtils.supportedOutputRasters['GTiff'] = ['tif']
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
if driver is None:
continue
shortName = driver.ShortName
metadata = driver.GetMetadata()
if gdal.DCAP_RASTER not in metadata \
or metadata[gdal.DCAP_RASTER] != 'YES':
continue
if gdal.DMD_EXTENSION in metadata:
extensions = metadata[gdal.DMD_EXTENSION].split('/')
if extensions:
GdalUtils.supportedRasters[shortName] = extensions
# Only creatable rasters can be referenced in output rasters
if ((gdal.DCAP_CREATE in metadata
and metadata[gdal.DCAP_CREATE] == 'YES')
or (gdal.DCAP_CREATECOPY in metadata
and metadata[gdal.DCAP_CREATECOPY] == 'YES')):
GdalUtils.supportedOutputRasters[
shortName] = extensions
return GdalUtils.supportedRasters
def GetOutputDriversFor(filename):
drv_list = []
ext = GetExtension(filename)
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
if (drv.GetMetadataItem(gdal.DCAP_CREATE) is not None or
drv.GetMetadataItem(gdal.DCAP_CREATECOPY) is not None) and \
drv.GetMetadataItem(gdal.DCAP_RASTER) is not None:
if ext and DoesDriverHandleExtension(drv, ext):
drv_list.append(drv.ShortName)
else:
prefix = drv.GetMetadataItem(gdal.DMD_CONNECTION_PREFIX)
if prefix is not None and filename.lower().startswith(
prefix.lower()):
drv_list.append(drv.ShortName)
# GMT is registered before netCDF for opening reasons, but we want
# netCDF to be used by default for output.
if ext.lower() == 'nc' and not drv_list and \
drv_list[0].upper() == 'GMT' and drv_list[1].upper() == 'NETCDF':
drv_list = ['NETCDF', 'GMT']
return drv_list
def driverList(drivertype='raster'):
'''Return the list of available GDAL/OGR drivers'''
if not drivertype:
types = ['gdal']
elif isinstance(drivertype, string_types):
types = [drivertype]
else:
types = drivertype
if not set(('raster', 'vector')).issuperset(types):
raise ValueError('invalid type list: "%s"' % types)
drivers = []
if 'raster' in types:
drivers.extend(
gdal.GetDriver(index) for index in range(gdal.GetDriverCount()))
if 'vector' in types:
# @TODO: check
from osgeo import ogr
drivers.extend(
ogr.GetDriver(index) for index in range(ogr.GetDriverCount()))
return drivers
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 " + QString.number(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 = QString(driver.LongName).remove(
QRegExp('\(.*$')).trimmed()
shortName = QString(driver.ShortName).remove(
QRegExp('\(.*$')).trimmed()
extensions = QString()
description = QString(driver.GetDescription())
glob = QStringList()
metadata = driver.GetMetadata()
if metadata.has_key(gdal.DMD_EXTENSION):
extensions = QString(metadata[gdal.DMD_EXTENSION])
if not longName.isEmpty():
if not extensions.isEmpty():
# XXX add check for SDTS; in that case we want (*CATD.DDF)
glob << QString("*." +
extensions.replace("/", " *.")).split(" ")
# 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 << "*.j2k" # add alternate extension
elif description == "GTiff":
glob << "*.tiff"
elif description == "JPEG":
glob << "*.jpeg"
else:
# USGS DEMs use "*.dem"
if description.startsWith("USGSDEM"):
glob << "*.dem"
elif description.startsWith("DTED"):
# DTED use "*.dt0"
glob << "*.dt0"
elif description.startsWith("MrSID"):
# MrSID use "*.sid"
glob << "*.sid"
else:
continue
self.supportedRasters[longName] = {
'EXTENSIONS': glob,
'LONGNAME': longName,
'SHORTNAME': shortName,
'DESCRIPTION': description
}
return self.supportedRasters
"version of the original Sentinel-2 file.")
parser.add_argument(
"--save_prefix",
default="",
help=
"If set, speficies the name of a prefix for all output files. Use a trailing / to save into a "
"directory. The default of no prefix will save into the current directory. "
"Example: --save_prefix result/")
args = parser.parse_args()
globals().update(args.__dict__)
if list_output_file_formats:
dcount = gdal.GetDriverCount()
for didx in range(dcount):
driver = gdal.GetDriver(didx)
if driver:
metadata = driver.GetMetadata()
if (gdal.DCAP_CREATE in (driver and metadata)
and metadata[gdal.DCAP_CREATE] == 'YES'
and gdal.DCAP_RASTER in metadata
and metadata[gdal.DCAP_RASTER] == 'YES'):
name = driver.GetDescription()
if "DMD_LONGNAME" in metadata:
name += ": " + metadata["DMD_LONGNAME"]
else:
name = driver.GetDescription()
if "DMD_EXTENSIONS" in metadata:
name += " (" + metadata["DMD_EXTENSIONS"] + ")"
print(name)
sys.exit(0)
def check_config(args):
"""
Check config and set some defaults if necessary.
"""
log(f"# Checking configuration")
errors = False
# Set some defaults
defaults = [
("quiet", False),
("product", "NBAR"),
("obstmp", "/tmp/obs.tif"),
("clipshpfn", "/tmp/clip.json"),
("tmpdir", "/tmp"),
("nocleanup", False),
("gdalconfig", {}),
("models", []),
]
for arg, value in defaults:
if not arg in args:
log(f"'{arg}' not set, setting to default: {arg} = {value}")
args[arg] = value
# Set GDAL config
for k, v in args["gdalconfig"].items():
if v == True:
v = "YES"
if v == False:
v = "NO"
gdal.SetConfigOption(k, v)
log(f"GDAL option {k} = {v}")
## Check that models exists
if not isinstance(args["models"], list):
log("'models' must be a list of models")
errors = True
# Set some model defaults
avail = [gdal.GetDriver(i).ShortName for i in range(gdal.GetDriverCount())]
# Check the models
models = args["models"]
for m in models:
name = m["name"]
if name[:7] == "file://":
try:
path = name[7:]
path, checksum = path.split(":")
except ValueError:
log(f"Incorrect model name format, it should be file://filename:sha256checksum"
)
errors = True
if name[:5] == "s3://":
try:
path = name[5:]
path, checksum = path.split(":")
except ValueError:
log(f"Incorrect model name format, it should be s3://bucket/key:sha256checksum"
)
errors = True
if "driver" not in m:
if gdal.GetDriverByName("COG"):
m["driver"] = "COG"
else:
m["driver"] = "GTiff"
if m["driver"] not in avail:
log(f"'driver' for model '{name}' is not available")
log(f"available drivers: {avail}")
errors = True
if "inputs" not in m:
m["inputs"] = []
# Normalise the urls
for ip in m["inputs"]:
fn = normalise_url(ip["filename"])
ip["filename"] = fn
# Parse tuples as tuples of numbers for models
for k, v in m.items():
if isinstance(v, dict):
for kk, vv in v.items():
if isinstance(
vv,
str) and vv.startswith("(") and vv.endswith(")"):
v[kk] = astuple(vv)
defaults = [
("output", "result.tif"),
]
for arg, value in defaults:
if not arg in m.keys():
log(f"Model {name} '{arg}' not set, setting to default: {arg} = {value}"
)
m[arg] = value
args["models"] = models
if errors:
sys.exit(1)
# TODO: Check GPU resources if needed?
return args
# https://pcjericks.github.io/py-gdalogr-cookbook/
import sys
try:
from osgeo import ogr, osr, gdal
print("GDAL VERSION: {}".format(gdal.__version__))
gdal_driver_list = [
gdal.GetDriver(i).GetDescription()
for i in range(gdal.GetDriverCount())
]
ogr_driver_list = [
ogr.GetDriver(i).GetDescription() for i in range(ogr.GetDriverCount())
]
print("\nGDAL DRIVERS:")
print(gdal_driver_list)
print("\nOGR DRIVERS:")
print(ogr_driver_list)
except:
sys.exit('ERROR: cannot find GDAL/OGR modules')
def __init__(self, parent: QtWidgets.QWidget=None):
super().__init__(parent)
self.layout = QtWidgets.QVBoxLayout()
self.setLayout(self.layout)
# Top
self.top_layout = QtWidgets.QHBoxLayout()
self.layout.addLayout(self.top_layout)
self.version_groupbox = QtWidgets.QGroupBox(self)
self.version_groupbox.setTitle("Version")
self.top_layout.addWidget(self.version_groupbox)
self.version_layout = QtWidgets.QVBoxLayout()
self.version_groupbox.setLayout(self.version_layout)
self.version_release = QtWidgets.QLabel("Release: %s" % gdal.VersionInfo('RELEASE_NAME'))
self.version_layout.addWidget(self.version_release)
self.version_date = QtWidgets.QLabel("Date: %s" % gdal.VersionInfo('RELEASE_DATE'))
self.version_layout.addWidget(self.version_date)
self.cache_groupbox = QtWidgets.QGroupBox(self)
self.cache_groupbox.setTitle("Cache")
self.top_layout.addWidget(self.cache_groupbox)
self.cache_layout = QtWidgets.QVBoxLayout()
self.cache_groupbox.setLayout(self.cache_layout)
self.cache_max = QtWidgets.QLabel("Max: %.1f MB" % (gdal.GetCacheMax() / (1024 * 1024),))
self.cache_layout.addWidget(self.cache_max)
self.cache_used = QtWidgets.QLabel("Used: %.1f MB" % (gdal.GetCacheUsed() / (1024 * 1024),))
self.cache_layout.addWidget(self.cache_used)
# Bottom
self.bottom_layout = QtWidgets.QHBoxLayout()
self.layout.addLayout(self.bottom_layout)
self.drivers_groupbox = QtWidgets.QGroupBox(self)
self.drivers_groupbox.setTitle("Drivers")
self.bottom_layout.addWidget(self.drivers_groupbox)
self.drivers_layout = QtWidgets.QVBoxLayout()
self.drivers_groupbox.setLayout(self.drivers_layout)
self.drivers_count = QtWidgets.QLabel("Number of drivers: %d" % (gdal.GetDriverCount(),))
self.drivers_layout.addWidget(self.drivers_count)
self.table = QtWidgets.QTableWidget(self)
self.table.setObjectName("GdalDriversTable")
self.table.setColumnCount(8)
self.table.setRowCount(0)
item = QtWidgets.QTableWidgetItem()
item.setText("Short Name")
self.table.setHorizontalHeaderItem(0, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Long Name")
self.table.setHorizontalHeaderItem(1, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Help Page")
self.table.setHorizontalHeaderItem(2, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Mime Type")
self.table.setHorizontalHeaderItem(3, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Extensions")
self.table.setHorizontalHeaderItem(4, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Data Types")
self.table.setHorizontalHeaderItem(5, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Creation Options")
self.table.setHorizontalHeaderItem(6, item)
item = QtWidgets.QTableWidgetItem()
item.setText("Metadata")
self.table.setHorizontalHeaderItem(7, item)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.horizontalHeader().setVisible(True)
self.table.verticalHeader().setVisible(False)
self.table.setRowCount(gdal.GetDriverCount())
for row in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(row)
self.table.setItem(row, 0, QtWidgets.QTableWidgetItem(driver.ShortName))
self.table.setItem(row, 1, QtWidgets.QTableWidgetItem(driver.LongName))
self.table.setItem(row, 2, QtWidgets.QTableWidgetItem(driver.HelpTopic))
metadata = driver.GetMetadata()
if metadata:
self.table.setItem(row, 3, QtWidgets.QTableWidgetItem(str(metadata.pop(gdal.DMD_MIMETYPE, ''))))
self.table.setItem(row, 4, QtWidgets.QTableWidgetItem(str(metadata.pop(gdal.DMD_EXTENSION, ''))))
self.table.setItem(row, 5,
QtWidgets.QTableWidgetItem(str(metadata.pop(gdal.DMD_CREATIONDATATYPES, ''))))
full_data = metadata.pop(gdal.DMD_CREATIONOPTIONLIST, '')
if full_data:
data = full_data[:10] + "[..]"
else:
data = full_data
table_item = QtWidgets.QTableWidgetItem(data)
table_item.setToolTip(full_data)
self.table.setItem(row, 6, table_item)
metadata_list = ['%s=%s' % (k, v) for k, v in metadata.items()]
metadata = ", ".join(metadata_list)[:10] + "[..]"
table_item = QtWidgets.QTableWidgetItem(metadata)
table_item.setToolTip('\n'.join(metadata_list))
self.table.setItem(row, 7, table_item)
self.table.horizontalHeader().resizeSections(QtWidgets.QHeaderView.ResizeToContents)
self.table.setSortingEnabled(True)
self.table.sortItems(0, QtCore.Qt.AscendingOrder)
self.drivers_layout.addWidget(self.table)
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)
md = drv.GetMetadata()
if ('DCAP_CREATECOPY' in md
or 'DCAP_CREATE' in md) and 'DCAP_RASTER' in md:
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' + get_filename(drv, ''),
src_ds)
gdal.PopErrorHandler()
if ds is None and gdal.GetLastErrorMsg() == '':
gdaltest.post_reason('failure')
print(
'CreateCopy() into non existing dir fails without error message for driver %s'
% drv.ShortName)
gdal.Unlink('/vsimem/misc_12_src.tif')
return 'fail'
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, _) = gdaltest.runexternal_out_and_err(
gdal_translate_path + ' -of ' + drv.ShortName +
' tmp/misc_12.vrt /nonexistingpath/' +
get_filename(drv, ''),
check_memleak=False)
del ds
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'
or __CODERS \
.update({'GoogleV3': 'api_key', # since July 2018 Google requires each request to have an API key
'Bing': 'api_key',
'GeoNames': 'username',
'Yandex': 'api_key',
'MapQuest': 'key',
'Nominatim': None, # using Nominatim with the default geopy is strongly discouraged
'OpenMapQuest': 'api_key'} if _is_geopy_installed else {}) \
or __CODERS # at the end, CODERS will be equal to __CODERS after its updates
# default geocoder... but this can be reset when declaring a subclass
DEF_CODER = {'Nominatim': None} # {'Bing' : None}
DEF_AGENT = PACKNAME
DRIVERS = {gdal.GetDriver(i).ShortName: gdal.GetDriver(i).LongName
for i in range(gdal.GetDriverCount())}
DEF_DRIVER = "GeoJSON"
DEF_PROJ = 'WGS84'
DEF_PROJ4LL = '+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs'
DEF_PROJ4SM = '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs'
# LATLON = ['lat', 'lon'] # 'coord' # 'latlon'
# ORDER = 'lL' # first lat, second Lon
DEF_PLACE = ['street', 'number', 'postcode', 'city', 'country']
"""Fields used to defined a toponomy (location/place).
"""
def has_jp2kdrv():
for i in range(gdal.GetDriverCount()):
if gdal.GetDriver(i).ShortName.startswith('JP2'):
return True
return False
def export(world,
export_filetype='GTiff',
export_datatype='float32',
path='seed_output'):
try:
gdal
except NameError:
print("Cannot export: please install pygdal.")
sys.exit(1)
gdal.AllRegister()
for i in range(1, gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
sTmp = drv.GetDescription()
print(sTmp)
final_driver = gdal.GetDriverByName(export_filetype)
metadata = final_driver.GetMetadata()
if metadata.has_key(
gdal.DCAP_CREATE) and metadata[gdal.DCAP_CREATE] == 'YES':
print('Driver %s supports Create() method.' % final_driver)
if metadata.has_key(
gdal.DCAP_CREATECOPY) and metadata[gdal.DCAP_CREATECOPY] == 'YES':
print('Driver %s supports CreateCopy() method.' % final_driver)
if final_driver is None:
print("%s driver not registered." % export_filetype)
sys.exit(1)
# try to find the proper file-suffix
export_filetype = export_filetype.lower()
if export_filetype in gdal_mapper:
export_filetype = gdal_mapper[export_filetype]
# Note: GDAL will throw informative errors on its own whenever file type and data type cannot be matched.
# translate export_datatype; http://www.gdal.org/gdal_8h.html#a22e22ce0a55036a96f652765793fb7a4
export_datatype = export_datatype.lower()
if export_datatype in ['gdt_byte', 'uint8', 'int8', 'byte',
'char']: # GDAL does not support int8
bpp, signed, normalize = (8, False, True)
numpy_type = numpy.uint8
gdal_type = gdal.GDT_Byte
elif export_datatype in ['gdt_uint16', 'uint16']:
bpp, signed, normalize = (16, False, True)
numpy_type = numpy.uint16
gdal_type = gdal.GDT_UInt16
elif export_datatype in ['gdt_uint32', 'uint32']:
bpp, signed, normalize = (32, False, True)
numpy_type = numpy.uint32
gdal_type = gdal.GDT_UInt32
elif export_datatype in ['gdt_int16', 'int16']:
bpp, signed, normalize = (16, True, True)
numpy_type = numpy.int16
gdal_type = gdal.GDT_Int16
elif export_datatype in ['gdt_int32', 'int32',
'int']: # fallback for 'int'
bpp, signed, normalize = (32, True, True)
numpy_type = numpy.int32
gdal_type = gdal.GDT_Int32
elif export_datatype in ['gdt_float32', 'float32',
'float']: # fallback for 'float'
bpp, signed, normalize = (32, True, False)
numpy_type = numpy.float32
gdal_type = gdal.GDT_Float32
elif export_datatype in ['gdt_float64', 'float64']:
bpp, signed, normalize = (64, True, False)
numpy_type = numpy.float64
gdal_type = gdal.GDT_Float64
else:
raise TypeError(
"Type of data not recognized or not supported by GDAL: %s" %
export_datatype)
# massage data to scale between the absolute min and max
elevation = numpy.copy(world.layers['elevation'].data)
# shift data according to minimum possible value
if signed:
elevation = elevation - world.sea_level(
) # elevation 0.0 now refers to sea-level
else:
elevation -= elevation.min() # lowest point at 0.0
# rescale data (currently integer-types only)
if normalize:
# elevation maps usually have a range of 0 to 10, maybe 15 - rescaling for integers is essential
if signed:
elevation *= (2**(bpp - 1) - 1) / max(abs(elevation.min()),
abs(elevation.max()))
else:
elevation *= (2**bpp - 1) / abs(elevation.max())
# round data (integer-types only)
if numpy_type != numpy.float32 and numpy_type != numpy.float64:
elevation = elevation.round()
# switch to final data type; no rounding performed
elevation = elevation.astype(numpy_type)
# take elevation data and push it into an intermediate GTiff format (some formats don't support being written by Create())
inter_driver = gdal.GetDriverByName("GTiff")
fh_inter_file, inter_file = tempfile.mkstemp(
) # returns: (file-handle, absolute path)
initial_ds = inter_driver.Create(inter_file, world.width, world.height, 1,
gdal_type)
band = initial_ds.GetRasterBand(1)
band.WriteArray(elevation)
band = None # dereference band
initial_ds = None # save/flush and close
# take the intermediate GTiff format and convert to final format
initial_ds = gdal.Open(inter_file)
final_driver.CreateCopy('%s-%d.%s' % (path, bpp, export_filetype),
initial_ds)
initial_ds = None
os.close(fh_inter_file)
os.remove(inter_file)
def create_transform(src, dst, transforms, format, dtype, scaling, sensor,
blue, green, red, nir, swir1, swir2, verbose):
if not transforms:
raise click.BadParameter('No transforms specified',
param_hint='<transform>...')
if verbose:
logger.setLevel(logging.DEBUG)
# Pair transforms requested with functions that calculate each transform
transform_funcs = [
obj for name, obj in inspect.getmembers(sys.modules[__name__],
inspect.isfunction)
if hasattr(obj, 'transform_name')
]
# Read input image
try:
ds = gdal.Open(src, gdal.GA_ReadOnly)
except:
logger.error("Could not open source dataset {0}".format(src))
raise
#driver = gdal.GetDriverByName(str(format))
driver = gdal.GetDriver(1)
# If no output dtype selected, default to input image dtype
if not dtype:
dtype = gdal_array.GDALTypeCodeToNumericTypeCode(
ds.GetRasterBand(1).DataType)
dtype = np.dtype(dtype)
gdal_dtype = gdal_array.NumericTypeCodeToGDALTypeCode(dtype)
# Only read in the bands that are required for the transforms
required_bands = set()
for t in transform_funcs:
required_bands.update(t.required_bands)
func_args = inspect.getargvalues(inspect.currentframe())[-1]
transform_args = dict.fromkeys(required_bands)
for b in transform_args.keys():
idx = func_args[b]
transform_args[b] = ds.GetRasterBand(idx).ReadAsArray()
logger.debug('Opened input file')
transform_args['scaling'] = scaling
transform_args['sensor'] = sensor
# Create transforms
transforms = OrderedDict([[t.transform_name,
t(**transform_args)] for t in transform_funcs
if t.transform_name.lower() in transforms])
logger.debug('Calculated transforms')
# Write output
nbands = len(transforms.keys())
out_ds = driver.Create(dst, ds.RasterXSize, ds.RasterYSize, nbands,
gdal_dtype)
metadata = {}
for i_b, (name, array) in enumerate(transforms.iteritems()):
r_band = out_ds.GetRasterBand(i_b + 1)
r_band.WriteArray(array)
r_band.SetDescription(name)
metadata['Band_' + str(i_b + 1)] = name
out_ds.SetMetadata(metadata)
out_ds.SetProjection(ds.GetProjection())
out_ds.SetGeoTransform(ds.GetGeoTransform())
logger.debug('Complete')
import logging
import warnings
import numpy
from osgeo import gdal
from osgeo import ogr
from osgeo import osr
LOGGER = logging.getLogger('pygeoprocessing.testing.sampledata')
ReferenceData = collections.namedtuple('ReferenceData',
'projection origin pixel_size')
gdal.AllRegister()
try:
GDAL_DRIVERS = sorted([gdal.GetDriver(i).GetDescription()
for i in range(1, gdal.GetDriverCount())])
OGR_DRIVERS = sorted([ogr.GetDriver(i).GetName()
for i in range(ogr.GetDriverCount())])
except TypeError:
# When building InVEST sphinx documentation, gdal.GetDriverCount() doesn't
# return an int.
GDAL_DRIVERS = OGR_DRIVERS = []
# Higher index in list represents more information is stored by the datatype
# Helpful for debug messages, used when creating sample rasters.
DTYPES = [
(numpy.byte, gdal.GDT_Byte),
(numpy.uint16, gdal.GDT_UInt16),
(numpy.uint32, gdal.GDT_UInt32),
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 and 'DCAP_RASTER' 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 getSupportedRasters(self):
'''Get list of the supported rasters.
Return list of extensions of the supported rasters.
'''
if self.rasterExtensions != None:
return self.rasterExtensions
# first get the GDAL driver manager
if gdal.GetDriverCount() == 0:
gdal.AllRegister()
self.rasterExtensions = []
jp2Driver = None
# for each loaded GDAL driver
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
if driver == None:
print('Unable to get driver', 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 = driver.LongName
description = driver.GetDescription()
extensions = []
metadata = driver.GetMetadata()
if metadata.has_key(gdal.DMD_EXTENSION):
extensions = metadata[gdal.DMD_EXTENSION]
ext = []
if longName != '':
if len(extensions) > 0:
# XXX add check for SDTS; in that case we want (*CATD.DDF)
ext.extend(
('*.' + extensions.replace('/', ' *.')).split(' '))
# 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
jp2Driver = driver
ext.append('*.j2k')
elif description == 'GTiff':
ext.append('*.tiff')
elif description == 'JPEG':
ext.append('*.jpeg')
else:
# USGS DEMs use "*.dem"
if description.startswith('USGSDEM'):
ext.append('*.dem')
elif description.startswith('DTED'):
# DTED use "*.dt0"
ext.append('*.dt0')
elif description.startswith('MrSID'):
# MrSID use "*.sid"
ext.append('*.sid')
else:
continue
self.rasterExtensions.extend(ext)
return list(set(self.rasterExtensions))
import numpy
from osgeo import gdal
from osgeo import ogr
from osgeo import osr
from .. import geoprocessing
from ..geoprocessing_core import DEFAULT_GTIFF_CREATION_TUPLE_OPTIONS
LOGGER = logging.getLogger('pygeoprocessing.testing.sampledata')
ReferenceData = collections.namedtuple('ReferenceData',
'projection origin pixel_size')
gdal.AllRegister()
GDAL_DRIVERS = sorted([
gdal.GetDriver(i).GetDescription() for i in range(1, gdal.GetDriverCount())
])
OGR_DRIVERS = sorted(
[ogr.GetDriver(i).GetName() for i in range(ogr.GetDriverCount())])
# Mappings of numpy -> GDAL types and GDAL -> numpy types.
NUMPY_GDAL_DTYPES = {
numpy.byte: gdal.GDT_Byte,
numpy.ubyte: gdal.GDT_Byte,
numpy.uint16: gdal.GDT_UInt16,
numpy.uint32: gdal.GDT_UInt32,
numpy.int16: gdal.GDT_Int16,
numpy.int32: gdal.GDT_Int32,
numpy.int64: gdal.GDT_Int32, # GDAL doesn't have an int6.
numpy.float32: gdal.GDT_Float32,
numpy.float64: gdal.GDT_Float64,
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('MEM').Create('', 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.SetMetadata(['a'])
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 and 'DCAP_RASTER' 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_class().cbk)
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')
return 'success'
def detect_ogr_driver(
ogr_ds: str,
name_only: bool = False) -> typing.Tuple[gdal.Driver, str]:
"""
Autodetect the appropriate driver for an OGR datasource.
Parameters
----------
ogr_ds : OGR datasource
Path to OGR datasource.
name_only : bool
True to return the name of the driver, else the ogr.Driver object will
be return
Returns
-------
OGR driver OR
OGR driver, layer name
"""
# Driver names
FileGDB = 'FileGDB'
OpenFileGDB = 'OpenFileGDB'
# Suffixes
GPKG = '.gpkg'
SHP = '.shp'
GEOJSON = '.geojson'
GDB = '.gdb'
supported_drivers = [
gdal.GetDriver(i).GetDescription()
for i in range(gdal.GetDriverCount())
]
if FileGDB in supported_drivers:
gdb_driver = FileGDB
else:
gdb_driver = OpenFileGDB
# OGR driver lookup table
driver_lut = {
GEOJSON: 'GeoJSON',
SHP: 'ESRI Shapefile',
GPKG: 'GPKG',
GDB: gdb_driver
}
layer = None
# Check if in-memory datasource
if isinstance(ogr_ds, PurePath):
ogr_ds = str(ogr_ds)
if isinstance(ogr_ds, ogr.DataSource):
driver = 'Memory'
elif 'vsimem' in ogr_ds:
driver = 'ESRI Shapefile'
else:
# Check if extension in look up table
if GPKG in ogr_ds:
drv_sfx = GPKG
layer = Path(ogr_ds).stem
elif GDB in ogr_ds:
drv_sfx = GDB
layer = Path(ogr_ds).stem
else:
drv_sfx = Path(ogr_ds).suffix
if drv_sfx in driver_lut.keys():
driver = driver_lut[drv_sfx]
else:
logger.warning("""Unsupported driver extension {}
Defaulting to 'ESRI Shapefile'""".format(drv_sfx))
driver = driver_lut[SHP]
logger.debug('Driver autodetected: {}'.format(driver))
if not name_only:
try:
driver = ogr.GetDriverByName(driver)
except ValueError as e:
logger.error('ValueError with driver_name: {}'.format(driver))
logger.error('OGR DS: {}'.format(ogr_ds))
raise e
return driver, layer
def misc_6_internal(datatype, nBands, setDriversDone):
ds = gdal.GetDriverByName('MEM').Create('', 10, 10, nBands, datatype)
if nBands > 0:
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.SetMetadata(['a'])
for i in range(gdal.GetDriverCount()):
drv = gdal.GetDriver(i)
md = drv.GetMetadata()
if ('DCAP_CREATECOPY' in md
or 'DCAP_CREATE' in md) and 'DCAP_RASTER' 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 skip is False:
dirname = 'tmp/tmp/tmp_%s_%d_%s' % (
drv.ShortName, nBands, gdal.GetDataTypeName(datatype))
try:
os.mkdir(dirname)
except OSError:
try:
os.stat(dirname)
# Hum the directory already exists... Not expected, but let's try to go on
except OSError:
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 = get_filename(drv, dirname)
dst_ds = drv.CreateCopy(filename, ds)
has_succeeded = dst_ds is not None
dst_ds = None
size = 0
stat = gdal.VSIStatL(filename)
if stat is not None:
size = stat.size
try:
shutil.rmtree(dirname)
except OSError:
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 drv.ShortName not in setDriversDone and nBands > 0:
setDriversDone.add(drv.ShortName)
# The first list of drivers fail to detect short writing
# The second one is because they are verbose in stderr
if 'DCAP_VIRTUALIO' in md and size != 0 and \
drv.ShortName not in ['JPEG2000', 'KMLSUPEROVERLAY', 'HF2', 'ZMap', 'DDS'] and \
drv.ShortName not in ['GIF', 'JP2ECW', 'JP2Lura']:
for j in range(10):
truncated_size = (size * j) / 10
vsimem_filename = (
'/vsimem/test_truncate/||maxlength=%d||' %
truncated_size) + get_filename(drv, '')[1:]
# print('drv = %s, nBands = %d, datatype = %s, truncated_size = %d' % (drv.ShortName, nBands, gdal.GetDataTypeName(datatype), truncated_size))
dst_ds = drv.CreateCopy(vsimem_filename, ds)
error_detected = False
if dst_ds is None:
error_detected = True
else:
gdal.ErrorReset()
dst_ds = None
if gdal.GetLastErrorMsg() != '':
error_detected = True
if not error_detected:
msg = 'write error not decteded with with drv = %s, nBands = %d, datatype = %s, truncated_size = %d' % (
drv.ShortName, nBands,
gdal.GetDataTypeName(datatype),
truncated_size)
print(msg)
gdaltest.post_reason(msg)
fl = gdal.ReadDirRecursive('/vsimem/test_truncate')
if fl is not None:
for myf in fl:
gdal.Unlink('/vsimem/test_truncate/' + myf)
fl = gdal.ReadDirRecursive(
'/vsimem/test_truncate')
if fl is not None:
print(fl)
if drv.ShortName not in [
'ECW', 'JP2ECW', 'VRT', 'XPM', 'JPEG2000', 'FIT',
'RST', 'INGR', 'USGSDEM', 'KMLSUPEROVERLAY', 'GMT'
]:
dst_ds = drv.CreateCopy(
filename,
ds,
callback=misc_6_interrupt_callback_class().cbk)
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 OSError:
pass
return 'fail'
dst_ds = None
try:
shutil.rmtree(dirname)
except OSError:
pass
try:
os.mkdir(dirname)
except OSError:
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
return 'success'
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 metadata.has_key(gdal.DMD_EXTENSION):
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
def UsageFormat():
print('Valid formats:')
count = gdal.GetDriverCount()
for index in range(count):
driver = gdal.GetDriver(index)
print(driver.ShortName)
#! /usr/bin/env python # -*- coding: utf-8 -*- # __author__ = "Uncle Xiang" # Email: [email protected] # Time: 2020/3/4 15:57 # version: python 37 from osgeo import gdal driver_count = gdal.GetDriverCount() print(driver_count) driver = gdal.GetDriver(1) print(driver)
def _export_raster(self,
raster_name,
format="COG",
additional_options=[],
use_raster_region=False):
"""Export a specific raster layer with r.out.gdal as GeoTiff.
The result is stored in a temporary directory
that is located in the temporary grass database.
The region of the raster layer can be used for export. In this case a
temporary region will be used for export, so that the original region
of the mapset is not modified.
COG-Driver: https://gdal.org/drivers/raster/cog.html
Args:
raster_name (str): The name of the raster layer
format (str): COG (default; requires GDAL >= 3.1 on server), GTiff
additional_options (list): Unused
use_raster_region (bool): Use the region of the raster layer for export
Returns:
tuple: A tuple (file_name, output_path)
Raises:
AsyncProcessError: If a GRASS module return status is not 0
"""
# Export the layer
suffix = ".tif"
# Remove a potential mapset
file_name = raster_name.split("@")[0] + suffix
if use_raster_region is True:
p = Process(exec_type="grass",
executable="g.region",
executable_params=["raster=%s" % raster_name, "-g"],
id=f"exporter_region_{raster_name}",
stdin_source=None)
self._update_num_of_steps(1)
self._run_module(p)
if format == 'COG':
# check if GDAL has COG driver
from osgeo import gdal
driver_list = [
gdal.GetDriver(i).ShortName
for i in range(gdal.GetDriverCount())
]
if 'COG' not in driver_list:
format = 'GTiff'
self.message_logger.info(
"COG driver not available, using GTiff driver")
# Save the file in the temporary directory of the temporary gisdb
output_path = os.path.join(self.temp_file_path, file_name)
module_name = "r.out.gdal"
args = [
"-fmt",
"input=%s" % raster_name,
"format=%s" % format,
"output=%s" % output_path
]
create_opts = "createopt=BIGTIFF=YES,COMPRESS=LZW"
if format == "GTiff":
# generate overviews with compression:
os.environ['COMPRESS_OVERVIEW'] = "LZW"
args.append("overviews=5")
create_opts += ",TILED=YES"
args.append(create_opts)
# current workaround due to color table export
# COG bug in GDAL, see https://github.com/OSGeo/gdal/issues/2946
# TODO: DELETE AND TEST ONCE GDAL 3.1.4 HAS BEEN RELEASED
if format == "COG":
args.append("-c")
if additional_options:
args.extend(additional_options)
p = Process(exec_type="grass",
executable=module_name,
executable_params=args,
id=f"exporter_raster_{raster_name}",
stdin_source=None)
self._update_num_of_steps(1)
self._run_module(p)
return file_name, output_path
def get_drivers() -> dict:
drivers = {}
for i in range(gdal.GetDriverCount()):
driver = gdal.GetDriver(i)
drivers[driver.ShortName] = driver.GetDescription()
return drivers
