LAS/LAZ-bestanden efficiënt downsamplen met Laspy: een stapsgewijze handleiding

Inzicht in het proces van het downsamplen van LAS-gegevens met Laspy

Bij het werken met grote LAS- of LAZ-bestanden in Python is downsampling essentieel voor efficiënte verwerking en analyse. Laspy, een Python-pakket voor het lezen, schrijven en wijzigen van LAS-gegevens, biedt talloze manieren om puntenwolkgegevens te manipuleren, zoals het maken en bewerken van LAS-headers.

Dit voorbeeld laat zien hoe u een gegevensset kunt downsamplen door elk tiende punt uit a te extraheren lui bestand en hergebruik een bestaand bestand LasHeader. Dit vereist inzicht in de manier waarop headers omgaan met gegevens, vooral als er met verschillende puntentellingen wordt gewerkt.

Bij het opzetten van een nieuwe LasData object uit een bestaande header, komen gebruikers vaak niet-overeenkomende arraygroottes tegen. Deze ongelijkheid treedt op omdat de header's punt_telling komt mogelijk niet automatisch overeen met de nieuwe gegevens.

De uitdaging is om te evalueren of het nodig is om headerkenmerken zoals offsets, scales en point_count handmatig te wijzigen, of dat er een meer automatische oplossing is. In dit bericht wordt uitgelegd hoe u deze waarden correct kunt bijwerken bij het downsamplen met behulp van Laspy, resulterend in een effectief proces.

Point Cloud-downsampling optimaliseren met Laspy

Het eerste script in dit bericht richt zich op het downsamplen van a LAZ -bestand, dat nodig is voor het beheren van grote puntenwolkdatasets. Door het originele bestand te importeren met behulp van de laspy.read() functie hebben we toegang tot de puntgegevens en de header die metadata over de puntenwolk bevat. Bij de downsamplingtechniek wordt elk tiende punt gekozen, waardoor de omvang van de dataset wordt geminimaliseerd, terwijl cruciale geografische eigenschappen behouden blijven. Dit gebeurt door gebruik te maken van np.arange() om een ​​reeks indices samen te stellen. Nadat u de punten heeft gekozen, kopieert u de koptekst van het originele bestand om compatibiliteit in metagegevens te garanderen, zoals punt_formaat en versie.

Er doet zich echter een veelvoorkomend probleem voor wanneer het aantal punten in de oorspronkelijke header niet overeenkomt met de gedownsamplede gegevens. Om dit op te lossen gebruiken we de kopiëren() functie om een ​​ondiepe kopie van de originele header te maken en de punt_telling veld om het aantal gedownsampelde punten weer te geven. Nadat de nieuwe kop is gemaakt, worden de gedownsamplede punten toegewezen aan een nieuwe LasData object dat de echte x-, y- en z-coördinaten bevat. Tenslotte de LasData wordt opgeslagen als een nieuw LAZ-bestand met behulp van de schrijven() methode. Dit script is efficiënt voor gebruikers die kleinere datasets uit grotere puntenwolken moeten halen.

Het tweede script breidt het eerste uit door automatisch de offsets en schalen voor gedownsampelde gegevens opnieuw te berekenen. Bij het werken met puntenwolken is het hebben van nauwkeurige offsets van cruciaal belang, omdat deze de oorsprong van de gegevens in de 3D-ruimte aangeven. De header.offsets attribuut wordt bijgewerkt met de minimale x-, y- en z-coördinaten van gedownsampelde punten. Op dezelfde manier worden de schaalfactoren die de nauwkeurigheid van de puntgegevens beïnvloeden, ingesteld met behulp van de header.schalen attribuut. Dit script minimaliseert niet alleen de grootte van de puntenwolk, maar zorgt er ook voor dat de gegevens nauwkeurig en uitgelijnd zijn, waardoor deze beter geschikt zijn voor praktisch gebruik.

Ten slotte demonstreert het uiteindelijke script het testen van eenheden met Python unittest kader. In dit script bepaalt een testcase of het gedownsamplede aantal punten overeenkomt met de voorspelde waarde. Dit is van cruciaal belang om ervoor te zorgen dat de downsampling-procedure consistent presteert in alle contexten en datasets. Het testgeval wordt gedefinieerd met behulp van de Testcase klasse, en de vergelijking wordt uitgevoerd met behulp van de self.assertEqual() methode. Door testen in de workflow op te nemen, kunnen we ervoor zorgen dat de downsampling-procedure goed werkt voordat we deze inzetten voor grotere projecten of pijplijnen. Dit script helpt gebruikers problemen en inconsistenties te voorkomen bij het werken met verschillende puntenwolkbestanden.

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

Omgaan met metagegevens van LAS-bestanden en geavanceerde downsamplingtechnieken

Bij het werken met enorme datasets met lasachtig, is het beheren van metadata net zo cruciaal als het beheren van de daadwerkelijke puntenwolkgegevens. Het bijhouden van de nauwkeurigheid van LasHeader waarden na downsampling is een aanzienlijk probleem. Omdat de coördinaten van de puntenwolkgegevens (x, y en z) veranderen, moet de header deze veranderingen weerspiegelen. Het herberekenen van de compensaties vereist het herberekenen van de minimumwaarden voor elke dimensie, terwijl de schubben bepaal de nauwkeurigheid van de puntgegevens, vooral voor opslag.

Een andere factor die moet worden geëvalueerd, is de integriteit van de extra dimensies in het LAS-bestand. Extra bytes worden vaak gebruikt om andere informatie dan de normale x-, y- en z-coördinaten vast te houden, zoals intensiteit of GPS-tijd. Als de dataset deze extra dimensies bevat, moeten deze bij het downsamplen worden afgehandeld. U moet garanderen dat het aantal punten in de extra dimensies overeenkomt met het verminderde puntenaantal in de primaire gegevens. De voeg_extra_dim toe functionaliteit bij lasachtig maakt de toevoeging van aangepaste afmetingen aan de LAS-header mogelijk.

Ten slotte is snelheidsoptimalisatie een belangrijke factor waarmee rekening moet worden gehouden bij het downsamplen van puntenwolken. Hoewel doorgaans menselijke aanpassingen aan de header vereist zijn, is het automatiseren van het proces door gebruik te maken van efficiënte indexering en het toepassen van array-bewerkingen via numpig kan het proces aanzienlijk versnellen. Door gebruik te maken van de kracht van numpig, kunt u snel enorme datasets beheren zonder dat dit ten koste gaat van de prestaties. Hierdoor kunt u oplossingen uitbreiden naar grotere projecten of zelfs pijplijnen automatiseren voor het verwerken van meerdere LAZ-bestanden.