def ClearSelectedFeatures(fc): """ Removes a selection from the provided feature class :param fc: a feature class :return: None """ if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") m = p.activeMap for lyr in m.listLayers(fc): if lyr.getSelectionSet(): arcpy.AddMessage("clearing {} selected features for " "layer: '{}'".format( len(lyr.getSelectionSet()), lyr.name)) arcpy.management.SelectLayerByAttribute(lyr, 'CLEAR_SELECTION') del m else: mxd = arcpy.mapping.MapDocument("CURRENT") for lyr in arcpy.mapping.ListLayers(mxd, fc): if lyr.getSelectionSet(): arcpy.AddMessage("clearing {} selected features for " "layer: '{}'".format( len(lyr.getSelectionSet()), lyr.name)) arcpy.management.SelectLayerByAttribute(lyr, 'CLEAR_SELECTION') del mxd
def AddAnthroToMap(workspace, anthro_feature): """ Adds anthropogenic features to the map document by replacing the existing state-wide layer with the clipped (project-specific) feature (replacing existing maintains the subtype templates for editing). Note that clipped anthro features must have 'Anthro_' and '_clip' (not cap sensitive) as prefix and suffix. :param workspace: the gdb with the clipped (project-specific) anthro features :param anthro_feature: the anthro feature to be added to the map document :return: None """ if arcpy.ListInstallations( )[0] == 'arcgispro': #switch for arcpro and gis desktop p = arcpy.mp.ArcGISProject("CURRENT") m = p.activeMap try: for existingLayer in m.listLayers(): if existingLayer.name == anthro_feature[7:-5]: #workspace_type = "FILEGDB_WORKSPACE" #dataset_name = anthro_feature new_conn_prop = existingLayer.connectionProperties new_conn_prop['connection_info']['database'] = workspace new_conn_prop['dataset'] = anthro_feature #existingLayer.replaceDataSource(workspace, workspace_type, # dataset_name) existingLayer.updateConnectionProperties( existingLayer.connectionProperties, new_conn_prop) #arcpy.RefreshActiveView() except arcpy.ExecuteError: for existingLayer in m.listLayers(): if existingLayer.name == anthro_feature: arcpy.mp.RemoveLayer(existingLayer) refLayer = m.ListLayers("Analysis_Area")[0] m.insertLayer(m, refLayer, anthro_feature, "AFTER") del p, m else: # Add layer to map arcpy.AddMessage("Adding layer to map document") mxd = arcpy.mapping.MapDocument("CURRENT") df = mxd.activeDataFrame layer = arcpy.mapping.Layer(anthro_feature) try: for existingLayer in arcpy.mapping.ListLayers(mxd, "", df): if existingLayer.name == layer.name[7:-5]: workspace_type = "FILEGDB_WORKSPACE" dataset_name = anthro_feature existingLayer.replaceDataSource(workspace, workspace_type, dataset_name) arcpy.RefreshActiveView() except arcpy.ExecuteError: for existingLayer in arcpy.mapping.ListLayers(mxd, "", df): if existingLayer.name == layer.name: arcpy.mapping.RemoveLayer(df, existingLayer) refLayer = arcpy.mapping.ListLayers(mxd, "Analysis_Area", df)[0] arcpy.mapping.InsertLayer(df, refLayer, layer, "AFTER") del mxd, df, layer
def AdoptParameter(provided_input, parameter_name, preserve_existing=True): """ Copies the provided input into the geodatabase as the parameter_name parameter. If a feature class already exists with the parameter_name, a unique copy will be saved (with preserve_existing=True). Workspace must be defined as project's unique geodatabase before calling this function. :param provided_input: a feature class or shapefile :param parameter_name: the name to save the provided_input as string :param preserve_existing: True to avoid overwriting :return: the name of the adopted parameter as a string """ # Save a copy of the existing feature class if it already exists if preserve_existing: if arcpy.Exists(parameter_name): new_parameter_name = arcpy.CreateUniqueName(parameter_name) arcpy.CopyFeatures_management(parameter_name, new_parameter_name) # Copy providedInput to temporary memory to allow overwriting arcpy.CopyFeatures_management(provided_input, "in_memory/tmp_provided") # Delete existing layers in the TOC of the paramaterName if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") m = p.activeMap for _ in m.listLayers(): arcpy.Delete_management(parameter_name) else: mxd = arcpy.mapping.MapDocument("CURRENT") for _ in arcpy.mapping.ListLayers(mxd, parameter_name): arcpy.Delete_management(parameter_name) # Delete feature classes in the geodatabase for _ in arcpy.ListFeatureClasses(parameter_name): arcpy.Delete_management(parameter_name) # Execute renaming adopted_parameter = arcpy.CopyFeatures_management( "in_memory/tmp_provided", parameter_name ) # Clean up arcpy.Delete_management("in_memory") return adopted_parameter
def getWorkflowManagerToolboxLocation(): # Import the workflow manager toolbox wmxToolbox = None installations = arcpy.ListInstallations() for installation in installations: installInfo = arcpy.GetInstallInfo(installation) if installInfo != None: tbx = installInfo["InstallDir"] + os.sep + "ArcToolbox" + os.sep + "Toolboxes" + os.sep + "Workflow Manager Administration Tools.tbx" tbx = os.path.normpath(tbx) if os.path.exists(tbx): wmxToolbox = tbx break if wmxToolbox == None: raise InstallationError("Workflow Manager Administration Tools toolbox not found") return wmxToolbox
def AddToMap(feature_or_raster, layer_file=None, zoom_to=False): """ Adds provided to the map document after removing any layers of the same name. :param feature_or_raster: feature class or raster dataset :param layer_file: layer file :param zoom_to: True to zoom to the added object :return: None """ # Add layer to map arcpy.AddMessage("Adding layer to map document") if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") m = p.activeMap layer_path = arcpy.Describe( feature_or_raster ).catalogPath #arcpy.Describe calls metadata, so this gives full path for existingLayer in m.listLayers(m): if existingLayer.name == feature_or_raster: m.remove_layer(existingLayer) m.addDataFromPath(layer_path) # TODO: revisit layer file application in Pro. if layer_file: arcpy.ApplySymbologyFromLayer_management(feature_or_raster, layer_file) #if zoom_to: # m.extent = layer.getSelectedExtent() del p, m else: mxd = arcpy.mapping.MapDocument("CURRENT") df = mxd.activeDataFrame layer_path = arcpy.Describe(feature_or_raster).catalogPath layer = arcpy.mapping.Layer(layer_path) for existingLayer in arcpy.mapping.ListLayers(mxd, "", df): if existingLayer.name == layer.name: arcpy.mapping.RemoveLayer(df, existingLayer) arcpy.mapping.AddLayer(df, layer) if layer_file: arcpy.ApplySymbologyFromLayer_management(layer.name, layer_file) if zoom_to: df.extent = layer.getSelectedExtent() del mxd, df, layer
def RenameFeatureClass(in_data, out_data): """ Deletes existing layers and feature classes of the out_data name and renames provided feature class. Provided feature class may not have the same name as the out_data. The in_data will be deleted. :param in_data: a feature class :param out_data: the name to save the output as a string :return: the name of the output as a string """ # Delete any existing instances of the file to be overwritten # Delete layers in the TOC if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") m = p.activeMap try: for layer in m.listLayers(out_data): arcpy.Delete_management(layer) for feature in arcpy.ListFeatureClasses(out_data): arcpy.Delete_management(feature) except arcpy.ExecuteError: arcpy.AddMessage("Renaming failed to delete existing feature") else: mxd = arcpy.mapping.MapDocument("CURRENT") try: for layer in arcpy.mapping.ListLayers(mxd, out_data): arcpy.Delete_management(layer) # Delete feature classes in the geodatabase for feature in arcpy.ListFeatureClasses(out_data): arcpy.Delete_management(feature) except arcpy.ExecuteError: arcpy.AddMessage("Renaming failed to delete existing feature") # Execute renaming out_fc = arcpy.CopyFeatures_management(in_data, out_data) arcpy.Delete_management(in_data) return out_fc
def main(): # GET PARAMETER VALUES Map_Units_Dissolve_Provided = arcpy.GetParameterAsText(0) Transects_Provided = arcpy.GetParameterAsText(1) # optional Project_Folder = arcpy.GetParameterAsText(2) Project_Name = arcpy.GetParameterAsText(3) # optional # DEFINE DIRECTORIES & PATH NAMES FOR FOLDERS & GBDs # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) # Construct pathname to workspace projectGDB = arcpy.Describe(Map_Units_Dissolve_Provided).path arcpy.AddMessage("Project geodatabase: " + projectGDB) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = projectGDB scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(projectGDB).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES # Filenames for feature classes or rasters used by this script MAP_UNITS_DISSOLVE = "Map_Units_Dissolve" # Filenames for feature classes or rasters created by this script TRANSECTS_SJ = "Transects_SpatialJoin" # ------------------------------------------------------------------------ # FUNCTION CALLS if Transects_Provided: # Update message arcpy.AddMessage("Executing spatial join of Transects and " "Map_Unit_Dissolve layer") # hqtlib.AddTransectFields(Transects) Map_Units_Dissolve = MAP_UNITS_DISSOLVE out_name = TRANSECTS_SJ hqtlib.TransectJoin(Map_Units_Dissolve, Transects_Provided, out_name) else: # arcpy.AddError("ERROR:: Please provide the transects feature " # "class or shapefile. See User's Guide.") # sys.exit(0) # Check out Spatial Analyst extension hqtlib.CheckOutSpatialAnalyst() # Check Map_Units_Dissolve layer required_fields = ["Transects"] no_null_fields = ["Transects"] expected_fcs = None hqtlib.CheckPolygonInput(Map_Units_Dissolve_Provided, required_fields, expected_fcs, no_null_fields) Map_Units = Map_Units_Dissolve_Provided field_name = "Transects" out_name = "Transects" transects = hqtlib.GenerateTransects( projectGDB, Map_Units, field_name, out_name) ##swapped "workspace" for "project GDB" hqtlib.AddTransectFields(transects) # Identify the map unit associated with each transect hqtlib.TransectJoin(MAP_UNITS_DISSOLVE, transects, TRANSECTS_SJ) # Remove unnecessary fields allowable_fields = [ "Bearing1", "Bearing2", "Bearing3", "UTM_E", "UTM_N", "Map_Unit_ID", "Map_Unit_Name", "Indirect", "Acres", "PropLek", "PropMesic", "Current_Breed", "Current_Summer", "Current_Winter", "Projected_Breed", "Projected_Summer", "Projected_Winter", "Permanent_Breed", "Permanent_Summer", "Permanent_Winter", "Transects" ] util.SimplifyFields(TRANSECTS_SJ, allowable_fields) # Add Transects to map util.AddToMap(TRANSECTS_SJ) # Export data to Excel table = TRANSECTS_SJ hqtlib.ExportToExcel(table, Project_Folder, Project_Name) # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES workspace = arcpy.GetParameterAsText(0) Provided_Disturbance = arcpy.GetParameterAsText(1) includes_anthro_mod = arcpy.GetParameterAsText(2) # optional Proposed_Modified_Features_Provided = arcpy.GetParameterAsText( 3) # optional # Update boolean parameters includes_anthro_mod = ccslib.Str2Bool(includes_anthro_mod) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace arcpy.env.scratchWorkspace = workspace # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES AnthroAttributeTable = ccsStandard.AnthroAttributeTable coordinate_system = ccsStandard.CoorSystem # Filenames for feature classes and rasters created by this script PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() # Update includes_anthro_mod if Proposed_Modified_Features is # provided if Proposed_Modified_Features_Provided and not includes_anthro_mod: includes_anthro_mod = True # Check input features for existence of features and feature type; # create template if Proposed_Surface_Disturbance is not provided if Provided_Disturbance: # Check provided input ccslib.CheckPolygonInput(Provided_Disturbance) # Check provided input for 'Feature' field, error and exit if so existing_fields = [ field.name.lower() for field in arcpy.ListFields(Provided_Disturbance) ] if 'feature' in existing_fields: arcpy.AddError("ERROR:: The provided proposed surface " "disturbance layer includes a field named " "'Feature' in the attribute table. Please " "rename this field and re-run this tool. ") sys.exit(0) # Create a local copy of the provided disturbance in case it is # the output of the projected input from re-running Debit Tool 1 PSD_copy = arcpy.CopyFeatures_management(Provided_Disturbance, "in_memory/PSD_provided") # Update message arcpy.AddMessage("Projecting provided feature(s) to " + coordinate_system.name) # Project input to standard coordinate system inputFeature = PSD_copy out_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS Proposed_Surface_Disturbance = ccslib.ProjectInput( inputFeature, out_name, coordinate_system) zoom_to = True else: # Update message arcpy.AddMessage("Creating template for digitizing proposed " "surface disturbance \nDigitize features in " "feature class named " "Proposed_Surface_Disturbance_Debits created within " "the project's unique geodatabase") # Create a template out_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS Proposed_Surface_Disturbance = ccslib.CreateTemplate( workspace, out_name, coordinate_system) zoom_to = False if includes_anthro_mod: # Create a template for digitizing anthropogenic features proposed for # modification out_name = "Proposed_Modified_Features_tmp" Template_Features = ccslib.CreateTemplate(workspace, out_name, coordinate_system) if Proposed_Modified_Features_Provided: # Do not zoom to proposed surface disturbance zoom_to = False # Merge with the provided layer, if provided fileList = [Proposed_Modified_Features_Provided, Template_Features] out_name = "in_memory/tmp_Modified" merged_features = ccslib.MergeFeatures(fileList, out_name) # Rename the provided as merged (cannot merge two files with # equivalent filenames) as Proposed_Modified_Features in_data = merged_features out_data = PROPOSED_MODIFIED_FEATURES Proposed_Modified_Features = arcpy.CopyFeatures_management( in_data, out_data) else: # Save the template as Proposed_Modified_Features in_data = Template_Features out_data = PROPOSED_MODIFIED_FEATURES Proposed_Modified_Features = ccslib.RenameFeatureClass( in_data, out_data) # Update message arcpy.AddMessage("Adding fields Type and Subtype to " "the Proposed_Modified_Features layer") # Add fields Type and Subtype inputFeature = Proposed_Modified_Features fieldsToAdd = ["Type", "Subtype"] fieldTypes = ["TEXT", "TEXT"] ccslib.AddFields(inputFeature, fieldsToAdd, fieldTypes, copy_existing=True) # Clean up arcpy.Delete_management(Template_Features) # Create Domain for Subtype attributes and assign to Subtype field featureList = [Proposed_Modified_Features] ccslib.AddSubtypeDomains(featureList, workspace, AnthroAttributeTable) # Add layer to map for editing layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Modified_Features, layerFile) # Add layer to map document layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Surface_Disturbance, layerFile, zoom_to) # Update message arcpy.AddMessage("Adding fields to Proposed_Surface_Disturbance") # Add fields for Type, Subtype, Surface Disturbance, and Reclassifed Subtype input_feature = Proposed_Surface_Disturbance fields = ["Type", "Subtype", "Surface_Disturbance", "Reclassified_Subtype"] fieldTypes = ["TEXT", "TEXT", "TEXT", "TEXT"] ccslib.AddFields(input_feature, fields, fieldTypes, copy_existing=True) # Add Domains to Proposed_Surface_Disturbance_Debits layer featureList = [Proposed_Surface_Disturbance] domain_name = "Type" code_list = [ row[0] for row in arcpy.da.SearchCursor(AnthroAttributeTable, "Type") ] # Create Domain for Subtype attributes and assign to Subtype field ccslib.AddSubtypeDomains(featureList, workspace, AnthroAttributeTable) # Create Domain for Type attributes and assign to Type field ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list) # Create Domain for Type attributes and assign to Surface Disturbance field domain_name = "Surface_Disturbance" code_list = [ "Term_Reclaimed", "Term_Retired", "Term_Reclassified", "Permanent" ] ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list) # Create Domain for Type attributes and assign to Reclassified Subtype # field domain_name = "Reclassified_Subtype" code_list = [ row[0] for row in arcpy.da.SearchCursor(AnthroAttributeTable, "Subtype") ] ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list) if includes_anthro_mod: # Extend type domain to Proposed_Modified_Features try: arcpy.AssignDomainToField_management(Proposed_Modified_Features, "Type", "Type") except arcpy.ExecuteError: arcpy.AddMessage("Type domain not updated for " "Proposed_Modified_Features") # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
inDTM = arcpy.GetParameterAsText(1) outGDB = arcpy.GetParameterAsText(2) temp = [] try: print "Starting at " + time.strftime("%c") ## This section returns the system information for the user. This is used to help ## debug any potential errors returned by the tool. This information does not compromise ## the annonymity of the user or their system. ##--------------------------------------------------------------------------------------- # Get information about ArcGIS version installed... arcpy.SetProgressorLabel("Reading installation information...") arcpy.AddMessage("--------------------------------") installList = arcpy.ListInstallations() for install in installList: arcpy.AddMessage("Product: ArcGIS for " + install + " " + arcpy.GetInstallInfo(install)["Version"] + " SP " + arcpy.GetInstallInfo()["SPNumber"] + ", Build " + arcpy.GetInstallInfo()["BuildNumber"]) print("Product: ArcGIS for " + install + " " + arcpy.GetInstallInfo(install)["Version"] + " SP " + arcpy.GetInstallInfo()["SPNumber"] + ", Build " + arcpy.GetInstallInfo()["BuildNumber"]) arcpy.AddMessage("Installed on: " + arcpy.GetInstallInfo()["InstallDate"] + " " + arcpy.GetInstallInfo()["InstallTime"]) print("Installed on: " + arcpy.GetInstallInfo()["InstallDate"] + " " + arcpy.GetInstallInfo()["InstallTime"]) arcpy.AddMessage("Using " + arcpy.ProductInfo() + " license level")
def main(): # GET PARAMETER VALUES Map_Units_Provided = arcpy.GetParameterAsText(0) Transects_Provided = arcpy.GetParameterAsText(1) # optional Project_Folder = arcpy.GetParameterAsText(2) Project_Name = arcpy.GetParameterAsText(3) # optional # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace projectGDB = arcpy.Describe(Map_Units_Provided).path arcpy.AddMessage("Project geodatabase: " + projectGDB) # Instantiate a idStandard object cheStandard = cohqt.cheStandard(projectGDB, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = projectGDB scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(projectGDB).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES # Filenames for feature classes or rasters used by this script MAP_UNITS = "Map_Units" # Filenames for feature classes or rasters created by this script TRANSECTS_SJ = "Transects_SpatialJoin" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check Map_Units_Dissolve layer required_fields = ["Transects"] no_null_fields = None expected_fcs = None hqtlib.CheckPolygonInput(Map_Units_Provided, required_fields, expected_fcs, no_null_fields) # Update Map Units layer with provided layer and add to map Map_Units = util.AdoptParameter(Map_Units_Provided, MAP_UNITS, preserve_existing=False) layerFile = cheStandard.getLayerFile("MapUnits.lyr") util.AddToMap(Map_Units, layerFile) if Transects_Provided: # Update message arcpy.AddMessage("Executing spatial join of Transects and " "Map_Unit_Dissolve layer") out_name = TRANSECTS_SJ transects = Transects_Provided hqtlib.TransectJoin(Map_Units, transects, out_name) else: # arcpy.AddError("ERROR:: Please provide the transects feature" # "class or shapefile provided by the SETT") # sys.exit(0) # Check out Spatial Analyst extension hqtlib.CheckOutSpatialAnalyst() # Generate transects field_name = "Transects" out_name = "Transects" transects = hqtlib.GenerateTransects(projectGDB, Map_Units, field_name, out_name) # Add transect fields hqtlib.AddTransectFields(transects) util.AddToMap(out_name) # Identify the map unit associated with each transect out_name = TRANSECTS_SJ transects = transects hqtlib.TransectJoin(Map_Units, transects, out_name) # Remove unnecessary fields allowable_fields = [ "Bearing1", "Bearing2", "Bearing3", "UTM_E", "UTM_N", "Map_Unit_ID", "Map_Unit_Name", "Precip", "Transects" ] util.SimplifyFields(TRANSECTS_SJ, allowable_fields) # Add Transects to map util.AddToMap(TRANSECTS_SJ) # Export data to Excel table = TRANSECTS_SJ hqtlib.ExportToExcel(table, Project_Folder, Project_Name) # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Map_Units_Provided = arcpy.GetParameterAsText(0) # optional Proposed_Modified_Features_Provided = arcpy.GetParameterAsText(1) # optional Project_Folder = arcpy.GetParameterAsText(2) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace if Map_Units_Provided: workspace = arcpy.Describe(Map_Units_Provided).path elif Proposed_Modified_Features_Provided: workspace = arcpy.Describe(Proposed_Modified_Features_Provided).path else: arcpy.AddMessage("Please provide either a Map_Units or " + "Proposed_Modified_Features layer.") sys.exit(0) arcpy.AddMessage("Project geodatabase: " + workspace) Project_Folder = arcpy.Describe(workspace).path arcpy.AddMessage("Project folder:" + Project_Folder) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join( arcpy.Describe(workspace).path, 'scratch' ) if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(workspace).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES AnthroAttributeTable = ccsStandard.AnthroAttributeTable # Filenames for feature class and rasters created by this script INDIRECT_IMPACT_AREA = "Indirect_Impact_Area" ANALYSIS_AREA = "Analysis_Area" # Filenames for feature classes or rasters used by this script MAP_UNITS = "Map_Units" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" CREDIT_PROJECT_AREA = "Credit_Project_Area" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check provided layers if not Map_Units_Provided and not Proposed_Modified_Features_Provided: arcpy.AddError("ERROR:: Please provide a 'Map_Units' and/or " "'Proposed_Modified_Features' feature.") sys.exit(0) if not Proposed_Modified_Features_Provided: # Ensure Proposed_Modified_Features does not exist if arcpy.Exists("Proposed_Modified_Features"): arcpy.AddError("ERROR:: A 'Proposed_Modified_Features' layer " "was detected in the project's geodatabase. " "Provide the 'Proposed_Modified_Features' layer " "and re-run Credit Tool 2.") sys.exit(0) if Map_Units_Provided: # Clear selection, if present ccslib.ClearSelectedFeatures(Map_Units_Provided) # Check provided layer feature = Map_Units_Provided required_fields = ["Map_Unit_ID", "Map_Unit_Name", "Meadow"] no_null_fields = ["Map_Unit_ID", "Meadow"] expected_fcs = [CREDIT_PROJECT_AREA] ccslib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Map Units layer with provided layer provided_input = Map_Units_Provided parameter_name = MAP_UNITS preserve_existing = False Map_Units = ccslib.AdoptParameter(provided_input, parameter_name, preserve_existing) # Add Map Units layer to map layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(Map_Units, layerFile) # Provide location of Credit Project Area Credit_Project_Area = CREDIT_PROJECT_AREA # Set up flag for projects that propose to modify anthro features includes_anthro_mod = False if Proposed_Modified_Features_Provided: # Update flag includes_anthro_mod = True # Clear selection, if present ccslib.ClearSelectedFeatures(Proposed_Modified_Features_Provided) # Check provided layer required_fields = ["Type", "Subtype"] no_null_fields = required_fields expected_fcs = None ccslib.CheckPolygonInput(Proposed_Modified_Features_Provided, required_fields, expected_fcs, no_null_fields) # Update Proposed_Modified_Features with provided layer provided_input = Proposed_Modified_Features_Provided parameterName = PROPOSED_MODIFIED_FEATURES preserve_existing = False Proposed_Modified_Features = ccslib.AdoptParameter( provided_input, parameterName, preserve_existing ) # Add Proposed Modified Features layer to map layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Modified_Features, layerFile) # Update message arcpy.AddMessage("Creating the area of indirect benefit") # Create Credit_Project_Area for projects that propose to modify # anthropogenic features # Create the Indirect_Impact_Area in_data = Proposed_Modified_Features out_name = INDIRECT_IMPACT_AREA Indirect_Impact_Area = ccslib.CreateIndirectImpactArea( in_data, AnthroAttributeTable, out_name ) # Add field "Indirect" input_feature = Indirect_Impact_Area fieldsToAdd = ["Indirect"] fieldTypes = ["TEXT"] ccslib.AddFields(input_feature, fieldsToAdd, fieldTypes) # Update field 'Indirect' to equal 'True' with arcpy.da.UpdateCursor(Indirect_Impact_Area, fieldsToAdd) as cursor: for row in cursor: row[0] = "True" cursor.updateRow(row) if Map_Units_Provided: # Merge with Credit_Project_Boundary fileList = [Map_Units_Provided, Indirect_Impact_Area] out_name = "in_memory/Credit_Project_Boundary" Project_Area = arcpy.Union_analysis(fileList, out_name) else: Project_Area = Indirect_Impact_Area # Eliminate areas of non-habitat to create Credit_Project_Area out_name = CREDIT_PROJECT_AREA habitat_bounds = ccsStandard.HabitatBounds Credit_Project_Area = ccslib.EliminateNonHabitat( Project_Area, out_name, habitat_bounds ) # Update message arcpy.AddMessage("Copying Credit_Project_Area as shapefile into project" " folder") # Export feature class to shapefile in project folder so it can be sent to # NDOW for Dist_Lek layer arcpy.FeatureClassToShapefile_conversion(Credit_Project_Area, Project_Folder) # Update message arcpy.AddMessage("Creating Analysis Area") # Create Analysis Area out_name = ANALYSIS_AREA Analysis_Area = ccslib.CreateAnalysisArea(Credit_Project_Area, AnthroAttributeTable, out_name) # Add Analysis_Area to map layerFile = ccsStandard.getLayerFile("Analysis_Area.lyr") ccslib.AddToMap(Analysis_Area, layerFile, zoom_to=True) # Update message arcpy.AddMessage("Clipping all anthropogenic features to Analysis Area " "and adding templates for digitizing new anthropogenic " "features") # Clip all provided anthropogenic feature layers and add to map clip_features = Analysis_Area anthroFeaturePath = ccsStandard.AnthroFeaturePath ccslib.ClipAnthroFeaturesCredit(clip_features, anthroFeaturePath) featureList = arcpy.ListFeatureClasses("Anthro_*_Clip") # If the project proposes to modify anthropogenic features, # add a 'Subtype_As_Modified" field if includes_anthro_mod: fieldsToAdd = ["Subtype_As_Modified"] fieldTypes = ["TEXT"] for feature in featureList: ccslib.AddFields(feature, fieldsToAdd, fieldTypes) # Apply domains field = fieldsToAdd[0] domainName = feature[7:-5] + "_Subtypes" try: arcpy.AssignDomainToField_management(feature, field, domainName) except arcpy.ExecuteError: arcpy.AddMessage(domainName + " not updated. Use caution " "when populating attribute field") # Copy current subtype to Subtype as Modified field arcpy.CalculateField_management(feature, field, "!Subtype!", "PYTHON_9.3") # Add each feature to map for editing for feature in featureList: ccslib.AddAnthroToMap(workspace, feature) # Clean up arcpy.Delete_management("in_memory") # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
import arcpy print 'List Installations' for install in arcpy.ListInstallations(): print(install)
def main(): # GET PARAMETER VALUES Proposed_Surface_Disturbance_Eligible = arcpy.GetParameterAsText(0) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) # Construct pathname to workspace workspace = arcpy.Describe(Proposed_Surface_Disturbance_Eligible).path arcpy.AddMessage("Project geodatabase: " + workspace) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join(arcpy.Describe(workspace).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(workspace).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE VARIABLES FOR INPUT DATA # Filenames for feature classes or rasters used by this script ELIGIBLE_PROPOSED_FEATURES = "Proposed_Surface_Disturbance_Eligible" # Filenames for feature classes or rasters created by this script ANALYSIS_AREA = "Analysis_Area" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() # Clear selection, if present ccslib.ClearSelectedFeatures(Proposed_Surface_Disturbance_Eligible) # Check Proposed_Surface_Disturbance_Eligible feature = Proposed_Surface_Disturbance_Eligible required_fields = ["Type", "Subtype", "Surface_Disturbance"] no_null_fields = required_fields expected_fcs = None ccslib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Proposed_Surface_Disturbance_Elligible layer with provided layer provided_input = Proposed_Surface_Disturbance_Eligible parameter_name = ELIGIBLE_PROPOSED_FEATURES Proposed_Surface_Disturbance_Eligible = ccslib.AdoptParameter( provided_input, parameter_name, preserve_existing=False) # Replace Proposed_Surface_Disturbance_Elibible layer on map layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Surface_Disturbance_Eligible, layerFile) # Update message arcpy.AddMessage("Clipping all anthropogenic features to Analysis Area " "and adding templates for digitizing new anthropogenic " "features") # Clip all provided anthropogenic feature layers and add to map clip_features = ANALYSIS_AREA anthroFeaturePath = ccsStandard.AnthroFeaturePath proposed_anthro = Proposed_Surface_Disturbance_Eligible fieldsToAdd = ["Overlap_Status", "Returned", "Subtype_As_Modified"] fieldTypes = ["TEXT", "TEXT", "TEXT"] mod_field = fieldsToAdd[0] removed_code = "Removed" retained_code = "Retained" ccslib.ClipAnthroFeaturesDebit(clip_features, anthroFeaturePath, proposed_anthro, fieldsToAdd, fieldTypes, mod_field, removed_code, retained_code) # Apply domains for Overlap_Status field and populate default featureList = arcpy.ListFeatureClasses("Anthro_*_Clip") domain_name = fieldsToAdd[0] code_list = ["Retained", "Removed"] ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list, assign_default=True, populate_default=True) # Apply domains for Returned field domain_name = fieldsToAdd[1] code_list = ["True", "False"] ccslib.AddCodedTextDomain(featureList, workspace, domain_name, code_list, assign_default=True, populate_default=True) # Add all Subtype anthro domains because ArcGIS doesn't transfer them # consistently desc_c = arcpy.Describe(workspace) current_domains = desc_c.domains desc_w = arcpy.Describe(ccsStandard.AnthroFeaturePath) anthro_domains = desc_w.domains for domain_name in anthro_domains: if domain_name not in current_domains and "Subtype" in domain_name: source_workspace = ccsStandard.AnthroFeaturePath code_field = 'code' description_field = 'description' domain_table = arcpy.DomainToTable_management( source_workspace, domain_name, domain_name, code_field, description_field) arcpy.TableToDomain_management(domain_table, code_field, description_field, workspace, domain_name) arcpy.Delete_management(domain_table) # Apply domains for each anthro feature for feature in featureList: # Apply for each Subtype field field = "Subtype" domainName = feature[7:-5] + "_Subtypes" arcpy.AssignDomainToField_management(feature, field, domainName) subtypes = arcpy.da.ListSubtypes(feature) if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '': pass else: st_codes = [ str(stcode) for stcode, stdict in list(subtypes.items()) ] arcpy.AssignDomainToField_management(feature, field, domainName, st_codes) # Apply for each Subtype As Modified Field field = fieldsToAdd[-1] domainName = feature[7:-5] + "_Subtypes" arcpy.AssignDomainToField_management(feature, field, domainName) subtypes = arcpy.da.ListSubtypes(feature) if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '': pass else: st_codes = [ str(stcode) for stcode, stdict in list(subtypes.items()) ] arcpy.AssignDomainToField_management(feature, field, domainName, st_codes) # Copy current subtype to Subtype as Modified field arcpy.CalculateField_management(feature, field, "!Subtype!", "PYTHON_9.3") # Add each feature to map for editing for feature in featureList: ccslib.AddAnthroToMap(workspace, feature) # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Analysis_Area = arcpy.GetParameterAsText(0) Current_Anthro_Features_Provided = arcpy.GetParameterAsText(1) # optional Dist_Lek = arcpy.GetParameterAsText(2) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) # Construct pathname to workspace workspace = arcpy.Describe(Analysis_Area).path arcpy.AddMessage("Project geodatabase: " + workspace) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join(arcpy.Describe(workspace).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(workspace).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE VARIABLES FOR INPUT DATA AnthroAttributeTable = ccsStandard.AnthroAttributeTable emptyRaster = ccsStandard.EmptyRaster inputDataPath = ccsStandard.InputDataPath # Filenames for feature classes and raster used by this script ELIGIBLE_PROPOSED_FEATURES = "Proposed_Surface_Disturbance_Eligible" DEBIT_PROJECT_AREA = "Debit_Project_Area" # Filenames for feature classes and rasters created by this script CURRENT_ANTHRO_FEATURES = "Current_Anthro_Features" PROJECTED_ANTHRO_FEATURES = "Projected_Anthro_Features" PERMANENT_ANTHRO_FEATURES = "Permanent_Anthro_Features" CURRENT_ANTHRO_DISTURBANCE = "Current_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE = "Projected_Anthro_Disturbance" PERMANENT_ANTHRO_DISTURBANCE = "Permanent_Anthro_Disturbance" MAP_UNITS = "Map_Units" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() # Check out Spatial Analyst extension ccslib.CheckOutSpatialAnalyst() # Check Analysis_Area expected_fcs = [ELIGIBLE_PROPOSED_FEATURES, DEBIT_PROJECT_AREA] ccslib.CheckPolygonInput(Analysis_Area, expected_fcs=expected_fcs) # Create Current_Anthro_Features layer, or copy provided into geodatabase if Current_Anthro_Features_Provided: # Clear selection, if present ccslib.ClearSelectedFeatures(Current_Anthro_Features_Provided) # Check Current_Anthro_Features required_fields = [ "Type", "Subtype", "Overlap_Status", "Returned", "Subtype_As_Modified" ] no_null_fields = None expected_fcs = None ccslib.CheckPolygonInput(Current_Anthro_Features_Provided, required_fields, expected_fcs, no_null_fields) # Update message arcpy.AddMessage("Copying Current_Anthro_Features to project " "geodatabase") # Copy Current_Anthro_Features to geodatabase provided_input = Current_Anthro_Features_Provided parameter_name = CURRENT_ANTHRO_FEATURES Current_Anthro_Features = ccslib.AdoptParameter(provided_input, parameter_name, preserve_existing=True) else: # Update message arcpy.AddMessage("Merging all clipped anthropogenic features to " "create the Current_Anthro_Features layer") # Merge features (selecting only polygon features) fileList = arcpy.ListFeatureClasses("Anthro*Clip", feature_type="Polygon") out_name = CURRENT_ANTHRO_FEATURES Current_Anthro_Features = ccslib.MergeFeatures(fileList, out_name) # Simplify fields. critical to remove any fields named # 'Surface_Disturbance' in Current_Anthro_Features before joining # Proposed_Surface_Disturbance to create Projected_Anthro_Features allowable_fields = [ "Type", "Subtype", "SubtypeID", "Subtype_As_Modified", "Overlap_Status", "Returned" ] ccslib.SimplifyFields(Current_Anthro_Features, allowable_fields) # Remove subtypes from Current_Anthro_Features feature = Current_Anthro_Features subtypes = arcpy.da.ListSubtypes(feature) try: if len(subtypes) == 1 and subtypes[0]['SubtypeField'] == '': pass else: for subtype in subtypes: arcpy.RemoveSubtype_management(feature, subtype) arcpy.AddMessage("Subtype removed") except arcpy.ExecuteError: arcpy.AddMessage("Could not remove Subtype Domain from " "Current_Anthro_Features") # Add Domains for Type and Subtype try: arcpy.RemoveDomainFromField_management(feature, "Type") arcpy.AssignDomainToField_management(feature, "Type", "Type") except arcpy.ExecuteError: arcpy.AddMessage("Could not update Type Domain for " "Current_Anthro_Features") try: arcpy.RemoveDomainFromField_management(feature, "Subtype") arcpy.AssignDomainToField_management(feature, "Subtype", "Subtype") except arcpy.ExecuteError: arcpy.AddMessage("Could not update Subtype Domain for " "Current_Anthro_Features") try: arcpy.RemoveDomainFromField_management(feature, "Subtype_As_Modified") arcpy.AssignDomainToField_management(feature, "Subtype", "Subtype") except arcpy.ExecuteError: arcpy.AddMessage("Could not update Type Domain for " "Current_Anthro_Features") # Calculate Current_Anthro_Disturbance extent_fc = Analysis_Area anthro_features = Current_Anthro_Features term = ccsStandard.DebitTerms[0] Current_Anthro_Disturbance = ccslib.CalcAnthroDist(extent_fc, anthro_features, emptyRaster, AnthroAttributeTable, term) Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Current_Anthro_Disturbance Calculated") arcpy.AddMessage("Removing any anthropogenic features from the " "Current_Anthro_Features layer that will be " "replaced or upgraded from one subtype to another " "by the debit project") # Calculate post-project anthropogenic disturbance mod_field = "Overlap_Status" removed_code = "Removed" subtype_mod_field = "Subtype_As_Modified" out_name = PROJECTED_ANTHRO_FEATURES Projected_Anthro_Features = ccslib.SelectProposed( Current_Anthro_Features, ELIGIBLE_PROPOSED_FEATURES, mod_field, removed_code, subtype_mod_field, out_name) # Simplify fields (do not remove Surface Disturbance or Reclassified # Subtype field for use in SelectPermanent()) allowable_fields = [ "Type", "Subtype", "SubtypeID", "Overlap_Status", "Returned", "Subtype_As_Modified" "Surface_Disturbance", "Reclassified_Subtype" ] ccslib.SimplifyFields(Projected_Anthro_Features, allowable_fields) # Calculate Projected_Anthro_Disturbance extent_fc = Analysis_Area anthro_features = Projected_Anthro_Features term = ccsStandard.DebitTerms[1] Projected_Anthro_Disturbance = ccslib.CalcAnthroDist( extent_fc, anthro_features, emptyRaster, AnthroAttributeTable, term) Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Projected_Anthro_Disturbance Calculated") arcpy.AddMessage("Creating Permanent Anthro Features and calculating " "disturbance") # Calculate permanent anthropogenic disturbance # Select permanent anthropogenic features from Projected Anthro Features mod_field = "Overlap_Status" returned_field = "Returned" subtype_mod_field = "Subtype_As_Modified" duration_field = "Surface_Disturbance" permanent_codes = ["Term_Reclassified", "Permanent"] reclass_code = "Term_Reclassified" reclass_subtype_field = "Reclassified_Subtype" out_name = PERMANENT_ANTHRO_FEATURES Permanent_Anthro_Features = ccslib.SelectPermanent( Current_Anthro_Features, ELIGIBLE_PROPOSED_FEATURES, mod_field, returned_field, subtype_mod_field, duration_field, permanent_codes, reclass_code, reclass_subtype_field, out_name) # Simplify fields allowable_fields = [ "Type", "Subtype", "SubtypeID", "Overlap_Status", "Returned", "Subtype_As_Modified" "Surface_Disturbance", "Reclassified_Subtype" ] ccslib.SimplifyFields(Permanent_Anthro_Features, allowable_fields) # Calculate Permanent Anthro Disturbance extent_fc = Analysis_Area anthro_features = Permanent_Anthro_Features term = ccsStandard.DebitTerms[2] Permanent_Anthro_Disturbance = ccslib.CalcAnthroDist( extent_fc, anthro_features, emptyRaster, AnthroAttributeTable, term) Permanent_Anthro_Disturbance.save(PERMANENT_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Permanent_Anthro_Disturbance Calculated") # Calculate local scale modifiers for Current, Projected, and # Permanent condition extent_fc = Analysis_Area terms = ccsStandard.DebitTerms for term in terms: anthro_disturbance = term + "_Anthro_Disturbance" ccslib.CalcModifiers(extent_fc, inputDataPath, Dist_Lek, anthro_disturbance, term) # Calculate impact intensity for debit project try: ccslib.calcDebitImpact(inputDataPath) # Add debit project impact to map layerFile = ccsStandard.getLayerFile("Debit_Project_Impact.lyr") ccslib.AddToMap("Debit_Project_Impact", layerFile, zoom_to=True) except: pass # Update message arcpy.AddMessage("Creating Map Units layer") # Create Map_Units layer Project_Area = DEBIT_PROJECT_AREA out_name = MAP_UNITS Map_Units = ccslib.CreateMapUnits(Project_Area, out_name) # Update message arcpy.AddMessage("Creating pre-defined map units of Wet Meadows") # Intersect the Map_Units layer with the NV Wet Meadows layer in_feature = ccsStandard.Wet_Meadows field_name = "Meadow" na_value = "No Meadow" ccslib.CreatePreDefinedMapUnits(Map_Units, in_feature, field_name, na_value) # Update message arcpy.AddMessage("Creating pre-defined map units of PJ") # Intersect the Map_Units layer with the Phase III PJ layer in_feature = ccsStandard.PJ_Phase_III field_name = "Conifer_Phase" ccslib.CreatePreDefinedMapUnits(Map_Units, in_feature, field_name) # Update message arcpy.AddMessage("Creating pre-defined map units of proposed surface " "disturbance") # Intersect the Map_Units layer with the proposed surface disturbance in_features = ELIGIBLE_PROPOSED_FEATURES ccslib.CreatePreDefinedMapUnits(Map_Units, in_features, field_name) # Remove unwanted fields from Map Units feature class allowable_fields = [ "Disturbance_Type", "BROTEC", "Conifer_Phase", "Meadow" ] ccslib.SimplifyFields(Map_Units, allowable_fields) # Populate empty attributes with Indirect feature = Map_Units fieldName = "Disturbance_Type" where_clause = "{} = ''".format( arcpy.AddFieldDelimiters(feature, fieldName)) with arcpy.da.UpdateCursor(feature, fieldName, where_clause) as cursor: for row in cursor: row[0] = "Indirect" cursor.updateRow(row) # Add Map_Units to map layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(Map_Units, layerFile) # Add fields Map_Unit_ID, Map_Unit_Name, and Precip to map unit input_feature = Map_Units fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes"] fieldTypes = ["SHORT", "TEXT", "TEXT"] ccslib.AddFields(input_feature, fields, fieldTypes, copy_existing=True) # Add Domains to Map_Units layer # Create Domain for Map_Unit_ID attributes input_feature = Map_Units domainName = "Map_Unit_ID" range_low = 0 range_high = 10000 ccslib.AddRangeDomain(input_feature, workspace, domainName, range_low, range_high) # Create Domain for Meadow attributes featureList = [Map_Units] domainName = "Meadow" codeList = ["Altered", "Unaltered", "No Meadow"] ccslib.AddCodedTextDomain(featureList, workspace, domainName, codeList) # Clean up arcpy.Delete_management("in_memory") # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Map_Units_Provided = arcpy.GetParameterAsText(0) # optional Proposed_Modified_Features_Provided = arcpy.GetParameterAsText( 1) # optional Project_Name = arcpy.GetParameterAsText(2) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace if Map_Units_Provided: projectGDB = arcpy.Describe(Map_Units_Provided).path elif Proposed_Modified_Features_Provided: projectGDB = arcpy.Describe(Proposed_Modified_Features_Provided).path else: arcpy.AddMessage("Please provide either a Map_Units or " + "Proposed_Modified_Features layer.") sys.exit(0) arcpy.AddMessage("Project geodatabase: " + projectGDB) Project_Folder = arcpy.Describe(projectGDB).path arcpy.AddMessage("Project folder:" + Project_Folder) # Instantiate a cheStandard object cheStandard = cohqt.cheStandard(projectGDB, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = projectGDB scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(projectGDB).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES Parameter_Values = cheStandard.ParameterValues ConiferModifier = cheStandard.ConiferModifier GrSG_LDI = cheStandard.GrSG_LDI LekPresenceRaster = cheStandard.LekPresenceRaster Lek_Distance_Modifier = cheStandard.LekDistanceModifier SageModifier = cheStandard.SageModifier GrSG_Habitat = cheStandard.GrSGHabitatRaster MigrationModifier = cheStandard.MuleDeerMigrationMod WinterModifier = cheStandard.MuleDeerWinterMod SummerModifier = cheStandard.MuleDeerSummerMod MuleDeer_LDI = cheStandard.MuleDeerLDI emptyRaster = cheStandard.EmptyRaster BWMD_Open = cheStandard.BWMD_Open GrSG_Range = cheStandard.GrSGHabitat Mule_Range = cheStandard.MuleDeerHabitat cellSize = arcpy.GetRasterProperties_management(emptyRaster, "CELLSIZEX").getOutput(0) # Filenames for feature classes or rasters used by this script MAP_UNITS = "Map_Units" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" CREDIT_PROJECT_AREA = "Credit_Project_Area" CONIFER_TREATMENT_AREA = "Conifer_Treatment_Area" # Filenames for feature class and rasters created by this script INDIRECT_IMPACT_AREA = "Indirect_Impact_Area" ANALYSIS_AREA = "Analysis_Area" MAP_UNITS_DISSOLVE = "Map_Units_Dissolve" # GrSG Filenames CURRENT_ANTHRO_DISTURBANCE = "GRSG_Pre_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE = "GRSG_Post_Anthro_Disturbance" GRSG_PRE_BREEDING = "GRSG_Pre_Breeding" GRSG_PRE_SUMMER = "GRSG_Pre_Summer" GRSG_PRE_WINTER = "GRSG_Pre_Winter" GRSG_POST_BREEDING = "GRSG_Post_Breeding" GRSG_POST_SUMMER = "GRSG_Post_Summer" GRSG_POST_WINTER = "GRSG_Post_Winter" POST_CONIFER_MODIFIER = "Post_Conifer_Modifier" # Mule Deer Filenames CURRENT_ANTHRO_DISTURBANCE_MD = "MuleDeer_Pre_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE_MD = "MuleDeer_Post_Anthro_Disturbance" MULE_PRE_SUMMER = "MuleDeer_Pre_Summer" MULE_PRE_MIGRATION = "MuleDeer_Pre_Migration" MULE_PRE_WINTER = "MuleDeer_Pre_Winter" MULE_POST_SUMMER = "MuleDeer_Post_Summer" MULE_POST_MIGRATION = "MuleDeer_Post_Migration" MULE_POST_WINTER = "MuleDeer_Post_Winter" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check out Spatial Analyst extension hqtlib.CheckOutSpatialAnalyst() # Check provided layers if not Map_Units_Provided and not Proposed_Modified_Features_Provided: arcpy.AddError("ERROR:: Please provide a 'Map_Units' and/or " "'Proposed_Modified_Features' feature.") sys.exit(0) if not Proposed_Modified_Features_Provided: # Ensure Proposed_Modified_Features does not exist if arcpy.Exists("Proposed_Modified_Features"): arcpy.AddError("ERROR:: A 'Proposed_Modified_Features' layer " "was detected in the project's geodatabase. " "Provide the 'Proposed_Modified_Features' layer " "and re-run Credit Tool 2.") sys.exit(0) if Map_Units_Provided: # Clear selection, if present util.ClearSelectedFeatures(Map_Units_Provided) # Check provided layer feature = Map_Units_Provided required_fields = ["Map_Unit_ID", "Map_Unit_Name"] no_null_fields = ["Map_Unit_ID"] expected_fcs = [CREDIT_PROJECT_AREA] hqtlib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Map Units layer with provided layer provided_input = Map_Units_Provided parameter_name = MAP_UNITS preserve_existing = False Map_Units = util.AdoptParameter(provided_input, parameter_name, preserve_existing) # Add Map Units layer to map layerFile = cheStandard.getLayerFile("MapUnits.lyr") util.AddToMap(Map_Units, layerFile) # Provide location of Credit Project Area Credit_Project_Area = CREDIT_PROJECT_AREA if Proposed_Modified_Features_Provided: # Clear selection, if present util.ClearSelectedFeatures(Proposed_Modified_Features_Provided) # Check provided layer required_fields = ["Type", "Subtype"] no_null_fields = required_fields expected_fcs = None hqtlib.CheckPolygonInput(Proposed_Modified_Features_Provided, required_fields, expected_fcs, no_null_fields) # Update Proposed_Modified_Features with provided layer provided_input = Proposed_Modified_Features_Provided parameterName = PROPOSED_MODIFIED_FEATURES preserve_existing = False Proposed_Modified_Features = util.AdoptParameter( provided_input, parameterName, preserve_existing) # Add Proposed Modified Features layer to map layerFile = cheStandard.getLayerFile("DebitProjectArea.lyr") util.AddToMap(Proposed_Modified_Features, layerFile) # Update message arcpy.AddMessage("Creating the area of indirect benefit") # Create Credit_Project_Area for projects that propose to modify # anthropogenic features # Create the Indirect_Impact_Area in_data = Proposed_Modified_Features out_name = INDIRECT_IMPACT_AREA Indirect_Impact_Area = hqtlib.CreateIndirectImpactArea( in_data, Parameter_Values, out_name) # Add field "Indirect" input_feature = Indirect_Impact_Area fieldsToAdd = ["Indirect"] fieldTypes = ["TEXT"] util.AddFields(input_feature, fieldsToAdd, fieldTypes) # Update field 'Indirect' to equal 'True' with arcpy.da.UpdateCursor(Indirect_Impact_Area, fieldsToAdd) as cursor: for row in cursor: row[0] = "True" cursor.updateRow(row) if Map_Units_Provided: # Merge with Credit_Project_Boundary fileList = [Map_Units_Provided, Indirect_Impact_Area] out_name = "in_memory/Credit_Project_Boundary" Project_Area = arcpy.Union_analysis(fileList, out_name) else: Project_Area = Indirect_Impact_Area # Eliminate areas of non-habitat to create Credit_Project_Area out_name = CREDIT_PROJECT_AREA habitat_bounds = cheStandard.HabitatMgmtArea Credit_Project_Area = hqtlib.EliminateNonHabitat( Project_Area, out_name, habitat_bounds) # Detect habitat types impacted directly or indirectly is_grsg = cohqt.DetectHabitat(Credit_Project_Area, GrSG_Range) is_mule = cohqt.DetectHabitat(Credit_Project_Area, Mule_Range) # Update message arcpy.AddMessage("Dissolving all multi-part map units to create " "Map_Units_Dissolve") # Dissolve Map Units in_features = MAP_UNITS allowable_fields = ["Map_Unit_ID", "Map_Unit_Name", "Indirect"] out_name = MAP_UNITS_DISSOLVE anthro_features = None Map_Units_Dissolve = hqtlib.DissolveMapUnits(in_features, allowable_fields, out_name, anthro_features) # Update message arcpy.AddMessage("Adding Map_Units_Dissolve to map") # Add layer to map document feature = Map_Units_Dissolve layerFile = cheStandard.getLayerFile("MapUnits.lyr") util.AddToMap(feature, layerFile, zoom_to=True) # Update message arcpy.AddMessage("Calculating area in acres for each map unit") # Calculate Area hqtlib.CalcAcres(Map_Units_Dissolve) # Update message arcpy.AddMessage("Adding transect field to Map Units Dissolve") # Add transects field to map units table fields = ["Transects"] fieldTypes = ["SHORT"] util.AddFields(Map_Units_Dissolve, fields, fieldTypes) # Update message arcpy.AddMessage("Creating Analysis Area") # Create Analysis Area out_name = ANALYSIS_AREA Analysis_Area = hqtlib.CreateAnalysisArea(Credit_Project_Area, Parameter_Values, out_name) # Add Analysis_Area to map layerFile = cheStandard.getLayerFile("AnalysisArea.lyr") util.AddToMap(Analysis_Area, layerFile, zoom_to=True) # Set processing extent to Analysis_Area arcpy.env.extent = ANALYSIS_AREA ### GREATER SAGE-GROUSE ANTHRO DIST & MODIFIERS ### if is_grsg: # Update message arcpy.AddMessage("Calculating proportion of each map unit within 1 km " "of a lek") # Calculate proportion of map unit within 1 km of a lek inZoneData = Map_Units_Dissolve inValueRaster = cheStandard.LekPresenceRaster zoneField = "Map_Unit_ID" outTable = "Proportion_Lek" hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table field_name = "PropLek" hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name) # Update message arcpy.AddMessage( "Calculating proportion of each map unit in the mesic " "precip zone") # Calculate Proportion of each map unit in the mesic precip zone inZoneData = Map_Units_Dissolve inValueRaster = cheStandard.Precip zoneField = "Map_Unit_ID" outTable = "Proportion_Mesic" hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table field_name = "PropMesic" hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name) # Update message arcpy.AddMessage("Calculating pre-project anthropogenic " "disturbance modifier for greater sage-grouse") # Calculate Current_Anthro_Disturbance dist_field = "GrSG_Dist" weight_field = "GrSG_Weight" term = cheStandard.CreditTerms[0] unique_proposed_subtypes = [] anthro_disturbance_type = "Pre" Current_Anthro_Disturbance = cohqt.CalcAnthroDisturbance( Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Current_Anthro_Disturbance Calculated") arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers for" "Greater Sage-Grouse") # Calculate pre-project cumulative habitat modifiers winterHabitatPre = cohqt.calcWinterHabitatGRSG( Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, GrSG_Habitat) LSDMWinterPre = cohqt.applyLekUpliftModifierPre( winterHabitatPre, LekPresenceRaster) breedingHabitatPre = cohqt.calcBreedingHabitatGRSG( Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, Lek_Distance_Modifier, GrSG_Habitat) LSDMBreedingPre = cohqt.applyLekUpliftModifierPre( breedingHabitatPre, LekPresenceRaster) summerHabitatPre = cohqt.calcSummerHabitatGRSG( Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, SageModifier, GrSG_Habitat) LSDMSummerPre = cohqt.applyLekUpliftModifierPre( summerHabitatPre, LekPresenceRaster) seasonalHabitatRasters = [ LSDMWinterPre, LSDMBreedingPre, LSDMSummerPre ] # Save outputs # winterHabitatPre.save(GRSG_PRE_WINTER) LSDMWinterPre.save(GRSG_PRE_WINTER) # breedingHabitatPre.save(GRSG_PRE_BREEDING) LSDMBreedingPre.save(GRSG_PRE_BREEDING) # summerHabitatPre.save(GRSG_PRE_SUMMER) LSDMSummerPre.save(GRSG_PRE_SUMMER) # Initialize list of uplift rasters to combine for LekUpliftModifier upliftRasters = [] if arcpy.Exists(CONIFER_TREATMENT_AREA): # Calculate post-project conifer modifier Conifer_Cover = cheStandard.ConiferCover coniferModifierPost = cohqt.calcConiferPost( CONIFER_TREATMENT_AREA, Conifer_Cover) coniferModifierPost.save(POST_CONIFER_MODIFIER) # Calculate uplift from conifer removal coniferUplift = cohqt.calcUplift(ConiferModifier, coniferModifierPost) upliftRasters.append(coniferUplift) else: coniferModifierPost = ConiferModifier if arcpy.Exists(PROPOSED_MODIFIED_FEATURES): # Prepare proposed anthropogenic features unique_proposed_subtypes = cohqt.convertProposedToRasterCredit( PROPOSED_MODIFIED_FEATURES, cellSize) anthroPath = cheStandard.AnthroFeaturePath cohqt.combineProposedWithCurrentCredit(anthroPath, unique_proposed_subtypes) # Update message arcpy.AddMessage("Calculating post-project anthropogenic " "disturbance modifier for greater sage-grouse") # Calculate post-project anthropogenic disturbance term = cheStandard.CreditTerms[1] anthro_disturbance_type = "Post" Projected_Anthro_Disturbance = cohqt.CalcAnthroDisturbance( Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Projected_Anthro_Disturbance Calculated") # Calculate uplift from anthro feature removal anthroUplift = cohqt.calcUplift(Current_Anthro_Disturbance, Projected_Anthro_Disturbance) upliftRasters.append(anthroUplift) # Update message arcpy.AddMessage( "Merging indirect benefits area and map units layer") # Combine the Map Units layer and Indirect Impact Layer indirect_benefit_area = CREDIT_PROJECT_AREA mgmt_map_units = Map_Units_Dissolve Map_Units_Dissolve = hqtlib.AddIndirectBenefitArea( indirect_benefit_area, mgmt_map_units) else: Projected_Anthro_Disturbance = Current_Anthro_Disturbance # Add Indirect field to Map Units layer and populate with False # Add field "Indirect" feature = Map_Units_Dissolve fieldsToAdd = ["Indirect"] fieldTypes = ["TEXT"] util.AddFields(feature, fieldsToAdd, fieldTypes) # Update field to equal "False" with arcpy.da.UpdateCursor(feature, fieldsToAdd) as cursor: for row in cursor: row[0] = "False" cursor.updateRow(row) # Calc zonal stats for pre-project modifiers (three seasons) term = cheStandard.CreditTerms[0] for season, raster in zip(cheStandard.GrSGSeasons, seasonalHabitatRasters): # Update message arcpy.AddMessage("Summarizing GrSG " + term + " " + season) # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = raster zoneField = "Map_Unit_ID" outTable = "GrSG_Stats_" + term + "_" + season hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table field_name = "GrSG_" + term + "_" + season hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name) if arcpy.Exists("Conifer_Treatment_Area") or \ arcpy.Exists("Anthro_Features_Removed"): # Update message arcpy.AddMessage("Calculating Lek Uplift Modifier") # Calculate Lek Uplift Modifier lekUpliftModifier = cohqt.calcLekUpliftModifier( LekPresenceRaster, upliftRasters) lekUpliftModifier.save("Lek_Uplift_Modifier") # Update message arcpy.AddMessage("Calculating Post-Project Habitat Modifiers") # Calculate post-project cumulative habtiat modifiers winterHabitatPost = cohqt.calcWinterHabitatGRSG( Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI, GrSG_Habitat) LSDMWinterPost = cohqt.applyLekUpliftModifierPost( winterHabitatPost, LekPresenceRaster, lekUpliftModifier) breedingHabitatPost = cohqt.calcBreedingHabitatGRSG( Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI, Lek_Distance_Modifier, GrSG_Habitat) LSDMBreedingPost = cohqt.applyLekUpliftModifierPost( breedingHabitatPost, LekPresenceRaster, lekUpliftModifier) summerHabitatPost = cohqt.calcSummerHabitatGRSG( Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI, SageModifier, GrSG_Habitat) LSDMSummerPost = cohqt.applyLekUpliftModifierPost( summerHabitatPost, LekPresenceRaster, lekUpliftModifier) seasonalHabitatRasters = [ LSDMWinterPost, LSDMBreedingPost, LSDMSummerPost ] # Save outputs # winterHabitatPost.save("Post_Seasonal_Winter") LSDMWinterPost.save(GRSG_POST_WINTER) # breedingHabitatPost.save("Post_Seasonal_Breeding") LSDMBreedingPost.save(GRSG_POST_BREEDING) # summerHabitatPost.save("Post_Seasonal_Summer") LSDMSummerPost.save(GRSG_POST_SUMMER) # Calc zonal stats for post-project modifiers term = cheStandard.CreditTerms[1] for season, raster in zip(cheStandard.GrSGSeasons, seasonalHabitatRasters): # Update message arcpy.AddMessage("Summarizing GrSG " + term + " " + season) # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = raster zoneField = "Map_Unit_ID" outTable = "GrSG_Stats_" + term + "_" + season hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table field_name = "GrSG_" + term + "_" + season hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name) # Calculate Credit Intensity ### END GREATER SAGE-GROUSE ### ### MULE DEER ANTHRO DIST & MODIFIERS ### if is_mule: # Update message arcpy.AddMessage("Calculating pre-project anthropogenic disturbance " "modifier for mule deer - process may repeat for " "habitats in mixed PJ and open habitat") # # Calculat pre-project anthropogenic disturbance # dist_field = "MDO_Dist" # weight_field = "MDO_Weight" # term = cheStandard.CreditTerms[0] # unique_proposed_subtypes = [] # anthro_disturbance_type = "Pre" # # Current_Anthro_Disturbance = hqtlib.cheCalcAnthroDisturbance( # Parameter_Values, term, unique_proposed_subtypes, # anthro_disturbance_type, cheStandard, dist_field, weight_field, # cellSize, emptyRaster # ) # Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE_MD) # Calculate pre-project anthropogenic disturbance # Calculate pre-project in PJ dist_field = "MDP_Dist" weight_field = "MDP_Weight" term = cheStandard.CreditTerms[0] unique_proposed_subtypes = [] anthro_disturbance_type = "Pre" anthro_pj = cohqt.CalcAnthroDisturbance(Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) anthro_pj.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_P") # Calculate pre-project in Open dist_field = "MDO_Dist" weight_field = "MDO_Weight" term = cheStandard.CreditTerms[0] unique_proposed_subtypes = [] anthro_disturbance_type = "Pre" anthro_open = cohqt.CalcAnthroDisturbance(Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster, mask=BWMD_Open) anthro_open.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_O") # Combine PJ and Open # If outside open, make 1 anthro_open_only = Con(BWMD_Open == 1, anthro_open, 1) anthro_open_only.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO") # Select minimum of pj and open rasters Current_Anthro_Disturbance = Con(anthro_open_only < anthro_pj, anthro_open_only, anthro_pj) Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE_MD) # Clean up arcpy.Delete_management("temp_masked_raster") # arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_P") # arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_O") # arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO") # Update message arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers") # Calculate pre-project cumulative habitat modifiers summerHabitatPre = cohqt.calcSummerHabitatMD( Current_Anthro_Disturbance, MuleDeer_LDI, SummerModifier, SuitableHabitat=None) # LSDMWinterPre = cohqt.applyLekUpliftModifierPre(summerHabitatPre, # LekPresenceRaster) migratoryHabitatPre = cohqt.calcMigratoryHabitatMD( Current_Anthro_Disturbance, MuleDeer_LDI, MigrationModifier, SuitableHabitat=None) # LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(migratoryHabitatPre, # LekPresenceRaster) winterHabitatPre = cohqt.calcWinterHabitatMD( Current_Anthro_Disturbance, MuleDeer_LDI, WinterModifier, SuitableHabitat=None) # LSDMSummerPre = cohqt.applyLekUpliftModifierPre(winterHabitatPre, # LekPresenceRaster) seasonalHabitatRasters = [ summerHabitatPre, migratoryHabitatPre, winterHabitatPre ] # Save outputs summerHabitatPre.save(MULE_PRE_SUMMER) # LSDMWinterPre.save("Pre_LSDM_Winter") migratoryHabitatPre.save(MULE_PRE_MIGRATION) # LSDMBreedingPre.save("Pre_LSDM_Breeding") winterHabitatPre.save(MULE_PRE_WINTER) # LSDMSummerPre.save("Pre_LSDM_Summer") # Update message arcpy.AddMessage("Current_Anthro_Disturbance Calculated") # Calc zonal stats for pre-project modifiers (three seasons) term = cheStandard.DebitTerms[0] for season, raster in zip(cheStandard.MuleDeerSeasons, seasonalHabitatRasters): # Update message arcpy.AddMessage("Summarizing Mule Deer " + term + " " + season) # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = raster zoneField = "Map_Unit_ID" outTable = "Mule_Stats_" + term + "_" + season hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table field_name = "Mule_" + term + "_" + season hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name) # # Calculate average of three seasonal habitat rasters pre-project # finalPreCumulative = hqtlib.calcAverageHabitatQuality( # seasonalHabitatRasters # ) # finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE) if arcpy.Exists(PROPOSED_MODIFIED_FEATURES): # Update message arcpy.AddMessage("Calculating post-project anthropogenic " "disturbance modifier") # Calculate post-project anthropogenic disturbance term = cheStandard.CreditTerms[1] anthro_disturbance_type = "Post" Projected_Anthro_Disturbance = cohqt.CalcAnthroDisturbance( Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE_MD) # Update message arcpy.AddMessage("Projected_Anthro_Disturbance Calculated") # Calculate post-project cumulative habitat modifiers summerHabitatPost = cohqt.calcSummerHabitatMD( Projected_Anthro_Disturbance, MuleDeer_LDI, SummerModifier, SuitableHabitat=None) # LSDMWinterPost = cohqt.applyLekUpliftModifierPost(summerHabitatPost, # LekPresenceRaster) migratoryHabitatPost = cohqt.calcMigratoryHabitatMD( Projected_Anthro_Disturbance, MuleDeer_LDI, MigrationModifier, SuitableHabitat=None) # LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(migratoryHabitatPost, # LekPresenceRaster) winterHabitatPost = cohqt.calcWinterHabitatMD( Projected_Anthro_Disturbance, MuleDeer_LDI, WinterModifier, SuitableHabitat=None) # LSDMSummerPost = cohqt.applyLekUpliftModifierPost(winterHabitatPost, # LekPresenceRaster) seasonalHabitatRasters = [ summerHabitatPost, migratoryHabitatPost, winterHabitatPost ] # Save outputs summerHabitatPost.save(MULE_POST_SUMMER) # LSDMWinterPre.save("Pre_LSDM_Winter") migratoryHabitatPost.save(MULE_POST_MIGRATION) # LSDMBreedingPre.save("Pre_LSDM_Breeding") winterHabitatPost.save(MULE_POST_WINTER) # LSDMSummerPre.save("Pre_LSDM_Summer") # Calc zonal stats for pre-project modifiers (three seasons) term = cheStandard.DebitTerms[1] for season, raster in zip(cheStandard.MuleDeerSeasons, seasonalHabitatRasters): # Update message arcpy.AddMessage("Summarizing Mule Deer " + term + season) # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = raster zoneField = "Map_Unit_ID" outTable = "Mule_Stats_" + term + season hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table field_name = "Mule_" + term + "_" + season hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, field_name) # # Calculate average of three seasonal habitat rasters post-project # finalPostCumulative = hqtlib.calcAverageHabitatQuality( # seasonalHabitatRasters # ) # finalPostCumulative.save(CUMULATIVE_MODIFIER_POST) # Calculate permanent cumulative habtiat modifiers # Update message arcpy.AddMessage("Calculating Mule Deer Benefit") # Calculate impact pre_fields = [ "Mule_Pre_Summer", "Mule_Pre_Migration", "Mule_Pre_Winter" ] post_fields = [ "Mule_Post_Summer", "Mule_Post_Migration", "Mule_Post_Winter" ] out_fields = [ "Mule_Summer_Benefit", "Mule_Migration_Benefit", "Mule_Winter_Benefit" ] for i in range(len(pre_fields)): pre_field = pre_fields[i] post_field = post_fields[i] out_field = out_fields[i] cohqt.calcDebits(Map_Units_Dissolve, pre_field, post_field, out_field) # # Export data to Excel input_Tables = [MAP_UNITS_DISSOLVE] for table in input_Tables: hqtlib.ExportToExcel(table, Project_Folder, Project_Name) ### END MULE DEER ### if not is_grsg and not is_mule: arcpy.AddMessage("Impacts were not detected in any habitat type. " "Please check credit project boundary and try " "again") # Clean up for raster in arcpy.ListRasters("*_Subtype_Disturbance"): arcpy.Delete_management(raster) for raster in arcpy.ListRasters("*_Type_Disturbance"): arcpy.Delete_management(raster) arcpy.Delete_management("in_memory") # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Map_Units_Provided = arcpy.GetParameterAsText(0) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace projectGDB = arcpy.Describe(Map_Units_Provided).path arcpy.AddMessage("Project geodatabase: " + projectGDB) # Instantiate a idStandard object cheStandard = cohqt.cheStandard(projectGDB, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = projectGDB scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management(scratch_folder) arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES cell_size = 30 inputDataPath = cheStandard.InputDataPath GrSG_Habitat = cheStandard.GrSGHabitatRaster ConiferModifier = cheStandard.ConiferModifier GrSG_LDI = cheStandard.GrSG_LDI LekPresenceRaster = cheStandard.LekPresenceRaster Lek_Distance_Modifier = cheStandard.LekDistanceModifier SageModifier = cheStandard.SageModifier GrSG_Habitat = cheStandard.BWSGHab # Filenames of feature classes and rasters used by this script MAP_UNITS = "Map_Units" PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits" DISTURBED_FOOTPRINT = "Disturbed_Footprint" CURRENT_ANTHRO_FEATURES = "Current_Anthro_Features" CURRENT_ANTHRO_DISTURBANCE = "GrSG_Pre_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE = "GRSG_Post_Anthro_Disturbance" LEK_DISTURBANCE_MODIFIER = "Lek_Disturbance_Modifier" DEBIT_PROJECT_AREA = "Debit_Project_Area" DEBIT_PROJECT_IMPACT_A = "Debit_Project_Impact_Adjusted" # Filenames of feature classes and rasters created by this script # GrSG Filenames GRSG_PRE_BREEDING_A = "GRSG_Pre_Breeding_adjusted" GRSG_PRE_SUMMER_A = "GRSG_Pre_Summer_adjusted" GRSG_PRE_WINTER_A = "GRSG_Pre_Winter_adjusted" GRSG_POST_BREEDING_A = "GRSG_Post_Breeding_adjusted" GRSG_POST_SUMMER_A = "GRSG_Post_Summer_adjusted" GRSG_POST_WINTER_A = "GRSG_Post_Winter_adjusted" CUMULATIVE_MODIFIER_PRE_A = "GRSG_Pre_Cumulative_Modifier_adjusted" CUMULATIVE_MODIFIER_POST_A = "GRSG_Post_Cumulative_Modifier_adjusted" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check out Spatial Analyst extension hqtlib.CheckOutSpatialAnalyst() # Clear selection, if present util.ClearSelectedFeatures(Map_Units_Provided) # Check Map_Units layer feature = Map_Units_Provided required_fields = ["Map_Unit_ID", "Map_Unit_Name"] no_null_fields = ["Map_Unit_ID"] expected_fcs = None hqtlib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Map Units layer with provided layer and add to map Map_Units = util.AdoptParameter(Map_Units_Provided, MAP_UNITS, preserve_existing=False) layerFile = cheStandard.getLayerFile("MapUnits.lyr") util.AddToMap(Map_Units, layerFile) # # Udpate message # arcpy.AddMessage("Dissolving all multi-part map units to create " # "Map_Units_Dissolve") # # Dissolve Map Units # allowable_fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes", # "Disturbance_Type", "Precip", ] # out_name = MAP_UNITS_DISSOLVE # anthro_features = CURRENT_ANTHRO_FEATURES # Map_Units_Dissolve = hqtlib.DissolveMapUnits(MUs, allowable_fields, # out_name, anthro_features) # # Update message # arcpy.AddMessage("Adding Map_Units_Dissolve to map") # # Add layer to map document # feature = Map_Units_Dissolve # layerFile = cheStandard.getLayerFile("Map_Units.lyr") # util.AddToMap(feature, layerFile) # # Update message # arcpy.AddMessage("Calculating area in acres for each map unit") # # Calculate Area # hqtlib.CalcAcres(Map_Units_Dissolve) # Update message arcpy.AddMessage("Creating site-scale habitat quality rasters") # # ADD Join from Excel Doc # out_table = os.path.join(projectGDB, "Site_Scale_Scores") # summary_table = arcpy.ExcelToTable_conversion(Debit_Calculator, # out_table, # "Summary") # arcpy.AddJoin_management(Map_Units, "Map_Unit_ID", # summary_table, "MapUnitID") # Convert Map Units to raster of Habitat Quality (0 - 1 scale) and mask # out BWSG habitat seasonsList = cheStandard.GrSGSeasons for season in seasonsList: mu_raster_path = cohqt.convertMapUnitsToRaster(projectGDB, Map_Units, season, cell_size) mu_raster = Raster(mu_raster_path) # Mask out BWSG habitat SuitableHabitat_adjusted = Con(IsNull(Float(mu_raster)), GrSG_Habitat, Float(mu_raster)) SuitableHabitat_adjusted.save( os.path.join(projectGDB, season + "_Habitat_adjusted")) # Update message arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers") # Re-run fron calcWinterHabitat down with updated BWSG layer (append # "_adjusted") WinterSuitableHabitat = os.path.join(projectGDB, "Winter_Habitat_adjusted") winterHabitatPre = cohqt.calcWinterHabitatGRSG(CURRENT_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, WinterSuitableHabitat) LSDMWinterPre = cohqt.applyLekUpliftModifierPre(winterHabitatPre, LekPresenceRaster) BreedingSuitableHabitat = os.path.join(projectGDB, "Breed_Habitat_adjusted") breedingHabitatPre = cohqt.calcBreedingHabitatGRSG( CURRENT_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, Lek_Distance_Modifier, BreedingSuitableHabitat) LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(breedingHabitatPre, LekPresenceRaster) SummerSuitableHabitat = os.path.join(projectGDB, "Summer_Habitat_adjusted") summerHabitatPre = cohqt.calcSummerHabitatGRSG(CURRENT_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, SageModifier, SummerSuitableHabitat) LSDMSummerPre = cohqt.applyLekUpliftModifierPre(summerHabitatPre, LekPresenceRaster) seasonalHabitatRasters = [LSDMWinterPre, LSDMBreedingPre, LSDMSummerPre] # Save outputs # winterHabitatPre.save("Pre_Seasonal_Winter_adjusted") LSDMWinterPre.save(GRSG_PRE_WINTER_A) # breedingHabitatPre.save("Pre_Seasonal_Breeding_adjusted") LSDMBreedingPre.save(GRSG_PRE_BREEDING_A) # summerHabitatPre.save("Pre_Seasonal_Summer_adjusted") LSDMSummerPre.save(GRSG_PRE_SUMMER_A) # Calculate average of three seasonal habitat rasters pre-project finalPreCumulative = cohqt.calcAverageHabitatQuality( seasonalHabitatRasters) finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE_A) # Calculate post-project cumulative habtiat modifiers winterHabitatPost = cohqt.calcWinterHabitatGRSG( PROJECTED_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, WinterSuitableHabitat) LSDMWinterPost = cohqt.applyLekUpliftModifierPost( winterHabitatPost, LekPresenceRaster, LEK_DISTURBANCE_MODIFIER) breedingHabitatPost = cohqt.calcBreedingHabitatGRSG( PROJECTED_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, Lek_Distance_Modifier, BreedingSuitableHabitat) LSDMBreedingPost = cohqt.applyLekUpliftModifierPost( breedingHabitatPost, LekPresenceRaster, LEK_DISTURBANCE_MODIFIER) summerHabitatPost = cohqt.calcSummerHabitatGRSG( PROJECTED_ANTHRO_DISTURBANCE, ConiferModifier, GrSG_LDI, SageModifier, SummerSuitableHabitat) LSDMSummerPost = cohqt.applyLekUpliftModifierPost( summerHabitatPost, LekPresenceRaster, LEK_DISTURBANCE_MODIFIER) seasonalHabitatRasters = [LSDMWinterPost, LSDMBreedingPost, LSDMSummerPost] # Save outputs # winterHabitatPost.save("Post_Seasonal_Winter") LSDMWinterPost.save(GRSG_POST_WINTER_A) # breedingHabitatPost.save("Post_Seasonal_Breeding") LSDMBreedingPost.save(GRSG_POST_BREEDING_A) # summerHabitatPost.save("Post_Seasonal_Summer") LSDMSummerPost.save(GRSG_POST_SUMMER_A) # Calculate average of three seasonal habitat rasters post-project finalPostCumulative = cohqt.calcAverageHabitatQuality( seasonalHabitatRasters) finalPostCumulative.save(CUMULATIVE_MODIFIER_POST_A) # Calculate Zonal Statistics for cumulative modifier rasters # Calculate zonal statistics for pre-project inZoneData = DEBIT_PROJECT_AREA inValueRaster = finalPreCumulative zoneField = "ZONAL" outTable = "GRSG_Stats_Pre_adjusted" hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Debit Project Area table fieldName = "GRSG_Pre_Project_A" hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate zonal statistics for post-project inZoneData = DEBIT_PROJECT_AREA inValueRaster = finalPostCumulative zoneField = "ZONAL" outTable = "GRSG_Stats_Post_adjusted" hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Debit Project Area table fieldName = "GrSG_Post_Project_A" hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate debits using field data cohqt.calcDebits(DEBIT_PROJECT_AREA, "GRSG_Pre_Project_A", "GrSG_Post_Project_A", "Debits_adj") # Update message arcpy.AddMessage("Creating visualization of impact from debit project") # Calculate impact intensity for debit project debit_impact = cohqt.calcImpact(finalPreCumulative, finalPostCumulative) debit_impact.save(DEBIT_PROJECT_IMPACT_A) # Add Debit Impact raster to map and save map document feature = debit_impact layerFile = cheStandard.getLayerFile("DebitProjectImpact.lyr") util.AddToMap(feature, layerFile, zoom_to=True) # Clean up arcpy.Delete_management("in_memory") # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Analysis_Area = arcpy.GetParameterAsText(0) Dist_Lek = arcpy.GetParameterAsText(1) Current_Anthro_Features_Provided = arcpy.GetParameterAsText(2) # optional Project_Folder = arcpy.GetParameterAsText(3) Project_Name = arcpy.GetParameterAsText(4) # optional # DEFINE DIRECTORIES & PATH NAMES FOR FOLDERS & GBDs # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) # Construct pathname to workspace workspace = arcpy.Describe(Analysis_Area).path arcpy.AddMessage("Project geodatabase: " + workspace) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join(arcpy.Describe(workspace).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(workspace).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES AnthroAttributeTable = ccsStandard.AnthroAttributeTable emptyRaster = ccsStandard.EmptyRaster inputDataPath = ccsStandard.InputDataPath # Filenames for feature classes or rasters used by this script MAP_UNITS = "Map_Units" ANALYSIS_AREA = "Analysis_Area" # provided CURRENT_ANTHRO_FEATURES = "Current_Anthro_Features" CREDIT_PROJECT_AREA = "Credit_Project_Area" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" # Filenames for feature classes or rasters created by this script CURRENT_ANTHRO_DISTURBANCE = "Current_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE = "Projected_Anthro_Disturbance" MAP_UNITS_DISSOLVE = "Map_Units_Dissolve" CURRENT_MGMT_CAT = "Current_Mgmt_Cat" CURRENT_WMZ = "Current_WMZ" CURRENT_PMU = "Current_PMU" CURRENT_PRECIP = "Current_Precip" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check out Spatial Analyst extension ccslib.CheckOutSpatialAnalyst() # Check Analysis_Area feature = Analysis_Area expected_fcs = [MAP_UNITS, ANALYSIS_AREA, CREDIT_PROJECT_AREA] ccslib.CheckPolygonInput(feature, expected_fcs=expected_fcs) # Set up flag for projects that propose to modify anthro features includes_anthro_mod = False # Check for existence of 'Proposed_Modified_Features' if arcpy.Exists(PROPOSED_MODIFIED_FEATURES): # Update flag includes_anthro_mod = True # Copy Dist_Lek to geodatabase # Create Current_Anthro_Features layer, or copy provided into geodatabase if Current_Anthro_Features_Provided: # Clear selection, if present ccslib.ClearSelectedFeatures(Current_Anthro_Features_Provided) # Check Current_Anthro_Features feature = Current_Anthro_Features_Provided required_fields = ["Type", "Subtype"] no_null_fields = None expected_fcs = None ccslib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update message arcpy.AddMessage("Copying Current_Anthro_Features to project " "geodatabase") # Copy Current_Anthro_Features to geodatabase provided_input = Current_Anthro_Features_Provided parameter_name = CURRENT_ANTHRO_FEATURES preserve_existing = True Current_Anthro_Features = ccslib.AdoptParameter( provided_input, parameter_name, preserve_existing) else: # Update message arcpy.AddMessage("Merging all clipped anthropogenic features to " "create the Current_Anthro_Features layer") # Merge features (selecting only polygon features) fileList = arcpy.ListFeatureClasses("Anthro*Clip", feature_type="Polygon") out_name = CURRENT_ANTHRO_FEATURES Current_Anthro_Features = ccslib.MergeFeatures(fileList, out_name) # Simplify fields allowable_fields = ["Type", "Subtype", "SubtypeID", "Subtype_As_Modified"] ccslib.SimplifyFields(Current_Anthro_Features, allowable_fields) # Remove subtypes from Current_Anthro_Features feature = Current_Anthro_Features try: subtypes = arcpy.da.ListSubtypes(feature) for subtype in subtypes: arcpy.RemoveSubtype_management(feature, subtype) arcpy.AddMessage("Subtype removed") except arcpy.ExecuteError: arcpy.AddMessage("Could not remove subtypes from " "Current_Anthro_Features") # Add Domains for Type and Subtype arcpy.RemoveDomainFromField_management(feature, "Type") try: domainName = "Type" arcpy.CreateDomain_management(workspace, domainName, "Valid " + domainName + "s", "TEXT", "CODED") typeList = [ row[0] for row in arcpy.da.SearchCursor(AnthroAttributeTable, "Type") ] for code in typeList: arcpy.AddCodedValueToDomain_management(workspace, domainName, code, code) except arcpy.ExecuteError: arcpy.AddMessage("Could not add domains for " "Current_Anthro_Features") arcpy.AssignDomainToField_management(feature, "Type", "Type") arcpy.RemoveDomainFromField_management(feature, "Subtype") arcpy.TableToDomain_management(AnthroAttributeTable, "Subtype", "Subtype", workspace, "Subtype", "Valid anthropogenic subtypes", "REPLACE") arcpy.AssignDomainToField_management(feature, "Subtype", "Subtype") # Update Message arcpy.AddMessage("Calculating Current Anthropogenic Disturbance") # Calculate Current_Anthro_Disturbance extent_fc = Analysis_Area anthro_features = Current_Anthro_Features term = ccsStandard.CreditTerms[0] Current_Anthro_Disturbance = ccslib.CalcAnthroDist(extent_fc, anthro_features, emptyRaster, AnthroAttributeTable, term) Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Current_Anthro_Disturbance Calculated") # If the project proposes to modify existing anthropogenic features, # calculate post-project anthropogenic disturbance (uplift) if includes_anthro_mod: # Calculate uplift extent_fc = Analysis_Area anthro_features = Current_Anthro_Features term = ccsStandard.CreditTerms[1] field = "Subtype_As_Modified" Projected_Anthro_Disturbance = ccslib.CalcAnthroDist( extent_fc, anthro_features, emptyRaster, AnthroAttributeTable, term, field) Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Projected_Anthro_Disturbance Calculated") arcpy.AddMessage("Creating pre-defined map units of PJ") Map_Units = MAP_UNITS if len(arcpy.ListFields(Map_Units, "Conifer_Phase")) == 0: # Create pre-defined map units for PJ # Intersect the Map_Units layer with the PJ layer in_feature = ccsStandard.PJ_Phases field_name = "Conifer_Phase" ccslib.CreatePreDefinedMapUnits(Map_Units, in_feature, field_name) # Remove unwanted fields from Map Units feature class allowable_fields = [ "Conifer_Phase", "Map_Unit_ID", "Map_Unit_Name", "Meadow", "Notes", "Indirect" ] ccslib.SimplifyFields(Map_Units, allowable_fields) # Update message arcpy.AddMessage("Merging indirect benefits area and map units layer") # Combine the Map Units layer and Indirect Impact Layer indirect_benefit_area = CREDIT_PROJECT_AREA mgmt_map_units = Map_Units Map_Units = ccslib.AddIndirectBenefitArea(indirect_benefit_area, mgmt_map_units) # Add Map Units layer to map document layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(Map_Units, layerFile) else: # Add Indirect field to Map Units layer and populate with False # Add field "Indirect" feature = MAP_UNITS fieldsToAdd = ["Indirect"] fieldTypes = ["TEXT"] ccslib.AddFields(feature, fieldsToAdd, fieldTypes) # Update field to equal "False" with arcpy.da.UpdateCursor(feature, fieldsToAdd) as cursor: for row in cursor: row[0] = "False" cursor.updateRow(row) # Calculate local scale modifiers for Current condition extent_fc = Analysis_Area anthro_disturbance = CURRENT_ANTHRO_DISTURBANCE term = ccsStandard.CreditTerms[0] ccslib.CalcModifiers(extent_fc, inputDataPath, Dist_Lek, anthro_disturbance, term) # Calculate local scale modifiers for Projected condition # Determine which anthropogenic disturbance raster to use extent_fc = Analysis_Area if arcpy.Exists(PROJECTED_ANTHRO_DISTURBANCE): anthro_disturbance = PROJECTED_ANTHRO_DISTURBANCE else: anthro_disturbance = CURRENT_ANTHRO_DISTURBANCE term = ccsStandard.CreditTerms[1] ccslib.CalcModifiers(extent_fc, inputDataPath, Dist_Lek, anthro_disturbance, term, PJ_removal=True) # Update message arcpy.AddMessage("Dissolving all multi-part map units to create " "Map_Units_Dissolve") # Dissolve Map Units allowable_fields = [ "Map_Unit_ID", "Map_Unit_Name", "Meadow", "Conifer_Phase", "BROTEC", "Indirect" ] out_name = MAP_UNITS_DISSOLVE anthro_features = Current_Anthro_Features Map_Units_Dissolve = ccslib.DissolveMapUnits(MAP_UNITS, allowable_fields, out_name, anthro_features) # Update message arcpy.AddMessage("Adding Map_Units_Dissolve to map") # Add layer to map document feature = Map_Units_Dissolve layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(feature, layerFile, zoom_to=True) # Update message arcpy.AddMessage("Calculating area in acres for each map unit") # Calculate Area ccslib.CalcAcres(Map_Units_Dissolve) # Initialize a list to track proportion feature classes prop_fcs = [] # Update message arcpy.AddMessage("Calculating Proportion within each precipitation zone") # Calculate Proportion of each map unit in each Precip Zone in_feature = os.path.join(inputDataPath, "Precip") out_feature_class = CURRENT_PRECIP field_name = "Precip_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Update message arcpy.AddMessage("Calculating Management Importance Factor") # Calculate Proportion of each map unit in each Management Category in_feature = os.path.join(inputDataPath, "Mgmt_Cat") out_feature_class = CURRENT_MGMT_CAT field_name = "Mgmt_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Update message arcpy.AddMessage("Evaluating WAFWA Management Zone") # Calculate Proportion in each map unit in each WAFWA Zone in_feature = os.path.join(inputDataPath, "NV_WAFWA") out_feature_class = CURRENT_WMZ field_name = "WMZ_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Update message arcpy.AddMessage("Evaluating Priority Management Unit") # Calculate Proportion in each map unit in each PMU in_feature = os.path.join(inputDataPath, "NV_PMU") out_feature_class = CURRENT_PMU field_name = "PMU_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Delete unnecessary fields in proportion feature classes allowable_fields = [ "Map_Unit_ID", "Management", "Mgmt_zone", "PMU_NAME", "Precip", "Mgmt_Proportion", "WMZ_Proportion", "PMU_Proportion", "Precip_Proportion" ] for feature in prop_fcs: ccslib.SimplifyFields(feature, allowable_fields) # Set processing extent to Map_Units layer arcpy.env.extent = arcpy.Describe(Map_Units_Dissolve).extent # Calculate the average HSI values per map unit for each map unit HSIseasons = ccsStandard.HSISeasons for season in HSIseasons: # Update message arcpy.AddMessage("Summarizing " + season + " HSI") # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = os.path.join(inputDataPath, season + "_HSI") zoneField = "Map_Unit_ID" outTable = "ZonalStats_" + season + "_HSI" ccslib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = season + "_HSI" ccslib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Update message arcpy.AddMessage("Calculating PJ cover per map unit") # Calculate the average pinon-juniper cover per map unit inZoneData = Map_Units_Dissolve inValueRaster = os.path.join(inputDataPath, "PJ_Cover") zoneField = "Map_Unit_ID" outTable = "ZonalStats_PJCover" ccslib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = "PJ_Cover" ccslib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate the average seasonal modifier values per map unit and # join to Map_Unit_Dissolve table terms = ccsStandard.CreditTerms seasons = ccsStandard.Seasons for term in terms: for season in seasons: # Update message arcpy.AddMessage("Summarizing " + term + "_Local_" + season) # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = term + "_Local_" + season zoneField = "Map_Unit_ID" outTable = "ZonalStats_" + term + season ccslib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = term + "_" + season ccslib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate impact intensity for credit project try: ccslib.calcCreditBenefit(inputDataPath, includes_anthro_mod) # Add credit project quality to map layerFile = ccsStandard.getLayerFile("Credit_Project_Benefit.lyr") ccslib.AddToMap("Credit_Quality", layerFile, zoom_to=True) except: pass # Remove uplift modifier for map units that do not qualify # Select map units of Indirect if project involves anthro # feature modification if includes_anthro_mod: feature = MAP_UNITS_DISSOLVE arcpy.MakeFeatureLayer_management(feature, "lyr") where_clause = """({} = '{}') AND ({} <> {} OR {} <> {} OR {} <> {})""".format( arcpy.AddFieldDelimiters(feature, "Indirect"), "True", arcpy.AddFieldDelimiters(feature, "Projected_Breed"), arcpy.AddFieldDelimiters(feature, "Current_Breed"), arcpy.AddFieldDelimiters(feature, "Projected_LBR"), arcpy.AddFieldDelimiters(feature, "Current_LBR"), arcpy.AddFieldDelimiters(feature, "Projected_Winter"), arcpy.AddFieldDelimiters(feature, "Current_Winter")) arcpy.SelectLayerByAttribute_management(feature, "NEW_SELECTION", where_clause) test = arcpy.GetCount_management(feature) count = int(test.getOutput(0)) if count > 0: # Update message arcpy.AddMessage("Confirming removal of PJ cover credits meet " "eligibility criteria (if applicable)") # Substitute Projected_Anthro_Disturbance if it exists extent_fc = Analysis_Area if arcpy.Exists(PROJECTED_ANTHRO_DISTURBANCE): anthroDisturbance = PROJECTED_ANTHRO_DISTURBANCE else: anthroDisturbance = CURRENT_ANTHRO_DISTURBANCE # Repeat calculation of modifiers w/o PJ_uplift term = ccsStandard.CreditTerms[1] ccslib.CalcModifiers(extent_fc, inputDataPath, Dist_Lek, anthroDisturbance, term, PJ_removal=False, suffix="noPJ") # Repeat joins to table for season in seasons: # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = term + "_Local_" + season + "_noPJ" zoneField = "Map_Unit_ID" outTable = "ZonalStats_" + term + season ccslib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = term + "_" + season + "_noPJ" ccslib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Overwrite Projected seasonal local scale scores overwrite_field = ccsStandard.CreditTerms[1] + "_" + season with arcpy.da.UpdateCursor( feature, [fieldName, overwrite_field]) as cursor: for row in cursor: row[1] = row[0] cursor.updateRow(row) # Clean up arcpy.DeleteField_management(feature, fieldName) # Clean up arcpy.SelectLayerByAttribute_management(feature, "CLEAR_SELECTION") arcpy.Delete_management("lyr") # Add transect field to Map_Units_Dissolve fields = ["Transects"] fieldTypes = ["SHORT"] ccslib.AddFields(Map_Units_Dissolve, fields, fieldTypes) # Export data to Excel input_Tables = [ MAP_UNITS_DISSOLVE, CURRENT_MGMT_CAT, CURRENT_WMZ, CURRENT_PMU, CURRENT_PRECIP ] for table in input_Tables: ccslib.ExportToExcel(table, Project_Folder, Project_Name) # Clean up arcpy.Delete_management("in_memory") # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Proposed_Surface_Disturbance_Provided = arcpy.GetParameterAsText(0) Proposed_Modified_Features_Provided = arcpy.GetParameterAsText( 1) # optional # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace projectGDB = arcpy.Describe(Proposed_Surface_Disturbance_Provided).path arcpy.AddMessage("Project geodatabase: " + projectGDB) # Instantiate a cheStandard object cheStandard = cohqt.cheStandard(projectGDB, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = projectGDB scratch_folder = os.path.join(arcpy.Describe(projectGDB).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(projectGDB).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES Parameter_Values = cheStandard.ParameterValues habitat_bounds = cheStandard.HabitatMgmtArea ConiferModifier = cheStandard.ConiferModifier GrSG_LDI = cheStandard.GrSG_LDI LekPresenceRaster = cheStandard.LekPresenceRaster Lek_Distance_Modifier = cheStandard.LekDistanceModifier SageModifier = cheStandard.SageModifier GrSGHabitat = cheStandard.BWSGHab MuleDeerHabitat = cheStandard.BWMDHab emptyRaster = cheStandard.EmptyRaster MigrationModifier = cheStandard.MuleDeerMigrationMod WinterModifier = cheStandard.MuleDeerWinterMod SummerModifier = cheStandard.MuleDeerSummerMod MuleDeer_LDI = cheStandard.MuleDeerLDI BWMD_Open = cheStandard.BWMD_Open GrSG_Range = cheStandard.GrSGHabitat Mule_Range = cheStandard.MuleDeerHabitat cellSize = arcpy.GetRasterProperties_management(emptyRaster, "CELLSIZEX").getOutput(0) # Filenames for feature classes or rasters used by this script PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits" # Filenames for feature classes or rasters created by this script ANALYSIS_AREA = "Analysis_Area" DEBIT_PROJECT_AREA = "Debit_Project_Area" INDIRECT_IMPACT_AREA = "Indirect_Impact_Area" INDIRECT_BENEFIT_AREA = "Indirect_Benefit_Area" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" DEBIT_PROJECT_IMPACT = "GrSG_Impact" MAP_UNITS = "Map_Units" # GrSG Filenames LEK_DISTURBANCE_MODIFIER = "Lek_Disturbance_Modifier" CUMULATIVE_MODIFIER_PRE = "GRSG_Pre_Cumulative_Modifier" CUMULATIVE_MODIFIER_POST = "GRSG_Post_Cumulative_Modifier" CURRENT_ANTHRO_DISTURBANCE = "GRSG_Pre_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE = "GRSG_Post_Anthro_Disturbance" GRSG_PRE_BREEDING = "GRSG_Pre_Breeding" GRSG_PRE_SUMMER = "GRSG_Pre_Summer" GRSG_PRE_WINTER = "GRSG_Pre_Winter" GRSG_POST_BREEDING = "GRSG_Post_Breeding" GRSG_POST_SUMMER = "GRSG_Post_Summer" GRSG_POST_WINTER = "GRSG_Post_Winter" # Mule Deer Filenames CURRENT_ANTHRO_DISTURBANCE_MD = "MuleDeer_Pre_Anthro_Disturbance" PROJECTED_ANTHRO_DISTURBANCE_MD = "MuleDeer_Post_Anthro_Disturbance" MULE_PRE_SUMMER = "MuleDeer_Pre_Summer" MULE_PRE_MIGRATION = "MuleDeer_Pre_Migration" MULE_PRE_WINTER = "MuleDeer_Pre_Winter" MULE_POST_SUMMER = "MuleDeer_Post_Summer" MULE_POST_MIGRATION = "MuleDeer_Post_Migration" MULE_POST_WINTER = "MuleDeer_Post_Winter" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check out Spatial Analyst extension hqtlib.CheckOutSpatialAnalyst() if not Proposed_Modified_Features_Provided: # Ensure Proposed_Modified_Features does not exist if arcpy.Exists("Proposed_Modified_Features"): arcpy.AddError("ERROR:: A 'Proposed_Modified_Features' layer " "was detected in the project's geodatabase. " "Provide the 'Proposed_Modified_Features' layer " "and re-run Debit Tool 2.") sys.exit(0) # Clear selection, if present util.ClearSelectedFeatures(Proposed_Surface_Disturbance_Provided) # Check Proposed_Surface_Disturbance feature = Proposed_Surface_Disturbance_Provided required_fields = ["Type", "Subtype", "Surface_Disturbance"] no_null_fields = required_fields expected_fcs = None hqtlib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Proposed_Surface_Disturbance layer with provided layer provided_input = Proposed_Surface_Disturbance_Provided parameter_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS Proposed_Surface_Disturbance = util.AdoptParameter(provided_input, parameter_name, preserve_existing=False) # Replace Proposed_Surface_Disturbance_Debits layer on map layerFile = cheStandard.getLayerFile("ProposedSurfaceDisturbance.lyr") util.AddToMap(Proposed_Surface_Disturbance, layerFile) # Add field for Disturbance_Type and populate. Values will be used in # Map_Units_Dissolve to identify map units of direct disturbance feature = Proposed_Surface_Disturbance fields = ["Disturbance_Type"] fieldTypes = ["TEXT"] util.AddFields(feature, fields, fieldTypes) with arcpy.da.UpdateCursor(feature, ["Surface_Disturbance"] + fields) as cursor: for row in cursor: row[1] = "Direct_" + row[0] cursor.updateRow(row) # Update message arcpy.AddMessage("Creating the area of indirect impact") # Buffer proposed surface disturbance to create Indirect_Impact_Area in_data = Proposed_Surface_Disturbance out_name = INDIRECT_IMPACT_AREA Indirect_Impact_Area = hqtlib.CreateIndirectImpactArea( in_data, Parameter_Values, out_name) # Set up flag for projects that propose to modify anthro features includes_anthro_mod = False if Proposed_Modified_Features_Provided: # Update flag includes_anthro_mod = True # Clear selection, if present util.ClearSelectedFeatures(Proposed_Modified_Features_Provided) # Check provided layer required_fields = ["Type", "Subtype"] no_null_fields = required_fields expected_fcs = None hqtlib.CheckPolygonInput(Proposed_Modified_Features_Provided, required_fields, expected_fcs, no_null_fields) # Update Proposed_Modified_Features with provided layer and add to map provided_input = Proposed_Modified_Features_Provided parameterName = PROPOSED_MODIFIED_FEATURES preserve_existing = False Proposed_Modified_Features = util.AdoptParameter( provided_input, parameterName, preserve_existing) # Add Proposed Modified Features layer to map layerFile = cheStandard.getLayerFile("ProposedSurfaceDisturbance.lyr") util.AddToMap(Proposed_Modified_Features, layerFile) # Update message arcpy.AddMessage("Creating the area of indirect benefit") # Create the Indirect_Impact_Area in_data = Proposed_Modified_Features out_name = INDIRECT_BENEFIT_AREA Indirect_Benefit_Area = hqtlib.CreateIndirectImpactArea( in_data, Parameter_Values, out_name) # Union the indirect benefit area and the indirect impact area in_features = [Indirect_Impact_Area, Indirect_Benefit_Area] out_name = "in_memory/Impact_Union" Impact_Union = arcpy.Union_analysis(in_features, out_name) # Dissolve the unioned indirect impact and benefit areas as # Indirect Impact Area in_features = Impact_Union out_feature_class = INDIRECT_IMPACT_AREA Indirect_Impact_Area = arcpy.Dissolve_management( in_features, out_feature_class) # Detect habitat types impacted directly or indirectly is_grsg = cohqt.DetectHabitat(Indirect_Impact_Area, GrSG_Range) is_mule = cohqt.DetectHabitat(Indirect_Impact_Area, Mule_Range) # Update message arcpy.AddMessage("Determining project area - eliminating areas of non-" "habitat from the Project Area") # Eliminate non-habitat project_area = Indirect_Impact_Area out_name = DEBIT_PROJECT_AREA Debit_Project_Area = hqtlib.EliminateNonHabitat(project_area, out_name, habitat_bounds) # Calculate Area hqtlib.CalcAcres(Debit_Project_Area) # Add Debit Project Area to map feature = Debit_Project_Area layerFile = cheStandard.getLayerFile("DebitProjectArea.lyr") util.AddToMap(feature, layerFile, zoom_to=True) # Update message arcpy.AddMessage("Creating Analysis Area") # Create Analysis_Area out_name = ANALYSIS_AREA Analysis_Area = hqtlib.CreateAnalysisArea(Debit_Project_Area, Parameter_Values, out_name) # Add Analysis_Area to map layerFile = cheStandard.getLayerFile("AnalysisArea.lyr") util.AddToMap(Analysis_Area, layerFile, zoom_to=True) # Set processing extent to Analysis_Area arcpy.env.extent = ANALYSIS_AREA # Prepare proposed anthropogenic features unique_proposed_subtypes = cohqt.convertProposedToRasterDebit( Proposed_Surface_Disturbance, cellSize) anthroPath = cheStandard.AnthroFeaturePath cohqt.combineProposedWithCurrentDebit(anthroPath, unique_proposed_subtypes) # # Do something about anthropogenic mod features # if includes_anthro_mod: # unique_proposed_subtypes_removed = hqtlib.convertProposedToRaster( # Proposed_Modified_Features, cellSize # ) # # anthroPath = cheStandard.AnthroFeaturePath # hqtlib.combineProposedWithCurrent(anthroPath, unique_proposed_subtypes) ### GREATER SAGE-GROUSE ANTHRO DIST & MODIFIERS ### if is_grsg: # Update message arcpy.AddMessage("Calculating pre-project anthropogenic disturbance " "modifier for greater sage-grouse") # Calculate pre-project anthropogenic disturbance dist_field = "GrSG_Dist" weight_field = "GrSG_Weight" term = cheStandard.DebitTerms[0] anthro_disturbance_type = "Pre" Current_Anthro_Disturbance = cohqt.CalcAnthroDisturbance( Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Current_Anthro_Disturbance Calculated") arcpy.AddMessage("Calculating post-project anthropogenic " "disturbance modifier for greater sage-grouse") # Calculate post-project anthropogenic disturbance term = cheStandard.DebitTerms[1] anthro_disturbance_type = "Post" Projected_Anthro_Disturbance = cohqt.CalcAnthroDisturbance( Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE) # Update message arcpy.AddMessage("Projected_Anthro_Disturbance Calculated") arcpy.AddMessage("Calculating lek disturbance modifier") # Calculate permanent anthropogenic disturbance # Calculate Lek Disturbance Modifier term = cheStandard.DebitTerms[1] anthro_disturbance_type = "LekDisturbanceModifier" Lek_Disturbance_Modifier = cohqt.CalcAnthroDisturbance( Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) Lek_Disturbance_Modifier.save(LEK_DISTURBANCE_MODIFIER) # Update message arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers") # Calculate pre-project cumulative habitat modifiers winterHabitatPre = cohqt.calcWinterHabitatGRSG( Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, GrSGHabitat) LSDMWinterPre = cohqt.applyLekUpliftModifierPre( winterHabitatPre, LekPresenceRaster) breedingHabitatPre = cohqt.calcBreedingHabitatGRSG( Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, Lek_Distance_Modifier, GrSGHabitat) LSDMBreedingPre = cohqt.applyLekUpliftModifierPre( breedingHabitatPre, LekPresenceRaster) summerHabitatPre = cohqt.calcSummerHabitatGRSG( Current_Anthro_Disturbance, ConiferModifier, GrSG_LDI, SageModifier, GrSGHabitat) LSDMSummerPre = cohqt.applyLekUpliftModifierPre( summerHabitatPre, LekPresenceRaster) seasonalHabitatRasters = [ LSDMWinterPre, LSDMBreedingPre, LSDMSummerPre ] # Save outputs # winterHabitatPre.save(GRSG_PRE_WINTER) LSDMWinterPre.save(GRSG_PRE_WINTER) # breedingHabitatPre.save(GRSG_PRE_BREEDING) LSDMBreedingPre.save(GRSG_PRE_BREEDING) # summerHabitatPre.save(GRSG_PRE_SUMMER) LSDMSummerPre.save(GRSG_PRE_SUMMER) # Calculate average of three seasonal habitat rasters pre-project finalPreCumulative = cohqt.calcAverageHabitatQuality( seasonalHabitatRasters) finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE) # Calculate post-project cumulative habtiat modifiers winterHabitatPost = cohqt.calcWinterHabitatGRSG( Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI, GrSGHabitat) LSDMWinterPost = cohqt.applyLekUpliftModifierPost( winterHabitatPost, LekPresenceRaster, Lek_Disturbance_Modifier) breedingHabitatPost = cohqt.calcBreedingHabitatGRSG( Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI, Lek_Distance_Modifier, GrSGHabitat) LSDMBreedingPost = cohqt.applyLekUpliftModifierPost( breedingHabitatPost, LekPresenceRaster, Lek_Disturbance_Modifier) summerHabitatPost = cohqt.calcSummerHabitatGRSG( Projected_Anthro_Disturbance, ConiferModifier, GrSG_LDI, SageModifier, GrSGHabitat) LSDMSummerPost = cohqt.applyLekUpliftModifierPost( summerHabitatPost, LekPresenceRaster, Lek_Disturbance_Modifier) seasonalHabitatRasters = [ LSDMWinterPost, LSDMBreedingPost, LSDMSummerPost ] # Save outputs # winterHabitatPost.save("Post_Seasonal_Winter") LSDMWinterPost.save(GRSG_POST_WINTER) # breedingHabitatPost.save("Post_Seasonal_Breeding") LSDMBreedingPost.save(GRSG_POST_BREEDING) # summerHabitatPost.save("Post_Seasonal_Summer") LSDMSummerPost.save(GRSG_POST_SUMMER) # Calculate average of three seasonal habitat rasters post-project finalPostCumulative = cohqt.calcAverageHabitatQuality( seasonalHabitatRasters) finalPostCumulative.save(CUMULATIVE_MODIFIER_POST) # Calculate permanent cumulative habtiat modifiers # Calculate Zonal Statistics for cumulative modifier rasters # Add field to use for zonal statistics inTable = Debit_Project_Area fields = ["ZONAL"] field_types = ["SHORT"] util.AddFields(inTable, fields, field_types) # Populate field with value 1 arcpy.CalculateField_management(inTable, fields[0], 1, "PYTHON_9.3", "") # Update message arcpy.AddMessage("Calculating debits for greater sage-grouse") # Calculate zonal statistics for pre-project inZoneData = Debit_Project_Area inValueRaster = finalPreCumulative zoneField = fields[0] outTable = "GRSG_Stats_Pre" hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Debit Project Area table fieldName = "GRSG_Pre_Project" hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate zonal statistics for post-project inZoneData = Debit_Project_Area inValueRaster = finalPostCumulative zoneField = fields[0] outTable = "GRSG_Stats_Post" hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Debit Project Area table fieldName = "GrSG_Post_Project" hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate debits (if not collecting field data) cohqt.calcDebits(Debit_Project_Area, "GRSG_Pre_Project", "GrSG_Post_Project", "Debits") # Update message arcpy.AddMessage("Creating visualization of impact from debit project") # Calculate impact intensity for debit project debit_impact = cohqt.calcImpact(finalPreCumulative, finalPostCumulative) debit_impact.save(DEBIT_PROJECT_IMPACT) # Add Debit Impact raster to map and save map document feature = debit_impact layerFile = cheStandard.getLayerFile("DebitProjectImpact.lyr") util.AddToMap(feature, layerFile, zoom_to=True) ### END GREATER SAGE-GROUSE ### ### MULE DEER ANTHRO DIST & MODIFIERS ### if not is_grsg: # Calculate Zonal Statistics for cumulative modifier rasters # Add field to use for zonal statistics inTable = Debit_Project_Area fields = ["ZONAL"] field_types = ["SHORT"] util.AddFields(inTable, fields, field_types) # Populate field with value 1 arcpy.CalculateField_management(inTable, fields[0], 1, "PYTHON_9.3", "") # Update message if is_mule: arcpy.AddMessage("Calculating pre-project anthropogenic disturbance " "modifier for mule deer") # Calculate pre-project anthropogenic disturbance # Calculate pre-project in PJ dist_field = "MDP_Dist" weight_field = "MDP_Weight" term = cheStandard.DebitTerms[0] #unique_proposed_subtypes = [] anthro_disturbance_type = "Pre" anthro_pj = cohqt.CalcAnthroDisturbance(Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) anthro_pj.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_P") # Calculate pre-project in Open dist_field = "MDO_Dist" weight_field = "MDO_Weight" term = cheStandard.DebitTerms[0] #unique_proposed_subtypes = [] anthro_disturbance_type = "Pre" anthro_open = cohqt.CalcAnthroDisturbance(Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster, mask=BWMD_Open) anthro_open.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_O") # Combine PJ and Open # If outside open, make 1 anthro_open_only = Con(BWMD_Open == 1, anthro_open, 1) anthro_open_only.save(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO") # Select minimum of pj and open rasters Current_Anthro_Disturbance = Con(anthro_open_only < anthro_pj, anthro_open_only, anthro_pj) Current_Anthro_Disturbance.save(CURRENT_ANTHRO_DISTURBANCE_MD) # Clean up arcpy.Delete_management("temp_masked_raster") # arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_P") # arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_O") # arcpy.Delete_management(CURRENT_ANTHRO_DISTURBANCE_MD + "_OO") # Update message arcpy.AddMessage("Current_Anthro_Disturbance Calculated") arcpy.AddMessage("Calculating post-project anthropogenic " "disturbance modifier") # Calculate post-project anthropogenic disturbance # Calculate post-project in PJ dist_field = "MDP_Dist" weight_field = "MDP_Weight" term = cheStandard.DebitTerms[1] #unique_proposed_subtypes = [] anthro_disturbance_type = "Post" anthro_pj = cohqt.CalcAnthroDisturbance(Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster) anthro_pj.save(PROJECTED_ANTHRO_DISTURBANCE_MD + "_P") # Calculate pre-project in Open dist_field = "MDO_Dist" weight_field = "MDO_Weight" term = cheStandard.DebitTerms[1] #unique_proposed_subtypes = [] anthro_disturbance_type = "Post" anthro_open = cohqt.CalcAnthroDisturbance(Parameter_Values, term, unique_proposed_subtypes, anthro_disturbance_type, cheStandard, dist_field, weight_field, cellSize, emptyRaster, mask=BWMD_Open) anthro_open.save(PROJECTED_ANTHRO_DISTURBANCE_MD + "_O") # Combine PJ and Open # If outside open, make 1 anthro_open_only = Con(BWMD_Open == 1, anthro_open, 1) anthro_open_only.save(PROJECTED_ANTHRO_DISTURBANCE_MD + "_OO") # Select minimum of pj and open rasters Projected_Anthro_Disturbance = Con(anthro_open_only < anthro_pj, anthro_open_only, anthro_pj) Projected_Anthro_Disturbance.save(PROJECTED_ANTHRO_DISTURBANCE_MD) # Update message arcpy.AddMessage("Projected_Anthro_Disturbance Calculated") # arcpy.AddMessage("Calculating lek disturbance modifier") # # # Calculate permanent anthropogenic disturbance # # # Calculate Lek Disturbance Modifier # term = cheStandard.CreditTerms[1] # anthro_disturbance_type = "LekDisturbanceModifier" # # Lek_Disturbance_Modifier = hqtlib.cheCalcAnthroDisturbance( # Parameter_Values, term, unique_proposed_subtypes, # anthro_disturbance_type, cheStandard, dist_field, weight_field, # cellSize, emptyRaster # ) # # Lek_Disturbance_Modifier.save(LEK_DISTURBANCE_MODIFIER) # Update message arcpy.AddMessage("Calculating Pre-Project Habitat Modifiers") # Calculate pre-project cumulative habitat modifiers summerHabitatPre = cohqt.calcSummerHabitatMD( Current_Anthro_Disturbance, MuleDeer_LDI, SummerModifier, SuitableHabitat=MuleDeerHabitat) # LSDMWinterPre = cohqt.applyLekUpliftModifierPre(summerHabitatPre, # LekPresenceRaster) migratoryHabitatPre = cohqt.calcMigratoryHabitatMD( Current_Anthro_Disturbance, MuleDeer_LDI, MigrationModifier, SuitableHabitat=MuleDeerHabitat) # LSDMBreedingPre = cohqt.applyLekUpliftModifierPre(migratoryHabitatPre, # LekPresenceRaster) winterHabitatPre = cohqt.calcWinterHabitatMD( Current_Anthro_Disturbance, MuleDeer_LDI, WinterModifier, SuitableHabitat=MuleDeerHabitat) # LSDMSummerPre = cohqt.applyLekUpliftModifierPre(winterHabitatPre, # LekPresenceRaster) seasonalHabitatRasters = [ summerHabitatPre, migratoryHabitatPre, winterHabitatPre ] # Save outputs summerHabitatPre.save(MULE_PRE_SUMMER) # LSDMWinterPre.save("Pre_LSDM_Winter") migratoryHabitatPre.save(MULE_PRE_MIGRATION) # LSDMBreedingPre.save("Pre_LSDM_Breeding") winterHabitatPre.save(MULE_PRE_WINTER) # LSDMSummerPre.save("Pre_LSDM_Summer") # Calc zonal stats for pre-project modifiers (three seasons) term = cheStandard.DebitTerms[0] for season, raster in zip(cheStandard.MuleDeerSeasons, seasonalHabitatRasters): # Update message arcpy.AddMessage("Summarizing Mule Deer " + term + " " + season) # Calculate zonal statistics for each map unit inZoneData = Debit_Project_Area inValueRaster = raster zoneField = fields[0] outTable = "Mule_Stats_" + term + "_" + season hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = "Mule_" + term + "_" + season hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # # Calculate average of three seasonal habitat rasters pre-project # finalPreCumulative = hqtlib.calcAverageHabitatQuality( # seasonalHabitatRasters # ) # finalPreCumulative.save(CUMULATIVE_MODIFIER_PRE) # Calculate post-project cumulative habitat modifiers summerHabitatPost = cohqt.calcSummerHabitatMD( Projected_Anthro_Disturbance, MuleDeer_LDI, SummerModifier, SuitableHabitat=MuleDeerHabitat) # LSDMWinterPost = cohqt.applyLekUpliftModifierPost(summerHabitatPost, # LekPresenceRaster) migratoryHabitatPost = cohqt.calcMigratoryHabitatMD( Projected_Anthro_Disturbance, MuleDeer_LDI, MigrationModifier, SuitableHabitat=MuleDeerHabitat) # LSDMBreedingPost = cohqt.applyLekUpliftModifierPost(migratoryHabitatPost, # LekPresenceRaster) winterHabitatPost = cohqt.calcWinterHabitatMD( Projected_Anthro_Disturbance, MuleDeer_LDI, WinterModifier, SuitableHabitat=MuleDeerHabitat) # LSDMSummerPost = cohqt.applyLekUpliftModifierPost(winterHabitatPost, # LekPresenceRaster) seasonalHabitatRasters = [ summerHabitatPost, migratoryHabitatPost, winterHabitatPost ] # Save outputs summerHabitatPost.save(MULE_POST_SUMMER) # LSDMWinterPre.save("Pre_LSDM_Winter") migratoryHabitatPost.save(MULE_POST_MIGRATION) # LSDMBreedingPre.save("Pre_LSDM_Breeding") winterHabitatPost.save(MULE_POST_WINTER) # LSDMSummerPre.save("Pre_LSDM_Summer") # Calc zonal stats for pre-project modifiers (three seasons) term = cheStandard.DebitTerms[1] for season, raster in zip(cheStandard.MuleDeerSeasons, seasonalHabitatRasters): # Update message arcpy.AddMessage("Summarizing Mule Deer " + term + " " + season) # Calculate zonal statistics for each map unit inZoneData = Debit_Project_Area inValueRaster = raster zoneField = fields[0] outTable = "Mule_Stats_" + term + "_" + season hqtlib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = "Mule_" + term + "_" + season hqtlib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # # Calculate average of three seasonal habitat rasters post-project # finalPostCumulative = hqtlib.calcAverageHabitatQuality( # seasonalHabitatRasters # ) # finalPostCumulative.save(CUMULATIVE_MODIFIER_POST) # Calculate permanent cumulative habtiat modifiers # Update message arcpy.AddMessage("Calculating Mule Deer Impact") # Calculate impact pre_fields = [ "Mule_Pre_Summer", "Mule_Pre_Migration", "Mule_Pre_Winter" ] post_fields = [ "Mule_Post_Summer", "Mule_Post_Migration", "Mule_Post_Winter" ] out_fields = [ "Mule_Summer_Impact", "Mule_Migration_Impact", "Mule_Winter_Impact" ] for i in range(len(pre_fields)): pre_field = pre_fields[i] post_field = post_fields[i] out_field = out_fields[i] cohqt.calcDebits(Debit_Project_Area, pre_field, post_field, out_field) # # Update message # arcpy.AddMessage("Creating visualization of impact from debit project") # # # Calculate impact intensity for debit project # debit_impact = hqtlib.calcImpact(finalPreCumulative, finalPostCumulative) # debit_impact.save(DEBIT_PROJECT_IMPACT) # # # Add Debit Impact raster to map and save map document # feature = debit_impact # layerFile = cheStandard.getLayerFile("DebitProjectImpact.lyr") # hqtlib.AddToMap(feature, layerFile, zoom_to=True) ### END MULE DEER ### if not is_grsg and not is_mule: arcpy.AddMessage("Impacts were not detected in any habitat type. " "Please check credit project boundary and try " "again") # Create Map_Units layer in_data = Debit_Project_Area out_data = MAP_UNITS Map_Units = hqtlib.CreateMapUnits(in_data, out_data) # Add Map_Units to map layerFile = cheStandard.getLayerFile("MapUnits.lyr") util.AddToMap(Map_Units, layerFile) # Add fields Map_Unit_ID, Map_Unit_Name, and Meadow to Map_Units fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes", "Precip", "Transects"] fieldTypes = ["SHORT", "TEXT", "TEXT", "TEXT", "SHORT"] util.AddFields(Map_Units, fields, fieldTypes, copy_existing=True) # Add Domains to Map_Units layer # Create Domain for Map_Unit_ID attributes domainName = "Map_Unit_ID" range_low = 0 range_high = 10000 util.AddRangeDomain(Map_Units, projectGDB, domainName, range_low, range_high) # Create Domain for Precip attributes feature_list = [Map_Units] domain_name = "Precip" code_list = ["Arid", "Mesic"] util.AddCodedTextDomain(feature_list, projectGDB, domain_name, code_list) # Update message arcpy.AddMessage("Cleaning up workspace") # Clean up for raster in arcpy.ListRasters("*_Subtype_Disturbance"): arcpy.Delete_management(raster) for raster in arcpy.ListRasters("*_Type_Disturbance"): arcpy.Delete_management(raster) arcpy.Delete_management("in_memory") try: arcpy.Delete_management(scratch_folder) except: pass # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Map_Units_Dissolve_Provided = arcpy.GetParameterAsText(0) Transects_Provided = arcpy.GetParameterAsText(1) Project_Folder = arcpy.GetParameterAsText(2) Project_Name = arcpy.GetParameterAsText(3) # optional # DEFINE DIRECTORIES & PATH NAMES FOR FOLDERS & GBDs scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace workspace = arcpy.Describe(Map_Units_Dissolve_Provided).path arcpy.AddMessage("Project geodatabase: " + workspace) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace arcpy.env.scratchWorkspace = workspace # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES # Filenames for feature classes or rasters used by this script # Filenames for feature classes or rasters created by this script TRANSECTS_SJ = "Transects_SpatialJoin" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() if Transects_Provided: # Update message arcpy.AddMessage("Executing spatial join of Transects and " "Map_Unit_Dissolve layer") # ccslib.AddTransectFields(Transects) Map_Units_Dissolve = Map_Units_Dissolve_Provided out_name = "in_memory/Transects" transects = ccslib.TransectJoin(Map_Units_Dissolve, Transects_Provided, out_name) else: arcpy.AddError("ERROR:: Please provide the transects feature" "class or shapefile provided by the SETT") sys.exit(0) # Update message arcpy.AddMessage("Preparing Transects Spatial Join for export") # Remove unnecessary fields allowable_fields = [ "Bearing1", "Bearing2", "Bearing3", "UTM_E", "UTM_N", "Map_Unit_ID", "Map_Unit_Name", "Meadow", "Indirect", "Acres", "Spring_HSI", "Summer_HSI", "Winter_HSI", "PJ_Cover", "Current_Breed", "Current_LBR", "Current_Winter", "Projected_Breed", "Projected_LBR", "Projected_Winter", "Permanent_Breed", "Permanent_LBR", "Permanent_Winter", "Transects", "Transect_Number", "Sample_Type", "Notes" ] allowable_fields_lower = [ allow_field.lower() for allow_field in allowable_fields ] for field in arcpy.ListFields(transects): if field.name.lower() not in allowable_fields_lower \ and field.required is False: try: arcpy.DeleteField_management(transects, field.name) except arcpy.ExecuteError: pass # ccslib.SimplifyFields(TRANSECTS_SJ, allowable_fields) # Sort fields by Transect ID arcpy.Sort_management(transects, TRANSECTS_SJ, [["Transect_Number", "ASCENDING"]]) # Add Transects to map ccslib.AddToMap(TRANSECTS_SJ) # Export data to Excel table = TRANSECTS_SJ ccslib.ExportToExcel(table, Project_Folder, Project_Name) # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ # Import system modules import arcpy import os import sys import gc import ccslib if arcpy.ListInstallations()[0] == 'arcgispro': # switch import importlib importlib.reload(ccslib) def main(): # GET PARAMETER VALUES Analysis_Area = arcpy.GetParameterAsText(0) Current_Anthro_Features_Provided = arcpy.GetParameterAsText(1) # optional Dist_Lek = arcpy.GetParameterAsText(2) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) # Construct pathname to workspace
def main(): # GET PARAMETER VALUES workspace = arcpy.GetParameterAsText(0) Credit_Project_Boundary = arcpy.GetParameterAsText(1) includes_anthro_mod = arcpy.GetParameterAsText(2) # optional Proposed_Modified_Features_Provided = arcpy.GetParameterAsText(3) # optional # Update boolean parameters includes_anthro_mod = ccslib.Str2Bool(includes_anthro_mod) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace arcpy.env.scratchWorkspace = workspace # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE GLOBAL VARIABLES AnthroAttributeTable = ccsStandard.AnthroAttributeTable coordinate_system = ccsStandard.CoorSystem habitat_bounds = ccsStandard.HabitatBounds # Filenames for feature classes and rasters created by this script CREDIT_PROJECT_AREA = "Credit_Project_Area" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" MAP_UNITS = "Map_Units" # ------------------------------------------------------------------------ # FUNCTION CALLS # Update includes_anthro_mod if Proposed_Modified_Features is # provided if Proposed_Modified_Features_Provided and not includes_anthro_mod: includes_anthro_mod = True # Exit with warning if no Credit Project Boundary is provided and project # is does not propose to remove or modify anthropogenic disturbance if not Credit_Project_Boundary and not includes_anthro_mod: arcpy.AddError("ERROR:: A credit project boundary must be provided " "unless the project proposes to remove or modify " "anthropogenic features. Ensure 'Credit Project will " "remove or modify existing anthropogenic features' is " "checked if true. Please see the User's Guide for " "additional instruction.") sys.exit(0) # Check input features if Credit_Project_Boundary: # Check provided input for polygon shape type ccslib.CheckPolygonInput(Credit_Project_Boundary) if Proposed_Modified_Features_Provided: # Check provided feature for polygon shape type ccslib.CheckPolygonInput(Proposed_Modified_Features_Provided) # Set up zoom to for map units variable zoom_to_mu = False # Check input features for existence of features and feature type; # create template if Credit_Project_Boundary is not provided if Credit_Project_Boundary: # Create a local copy of the credit project boundary in case it is # the output of the projected input from re-running Credit Tool 1 CPB_copy = arcpy.CopyFeatures_management(Credit_Project_Boundary, "in_memory/CPB_provided") # Update message arcpy.AddMessage("Projecting provided feature(s) to " + coordinate_system.name) # Project input to standard projection in_dataset = CPB_copy out_dataset = "Credit_Project_Boundary_Projected" projectedFeature = ccslib.ProjectInput(in_dataset, out_dataset, coordinate_system) # Update message arcpy.AddMessage("Determining project area - eliminating areas of non-" "habitat from the Project Area") # Eliminate areas of non-habitat from project boundary Project_Area = projectedFeature outName = "in_memory/Credit_Project_Boundary_Clipped" clippedFeature = ccslib.EliminateNonHabitat(Project_Area, outName, habitat_bounds) # Create Credit Project Area in_features = clippedFeature out_feature_class = CREDIT_PROJECT_AREA arcpy.Dissolve_management(in_features, out_feature_class) # Update message arcpy.AddMessage("Creating Map Units layer") # Create Map_Units layer in_data = clippedFeature out_data = MAP_UNITS Map_Units = ccslib.CreateMapUnits(in_data, out_data) zoom_to_mu = True if includes_anthro_mod: # Create a template for digitizing anthropogenic features proposed for # modification out_name = "Proposed_Modified_Features_tmp" Template_Features = ccslib.CreateTemplate( workspace, out_name, coordinate_system ) # Update message arcpy.AddMessage("Adding fields Type and Subtype to " "the Proposed_Modified_Features layer") # Add fields Type and Subtype inputFeature = Template_Features fieldsToAdd = ["Type", "Subtype"] fieldTypes = ["TEXT", "TEXT"] ccslib.AddFields(inputFeature, fieldsToAdd, fieldTypes, copy_existing=True) # Set up zoom to for proposed surface disturbance variable zoom_to_psd = False if Proposed_Modified_Features_Provided: # Merge the template created with the provided layer, if provided fileList = [Proposed_Modified_Features_Provided, Template_Features] out_name = "in_memory/tmp_Modified" merged_features = ccslib.MergeFeatures(fileList, out_name) # Rename the provided as merged (cannot merge two files with # equivalent filenames) as Proposed_Modified_Features in_data = merged_features out_data = PROPOSED_MODIFIED_FEATURES Proposed_Modified_Features = arcpy.CopyFeatures_management( in_data, out_data ) zoom_to_psd = True else: # Save the template as Proposed_Modified_Features in_data = Template_Features out_data = PROPOSED_MODIFIED_FEATURES Proposed_Modified_Features = ccslib.RenameFeatureClass( in_data, out_data ) # Clean up arcpy.Delete_management("Proposed_Modified_Features_tmp") # Add Domains to Proposed_Modified_Features layer featureList = [Proposed_Modified_Features] # Create Domain for Subtype attributes and assign to Subtype field ccslib.AddSubtypeDomains(featureList, workspace, AnthroAttributeTable) # Create Domain for Type attributes and assign to Type field typeList = [row[0] for row in arcpy.da.SearchCursor( AnthroAttributeTable, "Type")] ccslib.AddCodedTextDomain(featureList, workspace, "Type", typeList) # Add layer to map for editing layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Modified_Features, layerFile, zoom_to_psd) if not Credit_Project_Boundary: # Create dummy Map Units layer if no Credit Project Boundary provided out_name = MAP_UNITS Map_Units = ccslib.CreateTemplate(workspace, out_name, coordinate_system) if Proposed_Modified_Features_Provided: # Zoom to the Modified Anthro Feature layer if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") m = p.activeMap layer=m.Layer(PROPOSED_MODIFIED_FEATURES) pass # df.extent = layer.getSelectedExtent() else: mxd = arcpy.mapping.MapDocument("CURRENT") df = mxd.activeDataFrame layer = arcpy.mapping.Layer(PROPOSED_MODIFIED_FEATURES) df.extent = layer.getSelectedExtent() # Update message arcpy.AddMessage("Creating pre-defined map units of Wet Meadows") # Intersect the Map_Units layer with the NV Wet Meadows layer in_feature = ccsStandard.Wet_Meadows field_name = "Meadow" na_value = "No Meadow" ccslib.CreatePreDefinedMapUnits(Map_Units, in_feature, field_name, na_value) # Add fields Map_Unit_ID, Map_Unit_Name, and Meadow to Map_Units fields = ["Map_Unit_ID", "Map_Unit_Name", "Notes"] fieldTypes = ["SHORT", "TEXT", "TEXT"] ccslib.AddFields(Map_Units, fields, fieldTypes, copy_existing=True) # Add Domains to Map_Units layer # Create Domain for Map_Unit_ID attributes domainName = "Map_Unit_ID" range_low = 0 range_high = 10000 ccslib.AddRangeDomain(Map_Units, workspace, domainName, range_low, range_high) # Create Domain for Meadow attributes featureList = [Map_Units] domainName = "Meadow" codeList = ["No Meadow", "Altered", "Unaltered"] ccslib.AddCodedTextDomain(featureList, workspace, domainName, codeList, assign_default=True) if Credit_Project_Boundary: # Create pre-defined map units for PJ # Update message arcpy.AddMessage("Creating pre-defined map units of PJ") # Intersect the Map_Units layer with the Phase III PJ layer in_feature = ccsStandard.PJ_Phases field_name = "Conifer_Phase" ccslib.CreatePreDefinedMapUnits(Map_Units, in_feature, field_name) # Remove unwanted fields from Map Units feature class allowable_fields = fields + ["Conifer_Phase"] ccslib.SimplifyFields(Map_Units, allowable_fields) # Add Map_Units to map layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(Map_Units, layerFile, zoom_to_mu) # Clean up arcpy.Delete_management("in_memory") # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Proposed_Surface_Disturbance_Provided = arcpy.GetParameterAsText(0) Proposed_Modified_Features_Provided = arcpy.GetParameterAsText( 1) # optional Project_Folder = arcpy.GetParameterAsText(2) # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace workspace = arcpy.Describe(Proposed_Surface_Disturbance_Provided).path arcpy.AddMessage("Project geodatabase: " + workspace) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join(arcpy.Describe(workspace).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management( arcpy.Describe(workspace).path, 'scratch') arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE VARIABLES FOR INPUT DATA AnthroAttributeTable = ccsStandard.AnthroAttributeTable habitat_bounds = ccsStandard.HabitatBounds public_land = ccsStandard.Public # Filenames for feature classes or rasters used by this script PROPOSED_SURFACE_DISTURBANCE_DEBITS = "Proposed_Surface_Disturbance_Debits" # Filenames for feature classes or rasters created by this script ELIGIBLE_PROPOSED_FEATURES = "Proposed_Surface_Disturbance_Eligible" ANALYSIS_AREA = "Analysis_Area" DEBIT_PROJECT_AREA = "Debit_Project_Area" INDIRECT_IMPACT_AREA = "Indirect_Impact_Area" INDIRECT_BENEFIT_AREA = "Indirect_Benefit_Area" PROPOSED_MODIFIED_FEATURES = "Proposed_Modified_Features" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() # Check for proposed modified features if not Proposed_Modified_Features_Provided: # Ensure Proposed_Modified_Features does not exist if arcpy.Exists("Proposed_Modified_Features"): arcpy.AddError("ERROR:: A 'Proposed_Modified_Features' layer " "was detected in the project's geodatabase. " "Provide the 'Proposed_Modified_Features' layer " "and re-run Debit Tool 2.") sys.exit(0) # Clear selection, if present ccslib.ClearSelectedFeatures(Proposed_Surface_Disturbance_Provided) # Check Proposed_Surface_Disturbance feature = Proposed_Surface_Disturbance_Provided required_fields = ["Type", "Subtype", "Surface_Disturbance"] no_null_fields = required_fields expected_fcs = None ccslib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Proposed_Surface_Disturbance layer with provided layer provided_input = Proposed_Surface_Disturbance_Provided parameter_name = PROPOSED_SURFACE_DISTURBANCE_DEBITS Proposed_Surface_Disturbance_Debits = ccslib.AdoptParameter( provided_input, parameter_name, preserve_existing=False) # Replace Proposed_Surface_Disturbance_Debits layer on map layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Surface_Disturbance_Debits, layerFile) # Clip the Proposed Surface Disturbance to Public Lands input_features = PROPOSED_SURFACE_DISTURBANCE_DEBITS clip_features = public_land out_name = ELIGIBLE_PROPOSED_FEATURES Proposed_Surface_Disturbance = arcpy.Clip_analysis(input_features, clip_features, out_name) # Exit if no features on public land exist test = arcpy.GetCount_management(Proposed_Surface_Disturbance) count = int(test.getOutput(0)) if count < 1: arcpy.AddWarning(""" There are no proposed features located on public lands.\n Therefore, this project does not require mitigation.\n Please confirm with the SETT. """) sys.exit(0) # Add Surface_Disturbance_Eligible layer on map layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Surface_Disturbance, layerFile) # Add field for Disturbance_Type and populate. Values will be used in # Map_Units_Dissolve to identify map units of direct disturbance feature = Proposed_Surface_Disturbance fields = ["Disturbance_Type"] fieldTypes = ["TEXT"] ccslib.AddFields(feature, fields, fieldTypes) with arcpy.da.UpdateCursor(feature, ["Surface_Disturbance"] + fields) as cursor: for row in cursor: row[1] = "Direct_" + row[0] cursor.updateRow(row) # Update message arcpy.AddMessage("Creating the area of indirect impact") # Buffer proposed surface disturbance to create Indirect_Impact_Area in_data = Proposed_Surface_Disturbance out_name = INDIRECT_IMPACT_AREA Indirect_Impact_Area = ccslib.CreateIndirectImpactArea( in_data, AnthroAttributeTable, out_name) if Proposed_Modified_Features_Provided: # Clear selection, if present ccslib.ClearSelectedFeatures(Proposed_Modified_Features_Provided) # Check provided layer required_fields = ["Type", "Subtype"] no_null_fields = required_fields expected_fcs = None ccslib.CheckPolygonInput(Proposed_Modified_Features_Provided, required_fields, expected_fcs, no_null_fields) # Update Proposed_Modified_Features with provided layer and add to map provided_input = Proposed_Modified_Features_Provided parameterName = PROPOSED_MODIFIED_FEATURES preserve_existing = False Proposed_Modified_Features = ccslib.AdoptParameter( provided_input, parameterName, preserve_existing) # Add Proposed Modified Features layer to map layerFile = ccsStandard.getLayerFile("SurfaceDisturbance.lyr") ccslib.AddToMap(Proposed_Modified_Features, layerFile) # Update message arcpy.AddMessage("Creating the area of indirect benefit") # Create the Indirect_Impact_Area in_data = Proposed_Modified_Features out_name = INDIRECT_BENEFIT_AREA Indirect_Benefit_Area = ccslib.CreateIndirectImpactArea( in_data, AnthroAttributeTable, out_name) # Union the indirect benefit area and the indirect impact area in_features = [Indirect_Impact_Area, Indirect_Benefit_Area] out_name = "in_memory/Impact_Union" Impact_Union = arcpy.Union_analysis(in_features, out_name) # Dissolve the unioned indirect impact and benefit areas as # Indirect Impact Area in_features = Impact_Union out_feature_class = INDIRECT_IMPACT_AREA Indirect_Impact_Area = arcpy.Dissolve_management( in_features, out_feature_class) # Update message arcpy.AddMessage("Determining project area - eliminating areas of non-" "habitat from the Project Area") # Eliminate non-habitat project_area = Indirect_Impact_Area out_name = DEBIT_PROJECT_AREA Debit_Project_Area = ccslib.EliminateNonHabitat(project_area, out_name, habitat_bounds) # Update message arcpy.AddMessage("Copying Debit_Project_Area as shapefile into project " "folder") # Export feature class to shapefile in project folder so it can be sent to # NDOW for Dist_Lek layer arcpy.FeatureClassToShapefile_conversion(Debit_Project_Area, Project_Folder) # Update message arcpy.AddMessage("Creating Analysis Area") # Create Analysis_Area out_name = ANALYSIS_AREA Analysis_Area = ccslib.CreateAnalysisArea(Debit_Project_Area, AnthroAttributeTable, out_name) # Add Analysis_Area to map layerFile = ccsStandard.getLayerFile("Analysis_Area.lyr") ccslib.AddToMap(Analysis_Area, layerFile, zoom_to=True) # Save map document and exit if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()
def main(): # GET PARAMETER VALUES Map_Units_Provided = arcpy.GetParameterAsText(0) Project_Folder = arcpy.GetParameterAsText(1) Project_Name = arcpy.GetParameterAsText(2) # optional # DEFINE DIRECTORIES # Get the pathname to this script scriptPath = sys.path[0] arcpy.AddMessage("Script folder: " + scriptPath) arcpy.AddMessage("Python version: " + sys.version) # Construct pathname to workspace workspace = arcpy.Describe(Map_Units_Provided).path arcpy.AddMessage("Project geodatabase: " + workspace) # Instantiate a ccsStandard object ccsStandard = ccslib.ccsStandard(workspace, scriptPath) # ENVIRONMENT SETTINGS # Set workspaces arcpy.env.workspace = workspace scratch_folder = os.path.join(arcpy.Describe(workspace).path, 'scratch') if arcpy.Exists(scratch_folder): pass else: arcpy.CreateFolder_management(scratch_folder) arcpy.env.scratchWorkspace = scratch_folder # Overwrite outputs arcpy.env.overwriteOutput = True # DEFINE VARIABLES FOR INPUT DATA inputDataPath = ccsStandard.InputDataPath # Filenames of feature classes and rasters used by this script MAP_UNITS = "Map_Units" CURRENT_ANTHRO_FEATURES = "Current_Anthro_Features" # Filenames of feature classes and rasters created by this script MAP_UNITS_DISSOLVE = "Map_Units_Dissolve" CURRENT_MGMT_CAT = "Current_Mgmt_Cat" CURRENT_WMZ = "Current_WMZ" CURRENT_PMU = "Current_PMU" CURRENT_PRECIP = "Current_Precip" # ------------------------------------------------------------------------ # FUNCTION CALLS # Check tool version ccslib.CheckToolVersion() # Check out Spatial Analyst extension ccslib.CheckOutSpatialAnalyst() # Clear selection, if present ccslib.ClearSelectedFeatures(Map_Units_Provided) # Check Map_Units layer feature = Map_Units_Provided required_fields = ["Map_Unit_ID", "Map_Unit_Name", "Meadow"] no_null_fields = ["Map_Unit_ID"] expected_fcs = [CURRENT_ANTHRO_FEATURES] ccslib.CheckPolygonInput(feature, required_fields, expected_fcs, no_null_fields) # Update Map Units layer with provided layer and add to map Map_Units = ccslib.AdoptParameter(Map_Units_Provided, MAP_UNITS, preserve_existing=False) layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(Map_Units, layerFile) # Update message arcpy.AddMessage("Dissolving all multi-part map units to create " "Map_Units_Dissolve") # Dissolve Map Units allowable_fields = [ "Map_Unit_ID", "Map_Unit_Name", "Meadow", "Disturbance_Type", "PJ", "BROTEC", "Conifer_Phase" ] out_name = MAP_UNITS_DISSOLVE anthro_features = CURRENT_ANTHRO_FEATURES Map_Units_Dissolve = ccslib.DissolveMapUnits(Map_Units, allowable_fields, out_name, anthro_features) # Update message arcpy.AddMessage("Adding Map_Units_Dissolve to map") # Add layer to map document feature = Map_Units_Dissolve layerFile = ccsStandard.getLayerFile("Map_Units.lyr") ccslib.AddToMap(feature, layerFile) # Update message arcpy.AddMessage("Calculating area in acres for each map unit") # Calculate Area ccslib.CalcAcres(Map_Units_Dissolve) # Initialize a list to track proportion feature classes prop_fcs = [] # Update message arcpy.AddMessage("Calculating Proportion within each precipitation zone") # Calculate Proportion of each map unit in each Precip Zone in_feature = os.path.join(inputDataPath, "Precip") out_feature_class = CURRENT_PRECIP field_name = "Precip_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Update message arcpy.AddMessage("Calculating Management Importance Factor") # Calculate Proportion of each map unit in each Management Category in_feature = os.path.join(inputDataPath, "Mgmt_Cat") out_feature_class = CURRENT_MGMT_CAT field_name = "Mgmt_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Update message arcpy.AddMessage("Calculating Proportion within each WAFWA Management " "Zone") # Calculate Proportion in each map unit in each WAFWA Zone in_feature = os.path.join(inputDataPath, "NV_WAFWA") out_feature_class = CURRENT_WMZ field_name = "WMZ_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Update message arcpy.AddMessage("Calculating Proportion within each Priority Management " "Unit") # Calculate Proportion in each map unit in each PMU in_feature = os.path.join(inputDataPath, "NV_PMU") out_feature_class = CURRENT_PMU field_name = "PMU_Proportion" ccslib.CalcProportion(Map_Units_Dissolve, in_feature, out_feature_class, field_name) prop_fcs.append(out_feature_class) # Delete unnecessary fields in proportion feature classes allowable_fields = [ "Map_Unit_ID", "Management", "Mgmt_zone", "PMU_NAME", "Precip", "Mgmt_Proportion", "WMZ_Proportion", "PMU_Proportion", "Precip_Proportion" ] for feature in prop_fcs: ccslib.SimplifyFields(feature, allowable_fields) # Set processing extent to Map_Units layer arcpy.env.extent = arcpy.Describe(Map_Units_Dissolve).extent # Calculate the average HSI values per map unit for each map unit HSIseasons = ccsStandard.HSISeasons for season in HSIseasons: # Update message arcpy.AddMessage("Summarizing " + season + " HSI") # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = os.path.join(inputDataPath, season + "_HSI") zoneField = "Map_Unit_ID" outTable = "ZonalStats_" + season + "_HSI" ccslib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = season + "_HSI" ccslib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Calculate the average seasonal modifier values per map unit and join to # Map_Units_Dissolve layer terms = ccsStandard.DebitTerms seasons = ccsStandard.Seasons for term in terms: for season in seasons: # Update message arcpy.AddMessage("Summarizing " + term + "_Local_" + season) # Calculate zonal statistics for each map unit inZoneData = Map_Units_Dissolve inValueRaster = term + "_Local_" + season zoneField = "Map_Unit_ID" outTable = "ZonalStats_" + term + season ccslib.CalcZonalStats(inZoneData, zoneField, inValueRaster, outTable) # Join the zonal statistic to the Map Units Dissolve table fieldName = term + "_" + season ccslib.JoinMeanToTable(inZoneData, outTable, zoneField, fieldName) # Add transect field to Map_Units_Dissolve input_feature = Map_Units_Dissolve fields = ["Transects"] fieldTypes = ["SHORT"] ccslib.AddFields(input_feature, fields, fieldTypes) # Export data to Excel input_Tables = [ MAP_UNITS_DISSOLVE, CURRENT_MGMT_CAT, CURRENT_WMZ, CURRENT_PMU, CURRENT_PRECIP ] for table in input_Tables: ccslib.ExportToExcel(table, Project_Folder, Project_Name) # Save map document if arcpy.ListInstallations()[0] == 'arcgispro': p = arcpy.mp.ArcGISProject("CURRENT") p.save() else: mxd = arcpy.mapping.MapDocument("CURRENT") mxd.save()