def __enter__(self):
arcpy.CheckOutExtension("3D")
arcpy.CheckOutExtension("Spatial")
self.scratch = self.config['scratch']
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.output_workspace = self.config['output_workspace']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.flood_original =self.config['flood_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.sr = self.config['sr']
self.tin_folder=self.config['tin_folder']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.backwater=self.config['backwater']
self.flood_boundary=self.config['flood_boundary']
self.flood_dataset=self.config['flood_dataset']
self.wsel_field=self.config['wsel_field']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.scratchWorkspace = self.scratchgdb
env.parallelProcessingFactor = "0"
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __enter__(self):
self.scratch = self.config['scratch']
self.table_folder =self.config['table_folder']
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.output_workspace = self.config['output_workspace']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.flood_original =self.config['flood_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.streams_zm =self.config['streams_zm']
self.sr = self.config['sr']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratch
#env.parallelProcessingFactor = "4"
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
class WSEL_Stream_Setup:
def __init__(self, config, streams):
self.streams = streams
self.config = config
arcpy.CheckOutExtension("3D")
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.streams_original = self.config['streams_original']
self.streams_dataset = self.config['streams_dataset']
self.rid_field = self.config['rid_field']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return self
def processStream(self):
for stream in self.streams:
name = stream
self.safe_print.print_out("Configuring stream "+name)
expression = "'"+name+"'"
stream =arcpy.CopyFeatures_management(self.streams_original+"\\"+name+"_stream_feature", self.streams_dataset+"\\"+name+"_stream_feature" )
arcpy.AddField_management(stream, "strm_length", "FLOAT",10,3)
arcpy.CalculateField_management(stream, "strm_length", "float(!SHAPE.LENGTH!)","PYTHON")
arcpy.AddField_management(stream,"Route_ID","TEXT","","",50)
arcpy.CalculateField_management(stream,"Route_ID",expression,"PYTHON")
return self.streams
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.streams_original = self.config['streams_original']
self.streams_dataset = self.config['streams_dataset']
self.rid_field = self.config['rid_field']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
class WSEL_Intersects:
def __init__(self, config):
self.config = config
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.streams_original = self.config['streams_original']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.streams_dataset = self.config['streams_dataset']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return self
def get_intersect_all(self,comb_streams):
self.safe_print.print_out("Intersecting all streams")
env.workspace = self.streams_dataset
streams_intersect = []
tempLayer = "streamLayer"
streamLayer="streamsAll"
expression = """ "Route_ID" = "Route_ID_1" """
fieldName = "WSEL"
stream_array = [fc for fc in arcpy.ListFeatureClasses() if fc.endswith('_stream_feature')]
clusterTolerance = 0
for stream in stream_array:
sep = '_'
name = stream.split(sep, 1)[0]
self.safe_print.print_out("Intersecting "+name)
expression2 = """ "Route_ID" <>"""+"'"+name+"'"
arcpy.SelectLayerByAttribute_management(comb_streams, "NEW_SELECTION",expression2)
outFeature = self.streams_intersect_dataset+"/"+name+'_pt_intersect'
streams_intersect.append(outFeature)
pt = arcpy.Intersect_analysis([stream,comb_streams], outFeature, "ALL", clusterTolerance, "POINT")
arcpy.AddXY_management(pt)
arcpy.AddField_management(pt, fieldName,"FLOAT",10,3)
arcpy.MakeFeatureLayer_management(pt, tempLayer)
arcpy.SelectLayerByAttribute_management(tempLayer, "NEW_SELECTION",expression)
if int(arcpy.GetCount_management(tempLayer).getOutput(0)) > 0:
arcpy.DeleteFeatures_management(tempLayer)
env.workspace = scratchgdb
return
def processStream(self):
comb_streams = self.scratchgdb+'\\streams_all'
streams_layer = arcpy.MakeFeatureLayer_management(comb_streams,"streams_lyr")
intersect=self.get_intersect_all(streams_layer)
return intersect
class WSEL_Step_1:
def __init__(self, config, streams):
self.streams = streams
self.config = config
arcpy.CheckOutExtension("3D")
def __enter__(self):
self.scratch = self.config['scratch']
self.table_folder =self.config['table_folder']
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.output_workspace = self.config['output_workspace']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.flood_original =self.config['flood_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.streams_zm =self.config['streams_zm']
self.sr = self.config['sr']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratch
#env.parallelProcessingFactor = "4"
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return
def get_intersection(self, stream, xs, name):
self.safe_print.print_out("Getting Intersection between "+name+"'s Stream and XS files")
inFeatures = [stream, xs]
intersectOutput = self.xs_intersect_dataset+"/"+name+"_xs_pt"
clusterTolerance = 0
pt = arcpy.Intersect_analysis(inFeatures, intersectOutput, "ALL", clusterTolerance, "POINT")
self.feature = arcpy.FeatureToPoint_management(pt, self.xs_intersect_dataset+"/"+name+"_xs_pt_feature","CENTROID")
arcpy.Delete_management(pt)
return self.feature
def add_routes(self,stream,xs_pt,name,status):
rid = "Route_ID"
if status == 0:
self.safe_print.print_out("Adding Z-values to Polyline ZM")
mfield="WSEL"
pts = xs_pt
if status == 1:
self.safe_print.print_out("Adding M-values to Polyline ZM")
mfield ="XS_Station"
#need to add 0 station at beginning of line becuase the beginning of the stream line needs to match exactly
stationList = [r[0] for r in arcpy.da.SearchCursor (xs_pt, [mfield])]
min_station = min(stationList)
if min_station > 0:
self.safe_print.print_out("Creating zero station before processing")
pts = self.add_zero_station(stream, xs_pt,min_station,name)
out_fc = self.routes_dataset+"/"+name+"_stream_routes"
rts = stream
out_routes = self.routes_dataset+"/stream_measures"
route_evt_layer_temp =name+"_evt_lyr"
route_evt_layer= self.scratch+"\\"+name+"_evt"
props = "RID POINT MEAS"
out_table =self.table_folder+"\\route_loc.dbf"
route_meas = arcpy.CreateRoutes_lr(rts, rid, out_routes,"LENGTH", "#", "#", "UPPER_LEFT",1,0,"IGNORE", "INDEX")
loc_features = arcpy.LocateFeaturesAlongRoutes_lr(pts, route_meas, rid, "0", out_table, props, 'FIRST', 'NO_DISTANCE','NO_ZERO','FIELDS')
evt_lyr = arcpy.MakeRouteEventLayer_lr(route_meas, rid, loc_features, props, route_evt_layer_temp, "#", "NO_ERROR_FIELD", "NO_ANGLE_FIELD","NORMAL","ANGLE", "LEFT", "POINT")
lyr = arcpy.SaveToLayerFile_management(evt_lyr, route_evt_layer, "RELATIVE")
if status == 0:
routes = arcpy.CalibrateRoutes_lr (route_meas, rid, lyr, rid, mfield, out_fc,"MEASURES","0","BETWEEN","BEFORE","AFTER","IGNORE","KEEP","INDEX")
else:
routes = arcpy.CalibrateRoutes_lr (route_meas, rid, lyr, rid, mfield, out_fc,"MEASURES","0","BETWEEN","NO_BEFORE","AFTER","IGNORE","KEEP","INDEX")
arcpy.Delete_management(loc_features)
arcpy.Delete_management(route_meas)
arcpy.Delete_management(lyr)
return routes
def add_zero_station(self, stream, xs_pt, min_station, name):
tempLayer="min_stationxs"
temp_pt_Layer="zero_station"
keep_fields = [f.name for f in arcpy.ListFields(xs_pt)]
fieldName = "XS_Station"
fieldName2 = "OBJECTID"
sqlExp = "{0} = {1}".format(fieldName, min_station)
sqlExp2 = "'{0}'".format(name)
arcpy.MakeFeatureLayer_management(xs_pt, tempLayer)
arcpy.SelectLayerByAttribute_management(tempLayer, "NEW_SELECTION", sqlExp)
pts = arcpy.FeatureVerticesToPoints_management(stream, self.vertices_dataset+'/'+name+"_endpts","BOTH_ENDS")
stream_startend= arcpy.FeatureToPoint_management(pts,self.vertices_dataset+'/'+ name+"_endpts_feature","CENTROID")
arcpy.Delete_management(pts)
arcpy.Near_analysis(tempLayer, stream_startend)
start_oid =[r[0] for r in arcpy.da.SearchCursor (xs_pt,("NEAR_FID"),where_clause=sqlExp)][0]
sqlExp3 = "{0} <> {1}".format(fieldName2, start_oid)
arcpy.MakeFeatureLayer_management(stream_startend, temp_pt_Layer)
arcpy.SelectLayerByAttribute_management(temp_pt_Layer, "NEW_SELECTION", sqlExp3)
if int(arcpy.GetCount_management(temp_pt_Layer).getOutput(0)) > 0:
arcpy.DeleteFeatures_management(temp_pt_Layer)
arcpy.AddField_management(stream_startend,'XS_Station',"FLOAT")
arcpy.CalculateField_management(stream_startend, 'XS_Station', 0, "VB")
arcpy.AddField_management(stream_startend,'Route_ID',"TEXT","","",50)
arcpy.CalculateField_management(stream_startend, 'Route_ID', sqlExp2, "PYTHON")
stream_start =[r for r in arcpy.da.SearchCursor (stream_startend,("Route_ID","XS_Station","Shape@XY","Shape@Z","Shape@M"))]
cursor = arcpy.da.InsertCursor(xs_pt, ("Route_ID","XS_Station","Shape@XY","Shape@Z","Shape@M"))
for row in stream_start:
cursor.insertRow(row)
fields = [f.name for f in arcpy.ListFields(xs_pt) if not f.required and f.name not in keep_fields ]
arcpy.DeleteField_management(xs_pt, fields)
return xs_pt
def vertices_to_pts(self, feature,name):
pts = arcpy.FeatureVerticesToPoints_management(feature, self.vertices_dataset+'/'+name+"_pts","ALL")
self.verticies = arcpy.FeatureToPoint_management(pts,self.vertices_dataset+'/'+ name+"_vertices_feature","CENTROID")
arcpy.Delete_management(pts)
return self.verticies
def processStream(self):
all_streams = self.streams
env.overwriteOutput = True
for streams in all_streams:
name = streams
self.safe_print.print_out("Step 1 processing "+name)
stream = self.streams_dataset+"\\"+name+"_stream_feature"
xs = self.xs_dataset+'\\'+ name+'_xs'
xs_intersect_pt = self.get_intersection(stream, xs, name)
keep_fields = [f.name for f in arcpy.ListFields(stream)]
routes = self.add_routes(stream, xs_intersect_pt, name, 0)
streampt = self.vertices_to_pts(routes, name+'_stream')
streamxy = arcpy.AddXY_management(streampt)
dpts = arcpy.FeatureTo3DByAttribute_3d(streamxy, self.streams_zm+'/'+ name+"_pts_temp", 'POINT_M')
dpts_clean = arcpy.FeatureToPoint_management(dpts, self.streams_zm+'/'+ name+"_pts_zm","CENTROID")
arcpy.Delete_management(dpts)
streamline = arcpy.PointsToLine_management(dpts_clean, self.streams_zm+'/'+ name+"_line_zm")
updated_stream = arcpy.SpatialJoin_analysis(streamline, stream, self.streams_zm+'/'+ name+"_zm")
fields = [f.name for f in arcpy.ListFields(updated_stream) if not f.required and f.name not in keep_fields ]
arcpy.DeleteField_management(updated_stream, fields)
routes = self.add_routes(updated_stream,xs_intersect_pt, name, 1)
streampt = self.vertices_to_pts(routes, name+'_stream')
streamxy = arcpy.AddXY_management(streampt)
arcpy.DeleteField_management(routes, fields)
return
class WSEL_Step_5:
def __init__(self, config, streams):
self.streams = streams
self.config = config
def __enter__(self):
arcpy.CheckOutExtension("3D")
arcpy.CheckOutExtension("Spatial")
self.scratch = self.config['scratch']
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.output_workspace = self.config['output_workspace']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.flood_original =self.config['flood_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.sr = self.config['sr']
self.tin_folder=self.config['tin_folder']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.backwater=self.config['backwater']
self.flood_boundary=self.config['flood_boundary']
self.flood_dataset=self.config['flood_dataset']
self.wsel_field=self.config['wsel_field']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.scratchWorkspace = self.scratchgdb
env.parallelProcessingFactor = "0"
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return self.result
def points_to_tin(self, points, xs_lines, name):
out_raster = self.output_workspace+name+'_'+self.wsel_field
self.safe_print.print_out("Converting "+name+" elevation points to Tin")
tin = self.tin_folder+"\\tin_"+name
heightfield = "POINT_Z"
xs_height ="WSEL_REG"
projection = arcpy.SpatialReference(self.sr)
tin_out = arcpy.CreateTin_3d(tin, projection, [[points, heightfield , "Mass_Points"],[xs_lines,xs_height,"hardline"]], "CONSTRAINED_DELAUNAY")
self.safe_print.print_out("Converting "+name+" Tin to Raster")
raster = arcpy.TinRaster_3d(tin_out, out_raster, "FLOAT", "LINEAR", "CELLSIZE 3", 1)
return raster
def backwater_correction(self, points, xs_lines, name):
sqlexp ="{0}={1}".format("Backwater", "'no'")
sqlexp3="Shape_Area"
sql_intersect ="{0}={1}".format("Route_ID", "'"+name+"'")
sql_raster ="{0}={1}".format("Removed", "'no'")
out_raster = self.output_workspace+name+'_'+self.wsel_field
keep_fields = ["Removed","flood_area","flood_check"]
boundary = self.flood_original+"\\"+name+"_flood_boundary"
intersect_name = [r[0] for r in arcpy.da.SearchCursor (self.scratchgdb+'\\streams_intersect_all_2', ["Intersects"],sql_intersect)]
avail_intersect = len(intersect_name)
if avail_intersect>0:
intersect_bound = self.flood_original+"\\"+intersect_name[0]+"_flood_boundary"
temp_bound = self.flood_dataset+"\\"+name+"_flood_temp"
flood_bound = self.flood_dataset+"\\"+name+"_boundary"
dis_bound =self.flood_dataset+"\\"+name+"_flood_dis"
erase1 =self.flood_dataset+"\\"+name+"_flood_erase1"
erase2 =self.flood_dataset+"\\"+name+"_flood_erase2"
pts_layer = arcpy.MakeFeatureLayer_management (points, "pts")
xs_layer = arcpy.MakeFeatureLayer_management (xs_lines, "xs")
arcpy.Near_analysis(pts_layer, xs_layer)
arcpy.AddJoin_management(pts_layer,"NEAR_FID",xs_layer,"OBJECTID")
arcpy.SelectLayerByAttribute_management(xs_layer,"CLEAR_SELECTION",sqlexp)
arcpy.SelectLayerByAttribute_management(pts_layer,"CLEAR_SELECTION",sqlexp)
#arcpy.SelectLayerByAttribute_management(xs_layer,"NEW_SELECTION",sqlexp)
#arcpy.SelectLayerByAttribute_management(pts_layer,"NEW_SELECTION",sqlexp)
#if int(arcpy.GetCount_management(xs_layer).getOutput(0)) <= 0:
#arcpy.SelectLayerByAttribute_management(xs_layer,"CLEAR_SELECTION",sqlexp)
#arcpy.SelectLayerByAttribute_management(pts_layer,"CLEAR_SELECTION",sqlexp)
tin = self.tin_folder+"\\tin_"+name
heightfield = "POINT_Z"
xs_height ="WSEL_REG"
projection = arcpy.SpatialReference(self.sr)
#tin_out = arcpy.CreateTin_3d(tin, projection, [[pts_layer, heightfield , "Mass_Points"],[xs_layer,xs_height,"hardline"]], "CONSTRAINED_DELAUNAY")
#raster = arcpy.TinRaster_3d(tin_out, out_raster, "INT", "LINEAR", "CELLSIZE 3", 1)
#arcpy.RasterToPolygon_conversion(raster, temp_bound, "NO_SIMPLIFY")
#arcpy.Dissolve_management(temp_bound,dis_bound,"#","#","SINGLE_PART")
if self.flood_boundary == True and avail_intersect != 0:
arcpy.AddField_management(boundary, "Removed", "TEXT",4)
arcpy.CalculateField_management(boundary, "Removed", "'no'","PYTHON")
arcpy.Erase_analysis(boundary, intersect_bound, erase1)
arcpy.Erase_analysis(boundary,erase1,erase2)
arcpy.CalculateField_management(erase2, "Removed", "'yes'","PYTHON")
arcpy.Merge_management([erase1,erase2],temp_bound)
arcpy.Delete_management(erase1)
arcpy.Delete_management(erase2)
else:
arcpy.CopyFeatures_management(boundary,temp_bound)
arcpy.AddField_management(temp_bound, "Removed", "TEXT",4)
arcpy.CalculateField_management(temp_bound, "Removed", "'no'","PYTHON")
arcpy.MultipartToSinglepart_management(temp_bound,flood_bound)
arcpy.AddField_management(flood_bound, "flood_area", "FLOAT",10,3)
arcpy.CalculateField_management(flood_bound, "flood_area", "float(!SHAPE.AREA!)","PYTHON")
arcpy.AddField_management(flood_bound, "flood_check", "TEXT",4)
arcpy.CalculateField_management(flood_bound, "flood_check", "'no'","PYTHON")
temp_poly =arcpy.CopyFeatures_management(flood_bound,self.flood_dataset+"\\"+name+"_flood_boundary")
areaList = [r[0] for r in arcpy.da.SearchCursor (flood_bound, ["flood_area"])]
if len(areaList)>0:
max_area = max(areaList)
sqlexp2 ="{0}<>{1}".format("flood_area", max_area)
arcpy.MakeFeatureLayer_management (temp_poly, "flood_temp")
arcpy.SelectLayerByAttribute_management("flood_temp","NEW_SELECTION",sqlexp2)
arcpy.CalculateField_management("flood_temp", "flood_check", "'yes'","PYTHON")
#if int(arcpy.GetCount_management("flood_temp").getOutput(0)) > 0:
#arcpy.DeleteFeatures_management("flood_temp")
arcpy.Delete_management(temp_bound)
#arcpy.Delete_management(dis_bound)
arcpy.Delete_management(flood_bound)
fields = [f.name for f in arcpy.ListFields(temp_poly) if not f.required and f.name not in keep_fields ]
arcpy.DeleteField_management(temp_poly, fields)
tin_out = arcpy.CreateTin_3d(tin, projection, [[pts_layer, heightfield , "Mass_Points"],[xs_layer,xs_height,"hardline"]], "CONSTRAINED_DELAUNAY")
raster = arcpy.TinRaster_3d(tin_out, out_raster, "FLOAT", "LINEAR", "CELLSIZE 1.5", 1)
if self.flood_boundary == True:
self.safe_print.print_out("Clipping "+name+"'s raster to Flood Boundary")
arcpy.MakeFeatureLayer_management(temp_poly, "flood_temp")
#arcpy.SelectLayerByAttribute_management("flood_temp","NEW_SELECTION",sql_raster)#This will clip the boundary being overlapped by the stream it is flowing into
outExtractByMask = ExtractByMask(raster, "flood_temp")
outExtractByMask.save(self.output_workspace+name+'_'+self.wsel_field)
return
def raster_extract(self, raster, name):
boundary = self.flood_original+"\\"+name+"_flood_boundary"
self.safe_print.print_out("Clipping "+name+"'s raster to Flood Boundary")
outExtractByMask = ExtractByMask(raster, boundary)
outExtractByMask.save(self.output_workspace+name+'_'+self.wsel_field)
return
def processStream(self):
all_streams = self.streams
self.result =[]
for streams in all_streams:
name = streams
self.safe_print.print_out("Step 5 processing "+name)
stream_vertices = self.vertices_dataset+'/'+name+"_stream_vertices_feature"
xs = self.xs_dataset+'/'+name+"_xs"
if self.backwater == True:
self.backwater_correction(stream_vertices ,xs, name)
else:
raster = self.points_to_tin(stream_vertices ,xs, name)
if self.flood_boundary == True:
self.raster_extract(raster, name)
self.safe_print.print_out("Finished Step 5 for "+name)
return
class WSEL_Step_3:
def __init__(self, config, streams):
self.config = config
self.streams = streams
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return self.warnings
def remove_duplicate_pts(self, stream_intersects):
###THIS MAY NOT BE NEEDED WITH THE NEW PROCESS OF INTERSECTING
self.safe_print.print_out("Removing duplicate intersection points keeping ones with higher WSEL")
tempLayer = "intersectLayer"
expression = """ "Intersects"='Delete' """
comb_intersect = stream_intersects
compare =[]
cursor = arcpy.SearchCursor(comb_intersect, ['Route_ID','Intersects','WSEL', 'XS_Section'])
for row in cursor:
compare.append([row.getValue('Route_ID'),row.getValue('Intersects'),row.getValue('WSEL'),row.getValue('XS_Section')])
del cursor
cursor = arcpy.UpdateCursor(comb_intersect, ['Intersects', 'Route_ID','WSEL','XS_Section'])
for row in cursor:
intersect = row.getValue('Intersects')
intersect_stream = row.getValue('Route_ID')
intersect_WSEL = row.getValue('WSEL')
for strm in compare:
stream = strm[1]
stream_name = strm[0]
stream_WSEL = strm[2]
if intersect == stream_name and intersect_stream == stream and intersect_WSEL < stream_WSEL:
#print(intersect_stream+": "+str(intersect_WSEL)+" "+stream_name+": "+str(stream_WSEL))
row.setValue("Intersects","Delete")
cursor.updateRow(row)
del cursor
arcpy.MakeFeatureLayer_management(comb_intersect, tempLayer)
arcpy.SelectLayerByAttribute_management(tempLayer, "NEW_SELECTION",expression)
if int(arcpy.GetCount_management(tempLayer).getOutput(0)) > 0:
arcpy.DeleteFeatures_management(tempLayer)
return
def update_xs(self, intersect_fc, xs_name):
self.safe_print.print_out("Updating All XS's with backwater WSEL")
warning ={}
error = 0
env.workspace = self.xs_dataset
#xs_array = arcpy.ListFeatureClasses()
cursor = arcpy.SearchCursor(intersect_fc, ['Route_ID', 'Intersects','WSEL','XS_Section'])
compare =[]
for row in cursor:
name = row.getValue('Route_ID')
intersect_stream = row.getValue('Intersects')
section = row.getValue('XS_Section')
if section != 0 and name == xs_name:
compare.append([name,row.getValue('WSEL'),section])
else:
error =error+1
intersection = {name:intersect_stream}
warning.update(intersection)
del cursor
for strm in compare:
xs_name= strm[0]+"_xs"
xs_WSEL= strm[1]
cursor = arcpy.UpdateCursor(xs_name, ['Route_ID','WSEL','WSEL_REG','Backwater'])
for row in cursor:
original_wsel = row.getValue('WSEL')
if original_wsel < xs_WSEL:
row.setValue("WSEL_REG",xs_WSEL)
row.setValue("Backwater","yes")
cursor.updateRow(row)
del cursor
env.workspace = self.scratchgdb
return warning
def processStream(self):
self.warnings=[]
all_streams = self.streams
for streams in all_streams:
comb_intersect = self.scratchgdb+'\\streams_intersect_all_2'
self.remove_duplicate_pts(comb_intersect)
warning = self.update_xs(comb_intersect, streams)
#self.update_xs(comb_intersect, streams)
if warning != 'null':
self.warnings.append(warning)
return self.warnings
class WSEL_XS_Check:
def __init__(self, config, streams):
self.streams = streams
self.config = config
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.wsel_field =self.config['wsel_field']
self.station_field =self.config['station_field']
self.rid_field =self.config['rid_field']
self.backwater = self.config['backwater']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return self.warnings
def FieldExist(self,featureclass, fieldname):
fieldList = arcpy.ListFields(featureclass, fieldname)
fieldCount = len(fieldList)
if (fieldCount == 1):
return True
else:
return False
def xs_check(self, xs, name):
warning ={name:[]}
expression = "["+self.wsel_field+"]"
expression2 = "["+self.station_field+"]"
expression3 = "'"+name+"'"
arcpy.AddField_management(xs,'Valid',"Double")
arcpy.AddField_management(xs,'WSEL',"FLOAT",10,3)
arcpy.AddField_management(xs,'WSEL_REG',"FLOAT",10,3)
arcpy.AddField_management(xs,'XS_Station',"FLOAT",10,3)
arcpy.AddField_management(xs,'Route_ID',"TEXT","","",254)
arcpy.CalculateField_management(xs, 'WSEL', expression, "VB")
arcpy.CalculateField_management(xs, 'WSEL_REG', expression, "VB")
arcpy.CalculateField_management(xs, 'XS_Station', expression2, "VB")
arcpy.CalculateField_management(xs, 'Valid', "0", "VB")
arcpy.CalculateField_management(xs, 'Route_ID', expression3, "PYTHON")
if self.backwater == True:
arcpy.AddField_management(xs,'Backwater',"TEXT","","",6)
arcpy.CalculateField_management(xs, 'Backwater', "'no'", "PYTHON")
cursor = arcpy.UpdateCursor(xs, fields='Valid; WSEL; XS_Station',sort_fields="XS_Station A")
count = arcpy.GetCount_management(xs).getOutput(0)
i=0
error = 0
prevrow =''
for row in cursor:
wsel = row.getValue('WSEL_REG')
section =row.getValue('XS_Station')
if section == 0:
row.setValue("Valid",1)
row.setValue("XS_Station",0.001)
cursor.updateRow(row)
if i == 0:
prevrow = wsel
if i != 0:
previous = prevrow
if previous> wsel:
error = error + 1
section = row.getValue('XS_Station')
self.safe_print.print_out("Section: " + str(section) + " invalid")
row.setValue("Valid",1)
row.setValue("WSEL",previous+0.001)
row.setValue("WSEL_REG",previous+0.001)
warning[name].append(section)
cursor.updateRow(row)
wsel = row.getValue('WSEL_REG')
prevrow = wsel
i=i+1
del row
del cursor
if error != 0:
return warning
else:
return 'null'
def processStream(self):
self.warnings=[]
for stream in self.streams:
name = stream
self.safe_print.print_out("XS Check processing stream "+name)
xs = arcpy.FeatureToLine_management(self.xs_original+"\\"+name+"_xs", self.xs_dataset+"\\"+name+"_xs")
warning = self.xs_check(xs, name)
if warning != 'null':
self.warnings.append(warning)
return self.warnings
class WSEL_Step_2:
def __init__(self, config, streams):
self.config = config
self.streams = streams
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return self
def get_intersect_all(self,comb_streams,name):
self.safe_print.print_out("Intersecting all streams")
env.workspace = self.routes_dataset
tempLayer = "streamLayer"
keep_fields =['Route_ID','WSEL','Intersects','XS_Section']
expression = """ "Route_ID" = "Intersects" """
expression2 = "[POINT_Z]"
expression4 = "[Route_ID]"
expression5 = "[Route_ID_1]"
expression6 = "[POINT_M]"
stream = self.routes_dataset +'\\'+name+'_stream_routes'
clusterTolerance = 0.01
self.safe_print.print_out("Intersecting "+name)
outFeature = self.streams_intersect_dataset+"/"+name+'_pt_intersect'
pt = arcpy.Intersect_analysis([comb_streams,stream], outFeature, "ALL", clusterTolerance, "POINT")
arcpy.AddXY_management(pt)
arcpy.AddField_management(pt, "WSEL", "FLOAT",10,3)
arcpy.AddField_management(pt,'Intersects',"TEXT","","",50)
arcpy.AddField_management(pt,'XS_Section',"FLOAT",10,3)
arcpy.CalculateField_management(pt, "WSEL", expression2, "VB")
arcpy.CalculateField_management(pt, "Intersects", expression4, "VB")
arcpy.CalculateField_management(pt, "Route_ID", expression5, "VB")
arcpy.CalculateField_management(pt, "XS_Section", expression6, "VB")
fields = [f.name for f in arcpy.ListFields(pt) if not f.required and f.name not in keep_fields ]
arcpy.DeleteField_management(pt, fields)
arcpy.MakeFeatureLayer_management(pt, tempLayer)
arcpy.SelectLayerByAttribute_management(tempLayer, "NEW_SELECTION",expression)
if int(arcpy.GetCount_management(tempLayer).getOutput(0)) > 0:
arcpy.DeleteFeatures_management(tempLayer)
env.workspace = scratchgdb
return
def processStream(self):
all_streams = self.streams
env.overwriteOutput = True
for streams in all_streams:
name = streams
comb_streams = self.scratchgdb+'\\streams_all'
streams_layer = arcpy.MakeFeatureLayer_management(comb_streams,"streams_lyr")
self.get_intersect_all(streams_layer,name)
return
class WSEL_Intersects_Clean:
def __init__(self, config):
self.config = config
def __enter__(self):
self.scratchgdb = self.config['scratchgdb']
self.xs_original = self.config['xs_original']
self.xs_dataset = self.config['xs_dataset']
self.streams_original = self.config['streams_original']
self.xs_intersect_dataset = self.config['xs_intersect_dataset']
self.streams_intersect_dataset = self.config['streams_intersect_dataset']
self.routes_dataset = self.config['routes_dataset']
self.streams_dataset = self.config['streams_dataset']
self.vertices_dataset = self.config['vertices_dataset']
self.multi=self.config['multiproc']
self.modelbuilder=self.config['modelbuilder']
self.print_config = {'multi': self.multi, 'modelbuilder': self.modelbuilder}
self.safe_print = Safe_Print(self.print_config)
env.workspace = self.scratchgdb
env.overwriteOutput = True
env.MResolution = 0.0001
env.MDomain = "0 10000000"
env.outputMFlag = "Enabled"
env.outputZFlag = "Enabled"
return self
def __exit__(self, type, value, traceback):
return
def remove_duplicate_pts(self, stream_intersects):
self.safe_print.print_out("Removing duplicate intersection points keeping ones with higher WSEL")
tempLayer = "intersectLayer"
expression = """ "Route_ID_1"='Delete' """
expression2 = "[Route_ID]"
expression3 = "[Route_ID_1]"
expression4 = "[POINT_M]"
keep_fields=['SHAPE', 'OBJECTID', 'Route_ID', 'Intersects','WSEL', 'Station','strm_length']
comb_intersect = stream_intersects
compare =[]
fields = [f.name for f in arcpy.ListFields(comb_intersect)]
cursor = arcpy.SearchCursor(comb_intersect, ['Route_ID','Route_ID_1','strm_length'])
for row in cursor:
compare.append([row.getValue('Route_ID'),row.getValue('Route_ID_1'),row.getValue('strm_length')])
del row
del cursor
cursor = arcpy.UpdateCursor(comb_intersect,['Route_ID','Route_ID_1','strm_length'])
for row in cursor:
intersect = row.getValue('Route_ID_1')
intersect_stream = row.getValue('Route_ID')
intersect_length = int(row.getValue('strm_length'))
for strm in compare:
stream = strm[1]
stream_name = strm[0]
stream_length = int(strm[2])
if intersect == stream_name and intersect_stream == stream and intersect_length < stream_length:
row.setValue("Route_ID_1","Delete")
cursor.updateRow(row)
del row
del cursor
arcpy.AddField_management(comb_intersect,"Intersects","TEXT","","",50)
arcpy.AddField_management(comb_intersect,'Station',"FLOAT",10,3)
arcpy.CalculateField_management(comb_intersect, "Intersects", expression2, "VB")
arcpy.CalculateField_management(comb_intersect, "Route_ID", expression3, "VB")
arcpy.CalculateField_management(comb_intersect, "Station", expression4, "VB")
arcpy.MakeFeatureLayer_management(comb_intersect, tempLayer)
arcpy.SelectLayerByAttribute_management(tempLayer, "NEW_SELECTION",expression)
if int(arcpy.GetCount_management(tempLayer).getOutput(0)) > 0:
arcpy.DeleteFeatures_management(tempLayer)
fields = [f.name for f in arcpy.ListFields(comb_intersect) if not f.required and f.name not in keep_fields ]
arcpy.DeleteField_management(comb_intersect, fields)
return
def processStream(self):
self.warnings=[]
comb_intersect = self.scratchgdb+'\\streams_intersect_all_1'
self.remove_duplicate_pts(comb_intersect)
return
