Effektiv nedsampling av LAS/LAZ-filer med Laspy: en steg-för-steg-guide

Förstå processen för nedsampling av LAS-data med Laspy

När du arbetar med stora LAS- eller LAZ-filer i Python är nedsampling avgörande för effektiv bearbetning och analys. Laspy, ett Python-paket för att läsa, skriva och ändra LAS-data, erbjuder många sätt att manipulera punktmolndata, som att skapa och redigera LAS-rubriker.

Det här exemplet visar hur man nedsamplar en datauppsättning genom att extrahera var tionde punkt från en laz fil och återanvänd en befintlig LasHeader. Detta kräver en förståelse för hur rubriker interagerar med data, särskilt när man arbetar med olika poängräkningar.

Vid etablering av en ny LasData objekt från en befintlig rubrik, stöter användare ofta på en arraystorlek som inte matchar. Denna skillnad uppstår eftersom rubriken är poäng_antal kanske inte automatiskt anpassas till de nya uppgifterna.

Utmaningen är att utvärdera om det krävs att manuellt ändra rubrikattribut som offsets, skalor och point_count, eller om det finns en mer automatisk lösning. Det här inlägget förklarar hur du korrekt uppdaterar dessa värden vid nedsampling med hjälp av Laspy, vilket resulterar i en effektiv process.

Optimera Point Cloud Downsampling med Laspy

Det första manuset i det här inlägget fokuserar på nedsampling a LAZ fil, som är nödvändig för att hantera stora punktmolnsuppsättningar. Genom att importera originalfilen med hjälp av laspy.read() funktion kan vi komma åt punktdata och rubriken som innehåller metadata om punktmolnet. Nedsamplingstekniken innebär att man väljer var tionde punkt, vilket minimerar datasetets storlek samtidigt som viktiga geografiska egenskaper bibehålls. Detta görs genom att använda np.arange() att bygga en rad index. Efter att ha valt poäng, kopiera rubriken från originalfilen för att säkerställa kompatibilitet i metadata, som t.ex punktformat och version.

Ett vanligt problem uppstår dock när antalet punkter i den ursprungliga rubriken inte motsvarar den nedsamplade datan. För att fixa detta använder vi kopiera() funktion för att göra en ytlig kopia av originalhuvudet och manuellt ändra poäng_antal fältet för att återspegla antalet nedsamplade punkter. Efter att ha skapat den nya rubriken tilldelas de nedsamplade poängen till en ny LasData objekt som innehåller de verkliga x-, y- och z-koordinaterna. Slutligen, den LasData sparas som en ny LAZ-fil med hjälp av skriva() metod. Det här skriptet är effektivt för användare som behöver extrahera mindre datamängder från större punktmoln.

Det andra skriptet utökar det första genom att automatiskt räkna om offseten och skalorna för nedsamplade data. När du arbetar med punktmoln är det viktigt att ha exakta förskjutningar eftersom de indikerar ursprunget för data i 3D-rymden. De header.offsets attribut uppdateras med minsta x-, y- och z-koordinater från nedsamplade punkter. På liknande sätt ställs skalfaktorerna som påverkar punktdatas precision med hjälp av header.scales attribut. Det här skriptet minimerar inte bara storleken på punktmolnet, utan det säkerställer också att data är exakta och justerade, vilket gör den mer lämpad för praktisk användning.

Slutligen visar det slutliga skriptet enhetstestning med Pythons enhetstest ram. I det här skriptet avgör ett testfall om antalet nedsamplade poäng motsvarar det förutsagda värdet. Detta är avgörande för att säkerställa att nedsamplingsproceduren fungerar konsekvent över sammanhang och datauppsättningar. Testfallet definieras med hjälp av TestCase klass, och jämförelsen utförs med hjälp av self.assertEqual() metod. Genom att inkludera testning i arbetsflödet kan vi säkerställa att nedsamplingsproceduren fungerar korrekt innan den distribueras till större projekt eller pipelines. Det här skriptet hjälper användare att undvika problem och inkonsekvenser när de arbetar med flera punktmolnfiler.

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

Hantering av LAS-filmetadata och avancerade nedsamplingstekniker

När du arbetar med stora datamängder med lapig, är hantering av metadata lika viktigt som att hantera faktiska punktmolndata. Upprätthålla noggrannheten av LasHeader värden efter nedsampling är en betydande svårighet. Eftersom punktmolnsdatas koordinater (x, y och z) ändras måste rubriken återspegla dessa ändringar. Omräkning av offset kräver omräkning av minimivärdena för varje dimension, medan vågar bestämma precisionen för punktdata, speciellt för lagring.

En annan faktor att utvärdera är integriteten hos de ytterligare dimensionerna i LAS-filen. Extra byte används vanligtvis för att hålla annan information än de normala x-, y- och z-koordinaterna, såsom intensitet eller GPS-tid. Om datasetet innehåller dessa extra dimensioner måste de hanteras vid nedsampling. Du måste garantera att antalet poäng i de extra dimensionerna motsvarar det reducerade poängantalet i primärdata. De add_extra_dim funktionalitet i lapig möjliggör tillägg av anpassade dimensioner till LAS-huvudet.

Slutligen är hastighetsoptimering en viktig faktor att tänka på vid nedsampling av punktmoln. Medan mänskliga justeringar av rubriken vanligtvis krävs, automatisera processen genom att utnyttja effektiv indexering och tillämpa array-operationer via numpy kan påskynda processen avsevärt. Genom att utnyttja kraften i numpy, kan du snabbt hantera enorma datamängder utan att offra prestanda. Detta gör att du kan utöka lösningar till större projekt eller till och med automatisera pipelines för att bearbeta flera LAZ-filer.