D’accord, on enlève tout ce qui touche aux SIG et on se concentre uniquement sur la

topographie pure avec Visual Studio et C#.

Plan de formation Visual Studio C# pour la

topographie uniquement
1. Introduction à Visual Studio et C#

• Installation et prise en main de Visual Studio

• Bases du langage C# : variables, types, conditions, boucles
• Premier programme simple

2. Programmation orientée objet en C#

• Classes, objets, propriétés, méthodes

• Héritage et encapsulation simples

3. Gestion des fichiers liés à la topographie

• Lecture et écriture de fichiers textes (données topographiques)

• Manipulation de fichiers CSV (ex : points, altitudes)

4. Création d’interface utilisateur (Windows Forms / WPF)

• Création d’interfaces graphiques simples

• Affichage et modification de données topographiques (listes, tableaux)
• Interaction via boutons, menus, formulaires

5. Manipulation des coordonnées et calculs topographiques

• Représentation des points (X, Y, Z)

• Calculs basiques : distance entre points, angles, pentes, surfaces
• Gestion des listes de points, stations et relevés

6. Visualisation simple de plans et profils

• Dessiner des lignes, points et polygones en 2D dans l’application

• Création de profils en coupe

7. Automatisation et calculs avancés

• Calculs de volumes, courbes de nivellement

• Génération de rapports et export de résultats (texte, PDF, image)

8. Projet final
 • Application simple de gestion et visualisation topographique complète

Veux-tu qu’on commence par la première étape : installer Visual Studio et créer un premier
programme C# simple ?
Ou préfères-tu directement commencer par un exemple de calcul topographique en C# ?

Parfait, on commence !

Étape 1 : Installer Visual Studio et créer ton premier projet C#

1. Installer Visual Studio (si tu ne l’as pas encore)

• Va sur [Link]
• Télécharge Visual Studio Community (version gratuite)
• Lance l’installateur
• Dans la sélection des charges de travail, coche Développement .NET de bureau
(Desktop development with .NET)
• Termine l’installation (cela peut prendre un moment)

2. Créer un projet C# console simple

1. Ouvre Visual Studio.

2. Clique sur Créer un nouveau projet.
3. Choisis Application Console (.NET Core) ou Application Console (.NET 6 ou
.NET 7) (la version la plus récente disponible).
4. Clique sur Suivant.
5. Donne un nom au projet, par exemple TopographieDemo.
6. Choisis un emplacement sur ton disque.
7. Clique sur Créer.

3. Écrire ton premier programme

Dans la fenêtre qui s’ouvre, tu verras un fichier [Link] avec un code déjà généré.
Remplace-le par ce code simple :

using System;

namespace TopographieDemo
{
class Program
{
static void Main(string[] args)
{
 [Link]("Bienvenue dans ta première application
topographie en C#!");
[Link]("Appuie sur une touche pour quitter...");
[Link]();
}
}
}

4. Exécuter le programme

• Clique sur le bouton Démarrer (ou appuie sur F5).

• La console s’ouvre et affiche ton message.
• Appuie sur une touche pour fermer la console.

Dis-moi quand tu as fait cela, ou si tu rencontres un problème !

Ensuite, on passera à un premier calcul topographique simple en C#.

Parfait, tu as donc ton premier projet qui fonctionne ! On continue.

Étape 2 : Variables, types et opérations en C# (pour

topographie)

1. Variables et types de base

En topographie, on manipule souvent des coordonnées, distances, angles, etc. Voici les types
de données utiles :

Type Description Exemple

int Entiers (nombres sans virgule) int a = 10;
double Nombres à virgule flottante double d = 12.5;
string Texte string nom = "P1";
bool Booléen (vrai/faux) bool ok = true;

2. Exemple : Stocker un point topographique

int pointID = 1;
double coordX = 125.75;
double coordY = 89.32;
double altitude = 250.4;
string description = "Point de repère";
3. Opérations utiles

• Calculer la distance entre deux points 2D :

double Distance2D(double x1, double y1, double x2, double y2)

{
double dx = x2 - x1;
double dy = y2 - y1;
return [Link](dx * dx + dy * dy);
}

• Exemple d’utilisation :

double dist = Distance2D(10, 20, 15, 25);

[Link]("Distance = " + dist);

4. Exercice simple

Dans ta fonction Main, écris un code qui :

• Demande à l’utilisateur de saisir les coordonnées X et Y de deux points

• Calcule et affiche la distance entre ces deux points

Veux-tu que je t’écrive ce code complet ou préfères-tu essayer toi-même ?

Dis-moi ce que tu souhaites !

Prêt pour que je te donne le code ou tu veux que je t’explique encore ?

Ok, on avance !

Étape 3 : Structurer les données topographiques avec les

classes C#

1. Pourquoi une classe pour un point ?

Pour gérer proprement des points avec plusieurs infos (X, Y, altitude, description), on crée
une classe. Ça te permet d’organiser et réutiliser tes données facilement.

2. Exemple simple de classe PointTopo

