def test_poi_corrcet(extracted_area,poi_region,out_path):
#arcpy.Intersect_analysis([extracted_area,poi_region], 'temp.shp')
arcpy.MakeFeatureLayer_management(poi_region,'selected_area')
arcpy.SelectLayerByLocation_management('selected_area','CROSSED_BY_THE_OUTLINE_OF',extracted_area)
arcpy.Erase_analysis('selected_area', extracted_area, 'temp.shp')
arcpy.Union_analysis([extracted_area,'temp.shp'],'temp_1.shp')
arcpy.Dissolve_management('temp_1.shp','temp_2')
if os.path.isfile(workspace_path +'\\'+out_path):
print('File exists.Overwrite the original shp')
arcpy.Delete_management(out_path)
arcpy.Erase_analysis('temp_2.shp', '\\data\\waterregion.shp', out_path)
arcpy.Delete_management('temp.shp')
arcpy.Delete_management('temp_1.shp')
arcpy.Delete_management('temp_2.shp')
def geoProcess(datetime,
province,
target_area,
density_cell="10",
day_cell="15"):
# if arcpy.Exists("lightningDay") and arcpy.Exists("lightningDensity"):
# return
cwd = os.getcwd()
# todo 新建数据库占用了十几秒的时间，可以考虑在之前并行处理
workpath = ''.join([cwd, u"/temp/", province, '/', datetime])
workspace = ''.join([workpath, '/', target_area, '.gdb'])
if not arcpy.Exists(workspace):
arcpy.CreateFileGDB_management(workpath, ''.join([target_area,
'.gdb']))
arcpy.env.workspace = workspace
arcpy.env.outputCoordinateSystem = arcpy.SpatialReference("WGS 1984")
arcpy.env.overwriteOutput = True
origin_data = ''.join([workpath, u'/GDB.gdb/data', datetime])
infeature = ''.join([cwd, u'/data/LightningBulletin.gdb/', target_area])
# 获取当前extent
extents = getExtents(infeature)
####制作电闪密度插值点文件#######
# 制作网格文件
grid_feature = makeGrids(extents, density_cell)
# 剪裁数据
clip_feature = clipData(origin_data, grid_feature, density_cell)
# 制作电闪密度插值点
lightningDensity(clip_feature, grid_feature, density_cell)
# 制作掩盖文件
mask_feature = "densityMask"
arcpy.Erase_analysis(grid_feature, infeature, mask_feature)
####制作电闪雷暴日插值点文件####
# 制作网格文件
grid_feature = makeGrids(extents, day_cell)
# 剪裁数据
clip_feature = clipData(origin_data, grid_feature, day_cell)
# 制作电闪雷暴日插值点
lightningDay(clip_feature, grid_feature, day_cell)
# 制作掩盖文件
mask_feature = "dayMask"
arcpy.Erase_analysis(grid_feature, infeature, mask_feature)
####计算相关统计参数
statsProcess(infeature, workspace)
def processing(self):
pg_frames = self.make_pg()
self.get_pg(pg_frames)
# Choose the erase shp
areas_erase = []
for i, area_level in enumerate(self.areas_level):
if area_level <= self.max_level: # Notice <= means has the higher weight
areas_erase.append(self.areas[i])
areas_erase_path = 'areas_erase.shp'
erase_output_path = 'erase_' + self.output_path
if len(areas_erase) > 0: # Erase
if os.path.isfile(self.workspace_path + '\\' + areas_erase_path):
arcpy.Delete_management(areas_erase_path)
arcpy.Merge_management(areas_erase, areas_erase_path)
if os.path.isfile(self.workspace_path + '\\' + erase_output_path):
arcpy.Delete_management(self.workspace_path + '\\' +
erase_output_path)
arcpy.Erase_analysis(self.output_path, areas_erase_path,
erase_output_path)
zip_path = self.shp_to_zip(erase_output_path)
arcpy.Delete_management(erase_output_path)
arcpy.Delete_management(areas_erase_path)
else:
zip_path = self.shp_to_zip(self.output_path)
arcpy.Delete_management(self.output_path)
print('Frame done...')
return zip_path
def InsideState(state, nwi, lakes, outfc):
arcpy.env.outputCoordinateSystem = arcpy.SpatialReference(102039)
# Select only wetlands with their center inside this state
# This way all wetlands will only be represented once when we merge all states
arcpy.env.workspace = 'in_memory'
arcpy.MakeFeatureLayer_management(nwi, "nwi_lyr")
cu.multi_msg('Selecting wetlands with their center in the state.')
arcpy.SelectLayerByLocation_management("nwi_lyr", 'HAVE_THEIR_CENTER_IN',
state, '', 'NEW_SELECTION')
# Two things to make wetlands conform to the CSI definition
# Select only palustrine systems that aren't freshwater ponds
# and make it impossible for wetlands to be inside lakes
wetland_type_field = arcpy.ListFields("nwi_lyr", "WETLAND_TY*")[0].name
filter = """"ATTRIBUTE" LIKE 'P%' AND {} <> 'Freshwater Pond'""".format(
wetland_type_field)
cu.multi_msg("Selecting only palustrine wetlands...")
arcpy.SelectLayerByAttribute_management("nwi_lyr", "SUBSET_SELECTION",
filter)
cu.multi_msg('Erasing lakes from wetlands layer.')
arcpy.Erase_analysis("nwi_lyr", lakes, outfc)
# Add two fields we will use, an ID field and the area in hectares
arcpy.AddField_management(outfc, "WET_ID", "LONG")
arcpy.CalculateField_management(outfc, "WET_ID", "!OBJECTID!", "PYTHON")
arcpy.AddField_management(outfc, "AreaHa", "DOUBLE")
arcpy.CalculateField_management(outfc, "AreaHa", "!shape.area@hectares!",
"PYTHON")
def run(self):
self.e.load()
print "Starting Creating Facets processing..."
if arcpy.Exists(self.i.cmx): # this forces overwriting the cmx table
arcpy.Delete_management(self.i.cmx)
arcpy.gp.ZonalStatisticsAsTable_sa(self.i.catchment, "HydroID", self.i.fac, self.i.cmx, "DATA", "MAXIMUM")
# --- old code ---
# arcpy.gp.MakeFeatureLayer(self.i.catchment, "lyr")
# arcpy.AddJoin_management("lyr", "HydroID", self.i.cmx, "HydroID", "KEEP_ALL")
# arcpy.SelectLayerByAttribute_management("lyr","NEW_SELECTION","cmx.MAX > cmx.COUNT")
# arcpy.Clip_analysis(self.i.drl, "lyr", self.i.drl_c, "")
# arcpy.SelectLayerByAttribute_management("lyr","NEW_SELECTION","cmx.MAX <= cmx.COUNT") # ESSA PARTE NAO FOI FEITA
# arcpy.Clip_analysis(self.i.lfp, "lyr", self.i.lfp_c, "")
# --- old code ---
self.process_c(self.i.drl, self.i.drl_c)
# self.process_c(self.i.lfp, self.i.lfp_c)
arcpy.Erase_analysis(self.i.drl, self.i.drl_c, self.i.lfp_ct)
arcpy.SpatialJoin_analysis(target_features=self.i.lfp,join_features=self.i.lfp_ct,out_feature_class=self.i.lfp_c,join_operation="JOIN_ONE_TO_ONE",join_type="KEEP_COMMON",match_option="INTERSECT")
arcpy.Merge_management(self.i.drl_c + ";" + self.i.lfp_c, self.i.fm_vec)
arcpy.PolylineToRaster_conversion(self.i.fm_vec, "HydroID", self.i.fm_ras, "MAXIMUM_LENGTH", "NONE", self.e.cs)
arcpy.gp.Divide_sa(self.i.fm_ras, self.i.fm_ras, self.i.fm_ras_d)
arcpy.gp.Reclassify_sa(self.i.fm_ras_d, "VALUE", "1 NODATA;NODATA 0", self.i.fm_ras_r, "DATA")
arcpy.gp.Combine_sa(self.i.fm_ras_r + ";" + self.i.cat, self.i.fm_ras_c)
arcpy.RasterToPolygon_conversion(self.i.fm_ras_c, self.i.facets, "NO_SIMPLIFY", "VALUE")
# --- old code ---
# arcpy.RemoveJoin_management("lyr", "")
# arcpy.SelectLayerByAttribute_management("lyr", "CLEAR_SELECTION", "")
# arcpy.Delete_management("lyr")
# --- old code ---
print "Ending Creating Facets processing..."
def _create_random_points(area, buffer_val, points, messages):
# Process: Buffer
buffer_name = arcpy.CreateScratchName("temp", data_type="Shapefile", workspace=arcpy.env.scratchFolder)
arcpy.Buffer_analysis(points, buffer_name, buffer_val, "FULL", "ROUND", "ALL", "", "PLANAR")
# Process: Erase
erase_name = arcpy.CreateScratchName("temp", data_type="Shapefile", workspace=arcpy.env.scratchFolder)
arcpy.Erase_analysis(area, buffer_name, erase_name, "")
# Process: Create Random Points
random_name = arcpy.CreateScratchName("temp", data_type="FeatureClass", workspace=arcpy.env.scratchFolder)
num_points = int(arcpy.GetCount_management(points))
arcpy.CreateRandomPoints_management(arcpy.env.scratchFolder, random_name, erase_name, "0 0 250 250", num_points,
"1 Meters", "POINT", "0")
messages.AddMessage(str(arcpy.GetCount_management(random_name)) + " Random points created")
# array = arcpy.da.FeatureClassToNumPyArray(random_name, "SHAPE@XY")
# arcpy.Delete_management(buffer_name)
# arcpy.Delete_management(erase_name)
# arcpy.Delete_management(random_name)
# return array
return random_name
def execute_task(args):
# in_extentDict, data, traj_list = args
in_extentDict = args
fc_count = in_extentDict[0]
print fc_count
procExt = in_extentDict[1]
print procExt
XMin = procExt[0]
YMin = procExt[1]
XMax = procExt[2]
YMax = procExt[3]
#set environments
arcpy.env.extent = arcpy.Extent(XMin, YMin, XMax, YMax)
####### BUFFER ##########################################################################################
# roads_buffer = "D:\\projects\\intact_land\\intact\\refine\\tiles_t2\\roads_buffer_{}.shp".format(fc_count)
# arcpy.Buffer_analysis("D:\\projects\\intact_land\\intact\\refine\\mask\\roads.gdb\\region_roads", roads_buffer , "25 meters", "FULL", "ROUND", "ALL")
if fc_count == '27':
####### ERASE ##########################################################################################
in_features = 'D:\\projects\\intact_land\\intact\\main\\years\\2015.gdb\\clu_2015_noncrop_c'
erase_features = 'D:\\projects\\intact_land\\intact\\refine\mask\\final.gdb\\region_merged_masks_t2'
out_feature_class = 'D:\\projects\\intact_land\\intact\\refine\\pp_erase\\clu_2015_noncrop_c_w_masks_{}'.format(
fc_count)
arcpy.Erase_analysis(in_features=in_features,
erase_features=erase_features,
out_feature_class=out_feature_class)
def Merger(layer, layerTwo, layerThree):
arcpy.env.overwriteOutput = True
mergeLayer = "Temp_{0}".format(arcpy.Describe(layerTwo).name)
arcpy.Merge_management([layerTwo, layerThree], mergeLayer)
outLayer = arcpy.Erase_analysis(layer, mergeLayer)
arcpy.AddWarning(outLayer)
return outLayer
def rasterizeSinglebeam(points,
mb,
out="__rast",
number=6,
radius=18,
overWrite=False):
import arcpy
from arcpy.sa import *
if overWrite:
arcpy.env.overwriteOutput = True
outIDW = Idw(points, "bottom_elevation", 3, 2,
RadiusVariable(number, radius))
if mb:
conRast = Con(outIDW, 1, '', '')
poly = arcpy.RasterToPolygon_conversion(conRast, "_poly" + points,
"SIMPLIFY", "")
buff = arcpy.Buffer_analysis(poly, "buff_" + points, "-15 feet",
"FULL", "", "", "")
footprint = arcpy.Erase_analysis(buff, mb, "footprint_" + points, "")
finalRast = arcpy.Clip_management(outIDW, "", "rast_" + points,
footprint, "", "ClippingGeometry")
arcpy.Delete_management(poly)
arcpy.Delete_management(buff)
arcpy.Delete_management(footprint)
else:
outIDW.save(arcpy.Describe(points).catalogPath + out)
def create_karabakh(
in_polygon1, in_line, in_polygon0, out_shp
): # Arcpy doesn't have a method for cutting polygons with polylines. We use a solution suggested by https://gis.stackexchange.com/a/24757
print "...Removing Nakhichevan"
select_shp = "b_temp/select_shp.shp"
arcpy.Select_analysis(in_polygon1, select_shp, '"ADM2" = \'az3100\'')
print "...Creating the buffer on the north-east side of the Line of Contact" # This covers the whole of Azerbaijan proper. Thus, it can be used to erase this part of Azerbaijan to extract Nagorno-Karabakh.
buffer_shp = "b_temp/temp_buffer.shp"
arcpy.Buffer_analysis(
in_line, buffer_shp, "10 DecimalDegrees", "LEFT", "ROUND", "NONE", "",
"GEODESIC"
) # see http://desktop.arcgis.com/en/arcmap/10.3/tools/analysis-toolbox/buffer.htm
print "...Removing Azerbaijan proper"
erase_shp = "b_temp/temp_erase.shp"
arcpy.Erase_analysis(select_shp, buffer_shp, erase_shp)
print "...Merging Karabakh polygon with the rest of Azerbaijan"
inFeatures = [in_polygon0, erase_shp]
outFeatures = out_shp
arcpy.Union_analysis(inFeatures, outFeatures, "ONLY_FID")
print "...creating the territory indicator 1/2"
arcpy.AddField_management(out_shp, "territory", "TEXT")
print "...creating the territory indicator 2/2"
arcpy.CalculateField_management(
out_shp, "territory", "Reclass(!FID_temp_e!)", "PYTHON_9.3",
"def Reclass(name):\\n if (name == 0):\\n return \"NKR\"\\n else:\\n return \"AZE\""
) # FID_temp_e comes from Erase tool's output (erase_shp), taking the value of 0 for Karabakh and -1 for the rest
print "Deleting intermediate files"
files_to_delete = [
in_polygon1, in_polygon0, select_shp, buffer_shp, erase_shp
]
for file in files_to_delete:
delete_if_exists(file)
def CombineShorelinePolygons(bndMTL: str, bndMHW: str, inletLines: str,
ShorelinePts: str, bndpoly: str, SA_bounds: str='', verbose: bool=True):
"""
Use MTL and MHW contour polygons to create shoreline polygon.
'Shoreline' = MHW on oceanside and MTL on bayside
"""
start = time.clock()
# Inlet lines must intersect the MHW polygon
symdiff = os.path.join(arcpy.env.scratchGDB, 'shore_1symdiff')
split = os.path.join(arcpy.env.scratchGDB, 'shore_2split')
join = os.path.join(arcpy.env.scratchGDB, 'shore_3_oceanMTL')
erase = os.path.join(arcpy.env.scratchGDB, 'shore_4_bayMTL')
union_2 = os.path.join(arcpy.env.scratchGDB, 'shore_5union')
# Create layer (symdiff) of land between MTL and MHW and split by inlets
print("...delineating land between MTL and MHW elevations...")
arcpy.Delete_management(symdiff) # delete if already exists
arcpy.SymDiff_analysis(bndMTL, bndMHW, symdiff)
# Split symdiff at inlets (and SA_bounds)
print("...removing the MHW-MTL areas on the oceanside...")
if len(SA_bounds) > 0:
arcpy.FeatureToPolygon_management([symdiff, inletLines, SA_bounds], split) # Split MTL features at inlets and study area bounds
else:
arcpy.FeatureToPolygon_management([symdiff, inletLines], split) # Split MTL features at inlets
# Isolate polygons touching shoreline points and erase from symdiff
arcpy.SpatialJoin_analysis(split, ShorelinePts, split+'_join', "#","KEEP_COMMON", match_option="COMPLETELY_CONTAINS")
arcpy.Erase_analysis(symdiff, split+'_join', erase)
# Merge bayside MHW-MTL with above-MHW polygon
arcpy.Union_analysis([erase, bndMHW], union_2)
arcpy.Dissolve_management(union_2, bndpoly, multi_part='SINGLE_PART') # Dissolve all features in union_2 to single part polygons
print('''User input required! Select extra features in {} for deletion.\nRecommended technique: select the polygon/s to keep and then Switch Selection.\n'''.format(os.path.basename(bndpoly)))
return(bndpoly)
def Erase(in_features, erase_features, out_feature_class):
try:
arcpy.Erase_analysis(in_features, erase_features, out_feature_class,
'')
#print 'Erase_analysis successful'
except Exception:
print arcpy.GetMessages()
def check_schedule_a_is_within(tfl_basename, input_gdb):
"""Takes input edit database and checks to ensure that all schedule A land is
within the newly created/updated TFL Boundary. Returns False if Schedule A
exists outside of boundary and True if all Schedule A is within"""
arcpy.env.workspace = input_gdb
if arcpy.Exists(input_gdb + os.sep + 'schedule_a_outside'):
arcpy.Delete_management(input_gdb + os.sep + 'schedule_a_outside')
arcpy.AddMessage('Lookingfor boundary at : ' + input_gdb + os.sep +
tfl_basename + '_Boundary')
tfl_boundary = arcpy.MakeFeatureLayer_management(
input_gdb + os.sep + tfl_basename + '_Boundary', 'tfl_boundary')
tfl_schedule_a = arcpy.MakeFeatureLayer_management(
input_gdb + os.sep + tfl_basename + '_Schedule_A', 'tfl_schedule_a')
schedule_a_outside = arcpy.Erase_analysis(tfl_schedule_a, tfl_boundary,
'schedule_a_outside')
arcpy.Delete_management(tfl_boundary)
arcpy.Delete_management(tfl_schedule_a)
if int(arcpy.GetCount_management(schedule_a_outside)[0]) > 0:
arcpy.AddWarning(
'ERROR: Found Schedule A polygons outside of TFL Boundary - please review the schedule_a_outside feature class and fix before re-submitting'
)
return (False)
else:
arcpy.AddMessage('Schedule A is all within the boundary')
arcpy.Delete_management(schedule_a_outside)
return (True)
def handleCanals(streamNetwork, canal, tempFolder, is_verbose):
if is_verbose:
arcpy.AddMessage("Removing canals...")
if arcpy.GetInstallInfo()['Version'][0:4] == '10.5':
streamNetworkNoCanals = os.path.join(tempFolder, "NoCanals.shp")
else:
streamNetworkNoCanals = os.path.join('in_memory', 'NoCanals')
arcpy.Erase_analysis(streamNetwork, canal, streamNetworkNoCanals)
findBraidedReaches(streamNetworkNoCanals, is_verbose)
with arcpy.da.UpdateCursor(
streamNetworkNoCanals,
"IsMultiCh") as cursor: # delete non-braided reaches
for row in cursor:
if row[0] == 0:
cursor.deleteRow()
arcpy.MakeFeatureLayer_management(streamNetwork, "lyrBraidedReaches")
arcpy.MakeFeatureLayer_management(streamNetworkNoCanals, "lyrNoCanals")
arcpy.SelectLayerByLocation_management("lyrBraidedReaches",
"SHARE_A_LINE_SEGMENT_WITH",
"lyrNoCanals", '', "NEW_SELECTION")
arcpy.CalculateField_management("lyrBraidedReaches", "IsMultiCh", 1,
"PYTHON")
arcpy.CalculateField_management("lyrBraidedReaches", "IsMainCh", 0,
"PYTHON")
arcpy.Delete_management(streamNetworkNoCanals)
def __remove_exclusionary_areas(self, target_features, exclusion_list,
workspace, timestamp):
exclusive_features = 'tmp_exc_sut_{}'.format(timestamp)
if exclusion_list:
arcpy.AddMessage('Removing exclusionary areas...')
if len(exclusion_list) == 1:
exclusion_features = exclusion_list[0]
else:
exclusion_features = 'tmp_exc_fet_{}'.format(timestamp)
arcpy.Union_analysis(in_features=exclusion_list,
out_feature_class=os.path.join(
workspace, exclusion_features),
join_attributes='ONLY_FID')
arcpy.Erase_analysis(in_features=target_features,
erase_features=exclusion_features,
out_feature_class=exclusive_features)
else:
exclusive_features = target_features
return exclusive_features
def removeFlares(self, object):
outputLocation = r"C:\Users\lafia\Documents\GitHub\ConceptsOfSpatialInformation\CoreConceptsPy\ArcPy\data\China_noFlares.shp"
# erase gas flares from country, generates a mask
arcpy.Erase_analysis(
r"C:\Users\lafia\Documents\GitHub\ConceptsOfSpatialInformation\CoreConceptsPy\ArcPy\data\China.shp",
object.filename, outputLocation)
return outputLocation
def erase_overlaps_from_coverages(self, pid_list_input=None):
try:
state_wildcard = self.wildcard
if pid_list_input is None:
pid_list = get_path.pathFinder.query_provider_by_FIPS(
path_links.num_provider_per_state,
str(int(state_wildcard)))
else:
pid_list = pid_list_input
for pid in pid_list:
fc_wildcard = "Coverage_map_{}_{}_*".format(self.wildcard, pid)
print(fc_wildcard)
fc_list = get_path.pathFinder(
env_0=self.inputGDB).get_file_path_with_wildcard_from_gdb(
fc_wildcard)
erase_feature_list = get_path.pathFinder(
env_0=self.inputGDB2).get_file_path_with_wildcard_from_gdb(
"_merged_overlaps_{}".format(self.wildcard))
output = os.path.join(
self.outputGDB,
os.path.basename(fc_list[0]) + "_minus_overlaps")
if arcpy.Exists(output):
print("the file exits, skipping!!!!!!!!")
else:
print("Erasing {} from coverage map {}".format(
fc_list[0], erase_feature_list[0]))
arcpy.Erase_analysis(in_features=fc_list[0],
erase_features=erase_feature_list[0],
out_feature_class=output)
print(arcpy.GetMessages(0))
logging.info(arcpy.GetMessages(0))
except arcpy.ExecuteError:
msgs = arcpy.GetMessages(2)
arcpy.AddError(msgs)
print(msgs)
logging.info(msgs)
except:
tb = sys.exc_info()[2]
tbinfo = traceback.format_tb(tb)[0]
pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(
sys.exc_info()[1])
msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages(2) + "\n"
arcpy.AddError(pymsg)
arcpy.AddError(msgs)
print(pymsg)
print(msgs)
logging.info(pymsg)
logging.info(msgs)
def main():
logging.debug("Starting West Nile Virus Simulation...")
arcpy.env.overwriteOutput = True
arcpy.env.workspace = f"{config_dict.get('proj_dir')}WestNileOutbreak.gdb"
aprx = arcpy.mp.ArcGISProject(
r"C:\Users\Owner\Documents\ArcGIS\Projects\WestNileOutbreak\WestNileOutbreak.aprx"
)
for map in aprx.listMaps():
print("Map: " + map.name)
for lyr in map.listLayers():
print("- " + lyr.name)
# Create container for layers.
layer_list = [
"Mosquito_Larval_Sites", "Wetlands_Regulatory", "OSMP_Properties",
"Lakes_and_Reservoirs", "avoid_points"
]
# Define workspace.
resultsgeodatabase = r"C:\Users\Owner\Documents\ArcGIS\Projects\WestNileOutbreak\WestNileOutbreak.gdb\\"
arcpy.env.workspace = resultsgeodatabase
featureclass = arcpy.ListFeatureClasses()
logging.debug("Ending West Nile Virus Simulation!")
for layer in layer_list:
print(layer)
# Ask user for buffer distance input.
dist = input(
"Please type in a buffer distance between 1000-5000 feet: ")
bufferlayer = buffer(layer, dist)
featureclass = arcpy.ListFeatureClasses()
inter_list = [
"Mosquito_Larval_Sites_buf", "Wetlands_Regulatory_buf",
"OSMP_Properties_buf", "Lakes_and_Reservoirs_buf"
]
output_intersectlayer = intersect(inter_list)
target_features = "Boulder_addresses"
join_features = output_intersectlayer
out_feature_class = "spatial_join"
arcpy.SpatialJoin_analysis(target_features, join_features,
out_feature_class)
print("Spatial join layer created.")
target_features = r"C:\Users\Owner\Documents\ArcGIS\Projects\WestNileOutbreak\WestNileOutbreak.gdb\spatial_join"
erase_features = r"C:\Users\Owner\Documents\ArcGIS\Projects\WestNileOutbreak\WestNileOutbreak.gdb\avoid_points_buf"
out_feature_class = r"C:\Users\Owner\Documents\ArcGIS\Projects\WestNileOutbreak\WestNileOutbreak.gdb" \
r"\output_final_analysis "
arcpy.Erase_analysis(target_features, erase_features, out_feature_class)
print("Erase layer created.")
def erase_mask_list(tile_list, country_shapefile, datadir):
clipped_list = []
for tileid in tile_list:
mask_tile = os.path.join(r"s:\tcd_masks", tileid + ".shp")
clipped_mask = tileid + "_clip.shp"
clipped_mask_path = os.path.join(datadir, clipped_mask)
arcpy.Erase_analysis(mask_tile, country_shapefile, clipped_mask_path)
clipped_list.append(clipped_mask_path)
return clipped_list
def erase(self):
for i in self.listbuffers:
out_name = i.replace("buffer_with_inputmap", "donut_buffer")
arcpy.Erase_analysis(i, self.inputmap, out_name, '')
#self.lista_erases.append(out_name)
Listerased = arcpy.ListFeatureClasses()
self.onelist = Listerased
self.pattern = "_donut_buffer_"
self.Listerased = MSBuffer.selecInList(self)
def _constrain_from_points(constrain_area, excluding_points,
excluding_distance, select_inside):
"""
_constrain_from_points
Constrains an area to intersect/exclude zones around given points
:param constrain_area: General area to be constrained
:param excluding_points: Seed points to create the areas
:param excluding_distance: Radius of the areas
:param select_inside: Boolean to select if the area should be intersected (True) or excluded (false)
:return: Area after be intersected/excluded
"""
global MESSAGES
MESSAGES.AddMessage("Constraining Area from points...")
_verbose_print("Constrain Area: {}".format(constrain_area))
_verbose_print("Excluding points : {}".format(excluding_points))
_verbose_print("Excluding distance : {}".format(excluding_distance))
_verbose_print("select inside : {}".format(select_inside))
scratch_files = []
try:
# Create the buffer area from the points
buffer_scratch = arcpy.CreateScratchName(
"buff_sct.shp", workspace=arcpy.env.scratchWorkspace)
arcpy.Buffer_analysis(excluding_points,
buffer_scratch,
excluding_distance,
dissolve_option="ALL")
scratch_files.append(buffer_scratch)
_verbose_print(
"Scratch file created (buffer): {}".format(buffer_scratch))
combined_scratch = arcpy.CreateScratchName(
"comb_sct.shp", workspace=arcpy.env.scratchWorkspace)
# Intersect/Delete from the original area
if select_inside:
_verbose_print("Intersect selected")
arcpy.Intersect_analysis([buffer_scratch, constrain_area],
combined_scratch)
else:
_verbose_print("Erase selected")
arcpy.Erase_analysis(constrain_area, buffer_scratch,
combined_scratch)
_verbose_print(
"Scratch file created (erase): {}".format(combined_scratch))
except:
_verbose_print("Error constraining from points")
raise
finally:
# This process creates files that will not be needed and are erased at the end of the execution or when an error is found
for s_file in scratch_files:
_verbose_print("Scratch file deleted: {}".format(s_file))
arcpy.Delete_management(s_file)
_verbose_print("Constrain from points finished")
return combined_scratch
def erase(self):
for i in self.listbuffers:
out_name = i.replace("Buffer", "Erase")
arcpy.Erase_analysis(i, self.UCs, out_name, '')
self.lista_erases.append(out_name)
Listerase = arcpy.ListFeatureClasses()
self.lista = Listerase
self.pattern = "_Erase_"
self.Listerase = MSBuffer.selecInList(self)
def create_nonFP_byYear():
##Description: merge all the couties for a given year and then use erase() function with clu_[year]_crop to get non crop dataset
yearlist = range(2005, 2016)
##create an array to hold all files from all state gdbs for a given year
for year in yearlist:
print year
countylist = []
arcpy.env.workspace = "D:\\projects\\intactland\\intact_clu\\main\\states"
# List all file geodatabases in the current workspace
workspaces = arcpy.ListWorkspaces("*", "FileGDB")
#get each state geodtabase
for workspace in workspaces:
print workspace
arcpy.env.workspace = workspace
##list features for a given year in each state geodatabase
featureclasses = arcpy.ListFeatureClasses("*_acea_{}*".format(
str(year)))
for fc in featureclasses:
print 'fc:', fc
substring_list = fc.split("_")
countylist.append("'" + substring_list[2] + "'")
print "number of counties for {}: {}".format(str(year),
len(countylist))
def createWhereString(countylist):
print countylist
cntyString = ' OR atlas_stco='.join(countylist)
cond = 'atlas_stco={}'.format(cntyString)
return cond
if len(countylist) > 0:
arcpy.env.workspace = "G:\\ancillary_storage\\intactland\\intact_clu\\main\\years"
in_features = 'C:\\Users\\Bougie\\Desktop\\Gibbs\\data\\usxp\\ancillary\\vector\\shapefiles.gdb\\counties'
layer = 'counties_{}'.format(str(year))
where_clause = createWhereString(countylist)
# # # Make a layer from the feature class
arcpy.MakeFeatureLayer_management(in_features, layer, where_clause)
#create a feature class containing a counties with data for a given year
# arcpy.FeatureClassToFeatureClass_conversion(layer, "D:\\projects\\intact_land\\years\\{}.gdb".format(str(year)), "clu_{}_counties".format(str(year)))
##------------create to noncrop dataset per year ---------------------------------------------------------------------------
arcpy.Erase_analysis(
in_features=layer,
erase_features="{0}.gdb\\fp_{0}".format(str(year)),
out_feature_class="{0}.gdb\\nfp_{0}".format(str(year)))
def calcArea_erase_arcpy(selectSites_gdf, envData_gdf, areaField, regionField,
envDataField, envDataName, selectedSitesField,
selectedSitesFilename):
## Erase merged env category data
sp_erased = arcpy.Erase_analysis(selectSites_gdf, envData_gdf,
"in_memory/temp_erased")
elapsed_time = (time.time() - start_time) / (60)
print("Total time for completion: " + str(elapsed_time) + " minutes")
## Calculate new Area field
arcpy.AddField_management(sp_erased, "Area_remaining", "FLOAT")
arcpy.CalculateField_management(in_table = sp_erased, field = "Area_remaining", \
expression = "!Shape.Area@squarekilometers!", \
expression_type = "PYTHON_9.3")
## convert erased gdb table to numpy array to Pandas DF:
sp_erased_df = pd.DataFrame(arcpy.da.FeatureClassToNumPyArray(sp_erased, \
[regionField, areaField, 'Area_remaining']))
area_erased_regionSum_df = sp_erased_df.groupby(
[regionField])['Area_remaining'].sum().reset_index()
##### use the original (unerased selectedSites_gdf) feature/shapefile, convert to pd df and calculate the area_allSelSites_km2
area_orig_df = pd.DataFrame(
arcpy.da.FeatureClassToNumPyArray(selectSites_gdf,
[regionField, areaField]))
## Calculate the sum by region
area_orig_regionSum_df = area_orig_df.groupby(
[regionField])[areaField].sum().reset_index()
## merge the erased and original regionSum_df
area_merged_df = area_erased_regionSum_df.merge(area_orig_regionSum_df,
how="outer",
on=regionField)
## subtract Area_remaining from Area (original)
area_merged_df["area_envData_km2"] = area_merged_df[
"Area"] - area_merged_df["Area_remaining"]
## rename fields as needed
area_merged_df.rename(columns={
areaField: 'area_allSelSites_km2',
regionField: 'region'
},
inplace=True)
## assign new fields
area_merged_df[envDataField] = envDataName
area_merged_df[selectedSitesField] = selectedSitesFilename
## remove "Area_remaining" column
area_merged_df.drop(["Area_remaining"], axis=1)
area_merged_df["percent_selSites"] = area_merged_df[
"area_envData_km2"] / area_merged_df['area_allSelSites_km2']
return area_merged_df
def table(zones, idFld, output, exterior=True, selfrel=True):
common.debug('running neighbour table', zones, idFld, output, exterior,
selfrel)
with common.PathManager(output) as pathman:
if exterior:
common.progress('mapping zone surroundings')
buffer = pathman.tmpFC()
arcpy.Buffer_analysis(zones,
buffer,
'50 Meters',
dissolve_option='ALL')
common.progress('creating exterior zone')
erased = pathman.tmpFC()
arcpy.Erase_analysis(buffer, zones, erased, TOLERANCE)
common.progress('identifying exterior zone')
common.calcField(erased, idFld, EXTERIOR_ID,
common.pyTypeOfField(zones, idFld))
# common.progress('eliminating sliver polygons')
common.progress('merging exterior zone')
jointo = pathman.tmpFC()
arcpy.Merge_management([zones, erased], jointo)
else:
jointo = zones
common.progress('finding neighbours')
joined = pathman.tmpFC()
fm = arcpy.FieldMappings()
fm.addFieldMap(
common.fieldMap(zones, idFld, common.NEIGH_FROM_FLD, 'FIRST'))
fm.addFieldMap(
common.fieldMap(jointo, idFld, common.NEIGH_TO_FLD, 'FIRST'))
arcpy.SpatialJoin_analysis(zones, jointo, joined, 'JOIN_ONE_TO_MANY',
'KEEP_COMMON', fm, 'INTERSECT', TOLERANCE)
common.progress('converting to neighbour table')
fm2 = arcpy.FieldMappings()
fm.addFieldMap(
common.fieldMap(joined, common.NEIGH_FROM_FLD,
common.NEIGH_FROM_FLD, 'FIRST'))
fm.addFieldMap(
common.fieldMap(joined, common.NEIGH_TO_FLD, common.NEIGH_TO_FLD,
'FIRST'))
if selfrel:
query = common.safeQuery(
"[{}] <> '{}'".format(common.NEIGH_FROM_FLD, EXTERIOR_ID),
joined)
else:
query = common.safeQuery(
"[{0}] <> [{1}] AND [{0}] <> '{2}'".format(
common.NEIGH_FROM_FLD, common.NEIGH_TO_FLD, EXTERIOR_ID),
joined)
arcpy.TableToTable_conversion(joined, pathman.getLocation(),
pathman.getOutputName(), query, fm2)
common.clearFields(output,
[common.NEIGH_FROM_FLD, common.NEIGH_TO_FLD])
return output
def erase_PAD(state, ras, replace):
# Process: Erase
pad_state = constants.pad_dir + 'PAD-US_' + state + '\\PADUS1_3_' + state + '.gdb\\PADUS1_3' + state
pad_out_dir = constants.pad_dir + 'output\\' + state + os.sep
bound_out_dir = constants.bound_dir + 'output\\' + state + os.sep
state_dir = constants.out_dir + os.sep + state + os.sep
constants.make_dir_if_missing(pad_out_dir)
constants.make_dir_if_missing(bound_out_dir)
constants.make_dir_if_missing(state_dir)
select_state = bound_out_dir + state + '.shp'
erased_pad = pad_out_dir + state + '.shp'
extract_comb = state_dir + 'ext_' + state + '_' + str(
constants.START_YEAR)[2:] + '_' + str(constants.END_YEAR)[2:]
#
if arcpy.Exists(select_state) and not (replace):
pass
else:
where = '"STATE_ABBR" = ' + "'%s'" % state.upper()
try:
arcpy.Select_analysis(constants.BOUNDARIES, select_state, where)
except:
logging.info(arcpy.GetMessages())
#
if arcpy.Exists(erased_pad) and not (replace):
pass
else:
try:
arcpy.Erase_analysis(select_state, pad_state, erased_pad, "")
except:
logging.info(arcpy.GetMessages())
#
if arcpy.Exists(extract_comb) and not (replace):
pass
else:
try:
# Create bounding box from polygon (xmin, ymin, xmax, ymax)
#desc = arcpy.Describe(erased_pad)
#rectangle = "%s %s %s %s" % (desc.extent.XMin, desc.extent.YMin, desc.extent.XMax, desc.extent.YMax)
#arcpy.Clip_management(ras,rectangle,extract_comb,erased_pad,"#","ClippingGeometry")
arcpy.gp.ExtractByMask_sa(ras, erased_pad, extract_comb)
except:
logging.info(arcpy.GetMessages())
logging.info('\t Erasing PAD from state ' + state)
return extract_comb
def handleCanals(stream_network, canal, perennial_network, temp_folder, is_verbose):
"""
Finds braided sections of the stream network, not counting canals, if canals are available
:param stream_network:
:param canal:
:param temp_folder:
:param is_verbose:
:return:
"""
if is_verbose:
arcpy.AddMessage("Removing canals...")
if arcpy.GetInstallInfo()['Version'][0:4] == '10.5':
stream_network_no_canals = os.path.join(temp_folder, "NoCanals.shp")
perennial_no_canals = os.path.join(temp_folder, "PerenNoCanals.shp")
else:
stream_network_no_canals = os.path.join('in_memory', 'NoCanals')
perennial_no_canals = os.path.join('in_memory', "PerenNoCanals")
arcpy.Erase_analysis(stream_network, canal, stream_network_no_canals)
if perennial_network is not None:
arcpy.Erase_analysis(perennial_network, canal, perennial_no_canals)
else:
perennial_no_canals = None
findBraidedReaches(stream_network_no_canals, perennial_no_canals, is_verbose)
with arcpy.da.UpdateCursor(stream_network_no_canals, "IsMultiCh") as cursor: # delete non-braided reaches
for row in cursor:
if row[0] == 0:
cursor.deleteRow()
arcpy.MakeFeatureLayer_management(stream_network, "lyrBraidedReaches")
arcpy.MakeFeatureLayer_management(stream_network_no_canals,"lyrNoCanals")
arcpy.SelectLayerByLocation_management("lyrBraidedReaches","SHARE_A_LINE_SEGMENT_WITH","lyrNoCanals",'',"NEW_SELECTION")
arcpy.CalculateField_management("lyrBraidedReaches","IsMultiCh",1,"PYTHON")
arcpy.CalculateField_management("lyrBraidedReaches","IsMainCh",0,"PYTHON")
arcpy.Delete_management(stream_network_no_canals)
def erase(inShp, erase_feat, out):
"""
Difference between two feature classes
"""
import arcpy
arcpy.Erase_analysis(
in_features=inShp, erase_features=erase_feat,
out_feature_class=out
)
return out
def innerWedgeErase(centerX, centerY, r2, wedge, projOut):
"""Cut out the inner part of the wedge based upon the original point feature
class's radius2 field. Returns a string with the location of the output
wedge.
Keyword arguments:
centerX -- The X coordinate of the center of the wedge (int or float)
centerY -- The Y coordinate of the center of the wedge (int or float)
r2 -- The inner radius of the wedge (int or float)
wedge -- A string specifying the location of the wedge feature class or
object from which to erase (string)
projOut -- The projection of the wedge (arcpy.SpatialReference)
r2 must be greater than 0 and must be in meters.
"""
try:
#Create an arcpy.Point() object that will be buffered
pt = arcpy.Point()
pt.X = centerX
pt.Y = centerY
#Create a pointGeometry out of the arcpy.Point object, then add the
#pointGeometry object to the list that will be used in the
#CopyFeatures_management geoprocessor tool below.
pointGeometry = arcpy.PointGeometry(pt,projOut)
# Make a list with the center point in order to create a feature class
# with just this one point. This feature class will be buffered later
# to create the circle.
centerList = []
centerList.append(pointGeometry)
#Buffer the wedge center by the inner radius distance, then use that
#buffer to erase from the input wedge
circle = "in_memory\\circle"
arcpy.Buffer_analysis(centerList, circle, str(r2) + ' METERS')
oWedge2 = "in_memory\\oWedge2"
arcpy.Erase_analysis(wedge, circle, oWedge2)
arcpy.Delete_management(circle)
del centerList
arcpy.Delete_management(wedge)
return oWedge2
except Exception as e:
tb = sys.exc_info()[2]
arcpy.AddError("An error occured on line %i" % tb.tb_lineno)
print str(e)
arcpy.AddError(str(e))
def geo_process(self, gbz_merge_lyr, dltb_query_lyr):
"""
地理逻辑处理
:param dltb_query_lyr: 定义查询后的地类图斑数据
:param gbz_merge_lyr: 所有高标注农田的合并图层
:return:
"""
out_feature_class = "erase_left"
arcpy.Erase_analysis(dltb_query_lyr, gbz_merge_lyr, out_feature_class)
print "Erase success"
builded_area = "builded_area"
arcpy.Erase_analysis(dltb_query_lyr, out_feature_class, builded_area)
print "Erase success"
builded_area_id = "builded_area_id"
arcpy.Identity_analysis(builded_area, self.input_xzq, builded_area_id)
print "Identity success"
fields_o = arcpy.ListFields(builded_area_id)
f_exist = all([ezarcpy.check_field_exit(fields_o, i) for i in
["XZQDM", "XZQMC", "Shape_Area"]])
if not f_exist:
raise RuntimeError("field does not exist")
# 添加字段XZQ，用于存放XZQDM&XZQMC
ezarcpy.add_field(builded_area_id, [XZQ], "TEXT", 60)
expression = "[XZQDM] & [XZQMC]"
arcpy.CalculateField_management(builded_area_id, XZQ, expression, "VB")
cal_rel_area = "cal_rel_area"
if self.name:
cal_rel_area = self.name
arcpy.Dissolve_management(builded_area_id, cal_rel_area, "XZQ")
print "Dissolve suceess"
# 添加字段MJM，用于存放面积亩
ezarcpy.add_field(cal_rel_area, [MJM], "DOUBLE")
expression2 = "[Shape_Area] * 0.0015"
arcpy.CalculateField_management(cal_rel_area, MJM, expression2, "VB")
print u"output {}.shp".format(self.name)
return cal_rel_area
