def topographic_index(flow_accumulation,
slope,
px,
n_top,
div_col=0,
div_row=0):
'''
Method responsible for the partioning of the matrix
Parameters
----------
flow_accumulation : int
Flow accumulation. Servers as the...
slope : float
Highest slope to a neighbouring cell. Surrogate to...
px : int or float
Raster dimension size.
n_top : float
Expoent (<1) calibrated for the area
div_col : int, optional
Number of vertical divisions. The default is 0.
div_row : int, optional
Number of horizontal divisions. The default is 0.
Returns
-------
topographic_index : float
Topographic index..
modified_topographic_index : float
Modified Topographic index.
'''
row_size = len(flow_accumulation)
col_size = len(flow_accumulation[0])
bRow, bCol = divisor(row_size, col_size, div_row, div_col)
topographic_index = np.zeros((row_size, col_size))
modified_topographic_index = np.zeros((row_size, col_size))
bRow = np.insert(bRow, div_row, row_size)
bRow = np.insert(bRow, 0, 0)
bCol = np.insert(bCol, div_col, col_size)
bCol = np.insert(bCol, 0, 0)
for m in range(0, div_row + 1, 1):
for n in range(0, div_col + 1, 1):
mS = bRow[m]
mE = bRow[m + 1]
nS = bCol[n]
nE = bCol[n + 1]
topographic_index[mS:mE, nS:nE], modified_topographic_index[
mS:mE,
nS:nE] = topographic_index_cpu(flow_accumulation[mS:mE, nS:nE],
slope[mS:mE, nS:nE], px, n_top)
return topographic_index, modified_topographic_index
def downsloper(dem,
flow_direction,
px,
elevation_difference,
column_division=0,
row_division=0):
'''
Method responsible for the partioning of the matrix for the downslope.
Parameters
----------
dem : int or float
Digital elevation model.
flow_direction : int
Flow direction.
px : int or float
Raster pixel dimension.
elevation_difference : int
Elevation difference.
column_division : int, optional
Number of vertical divisions. The default is 0.
row_division : int, optional
Number of horizontal divisions. The default is 0.
Returns
-------
downslope : float array
Downslope index array.
'''
row_size = len(dem)
col_size = len(dem[0])
bRow, bCol = divisor(row_size, col_size, row_division, column_division)
downslope = np.zeros((row_size, col_size), dtype='float32')
bRow = np.insert(bRow, row_division, row_size)
bRow = np.insert(bRow, 0, 0)
bCol = np.insert(bCol, column_division, col_size)
bCol = np.insert(bCol, 0, 0)
for m in range(0, row_division + 1, 1):
for n in range(0, column_division + 1, 1):
mS = bRow[m]
mE = bRow[m + 1]
nS = bCol[n]
nE = bCol[n + 1]
downslope[mS:mE,
nS:nE] = downslope_cpu(dem[mS:mE, nS:nE],
flow_direction[mS:mE, nS:nE], px,
elevation_difference)
downslope = downslope_sequential_jit(dem, flow_direction, px,
elevation_difference, downslope)
return downslope
def gfi_calculator(hand,
flow_accumulation,
indices,
n_gfi,
scale_factor,
size,
division_column=0,
division_row=0):
'''
Method responsible for the partioning of the matrix
Parameters
----------
hand : int or flat array
Height above the nearest drainage.
flow_accumulation : int
Flow accumulation. Represent the river as source of hazard.
indices : indices : int array
River cell index.
n_gfi : float
Expoent (<1) Calibrated for the region.
scale_factor : float
Scale factor.
Returns
-------
gfi : float array
geomorphic flood index array.
'''
row_size = len(hand)
col_size = len(hand[0])
boundary_row, boundary_column = divisor(row_size, col_size, division_row,
division_column)
flow_accumulation = river_accumulation(flow_accumulation, indices)
gfi = np.zeros((row_size, col_size))
boundary_row = np.insert(boundary_row, division_row, row_size)
boundary_row = np.insert(boundary_row, 0, 0)
boundary_column = np.insert(boundary_column, division_column, col_size)
boundary_column = np.insert(boundary_column, 0, 0)
for m in range(0, division_row + 1, 1):
for n in range(0, division_column + 1, 1):
mS = boundary_row[m]
mE = boundary_row[m + 1]
nS = boundary_column[n]
nE = boundary_column[n + 1]
gfi[mS:mE, nS:nE] = geomorphic_flood_index_cpu(
hand[mS:mE, nS:nE], flow_accumulation[mS:mE, nS:nE], n_gfi,
scale_factor, size)
return gfi
def sloper(dem, px, division_column=0, division_row=0):
'''
Method responsible for the matrix dimension division
Parameters
----------
dem : int or float
Digital elevation model.
px : int or float
Raster pixel dimension.
Returns
-------
slope : float
Highest slope of the neighbouring cells.
'''
row_size = len(dem)
col_size = len(dem[0])
bRow, bCol = divisor(row_size, col_size, division_column, division_row)
slope = np.zeros((row_size, col_size))
bRow = np.insert(bRow, division_row, row_size)
bRow = np.insert(bRow, 0, 0)
bCol = np.insert(bCol, division_column, col_size)
bCol = np.insert(bCol, 0, 0)
for m in range(0, division_row + 1, 1):
for n in range(0, division_column + 1, +1):
mS = bRow[m]
mE = bRow[m + 1]
nS = bCol[n]
nE = bCol[n + 1]
extra = np.array([0, 0, 0, 0])
if m == 0:
extra[0] = 1 #up
if n == 0:
extra[1] = 1 #left
if n == division_column:
extra[2] = 1 #right
if m == division_row:
extra[3] = 1 #down
slope[mS:mE, nS:nE] = slope_cpu(
dem[mS - 1 + extra[0]:mE + 1 - extra[3],
nS - 1 + extra[1]:nE + 1 - extra[2]], px, extra)
return slope
def ln_hl_H_calculator(hand,
flow_accumulation,
n_gfi,
scale_factor,
size,
division_column=0,
division_row=0):
'''
Method responsible for the partioning of the matrix
Parameters
----------
hand : int or flat array
Height above the nearest drainage.
fac : int
Flow accumulation.
n_gfi : float
Expoent (<1) Calibrated for the region.
scale_factor : float
Scale factor.
Returns
-------
ln_hl_H : float array
ln(hl/H) index array.
'''
row_size = len(hand)
col_size = len(hand[0])
bRow, bCol = divisor(row_size, col_size, division_row, division_column)
lnhlh = np.zeros((row_size, col_size))
bRow = np.insert(bRow, division_row, row_size)
bRow = np.insert(bRow, 0, 0)
bCol = np.insert(bCol, division_column, col_size)
bCol = np.insert(bCol, 0, 0)
for m in range(0, division_row + 1, 1):
for n in range(0, division_column + 1, 1):
mS = bRow[m]
mE = bRow[m + 1]
nS = bCol[n]
nE = bCol[n + 1]
lnhlh[mS:mE, nS:nE] = ln_hl_H_cpu(hand[mS:mE, nS:nE],
flow_accumulation[mS:mE, nS:nE],
n_gfi, scale_factor, size)
return lnhlh
def flow_hand_index(dem_raster,
flow_direction_matrix,
river_matrix,
px,
division_column=0,
division_row=0):
'''
Overall method responsible for the matrix partitioning and
defining dimensions.
Parameters
----------
dem_raster : int or float array
Digital elevation model raster.
flow_direction_matrix : int8 array
Flow direction.
river_matrix : int8 array
Binary matrix that 1- river cell 0-not river cell.
px : int or float
Raster pixel dimension.
Returns
-------
fdist : float array
Flow distance.
indices : int array
River cell index.
hand : int or flat array
Height above the nearest drainage.
'''
row = len(dem_raster)
col = len(dem_raster[0])
boundary_row, boundary_column = divisor(row, col, division_row,
division_column)
flow_distance = np.zeros((row, col),dtype='float32')
indices = np.zeros((row, col), dtype='int')
if division_row > 0 or division_column > 0:
flow_distance[:, boundary_column] = -50
flow_distance[boundary_row, :] = -50
flow_distance, indices = fdist_indexes_sequential_jit(
flow_direction_matrix, river_matrix, px, flow_distance)
boundary_row = np.insert(boundary_row, division_row, row)
boundary_row = np.insert(boundary_row, 0, -1)
boundary_column = np.insert(boundary_column, division_column, col)
boundary_column = np.insert(boundary_column, 0, -1)
part = 0
for m in range(0, division_row + 1, 1):
for n in range(0, division_column + 1, 1):
out = np.zeros((4))
distance_up = np.zeros([1])
distance_left = np.zeros([1])
distance_right = np.zeros([1])
distance_down = np.zeros([1])
index_up = np.zeros([1])
index_left = np.zeros([1])
index_right = np.zeros([1])
index_down = np.zeros([1])
mS = boundary_row[m]
mE = boundary_row[m + 1]
nS = boundary_column[n]
nE = boundary_column[n + 1]
if division_row > 0:
if part < (division_column + 1) * division_row:
out[3] = 1
distance_down = flow_distance[mE, nS + 1:nE]
index_down = indices[mE, nS + 1:nE]
if n != division_column:
distance_down = np.insert(distance_down, nE - (nS + 1),
flow_distance[mE, nE])
index_down = np.insert(index_down, nE - (nS + 1),
indices[mE, nE])
if n != 0:
distance_down = np.insert(distance_down, 0, flow_distance[mE, nS])
index_down = np.insert(index_down, 0, indices[mE, nS])
if part > division_column:
out[0] = 1
distance_up = flow_distance[mS, nS + 1:nE]
index_up = indices[mS, nS + 1:nE]
if n != division_column:
distance_up = np.insert(distance_up, nE - (nS + 1),
flow_distance[mS, nE])
index_up = np.insert(index_up, nE - (nS + 1),
indices[mS, nE])
if n != 0:
distance_up = np.insert(distance_up, 0, flow_distance[mS, nS])
index_up = np.insert(index_up, 0, indices[mS, nS])
if division_column > 0:
if part % (division_column + 1) != 0:
out[1] = 1
distance_left = flow_distance[mS + 1:mE, nS]
index_left = indices[mS + 1:mE, nS]
if m != division_row:
distance_left = np.insert(distance_left, mE - (mS + 1),
flow_distance[mE, nS])
index_left = np.insert(index_left, mE - (mS + 1),
indices[mE, nS])
if m != 0:
distance_left = np.insert(distance_left, 0, flow_distance[mS, nS])
index_left = np.insert(index_left, 0, indices[mS, nS])
if part % (division_column + 1) != division_column:
out[2] = 1
distance_right = flow_distance[mS + 1:mE, nE]
index_right = indices[mS + 1:mE, nE]
if m != division_row:
distance_right = np.insert(distance_right, mE - (mS + 1),
flow_distance[mE, nE])
index_right = np.insert(index_right, mE - (mS + 1),
indices[mE, nE])
if m != 0:
distance_right = np.insert(distance_right, 0, flow_distance[mS, nE])
index_right = np.insert(index_right, 0, indices[mS, nE])
size = max(len(distance_up), len(distance_left), len(distance_right), len(distance_down))
bound = np.zeros((4, size))
bound_index = np.zeros((4, size))
bound[0, 0:len(distance_up)] = distance_up
bound_index[0, 0:len(index_up)] = index_up
bound[1, 0:len(distance_left)] = distance_left
bound_index[1, 0:len(index_left)] = index_left
bound[2, 0:len(distance_right)] = distance_right
bound_index[2, 0:len(index_right)] = index_right
bound[3, 0:len(distance_down)] = distance_down
bound_index[3, 0:len(index_down)] = index_down
mS += 1
nS += 1
part += 1
flow_distance[mS:mE,
nS:nE], indices[mS:mE,
nS:nE] = flow_distance_index_cpu(
dem_raster[mS:mE, nS:nE],
flow_direction_matrix[mS:mE,
nS:nE],
river_matrix[mS:mE, nS:nE], px,
bound, bound_index, out,
mS, nS, col)
# indices[mS:mE, nS:nE] = index_calculator(indices[mS:mE, nS:nE], mS,
# nS, col)
hand = hand_calculator(dem_raster, indices)
return flow_distance, indices, hand