def start():
user_input = input('Enter file path for first_band: ')
# Open First image and get its only band.
# first_tiff = Open(r'51/AST_L1B_00308132001191022_20110122163617_24451_ImageData1_b30de2ff.tif')
first_tiff = Open(user_input)
first_band = first_tiff.GetRasterBand(1)
user_input = input('Enter file path for second_band of same image: ')
# Open Second image and get its only band.
# second_tiff = Open(r'51/AST_L1B_00308132001191022_20110122163617_24451_ImageData2_b30de2ff.tif')
second_tiff = Open(user_input)
second_band = second_tiff.GetRasterBand(1)
# Release from memory
user_input = None
# Get the rows and cols from one of the images (both should always be the same)
rows, cols, geotransform = first_tiff.RasterYSize, first_tiff.RasterXSize, first_tiff.GetGeoTransform()
print(geotransform)
# Set an output for a 16-bit unsigned integer (0-255)
out_tiff_int16 = r'TEST-RESULTS/NDVI_INT16.tif'
# Set the output for a 32-bit floating point (-1 to 1)
out_tiff_float32 = r'TEST-RESULTS/NDVI_FLOAT32.tif'
# Run the function for unsigned 16-bit integer
ndwi(first_band, second_band, rows, cols, geotransform, out_tiff_int16, gdal.GDT_UInt16)
# Run the function for 32-bit floating point
ndwi(first_band, second_band, rows, cols, geotransform, out_tiff_float32, gdal.GDT_Float32)
print('done')
def main():
if len(sys.argv) < 6:
print "Few arguments"
sys.exit()
elif len(sys.argv) > 6:
print "Too many arguments"
sys.exit()
#Tiff paths
red_path = str(sys.argv[1])
nir_path = str(sys.argv[2])
bqa_path = str(sys.argv[3])
mtl_path = str(sys.argv[4])
output_path = str(sys.argv[5])
d_sun_earth_path = 'd_sun_earth'
# Open red image and get its only band.
red_tiff = Open(red_path)
red_band = red_tiff.GetRasterBand(1)
# Open NIR image and get its only band.
nir_tiff = Open(nir_path)
nir_band = nir_tiff.GetRasterBand(1)
# Open bqa image and get its only band.
bqa_tiff = Open(bqa_path)
bqa_band = bqa_tiff.GetRasterBand(1)
# Get the rows and cols from one of the images (both should always be the same)
row, col, geotransform = nir_tiff.RasterYSize, nir_tiff.RasterXSize, nir_tiff.GetGeoTransform(
)
# Reading metadata
parameters = metaReader.readParameters(mtl_path, d_sun_earth_path)
number_sensor = int(parameters[0])
julian_day = int(parameters[1])
sun_elevation = float(parameters[2])
dist_sun_earth = float(parameters[3])
mask = get_mask(number_sensor)
if shadow_check(bqa_band, (col, row), mask):
print "Invalid inputs. Lots of cloud in tiff images"
sys.exit()
ndviC = NDVI(sun_elevation, red_band, nir_band, bqa_band, (col, row),
geotransform)
ndviC.processNDVI(number_sensor, dist_sun_earth, output_path)
def apply_valid_range(input_data_set_path: str, file_path: str) -> str:
"""Apply Valid Range -10000 -> 10000.
Args:
input_data_set_path (str) - Path to the input data set
file_path (str) - Target data set filename
Returns:
Path to valid_range_image
"""
src_ds = GDALOpen(input_data_set_path, GA_ReadOnly)
if src_ds is None:
raise ValueError(
'Could not open data set "{}"'.format(input_data_set_path))
driver = GetDriverByName('MEM')
src_band = src_ds.GetRasterBand(1)
data_set = driver.Create('', src_ds.RasterXSize, src_ds.RasterYSize, 1,
src_band.DataType)
data_set.SetGeoTransform(src_ds.GetGeoTransform())
data_set.SetProjection(src_ds.GetProjection())
data_set_band = data_set.GetRasterBand(1)
data_set_band.WriteArray(src_band.ReadAsArray())
band_array = data_set_band.ReadAsArray()
dummy = -9999
data_set_band.SetNoDataValue(dummy)
band_array[band_array <= -10000] = dummy
band_array[band_array >= 10000] = dummy
driver = GetDriverByName('GTiff')
data_set_band.WriteArray(band_array)
dst_ds = driver.CreateCopy(file_path, data_set, options=["COMPRESS=LZW"])
del dst_ds
del src_ds
del data_set
return file_path
import gdal from gdal import Open from ndvi import ndvi # Abrindo banda NIR nir_tiff = Open(r'NIR_IMAGE.tif') #nir_tiff = Open(r'nir.tif') nir_band = nir_tiff.GetRasterBand(1) # Abrindo banda RED. red_tiff = Open(r'RED_IMAGE.tif') #red_tiff = Open(r'red.tif') red_band = red_tiff.GetRasterBand(1) # Get the rows and cols from one of the images (both should always be the same) rows, cols, geotransform = nir_tiff.RasterYSize, nir_tiff.RasterXSize, nir_tiff.GetGeoTransform() print(geotransform) # Arquivo de saida 16-bit (0-255) out_tiff_int16 = r'NDVI_16.tif' # Arquivo de saida 32-bit floating point (-1 to 1) out_tiff_float32 = r'NDVI_32.tif' # Gerando imagem NDVI 16-bit integer ndvi(nir_band, red_band, rows, cols, geotransform, out_tiff_int16, gdal.GDT_UInt16) # Gerando imagem NDVI 32-bit floating point ndvi(nir_band, red_band, rows, cols, geotransform, out_tiff_float32, gdal.GDT_Float32)
import sys
import os
from keras import backend as K
import tensorflow as tf
# ========== INPUT ==========
# Define input image dimensions
img_rows, img_cols = 32, 32
# The images are RGB.
img_channels = 3
# Use GDAL OPEN to read base RGB WorldView(WV02) map and corresponding reference label
wv = Open('mapMul.tif')
land = np.zeros((wv.RasterYSize,wv.RasterXSize,3)).astype('uint16') #np.zeros_like(wv).astype('int16')
land[:,:,0] = wv.GetRasterBand(5).ReadAsArray() # swaping the band and re-arrange the band order into 1-R, 2-G and 3-B
land[:,:,1] = wv.GetRasterBand(3).ReadAsArray()
land[:,:,2] = wv.GetRasterBand(2).ReadAsArray()
del wv # delete variables to save memory resources
label = imread("labelMul.tif")
# Convert to 0-255 valued UINT8 image
land = cv2.convertScaleAbs(land,alpha = 255.0/(np.max(land)))
slum = (label > 0).astype('uint8')
del label # delete variables to save memory resources
#plt.imshow(slum, 'gray')
land_slum = np.dstack((land, slum)) # stack the map and label for drawing training patches
# Sample from slum blocks according to the size of connected slum blocks
slum_block = measure.label(slum, background = False, connectivity = 1) # extract and label connected slum blocks
regions = measure.regionprops(slum_block) # get the properties of labelled slum blocks
def publish(collection_item: CollectionItem, scene: RadcorActivity):
"""Publish Landsat collection.
It works with both Digital Number (DN) and Surface Reflectance (SR).
Args:
collection_item - Collection Item
scene - Current Activity
"""
identifier = scene.sceneid
cc = identifier.split('_')
pathrow = cc[2]
date = cc[3]
yyyymm = '{}-{}'.format(date[0:4], date[4:6])
productdir = scene.args.get('file')
logging.warning('Publish {} - {} (id={})'.format(scene.collection_id,
productdir, scene.id))
if productdir and productdir.endswith('.gz'):
target_dir = Path(
Config.DATA_DIR) / 'Repository/Archive/{}/{}/{}'.format(
collection_item.collection_id, yyyymm, pathrow)
makedirs(target_dir, exist_ok=True)
productdir = uncompress(productdir, str(target_dir))
collection = Collection.query().filter(
Collection.id == collection_item.collection_id).one()
quicklook = collection.bands_quicklook.split(
',') if collection.bands_quicklook else DEFAULT_QUICK_LOOK_BANDS
files = {}
qlfiles = {}
if collection.id == 'LC8DN':
bands = BAND_MAP_DN
elif collection.id == 'LC8NBAR':
bands = BAND_MAP_NBAR
else:
bands = BAND_MAP_SR
for gband, band in bands.items():
template = productdir + '/LC08_*_{}_{}_*_{}.*'.format(
pathrow, date, band)
fs = glob.glob(template)
if not fs:
continue
for f in fs:
if f.lower().endswith('.tif'):
files[gband] = f
if gband in quicklook:
qlfiles[gband] = f
# Skip EVI/NDVI generation for Surface Reflectance
# since the espa-science already done
if collection.id == 'LC8DN' or collection.id == 'LC8NBAR':
generate_vi(productdir, files)
# Apply valid range and Cog files
for band, file_path in files.items():
if collection.id == 'LC8SR':
_ = apply_valid_range(file_path, file_path)
# Set destination of COG file
files[band] = generate_cogs(file_path, file_path)
if not is_valid_tif(file_path):
raise RuntimeError('Not Valid {}'.format(file_path))
# Extract basic scene information and build the quicklook
pngname = productdir + '/{}.png'.format(identifier)
dataset = GDALOpen(qlfiles['nir'], GA_ReadOnly)
numlin = 768
numcol = int(
float(dataset.RasterXSize) / float(dataset.RasterYSize) * numlin)
image = numpy.zeros((
numlin,
numcol,
len(qlfiles),
), dtype=numpy.uint8)
del dataset
nb = 0
for band in quicklook:
template = qlfiles[band]
dataset = GDALOpen(template, GA_ReadOnly)
raster = dataset.GetRasterBand(1).ReadAsArray(0, 0,
dataset.RasterXSize,
dataset.RasterYSize)
del dataset
raster = resize(raster, (numlin, numcol), order=1, preserve_range=True)
nodata = raster == -9999
# Evaluate minimum and maximum values
a = numpy.array(raster.flatten())
p1, p99 = numpy.percentile(a[a > 0], (1, 99))
# Convert minimum and maximum values to 1,255 - 0 is nodata
raster = exposure.rescale_intensity(raster,
in_range=(p1, p99),
out_range=(1, 255)).astype(
numpy.uint8)
image[:, :, nb] = raster.astype(numpy.uint8) * numpy.invert(nodata)
nb += 1
write_png(pngname, image, transparent=(0, 0, 0))
productdir = productdir.replace(Config.DATA_DIR, '')
assets_to_upload = {
'quicklook':
dict(file=pngname, asset=productdir.replace('/Repository/Archive', ''))
}
for instance in ['local', 'aws']:
engine_instance = {'local': db, 'aws': db_aws}
engine = engine_instance[instance]
# Skip catalog on aws for digital number
if collection_item.collection_id == 'LC8DN' and instance == 'aws':
continue
if instance == 'aws':
asset_url = productdir.replace('/Repository/Archive',
Config.AWS_BUCKET_NAME)
else:
asset_url = productdir
pngname = resource_path.join(asset_url, Path(pngname).name)
assets_to_upload['quicklook']['asset'] = pngname
with engine.session.begin_nested():
with engine.session.no_autoflush:
# Add collection item to the session if not present
if collection_item not in engine.session:
item = engine.session.query(CollectionItem).filter(
CollectionItem.id == collection_item.id).first()
if not item:
cloned_properties = CollectionItemForm().dump(
collection_item)
collection_item = CollectionItem(**cloned_properties)
engine.session.add(collection_item)
collection_item.quicklook = pngname
collection_bands = engine.session.query(Band).filter(
Band.collection_id == collection_item.collection_id).all()
# Inserting data into Product table
for band in files:
template = resource_path.join(asset_url,
Path(files[band]).name)
dataset = GDALOpen(files[band], GA_ReadOnly)
asset_band = dataset.GetRasterBand(1)
chunk_x, chunk_y = asset_band.GetBlockSize()
band_model = next(
filter(lambda b: band == b.common_name,
collection_bands), None)
if not band_model:
logging.warning(
'Band {} of collection {} not found in database. Skipping...'
.format(band, collection_item.collection_id))
continue
defaults = dict(url=template,
source=cc[0],
raster_size_x=dataset.RasterXSize,
raster_size_y=dataset.RasterYSize,
raster_size_t=1,
chunk_size_t=1,
chunk_size_x=chunk_x,
chunk_size_y=chunk_y)
asset, _ = get_or_create_model(
Asset,
engine=engine,
defaults=defaults,
collection_id=scene.collection_id,
band_id=band_model.id,
grs_schema_id=scene.collection.grs_schema_id,
tile_id=collection_item.tile_id,
collection_item_id=collection_item.id,
)
asset.url = defaults['url']
assets_to_upload[band] = dict(file=files[band],
asset=asset.url)
# Add into scope of local and remote database
add_instance(engine, asset)
# Persist database
commit(engine)
return assets_to_upload
import gdal
from gdal import Open
from ndvi import ndvi
# Open a before image and get its only band.
before_ndvi = Open(r'x') #input desired image file name into x
before_ndvi_band = before_ndvi.GetRasterBand(1)
# Open a after image and get its only band.
after_ndvi = Open(r'y') #input desired image file name into y
after_ndvi_band = after_ndvi.GetRasterBand(1)
# Get the rows and cols from one of the images (both should always be the same)
rows, cols = before_ndvi.RasterYSize, before_ndvi.RasterXSize
# Run the function for 32-bit floating point
comparison(before_ndvi_band, after_ndvi_band, rows, cols)
print('done')
def publish(collection_item: CollectionItem, scene: RadcorActivity):
"""Publish Landsat collection.
It works with both Digital Number (DN) and Surface Reflectance (SR).
Args:
collection_item - Collection Item
scene - Current Activity
"""
identifier = scene.sceneid
# Get collection level to publish. Default is l1
collection_level = scene.args.get('level') or 1
landsat_scene = factory.get_from_sceneid(identifier,
level=collection_level)
productdir = scene.args.get('file')
logging.warning('Publish {} - {} (id={})'.format(scene.collection_id,
productdir, scene.id))
if productdir and productdir.endswith('.gz'):
target_dir = landsat_scene.path()
makedirs(target_dir, exist_ok=True)
productdir = uncompress(productdir, str(target_dir))
collection = Collection.query().filter(
Collection.id == collection_item.collection_id).one()
quicklook = collection.bands_quicklook.split(
',') if collection.bands_quicklook else DEFAULT_QUICK_LOOK_BANDS
files = {}
qlfiles = {}
bands = landsat_scene.get_band_map()
for gband, band in bands.items():
fs = landsat_scene.get_files()
if not fs:
continue
for f in fs:
if f.stem.endswith(band) and f.suffix.lower().endswith('.tif'):
files[gband] = f
if gband in quicklook:
qlfiles[gband] = str(f)
# Generate Vegetation Index files
generate_vi(productdir, files)
# Apply valid range and Cog files
for band, file_path in files.items():
tif_file = str(file_path)
if landsat_scene.level == 2:
_ = apply_valid_range(tif_file, tif_file)
# Set destination of COG file
files[band] = generate_cogs(tif_file, tif_file)
if not is_valid_tif(tif_file):
raise RuntimeError('Not Valid {}'.format(tif_file))
# Extract basic scene information and build the quicklook
pngname = productdir + '/{}.png'.format(identifier)
dataset = GDALOpen(qlfiles['nir'], GA_ReadOnly)
numlin = 768
numcol = int(
float(dataset.RasterXSize) / float(dataset.RasterYSize) * numlin)
del dataset
create_quick_look(pngname,
[qlfiles[band] for band in quicklook if band in qlfiles],
rows=numlin,
cols=numcol)
productdir = productdir.replace(Config.DATA_DIR, '')
assets_to_upload = {
'quicklook':
dict(file=pngname, asset=productdir.replace('/Repository/Archive', ''))
}
for instance in ['local', 'aws']:
engine_instance = {'local': db, 'aws': db_aws}
engine = engine_instance[instance]
# Skip catalog on aws for digital number
if landsat_scene.level == 1 and instance == 'aws':
continue
if instance == 'aws':
asset_url = productdir.replace('/Repository/Archive',
Config.AWS_BUCKET_NAME)
else:
asset_url = productdir
pngname = resource_path.join(asset_url, Path(pngname).name)
assets_to_upload['quicklook']['asset'] = pngname
with engine.session.begin_nested():
with engine.session.no_autoflush:
# Add collection item to the session if not present
if collection_item not in engine.session:
item = engine.session.query(CollectionItem).filter(
CollectionItem.id == collection_item.id).first()
if not item:
cloned_properties = CollectionItemForm().dump(
collection_item)
collection_item = CollectionItem(**cloned_properties)
engine.session.add(collection_item)
collection_item.quicklook = pngname
collection_bands = engine.session.query(Band)\
.filter(Band.collection_id == collection_item.collection_id)\
.all()
# Inserting data into Product table
for band in files:
template = resource_path.join(asset_url,
Path(files[band]).name)
dataset = GDALOpen(files[band], GA_ReadOnly)
asset_band = dataset.GetRasterBand(1)
chunk_x, chunk_y = asset_band.GetBlockSize()
band_model = next(
filter(lambda b: band == b.common_name,
collection_bands), None)
if not band_model:
logging.warning(
'Band {} of collection {} not found in database. Skipping...'
.format(band, collection_item.collection_id))
continue
defaults = dict(url=template,
source=landsat_scene.source(),
raster_size_x=dataset.RasterXSize,
raster_size_y=dataset.RasterYSize,
raster_size_t=1,
chunk_size_t=1,
chunk_size_x=chunk_x,
chunk_size_y=chunk_y)
asset, _ = get_or_create_model(
Asset,
engine=engine,
defaults=defaults,
collection_id=scene.collection_id,
band_id=band_model.id,
grs_schema_id=scene.collection.grs_schema_id,
tile_id=collection_item.tile_id,
collection_item_id=collection_item.id,
)
asset.url = defaults['url']
assets_to_upload[band] = dict(file=files[band],
asset=asset.url)
# Add into scope of local and remote database
add_instance(engine, asset)
# Persist database
commit(engine)
return assets_to_upload
import gdal from gdal import Open from ndvi import ndvi from ndvi import evi from ndvi import dvi from ndvi import ndwi from ndvi import mndwi from ndvi import ndbi from ndvi import savi from ndvi import ndbi from ndvi import ndmi import xlrd import openpyxl nir_tiff = Open(r'NIR_IMAGE.tif') nir_band = nir_tiff.GetRasterBand(1) print(nir_band) red_tiff = Open(r'RED_IMAGE.tif') red_band = red_tiff.GetRasterBand(1) print(red_band) blue_tiff = Open(r'BLUE_IMAGE.tif') blue_band = blue_tiff.GetRasterBand(1) green_tiff = Open(r'GREEN_IMAGE.tif') green_band = green_tiff.GetRasterBand(1) swir_tiff = Open(r'SWIR_IMAGE.tif') swir_band = swir_tiff.GetRasterBand(1) mir_tiff = Open(r'MIR_IMAGE.tif')
