areawayfc, "temparea", "", "", "Shape_Length Shape_Length VISIBLE;Way_ID Way_ID VISIBLE") arcpy.AddJoin_management("temparea", "Way_ID", waytagtab, "Way_ID", "KEEP_COMMON") arcpy.CopyFeatures_management("temparea", finalareawayfc, "", "0.05", "0.5", "5.0") arcpy.Delete_management("temparea") arcpy.Delete_management(areawayfc) arcpy.Delete_management(waytagtab) #Sort out some of the mess caused by loading all loops as areas. #copy highways that are loops from areas to line feature class needs an ArcInfo License if arcpy.CheckProduct("ArcInfo") == "Available": arcpy.AddMessage("Tidying areas that should be lines") arcpy.MakeFeatureLayer_management(finalareawayfc, "loopyroads", "osm_way_tags_highway <> ''") arcpy.FeatureToLine_management("loopyroads", temproadsfc) arcpy.Append_management(temproadsfc, finalwayfc, "NO_TEST") arcpy.Delete_management(temproadsfc) arcpy.AddMessage("Step 7 --- %s seconds ---" % (time.time() - stepstarttime)) #Completed arcpy.AddMessage("Conversion Completed") arcpy.AddMessage( str(nodecount) + ' Nodes ' + str(waycount) + ' Ways' + str(relcount) + ' relations ') arcpy.AddMessage("Total runtime --- %s seconds ---" % (time.time() - starttime))
if state_dict2[cs_list[i]] in st: clist = clist + [city_list[i]] #if len(clist) == 1: # clist = tuple(clist)+tuple("XXXX") print "- " + str(clist) name_select = " \"NAME10\" IN " + str(tuple(clist)) arcpy.MakeFeatureLayer_management(state_place_clip, ua_places, name_select, "") place_line_hold = lines + "places_line_" + str(c) + ".shp" # Process: Feature To Line arcpy.FeatureToLine_management(ua_places, place_line_hold, "", "ATTRIBUTES") # Process: Near calculation print "- Near Calculations" arcpy.Near_analysis(ua_lehd_acs, place_line_hold, "", "NO_LOCATION", "NO_ANGLE", "PLANAR") ##This can be vastly improved by just computing a distance for each tract from boundary and merging on that one file! #for d in range(200,3200, 200): # boundary_tracts = boundary + "boundary_tracts_" + str(d) + "_" + str(c) + ".shp" # dist_str = str(d) + " Meters"
except Exception,e: arcpy.AddError('%s'%(e)) continue def Width(infc,mask): area = {} for feature in arcpy.da.SearchCursor(mask,['SHAPE@','Id']): try: if feature[1] not in area: area[feature[1]] = feature[0].area except Exception,e: arcpy.AddError('%s'%(e)) arcpy.FeatureToLine_management([mask],'in_memory\\templines',"0.001 Meters", "ATTRIBUTES") dname = os.path.dirname(infc) arcpy.CreateFeatureclass_management('in_memory','temppoints',"POINT",'','','',infc) arcpy.AddField_management('in_memory\\temppoints','FID',"LONG") cursor = arcpy.da.InsertCursor('in_memory\\temppoints',['SHAPE@','FID']) fields = ['Id','DCoordx','DCoordy','OID@'] for row in arcpy.da.SearchCursor(infc,fields): data = [[row[1],row[2]],row[-1]] cursor.insertRow(data) arcpy.Near_analysis('in_memory\\temppoints', 'in_memory\\templines') curfields = [f.name for f in arcpy.ListFields(infc)] if 'Width' not in curfields:
def main(): try: ################################################################################## #READ PARAMETERS ################################################################################## inpoints = arcpy.GetParameterAsText(0) inlines = arcpy.GetParameterAsText(1) outWorkspace = arcpy.GetParameterAsText(2) outpoints = arcpy.GetParameterAsText(3) outsegments = arcpy.GetParameterAsText(4) outpolygons = arcpy.GetParameterAsText(5) inroads_identifier = arcpy.GetParameterAsText(6) arcpy.env.workspace = outWorkspace ################################################################################## #HARD CODED PARAMETERS ################################################################################## if arcpy.env.scratchWorkspace is None: arcpy.env.scratchWorkspace = r'C:\Users\fancelin\Documents\ArcGIS\Default.gdb' factor = 100 inroads_split_name = "voronoying_lines_split" inroads_split_line_name = "voronoying_lines_split_lines" inroads_split = "{0}{1}{2}".format(arcpy.env.scratchWorkspace, os.path.sep, inroads_split_name) inroads_split_line = "{0}{1}{2}".format(arcpy.env.scratchWorkspace, os.path.sep, inroads_split_line_name) spatial_reference = arcpy.Describe(inlines).spatialReference ################################################################################## #VALIDATION ################################################################################## arcpy.AddMessage("Validation") #Validate license requirements validateLicense() #Validate lines are provided if len(outsegments) == 0: raise Exception("Input lines were not provided.") #Validate that a line identifier was provided if len(inroads_identifier) == 0: raise Exception("Input lines identifer was not provided.") extents = [] #Validate input line feature class. inlinesBBox = validateInputLineFeatureClass(inlines) extents.append(inlinesBBox) #Validate input point feature class if required. inPointsBBox = validateInputPointFeatureClass(inpoints) if len( arcpy.GetParameterAsText(0)) > 0 else None ################################################################################## #REMOVE FEATURE CLASSES ################################################################################## for fc in [ inroads_split, inroads_split_line, "{0}{1}{2}".format(outWorkspace, os.path.sep, outpoints), "{0}{1}{2}".format(outWorkspace, os.path.sep, outsegments), "{0}{1}{2}".format(outWorkspace, os.path.sep, outpolygons) ]: delFCByPath(fc) ################################################################################## #COMPUTING THE BOUNDING BOX ################################################################################## # Instanciate pyvoronoi pv = pyvoronoi.Pyvoronoi(factor) arcpy.AddMessage("Add points to voronoi") pointOIDs = [] if inPointsBBox != None: extents.append(inPointsBBox) for point in arcpy.da.SearchCursor(inpoints, ['SHAPE@X', 'SHAPE@Y', 'OID@']): pointOIDs.append(point[2]) pv.AddPoint([point[0], point[1]]) arcpy.AddMessage("Computing bounding box outlines") finalBBox = mergeExtent(extents) finalBBoxExpended = arcpy.Extent(finalBBox.XMin - 1, finalBBox.YMin - 1, finalBBox.XMax + 1, finalBBox.YMax + 1) bbox_line = [ arcpy.Array([ arcpy.Point(finalBBox.XMin, finalBBox.YMin), arcpy.Point(finalBBox.XMax, finalBBox.YMin) ]), arcpy.Array([ arcpy.Point(finalBBox.XMin, finalBBox.YMin), arcpy.Point(finalBBox.XMin, finalBBox.YMax) ]), arcpy.Array([ arcpy.Point(finalBBox.XMax, finalBBox.YMax), arcpy.Point(finalBBox.XMin, finalBBox.YMax) ]), arcpy.Array([ arcpy.Point(finalBBox.XMax, finalBBox.YMax), arcpy.Point(finalBBox.XMax, finalBBox.YMin) ]), arcpy.Array([ arcpy.Point(finalBBoxExpended.XMin, finalBBoxExpended.YMin), arcpy.Point(finalBBoxExpended.XMax, finalBBoxExpended.YMin) ]), arcpy.Array([ arcpy.Point(finalBBoxExpended.XMin, finalBBoxExpended.YMin), arcpy.Point(finalBBoxExpended.XMin, finalBBoxExpended.YMax) ]), arcpy.Array([ arcpy.Point(finalBBoxExpended.XMax, finalBBoxExpended.YMax), arcpy.Point(finalBBoxExpended.XMin, finalBBoxExpended.YMax) ]), arcpy.Array([ arcpy.Point(finalBBoxExpended.XMax, finalBBoxExpended.YMax), arcpy.Point(finalBBoxExpended.XMax, finalBBoxExpended.YMin) ]) ] arcpy.AddMessage("Bounding Box Info: {0},{1} | {2},{3}".format( finalBBox.XMin, finalBBox.YMin, finalBBox.XMax, finalBBox.YMax)) ################################################################################## #FORMAT INPUT. NEED TO MAKE SURE LINE ARE SPLIT AT VERTICES AND THAT THERE ARE NO OVERLAPS ################################################################################## arcpy.AddMessage("Format lines") arcpy.AddMessage("Split lines at vertices") arcpy.SplitLine_management(in_features=inlines, out_feature_class=inroads_split) arcpy.AddMessage("Add bounding box") with arcpy.da.InsertCursor(inroads_split, ['SHAPE@', inroads_identifier]) as op: for pointArray in bbox_line: arcpy.AddMessage("{0},{1} - {2},{3}".format( pointArray[0].X, pointArray[0].Y, pointArray[1].X, pointArray[1].Y)) op.insertRow([arcpy.Polyline(pointArray), None]) del op arcpy.AddMessage("Split lines at intersections") arcpy.FeatureToLine_management(inroads_split, inroads_split_line, '#', 'ATTRIBUTES') ################################################################################## #SEND LINE INPUT TO VORONOI AND CONSTRUCT THE GRAPH ################################################################################## arcpy.AddMessage("Add lines to voronoi") lineIds = [] for road in arcpy.da.SearchCursor( inroads_split_line, ['SHAPE@', 'OID@', 'SHAPE@LENGTH', inroads_identifier]): if (road[2] > 0): lineIds.append(road[3]) pv.AddSegment([[road[0].firstPoint.X, road[0].firstPoint.Y], [road[0].lastPoint.X, road[0].lastPoint.Y]]) arcpy.AddMessage("Construct voronoi") pv.Construct() cells = pv.GetCells() edges = pv.GetEdges() vertices = pv.GetVertices() ################################################################################## #CREATE THE OUTPUT FEATURE CLASSES ################################################################################## arcpy.AddMessage("Construct output segment feature class") if len(outsegments) > 0: arcpy.CreateFeatureclass_management( outWorkspace, outsegments, 'POLYLINE', spatial_reference=spatial_reference) arcpy.AddField_management(outsegments, 'EdgeIndex', "LONG") arcpy.AddField_management(outsegments, 'Start', "LONG") arcpy.AddField_management(outsegments, 'End', "LONG") arcpy.AddField_management(outsegments, 'IsLinear', "SHORT") arcpy.AddField_management(outsegments, 'IsPrimary', "SHORT") arcpy.AddField_management(outsegments, 'Site1', "LONG") arcpy.AddField_management(outsegments, 'Site2', "LONG") arcpy.AddField_management(outsegments, 'Cell', "LONG") arcpy.AddField_management(outsegments, 'Twin', "LONG") fields = [ 'EdgeIndex', 'Start', 'End', 'IsLinear', 'IsPrimary', 'Site1', 'Site2', 'Cell', 'Twin', 'SHAPE@' ] cursor = arcpy.da.InsertCursor(outsegments, fields) for cIndex in range(len(cells)): cell = cells[cIndex] if cell.is_open == False: if (cIndex % 5000 == 0 and cIndex > 0): arcpy.AddMessage("Cell Index: {0}".format(cIndex)) for i in range(len(cell.edges)): e = edges[cell.edges[i]] startVertex = vertices[e.start] endVertex = vertices[e.end] max_distance = distance( [startVertex.X, startVertex.Y], [endVertex.X, endVertex.Y]) / 10 array = arcpy.Array() if startVertex != -1 and endVertex != -1: if (e.is_linear == True): array = arcpy.Array([ arcpy.Point(startVertex.X, startVertex.Y), arcpy.Point(endVertex.X, endVertex.Y) ]) else: try: points = pv.DiscretizeCurvedEdge( cell.edges[i], max_distance) for p in points: #print "{0},{1}".format(p[0], p[1]) array.append(arcpy.Point(p[0], p[1])) except: arcpy.AddMessage( "Issue at: {5}. The drawing has been defaulted from a curved line to a straight line. Length {0} - From: {1}, {2} To: {3}, {4}" .format(max_distance, startVertex.X, startVertex.Y, endVertex.X, endVertex.Y, i)) #array = arcpy.Array([arcpy.Point(startVertex.X, startVertex.Y), arcpy.Point(endVertex.X, endVertex.Y)]) array = arcpy.Array([ arcpy.Point(startVertex.X, startVertex.Y), arcpy.Point(endVertex.X, endVertex.Y) ]) polyline = arcpy.Polyline(array) cursor.insertRow( (cell.edges[i], e.start, e.end, e.is_linear, e.is_primary, e.site1, e.site2, e.cell, e.twin, polyline)) arcpy.AddMessage("Construct output cells feature class") if len(outpolygons) > 0: arcpy.CreateFeatureclass_management( outWorkspace, outpolygons, 'POLYGON', spatial_reference=spatial_reference) arcpy.AddField_management(outpolygons, 'CELL_ID', "LONG") arcpy.AddField_management(outpolygons, 'CONTAINS_POINT', "SHORT") arcpy.AddField_management(outpolygons, 'CONTAINS_SEGMENT', "SHORT") arcpy.AddField_management(outpolygons, 'SITE', "LONG") arcpy.AddField_management(outpolygons, 'SOURCE_CATEGORY', "SHORT") arcpy.AddField_management(outpolygons, 'INPUT_TYPE', "TEXT") arcpy.AddField_management(outpolygons, 'INPUT_ID', "LONG") fields = [ 'CELL_ID', 'CONTAINS_POINT', 'CONTAINS_SEGMENT', 'SHAPE@', 'SITE', 'SOURCE_CATEGORY', 'INPUT_TYPE', 'INPUT_ID' ] cursor = arcpy.da.InsertCursor(outpolygons, fields) for cIndex in range(len(cells)): cell = cells[cIndex] if cell.is_open == False: if (cIndex % 5000 == 0 and cIndex > 0): arcpy.AddMessage("Cell Index: {0}".format(cIndex)) pointArray = arcpy.Array() for vIndex in cell.vertices: pointArray.add( arcpy.Point(vertices[vIndex].X, vertices[vIndex].Y)) input_type = None input_id = None if cell.site >= len(pointOIDs): input_type = "LINE" input_id = lineIds[cell.site - len(pointOIDs)] else: input_type = "POINT" input_id = pointOIDs[cell.site] polygon = arcpy.Polygon(pointArray) cursor.insertRow( (cell.cell_identifier, cell.contains_point, cell.contains_segment, polygon, cell.site, cell.source_category, input_type, input_id)) del cursor except Exception: tb = sys.exc_info()[2] tbInfo = traceback.format_tb(tb)[-1] arcpy.AddError('PYTHON ERRORS:\n%s\n%s: %s\n' % (tbInfo, sys.exc_type, sys.exc_value)) # print('PYTHON ERRORS:\n%s\n%s: %s\n' % # (tbInfo, _sys.exc_type, _sys.exc_value)) arcpy.AddMessage('PYTHON ERRORS:\n%s\n%s: %s\n' % (tbInfo, sys.exc_type, sys.exc_value)) gp_errors = arcpy.GetMessages(2) if gp_errors: arcpy.AddError('GP ERRORS:\n%s\n' % gp_errors)
# import system modules import arcpy from arcpy import env import os import shutil arcpy.env.overwriteOutput = True #Aqui se define la carpeta que va a contener las carpetas "RUSTICO" y "URBANO" con los shapefiles root = "d:\\carpeta" env.workspace = root auxiliar = root + "\\AUXILIAR" os.mkdir(auxiliar) #Se recortan los lindes y los frentes de parcela, corrigiendo algunos errores graficos arcpy.FeatureToLine_management("PARCELA.shp", "AUXILIAR\\PARCELA_LINE.shp") arcpy.Erase_analysis("AUXILIAR\\PARCELA_LINE.shp", "DOMPUB.shp", "AUXILIAR\\LINDEIROS_.shp") arcpy.Dissolve_management("PARCELA.shp", "AUXILIAR\\MANZANAS_.shp") arcpy.FeatureToLine_management("AUXILIAR\\MANZANAS_.shp", "AUXILIAR\\MANZANAS_FRONTE.shp") arcpy.Buffer_analysis("DOMPUB.shp", "AUXILIAR\\DOMPUB_.shp", "0,01", "FULL", "ROUND", "ALL") arcpy.Intersect_analysis( ["AUXILIAR\\DOMPUB_.shp", "AUXILIAR\\MANZANAS_FRONTE.shp"], "AUXILIAR\\MANZANAS_FRONTE2", "ALL", "", "") arcpy.Erase_analysis("AUXILIAR\\LINDEIROS_.shp", "AUXILIAR\\MANZANAS_FRONTE2.shp", "LINDEIROS.shp") # Se crean las medianeras y fachadas preliminares de las plantas altas (de edificios entre si para captar medianeras en voladizos) arcpy.FeatureToLine_management("ALTAS.shp", "AUXILIAR\\ALTAS_LINE.shp")
def ExtractIntFromSeg(Segments, Intersections, Buffer, Output): #Output should be on a GDB not a shapefile SegFields = [f.name for f in arcpy.ListFields(Segments)] SelInt = common.CreateOutPath(MainFile=Output, appendix='SelInt', Extension='') arcpy.SpatialJoin_analysis(target_features=Intersections, join_features=Segments, out_feature_class=SelInt, join_operation='JOIN_ONE_TO_ONE', join_type='KEEP_COMMON', match_option='INTERSECT', search_radius=Buffer) arcpy.DeleteField_management( SelInt, [f.name for f in arcpy.ListFields(SelInt) if not f.required]) SelIntBuf = common.CreateOutPath(MainFile=Output, appendix='SelIntBuf', Extension='') arcpy.Buffer_analysis(in_features=SelInt, out_feature_class=SelIntBuf, buffer_distance_or_field=str(Buffer) + ' Feet', line_side='FULL', line_end_type='FLAT') F2L = common.CreateOutPath(MainFile=Output, appendix='F2L', Extension='') arcpy.FeatureToLine_management(in_features=[Segments, SelIntBuf], out_feature_class=F2L, attributes='ATTRIBUTES') F2LLayer = common.CreateOutLayer('F2LLayer') arcpy.MakeFeatureLayer_management(in_features=F2L, out_layer=F2LLayer) arcpy.SelectLayerByAttribute_management(in_layer_or_view=F2LLayer, selection_type='NEW_SELECTION', where_clause="BUFF_DIST = 0") Seg1F = common.CreateOutPath(MainFile=Output, appendix='Seg1F', Extension='') arcpy.CopyFeatures_management(in_features=F2LLayer, out_feature_class=Seg1F) arcpy.DeleteField_management(Seg1F, [ f.name for f in arcpy.ListFields(Seg1F) if not f.required and not f.name in SegFields ]) Selseg = common.CreateOutPath(MainFile=Output, appendix='SelSeg', Extension='') arcpy.SpatialJoin_analysis(target_features=Seg1F, join_features=SelIntBuf, out_feature_class=Selseg, join_operation='JOIN_ONE_TO_ONE', join_type='KEEP_ALL', match_option='WITHIN') SPJLayer = common.CreateOutLayer('SPJLayer') arcpy.MakeFeatureLayer_management(in_features=Selseg, out_layer=SPJLayer) arcpy.SelectLayerByAttribute_management( in_layer_or_view=SPJLayer, selection_type='NEW_SELECTION', where_clause="Join_Count = 0 AND Shape_Length>528") arcpy.CopyFeatures_management(in_features=SPJLayer, out_feature_class=Output) arcpy.DeleteField_management(Output, [ f.name for f in arcpy.ListFields(Output) if not f.required and not f.name in SegFields ]) arcpy.Delete_management(SelInt) arcpy.Delete_management(SelIntBuf) arcpy.Delete_management(F2L) arcpy.Delete_management(F2LLayer) arcpy.Delete_management(Seg1F) arcpy.Delete_management(Selseg) arcpy.Delete_management(SPJLayer)
def connected_wetlands(lakes_fc, lake_id_field, wetlands_fc, out_table): env.workspace = 'in_memory' env.outputCoordinateSystem = arcpy.SpatialReference(102039) arcpy.Buffer_analysis(lakes_fc, 'lakes_30m', '30 meters') arcpy.FeatureToLine_management('lakes_30m', 'shorelines') # 3 selections for the wetlands types we want to look at openwater_exp = """"VegType" = 'PEMorPAB'""" forested_exp = """"VegType" = 'PFO'""" scrubshrub_exp = """"VegType" = 'PSS'""" other_exp = """"VegType" = 'Other'""" all_exp = '' selections = [ all_exp, forested_exp, scrubshrub_exp, openwater_exp, other_exp ] temp_tables = [ 'AllWetlands', 'ForestedWetlands', 'ScrubShrubWetlands', 'OpenWaterWetlands', 'OtherWetlands' ] # for each wetland type, get the count of intersection wetlands, and the length of the lake # shoreline that is within a wetland polygon for sel, temp_table in zip(selections, temp_tables): print("Creating temporary table for wetlands where {0}".format(sel)) # this function adds the count and the area using the lake as the zone polygons_in_zones('lakes_30m', lake_id_field, wetlands_fc, temp_table, sel, contrib_area=True) # make good field names now rather than later for f in new_fields: cu.rename_field(temp_table, f, f.replace('Poly', temp_table), True) # shoreline calculation # using the Shape_Length field so can't do this part in memory shoreline_gdb = cu.create_temp_GDB('shoreline') selected_wetlands = os.path.join(shoreline_gdb, 'wetlands') arcpy.Select_analysis(wetlands_fc, selected_wetlands, sel) intersect_output = os.path.join(shoreline_gdb, "intersect") arcpy.Intersect_analysis(['shorelines', selected_wetlands], intersect_output) arcpy.Statistics_analysis(intersect_output, 'intersect_stats', [['Shape_Length', 'SUM']], lake_id_field) cu.one_in_one_out('intersect_stats', ['SUM_Shape_Length'], lakes_fc, lake_id_field, 'temp_shoreline_table') cu.redefine_nulls('temp_shoreline_table', ['SUM_Shape_Length'], [0]) shoreline_field = temp_table + "_Shoreline_Km" arcpy.AddField_management('temp_shoreline_table', shoreline_field, 'DOUBLE') arcpy.CalculateField_management('temp_shoreline_table', shoreline_field, '!SUM_Shape_Length!/1000', 'PYTHON') # join the shoreline value to the temp_table arcpy.JoinField_management(temp_table, lake_id_field, 'temp_shoreline_table', lake_id_field, shoreline_field) # clean up shoreline intermediates for item in [shoreline_gdb, 'intersect_stats', 'temp_shoreline_table']: arcpy.Delete_management(item) # join em up and copy to final temp_tables.remove('AllWetlands') for t in temp_tables: try: arcpy.JoinField_management('AllWetlands', lake_id_field, t, lake_id_field) # sometimes there's no table if it was an empty selection except: empty_fields = [f.replace('Poly', t) for f in new_fields] for ef in empty_fields: arcpy.AddField_management('AllWetlands', ef, 'Double') arcpy.CalculateField_management('AllWetlands', ef, '0', 'PYTHON') continue # remove all the extra zone fields, which have underscore in name drop_fields = [ f.name for f in arcpy.ListFields('AllWetlands', 'Permanent_Identifier_*') ] for f in drop_fields: arcpy.DeleteField_management('AllWetlands', f) # remove all the overlapping metrics, which do not apply by definition fields = [f.name for f in arcpy.ListFields('AlLWetlands')] for f in fields: if 'Overlapping' in f: arcpy.DeleteField_management('AllWetlands', f) arcpy.CopyRows_management('AllWetlands', out_table) for item in ['AllWetlands'] + temp_tables: try: arcpy.Delete_management(item) except: continue
def execute(self, params, messages): deleteInMemory() rawPath = os.path.dirname( params[1].valueAsText) + "\\" + os.path.basename( params[1].valueAsText) + "_Raw_Data" finalPath = os.path.dirname( params[1].valueAsText) + "\\" + os.path.basename( params[1].valueAsText) + "_Final_Data" testPath = os.path.dirname( params[1].valueAsText) + "\\" + os.path.basename( params[1].valueAsText) + "_Test_Data" if not os.path.exists(rawPath): os.mkdir(rawPath) if not os.path.exists(finalPath): os.mkdir(finalPath) if not os.path.exists(testPath): os.mkdir(testPath) poly = arcpy.MakeFeatureLayer_management(params[0].valueAsText) outRaw = rawPath + "\\" + os.path.basename(params[1].valueAsText) outFinal = finalPath + "\\" + os.path.basename(params[1].valueAsText) outTest = testPath + "\\" + os.path.basename(params[1].valueAsText) arcpy.env.workspace = os.path.dirname(params[1].valueAsText) arcpy.env.scratchWorkspace = os.path.dirname(params[1].valueAsText) Sites = arcpy.MakeFeatureLayer_management(params[2].valueAsText) DEM = params[4].valueAsText zFactor = params[5].value Streams = arcpy.MakeFeatureLayer_management(params[6].valueAsText) #Process Input Polygon lyr = finalPath + "\\" + os.path.basename( params[1].valueAsText) + "_Poly.shp" polyParts = int(arcpy.GetCount_management(poly).getOutput(0)) if polyParts > 1: arcpy.Dissolve_management(poly, lyr) else: arcpy.CopyFeatures_management(poly, lyr) lyrDesc = arcpy.Describe(lyr) lyrFields = lyrDesc.fields lyrExtent = lyrDesc.extent arcpy.env.extent = lyrExtent fieldx = 0 for field in lyrFields: if field.name == "POLY_ACRES": fieldx = 1 if fieldx == 0: arcpy.AddField_management(lyr, "POLY_ACRES", 'DOUBLE', 12, 8) arcpy.CalculateField_management(lyr, "POLY_ACRES", "!shape.area@ACRES!", "PYTHON_9.3", "") Desc = arcpy.Describe(lyr) polyAcres = ([ row[0] for row in arcpy.da.SearchCursor(lyr, ["POLY_ACRES"]) ][0]) arcpy.AddMessage("Polygon acreage = %d" % polyAcres) #Clip Sites siteQuery = params[3].ValueAsText outPoints = outFinal + "_Data_Points.shp" outSites = outRaw + "_Sites" if siteQuery == "Use All Sites": arcpy.MakeFeatureLayer_management(Sites, outSites) else: arcpy.MakeFeatureLayer_management(Sites, outSites, siteQuery) arcpy.SelectLayerByLocation_management(outSites, "INTERSECT", lyr) siteResult = int(arcpy.GetCount_management(outSites).getOutput(0)) arcpy.AddMessage(siteQuery) arcpy.AddMessage("Site Count = " + str(siteResult)) if siteResult < 10: arcpy.AddMessage("There are insufficient site data for analysis") systemExit(0) arcpy.FeatureToPoint_management(outSites, outPoints, "CENTROID") #Add Random field to extract build and test points arcpy.AddField_management(outPoints, "Test_Hold", "Double") with arcpy.da.UpdateCursor(outPoints, "Test_Hold") as cursor: for row in cursor: row[0] = random.random() cursor.updateRow(row) buildPoints = outTest + "_Build_Sites.shp" testPoints = outTest + "_Test_Sites.shp" arcpy.MakeFeatureLayer_management(outPoints, "in_memory\\test", """ "Test_Hold" <= 0.2 """) arcpy.CopyFeatures_management("in_memory\\test", testPoints) arcpy.MakeFeatureLayer_management(outPoints, "in_memory\\build", """ "Test_Hold" > 0.2 """) arcpy.CopyFeatures_management("in_memory\\build", buildPoints) #These are the raw layers of interest outSlope = outRaw + "_slp" outTopoProm = outRaw + "_pro" outHHODist = outRaw + "_dtw" outEleHHO = outRaw + "_eaw" outConfDist = outRaw + "_dtc" outEaConf = outRaw + "_eac" #DEM-based analysis outDEM = outRaw + "_dem" arcpy.Clip_management(DEM, "#", outDEM, lyr, "#", "ClippingGeometry") arcpy.Slope_3d(outDEM, outSlope, "DEGREE", zFactor) outBlk = BlockStatistics(outDEM, NbrCircle(3, "CELL"), "RANGE", "DATA") outBlk.save(outTopoProm) #Stream-based analysis - rubs only if streams are within input polygon outStreams = outFinal + "_str.shp" outVPts = outRaw + "_vpt.shp" vPtsEle = outRaw + "_vpe.shp" vPtsCor = outRaw + "_vpc.shp" outCPts = outRaw + "_cpt.shp" outCPsC = outRaw + "_cpc.shp" outBuff = outRaw + "_buff.shp" outDiss = outRaw + "_diss.shp" outConPts = outRaw + "_con.shp" cPtsEle = outRaw + "_cpe.shp" arcpy.Clip_analysis(Streams, lyr, outStreams) streamCount = arcpy.GetCount_management(outStreams) if not streamCount == 0: arcpy.FeatureVerticesToPoints_management(outStreams, outVPts, "ALL") arcpy.gp.ExtractValuesToPoints_sa(outVPts, outDEM, vPtsEle, "NONE", "VALUE_ONLY") arcpy.MakeFeatureLayer_management(vPtsEle, "in_memory\\vPtsCor", """"RASTERVALU" > 0""") arcpy.CopyFeatures_management("in_memory\\vPtsCor", vPtsCor) arcpy.AddField_management(vPtsCor, "WAT_ELEV", "SHORT") arcpy.CalculateField_management(vPtsCor, "WAT_ELEV", "[RASTERVALU]", "VB", "#") arcpy.gp.EucAllocation_sa(vPtsCor, "in_memory\\outAllo", "#", "#", "10", "WAT_ELEV", outHHODist, "#") arcpy.Minus_3d(outDEM, "in_memory\\outAllo", outEleHHO) deleteList = [outVPts, vPtsEle, vPtsCor] #Confluence-based analysis arcpy.FeatureVerticesToPoints_management(outStreams, "in_memory\\outCPts", "BOTH_ENDS") arcpy.MakeFeatureLayer_management("in_memory\\outCPts", outCPts) arcpy.FeatureToLine_management(lyr, "in_memory\\lyrLine", "#", "ATTRIBUTES") arcpy.SelectLayerByLocation_management(outCPts, "WITHIN_A_DISTANCE", "in_memory\\lyrLine", "100 Meters", "NEW_SELECTION") arcpy.SelectLayerByLocation_management(outCPts, "#", "#", "#", "SWITCH_SELECTION") arcpy.CopyFeatures_management(outCPts, outCPsC) arcpy.Buffer_analysis(outCPsC, outBuff, "10 METERS", "#", "#", "NONE", "#") arcpy.Dissolve_management(outBuff, outDiss, "#", "#", "SINGLE_PART", "#") arcpy.SpatialJoin_analysis(outDiss, outCPsC, "in_memory\\outJoin") arcpy.MakeFeatureLayer_management("in_memory\\outJoin", "in_memory\\joinLayer", """"Join_Count" >= 3""") arcpy.FeatureToPoint_management("in_memory\\joinLayer", outConPts, "CENTROID") arcpy.gp.ExtractValuesToPoints_sa(outConPts, outDEM, cPtsEle, "NONE", "VALUE_ONLY") arcpy.AddField_management(cPtsEle, "CONF_ELEV", "SHORT") arcpy.CalculateField_management(cPtsEle, "CONF_ELEV", "[RASTERVALU]", "VB", "#") arcpy.gp.EucAllocation_sa(cPtsEle, "in_memory\\outConfAllo", "#", "#", "10", "CONF_ELEV", outConfDist, "#") arcpy.Minus_3d(outDEM, "in_memory\\outConfAllo", outEaConf) deleteList = [ outCPts, outCPsC, outBuff, outDiss, outConPts, cPtsEle, outVPts, vPtsEle, vPtsCor ] for delete in deleteList: arcpy.Delete_management(delete) #Extract values to seperate tables and rename fields def extractValues(pointLayer, raster, outPoints, renameField): arcpy.gp.ExtractValuesToPoints_sa(pointLayer, raster, outPoints, "NONE", "ALL") arcpy.AddField_management(outPoints, renameField, "SHORT") arcpy.CalculateField_management(outPoints, renameField, "[RASTERVALU]", "VB", "#") return slopeTable = outRaw + "_slopePts.shp" promTable = outRaw + "_promPts.shp" distTHOtable = outRaw + "_distTHOPts.shp" distAHOtable = outRaw + "_distAHOPts.shp" distTCOtable = outRaw + "_distTCOPts.shp" distACOtable = outRaw + "_distACOPts.shp" extractValues(buildPoints, outSlope, slopeTable, "Slope") extractValues(buildPoints, outTopoProm, promTable, "Relief") if not streamCount == 0: extractValues(buildPoints, outHHODist, distTHOtable, "DTo_Water") extractValues(buildPoints, outEleHHO, distAHOtable, "DAbo_Water") extractValues(buildPoints, outConfDist, distTCOtable, "DTo_Conf") extractValues(buildPoints, outEaConf, distACOtable, "DAbo_Conf") #Get range of values for each layer and populate lists - reject null values def getValues(layer, fieldName): vList = [] with arcpy.da.SearchCursor(layer, [fieldName]) as cursor: for row in cursor: if row[0] != -999 and row[0] != -9999: vList.append(row[0]) return vList slopeList = getValues(slopeTable, "Slope") promList = getValues(promTable, "Relief") if not streamCount == 0: dtwList = getValues(distTHOtable, "DTo_Water") dawList = getValues(distAHOtable, "DAbo_Water") dtcList = getValues(distTCOtable, "DTo_Conf") dacList = getValues(distACOtable, "DAbo_Conf") deleteList = [ slopeTable, promTable, distTHOtable, distAHOtable, distTCOtable, distACOtable ] for item in deleteList: if arcpy.Exists(item): arcpy.Delete_management(item) #Get statistics for range of values def meanstdv(xlist): from math import sqrt n, total, std1 = len(xlist), 0, 0 for x in xlist: total = total + x mean = total / float(n) for x in xlist: std1 = std1 + (x - mean)**2 std = sqrt(std1 / float(n - 1)) return mean, std slopeStats = meanstdv(slopeList) promStats = meanstdv(promList) if not streamCount == 0: dtwStats = meanstdv(dtwList) dawStats = meanstdv(dawList) dtcStats = meanstdv(dtcList) dacStats = meanstdv(dacList) #Remap rasters according to 1-sigma range def remapRaster(inRaster, outRaster, recField, statList): R1 = statList[0] - statList[1] R2 = statList[0] + statList[1] rasterMin = arcpy.GetRasterProperties_management( inRaster, "MINIMUM") rasterMax = arcpy.GetRasterProperties_management( inRaster, "MAXIMUM") if R1 < rasterMin: R1 = rasterMin if R2 > rasterMax: R2 = rasterMax remap = str(rasterMin) + " " + str(R1) + " 0;" + str( R1) + " " + str(R2) + " 1;" + str(R2) + " " + str( rasterMax) + " 0" arcpy.Reclassify_3d(inRaster, recField, remap, outRaster, "NODATA") return outRaster targetSlope = outTest + "_slp" targetTopoProm = outTest + "_pro" targetHHODist = outTest + "_dtw" targetConfDist = outTest + "_dtc" targetEleHHO = outTest + "_eaw" targetEaConf = outTest + "_eac" remapRaster(outSlope, targetSlope, "Value", slopeStats) remapRaster(outTopoProm, targetTopoProm, "Value", promStats) if not streamCount == 0: remapRaster(outHHODist, targetHHODist, "Value", dtwStats) remapRaster(outEleHHO, targetEleHHO, "Value", dawStats) remapRaster(outConfDist, targetConfDist, "Value", dtcStats) remapRaster(outEaConf, targetEaConf, "Value", dacStats) #Test against test points def AreaAndAccuracy(inRaster, inPoly): rasterPoly = outRaw + "_poly.shp" rasterPolyarea = 0 lyrPolyarea = 0 testCount = int(arcpy.GetCount_management(testPoints).getOutput(0)) arcpy.RasterToPolygon_conversion(inRaster, rasterPoly, "SIMPLIFY", "Value") with arcpy.da.SearchCursor(rasterPoly, ("GRIDCODE", "SHAPE@AREA")) as cursor: for row in cursor: if row[0] == 1: rasterPolyarea += row[1] with arcpy.da.SearchCursor(inPoly, "SHAPE@AREA") as cursor: for row in cursor: lyrPolyarea += row[0] targetAcres = rasterPolyarea / lyrPolyarea arcpy.MakeFeatureLayer_management(rasterPoly, "in_memory\\rasterPoly", """ "GRIDCODE" = 1 """) arcpy.MakeFeatureLayer_management(testPoints, "in_memory\\testPoints") arcpy.SelectLayerByLocation_management("in_memory\\testPoints", "WITHIN", "in_memory\\rasterPoly") selectCount = int( arcpy.GetCount_management("in_memory\\testPoints").getOutput( 0)) Accuracy = float(selectCount) / float(testCount) indexValue = float(Accuracy) / float(targetAcres) arcpy.AddMessage( os.path.basename(inRaster) + ": Accuracy = " + (str(Accuracy)[:5]) + ", Target Area Proportion = " + (str(targetAcres)[:5]) + ", Index = " + (str(indexValue)[:5])) arcpy.Delete_management(rasterPoly) return targetAcres, Accuracy, indexValue #Evaluate accuracy and target area proprtion - generate accuracy/area index - eliminate where index < 1 assessList = [ targetSlope, targetTopoProm, targetHHODist, targetEleHHO, targetConfDist, targetEaConf ] sumDict = {} for item in assessList: if arcpy.Exists(item): testX = AreaAndAccuracy(item, lyr) if testX[2] >= 1: sumDict[item] = testX nameList = sumDict.keys() #Weighted overlay outWeight = outFinal + "wgt" weightList = [] for item in sumDict: weightList.append(str(item) + " Value " + str(sumDict[item][2])) weightString = ";".join(weightList) arcpy.gp.WeightedSum_sa(weightString, outWeight) deleteInMemory() return
arcpy.RemoveJoin_management(PointsFL) #Set parcel elevation to 0 this will be replaced by SPOT value calculated above outIsNull = IsNull(outExtractByMask) #Identify NoData Areas outIsNull.save(IntermediateFiles+"\\isnull_"+str(value)) outCon = Con(outIsNull,Elevation,0,"") #Use Con tool to change building footprint to elevation of 0 while leaving all other building footprints as is outCon.save(IntermediateFiles+"\\con_"+str(value)) #Final raster to be used in viewshed analysis #buffer selected viewpoint arcpy.SetProgressorLabel("Buffering point "+str(value)) outBuffer = IntermediateFiles+"\\buffer_"+str(value)+".shp" arcpy.Buffer_analysis(PointsFL,outBuffer,"1 mile") #Convert buffer polygon to line BufferLine = IntermediateFiles+"\\BufferLine_"+str(value)+".shp" arcpy.FeatureToLine_management(outBuffer,BufferLine) #Clip buffer to Ocean arcpy.SetProgressorLabel("Clipping point "+str(value)+" buffer to ocean") BufferClip = IntermediateFiles+"\\buffer_clipped_"+str(value).split(".")[0]+".shp" arcpy.Clip_analysis(outBuffer, Ocean, BufferClip) if FlrCnt ==1: #parcel floor count = 1 arcpy.AddMessage("\nParcel "+str(value)+" has 1 story to process. Calculating viewshed now...") print "\nParcel ",str(value)," has 1 story to process. Calculating viewshed now..." DegViewshed(1,10) #Calculate the viewshed with an observer height of 10 feet then move to point arcpy.AddMessage("First floor viewshed for parcel "+str(value)+" has been completed...") print "First floor viewshed for parcel ",str(value)," has been completed..." arcpy.AddMessage(str(count)+" of "+str(RangeCount)+" parcles has been completed.\n")
output3 = "AUXILIAR4\\" + str(edificio) + "_21.shp" if row2.FID == 0: arcpy.Copy_management(output, output2) else: arcpy.Merge_management([output2, output], output3) arcpy.Copy_management(output3, output2) shutil.rmtree(auxiliar4) auxiliar2 = root + "\\AUXILIAR2" os.mkdir(auxiliar2) auxiliar3 = root + "\\AUXILIAR3" os.mkdir(auxiliar3) #SE RECALCULAN LAS CAPAS DE ADYACENCIA A PARTIR DE LAS MODIFICACIONES DEL USUARIO arcpy.FeatureToLine_management("PARCELA.shp", "AUXILIAR2\\PARCELA_LINE.shp") arcpy.Intersect_analysis( ["MEDIANEIRAS_LINDEIROS.shp", "AUXILIAR2\\PARCELA_LINE.shp"], "LINDEIROS.shp") arcpy.FeatureToLine_management("ALTAS.shp", "AUXILIAR2\\ALTAS_LINE.shp") arcpy.Erase_analysis("AUXILIAR2\\ALTAS_LINE.shp", "MEDIANEIRAS_LINDEIROS.shp", "FACHADAS.shp") arcpy.Erase_analysis("AUXILIAR2\\ALTAS_LINE.shp", "FACHADAS.shp", "MEDIANERAS.shp") #Bucle FOR con el objetivo de exportar cada edificio a un archivo de capa separado arcpy.AddField_management("ALTAS.dbf", "AREA", "FLOAT") arcpy.CalculateField_management("ALTAS.dbf", "AREA", "!SHAPE.area@SQUAREMETERS!", "PYTHON_9.3") rows = arcpy.SearchCursor("ALTAS.dbf") for row in rows:
arcpy.SelectLayerByLocation_management("temp_lines_lyr", 'intersect', study_area) lines_study_area = arcpy.FeatureClassToFeatureClass_conversion(lines_copy_lyr, temp_dir, 'temp_lines.shp') # erase print("Adding canyon roads...") canyon_roads = r'.\Inputs\Canyon_Roads.shp' lines_erased = os.path.join(temp_dir, 'lines_erased.shp') arcpy.Erase_analysis(lines_study_area, canyon_roads, lines_erased) # merge arcpy.Append_management([canyon_roads], lines_erased, schema_type='NO_TEST') # split lines at vertices #lines_copy = arcpy.FeatureToLine_management(lines_copy_lyr, os.path.join(temp_dir, 'temp_lines2.shp')) lines_copy = arcpy.FeatureToLine_management(lines_erased, os.path.join(temp_dir, 'temp_lines2.shp')) lines_copy_lyr = arcpy.MakeFeatureLayer_management(lines_copy,"temp_lines_lyr2") # Add unique ID unique_id_field = 'id' arcpy.AddField_management(lines_copy, field_name=unique_id_field, field_type='LONG') arcpy.CalculateField_management(lines_copy, unique_id_field, '"!FID!"') #===================================== # Create Nodes #=====================================
arcpy.Merge_management(infeatures, merge) print "merge done" # Let us check that the splitting above did not alter the quality of our lines and correct them arcpy.RepairGeometry_management(merge, "DELETE_NULL") print "geometry repaired" # Replace a layer/table view name with a path to a dataset (which can be a layer file) or create the layer/table view within the script # The following inputs are layers or table views: "centr_rail_Merge1" #arcpy.ExtendLine_edit(merge, "", "EXTENSION") #print "extend line done" # Feature to line allows us to split the different line shapefiles in segments for each line crossing [improvement from DH] arcpy.FeatureToLine_management(merge, feat_to_line, "", "ATTRIBUTES") print "feature to line done" database_creation = timeit.timeit() print database_creation - start # Let us check that the splitting above did not alter the quality of our lines and correct them arcpy.RepairGeometry_management(feat_to_line, "DELETE_NULL") print "geometry repaired" arcpy.AddField_management(feat_to_line, "Length", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") print "generate Length field centroids done" arcpy.CalculateField_management(feat_to_line, "Length", "!shape.geodesicLength@KILOMETERS!", "PYTHON_9.3", "") print "calculate length in kilometers"
def procesar_calidad(cant_zonas=0, data=[], campos=['UBIGEO', 'ZONA']): if len(data) == 0: data = conex.obtener_lista_zonas_calidad(cant_zonas)[:] importar_tablas_trabajo(data, campos) where = expresiones_consulta_arcpy.Expresion(data, campos) arcpy.AddField_management(tb_viviendas_ordenadas, 'IDMANZANA', 'TEXT') arcpy.CalculateField_management(tb_viviendas_ordenadas, 'IDMANZANA', '!UBIGEO!+!ZONA!+!MANZANA!', 'PYTHON_9.3') # print "Importar" list_zonas = [(x[0], x[1]) for x in arcpy.da.SearchCursor(tb_zonas, ["UBIGEO", "ZONA"])] ######################################################CALIDAD PUERTAS MULTIFAMILIAR AFUERA DEL FRENTE DE MANZANA############################################################ arcpy.AddField_management(tb_viviendas_ordenadas, 'IDMANZANA', 'TEXT') arcpy.CalculateField_management(tb_viviendas_ordenadas, 'IDMANZANA', '!UBIGEO!+!ZONA!+!MANZANA!', 'PYTHON_9.3') manzanas_mfl = arcpy.MakeFeatureLayer_management(tb_manzanas, "manzanas_mfl", where) viviendas_mfl = arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "viviendas_mfl", where) frentes_mfl = arcpy.MakeFeatureLayer_management(tb_frentes, "frentes_mfl", where) mzs_line = arcpy.FeatureToLine_management(manzanas_mfl, "in_memory/mzs_line") puertas_multifamiliar = arcpy.MakeFeatureLayer_management( tb_viviendas_ordenadas, "puertas_multifamiliar", "p29=6") puertas_multifamiliar_afuera = arcpy.SelectLayerByLocation_management( puertas_multifamiliar, "INTERSECT", mzs_line, '', "NEW_SELECTION", "INVERT") viviendas_selecc_frentes_mfl = arcpy.SelectLayerByLocation_management( viviendas_mfl, "INTERSECT", mzs_line) viviendas_selecc_frentes = arcpy.CopyFeatures_management( viviendas_selecc_frentes_mfl, "in_memory/viv_selecc_frentes") arcpy.CopyFeatures_management(puertas_multifamiliar_afuera, error_1) ########################################LISTA ZONAS CON ERROR PUERTA MULTIFAMILIAR############################### list_1 = list( set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_1, ["UBIGEO", "ZONA"])])) zonas_error_puertas_multi = list( set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_1, ["UBIGEO", "ZONA"])])) # print zonas_error_puertas_multi #####################################################CALIDAD EXISTENCIA DE EJES VIALES POR ZONA####################################################################### # tb_ejes_viales ejes_viales_mfl = arcpy.MakeFeatureLayer_management( tb_ejes_viales, "ejes_viales_mfl") manzanas_sin_vias = arcpy.SelectLayerByLocation_management( manzanas_mfl, "INTERSECT", ejes_viales_mfl, "20 METERS", "NEW_SELECTION", "INVERT") arcpy.CopyFeatures_management(manzanas_sin_vias, error_2) ######################################LISTA DE ZONAS SIN EJES VIALES############################################# #list_2 = [] #for x in arcpy.da.SearchCursor(tb_zonas, ["UBIGEO", "ZONA"]): # where = " UBIGEO='{}' AND ZONA='{}'".format(x[0], x[1]) # manzanas_mfl = arcpy.MakeFeatureLayer_management(tb_manzanas, "manzanas_mfl", where) # manzanas_sin_vias_mfl = arcpy.MakeFeatureLayer_management(error_2, "manzanas_sin_vias_mfl", where) # a = int(arcpy.GetCount_management(manzanas_mfl).getOutput(0)) # b = int(arcpy.GetCount_management(manzanas_sin_vias_mfl).getOutput(0)) # if a != 0: # porcentaje = b / float(a) * 100 # # else: # porcentaje = 100 # # if porcentaje > 10: # list_2.append((x[0], x[1])) ##################################################CALIDAD MANZANAS INTERSECTADO CON VIAS######################################## line_mzs = arcpy.FeatureToLine_management(tb_manzanas_ordenadas, "in_memory/line_mzs") buffer_line = arcpy.Buffer_analysis(line_mzs, "in_memory/buffer_line", "0.50 meters") mzs_cortadas = arcpy.Erase_analysis(tb_manzanas_ordenadas, buffer_line, "in_memory/erase_mzs") #manzanas_ordenadas_mfl = arcpy.MakeFeatureLayer_management(tb_manzanas_ordenadas, "manzanas_ordenadas_mfl") manzanas_cortadas_mfl = arcpy.MakeFeatureLayer_management( mzs_cortadas, "mzs_cortadas_mfl") #vias_dentro_manzana = arcpy.SelectLayerByLocation_management(manzanas_ordenadas_mfl, "INTERSECT", tb_ejes_viales,'', "NEW_SELECTION") vias_dentro_manzana = arcpy.SelectLayerByLocation_management( manzanas_cortadas_mfl, "INTERSECT", tb_ejes_viales, '', "NEW_SELECTION") arcpy.CopyFeatures_management(vias_dentro_manzana, error_3) #########################################LISTA DE ZONAS CON VIAS DENTRO DE MANZANAS################################### list_3 = [] if (int(arcpy.GetCount_management(error_3).getOutput(0)) > 0): list_3 = list( set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_3, ["UBIGEO", "ZONA"])])) #################Calidad Viviendas afuera de la manzana################################################# viviendas_mfl = arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "viviendas_mfl", where) viviendas_afuera_manzana = arcpy.SelectLayerByLocation_management( viviendas_mfl, "INTERSECT", tb_manzanas_ordenadas, '0.2 meters', "NEW_SELECTION", "INVERT") arcpy.CopyFeatures_management(viviendas_afuera_manzana, error_5) ##########################################LISTA DE ZONAS CON VIVIENDAS FUERA DE MANZANA################# list_4 = [] if (int(arcpy.GetCount_management(error_5).getOutput(0)) > 0): list_4 = list( set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_5, ["UBIGEO", "ZONA"])])) #################################################CALIDAD PUNTOS DE INICIO####################################################################### lineas_viviendas = arcpy.PointsToLine_management( viviendas_selecc_frentes, 'in_memory/lineas_viviendas', "IDMANZANA", "ID_REG_OR") puntos_extremos = arcpy.FeatureVerticesToPoints_management( lineas_viviendas, 'in_memory/puntos_extremos', "BOTH_ENDS") puntos_extremos_buffer = arcpy.Buffer_analysis( puntos_extremos, 'in_memory/puntos_extremos_buffer', "0.2 meters") erase_lineas = arcpy.Erase_analysis(mzs_line, puntos_extremos_buffer, 'in_memory/erase_lineas') split = arcpy.SplitLine_management(erase_lineas, "in_memory/split") dissolve = arcpy.Dissolve_management(split, "in_memory/dissolve", "UBIGEO;CODCCPP;ZONA;MANZANA", "", "MULTI_PART", "DISSOLVE_LINES") dissolve_multi = arcpy.MultipartToSinglepart_management( dissolve, "in_memory/dissolve_multi") dissolve_mfl = arcpy.MakeFeatureLayer_management(dissolve_multi, 'dissolve_mfl') puntos_inicio_mfl = arcpy.MakeFeatureLayer_management( tb_puntos_inicio, 'puntos_inicio_mfl') segmentos_selec = arcpy.SelectLayerByLocation_management( dissolve_mfl, "INTERSECT", tb_viviendas_ordenadas, '', "NEW_SELECTION", "INVERT") tb_segmentos_selec = arcpy.CopyFeatures_management( segmentos_selec, "{}/tb_segmentos_selec.shp".format(path_ini)) puntos_inici_selec = arcpy.SelectLayerByLocation_management( puntos_inicio_mfl, "INTERSECT", tb_segmentos_selec, '', "NEW_SELECTION", "INVERT") arcpy.CopyFeatures_management(puntos_inici_selec, error_4) ################################################LISTA DE ZONAS CON PROBLEMAS DE PUNTO DE INICIO################################################## list_5 = [] if (int(arcpy.GetCount_management(error_4).getOutput(0)) > 0): list_5 = list( set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_4, ["UBIGEO", "ZONA"])])) ############################ Cantidad de frentes############################################################ ''' resumen_frentes_viv=arcpy.Statistics_analysis(tb_viviendas_ordenadas,'in_memory/resumen_frentes_viv',[["FRENTE_ORD","MAX"]],["UBIGEO","ZONA","MANZANA"]) arcpy.AddField_management(resumen_frentes_viv,"ID_MANZANA","text") with arcpy.da.UpdateCursor(resumen_frentes_viv, ["UBIGEO","ZONA","MANZANA","ID_MANZANA"]) as cursor: for x in cursor: x[4]=u'{}{}{}'.format(x[0],x[1],x[2]) cursor.updateRow(x) #arcpy.CalculateField_management(resumen_frentes_viv,"ID_MANZANA","!UBIGEO!+!ZONA!+!MANZANA!","PYTHON_9.3") resumen_frentes = arcpy.Statistics_analysis(tb_frentes_dissolve, 'in_memory/resumen_frentes',[["FRENTE_ORD", "MAX"],["FRENTE_ORD", "COUNT"]], ["UBIGEO", "ZONA", "MANZANA"]) arcpy.AddField_management(resumen_frentes, "ID_MANZANA", "text") with arcpy.da.UpdateCursor(resumen_frentes, ["UBIGEO","ZONA","MANZANA","ID_MANZANA"]) as cursor: for x in cursor: x[4]=u'{}{}{}'.format(x[0],x[1],x[2]) cursor.updateRow(x) arcpy.CalculateField_management(resumen_frentes, "ID_MANZANA", "!UBIGEO!+!ZONA!+!MANZANA!", "PYTHON_9.3") arcpy.JoinField_management(resumen_frentes,"ID_MANZANA",resumen_frentes_viv,"ID_MANZANA",["MAX_FRENTE_ORD"]) mzs_dif_cant_frent=arcpy.TableSelect_analysis(resumen_frentes, error_6, " (MAX_FRENTE_ORD<>MAX_FRENTE_ORD_1)") arcpy.AddField_management(error_6, "CANT_FR_V", "SHORT") arcpy.CalculateField_management(error_6, "CANT_FR_V", "!MAX_FRENTE_ORD!") arcpy.AddField_management(error_6, "CANT_FR_F", "text") arcpy.CalculateField_management(error_6, "CANT_FR_F", "!MAX_FRENTE_ORD_1!") arcpy.DeleteField_management(error_6,["MAX_FRENTE_ORD","MAX_FRENTE_ORD_1"]) list_6=[] if (int(arcpy.GetCount_management(error_6).getOutput(0)) > 0): list_6 = list(set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_6, ["UBIGEO", "ZONA"])])) #mzs_dif_cant_frent_1 = arcpy.TableSelect_analysis(resumen_frentes, error_7_cant_frentes_dif, " CapVivNFr<>COUNT_FRENTE_ORD") #list_7 = [] #if (int(arcpy.GetCount_management(error_7_cant_frentes_dif).getOutput(0)) > 0): # list_7 = list(set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_7_cant_frentes_dif, ["UBIGEO", "ZONA"])])) #arcpy.SelectLayerByLocation_management ''' #####################################################ERROR DE FRENTE DE VIVIENDAS######################################################### resultado = arcpy.Intersect_analysis([tb_viviendas_ordenadas, tb_frentes], 'in_memory/results') arcpy.Select_analysis(resultado, error_7, 'FRENTE_ORD<>FRENTE_ORD_1') fields = arcpy.ListFields(error_7) list_campos_validos = [ 'FID', 'Shape', 'UBIGEO', 'CODCCPP', 'ZONA', 'MANZANA', 'ID_REG_OR', 'FRENTE_ORD' ] delete_fields = [] for el in fields: if el.name not in list_campos_validos: delete_fields.append(el.name) arcpy.DeleteField_management(error_7, delete_fields) #####################################################ERROR FRENTES DE MANZANAS NO COINCIDEN CON LA MANZANA EN FORMA################################# temp_frentes = arcpy.SelectLayerByLocation_management( frentes_mfl, "WITHIN", mzs_line, '', "NEW_SELECTION", "INVERT") arcpy.CopyFeatures_management(temp_frentes, error_8) list_8 = [] if (int(arcpy.GetCount_management(error_8).getOutput(0)) > 0): list_8 = list( set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_8, ["UBIGEO", "ZONA"])])) ####################################################ERROR NUMERACION DE VIVIENDAS############################################################# lineas_viviendas = arcpy.PointsToLine_management( viviendas_selecc_frentes, 'in_memory/lineas_viviendas', "IDMANZANA", "ID_REG_OR") viviendas_selecc_frentes_buffer = arcpy.Buffer_analysis( viviendas_selecc_frentes, "in_memory/puntos_extremos_buffer", "0.2 meters") erase_lineas = arcpy.Erase_analysis(lineas_viviendas, viviendas_selecc_frentes_buffer, 'in_memory/erase_lineas') split = arcpy.SplitLine_management(erase_lineas, path_ini + "/split.shp") mz_line_erase = arcpy.Erase_analysis(mzs_line, viviendas_selecc_frentes_buffer, "in_memory\mz_line_erase") mz_line_erase_multi = arcpy.MultipartToSinglepart_management( mz_line_erase, 'in_memory\m_l_e_m') result = arcpy.Statistics_analysis(mz_line_erase_multi, 'in_memory/result', [['FID', "MAX"]], ["Shape"]) maxids = [[ x[0] ] for x in arcpy.da.SearchCursor(result, ["MAX_FID"], 'FREQUENCY>1')] if len(maxids) == 0: where_ids = expresiones_consulta_arcpy.Expresion_2([["-1"]], [["FID", "SHORT"]]) else: where_ids = expresiones_consulta_arcpy.Expresion_2( maxids, [["FID", "SHORT"]]) arcpy.Select_analysis(mz_line_erase_multi, error_9, where_ids) ''' intersect=arcpy.Intersect_analysis([mz_line_erase_multi, split], path_ini+"/intersect.shp", "ALL", "", "") list_id_buffer_mzs_line_erase_multi=list(set( [x[0] for x in arcpy.da.SearchCursor(intersect,["FID_m_l_e_"])])) list_intersect= [x[0] for x in arcpy.da.SearchCursor(intersect,["FID_m_l_e_"])] errores_numeracion=[] print list_id_buffer_mzs_line_erase_multi print list_intersect for x in list_id_buffer_mzs_line_erase_multi: cont = 0 for y in list_intersect: if (x==y): cont=cont+1 #print cont if (cont>1): errores_numeracion.append([x]) print errores_numeracion where_exp=UBIGEO.Expresion_2(errores_numeracion,[["FID","SHORT"]]) b_m_l_e_m_selecc = arcpy.Select_analysis(mz_line_erase_multi, error_9, where_exp) list_9=[] if (int(arcpy.GetCount_management(error_9).getOutput(0)) > 0): list_9 = list(set([(x[0], x[1]) for x in arcpy.da.SearchCursor(error_9, ["UBIGEO", "ZONA"])])) #dissolve = arcpy.Dissolve_management(split, "in_memory/dissolve", "UBIGEO;CODCCPP;ZONA;MANZANA", "","MULTI_PART","DISSOLVE_LINES") #dissolve_multi=arcpy.MultipartToSinglepart_management(dissolve, "in_memory/dissolve_multi") #arcpy.SelectLayerByLocation_management (dissolve_multi, "INTERSECT",dissolve_multi) #arcpy.MultipartToSinglepart_management("intersect", "in_memory/intersect2") ''' #################################################VIVIENDAS Y VIAS##################################################### # list_zonas_error=list(set(list_1+list_2+list_3+list_4+list_5+list_6+list_8+list_9)) # print list_zonas_error #nombre_ejes_viales() ################################puertas hijos multifamiliar en el frente########################## puertas_hijos_multifamilar = arcpy.MakeFeatureLayer_management( tb_viviendas_ordenadas, "puertas_multifamiliar", "(p29=1 or p29=3) and ID_REG_PAD<>0 ") error_11_mfl = arcpy.SelectLayerByLocation_management( puertas_hijos_multifamilar, "INTERSECT", mzs_line, '', "NEW_SELECTION") arcpy.CopyFeatures_management(error_11_mfl, error_11) # puertas_hijos_multifamilar=arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "puertas_multifamiliar", "(p29=1 or p29=3) and ID_REG_PAD<>0 ") # error_11_mfl=arcpy.SelectLayerByLocation_management(puertas_hijos_multifamilar, "INTERSECT",mzs_line ,'' , "NEW_SELECTION") # arcpy.CopyFeatures_management(error_11_mfl, error_11) ###############################################ERROR HIJOS SIN PADRES######################################################################### ''' puertas_hijos_multifamilar = arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "puertas_multifamiliar", "(p29=1 or p29=3) and (ID_REG_PAD<>0)" ) list_puertas_hijos_multifamilar=[[x[0],x[1],x[2],x[3],x[4]] for x in arcpy.da.SearchCursor(puertas_hijos_multifamilar,["UBIGEO","ZONA","MANZANA","ID_REG_OR","ID_REG_PAD"])] list_puertas_multifamiliar=[ '{}{}{}{}'.format(x[0],x[1],x[2],x[3]) for x in arcpy.da.SearchCursor(puertas_multifamiliar,["UBIGEO","ZONA","MANZANA","ID_REG"])] where_error_12="" i=0 for el in list_puertas_hijos_multifamilar: i=i+1 id_padre='{}{}{}{}'.format(el[0],el[1],el[2],el[4]) if id_padre not in list_puertas_multifamiliar: if i==1: where_error_12=" (UBIGEO='{}' AND ZONA='{}' AND MANZANA='{}' AND ID_REG_OR={})".format(el[0],el[1],el[2],el[3]) else: where_error_12 = "{} OR (UBIGEO='{}' AND ZONA='{}' AND MANZANA='{}' AND ID_REG_OR={})".format(where_error_12,el[0], el[1], el[2], el[3]) error_12_mfl=arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "error_12",where_error_12 ) arcpy.CopyFeatures_management(error_12_mfl, error_12) #############################ERROR PUERTAS MULTIFAMILIAR CON MAS DE 2 GEOMETRIAS######################################### set_puertas_multi=set(list_puertas_multifamiliar) where_error_13="" j=0 for el in set_puertas_multi: i=0 if el in list_puertas_multifamiliar: i=i+1 if i>1: j=j+1 if (j==1): where_error_13 = " (UBIGEO='{}' AND ZONA='{}' AND MANZANA='{}' AND ID_REG_OR={})".format(el[0], el[1],el[2], el[3]) else: where_error_13 = "{} OR (UBIGEO='{}' AND ZONA='{}' AND MANZANA='{}' AND ID_REG_OR={})".format(where_error_13,el[0], el[1], el[2], el[3]) error_13_mfl = arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "error_13", where_error_13) arcpy.CopyFeatures_management(error_13_mfl, error_13) ''' ################################Insercion de data########################################### arcpy.env.workspace = "Database Connections/PruebaSegmentacion.sde" arcpy.env.outputCoordinateSystem = arcpy.SpatialReference(4326) if arcpy.Exists("GEODATABASE.sde") == False: arcpy.CreateDatabaseConnection_management( "Database Connections", "GEODATABASE.sde", "SQL_SERVER", ip_server, "DATABASE_AUTH", "sde", "$deDEs4Rr0lLo", "#", "GEODB_CPV_SEGM", "#", "#", "#", "#") arcpy.env.workspace = "Database Connections/GEODATABASE.sde" path_conexion2 = "Database Connections/GEODATABASE.sde" path_calidad = path_conexion2 + "/GEODB_CPV_SEGM.SDE.CALIDAD_URBANO" calidad_error_1_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_1_INPUT_PUERTA_MULTIFAMILIAR_DENTRO_MZ' calidad_error_2_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_2_INPUT_MANZANAS_SIN_VIAS' calidad_error_3_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_3_INPUT_MANZANAS_VIAS_DENTRO' calidad_error_4_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_4_INPUT_PUNTOS_INICIO' calidad_error_5_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_5_INPUT_VIVIENDAS_AFUERA_MZ' calidad_error_7_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_7_INPUT_VIVIENDAS_ERROR_FRENTE' calidad_error_8_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_8_INPUT_FRENTES_MANZANAS_FORMA' calidad_error_9_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_9_INPUT_ENUMERACION_VIV_POR_FRENTE' calidad_error_10_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_10_INPUT_VIV_ERROR_NOMBRE_VIA' calidad_error_11_input = path_calidad + '/GEODB_CPV_SEGM.SDE.ERROR_11_INPUT_PUERTAS_HIJOS_MULTI_EN_FRENTE_MZ' #error_7 = path_calidad + "/error_7_viviendas_error_frente.shp" list_errores = [ [error_1, calidad_error_1_input, 1], [error_2, calidad_error_2_input, 1], [error_3, calidad_error_3_input, 1], [error_4, calidad_error_4_input, 1], [error_5, calidad_error_5_input, 1], [error_8, calidad_error_8_input, 1], [error_9, calidad_error_9_input, 1], # [error_10, calidad_error_10_input, 1], [error_11, calidad_error_11_input, 1], [error_7, calidad_error_7_input, 1], ] conn = conex.Conexion2() cursor = conn.cursor() for el in data: ubigeo = el[0] zona = el[1] sql_query = """ DELETE GEODB_CPV_SEGM.SDE.ERROR_1_INPUT_PUERTA_MULTIFAMILIAR_DENTRO_MZ where ubigeo='{ubigeo}' and zona='{zona}' DELETE GEODB_CPV_SEGM.SDE.ERROR_2_INPUT_MANZANAS_SIN_VIAS where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_3_INPUT_MANZANAS_VIAS_DENTRO where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_4_INPUT_PUNTOS_INICIO where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_5_INPUT_VIVIENDAS_AFUERA_MZ where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_7_INPUT_VIVIENDAS_ERROR_FRENTE where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_8_INPUT_FRENTES_MANZANAS_FORMA where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_9_INPUT_ENUMERACION_VIV_POR_FRENTE where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_10_INPUT_VIV_ERROR_NOMBRE_VIA where ubigeo='{ubigeo}' and zona='{zona}' delete GEODB_CPV_SEGM.SDE.ERROR_11_INPUT_PUERTAS_HIJOS_MULTI_EN_FRENTE_MZ where ubigeo='{ubigeo}' and zona='{zona}' """.format(ubigeo=ubigeo, zona=zona) cursor.execute(sql_query) conn.commit() conn.close() i = 0 for el in list_errores: i = i + 1 print el[0] if (int(el[2]) > 1): a = arcpy.MakeTableView_management( el[0], "a{}".format(i), ) else: a = arcpy.MakeFeatureLayer_management(el[0], "a{}".format(i)) arcpy.Append_management(a, el[1], "NO_TEST") #for el in list_errores: # i = i + 1 # # print where # # if el[2] == 1: # a = arcpy.arcpy.MakeFeatureLayer_management(el[1], "a{}".format(i), where) # else: # a = arcpy.MakeTableView_management(el[1], "a{}".format(i), where) # # if (int(arcpy.GetCount_management(a).getOutput(0)) > 0): # arcpy.DeleteRows_management(a) # # print 'borro' # if el[2] == 1: # b = arcpy.arcpy.MakeFeatureLayer_management(el[0], "b{}".format(i), where) # else: # b = arcpy.MakeTableView_management(el[0], "b{}".format(i), where) # # if (int(arcpy.GetCount_management(b).getOutput(0)) > 0): # arcpy.Append_management(b, el[1], "NO_TEST") # print 'inserto' for el in data: conex.actualizar_errores_input_adicionales(ubigeo=el[0], zona=el[1])
def nombre_ejes_viales(): arcpy.AddField_management(tb_viviendas_ordenadas, 'ID_FRENTE', 'TEXT') arcpy.AddField_management(tb_viviendas_ordenadas, 'NOM_CAT_AL', 'TEXT') arcpy.AddField_management(tb_viviendas_ordenadas, 'NOM_VIA_AL', 'TEXT') arcpy.AddField_management(tb_viviendas_ordenadas, 'ERROR_VIA', 'SHORT') with arcpy.da.UpdateCursor( tb_viviendas_ordenadas, ["UBIGEO", "ZONA", "MANZANA", "FRENTE_ORD", "ID_FRENTE"]) as cursor: for x in cursor: x[4] = u'{}{}{}{}'.format(x[0], x[1], x[2], x[3]) cursor.updateRow(x) #arcpy.CalculateField_management(tb_viviendas_ordenadas,'ID_FRENTE','!UBIGEO!+!ZONA!+!MANZANA!+str(!FRENTE_ORD!)','PYTHON_9.3') viviendas_mfl = arcpy.MakeFeatureLayer_management(tb_viviendas_ordenadas, "viviendas_mfl") mzs_line = arcpy.FeatureToLine_management(tb_manzanas_ordenadas, "in_memory/mzs_line") viviendas_selecc_frentes_mfl = arcpy.SelectLayerByLocation_management( viviendas_mfl, "INTERSECT", mzs_line) viviendas_selecc_frentes = arcpy.CopyFeatures_management( viviendas_selecc_frentes_mfl, "in_memory/viv_selecc_frentes") ejes_viales_buffer = arcpy.Buffer_analysis( tb_ejes_viales, "in_memory/ejes_viales_buffer", "60 meters", "", "", "LIST", [ "CAT_VIA", "NOMBRE_CAT", "NOMBRE_VIA", "NOMBRE_ALT", "CAT_NOM", "UBIGEO" ]) intersect_viv_vias = arcpy.Intersect_analysis( [viviendas_selecc_frentes, ejes_viales_buffer], "in_memory/intersect_viv_vias") list_id_frentes_validos = list( set([ u"{}{}{}{}".format(x[0], x[1], x[2], x[3]) for x in arcpy.da.SearchCursor( intersect_viv_vias, ["UBIGEO", "ZONA", "MANZANA", "FRENTE_ORD"], "P20=NOMBRE_CAT AND NOMBRE_VIA=P21") ])) print list_id_frentes_validos where_expression_list = "" with arcpy.da.UpdateCursor(tb_viviendas_ordenadas, ["ID_FRENTE", "ERROR_VIA"]) as cursor: for x in cursor: if x[0] not in list_id_frentes_validos: x[1] = 1 cursor.updateRow(x) viviendas_no_enlazadas = arcpy.Select_analysis(tb_viviendas_ordenadas, error_10, "ERROR_VIA=1") viviendas_no_enlazadas_mfl = arcpy.MakeFeatureLayer_management( viviendas_no_enlazadas) viviendas_no_enlazadas_select = arcpy.SelectLayerByLocation_management( viviendas_no_enlazadas_mfl, "INTERSECT", mzs_line, '5 METERS', "NEW_SELECTION") lineas_viv_no_en = arcpy.PointsToLine_management( viviendas_no_enlazadas_select, path_calidad + '/lineas_viv_no_en.shp', 'p21', 'ID_FRENTE') ejes_viales_buffer = arcpy.Buffer_analysis( tb_ejes_viales, "in_memory/ejes_viales_buffer", "40 meters", "", "", "LIST", [ "CAT_VIA", "NOMBRE_CAT", "NOMBRE_VIA", "NOMBRE_ALT", "CAT_NOM", "UBIGEO" ]) where_eje = "NOMBRE_VIA<>'{}'".format("SN") ejes_viales_buffer_select = arcpy.Select_analysis( ejes_viales_buffer, 'in_memory/ejes_viales_buffer_select', where_eje) ejes_viales_buffer_select_mfl = arcpy.MakeFeatureLayer_management( ejes_viales_buffer_select) temp = arcpy.SpatialJoin_analysis(ejes_viales_buffer_select_mfl, lineas_viv_no_en, path_calidad + '/temp.shp', 'JOIN_ONE_TO_MANY', '', '', 'CONTAINS') arcpy.AddField_management(temp, 'AREA', 'DOUBLE') exp = "!SHAPE.AREA@METERS!" arcpy.CalculateField_management(temp, 'AREA', exp, 'PYTHON_9.3') temp_sort = arcpy.Sort_management( temp, 'in_memory/temp_sort', [["JOIN_FID", "ASCENDING"], ["AREA", "ASCENDING"]]) temp_sort_select = arcpy.Select_analysis( temp_sort, path_calidad + '/temp_sort_select.shp', "JOIN_FID<>-1") arcpy.DeleteIdentical_management(temp_sort_select, ["JOIN_FID"]) list_correcion_vias = list( set([(x[0], x[1], x[2]) for x in arcpy.da.SearchCursor( temp_sort_select, ["p21", "NOMBRE_CAT", "NOMBRE_VIA"])])) #list_correcion_vias_p21=list(set([x[0] for x in arcpy.da.SearchCursor(temp_sort_select,["p21"])])) arcpy.AddField_management(error_10, 'NOM_CAT_AL', 'TEXT') arcpy.AddField_management(error_10, 'NOM_VIA_AL', 'TEXT') ########################################################################################################## with arcpy.da.UpdateCursor(error_10, [ "UBIGEO", "ZONA", "MANZANA", "ID_REG_OR", "p21", "NOM_CAT_AL", "NOM_VIA_AL" ]) as cursor: for x in cursor: for y in list_correcion_vias: if (y[0] == x[4]): x[5] = y[1] x[6] = y[2] break cursor.updateRow(x)
arcpy.MakeXYEventLayer_management(crashCSVFile, XPoints, YPoints, "New York CrashData", "", "") arcpy.CopyFeatures_management("New York CrashData", crashShapeFile) #Clean traffic shape files #Delete everything besides data from Manhattan with arcpy.da.UpdateCursor(trafficShapeFile, "County_Cod") as cursor: for row in cursor: if row[0] != 61: cursor.deleteRow() #Create mapping traffic shape file -> this file is used to later correctly map the AADTs #Background: some segments are to long or to short, that leads to unwanted mini segments #Split at intersections arcpy.FeatureToLine_management(trafficShapeFile, mappingTrafficShapeFile, "0.001 Meters") #Create segment shape file arcpy.Dissolve_management(mappingTrafficShapeFile, segmentShapeFile) ##Now we have one big connected polygon #Intersect segment shape file arcpy.FeatureToLine_management(segmentShapeFile, segmentShapeFile2, "0.001 Meters") #Add fields segment shape file, length and id arcpy.AddField_management(in_table=segmentShapeFile2, field_name="Length_m", field_type="DOUBLE") arcpy.AddField_management(in_table=segmentShapeFile2, field_name="Segment_ID",
def route_fiber(nd_in, incidents_in, facilities_in, name_in, output_fc_in, pro_in, protection_in=False, sp_protection_in=True, brownfield_duct='#'): arcpy.CheckOutExtension('Network') # Set local variables layer_name = "ClosestFacility" impedance = "Length" # MakeClosestFacilityLayer_na (in_network_dataset, out_network_analysis_layer, impedance_attribute, # {travel_from_to}, {default_cutoff}, {default_number_facilities_to_find}, {accumulate_attribute_name}, # {UTurn_policy}, {restriction_attribute_name}, {hierarchy}, {hierarchy_settings}, {output_path_shape}, # {time_of_day}, {time_of_day_usage}) # # http://desktop.arcgis.com/en/arcmap/10.3/tools/network-analyst-toolbox/make-closest-facility-layer.htm result_object = arcpy.na.MakeClosestFacilityLayer(nd_in, layer_name, impedance, 'TRAVEL_TO', default_cutoff=None, default_number_facilities_to_find=1, output_path_shape='TRUE_LINES_WITH_MEASURES') # Get the layer object from the result object. The Closest facility layer can # now be referenced using the layer object. layer_object = result_object.getOutput(0) # Get the names of all the sublayers within the Closest facility layer. sublayer_names = arcpy.na.GetNAClassNames(layer_object) # Stores the layer names that we will use later incidents_layer_name = sublayer_names["Incidents"] # as origins facilities_layer_name = sublayer_names["Facilities"] # as destinations lines_layer_name = sublayer_names["CFRoutes"] # as lines arcpy.na.AddLocations(layer_object, incidents_layer_name, incidents_in) arcpy.na.AddLocations(layer_object, facilities_layer_name, facilities_in) if brownfield_duct != '#': mapping = "Name Name #;Attr_Length # " + '0,001' + "; BarrierType # 1" arcpy.na.AddLocations(layer_object, "Line Barriers", brownfield_duct, mapping, search_tolerance="5 Meters") # Solve the Closest facility layer arcpy.na.Solve(layer_object) # # Save the solved Closest facility layer as a layer file on disk # output_layer_file = os.path.join(output_dir_in, layer_name) # arcpy.MakeFeatureLayer_management(layer_object, output_layer_file) # Get the Lines Sublayer (all the distances) if pro_in: lines_sublayer = layer_object.listLayers(lines_layer_name)[0] elif not pro_in: lines_sublayer = arcpy.mapping.ListLayers(layer_object, lines_layer_name)[0] layer_out_path = os.path.join(output_fc_in, name_in) arcpy.management.CopyFeatures(lines_sublayer, layer_out_path) protection_out_path = "#" # If requested route the protection paths if protection_in: # For all the routed apths the disjoint path has to be found n_paths = int(arcpy.GetCount_management(incidents_in).getOutput(0)) field_objects = arcpy.ListFields(layer_out_path) fields = [field.name for field in field_objects if field.type != 'Geometry'] if 'Total_Length' in fields: field_len = 'Total_Length' elif 'Shape_Length' in fields: field_len = 'Shape_Length' # Iterate through all the facility-demand pairs and their respective routes cursor_r = arcpy.da.SearchCursor(layer_out_path, ['SHAPE@', field_len]) cursor_n = arcpy.da.SearchCursor(incidents_in, 'SHAPE@') if sp_protection_in: name_protect = 'sp' else: name_protect = 'duct_sharing' protection_out_path = os.path.join(output_fc_in, '{0}_protection_{1}'.format(name_in, name_protect)) check_exists(protection_out_path) arcpy.CreateFeatureclass_management(output_fc_in, '{0}_protection_{1}'.format(name_in, name_protect), template=layer_out_path) for i in range(n_paths): path = cursor_r.next() node = cursor_n.next() if not path[1] == 0: if sp_protection_in: tmp = protection_routing(nd_in, facilities_in, node[0], path[0], pro_in) # Add the protection route to the output feature class arcpy.Append_management(tmp, protection_out_path, schema_type="NO_TEST") else: all_paths = os.path.join('in_memory', 'all_paths_{0}'.format(i)) check_exists(all_paths) arcpy.CopyFeatures_management(layer_out_path, all_paths) other_paths_tmp = os.path.join('in_memory', 'other_paths_{0}_dissolved'.format(i)) check_exists(other_paths_tmp) arcpy.Dissolve_management(all_paths, other_paths_tmp) other_paths = os.path.join('in_memory', 'other_paths_{0}'.format(i)) check_exists(other_paths) arcpy.FeatureToLine_management(other_paths_tmp, other_paths) other_paths_layer = os.path.join('in_memory', 'other_paths_layer_{0}'.format(i)) check_exists(other_paths_layer) arcpy.MakeFeatureLayer_management(other_paths, other_paths_layer) arcpy.SelectLayerByLocation_management(other_paths_layer, 'SHARE_A_LINE_SEGMENT_WITH', path[0], selection_type='NEW_SELECTION', invert_spatial_relationship='INVERT') scaled_cost = os.path.join('in_memory', 'scaled_cost_{0}'.format(i)) check_exists(scaled_cost) arcpy.CopyFeatures_management(other_paths_layer, scaled_cost) tmp = protection_routing(nd_in, facilities_in, node[0], path[0], pro_in, scaled_cost) # Add the protection route to the output feature class arcpy.Append_management(tmp, protection_out_path, schema_type="NO_TEST") return layer_out_path, protection_out_path
arcpy.env.workspace = getGDBPath() root.destroy() ds = getfloor() #df = pd.DataFrame() fctypes = np.unique([ str(fc[fc.rfind("_") + 1:]) for fc in arcpy.ListFeatureClasses(feature_dataset=ds[0]) ]) #print fctypes new_build = getbuild() print "------------------------------------------------------------------------" #print "In %s there the:" % ds[0] for fctype in fctypes: FCinput = ds[0] + "/" + new_build + '_' + fctype Foutput = ds[0] + "/" + ds[1] + '_' + fctype if ar.Exists(FCinput): print new_build + '_' + fctype if ar.Exists(Foutput): ar.Append_management(FCinput, Foutput, "NO_TEST") print " Appended to:", ds[1] + '_' + fctype else: try: ar.FeatureToPolygon_management(FCinput, Foutput) except: ar.FeatureToLine_management(FCinput, Foutput) print ' Created: ', ds[1] + '_' + fctype print "------------------------------------------------------------------------"
g = Graph(roads, id, avg_Speed, direction) #Wyciagniecie punktow z klasy targets points = [] with arcpy.da.SearchCursor(targets, ["SHAPE@X", "SHAPE@Y"]) as sc: for row in sc: points.append([row[0], row[1]]) #Znalezienie punktow begin = g.search(points[0]) end = g.search(points[1]) arcpy.AddMessage(str(begin) + " " + str(end)) #Wyznaczenie trasy path = g.make_path(begin, end, [algorithm, ignore_direct, time_or_dist]) #Przypisanie workspace do celowego datasetu prev_work = arcpy.env.workspace arcpy.env.workspace = dat #Zamiana w Shapefile wizualizacja(roads, path, file_path, id) #Jezeli inna niz punkt koncowy, to zamien na linie if target != targets: temp = "toLine" arcpy.FeatureToLine_management([target], temp) target = temp #Ustalenie celu na granicy poligonu arcpy.Intersect_analysis([file_path, target], file_target, "ONLY_FID", None, "POINT") if target == "toLine": arcpy.Delete_management(target) #Zamiana z powrotem arcpy.env.workspace = prev_work
def cartoLimits(aoi, prod_db, desktop_fldr): # Subtype field used in where clause to filter inputs to Model subtype_fld = arcpy.AddFieldDelimiters(prod_db, "FCSubtype") # Make feature layer of aoi arcpy.MakeFeatureLayer_management(aoi, "aoi") # Convert AOI to polyline aoi_line = os.path.join(arcpy.env.scratchGDB, "aoi_line") arcpy.FeatureToLine_management("aoi", aoi_line) arcpy.MakeFeatureLayer_management(aoi_line, "aoi_line") # Get list of input feature classes, subtypes, and cart limit feature classes inputs = [["DangersA", [], "DangersA_L"], ["DepthsA", ["5", "10", "15"], "DepthsA_L"], ["IceFeaturesA", [], "IceA_L"], ["MilitaryFeaturesA", [], "MilitaryA_L"], ["NaturalFeaturesA", ["1", "20", "35"], "NaturalA_L"], ["OffshoreInstallationsA", [], "OffshoreA_L"], [ "PortsAndServicesA", [ "5", "10", "25", "30", "35", "40", "45", "50", "55", "60", "65", "70", "80" ], "PortsA_L" ], [ "RegulatedAreasAndLimitsA", [ "1", "5", "10", "15", "20", "30", "40", "50", "60", "65", "70", "75", "85", "95", "105", "110", "115" ], "RegulatedA_L" ], ["SeabedA", ["15"], "SeabedA_L"], [ "TracksAndRoutesA", ["1", "5", "10", "15", "20", "25", "40", "45", "70"], "TracksA_L" ]] # Set workspace arcpy.env.workspace = prod_db # Get CoastlineA and CloastlineL layers coastlinea_fc = getFC(prod_db, "CoastlineA", NAUT_FDS) arcpy.MakeFeatureLayer_management(coastlinea_fc, "CoastlineA") coastlinel_fc = getFC(prod_db, "CoastlineL", NAUT_FDS) arcpy.MakeFeatureLayer_management(coastlinel_fc, "CoastlineL") # Loop through list of inputs for data in inputs: # Get full paths to data input_fc = getFC(prod_db, data[0], NAUT_FDS) output_fc = getFC(prod_db, data[2], CARTO_FDS) if input_fc != "" and output_fc != "": # Check if there are subtypes, if there are, write where clause where = "" if len(data[1]) > 0: where = subtype_fld + " = " where = where + (" OR " + subtype_fld + " = ").join(data[1]) # Remove single quotes that get added to beginning and end of where clause where = where.replace("'", "") # Select features in where clause arcpy.MakeFeatureLayer_management(input_fc, "in_lyr", where) # Only run Generate Cartographic Limits model if layer has features if int(arcpy.GetCount_management("in_lyr").getOutput(0)) > 0: arcpy.AddMessage("\t\t" + data[2]) arcpy.GenerateCartographicLimits_nautical( "in_lyr", "CoastlineL; CoastlineA; aoi_line", output_fc) return
outputName = os.path.join(outputFolder, name) subset = arcpy.Select_analysis(rios, outputName, where) walk = arcpy.da.Walk(outputFolder, datatype="FeatureClass") listaRios = [] for dir_path, dir_names, file_names in walk: for filename in file_names: listaRios.append(os.path.join(dir_path, filename)) listaFeatures = [] for i in range(0, len(listaRios), 1): inputs = listaRios[i:i + 2] j = i + 1 nombreUnion = 'rios_{0}{1}'.format(j, j + 1) nombreSalida_union = os.path.join(carpeta, nombreUnion) if len(inputs) < 2: break uniones = arcpy.FeatureToLine_management(inputs, nombreSalida_union) whereSelect = "GRID_CODE = {0}".format(j) nombreSelect = 'rios_{0}{1}select'.format(j, j + 1) nombreSalida_select = os.path.join(carpeta, nombreSelect) ordenes = arcpy.Select_analysis(uniones, nombreSalida_select, whereSelect) listaFeatures.append(ordenes) riosProcesados = arcpy.Merge_management( listaFeatures, 'C:/Datos/Glaciares_vegas/rios_procesados.shp') riosProcesados = arcpy.AddField_management(featureTotal, "tramo", "LONG") riosProcesados = arcpy.CalculateField_management("rios_procesados", "tramo", "!FID! + 1", "PYTHON") ### AGRUPACION DE LAS VEGAS SEGUN LOS TRAMOS DE LOS RIOS ## FUNCION PARA DEFINIR MAPPINGS para spatial join. DOS atributos (GRID_CODE y tramo, PIDIENDO max)
def setupFiles(roadsFC, newRoadsFC, cityBoundFC): arcpy.env.overwriteOutput = True #Make sure that you set these flags to Disabled or else there is an issue with some of the functions and the roads env.outputMFlag = "Disabled" env.outputZFlag = "Disabled" intersectFC = "Intersect" featLyrIntersect = "FeatLayerPt" featLyrRoad = "FeatLayerLine" outFolder = "L:\\IntersectData" outWorkspace = "IntersectGDB.gdb" featLyrCity = "FeatLayerCity" featLyrTemp = "FeatLayerTemp" env.workspace = outFolder + "\\" + outWorkspace #Delete old data if (arcpy.Exists(env.workspace + "\\" + intersectFC)): print("Copying Features") arcpy.CopyFeatures_management( "Database Connections\\ARCSDE_10.sde\\City.DBO.CATSO\\City.DBO.CATSOMRP", roadsFC) arcpy.CopyFeatures_management( "Database Connections\\ARCSDE_10.sde\\City.DBO.PW_zoning\\City.DBO.columbia_corp_limit", cityBoundFC) print("Copied Features") UpdateCATSOIntersections.update( roadsFC, cityBoundFC) #If it already exists, reroute to the update script return #Create Geodatabase arcpy.CreateFileGDB_management(outFolder, outWorkspace) env.workspace = outFolder + "\\" + outWorkspace print("CREATING INTERSECTIONS") #Copy features from SDE print("Copying Features") arcpy.CopyFeatures_management( "Database Connections\\ARCSDE_10.sde\\City.DBO.CATSO\\City.DBO.CATSOMRP", roadsFC) arcpy.CopyFeatures_management( "Database Connections\\ARCSDE_10.sde\\City.DBO.PW_zoning\\City.DBO.columbia_corp_limit", cityBoundFC) print("Copied Features") #Convert to feature layer to select by location arcpy.MakeFeatureLayer_management(roadsFC, featLyrTemp) arcpy.MakeFeatureLayer_management(cityBoundFC, featLyrCity) #select only features within the city limits arcpy.SelectLayerByLocation_management(featLyrTemp, "INTERSECT", featLyrCity, "", "NEW_SELECTION") #Perform feature to line tool, to split the lines at vertices for more precise intersection output arcpy.FeatureToLine_management(featLyrTemp, newRoadsFC, "", "ATTRIBUTES") print("Feature to Line Completed") #Find all of the intersections arcpy.Intersect_analysis(newRoadsFC, intersectFC, "ONLY_FID", "", "POINT") print("Found Intersects") #Add fields to the output intersect feature arcpy.AddField_management(intersectFC, "STREETS", "TEXT", "", "", 150, "STREET_NAMES", "", "", "") arcpy.AddField_management(intersectFC, "INT_ID", "LONG", "", "", "", "INTERSECT_ID", "", "", "") arcpy.AddField_management(intersectFC, "MAJOR_INT", "TEXT", "", "", 10, "MAJOR_INTERSECTION", "", "", "") #Convert to feature layer to make later selections arcpy.MakeFeatureLayer_management(newRoadsFC, featLyrRoad) arcpy.MakeFeatureLayer_management(intersectFC, featLyrIntersect) IntersectCATSOAnalysis.runAnalysis(featLyrIntersect, featLyrRoad, False)
def main(fcInputCenterline, fcInputPolygon, fcSegmentedPolygons, workspaceTemp, dblPointDensity=10.0, dblJunctionBuffer=120.00): arcpy.AddMessage("GNAT Divide Polygon By Segment Tool") arcpy.AddMessage("GNAT DPS: Saving Polygon Results to: " + fcSegmentedPolygons) arcpy.AddMessage("GNAT DPS: Saving Temporary Files to: " + workspaceTemp) arcpy.env.OutputMFlag = "Disabled" arcpy.env.OutputZFlag = "Disabled" arcpy.AddMessage("arcpy M Output Flag: " + str(arcpy.env.OutputMFlag)) ## Copy Centerline to Temp Workspace fcCenterline = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_Centerline") arcpy.CopyFeatures_management(fcInputCenterline, fcCenterline) ## Build Thiessan Polygons arcpy.AddMessage("GNAT DPS: Building Thiessan Polygons") arcpy.env.extent = fcInputPolygon ## Set full extent to build Thiessan polygons over entire line network. arcpy.Densify_edit(fcCenterline, "DISTANCE", str(dblPointDensity) + " METERS") fcTribJunctionPoints = gis_tools.newGISDataset( workspaceTemp, "GNAT_DPS_TribJunctionPoints") # All Segment Junctions?? #gis_tools.findSegmentJunctions(fcCenterline,fcTribJunctionPoints,"ALL") arcpy.Intersect_analysis(fcCenterline, fcTribJunctionPoints, output_type="POINT") fcThiessanPoints = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_ThiessanPoints") arcpy.FeatureVerticesToPoints_management(fcCenterline, fcThiessanPoints, "ALL") lyrThiessanPoints = gis_tools.newGISDataset("Layer", "lyrThiessanPoints") arcpy.MakeFeatureLayer_management(fcThiessanPoints, lyrThiessanPoints) arcpy.SelectLayerByLocation_management(lyrThiessanPoints, "INTERSECT", fcTribJunctionPoints, str(dblJunctionBuffer) + " METERS", "NEW_SELECTION") fcThiessanPoly = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_ThiessanPoly") arcpy.CreateThiessenPolygons_analysis(lyrThiessanPoints, fcThiessanPoly, "ONLY_FID") fcThiessanPolyClip = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_TheissanPolyClip") arcpy.Clip_analysis(fcThiessanPoly, fcInputPolygon, fcThiessanPolyClip) ### Code to Split the Junction Thiessan Polys ### arcpy.AddMessage("GNAT DPS: Split Junction Thiessan Polygons") lyrTribThiessanPolys = gis_tools.newGISDataset("Layer", "lyrTribThiessanPolys") arcpy.MakeFeatureLayer_management(fcThiessanPolyClip, lyrTribThiessanPolys) arcpy.SelectLayerByLocation_management(lyrTribThiessanPolys, "INTERSECT", fcTribJunctionPoints, selection_type="NEW_SELECTION") fcSplitPoints = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_SplitPoints") arcpy.Intersect_analysis([lyrTribThiessanPolys, fcCenterline], fcSplitPoints, output_type="POINT") arcpy.AddMessage("GNAT DPS: Moving Starting Vertices of Junction Polygons") geometry_functions.changeStartingVertex(fcTribJunctionPoints, lyrTribThiessanPolys) arcpy.AddMessage("GNAT DPS: Vertices Moved.") fcThiessanTribPolyEdges = gis_tools.newGISDataset( workspaceTemp, "GNAT_DPS_ThiessanTribPolyEdges") arcpy.FeatureToLine_management(lyrTribThiessanPolys, fcThiessanTribPolyEdges) fcSplitLines = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_SplitLines") arcpy.SplitLineAtPoint_management(fcThiessanTribPolyEdges, fcSplitPoints, fcSplitLines, "0.1 METERS") fcMidPoints = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_MidPoints") arcpy.FeatureVerticesToPoints_management(fcSplitLines, fcMidPoints, "MID") arcpy.Near_analysis(fcMidPoints, fcTribJunctionPoints, location="LOCATION") arcpy.AddXY_management(fcMidPoints) fcTribToMidLines = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_TribToMidLines") arcpy.XYToLine_management(fcMidPoints, fcTribToMidLines, "POINT_X", "POINT_Y", "NEAR_X", "NEAR_Y") ### Select Polys by Centerline ### arcpy.AddMessage("GNAT DPS: Select Polygons By Centerline") fcThiessanEdges = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_ThiessanEdges") arcpy.FeatureToLine_management(fcThiessanPolyClip, fcThiessanEdges) fcAllEdges = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_AllEdges") arcpy.Merge_management([fcTribToMidLines, fcThiessanEdges, fcCenterline], fcAllEdges) # include fcCenterline if needed fcAllEdgesPolygons = gis_tools.newGISDataset(workspaceTemp, "GNAT_DPS_AllEdgesPolygons") arcpy.FeatureToPolygon_management(fcAllEdges, fcAllEdgesPolygons) fcAllEdgesPolygonsClip = gis_tools.newGISDataset( workspaceTemp, "GNAT_DPS_AllEdgesPolygonsClip") arcpy.Clip_analysis(fcAllEdgesPolygons, fcInputPolygon, fcAllEdgesPolygonsClip) fcPolygonsJoinCenterline = gis_tools.newGISDataset( workspaceTemp, "GNAT_DPS_PolygonsJoinCenterline") arcpy.SpatialJoin_analysis(fcAllEdgesPolygonsClip, fcCenterline, fcPolygonsJoinCenterline, "JOIN_ONE_TO_MANY", "KEEP_ALL", match_option="SHARE_A_LINE_SEGMENT_WITH") fcPolygonsDissolved = gis_tools.newGISDataset( workspaceTemp, "GNAT_DPS_PolygonsDissolved") arcpy.Dissolve_management(fcPolygonsJoinCenterline, fcPolygonsDissolved, "JOIN_FID", multi_part="SINGLE_PART") #fcSegmentedPolygons = gis_tools.newGISDataset(workspaceOutput,"SegmentedPolygons") lyrPolygonsDissolved = gis_tools.newGISDataset("Layer", "lyrPolygonsDissolved") arcpy.MakeFeatureLayer_management(fcPolygonsDissolved, lyrPolygonsDissolved) arcpy.SelectLayerByAttribute_management(lyrPolygonsDissolved, "NEW_SELECTION", """ "JOIN_FID" = -1 """) arcpy.Eliminate_management(lyrPolygonsDissolved, fcSegmentedPolygons, "LENGTH") arcpy.AddMessage("GNAT DPS: Tool Complete.") return
def main(workspace, areaOfInterest, albertaloticRiparian, albertaMergedWetlandInventory, quarterSectionBoundaries, parksProtectedAreasAlberta, humanFootprint): # Import necesarry modules import numpy as np import arcpy # Overwrite output and checkout neccesary extensions arcpy.env.overwriteOutput = True arcpy.CheckOutExtension("spatial") # assign workspace arcpy.env.workspace = workspace # First we project our parcel data into the correct projection, create a layer file, then select only parcels we are interested in with Select by Attribute # and Select by Location (Intersecting tht Area of Interest polygon), then export this selection to a new feature class called "ParcelsFinal" # Local Variables quarterSectionBoundaries_project = "quarterSectionBoundaries_project" quarterSectionBoundaries_project_layer = "quarterSectionBoundaries_project_layer" ParcelsFinal = "ParcelsFinal" # Process: Project arcpy.Project_management( quarterSectionBoundaries, quarterSectionBoundaries_project, "PROJCS['NAD_1983_10TM_AEP_Forest',GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]],PROJECTION['Transverse_Mercator'],PARAMETER['False_Easting',500000.0],PARAMETER['False_Northing',0.0],PARAMETER['Central_Meridian',-115.0],PARAMETER['Scale_Factor',0.9992],PARAMETER['Latitude_Of_Origin',0.0],UNIT['Meter',1.0]]", "", "GEOGCS['GCS_North_American_1983',DATUM['D_North_American_1983',SPHEROID['GRS_1980',6378137.0,298.257222101]],PRIMEM['Greenwich',0.0],UNIT['Degree',0.0174532925199433]]", "NO_PRESERVE_SHAPE", "", "NO_VERTICAL") # Process: Make Feature Layer arcpy.MakeFeatureLayer_management( quarterSectionBoundaries_project, quarterSectionBoundaries_project_layer, "", "", "OBJECTID OBJECTID VISIBLE NONE;Shape Shape VISIBLE NONE;MER MER VISIBLE NONE;RGE RGE VISIBLE NONE;TWP TWP VISIBLE NONE;SEC SEC VISIBLE NONE;QS QS VISIBLE NONE;RA RA VISIBLE NONE;PARCEL_ID PARCEL_ID VISIBLE NONE;Shape_length Shape_length VISIBLE NONE;Shape_area Shape_area VISIBLE NONE" ) # selects all parcels intersecting the users area of interest # Process: Select Layer By Location arcpy.SelectLayerByLocation_management( quarterSectionBoundaries_project_layer, "INTERSECT", areaOfInterest, "", "NEW_SELECTION", "NOT_INVERT") # Removes roads from parcel data to ensure that only quarter sections are selected # Process: Select Layer By Attribute arcpy.SelectLayerByAttribute_management( quarterSectionBoundaries_project_layer, "SUBSET_SELECTION", "RA NOT LIKE 'R'") # Process: Copy Features arcpy.CopyFeatures_management(quarterSectionBoundaries_project_layer, ParcelsFinal, "", "0", "0", "0") # ############### ArcGis MODEL BUILDER SECTION: for initial Geoproccessing ################################################################################################################# # The following was exported from ArcMap's Model builder. It performs most of the neccessary geoprocessing needed to determine the spatial relationships # between the parcels and the user provided data (Human footprint, Lotic(Riparian), Wetlands, Patch Size, and Proximity) # local Variables: footprint_EXTENT_CLIPPED = "Footprint_Extent_Clipped" Footprint_Inverse = "Footprint_Inverse" Intact_Area_Per_Parcel = "Intact_Area_Per_Parcel" Wetland_Extent_Clipped = "Wetland_Extent_Clipped" Wetland_Lines = "Wetland_Lines" Wetland_Edge_Per_Parcel = "Wetland_Edge_Per_Parcel" Lotic_Extent_Clipped = "Lotic_Extent_Clipped" Lotic_No_Wetlands = "Lotic_No_Wetlands" Lotic_Area_Per_Parcel = "Lotic_Area_Per_Parcel" Area_Of_Interest_Buffered = "Area_Of_Interest_Buffered" Footprint_Larger_Extent = "Footprint_Larger_Extent" Footprint_INVERSE_Large = "Footprint_INVERSE_Large" Footprint_INVERSE_Large_Explode = "Footprint_INVERSE_Large_Explode" # Process: Clip arcpy.Clip_analysis(humanFootprint, ParcelsFinal, footprint_EXTENT_CLIPPED, "") # Process: Erase arcpy.Erase_analysis(ParcelsFinal, footprint_EXTENT_CLIPPED, Footprint_Inverse, "") # # Process: Tabulate Intersection arcpy.TabulateIntersection_analysis(ParcelsFinal, "OBJECTID", Footprint_Inverse, Intact_Area_Per_Parcel, "", "", "", "UNKNOWN") # Process: Clip (3) arcpy.Clip_analysis(albertaMergedWetlandInventory, ParcelsFinal, Wetland_Extent_Clipped, "") # Process: Feature To Line arcpy.FeatureToLine_management(Wetland_Extent_Clipped, Wetland_Lines, "", "ATTRIBUTES") ##arcpy.FeatureToLine_management("'D:\\evanamiesgalonskiMOBILE\\1 Courses\\329\\Final Project\\DATA\\test results.gdb\\Wetland_Extent_Clipped'", Wetland_Lines, "", "ATTRIBUTES") # Process: Tabulate Intersection (2) arcpy.TabulateIntersection_analysis(ParcelsFinal, "OBJECTID", Wetland_Lines, Wetland_Edge_Per_Parcel, "", "", "", "UNKNOWN") # Process: Clip (4) arcpy.Clip_analysis(albertaloticRiparian, ParcelsFinal, Lotic_Extent_Clipped, "") # Process: Erase (2) arcpy.Erase_analysis(Lotic_Extent_Clipped, Wetland_Extent_Clipped, Lotic_No_Wetlands, "") # Process: Tabulate Intersection (3) arcpy.TabulateIntersection_analysis(ParcelsFinal, "OBJECTID", Lotic_No_Wetlands, Lotic_Area_Per_Parcel, "", "", "", "UNKNOWN") # Process: Buffer arcpy.Buffer_analysis(areaOfInterest, Area_Of_Interest_Buffered, "50 Kilometers", "FULL", "ROUND", "NONE", "", "PLANAR") # Process: Clip (2) arcpy.Clip_analysis(humanFootprint, Area_Of_Interest_Buffered, Footprint_Larger_Extent, "") # Process: Erase (3) arcpy.Erase_analysis(Area_Of_Interest_Buffered, Footprint_Larger_Extent, Footprint_INVERSE_Large, "") # Process: Multipart To Singlepart arcpy.MultipartToSinglepart_management(Footprint_INVERSE_Large, Footprint_INVERSE_Large_Explode) # ########################################################################################################################################################################### # This part of the script edits the nwely created tables that contain information about the instersection of Wetlands, Lotic, and Intactness data with the land parcels # The Area and Percent coverage fields are renamed to be more decriptive and to ensure there are no confusing duplicate field names in our ParcelsFinal feature class. # Alter Field names in intactness table arcpy.AlterField_management(Intact_Area_Per_Parcel, "AREA", new_field_name="Area_Intact", field_is_nullable="NULLABLE") arcpy.AlterField_management(Intact_Area_Per_Parcel, "PERCENTAGE", new_field_name="Percent_Intact", field_is_nullable="NULLABLE") # Alter field names in lotic_table arcpy.AlterField_management(Lotic_Area_Per_Parcel, "AREA", new_field_name="Area_Lotic", field_is_nullable="NULLABLE") arcpy.AlterField_management(Lotic_Area_Per_Parcel, "PERCENTAGE", new_field_name="Percent_Lotic", field_is_nullable="NULLABLE") # Alter Field name in wetlands_table arcpy.AlterField_management(Wetland_Edge_Per_Parcel, "LENGTH", new_field_name="Wetland_Edge", field_is_nullable="NULLABLE") # Now we will join the desired fields from the 3 tables (intactness, lotic, ad wetlands) to the Land Parcel feature class # Process: Join Field arcpy.JoinField_management(ParcelsFinal, "OBJECTID", Intact_Area_Per_Parcel, "OBJECTID_1", ["Area_Intact", "Percent_Intact"]) # Process: Join Field (2) arcpy.JoinField_management(ParcelsFinal, "OBJECTID", Lotic_Area_Per_Parcel, "OBJECTID_1", ["Area_Lotic", "Percent_Lotic"]) # Process: Join Field (3) arcpy.JoinField_management(ParcelsFinal, "OBJECTID", Wetland_Edge_Per_Parcel, "OBJECTID_1", "Wetland_Edge") # Now we get rid of null values in our new fields and replace them with zeros with arcpy.da.UpdateCursor(ParcelsFinal, ["Area_Intact"]) as cursor: for row in cursor: if row[0] == None: row[0] = 0 cursor.updateRow(row) with arcpy.da.UpdateCursor(ParcelsFinal, ["Percent_Intact"]) as cursor: for row in cursor: if row[0] == None: row[0] = 0 cursor.updateRow(row) with arcpy.da.UpdateCursor(ParcelsFinal, ["Area_Lotic"]) as cursor: for row in cursor: if row[0] == None: row[0] = 0 cursor.updateRow(row) with arcpy.da.UpdateCursor(ParcelsFinal, ["Percent_Lotic"]) as cursor: for row in cursor: if row[0] == None: row[0] = 0 cursor.updateRow(row) with arcpy.da.UpdateCursor(ParcelsFinal, ["Wetland_Edge"]) as cursor: for row in cursor: if row[0] == None: row[0] = 0 cursor.updateRow(row) # This section of the script calculates the largest intact patch that intersects each parcel # Local Variables Footprint_INVERSE_Large_Explode = "Footprint_INVERSE_Large_Explode" Patch_Sizes_Per_Parcel = "Patch_Sizes_Per_Parcel" # Process: Tabulate Intersection arcpy.TabulateIntersection_analysis(ParcelsFinal, "OBJECTID", Footprint_INVERSE_Large_Explode, Patch_Sizes_Per_Parcel, "SHAPE_Area", "", "", "UNKNOWN") # A table was created with Tabulate Intersection that contains the areas of all intact patches that intersect # each parcel. We have several duplicates of each Parcel OBJECTID in this table, one for every patch that intersects a parcel. # we need to determine which duplicate OBJECTID corresponds to the largest patch area. # First we get a full list of the object IDs in our clipped ParcelsFinal Class # even though there is only one value in each cell of the attribute table, the data type is a tuple, so we need to extract our value our of it, as with a list parcel_IDs_extracted = [] parcel_IDs = arcpy.da.SearchCursor(ParcelsFinal, "OBJECTID") for ID in parcel_IDs: if isinstance(ID, tuple): ID = ID[0] parcel_IDs_extracted.append(ID) else: parcel_IDs_extracted.append(ID) Patch_Sizes_Per_Parcel = "Patch_Sizes_Per_Parcel" ## # remove null values ## with arcpy.da.UpdateCursor(Patch_Sizes_Per_Parcel, ["SHAPE_Area"]) as cursor: ## for row in cursor: ## if row[0] == None: ## row[0] = 0 ## cursor.updateRow(row) # Now we get a full list of all of the Parcel Object ID that had at least one intersection with the "Intact" feature class (human footprint inverse) # NOTE: not all of the parcels in our area of interest necessarily intersect with the "Intact" feature class patch_IDs = arcpy.da.SearchCursor(Patch_Sizes_Per_Parcel, "OBJECTID_1") patch_IDs_extracted = [] for ID in patch_IDs: if isinstance(ID, tuple): ID = ID[0] patch_IDs_extracted.append(ID) elif isinstance(ID, str): patch_IDs_extracted.append(ID) # initialize 2 new lists orderedListofLists = [] newlist = [] # for each OBJECT ID we create a list of areas which are the intsects for a parcel, then append that list as an element in our list of lists (orderedListofLists) # the newlist is re-initialized every intereation after it has dumped its values into the orderedlistoflists. The orderedlistoflists is not re-initialized, and continues to be appended to. # Now the intersections for each parcel are nicely grouped together for ID in parcel_IDs_extracted: patch_IDs_and_Areas = arcpy.da.SearchCursor( Patch_Sizes_Per_Parcel, ["OBJECTID_1", "SHAPE_Area"]) if ID not in patch_IDs_extracted: # This step ensures that parcels that have not intersection receive a zero instead of being glossed over. This will maintain order of our field values. orderedListofLists.append(0) else: newlist = [] for rows in patch_IDs_and_Areas: if ID == rows[0]: x = rows[1] newlist.append(x) orderedListofLists.append(newlist) # initialize one more list # Since the intersections(areas) are grouped by parcel, we extract the highest number in each list element (which is a list), and this give us the largest patch size for each parcel. max_patch_size_per_parcel = [] for patchSizes in orderedListofLists: if patchSizes == 0: max_patch_size_per_parcel.append(0) else: max_patch_size_per_parcel.append(max(patchSizes)) # convert to acres for scoring max_patch_size_per_parcel_acres = [] acre = 0 for patchsize in max_patch_size_per_parcel: acre = patchsize / 4046.86 max_patch_size_per_parcel_acres.append(acre) # Now we have a list that contains the largest patch that intersects each parcel. # It is ordered the same as the OBJECTID and we can now create a new field in the parcels feature class and # iteratively polulate the rows with each patch area value # create new field arcpy.AddField_management(ParcelsFinal, "Largest_Patch_Area", "DOUBLE", field_length=50) # initialize x x = 0 # use update cursor to populate rows and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "Largest_Patch_Area") as cursor: for row in cursor: row[0] = max_patch_size_per_parcel_acres[x] cursor.updateRow(row) x += 1 # the following code calculates the nearest protected area feature and automatically creates a new field that contains that distance for each parcel. # Process: Near arcpy.Near_analysis(ParcelsFinal, parksProtectedAreasAlberta, "", "NO_LOCATION", "NO_ANGLE", "PLANAR") # ####################################################################################################################################################################################################### # The next section of code calulates the scores for each parcel based on the values is our newly added/created fields. # ##################### INTACTNESS SCORE ####################### # extract percent intact field intact_scores = [] percent_intact = arcpy.da.SearchCursor(ParcelsFinal, "Percent_Intact") # Perform calulation for score and append to new list. Accomodate for str and tuple field types for percent in percent_intact: if isinstance(percent, tuple): percent = percent[0] / 100 elif isinstance(percent, str): percent = float(percent) intact_scores.append(percent) # create new field arcpy.AddField_management(ParcelsFinal, "SCORE_Intactness", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "SCORE_Intactness") as cursor: for row in cursor: row[0] = intact_scores[x] cursor.updateRow(row) x += 1 # ################### Lotic (Riparian) Score ######################### # extract percent lotic field lotic_percent_list = [] percent_lotic = arcpy.da.SearchCursor(ParcelsFinal, "Percent_Lotic") # Accomodate for str and tuple field types for percent in percent_lotic: if isinstance(percent, tuple): percent = percent[0] elif isinstance(percent, str): percent = float(percent) lotic_percent_list.append(percent) # now we create a create a lotic percent list no zeros before establishing ranges for deciles lotic_percent_list_noZero = [] for percent in lotic_percent_list: if percent != 0: lotic_percent_list_noZero.append(percent) # use numbpy to calculate the decile ranges ranges = np.percentile(lotic_percent_list_noZero, np.arange(0, 100, 10)) # iterate through origincal lotic percent list and use the decile ranges to bin the lotic percent values to the appropriate scores final_lotic_scores = [] for percent in lotic_percent_list: if percent == 0: final_lotic_scores.append(0) elif percent >= ranges[0] and percent <= ranges[1]: final_lotic_scores.append(0.1) elif percent >= ranges[1] and percent <= ranges[2]: final_lotic_scores.append(0.2) elif percent >= ranges[2] and percent <= ranges[3]: final_lotic_scores.append(0.3) elif percent >= ranges[3] and percent <= ranges[4]: final_lotic_scores.append(0.4) elif percent >= ranges[4] and percent <= ranges[5]: final_lotic_scores.append(0.5) elif percent >= ranges[5] and percent <= ranges[6]: final_lotic_scores.append(0.6) elif percent >= ranges[6] and percent <= ranges[7]: final_lotic_scores.append(0.7) elif percent >= ranges[7] and percent <= ranges[8]: final_lotic_scores.append(0.8) elif percent >= ranges[8] and percent <= ranges[9]: final_lotic_scores.append(0.9) elif percent >= ranges[9]: final_lotic_scores.append(1) # the order of the resulting list is identical to the original, so it can be appended as a new field and the values will # correspond with the rows they are meant to score # create new field arcpy.AddField_management(ParcelsFinal, "SCORE_Lotic_Deciles", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "SCORE_Lotic_Deciles") as cursor: for row in cursor: row[0] = final_lotic_scores[x] cursor.updateRow(row) x += 1 # ######################### Wetland Score ##################### # extract Wetland edge length field wetland_edge_list = [] wetland_field = arcpy.da.SearchCursor(ParcelsFinal, "Wetland_Edge") # append values to new list. Accomodate for str and tuple field types. for length in wetland_field: if isinstance(length, tuple): length = length[0] elif isinstance(length, str): length = float(length) wetland_edge_list.append(length) # now we create a create a wetland edge list no zeros before establishing ranges for deciles wetland_edge_list_noZero = [] for edge_length in wetland_edge_list: if edge_length != 0: wetland_edge_list_noZero.append(edge_length) # use numbpy to calculate the decile ranges ranges = np.percentile(wetland_edge_list_noZero, np.arange(0, 100, 10)) # iterate through original wetland edge list and use the decile ranges to bin the wetland edge values to the appropriate scores final_wetland_scores = [] for edge_length in wetland_edge_list: if edge_length == 0: final_wetland_scores.append(0) elif edge_length >= ranges[0] and edge_length <= ranges[1]: final_wetland_scores.append(0.1) elif edge_length >= ranges[1] and edge_length <= ranges[2]: final_wetland_scores.append(0.2) elif edge_length >= ranges[2] and edge_length <= ranges[3]: final_wetland_scores.append(0.3) elif edge_length >= ranges[3] and edge_length <= ranges[4]: final_wetland_scores.append(0.4) elif edge_length >= ranges[4] and edge_length <= ranges[5]: final_wetland_scores.append(0.5) elif edge_length >= ranges[5] and edge_length <= ranges[6]: final_wetland_scores.append(0.6) elif edge_length >= ranges[6] and edge_length <= ranges[7]: final_wetland_scores.append(0.7) elif edge_length >= ranges[7] and edge_length <= ranges[8]: final_wetland_scores.append(0.8) elif edge_length >= ranges[8] and edge_length <= ranges[9]: final_wetland_scores.append(0.9) elif edge_length >= ranges[9]: final_wetland_scores.append(1) # the order of the resulting list is identical to the original, so it can be appended as a new field and the values will # correspond with the rows they are meant to score # create new field arcpy.AddField_management(ParcelsFinal, "SCORE_Wetland_Deciles", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "SCORE_Wetland_Deciles") as cursor: for row in cursor: row[0] = final_wetland_scores[x] cursor.updateRow(row) x += 1 # ################ Patch size score #################### # extract patch size field largest_patch_sizes = [] patch_sizes = arcpy.da.SearchCursor(ParcelsFinal, "Largest_Patch_Area") # Perform calulation for score and append to new list. Accomodate for str and tuple field types for size in patch_sizes: if isinstance(size, tuple): size = size[0] elif isinstance(size, str): size = float(size) largest_patch_sizes.append(size) # now we populate a new list and assign scores based on number ranges patch_size_scores = [] for size in largest_patch_sizes: if size < 160: patch_size_scores.append(0) elif size > 160 and size < 2500: patch_size_scores.append(0.5) elif size > 2500 and size < 10000: patch_size_scores.append(.75) elif size > 10000: patch_size_scores.append(1) # create new field arcpy.AddField_management(ParcelsFinal, "SCORE_Patch_Size", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "SCORE_Patch_Size") as cursor: for row in cursor: row[0] = patch_size_scores[x] cursor.updateRow(row) x += 1 # ############### Proximity Score ##################### # Rename Distance field to be more decriptive # delete NEAD FID feild (un-needed) arcpy.AlterField_management(ParcelsFinal, "NEAR_DIST", new_field_name="Dist_to_Protected", field_is_nullable="NULLABLE") arcpy.DeleteField_management(ParcelsFinal, "NEAR_FID") # extract proximity field all_proximities = [] proximities = arcpy.da.SearchCursor(ParcelsFinal, "Dist_to_Protected") # Perform calulation for score and append to new list. Accomodate for str and tuple field types for proximity in proximities: if isinstance(proximity, tuple): proximity = proximity[0] elif isinstance(proximity, str): proximity = float(proximity) all_proximities.append(proximity) # now we populate a new list and assign scores based on number ranges proximity_scores = [] for proximity in all_proximities: if proximity == 0: proximity_scores.append(1) elif proximity > 0 and proximity < 2000: proximity_scores.append(0.75) elif proximity > 2000 and proximity < 4000: proximity_scores.append(.5) elif proximity > 4000: proximity_scores.append(0) # create new field arcpy.AddField_management(ParcelsFinal, "SCORE_Proximity", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "SCORE_Proximity") as cursor: for row in cursor: row[0] = proximity_scores[x] cursor.updateRow(row) x += 1 # ##################### FINAL PRIORITY SCORES ########################### sumOfScores = [] scoreFields = arcpy.da.SearchCursor(ParcelsFinal, [ "SCORE_Lotic_Deciles", "SCORE_Wetland_Deciles", "SCORE_Intactness", "SCORE_Patch_Size", "SCORE_Proximity" ]) for score in scoreFields: sumScore = score[0] + score[1] + score[2] + score[3] + score[4] sumOfScores.append(sumScore) # create new field arcpy.AddField_management(ParcelsFinal, "PRIORITY_SCORE", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "PRIORITY_SCORE") as cursor: for row in cursor: row[0] = sumOfScores[x] cursor.updateRow(row) x += 1 # the order of the resulting list is identical to the original, so it can be appended as a new field and the values will # correspond with the rows they are meant to score # ################################## PRIORITY RANKING ####################################### # now we calculate ranges for priority ranking with 4 breaks (Quartiles) ranges = np.percentile(sumOfScores, np.arange(0, 100, 25)) final_priority_ranking = [] for score in sumOfScores: if score >= ranges[0] and score <= ranges[1]: final_priority_ranking.append(None) elif score >= ranges[1] and score <= ranges[2]: final_priority_ranking.append(3) elif score >= ranges[2] and score <= ranges[3]: final_priority_ranking.append(2) elif score >= ranges[3]: final_priority_ranking.append(1) # create new field arcpy.AddField_management(ParcelsFinal, "PRIORITY_RANKING", "DOUBLE", field_length=50) x = 0 # use update cursor to populate rows with list element and after each time the cursor moves down to the next row, # iterate to the next list element (x) with arcpy.da.UpdateCursor(ParcelsFinal, "PRIORITY_RANKING") as cursor: for row in cursor: row[0] = final_priority_ranking[x] cursor.updateRow(row) x += 1 arcpy.CheckInExtension("spatial") print("proccess complete") print("...........") print( "The resulting priority scored parcels feature class can be found in the user specified geodatabase by the name of 'ParcelsFinal'" ) print( "To view the Conservation Priority ranking, symbolize the feature class by unique values, using the 'PRIORITY_RANKING' field." )
def AnalyzePolylines(fc, route_id_fld, output_gdb): fc_name = os.path.basename(fc) if fc_name[-4:] == ".shp": fc_name = fc_name[:-4] fc_F2L_InMem = os.path.join("in_memory", fc_name + "_F2L") fc_F2L = os.path.join(output_gdb, fc_name + "_F2L") # fc_Diss name modification if prefixKeyString == '': fc_Diss = os.path.join(output_gdb, fc_name + "_SelfIntClassification") else: fc_Diss = os.path.join( output_gdb, fc_name + "_SelfIntClassification" + "_" + prefixKeyString) arcpy.AddMessage("Executing Feature To Line...") #arcpy.FeatureToLine_management(fc, fc_F2L) arcpy.FeatureToLine_management(fc, fc_F2L_InMem) arcpy.CopyFeatures_management(fc_F2L_InMem, fc_F2L) arcpy.AddMessage("Executing Dissolve...") arcpy.Dissolve_management(fc_F2L, fc_Diss, route_id_fld) arcpy.AddField_management(fc_Diss, "SelfIntersectionType", "TEXT", "", "", 50) arcpy.AddMessage("Classifying routes...") with arcpy.da.UpdateCursor( fc_Diss, ["SHAPE@", "SelfIntersectionType", route_id_fld]) as uCursor: for i, row in enumerate(uCursor): intersection_tuples_dict = { } # Keeps track of the number of times a particular vertex has come up for a route vtx_list = [] # Running list of vertices if i % 1000 == 0 and i != 0: arcpy.AddMessage(" Number of routes classified: " + str(i)) partnum = 0 #if row[1].isMultipart: vtx_prev = None skip_feature = False for part in row[0]: vtx_list.append([]) # Step through each vertex in the feature vtx_prev = None for vtx in part: vtx_current = (vtx.X, vtx.Y) # first check if the current vertex is already in intersection_tuples_dict. # If it's just a matter of duplicate consecutive vertices in this part, ignore (2nd clause in if statement condition) if vtx_current in intersection_tuples_dict and vtx_prev != vtx_current: if partnum in intersection_tuples_dict[vtx_current]: intersection_tuples_dict[vtx_current][partnum] += 1 else: intersection_tuples_dict[vtx_current][partnum] = 1 # if the current vertex is not already in intersection_tuples_dict, we still need to check if it's among # the vertices already reviewed (i.e., those in vtx_list) else: if vtx_prev != vtx_current: # want to ignore duplicate consecutive vertices vtx_in_list = False vtx_part = None for i, ls in enumerate(vtx_list): if vtx_current in ls: vtx_part = i vtx_in_list = True # if vtx_current is in the list, and it's part is the same as the previous incidence's: if vtx_in_list and partnum == vtx_part: intersection_tuples_dict[vtx_current] = { partnum: 2 } # if vtx_current is in the list, but it's not from the same part as the previous incidence's, add it's part to the dictionary with a count of 1 elif vtx_in_list: intersection_tuples_dict[vtx_current] = { vtx_part: 1 } intersection_tuples_dict[vtx_current][ partnum] = 1 # Add the vertex to the current part's list if vtx_prev != vtx_current: vtx_list[partnum].append(vtx_current) # save the current vertex as vtx_prev for the next iteration vtx_prev = vtx_current # if the feature has over 100k vertices, it may cause the tool to crash. Quick reviewing this vertex and put a warning. if len(vtx_list) > 100000: arcpy.AddWarning( "Route " + row[2] + " has more than 100,000 vertices. Analyze manually." ) skip_feature = True # added in order to break out of the outer for loop continue if skip_feature: continue partnum += 1 # Categorize the route based on the intersection info collected category = "Not self-intersecting" # More than two intersection points found if len(intersection_tuples_dict) >= 3: leng = len(intersection_tuples_dict) category = "Complex: " + str(leng) + " intersections total" # Only one intersection point found elif len(intersection_tuples_dict) == 1: for point_key in intersection_tuples_dict: if len(intersection_tuples_dict[point_key]) == 1: category = "Loop" elif len(intersection_tuples_dict[point_key]) == 2: part_pt_counts = [] for key in intersection_tuples_dict[point_key]: part_pt_counts.append( intersection_tuples_dict[point_key][key]) part_pt_counts.sort() if part_pt_counts == [2, 2]: category = "Infinity" else: category = "Lollipop" elif len(intersection_tuples_dict[point_key]) == 3: part_pt_counts = [] for key in intersection_tuples_dict[point_key]: part_pt_counts.append( intersection_tuples_dict[point_key][key]) part_pt_counts.sort() if part_pt_counts == [1, 1, 2]: category = "Alpha" else: category = "Branch" else: length = len(intersection_tuples_dict[point_key]) category = "Single self-intersection with " + str( length) + " approaches" # Two intersection points found elif len(intersection_tuples_dict) == 2: category_int1 = None category_int2 = None # Retrieve key for each intersection key_list = [] for key in intersection_tuples_dict: key_list.append(key) # Classify the first intersection for partnum_key in intersection_tuples_dict[key_list[0]]: if intersection_tuples_dict[key_list[0]][partnum_key] == 2: category_int1 = "Lollipop" if not category_int1: category_int1 = "Branch" if len(intersection_tuples_dict[key_list[0]]) > 2: category_int1 = "Branch or Alpha" # Classify the second intersection for partnum_key in intersection_tuples_dict[key_list[1]]: if intersection_tuples_dict[key_list[1]][partnum_key] == 2: category_int2 = "Lollipop" if not category_int2: category_int2 = "Branch" if len(intersection_tuples_dict[key_list[1]]) > 2: category_int1 = "Branch or Alpha" # Classify the route based on the two intersections if category_int1 == "Lollipop" and category_int2 == "Lollipop": category = "Barbell" else: int_ct = len(intersection_tuples_dict) category = "Complex: 2 intersections total" row[1] = category uCursor.updateRow(row) arcpy.Delete_management(fc_F2L) stats_table = os.path.join(output_gdb, "SelfIntersectingRoutes_CategoryCounts") arcpy.Statistics_analysis(fc_Diss, stats_table, [["Shape_Length", "SUM"]], "SelfIntersectionType")
costLayer = arcpy.sa.Int(costRaster) else: costLayer = costRaster costBndry = arcpy.RasterToPolygon_conversion(costLayer, "in_memory" + os.sep + "xxpoly", "SIMPLIFY", "VALUE") costBndry = arcpy.Dissolve_management(costBndry, "in_memory" + os.sep + "cb_dissolved", "", "", "SINGLE_PART", "") # Createfeature envelope of costRaster costEnv = arcpy.MinimumBoundingGeometry_management( costBndry, "in_memory" + os.sep + "cb_env", "ENVELOPE", "ALL") # Convert costRaster boundary to line costBndry = arcpy.FeatureToLine_management(costBndry, "in_memory" + os.sep + "xxline", "", "NO_ATTRIBUTES") costBndry = arcpy.Buffer_analysis(costBndry, "in_memory" + os.sep + "buf", CellSize + " Meters", "FULL", "ROUND", "NONE", "") costEnv = arcpy.FeatureToLine_management(costEnv, "in_memory" + os.sep + "xxenv", "", "NO_ATTRIBUTES") EnvPnt = arcpy.FeatureVerticesToPoints_management( costEnv, "in_memory" + os.sep + "xxpnt") fc = arcpy.MakeFeatureLayer_management(EnvPnt, "pLayer") oid_fieldname = arcpy.Describe(fc).OIDFieldName arcpy.SelectLayerByAttribute_management( fc, "NEW_SELECTION", oid_fieldname + " = 1 OR " + oid_fieldname + " = 3") diag_1 = arcpy.PointsToLine_management(fc, "in_memory" + os.sep + "diag_1") arcpy.SelectLayerByAttribute_management(fc, "SWITCH_SELECTION")
# Import arcpy module import arcpy # Local variables: ua_lehd_acs_1 = "ua_lehd_acs_1" ua_lehd_acs_1__2_ = ua_lehd_acs_1 tl_2010_06_place10 = "tl_2010_06_place10" tl_2010_06_place10_Layer = "tl_2010_06_place10_Layer" place_line_hold_shp = "L:\\Research\\Resurgence\\Working Files\\Place Dissolve\\place_line_hold.shp" boundary_tracts_hold_shp = "L:\\Research\\Resurgence\\Working Files\\Boundary\\boundary_tracts_hold.shp" # Process: Make Feature Layer arcpy.MakeFeatureLayer_management( tl_2010_06_place10, tl_2010_06_place10_Layer, "\"NAME10\" = 'Los Angeles'", "", "FID FID VISIBLE NONE;Shape Shape VISIBLE NONE;STATEFP10 STATEFP10 VISIBLE NONE;PLACEFP10 PLACEFP10 VISIBLE NONE;PLACENS10 PLACENS10 VISIBLE NONE;GEOID10 GEOID10 VISIBLE NONE;NAME10 NAME10 VISIBLE NONE;NAMELSAD10 NAMELSAD10 VISIBLE NONE;LSAD10 LSAD10 VISIBLE NONE;CLASSFP10 CLASSFP10 VISIBLE NONE;PCICBSA10 PCICBSA10 VISIBLE NONE;PCINECTA10 PCINECTA10 VISIBLE NONE;MTFCC10 MTFCC10 VISIBLE NONE;FUNCSTAT10 FUNCSTAT10 VISIBLE NONE;ALAND10 ALAND10 VISIBLE NONE;AWATER10 AWATER10 VISIBLE NONE;INTPTLAT10 INTPTLAT10 VISIBLE NONE;INTPTLON10 INTPTLON10 VISIBLE NONE" ) # Process: Feature To Line arcpy.FeatureToLine_management("tl_2010_06_place10_Layer", place_line_hold_shp, "", "ATTRIBUTES") # Process: Select Layer By Location arcpy.SelectLayerByLocation_management(ua_lehd_acs_1, "WITHIN_A_DISTANCE", place_line_hold_shp, "1 Miles", "NEW_SELECTION", "NOT_INVERT") # Process: Copy Features arcpy.CopyFeatures_management(ua_lehd_acs_1__2_, boundary_tracts_hold_shp, "", "0", "0", "0")
arcpy.AddField_management(ExtremePoints, "Del", "SHORT") ExtPts.ExtremePoints(ExtremePoints) Make = arcpy.MakeFeatureLayer_management(ExtremePoints, "%ScratchWorkspace%\\Make") Selection = arcpy.SelectLayerByAttribute_management(Make, "NEW_SELECTION", "\"Del\" = 1") arcpy.DeleteFeatures_management(Selection) #/splitting of the polygon with extreme points ncurrentstep += 1 arcpy.AddMessage("Converting the input polygon to line - Step " + str(ncurrentstep) + "/" + str(nstep)) PolyToLine = arcpy.FeatureToLine_management(Polygon, "%ScratchWorkspace%\\PolyToLine", "", "ATTRIBUTES") ncurrentstep += 1 arcpy.AddMessage( "Looking for the longer distance between extreme points and the polygon - Step " + str(ncurrentstep) + "/" + str(nstep)) NearTable = arcpy.GenerateNearTable_analysis(ExtremePoints, PolyToLine, "NearTable", "", "LOCATION", "NO_ANGLE") rows = arcpy.SearchCursor(NearTable) Counter = 0 for row in rows: if row.NEAR_DIST > Counter: Counter = row.NEAR_DIST Counter += 1
def dissolve_optimal_route_segments_feature_class_for_commodity_mapping( layer_name, sql_where_clause, the_scenario, logger): # Make a dissolved version of fc for mapping aggregate flows logger.info( "start: dissolve_optimal_route_segments_feature_class_for_commodity_mapping" ) scenario_gdb = the_scenario.main_gdb arcpy.env.workspace = scenario_gdb # Delete previous fcs if they exist for fc in [ "optimized_route_segments_dissolved_tmp", "optimized_route_segments_split_tmp", "optimized_route_segments_dissolved_tmp2", "optimized_route_segments_dissolved_tmp2", "dissolved_segments_lyr", "optimized_route_segments_dissolved_commodity", "optimized_route_segments_dissolved_" + layer_name ]: if arcpy.Exists(fc): arcpy.Delete_management(fc) arcpy.MakeFeatureLayer_management("optimized_route_segments", "optimized_route_segments_lyr") arcpy.SelectLayerByAttribute_management( in_layer_or_view="optimized_route_segments_lyr", selection_type="NEW_SELECTION", where_clause=sql_where_clause) # Dissolve arcpy.Dissolve_management( "optimized_route_segments_lyr", "optimized_route_segments_dissolved_tmp", ["NET_SOURCE_NAME", "NET_SOURCE_OID", "ARTIFICIAL"], [['COMMODITY_FLOW', 'SUM']], "SINGLE_PART", "DISSOLVE_LINES") # Second dissolve needed to accurately show aggregate pipeline flows arcpy.FeatureToLine_management("optimized_route_segments_dissolved_tmp", "optimized_route_segments_split_tmp") arcpy.AddGeometryAttributes_management( "optimized_route_segments_split_tmp", "LINE_START_MID_END") arcpy.Dissolve_management( "optimized_route_segments_split_tmp", "optimized_route_segments_dissolved_tmp2", ["NET_SOURCE_NAME", "Shape_Length", "MID_X", "MID_Y", "ARTIFICIAL"], [["SUM_COMMODITY_FLOW", "SUM"]], "SINGLE_PART", "DISSOLVE_LINES") arcpy.AddField_management( in_table="optimized_route_segments_dissolved_tmp2", field_name="SUM_COMMODITY_FLOW", field_type="DOUBLE", field_precision="", field_scale="", field_length="", field_alias="", field_is_nullable="NULLABLE", field_is_required="NON_REQUIRED", field_domain="") arcpy.CalculateField_management( in_table="optimized_route_segments_dissolved_tmp2", field="SUM_COMMODITY_FLOW", expression="!SUM_SUM_COMMODITY_FLOW!", expression_type="PYTHON_9.3", code_block="") arcpy.DeleteField_management( in_table="optimized_route_segments_dissolved_tmp2", drop_field="SUM_SUM_COMMODITY_FLOW") arcpy.DeleteField_management( in_table="optimized_route_segments_dissolved_tmp2", drop_field="MID_X") arcpy.DeleteField_management( in_table="optimized_route_segments_dissolved_tmp2", drop_field="MID_Y") # Sort for mapping order arcpy.AddField_management( in_table="optimized_route_segments_dissolved_tmp2", field_name="SORT_FIELD", field_type="SHORT") arcpy.MakeFeatureLayer_management( "optimized_route_segments_dissolved_tmp2", "dissolved_segments_lyr") arcpy.SelectLayerByAttribute_management( in_layer_or_view="dissolved_segments_lyr", selection_type="NEW_SELECTION", where_clause="NET_SOURCE_NAME = 'road'") arcpy.CalculateField_management(in_table="dissolved_segments_lyr", field="SORT_FIELD", expression=1, expression_type="PYTHON_9.3") arcpy.SelectLayerByAttribute_management( in_layer_or_view="dissolved_segments_lyr", selection_type="NEW_SELECTION", where_clause="NET_SOURCE_NAME = 'rail'") arcpy.CalculateField_management(in_table="dissolved_segments_lyr", field="SORT_FIELD", expression=2, expression_type="PYTHON_9.3") arcpy.SelectLayerByAttribute_management( in_layer_or_view="dissolved_segments_lyr", selection_type="NEW_SELECTION", where_clause="NET_SOURCE_NAME = 'water'") arcpy.CalculateField_management(in_table="dissolved_segments_lyr", field="SORT_FIELD", expression=3, expression_type="PYTHON_9.3") arcpy.SelectLayerByAttribute_management( in_layer_or_view="dissolved_segments_lyr", selection_type="NEW_SELECTION", where_clause="NET_SOURCE_NAME LIKE 'pipeline%'") arcpy.CalculateField_management(in_table="dissolved_segments_lyr", field="SORT_FIELD", expression=4, expression_type="PYTHON_9.3") arcpy.Sort_management("optimized_route_segments_dissolved_tmp2", "optimized_route_segments_dissolved_commodity", [["SORT_FIELD", "ASCENDING"]]) # Delete temp fc's arcpy.Delete_management("optimized_route_segments_dissolved_tmp") arcpy.Delete_management("optimized_route_segments_split_tmp") arcpy.Delete_management("optimized_route_segments_dissolved_tmp2") arcpy.Delete_management("optimized_route_segments_lyr") arcpy.Delete_management("dissolved_segments_lyr") # Copy to permanent fc (unique to commodity name) arcpy.CopyFeatures_management( "optimized_route_segments_dissolved_commodity", "optimized_route_segments_dissolved_" + layer_name)
def appendedNetwork(networkBike, networkFoot, outData): if arcpy.Exists(outData): arcpy.Delete_management(outData) arcpy.FeatureToLine_management([networkBike, networkFoot], outData, "", "ATTRIBUTES")
'Right Street ID' <None> VISIBLE NONE;'Display X' <None> VISIBLE NONE;'Display Y' <None> VISIBLE NONE;'Min X value for extent' <None> VISIBLE NONE; 'Max X value for extent' <None> VISIBLE NONE;'Min Y value for extent' <None> VISIBLE NONE;'Max Y value for extent' <None> VISIBLE NONE;'Left parity' <None> VISIBLE NONE; 'Right parity' <None> VISIBLE NONE;'Left Additional Field' <None> VISIBLE NONE;'Right Additional Field' <None> VISIBLE NONE;'Altname JoinID' <None> VISIBLE NONE;''' add_locator = dir_path + name + "_addloc_2" #'Add_30_2nd' originates from 'Create 1930 and 1940 Address Files_2nd.R' code addresses = dir_path + "Add_30_2nd.csv" address_fields = "Street address;City city;State state" points30 = dir_path + name + "_Points30_2.shp" pblk_points = dir_path + name + "_1930_Pblk_Points_2.shp" print "Working On: " + name + " Creating Physical Blocks" ##### #Create Physical Blocks# ##### #First Dissolve St_Grid lines arcpy.Dissolve_management(grid, dissolve_grid, "FULLNAME") #Second Split Lines at Intersections arcpy.FeatureToLine_management(dissolve_grid, split_grid) #Third Create Physical Blocks using Feature to Polygon arcpy.FeatureToPolygon_management(split_grid, pblocks) #Finally Add a Physical Block ID expression = "!FID! + 1" arcpy.AddField_management(pblocks, "pblk_id", "LONG", 4, "", "", "", "", "") arcpy.CalculateField_management(pblocks, "pblk_id", expression, "PYTHON_9.3") print "Working On: " + name + " Geocode" ##### #Geocode Points# ##### #Create Address Locator arcpy.CreateAddressLocator_geocoding("US Address - Dual Ranges", reference_data, in_field_map, add_locator, "") #Geocode Points arcpy.GeocodeAddresses_geocoding(addresses, add_locator, address_fields,