def Uniquity(): rcl = ng911 + r"/RoadCenterline" apt = ng911 + r"/AddressPoints" arcpy.FindIdentical_management(rcl, checkfile + r"/RCLDup", "SEGID", "#", "0", "ONLY_DUPLICATES") arcpy.FindIdentical_management(apt, checkfile + r"/AddressPointsDup", "ADDID", "#", "0", "ONLY_DUPLICATES")
def delete_loops(lines): arcpy.Copy_management(lines, "Lines_Copy") ends = arcpy.FeatureVerticesToPoints_management(lines, "Ends", "BOTH_ENDS") identical = arcpy.FindIdentical_management(ends, "Identical", "SHAPE;ORIG_FID") arcpy.JoinField_management(ends, "OBJECTID", identical, "IN_FID", fields="FEAT_SEQ") dissolved_ends = arcpy.Dissolve_management( ends, "Ends_Dissolve", "ORIG_FID;FEAT_SEQ", statistics_fields="FEAT_SEQ COUNT") rows = arcpy.da.SearchCursor(dissolved_ends, ['ORIG_FID', 'COUNT_FEAT_SEQ']) for row in rows: if row[1] == 2: del_lines = arcpy.da.UpdateCursor(lines, ['OBJECTID']) for del_line in del_lines: if del_line[0] == row[0]: arcpy.AddMessage("Deleting ID {0}".format(row[0])) del_lines.deleteRow() del del_line, del_lines del row, rows arcpy.AddMessage("Artefacts are removed")
def integrating_network(lines, tolerance="0 Meters"): overhead_lines = arcpy.FeatureClassToFeatureClass_conversion( lines, "Network", "Lines_over_p", where_clause="Line_Type = 'ВЛ'") cable_lines = arcpy.FeatureClassToFeatureClass_conversion( lines, "Network", "Lines_cable_p", where_clause="Line_Type = 'КЛ'") arcpy.Integrate_management(overhead_lines, tolerance) arcpy.Integrate_management(cable_lines, "0.1 Meters") lines = arcpy.Merge_management([overhead_lines, cable_lines], "Lines_merge") split = arcpy.SplitLine_management(lines, "SplitLine") find = arcpy.FindIdentical_management( split, "in_memory/Find_Ident", ["Shape", "Name", "Voltage"], xy_tolerance=tolerance, output_record_option="ONLY_DUPLICATES") joined_split = arcpy.JoinField_management(split, "OBJECTID", find, "IN_FID") arcpy.DeleteIdentical_management(joined_split, ["Shape", "Name", "Voltage"], "0.1 Meters") unsplit = arcpy.Dissolve_management( joined_split, "Unsplited_Lines", [ "Name", "Voltage", "Line_Type", "Start", "End", "Circuit", "Operate_Name", "Trace_Version", "Status" ], multi_part="MULTI_PART") return unsplit
def findDupPts(inFds,outFds): addMsgAndPrint('Looking for duplicate points') duplicatePoints = [] arcpy.env.workspace = os.path.dirname(inFds) ptFcs1 = arcpy.ListFeatureClasses('','POINT',os.path.basename(inFds)) ptFcs2 = [] for fc in ptFcs1: notEdit = True for pfx in editPrefixes: if fc.find(pfx) > -1: notEdit = False if notEdit: ptFcs2.append(fc) for fc in ptFcs2: addMsgAndPrint(' finding duplicate records in '+fc) newTb = os.path.dirname(outFds)+'/dups_'+fc testAndDelete(newTb) dupFields = ['Shape'] allFields1 = arcpy.ListFields(fc) allFields = [] for fld in allFields1: allFields.append(fld.name) for aF in ('Type','Azimuth','Inclination'): if aF in allFields: dupFields.append(aF) addMsgAndPrint(' fields to be compared: '+str(dupFields)) arcpy.FindIdentical_management(inFds+'/'+fc,newTb,dupFields,'','','ONLY_DUPLICATES') addMsgAndPrint(' dups_'+fc+': '+str(numberOfRows(newTb))+' rows') if numberOfRows(newTb) == 0: testAndDelete(newTb) else: duplicatePoints.append(' '+str(numberOfRows(newTb))+' rows in '+os.path.basename(newTb)) return duplicatePoints
def delete_identical_only_keep_min_oid(data, fields, xy_tolerance="1 meters"): """ Similar to the DeleteIdentical function in arcpy. This tool goes one more step to only keep the records with the smaller id :param data: :param fields: :param xy_tolerance: """ identical_table = "in_memory\\identical_table" arcpy.FindIdentical_management(data, identical_table, fields, xy_tolerance, "", "ONLY_DUPLICATES") fseq_list = [] delete_oid_list = [] sCursor = arcpy.SearchCursor(identical_table, "", "", "FEAT_SEQ;IN_FID", "IN_FID A") for sRow in sCursor: feat_seq, in_fid = sRow.getValue("FEAT_SEQ"), sRow.getValue("IN_FID") if feat_seq not in fseq_list: fseq_list.append(feat_seq) else: delete_oid_list.append(in_fid) del sCursor oid_field = arcpy.Describe(data).OIDFieldName if len(delete_oid_list) != 0: where_clause = build_numeric_in_sql_expression(oid_field, delete_oid_list) delete_subset_data(data, where_clause)
def main(line, seg_length): arcpy.AddMessage("Plotting segment endpoints...") arcpy.MakeFeatureLayer_management(line, "in_line_lyr") fields = ["SHAPE@", "LineOID"] # Plot endpoints for all segments endPnt_all = plot_end(line, fields) arcpy.MakeFeatureLayer_management(endPnt_all, "endPnt_all_lyr") # Find duplicate endpoints arcpy.FindIdentical_management("endPnt_all_lyr", "dup_table", ["Shape"], 0.5, "#", "ONLY_DUPLICATES") arcpy.MakeTableView_management(r"dup_table", "dup_tblview") arcpy.JoinField_management("endPnt_all_lyr", "LineOID", "dup_tblview", "IN_FID", "#") arcpy.SelectLayerByAttribute_management("endPnt_all_lyr", "NEW_SELECTION", """"IN_FID" IS NOT NULL""") arcpy.FeatureClassToFeatureClass_conversion("endPnt_all_lyr", "in_memory", "endPnt_dup") # Find segments with duplicate endpoints arcpy.JoinField_management("in_line_lyr", "OBJECTID", "dup_tblview", "IN_FID", "#") arcpy.SelectLayerByAttribute_management("in_line_lyr", "NEW_SELECTION", """"IN_FID" IS NOT NULL""") arcpy.FeatureClassToFeatureClass_conversion("in_line_lyr", "in_memory", "line_dup") arcpy.SelectLayerByAttribute_management("in_line_lyr", "SWITCH_SELECTION") arcpy.FeatureClassToFeatureClass_conversion("in_line_lyr", "in_memory", "line_nodup") # Re-plot endpoints for segments with duplicate endpoints endPnt_dup_final = plot_end(r"in_memory\line_dup", fields) arcpy.FeatureClassToFeatureClass_conversion(endPnt_dup_final, "in_memory", "endPnt_dup_final") endPnt_nodup_final = plot_end(r"in_memory\line_nodup", fields) arcpy.FeatureClassToFeatureClass_conversion(endPnt_nodup_final, "in_memory", "endPnt_nodup_final") finalEndpnt = arcpy.Merge_management( ["in_memory\endPnt_nodup_final", "in_memory\endPnt_dup_final"], r"in_memory\finalEndPnt") # clean up temp files arcpy.Delete_management("in_line_lyr") arcpy.Delete_management(r"dup_table") arcpy.Delete_management("dup_tblview") arcpy.Delete_management(endPnt_all) arcpy.Delete_management("endPnt_all_lyr") arcpy.Delete_management(r"in_memory\endPnt_dup") arcpy.Delete_management(r"in_memory\line_dup") arcpy.Delete_management(r"in_memory\line_nodup") arcpy.Delete_management(r"in_memory\endPnt_nodup_final") arcpy.Delete_management(r"in_memory\endPnt_dup_final") return finalEndpnt
def selectIdentical(dataset): dups = os.path.join("in_memory", "tempDups") dups1 = arcpy.FindIdentical_management( dataset, dups, 'EO_ID', output_record_option="ONLY_DUPLICATES") with arcpy.da.SearchCursor(dups1, 'IN_FID') as cursor: duplicates = sorted({row[0] for row in cursor}) query = '"OBJECTID" IN ' + str(tuple(duplicates)) arcpy.SelectLayerByAttribute_management(dataset, "ADD_TO_SELECTION", query)
def onClick(self): workspace, PFname = os.path.split(parcelFabric) ParcelPoints = "FabricInvestigation\\Points" DuplicatePointsTable = os.path.join("in_memory", PFname + "_IdenticalPoints") arcpy.FindIdentical_management(ParcelPoints, DuplicatePointsTable, "X;Y", "#", "0", "ONLY_DUPLICATES") arcpy.AddJoin_management(ParcelPoints, "OBJECTID", DuplicatePointsTable, "IN_FID", "KEEP_COMMON") saveDuplicates = pythonaddins.SaveDialog("Save Duplicate Points") arcpy.CopyFeatures_management(ParcelPoints, saveDuplicates) newPath, newLayer = os.path.split(saveDuplicates) arcpy.mapping.MoveLayer( df, arcpy.mapping.ListLayers(mxd, "FabricInvestigation")[0], arcpy.mapping.ListLayers(mxd, newLayer)[0], "BEFORE") DupPoints.checked = False
def duplicados(capa, ruta): global gdb nombre_gdb = "duplicados_%s" % ( datetime.datetime.now().strftime("%b_%d_%Y_%H_%M_%S")) nombre_gdb = nombre_gdb.replace(".", "") gdb = arcpy.CreateFileGDB_management(ruta, nombre_gdb) ##capa_copia=arcpy.CopyFeatures_management(in_features=capa,out_feature_class="in_memory\\%s"%(arcpy.ValidateTableName(arcpy.Describe(capa).name))) capa_copia = arcpy.CopyFeatures_management( in_features=capa, out_feature_class="%s\\%s" % (gdb, arcpy.ValidateTableName(arcpy.Describe(capa).name))) arcpy.AddField_management(capa_copia, "dupli", "TEXT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") with arcpy.da.UpdateCursor( capa_copia, ["SHAPE@Y", "SHAPE@X", "SHAPE@AREA", "dupli"]) as cursor: for fila in cursor: ## x=str(fila[1])[0:len(str(fila[1]))-2] ## y=str(fila[0])[0:len(str(fila[0]))-2] Cx = float(str(fila[1])[0:len(str(fila[1]))]) Cy = float(str(fila[0])[0:len(str(fila[0]))]) CArea = float(str(fila[2])[0:len(str(fila[2]))]) x = "{0:.2f}".format(Cx) ###funcion para dejar solo dos decimales y = "{0:.2f}".format(Cy) ###funcion para dejar solo dos decimales Area = "{0:.2f}".format(CArea) fila[3] = str(x) + "_" + str(y) + "_" + str(Area) cursor.updateRow(fila) arcpy.FindIdentical_management(in_dataset=capa_copia, out_dataset=str(gdb) + "\\duplicados", fields=["dupli"], output_record_option="ONLY_DUPLICATES") arcpy.Delete_management( "%s\\%s" % (gdb, arcpy.ValidateTableName(arcpy.Describe(capa).name))) registros = int(arcpy.GetCount_management(str(gdb) + "\\duplicados")[0]) return str(registros) + ";" + "%s\\duplicados" % (gdb)
def find_duplicates(fc, field_list): arcpy.env.workspace = "IN_MEMORY" arcpy.env.overwriteOutput = True arcpy.FindIdentical_management(fc, "temp_file", field_list, output_record_option="ONLY_DUPLICATES") select_list = [] seq_list = [] with arcpy.da.SearchCursor("temp_file", "*") as cursor: for row in cursor: seq_list.append(row[2]) if seq_list.count(row[2]) > 1: select_list.append(row[1]) query = "\"OBJECTID\"IN({0})".format(str(select_list).strip('[]')) arcpy.SelectLayerByAttribute_management(fc, "NEW_SELECTION", query)
def findsinglevertex(layer): # find single vertices # FIXME # Integrate fails when path contains spaces # Possible way to fix it is to use arcpy.env and call layer by it's name try: arcpy.Integrate_management(layer, '0.1 Meters') except RuntimeError: arcpy.AddMessage(u'...Failed to run Integrate tool') arcpy.env.addOutputsToMap = False vert = u'in_memory\\vert' ident = u'in_memory\\ident' arcpy.FeatureVerticesToPoints_management( in_features = layer, out_feature_class = vert, point_location = u'ALL') # FIXME # test way to skip last points in polygons # sql-clause doesn't work in in_memory datasets oid_field = arcpy.Describe(layer).OIDFieldName lastpoints = [] if arcpy.Describe(layer).shapeType == 'Polygon': prev_id = -1 prev_row = -1 with arcpy.da.SearchCursor(vert, ['OID@', 'ORIG_FID']) as sc: for row in sc: if row[1] != prev_id: lastpoints.append(prev_row) prev_id = row[1] prev_row = row[0] # append last point of last polygon lastpoints.append(row[0]) with arcpy.da.UpdateCursor(vert, ['OID@']) as uc: for row in uc: if row[0] in lastpoints: uc.deleteRow() # points = {PointFID: [LineID, PointNo], ...} points = {} lines_id = [] clause = (None, 'ORDER BY {0} DESC'.format(oid_field)) with arcpy.da.SearchCursor(vert, ['OID@', 'ORIG_FID'], sql_clause = clause) as sc: feat_num = -1 vert_num = -1 for row in sc: if row[1] != feat_num: feat_num = row[1] vert_num = 0 lines_id.append(feat_num) else: vert_num += 1 points[row[0]] = [feat_num, vert_num] arcpy.FindIdentical_management( in_dataset = vert, out_dataset = ident, fields = u'SHAPE', xy_tolerance = u'0.2 Meters', output_record_option = u'ONLY_DUPLICATES') identical_v = [row[0] for row in arcpy.da.SearchCursor(ident, 'IN_FID')] # ids of identical vetices single_pairs = [val for key, val in points.items() if key not in identical_v] single_out = {oid: [] for oid in lines_id} for p in single_pairs: single_out[p[0]].append(p[1]) arcpy.Delete_management(vert) arcpy.Delete_management(ident) return single_out
pass else: # Find duplicate geometry flds = arcpy.ListFields(fc) fldNames = [] for fld in flds: if fld.type not in ignoreType: if fld.name.lower() not in [x.lower() for x in ignoreFld]: fldNames.append(str(fld.name)) #if fld.name.lower() not in [x.lower() for x in ignoreFLD]: dupeTable = "in_memory\\tmp" arcpy.FindIdentical_management( fc, dupeTable, fldNames, xy_tolerance=xyTol, z_tolerance=zTol, output_record_option="ONLY_DUPLICATES") # Get table count and pass the dataset if no duplicates exist fidList = [] with arcpy.da.SearchCursor(dupeTable, ["IN_FID"]) as cursor: for row in cursor: fidList.append(row[0]) #expression = 'OBJECTID IN ({0})'.format(', '.join(map(str, fidList)) or 'NULL') tblCount = arcpy.GetCount_management(dupeTable) uniqdupCount = len(unique_values(dupeTable, "FEAT_SEQ")) dupCount = len(unique_values(dupeTable, "IN_FID"))
arcpy.CopyFeatures_management("Desig_union", "Desig_union_repair") MyFunctions.check_and_repair("Desig_union_repair") # Multipart to single part - there are many edge slivers spread over a long length of edge in multiple parts print("Converting to single part") arcpy.MultipartToSinglepart_management("Desig_union_repair", "Desig_union_repair_sp") # Delete identical shapes, which come either from overlaps in the union or from input dataset errors # Ideally you would inspect using Find Identical first, and make sure useful info is not being lost # i.e. none of the duplicates have differing attribute info # Inspection for Oxon has been carried out and only two polygons with different info were found # In both cases the polygon to keep is higher in the table so should be preserved arcpy.FindIdentical_management("Desig_union_repair_sp", "FindIdentical", ["Shape"], output_record_option="ONLY_DUPLICATES") print( "Deleting identical features. These are recorded in FindIdentical table - please check that the deletions are OK." ) if check_identical: # Over 8000 identical shapes so no time to check them individually. print "Exiting so that you can check the identical polygons. When finished, set check_identical and first_part to False and restart." exit() if second_part: print "Deleting identical shapes" arcpy.CopyFeatures_management("Desig_union_repair_sp", "Desig_union_repair_sp_delid") arcpy.DeleteIdentical_management("Desig_union_repair_sp_delid", ["Shape"])
"Access_paths_merge_" + str(ipath - 1), in_file + "_input", "Access_paths_merge_" + str(ipath)) except: print( "Erase failed - please try manually in ArcMap and then comment out this section and restart" ) exit() print("Appending " + in_file + "_input to merged paths") arcpy.Append_management( ["Access_paths_merge_1" + str(ipath)], in_file + "_input", "NO_TEST") else: # Check for any duplicate polygons arcpy.FindIdentical_management( in_file + "_input", "Identical_" + in_file, ["Shape"], output_record_option="ONLY_DUPLICATES") numrows = arcpy.GetCount_management("Identical_" + in_file) if numrows > 0: print( "Warning - " + str(numrows) + " duplicate polygons found in " + in_file + "_input. All but one of each shape will be deleted.") arcpy.DeleteIdentical_management(in_file + "_input", ["Shape"]) InAreas.append(in_file + "_input") print("Merging areas: " + ', '.join(InAreas)) arcpy.Merge_management(InAreas, "Access_areas_merge") # Need to convert merged paths to single part otherwise it crashes
def validate_sgid_addresses_and_voting_precincts(in_directory, in_dataset_name): #: add xy data to the in_dataset arcpy.AddXY_management(in_directory + in_dataset_name) #: Add field to mark flagged address records. flagged_exists = False dup_seqid_exists = False fields = arcpy.ListFields(in_directory + in_dataset_name) for field in fields: if field.name == "FLAGGED": flagged_exists = True elif field.name == "DUP_SEQID": dup_seqid_exists = True if flagged_exists == True: #: Delete it before creating it again (clears out any old values) arcpy.DeleteField_management(in_directory + in_dataset_name, "FLAGGED") arcpy.AddField_management(in_directory + in_dataset_name, "FLAGGED", "TEXT", field_length=255, field_is_nullable="NULLABLE") else: arcpy.AddField_management(in_directory + in_dataset_name, "FLAGGED", "TEXT", field_length=255, field_is_nullable="NULLABLE") if dup_seqid_exists == True: #: Delete it before creating it again (clears out any old values) arcpy.DeleteField_management(in_directory + in_dataset_name, "DUP_SEQID") arcpy.AddField_management(in_directory + in_dataset_name, "DUP_SEQID", "LONG", field_precision=6, field_is_nullable="NULLABLE") else: arcpy.AddField_management(in_directory + in_dataset_name, "DUP_SEQID", "LONG", field_precision=6, field_is_nullable="NULLABLE") #: find identical for address-based attributes only fields = ["UTAddPtID", "City", "ZipCode"] out_table = in_directory + "\\duplicate_addresspnts" duplicates = arcpy.FindIdentical_management( in_directory + in_dataset_name, out_table, fields, output_record_option="ONLY_DUPLICATES") #: Identify addresses that are duplicates by assigning the sequence id to the DUP_SEQID field. print(" begin assigning sequence ids...") transfer_seqIDs_to_featureclass(in_directory + in_dataset_name, duplicates) #: Loop through the dataset and check if any rows do not contain a voting precinct. print(" begin check for missing voting precinct...") check_for_missing_vp(in_directory + in_dataset_name) #: Loop through the duplicate addresses and see if it's an address point issue or voting precinct issue (if they have differnet x,y values then addrpnt, if same x,y then vp issue - ie: an overlap) print( " begin checking duplicates to see if address point issue or voting precinct issue..." ) check_duplicate_addresses_for_issue(in_directory + in_dataset_name, in_directory, duplicates) #: Check if there is a descrepency as to what county the address belongs to (ie: address point countyid does not match voting precinct countyid) print(" begin check for countyid discrepancies...") check_county_ids_for_discrepancies(in_directory + in_dataset_name) #: Clean up and delete the tables no longer needed. arcpy.Delete_management(in_directory + "\\duplicate_addresspnts") arcpy.Delete_management(in_directory + "\\summary_stats")
out_coor_system=cs_ref) #Create raster of weekly number of buses at the same resolution as bing data # Convert weekly number of buses to integer arcpy.AddField_management(NTMproj, 'adjustnum_int', 'SHORT') with arcpy.da.UpdateCursor(NTMproj, ['adjustnum_SUM', 'adjustnum_int']) as cursor: for row in cursor: if row[0]: row[1] = int(10 * row[0] + 0.5) cursor.updateRow(row) #Split lines at all intersections so that small identical overlapping segments can be dissolved arcpy.SplitLine_management(NTMproj, NTMproj + '_split') #Split at intersection arcpy.FindIdentical_management( NTMproj + '_split', "explFindID", "Shape" ) #Find overlapping segments and make them part of a group (FEAT_SEQ) arcpy.MakeFeatureLayer_management(NTMproj + '_split', "intlyr") arcpy.AddJoin_management("intlyr", arcpy.Describe("intlyr").OIDfieldName, "explFindID", "IN_FID", "KEEP_ALL") arcpy.Dissolve_management("intlyr", NTMsplitdiss, dissolve_field='explFindID.FEAT_SEQ', statistics_fields=[[ os.path.split(NTMproj)[1] + '_split.adjustnum_int', 'SUM' ]]) #Dissolve overlapping segments arcpy.RepairGeometry_management( NTMsplitdiss, delete_null='DELETE_NULL') #sometimes creates empty geom #Get the length of a half pixel diagonal to create buffers for
#Only keep buses with trips and whose schedule lasts more than 1 day arcpy.MakeFeatureLayer_management(PStransit, 'PStransit_lyr', where_clause= '(route_type = 3) AND (MIN_service_len > 1) AND (SUM_adjustnum > 0)') arcpy.CopyFeatures_management('PStransit_lyr', PStransitbus) arcpy.Project_management(PStransitbus, PStransitbus_proj, cs_ref) #Create raster of weekly number of buses at the same resolution as bing data # Convert weekly number of buses to integer arcpy.AddField_management(PStransitbus_proj, 'adjustnum_int', 'SHORT') arcpy.CalculateField_management(PStransitbus_proj, 'adjustnum_int', expression='int(10*!SUM_adjustnum!+0.5)', expression_type='PYTHON') #Split lines at all intersections so that small identical overlapping segments can be dissolved arcpy.SplitLine_management(PStransitbus_proj, PStransitbus_proj + '_split') #Split at intersection arcpy.FindIdentical_management(in_dataset=PStransitbus_proj + '_split', out_dataset=PStransitduplitab, fields="Shape") #Find overlapping segments and make them part of a group (FEAT_SEQ) arcpy.MakeFeatureLayer_management(PStransitbus_proj + '_split', "intlyr") arcpy.AddJoin_management("intlyr", arcpy.Describe("intlyr").OIDfieldName, PStransitduplitab, "IN_FID", "KEEP_ALL") arcpy.Dissolve_management("intlyr", PStransitbus_splitdiss, dissolve_field='explFindID.FEAT_SEQ', statistics_fields=[[os.path.split(PStransitbus_proj)[1] + '_split.adjustnum_int', 'SUM']]) #Dissolve overlapping segments arcpy.RepairGeometry_management(PStransitbus_splitdiss, delete_null = 'DELETE_NULL') #sometimes creates empty geom #Get the length of a half pixel diagonal to create buffers for #guaranteeing that segments potentially falling within the same pixel are rasterized separately tolerance = (2.0**0.5)*float(restemplate.getOutput(0))/2 arcpy.env.workspace = os.path.dirname(soundtransit) ExplodeOverlappingLines(PStransitbus_splitdiss, tolerance) #For each set of non-overlapping lines, create its own raster tilef = 'expl' tilelist = list(set([row[0] for row in arcpy.da.SearchCursor(PStransitbus_splitdiss, [tilef])]))
arcpy.Delete_management(fc) for tbl in arcpy.ListTables(): arcpy.Delete_management(tbl) sr = arcpy.Describe(sourceStreets).spatialReference arcpy.CreateFeatureclass_management(destGDB,'StreetIntersection','POINT',spatial_reference=sr,out_alias='Steet Intersection') for fName,fAlias in fldNames.items(): #print(fName,fAlias) arcpy.AddField_management (stIntersection,fName,'TEXT',field_length=100,field_alias=fAlias,) # In[9]: arcpy.FeatureVerticesToPoints_management(sourceStreets,stVertices,'BOTH_ENDS') arcpy.FindIdentical_management(stVertices,identEnds,'SHAPE',output_record_option='ONLY_DUPLICATES') # In[10]: lastFeatSeq = [row for row in arcpy.da.SearchCursor(identEnds, "FEAT_SEQ")][-1] lastFeatSeq = lastFeatSeq[0]+1 print(f"number of intersections: {lastFeatSeq}") # In[14]: # TODO create list from column Feat_Seq instead of range() arr = arcpy.da.TableToNumpyArray(identEnds,'FEAT_SEQ') df = pd.DataFrame(arr)
"Zero feature datasets found in " + workpath + ". \n Try migrating your feature classes to a feature datasets.") sys.exit(0) else: for dataset in FDSs: for fc in arcpy.ListFeatureClasses('', '', dataset): fcCount = arcpy.GetCount_management(fc) if int(fcCount[0]) == 0: arcpy.AddMessage("No features in " + fc + " ... skipping!") pass else: # Find duplicate geometry dupeTable = "in_memory\\tmp" arcpy.FindIdentical_management( fc, "in_memory\\tmp", ["Shape"], xy_tolerance=xyTolerance, z_tolerance=zTolerance, output_record_option="ONLY_DUPLICATES") # Get table count and pass the dataset if no duplicates exist tblCount = arcpy.GetCount_management(dupeTable) print fc + " duplicate feature count: " + str(tblCount) arcpy.AddMessage(fc + " duplicate feature count: " + str(tblCount)) if int(tblCount[0]) == 0: arcpy.Delete_management("in_memory\\tmp") continue else: # Get Object IDs of duplicate values to build expression for layer file fidList = []
"0.001 Meters", "ATTRIBUTES") #: Delete the newly-created FID_TrailsPathways field (this will keep the schema the same and also allow the append below w/o "NO_TEST") arcpy.DeleteField_management(finished_product, ["FID_TrailsAndPathways"]) #: Append the segments (bridges and tunnels) that did not get split back into the dataset arcpy.MakeFeatureLayer_management(trails_paths, "trails_paths_bridges_lyr", "CartoCode = '8 - Bridge, Tunnel'") print("begin append cartocode 8's") arcpy.management.Append("trails_paths_bridges_lyr", finished_product) #: Find duplicate uniqueids - these will need to be recalculated using the arcmap tool print("begin find duplicate Unique_IDs") unique_dup_tbl = arcpy.FindIdentical_management( finished_product, dup_uniqueid_table, "Unique_ID", output_record_option="ONLY_DUPLICATES") #: Null out the duplicates print("begin null out duplicates unique_ids") joined_fc = arcpy.management.JoinField(finished_product, "OBJECTID", unique_dup_tbl, "IN_FID") #: Make feature layer where IN_FID is not null and then calculate UniqueID values to null where this is true arcpy.MakeFeatureLayer_management(joined_fc, "joined_fc_lyr", "IN_FID is not NULL") arcpy.management.CalculateField("joined_fc_lyr", "Unique_ID", "0") #: Remove the join fields arcpy.DeleteField_management(finished_product, ["IN_FID", "FEAT_SEQ"])
# arcpy_Append_Example.py # Created on: 2017-02-13 14:18:40.00000 # (generated by ArcGIS/ModelBuilder) # Description: # --------------------------------------------------------------------------- # Set the necessary product code # import arcinfo # Import arcpy module import arcpy # Local variables: tmp_BufLYR = "tmp_BufLYR" location_coordinate_buffers__4_ = tmp_BufLYR location_coordinate_buffers = "location_coordinate_buffers" location_coordinate_buffers__2_ = location_coordinate_buffers location_coordinate_buffers_ = "C:\\Users\\chrism\\Documents\\ArcGIS\\Default.gdb\\location_coordinate_buffers_" # Process: Truncate Table arcpy.TruncateTable_management(location_coordinate_buffers) # Process: Append arcpy.Append_management("tmp_BufLYR", location_coordinate_buffers__2_, "NO_TEST", "LOCCRD_SEQ_NR_FK \"LOCCRD_SEQ_NR_FK\" true false false 4 Long 0 0 ,First,#,tmp_BufLYR,LOCCRD_SEQ_NR_FK,-1,-1;ACCURACY_LVL_CD \"ACCURACY_LVL_CD\" true true false 2 Text 0 0 ,First,#,tmp_BufLYR,ACCURACY_LVL_CD,-1,-1;CREATED_BY \"CREATED_BY\" true true false 20 Text 0 0 ,First,#,tmp_BufLYR,CREATED_BY,-1,-1;CREATED_DATE \"CREATED_DATE\" true true false 8 Date 0 0 ,First,#,tmp_BufLYR,CREATED_DATE,-1,-1;LAST_MODIFIED_BY \"LAST_MODIFIED_BY\" true true false 20 Text 0 0 ,First,#,tmp_BufLYR,LAST_MODIFIED_BY,-1,-1;LAST_MODIFIED_DATE \"LAST_MODIFIED_DATE\" true true false 8 Date 0 0 ,First,#,tmp_BufLYR,LAST_MODIFIED_DATE,-1,-1;LOCCRD_SEQ_NR \"LOCCRD_SEQ_NR\" true true false 4 Long 0 0 ,First,#,tmp_BufLYR,LOCCRD_SEQ_NR,-1,-1;SHAPE_Length \"SHAPE_Length\" false true true 8 Double 0 0 ,First,#,tmp_BufLYR,SHAPE_Length,-1,-1;SHAPE_Area \"SHAPE_Area\" false true true 8 Double 0 0 ,First,#,tmp_BufLYR,SHAPE_Area,-1,-1", "") # Process: Find Identical arcpy.FindIdentical_management(location_coordinate_buffers__4_, location_coordinate_buffers_, "LOCCRD_SEQ_NR_FK;LOCCRD_SEQ_NR", "", "0", "ALL")