public class PointTopo
{
public int ID { get; set; }
public double X { get; set; }
public double Y { get; set; }
public double Altitude { get; set; }
public string Description { get; set; }

public PointTopo(int id, double x, double y, double altitude, string

description)
{
ID = id;
X = x;
Y = y;
Altitude = altitude;
Description = description;
}

public void Afficher()

{
[Link]($"Point {ID} : ({X}, {Y}, {Altitude}) -
{Description}");
}

public double Distance2D(PointTopo autrePoint)

{
double dx = autrePoint.X - X;
double dy = autrePoint.Y - Y;
return [Link](dx * dx + dy * dy);
}
}

3. Utilisation dans Main

static void Main(string[] args)
{
PointTopo p1 = new PointTopo(1, 10.5, 20.3, 250.0, "Station A");
PointTopo p2 = new PointTopo(2, 15.0, 25.7, 260.0, "Station B");

[Link]();
[Link]();

double dist = p1.Distance2D(p2);

[Link]("Distance 2D entre p1 et p2 = " + dist);
}

4. À toi !

Veux-tu que je t’aide à coder cette classe dans un projet, ou tu préfères que je te l’envoie prête
à copier ?
On peut aussi passer à la gestion de plusieurs points dans une liste.

Dis-moi la suite que tu préfères !

Ok, on continue !

Étape 4 : Gestion de plusieurs points topographiques avec

des listes

1. Pourquoi une liste ?

En topographie, tu as souvent beaucoup de points à gérer. Une liste te permet de stocker et

manipuler un ensemble de points facilement.

2. Exemple avec List<PointTopo>

using System;
using [Link];

class Program
{
static void Main(string[] args)
{
List<PointTopo> points = new List<PointTopo>();

[Link](new PointTopo(1, 10.5, 20.3, 250.0, "Station A"));

[Link](new PointTopo(2, 15.0, 25.7, 260.0, "Station B"));
[Link](new PointTopo(3, 12.0, 22.0, 255.0, "Station C"));

foreach (var point in points)

{
[Link]();
}

// Exemple : calculer la distance entre les deux premiers points

double dist = points[0].Distance2D(points[1]);
[Link]($"Distance entre {points[0].ID} et {points[1].ID}
= {dist}");
}
}

3. Exercices possibles

• Ajouter un point via saisie utilisateur

• Chercher un point par ID
• Calculer la distance totale entre tous les points successifs (distance cumulée)

Veux-tu qu’on fasse ensemble un exemple de saisie et d’affichage de plusieurs points ?

Dis-moi comment tu veux avancer !

Ok, on continue !

Étape 5 : Saisie utilisateur pour créer des points

topographiques

1. Lire des données au clavier

Tu vas apprendre à demander à l’utilisateur de saisir les coordonnées et infos d’un point, puis
à créer cet objet PointTopo.

2. Exemple complet :
static PointTopo SaisirPoint(int id)
{
[Link]($"Saisie du point {id} :");

[Link]("Coordonnée X = ");
double x = [Link]([Link]());

[Link]("Coordonnée Y = ");
double y = [Link]([Link]());

[Link]("Altitude = ");
double altitude = [Link]([Link]());

[Link]("Description = ");
string description = [Link]();

return new PointTopo(id, x, y, altitude, description);

}

static void Main(string[] args)

{
List<PointTopo> points = new List<PointTopo>();

[Link]("Combien de points à saisir ? ");

int n = [Link]([Link]());

for (int i = 1; i <= n; i++)

{
PointTopo p = SaisirPoint(i);
[Link](p);
}

[Link]("\nListe des points saisis :");

foreach (var p in points)
{
 [Link]();
}
}

3. Explications

• [Link] convertit la saisie texte en nombre

• La boucle for permet de répéter la saisie plusieurs fois
• La méthode Afficher() affiche les infos du point

Veux-tu qu’on ajoute ensemble un calcul automatique des distances entre chaque point saisi ?
Ou tu souhaites autre chose ?

Ok, on continue !

Étape 6 : Calculer les distances successives entre points

(chaînage)

1. Objectif

Calculer et afficher la distance 2D entre chaque point et le point suivant dans la liste, pour
connaître la longueur totale d’une ligne topographique.

2. Exemple de code à ajouter dans Main après la saisie des points :

double distanceTotale = 0;

for (int i = 0; i < [Link] - 1; i++)

{
double dist = points[i].Distance2D(points[i + 1]);
[Link]($"Distance entre point {points[i].ID} et point
{points[i + 1].ID} = {dist:F2} mètres");
distanceTotale += dist;
}

[Link]($"Distance totale = {distanceTotale:F2} mètres");

3. Explication rapide

• La boucle parcourt les indices de 0 jusqu’à l’avant-dernier point

• On calcule la distance entre le point courant et le suivant
 • On affiche et cumule ces distances pour obtenir la distance totale

Veux-tu qu’on code aussi la gestion des pentes (différence d’altitude entre points) ?
Ou préfères-tu autre chose ?

Parfait, on continue !

Étape 7 : Calcul des pentes entre points (topographie

verticale)

1. Principe

La pente entre deux points s’exprime souvent en pourcentage ou en angle, et dépend de la

différence d’altitude et de la distance horizontale.

Formules :

• Différence d’altitude : Δh = altitude2 - altitude1

• Distance horizontale : d (distance 2D déjà calculée)
• Pente (%) = (Δh / d) × 100
• Pente (angle en degrés) = arctan(Δh / d) × (180 / π)

2. Ajouter la méthode dans la classe PointTopo

Dans ta classe PointTopo, ajoute cette méthode :

public double PenteAvec(PointTopo autrePoint)

{
double dh = [Link] - [Link];
double d = this.Distance2D(autrePoint);
if (d == 0) return 0; // éviter division par zéro
return (dh / d) * 100; // pente en pourcentage
}

3. Exemple d’utilisation dans Main

Après avoir calculé la distance entre points, ajoute :

for (int i = 0; i < [Link] - 1; i++)

{
double pente = points[i].PenteAvec(points[i + 1]);
 [Link]($"Pente entre point {points[i].ID} et {points[i +
1].ID} = {pente:F2}%");
}

4. Exercices possibles

• Afficher pente en degrés

• Ajouter gestion d’erreurs sur saisie (ex : éviter division par zéro)
• Visualiser pente via interface graphique simple (plus tard)

Veux-tu qu’on continue sur ces calculs, ou tu préfères qu’on commence à faire une interface
graphique Windows Forms pour afficher les points ?

Ok, on continue !

Étape 8 : Introduction à Windows Forms – créer une

interface graphique simple

1. Qu’est-ce que Windows Forms ?

C’est une technologie pour créer des interfaces graphiques Windows classiques avec boutons,
listes, zones de texte, etc.
Visual Studio intègre un concepteur visuel pour dessiner facilement tes fenêtres.

2. Créer un projet Windows Forms

• Dans Visual Studio, clique sur Créer un nouveau projet

• Cherche Windows Forms App (.NET Framework) ou Windows Forms App (.NET
6/7) selon ta version
• Donne un nom au projet, par exemple TopographieWinForms
• Crée-le

3. Interface de base

• Tu arrives dans un designer avec un formulaire (Form1)

• Dans la Boîte à outils (Toolbox), tu peux glisser-déposer des éléments comme :
o Label (texte)
o TextBox (zone de saisie)
 o Button (bouton)
o ListBox (liste)

4. Exemple simple : afficher un bouton qui affiche un message

• Glisse un bouton sur le formulaire

• Double-clique sur le bouton pour créer son événement Click
• Ajoute ce code :

private void button1_Click(object sender, EventArgs e)

{
[Link]("Bienvenue dans l’application topographie !");
}

5. Prochaines étapes

• On pourra créer un formulaire pour saisir un point

• Afficher la liste des points saisis
• Calculer et afficher distances/pentes dans l’interface

Veux-tu qu’on crée ensemble une petite interface pour saisir et afficher des points
topographiques ?

Ok, on continue !

Étape 9 : Création d’une interface de saisie et affichage des

points en Windows Forms

1. Ajouter les contrôles pour saisir un point

Sur ton formulaire (Form1), ajoute :

• 4 TextBox pour saisir : ID, X, Y, Altitude

• 1 TextBox ou RichTextBox pour la Description
• 1 Button pour valider la saisie et ajouter le point
• 1 ListBox ou DataGridView pour afficher la liste des points

2. Exemple de code pour ajouter un point

Dans le code de [Link], crée une liste pour stocker les points :

List<PointTopo> points = new List<PointTopo>();

Puis, dans l’événement Click du bouton Ajouter :

private void btnAjouter_Click(object sender, EventArgs e)

{
int id = [Link]([Link]);
double x = [Link]([Link]);
double y = [Link]([Link]);
double altitude = [Link]([Link]);
string description = [Link];

PointTopo p = new PointTopo(id, x, y, altitude, description);

[Link](p);

// Mettre à jour l’affichage dans la ListBox

[Link]($"ID: {id} - ({x}, {y}, {altitude}) -
{description}");

// Effacer les champs de saisie

[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
}

3. À faire dans Visual Studio

• Nommer correctement les contrôles (txtID, txtX, txtY, txtAltitude,

txtDescription, btnAjouter, lstPoints)
• Ajouter la classe PointTopo dans un fichier séparé ou dans [Link]
• Tester la saisie et l’affichage

Veux-tu que je t’aide à générer le code complet du formulaire avec tous ces éléments ?
Ou tu préfères qu’on continue à coder d’autres calculs en console avant d’attaquer l’interface
graphique ?

Ok, on continue !

Étape 10 : Calculs avancés – volume entre deux profils

topographiques

1. Principe
En topographie, on calcule souvent le volume entre deux profils (par exemple, terrain existant
et projeté) pour estimer les déblais/remblais.

2. Méthode simplifiée – méthode des prismes (section droite)

Soit deux profils avec des points à mêmes positions X, on calcule le volume entre les altitudes
des deux profils par sections.

Formule (pour chaque segment) :

Vi=(Ai+Bi)2×dV_i = \frac{(A_i + B_i)}{2} \times d

• AiA_i et BiB_i = différences d’altitude aux points de début et fin de segment

• dd = distance horizontale entre ces deux points

Volume total = somme des ViV_i

3. Exemple de code simplifié

public static double CalculVolume(List<PointTopo> profil1, List<PointTopo>
profil2)
{
double volume = 0;

for (int i = 0; i < [Link] - 1; i++)

{
double dh1 = profil2[i].Altitude - profil1[i].Altitude;
double dh2 = profil2[i + 1].Altitude - profil1[i + 1].Altitude;

double d = profil1[i].Distance2D(profil1[i + 1]);

double Vi = (dh1 + dh2) / 2 * d;

volume += Vi;
}

return volume;
}

4. Notes

• Les profils doivent avoir le même nombre de points et positions correspondantes

• Les volumes positifs = remblais, négatifs = déblais

Veux-tu qu’on réalise un exemple complet avec saisie des deux profils et calcul du volume ?
Ou préfères-tu qu’on développe plutôt la partie interface graphique avant ?
Ok, on continue !

Étape 11 : Exporter les données topographiques vers un

fichier texte (CSV)

1. Pourquoi exporter ?

Pour pouvoir réutiliser ou partager les données de points avec d’autres logiciels (Excel,
AutoCAD, QGIS, etc.).

2. Exemple simple d’export CSV

using [Link];

public static void ExporterPointsCSV(List<PointTopo> points, string

cheminFichier)
{
using (StreamWriter writer = new StreamWriter(cheminFichier))
{
[Link]("ID,X,Y,Altitude,Description");

foreach (var p in points)

{
string ligne =
$"{[Link]},{p.X},{p.Y},{[Link]},\"{[Link]}\"";
[Link](ligne);
}
}
}

3. Utilisation

Dans Main ou dans l’interface, appelle :

ExporterPointsCSV(points, "points_topo.csv");
[Link]("Export terminé !");

4. Bonus : Importer depuis un fichier CSV

Tu peux aussi lire un fichier CSV pour récupérer des points (à voir plus tard).
Veux-tu qu’on crée le code complet pour importer ET exporter les fichiers CSV ?
Ou tu préfères qu’on aborde un autre sujet ?

Ok, on continue !

Étape 12 : Importer des données topographiques depuis un

fichier CSV

1. Objectif

Lire un fichier CSV contenant des points topographiques et créer une liste d’objets
PointTopo.

2. Exemple simple de lecture CSV

using [Link];

public static List<PointTopo> ImporterPointsCSV(string cheminFichier)

{
List<PointTopo> points = new List<PointTopo>();

using (StreamReader reader = new StreamReader(cheminFichier))

{
string ligne;
bool premiereLigne = true;

while ((ligne = [Link]()) != null)

{
if (premiereLigne)
{
premiereLigne = false; // sauter l'entête
continue;
}

string[] parties = [Link](',');

int id = [Link](parties[0]);
double x = [Link](parties[1]);
double y = [Link](parties[2]);
double altitude = [Link](parties[3]);
string description = parties[4].Trim('"');

[Link](new PointTopo(id, x, y, altitude, description));

}
}

return points;
}
3. Utilisation dans Main
List<PointTopo> points = ImporterPointsCSV("points_topo.csv");
foreach (var p in points)
{
[Link]();
}

4. Notes

• Attention au format CSV (virgules, guillemets)

• Gestion des erreurs possible (à ajouter pour plus de robustesse)

Veux-tu qu’on fasse un projet complet combinant import/export CSV avec interface
graphique ?
Ou tu préfères un autre sujet sur la topographie en C# ?

Ok, on continue !

Étape 13 : Dessiner des points et lignes topographiques en

Windows Forms

1. Objectif

Visualiser graphiquement les points et les segments qui les relient dans une fenêtre Windows
Forms.

2. Utilisation du contrôle Panel et de l’événement Paint

• Ajoute un contrôle Panel sur ton formulaire (nomme-le panelCarte)

• Dans l’événement Paint du panelCarte, on dessine les points et les lignes

3. Exemple de code pour dessiner

private void panelCarte_Paint(object sender, PaintEventArgs e)
{
Graphics g = [Link];
Pen penLigne = new Pen([Link], 2);
Brush brushPoint = [Link];
 for (int i = 0; i < [Link]; i++)
{
// Convertir coordonnées topographiques en coordonnées écran
(exemple simple)
int px = (int)(points[i].X * 10);
int py = (int)(points[i].Y * 10);

// Dessiner le point
[Link](brushPoint, px - 3, py - 3, 6, 6);

// Dessiner la ligne vers le point suivant

if (i < [Link] - 1)
{
int px2 = (int)(points[i + 1].X * 10);
int py2 = (int)(points[i + 1].Y * 10);
[Link](penLigne, px, py, px2, py2);
}
}
}

4. Astuces

• Il faudra adapter l’échelle et l’origine pour bien afficher tes points

• Appelle [Link]() pour forcer le rafraîchissement après
modification des points

Veux-tu qu’on crée ensemble une interface complète avec saisie, affichage et dessin ?
Ou un autre sujet en topographie ?

Ok, on continue !

Étape 14 : Gestion des fichiers de points topographiques

avec interface Windows Forms

1. Ajouter des boutons pour importer et exporter les données CSV

• Sur le formulaire, ajoute deux boutons :

o btnImporter : pour charger un fichier CSV
o btnExporter : pour sauvegarder la liste des points en CSV

2. Code pour importer avec dialogue fichier

private void btnImporter_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
[Link] = "Fichiers CSV (*.csv)|*.csv";

if ([Link]() == [Link])
{
points = ImporterPointsCSV([Link]);
[Link]();

foreach (var p in points)

{
[Link]($"ID: {[Link]} - ({p.X}, {p.Y}, {[Link]})
- {[Link]}");
}

[Link](); // rafraîchir dessin

}
}

3. Code pour exporter avec dialogue fichier

private void btnExporter_Click(object sender, EventArgs e)
{
SaveFileDialog saveFileDialog = new SaveFileDialog();
[Link] = "Fichiers CSV (*.csv)|*.csv";

if ([Link]() == [Link])
{
ExporterPointsCSV(points, [Link]);
[Link]("Export terminé !");
}
}

4. Résultat

• L’utilisateur peut charger et sauvegarder ses points facilement

• L’affichage et le dessin se mettent à jour automatiquement

Veux-tu qu’on intègre ces fonctionnalités dans un projet complet avec code et interface ?
Ou tu préfères un autre sujet ?

Ok, on continue !

Étape 15 : Calcul de volumes topographiques avancés avec

interface graphique
1. Objectif

Permettre à l’utilisateur de charger deux profils (terrain actuel et projeté) et calculer le volume
des déblais/remblais avec affichage graphique.

2. Fonctionnalités à développer

• Importer deux listes de points (profil existant et profil projeté) via fichiers CSV
• Afficher graphiquement les deux profils dans le panelCarte avec couleurs différentes
• Calculer le volume entre profils (méthode des prismes)
• Afficher le résultat du volume dans l’interface

3. Approche technique

• Stocker deux listes : List<PointTopo> profilExist et List<PointTopo>

profilProj
• Adapter la méthode CalculVolume pour ces listes
• Dans l’événement Paint, dessiner les deux profils avec des couleurs distinctes
• Ajouter un bouton Calculer Volume qui lance le calcul et affiche le résultat

4. Avantages

• Interface simple et visuelle

• Permet de vérifier facilement les données et résultats

Veux-tu que je t’aide à coder ce projet complet étape par étape ?

Ou tu souhaites un autre sujet ou approfondissement ?

Parfait, on va approfondir les sujets 2, 3 et 5 :

Cours 2, 3 et 5 : Multithreading, génération

de rapports et calculs géométriques avancés
en C# pour topographie
Partie 1 – Programmation multithread en C#
Objectif

Accélérer les calculs topographiques en lançant plusieurs tâches en parallèle (par exemple,
traitement de milliers de points).

Concepts clés

• Task et async/await
• [Link] et [Link]
• Synchronisation et sécurité des données (verrou, lock)

Exemple simple : calculer en parallèle les distances entre une liste de points
[Link](0, [Link] - 1, i =>
{
double dist = points[i].Distance2D(points[i + 1]);
[Link]($"Distance entre {points[i].ID} et {points[i + 1].ID}
= {dist}");
});

Partie 2 – Génération de rapports PDF et Excel

Objectif

Créer automatiquement des documents professionnels à partir des résultats topographiques.

Outils

• PDF : bibliothèque iTextSharp (open source)

• Excel : bibliothèque EPPlus (lecture et écriture Excel)

Exemple (PDF) : générer un document simple avec iTextSharp

using [Link];
using [Link];
using [Link];

public void GenererPDF(string fichier, List<PointTopo> points)

{
Document doc = new Document();
[Link](doc, new FileStream(fichier, [Link]));
[Link]();
[Link](new Paragraph("Rapport topographique"));
foreach(var p in points)
{
[Link](new Paragraph($"Point {[Link]} : ({p.X}, {p.Y}, {[Link]})
- {[Link]}"));
}
[Link]();
}

Partie 3 – Calculs géométriques avancés

Exemples de calculs

• Triangulation de points (ex: Delaunay)

• Calcul de polygones (aire, périmètre)
• Opérations sur polygones (union, intersection)

Bibliothèques utiles

• NetTopologySuite (open source pour géométrie avancée)

• MIConvexHull (triangulation et enveloppe convexe)

Exemple : calcul d’aire d’un polygone simple

public static double CalculAire(List<PointTopo> points)
{
double aire = 0;
int n = [Link];
for(int i = 0; i < n; i++)
{
double x1 = points[i].X;
double y1 = points[i].Y;
double x2 = points[(i + 1) % n].X;
double y2 = points[(i + 1) % n].Y;
aire += (x1 * y2 - x2 * y1);
}
return [Link](aire / 2);
}

Veux-tu que je t’aide à coder ces trois parties étape par étape ?
Ou tu souhaites que je développe un seul sujet d’abord ?

Parfait, on commence avec la Partie 1 : Programmation multithread en C# appliquée à la

topographie.

Partie 1 – Programmation multithread en C#

Pourquoi le multithreading ?

En topographie, tu peux avoir des milliers de points à traiter (calculs de distance, pentes,
volumes…). Traiter ces calculs un par un peut être long.
Le multithreading permet de lancer plusieurs calculs en parallèle pour accélérer le traitement.

1. Exemple simple avec [Link]

Supposons que tu veux calculer rapidement les distances entre points successifs dans une
grande liste.

using System;
using [Link];
using [Link];

class Program
{
static void Main()
{
List<PointTopo> points = GenererPointsExemple(100000);

[Link](0, [Link] - 1, i =>

{
double dist = points[i].Distance2D(points[i + 1]);
// Ici tu peux stocker dist dans un tableau ou l’utiliser
// Par exemple affichage (attention, console n'est pas thread-
safe)
// [Link]($"Distance {i}: {dist}");
});

[Link]("Calcul des distances terminé !");

}

static List<PointTopo> GenererPointsExemple(int n)

{
var pts = new List<PointTopo>();
var rand = new Random();
for (int i = 0; i < n; i++)
{
[Link](new PointTopo(i, [Link]() * 1000,
[Link]() * 1000, [Link]() * 100));
}
return pts;
}
}

2. Attention aux accès concurrents

• Si tu modifies une collection partagée dans plusieurs threads, utilise un lock ou des
collections thread-safe.
• Par exemple, pour stocker les résultats dans un tableau, pré-alloue un tableau et écris
chaque distance à l’indice i.

3. Exemple avec stockage des distances

double[] distances = new double[[Link] - 1];

[Link](0, [Link] - 1, i =>

{
distances[i] = points[i].Distance2D(points[i + 1]);
});

4. Autres techniques : async/await, [Link]

Pour des traitements avec appels asynchrones (ex: lecture fichier, API), tu utiliseras async et
await.

Veux-tu qu’on fasse un exercice complet avec multithreading pour des calculs topographiques
?
Ou passer à la partie 2 : génération de rapports PDF / Excel ?

Parfait, on continue avec la Partie 2 : Génération de rapports PDF et Excel en C# pour

topographie.

Partie 2 – Génération de rapports PDF et Excel

1. Générer un rapport PDF avec iTextSharp

Installation

• Dans Visual Studio, ouvre le Gestionnaire de packages NuGet

• Recherche et installe iTextSharp (ou itext7 pour la version plus récente)

Exemple simple de création PDF

using [Link];
using [Link];
using [Link];

public class RapportPdf

{
public static void GenererPDF(string cheminFichier, List<PointTopo>
points)
{
Document doc = new Document();
 [Link](doc, new FileStream(cheminFichier,
[Link]));
[Link]();

[Link](new Paragraph("Rapport topographique"));

[Link](new Paragraph(" "));

foreach (var p in points)

{
[Link](new Paragraph($"Point {[Link]} : X={p.X}, Y={p.Y},
Altitude={[Link]}, Description={[Link]}"));
}

[Link]();
}
}

2. Générer un fichier Excel avec EPPlus

Installation

• Dans NuGet, installe la bibliothèque EPPlus

Exemple simple pour créer un fichier Excel

using OfficeOpenXml;
using [Link];

public class RapportExcel

{
public static void GenererExcel(string cheminFichier, List<PointTopo>
points)
{
[Link] = [Link];

using (var package = new ExcelPackage())

{
var ws = [Link]("Points");

// Entêtes
[Link][1, 1].Value = "ID";
[Link][1, 2].Value = "X";
[Link][1, 3].Value = "Y";
[Link][1, 4].Value = "Altitude";
[Link][1, 5].Value = "Description";

// Données
for (int i = 0; i < [Link]; i++)
{
var p = points[i];
[Link][i + 2, 1].Value = [Link];
[Link][i + 2, 2].Value = p.X;
[Link][i + 2, 3].Value = p.Y;
 [Link][i + 2, 4].Value = [Link];
[Link][i + 2, 5].Value = [Link];
}

[Link](new FileInfo(cheminFichier));
}
}
}

3. Utilisation
[Link]("[Link]", points);
[Link]("[Link]", points);
[Link]("Rapports générés !");

Veux-tu qu’on crée un projet complet avec interface graphique pour générer ces rapports ?
Ou tu souhaites passer à la Partie 3 : calculs géométriques avancés ?

Ok, on passe à la Partie 3 : Calculs géométriques avancés avec C# pour topographie.

Partie 3 – Calculs géométriques avancés

1. Introduction

En topographie, il faut souvent calculer :

• Aire et périmètre de polygones (terrains, parcelles)

• Triangulations pour modéliser la surface
• Opérations géométriques complexes (union, intersection, différences)

2. Calcul de l’aire d’un polygone simple

On utilise la formule du polygone à sommets (shoelace formula) :

public static double CalculAire(List<PointTopo> points)

{
double aire = 0;
int n = [Link];
for (int i = 0; i < n; i++)
{
double x1 = points[i].X;
double y1 = points[i].Y;
double x2 = points[(i + 1) % n].X;
double y2 = points[(i + 1) % n].Y;
aire += (x1 * y2 - x2 * y1);
 }
return [Link](aire / 2);
}

3. Utilisation de NetTopologySuite

• Bibliothèque open source puissante pour géométrie avancée en .NET

• Permet de faire des opérations complexes : intersections, buffer, convex hull,
triangulations

Installation

• Dans NuGet, installe NetTopologySuite

4. Exemple basique avec NetTopologySuite

using [Link];
using [Link];

public static double AireAvecNTS(List<PointTopo> points)

{
Coordinate[] coords = [Link](p => new Coordinate(p.X,
p.Y)).ToArray();
// Fermer le polygone en ajoutant le premier point à la fin
var coordsFermes = [Link](new[] { coords[0] }).ToArray();

var polygone = new Polygon(new LinearRing(coordsFermes));

return [Link];
}

5. Triangulation (Delaunay, convex hull)

• Utiliser MIConvexHull ou fonctions avancées dans NetTopologySuite

• Permet de construire un maillage triangulaire pour modéliser les surfaces

Veux-tu qu’on approfondisse le calcul d’aire, l’utilisation de NetTopologySuite, ou la

triangulation ?
Ou tu souhaites qu’on réalise un projet concret qui intègre ces calculs ?

Ok, on continue !

Étape 16 : Triangulation de points et génération de

maillages en topographie
1. Objectif

Créer une triangulation Delaunay à partir d’un ensemble de points topographiques pour
modéliser la surface (ex: Modèle Numérique de Terrain).

2. Bibliothèque recommandée

• MIConvexHull : bibliothèque .NET pour triangulation Delaunay et enveloppe

convexe

3. Installation

• Dans Visual Studio, via NuGet :

Install-Package MIConvexHull

4. Exemple de base pour triangulation Delaunay

using MIConvexHull;
using [Link];

public class Vertex : IVertex

{
public double[] Position { get; set; }

public Vertex(double x, double y)

{
Position = new double[] { x, y };
}
}

public class TriangulationExample

{
public static void ExempleTriangulation(List<PointTopo> points)
{
List<Vertex> vertices = new List<Vertex>();
foreach(var p in points)
{
[Link](new Vertex(p.X, p.Y));
}

var triangulation = DelaunayTriangulation<Vertex,

DefaultTriangulationCell<Vertex>>.Create(vertices);

foreach(var triangle in [Link])

{
// [Link] contient 3 sommets du triangle
[Link]("Triangle:");
 foreach(var v in [Link])
{
[Link]($"({[Link][0]},
{[Link][1]})");
}
}
}
}

5. Utilisations possibles

• Calcul de volumes à partir de surfaces triangulées

• Visualisation 3D
• Analyse géométrique avancée

Veux-tu qu’on crée un projet complet avec triangulation, affichage graphique et calculs
associés ?
Ou préfères-tu qu’on aborde un autre sujet ?

Ok, on continue !

Étape 17 : Visualisation 3D basique des données

topographiques en C#

1. Objectif

Afficher un Modèle Numérique de Terrain (MNT) en 3D à partir d’un nuage de points

triangulé.

2. Outils possibles

• Helix Toolkit : bibliothèque 3D pour WPF en C#

• SharpDX ou OpenTK : wrappers pour DirectX/OpenGL (plus complexes)

3. Exemple simple avec Helix Toolkit

• Installer Helix Toolkit via NuGet

• Créer un projet WPF
• Utiliser le contrôle HelixViewport3D pour afficher la scène 3D
4. Principes

• Construire un maillage 3D à partir de la triangulation (X, Y, Z = altitude)

• Ajouter lumière, caméra, navigation

5. Ressources

• Helix Toolkit GitHub

• Tutoriels YouTube et documentation officielle

Veux-tu qu’on réalise un petit projet WPF avec affichage 3D d’un MNT ?
Ou préfères-tu approfondir un autre sujet en topographie avec C# ?

Ok, on continue !

Étape 18 : Intégration de données GPS en temps réel dans

une application C#

1. Objectif

Recevoir des données GPS en temps réel via un port série, les lire et les exploiter dans ton
application topographique.

2. Concepts clés

• Communication série ([Link])

• Lecture des trames NMEA (format standard GPS)
• Parsing des données (latitude, longitude, altitude)

3. Exemple basique d’ouverture d’un port série

using [Link];

SerialPort port = new SerialPort("COM3", 4800);

[Link] += (s, e) =>
{
string data = [Link]();
[Link]($"Données GPS reçues : {data}");
};

[Link]();

4. Traitement des données NMEA

• Extraire les informations utiles (GGA, RMC, etc.)

• Convertir latitude/longitude en coordonnées topographiques

5. Applications

• Relevé de points en temps réel

• Guidage et contrôle terrain

Veux-tu qu’on code un exemple complet d’application C# qui lit et traite des données GPS ?
Ou un autre sujet ?

Ok, on continue !

Étape 19 : Automatisation des calculs topographiques avec

scripts C# et interface utilisateur

1. Objectif

Créer une application capable d’exécuter automatiquement des calculs fréquents (distance,
pente, volume) à partir des données saisies, avec un minimum d’intervention utilisateur.

2. Fonctionnalités à intégrer

• Chargement/importation des points

• Calculs automatiques (distance, pente, volumes) dès l’import ou la saisie
• Résultats affichés dans une interface claire (grilles, graphiques simples)
• Export des résultats (fichiers texte, CSV, PDF)
3. Approche technique

• Organisation du code en classes dédiées (Point, Calculs, Interface)

• Utilisation d’événements pour déclencher les calculs
• Multithreading pour ne pas bloquer l’interface lors des calculs longs

4. Exemple de structure
class CalculsTopo
{
public static double CalculDistance(PointTopo p1, PointTopo p2) { ... }
public static double CalculPente(PointTopo p1, PointTopo p2) { ... }
public static double CalculVolume(List<PointTopo> profil1,
List<PointTopo> profil2) { ... }
}

Veux-tu que je t’aide à développer un projet complet avec automatisation et interface ?

Ou un autre sujet t’intéresse ?

Ok, on continue !

Étape 20 : Gestion des erreurs et validation des données en

topographie avec C#

1. Pourquoi valider les données ?

En topographie, les erreurs de saisie (coordonnées, altitudes, ID) peuvent fausser les calculs.
Il est essentiel de valider chaque donnée avant traitement.

2. Validation simple

• Vérifier que les coordonnées sont dans des plages réalistes (ex : X, Y > 0)
• S’assurer que l’altitude est cohérente (ex : > -500 m)
• Vérifier l’unicité des IDs

3. Exemple de méthode de validation

public static bool ValiderPoint(PointTopo p, List<PointTopo> listePoints)
{
 if (p.X < 0 || p.Y < 0) return false;
if ([Link] < -500) return false;
if ([Link](pt => [Link] == [Link])) return false; // ID dupliqué
return true;
}

4. Gestion des exceptions

• Utiliser try-catch pour gérer les erreurs lors des conversions (ex : [Link])
• Informer l’utilisateur des erreurs avec des messages clairs

5. Intégration en interface

• Bloquer l’ajout de points invalides

• Afficher les messages d’erreur dans la fenêtre

Veux-tu un exemple complet d’application avec validation avancée ?

Ou un autre thème en topographie ?

Ok, on continue !

Étape 21 : Implémentation d’un système de projection et

transformation des coordonnées en C#

1. Introduction

En topographie, il est fréquent de devoir convertir des coordonnées d’un système de

projection à un autre (ex : WGS84 GPS → Lambert, UTM).

2. Concepts de base

• Systèmes de coordonnées géographiques (latitude, longitude)

• Systèmes de coordonnées projetées (cartésiennes)
• Transformations (ex : conversion degré → mètres)

3. Bibliothèques utiles
 • ProjNET : bibliothèque .NET pour transformations de coordonnées
• DotSpatial : bibliothèque SIG avec fonctions de projection

4. Exemple simple avec ProjNET

using [Link];
using [Link];

var wgs84 = GeographicCoordinateSystem.WGS84;

var utm = ProjectedCoordinateSystem.WGS84_UTM(33, true); // Zone 33N

var transformFactory = new CoordinateTransformationFactory();

var transform = [Link](wgs84, utm);

double[] pointGeo = new double[] { longitude, latitude };

double[] pointProj = [Link](pointGeo);

[Link]($"X: {pointProj[0]}, Y: {pointProj[1]}");

5. Applications

• Intégration des relevés GPS dans des systèmes cartographiques locaux

• Préparation des données pour CAO/SIG

Veux-tu qu’on développe un projet complet avec conversion GPS → coordonnées projetées ?
Ou un autre sujet t’intéresse ?

Ok, on continue !

Étape 22 : Export des données topographiques vers

AutoCAD via fichiers DXF en C#

1. Objectif

Permettre d’exporter les points et lignes topographiques vers un fichier DXF, format utilisé
par AutoCAD.

2. Concepts clés
 • Le format DXF est un format texte structuré pour décrire les entités (points, lignes,
polylignes, etc.)
• On peut générer un fichier DXF en créant le texte selon la spécification

3. Bibliothèques utiles

• netDxf : bibliothèque .NET open source pour lire et écrire des fichiers DXF

4. Exemple basique avec netDxf

using netDxf;
using [Link];

public static void ExporterDXF(List<PointTopo> points, string chemin)

{
DxfDocument doc = new DxfDocument();

foreach(var p in points)
{
var pt = new [Link](new netDxf.Vector3(p.X, p.Y,
[Link]));
[Link](pt);
}

[Link](chemin);
}

5. Avantages

• Intégration facile avec AutoCAD

• Visualisation précise des points dans le logiciel CAO

Veux-tu qu’on crée un projet complet d’export DXF avec interface graphique ?
Ou préfères-tu un autre sujet ?

Ok, on continue !

Étape 23 : Automatisation des levés topographiques par

scripts C# et intégration à Visual Studio
1. Objectif

Créer des scripts automatisés dans Visual Studio qui gèrent la collecte, le traitement et
l’export des données topographiques.

2. Concepts clés

• Utilisation de la console et interface graphique pour automatiser des tâches répétitives

• Gestion de fichiers, import/export, calculs automatiques
• Planification et lancement de scripts via l’interface ou en ligne de commande

3. Exemple : script de traitement automatique

• Chargement d’un fichier CSV de points

• Calcul automatique des distances et volumes
• Export des résultats en PDF/Excel

4. Intégration dans Visual Studio

• Création de projets console ou Windows Forms

• Utilisation de Task Scheduler ou services Windows pour exécuter les scripts
périodiquement

Veux-tu que je t’aide à créer un script complet automatisé étape par étape ?
Ou un autre thème t’intéresse ?

Ok, on continue !

Étape 24 : Sécurisation et sauvegarde des données

topographiques en C#

1. Importance

Garantir la sécurité et la sauvegarde des données de relevés topographiques est crucial pour
éviter la perte ou la corruption.
2. Méthodes de sauvegarde

• Sauvegarde locale sur disque (fichiers CSV, XML, bases de données)

• Sauvegarde distante (serveurs, cloud, FTP)
• Versions et historiques des fichiers

3. Sécurisation

• Cryptage simple des fichiers sensibles (ex: AES)

• Gestion des droits d’accès (authentification utilisateur dans l’application)
• Sauvegarde automatique et périodique

4. Exemple de sauvegarde locale avec cryptage AES

using [Link];
using [Link];

public static void SauvegarderCrypte(string chemin, byte[] data, byte[]

key, byte[] iv)
{
using (Aes aes = [Link]())
{
[Link] = key;
[Link] = iv;

using (FileStream fs = new FileStream(chemin, [Link]))

using (CryptoStream cs = new CryptoStream(fs,
[Link](), [Link]))
{
[Link](data, 0, [Link]);
}
}
}

Veux-tu qu’on développe une application complète avec sauvegarde sécurisée ?

Ou un autre sujet ?

Ok, on continue !

Étape 25 : Création d’un système de gestion des

utilisateurs dans une application topographique C#
1. Objectif

Ajouter une gestion des utilisateurs avec authentification, rôles et permissions pour sécuriser
l’accès aux fonctionnalités.

2. Concepts clés

• Authentification (login/mot de passe)

• Rôles utilisateurs (ex: administrateur, opérateur, visiteur)
• Gestion des permissions (accès lecture/écriture)

3. Implémentation simple

• Stocker les utilisateurs dans une base de données ou fichier crypté

• Interface login dans l’application
• Gestion des sessions et contrôle des droits

4. Exemple basique de vérification d’utilisateur

public bool VerifierUtilisateur(string login, string motDePasse)
{
// Rechercher utilisateur dans base ou fichier
// Comparer hash du mot de passe
return (login == "admin" && motDePasse == "1234"); // Exemple simple
}

Veux-tu qu’on développe un système complet avec interface et gestion avancée ?

Ou un autre sujet ?

Ok, on continue !

Étape 26 : Intégration de services Web dans une

application topographique C#

1. Objectif

Permettre à ton application de communiquer avec des services web pour récupérer ou envoyer
des données topographiques (ex : API météo, bases de données en ligne).
2. Concepts clés

• Protocoles HTTP/HTTPS
• Requêtes REST avec HttpClient
• Sérialisation et désérialisation JSON

3. Exemple simple : requête GET avec HttpClient

using [Link];
using [Link];

public async Task<string> GetDonneesAsync(string url)

{
using (HttpClient client = new HttpClient())
{
var response = await [Link](url);
[Link]();
return await [Link]();
}
}

4. Applications

• Récupérer des données météo pour planification de levés

• Envoyer des résultats vers un serveur central
• Intégrer des cartes en ligne (Google Maps, OpenStreetMap)

Veux-tu qu’on crée un projet complet avec intégration API Web ?

Ou un autre thème t’intéresse ?

Ok, on continue !

Étape 27 : Optimisation des performances d’une

application topographique en C#

1. Objectif

Améliorer la rapidité et la réactivité de ton application, surtout lors du traitement de grands

volumes de données.
2. Techniques principales

• Profilage du code pour identifier les goulots d’étranglement

• Optimisation des algorithmes (complexité, structures de données)
• Utilisation efficace de la mémoire (éviter les allocations inutiles)
• Mise en cache des résultats
• Multithreading et tâches asynchrones pour répartir la charge

3. Outils

• Visual Studio Diagnostic Tools

• PerfTips, Memory Usage, CPU Usage
• Analyseurs de performances tiers

4. Bonnes pratiques

• Ne pas recalculer les valeurs déjà connues

• Utiliser des collections adaptées (List, Dictionary, HashSet)
• Préférer les structures immuables pour certains cas
• Profiter des dernières fonctionnalités C# (Span, ValueTask, etc.)

Veux-tu que je t’aide à analyser et optimiser un projet existant ?

Ou un autre sujet ?

Ok, on continue !

Étape 28 : Déploiement d’une application topographique

C# sur différentes plateformes

1. Objectif

Distribuer ton application aux utilisateurs finaux, que ce soit sur Windows, ou via des
versions web/mobile.
2. Options de déploiement

• Application Windows classique : création d’un installateur MSI ou EXE avec Visual
Studio Installer Projects ou autres outils
• Applications multiplateformes : via .NET MAUI pour Windows, Android, iOS
• Application web : migration vers [Link] Core pour accès via navigateur

3. Création d’un installateur

• Utiliser Visual Studio Installer Projects (extension)

• Configurer les dépendances et raccourcis
• Signature numérique pour sécurité

4. Mise à jour automatique

• Implémenter un système de mise à jour (ex : via ClickOnce, [Link])

• Notifications utilisateur

Veux-tu un guide pas à pas pour créer un installateur et gérer le déploiement ?

Ou préfères-tu explorer une autre thématique ?

Ok, on continue !

Étape 29 : Test unitaire et validation du code en C# pour

applications topographiques

1. Objectif

Garantir la fiabilité du code grâce à des tests automatisés, pour éviter les erreurs lors des
calculs ou manipulations.

2. Concepts clés

• Tests unitaires (Unit Tests) avec frameworks comme MSTest, NUnit, ou xUnit
• Écriture de tests pour les méthodes de calcul (distance, aire, volume)
• Tests d’intégration pour les parties liées (import/export, interface)
3. Exemple simple avec MSTest
[TestClass]
public class CalculsTopoTests
{
[TestMethod]
public void TestCalculDistance()
{
var p1 = new PointTopo(1, 0, 0, 0, "");
var p2 = new PointTopo(2, 3, 4, 0, "");
double dist = [Link](p1, p2);
[Link](5, dist, 0.001);
}
}

4. Intégration continue

• Automatiser les tests dans le pipeline de développement

• Outils comme Azure DevOps, GitHub Actions, Jenkins

Veux-tu qu’on crée ensemble une suite de tests pour ton projet ?
Ou un autre sujet ?

Super choix ! Voici plusieurs idées de projets complets en C# pour la topographie qu’on
peut développer ensemble étape par étape :

Projet 1 : Application complète de gestion de levés

topographiques
Fonctionnalités :

• Import/export de points (CSV, DXF)

• Visualisation 2D des points et lignes
• Calculs automatiques (distances, pentes, volumes)
• Génération de rapports PDF/Excel
• Interface utilisateur intuitive avec validation des données

Projet 2 : Système de visualisation 3D de Modèles

Numériques de Terrain
Fonctionnalités :
 • Import de nuages de points
• Triangulation Delaunay automatique
• Affichage 3D interactif (zoom, rotation) avec Helix Toolkit
• Calculs et affichage des volumes de déblais/remblais

Projet 3 : Application de collecte GPS en temps réel

Fonctionnalités :

• Lecture des données GPS via port série

• Conversion coordonnées GPS en coordonnées locales
• Affichage temps réel sur carte 2D
• Export des points relevés

Projet 4 : Plateforme de gestion des utilisateurs et sécurité

Fonctionnalités :

• Authentification et rôles utilisateurs

• Gestion des permissions d’accès
• Sauvegarde sécurisée des données
• Journalisation des opérations

Tu veux commencer par quel projet ? Ou un autre projet en tête ?

Je peux t’accompagner étape par étape pour coder et construire l’application complète !