# Chemin vers les données du TP1 : Remplace par le chemin vers ton fichier tp1.gpkg
DATA_PATH = 'tp1.gpkg'

# --- Types de base ---
altitude = 494         # int   : altitude de la place Saint-François en mètres
temperature = 19.5      # float : température en degrés Celsius
ville = "Lausanne"       # str   : nom d'une ville
est_lacustre = True      # bool  : la ville est-elle au bord d'un lac ?

# La fonction type() permet de connaître le type d'une variable
print(type(altitude))
print(type(temperature))
print(type(ville))
print(type(est_lacustre))

# Affichage formaté avec f-strings (Python 3.6+)
print(f"{ville} se trouve à {altitude} m d'altitude.")
print(f"Température : {temperature} °C, ville lacustre : {est_lacustre}")

# Création d'une liste vide
cantons = []

# Création d'une liste non vide
cantons = ["Vaud", "Genève", "Valais", "Fribourg", "Berne"]

# Longueur
print(f"Nombre de cantons : {len(cantons)}")

# Indexation (commence à 0 !)
print(f"Premier canton  : {cantons[0]}")
print(f"Dernier canton  : {cantons[-1]}")

# Tranche (slice) : cantons[début:fin] — fin non incluse
print(f"Deux premiers   : {cantons[0:2]}")
print(f"Trois derniers  : {cantons[-3:]}")

# Modification
cantons.append("Neuchâtel")    # ajoute à la fin
cantons[1] = "GE"              # modifie un élément
print(cantons)

# Test d'appartenance
print("Vaud" in cantons)       # True
print("Zurich" in cantons)     # False

# Tri de la liste, avec modification de la liste originale
cantons.sort(reverse = False)    # False/True -> ordre croissant/décroissant
print(f"Liste triée avec .sort(): {cantons}")

# Tri sans modifier la liste originale
cantons_tries = sorted(cantons, reverse = False)  # False/True -> ordre croissant/décroissant
print(f"Liste triée avec sorted() : {cantons_tries}")

# Un dictionnaire représentant une entité géographique (commune)
lausanne = {
    "nom": "Lausanne",
    "canton": "Vaud",
    "population": 139408,
    "superficie_km2": 41.37,
    "chef_lieu": True,
    "altitude_m": 455
}

# Accès à une valeur par sa clé
print(lausanne["nom"])
print(lausanne["population"])

# Modification et ajout de clés
lausanne["altitude_m"] = 496            # mise à jour
lausanne["crs"] = "EPSG:2056"          # nouvelle clé
print(lausanne)

# Méthodes utiles
print(lausanne.keys())                  # toutes les clés
print(lausanne.values())                # toutes les valeurs

# Test d'existence d'une clé
if "population" in lausanne:
    print(f"Population : {lausanne['population']}")

# Boucle for sur une liste
pays_romands = ["Suisse", "France", "Belgique", "Luxembourg"]
for pays in pays_romands:
    print(f"  - {pays}")

# Boucle for avec range()
print("\nComptage :")
for i in range(5):              # 0, 1, 2, 3, 4
    print(f"  i = {i}")

# Boucle for avec enumerate() — fournit index ET valeur
cantons = ["VD", "GE", "VS", "FR"]
print("\nIndex + valeur :")
for i, canton in enumerate(cantons):
    print(f"  [{i}] {canton}")

# Boucle while
compteur = 0
while compteur < 3:
    print(f"Itération {compteur}")
    compteur += 1

# Compréhension de liste (list comprehension) — très idiomatique en Python
altitudes_m = [4478, 4634, 3970, 4165]
altitudes_ft = [round(a * 3.28084) for a in altitudes_m]
print("\nAltitudes en pieds :", altitudes_ft)

# Avec condition
hauts_sommets = [a for a in altitudes_m if a > 4200]
print("Sommets > 4200 m :", hauts_sommets)

villes = {
    "Zurich": {"population": 437000, "canton": "Zurich"},
    "Genève": {"population": 209000, "canton": "Genève"},
    "Aarau": {"population": 23000, "canton": "Argovie"},
    "Lausanne": {"population": 145000, "canton": "Vaud"},
    "Berne": {"population": 138000, "canton": "Berne"}
}

for ville, informations in villes.items():

    population = informations["population"]

    if population >= 200000:
        categorie = "Population supérieure à 200'000 habitants"

    elif population >= 100000:
        categorie = "Population entre 100'000 et 200'000 habitants"

    else:
        categorie = "Population inférieure à 100'000 habitants"

    print(ville, ":", categorie)

