def get_basics_gdal(name):
"""Get basic info from image
Args:
name (str): Image filename
Returns:
tuple: (file, File object (<gdal dataset>)
dims, Dimensions, tuple: (1920,1024)
bands_count, Number of channels, int
gdal_type, Type via GDAL typage (gdal.GDT_Byte, etc)
dtype , Type via numpy dtype
block_max_type_size Max value of numpy dtype
)
"""
file = gdal.Open(name, gdal.GA_ReadOnly)
bands_count = file.RasterCount
g_type = gdal.GetDataTypeName(file.GetRasterBand(1).DataType)
dims = [file.RasterXSize, file.RasterYSize]
_pix = file.ReadAsArray(0, 0, 1, 1)
# dtype in numpy
#block_max_type_size, type_np = _get_block_type_max_size(_pix)
return file, dims, bands_count, g_type #, type_np, block_max_type_size
def get_value_at_position(self, lat, lon, raster_band=1):
band = self.ds.GetRasterBand(raster_band)
bandtype = gdal.GetDataTypeName(band.DataType)
px, py = gdal.ApplyGeoTransform(self.transfInv, lon, lat)
if px > self.cols or py > self.rows:
return None
structval = band.ReadRaster(int(px),
int(py),
1,
1,
buf_type=band.DataType)
fmt = self._pt2fmt(band.DataType)
value = struct.unpack(fmt, structval)
if value[0] == band.GetNoDataValue():
if fmt == 'f':
return float('nan')
else:
return None
else:
result = value[0]
return value[0]
def get_hls_tile(blob_url):
"""
Given a URL pointing to an HLS image in blob storage, load that image via GDAL
and return both data and metadata.
"""
formatted_gdal_bloburl = '/{}/{}'.format('vsicurl', blob_url)
tile_open = gdal.Open(formatted_gdal_bloburl)
data = tile_open.GetRasterBand(1)
ndv, xsize, ysize = data.GetNoDataValue(
), tile_open.RasterXSize, tile_open.RasterYSize
projection = osr.SpatialReference()
projection.ImportFromWkt(tile_open.GetProjectionRef())
datatype = data.DataType
datatype = gdal.GetDataTypeName(datatype)
data_array = data.ReadAsArray()
return ndv, xsize, ysize, projection, data_array
def read_input_stack_geos(rasterfn):
# open raster file
raster3d = gdal.Open(rasterfn)
# Get blocksizes for iterating over tiles (chuuks)
myBlockSize=raster3d.GetRasterBand(1).GetBlockSize();
x_block_size = myBlockSize[0]
y_block_size = myBlockSize[1]
# Get image sizes
cols = raster3d.RasterXSize
rows = raster3d.RasterYSize
bands = raster3d.RasterCount
# get datatype and transform to numpy readable
data_type = raster3d.GetRasterBand(1).DataType
data_type_name = gdal.GetDataTypeName(data_type)
if data_type_name == "Byte":
data_type_name = "uint8"
print " INFO: Importing", raster3d.RasterCount, "bands from", rasterfn
#band=raster3d.GetRasterBand(1)
geotransform = raster3d.GetGeoTransform()
originX = geotransform[0]
originY = geotransform[3]
pixelWidth = geotransform[1]
pixelHeight = geotransform[5]
driver = gdal.GetDriverByName('GTiff')
ndv = raster3d.GetRasterBand(1).GetNoDataValue()
# we need this for file creation
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromWkt(raster3d.GetProjectionRef())
# we return a dict of all relevant values
return {'xB':x_block_size, 'yB': y_block_size, 'cols': cols, 'rows':rows, 'bands':bands, 'dt': data_type, 'dtn':data_type_name, 'ndv':ndv,
'gtr':geotransform, 'oX':originX, 'oY': originY, 'pW':pixelWidth, 'pH':pixelHeight, 'driver': driver, 'outR':outRasterSRS}
def get_cell_info(raster_file_name):
"""
(object) --> dict
Return: meta info of cells in raster
"""
raster_dataset = gdal.Open(raster_file_name, GA_ReadOnly)
# get cell size info
if raster_dataset:
rows = raster_dataset.RasterYSize
columns = raster_dataset.RasterXSize
proj_wkt = raster_dataset.GetProjection()
cell_size_x_value = raster_dataset.GetGeoTransform(
)[1] if proj_wkt else 0
cell_size_y_value = abs(
raster_dataset.GetGeoTransform()[5]) if proj_wkt else 0
band = raster_dataset.GetRasterBand(1)
cell_data_type = gdal.GetDataTypeName(band.DataType)
cell_info = OrderedDict([
('rows', rows),
('columns', columns),
('cellSizeXValue', cell_size_x_value),
('cellSizeYValue', cell_size_y_value),
('cellDataType', cell_data_type),
])
else:
cell_info = OrderedDict([
('rows', None),
('columns', None),
('cellSizeXValue', None),
('cellSizeYValue', None),
('cellDataType', None),
])
return cell_info
def read_image(filename, band=1, no_data_value=None):
gdal.UseExceptions()
try:
ds = gdal.Open(filename)
except RuntimeError as e:
logger.exception("Unable to open {}".format(filename))
raise e
logger.info("Reading {} file of size: {}x{}x{}".format(
ds.GetDriver().ShortName, ds.RasterXSize, ds.RasterYSize,
ds.RasterCount))
transform = ds.GetGeoTransform()
try:
data_band = ds.GetRasterBand(band)
except RuntimeError as e:
logger.exception("Could not get band {}".format(band))
logger.info("Bands available in {}: {}".format(filename,
ds.RasterCount))
raise e
data = data_band.ReadAsArray()
# replace the no data value entries with a user supplied value, if applicable
if no_data_value is not None and data_band.GetNoDataValue():
if gdal.GetDataTypeName(data_band.DataType).startswith("Float"):
masked_data = np.ma.masked_values(data,
data_band.GetNoDataValue(),
copy=False)
else:
masked_data = np.ma.masked_equal(data,
data_band.GetNoDataValue(),
copy=False)
masked_data.fill_value = no_data_value
masked_data = np.ma.fix_invalid(masked_data, copy=False)
data = masked_data.data
return data, transform
def extract_green(dataset, _geotransform, _projection):
""""Extract green locations from map.
"""
band = dataset.GetRasterBand(1)
if band is None:
raise ValueError('Could not read hdf file')
bandtype = gdal.GetDataTypeName(band.DataType)
log.debug('Data type %s', bandtype)
data = band.ReadAsArray()
raw_data = np.copy(data)
log.debug('Bytes: %s Size %.5d kb', data.nbytes, float(data.nbytes) / 1024)
passer = np.logical_and(data > 0, data <= 1000)
log.debug('Min: %5s Max: %5s Mean:%5.2f STD:%5.2f' % (
data[passer].min(), data[passer].max(),
data[passer].mean(), data[passer].std())
)
plot_green(data)
# create green mask
green = ma.masked_inside(data, 1, 5)
xarr, yarr = np.where(green.mask)
# test if we extracted green
data[green.mask] = 0
# check if all green is gone
plot_green(data)
# log.info('Converting xy to lon lat Locations')
# lons, lats = determine_lonlat(geotransform, projection, xarr[:], yarr[:])
# log.info('Extracted %d Locations', len(lons))
return dataset, raw_data, green, xarr, yarr
def get_precipitation_from_cru_indexes(self, i, j, m, y):
# Inputs are:
# (i, j): the location on the grid
# m: the month
# y: the year
prec_filename = self.get_precipitation_tiff_filename(y, m)
ds = gdal.Open(prec_filename, GA_ReadOnly)
# Examine the tiff metadata, but it's just the Area or Point info
# print("Tiff Metadata:\n%s" % ds.GetMetadata())
# Verify that we are checking a point in the grid
xdim = ds.RasterXSize
ydim = ds.RasterYSize
assert(i<xdim)
assert(j<ydim)
band = ds.GetRasterBand(1)
precipitations = band.ReadAsArray(0, 0, xdim,
ydim).astype(gdal.GetDataTypeName(band.DataType))
return precipitations[j][i]
def _setHistogram(self, dataset):
histogramBand = []
for band_number in range(1, dataset.RasterCount + 1):
band = dataset.GetRasterBand(band_number)
# get raster and overview if available
overview = 2
if overview < band.GetOverviewCount():
band_overview = band.GetOverview(overview)
else:
band_overview = band
# get overview statistics
rasterMin, rasterMax, rasterMean, rasterStddev = band_overview.ComputeStatistics(
False)
histogramBand.append([
"B" + str(band_number - 1),
int(rasterMin),
int(rasterMax), rasterMean, rasterStddev
])
self._dataType.append(gdal.GetDataTypeName(band.DataType))
self._noData.append(band.GetNoDataValue())
self._histogram = histogramBand
print "self._dataType", self._dataType
def __init__(self, ds):
import gdal
self.ds = ds
rb = ds.GetRasterBand(1)
self.fill_value = rb.GetNoDataValue()
self.dtype = np.dtype(gdal.GetDataTypeName(rb.DataType).lower())
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'
def misc_5_internal(drv, datatype, nBands):
dirname = 'tmp/tmp/tmp_%s_%d_%s' % (drv.ShortName, nBands,
gdal.GetDataTypeName(datatype))
print('drv = %s, nBands = %d, datatype = %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 for drv = %s, nBands = %d, datatype = %s' % (
dirname, drv.ShortName, nBands, gdal.GetDataTypeName(datatype))
gdaltest.post_reason(reason)
return 0
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'
ds = drv.Create(filename, 100, 100, nBands, datatype)
if ds is not None:
set_gt = (2, 1.0 / 10, 0, 49, 0, -1.0 / 10)
ds.SetGeoTransform(set_gt)
ds.SetProjection(
'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["degree",0.01745329251994328]]'
)
# PNM and MFF have no SetGeoTransform() method implemented
if drv.ShortName not in ['PNM', 'MFF']:
got_gt = ds.GetGeoTransform()
for i in range(6):
if abs(got_gt[i] - set_gt[i]) > 1e-10:
print(
'Did not get expected GT for drv = %s, nBands = %d, datatype = %s'
% (drv.ShortName, nBands,
gdal.GetDataTypeName(datatype)))
print(got_gt)
return -1
#if ds.RasterCount > 0:
# ds.GetRasterBand(1).Fill(255)
ds = None
ds = gdal.Open(filename)
if ds is None:
reason = 'Cannot reopen %s for drv = %s, nBands = %d, datatype = %s' % (
dirname, drv.ShortName, nBands, gdal.GetDataTypeName(datatype))
gdaltest.post_reason(reason)
#else:
# if ds.RasterCount > 0:
# print ds.GetRasterBand(1).Checksum()
ds = None
try:
shutil.rmtree(dirname)
except:
reason = 'Cannot remove %s for drv = %s, nBands = %d, datatype = %s' % (
dirname, drv.ShortName, nBands, gdal.GetDataTypeName(datatype))
gdaltest.post_reason(reason)
return 0
return 1
"""Get dataset Info"""
print 'Driver: ', dataset.GetDriver().ShortName,'/', \
dataset.GetDriver().LongName
print 'Size is ',dataset.RasterXSize,'x',dataset.RasterYSize, \
'x',dataset.RasterCount
print 'Projection is ',dataset.GetProjection()
geotransform = dataset.GetGeoTransform()
if not geotransform is None:
print 'Origin = (',geotransform[0], ',',geotransform[3],')'
print 'Pixel Size = (',geotransform[1], ',',geotransform[5],')'
"""Fetch a raster band"""
band = dataset.GetRasterBand(1)
print 'Band Type=',gdal.GetDataTypeName(band.DataType)
min = band.GetMinimum()
max = band.GetMaximum()
if min is None or max is None:
(min,max) = band.ComputeRasterMinMax(1)
print 'Min=%.3f, Max=%.3f' % (min,max)
if band.GetOverviewCount() > 0:
print 'Band has ', band.GetOverviewCount(), ' overviews.'
if not band.GetRasterColorTable() is None:
print 'Band has a color table with ', \
band.GetRasterColorTable().GetCount(), ' entries.'
"""Read raster data"""
def OpenAsArray(fh, bandnumber=1, dtype='float32', nan_values=False):
"""
Open a map as an numpy array.
Parameters
----------
fh: str
Filehandle to map to open.
bandnumber : int, optional
Band or layer to open as array, default is 1.
dtype : str, optional
Datatype of output array, default is 'float32'.
nan_values : boolean, optional
Convert he no-data-values into np.nan values, note that dtype needs to
be a float if True. Default is False.
Returns
-------
Array: :obj:`numpy.ndarray`
Array with the pixel values.
"""
print('WaPOR GIS: Opening file...')
checkMemory('OpenAsArray Start')
# datatypes = {
# "uint8": np.uint8, "int8": np.int8,
# "uint16": np.uint16, "int16": np.int16, "Int16": np.int16,
# "uint32": np.uint32, "int32": np.int32, "Int32": np.int32,
# "float32": np.float32, "float64": np.float64,
# "Float32": np.float32, "Float64": np.float64,
# "complex64": np.complex64, "complex128": np.complex128,
# "Complex64": np.complex64, "Complex128": np.complex128, }
DataSet = gdal.Open(fh, gdal.GA_ReadOnly)
checkMemory('OpenAsArray Opened')
Type = DataSet.GetDriver().ShortName
if Type == 'HDF4':
Subdataset = gdal.Open(DataSet.GetSubDatasets()[bandnumber][0])
NDV = int(Subdataset.GetMetadata()['_FillValue'])
else:
Subdataset = DataSet.GetRasterBand(bandnumber)
NDV = Subdataset.GetNoDataValue()
print('WaPOR GIS: Band DataType : {v}'.format(
v=Subdataset.DataType))
print('WaPOR GIS: Band DataTypeName : {v}'.format(
v=gdal.GetDataTypeName(Subdataset.DataType)))
print('WaPOR GIS: NoDataValue : {v}, {t}'.format(
v=NDV, t=type(NDV)))
# Array = Subdataset.ReadAsArray().astype(datatypes[dtype])
Array = Subdataset.ReadAsArray()
print('WaPOR GIS: Band Array dtype : {v} {sp} {sz}'.format(
v=Array.dtype.name, sp=Array.shape, sz=Array.size))
checkMemory('OpenAsArray Loaded')
# if nan_values:
# Array[Array == NDV] = np.nan
DataSet = None
checkMemory('OpenAsArray End')
return Array
def read(self, filename: Path):
# Open the image
poDataset = gdal.Open(str(filename.absolute()), gdalconst.GA_ReadOnly)
# Get geospatial metadata
print(f"Driver: {poDataset.GetDriver().GetDescription()} {poDataset.GetDriver().LongName}")
self.width = poDataset.RasterXSize
self.height = poDataset.RasterYSize
self.bands = poDataset.RasterCount
print(f"Width = {self.width}\nHeight = {self.height}\nBands = {self.bands}")
projection = poDataset.GetProjection()
self.projection = projection
print(f"Projection is {projection}")
adfGeoTransform = poDataset.GetGeoTransform()
print(f"GeoTransform = {adfGeoTransform[0]}, {adfGeoTransform[1]}, {adfGeoTransform[2]}, "
f"{adfGeoTransform[3]}, {adfGeoTransform[4]}, {adfGeoTransform[5]}")
xscale = adfGeoTransform[1]
yscale = -adfGeoTransform[5]
self.easting = adfGeoTransform[0] - adfGeoTransform[2] * xscale
self.northing = adfGeoTransform[3] - self.height * yscale
myOGRS = poDataset.GetProjectionRef()
srs = osr.SpatialReference(wkt=myOGRS)
if srs.IsProjected:
projection_string = srs.GetAttrValue('projcs')
# regex to find numbers followed by a single letter in projcs string
pattern = re.compile('\d+[a-zA-Z]{1}')
result = re.search(pattern, projection_string)
result_str = result.group()
zone_number = int(result_str[:-1])
zone_hemisphere = result_str[-1]
if zone_hemisphere is "S":
self.zone = zone_number * -1
elif zone_hemisphere is "N":
self.zone = zone_number
else:
print("Image is not projected. Returning None...")
self.gsd = (xscale+yscale) / 2
print(f"UTM Easting = {self.easting}\nUTM Northing = {self.northing}\n"
f"UTM Zone = {self.zone}\nGSD = {self.gsd}")
# Get band information
poBand = poDataset.GetRasterBand(1)
if poBand is None:
print("Error opening first band...")
BandDataType = gdal.GetDataTypeName(poBand.DataType)
noData = poBand.GetNoDataValue()
# TODO: Check for floating point precision
if noData is None:
if self.TYPE is float:
# Set noData only for floating point images
noData = float(-10000)
else:
noData = 0
# Get scale and offset values
if self.TYPE is float:
# Do not scale if floating point values
self.scale = 1
self.offset = 0
else:
adfMinMax = [0, 0]
first_pass = True
minVal = None
maxVal = None
for i in range(0, self.bands):
poBand = poDataset.GetRasterBand(i+1)
if poBand is None:
print(f"Error opening band {i+1}")
adfMinMax[0] = None #poBand.GetMinimum()
adfMinMax[1] = None #poBand.GetMaximum()
if not adfMinMax[0] or not adfMinMax[1]:
min, max = poBand.ComputeRasterMinMax(True)
adfMinMax[0] = min
adfMinMax[1] = max
if first_pass:
minVal = adfMinMax[0]
maxVal = adfMinMax[1]
first_pass = False
else:
if minVal > adfMinMax[0]:
minVal = float(adfMinMax[0])
if maxVal < adfMinMax[1]:
maxVal = float(adfMinMax[1])
# Reserve zero fo noData value
minVal -= 1
maxVal += 1
# TODO: Remove manual BandDataType, acquired above correctly.
# BandDataType = 'UInt16'
# maxImageVal = float(pow(2.0, int((np.iinfo(self.TYPE).max) * 8)) - 1)
maxImageVal = get_max_value_of_datatype(self.TYPE)
self.offset = minVal
self.scale = (maxVal - minVal) / maxImageVal
print(f"Offset = {self.offset}")
print(f"Scale = {self.scale}")
# Read the image, one band at a time
offset_function = lambda x: (x-self.offset)/self.scale
vfunc = np.vectorize(offset_function)
for ib in range(0, self.bands):
# Read the next row
poBand = poDataset.GetRasterBand(ib+1)
raster = poBand.ReadAsArray()
shifted_array = vfunc(raster)
self.data = shifted_array
return True
def create_gui(self):
self.dict_of_bands = get_list_of_bands_as_dict()
if self.dict_of_bands is None:
raise
self.list_of_bands = self.dict_of_bands.keys()
title_width = 120
box1 = GtkVBox(spacing=5)
self.add(box1)
box1.show()
#### OPERATIONS ####################################################
box_op = GtkHBox(spacing=10)
box1.set_border_width(10)
box1.pack_start(box_op, expand=FALSE)
box_op.show()
op_label = GtkLabel('Operation:')
op_label.set_alignment(0, 0.5)
box_op.pack_start(op_label, expand=FALSE)
# The item <operations_dict> is the dictionary, that contains
# the list of calculator operation names as keys and the set
# of corresponding functions.
self.operations_dict = {}
self.operations_dict['Add [Res = A * X + B * Y + C]'] = \
(3,self.add_bands)
self.operations_dict['Multiply [Res = X * Y]'] = \
(0,self.multiply_bands)
self.operations_dict['Divide [Res = A * X / (Y + B) + C]'] = \
(3,self.divide_bands)
self.operations_dict[
'Vegetation Index [Res = A * (X - Y) / ( X + Y) + B]'] = (
2, self.veg_index)
self.operations_list = self.operations_dict.keys()
self.operation = \
gvutils.GvOptionMenu(self.operations_list,self.update_gui)
box_op.pack_start(self.operation)
self.operation.show()
### COEFFICIENTS ######################################################
self.box_coeffs = GtkHBox(spacing=10)
box1.pack_start(self.box_coeffs, expand=FALSE)
self.box_coeffs.show()
self.box_coeff_a = GtkHBox(spacing=5)
self.box_coeffs.pack_start(self.box_coeff_a, expand=FALSE)
self.box_coeff_a.show()
a_label = GtkLabel('A =')
a_label.set_alignment(0, 0.5)
self.box_coeff_a.pack_start(a_label)
self.a_const = GtkEntry()
self.a_const.set_usize(80, 30)
self.a_const.set_text('1')
self.box_coeff_a.pack_start(self.a_const, expand=FALSE)
self.a_const.show()
self.box_coeff_b = GtkHBox(spacing=5)
self.box_coeffs.pack_start(self.box_coeff_b, expand=FALSE)
self.box_coeff_b.show()
b_label = GtkLabel('B =')
b_label.set_alignment(0, 0.5)
self.box_coeff_b.pack_start(b_label)
self.b_const = GtkEntry()
self.b_const.set_usize(80, 30)
self.b_const.set_text('1')
self.box_coeff_b.pack_start(self.b_const, expand=FALSE)
self.b_const.show()
self.box_coeff_c = GtkHBox(spacing=5)
self.box_coeffs.pack_start(self.box_coeff_c, expand=FALSE)
self.box_coeff_c.show()
c_label = GtkLabel('C =')
c_label.set_alignment(0, 0.5)
self.box_coeff_c.pack_start(c_label)
self.c_const = GtkEntry()
self.c_const.set_usize(80, 30)
self.c_const.set_text('1')
self.box_coeff_c.pack_start(self.c_const, expand=FALSE)
self.c_const.show()
self.coeffs_vis = [
self.box_coeff_a, self.box_coeff_b, self.box_coeff_c
]
### source1 #############################################################
frame1 = GtkFrame("Select Image Bands To Compute")
frame1.show()
box1.pack_start(frame1, expand=FALSE)
box2 = GtkVBox(spacing=10)
box2.set_border_width(10)
frame1.add(box2)
box2.show()
box_s1 = GtkHBox(spacing=10)
box2.pack_start(box_s1, expand=FALSE)
box_s1.show()
source1_label = GtkLabel('Source 1 < X >:')
source1_label.set_alignment(0, 0.5)
box_s1.pack_start(source1_label, expand=FALSE)
self.s1_list = gvutils.GvOptionMenu(self.list_of_bands)
box_s1.pack_start(self.s1_list)
self.s1_list.show()
## source2 ##############################################################
box_s2 = GtkHBox(spacing=10)
box2.pack_start(box_s2, expand=FALSE)
box_s2.show()
source2_label = GtkLabel('Source 2 < Y >:')
source2_label.set_alignment(0, 0.5)
box_s2.pack_start(source2_label, expand=FALSE)
self.s2_list = gvutils.GvOptionMenu(self.list_of_bands)
box_s2.pack_start(self.s2_list)
self.s2_list.show()
#####OUT TYPES#########################################################
box_types = GtkHBox(spacing=10)
box2.pack_start(box_types, expand=FALSE)
box_types.show()
types_label = GtkLabel('Image data type:')
types_label.set_alignment(0, 0.5)
box_types.pack_start(types_label, expand=FALSE)
self.types_list = []
i = GDT_Byte
while i < GDT_TypeCount:
self.types_list.append(gdal.GetDataTypeName(i))
i += 1
self.types = gvutils.GvOptionMenu(self.types_list)
box_types.pack_start(self.types)
self.types.show()
#### NEW VIEW ##########################################################
self.switch_new_view = GtkCheckButton("Create New View")
box1.pack_start(self.switch_new_view)
self.switch_new_view.show()
#### BUTTONS ###########################################################
box_buttons = GtkHBox(spacing=15)
box1.pack_start(box_buttons, expand=FALSE)
box_buttons.show()
self.ok_btn = GtkButton("Ok")
self.ok_btn.connect("clicked", self.compute)
box_buttons.pack_start(self.ok_btn)
self.cancel_btn = GtkButton("Cancel")
self.cancel_btn.connect("clicked", self.close)
box_buttons.pack_start(self.cancel_btn)
return TRUE
def raster2rgb(raster_file,
color_table,
out_file_name,
raster_band=1,
discrete=True):
#Reading the band
data_types = {
'Byte': 'B',
'UInt16': 'H',
'Int16': 'h',
'UInt32': 'I',
'Int32': 'i',
'Float32': 'f',
'Float64': 'd'
}
if os.path.isfile(raster_file) is False:
raise Exception('[Errno 2] No such file or directory: \'' +
raster_file + '\'')
dataset = gdal.Open(raster_file, gdal.GA_ReadOnly)
if dataset == None:
raise Exception("Unable to read the data file")
geoTransform = dataset.GetGeoTransform()
proj = dataset.GetProjection()
band = dataset.GetRasterBand(raster_band)
values = band.ReadRaster(0, 0, band.XSize, band.YSize, band.XSize,
band.YSize, band.DataType)
values = unpack(
data_types[gdal.GetDataTypeName(band.DataType)] * band.XSize *
band.YSize, values)
#Preparing the color table and the output file
classification_values = color_table.keys()
classification_values = sorted(classification_values)
base = Image.new('RGBA', (band.XSize, band.YSize))
base_draw = ImageDraw.Draw(base)
alpha_mask = Image.new('L', (band.XSize, band.YSize), 255)
alpha_draw = ImageDraw.Draw(alpha_mask)
#Reading the value and setting the output color for each pixel
for pos in range(len(values)):
y = pos / band.XSize
x = pos - y * band.XSize
for index in range(len(classification_values)):
if values[pos] <= classification_values[index] or index == len(
classification_values) - 1:
if discrete == True:
if index == 0:
index = 1
elif index == len(classification_values) - 1 and values[
pos] >= classification_values[index]:
index = index + 1
color = color_table[classification_values[index - 1]]
base_draw.point((x, y), (color[0], color[1], color[2]))
alpha_draw.point((x, y), color[3])
else:
if index == 0:
r = color_table[classification_values[0]][0]
g = color_table[classification_values[0]][1]
b = color_table[classification_values[0]][2]
a = color_table[classification_values[0]][3]
elif index == len(classification_values) - 1 and values[
pos] >= classification_values[index]:
r = color_table[classification_values[index]][0]
g = color_table[classification_values[index]][1]
b = color_table[classification_values[index]][2]
a = color_table[classification_values[index]][3]
else:
r = color_table[classification_values[index - 1]][0] + (
values[pos] - classification_values[index - 1]
) * (color_table[classification_values[index]][0] -
color_table[classification_values[index - 1]][0]
) / (classification_values[index] -
classification_values[index - 1])
g = color_table[classification_values[index - 1]][1] + (
values[pos] - classification_values[index - 1]
) * (color_table[classification_values[index]][1] -
color_table[classification_values[index - 1]][1]
) / (classification_values[index] -
classification_values[index - 1])
b = color_table[classification_values[index - 1]][2] + (
values[pos] - classification_values[index - 1]
) * (color_table[classification_values[index]][2] -
color_table[classification_values[index - 1]][2]
) / (classification_values[index] -
classification_values[index - 1])
a = color_table[classification_values[index - 1]][3] + (
values[pos] - classification_values[index - 1]
) * (color_table[classification_values[index]][3] -
color_table[classification_values[index - 1]][3]
) / (classification_values[index] -
classification_values[index - 1])
base_draw.point((x, y), (int(r), int(g), int(b)))
alpha_draw.point((x, y), int(a))
break
#Adding transparency and saving the output image
color_layer = Image.new('RGBA', base.size, (255, 255, 255, 0))
base = Image.composite(color_layer, base, alpha_mask)
base.save(out_file_name)
# update geolocation
ds_rgb = gdal.Open(out_file_name, 1)
ds_rgb.SetGeoTransform(geoTransform)
ds_rgb.SetProjection(proj)
ds_rgb.FlushCache()
ds_rgb = None
print(str(ulX) + "," + str(lrX))
print(str(lrY) + "," + str(ulY))
#Now cut out the pixels we want, and add them to a nice big csv file
xOffset = ulX
yOffset = ulY
xSize = lrX - ulX
ySize = ulY - lrY
#Output pixels to new raster file too - not doing this bit this time
newGeoTrans = list(geoTransform)
newGeoTrans[0] = minX
newGeoTrans[3] = maxY
band = dataset.GetRasterBand(1)
bandtype = gdal.GetDataTypeName(band.DataType)
btype = band.DataType
fmt = pt2fmt(btype)
print(bandtype)
csvoutfile = "GlobcoverTZA.csv"
fcsv = open(csvoutfile, 'wb')
rasteroutfile = "GlobcoverTZA.tif"
frast = open(rasteroutfile, 'wb')
csvout = csv.writer(fcsv, quoting=csv.QUOTE_NONNUMERIC)
for y in range(lrY, ulY):
scanline = band.ReadRaster(ulX, y, xSize, 1, xSize, 1, GDT_Float32)
row = struct.unpack('f' * xSize, scanline)
csvout.writerow([int(i) for i in row])
fcsv.close()
import gdal
import gdalconst
import numpy as np
import cv2
from scipy import ndimage, misc
import math
filename = 'satellite_imagery/20180206_074601_1033/20180206_074601_1033_3B_AnalyticMS.tif'
d = gdal.Open(filename, gdalconst.GA_ReadOnly)
geoTiffDataType = gdal.GetDataTypeName(d.GetRasterBand(1).DataType)
nC = d.RasterXSize
nR = d.RasterYSize
nB = d.RasterCount
#We've read it in using gdal, and now we will convert to a numpy array
im = np.zeros((nR, nC, nB), dtype=np.uint16)
for band in range(nB):
data = d.GetRasterBand(band + 1)
im[:, :, band] = data.ReadAsArray(0, 0, nC, nR)
#It's now a 16-bit numpy array. To display with OpenCV, normalize from 0 to 1 by dividing by max in im to get a float64 numpy array (OpenCV will either display uint8 images, 0 to 255, or it will display float64 images, 0 to 1)
src = im / im.max()
srccopy = (np.uint8)(src * 255)
# print(srccopy.shape)
width, height = srccopy.shape[0], srccopy.shape[1]
image_center = (width / 2, height / 2)
rotation_angle = 11.1
rotation_mat = cv2.getRotationMatrix2D(image_center, rotation_angle, 1)
def PiNo_classifier(infile, outfile, sat, detect_clouds, sun_azi,
fnorm_delta_val):
try:
print "INTO pino classifier"
start = time.time()
print infile
src_ds = gdal.Open(infile)
num_bands = src_ds.RasterCount
print infile
print "Bands:"
print num_bands
if (sat == "S2A_L1C" and (not num_bands == 13)):
src_ds = None
print "Input image does not have 13 bands" + "<br>"
return (-1)
DataType = src_ds.GetRasterBand(1).DataType
DataType = gdal.GetDataTypeName(DataType)
print "Type: " + DataType
if (DataType == "Byte"):
TOTmem = src_ds.RasterXSize * src_ds.RasterYSize * 8 / 1024 * 6 * 20
elif (DataType == "UInt16"):
TOTmem = src_ds.RasterXSize * src_ds.RasterYSize * 16 / 1024 * 6 * 20
else:
TOTmem = src_ds.RasterXSize * src_ds.RasterYSize * 32 / 1024 * 6 * 20
print TOTmem
res = UnixMemory()
FREEmem = res['free']
print FREEmem
if (FREEmem < TOTmem + (TOTmem / 100 * 20)):
print "Processing using tiling ..... " + "<br>"
ratio = int(round(TOTmem * Memory_Buffer / FREEmem * 1., ))
else:
ratio = 1
print "Ratio: " + str(ratio) + "<br>"
MaxX = src_ds.RasterXSize
MaxY = src_ds.RasterYSize
LenX = int(src_ds.RasterXSize / ratio)
LenY = int(src_ds.RasterYSize / ratio)
#print MaxX,MaxY
#print LenX,LenY
Xval = []
Yval = []
for x in range(1, ratio):
Xval.append(LenX * x)
Xval.append(MaxX)
for x in range(1, ratio):
Yval.append(LenY * x)
Yval.append(MaxY)
#print Xval
#print Yval
driver = gdal.GetDriverByName("GTiff")
print outfile
dst_ds = driver.Create(outfile,
src_ds.RasterXSize,
src_ds.RasterYSize,
1,
gdal.GDT_Byte,
options=['COMPRESS=LZW'])
dst_ds.GetRasterBand(1).SetRasterColorInterpretation(
gdal.GCI_PaletteIndex)
c = gdal.ColorTable()
ctable = [[0, (0, 0, 0)], [1, (255, 255, 255)], [2, (192, 242, 255)],
[3, (1, 255, 255)], [4, (0, 0, 0)], [5, (1, 1, 255)],
[6, (1, 123, 255)], [7,
(110, 150, 255)], [8, (168, 180, 255)],
[9, (160, 255, 90)], [10, (1, 80, 1)], [11, (12, 113, 1)],
[12, (1, 155, 1)],
[13, (100, 190, 90)], [14, (146, 255, 165)], [15, (0, 0, 0)],
[16, (210, 255, 153)], [17, (0, 0, 0)], [18, (0, 0, 0)],
[19, (0, 0, 0)], [20, (0, 0, 0)], [21, (237, 255, 193)],
[22, (200, 230, 200)], [23, (0, 0, 0)], [24, (0, 0, 0)],
[25, (0, 0, 0)], [26, (0, 0, 0)], [27, (0, 0, 0)],
[28, (0, 0, 0)], [29, (0, 0, 0)], [30, (200, 200, 150)],
[31, (227, 225, 170)], [32, (0, 0, 0)], [33, (0, 0, 0)],
[34, (255, 225, 255)], [35, (140, 5, 190)],
[36, (255, 1, 1)], [37, (0, 0, 0)], [38, (0, 0, 0)],
[39, (0, 0, 0)], [40, (20, 40, 10)], [41, (145, 1, 110)],
[42, (100, 100, 100)]]
for cid in range(0, 43):
c.SetColorEntry(cid, ctable[cid][1])
dst_ds.GetRasterBand(1).SetColorTable(c)
dst_ds.SetGeoTransform(src_ds.GetGeoTransform())
dst_ds.SetProjection(src_ds.GetProjectionRef())
print 'Setting out file ....'
OUTCLASS = dst_ds.GetRasterBand(1).ReadAsArray(0, 0,
dst_ds.RasterXSize,
dst_ds.RasterYSize)
print 'Processing <br>'
mytry = 0
#try:
if (1 == 1):
MinX = 0
MinY = 0
for x in range(0, len(Xval)):
for y in range(0, len(Yval)):
MaxX = Xval[x]
MaxY = Yval[y]
OUTCLASS[MinY:MaxY, MinX:MaxX] = classify_tile(
src_ds, MinX, MinY, MaxX, MaxY, sat, fnorm_delta_val,
DataType)
MinY = MaxY
MinX = MaxX
MinY = 0
dst_ds.GetRasterBand(1).WriteArray(OUTCLASS)
if (detect_clouds == 0):
OUTCLASS[(OUTCLASS == 1)] = 34
OUTCLASS[(OUTCLASS == 2)] = 34
else:
try:
dst_ds.GetRasterBand(1).WriteArray(
OUTCLASS
) # save temporary out so class is saved even on mask failure
filter = numpy.ndarray(shape=(17, 17), dtype=bool)
filter[:] = False
filter[0, 8] = True
filter[1, 7:9] = True
filter[2, 6:9] = True
filter[3, 5:10] = True
filter[4, 4:11] = True
filter[5, 3:12] = True
filter[6, 2:14] = True
filter[7, 2:14] = True
filter[8, 0:16] = True
filter[9, 2:14] = True
filter[10, 2:14] = True
filter[11, 3:12] = True
filter[12, 4:11] = True
filter[13, 5:10] = True
filter[14, 6:9] = True
filter[15, 7:9] = True
filter[16, 8] = True
BOOL_MATRIX = numpy.zeros(
(dst_ds.RasterXSize, dst_ds.RasterYSize)).astype(bool)
BOOL_MATRIX = (OUTCLASS == 1) + (OUTCLASS == 2)
#OUTCLASS[mmorph.close(BOOL_MATRIX,filter)]=1 # 3x3
#------------------------------------------------------------------------------------------
#-------------------------USE 3D filter for CL - SH detection -----------------------------
#------------------------------------------------------------------------------------------
if (int(sun_azi) > 0):
sft = getend([100, 100], 270 - int(sun_azi), 20)
shiftX = 100 - int(sft[0])
shiftY = 100 - int(sft[1])
BOOL_MATRIX = numpy.roll(BOOL_MATRIX, shiftX, axis=0)
BOOL_MATRIX = numpy.roll(BOOL_MATRIX, shiftY, axis=1)
print "Cloud masking step 1" + "<br>"
SHDW_MATRIX = ((OUTCLASS == 10) + (OUTCLASS == 40) +
(OUTCLASS == 41) + (OUTCLASS == 42) +
(OUTCLASS == 34) + (OUTCLASS == 35) +
(OUTCLASS == 36) + (OUTCLASS == 4) +
(OUTCLASS == 5) + (OUTCLASS == 6) +
(OUTCLASS == 7) +
(OUTCLASS == 8)).astype(bool)
SHDW_MATRIX *= BOOL_MATRIX
print "Cloud masking step 2" + "<br>"
#OUTCLASS[mmorph.close(SHDW_MATRIX,filter)]=42
print "Cloud masking step 3" + "<br>"
except:
print "Image is TOO BIG for morphological filters <br>"
dst_ds.GetRasterBand(1).WriteArray(OUTCLASS)
#close roperly the dataset
dst_ds = None
src_ds = None
print "Execution time: " + str(time.time() - start) + "<br>"
return 'Complete' + "<br>"
except Exception, e:
print "Error :"
print str(e)
def read_band(dataset: gdal.Dataset,
bnd_ndx: int = 1) -> Tuple[dict, 'np.array']:
"""
Read data and metadata of a rasters band based on GDAL.
:param dataset: the source raster dataset
:type dataset: gdal.Dataset
:param bnd_ndx: the index of the band (starts from 1)
:type bnd_ndx: int
:return: the band parameters and the data values
:rtype: dict of data parameters and values as a numpy.array
:raises: RasterIOException
Examples:
"""
band = dataset.GetRasterBand(bnd_ndx)
data_type = gdal.GetDataTypeName(band.DataType)
unit_type = band.GetUnitType()
stats = band.GetStatistics(False, False)
if stats is None:
dStats = dict(min=None, max=None, mean=None, std_dev=None)
else:
dStats = dict(min=stats[0],
max=stats[1],
mean=stats[2],
std_dev=stats[3])
noDataVal = band.GetNoDataValue()
nOverviews = band.GetOverviewCount()
colorTable = band.GetRasterColorTable()
if colorTable:
nColTableEntries = colorTable.GetCount()
else:
nColTableEntries = 0
# read data from band
grid_values = band.ReadAsArray()
if grid_values is None:
raise RasterIOException("Unable to read data from rasters")
# transform data into numpy array
data = np.asarray(grid_values)
# if nodatavalue exists, set null values to NaN in numpy array
if noDataVal is not None:
data = np.where(abs(data - noDataVal) > 1e-10, data, np.NaN)
band_params = dict(dataType=data_type,
unitType=unit_type,
stats=dStats,
noData=noDataVal,
numOverviews=nOverviews,
numColorTableEntries=nColTableEntries)
return band_params, data
def setup_playing(self, *args):
if self.view is not None:
self.tool.deactivate(self.view)
for view in self.app.view_manager.view_list:
if view.title == self.viewtitle:
self.app.view_manager.set_active_view(view)
self.view = view.viewarea
self.tool.activate(self.view)
self.tool.register_view(self.second_view, 0, 1,
self.trail_menu.get_history())
self.tool.set_trail_color(self.second_view,
self.trail_color.current_color[0],
self.trail_color.current_color[1],
self.trail_color.current_color[2],
self.trail_color.current_color[3])
# update the secondary view with a background raster
plyr = self.view.active_layer()
rst = None
ds = None
try:
rst = plyr.get_parent()
ds = rst.get_dataset()
except:
llist = self.view.list_layers()
llist.reverse()
for plyr in llist:
try:
rst = plyr.get_parent()
ds = rst.get_dataset()
break
except:
pass
if ds is None:
gvutils.error('Error- no raster to pan over in active view!')
return
dtype = gdal.GetDataTypeName(ds.GetRasterBand(1).DataType)
xsize = ds.RasterXSize
ysize = ds.RasterYSize
while (xsize > 512) and (ysize > 512):
xsize = xsize / 2
ysize = ysize / 2
srcrect = [0, 0, ds.RasterXSize, ds.RasterYSize]
dstrect = [0, 0, xsize, ysize]
vrt = vrtutils.VRTDatasetConstructor(xsize, ysize)
fname = ds.GetDescription()
lyrs = self.second_view.list_layers()
for lyr in lyrs:
self.second_view.remove_layer(lyr)
gcps = ds.GetGCPs()
if len(gcps) > 0:
vrt.SetGCPs(gcps, ds.GetGCPProjection(), None, srcrect, dstrect)
else:
gt = ds.GetGeoTransform()
if gt != (0.0, 1.0, 0.0, 0.0, 0.0, 1.0):
vrt.SetSRS(ds.GetProjection())
vrt.SetGeoTransform(gt, srcrect, dstrect, 1)
for idx in range(0, plyr.sources):
rst = plyr.get_data(idx)
if rst is not None:
cmin = plyr.min_get(idx)
cmax = plyr.max_get(idx)
srcdiff = cmax - cmin
if abs(srcdiff) > 0.0:
ratio = 255 / srcdiff
else:
ratio = 1.0
offset = -cmin * ratio
vrt.AddSimpleBand(fname,
rst.get_band_number(),
dtype,
srcrect,
dstrect,
ScaleOffset=offset,
ScaleRatio=ratio)
ds2 = gview.manager.get_dataset(vrt.GetVRTString())
raster = gview.manager.get_dataset_raster(ds2, 1)
options = []
if (ds2.RasterCount == 1):
raster_layer = gview.GvRasterLayer(raster,
options,
rl_mode=gview.RLM_AUTO)
else:
raster_layer = gview.GvRasterLayer(raster,
options,
rl_mode=gview.RLM_RGBA)
if (raster_layer.get_mode() == gview.RLM_RGBA):
green_raster = gview.manager.get_dataset_raster(ds2, 2)
raster_layer.set_source(1, green_raster)
if (ds2.RasterCount > 2):
blue_raster = \
gview.manager.get_dataset_raster( ds2, 3 )
raster_layer.set_source(2, blue_raster)
if (ds2.RasterCount > 3):
band = ds2.GetRasterBand(4)
if (band.GetRasterColorInterpretation() ==
gdal.GCI_AlphaBand):
raster_layer.blend_mode_set(gview.RL_BLEND_FILTER)
alpha_raster = \
gview.manager.get_dataset_raster( ds2, 4 )
raster_layer.set_source(3, alpha_raster)
self.second_view.add_layer(raster_layer)
self.active = 1
xmin, ymin, xmax, ymax = self.view.get_extents()
xwidth = xmax - xmin
ywidth = ymax - ymin
self.ext = (xmin, ymin, xwidth, ywidth)
self.tool.set_extents((xmin, ymin, xwidth, ywidth))
self.playing = 1
self.tool.set_speed(self.speed)
self.block_size_changed()
self.overlap_changed()
self.tool.play()
def processAlgorithm(self, parameters, context, feedback):
pasta = self.parameterAsFile(parameters, self.FOLDER, context)
if not pasta:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.FOLDER))
subpasta = self.parameterAsBool(parameters, self.SUBFOLDER, context)
formato = self.parameterAsString(parameters, self.FORMAT, context)
geometria = self.parameterAsEnum(parameters, self.GEOMETRY, context)
crs = self.parameterAsCrs(parameters, self.CRS, context)
# OUTPUT
GeomType = QgsWkbTypes.Point if geometria == 1 else QgsWkbTypes.Polygon
Fields = QgsFields()
itens = {
self.tr('name', 'nome'): QVariant.String,
self.tr('extension', 'extensão'): QVariant.String,
self.tr('path', 'caminho'): QVariant.String,
self.tr('resX'): QVariant.Double,
self.tr('resY'): QVariant.Double,
self.tr('n_cols'): QVariant.Int,
self.tr('n_rows', 'n_lin'): QVariant.Int,
self.tr('crs', 'src'): QVariant.String,
self.tr('n_bands', 'n_bandas'): QVariant.Int,
self.tr('dataType', 'tipoDado'): QVariant.String,
}
for item in itens:
Fields.append(QgsField(item, itens[item]))
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT,
context, Fields, GeomType, crs)
if sink is None:
raise QgsProcessingException(
self.invalidSinkError(parameters, self.OUTPUT))
# Listar Arquivos
feedback.pushInfo(
self.tr('Checking files in the folder...',
'Checando arquivos na pasta...'))
lista = []
if subpasta:
for root, dirs, files in os.walk(pasta, topdown=True):
for name in files:
if name[-1 * len(formato):] == formato:
lista += [os.path.join(root, name)]
else:
for item in os.listdir(pasta):
if item[-1 * len(formato):] == formato:
lista += [os.path.join(pasta, item)]
total = 100.0 / len(lista) if len(lista) > 0 else 0
# Obter dados dos arquivos listados
feedback.pushInfo(
self.tr('Creating raster files...',
'Criando inventário de arquivos raster...'))
for current, file_path in enumerate(lista):
image = gdal.Open(file_path) # https://gdal.org/python/
prj = image.GetProjection() # wkt
ulx, xres, xskew, uly, yskew, yres = image.GetGeoTransform()
GDT = image.GetRasterBand(1).DataType
n_bands = image.RasterCount
cols = image.RasterXSize # Number of columns
rows = image.RasterYSize # Number of rows
CRS = QgsCoordinateReferenceSystem(prj) # Create CRS
image = None # Close image
# Creating BBox
coord = [[
QgsPointXY(ulx, uly),
QgsPointXY(ulx + cols * xres, uly),
QgsPointXY(ulx + cols * xres, uly + rows * yres),
QgsPointXY(ulx, uly + rows * yres),
QgsPointXY(ulx, uly)
]]
geom = QgsGeometry.fromPolygonXY(coord)
# CRS transformation
coordinateTransformer = QgsCoordinateTransform()
coordinateTransformer.setDestinationCrs(crs)
coordinateTransformer.setSourceCrs(CRS)
geom_transf = self.reprojectPoints(geom, coordinateTransformer)
# Attributes
path, file = os.path.split(file_path)
name = os.path.splitext(file)[0]
extension = os.path.splitext(file)[1]
att = [
name, extension, path,
abs(xres),
abs(yres), cols, rows,
CRS.description(), n_bands,
gdal.GetDataTypeName(GDT)
]
# Saving feature
feat = QgsFeature()
feat.setGeometry(geom_transf.centroid()
) if geometria == 1 else feat.setGeometry(
geom_transf) # centroid or polygon
feat.setAttributes(att)
sink.addFeature(feat, QgsFeatureSink.FastInsert)
if feedback.isCanceled():
break
feedback.setProgress(int((current + 1) * total))
feedback.pushInfo(
self.tr('Operation completed successfully!',
'Operação finalizada com sucesso!'))
feedback.pushInfo('Leandro França - Eng Cart')
return {self.OUTPUT: dest_id}
def loadsetclone(name):
"""
load the maskmap and set as clone
:param name: name of mask map, can be a file or - row col cellsize xupleft yupleft -
"""
#if checkOption('PCRaster'): from pcraster.framework import *
warnings.filterwarnings("ignore")
if checkOption('PCRaster'): from pcraster.framework import pcraster
filename = cbinding(name)
#print("I m here")
#print(filename)
coord = filename.split()
#print(coord)
if len(coord) == 5:
# changed order of x, y i- in setclone y is first in CWATM
# settings x is first
# setclone row col cellsize xupleft yupleft
# retancle: Number of Cols, Number of rows, cellsize, upper left corner X, upper left corner Y
if checkOption('PCRaster'):
pcraster.setclone(int(coord[1]), int(coord[0]), float(coord[2]),
float(coord[3]), float(coord[4]))
mapnp = np.ones((int(coord[1]), int(coord[0])))
setmaskmapAttr(float(coord[3]), float(coord[4]), int(coord[0]),
int(coord[1]), float(coord[2]))
#mapnp[mapnp == 0] = 1
#map = numpy2pcr(Boolean, mapnp, -9999)
elif len(coord) == 1:
try:
# try to read a pc raster map
pcraster.setclone(filename)
map = pcraster.boolean(pcraster.readmap(filename))
flagmap = True
mapnp = pcraster.pcr2numpy(map, np.nan)
# Definition of cellsize, coordinates of the meteomaps and maskmap
# need some love for error handling
setmaskmapAttr(pcraster.clone().west(),
pcraster.clone().north(),
pcraster.clone().nrCols(),
pcraster.clone().nrRows(),
pcraster.clone().cellSize())
except:
filename = os.path.splitext(cbinding(name))[0] + '.nc'
try:
nf1 = Dataset(filename, 'r')
value = nf1.variables.items()[-1][
0] # get the last variable name
#x1 = nf1.variables.values()[0][0]
#x2 = nf1.variables.values()[0][1]
#xlast = nf1.variables.values()[0][-1]
x1 = nf1.variables['lon'][0]
x2 = nf1.variables['lon'][1]
xlast = nf1.variables['lon'][-1]
y1 = nf1.variables['lat'][0]
ylast = nf1.variables['lat'][-1]
# swap to make y1 the biggest number
if y1 < ylast:
y1, ylast = ylast, y1
cellSize = np.abs(x2 - x1)
invcell = round(1 / cellSize)
nrRows = int(0.5 + np.abs(ylast - y1) * invcell + 1)
nrCols = int(0.5 + np.abs(xlast - x1) * invcell + 1)
x = x1 - cellSize / 2
y = y1 + cellSize / 2
mapnp = np.array(nf1.variables[value][0:nrRows, 0:nrCols])
nf1.close()
setmaskmapAttr(x, y, nrCols, nrRows, cellSize)
# setclone row col cellsize xupleft yupleft
if checkOption('PCRaster'):
pcraster.setclone(maskmapAttr['row'], maskmapAttr['col'],
maskmapAttr['cell'], maskmapAttr['x'],
maskmapAttr['y'])
#map = numpy2pcr(Boolean, mapnp, 0)
flagmap = True
except:
# load geotiff
try:
filename = cbinding(name)
nf2 = gdal.Open(filename, GA_ReadOnly)
geotransform = nf2.GetGeoTransform()
setmaskmapAttr(geotransform[0], geotransform[3],
nf2.RasterXSize, nf2.RasterYSize,
geotransform[1])
band = nf2.GetRasterBand(1)
bandtype = gdal.GetDataTypeName(band.DataType)
mapnp = band.ReadAsArray(0, 0, nf2.RasterXSize,
nf2.RasterYSize)
mapnp[mapnp > 1] = 0
if checkOption('PCRaster'):
pcraster.setclone(maskmapAttr['row'],
maskmapAttr['col'],
maskmapAttr['cell'],
maskmapAttr['x'], maskmapAttr['y'])
#map = numpy2pcr(Boolean, mapnp, 0)
flagmap = True
except:
raise CWATMFileError(filename, sname=name)
if Flags['check']:
checkmap(name, filename, map, flagmap, 0)
else:
msg = "Maskmap: " + filename + \
" is not a valid mask map nor valid coordinates"
raise CWATMError(msg)
# put in the ldd map
# if there is no ldd at a cell, this cell should be excluded from modelling
#ldd = loadmap('Ldd',pcr=True)
#maskldd = pcr2numpy(ldd,np.nan)
maskldd = loadmap('Ldd', compress=False)
maskarea = np.bool8(mapnp)
mask = np.logical_not(np.logical_and(maskldd, maskarea))
# mask=np.isnan(mapnp)
# mask[mapnp==0] = True # all 0 become mask out
mapC = np.ma.compressed(np.ma.masked_array(mask, mask))
# Definition of compressed array and info how to blow it up again
maskinfo['mask'] = mask
maskinfo['shape'] = mask.shape
maskinfo['maskflat'] = mask.ravel() # map to 1D not compresses
maskinfo['shapeflat'] = maskinfo['maskflat'].shape #length of the 1D array
maskinfo['mapC'] = mapC.shape # length of the compressed 1D array
maskinfo['maskall'] = np.ma.masked_all(
maskinfo['shapeflat']) # empty map 1D but with mask
maskinfo['maskall'].mask = maskinfo['maskflat']
globals.inZero = np.zeros(maskinfo['mapC'])
return mapC
def get_attributes_from_file(self, srcfp):
self.srcfp = srcfp
self.srcdir, self.srcfn = os.path.split(srcfp)
ds = gdal.Open(self.srcfp)
if ds is not None:
self.xsize = ds.RasterXSize
self.ysize = ds.RasterYSize
self.proj = ds.GetProjectionRef(
) if ds.GetProjectionRef() != '' else ds.GetGCPProjection()
self.bands = ds.RasterCount
self.nodatavalue = [
ds.GetRasterBand(b).GetNoDataValue()
for b in list(range(1, self.bands + 1))
]
self.datatype = ds.GetRasterBand(1).DataType
self.datatype_readable = gdal.GetDataTypeName(self.datatype)
gtf = ds.GetGeoTransform()
num_gcps = ds.GetGCPCount()
if num_gcps == 0:
self.xres = abs(gtf[1])
self.yres = abs(gtf[5])
ulx = gtf[0] + 0 * gtf[1] + 0 * gtf[2]
uly = gtf[3] + 0 * gtf[4] + 0 * gtf[5]
urx = gtf[0] + self.xsize * gtf[1] + 0 * gtf[2]
ury = gtf[3] + self.xsize * gtf[4] + 0 * gtf[5]
llx = gtf[0] + 0 * gtf[1] + self.ysize * gtf[2]
lly = gtf[3] + 0 * gtf[4] + self.ysize * gtf[5]
lrx = gtf[0] + self.xsize * gtf[1] + self.ysize * gtf[2]
lry = gtf[3] + self.xsize * gtf[4] + self.ysize * gtf[5]
elif num_gcps == 4:
gcps = ds.GetGCPs()
gcp_dict = {}
id_dict = {
"UpperLeft": 1,
"1": 1,
"UpperRight": 2,
"2": 2,
"LowerLeft": 4,
"4": 4,
"LowerRight": 3,
"3": 3
}
for gcp in gcps:
gcp_dict[id_dict[gcp.Id]] = [
float(gcp.GCPPixel),
float(gcp.GCPLine),
float(gcp.GCPX),
float(gcp.GCPY),
float(gcp.GCPZ)
]
ulx = gcp_dict[1][2]
uly = gcp_dict[1][3]
urx = gcp_dict[2][2]
ury = gcp_dict[2][3]
llx = gcp_dict[4][2]
lly = gcp_dict[4][3]
lrx = gcp_dict[3][2]
lry = gcp_dict[3][3]
self.xres = abs(
math.sqrt((ulx - urx)**2 + (uly - ury)**2) / self.xsize)
self.yres = abs(
math.sqrt((ulx - llx)**2 + (uly - lly)**2) / self.ysize)
poly_wkt = 'POLYGON (( {0:.12f} {1:.12f}, {2:.12f} {3:.12f}, {4:.12f} {5:.12f}, {6:.12f} {7:.12f}, ' \
'{0:.12f} {1:.12f} ))'.format(ulx, uly, urx, ury, lrx, lry, llx, lly)
self.geom = ogr.CreateGeometryFromWkt(poly_wkt)
self.xs = [ulx, urx, lrx, llx]
self.ys = [uly, ury, lry, lly]
else:
logger.warning("Cannot open image: %s", self.srcfp)
self.xsize = None
self.ysize = None
self.proj = None
self.bands = None
self.datatype = None
self.datatype_readable = None
self.xres = None
self.yres = None
ds = None
#### Set unknown attribs to None for now
self.sataz = None
self.satel = None
self.sunaz = None
self.sunel = None
self.ona = None
self.cloudcover = None
self.sensor = None
self.scene_id = None
self.catid = None
self.tdi = None
self.acqdate = None
def mt_metrics(rasterfn,newRasterfn):
# open raster file
raster3d = gdal.Open(rasterfn)
# Get blocksizes for iterating over tiles (chuuks)
myBlockSize=raster3d.GetRasterBand(1).GetBlockSize();
x_block_size = myBlockSize[0]
y_block_size = myBlockSize[1]
# Get image sizes
cols = raster3d.RasterXSize
rows = raster3d.RasterYSize
# get datatype and transform to numpy readable
data_type = raster3d.GetRasterBand(1).DataType
data_type_name = gdal.GetDataTypeName(data_type)
if data_type_name == "Byte":
data_type_name = "uint8"
print " INFO: Importing", raster3d.RasterCount, "bands from", rasterfn
band=raster3d.GetRasterBand(1)
geotransform = raster3d.GetGeoTransform()
originX = geotransform[0]
originY = geotransform[3]
pixelWidth = geotransform[1]
pixelHeight = geotransform[5]
driver = gdal.GetDriverByName('GTiff')
# we need this for file creation
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromWkt(raster3d.GetProjectionRef())
# we will need this to create the output just once
k = 1
# loop through y direction
for y in range(0, rows, y_block_size):
if y + y_block_size < rows:
ysize = y_block_size
else:
ysize = rows - y
# loop throug x direction
for x in range(0, cols, x_block_size):
if x + x_block_size < cols:
xsize = x_block_size
else:
xsize = cols - x
# create the blocksized array
stacked_array=np.empty((raster3d.RasterCount, ysize, xsize), dtype=data_type_name) # change fixed uint16 with numpy datatype
# loop through the timeseries and fill the stacked array part
for i in range( raster3d.RasterCount ):
i += 0
stacked_array[i,:,:] = np.array(raster3d.GetRasterBand(i+1).ReadAsArray(x,y,xsize,ysize))
#mask = np.greater(0, stacked_array)
#masked_stack = ma.masked_array(stacked_array, mask)
# loop through the metrics
# create a vector of measures
metrics = ["avg", "max", "min", "std", "cov" ]
#metrics = ["mean", "maximum", "minimum", "stddev", "cov" , "skewness", "kurtosis", "argmin", "argmax", "median", "nth moment"]
for metric in metrics:
# calculate the specific metric
if metric == "avg":
if k == 1:
outRaster_avg = driver.Create(newRasterfn + ".avg.tif", cols, rows, 1, data_type,
options=[ # Format-specific creation options.
'TILED=YES',
'BIGTIFF=IF_SAFER',
'BLOCKXSIZE=256', # must be a power of 2
'BLOCKYSIZE=256', # also power of 2, need not match BLOCKXSIZEBLOCKXSIZE
'COMPRESS=LZW'
] )
outRaster_avg.SetGeoTransform((originX, pixelWidth, 0, originY, 0, pixelHeight))
outband_avg = outRaster_avg.GetRasterBand(1)
outRaster_avg.SetProjection(outRasterSRS.ExportToWkt())
outmetric = np.mean(stacked_array, axis=0)
outband_avg.WriteArray(outmetric, x, y)
elif metric == "max":
if k == 1:
outRaster_max = driver.Create(newRasterfn + ".max.tif", cols, rows, 1, data_type,
options=[ # Format-specific creation options.
'TILED=YES',
'BIGTIFF=IF_SAFER',
'BLOCKXSIZE=256', # must be a power of 2
'BLOCKYSIZE=256', # also power of 2, need not match BLOCKXSIZEBLOCKXSIZE
'COMPRESS=LZW'
] )
outRaster_max.SetGeoTransform((originX, pixelWidth, 0, originY, 0, pixelHeight))
outband_max = outRaster_max.GetRasterBand(1)
outRaster_max.SetProjection(outRasterSRS.ExportToWkt())
outmetric = np.max(stacked_array, axis=0)
outband_max.WriteArray(outmetric, x, y)
elif metric == "min":
if k == 1:
outRaster_min = driver.Create(newRasterfn + ".min.tif", cols, rows, 1, data_type,
options=[ # Format-specific creation options.
'TILED=YES',
'BIGTIFF=IF_SAFER',
'BLOCKXSIZE=256', # must be a power of 2
'BLOCKYSIZE=256', # also power of 2, need not match BLOCKXSIZEBLOCKXSIZE
'COMPRESS=LZW'
] )
outRaster_min.SetGeoTransform((originX, pixelWidth, 0, originY, 0, pixelHeight))
outband_min = outRaster_min.GetRasterBand(1)
outRaster_min.SetProjection(outRasterSRS.ExportToWkt())
outmetric = np.min(stacked_array, axis=0)
outband_min.WriteArray(outmetric, x, y)
elif metric == "std":
if k == 1:
outRaster_std = driver.Create(newRasterfn + ".std.tif", cols, rows, 1, data_type,
options=[ # Format-specific creation options.
'TILED=YES',
'BIGTIFF=IF_SAFER',
'BLOCKXSIZE=256', # must be a power of 2
'BLOCKYSIZE=256', # also power of 2, need not match BLOCKXSIZEBLOCKXSIZE
'COMPRESS=LZW'
] )
outRaster_std.SetGeoTransform((originX, pixelWidth, 0, originY, 0, pixelHeight))
outband_std = outRaster_std.GetRasterBand(1)
outRaster_std.SetProjection(outRasterSRS.ExportToWkt())
outmetric = np.std(stacked_array, axis=0)
outband_std.WriteArray(outmetric, x, y)
elif metric == "cov":
if k == 1:
outRaster_cov = driver.Create(newRasterfn + ".cov.tif", cols, rows, 1, data_type,
options=[ # Format-specific creation options.
'TILED=YES',
'BIGTIFF=IF_SAFER',
'BLOCKXSIZE=256', # must be a power of 2
'BLOCKYSIZE=256', # also power of 2, need not match BLOCKXSIZEBLOCKXSIZE
'COMPRESS=LZW'
] )
outRaster_cov.SetGeoTransform((originX, pixelWidth, 0, originY, 0, pixelHeight))
outband_cov = outRaster_cov.GetRasterBand(1)
outRaster_cov.SetProjection(outRasterSRS.ExportToWkt())
outmetric = scipy.stats.variation(stacked_array, axis=0)
outband_cov.WriteArray(outmetric, x, y)
# counter to write the outbup just once
k = k + 1
def create_gui(self):
self.dict_of_bands = get_list_of_bands_as_dict()
if self.dict_of_bands is None:
raise TypeError
self.list_of_bands = self.dict_of_bands.keys()
self.list_of_bands.sort()
title_width = 120
box1 = GtkVBox(spacing=10)
box1.set_border_width(10)
self.add(box1)
box1.show()
box2 = GtkVBox(spacing=5)
box2.set_border_width(5)
box1.pack_start(box2)
box2.show()
self.expression_unit = GtkEntry()
self.expression_unit.set_text(self.expression)
self.expression_unit.connect("changed", self.expression_edit_cb)
box2.pack_start(self.expression_unit)
self.expression_unit.show()
box3 = GtkHBox(spacing=5)
box1.pack_start(box3)
box3.show()
#####
funcbox = GtkVBox(spacing=5)
funcbox.set_border_width(10)
box3.pack_start(funcbox)
funcbox.show()
fg_list = ["Mathematics", "Bit Operations", "Trigionometry", "Special"]
self.fun_group_list = gvutils.GvOptionMenu(fg_list, self.group_changed)
funcbox.pack_start(self.fun_group_list, expand=FALSE)
self.mathematics_group(funcbox)
self.bit_operations_group(funcbox)
self.trigonometry_group(funcbox)
self.special_funcs_group(funcbox)
#####
digitbox = GtkVBox(spacing=10)
digitbox.set_border_width(10)
box3.pack_start(digitbox)
digitbox.show()
digit_table = GtkTable(5, 5)
digit_table.set_border_width(5)
digit_table.set_row_spacings(5)
digit_table.set_col_spacings(5)
digitbox.pack_start(digit_table)
digit_table.show()
btn = GtkButton("Back")
btn.connect("clicked", self.back_button_pressed)
digit_table.attach(btn, 1, 3, 0, 1)
btn = GtkButton("C")
btn.connect("clicked", self.clear_button_pressed)
digit_table.attach(btn, 3, 5, 0, 1)
btn = GtkButton("7")
btn.connect("clicked", self.button_pressed, "7")
digit_table.attach(btn, 0, 1, 1, 2)
btn = GtkButton("8")
btn.connect("clicked", self.button_pressed, "8")
digit_table.attach(btn, 1, 2, 1, 2)
btn = GtkButton("9")
btn.connect("clicked", self.button_pressed, "9")
digit_table.attach(btn, 2, 3, 1, 2)
btn = GtkButton(" / ")
btn.connect("clicked", self.button_pressed, "/")
digit_table.attach(btn, 3, 4, 1, 2)
btn = GtkButton("(")
btn.connect("clicked", self.button_pressed, "(")
digit_table.attach(btn, 4, 5, 1, 2)
btn = GtkButton("4")
btn.connect("clicked", self.button_pressed, "4")
digit_table.attach(btn, 0, 1, 2, 3)
btn = GtkButton("5")
btn.connect("clicked", self.button_pressed, "5")
digit_table.attach(btn, 1, 2, 2, 3)
btn = GtkButton("6")
btn.connect("clicked", self.button_pressed, "6")
digit_table.attach(btn, 2, 3, 2, 3)
btn = GtkButton("*")
btn.connect("clicked", self.button_pressed, "*")
digit_table.attach(btn, 3, 4, 2, 3)
btn = GtkButton(")")
btn.connect("clicked", self.button_pressed, ")")
digit_table.attach(btn, 4, 5, 2, 3)
btn = GtkButton("1")
btn.connect("clicked", self.button_pressed, "1")
digit_table.attach(btn, 0, 1, 3, 4)
btn = GtkButton("2")
btn.connect("clicked", self.button_pressed, "2")
digit_table.attach(btn, 1, 2, 3, 4)
btn = GtkButton("3")
btn.connect("clicked", self.button_pressed, "3")
digit_table.attach(btn, 2, 3, 3, 4)
btn = GtkButton("-")
btn.connect("clicked", self.button_pressed, "-")
digit_table.attach(btn, 3, 4, 3, 4)
btn = GtkButton("End")
btn.connect("clicked", self.end_button_pressed)
digit_table.attach(btn, 4, 5, 3, 4)
btn = GtkButton("0")
btn.connect("clicked", self.button_pressed, "0")
digit_table.attach(btn, 0, 1, 4, 5)
btn = GtkButton(",")
btn.connect("clicked", self.button_pressed, ",")
digit_table.attach(btn, 1, 2, 4, 5)
btn = GtkButton(".")
btn.connect("clicked", self.button_pressed, ".")
digit_table.attach(btn, 2, 3, 4, 5)
btn = GtkButton("+")
btn.connect("clicked", self.button_pressed, "+")
digit_table.attach(btn, 3, 4, 4, 5)
btn = GtkButton("=")
btn.connect("clicked", self.compute)
digit_table.attach(btn, 4, 5, 4, 5)
#####
rastersbox = GtkVBox(spacing=5)
box1.pack_start(rastersbox)
rastersbox.show()
### source list #############################################################
frame1 = GtkFrame("Select Image Bands To Compute")
frame1.show()
box1.pack_start(frame1, expand=FALSE)
box2r = GtkVBox(spacing=10)
box2r.set_border_width(10)
frame1.add(box2r)
box2r.show()
self.s1_list = \
gvutils.GvOptionMenu(self.list_of_bands, self.raster_selected_cb)
box2r.pack_start(self.s1_list)
self.s1_list.set_history(-1)
self.s1_list.show()
##### OUT TYPES #########################################################
box_types = GtkHBox(spacing=10)
box2r.pack_start(box_types)
box_types.show()
types_label = GtkLabel('Image Data Type:')
types_label.set_alignment(0, 0.5)
box_types.pack_start(types_label, expand=FALSE)
self.types_list = []
i = GDT_Byte
while i < GDT_TypeCount:
self.types_list.append(gdal.GetDataTypeName(i))
i += 1
self.types = gvutils.GvOptionMenu(self.types_list)
box_types.pack_start(self.types)
self.types.show()
#### NEW VIEW ##########################################################
self.switch_new_view = GtkCheckButton("Create New View")
box1.pack_start(self.switch_new_view)
self.switch_new_view.show()
return TRUE
def replaceValues(rasterfn, newRasterfn, repValue, newValue):
# open raster file
raster3d = gdal.Open(rasterfn)
# Get blocksizes for iterating over tiles (chuuks)
myBlockSize = raster3d.GetRasterBand(1).GetBlockSize()
x_block_size = myBlockSize[0]
y_block_size = myBlockSize[1]
# Get image sizes
cols = raster3d.RasterXSize
rows = raster3d.RasterYSize
# get datatype and transform to numpy readable
data_type = raster3d.GetRasterBand(1).DataType
data_type_name = gdal.GetDataTypeName(data_type)
if data_type_name == "Byte":
data_type_name = "uint8"
band = raster3d.GetRasterBand(1)
geotransform = raster3d.GetGeoTransform()
originX = geotransform[0]
originY = geotransform[3]
pixelWidth = geotransform[1]
pixelHeight = geotransform[5]
driver = gdal.GetDriverByName('GTiff')
# we need this for file creation
outRasterSRS = osr.SpatialReference()
outRasterSRS.ImportFromWkt(raster3d.GetProjectionRef())
outRaster = driver.Create(
newRasterfn,
cols,
rows,
1,
data_type,
options=[ # Format-specific creation options.
'BIGTIFF=IF_SAFER',
'BLOCKXSIZE=' + str(cols), # must be a power of 2
'BLOCKYSIZE=1' # also power of 2, need not match BLOCKXSIZEBLOCKXSIZE
#'COMPRESS=LZW'
#'TILED=YES'#,
])
outRaster.SetGeoTransform(
(originX, pixelWidth, 0, originY, 0, pixelHeight))
outband = outRaster.GetRasterBand(1)
outRaster.SetProjection(outRasterSRS.ExportToWkt())
# loop through y direction
for y in range(0, rows, y_block_size):
if y + y_block_size < rows:
ysize = y_block_size
else:
ysize = rows - y
# loop throug x direction
for x in range(0, cols, x_block_size):
if x + x_block_size < cols:
xsize = x_block_size
else:
xsize = cols - x
# create the blocksized array
#stacked_array=np.empty((raster3d.RasterCount, ysize, xsize), dtype=data_type_name)
rasterArray = np.array(band.ReadAsArray(x, y, xsize, ysize))
rasterArray[rasterArray == np.float32(repValue)] = np.float32(
newValue)
outband.WriteArray(rasterArray, x, y)
def gdal_calc(calculation,
raster_output,
rasters,
bands=None,
nodata=None,
allBands=False,
output_type=None,
format='GTiff'):
"""
Adopted from GDAL 1.10 gdal_calc.py script.
:param calculation: equation to calculate, such as A + (B / 2)
:param raster_output: Raster file to save output as
:param rasters: array of rasters, should equal # of letters in calculation
:param bands: array of band numbers, one for each raster in rasters array
:param nodata: NoDataValue to use in output raster
:param allBands: use all bands of specified raster by index
:param output_type: data type for output raster ('Float32', 'Uint16', etc)
:return: gdal Dataset
"""
calculation = re.sub(r'(logical_|bitwise_)', r'numpy.\1', calculation)
# set up some lists to store data for each band
datasets = [get_dataset(raster) for raster in rasters]
if not bands:
bands = [1 for raster in rasters]
datatypes = []
datatype_nums = []
nodata_vals = []
dimensions = None
alpha_list = string.ascii_uppercase[:len(rasters)]
# loop through input files - checking dimensions
for i, (raster, alpha, band) in enumerate(zip(datasets, alpha_list,
bands)):
raster_band = raster.GetRasterBand(band)
datatypes.append(gdal.GetDataTypeName(raster_band.DataType))
datatype_nums.append(raster_band.DataType)
nodata_vals.append(raster_band.GetNoDataValue())
# check that the dimensions of each layer are the same as the first
if dimensions:
if dimensions != [
datasets[i].RasterXSize, datasets[i].RasterYSize
]:
datasets[i] = gdal_resize(raster, dimensions,
datasets[0].GetProjection(),
datasets[0].GetGeoTransform())
else:
dimensions = [datasets[0].RasterXSize, datasets[0].RasterYSize]
# process allBands option
allbandsindex = None
allbandscount = 1
if allBands:
allbandscount = datasets[allbandsindex].RasterCount
if allbandscount <= 1:
allbandsindex = None
################################################################
# set up output file
################################################################
# open output file exists
# remove existing file and regenerate
if os.path.isfile(raster_output):
os.remove(raster_output)
# create a new file
logger.debug("Generating output file %s" % (raster_output))
# find data type to use
if not output_type:
# use the largest type of the input files
output_type = gdal.GetDataTypeName(max(datatype_nums))
# create file
output_driver = gdal.GetDriverByName('MEM')
output_dataset = output_driver.Create('', dimensions[0], dimensions[1],
allbandscount,
gdal.GetDataTypeByName(output_type))
# set output geo info based on first input layer
output_dataset.SetGeoTransform(datasets[0].GetGeoTransform())
output_dataset.SetProjection(datasets[0].GetProjection())
if nodata is None:
nodata = ndv_lookup[output_type]
for i in range(1, allbandscount + 1):
output_band = output_dataset.GetRasterBand(i)
output_band.SetNoDataValue(nodata)
# write to band
output_band = None
################################################################
# find block size to chop grids into bite-sized chunks
################################################################
# use the block size of the first layer to read efficiently
block_size = datasets[0].GetRasterBand(bands[0]).GetBlockSize()
# store these numbers in variables that may change later
n_x_valid = block_size[0]
n_y_valid = block_size[1]
# find total x and y blocks to be read
n_x_blocks = int((dimensions[0] + block_size[0] - 1) / block_size[0])
n_y_blocks = int((dimensions[1] + block_size[1] - 1) / block_size[1])
buffer_size = block_size[0] * block_size[1]
################################################################
# start looping through each band in allbandscount
################################################################
for band_num in range(1, allbandscount + 1):
################################################################
# start looping through blocks of data
################################################################
# loop through X-lines
for x in range(0, n_x_blocks):
# in the rare (impossible?) case that the blocks don't fit perfectly
# change the block size of the final piece
if x == n_x_blocks - 1:
n_x_valid = dimensions[0] - x * block_size[0]
buffer_size = n_x_valid * n_y_valid
# find X offset
x_offset = x * block_size[0]
# reset buffer size for start of Y loop
n_y_valid = block_size[1]
buffer_size = n_x_valid * n_y_valid
# loop through Y lines
for y in range(0, n_y_blocks):
# change the block size of the final piece
if y == n_y_blocks - 1:
n_y_valid = dimensions[1] - y * block_size[1]
buffer_size = n_x_valid * n_y_valid
# find Y offset
y_offset = y * block_size[1]
# create empty buffer to mark where nodata occurs
nodatavalues = numpy.zeros(buffer_size)
nodatavalues.shape = (n_y_valid, n_x_valid)
# fetch data for each input layer
for i, alpha in enumerate(alpha_list):
# populate lettered arrays with values
if allbandsindex is not None and allbandsindex == i:
this_band = band_num
else:
this_band = bands[i]
band_vals = BandReadAsArray(
datasets[i].GetRasterBand(this_band),
xoff=x_offset,
yoff=y_offset,
win_xsize=n_x_valid,
win_ysize=n_y_valid)
# fill in nodata values
nodatavalues = 1 * numpy.logical_or(
nodatavalues == 1, band_vals == nodata_vals[i])
# create an array of values for this block
exec("%s=band_vals" % alpha)
band_vals = None
# try the calculation on the array blocks
try:
calc_result = eval(calculation)
except Exception as e:
logger.error("eval of calculation %s failed" % calculation)
raise e
# propogate nodata values
# (set nodata cells to 0 then add nodata value to these cells)
calc_result = ((1 * (nodatavalues == 0)) * calc_result) + \
(nodata * nodatavalues)
# write data block to the output file
output_band = output_dataset.GetRasterBand(band_num)
BandWriteArray(output_band,
calc_result,
xoff=x_offset,
yoff=y_offset)
if raster_output:
output_driver = gdal.GetDriverByName(format)
outfile = output_driver.CreateCopy(raster_output, output_dataset,
False)
logger.debug(str(outfile))
return output_dataset
# extract geoetry from headers
east = int(meta['HDFEOS_GRIDS_VNP_Grid_DNB_EastBoundingCoord'])
west = int(meta['HDFEOS_GRIDS_VNP_Grid_DNB_WestBoundingCoord'])
north = int(meta['HDFEOS_GRIDS_VNP_Grid_DNB_NorthBoundingCoord'])
south = int(meta['HDFEOS_GRIDS_VNP_Grid_DNB_SouthBoundingCoord'])
date = meta['HDFEOS_GRIDS_VNP_Grid_DNB_RangeBeginningDate']
vt = int(meta['VerticalTileNumber'])
ht = int(meta['HorizontalTileNumber'])
rad_band = rad.GetRasterBand(1)
lum_band = lum.GetRasterBand(1)
cloud_band = cloud.GetRasterBand(1)
rad_BandType = gdal.GetDataTypeName(rad_band.DataType)
lum_BandType = gdal.GetDataTypeName(lum_band.DataType)
cloud_BandType = gdal.GetDataTypeName(cloud_band.DataType)
y = r
# read in scanlines and store in rad_m matrix
for c in np.arange(chunk):
rad_scan = rad_band.ReadRaster(0, int(y + c), rad_band.XSize,
1, rad_band.XSize, 1,
rad_band.DataType)
lum_scan = lum_band.ReadRaster(0, int(y + c), lum_band.XSize,
1, lum_band.XSize, 1,
rad_band.DataType)
cloud_scan = cloud_band.ReadRaster(0, int(y + c),
cloud_band.XSize, 1,
