Lire des fichiers GPX à l'aide de C#

Un fichier GPX contient des données GPS enregistrées au format d’échange GPS. Il s’agit d’un schéma XML pour décrire des informations géographiques telles que des waypoints, des pistes, des itinéraires, etc. Il permet de transférer des données GPS entre des unités GPS et des applications logicielles. Nous pouvons facilement charger le fichier GPX et extraire les informations GPS par programmation dans les applications .NET. Dans cet article, nous allons apprendre à lire des fichiers GPX à l’aide de C#.

L’article doit couvrir les sujets suivants :

API C# pour lire les fichiers GPX

Pour lire les fonctionnalités des fichiers GPX, nous utiliserons l’API Aspose.GIS for .NET. Il vous permet de restituer des cartes et de créer, lire et convertir des données géographiques sans logiciel supplémentaire. Il vous permet également de convertir des fichiers KML au format GPX et vice versa. Veuillez soit télécharger la DLL de l’API ou l’installer à l’aide de NuGet.

PM> Install-Package Aspose.GIS

Lire les waypoints du fichier GPX en C#

Nous pouvons lire les waypoints du fichier GPX en tant que Point Geometry en suivant les étapes ci-dessous :

  1. Tout d’abord, chargez le fichier GPX en utilisant la méthode OpenLayer.
  2. Ensuite, pour chaque entité de la couche, vérifiez si GeometryType est Point.
  3. Après cela, obtenez la géométrie de l’entité en tant que point.
  4. Enfin, affichez les points de coordonnées X et Y.

L’exemple de code suivant montre comment lire des waypoints à partir d’un fichier GPX à l’aide de C#.

// Cet exemple de code montre comment lire des waypoints à partir d'un fichier GPX
// Charger le fichier GPX
var layer = Drivers.Gpx.OpenLayer(@"D:\Files\GIS\St_Louis_Zoo_sample.gpx");

foreach (var feature in layer)
{
    // Vérifier la géométrie du point
    if (feature.Geometry.GeometryType == GeometryType.Point)
    {
        // Points de lecture
        Point point = (Point)feature.Geometry;
        Console.WriteLine(point.AsText() + " X: " + point.X + " Y: " + point.Y);
    }
}

POINT (-90.29408 38.63473) X: -90.29408 Y: 38.63473
POINT (-90.28679 38.63368) X: -90.28679 Y: 38.63368
POINT (-90.29323 38.63408) X: -90.29323 Y: 38.63408
POINT (-90.29019 38.63533) X: -90.29019 Y: 38.63533
POINT (-90.28976 38.63677) X: -90.28976 Y: 38.63677
POINT (-90.28948 38.63496) X: -90.28948 Y: 38.63496
POINT (-90.29458 38.63421) X: -90.29458 Y: 38.63421
POINT (-90.29083 38.63633) X: -90.29083 Y: 38.63633
POINT (-90.28715 38.63395) X: -90.28715 Y: 38.63395
POINT (-90.28769 38.63347) X: -90.28769 Y: 38.63347

Lire les routages à partir du fichier GPX en C#

Nous pouvons lire les itinéraires du fichier GPX en tant que géométrie de chaîne de lignes en suivant les étapes ci-dessous :

  1. Tout d’abord, chargez le fichier GPX en utilisant la méthode OpenLayer.
  2. Ensuite, pour chaque entité de la couche, vérifiez si GeometryType est LineString.
  3. Après cela, obtenez la géométrie de l’entité en tant que LineString.
  4. Enfin, affichez les points de coordonnées X, Y et Z.

L’exemple de code suivant montre comment lire des itinéraires à partir d’un fichier GPX à l’aide de C#.

// Cet exemple de code montre comment lire les itinéraires GPS à partir du fichier GPX
// Charger le fichier GPX
var layer = Drivers.Gpx.OpenLayer(@"D:\Files\GIS\schiehallion.gpx");

foreach (var feature in layer)
{
    // Vérifier la géométrie LineString
    if (feature.Geometry.GeometryType == GeometryType.LineString)
    {
        // Lire les routages
        LineString ls = (LineString)feature.Geometry;

        foreach (var point in ls)
        {
            Console.WriteLine(" X: " + point.X + " Y: " + point.Y + " Z: " + point.Z);
        }
    }
}

=====================================================
 X: -4.03601769647726 Y: 56.6758328268945 Z: 351.247702398777
 X: -4.03583038137853 Y: 56.6753865835736 Z: 344.690721458414
 X: -4.03614000315429 Y: 56.6735618299578 Z: 349.066837113628
 X: -4.03711323311608 Y: 56.6726922276694 Z: 352.76479861559
 X: -4.03921535478461 Y: 56.6708156570976 Z: 358.078238232484
 X: -4.04184722532733 Y: 56.668930361342 Z: 371.315914270806
 X: -4.04446052766014 Y: 56.668213511889 Z: 372.334546538997
 X: -4.04552528394144 Y: 56.6682858833434 Z: 398.610199355698
 X: -4.04660281552745 Y: 56.6678413316366 Z: 439.24188764472
 X: -4.04765411258453 Y: 56.6661616045966 Z: 430.695575764036
