def calculate(pts, line, start=0, search_radius="100 Meters"):
"""Calculate the milepost of each point in pts."""
# pts = sequence of (id,lat,lon)
# line = linear feature class with routes (linear referencing)
rid = "ROUTE"
props = "ID POINT MP"
tbl = "in_memory/results"
srs = arcpy.SpatialReference(4326) # WGS84
pt_fc = arcpy.CreateFeatureclass_management("in_memory", "pt_fc", "POINT",
"", "DISABLED", "DISABLED",
srs)
arcpy.AddField_management(pt_fc, "OBS_ID", "Long")
with arcpy.da.InsertCursor(pt_fc, ["OBS_ID", "SHAPE@XY"]) as in_cursor:
for point in pts:
in_cursor.insertRow([point[0], (point[2], point[1])])
arcpy.LocateFeaturesAlongRoutes_lr(pt_fc, Config.road_fc, rid,
search_radius, tbl, props)
with arcpy.da.SearchCursor("in_memory\\results",
["OBS_ID", "MP"]) as out_cursor:
mileposts = dict(out_cursor)
if start != 0:
for mile_id in mileposts:
mileposts[mile_id] = mileposts[mile_id] + start
arcpy.Delete_management(tbl)
arcpy.Delete_management(pt_fc)
return mileposts
def get_contour():
# buffer the queried route by 1 foot
arcpy.Buffer_analysis(ROUTE_FL, BUFFER_FL, buffer_distance_or_field="1 Feet", dissolve_option="NONE")
# arcpy.CopyFeatures_management(BUFFER_FL, os.path.join(gdb, "buffer")) # for testing, comment out when not in use
arcpy.AddMessage("Buffer Complete")
# clip the contours with the buffer
arcpy.AddMessage("Clipping Contours....")
arcpy.Clip_analysis(contour_5ft, BUFFER_FL, CLIPPED_CONTOUR_FL)
arcpy.CopyFeatures_management(CLIPPED_CONTOUR_FL, os.path.join(gdb, "CONTOUR"))
arcpy.AddMessage("Contour Clip Complete")
# intersect Queried Route with Clipped Contour to generate points for loading
arcpy.AddMessage("Intersecting Contours with Route....")
arcpy.Intersect_analysis([ROUTE_FL, CLIPPED_CONTOUR_FL], INTERSECT_POINTS_FL_MP, "ALL", 0, "POINT")
arcpy.AddMessage("Intersect Complete")
# explode multipart features
arcpy.AddMessage("Exploding Multipart Features....")
arcpy.MultipartToSinglepart_management(INTERSECT_POINTS_FL_MP, INTERSECT_POINTS_FL)
arcpy.AddMessage("Explode Complete")
# locate the intersected points along the route and give them a measure value
arcpy.AddMessage("Locating Features Along Route.....")
arcpy.LocateFeaturesAlongRoutes_lr(INTERSECT_POINTS_FL, route_copy, rid_field, "50 Feet",
out_table, props, "FIRST")
arcpy.AddMessage("Locate Complete")
def locateEventTable(gdb,inFC,pts,dem,sDistance,eventProperties,zType,isLines = False):
desc = arcpy.Describe(pts)
if not desc.hasZ:
addMsgAndPrint(' adding Z values')
arcpy.AddSurfaceInformation_3d (pts, dem, zType, 'LINEAR')
## working around bug in LocateFeaturesAlongRoutes
# add special field for duplicate detection
dupDetectField = 'xDupDetect'
arcpy.AddField_management(pts,dupDetectField,'LONG')
# and calc this field = OBJECTID
OID = arcpy.Describe(pts).OIDFieldName
expr = '"!'+OID+'!"'
arcpy.CalculateField_management(pts,dupDetectField,expr,"PYTHON")
# locate linePts along route
addMsgAndPrint(' making event table')
eventTable = gdb+'/evTb_'+inFC
testAndDelete(eventTable)
arcpy.LocateFeaturesAlongRoutes_lr(pts,ZMline,idField,sDistance,eventTable,eventProperties)
nRows = numberOfRows(eventTable)
nPts = numberOfRows(pts)
if nRows > nPts and not isLines: # if LocateFeaturesAlongRoutes has made duplicates (A BUG!)
addMsgAndPrint(' correcting for bug in LocateFeaturesAlongRoutes')
addMsgAndPrint(' '+str(nRows)+' rows in event table')
addMsgAndPrint(' removing duplicate entries in event table')
arcpy.DeleteIdentical_management(eventTable, dupDetectField)
addMsgAndPrint(' '+str(numberOfRows(eventTable))+' rows in event table')
arcpy.DeleteField_management(eventTable,dupDetectField)
return eventTable
def createEventTable(features, zmLine, rkey, buff, eventTable, rProps):
#builds event table of points located along a line route
try:
arcpy.AddMessage('Locating ' + features + ' on ' + zmLine)
arcpy.LocateFeaturesAlongRoutes_lr(features, zmLine, rkey, buff, eventTable, rProps, 'FIRST', 'NO_DISTANCE', 'NO_ZERO')
#return eventTable
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
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 arcpy_linear_reference_to_table(self, arg_features_to_locate, arg_inmem_output_table_name, radius="200 Meters", locate_on_every_route="ALL", field_name_route="ROAD", output_field_name_route_match="ROAD", output_feature_type="POINT", output_field_name_distance_measure="TRUE_DIST"):
"""To be called on the route feature
:param field_name_route: is the field in this dataset that uniquly identifies the routes.
:param locate_on_every_route: ALL or FIRST."""
thou_shalt("Locate Features along routes", #TODO: nice print
lambda: arcpy.LocateFeaturesAlongRoutes_lr(
in_features=str(arg_features_to_locate),
in_routes=str(self),
route_id_field=field_name_route,
radius_or_tolerance=radius,
route_locations=locate_on_every_route,
out_table=str(arg_inmem_output_table_name),
out_event_properties=' '.join([output_field_name_route_match, output_feature_type, output_field_name_distance_measure])
)
)
arcpy.AddField_management("Npoints", "N_MEAS", "DOUBLE")
for rd in rdsList:
arcpy.AddMessage(i)
query = "RTE_NBR = {0}".format(rd)
arcpy.MakeFeatureLayer_management("N_roads",
"Nroadstemp",
where_clause=query)
arcpy.MakeFeatureLayer_management("N_roads_points",
"Npointstemp",
where_clause=query)
arcpy.LocateFeaturesAlongRoutes_lr("Npointstemp",
"Nroadstemp",
"RTE_NM",
"0 Feet",
"locNRoads",
"RID_N POINT N_MEAS",
route_locations="ALL",
distance_field="NO_DISTANCE",
in_fields="FIELDS")
arcpy.Append_management("locNRoads", "Npoints", "NO_TEST")
i += 1
arcpy.Delete_management("Nroadstemp")
arcpy.Delete_management("Npointstemp")
time = str(datetime.datetime.now())
msg = "North features completed at {0}".format(time)
arcpy.AddMessage(msg)
######################################## Begin creating South Bound Roads data
arcpy.CreateFeatureclass_management(
wrkspce,
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",
"//gisdata/arcgis/GISdata/KDOT/BTP/Projects/RAIL/SplitLines.shp",
"50 Feet")
where_clause = "Perp" + "=" + str(year)
try:
arcpy.env.workspace = outDir
# create lrs layer
arcpy.MakeFeatureLayer_management(lrs, "lrs_lyr", where_clause)
print str(year) + ' lrs layer is created'
# select the lrs intersect mpo and create a layer
arcpy.SelectLayerByLocation_management('lrs_lyr', "INTERSECT", mpo)
print str(year) + ' lrs layer is selected'
# create lrs subset layer
arcpy.MakeFeatureLayer_management('lrs_lyr', 'lrs_subset')
print str(year) + ' lrs subset layer created'
# locate mpo along lrs subset
arcpy.LocateFeaturesAlongRoutes_lr(
mpo, 'lrs_subset', "NLF_ID", '', 'lrs_mpo_' + str(year),
"NLF_ID LINE CTL_BEGIN_NBR CTL_END_NBR")
print str(year) + ' lrs_mpo table created'
arcpy.Delete_management('lrs_subset')
arcpy.Delete_management('lrs_lyr')
print 'lrs and subset layer deleted'
except:
print(arcpy.GetMessages())
raw_input()
# lijn uitlezen en begin en eindpunt selecteren.
lineGeom = line.getValue(shapefieldname)
endPoints = lineGeom.firstPoint, lineGeom.lastPoint
arcpy.AddMessage("\n Lijnstuk: "+str(line.OBJECTID))
uitPNT = arcpy.CreateFeatureclass_management("in_memory", "BeginEindPNT", "POINT", "", "", "", inLine)
ptRows = arcpy.InsertCursor(uitPNT)
for pt in endPoints:
ptRow = ptRows.newRow()
ptRow.shape = pt
ptRows.insertRow(ptRow)
# Nu locatie op route zoeken
tol = "5 Meters" # Zoekafstand 5 meter
tbl = "locate_points"
props = "RID POINT MEASPnt" # uitvoer kolommen
# Execute LocateFeaturesAlongRoutes
Mtabel = arcpy.LocateFeaturesAlongRoutes_lr(uitPNT, inRT, Rkol, tol, tbl, props)
meas = arcpy.SearchCursor(Mtabel)
VanTot = []
for r in meas:
naam = r.RID
#traject = naam.split("_")[0]
dijkpl = naam.split("_")[1]
afst = r.MEASPnt
VanTot.append([int(dijkpl),int(afst)])
del Mtabel
VanTot = sorted(VanTot)
#nm1 = str(traj)+"_"+spoor+"_dp"
nm1 = str(traj)+"_dp"
# als de afstand tot de dijkpaal > 0 is dan verwerken
if VanTot[0][1] > 0:
nm2 = str(VanTot[0][0]).zfill(3)+"+"+str(VanTot[0][1]).zfill(3)
#Add DEM Z values to ZinterPts attribute table
#addZ(zInterPts)
try:
arcpy.AddField_management(zInterPts, 'zDEM', 'DOUBLE')
except:
pass
#and calc in the geometry x
arcpy.CalculateField_management(zInterPts, 'zDEM', '!SHAPE.FIRSTPOINT.Z!', 'PYTHON_9.3')
#locate intersection points along cross-section
eventTable = outName + '_interEvents'
rProps = 'rkey POINT RouteM'
#createEventTable(zInterPts, zmLine, 'ORIG_FID', '10', eventTable, rProps)
arcpy.AddMessage('Locating lines in ' + linesLayer + ' on ' + zmLine)
arcpy.LocateFeaturesAlongRoutes_lr(zInterPts, zmLine, 'ORIG_FID', '10', eventTable, rProps, 'FIRST', 'NO_DISTANCE', 'NO_ZERO')
arcpy.AddMessage(' ' + eventTable + 'written to ' + scratchDir)
if outShape == 'lines':
xInterFeats = outName + '_xsecLines'
xsecLines(xInterFeats, zInterPts, eventTable, 'zDEM')
else:
xInterFeats = outName + '_xsecPts'
xsecPoints(xInterFeats, zInterPts, eventTable, 'zDEM')
#I think we're done with 'ORIG_FID' here, nuke it
arcpy.DeleteField_management(xsecLayer, 'ORIG_FID')
#transfer attributes from linesLayer to xInterFeats
#first, what is the ID field of linesLayer (could be 'OBJECTID' or 'FID')
descLines = arcpy.Describe(linesLayer)
def generate_route_border_rule_table(workspace,route,route_id_field,boundary,boundary_id_field,buffer_size,route_border_rule_table,high_angle_threshold,offset):
arcpy.AddMessage("Generating route border rule source table for {1}...".format(boundary))
try:
date = datetime.now()
date_string = date.strftime("%m/%d/%Y")
spatial_reference = arcpy.Describe(route).spatialReference
xy_resolution = "{0} {1}".format(spatial_reference.XYResolution,spatial_reference.linearUnitName)
###############################################################################################################
# get all candidate border routes
arcpy.AddMessage("Identifying candidate border routes...")
# generate boundary border
boundary_border = os.path.join(workspace,"{0}_{1}_border".format(boundary,"boundary"))
arcpy.FeatureToLine_management(boundary, boundary_border)
# dissolve polygon boundary based on boundary id
boundary_border_dissolved = os.path.join(workspace,"{0}_boundary_border_dissolved".format(boundary))
arcpy.Dissolve_management(boundary_border,boundary_border_dissolved,[boundary_id_field])
# generate buffer around boundary
# arcpy.AddMessage("generate buffer around boundary")
boundary_border_buffer = os.path.join(workspace,"{0}_{1}".format(boundary,"boundary_buffer"))
arcpy.Buffer_analysis(boundary_border_dissolved, boundary_border_buffer, buffer_size, "FULL", "ROUND")
# get candidate border route
# arcpy.AddMessage("get candidate border route")
candidate_border_route_multipart = "in_memory\\candidate_{0}_border_route_multipart".format(boundary)
candidate_border_route = os.path.join(workspace,"candidate_{0}_border_route".format(boundary))
arcpy.Clip_analysis(route, boundary_border_buffer, candidate_border_route_multipart)
arcpy.MultipartToSinglepart_management(candidate_border_route_multipart, candidate_border_route)
################################################################################################################
################################################################################################################
# filter out candidate border routes that 'intersects' boundary at high angles
arcpy.AddMessage("Filtering out candidate border routes that 'intersects' boundary at high angles...")
route_buffer = os.path.join(workspace,"{0}_{1}".format(route,"buffer_flat"))
if not arcpy.Exists(route_buffer):
arcpy.Buffer_analysis(route, route_buffer, buffer_size, "FULL", "FLAT")
# clip boundary segments within route buffer
boundary_border_within_buffer_multipart = "in_memory\\{0}_boundary_within_{1}_buffer_multipart".format(boundary,route)
boundary_border_within_buffer = os.path.join(workspace,"{0}_boundary_within_{1}_buffer".format(boundary,route))
arcpy.Clip_analysis(boundary_border_dissolved, route_buffer, boundary_border_within_buffer_multipart)
arcpy.MultipartToSinglepart_management(boundary_border_within_buffer_multipart, boundary_border_within_buffer)
# Add 'SEGMENT_ID_ALL_CANDIDATES' field to candidate route and populate it with 'OBJECTID'
arcpy.AddField_management(candidate_border_route,"SEGMENT_ID_ALL_CANDIDATES","LONG")
arcpy.CalculateField_management(candidate_border_route, "SEGMENT_ID_ALL_CANDIDATES", "!OBJECTID!", "PYTHON")
# Add 'ANGLE_ROUTE' field to candidate route and populate it with the angle to the true north(= 0 degree)
arcpy.AddField_management(candidate_border_route,"ANGLE_ROUTE","DOUBLE")
with arcpy.da.UpdateCursor(candidate_border_route,("SHAPE@","ANGLE_ROUTE")) as uCur:
for row in uCur:
shape = row[0]
x_first = shape.firstPoint.X
y_first = shape.firstPoint.Y
x_last = shape.lastPoint.X
y_last = shape.lastPoint.Y
angle = calculate_angle(x_first,y_first,x_last,y_last)
if angle >=0:
row[1]=angle
uCur.updateRow(row)
# Add 'ANGLE_BOUNDARY' field to boundary segment within route buffer and populate it with the angle to the true north(= 0 degree)
arcpy.AddField_management(boundary_border_within_buffer,"ANGLE_BOUNDARY","DOUBLE")
with arcpy.da.UpdateCursor(boundary_border_within_buffer,("SHAPE@","ANGLE_BOUNDARY")) as uCur:
for row in uCur:
shape = row[0]
x_first = shape.firstPoint.X
y_first = shape.firstPoint.Y
x_last = shape.lastPoint.X
y_last = shape.lastPoint.Y
angle = calculate_angle(x_first,y_first,x_last,y_last)
if angle:
row[1]=angle
uCur.updateRow(row)
del uCur
# locate boundary segment within buffer along candidate border route.
# assuming that if the boundary segment can't be located along its corresponding route, these two might have high angles.
boundary_along_candidate_border_route = os.path.join(workspace,"{0}_boundary_along_candidate_{1}_border_route".format(boundary,boundary))
arcpy.LocateFeaturesAlongRoutes_lr(boundary_border_within_buffer,candidate_border_route,"SEGMENT_ID_ALL_CANDIDATES",buffer_size,\
boundary_along_candidate_border_route,"{0} {1} {2} {3}".format("RID","LINE","FMEAS","TMEAS"))
arcpy.JoinField_management(boundary_along_candidate_border_route, "RID", candidate_border_route, "SEGMENT_ID_ALL_CANDIDATES", ["ANGLE_ROUTE"])
positive_candidate_border_route = []
with arcpy.da.SearchCursor(boundary_along_candidate_border_route,("RID","ANGLE_ROUTE","ANGLE_BOUNDARY")) as sCur:
for row in sCur:
sid = str(row[0])
angle_route = row[1]
angle_boundary = row[2]
if angle_route and angle_boundary:
delta_angle = abs(angle_route-angle_boundary)
# get real intersecting angle
if delta_angle > 90 and delta_angle <= 270:
delta_angle = abs(180 - delta_angle)
elif delta_angle > 270:
delta_angle = 360 - delta_angle
else:
pass
# filter out negative candidate border route
if delta_angle <= high_angle_threshold:
if sid not in positive_candidate_border_route:
positive_candidate_border_route.append(sid)
del sCur
candidate_border_route_lyr = "in_memory\\candidate_border_route_lyr"
arcpy.MakeFeatureLayer_management(candidate_border_route, candidate_border_route_lyr)
candidate_border_route_positive = os.path.join(workspace,"candidate_{0}_border_route_positive".format(boundary))
where_clause = "\"{0}\" IN ({1})".format("OBJECTID",",".join(positive_candidate_border_route))
arcpy.SelectLayerByAttribute_management(candidate_border_route_lyr, "NEW_SELECTION", where_clause)
arcpy.CopyFeatures_management(candidate_border_route_lyr,candidate_border_route_positive)
candidate_border_route_negative = os.path.join(workspace,"candidate_{0}_border_route_negative".format(boundary))
where_clause = "\"{0}\" NOT IN ({1})".format("OBJECTID",",".join(positive_candidate_border_route))
arcpy.SelectLayerByAttribute_management(candidate_border_route_lyr, "NEW_SELECTION", where_clause)
arcpy.CopyFeatures_management(candidate_border_route_lyr,candidate_border_route_negative)
################################################################################################################
################################################################################################################
# get left, right boundary topology of positive candidate border route
# handle candidate border route segment with different L/R boundary id by offset
arcpy.AddMessage("Calculating L/R boundary topology of positive candidate border route...")
# generate offset around boundary
boundary_border_offset= os.path.join(workspace,"{0}_{1}".format(boundary,"boundary_offset"))
arcpy.Buffer_analysis(boundary_border_dissolved, boundary_border_offset, offset, "FULL", "ROUND")
# get intersections between positive candidate border route and boundary offset
candidate_border_route_positive_boundary_offset_intersections = os.path.join(workspace,"candidate_{0}_border_route_positive_{1}_offset_intersections".format(boundary,boundary))
arcpy.Intersect_analysis([candidate_border_route_positive,boundary_border_offset], candidate_border_route_positive_boundary_offset_intersections, "ALL", "", "point")
# split positive candidate border route by intersections generated above
candidate_border_route_positive_splitted_by_offset = os.path.join(workspace,"candidate_{0}_border_route_positive_splitted_by_offset".format(boundary))
arcpy.SplitLineAtPoint_management(candidate_border_route_positive,candidate_border_route_positive_boundary_offset_intersections,\
candidate_border_route_positive_splitted_by_offset,xy_resolution)
# Add 'SEGMENT_ID_POSITIVE_CANDIDATES' field to splitted positive candidate route and populate it with 'OBJECTID'
arcpy.AddField_management(candidate_border_route_positive_splitted_by_offset,"SEGMENT_ID_POSITIVE_CANDIDATES","LONG")
arcpy.CalculateField_management(candidate_border_route_positive_splitted_by_offset, "SEGMENT_ID_POSITIVE_CANDIDATES", "!OBJECTID!", "PYTHON")
# get positive candidate border route segments that within boundary offset
candidate_border_route_positive_within_offset = os.path.join(workspace,"candidate_{0}_border_route_positive_within_offset".format(boundary))
candidate_border_route_positive_splitted_by_offset_lyr = "in_memory\\candidate_{0}_border_route_positive_splitted_by_offset_lyr".format(boundary)
arcpy.MakeFeatureLayer_management(candidate_border_route_positive_splitted_by_offset, candidate_border_route_positive_splitted_by_offset_lyr)
arcpy.SelectLayerByLocation_management (candidate_border_route_positive_splitted_by_offset_lyr, "WITHIN", boundary_border_offset)
arcpy.CopyFeatures_management(candidate_border_route_positive_splitted_by_offset_lyr,candidate_border_route_positive_within_offset)
# get positive candidate border route segments that out of boundary offset
candidate_border_route_positive_outof_offset = os.path.join(workspace,"candidate_{0}_border_route_positive_outof_offset".format(boundary))
arcpy.SelectLayerByAttribute_management(candidate_border_route_positive_splitted_by_offset_lyr, "SWITCH_SELECTION")
arcpy.CopyFeatures_management(candidate_border_route_positive_splitted_by_offset_lyr,candidate_border_route_positive_outof_offset)
# generate offset around positive candidate border route within boundary offset
# arcpy.AddMessage("generate offset around boundary")
candidate_border_route_positive_within_offset_buffer= os.path.join(workspace,"candidate_{0}_border_route_positive_within_offset_buffer".format(boundary))
arcpy.Buffer_analysis(candidate_border_route_positive_within_offset, candidate_border_route_positive_within_offset_buffer, offset, "FULL", "FLAT")
# clip boundary segments within offset distance from positive candidate route that within boundary offset
boundary_border_within_positive_candidate_border_route_buffer_multipart = "in_memory\\{0}_boundary_within_positive_candidate_border_route_buffer_multipart".format(boundary)
boundary_border_within_positive_candidate_border_route_buffer = os.path.join(workspace,"{0}_boundary_within_positive_candidate_border_route_buffer".format(boundary))
arcpy.Clip_analysis(boundary_border_dissolved, candidate_border_route_positive_within_offset_buffer, boundary_border_within_positive_candidate_border_route_buffer_multipart)
arcpy.MultipartToSinglepart_management(boundary_border_within_positive_candidate_border_route_buffer_multipart, boundary_border_within_positive_candidate_border_route_buffer)
# get endpoints of boundary border within offset buffer of splitted positive candidate border routes
boundary_border_within_positive_candidate_border_route_buffer_endpoints = os.path.join(workspace,"{0}_boundary_within_positive_candidate_border_route_buffer_endpoints".format(boundary))
arcpy.FeatureVerticesToPoints_management(boundary_border_within_positive_candidate_border_route_buffer,\
boundary_border_within_positive_candidate_border_route_buffer_endpoints,"BOTH_ENDS")
arcpy.DeleteIdentical_management(boundary_border_within_positive_candidate_border_route_buffer_endpoints, ["Shape"])
# split boundary border within offset buffer of splitted positive candidate border routes and endpoints location
# then delete identical shape
boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints = os.path.join(workspace,"{0}_boundary_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints".format(boundary))
arcpy.SplitLineAtPoint_management(boundary_border_within_positive_candidate_border_route_buffer,boundary_border_within_positive_candidate_border_route_buffer_endpoints,\
boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints,xy_resolution)
arcpy.DeleteIdentical_management(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints, ["Shape"])
# Add 'SEGMENT_ID_BOUNDARY' field to boundary segments within offset distance from positive candidate route that within boundary offset and populate it with 'OBJECTID'
arcpy.AddField_management(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints,"SEGMENT_ID_BOUNDARY","LONG")
arcpy.CalculateField_management(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints, "SEGMENT_ID_BOUNDARY", "!OBJECTID!", "PYTHON")
# locate boundary segments within offset distance of positive candidate route that within boundary offset along positive candidate route that within boundary offset
boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route = os.path.join(workspace,"{0}_boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route".format(boundary))
arcpy.LocateFeaturesAlongRoutes_lr(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints,candidate_border_route_positive_within_offset,"SEGMENT_ID_POSITIVE_CANDIDATES",offset,\
boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route,"{0} {1} {2} {3}".format("RID","LINE","FMEAS","TMEAS"))
# get left, right boundary topology of boundary within offset distance of positive candidate route that within boundary offset along positive candidate route that within boundary offset
boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases= os.path.join(workspace,"{0}_boundary_border_within_positive_candidate_border_route_buffer_with_{1}_topology_allcases".format(boundary,boundary))
arcpy.Identity_analysis(boundary_border_within_positive_candidate_border_route_buffer_splitted_by_own_endpoints, boundary, boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases,"ALL","","KEEP_RELATIONSHIPS")
boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr = "in_memory\\{0}_boundary_border_within_positive_candidate_border_route_buffer_with_{1}_topology_allcases_lyr".format(boundary,boundary)
arcpy.MakeFeatureLayer_management(boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases, boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr)
where_clause = "\"{0}\"<>0 AND \"{1}\"<>0".format("LEFT_{0}".format(boundary),"RIGHT_{0}".format(boundary))
arcpy.SelectLayerByAttribute_management(boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr, "NEW_SELECTION", where_clause)
boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology = os.path.join(workspace,"{0}_boundary_border_within_positive_candidate_border_route_buffer_with_{1}_topology".format(boundary,boundary))
arcpy.CopyFeatures_management(boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology_allcases_lyr,boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology)
arcpy.JoinField_management(boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route,"SEGMENT_ID_BOUNDARY",\
boundary_border_within_positive_candidate_border_route_buffer_with_polygon_topology,"SEGMENT_ID_BOUNDARY",["LEFT_{0}".format(boundary_id_field),"RIGHT_{0}".format(boundary_id_field)])
arcpy.JoinField_management(candidate_border_route_positive_within_offset,"SEGMENT_ID_POSITIVE_CANDIDATES",\
boundary_border_within_positive_candidate_border_route_buffer_along_candidate_border_route,"RID",["SEGMENT_ID_BOUNDARY","LEFT_{0}".format(boundary_id_field),"RIGHT_{0}".format(boundary_id_field)])
candidate_border_route_positive_within_offset_lyr = "in_memory\\candidate_{0}_border_route_positive_within_offset_lyr".format(boundary)
arcpy.MakeFeatureLayer_management(candidate_border_route_positive_within_offset, candidate_border_route_positive_within_offset_lyr)
where_clause = "\"{0}\"IS NOT NULL AND \"{1}\"IS NOT NULL".format("LEFT_{0}".format(boundary_id_field),"RIGHT_{0}".format(boundary_id_field))
arcpy.SelectLayerByAttribute_management(candidate_border_route_positive_within_offset_lyr, "NEW_SELECTION", where_clause)
candidate_border_route_positive_within_offset_with_polygon_topology = os.path.join(workspace,"candidate_{0}_border_route_positive_within_offset_with_{1}_topology".format(boundary,boundary))
arcpy.CopyFeatures_management(candidate_border_route_positive_within_offset_lyr,candidate_border_route_positive_within_offset_with_polygon_topology)
# get left, right boundary topology of candidate border route out of boundary offset
candidate_border_route_positive_outof_offset_with_polygon_topology_allcases= os.path.join(workspace,"candidate_{0}_border_route_positive_outof_offset_with_{1}_topology_allcases".format(boundary,boundary))
arcpy.Identity_analysis(candidate_border_route_positive_outof_offset, boundary, candidate_border_route_positive_outof_offset_with_polygon_topology_allcases,"ALL","","KEEP_RELATIONSHIPS")
candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr = "in_memory\\candidate_{0}_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr".format(boundary)
arcpy.MakeFeatureLayer_management(candidate_border_route_positive_outof_offset_with_polygon_topology_allcases, candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr)
where_clause = "\"{0}\"<>0 AND \"{1}\"<>0".format("LEFT_{0}".format(boundary),"RIGHT_{0}".format(boundary))
arcpy.SelectLayerByAttribute_management(candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr, "NEW_SELECTION", where_clause)
candidate_border_route_positive_outof_offset_with_polygon_topology = os.path.join(workspace,"candidate_{0}_border_route_positive_outof_offset_with_{1}_topology".format(boundary,boundary))
arcpy.CopyFeatures_management(candidate_border_route_positive_outof_offset_with_polygon_topology_allcases_lyr,candidate_border_route_positive_outof_offset_with_polygon_topology)
# merge
candidate_border_route_positive_with_polygon_topology = "candidate_{0}_border_route_positive_with_{1}_topology".format(boundary,boundary)
arcpy.FeatureClassToFeatureClass_conversion(candidate_border_route_positive_outof_offset_with_polygon_topology,workspace,candidate_border_route_positive_with_polygon_topology)
arcpy.Append_management([candidate_border_route_positive_within_offset_with_polygon_topology],candidate_border_route_positive_with_polygon_topology,"NO_TEST")
################################################################################################################
################################################################################################################
arcpy.AddMessage("Populate route_border_rule_table...")
# calculate from measure and to measure of candidate border route
# arcpy.AddMessage("Calculating from measure and to measure of candidate border routes...")
arcpy.AddGeometryAttributes_management(candidate_border_route_positive_with_polygon_topology, "LINE_START_MID_END")
# get candidte border route segment geometry
arcpy.AddField_management(candidate_border_route_positive_with_polygon_topology,"SEGMENT_GEOMETRY","TEXT","","",100)
arcpy.CalculateField_management(candidate_border_route_positive_with_polygon_topology,"SEGMENT_GEOMETRY","!shape.type!","PYTHON")
# sort candidate border route segments based on route id and from measure, orderly
# arcpy.AddMessage("sort validated output got above based on route id and from measure, orderly")
candidate_border_route_positive_with_polygon_topology_sorted = os.path.join(workspace,"candidate_{0}_border_route_positive_with_polygon_topology_sorted".format(boundary))
arcpy.Sort_management(candidate_border_route_positive_with_polygon_topology,candidate_border_route_positive_with_polygon_topology_sorted,[[route_id_field,"ASCENDING"],["START_M","ASCENDING"]])
# create route_border_rule_table
if arcpy.Exists(route_border_rule_table):
arcpy.Delete_management(route_border_rule_table)
create_route_border_rule_table_schema(workspace,route_border_rule_table)
else:
create_route_border_rule_table_schema(workspace,route_border_rule_table)
# populate route_border_rule_table
iCur = arcpy.da.InsertCursor(route_border_rule_table,["ROUTE_ID","ROUTE_START_MEASURE","ROUTE_END_MEASURE","BOUNDARY_LEFT_ID",\
"BOUNDARY_RIGHT_ID","SEGMENT_GEOMETRY","EFFECTIVE_FROM_DT","EFFECTIVE_TO_DT"])
with arcpy.da.SearchCursor(candidate_border_route_positive_with_polygon_topology_sorted,[route_id_field,"START_M","END_M","LEFT_{0}".format(boundary_id_field),\
"RIGHT_{0}".format(boundary_id_field),"SEGMENT_GEOMETRY","START_DATE","END_DATE"]) as sCur:
for row in sCur:
iCur.insertRow(row)
del sCur
del iCur
arcpy.CalculateField_management(route_border_rule_table, "BRP_PROCESS_DT", "'{0}'".format(date_string), "PYTHON")
################################################################################################################
arcpy.AddMessage("done!")
return route_border_rule_table
except Exception:
# arcpy.AddMessage(traceback.format_exc())
sys.exit(traceback.format_exc())
return False
def AddSegFromAddresses(AddressList, SegInput, RouteID, Output):
import requests
APIKey = 'AIzaSyCs80htAI4UAHHuF5m9IclsbMqg1FKxoEQ'
PntLayer = CreateOutPath(Output, 'pnts', '')
arcpy.CreateFeatureclass_management(out_path=os.path.dirname(Output),
out_name=os.path.basename(PntLayer),
geometry_type='POINT',
spatial_reference=NAD1983IL)
arcpy.AddField_management(PntLayer, 'SegID', 'SHORT')
arcpy.AddField_management(PntLayer, 'Address', 'TEXT')
IC = arcpy.InsertCursor(PntLayer)
i = 0
for add in AddressList:
r = IC.newRow()
r.setValue('SegID', i)
r.setValue('Address', add[0])
IC.insertRow(r)
r = IC.newRow()
r.setValue('SegID', i)
r.setValue('Address', add[1])
IC.insertRow(r)
i += 1
del IC
AddPointFromAddress(PntLayer, 'Address')
Buffer = "200 Feet"
SPJ = CreateOutPath(MainFile=Output, appendix='SPJ', Extension='')
arcpy.SpatialJoin_analysis(
target_features=SegInput,
join_features=PntLayer,
out_feature_class=SPJ,
join_operation="JOIN_ONE_TO_ONE",
join_type="KEEP_COMMON",
match_option="INTERSECT",
search_radius=Buffer,
)
UnSplt = CreateOutPath(MainFile=Output, appendix='Unsplt', Extension='')
arcpy.UnsplitLine_management(in_features=SPJ,
out_feature_class=UnSplt,
dissolve_field="",
statistics_fields="")
SPJ2 = CreateOutPath(MainFile=Output, appendix='SPJ2', Extension='')
arcpy.SpatialJoin_analysis(
target_features=UnSplt,
join_features=PntLayer,
out_feature_class=SPJ2,
join_operation="JOIN_ONE_TO_ONE",
join_type="KEEP_COMMON",
match_option="INTERSECT",
search_radius=Buffer,
)
Final_Layer = CreateOutLayer('FinalLayer')
arcpy.MakeFeatureLayer_management(in_features=SPJ2, out_layer=Final_Layer)
arcpy.SelectLayerByAttribute_management(in_layer_or_view=Final_Layer,
selection_type='NEW_SELECTION',
where_clause="Join_Count = 2")
EventTable = CreateOutPath(MainFile=Output,
appendix='EventTable',
Extension='')
arcpy.LocateFeaturesAlongRoutes_lr(in_features=PntLayer,
in_routes=SPJ,
route_id_field=RouteID,
radius_or_tolerance=Buffer,
out_table=EventTable,
out_event_properties=" ".join(
[RouteID, "POINT", "MP"]),
route_locations="FIRST",
distance_field="DISTANCE",
in_fields="FIELDS",
m_direction_offsetting="M_DIRECTON")
SegTable = CreateOutPath(MainFile=Output,
appendix='SegTable',
Extension='')
arcpy.CreateTable_management(out_path=os.path.dirname(SegTable),
out_name=os.path.basename(SegTable))
arcpy.AddField_management(SegTable, RouteID, 'TEXT')
arcpy.AddField_management(SegTable, 'BEG_STA', 'DOUBLE')
arcpy.AddField_management(SegTable, 'END_STA', 'DOUBLE')
arcpy.AddField_management(SegTable, 'Address1', 'TEXT')
arcpy.AddField_management(SegTable, 'Address2', 'TEXT')
#SegIDDict = {r.getValue('SegID'):{'INV':'','BMP':0,'EMP':0,'Add1':'','Add2':''}}
SegIDDict = {}
for r in arcpy.SearchCursor(EventTable):
k = r.getValue('SegID')
if k in SegIDDict.keys():
mp = r.getValue('MP')
add = r.getValue('Address')
if SegIDDict[k]['BMP'] <= mp:
SegIDDict[k]['EMP'] = mp
SegIDDict[k]['Add2'] = add
else:
SegIDDict[k]['EMP'] = SegIDDict[k]['BMP']
SegIDDict[k]['BMP'] = mp
SegIDDict[k]['Add2'] = SegIDDict[k]['Add1']
SegIDDict[k]['Add1'] = add
else:
SegIDDict.update({
r.getValue('SegID'): {
'INV': r.getValue(RouteID),
'BMP': r.getValue('MP'),
'EMP': -1,
'Add1': r.getValue('Address'),
'Add2': ''
}
})
print('End point was not found')
IC = arcpy.InsertCursor(SegTable)
for k in SegIDDict.keys():
r = IC.newRow()
r.setValue(RouteID, SegIDDict[k]['INV'])
r.setValue('BEG_STA', SegIDDict[k]['BMP'])
r.setValue('END_STA', SegIDDict[k]['EMP'])
r.setValue('Address1', SegIDDict[k]['Add1'])
r.setValue('Address2', SegIDDict[k]['Add2'])
IC.insertRow(r)
del IC
Overlay_Event_Layer = CreateOutLayer('OverlayEventLayer')
arcpy.MakeRouteEventLayer_lr(in_routes=SegInput,
route_id_field=RouteID,
in_table=SegTable,
in_event_properties=' '.join(
[RouteID, 'LINE', 'BEG_STA', 'END_STA']),
out_layer=Overlay_Event_Layer,
offset_field="",
add_error_field="ERROR_FIELD")
Sort = CreateOutPath(MainFile=Output, appendix='sort', Extension='')
arcpy.Sort_management(in_dataset=Overlay_Event_Layer,
out_dataset=Sort,
sort_field=';'.join([RouteID, 'BEG_STA', 'END_STA']))
Final_Layer = CreateOutLayer('FinalLayer')
arcpy.MakeFeatureLayer_management(in_features=Sort, out_layer=Final_Layer)
arcpy.SelectLayerByAttribute_management(in_layer_or_view=Final_Layer,
selection_type='NEW_SELECTION',
where_clause="Shape_Length > 0")
arcpy.Delete_management(Output)
arcpy.CopyFeatures_management(in_features=Final_Layer,
out_feature_class=Output)
arcpy.Delete_management(PntLayer)
arcpy.Delete_management(SPJ)
arcpy.Delete_management(SPJ2)
arcpy.Delete_management(EventTable)
arcpy.Delete_management(SegTable)
arcpy.Delete_management(Overlay_Event_Layer)
arcpy.Delete_management(Sort)
arcpy.Delete_management(Final_Layer)
arcpy.Delete_management(UnSplt)
arcpy.CalculateField_management(zPts, 'zDEM', -999, 'PYTHON_9.3')
#'DEM_Z' becomes the collar elevation field
zField = 'zDEM'
#clear the selection
arcpy.SelectLayerByAttribute_management(ptLayer, "CLEAR_SELECTION")
#add ORIG_ID for deleting identical events and for joining attributes later
addAndCalc(zPts, 'ORIG_PTID', '[OBJECTID]')
# locate points points along the cross-section
eventTable = outName + '_ptEvents'
rProps = 'rkey POINT RouteM'
arcpy.AddMessage('Locating ' + zPts + ' on ' + zmLine)
arcpy.LocateFeaturesAlongRoutes_lr(zPts, zmLine, 'ORIG_FID', buff,
eventTable, rProps, '#', 'DISTANCE')
arcpy.AddMessage(' ' + eventTable + ' written to ' +
arcpy.env.scratchWorkspace)
#remove duplicate records that result from what appears to be
#an unresolved bug in the Locate Features Along Routes tool
#some points will get more than one record in the event table
#and slightly different, sub-mapunit, mValues
try:
arcpy.DeleteIdentical_management(eventTable, 'ORIG_PTID')
except:
pass
#place points as events on the cross section line
eventLyr = '_lyr'
rProps = 'rkey POINT RouteM'
# 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
arcpy.Intersect_analysis([toshore, transects], tempvert, "ONLY_FID", output_type="POINT")
# Calculate the distance of the shoreling along each transect
arcpy.LocateFeaturesAlongRoutes_lr(tempvert, temproute, "TRANSECT_ID", "100 Meters", temptable, "RID POINT MEAS", "FIRST", "DISTANCE", "ZERO", "FIELDS", "M_DIRECTON")
# Initiate Search Cursor to cycle through the linear referencing output table
search_cur = arcpy.SearchCursor(temptable)
for s in search_cur:
tran_id = s.RID
dist = s.MEAS
r = ins_cur.newRow()
r.TRANSECT_ID = str(tran_id)
r.YEAR = str(year)
r.DISTANCE = dist
ins_cur.insertRow(r)
f.write(str(location) + '|' + str(year) + '|' + str(tran_id) + '|' + str(dist) + '\n')
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)
n = 0
for line1 in rows1 :
if n >= nrows-1:
# At the end of the table set the MEAS as the UGO (line3) length and stop the process
line3 = next(rows3)
line2.MEAS = line3.Shape_Length
arcpy.AddField_management(B_SourceData_CopyForLocate, "From_Date", "DATE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Process: Calculate Unique Event_ID
arcpy.CalculateField_management(B_SourceData_CopyForLocate, "Event_ID", "CalcGUID()", "PYTHON", "def CalcGUID():\\n import uuid\\n return '{' + str(uuid.uuid4()).upper() + '}'\\n")
# Process: Calculate From_Date
arcpy.CalculateField_management(B_SourceData_CopyForLocate, "From_Date", "Date ( )", "VB", "")
# Process: Add Attribute Index (Event_ID)
arcpy.AddIndex_management(B_SourceData_CopyForLocate, "Event_ID", "index_EventID", "UNIQUE", "NON_ASCENDING")
# Process: Make Feature Layer
arcpy.MakeFeatureLayer_management(B_SourceData_CopyForLocate, B_SourceData_CopyForLocate_Layer, "", Workspace, "")
# Process: Locate Pts Along Routes (50ft buffer)
arcpy.LocateFeaturesAlongRoutes_lr(B_SourceData_CopyForLocate_Layer, LRS_Route_Network, "ROADWAY", "50 Feet", C_PointData_LocateFeatures, Output_Event_Table_Properties, "FIRST", "DISTANCE", "ZERO", "FIELDS", "M_DIRECTON")
# Process: Table to Table
arcpy.TableToTable_conversion(B_SourceData_CopyForLocate_Layer, Workspace, "E_CopyOfOriginalInputWithNewFields", "", "", "")
#if there's already a Measure field, create a new field named Source_Measure, copy those values in, and delete existing Measure field after copying out the values, and then process can pick up at next line.
###
# Process: Add Field (Source_Measure)
arcpy.AddField_management(B_SourceData_CopyForLocate, "Source_Measure", "DOUBLE", "", "", "", "", "NULLABLE", "NON_REQUIRED", "")
# Process: Calculate Source_Measure
arcpy.CalculateField_management(B_SourceData_CopyForLocate, "Source_Measure", "!Measure!", "PYTHON_9.3")
# Process: Delete Field (Measure)
arcpy.DeleteField_management(B_SourceData_CopyForLocate, "Measure")
###
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)))
n = 0
for line1 in rows1:
if n >= nrows - 1:
line3 = next(rows3)
line2.MEAS = line3.Shape_Length
def convert_lec_nodes_to_line_events(
workspace_gdb,
lec_nodes_fc,
lec_fault_id_field,
routes_fc,
routes_id_field,
snapping_tolerance_meters,
clean_up_temp_files=False,
):
# Naming file variables
temp_lines_fc = os.path.join(workspace_gdb, "temp_ConvertedLines")
temp_events_table = os.path.join(workspace_gdb, "temp_LocatedAlongRoute")
temp_events_lyr_name = "LEC_events_lyr"
output_fc = os.path.join(workspace_gdb, "LEC_LinearEvents")
# Snapping tolerance variable since GP tool accepts string with distance format
snapping_tolerance = "{0} Meters".format(str(snapping_tolerance_meters))
# GP Tool: LEC points to line, using a fault ID field to allow multiple edits to be processed
arcpy.PointsToLine_management(Input_Features=lec_nodes_fc,
Output_Feature_Class=temp_lines_fc,
Line_Field=lec_fault_id_field,
Sort_Field="OBJECTID",
Close_Line="NO_CLOSE")
# GP Tool: Locate features along route using lines and routes and write to a table.
arcpy.LocateFeaturesAlongRoutes_lr(
in_features=temp_lines_fc,
in_routes=routes_fc,
route_id_field=routes_id_field,
radius_or_tolerance=snapping_tolerance,
out_table=temp_events_table,
out_event_properties="RID LINE FMEAS TMEAS",
route_locations="FIRST",
distance_field="DISTANCE",
zero_length_events="ZERO",
in_fields="FIELDS",
m_direction_offsetting="M_DIRECTON")
# GP Tool: Table conversion of edited events to a feature layer.
event_layer = arcpy.MakeRouteEventLayer_lr(
in_routes=routes_fc,
route_id_field=routes_id_field,
in_table=temp_events_table,
in_event_properties="rid LINE fmeas tmeas",
out_layer=temp_events_lyr_name,
offset_field="",
add_error_field="NO_ERROR_FIELD",
add_angle_field="NO_ANGLE_FIELD",
angle_type="NORMAL",
complement_angle="ANGLE",
offset_direction="LEFT",
point_event_type="POINT").getOutput(0)
# GP Tool: Copy feature layer to disk as feature class.
arcpy.CopyFeatures_management(in_features=event_layer,
out_feature_class=output_fc)
# Optional clean-up of temp data.
if clean_up_temp_files:
arcpy.AddMessage("Cleaning up temporary content...")
# print("Cleaning up temporary content...")
content_to_delete = [temp_lines_fc, temp_events_table]
for item in content_to_delete:
arcpy.Delete_management(item)
arcpy.AddMessage("Temp files cleaned up.")
"(FromDate is null or FromDate<=CURRENT_TIMESTAMP) and (ToDate is null or ToDate>CURRENT_TIMESTAMP)"
)
arcpy.CopyFeatures_management('useMe', reviewer_db + '/useMe')
in_features = reviewer_db + "/REVDATASET/REVTABLELINE"
in_routes = reviewer_db + '/useMe'
route_id_field = "ROUTEID"
radius_or_tolerance = "1 Feet"
point_radius = "20 Feet"
out_table_line = reviewer_db + "/LineRT"
props_line = "RID LINE FMEAS TMEAS"
# arcpy.env.overwriteOutput = "true"
# Write log of Locate Events tool
now = datetime.datetime.now()
writeMsg("\nStarting Line Table at: " + str(now)[:-7])
arcpy.LocateFeaturesAlongRoutes_lr(in_features, in_routes, route_id_field,
radius_or_tolerance, out_table_line,
props_line, "#", "#", "ZERO", "FIELDS")
now = datetime.datetime.now()
writeMsg("\nFinished Line Table at: " + str(now)[:-7])
# Set variables for joining tables.
# (This is what allows review records to be paired with the routes the tool just located.)
in_join_features = in_features
layerName = "Line_Checks"
in_field = "LINKGUID"
in_field2 = "LineRT.LINKGUID"
join_table = out_table_line
join_table2 = reviewer_db + "/REVTABLEMAIN"
join_field = "LINKGUID"
join_field2 = "ID"
join_type = "KEEP_COMMON"
#the scratch gdb which has a length in the units of the SR of the dem.
#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)
#measure it and turn it into a route
zmLine = lineLayer + '_zm'
arcpy.AddMessage('Measuring the length of the line in ' + zLine)
arcpy.CreateRoutes_lr(zLine, 'ORIG_FID', zmLine, 'LENGTH', '#', '#', cp)
#intersect with geology layer
eventTable = polyLayer + '_polyEvents'
rProps = 'rkey LINE FromM ToM'
arcpy.AddMessage('Locating ' + polyLayer + ' on ' + zmLine)
arcpy.LocateFeaturesAlongRoutes_lr(polyLayer, zmLine, 'ORIG_FID', '#', eventTable, rProps, 'FIRST', 'NO_DISTANCE', 'NO_ZERO')
#place line events on interpolated route
locatedEvents = polyLayer + '_located'
placeEvents(zmLine, 'ORIG_FID', eventTable, 'rkey', 'FromM', 'ToM', locatedEvents)
#flip the surface profile events
#create an empty container for the features that has no spatial reference
zmProfiles = outName + '_profiles'
arcpy.AddMessage(scratchDir)
arcpy.AddMessage(zmProfiles)
arcpy.CreateFeatureclass_management(scratchDir, zmProfiles, 'POLYLINE', locatedEvents, 'ENABLED', 'ENABLED')
#append the features from locatedEvents (map view) to locatedEvents2 (unknown SR)
arcpy.Append_management(locatedEvents, zmProfiles)
if not saveIntermediate:
for f in (tempPoints, eventTable, eventLyr, outFCa):
testAndDelete(f)
addMsgAndPrint('\n Projecting polygon feature classes:')
for polyFC in polyFCs:
inFC = shortName(polyFC)
addMsgAndPrint(' ' + inFC)
arcpy.env.workspace = wsName(polyFC)
# locate features along routes
addMsgAndPrint(' making event table')
eventTable = gdb + '/evTb_' + inFC
addMsgAndPrint(eventTable)
testAndDelete(eventTable)
eventProperties = 'rtID LINE FromM ToM'
arcpy.LocateFeaturesAlongRoutes_lr(inFC, ZMline, idField, '#', eventTable,
eventProperties)
addMsgAndPrint(' placing events on section line')
eventLyr = 'xxxPolyEvents'
arcpy.MakeRouteEventLayer_lr(ZMline, idField, eventTable, eventProperties,
eventLyr)
outFC = 'ed_CS' + outFdsTag + shortName(inFC)
addMsgAndPrint(' creating feature class ' + outFC + ' in ' +
shortName(outFds))
# make new feature class using old as template
testAndDelete(outFds + '/' + outFC)
addMsgAndPrint(outFds + ' ' + outFC + ' ' + inFC)
try:
arcpy.CreateFeatureclass_management(outFds, outFC, 'POLYLINE', inFC,
'DISABLED', 'SAME_AS_TEMPLATE')
except:
addMsgAndPrint('Failed to create copy of ' + inFC +
def ImportRoadwayData(Input, Route, AttTable, Fields, Output, RouteID, BMP,
EMP, XY_Tolerance):
#Output should be on a GDB not a shapefile
#Step 1: Create a route FC based on the input
Sites_Event_Table = common.CreateOutPath(MainFile=Output,
appendix='EventTab',
Extension='')
arcpy.LocateFeaturesAlongRoutes_lr(in_features=Input,
in_routes=Route,
route_id_field=RouteID,
radius_or_tolerance=XY_Tolerance,
out_table=Sites_Event_Table,
out_event_properties=' '.join(
[RouteID, 'LINE', BMP, EMP]),
route_locations="FIRST",
distance_field="DISTANCE",
zero_length_events="ZERO",
in_fields="FIELDS",
m_direction_offsetting="M_DIRECTON")
Sites_Event_Layer = common.CreateOutLayer('EventLayer')
arcpy.MakeRouteEventLayer_lr(in_routes=Route,
route_id_field=RouteID,
in_table=Sites_Event_Table,
in_event_properties=' '.join(
[RouteID, 'LINE', BMP, EMP]),
out_layer=Sites_Event_Layer,
add_error_field="NO_ERROR_FIELD")
Sites_Routes = common.CreateOutPath(MainFile=Output,
appendix='route',
Extension='')
arcpy.CopyFeatures_management(in_features=Sites_Event_Layer,
out_feature_class=Sites_Routes)
IRIS_Diss = common.CreateOutPath(MainFile=Output,
appendix='diss',
Extension='')
arcpy.DissolveRouteEvents_lr(
in_events=AttTable,
in_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
dissolve_field=';'.join(Fields),
out_table=IRIS_Diss,
out_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
dissolve_type="DISSOLVE",
build_index="INDEX")
Overlay_Event_Table1 = common.CreateOutPath(MainFile=Output,
appendix='OverlayTab1',
Extension='')
arcpy.OverlayRouteEvents_lr(
in_table=IRIS_Diss,
in_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
overlay_table=Sites_Event_Table,
overlay_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
overlay_type="INTERSECT",
out_table=Overlay_Event_Table1,
out_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
zero_length_events="NO_ZERO",
in_fields="FIELDS",
build_index="INDEX")
Overlay_Event_Layer = common.CreateOutLayer('OverlayEventLayer')
arcpy.MakeRouteEventLayer_lr(in_routes=Route,
route_id_field=RouteID,
in_table=Overlay_Event_Table1,
in_event_properties=' '.join(
[RouteID, 'LINE', BMP, EMP]),
out_layer=Overlay_Event_Layer,
offset_field="",
add_error_field="ERROR_FIELD")
Sites_segs1 = common.CreateOutPath(MainFile=Output,
appendix='seg1',
Extension='')
arcpy.CopyFeatures_management(in_features=Overlay_Event_Layer,
out_feature_class=Sites_segs1)
#Curves_Table = common.CreateOutPath(MainFile=Output,appendix='curves',Extension='')
#ExtractCurves(inp=Sites_segs1,IDField=RouteID,RMax=5280,RMin=10,DegMin=2,desd=1000,LenMin=1000,out=Curves_Table)
#Overlay_Event_Table2 = common.CreateOutPath(MainFile=Output,appendix='OverlayTab2',Extension='')
#arcpy.OverlayRouteEvents_lr(in_table = Overlay_Event_Table1,
# in_event_properties = ' '.join([RouteID,'LINE',BMP,EMP]),
# overlay_table = Curves_Table,
# overlay_event_properties = ' '.join([RouteID,'LINE',BMP,EMP]),
# overlay_type = "UNION",
# out_table = Overlay_Event_Table2,
# out_event_properties = ' '.join([RouteID,'LINE',BMP,EMP]),
# zero_length_events = "NO_ZERO",
# in_fields = "FIELDS",
# build_index="INDEX")
#Overlay_Event_Layer2 = common.CreateOutLayer('OverlayEventLayer2')
#arcpy.MakeRouteEventLayer_lr(in_routes = Route,
# route_id_field = RouteID,
# in_table = Overlay_Event_Table2,
# in_event_properties = ' '.join([RouteID,'LINE',BMP,EMP]),
# out_layer = Overlay_Event_Layer2,
# offset_field = "",
# add_error_field = "ERROR_FIELD")
Sort = common.CreateOutPath(MainFile=Output, appendix='sort', Extension='')
arcpy.Sort_management(in_dataset=Sites_segs1,
out_dataset=Sort,
sort_field=';'.join([RouteID, BMP, EMP]))
Final_Layer = common.CreateOutLayer('FinalLayer')
arcpy.MakeFeatureLayer_management(in_features=Sort, out_layer=Final_Layer)
arcpy.SelectLayerByAttribute_management(in_layer_or_view=Final_Layer,
selection_type='NEW_SELECTION',
where_clause="Shape_Length > 52")
arcpy.Delete_management(Output)
arcpy.MultipartToSinglepart_management(in_features=Final_Layer,
out_feature_class=Output)
arcpy.DeleteField_management(Output, 'ORIG_FID')
FL = [
f.name for f in arcpy.ListFields(Output)
if f.name != arcpy.Describe(Output).OIDFieldName
]
arcpy.DeleteIdentical_management(in_dataset=Output,
fields=';'.join(FL),
xy_tolerance="",
z_tolerance="0")
arcpy.Delete_management(Sites_Event_Table)
arcpy.Delete_management(Sites_Event_Layer)
arcpy.Delete_management(Sites_Routes)
arcpy.Delete_management(IRIS_Diss)
arcpy.Delete_management(Overlay_Event_Table1)
arcpy.Delete_management(Overlay_Event_Layer)
arcpy.Delete_management(Sites_segs1)
#arcpy.Delete_management(Curves_Table)
#arcpy.Delete_management(Overlay_Event_Table2)
#arcpy.Delete_management(Overlay_Event_Layer2)
arcpy.Delete_management(Sort)
arcpy.Delete_management(Final_Layer)
'''
Created on Apr 18, 2013
@author: kyleg
'''
import arcpy
arcpy.env.overwriteOutput = True
ws = r"\\gisdata\arcgis\GISdata\KDOT\BTST\DeerAccs3.gdb"
arcpy.env.workspace = ws
#start with Accident Data points
crashlyr = "DeerCrashes"
sumlyr = "Deer_Crash_Summary"
#locate the points along the County Route LRS
arcpy.LocateFeaturesAlongRoutes_lr(crashlyr, "LRS_Route_CRM", "LRS_KEY",
"0 Feet", "LFAR_CRASHES",
"LRS_KEY POINT CRMP", "FIRST", "DISTANCE",
"ZERO", "FIELDS", "M_DIRECTON")
#Calculate the begin and end miles post integer around the CR_MP
arcpy.AddField_management("LFAR_CRASHES", "BeginCMP", "LONG")
arcpy.AddField_management("LFAR_CRASHES", "EndCMP", "LONG")
#take the crash location and calculate the integer part of the Logmile
arcpy.CalculateField_management("LFAR_CRASHES", "BeginCMP", "long( !CRMP! )",
"PYTHON_9.3", "#")
#and add one to it - now we have the crashes overlapping every mile covering the extent of the LRS Geometry
arcpy.CalculateField_management("LFAR_CRASHES", "EndCMP", "long( !CRMP! )+1",
"PYTHON_9.3", "#")
#locate the events now as lines
#dissolve the lines as follows
arcpy.MakeRouteEventLayer_lr("LRS_Route_CRM", "LRS_KEY", "LFAR_CRASHES",
"LRS_KEY LINE BeginCMP EndCMP",
"LFAR_CRASHES lines", "#", "ERROR_FIELD",
#check plotWRT boolean
if plotWRT == 'true':
#create points that represent the intersections between the profile lines
#and the single intersection line
intersectFC = outName + '_intersectPts'
arcpy.Intersect_analysis([linesLayer, wrtLineFC], intersectFC, '#', '#', 'POINT')
#now, locate those points on the profile routes
#a field called 'mValue' will be created that shows the distance
#from the beginning of the profile line to the point of intersection
#the offset required to plot the profile wrt to the intersecting line
intersectTab = outName + '_intersectTab'
rProps = 'rkey POINT mValue'
arcpy.AddMessage('Locating ' + linesLayer + ' on ' + zmLines)
arcpy.LocateFeaturesAlongRoutes_lr(intersectFC, zmLines, 'ORIG_FID', 1, intersectTab, rProps, 'FIRST', 'NO_DISTANCE', 'NO_ZERO')
#now update the profiles
profiles = arcpy.UpdateCursor(zmProfiles)
maxY = 0
minY = 0
for profile in profiles:
#get the offset for this profile
#first, get the route key of this profile
rte = profile.ORIG_FID
if not rte == None:
#and create a search cursor of hopefully just one row where the rkeys
#in the profiles fc and the intersect table are the same
where = '"rkey" = ' + str(rte)
#rows = arcpy.SearchCursor(intersectTab, where)
def recalculate_mileposts(self):
arcpy.AddMessage("recalculating mileposts")
routes = self._get_unique_routes()
#: Identity_analysis creates multipart features. Bust them up.
arcpy.MultipartToSinglepart_management(
self._output._intermediate_identity_city_and_county,
self._output._intermediate_singlepart_data)
#: Intermediate step to recalculate milepost values. Need to from values of road as points
arcpy.FeatureVerticesToPoints_management(
self._output._intermediate_singlepart_data,
self._output._intermediate_feature_to_vertices, "BOTH_ENDS")
routesCompleted = 0
totalRoutes = len(routes)
for route in routes:
#Limit Locatefeature with a def query
#: Creates table with new milepost values
if routesCompleted % 10 == 0:
arcpy.AddMessage("route recalculations remaining: {}".format(
totalRoutes - routesCompleted))
route_with_direction = route
route = route[:4]
arcpy.MakeFeatureLayer_management(
self._input.lrs_routes, "definitionQueryRoute{}".format(route),
"""{} = '{}'""".format(
arcpy.AddFieldDelimiters(self._input.lrs_routes,
'RT_NAME'), route))
self.delete_if_exists(
[self._output._intermediate_mileposts_along_route])
arcpy.LocateFeaturesAlongRoutes_lr(
in_features=self._output._intermediate_feature_to_vertices,
in_routes="definitionQueryRoute{}".format(route),
route_id_field="RT_NAME",
radius_or_tolerance="50 Meter",
out_table=self._output._intermediate_mileposts_along_route,
out_event_properties="RID POINT MEAS",
route_locations="FIRST",
distance_field=False,
zero_length_events="ZERO",
in_fields="FIELDS",
m_direction_offsetting=True)
new_mileposts = self._get_new_milepost_values(route_with_direction)
where_clause = """{} = '{}'""".format(
arcpy.AddFieldDelimiters(
self._output._intermediate_singlepart_data,
self._fields.route_name), route_with_direction)
with UpdateCursor(
self._output._intermediate_singlepart_data,
("OID@", self._fields.from_milepost, self._fields.to_milepost),
where_clause) as cursor:
for row in cursor:
original_feature_id = row[0]
if original_feature_id not in new_mileposts:
print "objectid: {} was not found along LRS Routes. Data mismatch?".format(
original_feature_id)
continue
mileposts = sorted(new_mileposts[original_feature_id])
if len(mileposts) is not 2:
raise Exception(
"Road segment with id {} does not fall within a 50 meter diameter of LRS data. Fix data or update radius_or_tolerance value."
.format(row[0]))
if mileposts[0] > mileposts[1]:
print "objectid: {} has to milepost smaller than from milepost. Data issue?".format(
original_feature_id)
row[1] = mileposts[0]
row[2] = mileposts[1]
cursor.updateRow(row)
routesCompleted += 1
return routes
def create_cond_events(workspace, condition, condlec_nodes_fc, condition_field,
routes_fc, routes_id_field, point_search_meters,
clean_up_temp_files):
"""
:param workspace:
:param condition:
:param condlec_nodes_fc:
:param condition_field:
:param routes_fc:
:param routes_id_field:
:param point_search_meters:
:param clean_up_temp_files:
:return:
"""
# STEP 0: Set-up
# Take the user parameter for search radius and append linear unit measurement for string
search_distance = "{0} Meters".format(str(point_search_meters))
# Create workspace file geodatabase
timestamp = '{:%Y%m%d_%H%M}'.format(datetime.datetime.now())
workspace_gdb_name = "ConditionPostProcessing_{0}".format(timestamp)
arcpy.AddMessage("Creating workspace file geodatabase '{0}'...".format(
workspace_gdb_name))
workspace_gdb = arcpy.CreateFileGDB_management(
workspace, workspace_gdb_name).getOutput(0)
os.chdir(workspace)
if os.path.isfile(os.path.join(workspace, "work_routes_lyr")):
arcpy.AddMessage("Removing previously-existing layers...")
os.remove(os.path.join(workspace, "work_routes_lyr"))
work_event_table = os.path.join(workspace_gdb, "work_cond_events_table")
out_condition_event_fc = os.path.join(workspace_gdb,
"out_{0}_events".format(condition))
# STEP 1: Create copy of our routes and condition points so we can operate on them for the splitting by point step.
arcpy.AddMessage("Copying data to workspace...")
work_nodes_fc = arcpy.FeatureClassToFeatureClass_conversion(
condlec_nodes_fc, workspace_gdb, "work_condition_nodes").getOutput(0)
work_routes_fc = arcpy.FeatureClassToFeatureClass_conversion(
routes_fc, workspace_gdb, "work_routes").getOutput(0)
work_routes_lyr = arcpy.MakeFeatureLayer_management(
routes_fc, "work_routes_lyr").getOutput(0)
# STEP 2: Perform Select-by-Location using the input points on the routes copy - the idea is to select only the
# lines that were evaluated. Export this selection to disk as "Evaluated_Routes".
arcpy.AddMessage("Finding evaluated roads...")
arcpy.SelectLayerByLocation_management(work_routes_lyr, "INTERSECT",
work_nodes_fc, search_distance)
work_routes_evaluated = arcpy.CopyFeatures_management(
work_routes_lyr, os.path.join(workspace_gdb,
"work_evaluated_routes")).getOutput(0)
# STEP 3: Use Split Line by Point to fracture the Routes into lines that are determined by the points entered.
# Make sure to enter a search area.
arcpy.AddMessage("Creating condition segments...")
#TODO - Use the near tool to find the nearest point on the line instead of a search radius for "SplitLineAtPoint"
work_route_evaluated_segments = arcpy.SplitLineAtPoint_management(
in_features=work_routes_evaluated,
point_features=work_nodes_fc,
out_feature_class=os.path.join(workspace_gdb,
"work_evaluated_route_segments"),
search_radius=search_distance).getOutput(0)
# STEP 4: Transfer the condition from the points to the line segments by using spatial join
arcpy.AddMessage(
"Transferring condition attributes to condition route segments...")
arcpy.SpatialJoin_analysis(target_features=work_route_evaluated_segments,
join_features=work_nodes_fc,
out_feature_class=os.path.join(
workspace_gdb,
"work_evaluated_route_segment_conditions"),
join_operation="JOIN_ONE_TO_ONE",
join_type="KEEP_ALL",
match_option="INTERSECT",
search_radius=search_distance,
distance_field_name="closest_node_distance")
work_evaluated_route_segment_conditions = os.path.join(
workspace_gdb, "work_evaluated_route_segment_conditions")
# STEP 5: Correct for the first line segment by selecting it and changing the condition rating to "Excellent"
arcpy.AddMessage("Adding default start segment condition...")
with arcpy.da.UpdateCursor(work_evaluated_route_segment_conditions,
condition_field) as cursor:
for row in cursor:
row[0] = "Excellent"
cursor.updateRow(row)
break
# STEP 6: Create event table using condition segments
arcpy.LocateFeaturesAlongRoutes_lr(
in_features=work_evaluated_route_segment_conditions,
in_routes=work_routes_evaluated,
route_id_field=routes_id_field,
out_table=work_event_table,
radius_or_tolerance=search_distance,
out_event_properties="RID LINE FMEAS TMEAS",
route_locations="FIRST",
distance_field="DISTANCE",
zero_length_events="ZERO",
in_fields="FIELDS",
m_direction_offsetting="M_DIRECTON")
# GP Tool: Table conversion of edited events to a feature layer.
work_condition_events_lyr = arcpy.MakeRouteEventLayer_lr(
in_routes=routes_fc,
route_id_field=routes_id_field,
in_table=work_event_table,
in_event_properties="rid LINE fmeas tmeas",
out_layer="work_condition_events_lyr").getOutput(0)
# GP Tool: Copy feature layer to disk as feature class.
arcpy.CopyFeatures_management(in_features=work_condition_events_lyr,
out_feature_class=out_condition_event_fc)
# Optional clean-up of temp data.
if clean_up_temp_files:
arcpy.AddMessage("Cleaning up temporary content...")
# print("Cleaning up temporary content...")
content_to_delete = [
work_evaluated_route_segment_conditions, work_nodes_fc,
work_routes_lyr, work_condition_events_lyr, work_event_table,
work_route_evaluated_segments, work_routes_evaluated,
work_routes_fc
]
for item in content_to_delete:
arcpy.Delete_management(item)
arcpy.AddMessage("Temp files cleaned up.")
del updateRows
del row
#Use spatial join on target(endPoints) and join(OutputTransect)
arcpy.SpatialJoin_analysis(endPoints, OutputTransect, endptTransctJoin)
#Locate endpoint features along streamline route
#Correct left/right orientation depends on direction that the streamlines were produced;
#either from Mark's tools, or from digitizing direction
arcpy.AddMessage("Locating endpoints along streamline route... ")
props = "RID POINT MEAS"
#Set search radius for locating features, set to the value of transect spacing minus 1
distnce = str(DistanceSplit) + locateFeatUnit
#Save the table as "locate_points" back into the wrkSpace user-inputted save location
arcpy.LocateFeaturesAlongRoutes_lr(endptTransctJoin, strmCenterline,
"Route", distnce, "locate_points",
props, "FIRST", "DISTANCE", "NO_ZERO",
"FIELDS", "NO_M_DIRECTION")
#Create XY event layer from linear referencing table
arcpy.MakeXYEventLayer_management("locate_points", "X_UTM", "Y_UTM",
tableLayer, spatial_reference)
#Find endpoints that are either on the left/right side of the streamline route
arcpy.AddMessage(
"Finding endpoints that are river left vs. river right... ")
rivLeftExpr = '"DISTANCE" <= 0'
rivRightExpr = '"DISTANCE" >= 0'
ptRiverLeft = arcpy.FeatureClassToFeatureClass_conversion(
tableLayer, General_GDB, "ptRiverLeft", rivLeftExpr)
ptRiverRight = arcpy.FeatureClassToFeatureClass_conversion(
tableLayer, General_GDB, "ptRiverRight", rivRightExpr)
def ImportIntAtt(Intersections, TrafficControl, Routes, RouteID, BMP, EMP,
AttTable, Fields, Output, OutputTable):
def FindAngle(O, P):
import math
if P[0] == O[0]:
if P[1] == O[1]:
#arcpy.AddWarning(str(O) + str(P))
return 0 #1
else:
if P[1] > O[1]:
return 90 #2
if P[1] < O[1]:
return 270 #3
else:
if P[1] == O[1]:
if P[0] > O[0]:
return 0 #4
else:
return 180 #5
else:
if (P[0] - O[0]) > 0 and (P[1] - O[1]) > 0:
return math.degrees(
math.atan((P[1] - O[1]) / (P[0] - O[0]))) #6
elif (P[0] - O[0]) > 0 and (P[1] - O[1]) < 0:
return 360 - math.degrees(
math.atan(-(P[1] - O[1]) / (P[0] - O[0]))) #7
elif (P[0] - O[0]) < 0 and (P[1] - O[1]) > 0:
return 180 - math.degrees(
math.atan(-(P[1] - O[1]) / (P[0] - O[0]))) #8
elif (P[0] - O[0]) < 0 and (P[1] - O[1]) < 0:
return 180 + math.degrees(
math.atan((P[1] - O[1]) / (P[0] - O[0])))
def FindClosestPoint(PolylineList, IntPoint):
n = len(PolylineList)
Dist0 = ((PolylineList[0][0] - IntPoint[0])**2 +
(PolylineList[0][1] - IntPoint[1])**2)**0.5
Distn = ((PolylineList[n - 1][0] - IntPoint[0])**2 +
(PolylineList[n - 1][1] - IntPoint[1])**2)**0.5
if Dist0 <= Distn:
return [PolylineList[0], PolylineList[1]]
else:
return [PolylineList[n - 1], PolylineList[n - 2]]
Buffer = "80 Feet"
Tolerance = "10 Feet"
Int = common.CreateOutPath(MainFile=Output, appendix='Int', Extension='')
arcpy.Intersect_analysis(in_features=Routes,
out_feature_class=Int,
join_attributes="ALL",
cluster_tolerance="-1 Unknown",
output_type="POINT")
SPJ = common.CreateOutPath(MainFile=Output, appendix='SPJ', Extension='')
arcpy.SpatialJoin_analysis(target_features=Int,
join_features=Intersections,
out_feature_class=SPJ,
join_operation="JOIN_ONE_TO_ONE",
join_type="KEEP_COMMON",
match_option="CLOSEST",
search_radius=Buffer,
distance_field_name="")
arcpy.DeleteIdentical_management(in_dataset=SPJ,
fields=arcpy.Describe(SPJ).ShapeFieldName,
xy_tolerance="",
z_tolerance="0")
OrgFields = [f.name for f in arcpy.ListFields(Intersections)]
arcpy.DeleteField_management(SPJ, [
f.name for f in arcpy.ListFields(SPJ)
if not f.required and not f.name in OrgFields
])
arcpy.SpatialJoin_analysis(target_features=SPJ,
join_features=TrafficControl,
out_feature_class=Output,
join_operation="JOIN_ONE_TO_ONE",
join_type="KEEP_COMMON",
match_option="CLOSEST",
search_radius=Buffer,
distance_field_name="")
OrgFields.extend(['TRAF_CONT', 'LEG_COUNT', 'PeerGroup_CH2M_TJM'])
arcpy.DeleteField_management(Output, [
f.name for f in arcpy.ListFields(Output)
if not f.required and not f.name in OrgFields
])
EventTable = common.CreateOutPath(MainFile=Output,
appendix='EventTable',
Extension='')
arcpy.LocateFeaturesAlongRoutes_lr(in_features=Output,
in_routes=Routes,
route_id_field=RouteID,
radius_or_tolerance=Tolerance,
out_table=EventTable,
out_event_properties=" ".join(
[RouteID, "POINT", "MP"]),
route_locations="ALL",
in_fields="FIELDS",
m_direction_offsetting="M_DIRECTON")
# Milepost Correction
EMPDict = {
r.getValue('INVENTORY'): r.getValue('Shape').lastPoint.M
for r in arcpy.SearchCursor(Routes)
}
r = 0
uc = arcpy.UpdateCursor(EventTable)
for r in uc:
inv = r.getValue('INVENTORY')
MP = r.getValue('MP')
if MP < 0:
r.setValue('MP', 0)
uc.updateRow(r)
if MP > EMPDict[inv]:
r.setValue('MP', EMPDict[inv])
uc.updateRow(r)
del uc, r
AllF = [f.name for f in arcpy.ListFields(AttTable)]
MF = [f for f in Fields if not f in AllF]
if not MF == []:
print(str(MF) + ' not found in ' + AttTable)
IRIS_Diss = common.CreateOutPath(MainFile=Output,
appendix='diss',
Extension='')
arcpy.DissolveRouteEvents_lr(
in_events=AttTable,
in_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
dissolve_field=';'.join(Fields),
out_table=IRIS_Diss,
out_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
dissolve_type="DISSOLVE",
build_index="INDEX")
arcpy.OverlayRouteEvents_lr(
in_table=EventTable,
in_event_properties=' '.join([RouteID, 'POINT', 'MP']),
overlay_table=IRIS_Diss,
overlay_event_properties=' '.join([RouteID, 'LINE', BMP, EMP]),
overlay_type="INTERSECT",
out_table=OutputTable,
out_event_properties=' '.join([RouteID, 'POINT', 'MP']),
in_fields="FIELDS",
build_index="INDEX")
common.AddField(Output, [
fields_SC.intr.AADT_Major, fields_SC.intr.AADT_Minor,
fields_SC.crash.ABuffer, fields_SC.crash.BBuffer
])
arcpy.AddField_management(OutputTable, 'ApprType', 'TEXT')
#arcpy.AddField_management(OutputTable,'ApprDeg','Double')
Approach = {r.getValue('SiteID'): [] for r in arcpy.SearchCursor(Output)}
OID = arcpy.Describe(OutputTable).OIDFieldName
for r in arcpy.SearchCursor(OutputTable):
k = r.getValue('SiteID')
if k in Approach.keys():
Approach[k].append({
'OID': r.getValue(OID),
'INV': r.getValue('INVENTORY'),
'AADT': common.GetIntVal(r, 'AADT'),
'Lanes': common.GetIntVal(r, 'LNS', 2),
'Urban': r.getValue('URBAN'),
'SurfWid': common.GetFloatVal(r, 'SURF_WTH', 24),
'MedWid': common.GetFloatVal(r, 'MED_WTH')
})
for k in Approach.keys():
AADT = [i['AADT'] for i in Approach[k]]
INV = [i['INV'] for i in Approach[k]]
major_i = AADT.index(max(AADT))
major_inv = INV[major_i]
for i, appr in enumerate(Approach[k]):
if appr['AADT'] == max(AADT) or appr['INV'] == major_inv:
Approach[k][i].update({'ApprType': 'Major'})
else:
Approach[k][i].update({'ApprType': 'Minor'})
UC = arcpy.UpdateCursor(OutputTable)
for r in UC:
k = r.getValue('SiteID')
o = r.getValue(OID)
Type = ''
for appr in Approach[k]:
if appr['OID'] == o:
Type = appr['ApprType']
r.setValue('ApprType', Type)
UC.updateRow(r)
UC = arcpy.UpdateCursor(Output)
for r in UC:
k = r.getValue('SiteID')
try:
r.setValue(
fields_SC.intr.AADT_Major['name'],
max([
appr['AADT'] for appr in Approach[k]
if appr['ApprType'] == 'Major'
]))
except:
r.setValue(fields_SC.intr.AADT_Major['name'], 0)
try:
r.setValue(
fields_SC.intr.AADT_Minor['name'],
max([
appr['AADT'] for appr in Approach[k]
if appr['ApprType'] == 'Minor'
]))
except:
r.setValue(fields_SC.intr.AADT_Minor['name'], 0)
try:
W_Major = max([
appr['SurfWid'] + appr['MedWid'] for appr in Approach[k]
if appr['ApprType'] == 'Major'
])
except:
W_Major = 24
try:
W_Minor = max([
appr['SurfWid'] + appr['MedWid'] for appr in Approach[k]
if appr['ApprType'] == 'Minor'
])
except:
W_Minor = 24
ABuffer = max(1.2 * (W_Major**2 + W_Minor**2)**0.5, 50)
r.setValue(fields_SC.crash.ABuffer['name'], ABuffer)
r.setValue(fields_SC.crash.BBuffer['name'], max(ABuffer, 250))
AADT = [i['AADT'] for i in Approach[k]]
major_i = AADT.index(max(AADT))
LaneMajor = [i['Lanes'] for i in Approach[k]][0]
UC.updateRow(r)
arcpy.Delete_management(Int)
arcpy.Delete_management(EventTable)
arcpy.Delete_management(SPJ)
arcpy.Delete_management(IRIS_Diss)
