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,