Downsampling efficiente dei file LAS/LAZ con Laspy: una guida passo passo

Comprendere il processo di downsampling dei dati LAS con Laspy

Quando si lavora con file LAS o LAZ di grandi dimensioni in Python, il downsampling è essenziale per un'elaborazione e un'analisi efficienti. Laspy, un pacchetto Python per leggere, scrivere e modificare i dati LAS, offre numerosi modi per manipolare i dati della nuvola di punti, come la creazione e la modifica delle intestazioni LAS.

Questo esempio mostra come sottocampionare un set di dati estraendo ogni decimo punto da a laz archiviare e riutilizzare un file esistente LasHeader. Ciò richiede la comprensione di come le intestazioni interagiscono con i dati, in particolare quando si lavora con conteggi di punti diversi.

Quando si stabilisce un nuovo LasData oggetto da un'intestazione esistente, gli utenti riscontrano spesso dimensioni dell'array non corrispondenti. Questa disparità si verifica perché l'intestazione conteggio_punti potrebbe non allinearsi automaticamente con i nuovi dati.

La sfida è valutare se è necessario modificare manualmente gli attributi dell'intestazione come offset, scale e point_count o se esiste una soluzione più automatica. Questo post spiega come aggiornare correttamente questi valori durante il downsampling utilizzando Laspy, dando vita ad un processo efficace.

Ottimizzazione del downsampling della nuvola di punti con Laspy

Il primo script in questo post si concentra sul downsampling a LAZ file, necessario per la gestione di set di dati di grandi nuvole di punti. Importando il file originale utilizzando il file laspy.read() funzione, possiamo accedere ai dati dei punti e all'intestazione che contiene i metadati sulla nuvola di punti. La tecnica di downsampling prevede la selezione di ogni decimo punto, riducendo al minimo le dimensioni del set di dati pur mantenendo le proprietà geografiche cruciali. Questo viene fatto utilizzando np.arancio() per costruire un array di indici. Dopo aver selezionato i punti, copia l'intestazione dal file originale per garantire la compatibilità nei metadati, ad esempio formato_punto e versione.

Tuttavia, un problema comune si verifica quando il numero di punti nell'intestazione originale non corrisponde ai dati sottoposti a downsampling. Per risolvere questo problema, utilizziamo il file copia() funzione per creare una copia superficiale dell'intestazione originale e modificare manualmente il file conteggio_punti campo per riflettere il numero di punti sottocampionati. Dopo aver creato la nuova intestazione, i punti sottocampionati vengono allocati in una nuova LasData oggetto che contiene le coordinate x, y e z reali. Infine, il LasData viene salvato come nuovo file LAZ utilizzando l'estensione scrivere() metodo. Questo script è efficace per gli utenti che necessitano di estrarre set di dati più piccoli da nuvole di punti più grandi.

Il secondo script estende il primo ricalcolando automaticamente gli offset e le scale per i dati sottoposti a downsampling. Quando si lavora con le nuvole di punti, avere offset accurati è fondamentale poiché indicano l'origine dei dati nello spazio 3D. IL header.offsets l'attributo viene aggiornato con le coordinate x, yez minime dai punti sottoposti a downsampling. Allo stesso modo, i fattori di scala che influenzano la precisione dei dati punto vengono impostati utilizzando intestazione.scale attributo. Questo script non solo riduce al minimo la dimensione della nuvola di punti, ma garantisce anche che i dati siano precisi e allineati, rendendoli più adatti all'uso pratico.

Infine, lo script finale dimostra il test unitario con Python unittest struttura. In questo script, un test case determina se il conteggio dei punti sottocampionati corrisponde al valore previsto. Ciò è fondamentale per garantire che la procedura di downsampling funzioni in modo coerente tra contesti e set di dati. Il caso di test è definito utilizzando il Caso di prova classe e il confronto viene condotto utilizzando la classe self.assertEqual() metodo. Includendo i test nel flusso di lavoro, possiamo garantire che la procedura di downsampling funzioni correttamente prima di distribuirla a progetti o pipeline più grandi. Questo script aiuta gli utenti a evitare problemi e incoerenze quando lavorano con diversi file di nuvole di punti.

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

Gestione dei metadati dei file LAS e tecniche avanzate di downsampling

Quando si lavora con enormi set di dati con lascivo, la gestione dei metadati è altrettanto cruciale quanto la gestione dei dati effettivi della nuvola di punti. Mantenere l'accuratezza di LasHeader valori dopo il downsampling rappresenta una difficoltà significativa. Poiché le coordinate dei dati della nuvola di punti (x, y e z) cambiano, l'intestazione deve riflettere tali modifiche. Ricalcolando il compensazioni richiede il ricalcolo dei valori minimi per ciascuna dimensione, mentre il scale determinare la precisione dei dati dei punti, in particolare per l'archiviazione.

Un altro fattore da valutare è l'integrità delle dimensioni aggiuntive nel file LAS. I byte aggiuntivi vengono comunemente utilizzati per contenere informazioni diverse dalle normali coordinate x, y e z, come l'intensità o il tempo GPS. Se il set di dati contiene queste dimensioni aggiuntive, devono essere gestite durante il downsampling. È necessario garantire che il numero di punti nelle dimensioni aggiuntive corrisponda al conteggio dei punti ridotto nei dati primari. IL aggiungi_extra_dim funzionalità dentro lascivo consente l'aggiunta di dimensioni personalizzate all'intestazione LAS.

Infine, l’ottimizzazione della velocità è un fattore importante da considerare quando si effettua il downsampling delle nuvole di punti. Sebbene in genere siano necessarie modifiche umane all'intestazione, l'automazione del processo sfrutta l'indicizzazione efficiente e applica operazioni di array tramite insensato può accelerare notevolmente il processo. Sfruttando il potere di intorpidito, puoi gestire rapidamente enormi set di dati senza sacrificare le prestazioni. Ciò consente di espandere le soluzioni a progetti più grandi o persino di automatizzare le pipeline per l'elaborazione di più file LAZ.