Pourquoi votre conversion de Shapefile échoue et comment la corriger en C#

Vous exécutez une conversion de Shapefiles qui a fonctionné cent fois, et cette fois elle s’arrête avec une TransformationException. Il n’y a aucune sortie partielle et aucune indication claire du registre qui a causé le problème. Souvent, le coupable est une seule coordonnée invalide enfouie parmi des milliers de fonctionnalités valides. Cet article explique pourquoi la conversion de Shapefile échoue avec cette erreur et comment la corriger en C# en utilisant OperationErrorCollector, introduit dans Aspose.GIS for .NET 26.6. Vous apprendrez comment laisser la conversion se terminer, conserver chaque fonctionnalité valide et obtenir un rapport précis des enregistrements qui nécessitent une attention.

Si vous avez seulement besoin du code de conversion de base, consultez Convert Shapefile to KML in C#. Ce guide s’appuie sur cela et se concentre sur la gestion des erreurs.

Pourquoi la conversion Shapefile génère une TransformationException

La plupart des formats cibles attendent des coordonnées dans un système de coordonnées spécifique. KML, par exemple, utilise toujours la longitude et la latitude WGS 84. Lors de la conversion, Aspose.GIS transforme chaque coordonnée du système de coordonnées source vers le système cible. Si une coordonnée ne peut pas être transformée, la bibliothèque lève une TransformationException et la conversion s’arrête.

Les causes les plus courantes sont :

• Valeurs de remplacement “no data”. Certains outils écrivent une valeur sentinelle au lieu de laisser une géométrie vide. Le fichier d’exemple de cet article contient un point à (-1.7976931348623157E+308, -1.7976931348623157E+308), la valeur minimale d’un double, qu’aucun système de coordonnées ne peut transformer.
• Coordonnées hors limites. Valeurs qui se trouvent en dehors de la zone valide du système de coordonnées source, souvent causées par des erreurs de saisie de données ou de mauvaises conversions d’unités.
• Un fichier .prj qui ne correspond pas aux données. Si les coordonnées projetées en mètres sont déclarées comme coordonnées géographiques en degrés, de nombreuses valeurs se retrouvent bien en dehors de la plage valide.
• Enregistrements de géométrie corrompus. Les exportations héritées et les fichiers endommagés peuvent contenir des valeurs numériques invalides dans des enregistrements individuels.

Dans chaque cas, le problème est généralement limité à quelques enregistrements, mais le comportement par défaut supprime toute la conversion.

Pourquoi cette fonctionnalité est importante

S’arrêter à la première erreur est sûr, mais cela coûte cher dans les pipelines réels. Un enregistrement défectueux vous oblige à nettoyer le fichier manuellement avant que les données puissent être converties, et l’exception seule ne vous indique pas combien d’autres enregistrements sont affectés. Avec la collecte des erreurs activée, vous pouvez :

• Convertir toutes les entités valides au lieu de perdre tout le fichier à cause d’un seul enregistrement défectueux.
• Enregistrer l’index et les coordonnées de chaque entité ignorée afin que les données sources puissent être réparées.
• Exécuter des conversions par lots non supervisées et des travaux ETL sans planter sur des entrées corrompues.
• Accepter les Shapefiles téléchargés par les utilisateurs dans les services web et signaler les problèmes de données à l’utilisateur.

Comment résoudre les échecs de conversion de Shapefile en C# avec Aspose.GIS

Aspose.GIS for .NET est une bibliothèque gérée pour la lecture, l’écriture et la conversion de formats géospatiaux tels que Shapefile, KML, GeoJSON, GML et File Geodatabase sans aucun autre logiciel SIG installé. La collecte d’erreurs nécessite la version 26.6 ou ultérieure. Installez le package depuis NuGet:

dotnet add package Aspose.GIS

Ou utilisez la console du Gestionnaire de packages :

Install-Package Aspose.GIS

