Sous-échantillonner efficacement les fichiers LAS/LAZ avec Laspy : un guide étape par étape

Comprendre le processus de sous-échantillonnage des données LAS avec Laspy

Lorsque vous travaillez avec de gros fichiers LAS ou LAZ en Python, le sous-échantillonnage est essentiel pour un traitement et une analyse efficaces. Laspy, un package Python permettant de lire, d'écrire et de modifier des données LAS, offre de nombreuses façons de manipuler les données de nuages ​​de points, telles que la création et la modification d'en-têtes LAS.

Cet exemple montre comment sous-échantillonner un ensemble de données en extrayant chaque dixième point d'un paresseux classer et réutiliser un existant LasEn-Tête. Cela nécessite une compréhension de la manière dont les en-têtes interagissent avec les données, en particulier lorsque vous travaillez avec différents points d'écoute.

Lors de l'établissement d'un nouveau LasData objet à partir d’un en-tête existant, les utilisateurs rencontrent fréquemment des tailles de tableau incompatibles. Cette disparité se produit parce que l'en-tête point_count peuvent ne pas s'aligner automatiquement sur les nouvelles données.

Le défi consiste à évaluer s'il est nécessaire de modifier manuellement les attributs d'en-tête tels que les décalages, les échelles et point_count, ou s'il existe une solution plus automatique. Cet article explique comment mettre à jour correctement ces valeurs lors du sous-échantillonnage à l'aide de Laspy, ce qui donne lieu à un processus efficace.

Optimisation du sous-échantillonnage des nuages ​​de points avec Laspy

Le premier script de cet article se concentre sur le sous-échantillonnage d'un LAZ fichier, nécessaire à la gestion de grands ensembles de données de nuages ​​de points. En important le fichier original à l'aide du laspy.read() fonction, nous pouvons accéder aux données de points et à l'en-tête qui contient des métadonnées sur le nuage de points. La technique de sous-échantillonnage consiste à sélectionner un point sur dix, ce qui minimise la taille de l'ensemble de données tout en conservant les propriétés géographiques cruciales. Cela se fait en utilisant np.arange() pour construire un tableau d'indices. Après avoir sélectionné les points, copiez l'en-tête du fichier d'origine pour garantir la compatibilité des métadonnées, telles que format_point et version.

Cependant, un problème courant survient lorsque le nombre de points dans l’en-tête d’origine ne correspond pas aux données sous-échantillonnées. Pour résoudre ce problème, nous utilisons le copie() fonction pour faire une copie superficielle de l'en-tête d'origine et modifier manuellement le point_count champ pour refléter le nombre de points sous-échantillonnés. Après avoir créé le nouvel en-tête, les points sous-échantillonnés sont alloués à un nouvel LasData objet qui contient les coordonnées réelles x, y et z. Enfin, le LasData est enregistré en tant que nouveau fichier LAZ à l'aide du écrire() méthode. Ce script est efficace pour les utilisateurs qui ont besoin d'extraire des ensembles de données plus petits à partir de nuages ​​de points plus grands.

Le deuxième script étend le premier en recalculant automatiquement les décalages et les échelles pour les données sous-échantillonnées. Lorsque vous travaillez avec des nuages ​​de points, il est essentiel de disposer de décalages précis car ils indiquent l'origine des données dans l'espace 3D. Le en-tête.offsets L'attribut est mis à jour avec les coordonnées minimales x, y et z des points sous-échantillonnés. De même, les facteurs d'échelle qui affectent la précision des données ponctuelles sont définis à l'aide de l'option en-tête.scales attribut. Ce script minimise non seulement la taille du nuage de points, mais garantit également que les données sont précises et alignées, ce qui les rend plus adaptées à une utilisation pratique.

