def process_DEM(path_to_dem, path_to_slope=None, path_to_aspect=None):
#reproject DEM to UTM
#set gdal raster processing options
processing_options = gdal.DEMProcessingOptions(alg='ZevenbergenThorne',
slopeFormat='degree')
#run processing
if path_to_slope == None and path_to_aspect == None:
return
elif path_to_slope != None and path_to_aspect == None:
gdal.DEMProcessing(path_to_slope,
path_to_dem,
'slope',
options=processing_options)
return
elif path_to_slope == None and path_to_aspect != None:
gdal.DEMProcessing(path_to_aspect,
path_to_dem,
'aspect',
options=processing_options)
return
else:
gdal.DEMProcessing(path_to_slope,
path_to_dem,
'slope',
options=processing_options)
gdal.DEMProcessing(path_to_aspect,
path_to_dem,
'aspect',
options=processing_options)
return
def get_dem_slope_and_angle(dem_path, slope_out_path, aspect_out_path):
"""Produces two .tifs, slope and aspect, from an imput DEM.
Assumes that the DEM is in meters."""
log.info("Calculating slope and apsect rasters from")
dem = gdal.Open(dem_path)
gdal.DEMProcessing(slope_out_path, dem, "slope") # For DEM in meters
gdal.DEMProcessing(aspect_out_path, dem, "aspect")
dem = None
def get_dem_slope_and_angle(dem_path, slope_out_path, aspect_out_path):
"""Produces two .tifs, slope and aspect, from an imput DEM.
Assumes that the DEM is in meters."""
log.info("Calculating slope and apsect rasters from {}".format(dem_path))
dem = gdal.Open(dem_path)
slope_options = gdal.DEMProcessingOptions(
slopeFormat="degree", scale=111139) # Scale from latlon to meters
gdal.DEMProcessing(slope_out_path, dem, "slope",
options=slope_options) # For DEM in latlon
aspect_options = gdal.DEMProcessingOptions(zeroForFlat=True, scale=111139)
gdal.DEMProcessing(aspect_out_path, dem, "aspect", options=aspect_options)
dem = None
def getPente(self):
""" Permet de récupérer un array Numpy de la pente (produit dérivé du modèle numérique de terrain).
Returns:
pente (Numpy.ma.masked_array): Array des valeurs de pente du modèle numérique de terrain (MNT).
"""
mnt = gdal.Open(self.mnt)
slope = gdal.DEMProcessing(r'data/slope.tif',
mnt,
'slope',
computeEdges=True)
slope = None
ds = gdal.Open(r'data/slope.tif')
band = ds.GetRasterBand(1)
array = band.ReadAsArray()
print('valeur de pente')
print(array)
array[array == 0] = -9999
print('valeur de pente')
print(array)
return array
def create_hillshade(srcDS, destName, zf, multiDirectional):
'''
Calculate hillshade for tile
'''
print('Creating hillshade for {}'.format(destName))
gdal.DEMProcessingOptions(zFactor=zf, multiDirectional=multiDirectional)
gdal.DEMProcessing(destName, srcDS, 'hillshade')
def roughness():
dstPath, dataset = create_raster_dataset_as_per_other_dataset()
dst_ds = gdal.DEMProcessing(dstPath, dataset, 'roughness', format='GTiff')
dst_ds.FlushCache()
for i in range(dst_ds.RasterCount):
i = i + 1
dst_ds.GetRasterBand(i).ComputeStatistics(False)
dst_ds.BuildOverviews('average',
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048])
def calculate_slope(DEM):
gdal.DEMProcessing('slope.tif',
DEM,
'slope',
alg='ZevenbergenThorne',
scale=500000)
with rasterio.open('slope.tif') as dataset:
slope = dataset.read(1)
return slope
def getOrientation(self):
""" Permet de récupérer un array Numpy de l'orientation (produit dérivé du modèle numérique de terrain).
Returns:
orientation (Numpy.ma.masked_array): Array des valeurs de l'orientation du modèle numérique de terrain (MNT).
"""
mnt = gdal.Open(self.mnt)
aspect = gdal.DEMProcessing(r'data/aspect.tif', mnt, 'aspect', computeEdges=True)
aspect = None
ds = gdal.Open(r'data/aspect.tif')
band = ds.GetRasterBand(1)
array = band.ReadAsArray()
array[array == 0] = -9999
return array
def hillshade():
dstPath, dataset = create_raster_dataset_as_per_other_dataset()
dst_ds = gdal.DEMProcessing(dstPath,
dataset,
'hillshade',
format='GTiff',
alg='ZevenbergenThorne',
multiDirectional=True,
computeEdges=True,
scale=111120,
zFactor=30)
dst_ds.FlushCache()
for i in range(dst_ds.RasterCount):
i = i + 1
dst_ds.GetRasterBand(i).ComputeStatistics(False)
dst_ds.BuildOverviews('average',
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048])
def aspect(path):
datasource, path = open_File(path)
print "Creating New Dataset for Aspect"
dstPath, dataset, filepath = create_raster_dataset_as_per_other_dataset(
path, datasource)
dst_ds = gdal.DEMProcessing(dstPath,
dataset,
'aspect',
format='GTiff',
alg='ZevenbergenThorne',
scale=111120,
zFactor=30)
dst_ds.FlushCache()
for i in range(dst_ds.RasterCount):
i = i + 1
dst_ds.GetRasterBand(i).ComputeStatistics(False)
min, max, d = reading_raster_band(dstPath)
histogram(min, max, dst_ds)
dst_ds.BuildOverviews('average',
[2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048])
dst_ds = None
return dstPath
def gdaldem(ds, producttype='slope', returnma=True):
"""
perform gdaldem operations such as slope, hillshade etc via the python api
Parameters
-----------
ds: gdal dataset
DEM dataset for which derived products are to be computed
producttype: str
operation to perform (e.g., slope, aspect, hillshade)
returnma: bool
return the product as masked array if true, or a dataset if false
Returns
-----------
out: masked array or dataset
output product in form of masked array or dataset (see params)
"""
dem_p_ds = gdal.DEMProcessing('', ds, producttype, format='MEM')
ma = iolib.ds_getma(dem_p_ds)
if returnma:
out = ma
else:
out = dem_p_ds
return out
def calcular_dem(operacion, fichero_entrada, fichero_salida):
gdal.DEMProcessing(fichero_salida, fichero_entrada, operacion)
def gdalslope(DEM, dst, latlon=True):
if latlon:
scale = 111120
else:
scale = 1
gdal.DEMProcessing(dst, DEM, "slope", scale=scale)
@author: Tobi
"""
#alternativa: from funciones import cargar_raster # selecionar cuales funciones a importar
import funciones as fun # archivo de funciones.py
import numpy as np
lado = 5
flow_acc = fun.cargar_raster('flowacc.tif')
a = flow_acc * lado**2 # **derivado, funcion tiene que empezar con minuscula
import gdal
gdal.DEMProcessing('aspect.tif', 'filldem.tif', 'aspect')
aspect = fun.cargar_raster('aspect.tif') #cargar raster
aspect_rad = aspect * np.pi / 180
aspect_sen = np.sin(aspect_rad) #calcular sinus (seno)
aspect_cos = np.cos(aspect_rad) #calcular cosinus
aspect_sen_pos = np.abs(aspect_sen)
aspect_cos_pos = np.abs(aspect_cos) #absolute/positive values
b = 5 * (aspect_sen_pos + aspect_cos_pos)
a_e = a / b
gdal.DEMProcessing('slope.tif', 'filldem.tif', 'slope')
addAspect = GetParameter(3)
writeLog(inputFolder, gdb, addSlope, addAspect)
# Collect raster images
gTiffs = getRasters(inputFolder)
virtualMosaic = gdal.BuildVRT('virtualRaster.vrt', gTiffs)
# Process DEM Mosaic
tempDEM = RasterProcessor(virtualMosaic)
mDEM = tempDEM.array2raster()
mDEM.save(os.path.join(gdb, 'DEM_Mosaic'))
del mDEM, tempDEM
tempDEM = RasterProcessor(virtualMosaic)
ftDEM = tempDEM.array2raster(footConversion=True)
ftDEM.save(os.path.join(gdb, 'DEM_Mosaic_ft'))
del ftDEM, tempDEM
if addSlope:
demSlope = gdal.DEMProcessing('slope.vrt', mosaic, "slope")
tempSlope = RasterProcessor(demSlope)
outSlope = tempSlope.array2raster()
outSlope.save(os.path.join(gdb, 'DEM_Slope'))
if addAspect:
demAspect = gdal.DEMProcessing('aspec.vrt', mosaic, "aspect")
tempAspect = RasterProcessor(demAspect)
outAspect = tempAspect.array2raster()
outAspect.save(os.path.join(gdb, 'DEM_Aspect'))
dest_folder, feuillet))
except:
print('mnt pas disponible')
continue
else:
print('mnt deja download, processing...')
pass
print('mnt disponible, processing.... ')
count_tile = count_tile + 1
mnt = r'{}\MNT_{}.tif'.format(dest_folder, feuillet)
## calcul de pente et des orientations de pente
slopes = os.path.join(dest_folder, 'slopes.tif')
aspect = os.path.join(dest_folder, 'aspect.tif')
gdal.DEMProcessing(slopes, mnt, "slope")
gdal.DEMProcessing(aspect, mnt, "aspect")
## identidfication des portion avec une pente assez prononc�e pour �tre consdid�r�e comme une falaise
raster = rasterio.open(slopes)
band = raster.read(1)
band = band.clip((min_slope - 1), min_slope)
band[band == (min_slope - 1)] = 0
band[band == min_slope] = 1
print(len(band[band == 1]))
if len(band[band == 1]) == 0:
print(
def calculate_slope(elevation, dst):
gdal.DEMProcessing(dst + '_slope.tif', elevation, 'slope')
def calculate_aspect(elevation, dst):
gdal.DEMProcessing(dst + '_aspect.tif', elevation, 'aspect')
outfile = infile.replace('.tif', '.{}_{}_{}.tif'.format(cmap_name, cmin, cmax))
#%% Create color table
### Format: value R G B alpha
colorfile = '{}_{}_{}.txt'.format(cmap_name, cmin, cmax)
cmap_RGB = np.int16(np.round(cmap(np.linspace(0, 1, n_color))*255))
with open(colorfile, "w") as f:
for i in range(n_color):
print("{} {} {} {} 255".format(cmin+i*(cmax-cmin)/(n_color-1),
cmap_RGB[i, 0], cmap_RGB[i, 1], cmap_RGB[i, 2]), file=f)
print("nv 0 0 0 0", file=f)
#%% gdal dem
gdal.DEMProcessing(outfile, infile, "color-relief", colorFilename=colorfile,
format="GTiff", creationOptions=gdal_option, addAlpha=4)
#%% colorbar
if cbar_flag:
fig, ax = plt.subplots(figsize=(3, 1))
norm = mpl.colors.Normalize(cmin, cmax)
mpl.colorbar.ColorbarBase(ax, cmap=cmap, norm=norm, orientation='horizontal')
cbarfile = "{}_{}_{}.pdf".format(cmap_name, cmin, cmax)
plt.tight_layout()
plt.savefig(cbarfile, transparent=True)
plt.close()
#%% Remove intermediate files
os.remove(colorfile)
def dem_slp_hillshade(gz_folder, dem, slp):
## filenames for processed dem, slope and hillshade
dst_dem = gz_folder + "/" + "DEM.tif"
dst_slp = gz_folder + "/" + "perslp.tif"
dst_hshd = gz_folder + "/" + "hillshade.tif"
## read in the first tif to crop the dem
file_list = glob.glob1(gz_folder, "*.tif")
print file_list, gz_folder
first_file_ds = gdal.Open(gz_folder + "/" + file_list[0])
## grab image size and projection info
nCol = first_file_ds.RasterXSize
nRow = first_file_ds.RasterYSize + 1
# coordinates are for top-left corners of pixels
geotrans = first_file_ds.GetGeoTransform()
# clip with geotrans from first Landsat band
minx = geotrans[0]
maxy = geotrans[3]
maxx = minx + geotrans[1] * nCol
miny = maxy + geotrans[5] * nRow
# open the big DEM and percent slope
src_dem = gdal.Open(dem)
src_slp = gdal.Open(slp)
##Clip our slope and hillshade mask to the image (have to do this for each image due to the variable extents of each image)
GeoClip= [minx, maxy, maxx, miny]
print GeoClip
print "clipping DEM..."
dem_clip = gdal.Translate(dst_dem, src_dem, projWin = GeoClip)
print "calculating slope..."
slp_clip = gdal.Translate(dst_slp, src_slp, projWin = GeoClip)
#perslp = gdal.DEMProcessing(dst_slp, dem_clip, 'slope', slopeFormat = 'percent', format = 'GTiff')
# close open datasets
src_dem = None
src_slp = None
dem_clip = None
slp_clip = None
## get solar geometry
print "Getting metadata ..."
Metadata = glob.glob1(gz_folder, "*.xml")
xmldoc = etree.parse(gz_folder + "/" + Metadata[0])
root = xmldoc.getroot()
SunAngleData=str(root[0][6].attrib)
charlist="':}{,"
for char in charlist:
SunAngleData=SunAngleData.replace(char,"")
SunAngleList=SunAngleData.split()
Zen= float(SunAngleList[3])
Az= float(SunAngleList[5])
Az = int(Az)
Alt= float(90 - Zen)
print Alt
print Az
## calculate hillshade
print "calculate hillshade ..."
#HillshadeOut="hillshade_mask" + "_%s.tif"%"_".join(raster.split('_'))[0:length]
#Hoping the altitude issue is repaired shortly, will be an easy fix once it is corrected
#Hillshade = gdal.DEMProcessing('hillshade.tif', DEM, 'hillshade', format = 'GTiff', azimuth = Az, altitude=Alt)
dst_dem_ds = gdal.Open(dst_dem)
geotrans = dst_dem_ds.GetGeoTransform()
prj = dst_dem_ds.GetProjectionRef()
hlshd_ds = gdal.DEMProcessing(dst_hshd, dst_dem_ds, 'hillshade', format = 'GTiff', azimuth = Az) # this fails on linux :(
hlshd_band = hlshd_ds.GetRasterBand(1)
hlshd_data = hlshd_band.ReadAsArray()
# save the hillshade
nrows,ncols = np.shape(hlshd_data)
driver = gdal.GetDriverByName("GTiff")
dst_hlshd = driver.Create(dst_hshd, ncols, nrows, 1, gdal.GDT_Byte)
dst_hlshd.SetGeoTransform( geotrans )
dst_hlshd.SetProjection( prj )
hlsh_band = dst_hlshd.GetRasterBand(1)
hlsh_band.WriteArray( hlshd_data )
hlsh_band.SetNoDataValue(255)
hlsh_band = None
dst_hlshd.FlushCache()
dst_hlshd = None
dst_dem_ds = None
def gdalTPI(DEM, dst, latlon=True):
gdal.DEMProcessing(dst, DEM, "TPI")
# "{qswatplus_wf_dir}/dem_data.dat".format(qswatplus_wf_dir=os.environ["qswatplus_wf"]))
# for suff in dem_data_variable.suffix_list: # suff is the last_part of each raster that is appended to dem
# if suff == "fel.tif":
# continue
# with open('{base}/{project_name}/Watershed/Rasters/DEM/{dem_name}{suff}'.format(
# base=sys.argv[1], project_name=project_name, dem_name=dem_name, suff=suff), 'wb') as fl:
# fl.write(dem_data_variable.raster_data)
log.info("creating hillshade for DEM", keep_log)
hillshade_name = '{base}/{project_name}/Watershed/Rasters/DEM/{dem_name}hillshade.tif'.format(
base=sys.argv[1], project_name=project_name, dem_name=dem_file_name_[:-4])
src_ds = gdal.Open(
'{base}/{project_name}/Watershed/Rasters/DEM/{dem_name}'.format(
base=sys.argv[1], project_name=project_name, dem_name=dem_file_name_))
ds = gdal.DEMProcessing(hillshade_name, src_ds, 'hillshade', zFactor=30)
# copy shapefile
shapes_dir = '{base}/{project_name}/Watershed/Shapes/'.format(
base=sys.argv[1], project_name=project_name)
rmtree(shapes_dir, ignore_errors=True)
data_shapes = list_files(
"{base_dir}/data/shapefiles/".format(base_dir=sys.argv[1]))
# place holding shapefiles
log.info("creating placeholder shapefiles", keep_log)
if not os.path.isdir(shapes_dir):
os.makedirs(shapes_dir)
with zipfile.ZipFile(
"{qswatplus_wf_dir}/packages/shapes.dat".format(
logger.info('masking variables where ice thickness < 10m')
nco.ncks(input=exp_file,
output=exp_nc_wd,
variable=','.join([x for x in pvars]),
overwrite=True)
nco.ncap2(input='-6 -s "{}" {}'.format(ncap2_str, exp_nc_wd),
output=exp_nc_wd,
overwrite=True)
opt = [
c.Atted(mode="o",
att_name="_FillValue",
var_name=myvar,
value=fill_value) for myvar in ppvars
]
nco.ncatted(input=exp_nc_wd, options=opt)
for mvar in pvars:
m_exp_nc_wd = 'NETCDF:{}:{}'.format(exp_nc_wd, mvar)
m_exp_gtiff_wd = os.path.join(idir, dir_gtiff,
mvar + '_' + exp_basename + '.tif')
logger.info('Converting variable {} to GTiff and save as {}'.format(
mvar, m_exp_gtiff_wd))
gdal.Translate(m_exp_gtiff_wd, m_exp_nc_wd, options=gdal_gtiff_options)
if mvar == 'usurf':
m_exp_hs_wd = os.path.join(idir, dir_hs,
mvar + '_' + exp_basename + '_hs.tif')
logger.info('Generating hillshade {}'.format(m_exp_hs_wd))
gdal.DEMProcessing(m_exp_hs_wd,
m_exp_nc_wd,
'hillshade',
options=gdal_options)
def get_raster_attribute(self, attribute):
raster = gdal.DEMProcessing('', self.file, attribute, format='MEM')
raster_values = self.get_values_for_raster(raster)
del raster
return raster_values
# demSlopeDS = driver.Create(slopeFilename, demSrcDS.RasterXSize, demSrcDS.RasterYSize,
# demSrcDS.RasterCount, gdal.GDT_Byte, options=['COMPRESS=RLE'])
#
demResultDS = driver.Create(resultFilename, demSrcDS.RasterXSize, demSrcDS.RasterYSize,
demSrcDS.RasterCount, gdal.GDT_Byte, options=['COMPRESS=RLE'])
GeoTransform = demSrcDS.GetGeoTransform()
Projection = demSrcDS.GetProjection()
demResultDS.SetGeoTransform(GeoTransform)
demResultDS.SetProjection(Projection)
#
# demAspectDS.SetGeoTransform(GeoTransform)
# demAspectDS.SetProjection(Projection)
demSlopeDS = gdal.DEMProcessing(slopeFilename, srcFilename, "slope", computeEdges=True)
demAspectDS = gdal.DEMProcessing(aspectFilename, srcFilename, "aspect", computeEdges=True)
rowNum = demSrcDS.RasterYSize
columnNum = demSrcDS.RasterXSize
rowblockNum = int((rowNum - 1) / 1024) + 1
colblockNum = int((columnNum - 1) / 1024) + 1
valueRange = (20,8000)
slopeThreshold = 80
srcBand = demSrcDS.GetRasterBand(1)
slopeBand = demSlopeDS.GetRasterBand(1)
aspectBand = demAspectDS.GetRasterBand(1)
resultBand = demResultDS.GetRasterBand(1)
help="Folder that contains DEM .Tifs or SubFolders containing .Tifs")
parser.add_argument("outputFolder",
type=str,
help="Directory Location for Output Files")
args = parser.parse_args()
# Collect raster images
gTiffs = getRasters(args.inputFolder)
virtualMosaic = gdal.BuildVRT('virtualRaster.vrt', gTiffs)
# Convert Temporary Mosaic to GeoTiff
gdal.Translate(os.path.join(args.outputFolder, 'DEM_Mosaic.tif'),
virtualMosaic)
# Process Slope and Aspect
demSlope = gdal.DEMProcessing(
os.path.join(args.outputFolder, 'DEM_Slope.tif'), virtualMosaic,
"slope")
demAspect = gdal.DEMProcessing(
os.path.join(args.outputFolder, 'DEM_Aspect.tif'), virtualMosaic,
"aspect")
# Convert DEM Mosaic from Meters to Feet
dem = RasterProcessor(
gdal.Open(os.path.join(args.outputFolder, 'DEM_Mosaic.tif')))
demArray = dem.array2raster(footConversion=True)
dem.raster2array(demArray,
os.path.join(args.outputFolder, 'DEM_Mosaic_ft.tif'))
print('{} Seconds'.format(time.time() - sTime))
'/externalCompany/PM2019007_nifs/곰소만_pnu/NDVI/#1_고도_150m'):
# dem_1970_hs_ds = gdal.DEMProcessing('', ds_list[0], 'hillshade', format='MEM')
image_start_time = time.time()
files.sort()
for file in files:
start_time = time.time()
filename = os.path.splitext(file)[0]
extension = os.path.splitext(file)[1]
file_path = root + '/' + file
if extension == '.JPG' or extension == '.jpg':
print('Read the image - ' + file)
# https://gis.stackexchange.com/questions/257109/gdaldem-alpha-flag-in-python-bindings-is-missing
gdal.DEMProcessing(dst_path + file,
file_path,
"color-relief",
colorFilename='NDVI_VGYRM-lut.txt',
format='JPEG')
# colored_vrt = gdal.DEMProcessing('', file_path, "color-relief",
# colorFilename='NDVI_VGYRM-lut.txt', format='MEM')
# gdal.Translate(dst_path + file, colored_vrt, format='JPEG')
print("--- %s seconds ---" % (time.time() - start_time))
elif extension == ".txt":
print('Read the image - ' + file)
shutil.copy(file_path, dst_path + file)
print("--- %s seconds ---" % (time.time() - start_time))
print('*** Processing time ***')
print("--- %s seconds ---" % (time.time() - image_start_time))
