def main(argv=None):
"""Run Linkage Priority tool."""
stime = lm_util.start_time()
if argv is None:
argv = sys.argv # Get parameters from ArcGIS tool dialog
try:
lm_env.configure(lm_env.TOOL_LP, argv)
lm_util.gprint("\nLinkage Priority Version " + lm_env.releaseNum)
lm_util.check_project_dir()
log_setup(argv)
run_analysis()
except AppError as err:
lm_util.gprint(err.message)
lm_util.write_log(err.message)
except arcpy.ExecuteError:
msg = arcpy.GetMessages(2)
arcpy.AddError(msg)
lm_util.write_log(msg)
exc_traceback = sys.exc_info()[2]
lm_util.gprint("Traceback (most recent call last):\n" +
"".join(traceback.format_tb(exc_traceback)[:-1]))
except Exception:
exc_value, exc_traceback = sys.exc_info()[1:]
arcpy.AddError(exc_value)
lm_util.gprint("Traceback (most recent call last):\n" +
"".join(traceback.format_tb(exc_traceback)))
finally:
if not lm_env.KEEPINTERMEDIATE:
lm_util.delete_dir(lm_env.SCRATCHDIR)
arcpy.CheckInExtension("Spatial")
lm_util.run_time(stime)
lm_util.close_log_file()
def config_lm():
"""Configure Linkage Mapper"""
lm_arg = (_SCRIPT_NAME, cc_env.proj_dir, cc_env.prj_core_fc,
cc_env.core_fld, cc_env.prj_resist_rast, "false", "false", "#",
"#", "true", "false", cc_env.prune_network, cc_env.max_nn,
cc_env.nn_unit, cc_env.keep_constelations, "true", "#", "#", "#")
lm_env.configure(lm_env.TOOL_CC, lm_arg)
lm_util.create_dir(lm_env.DATAPASSDIR)
lm_util.gprint('\nClimate Linkage Mapper Version ' + lm_env.releaseNum)
lm_util.gprint('NOTE: This tool runs best with BACKGROUND '
'PROCESSING (see user guide).')
def config_lm():
"""Configure Linkage Mapper"""
lm_arg = (_SCRIPT_NAME, cc_env.proj_dir, cc_env.prj_core_fc,
cc_env.core_fld, cc_env.prj_resist_rast, "false", "false", "#",
"#", "true", "false", cc_env.prune_network, cc_env.max_nn,
cc_env.nn_unit, cc_env.keep_constelations, "true", "#", "#", "#")
lm_env.configure(lm_env.TOOL_CC, lm_arg)
lm_util.create_dir(lm_env.DATAPASSDIR)
lm_util.gprint('\nClimate Linkage Mapper Version ' + lm_env.releaseNum)
lm_util.gprint('NOTE: This tool runs best with BACKGROUND '
'PROCESSING (see user guide).')
def config_lm():
"""Configure Linkage Mapper."""
lm_arg = [
_SCRIPT_NAME, cc_env.proj_dir, cc_env.prj_core_fc, cc_env.core_fld,
cc_env.prj_resist_rast, "false", "false", "#", "#", "true", "false",
cc_env.prune_network, cc_env.max_nn, cc_env.nn_unit,
cc_env.keep_constelations, "true", cc_env.WRITETRUNCRASTER,
cc_env.CWDTHRESH, "#", "#", "#", cc_env.OUTPUTFORMODELBUILDER,
cc_env.LMCUSTSETTINGS
]
lm_env.configure(lm_env.TOOL_CC, lm_arg)
lm_util.create_dir(lm_env.DATAPASSDIR)
lm_util.gprint('\nClimate Linkage Mapper Version ' + lm_env.releaseNum)
lm_util.gprint('NOTE: This tool runs best with BACKGROUND '
'PROCESSING (see user guide).')
def config_lm():
"""Configure Linkage Mapper."""
# get log file for last LM run
folder = os.path.join(lp_env.PROJDIR, "run_history",
"log") # lm_env.LOGDIR
if not os.path.exists(folder):
raise Exception(
"ERROR: Log file for last Linkage Mapper run not found. Please ensure Linkage Mapper is run "
+ "for this project before running Linkage Priority.")
entries = (os.path.join(folder, filename)
for filename in os.listdir(folder))
entries = ((os.stat(filepath), filepath) for filepath in entries)
entries = ((stats.st_ctime, filepath) for stats, filepath in entries)
last_lm_log = ""
for cdate, filepath in sorted(entries, reverse=True):
if "_Linkage Mapper" in filepath:
last_lm_log = filepath
break
if last_lm_log == "":
raise Exception(
"ERROR: Log file for last Linkage Mapper run not found")
# read parameters section from file and turn into tuple for passing
parms = ""
with open(last_lm_log) as log_file:
for line in log_file:
if line[0:13] == "Parameters:\t[":
parms = line[13:len(line) - 3]
break
lm_arg = tuple(parms.replace("'", "").split(", "))
if parms == "":
raise Exception(
"ERROR: Log file for last Linkage Mapper run does not contain a Parameters line"
)
# use LM config in addition to LP config by passing in parms from last LM run
try:
lm_env.configure(lm_env.TOOL_LP, lm_arg)
except Exception:
raise Exception(
"ERROR: Parameters from log file for last Linkage Mapper run could not be used. "
+
"Please Ensure the last run was completed with the current version of Linkage Mapper."
)
lm_util.gprint("\nLinkage Priority Version " + lm_env.releaseNum)
def bar_master(argv=None):
""" Experimental code to detect barriers using cost-weighted distance
outputs from Linkage Mapper tool.
"""
if argv is None:
argv = sys.argv
# cfg.configure(argv)
cfg.configure(cfg.TOOL_BM, argv) #xxx was sys.argv
gprint = lu.gprint
try:
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
cfg.logFilePath = lu.create_log_file(cfg.MESSAGEDIR, cfg.TOOL,
cfg.PARAMS)
lu.print_drive_warning()
# Move adj and cwd results from earlier versions to datapass directory
lu.move_old_results()
lu.create_dir(cfg.OUTPUTDIR)
lu.delete_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
lu.dashline(1)
gprint('\nMaking local copy of resistance raster.')
lu.delete_data(cfg.RESRAST)
desc = arcpy.Describe(cfg.RESRAST_IN)
if hasattr(desc, "catalogPath"):
cfg.RESRAST_IN = arcpy.Describe(cfg.RESRAST_IN).catalogPath
arcpy.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
arcpy.env.extent = cfg.RESRAST
arcpy.env.snapRaster = cfg.RESRAST
if cfg.BARRIER_METH_MAX:
cfg.SUM_BARRIERS = False
lu.dashline(1)
gprint('Calculating MAXIMUM barrier effects across core area pairs')
s6.STEP6_calc_barriers()
if cfg.BARRIER_METH_SUM:
cfg.SUM_BARRIERS = True
gprint('')
lu.dashline()
gprint('Calculating SUM of barrier effects across core area pairs')
s6.STEP6_calc_barriers()
#clean up
lu.delete_dir(cfg.SCRATCHDIR)
if not cfg.SAVEBARRIERDIR:
lu.delete_dir(cfg.BARRIERBASEDIR)
gprint('\nDone with barrier mapping.\n')
# Return GEOPROCESSING specific errors
except arcpy.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except:
lu.exit_with_python_error(_SCRIPT_NAME)
def lm_master(argv=None):
"""Main function for linkage mapper.
Called by ArcMap with parameters or run from command line with parameters
entered in script below. Calls functions in dedicated scripts for each of
5 processing steps.
"""
# Setup global variables
if not cfg.lm_configured: # Causing problems with iterative scripting
if argv is None:
argv = sys.argv
cfg.configure(cfg.TOOL_LM, argv)
gp = cfg.gp
try:
gprint = lu.gprint
# Move results from earlier versions to new directory structure
lu.move_old_results()
gp.OverwriteOutput = True
gp.pyramid = "NONE"
gp.rasterstatistics = "NONE"
# Create output directories if they don't exist
if gp.Exists(cfg.OUTPUTDIR):
gp.RefreshCatalog(cfg.OUTPUTDIR)
lu.create_dir(cfg.OUTPUTDIR)
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
lu.create_dir(cfg.DATAPASSDIR)
# Create fresh scratch directory if not restarting in midst of step 3
# if cfg.S2EUCDISTFILE != None:
# if cfg.S2EUCDISTFILE.lower() == "restart": pass
# else:
lu.delete_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
if cfg.TOOL == 'Linkage Mapper':
cfg.logFilePath = lu.create_log_file(cfg.MESSAGEDIR, cfg.TOOL,
cfg.PARAMS)
lu.print_drive_warning()
installD = gp.GetInstallInfo("desktop")
gprint('\nLinkage Mapper Version ' + cfg.releaseNum)
try:
gprint('on ArcGIS ' + installD['ProductName'] + ' ' +
installD['Version'] + ' Service Pack ' +
installD['SPNumber'])
except:
pass
if cfg.CONNECTFRAGS:
gwarn = gp.AddWarning
lu.dashline(1)
gwarn(
'Custom mode: will run steps 1-2 ONLY to cluster core polygons within '
)
gwarn('the maximum Euclidean corridor distance from one another ')
gwarn('into polygons with a single cluster_ID value.')
gwarn(
'Make sure you have set a Maximum Euclidean corridor distance.'
)
lu.dashline(2)
cfg.STEP3 = False
cfg.STEP4 = False
cfg.STEP5 = False
if cfg.MAXEUCDIST == None:
raise RuntimeError('Maximum Euclidean distance required '
'for custom cluster mode.')
# Set data frame spatial reference to coordinate system of input data
# Problems arise in this script (core raster creation) and in S2
# (generate near table) if they differ.
lu.set_dataframe_sr()
# Check core ID field and project directory name.
lu.check_cores(cfg.COREFC, cfg.COREFN)
lu.check_project_dir()
# Identify first step cleanup link tables from that point
lu.dashline(1)
if cfg.STEP1:
gprint('Starting at step 1.')
firststep = 1
elif cfg.STEP2:
gprint('Starting at step 2.')
firststep = 2
elif cfg.STEP3:
gprint('Starting at step 3.')
firststep = 3
linkTableFile = lu.get_prev_step_link_table(step=3) # Check exists
elif cfg.STEP4:
gprint('Starting at step 4.')
firststep = 4
linkTableFile = lu.get_prev_step_link_table(step=4) # Check exists
elif cfg.STEP5:
gprint('Starting at step 5.')
firststep = 5
linkTableFile = lu.get_prev_step_link_table(step=5) # Check exists
lu.clean_up_link_tables(firststep)
# Make a local grid copy of resistance raster for cwd runs-
# will run faster than gdb.
# Don't know if raster is in a gdb if entered from TOC
lu.delete_data(cfg.RESRAST)
gprint('\nMaking temporary copy of resistance raster for this run.')
gp.OutputCoordinateSystem = gp.describe(cfg.COREFC).SpatialReference
gp.Extent = gp.Describe(cfg.RESRAST_IN).Extent
gp.SnapRaster = cfg.RESRAST_IN
gp.cellSize = gp.Describe(cfg.RESRAST_IN).MeanCellHeight
# import pdb; pdb.set_trace()
gp.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
if (cfg.STEP1) or (cfg.STEP3):
# Make core raster file
gprint('\nMaking temporary raster of core file for this run.')
lu.delete_data(cfg.CORERAS)
gp.FeatureToRaster_conversion(
cfg.COREFC, cfg.COREFN, cfg.CORERAS,
gp.Describe(cfg.RESRAST).MeanCellHeight)
# # gp.RasterToPolygon_conversion(cfg.CORERAS, cfg.COREFC,
# "NO_SIMPLIFY")
def delete_final_gdb(finalgdb):
"""Deletes final geodatabase"""
if gp.Exists(finalgdb) and cfg.STEP5:
try:
lu.clean_out_workspace(finalgdb)
except:
lu.dashline(1)
msg = ('ERROR: Could not remove contents of geodatabase ' +
finalgdb + '. \nIs it open in ArcMap? You may '
'need to re-start ArcMap to release the file lock.')
lu.raise_error(msg)
lu.delete_dir(finalgdb)
# Delete final output geodatabase
delete_final_gdb(cfg.OUTPUTGDB_OLD)
delete_final_gdb(cfg.OUTPUTGDB)
delete_final_gdb(cfg.EXTRAGDB)
delete_final_gdb(cfg.LINKMAPGDB)
# Run linkage mapper processing steps
if cfg.STEP1:
s1.STEP1_get_adjacencies()
if cfg.STEP2:
s2.STEP2_build_network()
if cfg.STEP3:
s3.STEP3_calc_cwds()
if cfg.STEP4:
s4.STEP4_refine_network()
if cfg.STEP5:
s5.STEP5_calc_lccs()
lu.dashline()
gprint('Results from this run can be found in your output '
'directory:')
gprint(cfg.OUTPUTDIR)
# Clean up
lu.delete_dir(cfg.SCRATCHDIR)
# lu.delete_data(cfg.FCORES)
gp.addmessage('\nDone with linkage mapping.\n')
# Return GEOPROCESSING specific errors
except arcgisscripting.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except:
lu.exit_with_python_error(_SCRIPT_NAME)
finally:
lu.dashline()
gprint('A record of run settings and messages can be found in your '
'log directory:')
gprint(cfg.MESSAGEDIR)
lu.dashline(2)
lu.close_log_file()
def circuitscape_master(argv=None):
"""
"""
gprint = lu.gprint
gwarn = arcpy.AddWarning
if argv is None:
argv = sys.argv
cfg.configure(cfg.TOOL_CS, argv)
gp = cfg.gp
try:
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
cfg.logFilePath=lu.create_log_file(cfg.MESSAGEDIR, cfg.TOOL,
cfg.PARAMS)
CSPATH = lu.get_cs_path()
if CSPATH == None:
msg = ('Cannot find an installation of Circuitscape 3.5.5'
'\nor greater in your Program Files directory.')
arcpy.AddError(msg)
lu.write_log(msg)
exit(1)
try:
csDir, fn = path.split(CSPATH)
if 'flush' not in open(path.join(csDir,'cs_compute.py')).read():
gwarn('\n---------------------------------------------')
gwarn('Your version of Circuitscape is out of date. ')
gwarn('---------------------------------------------\n')
gwarn('Please get the latest from www.circuitscape.org.')
gwarn('The new version interacts more smoothly with ArcMap.')
gprint('Proceeding...\n')
except: pass
lu.print_drive_warning()
# Check core ID field.
lu.check_cores(cfg.COREFC, cfg.COREFN)
gp.OutputCoordinateSystem = gp.describe(cfg.COREFC).SpatialReference
# Set data frame spatial reference to coordinate system of input data
lu.set_dataframe_sr()
gp.pyramid = "NONE"
gp.rasterstatistics = "NONE"
# Move adj and cwd results from earlier versions to datapass directory
lu.move_old_results()
if cfg.CWDCUTOFF > 0:
lu.delete_dir(cfg.SCRATCHDIR)
# restart code- in progress
if cfg.CWDCUTOFF < 0:
cfg.CWDCUTOFF = cfg.CWDCUTOFF * -1
if not cfg.DOPINCH and not cfg.DOCENTRALITY:
msg = ('ERROR: Please choose at least one option: pinch point or\n'
'network centrality analysis.')
lu.raise_error(msg)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
if cfg.DO_ALLPAIRS:
# Fixme: move raster path to config
S5CORRIDORRAS = path.join(cfg.OUTPUTGDB,cfg.PREFIX + "_corridors")
if not gp.Exists(S5CORRIDORRAS):
S5CORRIDORRAS = path.join(cfg.OUTPUTGDB, cfg.PREFIX +
"_lcc_mosaic_int")
if not gp.Exists(S5CORRIDORRAS):
msg = ('ERROR: Corridor raster created in step 5 is required'
'\nfor all-pair analyses, but was not found.')
lu.raise_error(msg)
if cfg.DOPINCH:
if cfg.CWDCUTOFF == '#' or cfg.CWDCUTOFF == 0:
msg = ('ERROR: CWD cutoff distance is required for pinch point'
' analyses.')
lu.raise_error(msg)
# Make a local grid copy of resistance raster-
# will run faster than gdb.
lu.delete_data(cfg.RESRAST)
if not gp.Exists(cfg.RESRAST_IN):
msg = ('ERROR: Resistance raster is required for pinch point'
' analyses, but was not found.')
lu.raise_error(msg)
desc = arcpy.Describe(cfg.RESRAST_IN)
if hasattr(desc, "catalogPath"):
cfg.RESRAST_IN = arcpy.Describe(cfg.RESRAST_IN).catalogPath
arcpy.env.extent = cfg.RESRAST_IN
arcpy.env.snapRaster = cfg.RESRAST_IN
gprint('\nMaking local copy of resistance raster.')
gp.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
if cfg.DOCENTRALITY:
gprint("Creating output folder: " + cfg.CENTRALITYBASEDIR)
if path.exists(cfg.CENTRALITYBASEDIR):
shutil.rmtree(cfg.CENTRALITYBASEDIR)
lu.create_dir(cfg.CENTRALITYBASEDIR)
gp.CreateFolder_management(cfg.CENTRALITYBASEDIR,
cfg.CIRCUITOUTPUTDIR_NM)
gp.CreateFolder_management(cfg.CENTRALITYBASEDIR,
cfg.CIRCUITCONFIGDIR_NM)
lu.clean_out_workspace(cfg.CORECENTRALITYGDB)
s7.STEP7_calc_centrality()
if not cfg.SAVECENTRALITYDIR:
lu.delete_dir(cfg.CENTRALITYBASEDIR)
if cfg.DOPINCH:
if cfg.CWDCUTOFF > 0: # Negative values mean we're restarting
gprint("Creating output folder: " + cfg.CIRCUITBASEDIR)
lu.delete_dir(cfg.CIRCUITBASEDIR)
lu.create_dir(cfg.CIRCUITBASEDIR)
gp.CreateFolder_management(cfg.CIRCUITBASEDIR,
cfg.CIRCUITOUTPUTDIR_NM)
gp.CreateFolder_management(cfg.CIRCUITBASEDIR,
cfg.CIRCUITCONFIGDIR_NM)
s8.STEP8_calc_pinchpoints()
if not cfg.SAVE_TEMP_CIRCUIT_FILES:
lu.delete_dir(cfg.SCRATCHDIR)
if not cfg.SAVECIRCUITDIR:
lu.delete_dir(cfg.CIRCUITBASEDIR)
gprint('\nDONE!\n')
# Return GEOPROCESSING specific errors
except arcgisscripting.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except:
lu.exit_with_python_error(_SCRIPT_NAME)
def lm_master(argv=None):
"""Main function for linkage mapper.
Called by ArcMap with parameters or run from command line with parameters
entered in script below. Calls functions in dedicated scripts for each of
5 processing steps.
"""
# Setup global variables
if not cfg.lm_configured: # Causing problems with iterative scripting
if argv is None:
argv = sys.argv
cfg.configure(cfg.TOOL_LM, argv)
gp = cfg.gp
try:
gprint = lu.gprint
# Move results from earlier versions to new directory structure
lu.move_old_results()
gp.OverwriteOutput = True
gp.pyramid = "NONE"
gp.rasterstatistics = "NONE"
# Create output directories if they don't exist
if gp.Exists(cfg.OUTPUTDIR):
gp.RefreshCatalog(cfg.OUTPUTDIR)
lu.create_dir(cfg.OUTPUTDIR)
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
lu.create_dir(cfg.DATAPASSDIR)
# Create fresh scratch directory if not restarting in midst of step 3
# if cfg.S2EUCDISTFILE != None:
# if cfg.S2EUCDISTFILE.lower() == "restart": pass
# else:
lu.delete_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
if cfg.TOOL == 'Linkage Mapper':
cfg.logFilePath = lu.create_log_file(cfg.MESSAGEDIR, cfg.TOOL,
cfg.PARAMS)
lu.print_drive_warning()
installD = gp.GetInstallInfo("desktop")
gprint('\nLinkage Mapper Version ' + cfg.releaseNum)
try:
gprint('on ArcGIS ' + installD['ProductName'] + ' ' +
installD['Version'] + ' Service Pack ' + installD['SPNumber'])
except:
pass
if cfg.CONNECTFRAGS:
gwarn = gp.AddWarning
lu.dashline(1)
gwarn('Custom mode: will run steps 1-2 ONLY to cluster core polygons within ')
gwarn('the maximum Euclidean corridor distance from one another ')
gwarn('into polygons with a single cluster_ID value.')
gwarn('Make sure you have set a Maximum Euclidean corridor distance.')
lu.dashline(2)
cfg.STEP3 = False
cfg.STEP4 = False
cfg.STEP5 = False
if cfg.MAXEUCDIST == None:
raise RuntimeError('Maximum Euclidean distance required '
'for custom cluster mode.')
# Set data frame spatial reference to coordinate system of input data
# Problems arise in this script (core raster creation) and in S2
# (generate near table) if they differ.
lu.set_dataframe_sr()
# Check core ID field and project directory name.
lu.check_cores(cfg.COREFC, cfg.COREFN)
lu.check_project_dir()
# Identify first step cleanup link tables from that point
lu.dashline(1)
if cfg.STEP1:
gprint('Starting at step 1.')
firststep = 1
elif cfg.STEP2:
gprint('Starting at step 2.')
firststep = 2
elif cfg.STEP3:
gprint('Starting at step 3.')
firststep = 3
linkTableFile = lu.get_prev_step_link_table(step=3) # Check exists
elif cfg.STEP4:
gprint('Starting at step 4.')
firststep = 4
linkTableFile = lu.get_prev_step_link_table(step=4) # Check exists
elif cfg.STEP5:
gprint('Starting at step 5.')
firststep = 5
linkTableFile = lu.get_prev_step_link_table(step=5) # Check exists
lu.clean_up_link_tables(firststep)
# Make a local grid copy of resistance raster for cwd runs-
# will run faster than gdb.
# Don't know if raster is in a gdb if entered from TOC
lu.delete_data(cfg.RESRAST)
gprint('\nMaking temporary copy of resistance raster for this run.')
gp.OutputCoordinateSystem = gp.describe(cfg.COREFC).SpatialReference
gp.Extent = gp.Describe(cfg.RESRAST_IN).Extent
gp.SnapRaster = cfg.RESRAST_IN
gp.cellSize = gp.Describe(cfg.RESRAST_IN).MeanCellHeight
# import pdb; pdb.set_trace()
gp.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
if (cfg.STEP1) or (cfg.STEP3):
# Make core raster file
gprint('\nMaking temporary raster of core file for this run.')
lu.delete_data(cfg.CORERAS)
gp.FeatureToRaster_conversion(cfg.COREFC, cfg.COREFN,
cfg.CORERAS, gp.Describe(cfg.RESRAST).MeanCellHeight)
# # gp.RasterToPolygon_conversion(cfg.CORERAS, cfg.COREFC,
# "NO_SIMPLIFY")
def delete_final_gdb(finalgdb):
"""Deletes final geodatabase"""
if gp.Exists(finalgdb) and cfg.STEP5:
try:
lu.clean_out_workspace(finalgdb)
except:
lu.dashline(1)
msg = ('ERROR: Could not remove contents of geodatabase ' +
finalgdb + '. \nIs it open in ArcMap? You may '
'need to re-start ArcMap to release the file lock.')
lu.raise_error(msg)
lu.delete_dir(finalgdb)
# Delete final output geodatabase
delete_final_gdb(cfg.OUTPUTGDB_OLD)
delete_final_gdb(cfg.OUTPUTGDB)
delete_final_gdb(cfg.EXTRAGDB)
delete_final_gdb(cfg.LINKMAPGDB)
# Run linkage mapper processing steps
if cfg.STEP1:
s1.STEP1_get_adjacencies()
if cfg.STEP2:
s2.STEP2_build_network()
if cfg.STEP3:
s3.STEP3_calc_cwds()
if cfg.STEP4:
s4.STEP4_refine_network()
if cfg.STEP5:
s5.STEP5_calc_lccs()
lu.dashline()
gprint('Results from this run can be found in your output '
'directory:')
gprint(cfg.OUTPUTDIR)
# Clean up
lu.delete_dir(cfg.SCRATCHDIR)
# lu.delete_data(cfg.FCORES)
gp.addmessage('\nDone with linkage mapping.\n')
# Return GEOPROCESSING specific errors
except arcgisscripting.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except:
lu.exit_with_python_error(_SCRIPT_NAME)
finally:
lu.dashline()
gprint('A record of run settings and messages can be found in your '
'log directory:')
gprint(cfg.MESSAGEDIR)
lu.dashline(2)
lu.close_log_file()
def circuitscape_master(argv=None):
"""
"""
gprint = lu.gprint
if argv is None:
argv = sys.argv
argv.append(get_cs_path()) # Add Circuitscape path
cfg.configure(cfg.TOOL_CS, argv)
try:
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
cfg.logFilePath = lu.create_log_file(cfg.PARAM_NAMES, argv)
if cfg.DOPINCH :
lu.log_metadata(cfg.COREFC, [cfg.RESRAST_IN])
else:
lu.log_metadata(cfg.COREFC)
if cfg.CSPATH is None:
lu.raise_error("Cannot find an installation of Circuitscape"
"\nin your Program Files directory.")
lu.print_drive_warning()
# Check core ID field.
lu.check_cores(cfg.COREFC, cfg.COREFN)
arcpy.env.outputCoordinateSystem = arcpy.Describe(cfg.COREFC).SpatialReference
# Set data frame spatial reference to coordinate system of input data
lu.set_dataframe_sr()
arcpy.env.pyramid = "NONE"
arcpy.env.rasterStatistics = "NONE"
# Move adj and cwd results from earlier versions to datapass directory
lu.move_old_results()
if cfg.CWDCUTOFF > 0:
lu.delete_dir(cfg.SCRATCHDIR)
# restart code- in progress
if cfg.CWDCUTOFF < 0:
cfg.CWDCUTOFF = cfg.CWDCUTOFF * -1
if not cfg.DOPINCH and not cfg.DOCENTRALITY:
msg = ('ERROR: Please choose at least one option: pinch point or\n'
'network centrality analysis.')
lu.raise_error(msg)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
if cfg.DO_ALLPAIRS:
# Fixme: move raster path to config
S5CORRIDORRAS = path.join(cfg.OUTPUTGDB,cfg.PREFIX + "_corridors")
if not arcpy.Exists(S5CORRIDORRAS):
S5CORRIDORRAS = path.join(cfg.OUTPUTGDB, cfg.PREFIX +
"_lcc_mosaic_int")
if not arcpy.Exists(S5CORRIDORRAS):
msg = ('ERROR: Corridor raster created in step 5 is required'
'\nfor all-pair analyses, but was not found.')
lu.raise_error(msg)
if cfg.DOPINCH:
if cfg.CWDCUTOFF == '#' or cfg.CWDCUTOFF == 0:
msg = ('ERROR: CWD cutoff distance is required for pinch point'
' analyses.')
lu.raise_error(msg)
# Make a local grid copy of resistance raster-
# will run faster than gdb.
lu.delete_data(cfg.RESRAST)
if not arcpy.Exists(cfg.RESRAST_IN):
msg = ('ERROR: Resistance raster is required for pinch point'
' analyses, but was not found.')
lu.raise_error(msg)
arcpy.env.extent = cfg.RESRAST_IN
desc = arcpy.Describe(cfg.RESRAST_IN)
if hasattr(desc, "catalogPath"):
cfg.RESRAST_IN = arcpy.Describe(cfg.RESRAST_IN).catalogPath
gprint('\nMaking local copy of resistance raster.')
try:
arcpy.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
except Exception:
msg = ('ERROR: Could not make a copy of your resistance raster. ' +
'Try re-starting ArcMap to release the file lock.')
lu.raise_error(msg)
arcpy.env.snapRaster = cfg.RESRAST
if cfg.DOCENTRALITY:
gprint("Creating output folder: " + cfg.CENTRALITYBASEDIR)
if path.exists(cfg.CENTRALITYBASEDIR):
shutil.rmtree(cfg.CENTRALITYBASEDIR)
lu.create_dir(cfg.CENTRALITYBASEDIR)
arcpy.CreateFolder_management(cfg.CENTRALITYBASEDIR,
cfg.CIRCUITOUTPUTDIR_NM)
arcpy.CreateFolder_management(cfg.CENTRALITYBASEDIR,
cfg.CIRCUITCONFIGDIR_NM)
lu.clean_out_workspace(cfg.CORECENTRALITYGDB)
s7.STEP7_calc_centrality()
if not cfg.SAVECENTRALITYDIR:
lu.delete_dir(cfg.CENTRALITYBASEDIR)
if cfg.DOPINCH:
if cfg.CWDCUTOFF > 0: # Negative values mean we're restarting
gprint("Creating output folder: " + cfg.CIRCUITBASEDIR)
lu.delete_dir(cfg.CIRCUITBASEDIR)
lu.create_dir(cfg.CIRCUITBASEDIR)
arcpy.CreateFolder_management(cfg.CIRCUITBASEDIR,
cfg.CIRCUITOUTPUTDIR_NM)
arcpy.CreateFolder_management(cfg.CIRCUITBASEDIR,
cfg.CIRCUITCONFIGDIR_NM)
s8.STEP8_calc_pinchpoints()
if not cfg.SAVE_TEMP_CIRCUIT_FILES:
lu.delete_dir(cfg.SCRATCHDIR)
if not cfg.SAVECIRCUITDIR:
lu.delete_dir(cfg.CIRCUITBASEDIR)
gprint('\nDONE!\n')
# Return GEOPROCESSING specific errors
except arcpy.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except Exception:
lu.exit_with_python_error(_SCRIPT_NAME)
def bar_master(argv=None):
""" Experimental code to detect barriers using cost-weighted distance
outputs from Linkage Mapper tool.
"""
if argv is None:
argv = sys.argv
# cfg.configure(argv)
cfg.configure(cfg.TOOL_BM, argv) #xxx was sys.argv
gprint = lu.gprint
try:
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
cfg.logFilePath = lu.create_log_file(cfg.MESSAGEDIR, cfg.TOOL,
cfg.PARAMS)
lu.print_drive_warning()
# Move adj and cwd results from earlier versions to datapass directory
lu.move_old_results()
lu.create_dir(cfg.OUTPUTDIR)
lu.delete_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
lu.dashline(1)
gprint('\nMaking local copy of resistance raster.')
lu.delete_data(cfg.RESRAST)
desc = arcpy.Describe(cfg.RESRAST_IN)
if hasattr(desc, "catalogPath"):
cfg.RESRAST_IN = arcpy.Describe(cfg.RESRAST_IN).catalogPath
arcpy.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
arcpy.env.extent = cfg.RESRAST
arcpy.env.snapRaster = cfg.RESRAST
if cfg.BARRIER_METH_MAX:
cfg.SUM_BARRIERS = False
lu.dashline(1)
gprint(
'Calculating MAXIMUM barrier effects across core area pairs')
s6.STEP6_calc_barriers()
if cfg.BARRIER_METH_SUM:
cfg.SUM_BARRIERS = True
gprint('')
lu.dashline()
gprint('Calculating SUM of barrier effects across core area pairs')
s6.STEP6_calc_barriers()
#clean up
lu.delete_dir(cfg.SCRATCHDIR)
if not cfg.SAVEBARRIERDIR:
lu.delete_dir(cfg.BARRIERBASEDIR)
gprint('\nDone with barrier mapping.\n')
# Return GEOPROCESSING specific errors
except arcpy.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except:
lu.exit_with_python_error(_SCRIPT_NAME)
def lm_master(argv=None):
"""Main function for linkage mapper.
Called by ArcMap with parameters or run from command line with parameters
entered in script below. Calls functions in dedicated scripts for each of
5 processing steps.
"""
# Setup global variables
if cfg.TOOL != cfg.TOOL_CC:
if argv is None:
argv = sys.argv
cfg.configure(cfg.TOOL_LM, argv)
gprint = lu.gprint
try:
# Move results from earlier versions to new directory structure
lu.move_old_results()
arcpy.env.pyramid = "NONE"
arcpy.env.rasterStatistics = "NONE"
# Create output directories if they don't exist
lu.create_dir(cfg.OUTPUTDIR)
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
lu.create_dir(cfg.DATAPASSDIR)
if cfg.TOOL != cfg.TOOL_CC:
lu.delete_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
if cfg.TOOL == cfg.TOOL_LM:
cfg.logFilePath = lu.create_log_file(cfg.PARAM_NAMES, argv)
lu.write_custom_to_log(cfg.LMCUSTSETTINGS)
lu.log_metadata(cfg.COREFC, [cfg.RESRAST_IN])
lu.print_drive_warning()
if cfg.CONNECTFRAGS:
lu.dashline(1)
lu.warn('Custom mode: will run steps 1-2 ONLY to cluster core polygons within ')
lu.warn('the maximum Euclidean corridor distance from one another ')
lu.warn('into polygons with a single cluster_ID value.')
lu.warn('Make sure you have set a Maximum Euclidean corridor distance.')
lu.dashline(2)
cfg.STEP3 = False
cfg.STEP4 = False
cfg.STEP5 = False
if cfg.MAXEUCDIST == None:
raise RuntimeError('Maximum Euclidean distance required '
'for custom cluster mode.')
# Set data frame spatial reference to coordinate system of input data
# Problems arise in this script (core raster creation) and in S2
# (generate near table) if they differ.
lu.set_dataframe_sr()
# Check core ID field and project directory name.
lu.check_cores(cfg.COREFC, cfg.COREFN)
lu.check_project_dir()
# Identify first step cleanup link tables from that point
lu.dashline(1)
if cfg.STEP1:
gprint('Starting at step 1.')
firststep = 1
elif cfg.STEP2:
gprint('Starting at step 2.')
firststep = 2
elif cfg.STEP3:
gprint('Starting at step 3.')
firststep = 3
linkTableFile = lu.get_prev_step_link_table(step=3) # Check exists
elif cfg.STEP4:
gprint('Starting at step 4.')
firststep = 4
linkTableFile = lu.get_prev_step_link_table(step=4) # Check exists
elif cfg.STEP5:
gprint('Starting at step 5.')
firststep = 5
linkTableFile = lu.get_prev_step_link_table(step=5) # Check exists
lu.clean_up_link_tables(firststep)
# Make a local grid copy of resistance raster for cwd runs-
# will run faster than gdb.
# Don't know if raster is in a gdb if entered from TOC
lu.delete_data(cfg.RESRAST)
gprint('\nMaking temporary copy of resistance raster for this run.')
arcpy.env.outputCoordinateSystem = arcpy.Describe(cfg.COREFC).SpatialReference
arcpy.env.extent = arcpy.Describe(cfg.RESRAST_IN).Extent
arcpy.env.snapRaster = cfg.RESRAST_IN
arcpy.env.cellSize = arcpy.Describe(cfg.RESRAST_IN).MeanCellHeight
try:
arcpy.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
except Exception:
msg = ('ERROR: Could not make a copy of your resistance raster. ' +
'Try re-starting ArcMap to release the file lock.')
lu.raise_error(msg)
if (cfg.STEP1) or (cfg.STEP3):
# Make core raster file
gprint('\nMaking temporary raster of core file for this run.')
lu.delete_data(cfg.CORERAS)
arcpy.FeatureToRaster_conversion(cfg.COREFC, cfg.COREFN,
cfg.CORERAS, arcpy.Describe(cfg.RESRAST).MeanCellHeight)
def delete_final_gdb(finalgdb):
"""Deletes final geodatabase"""
if arcpy.Exists(finalgdb) and cfg.STEP5:
try:
lu.clean_out_workspace(finalgdb)
except Exception:
lu.dashline(1)
msg = ('ERROR: Could not remove contents of geodatabase ' +
finalgdb + '. \nIs it open in ArcMap? You may '
'need to re-start ArcMap to release the file lock.')
lu.raise_error(msg)
lu.delete_dir(finalgdb)
# Delete final output geodatabase
delete_final_gdb(cfg.OUTPUTGDB_OLD)
delete_final_gdb(cfg.OUTPUTGDB)
delete_final_gdb(cfg.EXTRAGDB)
delete_final_gdb(cfg.LINKMAPGDB)
# Run linkage mapper processing steps
if cfg.STEP1:
s1.STEP1_get_adjacencies()
if cfg.STEP2:
s2.STEP2_build_network()
if cfg.STEP3:
s3.STEP3_calc_cwds()
if cfg.STEP4:
s4.STEP4_refine_network()
if cfg.STEP5:
s5.STEP5_calc_lccs()
lu.dashline()
gprint('Results from this run can be found in your output '
'directory:')
gprint(cfg.OUTPUTDIR)
# Clean up
lu.delete_dir(cfg.SCRATCHDIR)
arcpy.AddMessage('\nDone with linkage mapping.\n')
# Return GEOPROCESSING specific errors
except arcpy.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except Exception:
lu.exit_with_python_error(_SCRIPT_NAME)
finally:
lu.dashline()
gprint('A record of run settings and messages can be found in your '
'log directory:')
gprint(cfg.MESSAGEDIR)
lu.dashline(2)
lu.close_log_file()
def bar_master(argv=None):
"""Detect barriers using CWD outputs from Linkage Mapper tool."""
if argv is None:
argv = sys.argv
cfg.configure(cfg.TOOL_BM, argv)
gprint = lu.gprint
try:
lu.create_dir(cfg.LOGDIR)
lu.create_dir(cfg.MESSAGEDIR)
cfg.logFilePath = lu.create_log_file(cfg.PARAM_NAMES, argv)
lu.log_metadata(rasters=[cfg.RESRAST_IN])
lu.print_drive_warning()
# Move adj and cwd results from earlier versions to datapass directory
lu.move_old_results()
lu.create_dir(cfg.OUTPUTDIR)
lu.delete_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.SCRATCHDIR)
lu.create_dir(cfg.ARCSCRATCHDIR)
lu.dashline(1)
gprint('\nMaking local copy of resistance raster.')
lu.delete_data(cfg.RESRAST)
arcpy.env.extent = arcpy.Describe(cfg.RESRAST_IN).Extent
desc = arcpy.Describe(cfg.RESRAST_IN)
if hasattr(desc, "catalogPath"):
cfg.RESRAST_IN = arcpy.Describe(cfg.RESRAST_IN).catalogPath
try:
arcpy.CopyRaster_management(cfg.RESRAST_IN, cfg.RESRAST)
except arcpy.ExecuteError:
msg = ('ERROR: Could not make a copy of your resistance raster. '
'Try re-starting ArcMap to release the file lock.')
lu.raise_error(msg)
arcpy.env.snapRaster = cfg.RESRAST
if cfg.BARRIER_METH_MAX:
cfg.SUM_BARRIERS = False
lu.dashline(1)
gprint('Calculating MAXIMUM barrier effects across core area '
'pairs')
s6.step6_calc_barriers()
if cfg.BARRIER_METH_SUM:
cfg.SUM_BARRIERS = True
gprint('')
lu.dashline()
gprint('Calculating SUM of barrier effects across core area pairs')
s6.step6_calc_barriers()
# Clean up
lu.delete_dir(cfg.SCRATCHDIR)
if not cfg.SAVEBARRIERDIR:
lu.delete_dir(cfg.BARRIERBASEDIR)
gprint('\nDone with barrier mapping.\n')
# Return GEOPROCESSING specific errors
except arcpy.ExecuteError:
lu.exit_with_geoproc_error(_SCRIPT_NAME)
# Return any PYTHON or system specific errors
except Exception:
lu.exit_with_python_error(_SCRIPT_NAME)