# Définition d'une fonction simple
import math

def surface_cercle(rayon_m):
    """Calcule la superficie d'un cercle en km²."""
    surface_m2 = math.pi * rayon_m ** 2
    return surface_m2 / 1_000_000       # conversion m² → km²

# Appel
rayon = 5000                           # 5 km
s = surface_cercle(rayon)
print(f"Surface d'un cercle de rayon {rayon} m : {s:.4f} km²")


# Fonction avec plusieurs paramètres et valeur par défaut
def densite_population(population, superficie_km2, unite="hab/km²"):
    """Retourne la densité de population."""
    densite = population / superficie_km2
    return f"{densite:.1f} {unite}"

print(densite_population(139408, 41.37))
print(densite_population(521000, 87.88, unite="personnes/km²"))

# --- Exemple de classe ---

class Commune:
    """Représente une commune avec quelques informations de base."""
    
    # methode d'initialisation (constructeur), appelée lors de la création d'un objet
    def __init__(self, nom, canton, population, superficie_km2):
        self.nom = nom
        self.canton = canton
        self.population = population
        self.superficie_km2 = superficie_km2

    # méthode pour calculer la densité de population
    def densite(self):
        """Calcule la densité de population."""
        return self.population / self.superficie_km2

    # méthode pour vérifier si la commune est une grande ville
    def est_grande_ville(self, seuil=100000):
        """Indique si la commune dépasse un certain seuil de population."""
        return self.population > seuil

    # méthode pour obtenir une description de la commune
    def description(self):
        """Retourne une phrase descriptive."""
        return (
            f"{self.nom} ({self.canton}) : {self.population} habitants, "
            f"{self.superficie_km2} km², densité = {self.densite():.1f} hab/km²"
        )


# Création d'objets à partir de la classe
ville1 = Commune("Lausanne", "Vaud", 139408, 41.37)
ville2 = Commune("Nyon", "Vaud", 22900, 6.79)

# Utilisation des objets
print(ville1.description())
print(ville2.description())

print(f"{ville1.nom} est une grande ville ? {ville1.est_grande_ville()}")
print(f"{ville2.nom} est une grande ville ? {ville2.est_grande_ville()}")

import numpy as np

# --- Création de tableaux ---
a = np.array([1, 2, 3, 4, 5])          # à partir d'une liste Python
b = np.arange(0, 100, 10)              # de 0 à 90, pas de 10
c = np.linspace(0, 1, 6)              # 6 valeurs régulièrement espacées entre 0 et 1
d = np.zeros(4)                        # tableau de zéros
e = np.ones((2, 3))                    # tableau 2D rempli de 1

print("a =", a)
print("b =", b)
print("c =", c)
print("d (zéros) =", d)
print("e (2×3 de 1) =\n", e)

# --- Opérations vectorisées (s'appliquent à chaque élément) ---
coords_deg = np.array([6.63, 6.85, 7.05, 7.25])    # longitudes en degrés

# Conversion degrés → radians, sans boucle
coords_rad = np.radians(coords_deg)
print("Degrés  :", coords_deg)
print("Radians :", np.round(coords_rad, 4))

# Opérations mathématiques
print("× 2 :", coords_deg * 2)
print("+ 1 :", coords_deg + 1)
print("²   :", coords_deg ** 2)

# --- Indexation et slicing ---
elev = np.array([375, 455, 520, 612, 728, 890, 1105, 1342])

print("Premier élément  :", elev[0])
print("Dernier élément  :", elev[-1])
print("Éléments 2 à 5   :", elev[2:5])       # indices 2, 3, 4
print("Un sur deux      :", elev[::2])

# Indexation booléenne (masque) — très puissant
masque = elev > 700
print("Éléments > 700 m :", elev[masque])
print("Nombre d'éléments > 700 m :", masque.sum())

# --- Statistiques descriptives ---
precipitations_mm = np.array([54, 62, 71, 68, 82, 93, 78, 74, 65, 59, 61, 55])
mois = ['Jan','Fév','Mar','Avr','Mai','Jun','Jul','Aoû','Sep','Oct','Nov','Déc']

print(f"Total annuel  : {precipitations_mm.sum()} mm")
print(f"Moyenne mensuelle : {precipitations_mm.mean():.1f} mm")
print(f"Écart-type    : {precipitations_mm.std():.1f} mm")
print(f"Min (mois)    : {precipitations_mm.min()} mm — {mois[precipitations_mm.argmin()]}")
print(f"Max (mois)    : {precipitations_mm.max()} mm — {mois[precipitations_mm.argmax()]}")