Enfin, le script final démontre les tests unitaires avec Python test unitaire cadre. Dans ce script, un scénario de test détermine si le nombre de points sous-échantillonnés correspond à la valeur prédite. Ceci est crucial pour garantir que la procédure de sous-échantillonnage fonctionne de manière cohérente dans tous les contextes et ensembles de données. Le scénario de test est défini à l'aide du Cas de test classe, et la comparaison est effectuée en utilisant la self.assertEqual() méthode. En incluant les tests dans le flux de travail, nous pouvons garantir que la procédure de sous-échantillonnage fonctionne correctement avant de la déployer sur des projets ou des pipelines plus importants. Ce script aide les utilisateurs à éviter les problèmes et les incohérences lorsqu'ils travaillent avec plusieurs fichiers de nuages ​​de points.

import laspy
import numpy as np
from copy import copy
# Load the existing LAZ file
las = laspy.read("input_file.laz")
# Downsample by taking every 10th point
indices = np.arange(0, len(las.points), 10)
downsampled_points = las.points[indices]
# Copy the header and adjust the point count
header = copy(las.header)
header.point_count = len(downsampled_points)
# Create new LasData with downsampled points
d_las = laspy.LasData(header)
d_las.points = downsampled_points
# Write to a new LAZ file
d_las.write("downsampled_output.laz")

import laspy
import numpy as np
# Load the original LAZ file
las = laspy.read("input_file.laz")
# Downsample by taking every 10th point
indices = np.arange(0, len(las.points), 10)
downsampled_points = las.points[indices]
# Create new header and adjust offsets/scales
header = laspy.LasHeader(point_format=las.header.point_format, version=las.header.version)
header.offsets = np.min([las.x[indices], las.y[indices], las.z[indices]], axis=1)
header.scales = np.array([0.01, 0.01, 0.01])  # Set new scales
# Create new LasData and write to file
downsampled_las = laspy.LasData(header)
downsampled_las.points = downsampled_points
downsampled_las.write("downsampled_with_scales.laz")

import unittest
import laspy
import numpy as np
class TestDownsampling(unittest.TestCase):
    def test_downsample_point_count(self):
        las = laspy.read("input_file.laz")
        indices = np.arange(0, len(las.points), 10)
        downsampled_points = las.points[indices]
        self.assertEqual(len(downsampled_points), len(indices))
if __name__ == "__main__":
    unittest.main()

Gestion des métadonnées des fichiers LAS et des techniques avancées de sous-échantillonnage

Lorsque vous travaillez avec d'énormes ensembles de données avec laspy, la gestion des métadonnées est tout aussi cruciale que la gestion des données réelles du nuage de points. Maintenir l'exactitude de LasEn-Tête les valeurs après sous-échantillonnage constituent une difficulté importante. Étant donné que les coordonnées des données du nuage de points (x, y et z) changent, l'en-tête doit refléter ces modifications. Recalculer le compensations nécessite de recalculer les valeurs minimales pour chaque dimension, alors que la Balance déterminer la précision des données ponctuelles, notamment pour le stockage.

Un autre facteur à évaluer est l'intégrité des dimensions supplémentaires dans le fichier LAS. Les octets supplémentaires sont couramment utilisés pour contenir des informations autres que les coordonnées normales x, y et z, telles que l'intensité ou l'heure GPS. Si l'ensemble de données contient ces dimensions supplémentaires, elles doivent être gérées lors du sous-échantillonnage. Vous devez garantir que le nombre de points dans les dimensions supplémentaires correspond au nombre de points réduit dans les données primaires. Le add_extra_dim fonctionnalité dans laspy permet l’ajout de dimensions personnalisées à l’en-tête LAS.

Enfin, l’optimisation de la vitesse est un facteur important à prendre en compte lors du sous-échantillonnage des nuages ​​de points. Bien que des modifications humaines de l'en-tête soient généralement nécessaires, l'automatisation du processus en tirant parti d'une indexation efficace et en appliquant des opérations sur les tableaux via numpy peut considérablement accélérer le processus. En exploitant le pouvoir de numpy, vous pouvez gérer rapidement d’énormes ensembles de données sans sacrifier les performances. Cela vous permet d'étendre les solutions à des projets plus importants ou même d'automatiser les pipelines pour le traitement de plusieurs fichiers LAZ.