def sort_shpfilebyidfield(inputshpfile, outputshpfile, intfield, desc=False): if desc: arcpy.Sort_management(inputshpfile, outputshpfile, [[intfield, "DESCENDING"]]) else: arcpy.Sort_management(inputshpfile, outputshpfile, [[intfield, "ASCENDING"]])
def GemstoneInProvince(): # input shapefile containing all gemstone feature classes (resulting layer after performing spatial join with Province # boundary layer) in_fc = r"C:\Gemstone-Geology maps\all_gemstones\join\gemstone_provinces.shp" # output shapefile for Sort_management to output fc = r"C:\Gemstone-Geology maps\all_gemstones\join\gemstone_provinces_sorted.shp" # Sort gemstone name in alphabetical order so that final list will be grouped by gemstone print( "Sorting Master gemstone-province feature class in ascending order " ) arcpy.Sort_management(in_fc, fc, [["Commodity1", 'ASCENDING']]) fields = [ "Commodity1", "ADM1_EN" ] # Search Cursor reads through gemstone and province name fields gem_loc = [] print( "Searching through feature class attribute table for unique combinations of gemstones in provinces " ) with arcpy.da.SearchCursor(fc, fields) as cursor: for row in cursor: if row not in gem_loc: # don't add to gem_loc list if this gemstone is already in this province gem_loc.append(row) # print gemstone-province pairs as strings # for i in gem_loc: # print(' ... '.join(i)) print( "Finished compiling list of unique gemstone-province combinations") print("***********************************") return gem_loc[:]
def summarizeGumByCategory(): layer = "in_memory\gumcount_0plus" #table = "GumCountByCategory" table = "in_memory/CityGumCountByCategory" #table = publishGDB + "/CityGumCountByCategory" #arcpy.Delete_management(layer) arcpy.MakeFeatureLayer_management("Sites", "lyr") arcpy.SelectLayerByAttribute_management("lyr", "NEW_SELECTION", "GUM_COUNT_ACTUAL > 0") arcpy.CopyFeatures_management("lyr", layer) #arcpy.Statistics_analysis(layer, "GumCountByCategory", "GUM_COUNT_ACTUAL SUM", "SIC_NAME") arcpy.Statistics_analysis(layer, table, "GUM_COUNT_ACTUAL SUM", "SIC_NAME") arcpy.AddField_management(table, "AVG_GUM_COUNT", "SHORT") fields = ['SIC_NAME', 'FREQUENCY', 'SUM_GUM_COUNT_ACTUAL', 'AVG_GUM_COUNT'] with arcpy.da.UpdateCursor(table, fields) as cursor: for row in cursor: print(row) if row[0] == None: row[0] = "ADDRESS POINT" row[3] = round(row[2] / row[1]) cursor.updateRow(row) sort_fields = [["SUM_GUM_COUNT_ACTUAL", "DESCENDING"]] sortTable = publishGDB + "/CityGumCountByCategory" arcpy.Sort_management(table, sortTable, sort_fields)
def sortToCameraRange(roughAOI,AOI_output): # establish new sorting, numbering, and area fields arcpy.AddField_management(roughAOI, "YMin", "DOUBLE", "20","12") arcpy.AddField_management(roughAOI, "AOI", "SHORT") arcpy.AddField_management(roughAOI,"SqrMeters","Double") # compile list of minimum Y bounds of each polygon (proximal to PHENOCAM-North) yMinExtents = [] readFeatures = arcpy.SearchCursor(roughAOI) changeFeatures = arcpy.UpdateCursor(roughAOI) featureNames = arcpy.Describe(roughAOI).shapeFieldName for readFeat in readFeatures: yMinExtents.append(readFeat.getValue('Shape').extent.YMin) # apply respective minimum Y bounds to each features new attribute field for idx, changeFeat in enumerate(changeFeatures): changeFeat.setValue("yMin",yMinExtents[idx]) changeFeatures.updateRow(changeFeat) # resort the attribute table based on the newly filled YMin attribute field arcpy.env.addOutputsToMap = True arcpy.Sort_management(roughAOI, AOI_output, [["YMin","ASCENDING"]], "") arcpy.Delete_management(roughAOI) # create top-down AOI numerical index (thnx to YMin-sort), and update AOI field changeFeatures = arcpy.UpdateCursor(AOI_output) for idx, changeFeat in enumerate(changeFeatures): aoiIdx = idx+1 changeFeat.setValue("AOI",aoiIdx) changeFeatures.updateRow(changeFeat)
def OrdenarManzanasFalsoCod(self): if self.uso_falso_cod == 1: manzanas_ordenadas = arcpy.Sort_management( self.tb_manzanas, self.tb_manzanas_ordenadas, ["UBIGEO", "ZONA", "FALSO_COD"]) else: manzanas_ordenadas = arcpy.Sort_management( self.tb_manzanas, self.tb_manzanas_ordenadas, ["UBIGEO", "ZONA", "MANZANA"]) expression = "flg_manzana(!CANT_VIV!)" codeblock = """def flg_manzana(CANT_VIV):\n if (CANT_VIV>18):\n return 1\n else:\n return 0""" #.format(self.cant_viv_techo) arcpy.AddField_management(manzanas_ordenadas, "FLG_MZ", "SHORT") arcpy.CalculateField_management(manzanas_ordenadas, "FLG_MZ", expression, "PYTHON_9.3", codeblock)
def get_footprints(centroids, shapefile): os.makedirs(resources.temp_footprints, exist_ok=True) output_feature_class = os.path.join(resources.temp_footprints, "unsorted.shp") join_operation = "JOIN_ONE_TO_MANY" join_type = "KEEP_COMMON" match_option = "CONTAINS" arcpy.SpatialJoin_analysis(shapefile, centroids, output_feature_class, join_operation=join_operation, join_type=join_type, match_option=match_option) fields = [ field.name for field in arcpy.ListFields(output_feature_class) ] valids = [ "FID", "Shape", "Roof", "Score", "Perc_000", "Perc_010", "Perc_050", "Perc_090", "Perc_100" ] to_drop = [item for item in fields if item not in valids] arcpy.DeleteField_management(output_feature_class, to_drop) output = os.path.join(resources.temp_footprints, "footprints.shp") arcpy.Sort_management(output_feature_class, output, "Shape ASCENDING", "UL") arcpy.Delete_management(output_feature_class) arcpy.DeleteIdentical_management(output, "Shape", None, 0) return output
def generate_top_ranked_subset(in_feature_class, ranking_attribute, out_feature_class): # Sort the feature class arcpy.Sort_management(in_feature_class, out_feature_class, [[ranking_attribute, "DESCENDING"]]) # Add a rank attribute and populate it arcpy.AddField_management(out_feature_class, "Rank", "LONG") arcpy.CalculateField_management(out_feature_class, "Rank", "!OBJECTID!", "PYTHON_9.3") # Create a new feature class with the top third rows max_rank = get_max(out_feature_class, "Rank") one_third_rows = max_rank / 3 #print(one_third_rows) arcpy.SelectLayerByAttribute_management(out_feature_class, "NEW_SELECTION", "Rank <= " + str(one_third_rows)) arcpy.CopyFeatures_management(out_feature_class, out_feature_class + "_top10pct") arcpy.SelectLayerByAttribute_management(out_feature_class, "CLEAR_SELECTION") # Create a new feature class with the top 20 rows arcpy.SelectLayerByAttribute_management(out_feature_class, "NEW_SELECTION", "Rank <= 20") arcpy.CopyFeatures_management(out_feature_class, out_feature_class + "_top20") arcpy.SelectLayerByAttribute_management(out_feature_class, "CLEAR_SELECTION")
def importar_tablas_trabajo(data, campos): arcpy.env.overwriteOutput = True db = 'CPV_SEGMENTACION_GDB' ip = '172.18.1.93' usuario = 'sde' password = '******' path_conexion = conx.conexion_arcgis(db, ip, usuario, password) arcpy.env.workspace = path_conexion temp_ubigeos = "" i = 0 for x in data: i = i + 1 if (i == 1): temp_ubigeos = "'{}'".format(x[0]) else: temp_ubigeos = "{},'{}'".format(temp_ubigeos, x[0]) if len(data) > 0: sql = expresion.Expresion_2(data, campos) else: sql = ' FLAG_NUEVO=1' list_capas = [ ["{}.sde.VW_FRENTES".format(db), tb_frentes_temp, 1], ] for i, capa in enumerate(list_capas): if capa[2] == 1: print "select * from {} where {} ".format(capa[0], sql) x = arcpy.MakeQueryLayer_management( path_conexion, 'capa{}'.format(i), "select * from {} where {} ".format(capa[0], sql)) else: x = arcpy.MakeQueryTable_management(capa[0], "capa{}".format(i), "USE_KEY_FIELDS", "objectid", "", sql) if capa[1] in [tb_frentes_temp]: temp = arcpy.CopyFeatures_management(x, 'in_memory/temp_{}'.format(i)) arcpy.AddField_management(temp, 'MANZANA2', 'TEXT', 50) arcpy.CalculateField_management(temp, 'MANZANA2', '!MANZANA!', "PYTHON_9.3") arcpy.DeleteField_management(temp, ['MANZANA']) arcpy.CopyFeatures_management(temp, capa[1]) arcpy.AddField_management(capa[1], 'MANZANA', 'TEXT', 50) arcpy.CalculateField_management(capa[1], 'MANZANA', '!MANZANA2!', "PYTHON_9.3") arcpy.DeleteField_management(capa[1], ['MANZANA2']) else: arcpy.CopyFeatures_management(x, capa[1]) arcpy.Sort_management(tb_frentes_temp, tb_frentes, ['UBIGEO', 'ZONA', 'MANZANA', 'FRENTE_ORD'])
def execute(self): # Create output GDB and add domain for asset type self.gdb = arcpy.CreateFileGDB_management(*os.path.split(self.gdb))[0] # Since NA.solve uses OID for start/end points, the OID of the feature classes being copied should # be maintained so that the attribute information can be linked back, if desired remote_temp = copy_features(self.remote, common.unique_name("in_memory/remoteTemp")) fixed_temp = copy_features(self.fixed, common.unique_name("in_memory/fixedTemp")) # The information that Near creates is not needed (distance to nearest feature and feature ID), so delete it. # Sorting the features by descending distance ensures that the furthest assets are backhauled first. arcpy.Near_analysis(remote_temp, fixed_temp) sort_temp = arcpy.Sort_management(remote_temp, common.unique_name("in_memory/sort"), [["NEAR_DIST", "DESCENDING"]])[0] common.delete(remote_temp) arcpy.DeleteField_management(sort_temp, ("NEAR_DIST", "NEAR_FID")) # For each remote asset, find the surrounding nearest fixed assets. This Near Table will be used # during backhaul to only load particular assets into the Facilities sublayer. Because this table is sorted # where the nearest features are first (NEAR_DIST and NEAR_RANK are ascending), an arbitrarily defined number of # fixed assets can be loaded into the Closest Facility via list slicing. # In practice, set closest_count to a reasonable number (such as 100). If closest_count=None, then the resultant # Near Table will have (nrows in remote * nrows in fixed) rows. This quickly gets very large (17m+ during dev). count = arcpy.GetCount_management(sort_temp) arcpy.AddMessage("\t{} Processing {} features...".format( common.timestamp(), count)) method = "GEODESIC" if arcpy.Describe( sort_temp).spatialReference.type == "Geographic" else "PLANAR" near_temp = arcpy.GenerateNearTable_analysis( sort_temp, fixed_temp, common.unique_name("in_memory/near"), closest="ALL", closest_count=NEAR_TABLE_SIZE, method=method)[0] arcpy.AddMessage("\t{} Saving Near Table...".format( common.timestamp())) arcpy.DeleteField_management(near_temp, ["NEAR_DIST", "NEAR_RANK"]) near_out = arcpy.CopyRows_management( near_temp, os.path.join(self.gdb, NEAR_TABLE))[0] common.delete(near_temp) arcpy.ResetProgressor() self.calc_update(sort_temp, "Remote") self.calc_update(fixed_temp, "Fixed") remote_out = arcpy.CopyFeatures_management( sort_temp, os.path.join(self.gdb, REMOTE))[0] fixed_out = arcpy.CopyFeatures_management( fixed_temp, os.path.join(self.gdb, FIXED))[0] common.delete([sort_temp, fixed_temp]) return remote_out, fixed_out, near_out
def calculoSortGeneral( capaObjetoC ): # organiza la tabla objeto del cluster de forma ascendente por id de cluster y distancia al punto de irradiación arcpy.AddMessage(time.strftime("%c") + " " + "Ejecutando Calculo Sort...") capaOrdenada = "in_memory" + "\\capaClusterOrdenada" aa = arcpy.Sort_management(capaObjetoC, capaOrdenada, 'NEAR_FID ASCENDING;NEAR_DIST ASCENDING', 'UR').getOutput(0) arcpy.AddMessage("Finaliza Calculo Sort") return capaOrdenada
def ordenar_manzanas_cod_falso(where_expression): manzanas_selecc = arcpy.Select_analysis(tb_manzanas, "in_memory//manzanas_selecc", where_expression) manzanas_ordenadas = arcpy.Sort_management(manzanas_selecc, tb_manzanas_ordenadas, ["UBIGEO", "ZONA", "FALSO_COD"]) expression = "flg_manzana(!VIV_MZ!)" arcpy.AddField_management(manzanas_ordenadas, "FLG_MZ", "SHORT")
def generate_ranked_subset(in_feature_class, ranking_attribute, out_feature_class): # Sort the attribute table arcpy.Sort_management(in_feature_class, out_feature_class, [[ranking_attribute, "DESCENDING"]]) # Add a Rank attribute and populate it arcpy.AddField_management(out_feature_class, "Rank", "LONG") arcpy.CalculateField_management(out_feature_class, "Rank", "!OBJECTID!", "PYTHON_9.3") # Also generate a separate feature class with the top 20 values arcpy.SelectLayerByAttribute_management(out_feature_class, "NEW_SELECTION", "Rank <= 20") arcpy.CopyFeatures_management(out_feature_class, out_feature_class + "_Top20" ) arcpy.SelectLayerByAttribute_management(out_feature_class, "CLEAR_SELECTION")
def makeNodeName2ArcsDict(caf, fields): # takes arc fc, list of fields (e.g. [Left_MapUnit, Right_MapUnit] ) # makes to and from node fcs, concatenates, sorts, finds arc-ends # that share common XY values # returns dictionary of arcs at each node, keyed to nodename # i.e., dict[nodename] = [[arc1 fields], [arc2 fields],...] fv1 = os.path.dirname(caf) + '/xxxNfv1' fv2 = os.path.dirname(caf) + '/xxxNfv12' lenFields = len(fields) addMsgAndPrint(' making endpoint feature classes') testAndDelete(fv1) arcpy.FeatureVerticesToPoints_management(caf, fv1, 'BOTH_ENDS') addMsgAndPrint(' adding XY values and sorting by XY') arcpy.AddXY_management(fv1) testAndDelete(fv2) arcpy.Sort_management(fv1, fv2, [["POINT_X", "ASCENDING"], ["POINT_Y", "ASCENDING"]]) ##fix fields statement and following field references fields.append('SHAPE@XY') indexShape = len(fields) - 1 isFirst = True nArcs = 0 nodeList = [] with arcpy.da.SearchCursor(fv2, fields) as cursor: for row in cursor: x = row[indexShape][0] y = row[indexShape][1] arcFields = row[0:lenFields] if isFirst: isFirst = False lastX = x lastY = y arcs = [arcFields] elif abs(x - lastX) < searchRadius and abs(y - lastY) < searchRadius: arcs.append(arcFields) else: nodeList.append([nodeName(lastX, lastY), arcs]) lastX = x lastY = y arcs = [arcFields] nodeList.append([nodeName(lastX, lastY), arcs]) addMsgAndPrint(' ' + str(len(nodeList)) + ' distinct nodes') addMsgAndPrint(' cleaning up') for fc in fv1, fv2: testAndDelete(fc) nodeDict = {} for n in nodeList: nodeDict[n[0]] = n[1] return nodeDict
def copyBackupPublishGDBtoStaging(): arcpy.Copy_management(backupPublishGDB, publishGDB) sort_fields = [["GUM_COUNT_DATE", "DESCENDING"]] table = publishGDB + "/UnsortedWorldwideGumCountByDate" sortTable = publishGDB + "/WorldwideGumCountByDate" arcpy.Sort_management(table, sortTable, sort_fields) arcpy.Delete_management(table)
def createMaxSpeed (featureclass): fcName = os.path.basename(featureclass).rstrip(os.path.splitext(featureclass)[1]).partition("_") [2] arcpy.AddField_management (featureclass, "Down", "SHORT") arcpy.CalculateField_management (featureclass, "Down", "!MAXADDOWN!", "PYTHON") arcpy.Union_analysis (featureclass, "temp_union_" + fcName, "ALL") arcpy.Sort_management ("temp_union_" + fcName, "temp_union_sort" + fcName, [["Down", "DESCENDING"]]) arcpy.AddField_management ("temp_union_sort" + fcName, "XCOORD", "DOUBLE") arcpy.AddField_management ("temp_union_sort" + fcName, "YCOORD", "DOUBLE") arcpy.CalculateField_management ("temp_union_sort" + fcName, "XCOORD", "!SHAPE.CENTROID!.split()[0]", "PYTHON") arcpy.CalculateField_management ("temp_union_sort" + fcName, "YCOORD", "!SHAPE.CENTROID!.split()[1]", "PYTHON") arcpy.Dissolve_management ("temp_union_sort" + fcName, "temp_union_sort_dz" + fcName, ["XCOORD", "YCOORD", "SHAPE_Area"], "Down FIRST", "MULTI_PART", "") arcpy.Dissolve_management ("temp_union_sort_dz" + fcName, "fc_mt_final_" + fcName + "_max_speed", ["FIRST_Down"], "", "MULTI_PART", "")
def main(huc_poly, in_hydro, seg_length, outFGB): DeleteTF = "true" # clip stream lines to huc polygon boundaries. arcpy.AddMessage("Clipping the stream network to the HUC boundaries...") clip_hydro = arcpy.Clip_analysis(in_hydro, huc_poly, r"in_memory\clip_hydro") # segmentation of the polyline arcpy.AddMessage( "Using the SLEM script to segment the polyline feature...") SplitLine = dS.SLEM(clip_hydro, seg_length, r"in_memory\SplitLine", DeleteTF) arcpy.AddMessage("Sorting the segmented line...") outSort = outFGB + r"\segments" arcpy.Sort_management( SplitLine, outSort, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.AddField_management(outSort, "Rank_DGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED") fieldname = [f.name for f in arcpy.ListFields(outSort)] arcpy.CalculateField_management(outSort, "Rank_DGO", "!" + str(fieldname[0]) + "!", "PYTHON_9.3") #delete temporary files arcpy.AddMessage("Deleting temporary files...") arcpy.Delete_management(SplitLine) # merges adjacent stream segments if one is less than threshold. arcpy.AddMessage("Cleaning line segments...") clusterTolerance = float(seg_length) * 0.25 clean_stream = cS.cleanLineGeom(outSort, "Rank_UGO", "Rank_DGO", clusterTolerance) arcpy.AddField_management(clean_stream, "LineOID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED") arcpy.CalculateField_management(clean_stream, "LineOID", '"!OBJECTID!"', "PYTHON_9.3") arcpy.DeleteField_management(clean_stream, "Rank_UGO") arcpy.DeleteField_management(clean_stream, "Rank_DGO") return clean_stream
def segOptionA(in_hydro, seg_length, outFGB, outSegmentIDField="SegmentID", scratchWorkspace="in_memory"): """Segment the input stream network feature class using 'remainder at inflow of reach' method.""" arcpy.AddMessage( "Segmenting process using the remainder at stream branch inflow method..." ) DeleteTF = "true" # Segmentation of the polyline using module from Fluvial Corridors toolbox. splitLine = dS.SLEM(in_hydro, seg_length, scratchWorkspace + r"\splitLine", DeleteTF) outSort = scratchWorkspace + r"\segments_sort" arcpy.Sort_management( splitLine, outSort, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.AddField_management(outSort, "Rank_DGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED") fieldname = [f.name for f in arcpy.ListFields(outSort)] arcpy.CalculateField_management(outSort, "Rank_DGO", "!" + str(fieldname[0]) + "!", "PYTHON_9.3") # Merges adjacent stream segments if less than 75% length threshold. clusterTolerance = float(seg_length) * 0.25 clean_stream = cleanLineGeom(outSort, "Rank_UGO", "Rank_DGO", clusterTolerance) arcpy.AddField_management(clean_stream, outSegmentIDField, "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED") arcpy.CalculateField_management(clean_stream, outSegmentIDField, '"!OBJECTID!"', "PYTHON_9.3") arcpy.DeleteField_management(clean_stream, "Rank_UGO") arcpy.DeleteField_management(clean_stream, "Rank_DGO") # Clean up del splitLine del outSort return clean_stream
def CreateRouteEventLayer(Sites_Routes, AttTable, RouteID, BMP, EMP, Fields, Output): IRIS_Diss = common.CreateOutPath(MainFile=Output, appendix='diss', Extension='') arcpy.DissolveRouteEvents_lr( in_events=AttTable, in_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]), dissolve_field=';'.join(Fields), out_table=IRIS_Diss, out_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]), dissolve_type="DISSOLVE", build_index="INDEX") Overlay_Event_Layer = common.CreateOutLayer('OverlayEventLayer') arcpy.MakeRouteEventLayer_lr(in_routes=Sites_Routes, route_id_field=RouteID, in_table=IRIS_Diss, in_event_properties=' '.join( [RouteID, 'LINE', BMP, EMP]), out_layer=Overlay_Event_Layer, offset_field="", add_error_field="ERROR_FIELD") Sort = common.CreateOutPath(MainFile=Output, appendix='sort', Extension='') arcpy.Sort_management(in_dataset=Overlay_Event_Layer, out_dataset=Sort, sort_field=';'.join([RouteID, BMP, EMP])) Final_Layer = common.CreateOutLayer('FinalLayer') arcpy.MakeFeatureLayer_management(in_features=Sort, out_layer=Final_Layer) arcpy.SelectLayerByAttribute_management(in_layer_or_view=Final_Layer, selection_type='NEW_SELECTION', where_clause="Shape_Length > 0") arcpy.Delete_management(Output) arcpy.CopyFeatures_management(in_features=Final_Layer, out_feature_class=Output) arcpy.Delete_management(IRIS_Diss) arcpy.Delete_management(Overlay_Event_Layer) arcpy.Delete_management(Sort) arcpy.Delete_management(Final_Layer)
def extract_by_proximity(multipt, targetpt, npts, output_file): #set local vars n=npts # copy in_memory files to local variables for the function arcpy.CopyFeatures_management(multipt, "in_memory//test_cloud_copy") arcpy.CopyFeatures_management(targetpt, "in_memory//singlepointcopy") single_pt_copy = "in_memory//singlepointcopy" test_cloud_copy = "in_memory//test_cloud_copy" ########################################################## # use near 3d to append distance data to the pt_cloud points # check out the exenstion arcpy.CheckOutExtension("3D") # apply the extension arcpy.Near3D_3d(test_cloud_copy,single_pt_copy, angle="ANGLE") # check in the extension arcpy.CheckInExtension("3D") ########################################################## # sort the resulting output shp table by distance arcpy.Sort_management(test_cloud_copy,"in_memory//test_cloud_copy_sorted",sort_field="NEAR_DIST3 ASCENDING", spatial_sort_method="UR") test_cloud_copy_sorted = "in_memory//test_cloud_copy_sorted" ##################################################################### # extract the lowest n table entries and save as the final output file arcpy.Select_analysis(test_cloud_copy_sorted,output_file, '"FID"<' + str(n+1)) #print("Proximity analysis: Complete. Closest " + str(n) + " points extracted.") return output_file;
u"FID", u"OBJECTID", u"Shape", u"INCSTRLEN", u"STRING2DBL", u"Field2", u"Field5", u"INT2DBL", u"INDEX" ] print("Keeping ", keepfield) # empty list Drop_Field = [] # Compile list of fields to delete for field in fieldlist2: if field not in keepfield: Drop_Field.append(field) print("dropping ", Drop_Field) # Delete unwanted fields arcpy.DeleteField_management(files.copy, Drop_Field) print("fields deleted") # Sort records by geographic location arcpy.Sort_management(files.copy, files.final, "Shape ASCENDING", "UL") print("points sorted") # Assign new ID number to points Code_Block = "rec=0 \\ndef autoIncrement(): \\n global rec \\n pStart = 1 \\n pInterval = 1 \\n if (rec == 0): \\n rec = pStart \\n else: \\n rec += pInterval \\n return rec" arcpy.CalculateField_management(files.final, "INDEX", "autoIncrement()", "PYTHON_9.3", Code_Block) print("new id assigned") # If more than 10 points in obstruction file, extract smaller cells as individual shapefiles # count points in sorted (final) file. featureclass = files.final variable = "INDEX" features = Stereoframework.Features(featureclass) # set coordinates system of fishnet # env.outputCoordinateSystem = features.coord_sys() # Count all points in file
# Set workspace and environment variables arcpy.env.workspace = inGDB arcpy.env.overwriteOutput = True arcpy.AddMessage("Searching the input workspace now...") fcList = arcpy.ListFeatureClasses("*", "point") fcCount = len(fcList) arcpy.AddMessage("There are {0} layers in the workspace".format(fcCount)) # Set the progressor arcpy.SetProgressor("step", "Sorting now...", 0, fcCount, 1) for fc in fcList: try: outPath = os.path.join(inGDB + "\\" + fc + "_sorted") arcpy.Sort_management(fc, outPath, [["ApplicationNumber", "ASCENDING"]]) arcpy.SetProgressorPosition() arcpy.AddMessage("{0} has been sorted".format(fc)) except: arcpy.AddMessage("{0} has a problem".format(fc)) arcpy.SetProgressorPosition() arcpy.AddMessage("Sort is complete.")
#The annual average solar radiation map is given and the annual average precipitation maps are used for this analysis arcpy.AddMessage("Starting solar power plant analysis....") #As the first step, the two shapefiles are merged, using identity analysis arcpy.Identity_analysis(datapath+"CASolar.shp",datapath+"Rainfall.shp", temp+"CASolRain.shp") #Make a temporary layer for selection analysis arcpy.MakeFeatureLayer_management(temp+"CASolRain.shp", temp+"CASol_lyr") #Filter the combined shapefile to remove the locations of existing solar projects, culturally sensitive lands, military lands, and potential wilderness filter_areas(temp+"CASol_lyr", "solar") #The solar file is sorted on high annual average solar radiation, followed by low annual average rainfall arcpy.Sort_management(temp+"CASol_lyr", temp+"CASolarSorted.shp", [[ "GHIANN", "DESCENDING"], ["RANGE", "ASCENDING"]]) arcpy.Delete_management(temp+"CASol_lyr") arcpy.Delete_management(temp+"CASolRain.shp") #Solar power plant energy generation calculation: #Area: Each power plant is assumed to be of 2000 acre size = 8.09X10^6 sq. m #Efficiency: The conversion efficiency from insolation to electricity is assumed to be 20% #The annual electricity generated in GWh = [(Annual GHI in kWh/sq.m-day) * Area (sq.m) * Efficiency * 365 days]/1000 #The constant multiplier is approx. 0.6 #Create a shapefile for new solar locations arcpy.CreateFeatureclass_management(newpath, "New_Solar.shp", "POINT", "", "DISABLED", "DISABLED", temp+"CASolarSorted.shp") arcpy.AddField_management(newpath+"New_Solar.shp", "GHIANN", "LONG") soldesc = arcpy.Describe(newpath+"New_Solar.shp") solshapename = soldesc.shapeFieldName
if str(DeleteTF) == "true": nstep += 1 ncurrentstep = 1 #/segmentation of the polyline arcpy.AddMessage( "Using the SLEM script to segment the in-polyline feature - Step " + str(ncurrentstep) + "/" + str(nstep)) SplitLine = dS.SLEM(inFC, SegmentationStep, "%ScratchWorkspace%\\SplitLine", ScratchW, DeleteTF) ncurrentstep += 1 arcpy.AddMessage("Sorting the segmented line - Step " + str(ncurrentstep) + "/" + str(nstep)) Sort = arcpy.Sort_management( SplitLine, OutputSeg, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.AddField_management(Sort, "Rank_DGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED") fieldname = [f.name for f in arcpy.ListFields(Sort)] arcpy.CalculateField_management(Sort, "Rank_DGO", "!" + str(fieldname[0]) + "!", "PYTHON_9.3") #=============================================================================== # DELETING TEMPORARY FILES #=============================================================================== if str(DeleteTF) == "true": ncurrentstep += 1 arcpy.AddMessage("Deleting Temporary Files - Step " +
def main(): ''' main ''' #UPDATE # Create a feature layer from the input point features if it is not one already #df = arcpy.mapping.ListDataFrames(mxd)[0] pointFeatureName = os.path.basename(pointFeatures) layerExists = False try: # Check that area to number is a polygon descArea = arcpy.Describe(areaToNumber) areaGeom = descArea.shapeType arcpy.AddMessage("Shape type: " + str(areaGeom)) if (descArea.shapeType != "Polygon"): raise Exception("ERROR: The area to number must be a polygon.") gisVersion = arcpy.GetInstallInfo()["Version"] global appEnvironment appEnvironment = Utilities.GetApplication() if DEBUG == True: arcpy.AddMessage("App environment: " + appEnvironment) global mxd global df global aprx global mp global mapList # mxd, df, aprx, mp = None, None, None, None #if gisVersion == "1.0": #Pro: if appEnvironment == "ARCGIS_PRO": from arcpy import mp aprx = arcpy.mp.ArcGISProject("CURRENT") mapList = aprx.listMaps()[0] for lyr in mapList.listLayers(): if lyr.name == pointFeatureName: layerExists = True #else: if appEnvironment == "ARCMAP": from arcpy import mapping mxd = arcpy.mapping.MapDocument('CURRENT') df = arcpy.mapping.ListDataFrames(mxd)[0] for lyr in arcpy.mapping.ListLayers(mxd): if lyr.name == pointFeatureName: layerExists = True if layerExists == False: arcpy.MakeFeatureLayer_management(pointFeatures, pointFeatureName) else: pointFeatureName = pointFeatures # Select all the points that are inside of area arcpy.AddMessage("Selecting points from (" + str(os.path.basename(pointFeatureName)) +\ ") inside of the area (" + str(os.path.basename(areaToNumber)) + ")") selectionLayer = arcpy.SelectLayerByLocation_management(pointFeatureName, "INTERSECT", areaToNumber, "#", "NEW_SELECTION") if DEBUG == True: arcpy.AddMessage("Selected " + str(arcpy.GetCount_management(pointFeatureName).getOutput(0)) + " points") # If no output FC is specified, then set it a temporary one, as this will be copied to the input and then deleted. # Sort layer by upper right across and then down spatially, overwriteFC = False global outputFeatureClass if outputFeatureClass == "": outputFeatureClass = "tempSortedPoints" overwriteFC = True; arcpy.AddMessage("Sorting the selected points geographically, right to left, top to bottom") arcpy.Sort_management(selectionLayer, outputFeatureClass, [["Shape", "ASCENDING"]]) # Number the fields arcpy.AddMessage("Numbering the fields") i = 1 cursor = arcpy.UpdateCursor(outputFeatureClass) for row in cursor: row.setValue(numberingField, i) cursor.updateRow(row) i += 1 # Clear the selection arcpy.AddMessage("Clearing the selection") arcpy.SelectLayerByAttribute_management(pointFeatureName, "CLEAR_SELECTION") # Overwrite the Input Point Features, and then delete the temporary output feature class targetLayerName = "" if (overwriteFC): arcpy.AddMessage("Copying the features to the input, and then deleting the temporary feature class") desc = arcpy.Describe(pointFeatureName) overwriteFC = os.path.join(os.path.sep, desc.path, pointFeatureName) fields = (numberingField, "SHAPE@") overwriteCursor = arcpy.da.UpdateCursor(overwriteFC, fields) for overwriteRow in overwriteCursor: sortedPointsCursor = arcpy.da.SearchCursor(outputFeatureClass, fields) for sortedRow in sortedPointsCursor: if sortedRow[1].equals(overwriteRow[1]): overwriteRow[0] = sortedRow[0] overwriteCursor.updateRow(overwriteRow) arcpy.Delete_management(outputFeatureClass) #UPDATE #if layerExists == False: #layerToAdd = arcpy.mapping.Layer(pointFeatureName) #arcpy.mapping.AddLayer(df, layerToAdd, "AUTO_ARRANGE") targetLayerName = pointFeatureName else: #UPDATE #layerToAdd = arcpy.mapping.Layer(outputFeatureClass) #arcpy.mapping.AddLayer(df, layerToAdd, "AUTO_ARRANGE") targetLayerName = os.path.basename(outputFeatureClass) # Get and label the output feature if appEnvironment == "ARCGIS_PRO": results = arcpy.MakeFeatureLayer_management(outputFeatureClass, targetLayerName).getOutput(0) mapList.addLayer(results, "AUTO_ARRANGE") layer = findLayerByName(targetLayerName) if(layer): labelFeatures(layer, numberingField) elif appEnvironment == "ARCMAP": arcpy.AddMessage("Adding features to map (" + str(targetLayerName) + ")...") arcpy.MakeFeatureLayer_management(outputFeatureClass, targetLayerName) layer = arcpy.mapping.Layer(targetLayerName) arcpy.mapping.AddLayer(df, layer, "AUTO_ARRANGE") arcpy.AddMessage("Labeling output features (" + str(targetLayerName) + ")...") layer = findLayerByName(targetLayerName) if (layer): labelFeatures(layer, numberingField) else: arcpy.AddMessage("Non-map application, skipping labeling...") arcpy.SetParameter(3, outputFeatureClass) except arcpy.ExecuteError: # Get the tool error messages msgs = arcpy.GetMessages() arcpy.AddError(msgs) print(msgs) except: # Get the traceback object tb = sys.exc_info()[2] tbinfo = traceback.format_tb(tb)[0] # Concatenate information together concerning the error into a message string pymsg = "PYTHON ERRORS:\nTraceback info:\n" + tbinfo + "\nError Info:\n" + str(sys.exc_info()[1]) msgs = "ArcPy ERRORS:\n" + arcpy.GetMessages() + "\n" # Return python error messages for use in script tool or Python Window arcpy.AddError(pymsg) arcpy.AddError(msgs) # Print Python error messages for use in Python / Python Window print(pymsg + "\n") print(msgs)
def createSegments(contour_at_mean_high_water, contour_at_surge): # Start a timer time1 = time.clock() arcpy.AddMessage("\nSegmentation of the coastline started at "+str(datetime.now())) # Specify a tolerance distance or minimum length of a seawall # Users are not yet given control of this th = 150 # Create random points along the lines (mean high water and the surge of choice) # The numbers used are just my choice based on iterative observations random0 = arcpy.CreateRandomPoints_management(out_path= arcpy.env.workspace, \ out_name= "random0", \ constraining_feature_class= contour_at_mean_high_water, \ number_of_points_or_field= long(1600), \ minimum_allowed_distance = "{0} Feet".format(th)) random1 = arcpy.CreateRandomPoints_management(out_path= arcpy.env.workspace, \ out_name= "random1", \ constraining_feature_class= contour_at_surge, \ number_of_points_or_field= long(1600), \ minimum_allowed_distance = "{0} Feet".format(th)) # Perform a proximity analysis with the NEAR tool arcpy.Near_analysis(random0, random1) # Give each point a fixed unique ID # Create the ID field arcpy.AddField_management (random0, "UniqueID", "SHORT") arcpy.AddField_management (random1, "UniqueID", "SHORT") # Add Unique IDs arcpy.CalculateField_management(random0, "UniqueID", "[FID]") arcpy.CalculateField_management(random1, "UniqueID", "[FID]") # Categorize/Separate each feature based on their near feature # Crate a table view of random0 table0 = arcpy.MakeTableView_management(random0, "random0_table") #table1 = arcpy.MakeTableView_management(random1, "random1_table") # Sort the near feature for each points in random0 random0_sorted = arcpy.Sort_management(table0, "random0_sorte.dbf", [["NEAR_FID", "ASCENDING"]]) # Create "long enough" lists for each of the field of interests: ID, NEAR_ID, and NEAR_DIST # (distance to closest point). I added [99999] here to extend the list length and avoid IndexError list_fid = [r.getValue("UniqueID") for r in arcpy.SearchCursor(random0_sorted, ["UniqueID"])] +[99999] list_nearid = [r.getValue("NEAR_FID") for r in arcpy.SearchCursor(random0_sorted, ["NEAR_FID"])]\ +[99999] list_neardist = [r.getValue("NEAR_DIST") for r in arcpy.SearchCursor(random0_sorted, ["NEAR_DIST"])]\ +[99999] del r # Only take points with near feature within the specified threshold. If it's too far, it's not better # than the others for a segment point list_fid_filtered = [i for i in list_neardist if i < th] # Then initiate a list o contain their Unique ID and Near ID first_unique_id = [] first_near_id = [] # Get NEAR_ID and Unique ID for each of these points for i in list_fid_filtered: first_unique_id.append(list_fid[list_neardist.index(i)]) first_near_id.append(list_nearid[list_neardist.index(i)]) # Only take the unique values in case there are duplicates. This shoudn't happen. Just to make sure. first_unique_id = [i for i in set(first_unique_id)] first_near_id = [i for i in set(first_near_id)] # Now create a new feature out of these points # Frist let's create a Feature Layer arcpy.MakeFeatureLayer_management("random0.shp", "random0_lyr") # Let's select all points and export them into a new feature random0_points = arcpy.SearchCursor(random0, ["UniqueID"]) point0 = random0_points.next() for point0 in random0_points: for i in range(len(first_unique_id)): if point0.getValue("UniqueID") == first_unique_id[i]: selector0 = arcpy.SelectLayerByAttribute_management(\ "random0_lyr", "ADD_TO_SELECTION", '"UniqueID" = {0}'.format(first_unique_id[i])) del point0, random0_points new_random0 = arcpy.CopyFeatures_management(selector0, "new_random0") arcpy.Delete_management('random0_lyr') # Now for the new point feature, remove clusters of points around them and take only the ones # with minimum NEAR_DIST # First, get the geometry attributes of the new points arcpy.AddGeometryAttributes_management(new_random0, "POINT_X_Y_Z_M", "", "", "") # Create long enough list of the field of interest (same as the previous) pointx = [r.getValue("POINT_X") for r in arcpy.SearchCursor(new_random0, ["POINT_X"])] +[99999] pointy = [r.getValue("POINT_Y") for r in arcpy.SearchCursor(new_random0, ["POINT_Y"])] +[99999] new_list_fid = [r.getValue("UniqueID") for r in arcpy.SearchCursor(new_random0, ["UniqueID"])]\ +[99999] new_list_nearid = [r.getValue("NEAR_FID") for r in arcpy.SearchCursor(new_random0, ["NEAR_FID"])]\ +[99999] new_list_neardist = [r.getValue("NEAR_DIST") for r in arcpy.SearchCursor(new_random0, ["NEAR_DIST"])]\ +[99999] del r # Initiate a list of every points that has already been compared to the near points garbage = [] # Also initiate a list for the new Unique ID and NEAR ID new_unique_ID = [] new_near_ID = [] # Then, check if the points are right next to them. If so, add them to a temporary list # and find the one with closest near ID (or find minimum of their NEAR_DIST) for i in range(len(pointx)): if i+1 < len(pointx): # If not within the th range if not calculateDistance(pointx[i], pointy[i], pointx[i+1], pointy[i+1]) < float(th)*1.5: # Skip if it's in garbage if new_list_nearid[i] in garbage: continue else: new_unique_ID.append(new_list_fid[i]) new_near_ID.append(new_list_nearid[i]) # If within the range else: # Skip if it's in garbage if new_list_nearid[i] in garbage: continue else: temp_ID = [] temp_NEAR = [] temp_DIST = [] while True: temp_ID.append(new_list_fid[i]) temp_NEAR.append(new_list_nearid[i]) temp_DIST.append(new_list_neardist[i]) garbage.append(new_list_nearid[i]) i = i+1 # Stop when within the range again. And add the last point within the range if not calculateDistance(pointx[i], pointy[i], pointx[i+1], pointy[i+1]) < 200: temp_ID.append(new_list_fid[i]) temp_NEAR.append(new_list_nearid[i]) temp_DIST.append(new_list_neardist[i]) garbage.append(new_list_nearid[i]) # Calculate the minimum and get the Unique ID and Near ID minD = min(temp_DIST) new_unique_ID.append(new_list_fid[new_list_neardist.index(minD)]) new_near_ID.append(new_list_nearid[new_list_neardist.index(minD)]) del temp_ID, temp_NEAR, temp_DIST break # Now select these final points export them into new feature. # These are the end points for the segments to be created # First, make a layer out of all the random points arcpy.MakeFeatureLayer_management("random0.shp", "random0_lyr") arcpy.MakeFeatureLayer_management("random1.shp", "random1_lyr") # Then select and export the end points into feature0 and feature1 # Based on new_unique_ID for random0 random0_points = arcpy.SearchCursor(random0, ["UniqueID"]) point0 = random0_points.next() for point0 in random0_points: for i in range(len(new_unique_ID)): if point0.getValue("UniqueID") == new_unique_ID[i]: selected0 = arcpy.SelectLayerByAttribute_management(\ "random0_lyr", "ADD_TO_SELECTION", '"UniqueID" = {0}'.format(new_unique_ID[i])) feature0 = arcpy.CopyFeatures_management(selected0, "feature0") # Based on new_near_ID for random1 random1_points = arcpy.SearchCursor(random1, ["UniqueID"]) point1 = random1_points.next() for point1 in random1_points: for k in range(len(new_near_ID)): if point1.getValue("UniqueID") == new_near_ID[k]: selected1 = arcpy.SelectLayerByAttribute_management(\ "random1_lyr", "ADD_TO_SELECTION", '"UniqueID" = {0}'.format(new_near_ID[k])) feature1 = arcpy.CopyFeatures_management(selected1, "feature1") del point0, point1, random0_points, random1_points arcpy.Delete_management('random0_lyr') arcpy.Delete_management('random1_lyr') # Now for the actual create of the coastal segments # Which include creation of polygon and splitting the contours as the corresponding points # STEPS NECESSARY FOR POLYGON CREATION # Let's first add geometry attributes to these points arcpy.AddGeometryAttributes_management(feature0, "POINT_X_Y_Z_M", "", "", "") arcpy.AddGeometryAttributes_management(feature1, "POINT_X_Y_Z_M", "", "", "") # Let's create lines that connects points from feature0 to feature1 # Initiate a POLYLINE feature class for these lines arcpy.CreateFeatureclass_management (arcpy.env.workspace, "connector_lines.shp", "POLYLINE") # Then for each of the points in feature0, get the correspondingin feature1 # And create a line for each of the two points with arcpy.da.SearchCursor(feature0, ["NEAR_FID", "POINT_X", "POINT_Y"]) as features0: for feat0 in features0: with arcpy.da.SearchCursor(feature1, ["UniqueID", "POINT_X", "POINT_Y"]) as features1: x=0 for feat1 in features1: x = x+1 theseTwoPoints = [] if feat0[0] == feat1[0]: # Get coordinates X0, Y0 = feat0[1], feat0[2] X1, Y1 = feat1[1], feat1[2] # Append coordinates theseTwoPoints.append(arcpy.PointGeometry(arcpy.Point(X0, Y0))) theseTwoPoints.append(arcpy.PointGeometry(arcpy.Point(X1, Y1))) # Create line from the coordinates subline = arcpy.PointsToLine_management(theseTwoPoints, "subline"+str(x)+".shp") # Append all lines into one feature lines = arcpy.Append_management(["subline"+str(x)+".shp"], "connector_lines.shp") # Then delete subline as it's now unnecessary arcpy.Delete_management(subline) continue del feat0, feat1, features0, features1 # Now that the connectors are created, let's split the segments # Before splitting contours into segments, let's integrate the points and the segments # Just in case, there are misalignment arcpy.Integrate_management([contour_at_mean_high_water, feature0]) arcpy.Integrate_management([contour_at_surge, feature1]) segments0 = arcpy.SplitLineAtPoint_management(contour_at_mean_high_water, feature0, "segments0.shp", "10 Feet") segments1 = arcpy.SplitLineAtPoint_management(contour_at_surge, feature1, "segments1.shp", "10 Feet") # And let's give fixed unique ID for each segment arcpy.CalculateField_management(segments0, "Id", "[FID]") arcpy.CalculateField_management(segments1, "Id", "[FID]") # Now with the split segments and connector lines, let's make segment polygon of the segments almost_segment_polygons = arcpy.FeatureToPolygon_management([segments0, segments1, lines],\ "almost_segment_polygons.shp") # Adding unique ID to the segment polygons arcpy.CalculateField_management(almost_segment_polygons, "Id", "[FID]") # The Feature to Polygon process also created polygons that are surrounded by polygons # These are because these areas are surrounded by flooded areas at surge. # They are above the surge and technically safe. So, let's remove them. arcpy.MakeFeatureLayer_management(almost_segment_polygons, 'almost_segment_polygons_lyr') arcpy.MakeFeatureLayer_management(segments0, 'segments0_lyr') # Only the polygons within the mean_high_water segments are at risk arcpy.SelectLayerByLocation_management('almost_segment_polygons_lyr', 'INTERSECT', 'segments0_lyr') final_without_length = arcpy.CopyFeatures_management('almost_segment_polygons_lyr', 'final.shp') arcpy.Delete_management('segments0_lyr') arcpy.Delete_management('almost_segment_polygons_lyr') # For the new polygons, let's add the corresponding seawall length # Let's add Length field to both first arcpy.AddField_management(final_without_length, "Length", "SHORT") arcpy.AddField_management(segments0, "Length", "SHORT") # Calculation of the length with arcpy.da.UpdateCursor(segments0, ["SHAPE@LENGTH", "Length"]) as segments_0: for segment_0 in segments_0: length = segment_0[0] segment_0[1] = length segments_0.updateRow(segment_0) del segment_0, segments_0 # With spatial join, let's add these results to the segment polygons final = spatialJoin(final_without_length, segments0, "Length", "Length", "max", "joined_segment.shp") # Delete the created but now unnecessary files arcpy.Delete_management(random0) arcpy.Delete_management(random1) # Stop the timer time2 = time.clock() arcpy.AddMessage("Seawall segments and regions successfully created. It took "\ +str(time2-time1)+" seconds") return final
predictor = "pre1;pre2;pre3;pre4;pre5" arcpy.GeographicallyWeightedRegression_stats( spatialJoin_result, "DV", predictor, GWR_result, "ADAPTIVE", "BANDWIDTH PARAMETER", "#", "50", "#", "#", "#", "#", "#", "#") # reclassify GWR predicted value and get the FUI classification # Replicate the GWR result GWR_reclassify = output arcpy.Copy_management(GWR_result, GWR_reclassify) arcpy.AddField_management(GWR_reclassify, "ESI", "DOUBLE", 20, 5) # get the min and max predicted values GWR_min = GWR_reclassify[:-4] + "_min.shp" GWR_max = GWR_reclassify[:-4] + "_max.shp" arcpy.Sort_management(GWR_reclassify, GWR_min, [["Predicted", "ASCENDING"]]) arcpy.Sort_management(GWR_reclassify, GWR_max, [["Predicted", "DESCENDING"]]) enumeration_min = arcpy.SearchCursor(GWR_min) minValue = enumeration_min.next().getValue("Predicted") arcpy.AddMessage("Minimum predicted value: " + str(minValue) + "\n") enumeration_max = arcpy.SearchCursor(GWR_max) maxValue = enumeration_max.next().getValue("Predicted") arcpy.AddMessage("Maximum predicted value: " + str(maxValue) + "\n") increase = (maxValue - minValue) / 4 first = increase + minValue second = increase * 2 + minValue third = increase * 3 + minValue
"OID@", "CATCHMENT_ID", "Ground_Sum", "Understory_Sum", "Overstory_Sum" ] ##search_fields = ["OID@","CATCHMENT_ID","ZonalSt_"+naming[:4]+"1","ZonalSt_"+naming[:4]+"2","ZonalSt_"+naming[:4]+"3"] update_fields = [ "OID@", "SHAPE@AREA", "GROUND_COUNT", "UNDER_COUNT", "OVER_COUNT", "Percent_Ground", "Percent_Understory", "Percent_Overstory" ] modelist_ground = [] modelist_under = [] modelist_over = [] #sort random points by cid so that cursor works sorttable = os.path.join(env.workspace, naming + "_sorttable_") arcpy.Sort_management(randos, sorttable, [["CATCHMENT_ID", "ASCENDING"]]) CID_counter = 0 previous_CID = None arcpy.AddMessage("Calculating Veg Stats...") # iterate through points sorted by catchment id with arcpy.da.SearchCursor(sorttable, (search_fields)) as search: for row in search: ## arcpy.AddMessage("CID is "+str(row[1])) if row[1] != previous_CID or CID_counter > 0: #append points to li st for mode calculation modelist_ground.append(row[2])
ddp.currentPageID = ddp.getPageIDFromName(PIN) #Graphic table variable values tableHeight = 3 tableWidth = 2.4 headerHeight = 0.2 rowHeight = 0.15 upperX = 8.1 upperY = 7.2 #Build selection set numRecords = int(arcpy.GetCount_management(FreqTable).getOutput(0)) print "\t\tRecords in ag use by soil type table: " + str(numRecords) #Sort selection arcpy.Sort_management(FreqTable, r'in_memory\sort1', [["TYPE", "ASCENDING"]]) #Add note if there are no records > 100% if numRecords == 0: noGrowth.elementPositionX = 3 noGrowth.elementPositionY = 2 else: #if number of rows exceeds page space, resize row height if ((tableHeight - headerHeight) / numRecords) < rowHeight: headerHeight = headerHeight * ( (tableHeight - headerHeight) / numRecords) / rowHeight rowHeight = (tableHeight - headerHeight) / numRecords else: pass #Set and clone vertical line work
startPos = "LL" elif (labelStartPos == "Lower-Right"): startPos = "LR" # Import the custom toolbox with the fishnet tool in it, and run this. This had to be added to a model, # because of a bug, which will now allow you to pass variables to the Create Fishnet tool. #UPDATE toolboxPath = os.path.dirname(sysPath) + "\\Clearing Operations Tools.tbx" arcpy.ImportToolbox(toolboxPath) arcpy.AddMessage("Creating Fishnet Grid") arcpy.Fishnet_ClearingOperations(tempOutput, originCoordinate, yAxisCoordinate, str(cellWidth), str(cellHeight), 0, 0, oppCornerCoordinate, "NO_LABELS", templateExtent, "POLYGON") # Sort the grid upper left to lower right, and delete the in memory one arcpy.AddMessage("Sorting the grid for labeling") tempSort = "tempSort" arcpy.Sort_management(tempOutput, tempSort, [["Shape", "ASCENDING"]], startPos) arcpy.Delete_management("in_memory") # Add a field which will be used to add the grid labels arcpy.AddMessage("Adding field for labeling the grid") gridField = "Grid" arcpy.AddField_management(tempSort, gridField, "TEXT") # Number the fields arcpy.AddMessage("Numbering the grids") letterIndex = 1 secondLetterIndex = 1 letter = 'A' secondLetter = 'A' number = 1 lastY = -9999
def generate_route_border_rule_table(workspace,route,route_id_field,boundary,boundary_id_field,buffer_size,route_border_rule_table,high_angle_threshold,offset): arcpy.AddMessage("Generating route border rule source table for {1}...".format(boundary)) try: date = datetime.now() date_string = date.strftime("%m/%d/%Y") spatial_reference = arcpy.Describe(route).spatialReference xy_resolution = "{0} {1}".format(spatial_reference.XYResolution,spatial_reference.linearUnitName) ############################################################################################################### # get all candidate border routes arcpy.AddMessage("Identifying candidate border routes...") # generate boundary border boundary_border = os.path.join(workspace,"{0}_{1}_border".format(boundary,"boundary")) arcpy.FeatureToLine_management(boundary, boundary_border) # dissolve polygon boundary based on boundary id boundary_border_dissolved = os.path.join(workspace,"{0}_boundary_border_dissolved".format(boundary)) arcpy.Dissolve_management(boundary_border,boundary_border_dissolved,[boundary_id_field]) # generate buffer around boundary # arcpy.AddMessage("generate buffer around boundary") boundary_border_buffer = os.path.join(workspace,"{0}_{1}".format(boundary,"boundary_buffer")) arcpy.Buffer_analysis(boundary_border_dissolved, boundary_border_buffer, buffer_size, "FULL", "ROUND") # get candidate border route # arcpy.AddMessage("get candidate border route") candidate_border_route_multipart = "in_memory\\candidate_{0}_border_route_multipart".format(boundary) candidate_border_route = os.path.join(workspace,"candidate_{0}_border_route".format(boundary)) arcpy.Clip_analysis(route, boundary_border_buffer, candidate_border_route_multipart) arcpy.MultipartToSinglepart_management(candidate_border_route_multipart, candidate_border_route) ################################################################################################################ ################################################################################################################ # filter out candidate border routes that 'intersects' boundary at high angles arcpy.AddMessage("Filtering out candidate border routes that 'intersects' boundary at high angles...") route_buffer = os.path.join(workspace,"{0}_{1}".format(route,"buffer_flat")) if not arcpy.Exists(route_buffer): arcpy.Buffer_analysis(route, route_buffer, buffer_size, "FULL", "FLAT") # clip boundary segments within route buffer boundary_border_within_buffer_multipart = "in_memory\\{0}_boundary_within_{1}_buffer_multipart".format(boundary,route) boundary_border_within_buffer = os.path.join(workspace,"{0}_boundary_within_{1}_buffer".format(boundary,route)) arcpy.Clip_analysis(boundary_border_dissolved, route_buffer, boundary_border_within_buffer_multipart) arcpy.MultipartToSinglepart_management(boundary_border_within_buffer_multipart, boundary_border_within_buffer) # Add 'SEGMENT_ID_ALL_CANDIDATES' field to candidate route and populate it with 'OBJECTID' arcpy.AddField_management(candidate_border_route,"SEGMENT_ID_ALL_CANDIDATES","LONG") arcpy.CalculateField_management(candidate_border_route, "SEGMENT_ID_ALL_CANDIDATES", "!OBJECTID!", "PYTHON") # Add 'ANGLE_ROUTE' field to candidate route and populate it with the angle to the true north(= 0 degree) arcpy.AddField_management(candidate_border_route,"ANGLE_ROUTE","DOUBLE") with arcpy.da.UpdateCursor(candidate_border_route,("SHAPE@","ANGLE_ROUTE")) as uCur: for row in uCur: shape = row[0] x_first = shape.firstPoint.X y_first = shape.firstPoint.Y x_last = shape.lastPoint.X y_last = shape.lastPoint.Y angle = calculate_angle(x_first,y_first,x_last,y_last) if angle >=0: row[1]=angle uCur.updateRow(row) # Add 'ANGLE_BOUNDARY' field to boundary segment within route buffer and populate it with the angle to the true north(= 0 degree) arcpy.AddField_management(boundary_border_within_buffer,"ANGLE_BOUNDARY","DOUBLE") with arcpy.da.UpdateCursor(boundary_border_within_buffer,("SHAPE@","ANGLE_BOUNDARY")) as uCur: for row in uCur: shape = row[0] x_first = shape.firstPoint.X y_first = shape.firstPoint.Y x_last = shape.lastPoint.X y_last = shape.lastPoint.Y angle = calculate_angle(x_first,y_first,x_last,y_last) if angle: row[1]=angle uCur.updateRow(row) del uCur # locate boundary segment within buffer along candidate border route. # assuming that if the boundary segment can't be located along its corresponding route, these two might have high angles. boundary_along_candidate_border_route = os.path.join(workspace,"{0}_boundary_along_candidate_{1}_border_route".format(boundary,boundary)) arcpy.LocateFeaturesAlongRoutes_lr(boundary_border_within_buffer,candidate_border_route,"SEGMENT_ID_ALL_CANDIDATES",buffer_size,\ boundary_along_candidate_border_route,"{0} {1} {2} {3}".format("RID","LINE","FMEAS","TMEAS")) arcpy.JoinField_management(boundary_along_candidate_border_route, "RID", candidate_border_route, "SEGMENT_ID_ALL_CANDIDATES", ["ANGLE_ROUTE"]) positive_candidate_border_route = [] with arcpy.da.SearchCursor(boundary_along_candidate_border_route,("RID","ANGLE_ROUTE","ANGLE_BOUNDARY")) as sCur: for row in sCur: sid = str(row[0]) angle_route = row[1] angle_boundary = row[2] if angle_route and angle_boundary: delta_angle = abs(angle_route-angle_boundary) # get real intersecting angle if delta_angle > 90 and delta_angle <= 270: delta_angle = abs(180 - delta_angle) elif delta_angle > 270: delta_angle = 360 - delta_angle else: pass # filter out negative candidate border route if delta_angle <= high_angle_threshold: if sid not in positive_candidate_border_route: positive_candidate_border_route.append(sid) del sCur candidate_border_route_lyr = "in_memory\\candidate_border_route_lyr" arcpy.MakeFeatureLayer_management(candidate_border_route, candidate_border_route_lyr) candidate_border_route_positive = os.path.join(workspace,"candidate_{0}_border_route_positive".format(boundary)) where_clause = "\"{0}\" IN ({1})".format("OBJECTID",",".join(positive_candidate_border_route)) arcpy.SelectLayerByAttribute_management(candidate_border_route_lyr, "NEW_SELECTION", where_clause) arcpy.CopyFeatures_management(candidate_border_route_lyr,candidate_border_route_positive) candidate_border_route_negative = os.path.join(workspace,"candidate_{0}_border_route_negative".format(boundary)) where_clause = "\"{0}\" NOT IN ({1})".format("OBJECTID",",".join(positive_candidate_border_route)) arcpy.SelectLayerByAttribute_management(candidate_border_route_lyr, "NEW_SELECTION", where_clause) arcpy.CopyFeatures_management(candidate_border_route_lyr,candidate_border_route_negative) ################################################################################################################ ################################################################################################################ # get left, right boundary topology of positive candidate border route # handle candidate border route segment with different L/R boundary id by offset arcpy.AddMessage("Calculating L/R boundary topology of positive candidate border route...") # generate offset around boundary boundary_border_offset= os.path.join(workspace,"{0}_{1}".format(boundary,"boundary_offset")) arcpy.Buffer_analysis(boundary_border_dissolved, boundary_border_offset, offset, "FULL", "ROUND") # get intersections between positive candidate border route and boundary offset candidate_border_route_positive_boundary_offset_intersections = os.path.join(workspace,"candidate_{0}_border_route_positive_{1}_offset_intersections".format(boundary,boundary)) arcpy.Intersect_analysis([candidate_border_route_positive,boundary_border_offset], candidate_border_route_positive_boundary_offset_intersections, "ALL", "", "point") # split positive candidate border route by intersections generated above candidate_border_route_positive_splitted_by_offset = os.path.join(workspace,"candidate_{0}_border_route_positive_splitted_by_offset".format(boundary)) arcpy.SplitLineAtPoint_management(candidate_border_route_positive,candidate_border_route_positive_boundary_offset_intersections,\ candidate_border_route_positive_splitted_by_offset,xy_resolution) # Add 'SEGMENT_ID_POSITIVE_CANDIDATES' field to splitted positive candidate route and populate it with 'OBJECTID' arcpy.AddField_management(candidate_border_route_positive_splitted_by_offset,"SEGMENT_ID_POSITIVE_CANDIDATES","LONG") arcpy.CalculateField_management(candidate_border_route_positive_splitted_by_offset, "SEGMENT_ID_POSITIVE_CANDIDATES", "!OBJECTID!", "PYTHON") # get positive candidate border route segments that within boundary offset candidate_border_route_positive_within_offset = os.path.join(workspace,"candidate_{0}_border_route_positive_within_offset".format(boundary)) candidate_border_route_positive_splitted_by_offset_lyr = "in_memory\\candidate_{0}_border_route_positive_splitted_by_offset_lyr".format(boundary) arcpy.MakeFeatureLayer_management(candidate_border_route_positive_splitted_by_offset, candidate_border_route_positive_splitted_by_offset_lyr) arcpy.SelectLayerByLocation_management (candidate_border_route_positive_splitted_by_offset_lyr, "WITHIN", boundary_border_offset) arcpy.CopyFeatures_management(candidate_border_route_positive_splitted_by_offset_lyr,candidate_border_route_positive_within_offset) # get positive candidate border route segments that out of boundary offset candidate_border_route_positive_outof_offset = os.path.join(workspace,"candidate_{0}_border_route_positive_outof_offset".format(boundary)) arcpy.SelectLayerByAttribute_management(candidate_border_route_positive_splitted_by_offset_lyr, "SWITCH_SELECTION") arcpy.CopyFeatures_management(candidate_border_route_positive_splitted_by_offset_lyr,candidate_border_route_positive_outof_offset) # generate offset around positive candidate border route within boundary offset # arcpy.AddMessage("generate offset around boundary") candidate_border_route_positive_within_offset_buffer= os.path.join(workspace,"candidate_{0}_border_route_positive_within_offset_buffer".format(boundary)) arcpy.Buffer_analysis(candidate_border_route_positive_within_offset, candidate_border_route_positive_within_offset_buffer, offset, "FULL", "FLAT") # clip boundary segments within offset distance from positive candidate route that within boundary offset boundary_border_within_positive_candidate_border_route_buffer_multipart = "in_memory\\{0}_boundary_within_positive_candidate_border_route_buffer_multipart".format(boundary) boundary_border_within_positive_candidate_border_route_buffer = os.path.join(workspace,"{0}_boundary_within_positive_candidate_border_route_buffer".format(boundary)) arcpy.Clip_analysis(boundary_border_dissolved, candidate_border_route_positive_within_offset_buffer, boundary_border_within_positive_candidate_border_route_buffer_multipart) arcpy.MultipartToSinglepart_management(boundary_border_within_positive_candidate_border_route_buffer_multipart, boundary_border_within_positive_candidate_border_route_buffer) # get endpoints of boundary border within offset buffer of splitted positive candidate border routes boundary_border_within_positive_candidate_border_route_buffer_endpoints = os.path.join(workspace,"{0}_boundary_within_positive_candidate_border_route_buffer_endpoints".format(boundary)) arcpy.FeatureVerticesToPoints_management(boundary_border_within_positive_candidate_border_route_buffer,\ boundary_border_within_positive_candidate_border_route_buffer_endpoints,"BOTH_ENDS") arcpy.DeleteIdentical_management(boundary_border_within_positive_candidate_border_route_buffer_endpoints, ["Shape"]) # split boundary border within offset buffer of splitted positive candidate border routes and endpoints location # then delete identical shape boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints = os.path.join(workspace,"{0}_boundary_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints".format(boundary)) arcpy.SplitLineAtPoint_management(boundary_border_within_positive_candidate_border_route_buffer,boundary_border_within_positive_candidate_border_route_buffer_endpoints,\ boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints,xy_resolution) arcpy.DeleteIdentical_management(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints, ["Shape"]) # Add 'SEGMENT_ID_BOUNDARY' field to boundary segments within offset distance from positive candidate route that within boundary offset and populate it with 'OBJECTID' arcpy.AddField_management(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints,"SEGMENT_ID_BOUNDARY","LONG") arcpy.CalculateField_management(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints, "SEGMENT_ID_BOUNDARY", "!OBJECTID!", "PYTHON") # locate boundary segments within offset distance of positive candidate route that within boundary offset along positive candidate route that within boundary offset boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route = os.path.join(workspace,"{0}_boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route".format(boundary)) arcpy.LocateFeaturesAlongRoutes_lr(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints,candidate_border_route_positive_within_offset,"SEGMENT_ID_POSITIVE_CANDIDATES",offset,\ boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route,"{0} {1} {2} {3}".format("RID","LINE","FMEAS","TMEAS")) # get left, right boundary topology of boundary within offset distance of positive candidate route that within boundary offset along positive candidate route that within boundary offset boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases= os.path.join(workspace,"{0}_boundary_border_within_positive_candidate_border_route_buffer_with_{1}_topology_allcases".format(boundary,boundary)) arcpy.Identity_analysis(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints, boundary, boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases,"ALL","","KEEP_RELATIONSHIPS") boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr = "in_memory\\{0}_boundary_border_within_positive_candidate_border_route_buffer_with_{1}_topology_allcases_lyr".format(boundary,boundary) arcpy.MakeFeatureLayer_management(boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases, boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr) where_clause = "\"{0}\"<>0 AND \"{1}\"<>0".format("LEFT_{0}".format(boundary),"RIGHT_{0}".format(boundary)) arcpy.SelectLayerByAttribute_management(boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr, "NEW_SELECTION", where_clause) boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology = os.path.join(workspace,"{0}_boundary_border_within_positive_candidate_border_route_buffer_with_{1}_topology".format(boundary,boundary)) arcpy.CopyFeatures_management(boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr,boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology) arcpy.JoinField_management(boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route,"SEGMENT_ID_BOUNDARY",\ boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology,"SEGMENT_ID_BOUNDARY",["LEFT_{0}".format(boundary_id_field),"RIGHT_{0}".format(boundary_id_field)]) arcpy.JoinField_management(candidate_border_route_positive_within_offset,"SEGMENT_ID_POSITIVE_CANDIDATES",\ boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route,"RID",["SEGMENT_ID_BOUNDARY","LEFT_{0}".format(boundary_id_field),"RIGHT_{0}".format(boundary_id_field)]) candidate_border_route_positive_within_offset_lyr = "in_memory\\candidate_{0}_border_route_positive_within_offset_lyr".format(boundary) arcpy.MakeFeatureLayer_management(candidate_border_route_positive_within_offset, candidate_border_route_positive_within_offset_lyr) where_clause = "\"{0}\"IS NOT NULL AND \"{1}\"IS NOT NULL".format("LEFT_{0}".format(boundary_id_field),"RIGHT_{0}".format(boundary_id_field)) arcpy.SelectLayerByAttribute_management(candidate_border_route_positive_within_offset_lyr, "NEW_SELECTION", where_clause) candidate_border_route_positive_within_offset_with_polygon_topology = os.path.join(workspace,"candidate_{0}_border_route_positive_within_offset_with_{1}_topology".format(boundary,boundary)) arcpy.CopyFeatures_management(candidate_border_route_positive_within_offset_lyr,candidate_border_route_positive_within_offset_with_polygon_topology) # get left, right boundary topology of candidate border route out of boundary offset candidate_border_route_positive_outof_offset_with_polygon_topology_allcases= os.path.join(workspace,"candidate_{0}_border_route_positive_outof_offset_with_{1}_topology_allcases".format(boundary,boundary)) arcpy.Identity_analysis(candidate_border_route_positive_outof_offset, boundary, candidate_border_route_positive_outof_offset_with_polygon_topology_allcases,"ALL","","KEEP_RELATIONSHIPS") candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr = "in_memory\\candidate_{0}_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr".format(boundary) arcpy.MakeFeatureLayer_management(candidate_border_route_positive_outof_offset_with_polygon_topology_allcases, candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr) where_clause = "\"{0}\"<>0 AND \"{1}\"<>0".format("LEFT_{0}".format(boundary),"RIGHT_{0}".format(boundary)) arcpy.SelectLayerByAttribute_management(candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr, "NEW_SELECTION", where_clause) candidate_border_route_positive_outof_offset_with_polygon_topology = os.path.join(workspace,"candidate_{0}_border_route_positive_outof_offset_with_{1}_topology".format(boundary,boundary)) arcpy.CopyFeatures_management(candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr,candidate_border_route_positive_outof_offset_with_polygon_topology) # merge candidate_border_route_positive_with_polygon_topology = "candidate_{0}_border_route_positive_with_{1}_topology".format(boundary,boundary) arcpy.FeatureClassToFeatureClass_conversion(candidate_border_route_positive_outof_offset_with_polygon_topology,workspace,candidate_border_route_positive_with_polygon_topology) arcpy.Append_management([candidate_border_route_positive_within_offset_with_polygon_topology],candidate_border_route_positive_with_polygon_topology,"NO_TEST") ################################################################################################################ ################################################################################################################ arcpy.AddMessage("Populate route_border_rule_table...") # calculate from measure and to measure of candidate border route # arcpy.AddMessage("Calculating from measure and to measure of candidate border routes...") arcpy.AddGeometryAttributes_management(candidate_border_route_positive_with_polygon_topology, "LINE_START_MID_END") # get candidte border route segment geometry arcpy.AddField_management(candidate_border_route_positive_with_polygon_topology,"SEGMENT_GEOMETRY","TEXT","","",100) arcpy.CalculateField_management(candidate_border_route_positive_with_polygon_topology,"SEGMENT_GEOMETRY","!shape.type!","PYTHON") # sort candidate border route segments based on route id and from measure, orderly # arcpy.AddMessage("sort validated output got above based on route id and from measure, orderly") candidate_border_route_positive_with_polygon_topology_sorted = os.path.join(workspace,"candidate_{0}_border_route_positive_with_polygon_topology_sorted".format(boundary)) arcpy.Sort_management(candidate_border_route_positive_with_polygon_topology,candidate_border_route_positive_with_polygon_topology_sorted,[[route_id_field,"ASCENDING"],["START_M","ASCENDING"]]) # create route_border_rule_table if arcpy.Exists(route_border_rule_table): arcpy.Delete_management(route_border_rule_table) create_route_border_rule_table_schema(workspace,route_border_rule_table) else: create_route_border_rule_table_schema(workspace,route_border_rule_table) # populate route_border_rule_table iCur = arcpy.da.InsertCursor(route_border_rule_table,["ROUTE_ID","ROUTE_START_MEASURE","ROUTE_END_MEASURE","BOUNDARY_LEFT_ID",\ "BOUNDARY_RIGHT_ID","SEGMENT_GEOMETRY","EFFECTIVE_FROM_DT","EFFECTIVE_TO_DT"]) with arcpy.da.SearchCursor(candidate_border_route_positive_with_polygon_topology_sorted,[route_id_field,"START_M","END_M","LEFT_{0}".format(boundary_id_field),\ "RIGHT_{0}".format(boundary_id_field),"SEGMENT_GEOMETRY","START_DATE","END_DATE"]) as sCur: for row in sCur: iCur.insertRow(row) del sCur del iCur arcpy.CalculateField_management(route_border_rule_table, "BRP_PROCESS_DT", "'{0}'".format(date_string), "PYTHON") ################################################################################################################ arcpy.AddMessage("done!") return route_border_rule_table except Exception: # arcpy.AddMessage(traceback.format_exc()) sys.exit(traceback.format_exc()) return False