Reducerea eficientă a fișierelor LAS/LAZ cu Laspy: un ghid pas cu pas

Înțelegerea procesului de subeșantionare a datelor LAS cu Laspy

Când lucrați cu fișiere LAS sau LAZ mari în Python, eșantionarea este esențială pentru o procesare și o analiză eficiente. Laspy, un pachet Python pentru citirea, scrierea și modificarea datelor LAS, oferă numeroase modalități de manipulare a datelor din norul de puncte, cum ar fi crearea și editarea anteturilor LAS.

Acest exemplu arată cum să eșantionați un set de date prin extragerea fiecărui al zecelea punct din a laz fișier și reutilizați unul existent LasHeader. Acest lucru necesită o înțelegere a modului în care anteturile interacționează cu datele, în special atunci când se lucrează cu numere diferite de puncte.

La stabilirea unui nou LasData obiect dintr-un antet existent, utilizatorii întâlnesc frecvent o dimensiune de matrice nepotrivită. Această diferență apare din cauza antetului număr_puncte este posibil să nu se alinieze automat cu noile date.

Provocarea este de a evalua dacă este necesară modificarea manuală a atributelor antetului, cum ar fi offset-uri, scale și point_count, sau dacă există o soluție mai automată. Această postare explică cum să actualizați corect aceste valori atunci când utilizați subeșantionarea Laspy, rezultând un proces eficient.

Optimizarea reducerii eșantionării norului de puncte cu Laspy

Primul script din această postare se concentrează pe downsampling a LAZ fișier, care este necesar pentru gestionarea seturilor de date de nor de puncte mari. Prin importul fișierului original folosind laspy.read() funcția, putem accesa datele punctului și antetul care conține metadate despre norul de puncte. Tehnica de eșantionare implică alegerea fiecărui al zecelea punct, ceea ce minimizează dimensiunea setului de date, păstrând în același timp proprietățile geografice cruciale. Acest lucru se face prin utilizarea np.arange() pentru a construi o serie de indici. După ce alegeți punctele, copiați antetul din fișierul original pentru a asigura compatibilitatea metadatelor, cum ar fi format_punct și versiune.

Cu toate acestea, o problemă comună apare atunci când numărul de puncte din antetul inițial nu corespunde datelor subeșantionate. Pentru a remedia acest lucru, folosim copie() funcția de a face o copie superficială a antetului original și de a modifica manual număr_puncte câmp pentru a reflecta numărul de puncte subeșantionate. După crearea noului antet, punctele subeșantionate sunt alocate unui nou LasData obiect care conține coordonatele reale x, y și z. În cele din urmă, cel LasData este salvat ca un nou fișier LAZ folosind scrie() metodă. Acest script este eficient pentru utilizatorii care trebuie să extragă seturi de date mai mici din nori de puncte mai mari.

Al doilea script îl extinde pe primul prin recalcularea automată a decalajelor și a scalelor pentru datele subeșantionate. Când lucrați cu nori de puncte, este esențial să aveți decalaje precise, deoarece acestea indică originea datelor în spațiul 3D. The antet.decalaje atributul este actualizat cu coordonatele minime x, y și z din punctele subeșantionate. În mod similar, factorii de scară care afectează precizia datelor punctului sunt setați folosind antet.scale atribut. Acest script nu numai că minimizează dimensiunea norului de puncte, dar asigură și că datele sunt precise și aliniate, făcându-le mai potrivite pentru utilizare practică.

În cele din urmă, scriptul final demonstrează testarea unitară cu Python test unitar cadru. În acest script, un caz de testare determină dacă numărul de puncte subeșantionat corespunde valorii prezise. Acest lucru este crucial pentru a ne asigura că procedura de subeșantionare funcționează în mod consecvent în contexte și seturi de date. Cazul de testare este definit folosind TestCase clasa, iar comparația se realizează folosind self.assertEqual() metodă. Prin includerea testării în fluxul de lucru, ne putem asigura că procedura de subeșantionare funcționează corect înainte de a o implementa în proiecte sau conducte mai mari. Acest script îi ajută pe utilizatori să evite problemele și inconsecvențele atunci când lucrează cu mai multe fișiere nor de puncte.

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

Gestionarea metadatelor fișierelor LAS și tehnici avansate de subeșantionare

Când lucrați cu seturi de date uriașe cu laspy, gestionarea metadatelor este la fel de crucială ca și gestionarea datelor reale din norul de puncte. Mentinerea acuratetii a LasHeader valorile după eșantionare reprezintă o dificultate semnificativă. Deoarece coordonatele datelor din norul de puncte (x, y și z) se modifică, antetul trebuie să reflecte aceste modificări. Recalcularea decalaje necesită recalcularea valorilor minime pentru fiecare dimensiune, în timp ce cântare determinați precizia datelor punctuale, în special pentru stocare.

Un alt factor de evaluat este integritatea dimensiunilor suplimentare din fișierul LAS. Octeții suplimentari sunt utilizați în mod obișnuit pentru a păstra alte informații decât coordonatele normale x, y și z, cum ar fi intensitatea sau timpul GPS. Dacă setul de date conține aceste dimensiuni suplimentare, ele trebuie să fie tratate la eșantionare redusă. Trebuie să vă garantați că numărul de puncte din dimensiunile suplimentare corespunde numărului redus de puncte din datele primare. The add_extra_dim funcționalitate în laspy permite adăugarea de dimensiuni personalizate la antetul LAS.

În cele din urmă, optimizarea vitezei este un factor important de luat în considerare la reducerea eșantionării norilor de puncte. În timp ce ajustările umane ale antetului sunt de obicei necesare, automatizarea procesului prin indexarea eficientă și aplicarea operațiunilor de matrice prin numpy poate accelera considerabil procesul. Prin valorificarea puterii de numpy, puteți gestiona rapid seturi de date enorme fără a sacrifica performanța. Acest lucru vă permite să extindeți soluțiile la proiecte mai mari sau chiar să automatizați conductele pentru procesarea mai multor fișiere LAZ.