def calc_topo(dem_path):
"""
Calculates slope and aspect from given DEM and saves output.
The function checks to see whether a slope/aspect file has already been created so as to avoid needless processing.
Parameters:
dem_path (pathlib.PosixPath): The relative or absolute path to an input DEM file.
Dependencies:
richdem module
GDAL binaries
pathlib module
"""
slope_path = Path(
str(dem_path).replace("dem", "slope"))
aspect_path = Path(
str(dem_path).replace("dem", "aspect"))
if ((not slope_path.is_file()) or
(not aspect_path.is_file())):
dem = rd.LoadGDAL(str(dem_path))
if not slope_path.is_file():
slope = rd.TerrainAttribute(
dem, attrib='slope_riserun')
rd.SaveGDAL(str(slope_path), slope)
if not aspect_path.is_file():
aspect = rd.TerrainAttribute(dem, attrib='aspect')
rd.SaveGDAL(str(aspect_path), aspect)
def create_slope_aspect(input_file):
arr = rd.LoadGDAL(input_file,
no_data=-9999) #rd.rdarray(input_file,no_data=-9999)
aspect = rd.TerrainAttribute(arr, attrib='aspect')
slope = rd.TerrainAttribute(arr, attrib='slope_radians')
aspect_output = input_file[:-4] + '_aspect.tif'
slope_output = input_file[:-4] + '_slope.tif'
rd.SaveGDAL(aspect_output, aspect)
rd.SaveGDAL(slope_output, slope)
return aspect_output, slope_output
def main():
"""
RichDEM flat resolution: give a gentle slope
"""
# lazy import RICHDEM
try:
import richdem as rd
except:
g.message(
flags="e",
message=("RichDEM not detected. Install pip3 and " +
"then type at the command prompt: " +
'"pip3 install richdem".'),
)
_input = options["input"]
_output = options["output"]
_attribute = options["attribute"]
_zscale = float(options["zscale"])
dem = garray.array()
dem.read(_input, null=np.nan)
rd_input = rd.rdarray(dem, no_data=np.nan)
del dem
rd_output = rd.TerrainAttribute(dem=rd_input,
attrib=_attribute,
zscale=_zscale)
outarray = garray.array()
outarray[:] = rd_output[:]
outarray.write(_output, overwrite=gscript.overwrite())
def TerrainAttribute():
parser = argparse.ArgumentParser(formatter_class=RawTextHelpFormatter, description="""RichDEM Terrain Attribute
A variety of methods are available.
Parameters:
dem -- An elevation model
attrib -- Terrain attribute to calculate. (See below.)
zscale -- How much to scale the z-axis by prior to calculation
Method:
slope_riserun
slope_percentage
slope_degrees
slope_radians
aspect
curvature
planform_curvature
profile_curvature
""")
parser.add_argument('dem', type=str, help='Elevation model')
parser.add_argument('outname', type=str, help='Name of output file')
parser.add_argument('-a', '--attrib', type=str, required=True, help='Terrain attribute to calculate')
parser.add_argument('-z', '--zscale', type=float, default=1.0, help='Scale elevations by this factor prior to calculation')
parser.add_argument('-v', '--version', action='version', version=rd._RichDEMVersion())
args = parser.parse_args()
dem = rd.LoadGDAL(args.dem)
rd._AddAnalysis(dem, ' '.join(sys.argv))
tattrib = rd.TerrainAttribute(dem, attrib=args.attrib, zscale=args.zscale)
rd.SaveGDAL(args.outname, tattrib)
def get_slope(self):
""" TODO """
beau = rd.rdarray(np.load('imgs/beauford.npz')['beauford'], no_data=-9999)
slope = rd.TerrainAttribute(beau, attrib='slope_riserun')
rd.rdShow(slope, axes=False, cmap='jet', figsize=(8,5.5))
pass
def mosaic_slope(url, Projection, Geotransform, Height, Width, Extent,
Resolution):
tile_id = url.split('/')[7]
name = f'{tile_id}.tif'
urllib.request.urlretrieve(
url, '/Users/jackson/Desktop/Execute/' + tile_id + '.tif')
# We must reproject our DEM tile
gdal.Warp(name, name, dstSRS=Projection)
# Now we run the the BTH over our DEM tile
Tile_GeoTiff = gdal.Open(name, 0)
T = Tile_GeoTiff.GetGeoTransform()
P = Tile_GeoTiff.GetProjection()
Tile_Array = rd.LoadGDAL(name)
Slopes = rd.TerrainAttribute(Tile_Array, attrib='slope_riserun')
filename = name
driver = gdal.GetDriverByName('GTiff')
dataset = driver.Create(filename, Slopes.shape[1], Slopes.shape[0], 1,
gdal.GDT_Float32)
dataset.GetRasterBand(1).WriteArray(Slopes)
dataset.SetGeoTransform(T)
dataset.SetProjection(P)
dataset.FlushCache()
dataset = None
# Preparing to add our new tile to the mosaic
src_files_to_mosaic = []
src = rasterio.open('Topo_Slope.tif')
src_files_to_mosaic.append(src)
src = rasterio.open(name)
src_files_to_mosaic.append(src)
os.remove('/Users/jackson/Desktop/Execute/' + tile_id + '.tif')
# Adding to Mosaic
mosaic, out = merge(src_files_to_mosaic,
method='first',
bounds=Extent,
res=Resolution,
nodata=-9999)
mosaic = np.reshape(mosaic, (Height, Width))
# Using GDAL to write the output raster
filename = 'Topo_Slope.tif' # Tiff holding Black Top Hat
driver = gdal.GetDriverByName('GTiff') # Driver for writing geo-tiffs
dataset = driver.Create(filename, Width, Height, 1,
gdal.GDT_Float32) # Creating our tiff file
dataset.GetRasterBand(1).WriteArray(mosaic) # Writing values to our tiff
dataset.SetGeoTransform(Geotransform) # Setting geo-transform
dataset.SetProjection(Projection) # Setting the projection
dataset.FlushCache() # Saving tiff to disk
dataset = None
def curvature(input_file):
"""Create a curvature layer (combine profile and planform curvature) using richdem."""
arr = rd.LoadGDAL(input_file) #rd.rdarray(input_file,no_data=-9999)
curvature = rd.TerrainAttribute(arr, attrib='curvature')
output_file = input_file[:-9] + '_curvature_temp.tif'
head, tail = os.path.split(output_file)
rd.SaveGDAL(output_file, curvature)
createMetadata(
sys.argv,
head + '/') #just remove the filename so you are left with the path
def terrain(elvDs, variable="elevation", fillDem=True, flowMethod='D8'):
out = elvDs.copy()
zScales = {
0: 0.00000898,
10: 0.00000912,
20: 0.00000956,
30: 0.00001036,
40: 0.00001171,
50: 0.00001395,
60: 0.00001792,
70: 0.00002619,
80: 0.00005156
}
# calculat the geospatial information from the dataset
elvDim = [elvDs.dims['lon'], elvDs.dims["lat"]]
xres = float((elvDs.lon[1] - elvDs.lon[0]).values)
yres = float((elvDs.lat[1] - elvDs.lat[0]).values)
xinit = float((elvDs.lon[0]).values) - (xres / 2)
yinit = float((elvDs.lat[0]).values) + (yres / 2)
# get elevation values as np.ndarray
elvVals = np.squeeze(elvDs[variable].values)
rdem = rd.rdarray(elvVals, no_data=np.nan)
rdem.projection = '''GEOGCS["WGS 84",
DATUM["WGS_1984",
SPHEROID["WGS 84",6378137,298.257223563,
AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich",0,
AUTHORITY["EPSG","8901"]],
UNIT["degree",0.0174532925199433,
AUTHORITY["EPSG","9122"]],
AUTHORITY["EPSG","4326"]]
'''
rdem.geotransform = (xinit, xres, 0, yinit, 0, yres)
if fillDem:
filled = rd.FillDepressions(rdem,
epsilon=True,
in_place=False,
topology='D8')
rdem = rd.ResolveFlats(filled, in_place=False)
zScale = zScales[np.around(yinit, decimals=-1)]
slope = rd.TerrainAttribute(rdem, attrib='slope_percentage', zscale=zScale)
accum = rd.FlowAccumulation(rdem, method=flowMethod)
out["slope"] = (('time', 'lat', 'lon'), slope[np.newaxis, :, :])
out["flowAcc"] = (('time', 'lat', 'lon'), accum[np.newaxis, :, :])
return out
def generate_slope_aspect():
"""Generate slope and aspect from DEM."""
dem_ds = xr.open_dataset(
'/Users/kenzatazi/Downloads/GMTED2010_15n015_00625deg.nc')
dem_ds = dem_ds.assign_coords({
'nlat': dem_ds.latitude,
'nlon': dem_ds.longitude
})
dem_ds = dem_ds.sel(nlat=slice(29, 34), nlon=slice(75, 83))
elev_arr = dem_ds.elevation.values
elev_rd_arr = rd.rdarray(elev_arr, no_data=np.nan)
slope_rd_arr = rd.TerrainAttribute(elev_rd_arr, attrib='slope_riserun')
slope_arr = np.array(slope_rd_arr)
aspect_rd_arr = rd.TerrainAttribute(elev_rd_arr, attrib='aspect')
aspect_arr = np.array(aspect_rd_arr)
dem_ds['slope'] = (('nlat', 'nlon'), slope_arr)
dem_ds['aspect'] = (('nlat', 'nlon'), aspect_arr)
streamlined_dem_ds = dem_ds[['elevation', 'slope', 'aspect']]
streamlined_dem_ds.to_netcdf('_Data/SRTM_data.nc')
def pendiente(srcFolder="./", dstFolder="./"):
for archivo in os.listdir(srcFolder):
if archivo.endswith(".tif"):
if srcFolder.endswith("/"):
ruta = srcFolder + archivo
else:
ruta = srcFolder + "/" + archivo
dem = richdem.LoadGDAL(ruta)
slope = richdem.TerrainAttribute(dem, attrib='slope_radians')
archivo = "pendiente_" + archivo
if not os.path.exists(dstFolder):
os.mkdir(dstFolder)
if srcFolder.endswith("/"):
dstRuta = dstFolder + archivo
else:
dstRuta = dstFolder + "/" + archivo
richdem.SaveGDAL(dstRuta, slope)
def _richdem2numpy(rda, attribute):
'''
Parameters
==========
in_array : richdem array
attribute : str
One of 'slope
'''
outfile = TemporaryFile()
np.save(outfile, rd.TerrainAttribute(rda, attrib=attribute))
_ = outfile.seek(0)
out_array = np.load(outfile)
if attribute == 'aspect':
out_array[out_array > 180] = out_array[out_array > 180] - 360
return out_array
else:
return out_array
def add_slope_aspect_curvature(df, file, indexes):
for attr in ['slope_percentage', 'aspect', 'profile_curvature']:
table = None
try:
table = rd.TerrainAttribute(rd.LoadGDAL(file, no_data=-9999),
attrib=attr)
rd.SaveGDAL("./temp.tif", table)
table = None
table = gr.from_file("./temp.tif")
for index in indexes:
try:
row = df.loc[index]
val = table.map_pixel(row['lon'], row['lat'])
df.loc[index, attr] = float(val)
except:
df.loc[index, attr] = np.nan
os.remove("./temp.tif")
except:
for index in indexes:
df.loc[index, attr] = np.nan
return df
def runoff():
# return 788
dem_path = os.path.join(os.getcwd(), 'Konambe_dem_clipped.tif')
village_dem = rd.LoadGDAL(dem_path, no_data=-9999)
rd.FillDepressions(village_dem, epsilon=False, in_place=False)
arr = rd.TerrainAttribute(village_dem,
attrib='slope_percentage',
zscale=1 / 111120)
np.save('out.npy', arr)
demnp = np.load('out.npy')
dem = copy.copy(arr)
dem[np.where((arr > 0) & (arr < 5))] = 1
dem[np.where((arr >= 5) & (arr < 20))] = 2
dem[np.where((arr >= 20))] = 3
c1 = np.count_nonzero(dem == 1)
c2 = np.count_nonzero(dem == 2)
c3 = np.count_nonzero(dem == 3)
area_m2_1 = c1 * 900
area_m2_2 = c2 * 900
area_m2_3 = c3 * 900
area_ha1 = area_m2_1 * 0.0001
area_ha2 = area_m2_2 * 0.0001
area_ha3 = area_m2_3 * 0.0001
#print('area',area_ha1+area_ha2)
worthy_area = area_ha1 + area_ha2
#coeff for rainfall 775mm
runoff1 = area_ha1 * 1.0791
runoff2 = area_ha2 * 1.6186
runoff3 = area_ha3 * 2.1583
#coeff for rainfall 725mm
#runoff1=area_ha1*1.0791
#runoff2=area_ha2*1.3878
#runoff3=area_ha3*1.8496
tot_runoff = runoff1 + runoff2 + runoff3
return tot_runoff, worthy_area
#r=runoff()
def main():
"""
RichDEM flat resolution: give a gentle slope
"""
options, flags = gscript.parser()
_input = options['input']
_output = options['output']
_attribute = options['attribute']
_zscale = float(options['zscale'])
dem = garray.array()
dem.read(_input, null=np.nan)
rd_input = rd.rdarray(dem, no_data=np.nan)
del dem
rd_output = rd.TerrainAttribute(dem=rd_input, attrib=_attribute,
zscale=_zscale)
outarray = garray.array()
outarray[:] = rd_output[:]
outarray.write(_output, overwrite=gscript.overwrite())
def process_dem(self, global_dem=''):
''' Download DEM from AWS, calculate slope
'''
# Download DEM
if not os.path.exists(self.dem_file) and global_dem == '':
tPrint("Downloading DEM")
elevation.clip(bounds=self.inD.total_bounds, max_download_tiles=90000, output=self.dem_file, product='SRTM3')
if not os.path.exists(self.dem_file) and not global_dem == '':
tPrint("Downloading DEM")
rMisc.clipRaster(rasterio.open(global_dem), self.inD, self.dem_file)
# Calculate slope
if not os.path.exists(self.slope_file) and os.path.exists(self.dem_file):
tPrint("Calculating slope")
in_dem = rasterio.open(self.dem_file)
in_dem_data = in_dem.read()
beau = richdem.rdarray(in_dem_data[0,:,:], no_data=in_dem.meta['nodata'])
slope = richdem.TerrainAttribute(beau, attrib='slope_riserun')
meta = in_dem.meta.copy()
meta.update(dtype = slope.dtype)
with rasterio.open(self.slope_file, 'w', **meta) as outR:
outR.write_band(1, slope)
#Load the data and convert it to an array for RichDEM fname = 'L:/feather_river_mixing_paper/dem/pomd_out.tif' # Loading the raster with rasterio raster = rd.LoadGDAL(fname) #rasterfig = rd.rdShow(raster, ignore_colours=[0], axes=False, cmap='gist_earth', figsize=(8,5.5)) raster_filled = rd.FillDepressions(raster, epsilon=True, in_place=False) #rasterfig_filled = rd.rdShow(raster_filled, ignore_colours=[0], axes=False, cmap='gist_earth', vmin=rasterfig['vmin'], vmax=rasterfig['vmax'], figsize=(8,5.5)) accum_d8 = rd.FlowAccumulation(raster_filled, method='D8') #d8_fig = rd.rdShow(accum_d8, figsize=(8,5.5), axes=False, cmap='jet') slope = rd.TerrainAttribute(raster_filled, attrib='slope_riserun') #rd.rdShow(slope, axes=False, cmap='jet', figsize=(8,5.5)) profile_curvature = rd.TerrainAttribute(raster_filled, attrib='curvature') #rd.rdShow(profile_curvature, axes=False, cmap='jet', figsize=(8,5.5)) print(raster) temp = np.flip(raster, 0) raster = temp print(raster) y = np.size(raster, 1) x = np.size(raster, 0) print(np.shape(raster)) #Creates a flow direction raster gradient = np.empty((8, x - 2, y - 2), dtype=np.float) print(np.shape(gradient))
### If you do not want to aggregate DEM, comment out the following to two lines
if aggregate:
os.system('gdalwarp -tr ' + aggregate_degree + ' ' + aggregate_degree +
' -r average ' + dem_path_tif + ' ' + dem_path_tif_temp2)
dem_path_tif = dem_path_tif_temp2
### convert DEM from tif to NetCDF
os.system('gdal_translate -of NETCDF ' + dem_path_tif + ' ' + dem_path)
### calculate slope as NetCDF from DEM
os.system('gdaldem slope -of NETCDF ' + dem_path + ' ' + slope_path +
' -s 111120')
### calculate aspect from DEM
aspect = np.flipud(
rd.TerrainAttribute(rd.LoadGDAL(dem_path_tif, no_data=np.nan),
attrib='aspect'))
### calculate mask as NetCDF with DEM and shapefile
os.system(
'gdalwarp -of NETCDF --config GDALWARP_IGNORE_BAD_CUTLINE YES -cutline ' +
shape_path + ' ' + dem_path_tif + ' ' + mask_path)
### open intermediate netcdf files
dem = xr.open_dataset(dem_path)
mask = xr.open_dataset(mask_path)
slope = xr.open_dataset(slope_path)
### set NaNs in mask to -9999 and elevation within the shape to 1
mask = mask.Band1.values
mask[np.isnan(mask)] = -9999
mask[mask > 0] = 1
def transform_slope(self):
self.dem_data = rd.rdarray(self.dem_data, no_data=-9999)
self.dem_data = rd.TerrainAttribute(self.dem_data,
attrib='slope_riserun')
#del pre_φdtm
φdtm[φdtm == 100000] = np.NaN
plt.imshow(
φdtm,
cmap='Greys') # displays better if first φdtm[φdtm == 100000] = np.NaN
plt.title(f'c = {c}')
#%% [markdown]
# Next we calculate the slope surface ```φslope```; max slope parameter, ```Slmin```; and min slope parameter,```Slmax```. In this case, Slmin
# and Slmax are established from the 65% and 90% quantiles of the cell
# values of the slope surface. We will use the handy TerrainAttribute function from RichDEM to find. ```φslope``'.
#%%
rda = rd.rdarray(φdtm, no_data=np.NaN)
φslope = rd.TerrainAttribute(rda, attrib='slope_riserun')
Slmin, Slmax = np.nanpercentile(φslope, [65, 90])
#%% [markdown]
# Then we classify points as ground if they are within δh of the reference surface given
# by φdtm, and calculate the penetrability surfac, eφpnt.#%% [markdown]
# Then we classify points as ground if they are within δh of the reference surface given
# by φdtm, and calculate the penetrability surfac, eφpnt.
#%%
# Classify as ground (2) if δi <= δh
S['Classification'] = (S['Z'] - φdtm[S['gridX'], S['gridY']] <= δh) * 2
# create φpnt
#φpnt = np.full_like(φdtm, np.NaN)
#x, y = φdtm.shape[0], φdtm.shape[1]
from osgeo import gdal filepath = r"c:\Users\Darshan\Desktop\nagpur\output.tif" # Open the file: raster = gdal.Open(filepath) # In[97]: raster = os.path.join(os.getcwd(), filepath) nagpur_dem = rd.LoadGDAL(raster) # In[98]: slope = rd.TerrainAttribute(nagpur_dem, attrib='slope_riserun') rd.rdShow(slope, axes=False, cmap='magma', figsize=(8, 5.5)) plt.show() # In[161]: slope # In[130]: slope.shape # In[163]: driver = "GTiff"
# First, specify outputfile path
out_tif = "data/ASTERGDEM3/Processed/Elevation_5min.tif"
with rasterio.open(out_tif, "w", **out_meta) as dest:
dest.write(elevation_low)
# =============================
# 3. Calculate slope and aspect
# 3.1. 30`` resolution
# Read elevarion with rd.LoadGDAL
elevation_raw = rd.LoadGDAL("data/ASTERGDEM3/Processed/Elevation_30s.tif",
no_data=-9999)
# Calculate slope
slope = rd.TerrainAttribute(elevation_raw, attrib='slope_riserun')
rd.rdShow(slope, axes=False, cmap='magma', figsize=(8, 5.5))
# Export as tif
rd.SaveGDAL("data/ASTERGDEM3/Processed/Slope_30s.tif", slope)
# Calculate aspect
aspect = rd.TerrainAttribute(elevation_raw, attrib='aspect')
rd.rdShow(aspect, axes=False, cmap='jet', figsize=(8, 5.5))
# Export as tif
rd.SaveGDAL("data/ASTERGDEM3/Processed/Aspect_30s.tif", aspect)
# 3.2. 2.5` resolution
# Read elevarion with rd.LoadGDAL
bbox = [args.ulx, args.uly, args.lrx, args.lry]
jimdem = pj.Jim(Path(demfn),
bbox=bbox,
tileindex=args.tileindex,
tiletotal=args.tiletotal,
overlap=args.overlap)
else:
jimdem = pj.Jim(Path(demfn),
tileindex=args.tileindex,
tiletotal=args.tiletotal,
overlap=args.overlap)
if args.t_srs is not None:
jimdem.geometry.warp(args.t_srs)
if args.output_dem is not None:
jimdem.io.write(args.output_dem, co=['COMPRESS=LZW', 'TILED=YES'])
jimdem.pixops.convert('GDT_Float32')
jimdem[jimdem <= 0] = -9999
dem_richdem = rd.rdarray(jimdem.np(), no_data=-9999)
dem_richdem.geotransform = jimdem.properties.getGeoTransform()
dem_richdem.projection = jimdem.properties.getProjection()
slope = rd.TerrainAttribute(dem_richdem, attrib=args.attribute)
jimdem.np()[:] = slope
jimdem.properties.setNoDataVals(-9999)
jimdem.io.write(args.output, co=['COMPRESS=LZW', 'TILED=YES'])
dem = xr.open_dataset(dem_path)
dem_tif = rd.LoadGDAL(dem_path_tif)
dem_tif2 = rasterio.open(dem_path_tif)
with fiona.open(shape_path, "r") as shapefile:
features = [feature["geometry"] for feature in shapefile]
with rasterio.open(dem_path_tif) as src:
out_image, out_transform = rasterio.mask.mask(src,
features,
crop=False,
nodata=-9999)
out_meta = src.meta.copy()
slope = xr.DataArray(rd.TerrainAttribute(dem_tif, attrib='slope_degrees'))
#rd.rdShow(slope, axes=False, cmap='magma', figsize=(8, 5.5))
#plt.show()
aspect = xr.DataArray(rd.TerrainAttribute(dem_tif, attrib='aspect'))
#rd.rdShow(aspect, axes=False, cmap='jet', figsize=(8, 5.5))
#plt.show()
mask = out_image[0, :, :]
mask[mask > 0] = 1
ds = xr.Dataset()
ds.coords['longitude'] = dem.lon.values
ds.longitude.attrs['standard_name'] = 'longitude'
ds.longitude.attrs['long_name'] = 'longitude'
import richdem as rd
import numpy as np
import matplotlib.pyplot as plt
dem = rd.LoadGDAL("/media/jayanthmouli/54EC-046F/elevation/the_better_one.tif",
no_data=0)
slope = rd.TerrainAttribute(dem, attrib='slope_riserun')
# rd.rdShow(slope, axes=False, cmap='magma', figsize=(8, 5.5))
# plt.show()
aspect = rd.TerrainAttribute(dem, attrib='aspect')
rd.rdShow(aspect, axes=False, cmap='jet', figsize=(8, 5.5))
plt.show()
print aspect.shape
cnt = 0
for index, row in table_y.iterrows():
try:
val = table.map_pixel(row['LONWGS84'], row['LATWGS84'])
table_y.loc[index, 'ELEVATION'] = float(val)
cnt += 1
except:
table_y.loc[index, 'ELEVATION'] = 0
print("Added elevation information to " + repr(cnt) + " instances out of " +
repr(len(table_y)) + " data instances...")
print("Computing information on terrain slope...")
for attr in ['slope_percentage', 'aspect', 'profile_curvature']:
table_y[attr.upper()] = 0.0
table = None
table = rd.TerrainAttribute(
rd.LoadGDAL("./globcover/digital-elevation-model.tif"), attrib=attr)
rd.SaveGDAL("./slope.tif", table)
table = None
NDV, xsize, ysize, GeoT, Projection, DataType = gr.get_geo_info(
"./slope.tif")
table = gr.from_file("./slope.tif")
cnt = 0
for index, row in table_y.iterrows():
try:
val = table.map_pixel(row['LONWGS84'], row['LATWGS84'])
table_y.loc[index, attr.upper()] = float(val)
cnt += 1
except:
table_y.loc[index, attr.upper()] = 0.0
os.remove("./slope.tif")
print("Added " + attr + " information to " + repr(cnt) +
def engineTopo(in_path='None',out_path='None',shpfilepath='None',drm_filepath='None',\
products=[],bandStacks=[],is_topocorrection=False,SunElevation=30,\
SunAzimuth=180,fileext="tif"):
time_start = time.time()
#some sample parameters for the topocorrection
#is_topocorrection=True; #topocorrection flag
#SunElevation=28.41189977 #31.23944509
#SunAzimuth=163.93705102 #163.133415
#Sun Elevation L1 31.73425917
#Sun Azimuth L1 162.99110733
"""
#for 105-029
#SunElevation=31.23944509
#SunAzimuth=163.133415
"""
if (drm_filepath == 'None'):
is_topocorrection = False
SolarZenith = 90 - SunElevation
"""
You may exclude files from processing by renaming like ".tiff"
"""
#files for processing, input and output directory
#pathrowfolder="104_029"
#datefolder="2015_11_05"
#imgfilepath=os.path.join("..","Landsat8",pathrowfolder,datefolder);
#shpfilepath=os.path.join("..","shp",pathrowfolder+".shp");
#shpfilepath=os.path.join("..","shp","AOI_tmp"+".shp");
#fileext="tif"; #extention for files
#outdir=os.path.join("..","Landsat8_Processed",pathrowfolder,datefolder);
dir_cropped = "cropped_bands_topo" #dir for AOI cropped
dir_crop_path = os.path.join(out_path, dir_cropped)
dir_products = "products_topo"
dir_products_path = os.path.join(out_path, dir_products)
band_number_inname = '_b%N%.' #%N% - for band number e.g. LC81050292016143LGN00_B6.TIF NOT A CASE SENSITIVE
band_number_inname = band_number_inname.lower()
excl_pfix = '_b8'
#endfile postfix to exclude from processing
#drm for topocorrection
#drm_name="mosaic_dem_south_kuril_utm.tif";
#drm_folder=os.path.join("..","SRTM","files_for_mosaic");
#drm_filepath=os.path.join(drm_folder,drm_name);
#nodata srtm -32768
#check is file/folder exists
#print(os.path.isdir("/home/el"))
#print(os.path.exists("/home/el/myfile.txt"))
#
file_for_crop = []
try:
for file in os.listdir(in_path):
#file=file.lower();
if file.lower().endswith("." + fileext.lower()) and (
file.lower().endswith(excl_pfix + '.' +
fileext.lower())) == False:
file_for_crop.append(file)
print(file + " was added to crop queue.")
except (FileNotFoundError):
print("Input image folder doesn\'t exist...")
"""
ДОПОЛНЕНИЯ в GUI сделать генерацию AOI shp выделением на изображении, если пользователь не генерирует
AOI, то AOI задать по размеру изображения
"""
#STEP 0. Prepare for the topocorrection
try:
shp_extent = get_shp_extent(shpfilepath)
except:
print("Can not read shp AOI file. Applying extent from geotiff")
gdal_object_tmp = gdal.Open(os.path.join(in_path, file_for_crop[0]))
tmp_xsize = gdal_object_tmp.RasterXSize
tmp_ysize = gdal_object_tmp.RasterYSize #x and y raster size in pixels
tmp_gt = gdal_object_tmp.GetGeoTransform()
tmp_ext = GetExtent(tmp_gt, tmp_ysize, tmp_xsize)
shp_extent = [
tmp_ext[0][0], tmp_ext[2][0], tmp_ext[1][1], tmp_ext[3][1]
]
#crop dem file
if is_topocorrection == True:
print("Perform cropping of srtm")
#read DEM geotiff
srtm_gdal_object = gdal.Open(drm_filepath)
srtm_band = srtm_gdal_object.GetRasterBand(1)
srtm_band_array = srtm_band.ReadAsArray()
#get spatial resolution
srtm_gt = srtm_gdal_object.GetGeoTransform()
srtm_xsize = srtm_gdal_object.RasterXSize
srtm_ysize = srtm_gdal_object.RasterYSize #x and y raster size in pixels
srtm_ext = GetExtent(
srtm_gt, srtm_ysize,
srtm_xsize) #[[влx,влy],[нлx,нлy],[нпy, нпy],[впx, впy]]
#resolution in meters
srtm_dpx = (srtm_ext[3][0] - srtm_ext[0][0]) / srtm_xsize
srtm_dpy = (srtm_ext[0][1] - srtm_ext[2][1]) / srtm_ysize
"""
print("srtm_ext={}".format(srtm_ext))
print("shp_extent={}".format(shp_extent))
"""
if check_shp_inside_raster(srtm_ext, shp_extent):
# sampleSrtmImage,ColMinIndSRTM,RowMinIndSRTM =crop_by_shp(shp_extent,srtm_ext,\
# srtm_dpx,srtm_dpy,srtm_band_array);
srtm_band = rd.LoadGDAL(drm_filepath)
slope = rd.TerrainAttribute(srtm_band, attrib='slope_degrees')
aspect = rd.TerrainAttribute(srtm_band, attrib='aspect')
rd.SaveGDAL(
os.path.join(os.path.dirname(drm_filepath),
"aspectInitialRes.tif"), aspect)
rd.SaveGDAL(
os.path.join(os.path.dirname(drm_filepath),
"SlopeInitialRes.tif"), slope)
else:
print("AOI shp file" + shpfilepath + "is not inside of DEM" +
drm_filepath + ". Stopping.")
return -1
#input('Press Enter for exit...')
#exit;
#reopening SRTM products
#read srtm products
aspect_gdal_object = gdal.Open(
os.path.join(os.path.dirname(drm_filepath),
"aspectInitialRes.tif")) #aspect
aspect_band = aspect_gdal_object.GetRasterBand(1)
aspect_band_array = aspect_band.ReadAsArray()
slope_gdal_object = gdal.Open(
os.path.join(os.path.dirname(drm_filepath),
"SlopeInitialRes.tif")) #slope
slope_band = slope_gdal_object.GetRasterBand(1)
slope_band_array = slope_band.ReadAsArray()
#get PRODUCTS spatial resolution
srtm_gt, srtm_xsize, srtm_ysize, srtm_ext, srtm_dpx, srtm_dpy = getGeotiffParams(
aspect_gdal_object)
#check if SRTM products inside of SHP AOI ad crop it
if check_shp_inside_raster(srtm_ext, shp_extent):
#do image crop
aspect_cropped, ColMinInd, RowMinInd = crop_by_shp(
shp_extent, srtm_ext, srtm_dpx, srtm_dpy, aspect_band_array)
slope_cropped, ColMinInd, RowMinInd = crop_by_shp(
shp_extent, srtm_ext, srtm_dpx, srtm_dpy, slope_band_array)
#for testing purporses
saveGeoTiff(slope_cropped, 'test_crop_slope.tif',
slope_gdal_object, ColMinInd,
RowMinInd) #tryna save cropped geotiff
else:
print("SRTM is outside of the AOI, exiting...")
return -1
#exit();
was_corrected = False
#flag to check if resolution and scale were corrected to landsat8
#STEP 1. CROP geotiffs one by one with AOI shape file
print("Step. 1. Starting geotiff crop operation...")
for myfile in file_for_crop:
#read geotiff
gdal_object = gdal.Open(os.path.join(in_path, myfile))
band = gdal_object.GetRasterBand(1)
band_array = band.ReadAsArray()
#get spatial resolution
#do image crop
gt, xsize, ysize, ext, dpx, dpy = getGeotiffParams(gdal_object)
"""
gt=gdal_object.GetGeoTransform()
xsize = gdal_object.RasterXSize
ysize = gdal_object.RasterYSize #x and y raster size in pixels
ext=GetExtent(gt,ysize,xsize) #[[влx,влy],[нлx,нлy],[нпy, нпy],[впx, впy]]
#resolution in meters
dpx=(ext[3][0]-ext[0][0])/xsize
dpy=(ext[0][1]-ext[2][1])/ysize
print(ext)
"""
#apply shp file
#try:
# shp_extent=get_shp_extent(shpfilepath);
#except:
# print("Can not read shp AOI file.")
#check shp posiiton inside of tiff
if check_shp_inside_raster(ext, shp_extent):
#do image crop
sampleImage, ColMinInd, RowMinInd = crop_by_shp(
shp_extent, ext, dpx, dpy, band_array)
else:
print("AOI shp file" + shpfilepath + "is not inside of tiff" +
myfile + ". Stopping.")
#input('Press Enter for exit...')
return -1
#exit;
#topocorrection
if is_topocorrection == True: #topocorrection flag
if was_corrected == False:
print('compute slope and aspect cropped')
#коррекция aspect по Landsat8
#adjust srtm resolution to landsat8
[hlc, wlc] = np.shape(sampleImage)
aspect_band_cropped = resize(
aspect_cropped, (hlc, wlc),
preserve_range=True,
mode="wrap") #it works with scikit-image resize
#коррекция slope по Landsat8
slope_band_cropped = resize(
slope_cropped, (hlc, wlc),
preserve_range=True,
mode="wrap") #it works with scikit-image resize
Cos_i=np.cos(np.deg2rad(slope_band_cropped))*np.cos(np.deg2rad(SolarZenith))+\
np.sin(np.deg2rad(slope_band_cropped))*np.sin(np.deg2rad(SolarZenith))*\
np.cos(np.deg2rad(SunAzimuth-aspect_band_cropped))
#ЭТОТ РАСЧЕТ КОС I РАССМАТРИВАЕТ ВСЕ СКЛОНЫ КАК ОСВЕЩЕННЫЕ ПОД ПРЯМЫМ УГЛОМ!
#Cos_i=np.cos(np.deg2rad(SolarZenith-slope_band_cropped));
#Do SCS+C correction anyway
"""
print("Check correlation between Cos(i) and Luminocity")
R_mat=np.corrcoef(Cos_i.ravel(),sampleImage.ravel())
print("R="+str(R_mat[0,1]));
if( R_mat[0,1]<0.5):
print("No or weak correlation, use SCS algoritm...");
C=0;
else:
print("Not a weak correlation, use SCS+C algoritm...");
(b,a)=np.polyfit(Cos_i.ravel(),sampleImage.ravel(),1);
C=a/b;
"""
(b, a) = np.polyfit(Cos_i.ravel(), sampleImage.ravel(), 1)
C = a / b
was_corrected = True
#switch the flag to true
print("Performing topographic correction.. Please, WAIT..")
#Sun-Canopy-Sensor Correction (SCS)+C
band_array=np.uint16(sampleImage*\
((np.cos(np.deg2rad(SolarZenith))*np.cos(np.deg2rad(slope_band_cropped))+C)\
/(C+Cos_i)))
pic_show(sampleImage, "landsat initial")
hist_show(sampleImage)
pic_show(band_array, "landsat SCS corrected")
hist_show(band_array)
else: #no topocorrection
print("No topocorrection was selected..")
band_array = copy.copy(sampleImage)
#no operation
#check shp posiiton inside of tiff
#if check_shp_inside_raster(ext,shp_extent):
# #do image crop
#sampleImage,ColMinInd,RowMinInd =crop_by_shp(shp_extent,ext,dpx,dpy,band_array)
#if is_topocorrection==True: #topocorrection flag
# #do topocorrection with SCS Algorythm
#drop image to the disk
print("drop image to the disk")
outfilename = os.path.join(dir_crop_path, "crop_" + myfile.lower())
if not os.path.isdir(dir_crop_path):
os.makedirs(dir_crop_path) #create output directory if none
try:
saveGeoTiff(band_array, outfilename, gdal_object, ColMinInd,
RowMinInd) #save topocorrected Landsat crop
except:
print(
"Can not write on a disk... and/or error(s) in saveGeoTiff function"
)
#STEP 2. COMPUTE pseudocolor RGB stacks and satellite indexes
"""
автоопределение BANDs для дефолтных имен, если пользователь не задал имена (пока что имена по умолчанию),
пропускаем индекс или RGB стек, если не находим BAND NUMBER
"""
print("Step. 2. Getting names of the cropped files...")
#getting names of the cropped files, aquire band names
file_for_processing = []
try:
for file in os.listdir(
dir_crop_path
): #набираем файлы из папки с кадрированными изображениями
file = file.lower()
if file.endswith("." + fileext.lower()):
file_for_processing.append(file)
print(file + " was added to the processing queue.")
except (FileNotFoundError):
print("Input image folder doesn\'t exist...")
bands = {}
#dictionary storing band names
for myfile in file_for_processing:
for N in range(1, 9):
#populating bands dictionary
if band_number_inname.replace('%n%', str(N), 1) in myfile:
try:
gdal_object = gdal.Open(
os.path.join(dir_crop_path, myfile)
) #as new gdal_object was created, no more ColMinInd,RowMinInd
bands['band' +
str(N)] = gdal_object.GetRasterBand(1).ReadAsArray()
except:
print("Error! Can not read cropped bands!")
#print("Bands dictionary output:")
#print(bands)
try:
#create RGB stacks:
#truecolor
if ('rgb' in bandStacks):
truecolorRGB = image_stack(bands['band4'],
bands['band3'],
bands['band2'],
do_norm8=0,
do_show=0)
#Комбинация 7-4-2. Изображение близкое к естественным цветам, позволяет анализировать состояние атмосферы и дым. Здоровая растительность выглядит ярко зеленой, ярко розовые участки детектируют открытую почву, коричневые и оранжевые тона характерны для разреженной растительности.
if ('742' in bandStacks):
b742RGB = image_stack(bands['band7'],
bands['band4'],
bands['band2'],
do_norm8=0,
do_show=0)
#Комбинация 5-4-1. Изображение близкое к предыдущему, позволяет анализировать сельскохозяйственные культуры
if ('652' in bandStacks):
b652RGB = image_stack(bands['band6'],
bands['band5'],
bands['band2'],
do_norm8=0,
do_show=0)
#Комбинация 4-5-3. Изображение позволяет четко различить границу между водой и сушей, с большой точностью будут детектироваться водные объекты внутри суши. Эта комбинация отображает растительность в различных оттенках и тонах коричневого, зеленого и оранжевого, дает возможность анализа влажности и полезны при изучении почв и растительного покрова.
if ('453' in bandStacks):
b453RGB = image_stack(bands['band4'],
bands['band5'],
bands['band3'],
do_norm8=0,
do_show=0)
#after Aydal, 2007
if ('642' in bandStacks):
b642RGB = image_stack(bands['band6'],
bands['band4'],
bands['band2'],
do_norm8=0,
do_show=0)
if ('765' in bandStacks):
b765RGB = image_stack(bands['band7'],
bands['band6'],
bands['band5'],
do_norm8=0,
do_show=0)
if ('764' in bandStacks):
b764RGB = image_stack(bands['band7'],
bands['band6'],
bands['band4'],
do_norm8=0,
do_show=0)
#create indexes
if ('NDVI' in products):
NDVI = (bands['band5'] - bands['band4']) / (
bands['band5'] + bands['band4']) #NDVI
if ('IOA' in products) or ('CA' in products):
IOA = (bands['band4'] / bands['band2']
) #Iron oxide alteration [Doğan Aydal, 2007]
if ('HA' in products) or ('CA' in products):
HA = (bands['band7'] / bands['band2']
) #Hydroxyl alteration [Doğan Aydal, 2007]
if ('CM' in products):
CM = (bands['band7'] / bands['band6']
) #Clay minerals [Doğan Aydal, 2007]
#compute PCA
if ('PC' in products):
print("Started to compute PCA...")
print("Flatten image matrix...")
flattened_img_matrix=mat4pca((bands['band1'],bands['band2'],bands['band3'],\
bands['band4'],bands['band5'],bands['band6'],bands['band7']))
#mybands=[bands['band1'],bands['band2'],bands['band3'],\
# bands['band4'],bands['band5'],bands['band6'],bands['band7']]
#tmp_matrix=[mynormalize16to8(tmpband) for tmpband in mybands]
#flattened_img_matrix=mat4pca(tmp_matrix) #same but images are normalized to uint8
print("Compute PCA matrix, the variance and the mean...")
m, n = np.shape(bands['band3']) #temporary height and width
(pca, eigenvalues, var_X,
mean_X) = pca_make(flattened_img_matrix, 7, m, n)
#create cumulative image composite image of the hydroxyl image(red band), the iron oxide image
#(green band) and the average of these two images (blue band).
if ('CA' in products):
index_composite = image_stack(HA, IOA, (HA + IOA) / 2, 1, 0)
except:
print('No bands or bands error!')
return -1
#GENERAL OUTPUT
if ('PC' in products):
print("Prepare to show PCA images")
#later incorporate path into functions
if not os.path.isdir(dir_products_path):
os.makedirs(
dir_products_path) #create output products directory if none
fig_save_cumsum_path = os.path.join(dir_products_path,
"variance_cumsum.svg")
fig_save_pca_path = os.path.join(dir_products_path, "pca_comp.png")
#num_comp=show_pca_cumsum(pca,fig_save_cumsum_path); #pca variance cumsum to determine right number of components
#show_pca_images(eigenvalues,mean_X,m,n,fig_save_pca_path) #show pca component images
#COMPUTE Landsat and PCA stat for the CROSTA METHOD
try:
stat_bands_save = os.path.join(dir_products_path, "bands_stat.xls")
cor_bands_save = os.path.join(dir_products_path, "bands_cor_stat.xls")
cov_bands_pca_save = os.path.join(dir_products_path,
"bands_pca_cov_stat.xls")
print("Saving band stat to {}".format(stat_bands_save))
save_landsat_bands_stat(bands, stat_bands_save)
print("Saving bands mutual correlation to {}".format(cor_bands_save))
save_landsat_mutual_cor(bands, cor_bands_save)
except:
print('can not save band stats')
try: #correlation of bands and PCA comp may be potentially errorneous, dep on PCA number
print(
"Saving covariance between bands and PCA components to {}".format(
cov_bands_pca_save))
save_landsat_pca_cov(bands, eigenvalues, cov_bands_pca_save)
except:
print('Can not compute/save pca/bands covariance...')
#save RGB's and index to the disk
print("Saving products on a disk")
if not os.path.isdir(dir_products_path):
os.makedirs(dir_products_path) #create output directory if none
try:
print("Saving RGBs...")
ColMinInd = 0
RowMinInd = 0
#because we work on already cropped pictures
if ('rgb' in bandStacks):
saveGeoTiff(
truecolorRGB,
os.path.join(dir_products_path, "truecolorRGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('742' in bandStacks):
saveGeoTiff(b742RGB,
os.path.join(dir_products_path, "b742RGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('652' in bandStacks):
saveGeoTiff(b652RGB,
os.path.join(dir_products_path, "b652RGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('453' in bandStacks):
saveGeoTiff(b453RGB,
os.path.join(dir_products_path, "b453RGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
#Aydal pseudocolor:
if ('642' in bandStacks):
saveGeoTiff(b642RGB,
os.path.join(dir_products_path, "b642RGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('765' in bandStacks):
saveGeoTiff(b765RGB,
os.path.join(dir_products_path, "b765RGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('764' in bandStacks):
saveGeoTiff(b764RGB,
os.path.join(dir_products_path, "b764RGB" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
print("Saving Indexes...")
if ('NDVI' in products):
saveGeoTiff(NDVI, os.path.join(dir_products_path, "NDVI" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('IOA' in products):
saveGeoTiff(IOA, os.path.join(dir_products_path, "IOA" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('HA' in products):
saveGeoTiff(HA, os.path.join(dir_products_path, "HA" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('CM' in products):
saveGeoTiff(CM, os.path.join(dir_products_path, "CM" + ".tif"),
gdal_object, ColMinInd, RowMinInd)
if ('CA' in products):
saveGeoTiff(
index_composite,
os.path.join(dir_products_path,
"CumulativeAlteration" + ".tif"), gdal_object,
ColMinInd, RowMinInd)
if ('PC' in products):
print("Saving PCA components...")
print("Result for the RANDOMIZED solver")
for ev in range(0, len(eigenvalues[:, 1, 1])):
PCAcomp = eigenvalues[ev, :, :].reshape(m, n)
saveGeoTiff(
PCAcomp,
os.path.join(dir_products_path,
"PCA{}_".format(ev + 1) + ".tif"),
gdal_object, ColMinInd, RowMinInd)
print("Products data were saved.")
return 1
except:
print(
"Can not write PRODUCTS on a disk... and/or error(s) in saveGeoTiff function"
)
return -1
print("Operations were finished. It took {} sec".format(time.time() -
time_start))
def loadfigures(pathascii, pathvis16R, pathxy, filename):
'''
pathascii = 'D:/ANALYSIS/SIMPLECRATERS_MOON/SLDEM_2013_COLDSPOTS/ascii/'
pathvis8R = 'D:/ANALYSIS/SIMPLECRATERS_MOON/SLDEM_2013_COLDSPOTS/ascii_visible8R/'
pathvis32R = 'D:/ANALYSIS/SIMPLECRATERS_MOON/SLDEM_2013_COLDSPOTS/ascii_visible/'
pathxy = 'D:/ANALYSIS/SIMPLECRATERS_MOON/SLDEM_2013_COLDSPOTS/double_detrending/data/'
pathascii = '/uio/kant/geo-ceed-u1/nilscp/Desktop/astra/TMP_DOWNLOAD/ascii/'
pathvis8R = '/uio/kant/geo-ceed-u1/nilscp/Desktop/astra/TMP_DOWNLOAD/ascii_visible8R/'
pathvis32R = '/uio/kant/geo-ceed-u1/nilscp/Desktop/astra/TMP_DOWNLOAD/ascii_visible/'
pathxy = 'D:/ANALYSIS/SIMPLECRATERS_MOON/SLDEM_2013_COLDSPOTS/double_detrending/data/'
filename = 'cpcrater0000'
'''
name_ascii = pathascii + filename + '.asc'
name_crater_txt = pathxy + filename + 'XY.txt'
name_vis16R = pathvis16R + filename + '_visible.asc'
# should be good this way
data = readASCII(name_ascii)
datavis16R = readASCII(name_vis16R)
# load data and constrain size of the array
(xc, yc, data, ncenterx,
ncentery) = constrainASCII(pathascii, name_ascii, data)
(xcv1, ycv1, datav1, ncenterxv1,
ncenteryv1) = constrainASCII(pathvis16R, name_vis16R, datavis16R)
# load xy
dataxy = np.loadtxt(name_crater_txt, skiprows=1, delimiter=";")
datax = dataxy[:, 0]
datay = dataxy[:, 1]
# slope
datareload = rd.rdarray(data, no_data=-9999)
slope = rd.TerrainAttribute(datareload, attrib='slope_riserun')
# profile_curvatyre
pfc = rd.TerrainAttribute(datareload, attrib='profile_curvature')
# planform curvature
pfc2 = rd.TerrainAttribute(datareload, attrib='planform_curvature')
# curvature
pfc3 = rd.TerrainAttribute(datareload, attrib='curvature')
# I could calculate the slope and the curvature and then plot it
# plot figures (1) visible 32R, (1) visible 8R, (2) DTM 8R, (3) Slope 8R, (4) Curvature 8R
# when (4) is open, engage
fig2 = plt.figure(1)
plt.pcolormesh(xcv1, ycv1, datav1)
plt.colorbar()
fig3 = plt.figure(2)
plt.pcolormesh(xc, yc, data)
plt.colorbar()
fig4 = plt.figure(3)
plt.pcolormesh(xc, yc, slope)
plt.colorbar()
return fig4
f"{topography}_proj.tif", f"dem.tif") # Clip Hand
else:
clip_to_boundary(f"RawFiles/Hand/{huc12[:-6]}", out_dir, geom,
f"{topography}_proj.tif",
f"{topography}.tif") # Clip Hand
# clip_to_boundary("RawFiles/Topography", out_dir, geom, f"elevation.tif",
# f"dem.tif")
# clip_to_boundary("RawFiles/Topography", out_dir, geom, f"texas_slope.tif",
# f"slope.tif")
gc.collect() # clean up ram
in_elevation = os.path.join(out_dir, f"dem.tif")
dem = rd.LoadGDAL(in_elevation)
rd.FillDepressions(dem, epsilon=True, in_place=True)
slope = rd.TerrainAttribute(dem, attrib='slope_riserun')
rd.SaveGDAL(os.path.join(out_dir, 'slope.tif'), slope)
accum_d8 = rd.FlowAccumulation(dem, method='D8')
rd.SaveGDAL(os.path.join(out_dir, 'FlowAccumulation.tif'), accum_d8)
# Once slope and flow acculation are clipped then TWI can be calculated.
clip_twi(out_dir)
# This clips rainfall intensities for specific storms. Not necessary for the first analysis but needed later down the line.
# for hr in [1, 2, 3, 4, 8, 12, 24, ]:
# for storm in [
# 'taxday',
# 'harvey']:
# clip_to_boundary(r"F:\test\{}\intensity\projected".format(storm), out_dir, geom,
# f"{storm}{hr}hr.tif",
# f"{storm}{hr}hr.tif")
### If you do not want to aggregate DEM, comment out the following to two lines
if aggregate:
os.system('gdalwarp -tr ' + aggregate_degree + ' ' + aggregate_degree +
' -r average ' + dem_path_tif + ' ' + dem_path_tif_temp2)
dem_path_tif = dem_path_tif_temp2
### convert DEM from tif to NetCDF
os.system('gdal_translate -of NETCDF ' + dem_path_tif + ' ' + dem_path)
### calculate slope as NetCDF from DEM
os.system('gdaldem slope -of NETCDF ' + dem_path + ' ' + slope_path +
' -s 111120')
### calculate aspect from DEM
aspect = np.flipud(
rd.TerrainAttribute(rd.LoadGDAL(dem_path_tif), attrib='aspect'))
### calculate mask as NetCDF with DEM and shapefile
os.system(
'gdalwarp -of NETCDF --config GDALWARP_IGNORE_BAD_CUTLINE YES -cutline ' +
shape_path + ' ' + dem_path_tif + ' ' + mask_path)
### open intermediate netcdf files
dem = xr.open_dataset(dem_path)
mask = xr.open_dataset(mask_path)
slope = xr.open_dataset(slope_path)
### set NaNs in mask to -9999 and elevation within the shape to 1
mask = mask.Band1.values
mask[np.isnan(mask)] = -9999
mask[mask > 0] = 1
import richdem as rd
import matplotlib
import matplotlib.pyplot as plt
import os
import time
import PIL
start = time.time()
# Na początku trzeba raster przekonwertować do układu metrycznego, tutaj jest zrobione do UTM34 (gdalwarp)
path = 'C:\\Users\\wojo1\\Desktop\\Doktorat\\Microrelief\\Data\\LIDAR\\NMT'
dem_path = path + '\\nmt_lidar.tif'
dem_plot = path + '\\L_NMT_N-34-138-B-b_utm.tif'
os.chdir("C:\\Users\\wojo1\\Desktop\\Doktorat\\Microrelief\\Data\\TIF")
# string = os.popen("gdalinfo " + dem_plot).read().rstrip()
# min_value = string.splitlines()
# min_float_value = float(min_value[-2][23:])
# print(os.popen('gdalinfo L_NMT_N-34-138-B-b_utm.tif').read().rstrip())
dem = rd.LoadGDAL(dem_plot)
# plt.imshow(dem, interpolation='bilinear')
# plt.clim(vmin=0, vmax=None)
# plt.colorbar(mappable=None, cax=None)
# plt.show()
slope = rd.TerrainAttribute(dem, attrib='slope_degrees')
rd.rdShow(slope, axes=False, cmap='jet', figsize=(10, 8))
plt.show()
# rd.SaveGDAL("nmt_python.tif", slope)
end = time.time()
print('process time: ', end - start)
