def createMZ_Route(inCurvesRemovedPath, outFeatureClass, surfaceForZ, routeIdField): """Input the shapefile with curves removed, calc Z values and create the routes with temp M values that will be overridden""" extStatus = arcpy.CheckOutExtension("3D") arcpy.AddMessage("3D analyst: " + str(extStatus)) outPolyLineZ = outFeatureClass + "LineZ" tempOutsList.append(outPolyLineZ) outRouteMZ = outFeatureClass rtPartNumField = "PrtNum" rtPartCalcExp = "!" + routeIdField + "![-1:]" arcpy.InterpolateShape_3d(surfaceForZ, inCurvesRemovedPath, outPolyLineZ, '', 1, '', True) arcpy.AddMessage(arcpy.GetMessages()) arcpy.CreateRoutes_lr(outPolyLineZ, routeIdField, outRouteMZ) arcpy.AddMessage(arcpy.GetMessages()) arcpy.AddField_management(outRouteMZ, rtPartNumField, "SHORT") arcpy.CalculateField_management(outRouteMZ, rtPartNumField, rtPartCalcExp, "PYTHON_9.3") arcpy.AddMessage( "Routes with Z values and M place holders have been created") extStatus = arcpy.CheckInExtension("3D") arcpy.AddMessage("3D analyst: " + str(extStatus)) return [outRouteMZ, rtPartNumField]
def convert_routes_to_lr(routes_fc, routes_id_field, out_fc): arcpy.CreateRoutes_lr(in_line_features=routes_fc, route_id_field=routes_id_field, out_feature_class=out_fc, measure_source="LENGTH", from_measure_field="", to_measure_field="", coordinate_priority="UPPER_LEFT", measure_factor="1", measure_offset="0", ignore_gaps="IGNORE", build_index="INDEX") return out_fc
def addReachDist(given_stream): """ Calculates the ReachDist attribute using StreamID :param given_stream: :return: """ print "Adding Reach Distance Attribute..." fields = [f.name for f in arcpy.ListFields(given_stream)] if 'ReachID' not in fields: arcpy.AddField_management(given_stream, "ReachID", "LONG") with arcpy.da.UpdateCursor(given_stream, ['FID', 'ReachID']) as cursor: for row in cursor: row[1] = row[0] cursor.updateRow(row) # get distance along route (LineID) for segment midpoints midpoints = arcpy.FeatureVerticesToPoints_management(given_stream, 'in_memory/midpoints', "MID") seg_network_dissolve = arcpy.Dissolve_management(given_stream, 'in_memory/seg_network_dissolve', 'StreamID', '', 'SINGLE_PART', 'UNSPLIT_LINES') arcpy.AddField_management(seg_network_dissolve, 'From_', 'DOUBLE') arcpy.AddField_management(seg_network_dissolve, 'To_', 'DOUBLE') with arcpy.da.UpdateCursor(seg_network_dissolve, ['SHAPE@Length', 'From_', 'To_']) as cursor: for row in cursor: row[1] = 0.0 row[2] = row[0] cursor.updateRow(row) arcpy.CreateRoutes_lr(seg_network_dissolve, 'StreamID', 'in_memory/flowline_route', 'TWO_FIELDS', 'From_', 'To_') routeTbl = arcpy.LocateFeaturesAlongRoutes_lr(midpoints, 'in_memory/flowline_route', 'StreamID', 1.0, os.path.join(os.path.dirname(given_stream), 'tbl_Routes.dbf'), 'RID POINT MEAS') distDict = {} # add reach id distance values to dictionary with arcpy.da.SearchCursor(routeTbl, ['ReachID', 'MEAS']) as cursor: for row in cursor: distDict[row[0]] = row[1] # populate dictionary value to output field by ReachID arcpy.AddField_management(given_stream, 'ReachDist', 'DOUBLE') with arcpy.da.UpdateCursor(given_stream, ['ReachID', 'ReachDist']) as cursor: for row in cursor: aKey = row[0] row[1] = distDict[aKey] cursor.updateRow(row) arcpy.Delete_management('in_memory')
def editMileage(): ''' 定义一个计算设备设施表里程的函数; 计算之前确保管段表中起点里程和终点里程已经正确填写; 基本思路: 首先利用创建路径工具构建库中所有管线的路径 然后将设备设施的路径通过定位要素工具计算出其里程(或起点里程和终点里程) 最后将里程值写入每一个要素的对应里程字段中 三通表计算完的里程需要检验(特别是对于管段编码号较大但里程值为0的或者管段编码值较小但里程值较大的情况需要重点检查), ''' #利用管段起点里程和终点里程字段创建管线的路径 arcpy.CreateRoutes_lr("T_PN_PIPESEGMENT_GEO","PLCODE","routes", "TWO_FIELDS", "MSTART","MEND") #获取管线地理要素集中的所有要素类 featureClassList=arcpy.ListFeatureClasses("","","PIPEGEO") for FC in featureClassList: if FC!="T_PN_THREEORFOUR_GEO": try: #对所有不为空的点状要素进行里程计算 if arcpy.Describe(FC).shapeType=="Point" and\ int(arcpy.GetCount_management(FC).getOutput(0))!=0: #获取输入要素的所有字段名称 fieldList=[] fieldNameList=[] fieldList=arcpy.ListFields(FC) #获取表中字段列表 for FL in fieldList: #获取每一个表的所有字段名称 fieldNameList.append(FL.name) if "MILEAGE" in fieldNameList: #添加一个字段用于复制要素的OBJECTID arcpy.AddField_management(FC,"OBJECTIDCOPY","TEXT") # 将目标表中的OBJECTID字段计算到设备编号中 arcpy.CalculateField_management(FC,"OBJECTIDCOPY","!OBJECTID!","PYTHON") #计算目标要素表的里程数据 arcpy.LocateFeaturesAlongRoutes_lr(FC,"routes","PLCODE","0.01 Kilometers","out") #利用属性连接将输出含有里程数据的表与目标要素表连接 arcpy.JoinField_management(FC,"OBJECTIDCOPY","out","OBJECTIDCOPY","MEAS") # 将属性连接后的字段计算成要素的管段编码 arcpy.CalculateField_management(FC,"MILEAGE","!MEAS!","PYTHON") # 删除连接时多出的临时字段 arcpy.DeleteField_management(FC,["MEAS","OBJECTIDCOPY"]) # 删除中间文件 arcpy.Delete_management("out") except Exception,e: print featureClassCodeDictionary[feature],"编辑里程时出错,错误信息:",e.message pass continue
def measureLines(inLayer, idField, Mlines, lengthVar, fromFld, toFld, cp): #measures the lines in Zlines and creates a new featureclass that is #M and Z aware try: arcpy.AddMessage('Measuring the length of the line(s) in ' + inLayer) arcpy.CreateRoutes_lr(inLayer, idField, Mlines, lengthVar, fromFld, toFld, cp) except: tb = sys.exc_info()[2] tbinfo = traceback.format_tb(tb)[0] pymsg = tbinfo + '\n' + str(sys.exc_type) + ': ' + str(sys.exc_value) arcpy.AddError(pymsg) raise SystemError finally: arcpy.AddMessage(Mlines + ' written to ' + arcpy.env.scratchWorkspace)
def create_linear_reference(): arcpy.AddField_management(OutputBrautTemp, "start", "FLOAT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(OutputBrautTemp, "end", "FLOAT", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(OutputBrautTemp, "start", "0", "PYTHON_9.3") arcpy.AddMessage( "Done adding and populating fields START and END to braut_temp feature class" ) arcpy.CalculateField_management(OutputBrautTemp, "end", "!shape.length@meters!", "PYTHON_9.3") arcpy.env.MTolerance = "0.001" # set tolerance for M coordinate arcpy.CreateRoutes_lr(OutputBrautTemp, "BRAUT", OutputBraut2dnafn, "TWO_FIELDS", "start", "end", "UPPER_LEFT", "1", "0", "IGNORE", "INDEX")
def generate_3d_features(): number_of_features = str(arcpy.GetCount_management(InputFeatureClass)) arcpy.AddMessage(number_of_features + " segments found") arcpy.InterpolateShape_3d(InputDEM, InputFeatureClass, OutputBraut3d) # convert 2D to 3D arcpy.AddMessage("Feature class braut3d created") arcpy.CalculateField_management(OutputBraut3d, "ID", "!OBJECTID!", "PYTHON_9.3") # populate fields arcpy.CalculateField_management(OutputBraut3d, "start", "0", "PYTHON_9.3") arcpy.CalculateField_management(OutputBraut3d, "end", "!shape.length@meters!", "PYTHON_9.3") arcpy.AddMessage("Fields ID, START and END populated") arcpy.env.MTolerance = "0.001" # set tolerance for M coordinate arcpy.CreateRoutes_lr(OutputBraut3d, "ID", OutputBraut3did, "TWO_FIELDS", "start", "end", "UPPER_LEFT", "1", "0", "IGNORE", "INDEX") arcpy.AddMessage("Feature class braut3did created")
@author: kyleg ''' import arcpy #export working railroad files to shapefiles # 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: "ActiveLines2013" arcpy.CalculateField_management("ActiveLines2013", "LRSKEY", """[RAILROAD] &"_" & [SUBDIVISIO]""", "VB", "#") # 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: "ActiveLines2013" arcpy.CreateRoutes_lr( "ActiveLines2013", "LRSKEY", "//gisdata/arcgis/GISdata/KDOT/BTP/Projects/RAIL/R1.shp", "ONE_FIELD", "LENGTHMILE", "#", "UPPER_RIGHT", "1", "0", "IGNORE", "INDEX") # 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: "ActiveStations", "R1" arcpy.LocateFeaturesAlongRoutes_lr( "ActiveStations", "R1", "LRSKEY", "1 Miles", "//gisdata/arcgis/gisdata/kdot/btp/projects/rail/stationlraf", "LRSKEY POINT MEAS", "FIRST", "DISTANCE", "ZERO", "FIELDS", "M_DIRECTON") #Make Route event layer # 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: "ActiveLines2013", "ActiveStationsSnap" arcpy.SplitLineAtPoint_management( "ActiveLines2013", "ActiveStationsSnap",
in_layer = arcpy.GetParameterAsText(0) #route_name = arcpy.GetParameterAsText(1) homeDir = path.dirname(in_layer) # GDB FC input if not homeDir: homeDir = env.workspace # Map Layer input diveDir = 'C:\\CurrentProjects\\Hump18HI\\GIS\\2018HI Hump_DivesV2.gdb' in_name = path.basename(in_layer) route_name = diveDir + '\\Routes\\rt_' + in_name[3:] try: # create route in gdb arcpy.CreateRoutes_lr(in_layer, "ptt", route_name, "TWO_FIELDS", "FromLoc", "ToLoc") # "TWO_FIELDS", "FromLocation", "ToLocation") # gather data from track sql_clause = (None, 'ORDER BY "FromLoc" ASC') #sql_clause = (None, 'ORDER BY "FromLocation" ASC') # fields = ("FromLocation", "ToLocation", "ptt", "SHAPE@XY", "OBJECTID") fields = ("FromLoc", "ToLoc", "ptt", "SHAPE@XY", "OBJECTID") with arcpy.da.SearchCursor(in_layer, fields, None, sr, None, sql_clause) as sCur: row = sCur.next() # get begin & end dates startLoc = row[0] ptt = row[2] locs = [[row[4] - 1, row[3]]] # [OID,(Lon,Lat)] for row in sCur:
def SLEM(Line, Distance, Output, TempFolder, TF): CopyLine = arcpy.CopyFeatures_management(Line, "%ScratchWorkspace%\CopyLine") fieldnames = [f.name for f in arcpy.ListFields(CopyLine)] #/identification of the polyline type : raw, UGOs, sequenced UGOs, or AGOs k = 0 if "Rank_AGO" in fieldnames: k = 3 elif "Order_ID" in fieldnames: k = 2 elif "Rank_UGO" in fieldnames: k = 1 arcpy.AddMessage(k) ################################ ########## Raw polyline ######## ################################ if k == 0: #/shaping of the segmented result arcpy.AddField_management(CopyLine, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "Rank_UGO", "[" + fieldnames[0] + "]", "VB", "") arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "VB", "") arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "") #/conversion in routes LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure") #/creation of the event table PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "") arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") UPD_SL.UpToDateShapeLengthField(LineRoutes) rowslines = arcpy.SearchCursor(LineRoutes) rowsevents = arcpy.InsertCursor(PointEventTEMP) for line in rowslines: tempdistance = float(0) while (tempdistance < float(line.Shape_Length)): row = rowsevents.newRow() row.Rank_UGO = line.Rank_UGO row.To_M = tempdistance + float(Distance) row.Distance = tempdistance rowsevents.insertRow(row) tempdistance = tempdistance + float(Distance) del rowslines del rowsevents #/creation of the route event layer MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr( LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP") Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0") Sort = arcpy.Sort_management( Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.DeleteField_management(Sort, "To_M") #/calculation of the "Distance" field UPD_SL.UpToDateShapeLengthField(Sort) rows1 = arcpy.UpdateCursor(Sort) rows2 = arcpy.UpdateCursor(Sort) line2 = rows2.next() line2.Distance = 0 rows2.updateRow(line2) nrows = int(str(arcpy.GetCount_management(Sort))) n = 0 for line1 in rows1: line2 = rows2.next() if n == nrows - 1: break if n == 0: line1.Distance = 0 if line2.Rank_UGO == line1.Rank_UGO: line2.Distance = line1.Distance + line1.Shape_Length rows2.updateRow(line2) if line2.Rank_UGO != line1.Rank_UGO: line2.Distance = 0 rows2.updateRow(line2) n += 1 #/deleting of the temporary files if str(TF) == "true": arcpy.Delete_management(Split) arcpy.Delete_management(CopyLine) arcpy.Delete_management(LineRoutes) arcpy.Delete_management(PointEventTEMP) ################## ###### UGO ####### ################## if k == 1: #/shaping of the segmented result arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "VB", "") arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "") #/conversion in routes LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure") #/creation of the event table PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "") arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") UPD_SL.UpToDateShapeLengthField(LineRoutes) rowslines = arcpy.SearchCursor(LineRoutes) rowsevents = arcpy.InsertCursor(PointEventTEMP) for line in rowslines: tempdistance = float(0) while (tempdistance < float(line.Shape_Length)): row = rowsevents.newRow() row.Rank_UGO = line.Rank_UGO row.To_M = tempdistance + float(Distance) row.Distance = tempdistance rowsevents.insertRow(row) tempdistance = tempdistance + float(Distance) del rowslines del rowsevents #/creation of the route event layer MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr( LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP") Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0") Sort = arcpy.Sort_management( Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.DeleteField_management(Sort, "To_M") #/calculation of the "Distance" field UPD_SL.UpToDateShapeLengthField(Sort) rows1 = arcpy.UpdateCursor(Sort) rows2 = arcpy.UpdateCursor(Sort) line2 = rows2.next() line2.Distance = 0 rows2.updateRow(line2) nrows = int(str(arcpy.GetCount_management(Sort))) n = 0 for line1 in rows1: line2 = rows2.next() if n == nrows - 1: break if n == 0: line1.Distance = 0 if line2.Rank_UGO == line1.Rank_UGO: line2.Distance = line1.Distance + line1.Shape_Length rows2.updateRow(line2) if line2.Rank_UGO != line1.Rank_UGO: line2.Distance = 0 rows2.updateRow(line2) n += 1 #/deleting of the temporary files if str(TF) == "true": arcpy.Delete_management(Split) arcpy.Delete_management(CopyLine) arcpy.Delete_management(LineRoutes) arcpy.Delete_management(PointEventTEMP) ################################ ######### Sequenced UGO ######## ################################ if k == 2: #/shaping of the segmented result arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "VB", "") arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "To_Measure", "!Shape_Length!", "PYTHON_9.3", "") #/conversion in routes LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure") arcpy.AddField_management(LineRoutes, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") Sort = arcpy.Sort_management(Line, "%ScratchWorkspace%\\Sort", [["Rank_UGO", "ASCENDING"]]) rows1 = arcpy.UpdateCursor(LineRoutes) rows2 = arcpy.SearchCursor(Sort) for line1 in rows1: line2 = rows2.next() line1.Order_ID = line2.Order_ID rows1.updateRow(line1) #/creation of the event table PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "") arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") UPD_SL.UpToDateShapeLengthField(LineRoutes) rowslines = arcpy.SearchCursor(LineRoutes) rowsevents = arcpy.InsertCursor(PointEventTEMP) for line in rowslines: tempdistance = float(0) while (tempdistance < float(line.Shape_Length)): row = rowsevents.newRow() row.To_M = tempdistance + float(Distance) row.Order_ID = line.Order_ID row.Rank_UGO = line.Rank_UGO row.Distance = tempdistance rowsevents.insertRow(row) tempdistance = tempdistance + float(Distance) del rowslines del rowsevents MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr( LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP") Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0") Sort = arcpy.Sort_management( Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.DeleteField_management(Sort, "To_M") #/calculation of the "Distance" field UPD_SL.UpToDateShapeLengthField(Sort) rows1 = arcpy.UpdateCursor(Sort) rows2 = arcpy.UpdateCursor(Sort) line2 = rows2.next() line2.Distance = 0 rows2.updateRow(line2) nrows = int(str(arcpy.GetCount_management(Split))) n = 0 for line1 in rows1: line2 = rows2.next() if n >= nrows - 1: break if n == 0: line1.Distance = 0 if line2.Rank_UGO == line1.Rank_UGO: line2.Distance = line1.Distance + line1.Shape_Length rows2.updateRow(line2) if line2.Rank_UGO != line1.Rank_UGO: line2.Distance = 0 rows2.updateRow(line2) n += 1 #/deleting of the temporary files if str(TF) == "true": arcpy.Delete_management(Split) arcpy.Delete_management(CopyLine) arcpy.Delete_management(LineRoutes) arcpy.Delete_management(PointEventTEMP) ############# #### AGO #### ############# if k == 3: #/shaping of the segmented result arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "VB", "") arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") try: arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "") except: arcpy.CalculateField_management(CopyLine, "To_Measure", "!forme.length!", "PYTHON_9.3", "") #/conversion in routes LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_AGO", "%ScratchWorkspace%\\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure") arcpy.AddField_management(LineRoutes, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(LineRoutes, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(LineRoutes, "AGO_Val", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") UPD_SL.UpToDateShapeLengthField(LineRoutes) Ext.Export(CopyLine, TempFolder, "ExportTable") fichier = open(TempFolder + "\\ExportTable.txt", 'r') Order_ID = [] Rank_UGO = [] Dist = [] Rank_AGO = [] AGO_Val = [] head = fichier.readline().split('\n')[0].split(';') iOrder_ID = head.index("Order_ID") iRank_UGO = head.index("Rank_UGO") iRank_AGO = head.index("Rank_AGO") iAGO_Val = head.index("AGO_Val") for l in fichier: Order_ID.append(int(l.split('\n')[0].split(';')[iOrder_ID])) Rank_UGO.append(int(l.split('\n')[0].split(';')[iRank_UGO])) Rank_AGO.append(float(l.split('\n')[0].split(';')[iRank_AGO])) AGO_Val.append( float(l.split('\n')[0].split(';')[iAGO_Val].replace(',', '.'))) p = 0 rows1 = arcpy.UpdateCursor(LineRoutes) for line1 in rows1: line1.Order_ID = Order_ID[p] line1.Rank_UGO = Rank_UGO[p] line1.Rank_AGO = Rank_AGO[p] line1.AGO_Val = AGO_Val[p] rows1.updateRow(line1) p += 1 #/creation of the event table PointEventTEMP = arcpy.CreateTable_management("%ScratchWorkspace%", "PointEventTEMP", "", "") arcpy.AddField_management(PointEventTEMP, "Distance_From_Start", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Order_ID", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Rank_AGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "AGO_Val", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") rowslines = arcpy.SearchCursor(LineRoutes) rowsevents = arcpy.InsertCursor(PointEventTEMP) for line in rowslines: tempdistance = float(0) while (tempdistance < float(line.Shape_Length)): row = rowsevents.newRow() row.Distance_From_Start = tempdistance row.To_M = tempdistance + float(Distance) row.Order_ID = line.Order_ID row.Rank_UGO = line.Rank_UGO row.Rank_AGO = line.Rank_AGO row.AGO_Val = line.AGO_Val rowsevents.insertRow(row) tempdistance = tempdistance + float(Distance) del rowslines del rowsevents MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr( LineRoutes, "Rank_AGO", PointEventTEMP, "Rank_AGO LINE Distance_From_Start To_M", "%ScratchWorkspace%\\MakeRouteEventTEMP") Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, "%ScratchWorkspace%\\Split", "", "0", "0", "0") arcpy.AddField_management(Split, "Distance", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(Split, "Distance", "!Distance_From_Start!", "PYTHON_9.3", "") arcpy.DeleteField_management(Split, ["To_M", "Distance_From_Start"]) Sort = arcpy.Sort_management( Split, Output, [["Order_ID", "ASCENDING"], ["Rank_UGO", "ASCENDING"], ["Rank_AGO", "ASCENDING"], ["Distance", "ASCENDING"]]) UPD_SL.UpToDateShapeLengthField(Sort) #/deleting of the temporary files if str(TF) == "true": arcpy.Delete_management(Split) arcpy.Delete_management(CopyLine) arcpy.Delete_management(LineRoutes) arcpy.Delete_management(PointEventTEMP) return Sort
SectionBendPoints = "C:\\PROJECTS\\UMAR\\Default.gdb\\SectionBendPoints" # Process: Densify arcpy.Densify_edit(SectionLine, "DISTANCE", Distance, "0.1 Meters", "10") # Process: Feature Vertices To Points (2) arcpy.FeatureVerticesToPoints_management(Output_Feature_Class__3_, Output_Feature_Class__6_, "ALL") # Process: Add Surface Information arcpy.AddSurfaceInformation_3d(Output_Feature_Class__6_, NED10m1, "Z", "BILINEAR", "", "1", "0", "NO_FILTER") # Process: Add XY Coordinates (2) arcpy.AddXY_management(SectionLine_FeatureVerticesT1) # Process: Create Routes arcpy.CreateRoutes_lr(SectionLine, Route_Identifier_Field__2_, SectionRoute, "LENGTH", "", "", "UPPER_LEFT", Measure_Factor, "0", "IGNORE", "INDEX") arcpy.CreateRoutes_lr(SectionLine, Route_Identifier_Field__2_, SectionRoute, "LENGTH", "", "", direction, Measure_Factor, "0", "IGNORE", "INDEX") # Process: Locate Features Along Routes arcpy.LocateFeaturesAlongRoutes_lr(SectionLine_FeatureVerticesT1__3_, SectionRoute, Route_Identifier_Field__2_, "0 Meters", ElevationPoints, Output_Event_Table_Properties, "FIRST", "DISTANCE", "ZERO", "FIELDS", "M_DIRECTON") # Process: Simplify Line arcpy.SimplifyLine_cartography(SectionLine, SectionLine_SimplifyLine, "POINT_REMOVE", "10 Meters", "FLAG_ERRORS", "NO_KEEP", "NO_CHECK") # Process: Feature Vertices To Points arcpy.FeatureVerticesToPoints_management(SectionLine_SimplifyLine, SectionLine_SimplifyLine_Fea, "ALL") # Process: Add Surface Information (2) arcpy.AddSurfaceInformation_3d(SectionLine_SimplifyLine_Fea, NED10m1, "Z", "BILINEAR", "", "1", "0", "NO_FILTER")
insertCursor.insertRow((row[0], int(row[4]))) currentStation = 0 while currentStation < row[2]: insertCursor.insertRow((row[0], currentStation * interval)) #AddMsgAndPrint("Added: ID: " + str(row[1]) + " -- " + str(currentStation*interval)) currentStation += 1 del insertCursor, currentStation # Create Route(s) lyr and define events along each route AddMsgAndPrint("\nCreating Stations") routes = arcpy.CreateScratchName("routes", data_type="FeatureClass", workspace="in_memory") arcpy.CreateRoutes_lr(lineTemp, "ID", routes, "TWO_FIELDS", "FROM_PT", "LENGTH_FT", "UPPER_LEFT", "1", "0", "IGNORE", "INDEX") stationEvents = arcpy.CreateScratchName("stationEvents", data_type="FeatureClass", workspace="in_memory") arcpy.MakeRouteEventLayer_lr(routes, "ID", stationTable, "ID POINT STATION", stationEvents, "", "NO_ERROR_FIELD", "NO_ANGLE_FIELD", "NORMAL", "ANGLE", "LEFT", "POINT") arcpy.AddField_management(stationEvents, "STATIONID", "TEXT", "", "", "25", "", "NULLABLE", "NON_REQUIRED") arcpy.CalculateField_management(stationEvents, "STATIONID", "str(!STATION!) + '_' + str(!ID!)", "PYTHON3")
desc = arcpy.Describe(lineLayer) idField = desc.OIDFieldName addAndCalc(lineLayer, 'ORIG_FID', '[' + idField + ']') #interpolate the line to add z values zLine = lineLayer + '_z' arcpy.AddMessage('Getting elevation values for the cross-section in ' + lineLayer) arcpy.InterpolateShape_3d(dem, lineLayer, zLine) arcpy.AddMessage(' ' + zLine + ' written to ' + arcpy.env.scratchWorkspace) #measure it and turn it into a route zmLine = lineLayer + '_zm' arcpy.AddMessage('Measuring the length of ' + zLine) arcpy.CreateRoutes_lr(zLine, 'ORIG_FID', zmLine, 'LENGTH', '#', '#', cp) arcpy.AddMessage(' ' + zmLine + ' written to ' + arcpy.env.scratchWorkspace) #figure out where the collar elevation is coming from, a user specified field or to be #calculated by interpolation from the DEM and stored in 'zDEM' if not bhzField == '': zField = bhzField zBoreholes = bhLayer else: #interpolate Z values for the boreholes # first, select the borehole location points based on the buffer distance #to minimize the processing time arcpy.SelectLayerByLocation_management(bhLayer, 'WITHIN_A_DISTANCE', zmLine, buff) zBoreholes = outName + '_zBoreholes'
def arcpy_create_routes_linear_refernancing_from(self, arg_input_path, route_id_field="ROAD", start_column="START_TRUE_DIST", end_column="END_TRUE_DIST"): arg_input_path = Path(arg_input_path) thou_shalt("Create Linear Referanceable Layer {} from {}".format(self.shortened_name_with_context(), arg_input_path.shortened_name_with_context()), lambda: arcpy.CreateRoutes_lr(str(arg_input_path), route_id_field, str(self), "TWO_FIELDS", start_column, end_column) ) return self
f = open(outlog_path + str(location) + '_transect_analysis_log.txt','w') f.write('Site: ' + str(location) + '\n') f.write('site | year | transect | distance\n') #Check to see if the output table already exists (delete it, if it does) if arcpy.Exists(out_table): arcpy.Delete_management(out_table) create_out_table(path, location) # Transects for each individual research site transects = path + str(location) + '_transects' # Convert starting points of transects to point feature class if arcpy.Exists(temproute): arcpy.Delete_management(temproute) arcpy.CreateRoutes_lr(transects, "TRANSECT_ID", temproute, "LENGTH", coordinate_priority=alcona_dir) # List of years in site to analyze from #years = alcona_years # Loop through all the years for any given site for year in years: toshore = path + location + '_shoreline_' + str(year) if arcpy.Exists(toshore): print str(location) + ' - ' + str(year) # Create search cursor to insert new data into the table ins_cur = arcpy.InsertCursor(out_table) # Convert shoreline verticies to points to calculate minimum and mean distances
def line_route_points(output_workspace, line, station_distance, route_id_field, fields): """ Converts an input line feature class into a route, densifies its vertices, and ctreates a point feature class in the output_workspace. Writes all outputs to the specified output_workspace. Args: output_workspace -- Path to the output workspace. line -- Path to a line feature class station_distance -- (numeric) Distance between output line station points (in the linear units of the line feature class) route_id_field -- (string) of the field name of the route identifier fields -- (string) a list of fields from the line feature class to join to the output line_points feature class (e.g., ["bank","ReachName"]). Outputs: <line>_points -- a point feature class named the same as the line input feature class written to the output_workspace """ # Set line name line_name = arcpy.Describe(line).baseName # Add a field to hold the linear referencing route `from_measure` # Check if the field already exists and if not add it field_names = [f.name for f in arcpy.ListFields(line)] if "from_measure" not in field_names: arcpy.AddField_management(in_table=line, field_name="from_measure", field_type="DOUBLE") # Set the value of the line `from_measure` to zero in units meters arcpy.CalculateField_management(in_table=line, field="from_measure", expression="0", expression_type="PYTHON_9.3") # Add a field to hold the linear referencing route `to_measure` if "to_measure" not in field_names: arcpy.AddField_management(in_table=line, field_name="to_measure", field_type="DOUBLE") # Set the value of the line `to_measure` to the length of the # line in units meters arcpy.CalculateField_management(in_table=line, field="to_measure", expression="!shape.length@meters!", expression_type="PYTHON_9.3") arcpy.AddMessage("Added route 'from_measure' and 'to_measure' fields to " + str(line_name)) # Densify vertices of the line feature class using the Densify tool. line_densify_name = line_name + "_densify" line_densify = os.path.join(output_workspace, line_densify_name) arcpy.CopyFeatures_management(in_features=line, out_feature_class=line_densify) arcpy.Densify_edit(in_features=line_densify, densification_method="DISTANCE", distance=station_distance) # Convert the line feature class to a route line_densify_route_name = line_name + "_densify_route" line_densify_route = os.path.join(output_workspace, line_densify_route_name) arcpy.CreateRoutes_lr(in_line_features=line_densify, route_id_field=route_id_field, out_feature_class=line_densify_route, measure_source="TWO_FIELDS", from_measure_field="from_measure", to_measure_field="to_measure") arcpy.AddMessage("Converted " + str(line_name) + " to a route") # Convert line feature vertices to points line_points_name = line_name + "_points" line_points = os.path.join(output_workspace, line_points_name) arcpy.FeatureVerticesToPoints_management(in_features=line_densify_route, out_feature_class=line_points) arcpy.AddMessage("Converted " + str(line_name) + " to points") # Add x, y, z, and m values to the `line_points` feature class arcpy.AddGeometryAttributes_management(Input_Features=line_points, Geometry_Properties="POINT_X_Y_Z_M", Length_Unit="METERS") # Set the first m-value for each line to zero. The `create route` # tool sets the first record to NULL. mNull_wc = """{0} IS NULL""".format( arcpy.AddFieldDelimiters(line_points, "POINT_M")) with arcpy.da.UpdateCursor(line_points, "POINT_M", where_clause=mNull_wc) as cursor: for row in cursor: row[0] = 0 cursor.updateRow(row) # Delete un-needed fields arcpy.DeleteField_management(in_table=line_points, drop_field=["ORIG_FID", "POINT_Z"]) # Join fields from the `line` to the `line_points` feature class arcpy.JoinField_management(in_data=line_points, in_field=route_id_field, join_table=line, join_field=route_id_field, fields=fields) arcpy.AddMessage("Joined fields from " + str(line_name)) # Cleanup arcpy.Delete_management(in_data=line_densify) arcpy.Delete_management(in_data=line_densify_route) arcpy.AddMessage("Converted " + str(line_name) + " to points") # Return the path to the feature class return line_points
def XSCreateStationPoints(output_workspace, cross_section, dem, dem_units, detrend_dem, station_distance): # Check out the extension licenses arcpy.CheckOutExtension("3D") # Set environment variables arcpy.env.overwriteOutput = True arcpy.env.workspace = output_workspace # List parameter values arcpy.AddMessage("Workspace: {}".format(arcpy.env.workspace)) arcpy.AddMessage("Cross Section: " "{}".format(arcpy.Describe(cross_section).baseName)) arcpy.AddMessage("DEM: {}".format(arcpy.Describe(dem).baseName)) arcpy.AddMessage("DEM vertical units: {}".format(dem_units)) if detrend_dem is True: arcpy.AddMessage("Detrended DEM: " "{}".format(arcpy.Describe(detrend_dem).baseName)) arcpy.AddMessage("Station distance: {0}".format(str(station_distance))) # Set cross_section name xs_name = arcpy.Describe(cross_section).baseName # Add a field to hold the linear referencing route `from_measure` # Check if the field already exists and if not add it field_names = [f.name for f in arcpy.ListFields(cross_section)] if "from_measure" not in field_names: arcpy.AddField_management(in_table=cross_section, field_name="from_measure", field_type="DOUBLE") # Set the value of the cross section `from_measure` to zero in units meters arcpy.CalculateField_management(in_table=cross_section, field="from_measure", expression="0", expression_type="PYTHON_9.3") # Add a field to hold the linear referencing route `to_measure` if "to_measure" not in field_names: arcpy.AddField_management(in_table=cross_section, field_name="to_measure", field_type="DOUBLE") # Set value of xs `to_measure` to length of xs in units meters arcpy.CalculateField_management(in_table=cross_section, field="to_measure", expression="!shape.length@meters!", expression_type="PYTHON_9.3") # Densify vertices of the cross_section fc arcpy.AddMessage("Densifying cross section vertices...") xs_densify = os.path.join(output_workspace, xs_name + "_densify") arcpy.CopyFeatures_management(in_features=cross_section, out_feature_class=xs_densify) arcpy.Densify_edit(in_features=xs_densify, densification_method="DISTANCE", distance=station_distance) # Convert the cross_section fc to a route arcpy.AddMessage("Creating cross section routes...") xs_densify_route = os.path.join(output_workspace, xs_name + "_densify_route") arcpy.CreateRoutes_lr(in_line_features=xs_densify, route_id_field="Seq", out_feature_class=xs_densify_route, measure_source="TWO_FIELDS", from_measure_field="from_measure", to_measure_field="to_measure") # Convert cross section feature vertices to points arcpy.AddMessage("Converting cross section vertices to points...") xs_points = os.path.join(output_workspace, xs_name + "_points") arcpy.FeatureVerticesToPoints_management(in_features=xs_densify_route, out_feature_class=xs_points) # Add x, y, z, and m values to the `cross_section_points` feature class arcpy.AddGeometryAttributes_management(Input_Features=xs_points, Geometry_Properties="POINT_X_Y_Z_M", Length_Unit="METERS") # Set the first m-value for each xs to zero (because the `create route` # tool sets it to NULL). arcpy.AddMessage("Setting XS NULL m-values to zero...") arcpy.CalculateField_management(in_table=xs_points, field="POINT_M", expression="setNull2Zero(!POINT_M!)", code_block="""def setNull2Zero(m): if m is None: return 0 else: return m""", expression_type="PYTHON_9.3") # Delete un-needed fields arcpy.DeleteField_management(in_table=xs_points, drop_field=["ORIG_FID", "POINT_Z"]) # Add a field to hold the linear referencing `route_units` arcpy.AddField_management(in_table=xs_points, field_name="POINT_M_units", field_type="TEXT") # Set the `route_units` field to "meter" arcpy.CalculateField_management(in_table=xs_points, field="POINT_M_units", expression="'m'", expression_type="PYTHON_9.3") # Join fields from the `cross_section` fc to `cross_section_points` fc fields = ["ReachName", "Watershed_Area_SqMile", "km_to_mouth"] arcpy.JoinField_management(in_data=xs_points, in_field="Seq", join_table=cross_section, join_field="Seq", fields=fields) # Add elevations to the `cross_section_points` feature class arcpy.AddMessage("Adding DEM surface information...") ## DEM arcpy.AddMessage("DEM: {}".format(dem)) arcpy.AddSurfaceInformation_3d(in_feature_class=xs_points, in_surface=dem, out_property="Z", z_factor=1.0) ## Change `Z` field name to `DEM_Z` arcpy.AlterField_management(in_table=xs_points, field="Z", new_field_name="DEM_Z") ## Create and set the value of the dem_units field arcpy.AddField_management(in_table=xs_points, field_name="dem_units", field_type="TEXT") arcpy.CalculateField_management(in_table=xs_points, field="dem_units", expression="'{}'".format(dem_units), expression_type="PYTHON_9.3") ## Detrend if detrend_dem: arcpy.AddMessage("Detrend DEM: {}".format(detrend_dem)) ## Add detrended elevations to the `cross_section_points` feature class arcpy.AddSurfaceInformation_3d(in_feature_class=xs_points, in_surface=detrend_dem, out_property="Z", z_factor=1.0) ## Change `Z` field name to `Detrend_DEM_Z` arcpy.AlterField_management(in_table=xs_points, field="Z", new_field_name="Detrend_DEM_Z") # Return arcpy.SetParameter(6, xs_points) # Cleanup arcpy.Delete_management(in_data=xs_densify) arcpy.Delete_management(in_data=xs_densify_route) return
"Segmentation of the inFC according to the inflection points - Step " + str(ncurrentstep) + "/" + str(nstep)) CopyinFC = arcpy.CopyFeatures_management(inFC, "%ScratchWorkspace%\\CopyinFC") UPD_SL.UpToDateShapeLengthField(CopyinFC) arcpy.AddField_management(CopyinFC, "Start", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(CopyinFC, "End", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyinFC, "Start", "0", "PYTHON_9.3", "") arcpy.CalculateField_management(CopyinFC, "End", "!Shape_Length!", "PYTHON_9.3", "") Routes = arcpy.CreateRoutes_lr(CopyinFC, "Rank_UGO", "%ScratchWorkspace%\\Routes", "TWO_FIELDS", "Start", "End") UPD_SL.UpToDateShapeLengthField(Routes) LocateTABLE = arcpy.LocateFeaturesAlongRoutes_lr( InflectionPts, Routes, "Rank_UGO", "1", "%ScratchWorkspace%\\LocateTABLE", "RID POINT MEAS") arcpy.LocateFeaturesAlongRoutes_lr(InflectionPts, Routes, "Rank_UGO", "1", "%ScratchWorkspace%\\LocateTABLE1", "RID POINT MEAS") rows1 = arcpy.UpdateCursor(LocateTABLE) rows2 = arcpy.UpdateCursor(LocateTABLE) rows3 = arcpy.SearchCursor(Routes) line2 = next(rows2) nrows = int(str(arcpy.GetCount_management(LocateTABLE)))
def SLEM(Line, Distance, Output, TF): CopyLine = arcpy.CopyFeatures_management(Line, r"in_memory\CopyLine") fieldnames = [f.name for f in arcpy.ListFields(CopyLine)] #/identification of the polyline type : raw, UGOs, sequenced UGOs, or AGOs k = 0 if "Rank_AGO" in fieldnames : k = 3 elif "Order_ID" in fieldnames : k = 2 elif "Rank_UGO" in fieldnames : k = 1 ################################ ########## Raw polyline ######## ################################ if k == 0 : #/shaping of the segmented result arcpy.AddField_management(CopyLine, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "Rank_UGO", "!"+fieldnames[0]+"!", "PYTHON_9.3", "") arcpy.AddField_management(CopyLine, "From_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "From_Measure", "0", "PYTHON_9.3", "") arcpy.AddField_management(CopyLine, "To_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(CopyLine, "To_Measure", "!shape.length!", "PYTHON_9.3", "") #/conversion in routes LineRoutes = arcpy.CreateRoutes_lr(CopyLine, "Rank_UGO", r"in_memory\LineRoutes", "TWO_FIELDS", "From_Measure", "To_Measure") #/creation of the event table PointEventTEMP = arcpy.CreateTable_management("in_memory", "PointEventTEMP", "", "") arcpy.AddField_management(PointEventTEMP, "Rank_UGO", "LONG", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "Distance", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(PointEventTEMP, "To_M", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") UPD_SL.UpToDateShapeLengthField(LineRoutes) rowslines = arcpy.SearchCursor(LineRoutes) rowsevents = arcpy.InsertCursor(PointEventTEMP) for line in rowslines: tempdistance = float(line.Shape_Length) while (tempdistance > float(0)): row = rowsevents.newRow() row.Rank_UGO = line.Rank_UGO row.To_M = max(0, tempdistance - float(Distance)) row.Distance = tempdistance rowsevents.insertRow(row) tempdistance = tempdistance - float(Distance) del rowslines del rowsevents #/creation of the route event layer MakeRouteEventTEMP = arcpy.MakeRouteEventLayer_lr(LineRoutes, "Rank_UGO", PointEventTEMP, "Rank_UGO LINE Distance To_M", r"in_memory\MakeRouteEventTEMP") Split = arcpy.CopyFeatures_management(MakeRouteEventTEMP, r"in_memory\Split", "", "0", "0", "0") Sort = arcpy.Sort_management(Split, Output, [["Rank_UGO", "ASCENDING"], ["Distance", "ASCENDING"]]) arcpy.DeleteField_management(Sort, "To_M") #/calculation of the "Distance" field UPD_SL.UpToDateShapeLengthField(Sort) rows1 = arcpy.UpdateCursor(Sort) rows2 = arcpy.UpdateCursor(Sort) line2 = rows2.next() line2.Distance = 0 rows2.updateRow(line2) nrows = int(str(arcpy.GetCount_management(Sort))) n = 0 for line1 in rows1 : line2 = rows2.next() if n == nrows-1 : break if n == 0 : line1.Distance = 0 if line2.Rank_UGO == line1.Rank_UGO : line2.Distance = line1.Distance + line1.Shape_Length rows2.updateRow(line2) if line2.Rank_UGO != line1.Rank_UGO : line2.Distance = 0 rows2.updateRow(line2) n+=1 #/deleting of the temporary files if str(TF) == "true" : arcpy.Delete_management(Split) arcpy.Delete_management(CopyLine) arcpy.Delete_management(LineRoutes) arcpy.Delete_management(PointEventTEMP) return Sort
## raise SystemError #environment variables arcpy.env.overwriteOutput = True scratchDir = arcpy.env.scratchWorkspace arcpy.env.workspace = scratchDir #add an rkey field to the table that consists of values from the OID desc = arcpy.Describe(xsecLayer) idField = desc.OIDFieldName addAndCalc(xsecLayer, 'ORIG_FID', '[' + idField + ']') #measure the cross section line mLine = xsecName + '_m' arcpy.AddMessage('Measuring the length of the cross section') arcpy.CreateRoutes_lr(xsecLayer, 'ORIG_FID', mLine, 'LENGTH', '#', '#', cp) arcpy.AddMessage(' ' + mLine + ' written to ' + scratchDir) #intersect the cross section with the lines layer #creates a table with only the original FIDs of the input features. #FID field is named FID_<fcname> so we can find it later to transfer attributes #otherwise, we get a ton of fields, which may be redundant if the same feature class #(with different selections or definition queries) is being passed for both #the cross-section layer and the lines layer, which was the case when I was developing, #that is, I was looking for intersections between the main cross-section line and #all other cross-sections intersectPts = outName + '_interPts' inList = linesLayer + ';' + xsecLayer arcpy.AddMessage( 'Intersecting lines in {} with the line of cross-section'.format( linesLayer))
arcpy.CopyFeatures_management('roadstraffic_lyr', roadstraffic_avg) arcpy.Delete_management('roadstraffic_lyr') #----------------------------------------------------------------------------------------------------------------------- # INTERPOLATE # After joining the two sources, AADT values are interpolated for missing segments based on linear inverse distance # weighting from road segments with the same name. #----------------------------------------------------------------------------------------------------------------------- #Interpolate for designated lines print('Interpolate AADT values along roads based on inverse distance weighting along lines') arcpy.MakeFeatureLayer_management(roadstraffic_avg, 'roadstraffic_lyr') arcpy.SelectLayerByAttribute_management('roadstraffic_lyr', 'NEW_SELECTION', "NOT (ARTDESCRIP = ' ' OR ARTDESCRIP = 'Not Designated')") routes = 'roadstraffic_route' arcpy.CreateRoutes_lr('roadstraffic_lyr', route_id_field='STNAME_ORD', out_feature_class=routes, measure_source='LENGTH', ignore_gaps='NO_IGNORE') arcpy.LocateFeaturesAlongRoutes_lr('roadstraffic_lyr', routes, route_id_field = 'STNAME_ORD', out_table= 'routes_loc') #For each line with a designated type and no AADT, get the AADT of the closest segment on both sides on the same street name arcpy.AddField_management('routes_loc', field_name='AADT_interp', field_type='double') interpdicplus = defaultdict(list) interpdicminus = defaultdict(list) [f.name for f in arcpy.ListFields('routes_loc')] with arcpy.da.UpdateCursor('routes_loc', ['CUSTOM_ID','STNAME_ORD','FMEAS', 'ARTDESCRIP', 'AADT_avg','AADT_interp']) as cursorOuter: for rowOuter in cursorOuter: if rowOuter[4] is None: #If AADT is null print(rowOuter[0]) #For each segment of artierial street with arcpy.da.SearchCursor('routes_loc',['CUSTOM_ID', 'STNAME_ORD', 'FMEAS', 'ARTDESCRIP', 'AADT_avg']) as cursorInner: for rowInner in cursorInner: #Loop over segments of the same street that have a non-zero AADT value if rowOuter[1] == rowInner[1] and rowInner[4] > 0:
def StreamNetworkPoints(output_workspace, stream_network, flow_accum, dem): # Check out the extension license arcpy.CheckOutExtension("Spatial") # Set environment variables arcpy.env.overwriteOutput = True arcpy.env.workspace = output_workspace # Get spatial reference of FAC spatial_ref = arcpy.Describe(flow_accum).spatialReference # List parameter values arcpy.AddMessage("Workspace: {}".format(arcpy.env.workspace)) arcpy.AddMessage("Stream Network: " "{}".format(arcpy.Describe(stream_network).baseName)) arcpy.AddMessage("Flow Accumulation Model: " "{}".format(arcpy.Describe(flow_accum).baseName)) arcpy.AddMessage("Digital Elevation Model: " "{}".format(arcpy.Describe(dem).baseName)) ## Convert stream_network fc to a route # Add a field to hold the linear referencing route `from_measure` # Check if the field already exists and if not add it field_names = [f.name for f in arcpy.ListFields(stream_network)] if "from_measure" not in field_names: arcpy.AddField_management(in_table=stream_network, field_name="from_measure", field_type="DOUBLE") # Set the value of the cross section `from_measure` to zero in units meters arcpy.CalculateField_management(in_table=stream_network, field="from_measure", expression="!shape.length@kilometers!", expression_type="PYTHON_9.3") # Add a field to hold the linear referencing route `to_measure` if "to_measure" not in field_names: arcpy.AddField_management(in_table=stream_network, field_name="to_measure", field_type="DOUBLE") # Set the value of the cross section `to_measure` to the length of the # stream_network in units kilometers arcpy.CalculateField_management(in_table=stream_network, field="to_measure", expression="0", expression_type="PYTHON_9.3") # Convert stream_network fc into a route stream_network_route = os.path.join(output_workspace, "stream_network_route") arcpy.CreateRoutes_lr(in_line_features=stream_network, route_id_field="ReachName", out_feature_class=stream_network_route, measure_source="TWO_FIELDS", from_measure_field="from_measure", to_measure_field="to_measure") arcpy.AddMessage("Stream network route created") # Convert stream network feature vertices to points stream_network_points = os.path.join(output_workspace, "stream_network_points") arcpy.FeatureVerticesToPoints_management( in_features=stream_network_route, out_feature_class=stream_network_points) arcpy.AddMessage("Converted the stream network to points") # Add x, y, z, and m values to the `cross_section_points` feature class arcpy.AddGeometryAttributes_management( Input_Features=stream_network_points, Geometry_Properties="POINT_X_Y_Z_M", Length_Unit="KILOMETERS") # Set the first m-value for each stream network to zero. The `create route` # tool sets it to NULL. arcpy.CalculateField_management(in_table=stream_network_points, field="POINT_M", expression="setNull2Zero(!POINT_M!)", code_block="""def setNull2Zero(m): if m is None: return 0 else: return m""", expression_type="PYTHON_9.3") # Delete un-needed fields arcpy.DeleteField_management(in_table=stream_network_points, drop_field=["ORIG_FID", "POINT_Z"]) arcpy.AddMessage("Added stream network route lengths") # Add flow accumulation values to the stream_network_points fc arcpy.sa.ExtractMultiValuesToPoints( in_point_features=stream_network_points, in_rasters=[flow_accum], bilinear_interpolate_values="NONE") # Add a field to to the stream_network_points fc to hold watershed area # Check if the field already exists and if not add it field_names = [f.name for f in arcpy.ListFields(stream_network_points)] if "Watershed_Area_SqMile" not in field_names: arcpy.AddField_management(in_table=stream_network_points, field_name="Watershed_Area_SqMile", field_type="DOUBLE") # Convert flow accumulation cell counts to area in square miles cell_size = str( arcpy.GetRasterProperties_management(flow_accum, "CELLSIZEX")) # Expression to convert sq m to sq mi: 1 sq m = 0.0000003861 sq mile meters_sqmi = ("((float({0}) * float({0})) * 0.0000003861) * " "!{1}!".format(cell_size, arcpy.Describe(flow_accum).baseName)) if spatial_ref.linearUnitName == "Meter": arcpy.CalculateField_management(in_table=stream_network_points, field="Watershed_Area_SqMile", expression=meters_sqmi, expression_type="PYTHON_9.3") else: # Error arcpy.AddError(" Watershed linear unit not recognized." " Area not calculated") # Delete un-needed fields arcpy.DeleteField_management( in_table=stream_network_points, drop_field=[arcpy.Describe(flow_accum).baseName]) arcpy.AddMessage("Added stream network drainage area") # Add elevation values to the stream_network_points fc arcpy.sa.ExtractMultiValuesToPoints( in_point_features=stream_network_points, in_rasters=[dem], bilinear_interpolate_values="NONE") arcpy.AlterField_management(in_table=stream_network_points, field=arcpy.Describe(dem).baseName, new_field_name="Z", new_field_alias="Z") arcpy.AddMessage("Added stream network elevations") # Return arcpy.SetParameter(4, stream_network_points) # Cleanup arcpy.Delete_management(in_data=stream_network_route)
pass ## check for Z and M values desc = arcpy.Describe(tempXsLine) if desc.hasZ and desc.hasM: ZMline = tempXsLine else: #Add Z values addMsgAndPrint(' getting elevation values for ' + shortName(tempXsLine)) Zline = arcpy.CreateScratchName('xx', outFdsTag + '_Z', 'FeatureClass', scratch) arcpy.InterpolateShape_3d(dem, tempXsLine, Zline) #Add M values addMsgAndPrint(' measuring ' + shortName(Zline)) ZMline = arcpy.CreateScratchName('xx', outFdsTag + '_ZM', 'FeatureClass', scratch) arcpy.CreateRoutes_lr(Zline, idField, ZMline, 'LENGTH', '#', '#', startQuadrant) ## buffer line to get selection polygon addMsgAndPrint(' buffering ' + shortName(tempXsLine) + ' to get selection polygon') tempBuffer = arcpy.CreateScratchName('xx', outFdsTag + "xsBuffer", 'FeatureClass', scratch) arcpy.Buffer_analysis(ZMline, tempBuffer, bufferDistance, 'FULL', 'FLAT') ## get lists of feature classes to be projected lineFCs = [] polyFCs = [] pointFCs = [] if projectAll: oldws = arcpy.env.workspace arcpy.env.workspace = gdb + '/GeologicMap' linefc = arcpy.ListFeatureClasses('*', 'Line')
if type == "A1": return "AA001" elif type == "A2": return "A002" elif type == "A3": return "A003" elif type == "A4": return "A004" elif type == "A5": return "A005" elif type == "A6": return "A006" elif type == "A7": return "A007" else: return type""" # Execute AddField arcpy.AddField_management(roadsfull, "ROADT", "TEXT") # Execute CalculateField arcpy.CalculateField_management(roadsfull, "ROADT", expression, "PYTHON", codeblock) rid = "ROADT" out_routes = "SLRoutes" # Execute CreateRoutes arcpy.CreateRoutes_lr(roadsfull, rid, out_routes, "LENGTH", "#", "#", "LOWER_LEFT")
count_pts = int(result.getOutput(0)) # select segments that cross the area of interest arcpy.SelectLayerByLocation_management(track_name, "INTERSECT", sel_layer) result = arcpy.GetCount_management(track_name) count_path = int(result.getOutput(0)) if count_path > 0: # save selection to a temp polyline class _select = 'in_memory\\sel_segments' arcpy.Select_analysis(track_name, _select) # create route from selection route_name = 'in_memory\\rt_' + track_name[3:] arcpy.CreateRoutes_lr( track_name, "name", route_name, # MUST use trajectory!! "TWO_FIELDS", "from_loc", "to_loc") # extract FromLocation, ToLocation from temp points sql_clause = (None, 'ORDER BY "from_loc" ASC') fields = ("from_loc", "to_loc", "name") with arcpy.da.SearchCursor(_select, fields, None, sr, None, sql_clause) as sCur: row = sCur.next() startPath, endPath, ptt = row[0:4] for row in sCur: if not row == None: pass endPath = row[1]
arcpy.AddMessage(" Connecting inflection point by straight lines - 1/9") InflToLine = arcpy.XYToLine_management(PtsForInflLine, "%ScratchWorkspace%\\InflToLine", "NEAR_X", "NEAR_Y", "END_X", "END_Y", "GEODESIC", "Rank_UGO", SpatialRef) arcpy.AddMessage(" Dissolving all lines with the same \"Rank_UGO\" field - 2/9") Dissolve = arcpy.Dissolve_management(InflToLine, "%ScratchWorkspace%\\Dissolve", "Rank_UGO", "", "MULTI_PART", "DISSOLVE_LINES") arcpy.AddMessage(" Smoothing by Bezier interpolation - 3/9") Bezier = arcpy.SmoothLine_cartography(Dissolve, "%ScratchWorkspace%\\Bezier", "BEZIER_INTERPOLATION") arcpy.AddField_management(Bezier, "Start", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.AddField_management(Bezier, "End", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "") arcpy.CalculateField_management(Bezier, "Start", "0", "PYTHON_9.3", "") arcpy.CalculateField_management(Bezier, "End", "!Shape_Length!", "PYTHON_9.3", "") arcpy.AddMessage(" Converting in routes - 4/9") BezierRoutes = arcpy.CreateRoutes_lr(Bezier, "Rank_UGO", "%ScratchWorkspace%\\BezierRoutes", "TWO_FIELDS", "Start", "End") arcpy.AddMessage(" Up to date the \"Shape_Length\" field - 5/9") UPD_SL.UpToDateShapeLengthField(BezierRoutes) arcpy.AddMessage(" Locate inflection points on Bezier routes - 6/9") InflectionPtTABLE = arcpy.LocateFeaturesAlongRoutes_lr(PtsForSplitting, BezierRoutes, "Rank_UGO", "1", "%ScratchWorkspace%\\InflectionPtTABLE", "RID POINT MEAS") #/correction of the table : some errors have occured at confluences rows1 = arcpy.UpdateCursor(InflectionPtTABLE) rows2 = arcpy.UpdateCursor(InflectionPtTABLE) rows3 = arcpy.SearchCursor(BezierRoutes) line2 = next(rows2) nrows = int(str(arcpy.GetCount_management(InflectionPtTABLE))) # Each inflection point has a MEAS field (distance from upstream)
idField = desc.OIDFieldName addAndCalc(lineLayer, 'ORIG_FID', '[' + idField + ']') #interpolate the line to add z values zLine = lineLyrName + '_z' arcpy.AddMessage('Getting elevation values for the cross-section in ' + lineLyrName) arcpy.InterpolateShape_3d(dem, lineLayer, zLine) arcpy.AddMessage(' ' + zLine + ' written to ' + arcpy.env.scratchWorkspace) #measure it and turn it into a route zmLine = lineLyrName + '_zm' if arcpy.Exists(zmLine): arcpy.Delete_management(zmLine) arcpy.AddMessage('Measuring the length of ' + zLine) arcpy.CreateRoutes_lr(zLine, 'ORIG_FID', zmLine, 'LENGTH', '#', '#', cp) arcpy.AddMessage(' ' + zmLine + ' written to ' + arcpy.env.scratchWorkspace) #select points according to the section distance arcpy.SelectLayerByLocation_management(ptLayer, 'WITHIN_A_DISTANCE', zmLine, buff) zPts = outName + '_z' #figure out where the point elevation is coming from: a user specified field or to be #calculated by interpolation from the DEM and stored in 'zDEM' if not ptZField == '': arcpy.AddMessage('Using elevations stored in the field ' + ptZField) #if the elevation values are in the table, copy the selection to an #output fc zField = ptZField
# arcpy.AddMessage(count_pts) # select segments that cross the area of interest arcpy.SelectLayerByLocation_management(track_name, "INTERSECT", sel_layer) result = arcpy.GetCount_management(track_name) count_path = int(result.getOutput(0)) if count_path > 0: # save selection to a temp polyline class _select = 'in_memory\\sel_segments' arcpy.Select_analysis(track_name, _select) # create route from selection route_name = 'in_memory\\rt_' + track_name[3:] # ASSUMES track created by trajectory.py !! arcpy.CreateRoutes_lr(track_name, "ptt", route_name, "TWO_FIELDS", "FromLoc", "ToLoc") # arcpy.CreateRoutes_lr(track_name, "name", route_name, # "TWO_FIELDS", "from_loc", "to_loc") arcpy.AddMessage('Route created') # extract First & Last time reference from temp points sql_clause = (None, 'ORDER BY "from_loc" ASC') # fields = ("from_loc", "to_loc", "name") fields = ("FromLoc", "ToLoc", "ptt") with arcpy.da.SearchCursor(_select, fields, None, sr, None, sql_clause) as sCur: row = sCur.next() startPath, endPath, ptt = row[0:4] for row in sCur: if not row == None: pass
def crashReportLRS(GDBspot, csv, fatalwt, seriouswt, nonseriouswt, possiblewt, IntersectionThreshold, SegmentThreshold): # workspace= "Z:/fullerm/Safety Locations/Safety.gdb" # Input parameters # GCAT file/location GCATfile = csv # csv created after mapping fields with schemaCleaner # Intermediate file/location? # Intersection polygon file/location # IntersectionFeatures = arcpy.GetParameterAsText(1) # IntersectionFeatures = "Z:/fullerm/Safety Locations/Crash_Report_Script_Tool.gdb/Fed_Aid_2010_LucWoo_Intersection_Buffer_Dissolve" IntersectionFeatures = "Z:/fullerm/Safety Locations/Crash_Report_Script_Tool.gdb/LMW_intersection_250ft_buffer_5Jul2017_3857" psFeatures = "Z:/fullerm/Safety Locations/Crash_Report_Script_Tool.gdb/CS_IP_Merge_copy_clip_16june2017_LMW_3857" psThreshold = str(0) countyFeatures = "Z:/fullerm/Safety Locations/Crash_Report_Script_Tool.gdb/County_FLOWHHMS_Clipped_3857" # Segment polygon file/location # SegmentFeatures = arcpy.GetParameterAsText(2) SegmentFeatures = "Z:/fullerm/Safety Locations/Crash_Report_Script_Tool.gdb/LMW_segments_70ft_buffer_5Jul2017_3857" # output file name/location for the spatial join # GDBspot = arcpy.GetParameterAsText(1) # user input location for gdb and result excel tables # psThreshold = arcpy.GetParameterAsText(8) # output file name/location for excel table # TableFolder = arcpy.GetParameterAsText(4) # rdinv = arcpy.GetParameterAsText(8) rdinv = "C:/Users/fullerm/Documents/ArcGIS/Projects/Safety Report Script/Safety Report Script.gdb/Road_Inventory_CopyFeatures" # create geodatabase TimeDate = datetime.now() TimeDateStr = "CrashLocations" + TimeDate.strftime('%Y%m%d%H%M') + "_LRS" outputGDB = arcpy.CreateFileGDB_management(GDBspot, TimeDateStr) arcpy.env.workspace = str(outputGDB).replace('/', '\\') # I kept getting errors because arcmap sets the field type based on first dozen features and some ids were numeric '''fldmppng = arcpy.FieldMappings() fldmppng.addTable(GCATfile) nameFI = fldmppng.findFieldMapIndex("LOCAL_REPORT_NUMBER_ID") fldmp = fldmppng.getFieldMap(nameFI) fld = fldmp.outputField fld.name = "LOCAL_REPORT_NUMBER_ID" fld.aliasName = "LOCAL_REPORT_NUMBER_ID" fld.type = "String" fldmp.outputField = fld fldmppng.replaceFieldMap(nameFI,fldmp)''' # convert GCAT txt file to gdb table and add to map NewTable = arcpy.TableToTable_conversion(GCATfile, outputGDB, "OHMI_data") arcpy.TableSelect_analysis(NewTable, "oh_table", '"NLF_COUNTY_CD" <> \'Monroe\' ') ohTable = arcpy.CopyRows_management("oh_table", "ohTable") arcpy.TableSelect_analysis(NewTable, "mi_table", '"NLF_COUNTY_CD" = \'Monroe\' ') miTable = arcpy.CopyRows_management('mi_table', 'miTable') # arcpy.SelectLayerByAttribute_management(NewTable,"CLEAR_SELECTION") rdlyr = arcpy.MakeFeatureLayer_management(rdinv, "rdlyr") rtloc = os.path.join( GDBspot, "Road_Inventory3456_CreateRoutes" + TimeDateStr + ".shp") lrs = arcpy.CreateRoutes_lr(rdlyr, "NLF_ID", rtloc, "TWO_FIELDS", "CTL_BEGIN", "CTL_END") event_props = "NLFID POINT COUNTY_LOG_NBR" PointFile = arcpy.MakeRouteEventLayer_lr(lrs, "NLF_ID", ohTable, event_props, "Crash_Events") # creating this extra feature class and working from it instead of the event layer # decreased script tool runtime from ~8 min to ~2 min arcpy.SelectLayerByAttribute_management(PointFile, "clear_selection") pointOH = arcpy.FeatureClassToFeatureClass_conversion( PointFile, outputGDB, "GCAT_LUCWOO_lrs_points_" + TimeDateStr) # pointOH = arcpy.CopyFeatures_management(PointFile, "LRS_Events_copy") mi_points = milocationsxy(miTable, outputGDB) pointcopy = arcpy.Merge_management([pointOH, mi_points], 'miohpointsmerge') dict = { 'fatalities_count': "ODPS_TOTAL_FATALITIES_NBR<>0", 'incapac_inj_count': "Incapac_injuries_NBR<>0 and ODPS_TOTAL_FATALITIES_NBR=0", 'non_incapac_inj_count': "non_incapac_injuries_NBR<>0 and ODPS_TOTAL_FATALITIES_NBR=0 and incapac_injuries_nbr=0", 'possible_inj_count': "possible_injuries_nbr<>0 and ODPS_TOTAL_FATALITIES_NBR=0 and non_incapac_injuries_nbr=0 and incapac_injuries_nbr=0" } fld_lst = [ 'SEVERITY_BY_TYPE_CD', 'fatalities_count', 'incapac_inj_count', 'non_incapac_inj_count', 'possible_inj_count' ] # add fields for point layer for key in dict: arcpy.AddField_management(pointcopy, key, "LONG") '''arcpy.SelectLayerByAttribute_management(PointFile, "NEW_SELECTION", dict[key]) arcpy.CalculateField_management(PointFile, key, 1) arcpy.SelectLayerByAttribute_management(PointFile, "Switch_selection") arcpy.CalculateField_management(PointFile, key, 0)''' # fillCountFields(pointcopy, fld_lst) with arcpy.da.UpdateCursor(pointcopy, fld_lst) as cursor: for row in cursor: if row[0] == 'Fatal Crashes': row[1] = 1 row[2] = 0 row[3] = 0 row[4] = 0 elif row[0] == 'Incapacitating Injury Crashes': row[1] = 0 row[2] = 1 row[3] = 0 row[4] = 0 elif row[0] == 'Non-Incapacitating Injury Crashes': row[1] = 0 row[2] = 0 row[3] = 1 row[4] = 0 elif row[0] == 'Possible Injury Crashes': row[1] = 0 row[2] = 0 row[3] = 0 row[4] = 1 else: row[1] = 0 row[2] = 0 row[3] = 0 row[4] = 0 cursor.updateRow(row) # Clear Selected Features arcpy.SelectLayerByAttribute_management(PointFile, "clear_selection") # PointFeatures2 = arcpy.CopyFeatures_management(PointFeatures,os.path.join(GDBspot, TimeDateStr + ".gdb\PointFeatures2")) PointFeatures = arcpy.FeatureClassToFeatureClass_conversion( pointcopy, outputGDB, "ohmi_points_copy" + TimeDateStr) ftype = { 'Intersection': [IntersectionThreshold, IntersectionFeatures], 'Segment': [SegmentThreshold, SegmentFeatures], 'Subdivision': [psThreshold, psFeatures] } # field map and merge rules attchmnt = [] writer = pandas.ExcelWriter(os.path.join(GDBspot, "Top_Locations.xlsx"), engine='xlsxwriter') for f in ftype: # Create a new fieldmappings and add the two input feature classes. fieldmappings = arcpy.FieldMappings() fieldmappings.addTable(ftype[f][1]) fieldmappings.addTable(PointFeatures) # First get the fieldmaps. POP1990 is a field in the cities feature class. # The output will have the states with the attributes of the cities. Setting the # field's merge rule to mean will aggregate the values for all of the cities for # each state into an average value. The field is also renamed to be more appropriate # for the output. addSumFlds(fieldmappings) # Run the Spatial Join tool, using the defaults for the join operation and join type loc = os.path.join(GDBspot, TimeDateStr + ".gdb\\" + f + "Join_LRS") Join = arcpy.SpatialJoin_analysis(ftype[f][1], PointFeatures, loc, "Join_one_to_one", "keep_all", fieldmappings) arcpy.AddField_management(Join, "PDO_", "LONG") arcpy.AddField_management(Join, "EPDO_Index", "DOUBLE") # CRLRS_EPDO_index(Join) CursorFlds = [ 'PDO_', 'EPDO_Index', 'Join_Count', 'sum_fatalities_count', 'sum_incapac_inj_count', 'sum_non_incapac_inj_count', 'sum_possible_inj_count' ] # determine PDO and EPDO Index/Rate with arcpy.da.UpdateCursor(Join, CursorFlds) as cursor: for row in cursor: try: row[0] = row[2] - int(row[3]) - int(row[4]) - int( row[5]) - int(row[6]) except: row[0] = 0 # null or divide by zero are the major exceptions we are handling here try: row[1] = (float(row[3]) * fatalwt + float(row[4]) * seriouswt + float(row[5]) * nonseriouswt + float(row[6]) * possiblewt + float(row[0])) / float(row[2]) except: row[1] = 0 # null or divide by zero are the major exceptions we are handling here cursor.updateRow(row) # delete unnecessary fields keepFlds = [ 'OBJECTID', 'Shape', 'Shape_Area', 'Shape_Length', 'Name', 'NAMELSAD', 'COUNTY', 'COUNTY_NME', 'Join_Count', 'sum_fatalities_count', 'sum_incapac_inj_count', 'sum_non_incapac_inj_count', 'sum_possible_inj_count', 'PDO_', 'EPDO_Index', 'Fed_Aid_Buffer_Segments_2_Name', 'Length_ft', 'County' ] # lstFlds = arcpy.ListFields(Join) dropFlds = [ x.name for x in arcpy.ListFields(Join) if x.name not in keepFlds ] # delete fields arcpy.DeleteField_management(Join, dropFlds) # select high crash locations JoinLayer = arcpy.MakeFeatureLayer_management( Join, os.path.join(GDBspot, TimeDateStr + ".gdb\\" + f + "JoinLayer")) arcpy.AddMessage("{}".format(type(JoinLayer))) # arcpy.SelectLayerByAttribute_management(JoinLayer, "NEW_SELECTION", "Join_Count >=" + ftype[f][0]) fld_nmes = [fld.name for fld in arcpy.ListFields(JoinLayer)] fld_nmes.remove( 'Shape' ) # I think this field kept causing an exception: Data must be 1 dimensional arcpy.AddMessage("{}".format(fld_nmes)) arcpy.AddMessage("{}".format( type( os.path.join(GDBspot, TimeDateStr + ".gdb\\" + f + "JoinLayer")))) # do this because political sud # fields can be list or tuple, list works when 'Shape' field removed n = arcpy.da.FeatureClassToNumPyArray(JoinLayer, fld_nmes, where_clause="Join_Count >=" + ftype[f][0], skip_nulls=False, null_value=0) df = pandas.DataFrame(n) CRLRS_excel_export(df, f, writer) writer.save() return os.path.join(GDBspot, "Top_Locations.xlsx")
def StreamProfilePoints(output_workspace, flowline, dem, km_to_mouth, station_distance, calibration_points, point_id_field, measure_field, search_radius): # Check out the extension licenses arcpy.CheckOutExtension("3D") # Set environment variables arcpy.env.overwriteOutput = True arcpy.env.workspace = output_workspace # List parameter values arcpy.AddMessage("Workspace: {}".format(arcpy.env.workspace)) arcpy.AddMessage("flowline: {}".format(arcpy.Describe(flowline).baseName)) arcpy.AddMessage("km_to_mouth: {}".format(str(km_to_mouth))) arcpy.AddMessage("DEM: {}".format(arcpy.Describe(dem).baseName)) arcpy.AddMessage("Station distance: {}".format(str(station_distance))) if calibration_points: arcpy.AddMessage("Calibration points: {}".format(str(calibration_points))) arcpy.AddMessage("point_id_field: {}".format(str(point_id_field))) arcpy.AddMessage("measure_field: {}".format(str(measure_field))) arcpy.AddMessage("search_radius: {}".format(str(search_radius))) # Add a field to hold the linear referencing route from measure # Check if the field already exists and if not add it field_names = [f.name for f in arcpy.ListFields(flowline)] if "from_measure" not in field_names: arcpy.AddField_management(in_table = flowline, field_name = "from_measure", field_type = "DOUBLE") # Set the value of the flowline `from_measure` to the input parameter # `km_to_mouth` in units kilometers arcpy.CalculateField_management(in_table = flowline, field = "from_measure", expression = km_to_mouth, expression_type = "PYTHON_9.3") # Add a field to hold the linear referencing route to measure if "to_measure" not in field_names: arcpy.AddField_management(in_table = flowline, field_name = "to_measure", field_type = "DOUBLE") # Set the value of the flowline `to_measure` to the length of the flowline # in units kilometers plus the value of km_to_mouth expression = "!shape.length@kilometers! + {}".format(str(km_to_mouth)) arcpy.CalculateField_management(in_table = flowline, field = "to_measure", expression = expression, expression_type = "PYTHON_9.3") # Simplify the flowline to speed interpolation arcpy.SimplifyLine_cartography(in_features = flowline, out_feature_class = "flowline_simplify", algorithm = "POINT_REMOVE", tolerance = "1 Feet") arcpy.AddMessage("Simplified flowline: flowline_simplify") # Densify vertices of the flowline_simplify feature class using the Densify tool. arcpy.CopyFeatures_management(in_features = "flowline_simplify", out_feature_class = "flowline_densify") arcpy.Densify_edit(in_features = "flowline_densify", densification_method = "DISTANCE", distance = station_distance) arcpy.AddMessage("Densified verticies of flowline: flowline_densify") # Convert the flowline feature class to a route arcpy.CreateRoutes_lr(in_line_features = "flowline_densify", route_id_field = "ReachName", out_feature_class = "flowline_densify_route", measure_source = "TWO_FIELDS", from_measure_field = "from_measure", to_measure_field = "to_measure") arcpy.AddMessage("Converted densfied flowline to a route: " "flowline_densify_route") # Calibrate route if calibration_points: arcpy.CalibrateRoutes_lr(in_route_features = "flowline_densify_route", route_id_field = "ReachName", in_point_features = calibration_points, point_id_field = point_id_field, measure_field = measure_field, out_feature_class = "flowline_route_calibrate", calibrate_method = "DISTANCE", search_radius = search_radius) arcpy.CopyFeatures_management(in_features = "flowline_route_calibrate", out_feature_class = "flowline_densify_route") arcpy.AddMessage("Calibrated route") # Convert flowline feature vertices to points flowline_points = os.path.join(output_workspace, "flowline_points") arcpy.FeatureVerticesToPoints_management( in_features = "flowline_densify_route", out_feature_class = flowline_points) arcpy.AddMessage("Converted densified flowline route to points: " "flowline_points") # Add x, y, z, and m values to the `flowline_points` feature class arcpy.AddGeometryAttributes_management(Input_Features = flowline_points, Geometry_Properties = "POINT_X_Y_Z_M", Length_Unit = "METERS") # Set the first m-value for the flowline_points to zero. The `create # route` tool sets it to NULL. # Create code block that inserts the km_to_mouth value for the NULL record # (the first record) #arcpy.AddMessage("Set Null m-values to zero - start: {}".format(datetime.now().strftime("%H:%M:%S"))) codeBlock = """def setNull2Zero(m): if m is None: return {} else: return m""".format(km_to_mouth) arcpy.CalculateField_management(in_table = flowline_points, field = "POINT_M", expression = "setNull2Zero(!POINT_M!)", code_block = codeBlock, expression_type = "PYTHON_9.3") #arcpy.AddMessage("Set Null m-values to zero - end: {}".format(datetime.now().strftime("%H:%M:%S"))) # Delete un-needed fields arcpy.DeleteField_management(in_table = flowline_points, drop_field = ["ORIG_FID","POINT_Z"]) # Add elevations to the `flowline_points` feature class arcpy.AddSurfaceInformation_3d(in_feature_class = flowline_points, in_surface = dem, out_property = "Z", z_factor = 1.0) arcpy.AddMessage("Added geometry fields to flowline points.") # Return arcpy.SetParameter(9, flowline_points) # Cleanup arcpy.Delete_management(in_data = "flowline_simplify") arcpy.Delete_management(in_data = "flowline_simplify_Pnt") arcpy.Delete_management(in_data = "flowline_densify") arcpy.Delete_management(in_data = "flowline_route_calibrate") arcpy.Delete_management(in_data = "flowline_densify_route") return