Les types suivants sont utilisés dans ce tutoriel :

• VectorLayer (Aspose.Gis): ouvre, crée et convertit des couches vectorielles. VectorLayer.Convert effectue la conversion.
• ConversionOptions (Aspose.Gis): contient les paramètres de conversion, y compris DestinationDriverOptions et DestinationSpatialReferenceSystem.
• KmlOptions (Aspose.Gis.Formats.Kml): options du pilote KML. Il hérite de la propriété ErrorCollector de DriverOptions.
• OperationErrorCollector (Aspose.Gis.Operations): stocke les erreurs récupérables. Il expose Errors, Count, HasErrors, Add et Clear.
• OperationError et TransformationError (Aspose.Gis.Operations): chaque erreur possède un Message et une Exception. TransformationError ajoute FeatureIndex, X, Y et Z.
• TransformationException (Aspose.Gis.SpatialReferencing): levée lorsqu’une coordonnée ne peut pas être transformée et aucun collecteur n’est attaché.

Comment corriger TransformationException lors de la conversion de Shapefile

La correction comporte deux parties. Tout d’abord, attachez un OperationErrorCollector afin que la conversion ignore les entités invalides au lieu d’échouer. Ensuite, utilisez le rapport collecté pour réparer ou supprimer ces enregistrements à la source. Les étapes ci‑dessous utilisent une conversion de Shapefile vers KML comme exemple.

1. Préparer l’environnement

1. Créez un projet console .NET et ajoutez le package NuGet Aspose.GIS 26.6+.
2. Copiez le Shapefile et ses fichiers associés (.shp, .shx, .dbf et .prj) dans un même dossier. Cet exemple utilise data/light-traffics.shp.
3. Ajoutez les espaces de noms requis :

using System;
using System.IO;
using Aspose.Gis;
using Aspose.Gis.Formats.Kml;
using Aspose.Gis.Operations;
using Aspose.Gis.SpatialReferencing;

2. Créer un OperationErrorCollector

Le collecteur enregistre chaque erreur récupérable générée pendant la conversion. Créez une nouvelle instance pour chaque conversion afin que les erreurs provenant de différents fichiers ne soient pas mélangées.

// Records recoverable errors instead of throwing them.
var errors = new OperationErrorCollector();

3. Attacher le collecteur via ConversionOptions

Attribuez le collecteur à KmlOptions.ErrorCollector, puis transmettez les options KML en tant que DestinationDriverOptions. Définir DestinationSpatialReferenceSystem sur WGS 84 est facultatif pour KML, mais cela rend le système de coordonnées cible explicite dans votre code.

var options = new ConversionOptions
{
    // KML always uses WGS 84; stating it makes the reprojection explicit.
    DestinationSpatialReferenceSystem = SpatialReferenceSystem.Wgs84,
    DestinationDriverOptions = new KmlOptions
    {
        ErrorCollector = errors // Skip and record features that fail transformation.
    }
};

4. Exécuter la conversion

Appelez VectorLayer.Convert avec le chemin source, le pilote Shapefile, le chemin de destination, le pilote KML et les options que vous venez de configurer.

string sourcePath = Path.Combine("data", "light-traffics.shp");
string destinationPath = Path.Combine("output", "light-traffics.kml");
Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));

VectorLayer.Convert(sourcePath, Drivers.Shapefile, destinationPath, Drivers.Kml, options);

Lorsqu’une fonctionnalité ne peut pas être transformée, le pilote KML ajoute une erreur au collecteur, ignore cette fonctionnalité et continue avec la suivante. Aucune TransformationException n’est levée.

5. Signaler les fonctionnalités ignorées et vérifier la sortie

Une conversion qui se termine normalement peut néanmoins avoir sauté des entités, il faut donc toujours vérifier le collecteur par la suite. Convertissez chaque erreur en TransformationError pour obtenir l’index de l’entité et la coordonnée qui a échoué, puis ouvrez le fichier de sortie pour confirmer le nombre d’entités écrites.

