Redução eficiente da resolução de arquivos LAS/LAZ com Laspy: um guia passo a passo

Compreendendo o processo de redução da resolução de dados LAS com Laspy

Ao trabalhar com grandes arquivos LAS ou LAZ em Python, a redução da resolução é essencial para processamento e análise eficientes. Laspy, um pacote Python para leitura, gravação e alteração de dados LAS, oferece inúmeras maneiras de manipular dados de nuvem de pontos, como criação e edição de cabeçalhos LAS.

Este exemplo mostra como reduzir a resolução de um conjunto de dados extraindo cada décimo ponto de um preguiçoso arquivar e reutilizar um existente LasHeader. Isso requer uma compreensão de como os cabeçalhos interagem com os dados, principalmente ao trabalhar com diferentes contagens de pontos.

Ao estabelecer um novo LasData objeto de um cabeçalho existente, os usuários frequentemente encontram tamanhos de array incompatíveis. Essa disparidade ocorre porque o cabeçalho contagem_pontos pode não se alinhar automaticamente com os novos dados.

O desafio é avaliar se é necessário modificar manualmente os atributos do cabeçalho, como deslocamentos, escalas e point_count, ou se existe uma solução mais automática. Esta postagem explica como atualizar corretamente esses valores ao reduzir a resolução usando Laspy, resultando em um processo eficaz.

Otimizando a redução da resolução da nuvem de pontos com Laspy

O primeiro script desta postagem se concentra na redução da resolução de um LAZ arquivo, que é necessário para gerenciar conjuntos de dados de nuvem de pontos grandes. Ao importar o arquivo original usando o laspy.read() função, podemos acessar os dados do ponto e o cabeçalho que contém metadados sobre a nuvem de pontos. A técnica de redução da resolução envolve escolher cada décimo ponto, o que minimiza o tamanho do conjunto de dados, ao mesmo tempo que mantém propriedades geográficas cruciais. Isso é feito usando np.arange() para construir uma matriz de índices. Após escolher os pontos, copie o cabeçalho do arquivo original para garantir compatibilidade nos metadados, como formato_ponto e versão.

No entanto, um problema comum ocorre quando o número de pontos no cabeçalho original não corresponde aos dados com amostragem reduzida. Para corrigir isso, usamos o cópia() função para fazer uma cópia superficial do cabeçalho original e modificar manualmente o contagem_pontos campo para refletir o número de pontos reduzidos. Depois de criar o novo cabeçalho, os pontos reduzidos são alocados para um novo LasData objeto que contém as coordenadas reais x, y e z. Finalmente, o LasData é salvo como um novo arquivo LAZ usando o escrever() método. Este script é eficiente para usuários que precisam extrair conjuntos de dados menores de nuvens de pontos maiores.

O segundo script estende o primeiro recalculando automaticamente os deslocamentos e escalas para dados com amostragem reduzida. Ao trabalhar com nuvens de pontos, é fundamental ter deslocamentos precisos, pois eles indicam a origem dos dados no espaço 3D. O cabeçalho.offsets O atributo é atualizado com as coordenadas mínimas x, y e z dos pontos com amostragem reduzida. Da mesma forma, os fatores de escala que afetam a precisão dos dados do ponto são definidos usando o método cabeçalho.escalas atributo. Este script não só minimiza o tamanho da nuvem de pontos, mas também garante que os dados sejam precisos e alinhados, tornando-os mais adequados para uso prático.

Finalmente, o script final demonstra testes unitários com Python teste unitário estrutura. Neste script, um caso de teste determina se a contagem de pontos com amostragem reduzida corresponde ao valor previsto. Isto é crucial para garantir que o procedimento de redução da resolução funcione de forma consistente em todos os contextos e conjuntos de dados. O caso de teste é definido usando o Caso de teste classe, e a comparação é realizada usando o self.assertEqual() método. Ao incluir testes no fluxo de trabalho, podemos garantir que o procedimento de redução da resolução funcione corretamente antes de implantá-lo em projetos ou pipelines maiores. Este script ajuda os usuários a evitar problemas e inconsistências ao trabalhar com vários arquivos de nuvem de pontos.

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

Tratamento de metadados de arquivos LAS e técnicas avançadas de redução da resolução

Ao trabalhar com grandes conjuntos de dados com laspy, o gerenciamento de metadados é tão crucial quanto o gerenciamento dos dados reais da nuvem de pontos. Mantendo a precisão de LasHeader valores após a redução da resolução é uma dificuldade significativa. Como as coordenadas dos dados da nuvem de pontos (x, y e z) mudam, o cabeçalho deve refletir essas alterações. Recalculando o compensações requer recalcular os valores mínimos para cada dimensão, enquanto o escalas determinar a precisão dos dados do ponto, especialmente para armazenamento.

Outro fator a avaliar é a integridade das dimensões adicionais no arquivo LAS. Bytes extras são comumente usados ​​para armazenar informações diferentes das coordenadas normais x, y e z, como intensidade ou tempo de GPS. Se o conjunto de dados contiver essas dimensões extras, elas deverão ser tratadas durante a redução da resolução. Você deve garantir que o número de pontos nas dimensões extras corresponda à contagem reduzida de pontos nos dados primários. O add_extra_dim funcionalidade em laspy permite a adição de dimensões personalizadas ao cabeçalho LAS.

Finalmente, a otimização da velocidade é um fator importante a ser considerado ao reduzir a resolução de nuvens de pontos. Embora normalmente sejam necessários ajustes humanos no cabeçalho, automatizar o processo aproveitando a indexação eficiente e aplicando operações de array por meio de entorpecido pode acelerar consideravelmente o processo. Ao aproveitar o poder de entorpecido, você pode gerenciar rapidamente enormes conjuntos de dados sem sacrificar o desempenho. Isso permite expandir soluções para projetos maiores ou até mesmo automatizar pipelines para processar vários arquivos LAZ.