def main(): # import required modules and extensions import arcpy arcpy.CheckOutExtension('Spatial') # environment settings arcpy.env.workspace = 'in_memory' # set workspace to temporary workspace arcpy.env.overwriteOutput = True # set to overwrite output sr = arcpy.Describe(flowline_path).spatialReference # dissolve input flowline network flowline_dissolve = arcpy.Dissolve_management(flowline_path, 'in_memory/flowline_dissolve', '', '', 'SINGLE_PART', 'UNSPLIT_LINES') # create line id field and line length fields arcpy.AddField_management(flowline_dissolve, 'LineID', 'SHORT') arcpy.AddField_management(flowline_dissolve, 'LineLen', 'DOUBLE') with arcpy.da.UpdateCursor(flowline_dissolve, ['FID', 'LineID', 'Shape@Length', 'LineLen']) as cursor: for row in cursor: row[1] = row[0] row[3] = row[2] cursor.updateRow(row) # flip lines so segment points are created from end-start of line rather than start-end arcpy.FlipLine_edit(flowline_dissolve) # create points at regular interval along each flowline seg_pts = arcpy.CreateFeatureclass_management('in_memory', 'seg_pts', 'POINT', '', 'DISABLED', 'DISABLED', sr) with arcpy.da.SearchCursor(flowline_dissolve, ['SHAPE@'], spatial_reference = sr) as search: with arcpy.da.InsertCursor(seg_pts, ['SHAPE@']) as insert: for row in search: try: lineGeom = row[0] lineLength = row[0].length lineDist = interval while lineDist + min_segLength <= lineLength: newPoint = lineGeom.positionAlongLine(lineDist) insert.insertRow(newPoint) lineDist += interval except Exception as e: arcpy.AddMessage(str(e.message)) # split flowlines at segment interval points flowline_seg = arcpy.SplitLineAtPoint_management(flowline_dissolve, seg_pts, 'in_memory/flowline_seg', 1.0) # add and populate segment id and length fields arcpy.AddField_management(flowline_seg, 'SegID', 'SHORT') arcpy.AddField_management(flowline_seg, 'SegLen', 'DOUBLE') with arcpy.da.UpdateCursor(flowline_seg, ['FID', 'SegID', 'Shape@Length', 'SegLen']) as cursor: for row in cursor: row[1] = row[0] row[3] = row[2] cursor.updateRow(row) # flip lines back to correct direction arcpy.FlipLine_edit(flowline_seg) # save flowline segment output arcpy.CopyFeatures_management(flowline_seg, outpath) arcpy.Delete_management('in_memory')
def routeFlipTemp(routesMZ, idField, refPointLayer): flipRtField = "FlipRt" arcpy.AddField_management(routesMZ, flipRtField, "SHORT") routesCursor = arcpy.UpdateCursor(routesMZ) for route in routesCursor: rtShp = route.getValue(inFcShpField) rtID = route.getValue(idField) print rtID rtEndPnt = rtShp.lastPoint #TODO if no ref points are found script errors out refPntCursor = arcpy.SearchCursor(refPointLayer, """ "LABEL" = '""" + rtID + "'")#Create reference point cursor limited by route ID of current route #Get the first ref point of the route and reset the closest point with it. # p = refPntCursor.next() closestRefPnt = p.getValue(inFcShpField).centroid closestDist = distanceFormula(rtEndPnt.X, rtEndPnt.Y, closestRefPnt.X, closestRefPnt.Y) print "SP : " + str(p.CALPT_TYPE) + str(closestDist) closestType = str(p.CALPT_TYPE) ## for refPnt in refPntCursor: nextRefPnt = refPnt.getValue(inFcShpField).centroid nextDist = distanceFormula(rtEndPnt.X, rtEndPnt.Y, nextRefPnt.X, nextRefPnt.Y) if nextDist < closestDist: closestRefPnt = refPnt closestDist = nextDist closestType = str(refPnt.CALPT_TYPE) print str(refPnt.CALPT_TYPE) + " c: " + str(closestDist) elif nextDist == closestDist: if str(refPnt.CALPT_TYPE).count("END") > 0 or str(refPnt.CALPT_TYPE).count("START") > 0: closestRefPnt = refPnt closestDist = nextDist closestType = str(refPnt.CALPT_TYPE) print str(refPnt.CALPT_TYPE) + " c: " + str(closestDist) # else: # print str(refPnt.CALPT_TYPE) + " f: " + str(nextDist) print closestType + " final: " + str(closestDist) print if closestType.count("START") > 0: route.setValue(flipRtField, 1) routesCursor.updateRow(route) del route del routesCursor #Select by the flipRtField to flip routes that need it. arcpy.MakeFeatureLayer_management(routesMZ, "flipRts", '"' + flipRtField + '"' + " = 1 ") matchCount = int(arcpy.GetCount_management("flipRts").getOutput(0)) #temp arcpy.AddMessage("Attemping Flip of: " + str(matchCount)) arcpy.FlipLine_edit("flipRts") arcpy.AddMessage("Routes flipped: " + str(matchCount))
def onClick(self): # Script to flip attributes on a centerline. # arcpy.da.SearchCursor requires ArcGIS 10.1 or higher # coding help via GIS StackExchange: # http://gis.stackexchange.com/a/79625/15499 # http://gis.stackexchange.com/questions/79615/is-there-a-programmatic-way-to-swap-attributes-on-a-feature/79625?noredirect=1#comment109573_79625 try: workspace = r"Database Connections\facilities@5160_93.sde" # set workspace to SDE connection fields = ([ "FROMLEFTP", "TORIGHTP", "TOLEFTP", "FROMRIGHTP", "FROMLEFTA", "TORIGHTA", "TOLEFTA", "FROMRIGHTA", "TRAFFIC_FLOW" ]) # set the fields to the ones being flipped fc = "FACILITIES.Centerline" # set the feature class to the SDE feature class name fc_shp = "CENTERLINE_FLIPS" # feature class to calculate field = "FLIP" # calc filed to change fc_desc = arcpy.Describe(fc) # describe selection of fc_shape fc_shp_desc = arcpy.Describe( fc_shp) # describe selection of fc_shape if not fc_desc.FIDSet == '' and fc_shp_desc == '': # an fc_shp is selected # Marked the discrepancy as done in the CENTERLINE_FLIPS tracking shapefile arcpy.CalculateField_management(fc_shp, field, '1') # loops through selected rows and swaps the values with arcpy.da.UpdateCursor(fc, fields) as cursor: for row in cursor: # flips the line direction arcpy.FlipLine_edit("FACILITIES.Centerline") # update swaps row[0], row[1] = row[1], row[0] row[2], row[3] = row[3], row[2] row[4], row[5] = row[5], row[4] row[6], row[7] = row[7], row[6] # swap directions if row[8] == 'F': row[8] = 'R' cursor.updateRow(row) elif row[8] == 'R': row[8] = 'F' cursor.updateRow(row) else: cursor.updateRow(row) else: # this is not working at the moment arcpy.AddError( "Error. No {0} features are selected.".format(fc_shp)) print(arcpy.GetMessages()) except Exception as e: arcpy.AddError(e.message)
def generate_linkshape(arcs, output_dir): linkshape = os.path.join(output_dir, 'highway.linkshape') w = open(linkshape, 'w') w.write('c HIGHWAY LINK SHAPE FILE FOR SCENARIO {0}\n'.format(scen)) w.write('c {0}\n'.format(MHN.timestamp('%d%b%y').upper())) w.write('t linkvertices\n') def write_vertices(fc, writer, reversed=False): with arcpy.da.SearchCursor(fc, ['SHAPE@', 'ANODE', 'BNODE']) as cursor: for row in cursor: arc = row[0] if not reversed: fnode = str(row[1]) tnode = str(row[2]) else: fnode = str(row[2]) # ANODE now references to-node tnode = str(row[1]) # BNODE now references from-node writer.write(' '.join(['r', fnode, tnode]) + '\n') n = 0 # Before for-loop, will not be reset if an arc is multi-part for some reason for part in arc: vertex = part.next() while vertex: n += 1 writer.write(' '.join([ 'a', fnode, tnode, str(n), str(vertex.X), str(vertex.Y) ]) + '\n') vertex = part.next() if not vertex: vertex = part.next() return None arcs_mem = os.path.join(MHN.mem, 'arcs') arcpy.CopyFeatures_management(arcs, arcs_mem) write_vertices(arcs_mem, w) arcs_mem_flipped = os.path.join(MHN.mem, 'arcs_flipped') arcs_2dir_lyr = 'arcs_2dir' arcpy.MakeFeatureLayer_management(arcs_mem, arcs_2dir_lyr, ''' "DIRECTIONS" <> '1' ''') arcpy.CopyFeatures_management(arcs_2dir_lyr, arcs_mem_flipped) arcpy.FlipLine_edit(arcs_mem_flipped) write_vertices(arcs_mem_flipped, w, reversed=True) w.close() arcpy.Delete_management(arcs_mem) arcpy.Delete_management(arcs_mem_flipped) return linkshape
def correct_orientation(self, geometry_name, geometry_folder, networkLine): arcpy.env.overwriteOutput = True print("Création du fichier du réseau avec le bon sens d'écoulement") arcpy.gp.TraceGeometricNetwork( geometry_folder + geometry_name, "lyr", geometry_folder + networkLine + "_Exutoire", "TRACE_UPSTREAM") arcpy.CopyFeatures_management( "lyr/" + networkLine, geometry_folder + networkLine + "_Upstream") print( "Création du fichier des réseaux avec le mauvais sens d'écoulement" ) arcpy.SelectLayerByAttribute_management("lyr/" + networkLine, "SWITCH_SELECTION") arcpy.CopyFeatures_management( "lyr/" + networkLine, geometry_folder + networkLine + "_notUpstream") arcpy.SelectLayerByAttribute_management('lyr/' + networkLine, "CLEAR_SELECTION") arcpy.SelectLayerByAttribute_management( 'lyr/' + networkLine + "_summit", "CLEAR_SELECTION") arcpy.Delete_management("lyr") print( "Sélection des entités avec un mauvais sens de digitalisation et qui ne sont pas intermitent" ) arcpy.MakeFeatureLayer_management( geometry_folder + networkLine + "_notUpstream", 'lyr') arcpy.SelectLayerByLocation_management( 'lyr', "BOUNDARY_TOUCHES", geometry_folder + networkLine + "_Upstream", "#", "NEW_SELECTION") #arcpy.SelectLayerByAttribute_management('lyr',"SUBSET_SELECTION",flowField + " = '" + flowAttribut + "'") print("Correction du sens de digitalisation") arcpy.FlipLine_edit('lyr') arcpy.SelectLayerByAttribute_management('lyr', "CLEAR_SELECTION") # arcpy.Delete_management("lyr") print("Assemblage des données du nouveau réseau") arcpy.Delete_management(geometry_folder + "/" + geometry_name) arcpy.Delete_management(geometry_folder + networkLine) arcpy.Merge_management( geometry_folder + networkLine + "_Upstream;" + geometry_folder + networkLine + "_notUpstream", geometry_folder + networkLine)
def line_extend_within_polygon(boundary_polygon, lines_to_extend): """ This python function can extend the lines within a boundary polygon upto the border line. Here, boundary_polygon is the polygon shapefile and the lines_to_extend is the line shapefile which will be extended upto the border using the function. """ arcpy.PolygonToLine_management(in_features=boundary_polygon, out_feature_class="boundary_line", neighbor_option="IDENTIFY_NEIGHBORS") arcpy.RepairGeometry_management(in_features=lines_to_extend, delete_null="DELETE_NULL") coastline = "boundary_line" directions = lines_to_extend g = arcpy.Geometry() bank = arcpy.CopyFeatures_management(coastline, g)[0] for i in range(2): with arcpy.da.UpdateCursor(directions, "Shape@") as cursor: for row in cursor: line = row[0] pStart = line.firstPoint pEnd = line.lastPoint L = line.length dX = (pEnd.X - pStart.X) / L dY = (pEnd.Y - pStart.Y) / L p = pEnd m = 0 while True: l = bank.distanceTo(p) L += l p.X = pStart.X + dX * L p.Y = pStart.Y + dY * L m += 1 if m > 100: break if l < 0.001: break if m > 100: continue row[0] = arcpy.Polyline(arcpy.Array([pStart, p])) cursor.updateRow(row) if i == 0: arcpy.FlipLine_edit(in_features=directions) # deleting the boundary_line layer arcpy.Delete_management(coastline) return
outlines.append( arcpy.Polyline(arcpy.Array([start.centroid, end.centroid]), sr)) outlines.append( arcpy.Polyline(arcpy.Array([start.centroid, end2.centroid]), sr)) arcpy.CopyFeatures_management(outlines, 'in_memory\Aux1') del cursor1 # Define cursor to loop the Plan Profile Line Feature Layer cursor2 = arcpy.SearchCursor(profileFC) # Adjust the value in case the azimuth is greater than 180 for row in cursor2: azVal = row.BEARING if azVal > 180: azVal = azVal - 180 arcpy.FlipLine_edit(profileFC) arcpy.AddMessage("Bearing azimuth profile line: " + str(azVal)) arcpy.CalculateField_management(profileFC, "BEARING", str(azVal), "PYTHON", "#") arcpy.SpatialJoin_analysis( 'in_memory\Aux1', strDataFC, 'in_memory\Aux2' ) # Join the Structural Data attributes to the temporal projection lines arcpy.Intersect_analysis( [profileFC, 'in_memory\Aux2'], 'in_memory\Aux5', "ALL", "", "POINT" ) # Capture the intersection points to project the structural data in the plan profile line # Project the intersection points in case there are faults and/or folds if foldFC != '' and faultFC != '': arcpy.Intersect_analysis([profileFC, foldFC], 'in_memory\Aux3', "ALL", "",
def get_centerline (feature, dem, workspace, power = 5, eu_cell_size = 10): """Returns a center line feature of the given polygon feature based on cost over an euclidean distance raster and cost path. points are seeded using minimum and maximum elevation.""" centerline = workspace + '\\centerline.shp' center_length = 0 center_slope = 0 smoothing = 4 trim_distance = "100 Meters" try: # Setup extents / environments for the current feature ARCPY.env.extent = feature.shape.extent desc = ARCPY.Describe(feature) XMin_new = desc.extent.XMin - 200 YMin_new = desc.extent.YMin - 200 XMax_new = desc.extent.XMax + 200 YMax_new = desc.extent.YMax + 200 ARCPY.env.extent = ARCPY.Extent(XMin_new, YMin_new, XMax_new, YMax_new) ARCPY.env.overwriteOutput = True ARCPY.env.cellSize = eu_cell_size ARCPY.env.snapRaster = dem # Get minimum and maximum points resample = ARCPY.Resample_management (dem, 'in_memory\\sample', eu_cell_size) masked_dem = spatial.ExtractByMask (resample, feature.shape) # Find the maximum elevation value in the feature, convert them to # points and then remove all but one. maximum = get_properties (masked_dem, 'MAXIMUM') maximum_raster = spatial.SetNull(masked_dem, masked_dem, 'VALUE <> ' + maximum) maximum_point = ARCPY.RasterToPoint_conversion(maximum_raster, 'in_memory\\max_point') rows = ARCPY.UpdateCursor (maximum_point) for row in rows: if row.pointid <> 1: rows.deleteRow(row) del row, rows # Find the minimum elevation value in the feature, convert them to # points and then remove all but one. minimum = get_properties (masked_dem, 'MINIMUM') minimum_raster = spatial.SetNull(masked_dem, masked_dem, 'VALUE <> ' + minimum) minimum_point = ARCPY.RasterToPoint_conversion(minimum_raster, 'in_memory\\min_point') rows = ARCPY.UpdateCursor (minimum_point) for row in rows: if row.pointid <> 1: rows.deleteRow(row) del row, rows # Calculate euclidean Distance to boundary line for input DEM cells. polyline = ARCPY.PolygonToLine_management(feature.shape, 'in_memory\\polyline') eucdist =spatial.EucDistance(polyline, "", eu_cell_size, '') masked_eucdist = spatial.ExtractByMask (eucdist, feature.shape) # Calculate the cost raster by inverting the euclidean distance results, # and raising it to the power of x to exaggerate the least expensive route. cost_raster = (-1 * masked_eucdist + float(maximum))**power # Run the cost distance and cost path function to find the path of least # resistance between the minimum and maximum values. The results are set # so all values equal 1 (different path segments have different values) # and convert the raster line to a poly-line. backlink = 'in_memory\\backlink' cost_distance = spatial.CostDistance(minimum_point, cost_raster, '', backlink) cost_path = spatial.CostPath(maximum_point, cost_distance, backlink, 'EACH_CELL', '') cost_path_ones = spatial.Con(cost_path, 1, '', 'VALUE > ' + str(-1)) # Set all resulting pixels to 1 r_to_p = ARCPY.RasterToPolyline_conversion (cost_path_ones, 'in_memory\\raster_to_polygon') del ARCPY.env.extent # Delete current extents (need here but do not know why) # Removes small line segments from the centerline shape. These segments are # a byproduct of cost analysis. lines = str(ARCPY.GetCount_management(r_to_p)) #check whether we have more than one line segment if float(lines) > 1: # If there is more then one line rows = ARCPY.UpdateCursor(r_to_p) for row in rows: if row.shape.length == eu_cell_size: # delete all the short 10 m lines rows.deleteRow(row) del row, rows lines = str(ARCPY.GetCount_management(r_to_p)) if float(lines) > 1: ARCPY.Snap_edit(r_to_p, [[r_to_p, "END", "50 Meters"]]) # make sure that the ends of the lines are connected r_to_p = ARCPY.Dissolve_management(r_to_p, 'in_memory\\raster_to_polygon_dissolve') # Smooth the resulting line. Currently smoothing is determined by minimum # and maximum distance. The greater change the greater the smoothing. smooth_tolerance = (float(maximum) - float(minimum)) / smoothing ARCPY.SmoothLine_cartography(r_to_p, centerline, 'PAEK', smooth_tolerance, 'FIXED_CLOSED_ENDPOINT', 'NO_CHECK') field_names = [] # List of field names in the file that will be deleted. fields_list = ARCPY.ListFields(centerline) for field in fields_list: # Loop through the field names if not field.required: # If they are not required append them to the list of field names. field_names.append(field.name) # Add new fields to the center line feature ARCPY.AddField_management(centerline, 'GLIMSID', 'TEXT', '', '', '25') ARCPY.AddField_management(centerline, 'LENGTH', 'FLOAT') ARCPY.AddField_management(centerline, 'SLOPE', 'FLOAT') ARCPY.DeleteField_management(centerline, field_names) # Remove the old fields. # Calculate the length of the line segment and populate segment data. ARCPY.CalculateField_management(centerline, 'LENGTH', 'float(!shape.length@meters!)', 'PYTHON') rows = ARCPY.UpdateCursor (centerline) for row in rows: row.GLIMSID = feature.GLIMSID # Get GLIMS ID and add it to segment center_length = row.LENGTH # Get the length of the center line # Calculate slope of the line based on change in elevation over length of line center_slope = round(math.degrees(math.atan((float(maximum) - float(minimum)) / row.LENGTH)), 2) row.SLOPE = center_slope # Write slope to Segment rows.updateRow(row) # Update the new entry del row, rows #Delete cursors and remove locks # Flip Line if needed - Turn min point and end point into a line segment if # the length of this line is greater then the threshold set, flip the line. end_point = ARCPY.FeatureVerticesToPoints_management(centerline, 'in_memory\\end_point', 'END') merged_points = ARCPY.Merge_management ([end_point, minimum_point], 'in_memory\\merged_points') merged_line = ARCPY.PointsToLine_management (merged_points, 'in_memory\\merged_line') merged_line_length = 0 # Get the line Length rows = ARCPY.SearchCursor (merged_line) for row in rows: merged_line_length += row.shape.length del row, rows # if the line length is greater then a quarter the entire feature length, flip if merged_line_length > (center_length/4): ARCPY.FlipLine_edit(centerline) # This function attempts to extend the line and clip it back to the # feature extents in order to create a line that runs from edge to edge #trimmed_line = ARCPY.Merge_management([polyline, centerline], 'in_memory\\line_merge') trimmed_line = ARCPY.Append_management (polyline, centerline, 'NO_TEST') ARCPY.TrimLine_edit (trimmed_line, trim_distance, "DELETE_SHORT") ARCPY.ExtendLine_edit(trimmed_line, trim_distance, "EXTENSION") rows = ARCPY.UpdateCursor (trimmed_line) for row in rows: if row.LENGTH == 0.0: rows.deleteRow(row) del row, rows # Recalculate length. Must be after 0.0 lengths are deleted or they will # not be removed above. ARCPY.CalculateField_management(centerline, 'LENGTH', 'float(!shape.length@meters!)', 'PYTHON') ARCPY.env.overwriteOutput = False return centerline, center_length, center_slope, False except: ARCPY.env.overwriteOutput = False return centerline, '', '', True
def _stream_direction(self, stream): """ Compute elevation of start/end point of stream parts. Add code of ascending stream part into attribute table. :param stream: vector stream features """ # TODO: vyresit mazani atributu v atributove tabulce (jestli je to potreba) # TODO: vyresit nasledujici: # # Nasledujici blok je redundantni, nicmene do "stream" # pridava nekolik sloupecku, u kterych jsem nemohl dohledat, # jestli se s nimi neco dela. Proto to tu zatim nechavam. # start = arcpy.FeatureVerticesToPoints_management( # stream, os.path.join(self.temp, self._data["start"]), "START" # ) # end = arcpy.FeatureVerticesToPoints_management( # stream, os.path.join(self.temp, self._data["end"]), "END" # ) start = arcpy.FeatureVerticesToPoints_management( stream, self.storage.output_filepath("start"), "START") end = arcpy.FeatureVerticesToPoints_management( stream, self.storage.output_filepath("end"), "END") arcpy.sa.ExtractMultiValuesToPoints( start, [[self.dem_clip, self._data["start_elev"]]], "NONE") arcpy.sa.ExtractMultiValuesToPoints( end, [[self.dem_clip, self._data["end_elev"]]], "NONE") # Join self._join_table(stream, self._primary_key, start, "ORIG_FID") self._join_table(stream, self._primary_key, end, "ORIG_FID") self._delete_fields(stream, [ "SHAPE_LEN", "SHAPE_LENG", "SHAPE_LE_1", "NAZ_TOK_1", "TOK_ID_1", "SHAPE_LE_2", "SHAPE_LE_3", "NAZ_TOK_12", "TOK_ID_12", "SHAPE_LE_4", "ORIG_FID_1" ]) self._delete_fields( stream, ["start_elev", "end_elev", "ORIG_FID", "ORIG_FID_1"]) start = arcpy.FeatureVerticesToPoints_management( stream, self.storage.output_filepath("start"), "START") end = arcpy.FeatureVerticesToPoints_management( stream, self.storage.output_filepath("end"), "END") arcpy.sa.ExtractMultiValuesToPoints(start, [[self.dem_clip, "start_elev"]], "NONE") arcpy.sa.ExtractMultiValuesToPoints(end, [[self.dem_clip, "end_elev"]], "NONE") arcpy.AddXY_management(start) arcpy.AddXY_management(end) # Join self._join_table(stream, self._primary_key, start, "ORIG_FID") self._join_table(stream, self._primary_key, end, "ORIG_FID") self._delete_fields( stream, ["NAZ_TOK_1", "NAZ_TOK_12", "TOK_ID_1", "TOK_ID_12"]) field = [ self._primary_key, "start_elev", "POINT_X", "end_elev", "POINT_X_1" ] with arcpy.da.SearchCursor(stream, field) as cursor: for row in cursor: if row[1] > row[3]: continue arcpy.FlipLine_edit(stream) ### TODO: ? all self._add_field(stream, "to_node", "DOUBLE", -9999) fields = [ self._primary_key, "POINT_X", "POINT_Y", "POINT_X_1", "POINT_Y_1", "to_node" ] # if stream is saved in gdb, it's id field begins with 1 # in further computation (stream.py) it would exceed array length # MK 4.4.19 fid_offset_flag = True fid_offset = 0 with arcpy.da.SearchCursor(stream, fields) as cursor_start: for row in cursor_start: if fid_offset_flag: fid_offset = row[0] fid_offset_flag = False a = (row[1], row[2]) d = row[0] - fid_offset with arcpy.da.UpdateCursor(stream, fields) as cursor_end: for row in cursor_end: b = (row[3], row[4]) if a == b: row[5] = d cursor_end.updateRow(row) else: row[5] = "-9999" self._delete_fields(stream, [ "SHAPE_LEN", "SHAPE_LE_1", "SHAPE_LE_2", "SHAPE_LE_3", "SHAPE_LE_4", "SHAPE_LE_5", "SHAPE_LE_6", "SHAPE_LE_7", "SHAPE_LE_8", "SHAPE_LE_9", "SHAPE_L_10", "SHAPE_L_11", "SHAPE_L_12", "SHAPE_L_13", "SHAPE_L_14" ]) self._delete_fields(stream, ["ORIG_FID", "ORIG_FID_1", "SHAPE_L_14"])
# --------------------------------------------------------------------------- # 12) Select Layer By Attribute, Flip Lines (optional) flip_ids_str = '' if flip_routes.lower() == 'yes': for i in results['flip']: flip_ids_str += (str(i) + ",") if len(flip_ids_str) > 0: arcpy.SelectLayerByAttribute_management( in_layer_or_view = 'road_seg_working', selection_type = "NEW_SELECTION", where_clause = unique_id + " IN (" + flip_ids_str[:-1] + ")" ) arcpy.FlipLine_edit( in_features = 'road_seg_working' ) arcpy.AddMessage(str(len(results['flip'])) + " wrongly digitized polyline segments flipped to proper direction.") # 13) Reclassify Street Operation Attribute Field (optional) if reclassify.lower() == 'yes': twoway_streets_str = '' for i in results['twoway']: twoway_streets_str += (str(i) + ",") arcpy.SelectLayerByAttribute_management( in_layer_or_view = 'road_seg_working', selection_type = "NEW_SELECTION", where_clause = unique_id + " IN (" + twoway_streets_str[:-1] + ")" ) arcpy.CalculateField_management("road_seg_working","STREETOPERATION",2,"PYTHON_9.3")
rows = arcpy.SearchCursor(NearTableS) line = rows.next() dS = line.NEAR_DIST NearTableE = arcpy.GenerateNearTable_analysis(EPt, OutPt, "NearTable", "", "LOCATION", "NO_ANGLE", "") rows = arcpy.SearchCursor(NearTableE) line = rows.next() dE = line.NEAR_DIST arcpy.AddMessage(dS) arcpy.AddMessage(dE) #/orientation of the streamline if dS < dE: arcpy.AddMessage(" Wrong Direction") arcpy.FlipLine_edit(InputFCMTS) rows = arcpy.SearchCursor(InputFCMTS) line = rows.next() ncurrentstep += 1 arcpy.AddMessage("Extracting the new first point - Step " + str(ncurrentstep) + "/" + str(nstep)) shapeName = arcpy.Describe(InputFCMTS).shapeFieldName SpatialRef = arcpy.Describe(InputFCMTS).spatialReference Obj = line.getValue(shapeName) first = Obj.firstPoint end = Obj.lastPoint firstPt = arcpy.PointGeometry(first, SpatialRef) endPt = arcpy.PointGeometry(end, SpatialRef)
def main(): # import required modules and extensions import os import arcpy arcpy.CheckOutExtension('Spatial') # environment settings arcpy.env.workspace = 'in_memory' # set workspace to temporary workspace arcpy.env.overwriteOutput = True # set to overwrite output sr = arcpy.Describe(nhd_flowline_path).spatialReference # select lines from original nhd that are not coded as pipeline (fcdoe 428**) arcpy.MakeFeatureLayer_management(nhd_flowline_path, 'nhd_flowline_lyr') quer = """ "FCODE" >=42800 AND "FCODE" <= 42813 """ arcpy.SelectLayerByAttribute_management('nhd_flowline_lyr', 'NEW_SELECTION', quer) arcpy.SelectLayerByAttribute_management('nhd_flowline_lyr', 'SWITCH_SELECTION') flowline_network = arcpy.CopyFeatures_management('nhd_flowline_lyr', 'in_memory/flowline_selection') # dissolve flowline network by name #flowline_dissolve_name = arcpy.Dissolve_management(flowline_network, 'in_memory/flowline_dissolve', 'GNIS_NAME', '', 'SINGLE_PART', 'UNSPLIT_LINES') tmp_flowline_dissolve_name = arcpy.Dissolve_management(flowline_network, 'in_memory/flowline_dissolve_tmp', 'GNIS_NAME', '', 'SINGLE_PART', 'UNSPLIT_LINES') flowline_dissolve_name = arcpy.Sort_management(tmp_flowline_dissolve_name, 'in_memory/flowline_dissolve', [['Shape', 'DESCENDING']], 'PEANO') # create line id field and line length fields # if fields already exist, delete them check_fields = ['LineID', 'LineLen', 'SegID', 'SegLen', 'ReachID', 'ReachLen'] fields = [f.name for f in arcpy.ListFields(flowline_dissolve_name)] for field in fields: if field in check_fields: arcpy.DeleteField_management(flowline_dissolve_name, field) arcpy.AddField_management(flowline_dissolve_name, 'StreamName', 'TEXT', 50) arcpy.AddField_management(flowline_dissolve_name, 'StreamID', 'LONG') arcpy.AddField_management(flowline_dissolve_name, 'StreamLen', 'DOUBLE') ct = 1 with arcpy.da.UpdateCursor(flowline_dissolve_name, ['FID', 'StreamID', 'Shape@Length', 'StreamLen', 'GNIS_NAME', 'StreamName']) as cursor: for row in cursor: #row[1] = row[0] row[1] = ct row[3] = row[2] row[5] = row[4] ct += 1 cursor.updateRow(row) # dissolve flowline network flowline_dissolve_all = arcpy.Dissolve_management(flowline_network, 'in_memory/flowline_dissolve_all', '', '', 'SINGLE_PART', 'UNSPLIT_LINES') arcpy.AddField_management(flowline_dissolve_all, 'SegID', 'LONG') arcpy.AddField_management(flowline_dissolve_all, 'SegLen', 'DOUBLE') with arcpy.da.UpdateCursor(flowline_dissolve_all, ['FID', 'SegID', 'Shape@Length', 'SegLen']) as cursor: for row in cursor: row[1] = row[0] row[3] = row[2] cursor.updateRow(row) flowline_int = arcpy.Intersect_analysis([flowline_dissolve_name, flowline_dissolve_all], 'in_memory/flowline_int') keep = ['FID', 'Shape', 'StreamID', 'StreamLen', 'StreamName', 'SegID', 'SegLen'] drop = [] fields = [f.name for f in arcpy.ListFields(flowline_int)] for field in fields: if field not in keep: drop.append(field) arcpy.DeleteField_management(flowline_int, drop) # flip lines so segment points are created from end-start of line rather than start-end arcpy.FlipLine_edit(flowline_int) # create points at regular interval along each flowline seg_pts = arcpy.CreateFeatureclass_management('in_memory', 'seg_pts', 'POINT', '', 'DISABLED', 'DISABLED', sr) with arcpy.da.SearchCursor(flowline_int, ['SHAPE@'], spatial_reference = sr) as search: with arcpy.da.InsertCursor(seg_pts, ['SHAPE@']) as insert: for row in search: try: lineGeom = row[0] lineLength = row[0].length lineDist = interval while lineDist + min_segLength <= lineLength: newPoint = lineGeom.positionAlongLine(lineDist) insert.insertRow(newPoint) lineDist += interval except Exception as e: arcpy.AddMessage(str(e.message)) # split flowlines at segment interval points flowline_seg = arcpy.SplitLineAtPoint_management(flowline_int, seg_pts, 'in_memory/flowline_seg', 1.0) # add and populate reach id and length fields arcpy.AddField_management(flowline_seg, 'ReachID', 'SHORT') arcpy.AddField_management(flowline_seg, 'ReachLen', 'DOUBLE') with arcpy.da.UpdateCursor(flowline_seg, ['FID', 'ReachID', 'Shape@Length', 'ReachLen']) as cursor: for row in cursor: row[1] = row[0] row[3] = row[2] cursor.updateRow(row) # # get distance along route (LineID) for segment midpoints # midpoints = arcpy.FeatureVerticesToPoints_management(flowline_seg, 'in_memory/midpoints', "MID") # arcpy.CopyFeatures_management(midpoints, os.path.join(os.path.dirname(outpath), 'tmp_midpoints.shp')) # # arcpy.FlipLine_edit(flowline_int) # arcpy.AddField_management(flowline_int, 'From_', 'DOUBLE') # arcpy.AddField_management(flowline_int, 'To_', 'DOUBLE') # with arcpy.da.UpdateCursor(flowline_int, ['SegLen', 'From_', 'To_']) as cursor: # for row in cursor: # row[1] = 0.0 # row[2] = row[0] # cursor.updateRow(row) # # # arcpy.CreateRoutes_lr(flowline_int, 'SegID', 'in_memory/flowline_route', 'TWO_FIELDS', 'From_', 'To_') # routeTbl = arcpy.LocateFeaturesAlongRoutes_lr(midpoints, 'in_memory/flowline_route', 'SegID', # 1.0, os.path.join(os.path.dirname(outpath), '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(flowline_seg, 'ReachDist', 'DOUBLE') # with arcpy.da.UpdateCursor(flowline_seg, ['ReachID', 'ReachDist']) as cursor: # for row in cursor: # aKey = row[0] # row[1] = distDict[aKey] # cursor.updateRow(row) # # flip lines back to correct direction # arcpy.FlipLine_edit(flowline_seg) # save flowline segment output arcpy.CopyFeatures_management(flowline_seg, outpath) arcpy.Delete_management('in_memory')
def main(fcLineNetwork, fieldStreamRouteID, seed_distance, window_sizes, stat_fields, fcOutputWindows, fcOutputSeedPoints, tempWorkspace=arcpy.env.scratchWorkspace): """Perform a Moving Window Analysis on a Line Network.""" # Prepare Inputs arcpy.AddMessage("Preparing Moving Window Analysis") fc_line_dissolve = gis_tools.newGISDataset(tempWorkspace, "GNAT_MWA_LineNetworkDissolved") arcpy.Dissolve_management(fcLineNetwork, fc_line_dissolve, fieldStreamRouteID, multi_part=False, unsplit_lines=True) arcpy.FlipLine_edit(fc_line_dissolve) listSeeds = [] listgWindows = [] intSeedID = 0 # Moving Window Generation arcpy.AddMessage("Starting Window Generation") iRoutes = int(arcpy.GetCount_management(fc_line_dissolve).getOutput(0)) arcpy.SetProgressor("step", "Processing Each Route", 0, iRoutes, 1) iRoute = 0 with arcpy.da.SearchCursor(fc_line_dissolve, ["SHAPE@", fieldStreamRouteID, "SHAPE@LENGTH"]) as scLines: for fLine in scLines: # Loop Through Routes arcpy.SetProgressorLabel("Route: {} Seed Point: {}".format(iRoute, intSeedID)) arcpy.SetProgressorPosition(iRoute) dblSeedPointPosition = float(max(window_sizes)) / 2 # Start Seeds at position of largest window while dblSeedPointPosition + float(max(window_sizes)) / 2 < fLine[2]: arcpy.SetProgressorLabel("Route: {} Seed Point: {}".format(iRoute, intSeedID)) gSeedPointPosition = fLine[0].positionAlongLine(dblSeedPointPosition) listSeeds.append([scLines[1], intSeedID, gSeedPointPosition, dblSeedPointPosition]) for window_size in window_sizes: dblWindowSize = float(window_size) dblLengthStart = dblSeedPointPosition - dblWindowSize / 2 dblLengthEnd = dblSeedPointPosition + dblWindowSize / 2 listgWindows.append([scLines[1], intSeedID, dblWindowSize, fLine[0].segmentAlongLine(dblLengthStart, dblLengthEnd)]) dblSeedPointPosition = dblSeedPointPosition + float(seed_distance) intSeedID = intSeedID + 1 iRoute = iRoute + 1 arcpy.AddMessage("Compiling Moving Windows") fcSeedPoints = gis_tools.newGISDataset(tempWorkspace, "GNAT_MWA_SeedPoints") fcWindowLines = gis_tools.newGISDataset(tempWorkspace, "GNAT_MWA_WindowLines") arcpy.CreateFeatureclass_management(tempWorkspace, "GNAT_MWA_SeedPoints", "POINT", spatial_reference=fcLineNetwork) arcpy.CreateFeatureclass_management(tempWorkspace, "GNAT_MWA_WindowLines", "POLYLINE", spatial_reference=fcLineNetwork) gis_tools.resetField(fcSeedPoints, "RouteID", "TEXT") gis_tools.resetField(fcSeedPoints, "SeedID", "LONG") gis_tools.resetField(fcSeedPoints, "SeedDist", "DOUBLE") gis_tools.resetField(fcWindowLines, "RouteID", "TEXT") gis_tools.resetField(fcWindowLines, "SeedID", "LONG") gis_tools.resetField(fcWindowLines, "Seg", "DOUBLE") with arcpy.da.InsertCursor(fcSeedPoints, ["RouteID", "SeedID", "SHAPE@XY", "SeedDist"]) as icSeedPoints: for row in listSeeds: icSeedPoints.insertRow(row) with arcpy.da.InsertCursor(fcWindowLines, ["RouteID", "SeedID", "Seg", "SHAPE@"]) as icWindowLines: for row in listgWindows: icWindowLines.insertRow(row) # Intersecting Network Attributes with Moving Windows arcpy.AddMessage("Intersecting Network Attributes with Moving Windows") fcIntersected = gis_tools.newGISDataset(tempWorkspace, "GNAT_MWA_IntersectWindowAttributes") arcpy.Intersect_analysis([fcWindowLines, fcLineNetwork], fcIntersected, "ALL", output_type="LINE") # Use Python Dictionaries for Summary Stats # Reference: https://community.esri.com/blogs/richard_fairhurst/2014/11/08/turbo-charging-data-manipulation-with-python-cursors-and-dictionaries arcpy.AddMessage("Loading Moving Window Attributes") valueDict = {} with arcpy.da.SearchCursor(fcIntersected, ["SeedID", "Seg", "SHAPE@LENGTH"] + stat_fields) as searchRows: for searchRow in searchRows: keyValue = str(searchRow[0]) segValue = str(searchRow[1]) if not keyValue in valueDict: valueDict[keyValue] = {segValue: [(searchRow[2:])]} else: if segValue not in valueDict[keyValue]: valueDict[keyValue][segValue] = [(searchRow[2:])] else: valueDict[keyValue][segValue].append((searchRow[2:])) addfields = ["w{}{}{}".format(str(ws)[:4].rstrip("."), stat, field)[:10] for ws in window_sizes for field in stat_fields for stat in ["N", "Av", "Sm", "Rn", "Mn", "Mx", "Sd", "WA"]] for field in addfields: gis_tools.resetField(fcSeedPoints, field, "DOUBLE") arcpy.AddMessage("Calculating Attribute Statistics") with arcpy.da.UpdateCursor(fcSeedPoints, ["SeedID"] + addfields) as ucSeedPoints: for row in ucSeedPoints: new_row = [row[0]] for ws in window_sizes: seglen = [segment[0] for segment in valueDict[str(row[0])][str(ws)]] for i in range(1, len(stat_fields) + 1): vals = [float(segment[i]) for segment in valueDict[str(row[0])][str(ws)]] count_vals = float(len(vals)) sum_vals = sum(vals) ave_vals = sum_vals / float(count_vals) max_vals = max(vals) min_vals = min(vals) range_vals = max_vals - min_vals sd_vals = sqrt(sum([abs(float(x) - float(ave_vals))**2 for x in vals]) / float(count_vals)) wave_vals = sum([val / slen for val, slen in zip(vals, seglen)])/ float(count_vals) new_row.extend([count_vals, ave_vals, sum_vals, range_vals, min_vals, max_vals, sd_vals, wave_vals]) ucSeedPoints.updateRow(new_row) # Manage Outputs arcpy.AddMessage("Saving Outputs") gis_tools.resetData(fcOutputSeedPoints) arcpy.CopyFeatures_management(fcSeedPoints, fcOutputSeedPoints) gis_tools.resetData(fcOutputWindows) arcpy.CopyFeatures_management(fcWindowLines, fcOutputWindows) return 0
def prepare_streams(dmt, dmt_copy, mat_dmt_fill, null, mat_nan, mat_fd, vpix, spix, rows, cols, ll_corner, NoDataValue, addfield, delfield, output, dmt_clip, intersect, null_shp, gp): # creating the geoprocessor object gp = arcgisscripting.create() # setting the workspace environment gp.workspace = gp.GetParameterAsText( constants.PARAMETER_PATH_TO_OUTPUT_DIRECTORY) # Overwriting output arcpy.env.overwriteOutput = 1 # Check extensions arcpy.CheckOutExtension("3D") arcpy.CheckOutExtension("Spatial") # SET INPUT: # Set input stream = gp.GetParameterAsText(constants.PARAMETER_STREAM) # dmt = data_preparation.dmt # dmt_copy = data_preparation.dmt_copy # mat_dmt = data_preparation.mat_dmt_fill # mat_nan = data_preparation.mat_nan # mat_fd = data_preparation.mat_fd # vpix = data_preparation.vpix # spix = data_preparation.spix # rows = data_preparation.rows # cols = data_preparation.cols # gp = data_preparation.gp # ll_corner = data_preparation.ll_corner # NoDataValue = data_preparation.NoDataValue # addfield = data_preparation.addfield # delfield = data_preparation.delfield STREAM_RATIO = 1 # cropped raster info dmt_desc = arcpy.Describe(dmt_copy) # lower left corner coordinates x_coordinate = dmt_desc.extent.XMin y_coordinate = dmt_desc.extent.YMin arcpy.env.snapRaster = dmt # Set output # output = data_preparation.output temp_dp = output + os.sep + "temp_dp" if not os.path.exists(temp_dp): os.makedirs(temp_dp) tempgdb_dp = arcpy.CreateFileGDB_management(temp_dp, "temp_dp.gdb") # WATER FLOWS ACCORDING DMT: # dmt_clip = data_preparation.dmt_clip dmt_fill, flow_direction, flow_accumulation, slope = arcgis_dmtfce.dmtfce( dmt_clip, temp_dp, "TRUE", "TRUE", "NONE") # Setnull try: setnull = arcpy.sa.SetNull(flow_accumulation, 1, "VALUE < 300") # hodnota value?? setnull.save(temp_dp + os.sep + "setnull") except: prt.message("Unexepted error during setnull calculation:", sys.exc_info()[0]) raise # Stream to feature """try: toky_dmt = arcpy.sa.StreamToFeature(setnull, flow_direction, temp_dp+os.sep+"toky_dmt", "SIMPLIFY") except: prt.message("Unexepted error during stream to future calculation:", sys.exc_info()[0]) raise""" # WATER FLOWS ACCORDING DIBAVOD: # Clip toky = temp_dp + os.sep + "toky.shp" tokyLoc = temp_dp + os.sep + "toky.shp" # intersect = data_preparation.intersect hranice = temp_dp + os.sep + "hranice.shp" # null = data_preparation.null_shp hranice = arcpy.Clip_analysis(null, intersect, hranice) hranice2 = arcpy.Buffer_analysis(hranice, temp_dp + os.sep + "hranice2.shp", -spix / 3, "FULL", "ROUND", "NONE") # hranice2 = hranice toky = arcpy.Clip_analysis(stream, hranice2, toky) arcpy.DeleteField_management(toky, [ "EX_JH", "POZN", "PRPROP_Z", "IDVT", "UTOKJ_ID", "UTOKJN_ID", "UTOKJN_F" ]) # Feature vertices to points - START prt.message("Feature vertices to points - START...") start = arcpy.FeatureVerticesToPoints_management( toky, temp_dp + os.sep + "start", "START") # Feature vertices to points - END prt.message("Feature vertices to points - END...") end = arcpy.FeatureVerticesToPoints_management(toky, temp_dp + os.sep + "end", "END") # Extract value to points - END prt.message("Extract value to points - END...") xxx = temp_dp + os.sep + "end_point" end_point = arcpy.sa.ExtractValuesToPoints(end, dmt_clip, xxx, "NONE", "VALUE_ONLY") # Extract value to points - START arcpy.AddMessage("Extract value to points - START...") xxx = temp_dp + os.sep + "start_point" start_point = arcpy.sa.ExtractValuesToPoints(start, dmt_clip, xxx, "NONE", "VALUE_ONLY") # Join arcpy.JoinField_management(toky, "FID", start_point, "ORIG_FID") arcpy.JoinField_management(toky, "FID", end_point, "ORIG_FID") arcpy.DeleteField_management(toky, [ "SHAPE_LEN", "SHAPE_LENG", "SHAPE_LE_1", "NAZ_TOK_1", "TOK_ID_1", "SHAPE_LE_2", "SHAPE_LE_3", "NAZ_TOK_12", "TOK_ID_12", "SHAPE_LE_4", "ORIG_FID_1" ]) # Flip selected lines fc = temp_dp + os.sep + "toky.shp" field = ["OBJECTID", "RASTERVALU", "RASTERVA_1"] prt.message("Flip lines...") # mat_tok_usek # jj tu se zamkne toky a zustane zamcen... toky_t = arcpy.MakeFeatureLayer_management(toky, temp_dp + os.sep + "tok_t.shp") arcpy.SelectLayerByAttribute_management(toky_t, "NEW_SELECTION", "RASTERVALU < RASTERVA_1") arcpy.FlipLine_edit(toky_t) # arcpy.DeleteField_management(toky_t, # ["RASTERVALU","RASTERVA_1","ORIG_FID","ORIG_FID_1"]) arcpy.DeleteField_management( toky, ["RASTERVALU", "RASTERVA_1", "ORIG_FID", "ORIG_FID_1"]) # Feature vertices to points - START prt.message("Feature vertices to points - START...") start = arcpy.FeatureVerticesToPoints_management( toky, temp_dp + os.sep + "start", "START") # Feature vertices to points - END prt.message("Feature vertices to points - END...") end = arcpy.FeatureVerticesToPoints_management(toky, temp_dp + os.sep + "end", "END") # Extract value to points - START prt.message("Extract value to points - START...") start_point_check = arcpy.sa.ExtractValuesToPoints( start, dmt, temp_dp + os.sep + "start_point_check", "NONE", "VALUE_ONLY") arcpy.AddXY_management(start_point_check) # Extract value to points - END prt.message("Extract value to points - END...") end_point_check = arcpy.sa.ExtractValuesToPoints( end, dmt, temp_dp + os.sep + "end_point_check", "NONE", "VALUE_ONLY") arcpy.AddXY_management(end_point_check) # Join A = arcpy.JoinField_management(toky, "FID", start_point_check, "ORIG_FID") B = arcpy.JoinField_management(toky, "FID", end_point_check, "ORIG_FID") arcpy.DeleteField_management( toky, ["NAZ_TOK_1", "NAZ_TOK_12", "TOK_ID_1", "TOK_ID_12"]) fc = toky field = ["FID", "RASTERVALU", "POINT_X", "RASTERVA_1", "POINT_X_1"] with arcpy.da.SearchCursor(fc, field) as cursor: for row in cursor: if row[1] > row[3]: continue else: prt.message("Flip line") arcpy.FlipLine_edit(fc) addfield(toky, "to_node", "DOUBLE", -9999) fc = toky field_end = [ "FID", "POINT_X", "POINT_Y", "POINT_X_1", "POINT_Y_1", "to_node" ] field_start = [ "FID", "POINT_X", "POINT_Y", "POINT_X_1", "POINT_Y_1", "to_node" ] with arcpy.da.SearchCursor(fc, field_start) as cursor_start: for row in cursor_start: a = (row[1], row[2]) d = row[0] with arcpy.da.UpdateCursor(fc, field_end) as cursor_end: for row in cursor_end: b = (row[3], row[4]) if a == b: row[5] = d cursor_end.updateRow(row) else: row[5] = "-9999" arcpy.DeleteField_management(toky, [ "SHAPE_LEN", "SHAPE_LE_1", "SHAPE_LE_2", "SHAPE_LE_3", "SHAPE_LE_4", "SHAPE_LE_5", "SHAPE_LE_6", "SHAPE_LE_7", "SHAPE_LE_8", "SHAPE_LE_9", "SHAPE_L_10", "SHAPE_L_11", "SHAPE_L_12", "SHAPE_L_13", "SHAPE_L_14" ]) arcpy.DeleteField_management(toky, ["ORIG_FID", "ORIG_FID_1", "SHAPE_L_14"]) stream_rst1 = temp_dp + os.sep + "stream_rst" stream_rst = arcpy.PolylineToRaster_conversion(toky, "FID", stream_rst1, "MAXIMUM_LENGTH", "NONE", spix) tok_usek = temp_dp + os.sep + "tok_usek" arcpy.gp.Reclassify_sa( stream_rst, "VALUE", "NoDataValue 1000", tok_usek, "DATA") # jj no data 1000 kdyz in useku bude od 10000 mat_tok_usek = arcpy.RasterToNumPyArray(temp_dp + os.sep + "tok_usek", ll_corner, cols, rows) mat_tok = arcpy.RasterToNumPyArray(temp_dp + os.sep + "tok_usek", ll_corner, cols, rows) # hit = arcpy.NumPyArrayToRaster(mat_tok_usek,ll_corner,spix) # hit.save(temp_dp+"\\hit") pocet = len(mat_tok_usek) e = range(pocet) # useky toku + posledni NoData cell_stream = [] # cropped raster info reclass_desc = arcpy.Describe(tok_usek) ReclNoDataValue = reclass_desc.noDataValue mat_tok_usek = mat_tok_usek.astype('int16') for i in range(rows): for j in range(cols): if mat_tok_usek[i][j] < 0: mat_tok_usek[i][j] = 0 else: mat_tok_usek[i][j] += 1000 poz = [mat_tok_usek[i][j], i, j] cell_stream.append(poz) for i in range(rows): for j in range(cols): if mat_tok[i][j] != 255: mat_tok[i][j] = 3 else: continue # hit1 = arcpy.NumPyArrayToRaster(mat_tok,ll_corner,spix) # hit1.save(temp_dp+"\\hit1") mat_nan = arcpy.NumPyArrayToRaster(mat_nan, ll_corner, spix) mat_nan.save(temp_dp + os.sep + "mat_nan") # kavka - proc se tu uklada tady # HYDRAULIKA TOKU addfield(toky, "length", "DOUBLE", 0.0) # (m) # addfield(toky,"vegetace","TEXT", "trava") #tabulka pro drsnosti, vstupem # bude tabulka suseky toku - tvar a opevneni(vegetace) ci rovnou drsnost # na tvrdo? addfield(toky, "sklon", "DOUBLE", 0.0) # (-) # addfield(toky,"drsnost","DOUBLE", 0) addfield(toky, "V_infl_ce", "DOUBLE", 0.0) # (m3) addfield(toky, "V_infl_us", "DOUBLE", 0.0) # (m3) addfield(toky, "V_infl", "DOUBLE", 0.0) # (m3) addfield(toky, "Q_outfl", "DOUBLE", 0.0) # (m3/s) addfield(toky, "V_outfl", "DOUBLE", 0.0) # (m3) addfield(toky, "V_outfl_tm", "DOUBLE", 0.0) # (m3) addfield(toky, "V_zbyt", "DOUBLE", 0.0) # (m3) addfield(toky, "V_zbyt_tm", "DOUBLE", 0.0) # (m3) addfield(toky, "V", "DOUBLE", 0.0) # (m3) addfield(toky, "h", "DOUBLE", 0.0) # (m) addfield(toky, "vs", "DOUBLE", 0.0) # (m/s) addfield(toky, "NS", "DOUBLE", 0.0) # (m) addfield(toky, "total_Vic", "DOUBLE", 0.0) # (m3) addfield(toky, "total_Viu", "DOUBLE", 0.0) # (m3) addfield(toky, "max_Q", "DOUBLE", 0.0) # (m3/s) addfield(toky, "max_h", "DOUBLE", 0.0) # (m) addfield(toky, "max_vs", "DOUBLE", 0.0) # (m/s) addfield(toky, "total_Vo", "DOUBLE", 0.0) # (m3) addfield(toky, "total_Vi", "DOUBLE", 0.0) # (m3) addfield(toky, "total_NS", "DOUBLE", 0.0) # (m3) addfield(toky, "total_Vz", "DOUBLE", 0.0) # (m3) # sklon fc = toky field = [ "FID", "RASTERVALU", "RASTERVA_1", "sklon", "SHAPE@LENGTH", "length" ] with arcpy.da.UpdateCursor(fc, field) as cursor: for row in cursor: sklon_koryta = (row[1] - row[2]) / row[4] if sklon_koryta == 0: raise ZeroSlopeError(row(0)) row[3] = sklon_koryta cursor.updateRow(row) row[5] = row[4] cursor.updateRow(row) # tvar koryt tab_stream_tvar = gp.GetParameterAsText(constants.PARAMETER_STREAMTABLE) tab_stream_tvar_code = gp.GetParameterAsText( constants.PARAMETER_STREAMTABLE_CODE) stream_tvar_dbf = temp_dp + os.sep + "stream_tvar.dbf" arcpy.CopyRows_management(tab_stream_tvar, stream_tvar_dbf) sfield = ["cislo", "smoderp", "tvar", "b", "m", "drsnost", "Q365"] try: arcpy.JoinField_management(toky, tab_stream_tvar_code, stream_tvar_dbf, tab_stream_tvar_code, "cislo;tvar;b;m;drsnost;Q365") except: arcpy.AddField_management(toky, "smoderp", "TEXT") arcpy.CalculateField_management(toky, "smoderp", "0", "PYTHON") arcpy.JoinField_management(toky, tab_stream_tvar_code, stream_tvar_dbf, tab_stream_tvar_code, "cislo;tvar;b;m;drsnost;Q365") with arcpy.da.SearchCursor(toky, sfield) as cursor: for row in cursor: for i in range(len(row)): if row[i] == " ": prt.message( "Value in tab_stream_tvar are no correct - STOP, check shp file toky in output" ) sys.exit() fields = arcpy.ListFields(toky) # field_names = [field.name for field in fields if field.type != # 'Geometry'] field_names = [field.name for field in fields] toky_tmp = [[] for field in fields] for row in arcpy.SearchCursor(toky): field_vals = [row.getValue(field) for field in field_names] # field_vals for i in range(len(field_vals)): toky_tmp[i].append(field_vals[i]) del row # all columns names in """[u'FID', u'Shape', u'Id', u'Id_1', u'Id_12', u'Id_12_13', u'Id_12_1_14', u'Id_12_1_15', u'RASTERVALU', u'POINT_X', u'POINT_Y', u'Id_12_1_16', u'Id_12_1_17', u'Id_12_1_18', u'RASTERVA_1', u'POINT_X_1', u'POINT_Y_1', u'to_node', u'length', u'sklon', u'V_infl_ce', u'V_infl_us', u'V_infl', u'Q_outfl', u'V_outfl', u'V_outfl_tm', u'V_zbyt', u'V_zbyt_tm', u'V', u'h', u'vs', u'NS', u'total_Vic', u'total_Viu', u'max_Q', u'max_h', u'max_vs', u'total_Vo', u'total_Vi', u'total_NS', u'total_Vz', u'smoderp', u'CISLO', u'TVAR', u'B', u'M', u'DRSNOST', u'Q365']""" tokylist = [] # Kubuv vyber tokylist.append(toky_tmp[field_names.index('FID')]) tokylist.append(toky_tmp[field_names.index('POINT_X')]) tokylist.append(toky_tmp[field_names.index('POINT_Y')]) tokylist.append(toky_tmp[field_names.index('POINT_X_1')]) tokylist.append(toky_tmp[field_names.index('POINT_Y_1')]) tokylist.append(toky_tmp[field_names.index('to_node')]) tokylist.append(toky_tmp[field_names.index('length')]) tokylist.append(toky_tmp[field_names.index('sklon')]) try: tokylist.append(toky_tmp[field_names.index('smoderp')]) except ValueError: tokylist.append(toky_tmp[field_names.index('SMODERP')]) try: tokylist.append(toky_tmp[field_names.index('cislo')]) except ValueError: tokylist.append(toky_tmp[field_names.index('CISLO')]) try: tokylist.append(toky_tmp[field_names.index('tvar')]) except ValueError: tokylist.append(toky_tmp[field_names.index('TVAR')]) try: tokylist.append(toky_tmp[field_names.index('b')]) except ValueError: tokylist.append(toky_tmp[field_names.index('B')]) try: tokylist.append(toky_tmp[field_names.index('m')]) except ValueError: tokylist.append(toky_tmp[field_names.index('M')]) try: tokylist.append(toky_tmp[field_names.index('drsnost')]) except ValueError: tokylist.append(toky_tmp[field_names.index('DRSNOST')]) try: tokylist.append(toky_tmp[field_names.index('q365')]) except ValueError: tokylist.append(toky_tmp[field_names.index('Q365')]) return tokylist, cell_stream, mat_tok_usek, STREAM_RATIO, tokyLoc
# ----------------------------------------------------------------------------- # Copy all input arcs into temp fc for primary direction. # ----------------------------------------------------------------------------- arc_dir1_lyr = 'arc_dir1_lyr' arcpy.MakeFeatureLayer_management(in_arc, arc_dir1_lyr) arcpy.CopyFeatures_management(arc_dir1_lyr, temp_arc_1) delete_dir2_fields(temp_arc_1) # ----------------------------------------------------------------------------- # Process DIRECTIONS = 2 & DIRECTIONS = 3. # ----------------------------------------------------------------------------- arc_dirs23_lyr = 'arc_dirs23_lyr' arcpy.MakeFeatureLayer_management(in_arc, arc_dirs23_lyr, """ "DIRECTIONS" IN ('2', '3') """) arcpy.CopyFeatures_management(arc_dirs23_lyr, temp_arc_2) arcpy.FlipLine_edit(temp_arc_2) # Reverse digitized direction with arcpy.da.UpdateCursor(temp_arc_2, ['ANODE', 'BNODE', 'ABB', 'BEARING']) as cursor: for row in cursor: anode = row[1] # Switch ANODE and BNODE bnode = row[0] baselink = row[2][-1] abb = '{0}-{1}-{2}'.format(anode, bnode, baselink) # Generate new ABB bearing = invert_bearing(row[3]) cursor.updateRow([anode, bnode, abb, bearing]) arc_dir3_lyr = 'arc_dir3_lyr' arcpy.MakeFeatureLayer_management(temp_arc_2, arc_dir3_lyr, """ "DIRECTIONS" = '3' """) for field in dir_fields: field1 = '{0}1'.format(field) field2 = '{0}2'.format(field) arcpy.CalculateField_management(arc_dir3_lyr, field1, '!{0}!'.format(field2), 'PYTHON')
def FlowPath(in_dem, in_sink, rain_intensity, out_flowpath): arcpy.CheckOutExtension("Spatial") workspace = os.path.split(out_flowpath)[0] arcpy.env.workspace = workspace arcpy.env.overwriteOutput = True dem = arcpy.Raster(in_dem) cell_size = dem.meanCellWidth if arcpy.Exists(in_dem) == False: arcpy.AddMessage("The input raster does not exist") quit() if os.path.splitext(out_flowpath)[1].lower() == ".shp": FieldOID = "FID" FlowDir = os.path.join(workspace, "FlowDir.tif") SinkCentroid = os.path.join(workspace, "SinkCentroid.shp") CostPath = os.path.join(workspace, "CostPath.tif") PathThin = os.path.join(workspace, "PathThin.tif") PathLine = os.path.join(workspace, "PathLine.shp") PathLineErase = os.path.join(workspace, "PathLineErase.shp") Path = os.path.join(workspace, "FlowPath_Raw.shp") # Path = out_flowpath LineFlip = os.path.join(workspace, "LineFlip.shp") LineNoFlip = os.path.join(workspace, "LineNoFlip.shp") FlowFrom = os.path.join(workspace, "FlowFrom.shp") FlowTo = os.path.join(workspace, "FlowTo.shp") PathLineEraseSingle = os.path.join(workspace, "PathLineEraseSingle.shp") LineStart = os.path.join(workspace, "LineStart.shp") LineEnd = os.path.join(workspace, "LineEnd.shp") LineStartElev = os.path.join(workspace, "LineStartElev.shp") LineEndElev = os.path.join(workspace, "LineEndElev.shp") PathBuffer = os.path.join(workspace, "PathBuffer.shp") PathBufferSingle = os.path.join(workspace, "PathBufferSingle.shp") FlowFromJoin = os.path.join(workspace, "FlowFromJoin.shp") FlowToJoin = os.path.join(workspace, "FlowToJoin.shp") FlowFromJoinBuffer = os.path.join(workspace, "FlowFromJoinBuffer.shp") FlowToJoinBuffer = os.path.join(workspace, "FlowToJoinBuffer.shp") else: FieldOID = "OBJECTID" FlowDir = os.path.join(workspace, "FlowDir") SinkCentroid = os.path.join(workspace, "SinkCentroid") CostPath = os.path.join(workspace, "CostPath") PathThin = os.path.join(workspace, "PathThin") PathLine = os.path.join(workspace, "PathLine") PathLineErase = os.path.join(workspace, "PathLineErase") Path = os.path.join(workspace, "FlowPath") LineFlip = os.path.join(workspace, "LineFlip") LineNoFlip = os.path.join(workspace, "LineNoFlip") FlowFrom = os.path.join(workspace, "FlowFrom") FlowTo = os.path.join(workspace, "FlowTo") LineStart = os.path.join(workspace, "LineStart.shp") LineEnd = os.path.join(workspace, "LineEnd.shp") ### Delineate flow direction flow_dir = arcpy.sa.FlowDirection(in_dem) flow_dir.save(FlowDir) ### Extract the depression polygon centroids arcpy.FeatureToPoint_management(in_sink, SinkCentroid, "INSIDE") ### Delineate cost path cost_path = arcpy.sa.CostPath(SinkCentroid, in_dem, FlowDir, "EACH_CELL", FieldOID) cost_path.save(CostPath) ### Thin the raster cost path to single-cell width path_thin = arcpy.sa.Thin(cost_path, "#", "#", "#", 1) path_thin.save(PathThin) ### Convert the raster path to vector arcpy.RasterToPolyline_conversion(path_thin, PathLine, simplify="NO_SIMPLIFY") ### Erase the flow path within depression polygons arcpy.Erase_analysis(PathLine, in_sink, PathLineErase) arcpy.MultipartToSinglepart_management(PathLineErase, PathLineEraseSingle) arcpy.FeatureVerticesToPoints_management(PathLineEraseSingle, LineStart, "START") arcpy.FeatureVerticesToPoints_management(PathLineEraseSingle, LineEnd, "END") arcpy.sa.ExtractValuesToPoints(LineStart, in_dem, LineStartElev) arcpy.sa.ExtractValuesToPoints(LineEnd, in_dem, LineEndElev) arcpy.AddField_management(LineStartElev, field_name="FromElev", field_type="FLOAT") arcpy.AddField_management(LineEndElev, field_name="ToElev", field_type="FLOAT") arcpy.CalculateField_management( in_table=LineStartElev, field="FromElev", expression="!RASTERVALU!", expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( in_table=LineEndElev, field="ToElev", expression="!RASTERVALU!", expression_type="PYTHON", code_block="", ) arcpy.JoinField_management( in_data=PathLineEraseSingle, in_field="FID", join_table=LineStartElev, join_field="FID", fields="FromElev", ) arcpy.JoinField_management( in_data=PathLineEraseSingle, in_field="FID", join_table=LineEndElev, join_field="FID", fields="ToElev", ) arcpy.CopyFeatures_management(PathLineEraseSingle, Path) # ExtractElevation(PathLineErase, in_dem, Path) arcpy.AddField_management(Path, "Flip", "SHORT") FromElev = arcpy.AddFieldDelimiters(workspace, "FromElev") ToElev = arcpy.AddFieldDelimiters(workspace, "ToElev") sql = FromElev + "<" + ToElev sql2 = FromElev + ">=" + ToElev arcpy.Select_analysis(Path, LineFlip, sql) arcpy.CalculateField_management(LineFlip, "Flip", "1", "PYTHON") arcpy.FlipLine_edit(LineFlip) arcpy.Select_analysis(Path, LineNoFlip, sql2) arcpy.Delete_management(Path) MergeList = [] MergeList.append(LineFlip) MergeList.append(LineNoFlip) arcpy.Merge_management(MergeList, Path) arcpy.AddField_management(Path, field_name="StartElev", field_type="FLOAT") arcpy.AddField_management(Path, field_name="EndElev", field_type="FLOAT") arcpy.AddField_management(Path, field_name="DiffElev", field_type="FLOAT") arcpy.AddField_management(Path, field_name="Length", field_type="FLOAT") arcpy.CalculateField_management( in_table=Path, field="StartElev", expression="max( !FromElev! , !ToElev! )", expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( in_table=Path, field="EndElev", expression="min( !FromElev! , !ToElev! )", expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( in_table=Path, field="DiffElev", expression="!StartElev! - !EndElev!", expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( Path, "Length", "!shape.length@meters!", "PYTHON_9.3", "#" ) arcpy.DeleteField_management( in_table=Path, drop_field="ARCID;GRID_CODE;FROM_NODE;TO_NODE;ORIG_FID;FromElev;ToElev;Flip", ) sql3 = "Length >" + str( 2 * cell_size ) # if flow path is shorter than 2 pixels, delete arcpy.Select_analysis(Path, out_flowpath, sql3) arcpy.FeatureVerticesToPoints_management(out_flowpath, FlowFrom, "START") arcpy.FeatureVerticesToPoints_management(out_flowpath, FlowTo, "END") arcpy.AddField_management(FlowFrom, field_name="FlowFromID", field_type="Long") arcpy.AddField_management(FlowTo, field_name="FlowToID", field_type="Long") arcpy.CalculateField_management( in_table=FlowFrom, field="FlowFromID", expression="!FID! + 1", expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( in_table=FlowTo, field="FlowToID", expression="!FID! + 1", expression_type="PYTHON", code_block="", ) # derive sink connectivity arcpy.Buffer_analysis( in_features=Path, out_feature_class=PathBuffer, buffer_distance_or_field="0.1 Meters", line_side="FULL", line_end_type="FLAT", dissolve_option="ALL", dissolve_field="", method="PLANAR", ) arcpy.MultipartToSinglepart_management( in_features=PathBuffer, out_feature_class=PathBufferSingle ) arcpy.AddField_management( PathBufferSingle, field_name="BufferID", field_type="Long" ) arcpy.CalculateField_management( in_table=PathBufferSingle, field="BufferID", expression="!FID! + 1", expression_type="PYTHON", code_block="", ) search_radius = str(2.1 * cell_size) + " Meters" arcpy.SpatialJoin_analysis( target_features=FlowFrom, join_features=in_sink, out_feature_class=FlowFromJoin, join_operation="JOIN_ONE_TO_ONE", join_type="KEEP_COMMON", # field_mapping="""ID "ID" true true false 10 Long 0 10 ,First,#,poly,ID,-1,-1""", match_option="INTERSECT", search_radius=search_radius, distance_field_name="", ) arcpy.SpatialJoin_analysis( target_features=FlowTo, join_features=in_sink, out_feature_class=FlowToJoin, join_operation="JOIN_ONE_TO_ONE", join_type="KEEP_COMMON", # field_mapping="""ID "ID" true true false 10 Long 0 10 ,First,#,poly,ID,-1,-1""", match_option="INTERSECT", search_radius=search_radius, distance_field_name="", ) arcpy.SpatialJoin_analysis( target_features=FlowFromJoin, join_features=PathBufferSingle, out_feature_class=FlowFromJoinBuffer, join_operation="JOIN_ONE_TO_ONE", join_type="KEEP_COMMON", # field_mapping="""ID "ID" true true false 10 Long 0 10 ,First,#,poly,ID,-1,-1""", match_option="INTERSECT", search_radius=search_radius, distance_field_name="", ) arcpy.SpatialJoin_analysis( target_features=FlowToJoin, join_features=PathBufferSingle, out_feature_class=FlowToJoinBuffer, join_operation="JOIN_ONE_TO_ONE", join_type="KEEP_COMMON", # field_mapping="""ID "ID" true true false 10 Long 0 10 ,First,#,poly,ID,-1,-1""", match_option="INTERSECT", search_radius=search_radius, distance_field_name="", ) arcpy.JoinField_management( in_data=FlowFromJoinBuffer, in_field="BufferID", join_table=FlowToJoinBuffer, join_field="BufferID", fields="ID", ) arcpy.JoinField_management( in_data=in_sink, in_field="ID", join_table=FlowFromJoinBuffer, join_field="ID", fields="ID_12", ) arcpy.AddField_management(in_sink, field_name="Downstream", field_type="LONG") arcpy.CalculateField_management( in_table=in_sink, field="Downstream", expression="!ID_12!", expression_type="PYTHON", code_block="", ) arcpy.DeleteField_management(in_table=in_sink, drop_field="ID_12") arcpy.AddField_management(in_sink, field_name="simu_depth", field_type="FLOAT") arcpy.AddField_management(in_sink, field_name="rain_inten", field_type="FLOAT") arcpy.AddField_management(in_sink, field_name="time_inund", field_type="FLOAT") arcpy.CalculateField_management( in_table=in_sink, field="simu_depth", expression="!volume! / !cat_area!", expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( in_table=in_sink, field="rain_inten", expression=rain_intensity, expression_type="PYTHON", code_block="", ) arcpy.CalculateField_management( in_table=in_sink, field="time_inund", expression="!simu_depth! / !rain_inten!", expression_type="PYTHON", code_block="", ) arcpy.JoinField_management( in_data=out_flowpath, in_field="FID", join_table=FlowFromJoin, join_field="ORIG_FID", fields="ID", ) arcpy.AddField_management( in_table=out_flowpath, field_name="start_sink", field_type="LONG" ) arcpy.CalculateField_management( in_table=out_flowpath, field="start_sink", expression="!ID!", expression_type="PYTHON", code_block="", ) arcpy.DeleteField_management(in_table=out_flowpath, drop_field="ID") arcpy.JoinField_management( in_data=out_flowpath, in_field="FID", join_table=FlowToJoin, join_field="ORIG_FID", fields="ID", ) arcpy.AddField_management( in_table=out_flowpath, field_name="end_sink", field_type="LONG" ) arcpy.CalculateField_management( in_table=out_flowpath, field="end_sink", expression="!ID!", expression_type="PYTHON", code_block="", ) arcpy.DeleteField_management(in_table=out_flowpath, drop_field="ID") arcpy.JoinField_management( in_data=out_flowpath, in_field="start_sink", join_table=in_sink, join_field="ID", fields="volume;cat_area;simu_depth;rain_inten;time_inund", ) arcpy.Delete_management(LineFlip) arcpy.Delete_management(LineNoFlip) arcpy.Delete_management(CostPath) arcpy.Delete_management(FlowDir) arcpy.Delete_management(PathLineErase) arcpy.Delete_management(PathThin) arcpy.Delete_management(LineStart) arcpy.Delete_management(LineStartElev) arcpy.Delete_management(LineEnd) arcpy.Delete_management(LineEndElev) arcpy.Delete_management(PathLineEraseSingle) arcpy.Delete_management(SinkCentroid) arcpy.Delete_management(PathLine) arcpy.Delete_management(PathBuffer) arcpy.Delete_management(PathBufferSingle) arcpy.Delete_management(FlowFromJoin) arcpy.Delete_management(FlowToJoin) arcpy.Delete_management(FlowFromJoinBuffer) arcpy.Delete_management(FlowToJoinBuffer) arcpy.AddMessage("Flow path delineation done!") return out_flowpath