if (errors.HasErrors)
{
    Console.WriteLine($"Skipped {errors.Count} feature(s):");

foreach (var error in errors.Errors)
    {
        if (error is TransformationError transformationError)
        {
            Console.WriteLine(
                $"  Feature #{transformationError.FeatureIndex} at " +
                $"({transformationError.X}, {transformationError.Y}, {transformationError.Z}): {error.Message}");
        }
        else
        {
            Console.WriteLine($"  {error.Message}");
        }
    }
}

using (var layer = VectorLayer.Open(destinationPath, Drivers.Kml))
{
    Console.WriteLine($"Features written to KML: {layer.Count}");
}

Pour le fichier d’exemple, le collecteur enregistre une erreur pour le point d’espace réservé, et les features restantes (au moins 444) sont écrites dans le fichier KML.

L’index des entités et les coordonnées dans ce rapport complètent la correction. Ouvrez le Shapefile source dans votre flux de travail de nettoyage des données, localisez les enregistrements signalés et corrigez‑les ou supprimez‑les. Si de nombreux enregistrements échouent avec des valeurs apparemment raisonnables, vérifiez d’abord le fichier .prj, car un système de coordonnées incompatible est probablement la cause.

6. Code complet d’exemple

L’application console complète ci‑dessous exécute la conversion deux fois. La première exécution utilise les paramètres par défaut et reproduit l’TransformationException. La deuxième exécution attache un OperationErrorCollector, ignore la fonctionnalité invalide et affiche un rapport.

using System;
using System.IO;
using Aspose.Gis;
using Aspose.Gis.Formats.Kml;
using Aspose.Gis.Operations;
using Aspose.Gis.SpatialReferencing;

namespace ShapefileTransformationErrors
{
    internal class Program
    {
        private static void Main()
        {
            string sourcePath = Path.Combine("data", "light-traffics.shp");
            string outputFolder = "output";
            Directory.CreateDirectory(outputFolder);

// -----------------------------------------------------------------
            // Run 1: default behavior. The first failed transformation aborts
            // the whole conversion with a TransformationException.
            // -----------------------------------------------------------------
            string failFastPath = Path.Combine(outputFolder, "fail-fast.kml");
            try
            {
                VectorLayer.Convert(sourcePath, Drivers.Shapefile, failFastPath, Drivers.Kml);
                Console.WriteLine("Default conversion finished without transformation errors.");
            }
            catch (TransformationException ex)
            {
                Console.WriteLine($"Default conversion aborted: {ex.Message}");
                Console.WriteLine($"Failing coordinate: ({ex.X}, {ex.Y}, {ex.Z})");
            }

// -----------------------------------------------------------------
            // Run 2: error-tolerant conversion. Invalid features are skipped
            // and recorded in the collector; valid features are written.
            // -----------------------------------------------------------------
            string destinationPath = Path.Combine(outputFolder, "light-traffics.kml");

var errors = new OperationErrorCollector();
            var options = new ConversionOptions
            {
                DestinationSpatialReferenceSystem = SpatialReferenceSystem.Wgs84,
                DestinationDriverOptions = new KmlOptions
                {
                    ErrorCollector = errors
                }
            };

VectorLayer.Convert(sourcePath, Drivers.Shapefile, destinationPath, Drivers.Kml, options);

// Report every skipped feature so the source data can be repaired.
            if (errors.HasErrors)
            {
                Console.WriteLine($"Conversion completed with {errors.Count} skipped feature(s):");

foreach (var error in errors.Errors)
                {
                    if (error is TransformationError transformationError)
                    {
                        Console.WriteLine(
                            $"  Feature #{transformationError.FeatureIndex} at " +
                            $"({transformationError.X}, {transformationError.Y}, {transformationError.Z}): {error.Message}");
                    }
                    else
                    {
                        Console.WriteLine($"  {error.Message}");
                    }
                }
            }
            else
            {
                Console.WriteLine("Conversion completed with no errors.");
            }

// Verify the output file.
            using (var layer = VectorLayer.Open(destinationPath, Drivers.Kml))
            {
                Console.WriteLine($"Features written to KML: {layer.Count}");
            }
        }
    }
}