import matplotlib.pyplot as plt
import numpy as np

# --- Graphique linéaire ---
mois = ['Jan','Fév','Mar','Avr','Mai','Jun','Jul','Aoû','Sep','Oct','Nov','Déc']
t_lausanne = [0.7, 1.8, 5.5, 9.3, 13.6, 17.1, 19.4, 18.9, 14.8, 10.2, 4.9, 1.5]

fig, ax = plt.subplots(figsize=(9, 4))
ax.plot(mois, t_lausanne, marker='o', color='tomato', linewidth=2, label='Lausanne')
ax.axhline(0, color='steelblue', linestyle='--', linewidth=1, alpha=0.7, label='0 °C')
ax.fill_between(mois, 0, t_lausanne, alpha=0.15, color='tomato')
ax.set_title('Températures moyennes mensuelles — Lausanne', fontsize=13)
ax.set_xlabel('Mois')
ax.set_ylabel('Température (°C)')
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# --- Histogramme + nuage de points côte à côte ---
np.random.seed(42)
n_points = 200
lon = np.random.normal(6.63, 0.15, n_points)    # longitudes simulées (région Lausanne)
lat = np.random.normal(46.52, 0.08, n_points)   # latitudes simulées

fig, axes = plt.subplots(1, 2, figsize=(11, 4))

# Histogramme
axes[0].hist(lon, bins=20, color='steelblue', edgecolor='white', alpha=0.8)
axes[0].set_title('Distribution des longitudes')
axes[0].set_xlabel('Longitude (°)')
axes[0].set_ylabel('Fréquence')

# Nuage de points
sc = axes[1].scatter(lon, lat, c=lat, cmap='viridis', s=20, alpha=0.7)
axes[1].set_title('Nuage de points (longitude × latitude)')
axes[1].set_xlabel('Longitude (°)')
axes[1].set_ylabel('Latitude (°)')
plt.colorbar(sc, ax=axes[1], label='Latitude (°)')

plt.tight_layout()
plt.show()

import geopandas as gpd
import matplotlib.pyplot as plt

# Chargement de la couche Cantons depuis le même GeoPackage utilisé dans QGIS au TP1
# Même fichier, même couche — mais maintenant accessible en Python !
cantons = gpd.read_file(DATA_PATH, layer='Cantons')

# Exploration des premières lignes
print("Colonnes disponibles :")
print(cantons.columns.tolist())
print(f"\nType      : {type(cantons)}")
print(f"Dimensions : {cantons.shape[0]} lignes × {cantons.shape[1]} colonnes")
print()
cantons.head()

# --- Explorer les attributs (≡ ouvrir la table attributaire dans QGIS) ---
print("Types de données :")
print(cantons.dtypes)
print()
# La colonne 'geometry' contient les géométries vectorielles
print("Type de géométrie :", cantons.geometry.geom_type.value_counts())

# --- CRS (Coordinate Reference System) ---
# Dans QGIS, tu as vu que les couches de tp1.gpkg utilisent le système suisse MN03
# Ce même code EPSG est accessible directement en Python
print("CRS du jeu de données :", cantons.crs)
print("Code EPSG             :", cantons.crs.to_epsg())
print("Unité de mesure       :", cantons.crs.axis_info[0].unit_name)
print("→ Les coordonnées sont en mètres (système suisse MN03 / CH1903)")

# --- Affichage simple avec .plot() ---
# Équivalent du rendu cartographique dans QGIS
fig, ax = plt.subplots(figsize=(10, 8))
cantons.plot(ax=ax, color='#d4e6b5', edgecolor='#555', linewidth=0.8)
ax.set_title('Cantons suisses — tp1.gpkg (EPSG:21781)', fontsize=13)
ax.set_xlabel('Est (m)')
ax.set_ylabel('Nord (m)')
plt.tight_layout()
plt.show()

# --- Affichage multi-couches (comme superposer des couches dans QGIS) ---
# Chargement de plusieurs couches du même GeoPackage
towns = gpd.read_file(DATA_PATH, layer='Towns')
lakes = gpd.read_file(DATA_PATH, layer='Lakes')

fig, ax = plt.subplots(figsize=(10, 8))

