Effizientes Downsampling von LAS/LAZ-Dateien mit Laspy: Eine Schritt-für-Schritt-Anleitung

Den Prozess des Downsampling von LAS-Daten mit Laspy verstehen

Bei der Arbeit mit großen LAS- oder LAZ-Dateien in Python ist Downsampling für eine effiziente Verarbeitung und Analyse unerlässlich. Laspy, ein Python-Paket zum Lesen, Schreiben und Ändern von LAS-Daten, bietet zahlreiche Möglichkeiten zum Bearbeiten von Punktwolkendaten, beispielsweise das Erstellen und Bearbeiten von LAS-Headern.

Dieses Beispiel zeigt, wie ein Datensatz heruntergerechnet wird, indem jeder zehnte Punkt aus a extrahiert wird laz Datei ablegen und eine vorhandene wiederverwenden LasHeader. Dies erfordert ein Verständnis dafür, wie Header mit Daten interagieren, insbesondere wenn mit unterschiedlichen Punktzahlen gearbeitet wird.

Bei der Neugründung LasData Wenn Benutzer ein Objekt aus einem vorhandenen Header entfernen, stoßen sie häufig auf nicht übereinstimmende Array-Größen. Diese Ungleichheit tritt auf, weil der Header point_count werden möglicherweise nicht automatisch an die neuen Daten angepasst.

Die Herausforderung besteht darin, zu bewerten, ob es erforderlich ist, Header-Attribute wie Offsets, Scales und point_count manuell zu ändern, oder ob es eine automatischere Lösung gibt. In diesem Beitrag wird erläutert, wie Sie diese Werte beim Downsampling ordnungsgemäß aktualisieren Laspy, was zu einem effektiven Prozess führt.

Optimieren des Punktwolken-Downsamplings mit Laspy

Das erste Skript in diesem Beitrag konzentriert sich auf das Downsampling von a LAZ Datei, die für die Verwaltung großer Punktwolkendatensätze erforderlich ist. Durch Importieren der Originaldatei mit dem laspy.read() Mit der Funktion können wir auf die Punktdaten und den Header zugreifen, der Metadaten über die Punktwolke enthält. Bei der Downsampling-Technik wird jeder zehnte Punkt ausgewählt, wodurch die Größe des Datensatzes minimiert und gleichzeitig wichtige geografische Eigenschaften beibehalten werden. Dies geschieht durch die Verwendung np.arange() um eine Reihe von Indizes zu erstellen. Nachdem Sie die Punkte ausgewählt haben, kopieren Sie den Header aus der Originaldatei, um die Kompatibilität in Metadaten sicherzustellen, z point_format und Version.

Ein häufiges Problem tritt jedoch auf, wenn die Anzahl der Punkte im ursprünglichen Header nicht mit den heruntergesampelten Daten übereinstimmt. Um dies zu beheben, verwenden wir die Kopie() Funktion, um eine flache Kopie des ursprünglichen Headers zu erstellen und diese manuell zu ändern point_count Feld, um die Anzahl der Downsampling-Punkte widerzuspiegeln. Nach dem Erstellen des neuen Headers werden die heruntergesampelten Punkte einem neuen zugeordnet LasData Objekt, das die tatsächlichen x-, y- und z-Koordinaten enthält. Schließlich ist die LasData wird als neue LAZ-Datei mit gespeichert schreiben() Verfahren. Dieses Skript ist effizient für Benutzer, die kleinere Datensätze aus größeren Punktwolken extrahieren müssen.

Das zweite Skript erweitert das erste, indem es die Offsets und Skalierungen für heruntergesampelte Daten automatisch neu berechnet. Bei der Arbeit mit Punktwolken sind genaue Offsets von entscheidender Bedeutung, da sie den Ursprung der Daten im 3D-Raum angeben. Der header.offsets Das Attribut wird mit den minimalen X-, Y- und Z-Koordinaten der heruntergerechneten Punkte aktualisiert. Ebenso werden die Skalierungsfaktoren, die sich auf die Genauigkeit der Punktdaten auswirken, mithilfe von festgelegt header.scales Attribut. Dieses Skript minimiert nicht nur die Größe der Punktwolke, sondern stellt auch sicher, dass die Daten präzise und ausgerichtet sind, sodass sie besser für die praktische Verwendung geeignet sind.

Schließlich demonstriert das endgültige Skript Unit-Tests mit Python Unittest Rahmen. In diesem Skript bestimmt ein Testfall, ob die Anzahl der heruntergerechneten Punkte dem vorhergesagten Wert entspricht. Dies ist von entscheidender Bedeutung, um sicherzustellen, dass das Downsampling-Verfahren in allen Kontexten und Datensätzen konsistent funktioniert. Der Testfall wird mit definiert Testfall Klasse, und der Vergleich wird mit der durchgeführt self.assertEqual() Verfahren. Indem wir Tests in den Arbeitsablauf einbeziehen, können wir sicherstellen, dass das Downsampling-Verfahren ordnungsgemäß funktioniert, bevor wir es in größeren Projekten oder Pipelines einsetzen. Dieses Skript hilft Benutzern, Probleme und Inkonsistenzen beim Arbeiten mit mehreren Punktwolkendateien zu vermeiden.

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()

Umgang mit LAS-Dateimetadaten und erweiterten Downsampling-Techniken

Bei der Arbeit mit großen Datensätzen mit lächerlichDie Verwaltung von Metadaten ist ebenso wichtig wie die Verwaltung der tatsächlichen Punktwolkendaten. Aufrechterhaltung der Genauigkeit von LasHeader Werte nach dem Downsampling ist eine erhebliche Schwierigkeit. Da sich die Koordinaten der Punktwolkendaten (x, y und z) ändern, muss der Header diese Änderungen widerspiegeln. Neuberechnung der Offsets erfordert eine Neuberechnung der Mindestwerte für jede Dimension, während die Waage Bestimmen Sie die Genauigkeit der Punktdaten, insbesondere für die Speicherung.

Ein weiterer zu bewertender Faktor ist die Integrität der zusätzlichen Dimensionen in der LAS-Datei. Zusätzliche Bytes werden üblicherweise verwendet, um andere Informationen als die normalen X-, Y- und Z-Koordinaten zu speichern, wie z. B. Intensität oder GPS-Zeit. Wenn der Datensatz diese zusätzlichen Dimensionen enthält, müssen sie beim Downsampling behandelt werden. Sie müssen sicherstellen, dass die Anzahl der Punkte in den zusätzlichen Dimensionen der reduzierten Punktanzahl in den Primärdaten entspricht. Der add_extra_dim Funktionalität in lächerlich ermöglicht das Hinzufügen benutzerdefinierter Dimensionen zum LAS-Header.

Schließlich ist die Geschwindigkeitsoptimierung ein wichtiger Faktor, der beim Downsampling von Punktwolken berücksichtigt werden muss. Während in der Regel menschliche Anpassungen am Header erforderlich sind, lässt sich der Prozess durch effiziente Indizierung und Anwendung von Array-Operationen automatisieren Numpy kann den Prozess erheblich beschleunigen. Durch die Nutzung der Kraft von Numpykönnen Sie riesige Datenmengen schnell verwalten, ohne Einbußen bei der Leistung hinnehmen zu müssen. Dadurch können Sie Lösungen auf größere Projekte erweitern oder sogar Pipelines für die Verarbeitung mehrerer LAZ-Dateien automatisieren.