7. Pièges courants et comment les éviter

Obtenez une licence gratuite

Vous pouvez obtenir une licence temporaire gratuite pour Aspose.GIS depuis la page de licence temporaire d’Aspose : https://purchase.aspose.com/temporary-license/

Ressources supplémentaires gratuites

• Documentation: https://docs.aspose.com/gis/net/
• Référence API: https://reference.aspose.com/gis/net/
• Applications Web gratuites: https://products.aspose.app/gis/family

Conclusion

Une TransformationException lors de la conversion de Shapefile signifie généralement qu’un petit nombre d’enregistrements contiennent des coordonnées qui ne peuvent pas être transformées, comme des valeurs de remplacement, des nombres hors limites ou des données qui ne correspondent pas à leur fichier .prj. Corriger cela en C# se fait en deux étapes : attacher un OperationErrorCollector afin qu’Aspose.GIS for .NET ignore les entités invalides et termine la conversion, puis utiliser les index d’entités et les coordonnées collectés pour réparer les données source. Le résultat est un pipeline qui continue de fournir une sortie valide tout en transformant les échecs critiques en rapports de qualité de données exploitables.

FAQ

1. Pourquoi l’exception TransformationException se produit‑elle lors de la conversion d’un Shapefile ? Cela se produit lorsqu’une coordonnée ne peut pas être transformée du système de coordonnées source vers le système cible. Les causes courantes sont les valeurs de remplacement “no data”, des coordonnées en dehors de la plage valide de leur système de coordonnées, un fichier .prj qui ne correspond pas aux données réelles, et des enregistrements de géométrie corrompus.

2. Que se passe-t-il par défaut lorsqu’une coordonnée ne peut pas être transformée ?
   VectorLayer.Convert lance une TransformationException et la conversion s’arrête. À partir de la version 26.6, l’exception expose également les valeurs X, Y et Z de la coordonnée qui a échoué.

3. Quelle version d’Aspose.GIS for .NET prend en charge OperationErrorCollector ?
   OperationErrorCollector et la propriété DriverOptions.ErrorCollector ont été introduits dans Aspose.GIS for .NET 26.6. Les versions antérieures ne les incluent pas.

4. Le OperationErrorCollector répare-t-il les coordonnées invalides ? Non. Il ignore les entités qui échouent lors de la transformation et les enregistre, de sorte que la sortie ne contient que des entités valides. Utilisez l’index de l’entité signalé et les coordonnées pour corriger ou supprimer les enregistrements défectueux dans les données source.

5. Puis-je utiliser OperationErrorCollector avec des formats de sortie autres que KML ? ErrorCollector est défini dans la classe de base DriverOptions, de sorte que chaque classe d’options de pilote l’expose. Les exemples documentés couvrent les destinations KML et MapInfo TAB ; testez le comportement avec votre propre pilote cible avant de vous y fier en production.

6. Quels détails chaque erreur collectée contient‑elle ? Chaque OperationError fournit un Message et l’Exception sous‑jacente. Les échecs de transformation sont signalés sous forme d’objets TransformationError, qui ajoutent le FeatureIndex ainsi que les valeurs X, Y et Z de la coordonnée défaillante.

7. Comment savoir si une conversion s’est terminée sans aucune erreur ? Vérifiez la propriété HasErrors ou Count du collecteur après le retour de VectorLayer.Convert. Une conversion qui se termine sans lever d’exception peut néanmoins avoir ignoré des entités.

En savoir plus

• Convertir Shapefile en KML en C#
• Conversion de GEOJSON en Topojson dans .NET : Guide d’exemple