def check_area(input_file, workspace): """check the area values and make sure they are reasonable.""" original_sum = 0 final_sum = 0 # Project to Equal Area reprojected = workspace + '\\Reproject.shp' projection = os.path.dirname(os.path.abspath( __file__)) + '\\projection\\Cylindrical_Equal_Area_world.prj' ARCPY.Project_management(input_file, reprojected, projection) area_shapefile = workspace + '\\Area_Shapefile.shp' ARCPY.CalculateAreas_stats(reprojected, area_shapefile) rows = ARCPY.SearchCursor(area_shapefile) for row in rows: original_sum += row.AREA final_sum += (row.F_AREA / 1000000) ARCPY.Delete_management( reprojected) # Delete multi-part .shp part results. ARCPY.Delete_management( area_shapefile) # Delete Area Statistics .shp part results. return [str(original_sum), str(final_sum), str(original_sum - final_sum)]
def filter_polygon(state, extract_comb): poly_1 = constants.out_dir + os.sep + state + os.sep + 'poly_1.shp' poly_2 = constants.out_dir + os.sep + state + os.sep + 'poly_2.shp' arcpy.RasterToPolygon_conversion(extract_comb, poly_1, "NO_SIMPLIFY", "VALUE") arcpy.CalculateAreas_stats(poly_1, poly_2)
def Read_Attribute_Table_To_EXCEL(featureClass, hotorcold): ''' To write the attribute table of feature class into excel file :param featureClass: feature class name of input :param hotorcold: select hot or cold spot analysis :return: ''' arcpy.CalculateAreas_stats(featureClass, featureClass + "Area") rows = arcpy.da.SearchCursor(featureClass + "Area", ['name', 'F_AREA']) wb = xlwt.Workbook() ws = wb.add_sheet(hotorcold) ws.write(0, 0, featureClass + "Area") ws.write(1, 0, "Area") r = 1 sum = 0 for row in rows: ws.write(0, r, row[0].encode('utf-8')) ws.write(1, r, row[1]) sum += row[1] r += 1 ws.write(0, r, "SUM") ws.write(1, r, sum) wb.save(hotorcold + '.xls') if arcpy.Exists(featureClass + "Area"): arcpy.Delete_management(featureClass + "Area") print("Complete reading name and area to excel file!")
def check_area(input_file, workspace): """check the area values and make sure they are reasonable.""" from utilities.projection import cylindrical_equal_area original_sum = 0 final_sum = 0 # Project to Equal Area reprojected = workspace + '\\Reproject.shp' arcpy.Project_management(input_file, reprojected, cylindrical_equal_area()) area_shapefile = workspace + '\\Area_Shapefile.shp' arcpy.CalculateAreas_stats(reprojected, area_shapefile) rows = arcpy.SearchCursor(area_shapefile) for row in rows: original_sum += row.AREA final_sum += (row.F_AREA / 1000000) arcpy.Delete_management( reprojected) # Delete multi-part .shp part results. arcpy.Delete_management( area_shapefile) # Delete Area Statistics .shp part results. return [str(original_sum), str(final_sum), str(original_sum - final_sum)]
def mu_maker(self, h_raster, u_raster, full_out_ras_name, full_out_shp_name, *mu): # h_raster: STR - full path to depth raster # u_raster: STR - full path to velocity raster # full_out_ras_name: STR - full path of the results raster name # full_out_shp_name: STR - full path of the result shapefile name # mu = LIST(STR) - (optional) - restricts analysis to a list of morphological units according to mu.xlsx # start with raster calculations self.logger.info("Raster Processing --- --- ") self.license_state = arcpy.CheckOutExtension( 'Spatial') # check out license arcpy.gp.overwriteOutput = True arcpy.env.workspace = self.path arcpy.env.extent = "MAXOF" try: self.mu_names = mu[ 0] # limit mu analysis to optional list, if provided except: pass out_ras = self.calculate_mu(h_raster, u_raster) try: self.logger.info(" > Saving Raster ...") out_ras.save(full_out_ras_name) self.logger.info(" * OK") except: self.logger.info("ERROR: Could not save MU raster.") arcpy.CheckInExtension('Spatial') # release license self.logger.info("Raster Processing OK --- \n") self.logger.info("Shapefile Processing --- --- ") self.logger.info(" > Converting mu raster to shapefile ...") temporary_shp = full_out_shp_name.split(".shp")[0] + "1.shp" arcpy.RasterToPolygon_conversion(arcpy.Raster(full_out_ras_name), temporary_shp, 'NO_SIMPLIFY') self.logger.info(" > Calculating Polygon areas ...") arcpy.CalculateAreas_stats(temporary_shp, full_out_shp_name) self.logger.info(" * OK - Removing remainders ...") arcpy.Delete_management(temporary_shp) self.logger.info(" > Adding MU field ...") arcpy.AddField_management(full_out_shp_name, "MorphUnit", "TEXT", field_length=50) expression = "the_dict[!gridcode!]" codeblock = "the_dict = " + str( dict( zip(self.mu_names_number.values(), self.mu_names_number.keys()))) arcpy.CalculateField_management(full_out_shp_name, "MorphUnit", expression, "PYTHON", codeblock) self.logger.info("Shapefile Processing OK --- ")
def get_area(feature_class): '''returns the total area of a feature class''' temp_fc = generate_gdb_filename(return_full=True) arcpy.CalculateAreas_stats(feature_class, temp_fc) area_field = "F_AREA" # this is hardcoded, but now guaranteed because it is added to a copy and the field is updated if it already exists area_curs = arcpy.SearchCursor(temp_fc) total_area = 0 for row in area_curs: total_area += row.getValue(area_field) del row del area_curs return total_area
def raster_to_polygon (feature, raster, workspace, raster_scaling = 1000): """Convert raster to a features class, clip it to an input feature and calculate the area of each polygon. This new feature class is then returned for calculating statistics. """ # Scale the subset DEM and temporarily save it to file. If it is not # saved an error is sometimes thrown when converting to polygon. # This is no good reason for this VAT error. rand_id = str(random.randrange(10000, 999999)) subset_name = workspace + '\\raster_to_poly_' + rand_id + '.img' subset = spatial.Int(spatial.Raster(raster) * raster_scaling + 0.5) subset.save(subset_name) polygon = ARCPY.RasterToPolygon_conversion(subset, subset_name, "NO_SIMPLIFY") clipped = ARCPY.Clip_analysis(polygon, feature.shape, 'in_memory\\clip_' + rand_id) feature = ARCPY.CalculateAreas_stats(clipped, 'in_memory\\area_'+ rand_id) ARCPY.Delete_management(subset) ARCPY.Delete_management(polygon) ARCPY.Delete_management(clipped) return feature
sys.exit() if Want_CloudRemoval != 'True': mask_dir = os.makedirs(workspace + 'empty') import DebrisMap DebrisMap.DebrisMap(workspace, data_dir, landsat, shp_dir, mask_dir, A_remove, A_fill, Want_CloudRemoval) finddeb = arcpy.ListFeatureClasses('*MERGED*') debarea = workspace + finddeb[0] del finddeb if Want_CloudRemoval != 'True': del mask_dir arcpy.Delete_management(workspace + 'empty') ##----------------------------------------- CliffProcessingSegments ------------------------------------------------ arcpy.CalculateAreas_stats(debarea, 'debareaMeters.shp') rows = arcpy.SearchCursor('debareaMeters.shp') for row in rows: debarea_m2 = row.getValue("F_AREA") del row, rows arcpy.Delete_management('debareaMeters.shp') workspaceSplit = workspace.split("\\")[-2] workspace = workspace[:-workspaceSplit.count('')] workspace = workspace + 'CliffProcessingSegments\\' fishnetRes = L_t #name follows Herreid and Pellicciotti, 2018 lookDistance = n_c #name follows Herreid and Pellicciotti, 2018 try: os.makedirs(workspace) env.workspace = workspace except: print "Cliff segmentation workspace cannot be created. It may already exist."
def glacier_debris(band_4, band_5, glacier_outline, out_dir): print 'Running glacier_debris' if Want_CloudRemoval == 'True': outExtractByMask = ExtractByMask( band_4, mask_dir + '\\' + band_4.split('\\')[-1].split('_b')[0][0:16] + band_4.split('\\')[-1].split('_b')[0][17:21] + 'mask.shp') outExtractByMask.save('del_nodatagone4.TIF') outExtractByMask = ExtractByMask( band_5, mask_dir + '\\' + band_4.split('\\')[-1].split('_b')[0][0:16] + band_4.split('\\')[-1].split('_b')[0][17:21] + 'mask.shp') outExtractByMask.save('del_nodatagone5.TIF') outExtractByMask = ExtractByMask('del_nodatagone4.TIF', glacier_outline) outExtractByMask.save('del_mask4.TIF') outExtractByMask = ExtractByMask('del_nodatagone5.TIF', glacier_outline) outExtractByMask.save('del_mask5.TIF') print 'extract' else: outExtractByMask = ExtractByMask(band_4, glacier_outline) outExtractByMask.save('del_mask4.TIF') outExtractByMask = ExtractByMask(band_5, glacier_outline) outExtractByMask.save('del_mask5.TIF') print 'extract' #Convert Raster to float for decimal threshold values arcpy.RasterToFloat_conversion('del_mask4.TIF', 'del_band_4a.flt') arcpy.RasterToFloat_conversion('del_mask5.TIF', 'del_band_5a.flt') arcpy.Divide_3d('del_band_4a.flt', 'del_band_5a.flt', 'del_division.TIF') print 'division' outSetNull = SetNull('del_division.TIF', 'del_division.TIF', 'VALUE > ' + str(threshold)) #path to results folder, for loops add a counter if images are from the same year and day result_name = glacier_outline.split('.shp')[0].split( '\\' )[-1] + '_' + band_4.split('\\')[-1][9:13] + 'y' + band_4.split( '\\')[-1][13:16] + 'd' + '_L' + band_4.split( '\\')[-1][2:3] + '_' + Lband.split('_')[-1][1:2] + Hband.split( '_')[-1][1:2] + 'b' + str(int( threshold * 100)) + 't' + str(A_remove) + 'r' + str(A_fill) + 'f' result_path = out_dir + glacier_outline.split('.shp')[0].split( '\\' )[-1] + '_' + band_4.split('\\')[-1][9:13] + 'y' + band_4.split( '\\')[-1][13:16] + 'd' + '_L' + band_4.split( '\\')[-1][2:3] + '_' + Lband.split('_')[-1][1:2] + Hband.split( '_')[-1][1:2] + 'b' + str(int( threshold * 100)) + 't' + str(A_remove) + 'r' + str(A_fill) + 'f' if str(result_name + '1.shp' in os.listdir(out_dir)) == 'True': result_path = result_path + '2' elif str(result_name + '2.shp' in os.listdir(out_dir)) == 'True': result_path = result_path + '3' elif str(result_name + '3.shp' in os.listdir(out_dir)) == 'True': result_path = result_path + '4' elif str(result_name + '4.shp' in os.listdir(out_dir)) == 'True': result_path = result_path + '5' elif str(result_name + '5.shp' in os.listdir(out_dir)) == 'True': result_path = result_path + '6' else: result_path = result_path + '1' result_file = result_path + '.TIF' print 'result file: ' + result_file outSetNull.save(result_file) print 'Level 1 product produced' #Float raster to integer outInt = Int(result_file) outInt.save('del_result_file_int.TIF') # Set local variables inRaster = 'del_result_file_int.TIF' outPolygons = 'del_debris.shp' field = 'VALUE' arcpy.RasterToPolygon_conversion(inRaster, outPolygons, 'NO_SIMPLIFY', field) print 'to polygon' #Process: Dissolve. need to create "value" row where all elements=0 arcpy.AddField_management('del_debris.shp', 'value', 'SHORT', 1, '', '', '', '', '') arcpy.Dissolve_management('del_debris.shp', 'del_debris_dissolve.shp', 'value') print 'dissolve' # Run the tool to create a new fc with only singlepart features arcpy.MultipartToSinglepart_management('del_debris_dissolve.shp', 'del_explode.shp') print 'explode' # Process: Calculate polygon area (km2) arcpy.CalculateAreas_stats('del_explode.shp', 'del_area.shp') arcpy.MakeFeatureLayer_management('del_area.shp', 'tempLayer') # Execute SelectLayerByAttribute to determine which features to delete expression = 'F_AREA <=' + str(A_remove) # m2 arcpy.SelectLayerByAttribute_management('tempLayer', 'NEW_SELECTION', expression) arcpy.DeleteFeatures_management('tempLayer') print 'Shapes with an area <= ' + str( A_remove) + ' m2 removed; ' + str( A_remove / 900) + ' pixles, if 30m pixels' #Delete polygons < xx m2 arcpy.Delete_management('tempLayer') print 'tempLayer deleted' result_file2 = result_path + '.shp' print 'Level 2 result file: ' + result_file2 #Process: aggrigate (distance=1 m minimum area=0 minimum hole size=xx m: ) CA.AggregatePolygons('del_area.shp', result_file2, 1, 0, A_fill, 'NON_ORTHOGONAL') print 'holes with an area <= ' + str( A_fill) + ' m2 filled/merged with debris polygon; ' + str( A_fill / 900) + ' pixles, if 30m pixels' rasterList = arcpy.ListRasters('*del*') for raster in rasterList: arcpy.Delete_management(raster) fcList = arcpy.ListFeatureClasses('*del*') for fc in fcList: arcpy.Delete_management(fc) print 'intermediate files deleted' print 'level 2 product produced'
def connect_clusters(linkTable): # CUSTOM Fragment connecting code try: clusterFC = path.join( cfg.SCRATCHDIR, "Cores_Grouped_dist" + str(int(cfg.MAXEUCDIST)) + ".shp") arcpy.CopyFeatures_management(cfg.COREFC, clusterFC) gprint('Running custom fragment connecting code.') numLinks = linkTable.shape[0] cluster_ID = 'clus' + str(int(cfg.MAXEUCDIST)) if arcpy.ListFields(clusterFC, cluster_ID): arcpy.DeleteField_management(clusterFC, cluster_ID) arcpy.AddField_management(clusterFC, cluster_ID, "LONG") rows = arcpy.UpdateCursor(clusterFC) row = next(rows) while row: # linkCoords indices fragID = row.getValue(cfg.COREFN) row.setValue(cluster_ID, fragID) rows.UpdateRow(row) row = next(rows) del row, rows linkTable[:, cfg.LTB_CLUST1] = linkTable[:, cfg.LTB_CORE1] linkTable[:, cfg.LTB_CLUST2] = linkTable[:, cfg.LTB_CORE2] #if frags less than cutoff set cluster_ID equal. for x in range(0, numLinks): gprint("link #" + str(x + 1)) # Set newfragmentID of 2nd fragment to that of frag 1 frag1ID = linkTable[x, cfg.LTB_CLUST1] frag2ID = linkTable[x, cfg.LTB_CLUST2] if frag1ID == frag2ID: continue eucDist = linkTable[x, cfg.LTB_EUCDIST] if eucDist < cfg.MAXEUCDIST: gprint("Joining fragments " + str(frag1ID) + " and " + str(frag2ID) + " separated by distance " + str(eucDist)) # update linktable to new fragment ID in cluster field rows = npy.where(linkTable[:, cfg.LTB_CLUST1] == frag2ID) linkTable[rows, cfg.LTB_CLUST1] = frag1ID rows = npy.where(linkTable[:, cfg.LTB_CLUST2] == frag2ID) linkTable[rows, cfg.LTB_CLUST2] = frag1ID del rows # update shapefile to new fragment ID in cluster_ID field rows = arcpy.UpdateCursor(clusterFC) row = next(rows) while row: if row.getValue(cluster_ID) == frag2ID: row.setValue(cluster_ID, frag1ID) rows.UpdateRow(row) row = next(rows) del row, rows gprint('Done Joining. Creating output shapefiles.') coreBaseName = path.splitext(path.basename(cfg.COREFC))[0] outputFN = coreBaseName + "_Cluster" + str(int( cfg.MAXEUCDIST)) + "_dissolve.shp" outputShapefile = path.join(cfg.SCRATCHDIR, outputFN) arcpy.Dissolve_management(clusterFC, outputShapefile, cluster_ID) outputFN = coreBaseName + "_Cluster" + str(int( cfg.MAXEUCDIST)) + "_dissolve_area.shp" coreFCWithArea = path.join(cfg.SCRATCHDIR, outputFN) arcpy.CalculateAreas_stats(outputShapefile, coreFCWithArea) outputFN = coreBaseName + "_Cluster" + str(int( cfg.MAXEUCDIST)) + ".shp" clusterFCFinal = path.join(cfg.PROJECTDIR, outputFN) arcpy.CopyFeatures_management(clusterFC, clusterFCFinal) # Update final core featureclass with cluster ID and area arcpy.AddField_management(clusterFCFinal, cluster_ID, "LONG") arcpy.AddField_management(clusterFCFinal, "clust_area", "DOUBLE") #run through rows- get cluster id, then get area from coreFCwitharea using searchcursor rows = arcpy.UpdateCursor(clusterFCFinal) row = next(rows) while row: # linkCoords indices clustID = row.getValue(cluster_ID) rows2 = arcpy.SearchCursor(coreFCWithArea) row2 = next(rows2) while row2: if row2.getValue(cluster_ID) == clustID: fArea = "F_AREA" clustArea = row2.getValue(fArea) break row2 = next(rows2) row.setValue("clust_area", clustArea) rows.UpdateRow(row) row = next(rows) del row, rows, row2, rows2 gprint('Cores with cluster ID and cluster area written to: ' + clusterFCFinal) outlinkTableFile = path.join(cfg.DATAPASSDIR, 'linktable_clusters.csv') gprint('Writing ' + outlinkTableFile) lu.write_link_table(linkTable, outlinkTableFile) ########################################################## except arcpy.ExecuteError: lu.dashline(1) gprint('****Failed in step 2. Details follow.****') lu.exit_with_geoproc_error(_SCRIPT_NAME) # Return any PYTHON or system specific errors except Exception: lu.dashline(1) gprint('****Failed in step 2. Details follow.****') lu.exit_with_python_error(_SCRIPT_NAME)
arcpy.CopyFeatures_management("SH_all_islands_dissolved by spp and island", 'sp_CH_data') #select species point data spp_pt_data = "%sSp_point_data2.shp" % (datadir) if os.path.exists(spp_pt_data): point_filtered = 1 #REMOVE LARGE POLYGONS BASED ON POINT DATA arcpy.MultipartToSinglepart_management( "sp_CH_data", "sp_CH_data_multi") #make each polygon a distinct feature n_original_polygons = arcpy.GetCount_management("sp_CH_data_multi") n_original_polygons = int(n_original_polygons[0]) arcpy.CalculateAreas_stats( "sp_CH_data_multi", "sp_CH_data_multi_w_area") #calc polygon areas #select only large polygons expr = '"F_AREA" > 1000000' #select polygons greater than 1 sq km arcpy.SelectLayerByAttribute_management("sp_CH_data_multi_w_area", "", expr) arcpy.CopyFeatures_management( "sp_CH_data_multi_w_area", "sp_CH_data_multi_w_area_large" ) #Save large polygons selected as separate layer arcpy.DeleteFeatures_management( "sp_CH_data_multi_w_area" ) #temporarily deletes large polygons from species distribution map #determine which large polygons have points in them arcpy.SelectLayerByLocation_management("sp_CH_data_multi_w_area_large", "INTERSECT", spp_pt_data, "", "")
x2 = fieldmappings.findFieldMapIndex("FID_xian2_") fieldmappings.removeFieldMap(x2) x3 = fieldmappings.findFieldMapIndex("Id") fieldmappings.removeFieldMap(x3) t5 = time.time() arcpy.SpatialJoin_analysis(to_polygon, id_features, spatial_join5, "#", "#", fieldmappings, "SHARE_A_LINE_SEGMENT_WITH") elapsed5 = (time.time()-t5) print("finish part 5------------------") print("time:",elapsed5) time.sleep(2) # 6 calculate out_calculate = "finally_areas.shp" t6 = time.time() try: # Process: Calculate Areas... arcpy.CalculateAreas_stats(spatial_join5, out_calculate) except: # If an error occurred when running the tool, print out the error message. print arcpy.GetMessages() elapsed6 = (time.time()-t6) print("finish part 6------------------") print("time:",elapsed6)
#Solve arcpy.na.Solve(Treatment_SA, "SKIP") #CHECK FOR ERRORS #Save Injection transformers which were restricted by existing transformers Injection_TX_restricted = arcpy.SelectData_management(Treatment_SA, "Facilities") Injection_TX_restricted = arcpy.SelectLayerByAttribute_management( Injection_TX_restricted, "NEW_SELECTION", '"Status"= 3') arcpy.MakeFeatureLayer_management(Injection_TX_restricted, "Injection_TX_restricted") #Export polygon layer Treatment_Polygons = arcpy.SelectData_management(Treatment_SA, "Polygons") Treatment_Polygons = Treatment_Polygons.getOutput(0) Treatment_Polygons_withArea = arcpy.CalculateAreas_stats( Treatment_Polygons, "Treatment_Polygons") #arcpy.MakeFeatureLayer_management(Treatment_Polygons_withArea,"Treatment_Polygons_Standard",'"F_AREA" >= 10000' ) arcpy.MakeFeatureLayer_management(Treatment_Polygons_withArea, "Treatment_Polygons_Small", '"F_AREA" <= 10000') ##T3## #It is possible that the resulting polygon from the previous step is <10,000 sq meters or #if an injection TX is completely engulfed in existing TX SA. #In this case, a new SA is drawn extending 150m from the injection TX in all possible directions. #This was the case with 3 treatment sites in Dansoman. if arcpy.management.GetCount('Treatment_Polygons_Small')[0] > "0": Injection_TX_Alt = arcpy.SelectLayerByLocation_management( Injection_TX, "INTERSECT", 'Treatment_Polygons_Small', "15 Meters")
#Aqui se crea una nueva capa de PARCELAS privadas y de DOMinioPUBlico #En la capa de DOMinioPUBlico se borran las entidades menores de 1m2 (basura) arcpy.Erase_analysis("RUSTICO\\PARCELA.shp", "URBANO\\PARCELA.shp", "AUXILIAR\\RECORTE.shp") arcpy.Merge_management(["URBANO\\PARCELA.shp", "AUXILIAR\\RECORTE.shp"], "AUXILIAR\\PARCELA_.shp") clause = "TIPO='X'" arcpy.Select_analysis("AUXILIAR\\PARCELA_.shp", "AUXILIAR\\DOMPUB_.shp", clause) arcpy.MultipartToSinglepart_management("AUXILIAR\\DOMPUB_.shp", "AUXILIAR\\DOMPUB_2.shp") arcpy.CalculateAreas_stats("AUXILIAR\\DOMPUB_2.shp", "AUXILIAR\\DOMPUB_3.shp") clause = "F_AREA > 1" arcpy.Select_analysis("AUXILIAR\\DOMPUB_3.shp", "AUXILIAR\\DOMPUB_4.shp", clause) arcpy.Dissolve_management("AUXILIAR\\DOMPUB_4.shp", "AUXILIAR\\DOMPUB_5.shp") arcpy.MultipartToSinglepart_management("AUXILIAR\\DOMPUB_5.shp", "DOMPUB") clause = "TIPO<>'X'" arcpy.Select_analysis("AUXILIAR\\PARCELA_.shp", "PARCELA.shp", clause) #EQUIVALENCIA A LA DESCRIPCION DE ALTURAS DEL CATASTRO #Existen tienen variaciones entre las categorias de alturas de los municipios arcpy.Merge_management(["URBANO\\CONSTRU.shp", "RUSTICO\\CONSTRU.shp"], "AUXILIAR\\CONSTRU_.shp") clause = "NUMSYMBOL <13"
import arcpy fc = arcpy.GetParameterAsText(0) fcout = arcpy.GetParameterAsText(1) arcpy.CalculateAreas_stats(fc, fcout) arcpy.AddMessage('-------------------') arcpy.AddMessage('Area in Sq Meters') arcpy.AddMessage('-------------------')
Existing_TX_Polygons_300m, "", "25 Meters") #Solve arcpy.na.Solve(Control_SA, "SKIP") #CHECK FOR ERRORS #Save Injection transformers which were restricted by existing transformers Control_restricted = arcpy.SelectData_management(Control_SA, "Facilities") Control_restricted = arcpy.SelectLayerByAttribute_management( Control_restricted, "NEW_SELECTION", '"Status"= 3') arcpy.MakeFeatureLayer_management(Control_restricted, "Control_restricted") #Calculate polycon areas Control_Polygons = arcpy.SelectData_management(Control_SA, "Polygons") Control_Polygons = Control_Polygons.getOutput(0) Control_Polygons_withArea = arcpy.CalculateAreas_stats(Control_Polygons, "Control_Polygons") #arcpy.MakeFeatureLayer_management(Control_Polygons_withArea,"Control_Polygons_Standard",'"F_AREA" >= 10000' ) arcpy.MakeFeatureLayer_management(Control_Polygons_withArea, "Control_Polygons_Small", '"F_AREA" <= 10000') if arcpy.management.GetCount('Control_Polygons_Small')[0] > "0": Control_Points_Alt = arcpy.SelectLayerByLocation_management( 'Control_Points', "INTERSECT", 'Control_Polygons_Small', "15 Meters") arcpy.MakeFeatureLayer_management(Control_Points_Alt, "Control_Points_Alt") #Injection_TX_Alt = Injection_TX_Alt.getOutput(0) Control_Alt_SA = arcpy.na.MakeServiceAreaLayer( network, district + "_Control_Alt_SA", "Length", "TRAVEL_FROM", "150", "DETAILED_POLYS", "NO_MERGE", "DISKS", "NO_LINES", "NON_OVERLAP", "NO_SPLIT", Feeders, "", "", "", "TRIM_POLYS", distance_from_line)
def execute(self, parameters, messages): """The source code of your tool.""" arcpy.env.overwriteOutput = True arcpy.AddMessage( "Species distribution patterns around islands, generate a grid for analysis" ) for param in parameters: arcpy.AddMessage("Parameter: %s = %s" % (param.name, param.valueAsText)) # See http://resources.arcgis.com/en/help/main/10.2/index.html#//018z00000063000000 input_line = parameters[0].valueAsText output_directory = parameters[1].valueAsText distance = parameters[2].value simp_distance = parameters[3].value points_distance = parameters[4].value clean_up = parameters[5].value # 0 Describe files to set coordinate systems desc_input = arcpy.Describe(input_line) coord_system = desc_input.spatialReference arcpy.env.outputCoordinateSystem = coord_system # 1 Make output director and output files they do not exist if not os.path.exists(output_directory): os.makedirs(output_directory) arcpy.env.workspace = output_directory # 2 Buffer at distance around line arcpy.Buffer_analysis( in_features=input_line, out_feature_class=os.path.join(output_directory, "buffer.shp"), buffer_distance_or_field=str(distance) + " Meters", line_side="FULL", line_end_type="ROUND", dissolve_option="NONE", dissolve_field="", method="PLANAR") # 3 Convert polygon to Line def polys_to_lines(fc, new_fc): # From http://gis.stackexchange.com/questions/129662/creating-lines-from-polygon-borders-with-polygon-attributes-using-arcgis-arcpy path, name = os.path.split(new_fc) sm = 'SAME_AS_TEMPLATE' arcpy.CreateFeatureclass_management(path, name, 'POLYLINE', fc, sm, sm, fc) fields = [ f.name for f in arcpy.ListFields(new_fc) if f.type not in ('OID', 'Geometry') ] # get attributes with arcpy.da.SearchCursor(fc, ['SHAPE@'] + fields) as rows: values = [(r[0].boundary(), ) + tuple(r[1:]) for r in rows] # insert rows with arcpy.da.InsertCursor(new_fc, ['SHAPE@'] + fields) as irows: for vals in values: irows.insertRow(vals) return new_fc polys_to_lines(os.path.join(output_directory, "buffer.shp"), os.path.join(output_directory, "lines.shp")) arcpy.MultipartToSinglepart_management( in_features=os.path.join(output_directory, "lines.shp"), out_feature_class=os.path.join(output_directory, "lines_explode.shp")) arcpy.SimplifyLine_cartography( in_features=os.path.join(output_directory, "lines_explode.shp"), out_feature_class=os.path.join(output_directory, "lines_explode_simplify.shp"), algorithm="BEND_SIMPLIFY", tolerance=str(simp_distance) + " Meters", error_resolving_option="FLAG_ERRORS", collapsed_point_option="KEEP_COLLAPSED_POINTS", error_checking_option="CHECK") # 4 Create points along the line arcpy.CreateFeatureclass_management(output_directory, "points_line.shp", 'POINT') arcpy.Project_management( in_dataset=os.path.join(output_directory, "lines_explode_simplify.shp"), out_dataset=os.path.join(output_directory, "lines_explode_simplify_proj.shp"), out_coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]", transform_method="", in_coor_system=coord_system, preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") arcpy.CreateFeatureclass_management(output_directory, "points_line_outer.shp", 'POINT') arcpy.CreateFeatureclass_management(output_directory, "points_line_inner.shp", 'POINT') def points_along_line(line_lyr, pnt_layer, pnt_dist, inn_out): # From https://geonet.esri.com/thread/95549 search_cursor = arcpy.da.SearchCursor(line_lyr, ['SHAPE@', 'FID']) insert_cursor = arcpy.da.InsertCursor(pnt_layer, 'SHAPE@') for row in search_cursor: if inn_out == "inner": if row[1] == 1: for dist in range(0, int(row[0].length), int(pnt_dist)): point = row[0].positionAlongLine(dist).firstPoint insert_cursor.insertRow([point]) elif inn_out == "outer": if row[1] == 0: for dist in range(0, int(row[0].length), int(pnt_dist)): point = row[0].positionAlongLine(dist).firstPoint insert_cursor.insertRow([point]) points_along_line( os.path.join(output_directory, "lines_explode_simplify_proj.shp"), os.path.join(output_directory, "points_line.shp"), points_distance, "inner") points_along_line( os.path.join(output_directory, "lines_explode_simplify_proj.shp"), os.path.join(output_directory, "points_line_outer.shp"), 1, "outer") points_along_line( os.path.join(output_directory, "lines_explode_simplify_proj.shp"), os.path.join(output_directory, "points_line_inner.shp"), 1, "inner") rows_list = [ row for row in arcpy.da.SearchCursor( os.path.join(output_directory, "points_line.shp"), "FID") ] delete_cursor = arcpy.da.UpdateCursor( os.path.join(output_directory, "points_line.shp"), "FID") delete_value = rows_list[-1][0] for row in delete_cursor: if row[0] == delete_value: delete_cursor.deleteRow() arcpy.DefineProjection_management( os.path.join(output_directory, "points_line.shp"), coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]" ) arcpy.DefineProjection_management( os.path.join(output_directory, "points_line_outer.shp"), coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]" ) arcpy.DefineProjection_management( os.path.join(output_directory, "points_line_inner.shp"), coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]" ) arcpy.Project_management( os.path.join(output_directory, "points_line.shp"), out_dataset=os.path.join(output_directory, "points_line_wgs.shp"), out_coor_system=coord_system, transform_method="", in_coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]", preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") def points_to_polygon_line(output_directory, points): sr = arcpy.Describe(os.path.join(output_directory, points)).spatialReference coords = np.array(list( list(x) for x in arcpy.da.FeatureClassToNumPyArray(os.path.join( output_directory, points), ["SHAPE@X", "SHAPE@Y"], "", sr, explode_to_points=True)), dtype="float64") arcpy.CreateFeatureclass_management(output_directory, "p2pl_li_" + points, "Polyline") arcpy.CreateFeatureclass_management(output_directory, "p2pl_pol_" + points, "Polygon") pnt = arcpy.Point() ary = arcpy.Array() cur = arcpy.InsertCursor( os.path.join(output_directory, "p2pl_pol_" + points)) for coord in coords: pnt.X = coord[0] pnt.Y = coord[1] ary.add(pnt) polygon = arcpy.Polygon(ary) feat = cur.newRow() feat.shape = polygon cur.insertRow(feat) del cur, pnt, ary, coord, polygon, feat pnt = arcpy.Point() ary = arcpy.Array() cur = arcpy.InsertCursor( os.path.join(output_directory, "p2pl_li_" + points)) for coord in coords: pnt.X = coord[0] pnt.Y = coord[1] ary.add(pnt) line = arcpy.Polyline(ary) feat = cur.newRow() feat.shape = line cur.insertRow(feat) del cur, pnt, ary, coord, line, feat arcpy.DefineProjection_management( os.path.join(output_directory, "p2pl_li_" + points), coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]" ) arcpy.DefineProjection_management( os.path.join(output_directory, "p2pl_pol_" + points), coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]" ) return points_to_polygon_line(output_directory, "points_line_inner.shp") points_to_polygon_line(output_directory, "points_line_outer.shp") # 5 Generate perpendicular lines desc = arcpy.Describe(os.path.join(output_directory, "points_line.shp")) sr = arcpy.SpatialReference(desc.spatialReference.factoryCode) dests = np.array(list( list(x) for x in arcpy.da.FeatureClassToNumPyArray( os.path.join(output_directory, "points_line_outer.shp"), ["SHAPE@X", "SHAPE@Y"], "", sr, True)), dtype="float64") arcpy.CreateFeatureclass_management(output_directory, "intersect_lines.shp", "Polyline") search_cursor = arcpy.da.SearchCursor( os.path.join(output_directory, "points_line.shp"), ['SHAPE@X', 'SHAPE@Y']) for row in search_cursor: origin = np.array((row[0], row[1]), dtype="float64") deltas = dests - origin distances = np.hypot(deltas[:, 0], deltas[:, 1]) min_dist = np.min(distances) wh = np.where(distances == min_dist) closest = dests[wh[0]] cur = arcpy.InsertCursor( os.path.join(output_directory, "intersect_lines.shp")) # Build array of start/ends line_array = arcpy.Array() # start point start = arcpy.Point() (start.ID, start.X, start.Y) = (1, origin.item( (0)), origin.item((1))) line_array.add(start) # end point end = arcpy.Point() (end.ID, end.X, end.Y) = (2, closest.item( (0, 0)), closest.item((0, 1))) line_array.add(end) # write our fancy feature to the shapefile feat = cur.newRow() feat.shape = line_array cur.insertRow(feat) # yes, this shouldn't really be necessary... line_array.removeAll() del origin arcpy.DefineProjection_management( os.path.join(output_directory, "intersect_lines.shp"), coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]" ) arcpy.Union_analysis(in_features=[ os.path.join(output_directory, "p2pl_pol_points_line_inner.shp"), os.path.join(output_directory, "p2pl_pol_points_line_outer.shp") ], out_feature_class=os.path.join( output_directory, "simplified_polygon.shp"), join_attributes="ALL", cluster_tolerance="", gaps="GAPS") with arcpy.da.UpdateCursor( os.path.join(output_directory, "simplified_polygon.shp"), "FID") as cursor: for row in cursor: if row[0] == 1: cursor.deleteRow() arcpy.Buffer_analysis(in_features=os.path.join(output_directory, "intersect_lines.shp"), out_feature_class=os.path.join( output_directory, "intersect_lines_buf.shp"), buffer_distance_or_field="1 Centimeters", line_side="FULL", line_end_type="ROUND", dissolve_option="NONE", dissolve_field="", method="PLANAR") arcpy.Union_analysis(in_features=[ os.path.join(output_directory, "intersect_lines_buf.shp"), os.path.join(output_directory, "simplified_polygon.shp") ], out_feature_class=os.path.join( output_directory, "intersect_lines_buffered_polygon.shp"), join_attributes="ALL", cluster_tolerance="", gaps="GAPS") arcpy.Project_management( os.path.join(output_directory, "intersect_lines_buffered_polygon.shp"), out_dataset=os.path.join( output_directory, "intersect_lines_buffered_polygon_proj.shp"), out_coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]", transform_method="", in_coor_system=coord_system, preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") arcpy.CalculateAreas_stats( Input_Feature_Class=os.path.join( output_directory, "intersect_lines_buffered_polygon_proj.shp"), Output_Feature_Class=os.path.join( output_directory, "intersect_lines_buffered_polygon_areas.shp")) polygon_sizes = [] with arcpy.da.SearchCursor( os.path.join(output_directory, "intersect_lines_buffered_polygon_areas.shp"), "F_Area") as cursor: for row in cursor: polygon_sizes.append(int(row[0])) polygon_sizes = sorted(polygon_sizes, key=int, reverse=True) with arcpy.da.UpdateCursor( os.path.join(output_directory, "intersect_lines_buffered_polygon_areas.shp"), "F_Area") as cursor: for row in cursor: if int(row[0]) == int(polygon_sizes[0]): pass else: cursor.deleteRow() arcpy.MultipartToSinglepart_management(in_features=os.path.join( output_directory, "intersect_lines_buffered_polygon_areas.shp"), out_feature_class=os.path.join( output_directory, "grid_file1.shp")) arcpy.Project_management( os.path.join(output_directory, "grid_file1.shp"), out_dataset=os.path.join(output_directory, "grid_file.shp"), out_coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]", transform_method="", in_coor_system=coord_system, preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") arcpy.AddField_management(in_table=os.path.join( output_directory, "grid_file.shp"), field_name="GRID_ID", field_type="LONG", field_precision="", field_scale="", field_length="", field_alias="", field_is_nullable="NULLABLE", field_is_required="NON_REQUIRED", field_domain="") with arcpy.da.UpdateCursor( os.path.join(output_directory, "grid_file.shp"), ["FID", "GRID_ID"]) as cursor: for row in cursor: row[1] = row[0] cursor.updateRow(row) arcpy.Project_management( os.path.join(output_directory, "grid_file.shp"), out_dataset=os.path.join(output_directory, "grid_file_wgs.shp"), out_coor_system=coord_system, transform_method="", in_coor_system= "PROJCS['World_Mercator',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Mercator'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],PARAMETER['Standard_Parallel_1',0.0],UNIT['Meter',1.0]]", preserve_shape="NO_PRESERVE_SHAPE", max_deviation="", vertical="NO_VERTICAL") arcpy.AddWarning( "The field name GRID_ID will likely not be sequential, and you will have to fix manually." ) arcpy.AddMessage( "After fixing the non-sequentially spaced names, you will have to manually join " "the layer back to the original point observations.") if clean_up: delete_list = [ os.path.join(output_directory, "buffer.shp"), os.path.join(output_directory, "lines.shp"), os.path.join(output_directory, "lines_explode.shp"), os.path.join(output_directory, "lines_explode_simplify.shp"), os.path.join(output_directory, "lines_explode_simplify_Pnt.shp"), os.path.join(output_directory, "intersect_lines_buffered_polygon_areas.shp"), os.path.join(output_directory, "intersect_lines_buffered_polygon_proj.shp"), os.path.join(output_directory, "lines_explode_simplify_proj.shp"), os.path.join(output_directory, "p2pl_li_points_line_inner.shp"), os.path.join(output_directory, "p2pl_li_points_line_outer.shp"), os.path.join(output_directory, "p2pl_pol_points_line_inner.shp"), os.path.join(output_directory, "p2pl_pol_points_line_outer.shp"), os.path.join(output_directory, "points_line.shp"), os.path.join(output_directory, "points_line_inner.shp"), os.path.join(output_directory, "points_line_outer.shp"), os.path.join(output_directory, "points_line_wgs.shp"), os.path.join(output_directory, "simplified_polygon.shp"), os.path.join(output_directory, "grid_file1.shp"), os.path.join(output_directory, "intersect_lines.shp"), os.path.join(output_directory, "intersect_lines_buf.shp"), os.path.join(output_directory, "intersect_lines_buffered_polygon.shp"), ] for i in delete_list: arcpy.Delete_management(i) return
distanceField = "%s Meters" % (list_buffer_distance_m / 2) sideType = "" endType = "" dissolveType = "NONE" dissolveField = "" arcpy.Buffer_analysis(islands_infested, eradication_zone_temp, distanceField, sideType, endType, dissolveType, dissolveField) #Disssolve group_dissolve(eradication_zone_temp, eradication_zone, 80, path_process) # Calculate area for the visual buffer and clean up arcpy.Delete_management(eradication_zone_temp) arcpy.CalculateAreas_stats(eradication_zone, eradication_zone_temp) arcpy.Delete_management(eradication_zone) arcpy.Copy_management(eradication_zone_temp, eradication_zone) arcpy.Delete_management(eradication_zone_temp) arcpy.DefineProjection_management(eradication_zone, file_projection) # Add some fields for the visual buffer: # - index number arcpy.AddField_management(eradication_zone, "z_nr", "LONG", "9", "", "", "z_nr", "NULLABLE", "REQUIRED") # - Zone area (area covered by this zone arcpy.AddField_management(eradication_zone, "z_area", "FLOAT", "12", "", "", "z_area", "NULLABLE", "REQUIRED") # - Total islands in zone
fin = mapping.Layer(r"fin") mapping.InsertLayer(df, refLayer, fin, "BEFORE") #--------------------------------------To extrate suitalbe reginons' area in China----------------------------------------# # Execute SelectLayerByAttribute arcpy.SelectLayerByAttribute_management("fin", "NEW_SELECTION", "\"VALUE\" =0") # Execute RasterToPolygon arcpy.RasterToPolygon_conversion("fin", "zones.shp", "NO_SIMPLIFY", "value") # Execute IntersectAnalysis arcpy.Intersect_analysis(["zones.shp", input1], "Intersect", "ALL", "", "") # Execute ConversationReference arcpy.DefineProjection_management( "Intersect.shp", "PROJCS['Sphere_Aitoff',GEOGCS['GCS_Sphere',DATUM['D_Sphere',SPHEROID['Sphere',6371000.0,0.0]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Aitoff'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],UNIT['Meter',1.0]]" ) # Execute AddFileld arcpy.CalculateAreas_stats("Intersect.shp", "IntersectAreaField.shp") # Execute CountAreas arcpy.Statistics_analysis("IntersectAreaField.shp", "CountAreas1", [["F_AREA", "SUM"]], "PYNAME") #-------------------------------------To extrate suitalbe reginons' area across the globle--------------------------------# # Execute IntersectAnalysis arcpy.Intersect_analysis(["zones.shp", input2], "Intersect1", "ALL", "", "") # Execute ConversationReference arcpy.DefineProjection_management( "Intersect1.shp", "PROJCS['Sphere_Aitoff',GEOGCS['GCS_Sphere',DATUM['D_Sphere',SPHEROID['Sphere',6371000.0,0.0]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Aitoff'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],UNIT['Meter',1.0]]" ) # Execute AddFileld arcpy.CalculateAreas_stats("Intersect1.shp", "IntersectAreaField1.shp") # Execute CountAreas arcpy.Statistics_analysis("IntersectAreaField1.shp", "CountAreas2",
print " End time is", str(datetime.datetime.now()) print " Reprojecting {} loss area to World Eckert IV".format(year) print " Start time is", str(datetime.datetime.now()) out_coordinate_system = "PROJCS['World_Eckert_IV',GEOGCS['GCS_WGS_1984',DATUM['D_WGS_1984',SPHEROID['WGS_1984',6378137.0,298.257223563]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Eckert_IV'],PARAMETER['False_Easting',0.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',0.0],UNIT['Meter',1.0]]" arcpy.Project_management( legal_loss_year_PRODES_noFire_neighbor_shp_dissolve, legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj, out_coor_system=out_coordinate_system, transform_method="") print " End time is", str(datetime.datetime.now()) print " Calculating feature areas" print " Start time is", str(datetime.datetime.now()) arcpy.CalculateAreas_stats( legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj, legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj_areas) print " End time is", str(datetime.datetime.now()) # Keeps only the features that are larger than 6.25 ha (Brazil exclusion criteria 4) print " Selecting features larger than 6.25 ha" print " Start time is", str(datetime.datetime.now()) where = "F_AREA > 62500" arcpy.MakeFeatureLayer_management( legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj_areas, "layer_{}".format(year), where_clause=where) arcpy.CopyFeatures_management( "layer_{}".format(year), legal_loss_year_PRODES_noFire_neighbor_shp_dissolve_reproj_areas_large )
#Create temporary directory and define temporary files os.mkdir(temp_dir) buffer_shp = os.path.join(temp_dir, 'BUFFER.shp') intersect_shp = os.path.join(temp_dir, 'INTERSECTED.shp') area_shp = os.path.join(temp_dir, 'AREA.shp') try: arcpy.AddMessage('Creating Temporary Shapefiles') if arcpy.ProductInfo() == 'ArcInfo': arcpy.Buffer_analysis(route_file, buffer_shp, assumed_lane_width, dissolve_option = 'ALL', line_side = 'RIGHT', line_end_type = 'FLAT') else: arcpy.AddMessage('WARNING: Results will be more accurate with ArcInfo license') arcpy.Buffer_analysis(route_file, buffer_shp, assumed_lane_width, dissolve_option = 'ALL') arcpy.Intersect_analysis([polygon_file, buffer_shp], intersect_shp) arcpy.CalculateAreas_stats(intersect_shp, area_shp) arcpy.AddMessage('Approximating Stops By Polygon') stops = {} polygons = arcpy.da.SearchCursor(area_shp, field_names = [id_field, 'F_AREA']) for polygon in polygons: if polygon[0] not in stops: stops[polygon[0]] = 0 stops[polygon[0]] += polygon[1] / (lane_width * spacing) del polygons arcpy.AddMessage('Adding Approximate Number of Stops to Polygon File') if new_field in [field.name for field in arcpy.ListFields(polygon_file)]: arcpy.DeleteField_management(polygon_file, new_field) if return_integer: arcpy.AddField_management(polygon_file, new_field, 'LONG')
# Execute Reclassify outReclassify2 = Reclassify(inRaster2, reclassField, remap, "NODATA") # Save the output outReclassify1.save(inRaster4) # Execute RasterToPolygon arcpy.RasterToPolygon_conversion(inRaster3, before, "NO_SIMPLIFY", field) arcpy.RasterToPolygon_conversion(inRaster4, after, "NO_SIMPLIFY", field) xyTol = "1 Meters" arcpy.Erase_analysis(after, before, eraseOutput, xyTol) # Process: Calculate Areas... arcpy.CalculateAreas_stats(eraseOutput, calculate_output) # # Execute Select # arcpy.Select_analysis(in_features, out_feature_class, where_clause) # # Create a new fieldmappings and add the two input feature classes. # fieldmappings = arcpy.FieldMappings() # fieldmappings.addTable(targetFeatures) # fieldmappings.addTable(joinFeatures) # # First get the POP1990 fieldmap. POP1990 is a field in the cities feature class. # # The output will have the states with the attributes of the cities. Setting the # # field's merge rule to mean will aggregate the values for all of the cities for # # each state into an average value. The field is also renamed to be more appropriate # # for the output. # pop1990FieldIndex = fieldmappings.findFieldMapIndex("F_AREA")
def ExtractRange(outRaster, outFilePath, file): inSQLClause = "VALUE > 0" try: # Execute ExtractByAttributes attExtract = arcpy.sa.ExtractByAttributes(outRaster, inSQLClause) print('87') sys.stdout.flush() # Save the output #attExtract.save("F:\\ree\\PM25T08.tif") rasfile = os.path.split(outRaster)[1] in_point_features = os.path.join(file, u"RasterToPoint_conversion.shp") out_feature_class = os.path.join(file, u"AggregatePoints_cartography.shp") out_SmoothPolygon_class = os.path.join(file, u"out_SmoothPolygon_class.shp") calculate_output = os.path.join(file, u"calculate_output.shp") try: arcpy.RasterToPoint_conversion(attExtract, in_point_features, "VALUE") except: pass try: arcpy.AggregatePoints_cartography(in_point_features, out_feature_class, 30) except: pass try: arcpy.SmoothPolygon_cartography(out_feature_class, out_SmoothPolygon_class, 'PAEK', 30) except: pass try: # Process: Calculate Areas... arcpy.CalculateAreas_stats(out_SmoothPolygon_class, calculate_output) except: # If an error occurred when running the tool, print out the error message. traceback.print_exc() try: arcpy.Delete_management(in_point_features) except: traceback.print_exc() try: arcpy.DeleteFeatures_management(out_SmoothPolygon_class) except: traceback.print_exc() try: arcpy.DeleteFeatures_management(out_feature_class) except: traceback.print_exc() try: arcpy.Delete_management(out_feature_class) except: traceback.print_exc() try: arcpy.Delete_management(out_SmoothPolygon_class) except: traceback.print_exc() except Exception as err: arcpy.AddMessage("ExtractByAttributes Failed") arcpy.AddMessage(err) traceback.print_exc() return
#%% # CLIP TO STATES in_features = "//Intermediates//Census_Station_P3_Nowater.shp" clip_features = "//Boundary Files//States_equidistant.shp" out_feature_class = "//Intermediates//Census_Station_Clip3.shp" xy_tolerance = "" # Execute Clip arcpy.Clip_analysis(in_features, clip_features, out_feature_class, xy_tolerance) #%% # FIGURE OUT WEIGHTING SCHEME BASED ON AREA arcpy.CalculateAreas_stats("//Intermediates//Census_Station_Clip3.shp", "//Output//Census_Station_"+record_length+"_"+missing+".shp") #arcpy.Delete_management("in_memory","") #%% #switching over to R now to read the .dbf and find weighted mean #%% # UNION OF STATES AND THEISSEN POLYGONS # LINK STATION POLYGONS TO CENSUS
# Process: Polygon to Raster (2) arcpy.PolygonToRaster_conversion(lu_01, "LANDUSE", lu_2001, "CELL_CENTER", "NONE", "10") # Process: Reclassify (2) arcpy.gp.Reclassify_sa( lu_2001, "LANDUSE", "1420 7;4300 3;1320 6;1222 5;1440 7;1240 10;1110 1;1330 6;1231 5;1232 5;1540 8;1520 8;1430 7;1310 6;1223 5;1130 2;1350 6;4110 3;1530 8;3100 10;1370 6;1360 6;1212 5;1560 8;4220 3;1250 5;3500 10;1511 8;5200 11;4210 3;1512 8;5100 11;3200 10;1340 6;3600 10;1120 3;3300 10;1550 8;1211 5;4120 3;1410 7;5300 11;1140 3;3400 10;2100 9", Reclass_lu_01, "DATA") # Process: Raster to Polygon (2) arcpy.RasterToPolygon_conversion(Reclass_lu_01, lu2001_recl_shp, "SIMPLIFY", "LANDUSE") # Process: Calculate Areas (2) arcpy.CalculateAreas_stats(lu2001_recl_shp, lu2001_recl_a_shp) # Process: Polygon to Raster (3) arcpy.PolygonToRaster_conversion(lu_2005, "LANDUSE", lu_2005__3_, "CELL_CENTER", "NONE", "10") # Process: Reclassify (3) arcpy.gp.Reclassify_sa( lu_2005__3_, "LANDUSE", "1420 7;4300 3;1320 6;1222 5;1440 7;1240 10;1110 1;1330 6;1231 5;1232 5;1540 8;1520 8;1430 7;1310 6;1223 5;1130 2;1350 6;4110 3;1530 8;3100 10;1370 6;1360 6;1212 5;1560 8;4220 3;1250 5;3500 10;1511 8;5200 11;4210 3;1512 8;5100 11;3200 10;1340 6;3600 10;1120 3;3300 10;1550 8;1211 5;4120 3;1410 7;5300 11;1140 3;3400 10;2100 9", Reclass_lu_05, "DATA") # Process: Raster to Polygon (3) arcpy.RasterToPolygon_conversion(Reclass_lu_05, lu2005_recl_shp, "SIMPLIFY", "LANDUSE")
import arcpy arcpy.env.workspace = r'C:\Users\Luis\Downloads\nhn_rhn_05ck000_shp_en' arcpy.CalculateAreas_stats('NHN_05CK000_1_0_HD_WATERBODY_2.shp','areaWaterbody.shp')
def CalShpArea(inshp, outshp, isprint): arcpy.CalculateAreas_stats(inshp, outshp) if isprint: print('CalShpArea is finished....')
def main(*args): #Read in inputs from_shp_file = args[0] from_field = args[1] to_shp_file = args[2] to_field = args[3] outfile = args[4] show_matrix = args[5] remove_temp_if_successful = args[6] remove_temp_if_error = args[7] if from_field == to_field: to_field += '_1' #Check if the outfile is specified as a csv file. If it isn't, do so. if outfile[-4:] != '.csv': outfile += '.csv' #Create temporary directory temp_dir = r'C:\TEMP' os.mkdir(temp_dir) temp_shp = os.path.join(temp_dir, 'TEMP.shp') from_shp = os.path.join(temp_dir, 'FROM.shp') to_shp = os.path.join(temp_dir, 'TO.shp') #Copy input shapefiles into temporary directory arcpy.CopyFeatures_management(from_shp_file, from_shp) arcpy.CopyFeatures_management(to_shp_file, to_shp) #Process the data. If an error occurs, the temporary directory will be deleted, and then the exception will be raised try: #Intersect the two shapefiles and calculate the area of the intersected shapefile arcpy.Intersect_analysis([from_shp, to_shp], temp_shp) temp2_shp = temp_shp.replace('.shp', '2.shp') arcpy.CalculateAreas_stats(temp_shp, temp2_shp) #Create a list of all of the origin and destination polygons from_list = [] to_list = [] polygons = arcpy.da.SearchCursor(temp_shp, [from_field, to_field]) for polygon in polygons: from_list += [polygon[0]] to_list += [polygon[1]] del polygons from_codes = pd.Series(from_list).value_counts().index to_codes = pd.Series(to_list).value_counts().index #Create matrix with total area of each intersected polygon, arranged by the from polygon and to polygon areas = pd.DataFrame(np.zeros((len(to_codes), len(from_codes))), index=to_codes, columns=from_codes) polygons = arcpy.da.SearchCursor(temp2_shp, [from_field, to_field, 'F_AREA']) for polygon in polygons: areas.loc[polygon[1], polygon[0]] = polygon[2] del polygons #Divide each column of the matrix by its sum total = areas.sum(0) out_data = areas.copy() for row in out_data.index: out_data.loc[row] /= total #Write to csv, and delete the temporary directory out_data.to_csv(outfile) if remove_temp_if_successful: clear_temp() except Exception as e: if remove_temp_if_error: clear_temp() exc_type, exc_obj, exc_tb = sys.exc_info() print(exc_tb.tb_lineno) raise e #Open the file if instructed to do so if show_matrix: Popen(outfile, shell=True)
def IceCliffLocation(workspace,dem,tileDebarea,pixel,skinny,minSlope,n_iterations,L_e,alpha,beta_e,A_min,phi,gamma): import sys import os import arcpy from arcpy import env from arcpy.sa import Slope, ExtractByMask, Raster, SetNull, Int import matplotlib.pyplot as plt import numpy as np from numpy import array from scipy.optimize import curve_fit env.overwriteOutput = True try: import arcinfo except: sys.exit("ArcInfo license not available") arcpy.AddMessage("ArcInfo license not available") if arcpy.CheckExtension("spatial") == "Available": arcpy.CheckOutExtension("spatial") else: sys.exit("Spatial Analyst license not available") arcpy.AddMessage("Spatial Analyst license not available") #Parameters that should be stable: slopeLimit = 90 # slope detection capped at this value ## Loop for optimizing slope if str(workspace.split("\\")[-1]) == 'Final': n = [] n.append(minSlope) else: minSlope = 0 n = np.arange(minSlope,slopeLimit,(slopeLimit-minSlope)/n_iterations) skipIteration = [] for minSlope in n: # check for existing iterations if code has previously run but crashed. if arcpy.ListFeatureClasses("*cliffMap*"): fcListPrior = arcpy.ListFeatureClasses("*cliffMap*") skipIteration = [] for prior_i in fcListPrior: if int(prior_i[14:16]) == int("%02d" % (int(minSlope),)): skipIteration = 1 if skipIteration == 1: continue ## Ice Cliff code if skinny == 'false': print 'IceCliffLocation script started...' if skinny == 'true': print 'skinny IceCliffLocation script started...' # Parameter that probably should be 0 minProb = 0 # probability associated with minSlope. arcpy.CopyFeatures_management(tileDebarea, workspace+"\\del_debarea.shp") debarea_iteration = workspace+"\\del_debarea.shp" arcpy.env.snapRaster = dem outExtractSlope = ExtractByMask(dem, debarea_iteration) outExtractSlope.save("dem_extract.TIF") if int(round(float(str(arcpy.GetRasterProperties_management(dem, "CELLSIZEX"))))) == pixel: dem = "dem_extract.TIF" else: arcpy.Resample_management("dem_extract.TIF", "dem_extractResample.TIF", pixel, "NEAREST") arcpy.env.snapRaster = dem print "DEM resampeld from "+str(int(round(float(str(arcpy.GetRasterProperties_management(dem, "CELLSIZEX"))))))+' to '+str(pixel) dem = "dem_extractResample.TIF" # Create slope raster outSlope = Slope(dem, "DEGREE", 1) outSlope.save("del_slope.TIF") # Isolate slope values above minSlope outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE <= "+ str(minSlope)) outSetNull.save("del_minSlope.TIF") # Exit process if no cliffs exist nocliff = arcpy.GetRasterProperties_management(Int("del_minSlope.TIF"), "ALLNODATA") if int(str(nocliff)) == 1: print "No area with a slope above "+str(minSlope)+"." elif float(str(arcpy.GetRasterProperties_management('del_minSlope.TIF',"MAXIMUM"))) - float(str(arcpy.GetRasterProperties_management('del_minSlope.TIF',"MINIMUM"))) == 0: print "Only one pixel with a slope above "+str(minSlope)+", iteration skipped." else: minMean = float(str(arcpy.GetRasterProperties_management("del_minSlope.TIF", "MEAN"))) minSD = float(str(arcpy.GetRasterProperties_management("del_minSlope.TIF", "STD"))) areaSlope = minMean print 'areaSlope = ' + str(areaSlope) # Isolate slope values above areaSlope outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE <= "+ str(areaSlope)) outSetNull.save("del_areaSlope.TIF") arcpy.env.snapRaster = dem # Exit process if no cliffs exist nocliff = arcpy.GetRasterProperties_management(Int("del_areaSlope.TIF"), "ALLNODATA") if int(str(nocliff)) == 1: print "No area with a slope above "+str(areaSlope)+"." elif float(str(arcpy.GetRasterProperties_management("del_areaSlope.TIF","MAXIMUM"))) - float(str(arcpy.GetRasterProperties_management("del_areaSlope.TIF","MINIMUM"))) == 0: print "Only one pixel with a slope above "+str(areaSlope)+", iteration skipped." else: seedSlope = minMean+minSD print 'seedSlope = ' + str(seedSlope) # Isolate slope values above areaSlope outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE <= "+ str(seedSlope)) outSetNull.save("del_seedSlope.TIF") # Exit process if no cliffs exist nocliff = arcpy.GetRasterProperties_management(Int("del_seedSlope.TIF"), "ALLNODATA") if int(str(nocliff)) == 1: print "No seed area with a slope above "+str(seedSlope)+"." else: # to int speeds up computation time outInt = Int("del_areaSlope.TIF") outInt.save("del_minSlopeInt.TIF") outInt = Int("del_seedSlope.TIF") outInt.save("del_seedSlopeInt.TIF") arcpy.RasterToPolygon_conversion("del_minSlopeInt.TIF", "del_minCliffSlope.shp", "NO_SIMPLIFY", "VALUE") arcpy.AddField_management("del_minCliffSlope.shp", "value", "SHORT", 1, "", "", "", "", "") arcpy.Dissolve_management("del_minCliffSlope.shp", "del_minCliff_dissolve.shp", "value") arcpy.MultipartToSinglepart_management("del_minCliff_dissolve.shp", "del_minCliff_explode.shp") arcpy.AddField_management("del_minCliff_explode.shp",'Area','FLOAT') rows = arcpy.UpdateCursor("del_minCliff_explode.shp") for row in rows: areacliff = row.shape.area row.Area = areacliff rows.updateRow(row) del row, rows arcpy.CopyFeatures_management("del_minCliff_explode.shp", "min"+str("%02d" % (minSlope,))+"_CliffArea.shp") # skinny/non-skinny fix for ending iteration. 0 = no skip, 1 = skip skip_iter = 0 # skinny ice cliffs, does not include ice cliff end extension to speed up computations if skinny == 'true': if arcpy.management.GetCount("del_minCliff_explode.shp")[0] == "0": skip_iter = 1 print "No area within del_minCliff_explode.shp, skinny iteration skipped." else: # "_FinalCliffShape.shp" and "_cliffArea.shp" are the same if skinny == true arcpy.CopyFeatures_management("del_minCliff_explode.shp", "min"+str("%02d" % (minSlope,))+"area"+str(int(areaSlope))+"_FinalCliffShape.shp") # copy working .shp, used below arcpy.CopyFeatures_management('del_minCliff_explode.shp', 'del_lineAndArea_area.shp') arcpy.CalculateAreas_stats('del_minCliff_explode.shp', 'del_lineAndArea_area.shp') arcpy.MakeFeatureLayer_management('del_lineAndArea_area.shp', 'tempLayer') expression = 'F_AREA <=' + str((pixel**2)*A_min) arcpy.SelectLayerByAttribute_management('tempLayer', 'NEW_SELECTION', expression) arcpy.DeleteFeatures_management('tempLayer') arcpy.Delete_management('tempLayer') if skinny == 'false': # buffer in/out area to break up attached features arcpy.Buffer_analysis("del_minCliff_explode.shp", "del_extendLineBuffer.shp", (pixel/2)-0.1, "FULL", "ROUND", "NONE") # Generate ice cliff centerlines from Voronoi cells if arcpy.management.GetCount("del_extendLineBuffer.shp")[0] == "0": arcpy.CreateFeatureclass_management(workspace, 'del_lineAndArea_area.shp', "POLYGON","del_minCliff_dissolve.shp") skip_iter = 1 print "No area within the criteria defined by seed area value "+str(seedSlope)+", iteration stopped before centerlines." else: arcpy.FeatureToLine_management("del_extendLineBuffer.shp","del_line.shp","","ATTRIBUTES") arcpy.Densify_edit("del_line.shp", "","5", "", "") arcpy.FeatureVerticesToPoints_management ("del_line.shp", "del_verti.shp", "ALL") arcpy.CreateThiessenPolygons_analysis("del_verti.shp","del_voronoiCells.shp" ,"ONLY_FID") arcpy.RepairGeometry_management("del_voronoiCells.shp") #use geodatabase here due to unexpected error: "Invalid Topology [Duplicate segment.]" arcpy.CreateFileGDB_management(workspace, "fGDB.gdb") fgdb = workspace+"\\fGDB.gdb" #arcpy.env.workspace = fgdb arcpy.Clip_analysis(workspace+"\\del_voronoiCells.shp", workspace+"\\del_extendLineBuffer.shp", fgdb+"\\shp","") arcpy.FeatureToLine_management(fgdb+"\\shp", workspace+"\\del_toLine.shp", "", attributes="ATTRIBUTES") arcpy.Delete_management(fgdb) #arcpy.env.workspace = workspace #arcpy.FeatureToLine_management("del_voronoiCellsClip.shp","del_toLine.shp", "", attributes="ATTRIBUTES") arcpy.MakeFeatureLayer_management("del_toLine.shp", "tempLayer", "", "", "") arcpy.SelectLayerByLocation_management("tempLayer", "CROSSED_BY_THE_OUTLINE_OF","del_minCliff_explode.shp","","NEW_SELECTION") arcpy.DeleteFeatures_management("tempLayer") arcpy.Delete_management("tempLayer") arcpy.Intersect_analysis(["del_toLine.shp",'del_minCliff_explode.shp'],"del_lineIntersect.shp") arcpy.Dissolve_management("del_lineIntersect.shp", "del_toLineDis.shp", "", "", "SINGLE_PART", "DISSOLVE_LINES") arcpy.UnsplitLine_management("del_toLineDis.shp","del_unsplit.shp","Id") arcpy.MakeFeatureLayer_management("del_unsplit.shp", "tempLayer2", "", "", "") arcpy.SelectLayerByLocation_management("tempLayer2", "BOUNDARY_TOUCHES","del_minCliff_explode.shp","","NEW_SELECTION") arcpy.DeleteFeatures_management("tempLayer2") arcpy.Delete_management("tempLayer2") arcpy.cartography.SimplifyLine("del_unsplit.shp","del_clineSimpExp.shp","POINT_REMOVE",10) arcpy.AddField_management("del_clineSimpExp.shp", "value", "SHORT", 1, "", "", "", "", "") arcpy.Dissolve_management("del_clineSimpExp.shp", "del_clineSimp.shp", "value") arcpy.TrimLine_edit("del_clineSimp.shp", "8 meters", "KEEP_SHORT") arcpy.CopyFeatures_management("del_unsplit.shp", "min"+str("%02d" % (minSlope,))+"_Centerlines.shp") #refine centerline for final map if arcpy.management.GetCount("del_clineSimp.shp")[0] == "0": arcpy.CreateFeatureclass_management(workspace, 'del_lineAndArea_area.shp', "POLYGON","del_minCliff_dissolve.shp") skip_iter = 1 print "No area big enough to generate a centerline, iteration skipped." else: # extend lines to capture cliff ends count = 0 print "Extend line started..." jlist = [(pixel/2)-0.1] * int(round(L_e/(pixel/2))) for j in jlist: #create buffer out to set the limit a line will be extended to arcpy.Buffer_analysis("del_clineSimp.shp", "del_clineSimpBuff1.shp", j, "FULL", "ROUND", "ALL") arcpy.PolygonToLine_management("del_clineSimpBuff1.shp","del_clineSimpBuff1line.shp") #merge centerline and bufferline arcpy.Merge_management(["del_clineSimp.shp","del_clineSimpBuff1line.shp"], "del_clineSimpBuff1merge_dis.shp") arcpy.Delete_management("del_clineSimp.shp") print "Extend line "+str(count)+" started..." arcpy.MultipartToSinglepart_management("del_clineSimpBuff1merge_dis.shp", "del_clineSimpBuff1merge.shp") arcpy.MakeFeatureLayer_management("del_clineSimpBuff1merge.shp", "lineLayer", "", "", "") arcpy.SelectLayerByLocation_management("lineLayer", "SHARE_A_LINE_SEGMENT_WITH", "del_clineSimpBuff1.shp", "", "NEW_SELECTION", "INVERT") arcpy.ExtendLine_edit("del_clineSimpBuff1merge.shp", str(j+1)+" meters", "EXTENSION") #select share a line segment with buffer to remove buffer arcpy.SelectLayerByLocation_management("lineLayer", "SHARE_A_LINE_SEGMENT_WITH", "del_clineSimpBuff1.shp", "", "NEW_SELECTION") arcpy.DeleteFeatures_management("lineLayer") arcpy.Delete_management("lineLayer") arcpy.CopyFeatures_management("del_clineSimpBuff1merge.shp", "del_clineSimp.shp") arcpy.Delete_management("del_clineSimpBuff1.shp") arcpy.Delete_management("del_clineSimpBuff1line.shp") arcpy.Delete_management("del_clineSimpBuff1merge.shp") count = count + j del j, jlist #remove last short ribs with a lenght threhold then reattach centerlines that may have been split # calculate lenght of each centerline if arcpy.management.GetCount("del_clineSimp.shp")[0] == "0": arcpy.CreateFeatureclass_management(workspace, 'del_lineAndArea_area.shp', "POLYGON","del_minCliff_explode.shp") skip_iter = 1 print "Centerline shape empty, iteration skipped." else: arcpy.AddField_management("del_clineSimp.shp",'L','FLOAT') rows = arcpy.UpdateCursor("del_clineSimp.shp") for row in rows: areacliff = row.shape.length row.L = areacliff rows.updateRow(row) del row, rows arcpy.CopyFeatures_management("del_clineSimp.shp", "min"+str("%02d" % (minSlope,))+"_extendedCenterlines.shp") # buffer out centerlines to capture end area removed in earlier buffer arcpy.Buffer_analysis("del_clineSimp.shp", "del_CliffCenterlineOut.shp", ((alpha*pixel*(2**(1/2)))/2), "FULL", "ROUND", "NONE") # define area with a slope less than that which defined "del_minCliff_dissolve.shp" edgeAreaSlope = areaSlope-beta_e print "Edge area defined by slope "+str(edgeAreaSlope) outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE <= "+ str(edgeAreaSlope)) outSetNull.save("del_edgeSlope.TIF") outInt = Int("del_edgeSlope.TIF") outInt.save("del_edgeSlopeInt.TIF") arcpy.RasterToPolygon_conversion("del_edgeSlopeInt.TIF", "del_edgeAreaSlope.shp", "NO_SIMPLIFY", "VALUE") arcpy.AddField_management("del_edgeAreaSlope.shp", "value", "SHORT", 1, "", "", "", "", "") arcpy.Dissolve_management("del_edgeAreaSlope.shp", "del_edgeAreaSlope_dissolve.shp", "value") arcpy.CopyFeatures_management("del_edgeAreaSlope_dissolve.shp", "min"+str("%02d" % (minSlope,))+"_edgeArea.shp") arcpy.Intersect_analysis (["del_edgeAreaSlope_dissolve.shp", "del_CliffCenterlineOut.shp"], "del_betaF_edgeArea.shp") # merge buffered lines with buffered area arcpy.Merge_management(["del_betaF_edgeArea.shp", "del_minCliff_explode.shp"], "del_lineAndArea.shp") arcpy.AddField_management("del_lineAndArea.shp", "valueDis", "SHORT", 1, "", "", "", "", "") arcpy.Dissolve_management("del_lineAndArea.shp", "del_lineAndArea_dissolve1.shp", "valueDis") arcpy.RepairGeometry_management("del_lineAndArea_dissolve1.shp") # fill holes and remove shapes less than one pixel to avoid error from buffer tool arcpy.MultipartToSinglepart_management("del_lineAndArea_dissolve1.shp", "del_lineAndArea_explode1.shp") arcpy.CalculateAreas_stats("del_lineAndArea_explode1.shp", 'del_lineAndArea_area1.shp') arcpy.MakeFeatureLayer_management('del_lineAndArea_area1.shp', 'tempLayer') expression = 'F_AREA <' + str(pixel**2) # m2 arcpy.SelectLayerByAttribute_management('tempLayer', 'NEW_SELECTION', expression) arcpy.DeleteFeatures_management('tempLayer') arcpy.Delete_management('tempLayer') arcpy.cartography.AggregatePolygons('del_lineAndArea_area1.shp', "del_lineAndArea_dissolve.shp", 1, 0, pixel**2, 'NON_ORTHOGONAL') arcpy.RepairGeometry_management("del_lineAndArea_dissolve.shp") # buffer in to reomve sliver geometries and out to make a diagonal set of single pixel shapes one feature arcpy.Buffer_analysis("del_lineAndArea_dissolve.shp", "del_lineAndArea_dissolveSmallBufferIn.shp", -0.5, "FULL", "ROUND", "ALL") arcpy.Buffer_analysis("del_lineAndArea_dissolveSmallBufferIn.shp", "del_lineAndArea_dissolveSmallBuffer.shp", 1, "FULL", "ROUND", "ALL") arcpy.MultipartToSinglepart_management("del_lineAndArea_dissolveSmallBuffer.shp", "del_lineAndArea_explode.shp") arcpy.CalculateAreas_stats('del_lineAndArea_explode.shp', 'del_lineAndArea_area.shp') arcpy.MakeFeatureLayer_management('del_lineAndArea_area.shp', 'tempLayer') expression = 'F_AREA <=' + str((pixel**2)*A_min) arcpy.SelectLayerByAttribute_management('tempLayer', 'NEW_SELECTION', expression) arcpy.DeleteFeatures_management('tempLayer') arcpy.Delete_management('tempLayer') if arcpy.management.GetCount("del_lineAndArea_area.shp")[0] == "0": print "del_lineAndArea_area.shp empty, iteration stopped." skip_iter = 1 else: arcpy.AddField_management("del_lineAndArea_area.shp", "value", "SHORT", 1, "", "", "", "", "") arcpy.CopyFeatures_management('del_lineAndArea_area.shp', "min"+str("%02d" % (minSlope,))+"area"+str(int(areaSlope))+"_FinalCliffShape.shp") if skip_iter == 0: # CDF for values between minSlope and maxSlope outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE >= "+ str(minSlope)) outSetNull.save("del_min.TIF") arcpy.RasterToFloat_conversion("del_min.TIF", "del_min.flt") minsl = Raster('del_min.flt') slopemin = minsl*0.0 slopemin.save('del_minSl.TIF') outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE > "+ str(seedSlope)) outSetNull = SetNull(outSetNull, outSetNull, "VALUE < "+ str(minSlope)) outSetNull.save("del_mid.TIF") arcpy.RasterToFloat_conversion("del_mid.TIF", "del_mid.flt") midsl = Raster('del_mid.flt') b = (1-(((1-minProb)/(seedSlope-minSlope))*seedSlope)) slopemid = (((1-minProb)/(seedSlope-minSlope))*midsl)+b arcpy.env.snapRaster = dem slopemid.save('del_midSl.TIF') arcpy.env.snapRaster = dem outSetNull = SetNull("del_slope.TIF", "del_slope.TIF", "VALUE <= "+ str(seedSlope)) outSetNull.save("del_max.TIF") arcpy.RasterToFloat_conversion("del_max.TIF", "del_max.flt") maxsl = Raster('del_max.flt') slopemax = maxsl*0.0+1.0 arcpy.env.snapRaster = dem slopemax.save('del_maxSl.TIF') arcpy.env.snapRaster = dem arcpy.MosaicToNewRaster_management("del_minSl.TIF;del_midSl.TIF;del_maxSl.TIF", workspace, "del_cliffProbabilitySlope.TIF", "", "32_BIT_FLOAT", "", "1", "LAST","FIRST") arcpy.env.snapRaster = dem # extract cliff probability and apply reduction factor to area outside of buffer.shp if arcpy.management.GetCount("del_lineAndArea_area.shp")[0] == "0": print "del_lineAndArea_area.shp is empty, did not create: CliffProbability_betai" + str("%02d" % (int(minSlope),)) + "betaA" + str(int(areaSlope))+".TIF" else: outExtractSlope = ExtractByMask("del_cliffProbabilitySlope.TIF", "del_lineAndArea_area.shp") outExtractSlope.save("del_final_cliffs_found.TIF") arcpy.RasterToFloat_conversion("del_cliffProbabilitySlope.TIF", "del_CliffProbabilitySlope.flt") CliffProbabilitySlope = Raster('del_CliffProbabilitySlope.flt') CliffProbabilitySlopeREDUCED = CliffProbabilitySlope*phi arcpy.env.snapRaster = dem CliffProbabilitySlopeREDUCED.save('del_CliffProbabilitySlopeREDUCED.TIF') arcpy.MosaicToNewRaster_management("del_final_cliffs_found.TIF;del_CliffProbabilitySlopeREDUCED.TIF", workspace, "CliffProbability_betai" + str("%02d" % (int(minSlope),)) + "betaA" + str(int(areaSlope))+".TIF", "", "32_BIT_FLOAT", "", "1", "FIRST","FIRST") arcpy.env.snapRaster = dem del CliffProbabilitySlope del CliffProbabilitySlopeREDUCED del minsl del midsl del maxsl ## ---------------------------------- ## Compute percent cliff in total spatial domain cliff_area_sum = 0 debris_area_sum = 0 Perc_Cliff = 0 arcpy.CalculateAreas_stats(debarea_iteration, 'del_debris_area.shp') with arcpy.da.SearchCursor('del_debris_area.shp', ['F_AREA']) as cursor: for row in cursor: debris_area_sum += row[0] if os.path.isfile(workspace+'\\del_lineAndArea_area.shp') == False: print "'del_lineAndArea_area.shp'does not exist." elif arcpy.management.GetCount('del_lineAndArea_area.shp')[0] == "0": print "No area within 'del_lineAndArea_area.shp'." else: with arcpy.da.SearchCursor('del_lineAndArea_area.shp', ['F_AREA']) as cursor: for row in cursor: cliff_area_sum += row[0] Perc_Cliff = (cliff_area_sum/debris_area_sum)*100 arcpy.Dissolve_management("del_lineAndArea_area.shp", 'cliffMap_betai' + str("%02d" % (int(minSlope),)) + 'betaA' + str(int(areaSlope)) + '.shp', "value") arcpy.AddField_management('cliffMap_betai' + str("%02d" % (int(minSlope),)) + 'betaA' + str(int(areaSlope)) + '.shp','minSlope','FLOAT') arcpy.AddField_management('cliffMap_betai' + str("%02d" % (int(minSlope),)) + 'betaA' + str(int(areaSlope)) + '.shp','Area_Cliff','FLOAT') arcpy.AddField_management('cliffMap_betai' + str("%02d" % (int(minSlope),)) + 'betaA' + str(int(areaSlope)) + '.shp','Area_Deb','FLOAT') arcpy.AddField_management('cliffMap_betai' + str("%02d" % (int(minSlope),)) + 'betaA' + str(int(areaSlope)) + '.shp','Perc_Cliff','FLOAT') rows = arcpy.UpdateCursor('cliffMap_betai' + str("%02d" % (int(minSlope),)) + 'betaA' + str(int(areaSlope)) + '.shp') for row in rows: row.setValue('Area_Cliff', cliff_area_sum) row.setValue('Area_Deb', debris_area_sum) row.setValue('minSlope', minSlope) row.setValue('Perc_Cliff', Perc_Cliff) rows.updateRow(row) del row, rows print 'IceCliffLocation script [minSlope: ' + str("%02d" % (int(minSlope),)) + ' areaSlope: ' + str(int(areaSlope))+ '] done...' rasterList = arcpy.ListRasters("*del*") for raster in rasterList: arcpy.Delete_management(raster) del raster del rasterList fcList = arcpy.ListFeatureClasses("*del*") for fc in fcList: arcpy.Delete_management(fc) del fc del fcList print "intermediate files deleted" del minSlope del n if str(workspace.split("\\")[-1]) == 'Final': print "Script complete" else: initialSlope_doubles = [] percentCliffs_doubles = [] initialSlope = [] percentCliffs = [] xfit = [] yfit = [] fcList = [] arr = [] fcList = arcpy.ListFeatureClasses("*cliffMap*") arcpy.Merge_management(fcList, "mergedSolutions.shp") arr = arcpy.da.TableToNumPyArray("mergedSolutions.shp", ('Perc_Cliff','minSlope')) arcpy.Delete_management("del_mergedSolutions.shp") initialSlope_doubles = [row[1] for row in arr] percentCliffs_doubles = [row[0] for row in arr] #remove rows that are repeated due to (possible) earlier tiled dissolve from insufficient memory for i,j in enumerate(initialSlope_doubles): if j != initialSlope_doubles[(i-1) % len(initialSlope_doubles)]: initialSlope.append(j) del i,j for i,j in enumerate(percentCliffs_doubles): if j != percentCliffs_doubles[(i-1) % len(percentCliffs_doubles)]: percentCliffs.append(j) del i,j def func(x,a,b,c): return a*np.exp(-((x-b)/c)**2) try: popt, pcov = curve_fit(func,initialSlope,percentCliffs, maxfev=1000) except RuntimeError: fig = plt.figure() ax1 = fig.add_subplot(111) ax1.plot(initialSlope, percentCliffs, 'ko');plt.draw() fig.show() print("Error - curve_fit failed") xfit = np.linspace(min(initialSlope), max(initialSlope), 100) yfit = popt[0]*np.exp(-((xfit-popt[1])/popt[2])**2) def secondDer(x): return popt[0]*(((4*(x-popt[1])**2*np.exp(-(x-popt[1])**2/popt[2]**2))/popt[2]**4)-((2*np.exp(-(x-popt[1])**2/popt[2]**2))/popt[2]**2)) a1 = [] a1 = [i for i in xrange(91)] a2 = secondDer(a1) #the next 3 for loops and a[x] variables define 1 of the 2 points to derive the optimization line. a3 = [] a4 = [] # values of second derivative where slope is below 'gamma' for i, j in enumerate(a2): if j <= gamma: a3.append(i) == i # find the steepest point (in the middle of the side of the bell) for i, j in enumerate(a2): if j == max(a2): m=i # take only values to the right of 'm' in case the curve is flat at 0 slope for i in a3: if i > m: a4.append(i) == i del i,j ax = min(a4) ay = popt[0]*np.exp(-((ax-popt[1])/popt[2])**2) #find max of bell for first point in optmization line yfit_array = array(yfit) ftup = (np.where(yfit_array == max(yfit_array))) f = int(ftup[0]) # x,y index of max yfit # d = distance from fit Equation 2 (Herreid and Pellicciotti, 2018) to line definded by ((xfit[0],yfit[0]),(ax,yx)) d = abs((yfit[f]-ay)*xfit-(xfit[f]-ax)*yfit+xfit[f]*ay-yfit[f]*ax)/((yfit[f]-ay)**2+(xfit[f]-ax)**2)**(1/2) # crit is the index of the longest d crit = np.where(d == max(d)) m = (yfit[f]-ay)/(xfit[f]-ax) b = yfit[f]-m*xfit[f] x_crit = (xfit[crit]+m*yfit[crit]-m*b)/(m**2+1) y_crit = m*((xfit[crit]+m*yfit[crit]-m*b)/(m**2+1))+b fig = plt.figure() ax1 = fig.add_subplot(111) ax1.plot(initialSlope, percentCliffs, 'ko'); plt.plot([xfit[f],ax],[yfit[f],ay]); plt.plot([xfit[crit],x_crit],[yfit[crit],y_crit]); plt.plot(xfit,yfit);plt.xlim(0, 100);plt.ylim(0, 100);plt.gca().set_aspect('equal', adjustable='box');plt.draw() ax1.set_xlabel(r'$\mathrm{\beta_i (^\circ)}$') ax1.set_ylabel('Ice cliff fraction (%)') fig.show() #fig.canvas.flush_events() import time time.sleep(1) #plt.pause(0.01) #plt.waitforbuttonpress() #save data used to make figure np.save(workspace+'\\figureData', (initialSlope, percentCliffs,[xfit[f],ax],[yfit[f],ay],[xfit[crit],x_crit],[yfit[crit],y_crit],xfit,yfit)) IceCliffLocation.minSlope = float(xfit[crit])
arcpy.MakeFeatureLayer_management(FSAselection, tempFSAlyr) area = 0 for a in arcpy.da.SearchCursor(FSAselection, "Shape_Area"): area = float(a[0]) # Iterates through the ADAs that intersect with the currently selected FSA: for row in arcpy.SearchCursor(ADAselection): adaentry_fid = row.fid arcpy.MakeFeatureLayer_management(ADAselection, tempADAlyr) tempselect = arcpy.SelectLayerByAttribute_management(tempADAlyr, "NEW_SELECTION", "FID = "+str(adaentry_fid)) inputFeatures = [tempFSAlyr, tempADAlyr] try: arcpy.Intersect_analysis(inputFeatures, tempIntersection, "ALL", "", "INPUT") if arcpy.management.GetCount(tempIntersection)[0] == "1": arcpy.CalculateAreas_stats(tempIntersection, tempIntersectionWithArea) for a in arcpy.da.SearchCursor(tempIntersectionWithArea, "F_AREA"): matrix[int(adaentry_fid)] = a[0]/area except Exception as e: print("Failed operation: ", e) arcpy.Delete_management(tempADAlyr) arcpy.Delete_management(tempIntersection) arcpy.Delete_management(tempIntersectionWithArea) arcpy.Delete_management(tempFSAlyr) writer.writerow(matrix) end = time.strftime('%X %x %Z') print("Relationship matrix processing times:") print("Start: ", start) print("End: ", end)