def main(bathy=None, out_sin_raster=None, out_cos_raster=None):
"""
Calculate the statistical aspect of a raster, which
computes the sin(aspect) and cos(aspect). By using these two
variables, aspect can be accounted for as a continuous circular
variable. Because aspect is circular (0 and 359.9 are immediately
adjacent), this trigonometric transformation preserves distances
between elements and is the simplest transformation mechanism.
"""
try:
arcpy.env.compression = "LZW"
arcpy.env.rasterStatistics = "STATISTICS"
# Calculate the aspect of the bathymetric raster. "Aspect is expressed
# in positive degrees from 0 to 359.9, measured clockwise from north."
utils.msg("Calculating aspect...")
aspect = Aspect(bathy)
# Both the sin and cos functions here expect radians, not degrees.
# convert our Aspect raster into radians, check that the values
# are in range.
aspect_rad = aspect * (math.pi / 180)
aspect_sin = Sin(aspect_rad)
aspect_cos = Cos(aspect_rad)
out_sin_raster = utils.validate_path(out_sin_raster)
out_cos_raster = utils.validate_path(out_cos_raster)
arcpy.CopyRaster_management(aspect_sin, out_sin_raster)
arcpy.CopyRaster_management(aspect_cos, out_cos_raster)
except Exception as e:
utils.msg(e, mtype='error')
def slopeaspect(path):
import arcpy, os, re
from arcpy.sa import Slope,Times,Aspect,Int
from arcpy import env
arcpy.env.workspace = path
print('creating slope and aspect raster map')
arcpy.CheckOutExtension("Spatial") # activating spetial analyst module
# Transforming altitude, soil type, landuse and slope raster maps to polygon
# cellsize = arcpy.GetRasterProperties_management("altitude.tif","CELLSIZEX") #Extracting the raster cell size
# cellsize1 = float(cellsize.getOutput(0))
# cellarea = cellsize1*cellsize1/1000000.0
slope1 = Slope("altitude.tif", 'DEGREE') # SLOPE IN DEGREE
slope1.save("slope_in_deg.tif")
const = 100.0
OutRas = Times("slope_in_deg.tif", 100.0)
intslope = Int(OutRas)
intslope.save("times.tif")
#
aspect1 = Aspect("altitude.tif") # ATTENTION: Aspect in Arcgis is calculated clockwise so East is 90. in Raven's manual Aspect is assumed to be counterclockwise i.e., west 90
aspect1.save("aspect")
print('done!')
while 1:
iteration = iteration + 1
arcpy.AddMessage(
"--------------------------------------------------------------")
arcpy.AddMessage("Iteration {0} is running!".format(iteration))
# DEM difference [m]
dh = Raster(DEM_master) - Raster(DEM_slave_after)
# slope of the slave DEM [degree]
slp = Slope(DEM_slave_after, "DEGREE", "1")
# aspect of the slave DEM [degree]
asp = Aspect(DEM_slave_after)
# Mask 'dh' using statale terrain polygon
dh_mask = ExtractByMask(dh, OffGlacier)
# Mask 'slp' and 'asp' using 'dh_mask' in order to keep same georeference as 'dh_mask'
slp_mask = ExtractByMask(slp, dh_mask)
asp_mask = ExtractByMask(asp, dh_mask)
del dh, slp, asp
# Raster to Array
dh_mask_arr = arcpy.RasterToNumPyArray(dh_mask, nodata_to_value=-32768)
slp_mask_arr = arcpy.RasterToNumPyArray(slp_mask, nodata_to_value=-32768)
asp_mask_arr = arcpy.RasterToNumPyArray(asp_mask, nodata_to_value=-32768)
def aspect(fc): output = os.path.join(arcpy.env.workspace, 'Aspect') desc = arcpy.Describe(fc) if desc.dataType == 'RasterDataset': aspect = Aspect(fc) aspect.save(output)
def main(in_raster=None, neighborhood_size=None, out_raster=None):
"""
Compute terrain ruggedness, using the vector ruggedness measure (VRM),
as described in:
Sappington et al., 2007. Quantifying Landscape Ruggedness for
Animal Habitat Analysis: A Case Study Using Bighorn Sheep in the
Mojave Desert. Journal of Wildlife Management. 71(5): 1419 -1426.
"""
hood_size = int(neighborhood_size)
# FIXME: expose this as an option per #18
w = utils.Workspace()
if w.exists:
out_workspace = w.path
else:
out_workspace = os.path.dirname(out_raster)
utils.workspace_exists(out_workspace)
# force temporary stats to be computed in our output workspace
arcpy.env.scratchWorkspace = out_workspace
arcpy.env.workspace = out_workspace
# TODO expose as config
pyramid_orig = arcpy.env.pyramid
arcpy.env.pyramid = "NONE"
# TODO: currently set to automatically overwrite, expose this as option
arcpy.env.overwriteOutput = True
arcpy.env.compression = 'LZW'
try:
# Create Slope and Aspect rasters
utils.msg("Calculating aspect...")
out_aspect = Aspect(in_raster)
utils.msg("Calculating slope...")
out_slope = Slope(in_raster, "DEGREE")
# Convert Slope and Aspect rasters to radians
utils.msg("Converting slope and aspect to radians...")
slope_rad = out_slope * (math.pi / 180)
aspect_rad = out_aspect * (math.pi / 180)
# Calculate x, y, and z rasters
utils.msg("Calculating x, y, and z rasters...")
xy_raster_calc = Sin(slope_rad)
z_raster_calc = Cos(slope_rad)
x_raster_calc = Con(out_aspect == -1, 0,
Sin(aspect_rad)) * xy_raster_calc
y_raster_calc = Con(out_aspect == -1, 0,
Cos(aspect_rad)) * xy_raster_calc
# Calculate sums of x, y, and z rasters for selected neighborhood size
utils.msg("Calculating sums of x, y, and z rasters in neighborhood...")
hood = NbrRectangle(hood_size, hood_size, "CELL")
x_sum_calc = FocalStatistics(x_raster_calc, hood, "SUM", "NODATA")
y_sum_calc = FocalStatistics(y_raster_calc, hood, "SUM", "NODATA")
z_sum_calc = FocalStatistics(z_raster_calc, hood, "SUM", "NODATA")
# Calculate the resultant vector
utils.msg("Calculating the resultant vector...")
result_vect = (x_sum_calc**2 + y_sum_calc**2 + z_sum_calc**2)**0.5
arcpy.env.rasterStatistics = "STATISTICS"
arcpy.env.pyramid = pyramid_orig
# Calculate the Ruggedness raster
utils.msg("Calculating the final ruggedness raster...")
ruggedness = 1 - (result_vect / hood_size**2)
out_raster = utils.validate_path(out_raster)
utils.msg("Saving ruggedness raster to to {}.".format(out_raster))
arcpy.CopyRaster_management(ruggedness, out_raster)
except Exception as e:
utils.msg(e, mtype='error')
def calculate_topographic_properties(**kwargs):
"""
Description: calculates topographic properties from an elevation raster
Inputs: 'z_unit' -- a string value of either 'Meter' or 'Foot' representing the vertical unit of the elevation raster
'input_array' -- an array containing the grid raster (must be first) and the elevation raster
'output_array' -- an array containing the output rasters for aspect, compound topographic index, heat load index, integrated moisture index, roughness, site exposure, slope, surface area ratio, and surface relief ratio (in that order)
Returned Value: Returns a raster dataset on disk for each topographic property
Preconditions: requires an input DEM that can be created through other scripts in this repository
"""
# Import packages
import arcpy
from arcpy.sa import Con
from arcpy.sa import IsNull
from arcpy.sa import ExtractByMask
from arcpy.sa import Raster
from arcpy.sa import Int
from arcpy.sa import FlowDirection
from arcpy.sa import FlowAccumulation
from arcpy.sa import Slope
from arcpy.sa import Aspect
from package_Geomorphometry import compound_topographic
from package_Geomorphometry import getZFactor
from package_Geomorphometry import linear_aspect
from package_Geomorphometry import mean_slope
from package_Geomorphometry import roughness
from package_Geomorphometry import site_exposure
from package_Geomorphometry import surface_area
from package_Geomorphometry import surface_relief
from package_Geomorphometry import topographic_position
from package_Geomorphometry import topographic_radiation
import datetime
import os
import time
# Parse key word argument inputs
z_unit = kwargs['z_unit']
grid_raster = kwargs['input_array'][0]
elevation_input = kwargs['input_array'][1]
elevation_output = kwargs['output_array'][0]
aspect_output = kwargs['output_array'][1]
cti_output = kwargs['output_array'][2]
roughness_output = kwargs['output_array'][3]
exposure_output = kwargs['output_array'][4]
slope_output = kwargs['output_array'][5]
area_output = kwargs['output_array'][6]
relief_output = kwargs['output_array'][7]
position_output = kwargs['output_array'][8]
radiation_output = kwargs['output_array'][9]
# Set overwrite option
arcpy.env.overwriteOutput = True
# Use two thirds of cores on processes that can be split.
arcpy.env.parallelProcessingFactor = "75%"
# Set snap raster and extent
arcpy.env.snapRaster = grid_raster
arcpy.env.extent = Raster(grid_raster).extent
# Define folder structure
grid_title = os.path.splitext(os.path.split(grid_raster)[1])[0]
raster_folder = os.path.split(elevation_output)[0]
intermediate_folder = os.path.join(raster_folder, 'intermediate')
# Create raster folder if it does not already exist
if os.path.exists(raster_folder) == 0:
os.mkdir(raster_folder)
# Create intermediate folder if it does not already exist
if os.path.exists(intermediate_folder) == 0:
os.mkdir(intermediate_folder)
# Define intermediate datasets
flow_direction_raster = os.path.join(intermediate_folder,
'flow_direction.tif')
flow_accumulation_raster = os.path.join(intermediate_folder,
'flow_accumulation.tif')
raw_slope_raster = os.path.join(intermediate_folder, 'raw_slope.tif')
raw_aspect_raster = os.path.join(intermediate_folder, 'raw_aspect.tif')
# Get the z factor appropriate to the xy and z units
zFactor = getZFactor(elevation_input, z_unit)
#### CALCULATE INTERMEDIATE DATASETS
# Calculate flow direction if it does not already exist
if os.path.exists(flow_direction_raster) == 0:
# Calculate flow direction
print(f'\tCalculating flow direction for {grid_title}...')
iteration_start = time.time()
flow_direction = FlowDirection(elevation_input, 'NORMAL', '', 'D8')
flow_direction.save(flow_direction_raster)
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tFlow direction already exists for {grid_title}.')
print('\t----------')
# Calculate flow accumulation if it does not already exist
if os.path.exists(flow_accumulation_raster) == 0:
# Calculate flow accumulation
print(f'\tCalculating flow accumulation for {grid_title}...')
iteration_start = time.time()
flow_accumulation = FlowAccumulation(flow_direction_raster, '',
'FLOAT', 'D8')
flow_accumulation.save(flow_accumulation_raster)
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tFlow accumulation already exists for {grid_title}.')
print('\t----------')
# Calculate raw slope in degrees if it does not already exist
if os.path.exists(raw_slope_raster) == 0:
# Calculate slope
print(f'\tCalculating raw slope for {grid_title}...')
iteration_start = time.time()
raw_slope = Slope(elevation_input, "DEGREE", zFactor)
raw_slope.save(raw_slope_raster)
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tRaw slope already exists for {grid_title}.')
print('\t----------')
# Calculate raw aspect if it does not already exist
if os.path.exists(raw_aspect_raster) == 0:
# Calculate aspect
print(f'\tCalculating raw aspect for {grid_title}...')
iteration_start = time.time()
raw_aspect = Aspect(elevation_input, 'PLANAR', z_unit)
raw_aspect.save(raw_aspect_raster)
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tRaw aspect already exists for {grid_title}.')
print('\t----------')
#### CALCULATE INTEGER ELEVATION
# Calculate integer elevation if it does not already exist
if arcpy.Exists(elevation_output) == 0:
print(f'\tCalculating integer elevation for {grid_title}...')
iteration_start = time.time()
# Round to integer
print(f'\t\tConverting values to integers...')
integer_elevation = Int(Raster(elevation_input) + 0.5)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_elevation, elevation_output, '',
'', '-32768', 'NONE', 'NONE',
'16_BIT_SIGNED', 'NONE', 'NONE', 'TIFF',
'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tInteger elevation already exists for {grid_title}.')
print('\t----------')
#### CALCULATE LINEAR ASPECT
# Calculate linear aspect if it does not already exist
if arcpy.Exists(aspect_output) == 0:
print(f'\tCalculating linear aspect for {grid_title}...')
iteration_start = time.time()
# Create an initial linear aspect calculation using the linear aspect function
aspect_intermediate = os.path.splitext(
aspect_output)[0] + '_intermediate.tif'
linear_aspect(raw_aspect_raster, aspect_intermediate)
# Round to integer
print(f'\t\tConverting values to integers...')
integer_aspect = Int(Raster(aspect_intermediate) + 0.5)
# Fill missing data (no aspect) with values of -1
print(f'\t\tFilling values of no aspect...')
conditional_aspect = Con(IsNull(integer_aspect), -1, integer_aspect)
# Extract filled raster to grid mask
print(f'\t\tExtracting filled raster to grid...')
extract_aspect = ExtractByMask(conditional_aspect, grid_raster)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(extract_aspect, aspect_output, '', '',
'-32768', 'NONE', 'NONE', '16_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(aspect_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tLinear aspect already exists for {grid_title}.')
print('\t----------')
#### CALCULATE COMPOUND TOPOGRAPHIC INDEX
# Calculate compound topographic index if it does not already exist
if arcpy.Exists(cti_output) == 0:
print(f'\tCalculating compound topographic index for {grid_title}...')
iteration_start = time.time()
# Create an intermediate compound topographic index calculation
cti_intermediate = os.path.splitext(
cti_output)[0] + '_intermediate.tif'
compound_topographic(elevation_input, flow_accumulation_raster,
raw_slope_raster, cti_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_compound = Int((Raster(cti_intermediate) * 100) + 0.5)
# Copy integer raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_compound, cti_output, '', '',
'-32768', 'NONE', 'NONE', '16_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(cti_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tCompound topographic index already exists for {grid_title}.')
print('\t----------')
#### CALCULATE ROUGHNESS
# Calculate roughness if it does not already exist
if arcpy.Exists(roughness_output) == 0:
print(f'\tCalculating roughness for {grid_title}...')
iteration_start = time.time()
# Create an intermediate compound topographic index calculation
roughness_intermediate = os.path.splitext(
roughness_output)[0] + '_intermediate.tif'
roughness(elevation_input, roughness_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_roughness = Int(Raster(roughness_intermediate) + 0.5)
# Fill missing data (no aspect) with values of 0
print(f'\t\tFilling values of roughness...')
conditional_roughness = Con(IsNull(integer_roughness), 0,
integer_roughness)
# Extract filled raster to grid mask
print(f'\t\tExtracting filled raster to grid...')
extract_roughness = ExtractByMask(conditional_roughness, grid_raster)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(extract_roughness, roughness_output, '',
'', '-32768', 'NONE', 'NONE',
'16_BIT_SIGNED', 'NONE', 'NONE', 'TIFF',
'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(roughness_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tRoughness already exists for {grid_title}.')
print('\t----------')
#### CALCULATE SITE EXPOSURE
# Calculate site exposure if it does not already exist
if arcpy.Exists(exposure_output) == 0:
print(f'\tCalculating site exposure for {grid_title}...')
iteration_start = time.time()
# Create an intermediate compound topographic index calculation
exposure_intermediate = os.path.splitext(
exposure_output)[0] + '_intermediate.tif'
site_exposure(raw_aspect_raster, raw_slope_raster,
exposure_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_exposure = Int((Raster(exposure_intermediate) * 100) + 0.5)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_exposure, exposure_output, '', '',
'-32768', 'NONE', 'NONE', '16_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(exposure_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tSite exposure already exists for {grid_title}.')
print('\t----------')
#### CALCULATE MEAN SLOPE
# Calculate mean slope if it does not already exist
if arcpy.Exists(slope_output) == 0:
print(f'\tCalculating mean slope for {grid_title}...')
iteration_start = time.time()
# Create an intermediate mean slope calculation
slope_intermediate = os.path.splitext(
slope_output)[0] + '_intermediate.tif'
mean_slope(raw_slope_raster, slope_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_slope = Int(Raster(slope_intermediate) + 0.5)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_slope, slope_output, '', '',
'-128', 'NONE', 'NONE', '8_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(slope_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tMean slope already exists for {grid_title}.')
print('\t----------')
#### CALCULATE SURFACE AREA RATIO
# Calculate surface area ratio if it does not already exist
if os.path.exists(area_output) == 0:
print(f'\tCalculating surface area ratio for {grid_title}...')
iteration_start = time.time()
# Create an intermediate surface area ratio calculation
area_intermediate = os.path.splitext(
area_output)[0] + '_intermediate.tif'
surface_area(raw_slope_raster, area_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_area = Int((Raster(area_intermediate) * 10) + 0.5)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_area, area_output, '', '',
'-32768', 'NONE', 'NONE', '16_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(area_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tSurface area ratio already exists for {grid_title}.')
print('\t----------')
#### CALCULATE SURFACE RELIEF RATIO
# Calculate surface relief ratio if it does not already exist
if arcpy.Exists(relief_output) == 0:
print(f'\tCalculating surface relief ratio for {grid_title}...')
iteration_start = time.time()
# Create an intermediate surface relief ratio calculation
relief_intermediate = os.path.splitext(
relief_output)[0] + '_intermediate.tif'
surface_relief(elevation_input, relief_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_relief = Int((Raster(relief_intermediate) * 1000) + 0.5)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_relief, relief_output, '', '',
'-32768', 'NONE', 'NONE', '16_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(relief_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tSurface relief ratio already exists for {grid_title}.')
print('\t----------')
#### CALCULATE TOPOGRAPHIC POSITION
# Calculate topographic position if it does not already exist
if arcpy.Exists(position_output) == 0:
print(f'\tCalculating topographic position for {grid_title}...')
iteration_start = time.time()
# Create an intermediate topographic position calculation
position_intermediate = os.path.splitext(
position_output)[0] + '_intermediate.tif'
topographic_position(elevation_input, position_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_position = Int((Raster(position_intermediate) * 100) + 0.5)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(integer_position, position_output, '', '',
'-32768', 'NONE', 'NONE', '16_BIT_SIGNED',
'NONE', 'NONE', 'TIFF', 'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(position_intermediate)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tTopographic position already exists for {grid_title}.')
print('\t----------')
#### CALCULATE TOPOGRAPHIC RADIATION
# Calculate topographic radiation if it does not already exist
if arcpy.Exists(radiation_output) == 0:
print(f'\tCalculating topographic radiation for {grid_title}...')
iteration_start = time.time()
# Create an intermediate topographic position calculation
radiation_intermediate = os.path.splitext(
radiation_output)[0] + '_intermediate.tif'
radiation_integer = os.path.splitext(
radiation_output)[0] + '_integer.tif'
topographic_radiation(elevation_input, radiation_intermediate)
# Convert to integer values
print(f'\t\tConverting values to integers...')
integer_radiation = Int((Raster(radiation_intermediate) * 1000) + 0.5)
arcpy.management.CopyRaster(integer_radiation, radiation_integer, '',
'', '-32768', 'NONE', 'NONE',
'16_BIT_SIGNED', 'NONE', 'NONE', 'TIFF',
'NONE')
# Extract filled raster to grid mask
print(f'\t\tExtracting integer raster to grid...')
extract_radiation = ExtractByMask(radiation_integer, grid_raster)
# Copy extracted raster to output
print(f'\t\tCreating output raster...')
arcpy.management.CopyRaster(extract_radiation, radiation_output, '',
'', '-32768', 'NONE', 'NONE',
'16_BIT_SIGNED', 'NONE', 'NONE', 'TIFF',
'NONE')
# End timing
iteration_end = time.time()
iteration_elapsed = int(iteration_end - iteration_start)
iteration_success_time = datetime.datetime.now()
# Delete intermediate dataset if possible
try:
arcpy.management.Delete(radiation_intermediate)
arcpy.management.Delete(radiation_integer)
except:
print('\t\tCould not delete intermediate dataset...')
# Report success
print(
f'\tCompleted at {iteration_success_time.strftime("%Y-%m-%d %H:%M")} (Elapsed time: {datetime.timedelta(seconds=iteration_elapsed)})'
)
print('\t----------')
else:
print(f'\tTopographic radiation already exists for {grid_title}.')
print('\t----------')
outprocess = f'Finished topographic properties for {grid_title}.'
return outprocess
def aspect(fc):
output = os.path.join(arcpy.env.workspace, 'Aspect')
desc = arcpy.Describe(fc)
if desc.dataType == 'RasterDataset':
aspect = Aspect(fc)
aspect.save(output)
"157" : 0.,
"202" : 0.,
"247" : 0.,
"292" : 0.,
"337" : 0.
}}
# il faut en le ver les véroux.
del row, scur
return d
# Calculer l'expostion à partir du mnt :
from arcpy.sa import Aspect
mnt = mnt.encode('utf8')
outAspect = Aspect(mnt)
exposition = os.path.join(workspace,"exposition")
outAspect.save(exposition)
# Reclasser l'exposition : en fonction du nombre de classes en entrée.
if NbClasses=="4":
b1, b2, b3, b4 = 90,180,270,360
classes = "%s %s 45;%s %s 135;%s %s 225; %s %s 315" %(0,b1,b1,b2,b2,b3,b3,b4)
if NbClasses=="8":
b1, b2, b3, b4, b5, b6, b7, b8 = 45,90,135,180,225,270,315,360
classes = "%s %s 22;%s %s 67;%s %s 112; %s %s 157;%s %s 202;%s %s 247;%s %s 292; %s %s 337" %(0,b1,b1,b2,b2,b3,b3,b4,b4,b5,b5,b6,b6,b7,b7,b8)
arcpy.gp.Reclassify_sa(exposition, "Value", classes, "OrientReclass", "DATA")
# Vectoriser le raster reclasser :