.
.
.

Extraire les pistes du fichier GPX en C#

Nous pouvons lire les pistes du fichier GPX en tant que géométrie MultiLineString en suivant les étapes ci-dessous :

  1. Tout d’abord, chargez le fichier GPX en utilisant la méthode OpenLayer.
  2. Ensuite, pour chaque entité de la couche, vérifiez si GeometryType est MultiLineString.
  3. Après cela, obtenez la géométrie de l’entité en tant que MultiLineString.
  4. Enfin, montrez les pistes.

L’exemple de code suivant montre comment lire les pistes d’un fichier GPX à l’aide de C#.

// Cet exemple de code montre comment lire des pistes à partir d'un fichier GPX
// Charger le fichier GPX
var layer = Drivers.Gpx.OpenLayer(@"D:\Files\GIS\nested_data.gpx");

foreach (var feature in layer)
{
    // Vérifier la géométrie MultiLineString
    if (feature.Geometry.GeometryType == GeometryType.MultiLineString)
    {
        // Lire la piste
        var lines = (MultiLineString)feature.Geometry;
        foreach(var line in lines)
        {
            Console.WriteLine(line.AsText());
        }
    }
}

LINESTRING (0 0, 1 1, 2 2, 3 3)
LINESTRING EMPTY
LINESTRING EMPTY
LINESTRING (10 10, 11 11, 12 12, 13 13)

Lire les attributs imbriqués GPX en C#

Nous pouvons lire les caractéristiques de chaque point du segment et extraire les valeurs d’attributs imbriqués en suivant les étapes ci-dessous :

  1. Tout d’abord, créez une instance de la classe GpxOptions.
  2. Ensuite, définissez ReadNestedAttributes sur true.
  3. Ensuite, chargez le fichier GPX en utilisant la méthode OpenLayer() avec l’objet GpxOptions comme argument.
  4. Ensuite, pour chaque entité de la couche, vérifiez si GeometryType est MultiLineString.
  5. Ensuite, obtenez la géométrie de l’entité en tant que MultiLineString.
  6. Après cela, lisez le segment en tant que LineString à partir de chaque MultiLineString.
  7. Enfin, lisez les points du segment et affichez les valeurs des attributs.

L’exemple de code suivant montre comment lire les attributs imbriqués GPX à partir d’un fichier GPX à l’aide de C#.

// Cet exemple de code montre comment lire les attributs imbriqués GPX à partir du fichier GPX
// Spécifiez l'option GPX
GpxOptions options = new GpxOptions()
{
    ReadNestedAttributes = true
};


// Chargez le fichier GPX et ouvrez la couche pour lire les fonctionnalités
using (var layer = Drivers.Gpx.OpenLayer(@"D:\Files\GIS\nested_data.gpx", options))
{
    foreach (var feature in layer)
    {
        // Vérifier la géométrie MultiLineString
        if (feature.Geometry.GeometryType == GeometryType.MultiLineString)
        {
            // Lire le segment
            var lines = (MultiLineString) feature.Geometry;
            for (int i = 0; i < lines.Count; i++)
            {
                Console.WriteLine($"....segment({i})......");
                var segment = (LineString)lines[i];

                // Lire les points dans le segment
                for (int j = 0; j < segment.Count; j++)
                {
                    // Rechercher l'attribut
                    string attributeName = $"name__{i}__{j}";
                    if (layer.Attributes.Contains(attributeName) && feature.IsValueSet(attributeName))
                    {
                        // Imprimer un point et un attribut
                        var value = feature.GetValue<string>(attributeName);
                        Console.WriteLine($"{segment[j].AsText()} - {attributeName}: {value}, ");
                    }
                    else
                    {
                        // Imprimer un point seulement
                        Console.WriteLine(segment[j].AsText());
                    }
                }
            }
            Console.WriteLine("..........");
        }
    }
}

Obtenez une licence gratuite

Vous pouvez obtenir une licence temporaire gratuite pour essayer la bibliothèque sans limitations d’évaluation.

Conclusion

Dans cet article, nous avons appris à :

  • charger un fichier GPX en utilisant OpenLayer en C# ;
  • lire les points de cheminement, les routes et les pistes du fichier GPX par programmation ;
  • lire l’attribut imbriqué à partir d’un fichier GPX à l’aide de C#.

En outre, vous pouvez en savoir plus sur l’API Aspose.GIS for .NET en utilisant la documentation. En cas d’ambiguïté, n’hésitez pas à nous contacter sur le forum.

Voir également