En faite mon limite de zone d'etude est maintenant
le bassin versant superieur d'Ikopa , .. est que vous
pouvez me montrer la limitr de ce bassin et
comment l'obtenir ?
Excellent ! Le bassin versant supérieur de l'Ikopa est une zone d'étude très pertinente et bien
délimitée pour ton mémoire. Voici tout ce que tu dois savoir.
📍 Limites du Bassin Versant Supérieur de l'Ikopa
Caractéristiques géographiques
Superficie : Environ 1 500 km² [1] [2]
Altitude :
Point culminant (source) : 1 810 m au rocher Angavokely [3] [4]
Exutoire : Station de Mahitsy Kely à 1 250 m d'altitude [1] [2]
Altitude moyenne : 1 400 m [2]
Coordonnées de l'exutoire :
Latitude : 18°51' S
Longitude : 47°27' E [1]
Délimitation naturelle
Le bassin supérieur de l'Ikopa est délimité par [5] [1] :
Nord : Crêtes à plus de 1 500 m
Sud : Crêtes à plus de 1 700 m (massif de l'Ankaratra)
Est : Falaise orientale (ligne de partage des eaux entre versants est et ouest de
Madagascar)
Ouest : Zone de transition vers la plaine d'Antananarivo
Cours d'eau principaux
Sources :
Varahina-Nord et Varahina-Sud qui confluent pour former l'Ikopa [1] [4]
Source au rocher Angavokely (altitude 1 810 m)
Affluents principaux dans le bassin supérieur :
Sisaony (rive droite)
Andromba (rive droite)
Mamba (rive gauche) [4] [6]
🗺️Comment obtenir les limites du bassin (Shapefile)
Méthode 1 : Délimitation automatique avec QGIS/ArcGIS
Tu peux créer toi-même le shapefile du bassin !
A. Avec ArcGIS Pro (Spatial Analyst)
import arcpy
from [Link] import *
# Activer Spatial Analyst
[Link]("Spatial")
# 1. Télécharger MNT SRTM 30m pour Madagascar
# Depuis [Link]
# 2. Définir le point exutoire (Mahitsy Kely)
exutoire_coords = "-18.85, 47.45" # Lat, Lon
# 3. Créer point exutoire
[Link](
"C:/Temp", "Exutoire_Mahitsy", "POINT",
spatial_reference=[Link](4326)
)
# 4. Remplir les dépressions du MNT
dem_fill = Fill("MNT_Madagascar_30m.tif")
# 5. Calculer direction d'écoulement
flow_direction = FlowDirection(dem_fill)
# 6. Calculer accumulation
flow_accumulation = FlowAccumulation(flow_direction)
# 7. Délimiter le bassin versant
watershed = Watershed(flow_direction, "Exutoire_Mahitsy")
# 8. Convertir en shapefile
[Link](
watershed,
"Bassin_Ikopa_Superieur.shp",
"NO_SIMPLIFY"
)
print("✓ Bassin versant délimité et sauvegardé!")
B. Avec Python (WhiteboxTools + rasterio)
import whitebox
import rasterio
import geopandas as gpd
# Initialiser WhiteboxTools
wbt = [Link]()
# 1. Remplir dépressions
wbt.fill_depressions(
"MNT_Madagascar_30m.tif",
"MNT_filled.tif"
)
# 2. Direction d'écoulement (D8)
wbt.d8_pointer(
"MNT_filled.tif",
"flow_direction.tif"
)
# 3. Accumulation
wbt.d8_flow_accumulation(
"MNT_filled.tif",
"flow_accumulation.tif"
)
# 4. Créer point exutoire
exutoire_shapefile = "exutoire_mahitsy.shp"
# Créer manuellement ou depuis coordonnées
# 5. Délimiter bassin
[Link](
"flow_direction.tif",
exutoire_shapefile,
"Bassin_Ikopa_Superieur.tif"
)
# 6. Vectoriser
wbt.raster_to_vector_polygons(
"Bassin_Ikopa_Superieur.tif",
"Bassin_Ikopa_Superieur.shp"
)
print("✓ Bassin versant créé!")
Méthode 2 : Télécharger depuis sources existantes
A. HydroSHEDS (Recommandé)
Source : Base de données hydrologique mondiale à 30 arc-secondes (~1 km)
Lien : [Link]
Procédure :
1. Aller sur [Link]
2. Sélectionner région : Africa
3. Télécharger HydroBasins Level 8 ou 9
4. Filtrer pour Madagascar et bassin Ikopa
B. Madagascar Data Portal
CIRAD Dataverse (déjà mentionné pour les cartes d'occupation du sol)
Lien : [Link]
Rechercher : "bassin versant Madagascar" ou "Ikopa watershed"
C. OpenStreetMap (OSM)
import osmnx as ox
# Télécharger cours d'eau autour d'Antananarivo
rivers = ox.features_from_place(
"Antananarivo, Madagascar",
tags={'waterway': ['river', 'stream']}
)
rivers.to_file("rivers_antananarivo.shp")
Méthode 3 : Digitalisation manuelle
Si aucune donnée n'est disponible, tu peux digitaliser manuellement avec QGIS :
1. Charger le MNT SRTM dans QGIS
2. Afficher les courbes de niveau : Raster → Extraction → Contour
3. Identifier les lignes de crête (points hauts)
4. Créer une nouvelle couche polygon
5. Dessiner le contour en suivant les crêtes
6. Sauvegarder : Bassin_Ikopa_Superieur.shp
📊 Script Python complet : Délimitation automatique du bassin
import rasterio
import numpy as np
from scipy import ndimage
import geopandas as gpd
from [Link] import Point, Polygon
import [Link] as plt
class WatershedDelineator:
"""Délimitation automatique de bassin versant"""
def __init__(self, dem_path):
"""
Initialiser avec MNT
Parameters:
-----------
dem_path : str
Chemin vers MNT (SRTM 30m)
"""
with [Link](dem_path) as src:
[Link] = [Link](1)
[Link] = [Link]
[Link] = [Link]
print(f"✓ MNT chargé: {[Link]}")
def fill_depressions(self):
"""Remplir les dépressions du MNT"""
from [Link] import maximum_filter
filled = [Link]()
max_elev = [Link](filled)
# Algorithme de remplissage simple
for _ in range(10):
filled_new = maximum_filter(filled, size=3)
filled_new = [Link](filled_new, max_elev)
if [Link](filled, filled_new):
break
filled = filled_new
self.dem_filled = filled
print("✓ Dépressions remplies")
return filled
def flow_direction_d8(self):
"""Calculer direction d'écoulement (D8)"""
rows, cols = self.dem_filled.shape
flow_dir = [Link]((rows, cols), dtype=np.uint8)
# Directions D8
directions = [
(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 1),
(1, -1), (1, 0), (1, 1)
]
direction_codes = [64, 128, 1, 32, 2, 16, 8, 4]
for i in range(1, rows-1):
for j in range(1, cols-1):
max_slope = -[Link]
max_dir = 0
for k, (di, dj) in enumerate(directions):
ni, nj = i + di, j + dj
slope = self.dem_filled[i, j] - self.dem_filled[ni, nj]
if slope > max_slope:
max_slope = slope
max_dir = direction_codes[k]
flow_dir[i, j] = max_dir
self.flow_direction = flow_dir
print("✓ Direction d'écoulement calculée")
return flow_dir
def flow_accumulation(self):
"""Calculer accumulation de flux"""
rows, cols = self.flow_direction.shape
accumulation = [Link]((rows, cols), dtype=np.int32)
# Tri des cellules par altitude décroissante
flat_dem = self.dem_filled.flatten()
sorted_indices = [Link](-flat_dem)
# Directions inverses
direction_map = {
64: (1, 1), 128: (1, 0), 1: (1, -1),
32: (0, 1), 2: (0, -1),
16: (-1, 1), 8: (-1, 0), 4: (-1, -1)
}
for idx in sorted_indices:
i = idx // cols
j = idx % cols
if i == 0 or i == rows-1 or j == 0 or j == cols-1:
continue
dir_code = self.flow_direction[i, j]
if dir_code in direction_map:
di, dj = direction_map[dir_code]
ni, nj = i + di, j + dj
if 0 <= ni < rows and 0 <= nj < cols:
accumulation[ni, nj] += accumulation[i, j]
[Link] = accumulation
print("✓ Accumulation calculée")
return accumulation
def delineate_watershed(self, outlet_row, outlet_col):
"""Délimiter le bassin versant depuis un exutoire"""
rows, cols = self.flow_direction.shape
watershed = [Link]((rows, cols), dtype=bool)
# File d'attente pour parcours inverse
queue = [(outlet_row, outlet_col)]
watershed[outlet_row, outlet_col] = True
# Directions inverses
inverse_directions = {
64: (-1, -1), 128: (-1, 0), 1: (-1, 1),
32: (0, -1), 2: (0, 1),
16: (1, -1), 8: (1, 0), 4: (1, 1)
}
visited = set()
while queue:
i, j = [Link](0)
if (i, j) in visited:
continue
[Link]((i, j))
# Chercher cellules qui drainent vers (i,j)
for di in [-1, 0, 1]:
for dj in [-1, 0, 1]:
if di == 0 and dj == 0:
continue
ni, nj = i + di, j + dj
if 0 <= ni < rows and 0 <= nj < cols:
dir_code = self.flow_direction[ni, nj]
if dir_code in inverse_directions:
target_di, target_dj = inverse_directions[dir_code]
if ni + target_di == i and nj + target_dj == j:
watershed[ni, nj] = True
[Link]((ni, nj))
[Link] = watershed
print(f"✓ Bassin délimité: {[Link](watershed)} pixels")
return watershed
def watershed_to_shapefile(self, output_path):
"""Convertir bassin en shapefile"""
from rasterio import features
# Vectoriser
shapes = [Link](
[Link](np.uint8),
transform=[Link]
)
polygons = []
for geom, val in shapes:
if val == 1:
[Link](Polygon(geom['coordinates'][^0]))
# Créer GeoDataFrame
gdf = [Link](
{'geometry': polygons},
crs=[Link]['crs']
)
# Sauvegarder
gdf.to_file(output_path)
print(f"✓ Shapefile sauvegardé: {output_path}")
return gdf
def visualize(self):
"""Visualiser le bassin délimité"""
fig, axes = [Link](2, 2, figsize=(14, 12))
# MNT original
axes[0, 0].imshow([Link], cmap='terrain')
axes[0, 0].set_title('MNT Original')
axes[0, 0].axis('off')
# Direction d'écoulement
axes[0, 1].imshow(self.flow_direction, cmap='viridis')
axes[0, 1].set_title('Direction d\'écoulement')
axes[0, 1].axis('off')
# Accumulation
log_accum = np.log10([Link] + 1)
axes[1, 0].imshow(log_accum, cmap='Blues')
axes[1, 0].set_title('Accumulation (log10)')
axes[1, 0].axis('off')
# Bassin délimité
axes[1, 1].imshow([Link], cmap='terrain', alpha=0.5)
axes[1, 1].imshow([Link], cmap='Reds', alpha=0.5)
axes[1, 1].set_title('Bassin Versant Délimité')
axes[1, 1].axis('off')
plt.tight_layout()
[Link]('watershed_delineation_results.png', dpi=300)
[Link]()
# === UTILISATION ===
# 1. Charger MNT
delineator = WatershedDelineator('MNT_Antananarivo_SRTM_30m.tif')
# 2. Remplir dépressions
delineator.fill_depressions()
# 3. Calculer direction d'écoulement
delineator.flow_direction_d8()
# 4. Calculer accumulation
delineator.flow_accumulation()
# 5. Définir exutoire (Mahitsy Kely : 18°51'S, 47°27'E)
# Convertir coordonnées géographiques en indices pixels
outlet_row = 1200 # À ajuster selon ton MNT
outlet_col = 1500 # À ajuster selon ton MNT
# 6. Délimiter bassin
delineator.delineate_watershed(outlet_row, outlet_col)
# 7. Sauvegarder shapefile
basin_gdf = delineator.watershed_to_shapefile('Bassin_Ikopa_Superieur.shp')
# 8. Visualiser
[Link]()
print("\n✓ Délimitation du bassin versant supérieur de l'Ikopa terminée!")
print(f"Surface: {basin_gdf.[Link]() / 1e6:.2f} km²")
📦 Données nécessaires pour délimitation
Donnée Source Résolution Lien
MNT SRTM USGS 30 m [Link]
MNT ALOS JAXA 12.5 m [Link]
Coordonnées exutoire GPS / Google Earth - Mahitsy Kely : -18.85, 47.45
📝 Intégration dans ton mémoire
Chapitre 2 : Présentation de la zone d'étude
Section à ajouter :
2.2.1 Délimitation du bassin versant supérieur de l'Ikopa
Le bassin versant supérieur de l'Ikopa a été délimité à partir du Modèle Numérique
de Terrain SRTM à 30 m de résolution. L'exutoire a été fixé à la station hydrométrique
de Mahitsy Kely (18°51'S, 47°27'E, altitude 1 250 m).
La délimitation a été réalisée selon la méthodologie suivante :
1. Remplissage des dépressions du MNT
2. Calcul de la direction d'écoulement (algorithme D8)
3. Calcul de l'accumulation de flux
4. Extraction du bassin versant contributif
Le bassin ainsi délimité couvre une superficie de 1 500 km², avec une altitude
moyenne de 1 400 m. Il est bordé au nord par des crêtes à 1 500 m, au sud par
le massif de l'Ankaratra (1 700 m), et à l'est par la falaise orientale qui
constitue la ligne de partage des eaux entre les versants est et ouest de Madagascar.
Carte à inclure :
Figure 2.3 : Carte du bassin versant supérieur de l'Ikopa avec limites, réseau
hydrographique, MNT et localisation de l'exutoire.
Avec ces informations et scripts, tu peux maintenant délimiter précisément ton bassin
versant supérieur de l'Ikopa et l'intégrer dans ton mémoire ! 🗺️📊
⁂
1. [Link]
2. [Link]
3. [Link]
4. [Link]
5. [Link]
6. [Link]
-Hydrological-Study
7. [Link]
8. [Link]
9. [Link]
10. [Link]
11. [Link]
12. [Link]
13. [Link]
d4-479c-b7ea-edec4db92697/download/[Link]
14. [Link]
15. [Link]
[Link]
16. [Link]
file/
17. [Link]
[Link]
18. [Link]
19. [Link]
stique_des_parametres_morphometriques.pdf
20. [Link]