# On superpose les couches dans le même ordre que le panneau "Couches" de QGIS :
# cantons en fond, puis lacs, puis villes au-dessus
cantons.plot(ax=ax, color='#f5f5dc', edgecolor='#555', linewidth=0.8, label='Cantons')
lakes.plot(ax=ax, color='#a8d5e2', edgecolor='#3399cc', linewidth=0.5, label='Lacs')
towns.plot(ax=ax, color='#e53935', markersize=6, label='Villes')

ax.set_title("Suisse — cantons, lacs et villes (tp1.gpkg)", fontsize=13)
ax.legend(loc='lower right')
ax.set_xlabel('Est (m)')
ax.set_ylabel('Nord (m)')
plt.tight_layout()
plt.show()

# Finalement, pour le workflow complet :
# charger → explorer → filtrer → visualiser
# (les mêmes étapes que dans QGIS au TP1, mais en Python)

import geopandas as gpd
import matplotlib.pyplot as plt

# 1. Chargement (= ouvrir les couches depuis tp1.gpkg dans QGIS)
towns   = gpd.read_file(DATA_PATH, layer='Towns')
cantons = gpd.read_file(DATA_PATH, layer='Cantons')
print(f"Villes chargées : {towns.shape[0]} entités, CRS = {towns.crs.to_epsg()}")

# 2. Exploration (= consulter la table attributaire dans QGIS)
print("\nAperçu des attributs (couche Towns) :")
print(towns[['ID1', 'Population', 'Rank']].head())

# 3. Filtrage (= sélection par attribut dans QGIS)
grandes_villes = towns[towns['Population'] > 50000]
print(f"\nVilles de plus de 50 000 habitants : {len(grandes_villes)}")
print(grandes_villes[['ID1', 'Population']].sort_values('Population', ascending=False).to_string(index=False))

# 4. Visualisation (= rendu cartographique dans QGIS)
fig, ax = plt.subplots(figsize=(10, 8))
cantons.plot(ax=ax, color='#f5f5dc', edgecolor='#555', linewidth=0.8)
towns.plot(ax=ax, color='#aaa', markersize=4, label='Toutes les villes')
grandes_villes.plot(ax=ax, color='#e53935', markersize=40,
                    marker='*', label='>50 000 hab.')

# Étiquettes des grandes villes (≡ onglet Étiquettes dans QGIS)
for _, row in grandes_villes.iterrows():
    ax.annotate(row['ID1'], xy=(row.geometry.x, row.geometry.y),
                xytext=(5, 5), textcoords='offset points', fontsize=8)

ax.set_title('Villes suisses par population', fontsize=13)
ax.legend(loc='lower right')
ax.set_xlabel('Est (m)')
ax.set_ylabel('Nord (m)')
plt.tight_layout()
plt.show()

import os

os.makedirs('sortie', exist_ok=True)

# 1. Résultats du traitement Python → GeoPackage (on conserve le CRS suisse MN03)
#    Un seul fichier .gpkg peut contenir plusieurs couches, comme un projet QGIS.
grandes_villes.to_file('sortie/resultats.gpkg', layer='grandes_villes', driver='GPKG')
cantons.to_file('sortie/resultats.gpkg', layer='cantons', driver='GPKG')
print("GeoPackage sauvegardé : sortie/resultats.gpkg (2 couches)")

# 2. Export web → GeoJSON, reprojeté en WGS84 (EPSG:4326)
#    Le GeoJSON attend par convention des coordonnées en degrés.
cantons_wgs84 = cantons.to_crs(epsg=4326)
cantons_wgs84.to_file('sortie/cantons.geojson', driver='GeoJSON')
print("GeoJSON sauvegardé   : sortie/cantons.geojson (reprojeté en WGS84)")

print(f"\nCRS d'origine : EPSG:{cantons.crs.to_epsg()} (MN03, mètres)")
print(f"CRS GeoJSON   : EPSG:{cantons_wgs84.crs.to_epsg()} (WGS84, degrés)")

# --- Vérification : relire les fichiers exportés ---
villes_relu  = gpd.read_file('sortie/resultats.gpkg', layer='grandes_villes')
cantons_relu = gpd.read_file('sortie/cantons.geojson')

print(f"grandes_villes (gpkg) : {villes_relu.shape[0]} entités  CRS = EPSG:{villes_relu.crs.to_epsg()}")
print(f"cantons.geojson       : {cantons_relu.shape[0]} entités  CRS = EPSG:{cantons_relu.crs.to_epsg()}")
print("\n→ Ces fichiers peuvent maintenant être ouverts dans QGIS pour la mise en page finale de la carte.")