def findBraidedReaches(fcLines, perennial_network, is_verbose): if is_verbose: arcpy.AddMessage("Finding streams with mutltiple channels...") # Clear temporary data if arcpy.Exists("in_memory//DonutPolygons"): arcpy.Delete_management("in_memory//DonutPolygons") if arcpy.Exists("lyrDonuts"): arcpy.Delete_management("lyrDonuts") if arcpy.Exists("lyrBraidedReaches"): arcpy.Delete_management("lyrBraidedReaches") # Find donut reaches donut_polygons = "in_memory/DonutPolygons" if perennial_network is not None: arcpy.FeatureToPolygon_management(perennial_network, donut_polygons) else: arcpy.FeatureToPolygon_management(fcLines, donut_polygons) # delete extremely large donuts (< 0.5 sq km) since these are false positives for finding side channels with arcpy.da.UpdateCursor(donut_polygons, ['SHAPE@AREA']) as cursor: for row in cursor: if row[0] > 500000: cursor.deleteRow() arcpy.MakeFeatureLayer_management(donut_polygons,"lyrDonuts") arcpy.MakeFeatureLayer_management(fcLines,"lyrBraidedReaches") arcpy.SelectLayerByLocation_management("lyrBraidedReaches","SHARE_A_LINE_SEGMENT_WITH","lyrDonuts",'',"NEW_SELECTION") arcpy.CalculateField_management("lyrBraidedReaches","IsMultiCh",1,"PYTHON") arcpy.CalculateField_management("lyrBraidedReaches","IsMainCh",0,"PYTHON")
def CombineShorelinePolygons(bndMTL: str, bndMHW: str, inletLines: str, ShorelinePts: str, bndpoly: str, SA_bounds: str='', verbose: bool=True): """ Use MTL and MHW contour polygons to create shoreline polygon. 'Shoreline' = MHW on oceanside and MTL on bayside """ start = time.clock() # Inlet lines must intersect the MHW polygon symdiff = os.path.join(arcpy.env.scratchGDB, 'shore_1symdiff') split = os.path.join(arcpy.env.scratchGDB, 'shore_2split') join = os.path.join(arcpy.env.scratchGDB, 'shore_3_oceanMTL') erase = os.path.join(arcpy.env.scratchGDB, 'shore_4_bayMTL') union_2 = os.path.join(arcpy.env.scratchGDB, 'shore_5union') # Create layer (symdiff) of land between MTL and MHW and split by inlets print("...delineating land between MTL and MHW elevations...") arcpy.Delete_management(symdiff) # delete if already exists arcpy.SymDiff_analysis(bndMTL, bndMHW, symdiff) # Split symdiff at inlets (and SA_bounds) print("...removing the MHW-MTL areas on the oceanside...") if len(SA_bounds) > 0: arcpy.FeatureToPolygon_management([symdiff, inletLines, SA_bounds], split) # Split MTL features at inlets and study area bounds else: arcpy.FeatureToPolygon_management([symdiff, inletLines], split) # Split MTL features at inlets # Isolate polygons touching shoreline points and erase from symdiff arcpy.SpatialJoin_analysis(split, ShorelinePts, split+'_join', "#","KEEP_COMMON", match_option="COMPLETELY_CONTAINS") arcpy.Erase_analysis(symdiff, split+'_join', erase) # Merge bayside MHW-MTL with above-MHW polygon arcpy.Union_analysis([erase, bndMHW], union_2) arcpy.Dissolve_management(union_2, bndpoly, multi_part='SINGLE_PART') # Dissolve all features in union_2 to single part polygons print('''User input required! Select extra features in {} for deletion.\nRecommended technique: select the polygon/s to keep and then Switch Selection.\n'''.format(os.path.basename(bndpoly))) return(bndpoly)
def NewBNDpoly(old_boundary, modifying_feature, new_bndpoly='boundary_poly', vertexdist='25 METERS', snapdist='25 METERS', verbose=True): """Snaps the boundary polygon to the shoreline points anywhere they don't already match and as long as as they are within 25 m of each other.""" # boundary = input line or polygon of boundary to be modified by newline typeFC = arcpy.Describe(old_boundary).shapeType if typeFC == "Line" or typeFC =='Polyline': arcpy.FeatureToPolygon_management(old_boundary, new_bndpoly, '1 METER') else: if len(os.path.split(new_bndpoly)[0]): path = os.path.split(new_bndpoly)[0] else: path = arcpy.env.workspace arcpy.FeatureClassToFeatureClass_conversion(old_boundary, path, os.path.basename(new_bndpoly)) typeFC = arcpy.Describe(modifying_feature).shapeType if typeFC == "Line" or typeFC == "Polyline": arcpy.Densify_edit(modifying_feature, 'DISTANCE', vertexdist) # elif typeFC == "Point" or typeFC == "Multipoint": # arcpy.PointsToLine_management(modifying_feature, modifying_feature+'_line') # modifying_feature = modifying_feature+'_line' # arcpy.Densify_edit(modifying_feature, 'DISTANCE', vertexdist) arcpy.Densify_edit(new_bndpoly, 'DISTANCE', vertexdist) #arcpy.Densify_edit(modifying_feature,'DISTANCE',vertexdist) arcpy.Snap_edit(new_bndpoly,[[modifying_feature, 'VERTEX',snapdist]]) # Takes a while if verbose: print("Created: {} ... Should be in your home geodatabase.".format(os.path.basename(new_bndpoly))) return new_bndpoly # string name of new polygon
def crear_limite_manzanas(self): arcpy.env.overwriteOutput = True path_manzana = path.join(self.path_trabajo, 'tb_manzana_procesar') path_eje_vial = path.join(self.path_trabajo, 'tb_eje_vial_procesar') path_zona = path.join(self.path_trabajo, 'tb_zona_procesar') fragmentos = arcpy.FeatureToPolygon_management( [path_eje_vial, path_zona, path_manzana], path.join(self.path_trabajo, 'fragmentos'), "10 Meters", "NO_ATTRIBUTES", "") x = arcpy.SpatialJoin_analysis( fragmentos, path_manzana, path.join(self.path_trabajo, 'fragmentos_manzanas_x'), 'JOIN_ONE_TO_ONE', 'KEEP_ALL', '', 'HAVE_THEIR_CENTER_IN') arcpy.SelectLayerByAttribute_management(x, "NEW_SELECTION", " Join_Count=1") dissolveFields = [ 'CODDPTO', 'CODPROV', 'CODDIST', 'CODZONA', 'SUFZONA', 'CODMZNA', 'UBIGEO ' 'CODCCPP', 'DEPARTAMENTO', 'PROVINCIA', 'DISTRITO', 'NOMCCCPP' 'SUF_MZNA', 'PK_MANZANA', 'ZONA', 'MANZANA' ] fragmentos_manzanas = arcpy.Dissolve_management( x, path.join(self.path_trabajo, 'fragmentos_manzanas'), dissolveFields, "", "SINGLE_PART", "DISSOLVE_LINES")
def create_polys(input_workspace, folder_basename): """"Takes input TFL lines and attempts to build polygons to a temp layer. If build succeeds, informs user and deletes the temp feature class. If no polygons created, deletes temp feature class and warns user""" tfl_lines = input_workspace + os.sep + folder_basename + '_Line' #Check if a previous temp poly exists - if so delete it first if arcpy.Exists(input_workspace + os.sep + 'Temp_Poly'): arcpy.Delete_management(input_workspace + os.sep + 'Temp_Poly') #select only the active and retired lines - use to build polys - retired lines are used for deletions arcpy.MakeFeatureLayer_management(tfl_lines, 'tfl_lines_layer', "Status_Code = 'ACTIVE'") arcpy.FeatureToPolygon_management('tfl_lines_layer', input_workspace + os.sep + 'Temp_Poly') if int( arcpy.GetCount_management(input_workspace + os.sep + 'Temp_Poly').getOutput(0)) == 0: arcpy.AddWarning( "===== Warning - No polygons created using input active lines\n") arcpy.Delete_management(input_workspace + os.sep + 'Temp_Poly') else: #If there are any records then at least one polygon built - inform user arcpy.AddMessage( 'One or more polygons created from active input lines\n') arcpy.Delete_management(input_workspace + os.sep + 'Temp_Poly')
def execute(self, params, messages): workingCoreInput = params[0].valueAsText workingSLPInput = params[1].valueAsText watershedInput = params[2].valueAsText #Print the specification version id arcpy.AddMessage( "\n********************************************************************\n\ Script follows specification version: \n\ {0}.\n\ ********************************************************************\n" .format(str(self.specIDVersion))) # Set the workspace environment arcpy.env.workspace = "in_memory" # Get eoid from core srows = arcpy.da.SearchCursor(workingCoreInput, ["EO_ID"]) for srow in srows: eoid = srow[0] arcpy.AddMessage("Processing EO ID {0} at {1}".format( eoid, datetime.datetime.now().strftime("%H:%M:%S"))) #Create EO_ID selection query eoidQuery = '"EO_ID" = {0}'.format(eoid) #Create a targetCore layer arcpy.MakeFeatureLayer_management(workingCoreInput, "targetCore", eoidQuery) #Capture all HUC-12 watersheds that intersect the target core arcpy.MakeFeatureLayer_management(watershedInput, "watershedLayer") arcpy.SelectLayerByLocation_management("watershedLayer", "INTERSECT", "targetCore") # Use feature to polygon tool to remove voids and dissolve to a single feature arcpy.FeatureToPolygon_management("watershedLayer", "features_to_polygon") arcpy.Dissolve_management("features_to_polygon", "newSLP") #Append to the workingSLPInput arcpy.Append_management("newSLP", workingSLPInput, "NO_TEST") # Add eoid to supporting polygon urows = arcpy.da.UpdateCursor(workingSLPInput, ["EO_ID"], '"EO_ID" is null') for urow in urows: urow[0] = eoid urows.updateRow(urow) # Calculate attributes cpp.calc_attr_slp(eoid, workingCoreInput, workingSLPInput, specid=self.specIDVersion) #Clear the in_memory workspace arcpy.Delete_management("in_memory") return
def main(): N = len(sys.argv) #print N inputlist = ["hi"] * (N - 3) # print command line arguments print "The input features are: " for index in range(len(sys.argv)): if index == 0: continue if index == N - 2: break inputlist[index - 1] = sys.argv[index] + ".shp" print " " + sys.argv[index] #print inputlist[0] outputname = sys.argv[N - 2] print "The temporary file name is: " print " " + outputname tol = sys.argv[N - 1] print "User specified tolerance: " print " " + tol print "ARCGIS Commands >>>" # STEP 1 print " " + "FeatureToLine_management ..." arcpy.FeatureToLine_management(inputlist, outputname, tol, "ATTRIBUTES") # STEP 2 outputname_poly = outputname + "_poly" print " " + "FeatureToPolygon_management ..." arcpy.FeatureToPolygon_management(outputname + ".shp", outputname_poly, tol, "ATTRIBUTES", "") #print outputname_poly # STEP 3 print " " + "AddField_management ..." arcpy.AddField_management(outputname_poly + ".shp", "ID_temp", "SHORT") outputname_diss = outputname_poly + "_diss" #print outputname_diss # STEP 4 print " " + "Dissolve_management ..." arcpy.Dissolve_management(outputname_poly + ".shp", outputname_diss, "ID_temp") outputname_inter = outputname_diss + "_int" # STEP 5 print " " + "Intersect_analysis ..." arcpy.Intersect_analysis([outputname_diss + ".shp", inputlist[0]], outputname_inter, "", tol) outputname_AllVerts = outputname + "_allVert" # STEP 6 print " " + "FeatureVerticesToPoints_management ..." arcpy.FeatureVerticesToPoints_management(outputname + ".shp", outputname_AllVerts, "ALL")
def spreadsheetToLinePolygon(dataFile, geometryType, xField, yField, spreadsheetUniqueID, inputCoordinateSystemName, inputCoordinateSystem, outputCoordinateSystemName, outputCoordinateSystem, transformation): # If excel spreadsheet if dataFile.lower().endswith(('.xls', '.xlsx')): dataFile = arcpy.ExcelToTable_conversion(dataFile, "in_memory\\DatasetExcel", "") # If projection needed if (transformation.lower() != "none"): printMessage("Importing CSV/Excel...", "info") arcpy.MakeXYEventLayer_management(dataFile, xField, yField, "InputLayer", inputCoordinateSystem, "") printMessage( "Projecting layer from " + inputCoordinateSystemName + " to " + outputCoordinateSystemName + "...", "info") arcpy.Project_management( "InputLayer", os.path.join(arcpy.env.scratchGDB, "Layer_Projected"), outputCoordinateSystem, transformation, inputCoordinateSystem, "NO_PRESERVE_SHAPE", "") else: printMessage("Importing CSV/Excel...", "info") arcpy.MakeXYEventLayer_management(dataFile, xField, yField, "Layer", inputCoordinateSystem, "") arcpy.CopyFeatures_management("Layer", "in_memory\\Dataset", "", "0", "0", "0") if (transformation.lower() != "none"): dataset = os.path.join(arcpy.env.scratchGDB, "Layer_Projected") else: dataset = "in_memory\\Dataset" printMessage("Creating layer...", "info") if (geometryType.lower() == "line"): # Convert the points to lines using the unique identifier field to create each unique line arcpy.PointsToLine_management(dataset, "in_memory\\DatasetLine", spreadsheetUniqueID, "", "NO_CLOSE") output = arcpy.MakeFeatureLayer_management("in_memory\\DatasetLine", "Layer", "", "", "") if (geometryType.lower() == "polygon"): # Convert the points to lines using the unique identifier field to create each unique line, then close the final line arcpy.PointsToLine_management(dataset, "in_memory\\DatasetLine", spreadsheetUniqueID, "", "CLOSE") # Convert the lines to polygons and join on attribute from lines arcpy.FeatureToPolygon_management("in_memory\\DatasetLine", "in_memory\\DatasetPolygon", "", "ATTRIBUTES", "") arcpy.JoinField_management("in_memory\\DatasetPolygon", "OID", "in_memory\\DatasetLine", "OID", spreadsheetUniqueID) output = arcpy.MakeFeatureLayer_management("in_memory\\DatasetPolygon", "Layer", "", "", "") return output
def optimizacion_cobertura(oid): global troba, tapt, identificador, vias_mfl query = "OBJECTID = %s" % oid troba_mfl = arcpy.MakeFeatureLayer_management(troba, "troba", query) pol_tmp = arcpy.FeatureToPolygon_management([troba_mfl, vias_mfl], r'D:\TEMP\hora.shp') for m in arcpy.da.SearchCursor(pol_tmp, ['OID@', 'SHAPE@']): identificador += 1 arcpy.AddMessage(identificador) pol = arcpy.MakeFeatureLayer_management(pol_tmp, 'pol_tmp_mfl', 'FID = {}'.format(m[0])) arcpy.SelectLayerByLocation_management(vias_mfl, "INTERSECT", troba_mfl, "#", 'NEW_SELECTION') arcpy.SelectLayerByLocation_management(tapt, "INTERSECT", pol, "#", 'NEW_SELECTION') if arcpy.GetCount_management(vias_mfl).__str__() == '0': arcpy.AddMessage("Tiene vias") pol = arcpy.FeatureToPolygon_management([pol, vias_mfl], "in_memory//thiessenVias") arcpy.env.extent = pol taps_thiessen = arcpy.CreateThiessenPolygons_analysis(tapt, "in_memory//taptemp") pol = arcpy.Clip_analysis(taps_thiessen, m[1], "in_memory//clipThiessen") #if pol: arcpy.Append_management(pol, output, 'NO_TEST') with arcpy.da.UpdateCursor(output, [field], "%s is null" % field) as cursor: for i in cursor: i[0] = identificador cursor.updateRow(i) del cursor arcpy.SelectLayerByAttribute_management(tapt, 'CLEAR_SELECTION') arcpy.SelectLayerByAttribute_management(vias_mfl, 'CLEAR_SELECTION')
def pre_processing(self): print('Pre-processing...') for i, line in enumerate(self.lines): fields = arcpy.ListFields(line) field_names = [] for field in fields: field_names.append(field.name) if self.weight not in field_names: arcpy.AddField_management(line, self.weight, 'TEXT') # Add the field 'weight' rows = arcpy.UpdateCursor(line) for row in rows: row.setValue(self.weight, str(self.lines_level[i])) # Set the weight rows.updateRow(row) self.lines.append(self.road) if not os.path.isfile(self.workspace_path + '\\' + 'merge_all.shp'): arcpy.Merge_management(self.lines, 'merge_all.shp') if not os.path.isfile( self.workspace_path + '\\' + 'streets_polygon.shp'): # Roads: lines to polygons arcpy.FeatureToPolygon_management('merge_all.shp', 'streets_polygon.shp') if not os.path.exists(self.coverage_folder ): # Roads: poltgons to coverage to get topo arcpy.FeatureclassToCoverage_conversion( [['streets_polygon.shp', 'POLYGON']], self.coverage_folder) if not os.path.isfile(self.workspace_path + '\\' + 'arc.shp'): # To get topo arcpy.FeatureClassToFeatureClass_conversion( self.coverage_folder + '\\arc', self.workspace_path, 'arc') if not os.path.isfile(self.workspace_path + '\\' + self.__area_path): # Coverage to polygons arcpy.FeatureClassToFeatureClass_conversion( self.coverage_folder + '\\polygon', self.workspace_path, self.__area_path) if not os.path.isfile(self.workspace_path + '\\' + self.__arc_path): # Create field mappings # Get weights for arc fld_mappings = arcpy.FieldMappings() fld_mappings.addTable('arc.shp') fld_map = arcpy.FieldMap() fld_map.addInputField('merge_all.shp', self.weight) fld_mappings.addFieldMap(fld_map) # Spatial join to get the weights arcpy.SpatialJoin_analysis('arc.shp', 'merge_all.shp', self.__arc_path, 'JOIN_ONE_TO_ONE', 'KEEP_ALL', fld_mappings, 'CLOSEST') arcpy.Delete_management('arc.shp') arcpy.Delete_management('merge_all.shp') arcpy.Delete_management('streets_polygon.shp') print('Pre-processing done...')
def findBraidedReaches(fcLines): # Clear temporary data if arcpy.Exists("in_memory//DonutPolygons"): arcpy.Delete_management("in_memory//DonutPolygons") if arcpy.Exists("lyrDonuts"): arcpy.Delete_management("lyrDonuts") if arcpy.Exists("lyrBraidedReaches"): arcpy.Delete_management("lyrBraidedReaches") # Find donut reaches arcpy.FeatureToPolygon_management(fcLines,"in_memory/DonutPolygons") arcpy.MakeFeatureLayer_management(fcLines,"lyrBraidedReaches") arcpy.MakeFeatureLayer_management("in_memory/DonutPolygons","lyrDonuts") arcpy.SelectLayerByLocation_management("lyrBraidedReaches","SHARE_A_LINE_SEGMENT_WITH","lyrDonuts",'',"NEW_SELECTION") arcpy.CalculateField_management("lyrBraidedReaches","IsBraided",1,"PYTHON")
def create_pblks(city_info, geo_path): city_name, state_abbr, decade = city_info city_name = city_name.replace(' ','') pblk_shp = geo_path + city_name + "_" + str(decade) + "_Pblk.shp" split_grid = geo_path + city_name + "_" + str(decade) + "_stgrid_Split.shp" grid_uns2 = geo_path + city_name + state_abbr + "_" + str(decade) + "_stgrid_edit_Uns2.shp" if not os.path.isfile(split_grid) or not os.path.isfile(grid_uns2): print("Processing raw stgrid for %s" %decade) _ = process_raw_grid(city_info, geo_path) #Create Physical Blocks# ##### arcpy.FeatureToPolygon_management(split_grid, pblk_shp) #Add a Physical Block ID expression="!FID! + 1" arcpy.AddField_management(pblk_shp, "pblk_id", "LONG", 4, "", "","", "", "") arcpy.CalculateField_management(pblk_shp, "pblk_id", expression, "PYTHON_9.3")
def onRectangle(self, rectangle_geometry): """Occurs when the rectangle is drawn and the mouse button is released. The rectangle is a extent object.""" array = arcpy.Array() array.add(rectangle_geometry.upperLeft) array.add(rectangle_geometry.upperRight) array.add(rectangle_geometry.lowerRight) array.add(rectangle_geometry.lowerLeft) array.add(rectangle_geometry.upperLeft) polygon = arcpy.Polygon(array) arcpy.env.overwriteOutput = True # temporarily allow overwriting of existing datasets, then disallow. arcpy.FeatureToPolygon_management( polygon, r"C:\Users\s\Documents\Masters of Geospatial\GISP\Assignment2\GISdata\survey_area.shp" ) arcpy.env.overwriteOutput = False WORKSPACE = r"C:\Users\s\Documents\Masters of Geospatial\GISP\Assignment2\GISdata" arcpy.env.workspace = WORKSPACE
def polygon(self): inFeatures1 = os.path.join(workspce, cad, cad_use[0]) outFeatureClass = os.path.join(workspce, creat_gdb, self.polygon_name) arcpy.FeatureToPolygon_management(inFeatures1, outFeatureClass) inFeatures2 = os.path.join(workspce, cad, cad_use[1]) outFeatureClass = os.path.join(workspce, creat_gdb, self.point_name) arcpy.FeatureToPoint_management(inFeatures2, outFeatureClass) where_clause = " RefName LIKE '5%' OR RefName LIKE '3%'" # 筛选符合要求的编号,其都以5和3开头 select_fc = os.path.join(workspce, creat_gdb, self.select_anno) arcpy.Select_analysis(os.path.join(workspce, creat_gdb, self.point_name), select_fc , where_clause) outFeatureClass = os.path.join(workspce, creat_gdb, self.sp_fc) arcpy.SpatialJoin_analysis(os.path.join(workspce, creat_gdb, self.polygon_name), os.path.join(workspce, creat_gdb, self.select_anno), outFeatureClass) arcpy.MakeFeatureLayer_management(os.path.join(workspce, creat_gdb, self.sp_fc), "lyr") arcpy.SelectLayerByLocation_management ("lyr", select_features = area_fc) arcpy.CopyFeatures_management("lyr", os.path.join(workspce, creat_gdb, self.final_fc))
def findBraidedReaches(fcLines, is_verbose): if is_verbose: arcpy.AddMessage("Finding streams with mutltiple channels...") # Clear temporary data if arcpy.Exists("in_memory//DonutPolygons"): arcpy.Delete_management("in_memory//DonutPolygons") if arcpy.Exists("lyrDonuts"): arcpy.Delete_management("lyrDonuts") if arcpy.Exists("lyrBraidedReaches"): arcpy.Delete_management("lyrBraidedReaches") # Find donut reaches arcpy.FeatureToPolygon_management(fcLines, "in_memory/DonutPolygons") arcpy.MakeFeatureLayer_management(fcLines, "lyrBraidedReaches") arcpy.MakeFeatureLayer_management("in_memory/DonutPolygons", "lyrDonuts") arcpy.SelectLayerByLocation_management("lyrBraidedReaches", "SHARE_A_LINE_SEGMENT_WITH", "lyrDonuts", '', "NEW_SELECTION") arcpy.CalculateField_management("lyrBraidedReaches", "IsMultiCh", 1, "PYTHON") arcpy.CalculateField_management("lyrBraidedReaches", "IsMainCh", 0, "PYTHON")
def surface_in_between(self): arcpy.AddMessage("Started differential surface statistics... ") self.report.write("\n---Differential surface---\n") temp_merge = "in_memory\\merge" arcpy.Merge_management([self.original, self.simplified], temp_merge) temp_poly = "in_memory\\poly" arcpy.FeatureToPolygon_management(temp_merge, temp_poly) arcpy.Delete_management(temp_merge) arcpy.AddGeometryAttributes_management(temp_poly, "AREA", "#", "SQUARE_METERS") with arcpy.da.SearchCursor(temp_poly, ["POLY_AREA"]) as cursor: summarize = 0 parts = 0 for row in cursor: summarize += row[0] parts += 1 mean = summarize / parts arcpy.Delete_management(temp_poly) self.report.write("Sum area: {:0.0f} sq m\n".format(summarize)) self.report.write("Mean area: {:0.0f} sq m\n".format(mean)) arcpy.AddMessage("Differential surface statistics - done.") return
def label_polygons(infc, labelfc, outfc): """ Label polygons. infc input feature class (can be lines or polygons) labelfc point feature class containing attributes for outfc outfc where to write polygons """ logging.info("label_polygons(%s, %s, %s)" % (infc, labelfc, outfc)) # Notes on "FeatureToPolygon" # If you use the "NO ATTRIBUTES" default, then only the shapes are move from the input to the generated polygon feature class. # If you use "ATTRIBUTES" the attributes are copied. # If you use "ATTRIBUTES" and a polygon or line feature class AND a point feature class, # the attributes from the points are copied to the output (the poly/line attributes are lost). # If there are multiple points inside a new polygon feature it picks attributes from one randomly. # Input features can be lines or polygons, so you can think of it as a way of just transferring the attributes if you have input polygons. # The blank "" arg is a tolerance, if you have sloppy input you can use this to close the polygons. # # NB when I ran it as a standalone tool in ArcMap I got a background server error, I had to run it in foreground. # I wish that ESRI was a bit more consistent in what DOES and DOES NOT support the workspace environment variable. ws = str(arcpy.env.workspace) logging.info("label_polygons(%s, %s, %s)" % (infc, labelfc, outfc)) i = os.path.join(ws, infc) l = os.path.join(ws, labelfc) o = os.path.join(ws, outfc) try: arcpy.Delete_management(o) except Exception as e: logging.info("Did not delete %s, %s" % (o, e)) try: arcpy.FeatureToPolygon_management(i, o, "", "ATTRIBUTES", l) except Exception as e: logging.error(e) return