def test_BNetwork_class04(self):
"""
Test que prueba cabeceras en cuenca 1 con small25 (sin utilizar id field)
474260.9;4114339.6;3
474856.9;4114711.1;2
"""
# Cargamos DEM, Flow, Network
fd = Flow("{}/{}_fd.tif".format(infolder, "small25"))
net = Network("{}/{}_net.dat".format(infolder, "small25"))
# Cargamos outlets, heads y generamos cuencas
outlets = np.loadtxt("{}/{}_bnet_outlets.txt".format(
infolder, "small25"),
delimiter=";")
heads = np.loadtxt("{}/{}_bnet_heads.txt".format(infolder, "small25"),
delimiter=";")
# Remove the id column
heads = heads[:, :-1]
outlets = net.snap_points(outlets)
cuencas = fd.get_drainage_basins(outlets)
bid = 1
bnet = BNetwork(net, cuencas, heads, bid)
self.assertEqual(np.array_equal(bnet._heads, np.array([16171, 13494])),
True)
def test_BNetwork_class01(self):
"""
Test00 Crea BNetwork para cuencas de prueba a partir de un objeto Basin
Sin utilizar cabeceras
"""
files = ["small25", "jebja30", "tunez"]
for file in files:
# Cargamos DEM, Flow, Network
fd = Flow("{}/{}_fd.tif".format(infolder, file))
dem = DEM("{}/{}.tif".format(infolder, file))
net = Network("{}/{}_net.dat".format(infolder, file))
# Cargamos outlets y generamos cuencas
outlets = np.loadtxt("{}/{}_bnet_outlets.txt".format(
infolder, file),
delimiter=";")
outlets = net.snap_points(outlets)
cuencas = fd.get_drainage_basins(outlets)
for bid in np.unique(cuencas.read_array()):
if bid == 0:
continue
basin = Basin(dem, cuencas, bid)
bnet = BNetwork(net, basin)
# Este test solo verifica que se realice sin fallos y que
# el objeto bnet tiene una única cabecera
bnet = BNetwork(net, cuencas, None, bid)
self.assertEqual(int(bnet._heads[0]), self.results[file][bid])
def test_BasinClass01(self):
files = ["small25", "jebja30", "tunez"]
for file in files:
# Cargamos flow
flw_path = "{}/{}_fd.tif".format(infolder, file)
dem_path = "{}/{}.tif".format(infolder, file)
dem = DEM(dem_path)
fd = Flow(flw_path)
# Obtenemos cuencas
cuencas = fd.get_drainage_basins(min_area=0.0025)
# Mayor, menor, y random
bids, counts = np.unique(cuencas.read_array(), return_counts=True)
if 0 in bids:
bids = bids[1:]
counts = counts[1:]
idmax = bids[np.argmax(counts)]
idmin = bids[np.argmin(counts)]
idrdn = np.random.choice(bids)
idxs = [idmax, idmin, idrdn]
lbls = ["max", "min", "rdn"]
for n in range(3):
basin = Basin(dem, cuencas, idxs[n])
basin_path = "{}/{}_basin{}.tif".format(
outfolder, file, lbls[n])
basin.save(basin_path)
basin2 = Basin(basin_path)
computed = np.array_equal(basin.read_array(),
basin2.read_array())
self.assertEqual(computed, True)
def test_drainage_basins_04(self):
# Test extracting all basins (min_area = 10%)
files = ["small25", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
# Extract all basin with min_area
basins = fd.get_drainage_basins()
basins.save(outfolder + "/all_basins-minarea_{0}.tif".format(file))
def test_drainage_basins_05(self):
# Test extracting all basins
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
# Extract all basin without min_area
basins = fd.get_drainage_basins(min_area=0)
basins.save(outfolder + "/all_basins{0}".format(file))
def setUp(self):
# Load test data
self.ids = np.load(infolder + "/np_files/small25_100rnd_id.npy")
self.rows = np.load(infolder + "/np_files/small25_100rnd_row.npy")
self.cols = np.load(infolder + "/np_files/small25_100rnd_col.npy")
self.xi = np.load(infolder + "/np_files/small25_100rnd_X.npy")
self.yi = np.load(infolder + "/np_files/small25_100rnd_Y.npy")
self.zi = np.load(infolder + "/np_files/small25_100rnd_Z.npy")
# Load Flow object
self.fd = Flow(infolder + "/small25_fd.tif")
def test_create_Flow_03(self):
# Create Flow object with previously filled DEM (auxtopo is ignored)
files = ["small", "small25", "morocco", "tunez", "jebja30"]
for file in files:
dem_path = infolder + "/{0}_fil.tif".format(file)
flw_path = infolder + "/{0}_fd.tif".format(file)
dem = DEM(dem_path)
fd = Flow(dem, auxtopo=False, filled=True, verbose=False) # Flow obj with filled dem and without auxiliar topography
fd2 = Flow(flw_path)
computed = np.array_equal(fd2._ix, fd._ix)
self.assertEqual(computed, True)
def test_create_Flow_02(self):
# Create Flow object with auxiliar topography
files = ["small", "small25", "tunez", "jebja30"]
for file in files:
dem_path = infolder + "/{0}.tif".format(file)
flw_path = infolder + "/{0}_fd_auxtp.tif".format(file)
dem = DEM(dem_path)
fd = Flow(dem, auxtopo=True, filled=False, verbose=False) # Flow obj with auxiliar topography
fd2 = Flow(flw_path)
computed = np.array_equal(fd2._ix, fd._ix)
self.assertEqual(computed, True)
def test_stream_poi_01(self):
# Test 10 random basins
files = ["small25", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
thr = int(fd.get_ncells() * 0.0025)
for kind in ["heads", "confluences", "outlets"]:
poi = fd.get_stream_poi(thr, kind, "XY")
spoi = np.loadtxt(infolder + "/{0}_{1}.txt".format(file, kind), delimiter=";", skiprows=1)
compare = np.array_equal(poi, spoi)
self.assertEqual(compare, True)
def test_snap_poi_02(self):
# Test 10 random basins
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
thr = int(fd.get_ncells() * 0.01)
# Obtenemos 20 puntos aleatorios
x1, x2, y1, y2 = fd.get_extent()
xi = (x2 - x1) * np.random.random(25) + x1
yi = (y2 - y1) * np.random.random(25) + y1
puntos = np.array((xi, yi)).T
# Obtenemos lista con Flow Accumulations cells
fac = fd.get_flow_accumulation(nodata=False, asgrid=False)
ch_cells = np.where(fac.ravel() >= thr)[0]
# Hacemos snap a celdas de canal
snap_pp = fd.snap_points(puntos, thr, kind="channel")
row, col = fd.xy_2_cell(snap_pp[:, 0], snap_pp[:, 1])
inds = fd.cell_2_ind(row, col)
# Comprobamos que punto esta entre los POI
for ind in inds:
res = ind in ch_cells
self.assertEqual(res, True)
def test_stream_poi_02(self):
dem_files = ['tunez.tif', 'small25.tif', "jebja30.tif"]
for file in dem_files:
dem = DEM(infolder + "/" + file)
fd = Flow(dem)
thr = int(fd.get_ncells() * 0.01)
net = Network(fd, dem, thr)
out01 = fd.get_stream_poi(thr, "confluences", "CELL")
out02 = net.get_stream_poi("confluences", "CELL")
computed = np.array_equal(out01, out02)
print(file)
self.assertEqual(computed, True)
def test_drainage_basins_01(self):
# Test 10 random basins
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
# Creamos 10 cuencas aleatorias
ri = np.random.randint(0, fd._dims[0], 10)
ci = np.random.randint(0, fd._dims[1], 10)
xi, yi = fd.cell_2_xy(ri, ci)
# Extract basins
outlets = np.array((xi, yi)).T
basins = fd.get_drainage_basins(outlets)
basins.save(outfolder + "/rnd_basins_{0}".format(file))
def test_drainage_basins_03(self):
# Test extracting the biggest basin and input as a list [x, y]
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
# Get coords of the highest flow accumulation
fac = fd.get_flow_accumulation()
maxval = fac.max()
rowpos, colpos = np.where(fac.read_array() == maxval)
xi, yi = fd.cell_2_xy(rowpos, colpos)
# Extract basin
outlets = np.array((xi, yi)).T
basins = fd.get_drainage_basins(outlets)
basins.save(outfolder + "/max_basin2_{0}".format(file))
def test_create_network(self):
files = ["small25", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
net_path = outfolder + "/{0}_net.dat".format(file)
fd = Flow(flw_path)
# Creamos objeto network
net = Network(fd, gradients=True)
# Guardamos objeto network y cargamos
net.save(net_path)
net2 = Network(net_path)
# Comparamos propiedades,
prop_net = [net._size, net._geot, net._proj]
prop_net2 = [net2._size, net2._geot, net2._proj]
self.assertEqual(prop_net, prop_net2)
# Comparamos los datos
arr1 = np.array((net._ix, net._ixc, net._ax, net._dx, net._zx,
net._chi, net._slp, net._ksn, net._dd))
arr2 = np.array((net2._ix, net2._ixc, net2._ax, net2._dx, net2._zx,
net2._chi, net2._slp, net2._ksn, net2._dd))
res = np.array_equal(arr1, arr2)
self.assertEqual(res, True)
def test_BNetwork_class05(self):
"""
Test de creado masivo de cuencas con cabeceras aleatorias
"""
files = ["small25", "jebja30", "tunez"]
for file in files:
# Cargamos DEM, Flow, Network
fd = Flow("{}/{}_fd.tif".format(infolder, file))
net = Network("{}/{}_net.dat".format(infolder, file))
dem = DEM("{}/{}.tif".format(infolder, file))
# Generamos todas las cuencas
cuencas = fd.get_drainage_basins(min_area=0.0025)
# Generamos 50 puntos aleatorios dentro de la extensión del objeto Network
# Estos 50 puntos se usaran como cabeceras
xmin, xmax, ymin, ymax = net.get_extent()
xi = np.random.randint(xmin, xmax, 50)
yi = np.random.randint(ymin, ymax, 50)
heads = np.array((xi, yi)).T
# Cogemos 5 cuencas aleatorias
bids = np.random.choice(np.unique(cuencas.read_array())[1:], 5)
for bid in bids:
try:
if np.random.randint(100) < 70:
bnet = BNetwork(net, cuencas, heads, bid)
else:
basin = Basin(dem, cuencas, bid)
bnet = BNetwork(net, basin, heads)
except NetworkError:
print(
"Network of {} file inside the basin {} has not enough pixels"
.format(file, bid))
continue
# Salvamos BNetwork y volvemos a cargar para comprobar que se cargan-guardan bien
bnet_path = "{}/{}_{}_bnet.dat".format(outfolder, file, bid)
bnet.save(bnet_path)
bnet2 = BNetwork(bnet_path)
computed = np.array_equal(bnet._ix, bnet2._ix)
self.assertEqual(computed, True)
# borramos archivo
os.remove(bnet_path)
def test_stream_segments(self):
dem_files = ['tunez', 'tunez2', 'small25']
for filename in dem_files:
fd = Flow("data/fd_{0}.tif".format(filename))
st = Network(fd, 1000)
ssegments = st.get_stream_segments(False)
esegments = Grid("data/mlab_files/{0}_segments.tif".format(
filename)).read_array()
self.assertTrue(np.array_equal(ssegments, esegments), True)
def test_streams(self):
dem_files = ['tunez', 'tunez2', 'small25']
for filename in dem_files:
fd = Flow("data/fd_{0}.tif".format(filename))
st = Network(fd, 1000)
streams = st.get_streams()
st01 = streams.read_array()
st02 = Grid("data/str_{0}.tif".format(filename)).read_array()
self.assertTrue(np.array_equal(st01, st02), True)
def test_stream_order(self):
dem_files = ['tunez', 'tunez2', 'small25']
for filename in dem_files:
fd = Flow("data/fd_{0}.tif".format(filename))
st = Network(fd, 1000)
for kind in ['strahler', 'shreeve']:
exp_order = st.get_stream_order(kind=kind, asgrid=False)
cmp_order = Grid("data/mlab_files/{0}_{1}.tif".format(
filename, kind)).read_array()
self.assertTrue(np.array_equal(exp_order, cmp_order), True)
def test_flow_properties_02(self):
# Testing an empty Flow object
dem = DEM()
fd = Flow()
computed = (fd.get_size(), fd.get_dims(), fd.get_ncells(), fd.get_projection(), fd.get_cellsize(), fd.get_geotransform())
expected = (dem.get_size(), dem.get_dims(), dem.get_ncells(), dem.get_projection(), dem.get_cellsize(), dem.get_geotransform())
self.assertEqual(computed, expected)
def test_flow_properties_01(self):
files = ["small", "small25", "morocco", "tunez", "jebja30"]
for file in files:
dem = DEM(infolder + "/{0}.tif".format(file))
fd = Flow(infolder + "/{0}_fd.tif".format(file))
computed = (fd.get_size(), fd.get_dims(), fd.get_ncells(), fd.get_projection(), fd.get_cellsize(), fd.get_geotransform())
expected = (dem.get_size(), dem.get_dims(), dem.get_ncells(), dem.get_projection(), dem.get_cellsize(), dem.get_geotransform())
self.assertEqual(computed, expected)
def test_streampoi(self):
dem_files = ['tunez', 'tunez2', 'small25']
for filename in dem_files:
fd = Flow("data/fd_{0}.tif".format(filename))
st = Network(fd, 1000)
kinds = ['heads', 'confluences', 'outlets']
for kind in kinds:
poi = st.get_stream_poi(kind)
rows = poi[0].reshape((poi[0].size, 1))
cols = poi[1].reshape((poi[1].size, 1))
comp_poi = np.append(rows, cols, axis=1)
exp_poi = np.load("data/mlab_files/{0}_{1}.npy".format(
filename, kind))
self.assertEqual(np.array_equal(comp_poi, exp_poi), True)
def test_BNetwork_class00(self):
"""
Test00 Crea BNetwork para cuencas de prueba a partir de un Grid de cuencas
Sin utilizar cabeceras
"""
files = ["small25", "jebja30", "tunez"]
for file in files:
# Cargamos DEM, Flow, Network
fd = Flow("{}/{}_fd.tif".format(infolder, file))
net = Network("{}/{}_net.dat".format(infolder, file))
# Cargamos outlets y generamos cuencas
outlets = np.loadtxt("{}/{}_bnet_outlets.txt".format(
infolder, file),
delimiter=";")
outlets = net.snap_points(outlets)
cuencas = fd.get_drainage_basins(outlets)
for bid in np.unique(cuencas.read_array()):
if bid == 0:
continue
bnet = BNetwork(net, cuencas, None, bid)
self.assertEqual(int(bnet._heads[0]), self.results[file][bid])
def test_stream_poi_01(self):
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
dem_path = infolder + "/{0}.tif".format(file)
net_path = infolder + "/{0}_network.net".format(file)
dem = DEM(dem_path)
fd = Flow(flw_path)
thr = int(fd.get_ncells() * 0.01)
# Creamos objeto network
net = Network(dem, fd, thr)
net.save(net_path)
# Cargamos objeto network guardado
net2 = Network(net_path)
# Comparamos propiedades,
prop_net = [
net._size, net._dims, net._geot, net._cellsize, net._ncells,
net._proj
]
prop_net2 = [
net2._size, net2._dims, net2._geot, net2._cellsize,
net2._ncells, net2._proj
]
self.assertEqual(prop_net, prop_net2)
# Comparamos los datos
arr1 = np.array(
(net._ix, net._ixc, net._ax, net._dx, net._zx, net._chi,
net._slp, net._ksn, net._r2slp, net._r2ksn, net._dd))
arr2 = np.array(
(net2._ix, net2._ixc, net2._ax, net2._dx, net2._zx, net2._chi,
net2._slp, net2._ksn, net2._r2slp, net2._r2ksn, net2._dd))
res = np.array_equal(arr1, arr2)
self.assertEqual(res, True)
def processAlgorithm(self, parameters, context, feedback):
dem_raster = self.parameterAsRasterLayer(parameters, self.INPUT_DEM,
context)
fac_raster = self.parameterAsOutputLayer(parameters, self.OUTPUT_FAC,
context)
fd_raster = self.parameterAsOutputLayer(parameters, self.OUTPUT_FD,
context)
verbose = self.parameterAsBool(parameters, self.VERBOSE, context)
filled = self.parameterAsBool(parameters, self.FILLED, context)
auxtopo = self.parameterAsBool(parameters, self.AUXTOPO, context)
dem = DEM(dem_raster.source())
fd = Flow(dem,
auxtopo=auxtopo,
filled=filled,
verbose=verbose,
verb_func=feedback.setProgressText)
fac = fd.get_flow_accumulation()
fd.save_gtiff(fd_raster)
fac.save(fac_raster)
results = {}
results[self.OUTPUT_FD] = fd_raster
results[self.OUTPUT_FAC] = fac_raster
return results
def test_create_load(self):
dem_files = ['tunez', 'tunez2', 'small25']
for filename in dem_files:
fd = Flow("data/fd_{0}.tif".format(filename))
st = Network(fd, 1000)
computed = [
st.get_dims(),
st.get_size(),
st.get_ncells(),
st.get_cellsize(),
st.get_geotransform(),
st.get_projection()
]
expected = [
fd.get_dims(),
fd.get_size(),
fd.get_ncells(),
fd.get_cellsize(),
fd.get_geotransform(),
fd.get_projection()
]
self.assertTrue(computed, expected)
def test_drainage_basins_00(self):
# Test 10 random basins
files = ["small25", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
# Creamos 10 cuencas aleatorias
ri = np.random.randint(0, fd.get_dims()[0], 10)
ci = np.random.randint(0, fd.get_dims()[1], 10)
rdn_ids = np.random.randint(100, 700, 10)
xi, yi = fd.cell_2_xy(ri, ci)
# Extract basins
outlets = np.array((xi, yi, rdn_ids)).T
threshold = int(fd.get_ncells() * 0.05)
snap_outlets = fd.snap_points(outlets, threshold, kind="channel")
snap = np.append(snap_outlets, rdn_ids.reshape(rdn_ids.size, 1), 1)
basins = fd.get_drainage_basins(snap)
basins.save(outfolder + "/rnd_snap_basins_{0}.tif".format(file))
def test_snap_poi_01(self):
# Test 10 random basins
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
fd = Flow(flw_path)
thr = int(fd.get_ncells() * 0.01)
# Obtenemos 20 puntos aleatorios
x1, x2, y1, y2 = fd.get_extent()
xi = (x2 - x1) * np.random.random(25) + x1
yi = (y2 - y1) * np.random.random(25) + y1
puntos = np.array((xi, yi)).T
# Hacemos snap a los stream poi
for kind in ["heads", "confluences", "outlets"]:
poi = fd.get_stream_poi(thr, kind, "XY")
snap_pp = fd.snap_points(puntos, thr, kind)
# Comprobamos que punto esta entre los POI
for row in snap_pp:
res = row in poi
self.assertEqual(res, True)
# -*- coding: utf-8 -*-
"""
Editor de Spyder
Este es un archivo temporal
"""
from topopy import DEM, Flow, Network
infolder = "data/in"
outfolder = "data/out"
files = ["small25", "morocco", "tunez", "jebja30"]
for file in files:
flw_path = infolder + "/{0}_fd.tif".format(file)
dem_path = infolder + "/{0}.tif".format(file)
dem = DEM(dem_path)
fd = Flow(flw_path)
thr = int(fd.get_ncells() * 0.001)
# Simplemente probamos que no hay fallos al crear el objeto net
net = Network(dem, fd, thr)
net.save(infolder + "/{0}_network.net".format(file))
out_pos = (sum_arr == 0) & w
elif kind == 'confluences':
sum_arr = np.asarray(np.sum(sp_arr, 0)).ravel()
out_pos = sum_arr > 1
elif kind == 'outlets':
sum_arr = np.asarray(np.sum(sp_arr, 1)).ravel()
out_pos = (sum_arr == 0) & w
out_pos = out_pos.reshape(fd._dims)
row, col = np.where(out_pos)
return row, col
dem = DEM("../data/tunez.tif")
fd = Flow()
fd.load_gtiff("../data/tunez_fd.tif")
fig, ax = plt.subplots()
dem.plot(ax)
streams = fd.get_network(1000)
streams.plot(ax)
# Heads
row, col = get_stream_poi(fd, 1000, 'heads')
ax.plot(col, row, "ro")
#
# Confluences
row, col = get_stream_poi(fd, 1000, 'confluences')
ax.plot(col, row, "bs")
# -*- coding: utf-8 -*-
"""
Editor de Spyder
Este es un archivo temporal
"""
import numpy as np
from topopy import DEM, Flow, Network
import matplotlib.pyplot as plt
import gdal, ogr, osr
dem = DEM("../data/in/jebja30.tif")
fd = Flow("../data/in/jebja30_fd.tif")
net = Network(dem, fd, 2000)
path = "../data/out/jebja_streams.shp"
# Prepare auxiliar arrays
seg_array = net.get_stream_segments(False).ravel()
seg_array = seg_array[net._ix]
ord_array = net.get_stream_order('strahler', False).ravel()
ord_array = ord_array[net._ix]
ixcix = np.zeros(net._ncells, np.int)
ixcix[net._ix] = np.arange(net._ix.size)
# Create output shapefile
driver = ogr.GetDriverByName("ESRI Shapefile")
dataset = driver.CreateDataSource(path)
sp = osr.SpatialReference()
sp.ImportFromWkt(net._proj)
layer = dataset.CreateLayer("rios", sp, ogr.wkbLineString)
layer.CreateField(ogr.FieldDefn("sid", ogr.OFTInteger))
