Reducció de mostreig eficient dels fitxers LAS/LAZ amb Laspy: una guia pas a pas

Entendre el procés de reducció de mostreig de dades LAS amb Laspy

Quan es treballa amb fitxers LAS o LAZ grans a Python, la reducció de mostres és essencial per a un processament i anàlisi eficients. Laspy, un paquet de Python per llegir, escriure i modificar dades LAS, ofereix nombroses maneres de manipular les dades del núvol de punts, com ara la creació i l'edició de capçaleres LAS.

Aquest exemple mostra com es pot reduïr la mostra d'un conjunt de dades extraient cada desè punt d'a mandra fitxer i reutilitzar un existent LasHeader. Això requereix una comprensió de com les capçaleres interactuen amb les dades, especialment quan es treballa amb diferents recomptes de punts.

En establir un nou LasData objecte d'una capçalera existent, els usuaris sovint es troben amb una mida de matriu que no coincideix. Aquesta disparitat es produeix perquè la capçalera nombre_de_punts pot no estar alineat automàticament amb les dades noves.

El repte és avaluar si cal modificar manualment els atributs de la capçalera, com ara els desplaçaments, les escales i el nombre de punts, o si hi ha una solució més automàtica. En aquesta publicació s'explica com actualitzar correctament aquests valors quan es redueix el mostreig Laspy, donant lloc a un procés eficaç.

Optimització de la submostreig del núvol de punts amb Laspy

El primer script d'aquesta publicació se centra en la reducció de mostreig a LAZ fitxer, que és necessari per gestionar grans conjunts de dades de núvols de punts. En importar el fitxer original amb el fitxer laspy.read() funció, podem accedir a les dades del punt i a la capçalera que conté metadades sobre el núvol de punts. La tècnica de mostreig inferior consisteix a escollir cada desè punt, la qual cosa minimitza la mida del conjunt de dades tot conservant les propietats geogràfiques crucials. Això es fa utilitzant np.arange() per construir una sèrie d'índexs. Després d'escollir els punts, copieu la capçalera del fitxer original per garantir la compatibilitat de les metadades, com ara format_punt i versió.

Tanmateix, es produeix un problema comú quan el nombre de punts de la capçalera original no es correspon amb les dades reduïdes. Per solucionar-ho, fem servir el copiar () funció per fer una còpia superficial de la capçalera original i modificar manualment el fitxer nombre_de_punts camp per reflectir el nombre de punts reduïts. Després de crear la nova capçalera, els punts reduïts s'assignen a una nova LasData objecte que conté les coordenades reals x, y i z. Finalment, el LasData es desa com a fitxer LAZ nou mitjançant el fitxer escriure () mètode. Aquest script és eficient per als usuaris que necessiten extreure conjunts de dades més petits de núvols de punts més grans.

El segon script amplia el primer recalculant automàticament els desplaçaments i les escales de les dades reduïdes. Quan es treballa amb núvols de punts, tenir desplaçaments precisos és fonamental, ja que indiquen l'origen de les dades a l'espai 3D. El capçalera.desplaçaments L'atribut s'actualitza amb les coordenades mínimes x, y i z dels punts reduïts. De la mateixa manera, els factors d'escala que afecten la precisió de les dades puntuals s'estableixen mitjançant el capçalera.escales atribut. Aquest script no només minimitza la mida del núvol de punts, sinó que també assegura que les dades siguin precises i alineades, la qual cosa la fa més adequada per a un ús pràctic.

Finalment, l'script final demostra les proves unitàries amb Python test unitari marc. En aquest script, un cas de prova determina si el recompte de punts reduïts correspon al valor previst. Això és crucial per garantir que el procediment de reducció de mostreig funciona de manera coherent en contextos i conjunts de dades. El cas de prova es defineix mitjançant el TestCase classe, i la comparació es realitza mitjançant el self.assertEqual() mètode. En incloure les proves al flux de treball, podem assegurar-nos que el procediment de mostreig inferior funciona correctament abans de desplegar-lo en projectes o canalitzacions més grans. Aquest script ajuda els usuaris a evitar problemes i inconsistències quan treballen amb diversos fitxers de núvols de punts.

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

Maneig de les metadades de fitxers LAS i tècniques avançades de submostreig

Quan es treballa amb grans conjunts de dades amb laspy, la gestió de les metadades és tan important com la gestió de les dades reals del núvol de punts. Mantenint la precisió de LasHeader valors després de la reducció de mostreig és una dificultat important. Com que les coordenades del núvol de punts (x, y i z) canvien, la capçalera ha de reflectir aquests canvis. Recalculant el compensacions requereix recalcular els valors mínims per a cada dimensió, mentre que el escales determinar la precisió de les dades puntuals, especialment per a l'emmagatzematge.

Un altre factor a avaluar és la integritat de les dimensions addicionals del fitxer LAS. Els bytes addicionals s'utilitzen habitualment per contenir informació diferent de les coordenades x, y i z normals, com ara la intensitat o el temps GPS. Si el conjunt de dades conté aquestes dimensions addicionals, s'han de gestionar quan es redueix el mostreig. Heu de garantir que el nombre de punts de les dimensions addicionals correspon al nombre de punts reduït de les dades primàries. El add_extra_dim funcionalitat en laspy permet afegir dimensions personalitzades a la capçalera LAS.

Finalment, l'optimització de la velocitat és un factor important a tenir en compte a l'hora de reduir el mostreig dels núvols de punts. Tot i que normalment es requereixen ajustaments humans a la capçalera, automatitzar el procés aprofitant una indexació eficient i aplicant operacions de matriu mitjançant numpy pot accelerar considerablement el procés. Aprofitant el poder de numpy, podeu gestionar ràpidament grans conjunts de dades sense sacrificar el rendiment. Això us permet ampliar solucions a projectes més grans o fins i tot automatitzar canalitzacions per processar diversos fitxers LAZ.