Conjunto de ferramentas para manipular dados

Pacote ‘lidR’18 de janeiro de 2021Tipo de pacoteTítulo Manipulação e Visualização de Dados Aerotransportados LiDAR para SilviculturaFormuláriosVersão 3.1.0Data 2021-01-15Descrição Interface aerotransportada LiDAR (detecção de luz e alcance) para dadosmanipulação e visualização. Ler / escrever arquivos ‘las’ e ‘laz’, computaçãode métricas na abordagem baseada em área, filtragem de pontos, redução artificial de pontos,classificação de dados geográficos, normalização, segmentação de árvore individuale outras manipulações.URL https://github.com/Jean-Romain/lidRBugReports https://github.com/Jean-Romain/lidR/issuesLicença GPL-3Depende de R (> = 3.1.0), métodos, raster, sp (> = 1.4.2)Importa data.table (> = 1.12.0), future, geometry, glue, grDevices,lazyeval, Rcpp (> = 1.0.3), RCSF, rgeos, rgdal (> = 1.4.8), rgl,rlas (> = 1.3.5), sf, estatísticas, ferramentas, utilitáriosSugere EBImage, concaveman, crayon, gstat, hexbin, mapview, mapedit,progresso, teste que (> = 2.1.0), knitr, rmarkdown, covrLazyData trueRoxygenNote 7.1.1LinkingTo BH (> = 1.72.0), Rcpp, RcppArmadilloCodificando UTF-8ByteCompile trueKnitr VignetteBuilderbiocViewsAgrupe ‘Class-LASheader.R’ ‘Class-LAS.R’ ‘Class-LAScatalog.R”Class-LAScluster.R’ ‘RcppExports.R’ ‘add_attribute.R”algoritmo-dec.R’ ‘algoritmo-dsm.R’ ‘algoritmo-gnd.R’1

2Tópicos R documentados:’algoritmo-itd.R’ ‘algoritmo-its.R’ ‘algoritmo-noi.R”algoritmo-saída.R’ ‘algoritmo-shp.R’ ‘algoritmo-obstáculo.R”algoritmo-spi.R’ ‘algoritmo-trk.R’ ‘catalog_apply.R”catalog_fakerun.R’ ‘catalog_index.R’ ‘catalog_intersect.R”catalog_laxindex.R’ ‘catalog_makecluster.R”catalog_merge_results.R’ ‘catalog_overlaps.R”catalog_retile.R’ ‘catalog_select.R’ ‘classify_ground.R”classify_noise.R’ ‘clip_roi.R’ ‘cloud_metrics.R”clusters_apply.R’ ‘decimate_points.R’ ‘delineate_crowns.R”deprecated.R’ ‘doc-drivers.R’ ‘doc-lidR.R’ ‘doc-parallelism.R”filter_duplicates.R’ ‘filter_poi.R’ ‘filter_roi.R”filter_surfacepoints.R’ ‘find_localmaxima.R’ ‘find_trees.R”generate_las.R’ ‘grid_canopy.R’ ‘grid_density.R”grid_metrics.R’ ‘grid_terrain.R’ ‘hexbin_metrics.R”io_readLAS.R’ ‘io_readLAScatalog.R’ ‘io_readXLAS.R”io_writeANY.R’ ‘io_writeLAS.R’ ‘las_check.R’ ‘las_tools.R”merge_las.R’ ‘merge_spatial.R’ ‘methods-LAS.R”methods-LAScatalog.R’ ‘methods-LAScluster.R”methods-LASheader.R’ ‘normalize_height.R”normalize_intensity.R’ ‘plot.R’ ‘plot.s3.R’ ‘point_metrics.R”print.R’ ‘projection.R’ ‘retrieve_info.R’ ‘segment_shapes.R”segment_snags.R’ ‘segment_trees.R’ ‘sensor_tracking.R”smooth_height.R’ ‘tree_metrics.R’ ‘utils_assertive.R”utils_catalog_options.R’ ‘utils_colors.R”utils_define_constant.R’ ‘utils_delaunay.R’ ‘utils_geometry.R”utils_is.R’ ‘utils_metrics.R’ ‘utils_misc.R’ ‘utils_raster.R”utils_spatial_index.R’ ‘utils_threads.R’ ‘utils_typecast.R”voxel_metrics.R’ ‘voxelize_points.R’ ‘zzz.R’NeedsCompilation simAutor Jean-Romain Roussel [aut, cre, cph],David Auty [aut, ctb] (analisa a documentação),Florian De Boissieu [ctb] (bugs corrigidos e recursos de catálogo aprimorados),Andrew Sánchez Meador [ctb] (Wing2015 implementado () parasegment_snags ()),Bourdon Jean-François [ctb] (Contribuído para Roussel2020 () paratrack_sensor ()),Gatziolis Demetrios [ctb] (Implementado Gatziolis2019 () paratrack_sensor ())Mantenedor Jean-Romain Roussel <jean-romain.roussel.1@ulaval.ca>Repositório CRANData / Publicação 2021-01-18 17:30:02 UTCTópicos R documentados:lidR-package. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .5add_attribute. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6

Tópicos R documentados:3área . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .8as.list.LASheader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9as.spatial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10asprs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10catalog_apply. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12catalog_intersect. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16catalog_makechunks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17catalog_options_tools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18catalog_retile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19catalog_select. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21classify_ground. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22classify_noise. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24clipe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25cloud_metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28csf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30dalponte2016. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31decimate_points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33delineate_crowns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34descontinuada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36dsmtin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40entropia. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41extensão, método LAS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42filtros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43filter_duplicates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44filter_poi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45filter_surfacepoints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46find_localmaxima. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47find_trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48gap_fraction_profile. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50Gatziolis2019. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51grid_canopy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52grid_density. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53grid_metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55grid_terrain. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58hexbin_metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60Altíssima . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61homogeneizar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62é. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63ivf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64knnidw. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65krigagem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66LAD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67Classe LAS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68Classe LAScatalog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70LASheader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Classe LASheader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74las_check. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74las_utilities. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

4Tópicos R documentados:li2012. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77lidR-LAScatalog-drivers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78paralelismo lidR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80lidR-índice espacial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83lidrpalettes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86lmf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87manual. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88merge_spatial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89normalize_height. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90normalize_intensity. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93p2r. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95pitfree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96enredo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97plot.lasmetrics3d. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99plot_3d. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100pmf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102point_metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103impressão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106projeção. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106aleatória . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109range_correction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110rbind.LAS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111readLAS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111readLAScatalog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113readLASheader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115retrieve_pulses. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116Roussel2020. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117rumple_index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118segment_shapes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119segment_snags. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120segment_trees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122set_lidr_threads. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124shape_detection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125silva2016. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126smooth_height. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127sor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128stdmetrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129lata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133track_sensor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134tree_metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136util_makeZhangParam. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139VCI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140voxelize_points. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141voxel_metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142bacia hidrográfica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144wing2015. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145writeLAS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147$ <-, método LAS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

pacote lidR5Índice150pacote lidRlidR: LiDAR aerotransportado para aplicações florestaisDescriçãolidR fornece um conjunto de ferramentas para manipular dados LiDAR aerotransportados em contextos florestais. O pacotefunciona essencialmente com arquivos .las ou .laz. A caixa de ferramentas inclui algoritmos para DSM, CHM, DTM,ABA, normalização, detecção de árvore, segmentação de árvore e outras ferramentas, bem como um motor paracesso amplas coberturas LiDAR divididas em muitos arquivos.DetalhesPara saber mais sobre lidR, comece com as vinhetas: browseVignettes (pacote = “lidR”). Os usuários podemtambém encontre documentação suplementar não oficial nas páginas wiki do github. Para perguntar “como” questionarções, pergunte em gis.stackexchange.com com a tag lidr.Opções de pacotelidR.progress Várias funções têm uma barra de progresso para operações longas (mas não todas). Devemosas operações demoradas mostram uma barra de progresso? Padrão: TRUElidR.progress.delay A barra de progresso aparece apenas para operações longas. Depois de quantos segundosonds de computação a barra de progresso aparece? Padrão: 2lidR.verbose Torna o pacote detalhado. Padrão: FALSElidR.buildVRT As funções grid_ * podem escrever os rasters sequencialmente no disco e carregar de voltaum mosaico raster virtual (VRT) em vez da lista de arquivos gravados. Deve ser construído um VRT?Padrão: TRUEAutor (es)Mantenedor: Jean-Romain Roussel <jean-romain.roussel.1@ulaval.ca> [detentor dos direitos autorais]Autores:• David Auty (analisa a documentação) [contribuidor]Outros contribuidores:• Florian De Boissieu (bugs corrigidos e recursos de catálogo aprimorados) [contribuidor]• Andrew Sánchez Meador (Wing2015 implementado () para segment_snags ()) [contribuidor]• Bourdon Jean-François (Contribuído para Roussel2020 () para track_sensor ()) [contribuidor]• Gatziolis Demetrios (Implementado Gatziolis2019 () para track_sensor ()) [contribuidor]Veja tambémLinks Úteis:• https://github.com/Jean-Romain/lidR• Relate bugs em https://github.com/Jean-Romain/lidR/issues

6add_attributeadd_attributeAdicionar atributos em um objeto LASDescriçãoUm objeto LAS representa um arquivo las em R. De acordo com as especificações LAS, um arquivo las contém umnúcleo de atributos definidos, como coordenadas XYZ, intensidade, número de retorno e assim por diante, para cadaponto. É possível adicionar atributos suplementares.Usoadd_attribute (las, x, nome)add_lasattribute (las, x, nome, desc)add_lasattribute_manual (las,x,nome,desc,tipo,deslocamento = NULL,escala = NULL,NA_value = NULL)add_lasrgb (las, R, G, B)remove_lasattribute (las, nome)ArgumentoslasUm objeto da classe LASxum vetor que precisa ser adicionado ao objeto LAS. Para add_lasattribute * itpode estar faltando (ver detalhes).nomepersonagem. O nome do atributo de bytes extras a ser adicionado ao arquivo.descpersonagem. Uma breve descrição do atributo de bytes extras para adicionar no arquivo (32personagens).tipopersonagem. O tipo de dados do atributo de bytes extras. Pode ser “uchar”, “char”, “ushort”, “short”, “uint”, “int”, “uiescala, deslocamentonumérico. A escala e deslocamento dos dados. NULL se não for relevante.NA_valuenumérico ou inteiro. NA não é um valor válido em um arquivo las. Na hora de escrever isso vaiser substituído por este valor que será considerado NA. NULL se não for relevante.R, G, Binteiro. Valores RGB

add_attribute7DetalhesOs usuários não podem atribuir nomes iguais aos nomes dos atributos principais. Essas funções sãodedicado a adicionar dados que não fazem parte da especificação LAS. Por exemplo, add_lasattribute (las, x, “R”)irá falhar porque R é um nome reservado para o canal vermelho de um arquivo .las que contém atributos RGB.Use add_lasrgb em vez disso.add_attribute Simplesmente adiciona uma nova coluna nos dados, mas não atualiza o cabeçalho. Então, oO objeto LAS não é estritamente válido. Esses dados serão temporariamente utilizáveis ​​no nível R, mas serãonão ser escrito em um arquivo las com writeLAS.add_lasattribute Faz o mesmo que add_attribute, mas atualiza automaticamente o cabeçalho doObjeto LAS. Assim, o objeto LAS é válido e os novos dados são considerados “bytes extras”.Esses novos dados serão gravados em um arquivo las com writeLAS.add_lasattribute_manual Permite ao usuário gravar manualmente todos os metadados de bytes extras. estefunção é reservada para usuários experientes com um bom conhecimento das especificações LASções. A função não realiza testes para verificar a validade das informações. Quandousando add_lasattribute e add_lasattribute_manual, x só pode ser do tipo numérico,(inteiro ou duplo). Não pode ser do tipo caractere ou lógico, pois não são suportadospelas especificações LAS. Os tipos que são suportados em lidR são os tipos 0 a 10 (Tabela 24 empágina 25 da especificação). Tipos maiores que 10 não são suportados.add_lasrgb Adiciona 3 colunas chamadas RGB e atualiza o formato do ponto do objeto LAS para umformato que suporta atributos RGB. Se os valores RGB estão variando de 0 a 255, eles sãodimensionado automaticamente em 16 bits.ValorUm objeto da classe LASExemplosLASfile <- system.file (“extdata”, “exemplo.laz”, pacote = “rlas”)las <- readLAS (arquivo LAS, select = “xyz”)imprimir (las)imprimir (las @ cabeçalho)x <- 1:30las <- add_attribute (las, x, “mydata”)imprimir (las)# O objeto las tem um novo atributo chamado “mydata”print (las @ header) # Mas o cabeçalho não foi atualizado. Esses novos dados não serão gravadoslas <- add_lasattribute (las, x, “mydata2”, “A new data”)imprimir (las)# O objeto las tem um novo atributo chamado “mydata2″print (las @ header) # O cabeçalho foi atualizado. Esses novos dados serão gravados# Opcionalmente, se os dados já estiverem no objeto LAS, você pode atualizar o cabeçalho pulando o# parâmetro xlas <- add_lasattribute (las, name = “mydata”, desc = “Amplitude”)imprimir (las @ cabeçalho)

8área# Remova um atributo de bytes extraslas <- remove_lasattribute (las, “mydata2”)imprimir (las)imprimir (las @ cabeçalho)las <- remove_lasattribute (las, “mydata”)imprimir (las)imprimir (las @ cabeçalho)áreaSuperfície coberta por um objeto LAS *DescriçãoSuperfície coberta por um objeto LAS *. Para nuvens de pontos LAS, é calculado com base no casco convexodos pontos. Para um LAScatalog, é calculado como a soma das caixas delimitadoras dos arquivos.Para ladrilhos sobrepostos, o valor pode ser maior do que a área total coberta porque algumas regiões sãoamostrado duas vezes. Para um LASheader, é calculado com a caixa delimitadora. A função npoints fazo que o usuário pode esperar que ele faça e a densidade da função é equivalente a npoints (x) / área (x).Como consequência, para a mesma área de arquivo aplicada em um LASheader ou em um LAS pode retornar ligeiramentevalores diferentes.Usoárea (x, …)## Método S4 para assinatura LASárea (x, …)## Método S4 para assinatura LASheaderárea (x, …)## Método S4 para assinatura LAScatalogárea (x, …)npoints (x, …)## Método S4 para assinatura LASnpoints (x, …)## Método S4 para assinatura LASheadernpoints (x, …)## Método S4 para assinatura LAScatalognpoints (x, …)densidade (x, …)

as.list.LASheader9## Método S4 para assinatura LASdensidade (x, …)## Método S4 para assinatura LASheaderdensidade (x, …)## Método S4 para assinatura LAScatalogdensidade (x, …)ArgumentosxUm objeto da classe LAS *….não utilizado.Valornumérico. Um número. Observe que para a área a medida está nas mesmas unidades que a referência de coordenadasistema.as.list.LASheaderTransforme-se em uma listaDescriçãoFunções para construir, coagir e verificar os dois tipos de listas R.Uso## Método S3 para a classe LASheaderas.list (x, …)ArgumentosxUm objeto LASheader…não utilizado

10asprsas.spatialTransforme um objeto LAS * em um objeto spDescriçãoOs objetos LAS e LAScatalog são transformados em SpatialPointsDataFrame e SpatialPolygons-Objetos DataFrame, respectivamente.Usoas.spatial (x)Argumentosxum objeto do pacote lidRValorUm objeto de spasprsClassificação ASPRS LASDescriçãoUm conjunto de variáveis ​​globais correspondentes à classificação de pontos definida pelo ASPRS para oFormato LAS. Em vez de lembrar a tabela de classificação da especificação, é possível usaruma dessas variáveis ​​globais.UsoLASNONCLASSIFIEDLASUNCLASSIFIEDLASGROUNDLASLOWVEGETATIONLASMEDIUMVEGETATIONLASHIGHVEGETATIONLASBUILDINGLASLOWPOINT

asprs11LASKEYPOINTLASWATERLASRAILLASROADSURFACELASWIREGUARDLASWIRECONDUCTORLASTRANSMISSIONTOWERLASBRIGDELASNOISEFormatoUm objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.Um objeto de classe inteira de comprimento 1.ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (arquivo LAS)las2 = filter_poi (las, Classificação% em% c (LASGROUND, LASWATER))

12catalog_applyimprimir (LASGROUND)catalog_applyMotor de processamento LAScatalogDescriçãoEsta função dá aos usuários acesso ao mecanismo de processamento LAScatalog . Permite a aplicação de umrotina definida pelo usuário em um catálogo inteiro. A ferramenta do mecanismo de processamento LAScatalog é explicada ema classe LAScatalogcatalog_apply () é o núcleo do pacote lidR. Ele dirige todas as funções que podem pro-cess um LAScatalog. É flexível e poderoso, mas também complexo. catalog_sapply é o mesmo coma opção automerge = TRUE aplicada para simplificar a saída.Aviso: o motor de processamento LAScatalog tem um mecanismo para carregar dados em buffer ‘on-the-fly’para evitar artefatos de borda, mas nenhum mecanismo para remover o buffer após a aplicação de funções definidas pelo usuárioções, já que essa tarefa é específica de cada processo. Em outras funções lidR, esta tarefa é realizadaespecificamente para cada função. Em catalog_apply () a função do usuário pode retornar qualquer saída, portantoos usuários devem cuidar dessa tarefa eles próprios (consulte a seção “Artefatos de borda”)Usocatalog_apply (ctg, FUN, …, .options = NULL)catalog_sapply (ctg, FUN, …, .options = NULL)ArgumentosctgUm objeto LAScatalog .DIVERSÃOUma função definida pelo usuário que respeita um determinado modelo (consulte a seção tem-prato)…Argumentos opcionais para FUN..optionsVeja a seção dedicada e exemplos.Artefatos de pontaÉ importante tomar precauções para evitar ‘artefatos de borda’ ao processar azulejos de parede a parede. E seos pontos de telhas vizinhas não são incluídos durante certos processos, isso pode criar ‘bordaartefatos ‘nos limites dos ladrilhos. Por exemplo, pixels vazios ou incompletos em um processo de rasterização,ou elevações simuladas em uma interpolação de solo. O mecanismo de processamento LAScatalog forneceferramentas para carregar dados em buffer ‘on-the-fly’. No entanto, não há mecanismo para remover os resultadoscalculado na área de buffer, pois essa tarefa depende da saída da função definida pelo usuário.O usuário deve cuidar desta tarefa (ver exemplos) para evitar saída inesperada comentradas ou conflito entre valores calculados duas vezes.

catalog_apply13Dados em bufferOs objetos LAS lidos pela função do usuário têm um atributo especial chamado ‘buffer’ que indica, paracada ponto, se vem de uma área protegida ou não. Pontos de áreas não protegidas têm um ‘buffer’valor de 0, enquanto os pontos de áreas protegidas têm um valor de ‘buffer’ de 1, 2, 3 ou 4, onde 1 é obuffer inferior e 2, 3 e 4 são os buffers esquerdo, superior e direito, respectivamente. Isso permite a filtragemde pontos tampão, se necessário.Template de funçãoO parâmetro FUN espera uma função com um primeiro argumento que será fornecido automaticamente poro mecanismo de processamento LAScatalog. Este primeiro argumento é um LAScluster. Um LAScluster é umclasse interna não documentada, mas o usuário precisa saber apenas três coisas sobre esta classe:• Representa um pedaço do catálogo• A função readLAS pode ser usada com um LAScluster• A função extensão ou bbox pode ser usada com um LAScluster e retorna a caixa delimitadora deo cluster sem o buffer. Ele pode ser usado para cortar a saída e remover a região do buffer(veja exemplos).Uma função definida pelo usuário deve ter o seguinte modelo:myfun <- function (cluster, …) {las <- readLAS (cluster)if (is.empty (las)) return (NULL)# faça alguma coisa# remove o buffer da saídaretorno (algo)}A linha if (is.empty (las)) return (NULL) é importante porque alguns clusters (pedaços) podemcontém 0 pontos (não podemos saber isso antes de ler o arquivo). Neste caso, uma nuvem de pontos vaziacom 0 pontos é retornado por readLAS () e isso pode falhar no código subsequente. Assim, saindo cedoda função definida pelo usuário, retornando NULL, indica ao mecanismo interno que o cluster foivazio.De v3.0.0 se autoread = TRUE o seguinte modelo é aceito porque o motor toma cuidadodas etapas mencionadas acima:myfun <- function (las, bbox …) {# faça alguma coisa}.optionsOs usuários podem ter notado que algumas funções lidR geram um erro quando as opções de processamento sãoinapropriado. Por exemplo, algumas funções precisam de um buffer e, portanto, buffer = 0 é proibido. Comercialpode adicionar as mesmas restrições para proteger contra opções inadequadas. O argumento .options é umlista que permite aos usuários ajustar o comportamento do mecanismo de processamento.

14catalog_apply• drop_null = FALSE Não se destina a ser usado por usuários regulares. O motor não removeSaídas NULL• need_buffer = TRUE a função reclama se o buffer é 0.• need_output_file = TRUE a função reclama se nenhum template de arquivo de saída for fornecido.• raster_alignment = … a função verifica o alinhamento dos pedaços. Esta opção éimportante se a saída for um raster. Veja abaixo para mais detalhes.• automerge = TRUE por padrão, o mecanismo retorna uma lista com um item por bloco. Se automerge= TRUE, ele tenta mesclar as saídas em um único objeto: um Raster * “, um Spatial *, um ‘LAS *’semelhante a outras funções do pacote. Esta é uma opção à prova de falhas, portanto, no pior caso, se oa fusão falha, a ‘lista’ é retornada.• autoread = TRUE. Introduzida na v3.0.0, esta opção permite se livrar das primeiras etapas doou seja, readLAS () e if (is.empty ()). Neste caso, a função deve levar dois objetos comoentrada, primeiro um objeto LAS e, segundo, uma extensão do raster.Quando a função FUN retorna um raster, é importante garantir que os pedaços estejam alinhados como raster para evitar artefatos de borda. Na verdade, se a borda de um pedaço não corresponde à borda deos pixels, a saída não será estritamente contínua e terá artefatos de borda (que podem não servisível). Os usuários podem verificar isso com as opções raster_alignment, que podem ter a resolução deo raster como entrada, bem como o ponto de partida, se necessário. Os seguintes são aceitos:# verifique se os pedaços estão alinhados com um raster de resolução 20raster_alignment = 20raster_alignment = list (res = 20)# verifique se os pedaços estão alinhados com um raster de resolução 20# que começa em (0,10)raster_alignment = list (res = 20, start = c (0,10))Veja também \ link {grid_metrics} para mais detalhes.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• chunk_size: a quantidade de dados carregada de uma vez.• chunk_buffer: Carrega pedaços com um buffer.• chunk_alignment: Alinha os pedaços.• progresso: exibe uma estimativa de progresso.• output_files: As saídas de funções definidas pelo usuário serão gravadas em arquivos em vez de serem retornadasem R.• laz_compression: grava arquivos las ou laz apenas se a função definida pelo usuário retornar um ‘LAS “objeto.• selecionar: Selecione apenas os dados de interesse para salvar a memória de processamento.• filtro: Leia apenas os pontos de interesse.

catalog_apply15Exemplos# Mais exemplos podem estar disponíveis nas vinhetas oficiais do lidR ou# no livro github <https://jean-romain.github.io/lidRbook/>## ====================================================== ===========================## Exemplo 1: detectar todas as copas das árvores em um catálogo inteiro## (esta é basicamente uma reprodução da função lidR existente tree_detection)## ====================================================== ===========================# 1. Construa a função definida pelo usuário que analisa cada pedaço do catálogo.# O primeiro argumento da função é um objeto LAScluster. Os outros argumentos podem ser livremente# escolhido pelo usuário.my_tree_detection_method <- função (cluster, ws){# O argumento cluster é um objeto LAScluster. O usuário não precisa saber como funciona.# readLAS irá carregar a região de interesse (chunk) com um buffer em torno dela, aproveitando# indexação de nuvem de pontos, se possível. O filtro e as opções de seleção são propagadas automaticamentelas <- readLAS (cluster)if (is.empty (las)) return (NULL)# Encontre o topo das árvores usando um método desenvolvido pelo usuário (aqui simplesmente um LMF).ttops <- find_trees (las, lmf (ws))# ttops é um SpatialPointsDataFrame que contém as copas das árvores em nossa região de interesse# mais as copas das árvores na área protegida. Precisamos remover o buffer, caso contrário, obteremos# algumas árvores mais de uma vez.bbox <- raster :: extend (cluster)ttops <- raster :: crop (ttops, bbox)retorno (ttops)}# 2. Construir um projeto (aqui, um catálogo de arquivo único para os fins deste exemplo fictício).LASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)prj <- readLAScatalog (LASfile)plot (prj)# 3. Defina algumas opções de processamento.# Para este exemplo fictício, o tamanho do bloco é 100 m e o buffer é 10 mopt_chunk_buffer (prj) <- 10opt_chunk_size (prj)<- 100# pequeno porque este é um exemplo fictício.opt_chunk_alignment (prj) <- c (-50, -35) # Alinha como cria 2 pedaços apenas.opt_select (prj)<- “xyz”# Leia apenas as coordenadas.opt_filter (prj)<- “-keep_first” # Primeiros retornos somente leitura.# 4. Aplicar uma função definida pelo usuário para aproveitar as vantagens do motor internooptar<- list (need_buffer = TRUE,# catalog_apply gerará um erro se buffer = 0automerge = TRUE) # catalog_apply irá mesclar as saídas em um único objetooutput <- catalog_apply (prj, my_tree_detection_method, ws = 5, .options = opt)spplot (saída)

16catalog_intersect## Não correr:## ====================================================== ===## Exemplo 2: calcule um índice de rugas nos pontos da superfície## ====================================================== ===rumple_index_surface = função (cluster, res){las = readLAS (cluster)if (is.empty (las)) return (NULL)las<- filter_surfacepoints (las, 1)rumple <- grid_metrics (las, ~ rumple_index (X, Y, Z), res)bbox<- raster :: extend (cluster)rumple <- raster :: crop (rumple, bbox)voltar (enrugar)}LASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)prj <- readLAScatalog (LASfile)opt_chunk_buffer (prj) <- 1opt_chunk_size (prj)<- 140# pequeno porque este é um exemplo fictício.opt_select (prj)<- “xyz”# lê apenas as coordenadas.optar<- list (raster_alignment = 20, # catalog_apply ajustará os pedaços se necessárioautomerge = TRUE)# catalog_apply irá mesclar as saídas em um único rasteroutput <- catalog_apply (prj, rumple_index_surface, res = 20, .options = opt)plot (saída, col = height.colors (50))## End (não executado)catalog_intersectSubconjunto de um LAScatalog com um objeto Spatial *DescriçãoSubconjunto de um LAScatalog com um objeto Spatial * para manter apenas os blocos de interesse. Internamente, ele usa ointerseção da função raster com um ajuste para fazê-la funcionar com um LAScatalog. Isso pode ser usadopara selecionar blocos de interesse que abrangem objetos Spatial *, como SpatialPoints, SpatialPolygons ouSpatialLines.Usocatalog_intersect (ctg, y)

catalog_makechunks17ArgumentosctgUm objeto LAScatalogyObjeto Extent, Raster *, SpatialPolygons *, SpatialLines * ou SpatialPoints *ValorA LAScatalogcatalog_makechunksSubdividir um catálogo LAS em blocosDescriçãoPraticamente subdivida um LAScatalog em blocos. Esta função é uma função interna exportada parausuários na versão 3.0.0 porque pode ser útil para alguns propósitos de depuração. Também pode serútil para alguns desenvolvedores avançados. Não se espera que usuários regulares usem esta função. oos pedaços são feitos de acordo com as opções de processamento do catálogo.Usocatalog_makechunks (ctg, realinhamento = FALSE, plot = opt_progress (ctg))Argumentosctgum objeto da classe LAScatalogrealinhamentoFALSE ou lista (res = x, início = c (y, z)). Às vezes, o pedaço deve ser alinhadocom um raster, por exemplo, para garantir a continuidade da saída. Se o pedaçotamanho é 800 e o produto esperado é um raster com resolução de 35, 800 e35 não são compatíveis e criarão 2 pixels parciais diferentes nas bordas. oA opção de realinhamento força o pedaço a se ajustar ao alinhamento da grade.enredológico. Exibe o padrão de bloco.ValorUma lista contendo objetos da classe LAScluster.

18catalog_options_toolscatalog_options_tools Obtenha ou defina as opções do mecanismo de processamento LAScatalogDescriçãoOs nomes das opções e suas funções são documentados no LAScatalog. As opções são usadas portodas as funções que suportam um LAScatalog como entrada.Usoopt_chunk_buffer (ctg)opt_chunk_buffer (ctg) <- valoropt_chunk_size (ctg)opt_chunk_size (ctg) <- valoropt_chunk_alignment (ctg)opt_chunk_alignment (ctg) <- valoropt_progress (ctg)opt_progress (ctg) <- valoropt_stop_early (ctg)opt_stop_early (ctg) <- valoropt_wall_to_wall (ctg)opt_wall_to_wall (ctg) <- valoropt_independent_files (ctg)opt_independent_files (ctg) <- valoropt_output_files (ctg)opt_output_files (ctg) <- valoropt_laz_compression (ctg)opt_laz_compression (ctg) <- valoropt_merge (ctg)

catalog_retile19opt_merge (ctg) <- valoropt_select (ctg)opt_select (ctg) <- valoropt_filter (ctg)opt_filter (ctg) <- valorArgumentosctgUm objeto da classe LAScatalogvalorUm valor apropriado dependendo da entrada esperada.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)ctg = readLAScatalog (LASfile)plot (ctg, chunk_pattern = TRUE)opt_chunk_size (ctg) <- 150plot (ctg, chunk_pattern = TRUE)opt_chunk_buffer (ctg) <- 10plot (ctg, chunk_pattern = TRUE)opt_chunk_alignment (ctg) <- c (270.250)plot (ctg, chunk_pattern = TRUE)resumo (ctg)opt_output_files (ctg) <- “/ path / to / folder / template_filename_ {XBOTTOM} _ {ID}”resumo (ctg)catalog_retileRetile um LAScatalogDescriçãoDivide ou mescla arquivos para remodelar os arquivos de catálogo originais (.las ou .laz) em arquivos menores ou maiores.Também permite a adição ou remoção de um buffer em torno dos ladrilhos. A função primeiro exibe olayout do novo padrão de tiling e então pede ao usuário para validar o comando.Internamente, a função lê e grava os clusters definidos pelas opções de processamento interno deum mecanismo de processamento LAScatalog . Assim, a função é flexível e permite que o usuário retile oconjunto de dados, retile ao adicionar ou remover um buffer (buffers negativos são permitidos) ou, opcionalmente, para

20catalog_retilecomprima os dados retiling sem alterar o padrão, mas alterando o formato (las / laz).Observe que esta função não é realmente muito útil, pois lidR gerencia tudo (recorte, proprocessamento, armazenamento em buffer, …) internamente usando as opções adequadas. Assim, retiling pode ser útil para trabalharem outro software, por exemplo, mas não em lidR.Usocatalog_retile (ctg)ArgumentosctgUm objeto LAScatalogValorUm novo objeto LAScatalogTrabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• chunk_size: Tamanho das novas peças.• buffer: carregue novos ladrilhos com um buffer. O valor esperado geralmente é 0.• alinhamento: alinhamento dos novos ladrilhos.• núcleos: o número de núcleos usados. catalog_retile transmite os dados (nada é carregado noNível R). O número máximo de núcleos pode ser usado com segurança.• progresso: exibe uma estimativa de progresso.• output_files *: Obrigatório. Os novos blocos serão gravados em novos arquivos.• laz_compression: salva os arquivos las ou laz.• select: catalog_retile preserva o formato do arquivo de qualquer maneira.• filtro: retile e salve apenas os pontos de interesse.

catalog_select21Exemplos## Não correr:ctg = readLAScatalog (“caminho / para / catálogo”)# Crie um novo conjunto de arquivos .las de 500 x 500 de largura na pasta# path / to / new / catalog / e iterativamente nomeado Forest_1.las, Forest_2.las# Forest_3.las e assim por diante.opt_chunk_buffer (ctg) <- 0opt_chunk_size (ctg) <- 500opt_output_files (ctg) <- “caminho / para / novo / catálogo / Floresta_ {ID}newctg = catalog_retile (ctg)# Crie um novo conjunto de arquivos .las equivalente ao original,# mas estendido com um buffer de 50 m no caminho da pasta / to / new / catalog /# e com o nome iterativo dos arquivos originais.opt_chunk_buffer (ctg) <- 50opt_chunk_size (ctg) <- 0opt_output_files (ctg) <- “path / to / new / catalog / {ORIGINALFILENAME} _bufferednewctg = catalog_retile (ctg)# Crie um novo conjunto de arquivo .laz compactado equivalente ao original, mantendo apenas# primeiro retorna acima de 2 mopt_chunk_buffer (ctg) <- 0opt_chunk_size (ctg) <- 0opt_laz_compression (ctg) <- TRUEopt_filter (ctg) <- “-keep_first -drop_z_below 2″newctg = catalog_retile (ctg)## End (não executado)catalog_selectSelecione os arquivos LAS manualmente em um catálogo LASDescriçãoSelecione um conjunto de blocos LAS de um catálogo LAS interativamente usando o mouse. Esta função permiteusuários subconjuntos de um LAScatalog clicando em um mapa do arquivo.Usocatalog_select (ctg,mapview = TRUE,método = c (“subconjunto”, “flag_unprocessed”, “flag_processed”))

22classify_groundArgumentosctgUm objeto LAScatalogvisão do mapalógico. Se FALSE, use R base plot em vez de mapview (sem panorâmica, sem zoom, veja tambémenredo)métodopersonagem. Por padrão, selecionar blocos que são um subconjunto do catálogo. Isso é tambémpossível sinalizar os arquivos para manter o catálogo como um todo, mas processar apenas umsubconjunto de seu conteúdo. flag_unprocessed permite aos usuários apontar e clicar emarquivos que não serão processados. flag_processed permite aos usuários apontar eclique nos arquivos que serão processados.ValorUm objeto LAScatalogExemplos## Não correr:ctg = readLAScatalog (“<Caminho para uma pasta contendo um conjunto de arquivos .las>”)new_ctg = catalog_select (ctg)## End (não executado)classify_groundClassifique os pontos como ‘chão’DescriçãoClassifique os pontos como ‘chão’ com vários algoritmos possíveis. A função atualiza o atributoClassificação do objeto LAS. Os pontos classificados como ‘chão’ recebem um valor de 2de acordo com as especificações.Usoclassify_ground (las, algoritmo, last_returns = TRUE)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmouma função de segmentação de solo. lidR tem: pmf e csf. O pacote lidRplugins-idade tem ‘mcc’.last_returnslógico. O algoritmo usará apenas os últimos retornos (incluindo o primeiro re-transforma em casos de um único retorno) para executar o algoritmo. Se FALSE todos os retornossão usados. Se o atributo ReturnNumber ou NumberOfReturns estiverem ausentes,last_returns muda para FALSE automaticamente.

classify_ground23ValorSe a entrada for um objeto LAS, retorne um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (LASfile, select = “xyzrn”, filter = “-inside 273450 5274350 273550 5274450”)# Usando o Filtro Morfológico Progressivo# ————————————–# (Parâmetros escolhidos principalmente para velocidade)ws <- seq (3,12, 4)th <- seq (0,1, 1,5, comprimento.out = comprimento (ws))

24classify_noiselas <- classify_ground (las, pmf (ws, th))#plot (las, color = “Classificação”)# # Usando o filtro de simulação de tecido# ————————————–# (Parâmetros escolhidos principalmente para velocidade)mycsf <- csf (TRUE, 1, 1, time_step = 1)las <- classify_ground (las, mycsf)#plot (las, color = “Classificação”)classify_noiseClassifique os pontos como ‘ruído’DescriçãoClassifique os pontos como ‘ruído’ (outliers) com vários algoritmos possíveis. A função atualiza oatributo Classificação do objeto LAS. Os pontos classificados como ‘ruído’ recebem um valorde 18 de acordo com as especificações las .Usoclassify_noise (las, algoritmo)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmouma função de segmentação de ruído. lidR tem: sor , ivf.ValorSe a entrada for um objeto LAS, retorne um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.

grampo25Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (LASfile, filter = “-inside 273450 5274350 273550 5274450”)# Adicionar 20 outliers artificiaisset.seed (314)id = round (runif (20, 0, npoints (las)))set.seed (42)err = runif (20, -50, 50)las $ Z [id] = las $ Z [id] + err# Usando SORlas <- classify_noise (las, sor (15,7))#plot (las, color = “Classificação”)# Usando FIVlas <- classify_noise (las, ivf (5,2))# Remova outliers usando filter_poi ()las_denoise <- filter_poi (las, Classificação! = LASNOISE)grampoPontos de corte em regiões de interesseDescriçãoRecorte pontos dentro de uma determinada região de interesse (ROI) de uma nuvem de pontos (objeto LAS) ou um catálogo(Objeto LAScatalog). Com um objeto LAS, o usuário primeiro lê e carrega uma nuvem de pontos na memóriae então pode cortá-lo para obter um subconjunto dentro de uma região de interesse. Com um objeto LAScatalog, o usuáriopode extrair qualquer ROI arbitrário para um conjunto de arquivos las / laz, carregando apenas os pontos de interesse. Isto émais rápido, fácil e com muito mais economia de memória para extrair ROIs.

26grampoUsoclip_roi (las, geometry, …)clip_rectangle (las, xleft, ybottom, xright, ytop, …)clip_polygon (las, xpoly, ypoly, …)clip_circle (las, xcenter, ycenter, radius, …)clip_transect (las, p1, p2, largura, xz = FALSE, …)ArgumentoslasUm objeto da classe LAS ou LAScatalog.geometriaum objeto geométrico. Muitos tipos são suportados, consulte a seção ‘geome-tentativas’….em clip_roi: opções suplementares opcionais (consulte as geometrias compatíveis). Un-usado em outras funçõesxesquerdonumérico. coordenadas x esquerdas dos retângulos.ybottomnumérico. Coordenadas y inferiores de retângulos.certonumérico. Coordenadas x direitas dos retângulos.ytopnumérico. principais coordenadas y de retângulos.xpolynumérico. Coordenadas x de um polígono.ypolynumérico. coordenadas y de um polígono.xcenternumérico. Coordenadas x dos centros dos discos.ycenternumérico. coordenadas y dos centros dos discos.raionumérico. raio ou raios do disco.p1, p2vetores numéricos de comprimento 2 que dá as coordenadas de dois pontos que definemum transectolarguranumérico. largura do transecto.xzbool. Se TRUE, a nuvem de pontos é reorientada para caber nas coordenadas XZValorSe a entrada for um objeto LAS: um objeto da classe LAS, ou uma lista de objetos LAS se a consulta implicarvárias regiões de interesse serão devolvidas.Se a entrada for um objeto LAScatalog: um objeto da classe LAS, ou uma lista de objetos LAS se a consultaimplica que várias regiões de interesse serão retornadas, ou um LAScatalog se as consultas forem imediatamenteescrito em arquivos sem carregar nada em R.

grampo27Geometrias suportadas• string WKT: descrevendo um PONTO, um POLÍGONO ou um MULTIPOLÍGONO. Se pontos, um parâmetro-ter ‘radius’ deve ser passado em …• Polígono ou polígonos• SpatialPolygons ou SpatialPolygonsDataFrame• SpatialPoints ou SpatialPointsDataFrame , nesse caso, um parâmetro ‘radius’ deve ser passado…• SimpleFeature que contém consistentemente POINT ou POLYGON / MULTIPOLYGON. No caso de POINTum parâmetro ‘radius’ deve ser passado em …• Extensão• matriz 2 x 2 que descreve uma caixa delimitadora seguindo esta ordem:minmaxx 684816 684943y 5017823 5017957Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• chunk_size: Não faz sentido aqui.• buffer: ainda não suportado.• alinhamento: não faz sentido aqui.• progresso: exibe uma estimativa de progresso.• output_files: Se ‘output_files’ for definido no catálogo, os ROIs não serão retornados em R. Eles serãoser escrito imediatamente em arquivos. Veja LAScatalog-class e exemplos. Os modelos permitidos emclip_ * são {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {ID}, {XCENTER}, {YCENTER}. Além dissoção clip_roi suporta qualquer nome da tabela de atributos de um objeto espacial dado comoentrada como {PLOTID}, {YEAR}, {SPECIES}, para exemplos, se esses atributos existirem. Se vaziotudo é devolvido na R.

28cloud_metrics• laz_compression: grava arquivos las ou laz• selecionar: a função gravará arquivos equivalentes aos originais. Esta opção não é respeitada.• filtro: Leia apenas os pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)# Carregue o arquivo e corte a região de interesselas = readLAS (LASfile, select = “xyz”, filter = “-keep_first”)subset1 = clip_rectangle (las, 684850, 5017850, 684900, 5017900)# Não carregue o (s) arquivo (s), extraia apenas a região de interesse# de um conjunto de dados maiorctg = readLAScatalog (LASfile, progress = FALSE, filter = “-keep_first”)subset2 = clip_rectangle (ctg, 684850, 5017850, 684900, 5017900)# Extraia todos os polígonos de um shapefilef <- system.file (“extdata”, “lake_polygons_UTM17.shp”, package = “lidR”)lagos <- sf :: st_read (f, quiet = TRUE)subset3 <- clip_roi (las, lagos)# Extraia os polígonos para um catálogo, escreva-os em arquivos chamados# após os nomes dos lagos, não carregue nada em Ropt_output_files (ctg) <- paste0 (tempfile (), “_ {LAKENAME_1}”)new_ctg = clip_roi (ctg, lagos)plot (new_ctg)# Extraia um transectop1 <- c (684800, y = 5017800)p2 <- c (684900, y = 5017900)tr1 <- clip_transect (las, p1, p2, largura = 4)## Não correr:plot (subconjunto1)plot (subconjunto2)plot (subconjunto3)plot (tr1, eixo = TRUE, clear_artifacts = FALSE)## End (não executado)cloud_metricsCalcule métricas para uma nuvem de pontosDescriçãocloud_metrics calcula uma série de estatísticas descritivas definidas pelo usuário para um conjunto de dados LiDAR. Vejogrid_metrics para calcular métricas em uma grade. Basicamente, não existem métricas predefinidas. Os usuários devem

cloud_metrics29escrever suas próprias funções para criar métricas (ver exemplo). As seguintes funções existentes podemservem como um guia para ajudar os usuários a calcular suas próprias métricas:• stdmetrics• entropia• VCI• LADUsocloud_metrics (las, func)ArgumentoslasUm objeto da classe LASfunçãoFórmula. Uma expressão a ser aplicada à nuvem de pontos (ver exemplo)ValorEle retorna uma lista contendo as métricasVeja tambémgrid_metrics stdmetrics entropia VCI LADOutras métricas: grid_metrics(), hexbin_metrics(), point_metrics(), árvore_métrica(), voxel_metrics()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)lidar = readLAS (arquivo LAS)cloud_metrics (lidar, ~ max (Z))cloud_metrics (lidar, ~ mean (Intensity))# Defina suas próprias novas métricasmyMetrics = função (z, i){metrics = list (zwimean = sum (z * i) / sum (i), # elevação média ponderada por intensidadeszimean = média (z * i),# Produtos médios de z por intensidadezsqmean = sqrt (média (z ^ 2)) # Média quadrática)retorno (métricas)}metrics = cloud_metrics (lidar, ~ myMetrics (Z, Intensity))# Métricas predefinidascloud_metrics (lidar, .stdmetrics)

30csfcsfAlgoritmo de Segmentação de SoloDescriçãoEsta função é feita para ser usada em classify_ground. Ele implementa um algoritmo para segmentaçãode pontos de aterramento com base em um filtro de simulação de tecido. Este método é uma implementação estrita doAlgoritmo CSF ​​feito por Zhang et al. (2016) (ver referências) que se baseia no original dos autorescódigo-fonte escrito e exposto em R por meio do pacote RCSF.Usocsf (sloop_smooth = FALSE,limite_classe = 0,5,pano_resolução = 0,5,rigidez = 1L,iterações = 500L,time_step = 0,65)Argumentossloop_smoothlógico. Quando existirem encostas íngremes, defina este parâmetro como TRUE para reduzir errosdurante o pós-processamento.class_thresholdescalar. A distância até o tecido simulado para classificar uma nuvem de pontos no soloe não aterrado. O padrão é 0,5.pano_resoluçãoescalar. A distância entre as partículas no tecido. Isso geralmente é definido comodistância média dos pontos na nuvem de pontos. O valor padrão é 0,5.rigidezinteiro. A rigidez do tecido. 1 significa muito macio (para se ajustar a terrenos acidentados),2 significa médio e 3 significa tecido duro (para terreno plano). O padrão é1iteraçõesinteiro. Iterações máximas para simular o pano. O valor padrão é 500.Normalmente, não há necessidade de alterar este valor.time_stepescalar. Intervalo de tempo ao simular o pano sob a gravidade. o valor padrão é0,65. Normalmente, não há necessidade de alterar este valor. É adequado para a maioria dos casos.ReferênciasW. Zhang, J. Qi *, P. Wan, H. Wang, D. Xie, X. Wang e G. Yan, “An Easy-to-Use AirborneMétodo de filtragem de dados LiDAR com base na simulação de tecido ”, Remote Sens., Vol. 8, não. 6, pág. 501,2016. (http://www.mdpi.com/2072-4292/8/6/501/htm)

dalponte201631Veja tambémOutros algoritmos de segmentação de solo: pmf()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (arquivo LAS, select = “xyzrn”)mycsf <- csf (TRUE, 1, 1, time_step = 1)las <- classify_ground (las, mycsf)#plot (las, color = “Classificação”)dalponte2016Algoritmo de segmentação de árvore individualDescriçãoEsta função é feita para ser usada em segment_trees. Ele implementa um algoritmo para segmentação de árvorebaseado no algoritmo de Dalponte e Coomes (2016) (ver referência). Esta é uma semente + crescendoalgoritmo de região. Este algoritmo existe no pacote itcSegment. Esta versão foi escritado papel em C ++. Consequentemente, é centenas a milhões de vezes mais rápido do que a versão original.Observe que este algoritmo executa estritamente uma segmentação, enquanto o método original implementadoem itcSegment e descrito no manuscrito também executa tarefas de pré e pós-processamento. Aquiespera-se que essas tarefas sejam realizadas pelo usuário em funções separadas.Usodalponte2016 (chm,Copa das árvores,th_tree = 2,th_seed = 0,45,th_cr = 0,55,max_cr = 10,ID = “treeID”)ArgumentoschmRasterLayer. Imagem da copa. Pode ser calculado com grid_canopy ou lerde um arquivo externo.Copa das árvoresSpatialPointsDataFrame. Pode ser calculado com find_trees ou lido de umshapefile externo.th_treenumérico. Limiar abaixo do qual um pixel não pode ser uma árvore. O padrão é 2.a sementenumérico. Limiar de crescimento 1. Ver referência em Dalponte et al. 2016. Um pixelé adicionado a uma região se a sua altura for maior do que a altura da árvore multiplicada por estevalor. Deve estar entre 0 e 1. O padrão é 0,45.

32dalponte2016th_crnumérico. Limiar de crescimento 2. Ver referência em Dalponte et al. 2016. Um pixelé adicionado a uma região se sua altura for maior do que a altura média atual doregião multiplicada por este valor. Deve estar entre 0 e 1. O padrão é 0,55.max_crnumérico. Valor máximo do diâmetro da copa de uma árvore detectada (em pixels).O padrão é 10.EU IRIApersonagem. Se o SpatialPointsDataFrame contiver um atributo com o ID paracada árvore, o nome deste atributo. Dessa forma, os IDs originais serão preservados. E senão existe tal árvore de dados será numerada sequencialmente.DetalhesComo esse algoritmo funciona apenas em um CHM, não há necessidade real de uma nuvem de pontos. As vezeso usuário nem tem a nuvem de pontos que gerou o CHM. lidR é um ponto orientado para a nuvembiblioteca, é por isso que este algoritmo deve ser usado em segment_trees para mesclar o resultado com oNuvem. No entanto, o usuário pode usar isso como uma função autônoma como esta:chm = raster (“arquivo / para / a / chm /”)ttops = find_trees (chm, lmf (3))coroas = dalponte2016 (chm, ttops) ()ReferênciasDalponte, M. e Coomes, DA (2016), Mapeamento centrado na árvore da densidade de carbono da floresta a partir do arvarredura a laser transmitida e dados hiperespectrais. Methods Ecol Evol, 7: 1236–1245. doi: 10.1111 / 2041-210X,12575.Veja tambémOutros algoritmos de segmentação de árvore individual: li2012(), silva2016(), divisor de águas()Outros algoritmos de segmentação de árvore baseados em raster: silva2016(), divisor de águas()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyz”, filter = “-drop_z_below 0”)col <- pastel.colors (200)chm <- grid_canopy (las, 0,5, p2r (0,3))ker <- matriz (1,3,3)chm <- raster :: focal (chm, w = ker, fun = mean, na.rm = TRUE)ttops <- find_trees (chm, lmf (4, 2))las<- segment_trees (las, dalponte2016 (chm, ttops))#plot (las, color = “treeID”, colorPalette = col)

decimate_points33decimate_pointsDecime um objeto LASDescriçãoReduza o número de pontos usando vários algoritmos possíveis.Usodecimate_points (las, algoritmo)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmofunção. Um algoritmo de decimação de pontos. lidR tem: aleatório , homogeneizare mais alto.ValorSe a entrada for um objeto LAS, retorna um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer: Esta função garante uma saída contínua estrita de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.

34delineate_crowns• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS, select = “xyz”)# Selecione pontos aleatoriamente para alcançar uma densidade geral de 1thinned1 = decimate_points (las, random (1))#plot (grid_density (las))#plot (grid_density (thinned1))# Selecione pontos aleatoriamente para alcançar uma densidade homogênea de 1thinned2 = decimate_points (las, homogeneizar (1,5))#plot (grid_density (thinned2))# Selecione o ponto mais alto em cada pixel de uma grade sobrepostathinned3 = decimate_points (las, maior (5))#plot (thinned3)delineate_crownsCalcule o casco de cada árvore.DescriçãoCalcule o casco de cada árvore segmentada. O casco pode ser convexo, côncavo ou uma caixa delimitadora (verdetalhes e referências).Usodelineate_crowns (las,type = c (“convexo”, “côncavo”, “bbox”),concavidade = 3,limite_de_primento = 0,func = NULL,attribute = “treeID”)

delineate_crowns35ArgumentoslasUm objeto da classe LAS ou LAScatalog.tipopersonagem. Tipo de casco. Pode ser ‘convexo’, ‘côncavo’ ou ‘bbox’.concavidadenumérico. Se type = “côncavo”, uma medida relativa de concavidade. 1 resulta em umforma relativamente detalhada, o Infinity resulta em um casco convexo.length_thresholdnumérico. Se type = “côncavo”, quando o comprimento de um segmento está abaixo desse limite,nenhum detalhe adicional é adicionado. Valores mais altos resultam em formas mais simples.funçãoFórmula. Uma expressão a ser aplicada a cada árvore. Funciona como em grid_metricsvoxel_metrics ou tree_metrics e computa, além dos cascos um conjunto demétricas para cada árvore.atributopersonagem. O atributo onde o ID de cada árvore é armazenado. Em lidR, o padrãoé “treeID”.DetalhesO método do casco côncavo sob o capô é descrito em Park & ​​Oh (2012). A função depende dea função côncava .ValorUm SpatialPolygonsDataFrame. Se uma árvore tiver menos de 4 pontos, ela não é considerada.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.

36descontinuada• progresso: Exibe uma estimativa de progressão.• arquivos de saída: os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER},{YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: Carrega apenas atributos de interesse.• filtro: Leia apenas pontos de interesse.ReferênciasPark, JS e Oh, SJ (2012). Um novo algoritmo de casco côncavo e medida de concavidade para n-conjuntos de dados dimensionais. Journal of Information science and engineering, 28 (3), 587-600.ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)poi = “-drop_z_below 0 -inside 481280 3812940 481320 3812980″las = readLAS (arquivo LAS, select = “xyz0”, filtro = poi)# NOTA: Este conjunto de dados já está segmentado#plot (las, color = “treeID”, colorPalette = pastel.colors (200))# Apenas os cascosconvex_hulls = delineate_crowns (las)plot (convex_hulls)# Os cascos + algumas métricas definidas pelo usuárioconvex_hulls = delineate_crowns (las, func = ~ list (Zmean = mean (Z)))convex_hulls# A caixa delimitadorabbox_hulls = delineate_crowns (las, “bbox”)plot (bbox_hulls)## Não correr:# Com casco côncavo (mais para calcular)concave_hulls = delineate_crowns (las, “côncavo”)plot (côncavo_ cascas)spplot (convex_hulls, “ZTOP”)spplot (convex_hulls, “Zmean”)## End (não executado)descontinuadaFunções obsoletas em lidR

descontinuada37DescriçãoEssas funções são fornecidas para compatibilidade com versões mais antigas de lidR, mas estão obsoletas desdelidR versão 3. Eles irão imprimir uma mensagem progressivamente, lançar um aviso e, eventualmente, ser re-mudou-se. Os links abaixo apontam para a documentação dos novos nomeslasadd lascheck lasclip lasdetectshape lasfilter lasfiltersurfacepoints lasflightline lasground lasmerges-patial lasnormalize laspulse lasrangecorreção lasflightline lasreoffset lasrescale lasscanlines lass-mooth lassnags lastrees lasvoxelize sensor_tracking tree_detection tree_hullUsolascheck (las)lasclip (las, geometry, …)lasclipRectangle (las, xleft, ybottom, xright, ytop, …)lasclipPolygon (las, xpoly, ypoly, …)lasclipCircle (las, xcenter, ycenter, radius, …)lasdetectshape (las, algoritmo, atributo = “Forma”, filtro = NULL)lasfilter (las, …)lasfilterfirst (las)lasfilterfirstlast (las)lasfilterfirstofmany (las)lasfilterground (las)lasfilterlast (las)Lasfilternth (las, n)lasfiltersingle (las)lasfilterdecimate (las, algoritmo)lasfilterduplicates (las)lasfiltersurfacepoints (las, res)lasground (las, algoritmo, last_returns = TRUE)laspulse (las)

38descontinuadaúltima linha (las, dt = 30)lasscanline (las)lasmergespatial (las, source, attribute = NULL)lasnormalize (las,algoritmo,na.rm = FALSE,use_class = c (2L, 9L),…,add_lasattribute = FALSE)lasunnormalize (las)Lasrangecorrection (las,sensor,Rs,f = 2,3,gpstime = “gpstime”,elevação = “Z”)lasrescale (las, xscale, yscale, zscale)lasreoffset (las, xoffset, yoffset, zoffset)lassmooth (las,Tamanho,método = c (“média”, “gaussiana”),forma = c (“círculo”, “quadrado”),sigma = tamanho / 6)lasunsmooth (las)lassnags (las, algoritmo, atributo = “snagCls”)lastransform (las, CRSobj)lastrees (las, algoritmo, atributo = “treeID”, uniqueness = “incremental”)lasadddata (las, x, nome)

descontinuada39lasaddextrabytes (las, x, nome, desc)lasaddextrabytes_manual (las,x,nome,desc,tipo,deslocamento = NULL,escala = NULL,NA_value = NULL)lasremoveextrabytes (las, nome)lasvoxelize (las, res)sensor_tracking (las,intervalo = 0,5,pmin = 50,extra_check = TRUE,thin_pulse_with_time = 0,001)tree_detection (las, algoritmo)tree_hulls (las,type = c (“convexo”, “côncavo”, “bbox”),concavidade = 3,limite_de_primento = 0,func = NULL,attribute = “treeID”)ArgumentoslasVeja as novas funções que substituem as antigasgeometriaVeja as novas funções que substituem as antigas…Veja as novas funções que substituem as antigasxleft, ybottom, xright, ytopVeja as novas funções que substituem as antigasxpoly, ypolyVeja as novas funções que substituem as antigasxcenter, ycenter, radiusVeja as novas funções que substituem as antigas

40dsmtinalgoritmoVeja as novas funções que substituem as antigasatributoVeja as novas funções que substituem as antigasfiltroVeja as novas funções que substituem as antigasn, res, dtVeja as novas funções que substituem as antigaslast_returnsVeja as novas funções que substituem as antigasfonteVeja as novas funções que substituem as antigasna.rm, use_class, add_lasattributeVeja as novas funções que substituem as antigassensor, Rs, f, gpstime, elevaçãoVeja as novas funções que substituem as antigasxscale, yscale, zscale, xoffset, yoffset, zoffsetVeja as novas funções que substituem as antigastamanho, método, forma, sigmaVeja as novas funções que substituem as antigasCRSobjVeja as novas funções que substituem as antigassingularidadeVeja as novas funções que substituem as antigasx, nome, desc, tipo, deslocamento, escala, NA_valueVeja as novas funções que substituem as antigasintervalo, pmin, extra_check, thin_pulse_with_timeVeja as novas funções que substituem as antigasconcavidade, length_threshold, funcVeja as novas funções que substituem as antigasdsmtinAlgoritmo de modelo de superfície digitalDescriçãoEsta função é feita para ser usada em grid_canopy. Ele implementa um algoritmo para superfície digitalcálculo do modelo usando uma triangulação de Delaunay dos primeiros retornos com uma interpolação linear dentrocada triângulo.Usodsmtin (max_edge = 0)Argumentosmax_edgenumérico. Comprimento máximo da borda de um triângulo na triangulação de Delaunay. E seum triângulo tem um comprimento de borda maior do que este valor, ele será removido para apararinterpolação simulada em áreas não convexas. Se max_edge = 0 nenhum corte é feito(veja exemplos).

entropia41Veja tambémOutros algoritmos de modelo de superfície digital: p2r(), pitfree()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (arquivo LAS)col <- height.colors (50)# Triangulação básica e rasterização de primeiros retornoschm <- grid_canopy (las, res = 1, dsmtin ())plot (chm, col = col)## Não correr:# Subconjunto côncavo potencialmente complexo de nuvem de pontosx = c (481340, 481340, 481280, 481300, 481280, 481340)y = c (3812940, 3813000, 3813000, 3812960, 3812940, 3812940)las2 = clip_polygon (las, x, y)plot (las2)# Uma vez que a interpolação TIN é feita dentro do casco convexo da nuvem de pontos# pixels falsos são interpolados estritamente corretos de acordo com o método de interpolação# usado, mas sem sentido em nosso CHMchm <- grid_canopy (las2, res = 0,5, dsmtin ())plot (chm, col = col)# Use max_edge para aparar triângulos falsoschm = grid_canopy (las2, res = 0,5, dsmtin (max_edge = 3))plot (chm, col = col)## End (não executado)entropiaÍndice de diversidade de Shannon normalizadoDescriçãoUm índice de complexidade vertical de Shannon normalizado. O índice de diversidade de Shannon é uma medida paraquantificar a diversidade e se baseia no número e na frequência das espécies presentes. Este índice,desenvolvido por Shannon e Weaver para uso na teoria da informação, foi transferido com sucesso paraa descrição da diversidade de espécies em sistemas biológicos (Shannon 1948). Aqui é aplicado aquantifique a diversidade e a uniformidade de uma distribuição elevada dos pontos. Faz caixotes do lixoentre 0 e a elevação máxima. Se houver valores negativos, a função retorna NA.Usoentropia (z, por = 1, zmax = NULL)

42extensão, método LASArgumentoszvetor de coordenadas z positivasdenumérico. A espessura das camadas usadas (bin de altura)zmaxnumérico. Usado para transformar a entropia da função para a função VCI.ValorUm número entre 0 e 1ReferênciasPretzsch, H. (2008). Descrição e Análise de Estruturas de Stand. Springer Berlin Heidelberg.http://doi.org/10.1007/978-3-540-88307-4 (páginas 279-280) Shannon, Claude E. (1948), “A mathe-teoria matemática da comunicação, “Bell System Tech. Journal 27, 379-423, 623-656.Veja tambémVCIExemplosz <- runif (10000, 0, 10)# deverá estar próximo de 1. A maior diversidade é dada para uma distribuição uniformeentropia (z, por = 1)z <- runif (10000, 9, 10)# Deve ser 0. A menor diversidade é dada para uma possibilidade únicaentropia (z, por = 1)z <- abs (rnorm (10000, 10, 1))# deve estar entre 0 e 1.entropia (z, por = 1)extensão, método LASExtensãoDescriçãoRetorna um objeto Extent de um LAS *.Uso## Método S4 para assinatura LASextensão (x, …)## Método S4 para assinatura LAScatalogextensão (x, …)

filtros43ArgumentosxUm objeto da classe LAS ou LAScatalog…Não utilizadoValorObjeto de extensão do rasterVeja tambémraster :: extendfiltrosFiltros predefinidos de ponto de interesseDescriçãoSelecione apenas algumas devoluçõesUsofilter_first (las)filter_firstlast (las)filter_firstofmany (las)filter_ground (las)filter_last (las)filter_nth (las, n)filter_single (las)ArgumentoslasUm objeto da classe LASna posição na sequência de retornoDetalhes• filter_first Selecione apenas os primeiros retornos.• filter_firstlast Selecione apenas o primeiro e o último retorno.• filter_ground Selecione apenas os retornos classificados como aterrados de acordo com a especificação LAS.• filter_last Selecione apenas os últimos retornos, ou seja, os últimos retornos e os retornos únicos.

44filter_duplicates• filter_nth Selecione os retornos de sua posição na sequência de retorno.• filter_firstofmany Selecione apenas os primeiros retornos de pulsos que retornaram vários pontos.• filter_single Selecione apenas os retornos que retornam apenas um ponto.ValorUm objeto da classe LASVeja tambémOutros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()Outros filtros: filter_duplicates(), filter_poi(), filter_surfacepoints()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)lidar = readLAS (arquivo LAS)firstReturns = filter_first (lidar)groundReturns = filter_ground (lidar)filter_duplicatesFiltrar pontos duplicadosDescriçãoPontos de filtro que aparecem mais de uma vez na nuvem de pontos de acordo com suas coordenadas XYZUsofilter_duplicates (las)ArgumentoslasUm objeto da classe LAS ou LAScatalog.ValorSe a entrada for um objeto LAS, retorna um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.

filter_poi45Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer: Esta função garante uma saída contínua estrita de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.Veja tambémOutros filtros: filter_poi(), filter_surfacepoints(), filtrosfilter_poiFiltrar pontos de interesse com condições correspondentesDescriçãoFiltre pontos de interesse (POI) de um objeto LAS onde as condições são verdadeiras.Usofilter_poi (las, …)

46filter_surfacepointsArgumentoslasUm objeto da classe LAS…Predicados lógicos. Várias condições são combinadas com ‘&’ ou ‘,’ValorUm objeto da classe LASVeja tambémOutros filtros: filter_duplicates(), filter_surfacepoints(), filtrosExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)lidar = readLAS (arquivo LAS)# Selecione as primeiras devoluções classificadas como terrestresfirstground = filter_poi (lidar, Classificação == 2L & ReturnNumber == 1L)# Vários argumentos são equivalentes a &firstground = filter_poi (lidar, Classificação == 2L, ReturnNumber == 1L)# Critérios múltiplosfirst_or_ground = filter_poi (lidar, Classificação == 2L | ReturnNumber == 1L)filter_surfacepointsFiltre os pontos de superfícieDescriçãoEsta função é substituída pelo algoritmo mais utilizável em decimate_pointsUsofilter_surfacepoints (las, res)ArgumentoslasUm objeto da classe LAS ou LAScatalog.resnumérico. A resolução da grade usada para filtrar a nuvem de pontosValorSe a entrada for um objeto LAS, retorna um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.

find_localmaxima47Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer: Esta função garante uma saída contínua estrita de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.Veja tambémOutros filtros: filter_duplicates(), filter_poi(), filtrosfind_localmaximaFiltro Máximo LocalDescriçãoFiltro máximo local genérico. Para detecção de árvore individual, use find_trees com o algoritmo lmfque é mais adequado para ITD. Esta função é um método mais genérico para vários fins, outrosdo que a segmentação de árvores. Esta função é paralelizada nativamente com OpenMP.Usofind_localmaxima (las, w, filtro = NULL)ArgumentoslasUm objeto da classe LASWnumérico. Forma de janela. 1 número para o diâmetro de um disco, 2 números paraum retângulo (largura, altura), 3 números para um retângulo orientado (largura, altura,ângulo). O ângulo deve ser em radianos.filtroFórmula. Maneira eficiente de memória para trabalhar apenas com um subconjunto de dados semcriando uma cópia dos dados.ValorSpatialPointsDataFrame com atributos do ponto correspondente no objeto LAS,

48find_treesExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyzi”, filter = “-drop_z_below 0 -keep_random_fraction 0.5”)# Usando um retângulo de 20×5 com um ângulo de 45 graus.# Isso não vai encontrar a árvore corretamente no caso geral# mas pode encontrar alguma estrutura orientada.lm = find_localmaxima (las, c (20, 5, pi / 4))enredo (lm)find_treesDetecção de árvore individualDescriçãoFunção de detecção de árvore individual que encontra a posição das árvores usando vários algoritmos possíveis.Usofind_trees (las, algoritmo, unicidade = “incremental”)ArgumentoslasUm objeto da classe LAS ou LAScatalog. Também pode ser um RasterLayer representandoum modelo de altura de dossel, caso em que é processado como umNuvem.algoritmoUm algoritmo para detecção de árvore individual. lidR tem: lmf e manual. Maisalgoritmos experimentais podem ser encontrados no pacote lidRplugins.singularidadepersonagem. Um método para calcular um ID exclusivo. Pode ser ‘incremental’, ‘gpstime’ou ‘bitmerge’. Consulte a seção ‘Unicidade’. Este recurso deve ser considerado como’experimental’.ValorUm SpatialPointsDataFrame com um atributo Z para os topos das árvores e treeID com um ID individual paracada árvore.SingularidadePor padrão, os IDs das árvores são numerados de 1 a n, sendo n o número de árvores encontradas. O problemacom tal numeração incremental é que, embora garanta que um ID único seja atribuído a cada árvoreem uma determinada nuvem de pontos, ele também garante a duplicação de IDs de árvore em diferentes blocos ou pedaços quandoprocessando um LAScatalog. Isso ocorre porque cada arquivo é processado independentemente dos outros epotencialmente em paralelo em computadores diferentes. Assim, o índice sempre reinicia em 1 em cada arquivo oupedaço. Pior, em um processo de segmentação de árvore, uma árvore que está localizada exatamente entre 2 arquivos terádois IDs diferentes para suas duas metades.

find_trees49É por isso que introduzimos algumas estratégias de exclusividade que são todas imperfeitas e que devem ser vistascomo experimental. Relate qualquer solução de problemas. Usar uma estratégia segura de exclusividade garante queárvores de arquivos diferentes não compartilharão os mesmos IDs. Além disso, também significa que duas metades de umárvore na borda de um bloco de processamento receberá o mesmo ID.Número incremental de 0 a n. Este método não garante a exclusividade dos IDs. Isto é ométodo legado.gpstime Este método usa gpstime do ponto mais alto de uma árvore (apex) para criar um ID exclusivo.Este ID não é um número inteiro, mas um número decimal de 64 bits que é subótimo, mas pelo menos éEspera-se que seja exclusivo se o atributo gpstime for consistente entre os arquivos. Se inconsistênciascom gpstime são relatados (por exemplo gpstime registra o horário da semana e foi redefinido para 0 emuma cobertura que leva mais de uma semana para ser concluída), há uma (baixa) probabilidade de obter IDerros de atribuição.bitmerge Este método usa as coordenadas XY do ponto mais alto (vértice) de uma árvore para criar umnúmero único com uma operação bit a bit. Primeiro, as coordenadas XY são convertidas em inteiros usandoas escalas e deslocamentos da nuvem de pontos. Em seguida, o ID é calculado com X * 2 ^ 32 + Y paracombine duas vezes os 32 bits de informação em um número de 64 bits. Por exemplo, se o ápice éem (10.32, 25.64) com um fator de escala de 0,01 e um deslocamento de 0, as coordenadas inteiras são X= 1032 e Y = 2564 e o ID é 4432406252036. Esses métodos retornam um número inteiro de 64 bitsmas como não existem inteiros de 64 bits em R, ele é convertido em um número decimal de 64 bits que égarantido como exclusivo se todos os arquivos tiverem os mesmos deslocamentos e fatores de escala.Todas as opções propostas são abaixo do ideal porque não garantem exclusividade em todoscasos (inconsistências na coleção de arquivos), ou eles implicam que os IDs são baseados em números não inteiros ounúmeros sem sentido. Mas, no mínimo, esperamos que isso funcione para casos simples.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída: os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER},{YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: Carrega apenas atributos de interesse.• filtro: Leia apenas pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyz”, filter = “-inside 481250 3812980 481300 3813030”)ttops <- find_trees (las, lmf (ws = 5))

50gap_fraction_profile#x = plot (las)# add_treetops3d (x, ttops)gap_fraction_profilePerfil de fração de lacunaDescriçãoCalcula o perfil da fração de lacuna usando o método de Bouvier et al. (ver referência)Usogap_fraction_profile (z, dz = 1, z0 = 2)Argumentoszvetor de coordenadas z positivasdznumérico. A espessura das camadas usadas (bin de altura)z0numérico. O limite inferior do perfilDetalhesA função avalia o número de pontos de laser que realmente alcançaram a camada z + dz e aqueles quepassou pela camada [z, z + dz]. Por definição, a camada 0 sempre retornará 0 porque não há retornospassar pelo chão. Portanto, a camada 0 é removida dos resultados retornados.ValorUm data.frame contendo as elevações do compartimento (z) e a fração do intervalo para cada compartimento (gf)ReferênciasBouvier, M., Durrieu, S., Fournier, R. a, & Renaud, J. (2015). Generalizando modelos preditivos deAtributos de inventário florestal usando uma abordagem baseada em área com dados aerotransportados. Sensoriamento Remoto deEnvironment, 156, 322-334. http://doi.org/10.1016/j.rse.2014.10.004Veja tambémRAPAZExemplosz <- c (rnorm (1e4, 25, 6), rgamma (1e3, 1, 8) * 6, rgamma (5e2, 5,5) * 10)z <- z [z <45 & z> 0]hist (z, n = 50)gapFraction = gap_fraction_profile (z)plot (gapFraction, type = “l”, xlab = “Elevation”, ylab = “Gap fração”)

Gatziolis201951Gatziolis2019Algoritmo de rastreamento de sensorDescriçãoEsta função é feita para ser usada em track_sensor. Ele implementa um algoritmo de Gatziolis eMcGaughey 2019 (ver referência) para rastreamento de sensor usando vários retornos para estimar a posiçãodo sensor, calculando a interseção no espaço das linhas que passam pelo primeiroe últimos retornos.UsoGatziolis2019 (SEGLENFactor = 1,0059, AngleFactor = 0,8824, deltaT = 0,5)ArgumentosSEGLENFactorescalar. Fator de ponderação para a distância b / w 1º e último retorno de pulsoAngleFactorescalar. Fator de ponderação para o ângulo de visão do pulso-mãe de um retornodeltaTescalar. Duração do TimeBlock (em segundos)DetalhesNo artigo original, duas etapas são descritas: (1) abordagem do ponto mais próximo (CPA) e (2) spline cúbicoapropriado. Tecnicamente, a etapa de ajuste de spline cúbica é uma etapa de pós-processamento e não está incluída nestealgoritmo.O código-fonte do algoritmo é uma ligeira modificação do código-fonte original fornecidocom o papel para caber no pacote lidR.Autor (es)Demetrios Gaziolis e Jean-Romain RousselReferênciasGatziolis, D., & McGaughey, RJ (2019). Reconstruindo Trajetórias de Aeronaves de Multi-RetornoDados de varredura a laser aerotransportados. Sensoriamento remoto, 11 (19), 2258.Exemplos# Um arquivo válido devidamente preenchidoLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (arquivo LAS)linhas de voo <- track_sensor (las, Gatziolis2019 ())plot (las @ header)plot (linhas de vôo, adicionar = TRUE)

52grid_canopygrid_canopyModelo Digital de SuperfícieDescriçãoCria um modelo de superfície digital (DSM) usando vários algoritmos possíveis. Se o usuário fornecer umnuvem de pontos normalizada, a saída é de fato um modelo de altura de dossel (CHM).Usogrid_canopy (las, res, algoritmo)ArgumentoslasUm objeto da classe LAS ou LAScatalog.resnumérico. A resolução do Raster de saída. Opcionalmente, pode ser um RasterLayer.Nesse caso, o RasterLayer é usado como layout.algoritmofunção. Uma função que implementa um algoritmo para calcular uma superfície digitalmodelo. lidR implementa p2r , dsmtin , pitfree (consulte a respectiva documentação eexemplos).ValorUm RasterLayer contendo um valor numérico em cada célula. Se os RasterLayers forem gravados no discoao executar a função com um LAScatalog, um mosaico raster virtual é retornado (ver gdalbuildvrt)Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog nas funções grid_ * (em negrito). Para mais detalhes vejaa documentação do motor LAScatalog:

grid_density53• tamanho do pedaço: quantos dados são carregados de uma vez. O tamanho do pedaço pode ser ligeiramente modificadointernamente para garantir uma saída de parede a parede contínua estrita, mesmo quando o tamanho do bloco é igual a 0(processamento por arquivo).• Chunk buffer: esta função garante uma saída estritamente contínua de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados. O alinhamento pode ser ligeiramente modificadointernamente para garantir uma saída estritamente contínua de parede a parede.• progresso: exibe uma estimativa de progresso.• arquivos de saída: retorna a saída em R ou grava a saída de cada cluster em um arquivo. Modelos suportadossão {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do pedaçoé igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: As funções grid_ * geralmente ‘sabem’ o que deve ser carregado e esta opção não éconsiderado. Em grid_metrics esta opção é respeitada.• filtro: Leia apenas os pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, filter = “-inside 481280 3812940 481330 3812990”)col <- height.colors (50)# Algoritmo de pontos para varredura com resolução de 1 metrochm <- grid_canopy (las, res = 1, p2r ())plot (chm, col = col)# Algoritmo Points-to-raster com resolução de 0,5 metros, substituindo cada um# ponto por um círculo de raio de 20 cm de 8 pontoschm <- grid_canopy (las, res = 0,5, p2r (0,2))plot (chm, col = col)# Triangulação básica e rasterização de primeiros retornoschm <- grid_canopy (las, res = 0,5, dsmtin ())plot (chm, col = col)# Khosravipour et al. algoritmo pitfreechm <- grid_canopy (las, res = 0,5, pitfree (c (0,2,5,10,15), c (0, 1,5)))plot (chm, col = col)grid_densityMapeie o pulso ou a densidade do pontoDescriçãoCria um mapa da densidade de pontos. Se um atributo “pulseID” for encontrado, também retorna um mapa do pulsodensidade.

54grid_densityUsogrid_density (las, res = 4)ArgumentoslasUm objeto da classe LAS ou LAScatalog.resnumérico. O tamanho de uma célula de grade em unidades de coordenadas de dados LiDAR. O padrão é 4 =16 metros quadrados.ValorUm RasterLayer ou um RasterBrick contendo um valor numérico em cada célula. Se os RasterLayerssão gravados no disco ao executar a função com um LAScatalog, um mosaico raster virtual é retornado(ver gdalbuildvrt)Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog nas funções grid_ * (em negrito). Para mais detalhes vejaa documentação do motor LAScatalog:• tamanho do pedaço: quantos dados são carregados de uma vez. O tamanho do pedaço pode ser ligeiramente modificadointernamente para garantir uma saída de parede a parede contínua estrita, mesmo quando o tamanho do bloco é igual a 0(processamento por arquivo).• Chunk buffer: esta função garante uma saída estritamente contínua de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados. O alinhamento pode ser ligeiramente modificadointernamente para garantir uma saída estritamente contínua de parede a parede.• progresso: exibe uma estimativa de progresso.• arquivos de saída: retorna a saída em R ou grava a saída de cada cluster em um arquivo. Modelos suportadossão {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do pedaçoé igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: As funções grid_ * geralmente ‘sabem’ o que deve ser carregado e esta opção não éconsiderado. Em grid_metrics esta opção é respeitada.• filtro: Leia apenas os pontos de interesse.

grid_metrics55ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (LASfile, filter = “-inside 684800 5017800 684900 5017900”)d <- grid_density (las, 5)plot (d)las <- retrieve_pulses (las)d <- grid_density (las)plot (d)grid_metricsAbordagem Baseada em ÁreaDescriçãoCalcula uma série de estatísticas descritivas definidas pelo usuário para um conjunto de dados LiDAR dentro de cada pixel de umraster (abordagem baseada em área). As coordenadas da célula da grade são pré-determinadas para uma determinada resolução,portanto, o algoritmo sempre fornecerá as mesmas coordenadas, independentemente do conjunto de dados. Quando começar= (0,0) e res = 20 grid_metrics irá produzir os seguintes centros celulares: (10,10), (10,30), (30,10)etc. alinhando o canto de uma célula em (0,0). Quando start = (-10, -10) e res = 20 grid_metrics iráproduz os seguintes centros de células: (0,0), (0,20), (20,0) etc. alinhando o canto de uma célula em (-10,-10).Usogrid_metrics (las, func, res = 20, start = c (0, 0), filter = NULL)ArgumentoslasUm objeto da classe LAS ou LAScatalog.funçãoFórmula. Uma expressão a ser aplicada a cada célula (consulte a seção “Função de parâmetro”).resnumérico. A resolução do Raster de saída. Opcionalmente, pode ser um RasterLayer.Nesse caso, o RasterLayer é usado como layout.começarvetor de coordenadas xey para o raster de referência. O padrão é (0,0), o que significaque a grade se alinha em (0,0).filtrofórmula de predicados lógicos. Permite que a função seja executada apenas em pontos deinteresse de forma otimizada. Veja exemplos.ValorUm RasterLayer ou um RasterBrick contendo um valor numérico em cada célula. Se os RasterLayerssão gravados no disco ao executar a função com um LAScatalog, um mosaico raster virtual é retornado(ver gdalbuildvrt)

56grid_metricsParâmetro funcA função a ser aplicada a cada célula é uma função clássica (ver exemplos) que retorna umlista de métricas. Por exemplo, a seguinte função f está formada corretamente.f = função (x) {lista (média = média (x), máx = máx (x))}E pode ser aplicado tanto nas coordenadas Z quanto nas intensidades. Essas duas declarações sãoválido:grid_metrics (las, ~ f (Z), res = 20)grid_metrics (las, ~ f (Intensidade), res = 20)As seguintes funções existentes permitem que o usuário calcule algumas métricas predefinidas:• stdmetrics• entropia• VCI• LADMas geralmente os usuários devem escrever suas próprias funções para criar métricas. grid_metrics irá despachar onuvem de pontos na função do usuário.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog nas funções grid_ * (em negrito). Para mais detalhes vejaa documentação do motor LAScatalog:• tamanho do pedaço: quantos dados são carregados de uma vez. O tamanho do pedaço pode ser ligeiramente modificadointernamente para garantir uma saída de parede a parede contínua estrita, mesmo quando o tamanho do bloco é igual a 0(processamento por arquivo).• Chunk buffer: esta função garante uma saída estritamente contínua de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados. O alinhamento pode ser ligeiramente modificadointernamente para garantir uma saída estritamente contínua de parede a parede.

grid_metrics57• progresso: exibe uma estimativa de progresso.• arquivos de saída: retorna a saída em R ou grava a saída de cada cluster em um arquivo. Modelos suportadossão {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do pedaçoé igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: As funções grid_ * geralmente ‘sabem’ o que deve ser carregado e esta opção não éconsiderado. Em grid_metrics esta opção é respeitada.• filtro: Leia apenas os pontos de interesse.Veja tambémOutras métricas: cloud_metrics(), hexbin_metrics(), point_metrics(), árvore_métrica(), voxel_metrics()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS)col = height.colors (50)# === Usando todos os pontos ===# Altura média com 400 m ^ 2 célulasmetrics = grid_metrics (las, ~ mean (Z), 20)plot (métricas, col = col)# Defina suas próprias novas métricasmyMetrics = function (z, i) {metrics = list (zwimean = sum (z * i) / sum (i), # elevação média ponderada por intensidadeszimean = média (z * i),# Produtos médios de z por intensidadezsqmean = sqrt (média (z ^ 2))) # Média quadráticaretorno (métricas)}metrics = grid_metrics (las, ~ myMetrics (Z, Intensity))plot (métricas, col = col)#plot (metrics, “zwimean”, col = col)#plot (metrics, “zimean”, col = col)# === Com filtros de pontos ===# Calcule usando apenas alguns pontos: básicoprimeiro = filter_poi (las, ReturnNumber == 1)metrics = grid_metrics (primeiro, ~ média (Z), 20)# Calcule usando apenas alguns pontos: otimizado# mais rápido e usa menos memória. Nenhum objeto intermediáriometrics = grid_metrics (las, ~ mean (Z), 20, filter = ~ ReturnNumber == 1)# Calcule usando apenas alguns pontos: melhor

58grid_terrain# ~ 50% mais rápido e usa ~ 10x menos memórialas = readLAS (LASfile, filter = “-keep_first”)metrics = grid_metrics (las, ~ mean (Z), 20)grid_terrainModelo Digital de TerrenoDescriçãoInterpola os pontos de solo e cria um modelo digital rasterizado do terreno. O algoritmo usa opontos classificados como “solo” e “água” (Classificação = 2 e 9, respectivamente, de acordo com o LASespecificações de formato de arquivo) para calcular a interpolação.O quão bem as bordas do conjunto de dados são interpoladas depende do método de interpolação usado. UMAbuffer em torno da região de interesse é sempre recomendado para evitar efeitos de borda.Usogrid_terrain (las,res = 1,algoritmo,…,keep_lowest = FALSE,full_raster = FALSE,use_class = c (2L, 9L),Wdegenerated = TRUE,is_concave = FALSE)ArgumentoslasUm objeto da classe LAS ou LAScatalog.resnumérico. A resolução do Raster de saída. Opcionalmente, pode ser um RasterLayer.Nesse caso, o RasterLayer é usado como layout.algoritmofunção. Uma função que implementa um algoritmo para calcular a interpolação espacialção. lidR implementa knnidw , tin, e kriging (ver a documentação respectivae exemplos)….Não utilizadokeep_lowestlógico. Esta opção força o ponto mais baixo do solo original de cada célula (seexiste) a ser escolhido em vez dos valores interpolados.full_rasterlógico. Por padrão, a interpolação é feita apenas dentro do casco convexo doNuvem. Isso evita interpolações sem sentido onde não há dados. E seTRUE, cada pixel do raster é interpolado.use_classvetor inteiro. Por padrão, o terreno é calculado usando pontos de solo (classe2) e pontos de água (classe 9).

grid_terrain59Wdegeneradológico. A função sempre verifica e remove pontos de aterramento degeneradospara calcular o DTM para evitar comportamentos inesperados, como elevação infinitação. Se TRUE, um aviso é lançado para alertar os usuários sobre a presença de degeneradospontos de aterramento.is_concaveboleano. Por padrão, a função tenta calcular um DTM que tem a mesma formacomo a nuvem de pontos interpolando apenas no casco convexo dos pontos. Se oa nuvem de pontos é côncava, o que pode levar a valores estranhos onde não há pontos.Use is_concave = TRUE para usar um casco côncavo. Isso é mais computacionalmente-envolvido e requer o pacote côncavo.ValorUm RasterLayer contendo um valor numérico em cada célula. Se os RasterLayers forem gravados no discoao executar a função com um LAScatalog, um mosaico raster virtual é retornado (ver gdalbuildvrt)Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog nas funções grid_ * (em negrito). Para mais detalhes vejaa documentação do motor LAScatalog:• tamanho do pedaço: quantos dados são carregados de uma vez. O tamanho do pedaço pode ser ligeiramente modificadointernamente para garantir uma saída de parede a parede contínua estrita, mesmo quando o tamanho do bloco é igual a 0(processamento por arquivo).• Chunk buffer: esta função garante uma saída estritamente contínua de parede a parede. O bufferopção não é considerada.• alinhamento de pedaços: Alinha os pedaços processados. O alinhamento pode ser ligeiramente modificadointernamente para garantir uma saída estritamente contínua de parede a parede.• progresso: exibe uma estimativa de progresso.• arquivos de saída: retorna a saída em R ou grava a saída de cada cluster em um arquivo. Modelos suportadossão {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do pedaçoé igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: A função ‘sabe’ o que deve ser carregado e esta opção não é considerada.• filtro: Leia apenas os pontos de interesse.

60hexbin_metricsExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (LASfile, filter = “-inside 273450 5274350 273550 5274450”)#plot (las)dtm1 = grade_terre (las, algoritmo = knnidw (k = 6L, p = 2))dtm2 = grid_terrain (las, algoritmo = tin ())## Não correr:dtm3 = grade_terre (las, algoritmo = krigagem (k = 10L))plot (dtm1)plot (dtm2)plot (dtm3)plot_dtm3d (dtm1)plot_dtm3d (dtm2)plot_dtm3d (dtm3)## End (não executado)hexbin_metricsAbordagem baseada em área em células hexagonais.DescriçãoCalcula uma série de estatísticas descritivas para um conjunto de dados LiDAR em células hexagonais. Esta funçãoé idêntico a grid_metrics, mas com células hexagonais em vez de pixels quadrados. Afinal, nós conduzimosinventários de plotagem circular e mapeamos modelos em mapas baseados em pixels. hexbin_metrics fornece ooportunidade de testar outra coisa. Consulte grid_metrics para obter mais informações.Usohexbin_metrics (las, func, res = 20)ArgumentoslasUm objeto da classe LAS.funçãoFórmula. Uma expressão a ser aplicada a cada célula hexagonal.resnumérico. Para ser consistente com grid_metrics, o quadrado de res dá a área deas células hexagonais, como em grid_metrics. A diferença é o fato de que parapixels quadrados, isso é óbvio. Aqui res = 20 dá 400 metros quadrados hexagonaiscélulas.ValorUm objeto hexbin do pacote hexbin ou uma lista de objetos hexbin se várias métricas forem retornadas.

Altíssima61Veja tambémOutras métricas: cloud_metrics(), grid_metrics(), point_metrics(), árvore_métrica(), voxel_metrics()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)lidar = readLAS (LASfile, filter = “-keep_random_fraction 0.5”)col = grDevices :: colorRampPalette (c (“blue”, “cyan2”, “yellow”, “red”))# Elevação máxima com resolução de 8 mhm = hexbin_metrics (lidar, ~ max (Z), 8)hexbin :: plot (hm, colramp = col, main = “Max Z”)# Altura média com resolução de 20 mhm = hexbin_metrics (lidar, ~ média (Z), 20)hexbin :: plot (hm, colramp = col, main = “Média Z”)# Defina suas próprias novas métricasmyMetrics = função (z, i){metrics = list (zwimean = sum (z * i) / sum (i), # elevação média ponderada por intensidadeszimean = média (z * i),# Produtos médios de z por intensidadezsqmean = sqrt (média (z ^ 2))# Média quadrática)retorno (métricas)}metrics = hexbin_metrics (lidar, ~ myMetrics (Z, Intensity), 10)hexbin :: plot (metrics $ zwimean, colramp = col, main = “zwimean”)#hexbin :: plot (metrics $ zimean, colramp = col, main = “zimean”)#hexbin :: plot (metrics $ zsqmean, colramp = col, main = “zsqmean”)AltíssimaAlgoritmo de Decimação de Nuvem de PontosDescriçãoEsta função é feita para ser usada em decimate_points. Ele implementa um algoritmo que cria uma gradecom uma determinada resolução e filtra a nuvem de pontos, selecionando o ponto mais alto em cada célula.Usomais alto (res = 1)

62homogeneizarArgumentosresnumérico. A resolução da grade usada para filtrar a nuvem de pontosVeja tambémOutros algoritmos de dizimação de nuvem de pontos: homogeneizar(), aleatório()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS, select = “xyz”)# Selecione o ponto mais alto dentro de cada célula de uma grade sobrepostathinned = decimate_points (las, maior (4))#plot (diluído)homogeneizarAlgoritmo de Decimação de Nuvem de PontosDescriçãoEsta função é feita para ser usada em decimate_points. Ele implementa um algoritmo que cria uma gradecom uma determinada resolução e filtra a nuvem de pontos selecionando aleatoriamente alguns pontos em cada célula. istoé projetado para produzir nuvens de pontos com densidades uniformes em toda a área de cobertura. Paracada célula, a proporção de pontos ou pulsos que serão retidos é calculada usando o local realdensidade e a densidade desejada. Se a densidade desejada for maior do que a densidade real, ele retornaum conjunto de pontos inalterado (não pode aumentar a densidade). O tamanho da célula deve ser grande o suficiente paracalcular uma densidade local coerente. Por exemplo, em uma nuvem de 2 pontos / m ^ 2 pontos, 25 metros quadradosseria viável; no entanto, células de 1 metro quadrado não seriam viáveis ​​porque a densidade nãotêm significado nesta escala.Usohomogeneizar (densidade, res = 5, use_pulse = FALSE)Argumentosdensidadenumérico. A densidade de saída desejada.resnumérico. A resolução da grade usada para filtrar a nuvem de pontosuse_pulselógico. Decime removendo pulsos aleatórios em vez de pontos aleatórios (re-deve executar retrieve_pulses primeiro)Veja tambémOutros algoritmos de dizimação de nuvem de pontos: mais alto(), aleatório()

é63ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS, select = “xyz”)# Selecione pontos aleatoriamente para alcançar uma densidade homogênea de 1thinned = decimate_points (las, homogeneize (1,5))plot (grid_density (thinned, 10))éUm conjunto de testes booleanos em objetosDescriçãois.empty testa se um objeto LAS é uma nuvem de pontos com 0 pontos.is.overlapping testa se um LAScatalog tem blocos sobrepostos.is.indexed testa se os pontos de um LAScatalog são indexados com arquivos .lax.is.algorithm testa se um objeto é um algoritmo do pacote lidR.is.parallelised testa se um algoritmo do pacote lidR é nativamente paralelizado com OpenMP.Retorna TRUE se o algoritmo estiver pelo menos parcialmente paralelizado, ou seja, se alguma parte do código forcalculado em paralelo.Usois.empty (las)is.overlapping (catálogo)is.indexed (catálogo)is.algorithm (x)is.parallelised (algoritmo)ArgumentoslasUm objeto LAS.CatálogoUm objeto LAScatalog.xQualquer objeto R.algoritmoUm objeto de algoritmo.ValorVerdadeiro ou falso

64ivfExemplosLASfile <- system.file (“extdata”, “exemplo.laz”, pacote = “rlas”)las = readLAS (arquivo LAS)is.empty (las)las = novo (“LAS”)is.empty (las)f <- lmf (2)is.parallelised (f)g <- pitfree ()is.parallelised (g)ctg <- readLAScatalog (LASfile)is.indexed (ctg)ivfAlgoritmo de segmentação de ruídoDescriçãoEsta função é feita para ser usada em classify_noise. Ele implementa um algoritmo para outliers (ruído)segmentação baseada em filtro de voxels isolados (FIV). É semelhante ao lasnoise de lastools. oo algoritmo encontra pontos que possuem apenas alguns outros pontos em torno de 3 x 3 x 3 = 27 voxels.Usoivf (res = 5, n = 6)Argumentosresnumérico. Resolução dos voxelsninteiro. O número máximo de ‘outros pontos’ nos 27 voxelsVeja tambémOutros algoritmos de segmentação de ruído: sor()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (LASfile, filter = “-inside 273450 5274350 273550 5274450”)# Adicione alguns outliers artificiaisset.seed (314)id = round (runif (20, 0, npoints (las)))set.seed (42)err = runif (20, -50, 50)

Knnidw65las $ Z [id] = las $ Z [id] + errlas <- classify_noise (las, ivf (5,2))KnnidwAlgoritmo de Interpolação EspacialDescriçãoEsta função é feita para ser usada em grid_terrain ou normalize_height. Ele implementa um algoritmopara interpolação espacial. A interpolação é feita usando uma abordagem de k-vizinho mais próximo (KNN) com umponderação de distância inversa (IDW).Usoknnidw (k = 10, p = 2, rmax = 50)Argumentoskinteiro. Número de k-vizinhos mais próximos. Padrão 10.pnumérico. Potência para ponderação de distância inversa. Padrão 2.rmaxnumérico. Raio máximo onde pesquisar por knn. Padrão 50.Veja tambémOutros algoritmos de interpolação espacial: krigagem(), lata()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (arquivo LAS)#plot (las)dtm = grid_terrain (las, algoritmo = knnidw (k = 6L, p = 2))#plot (dtm, col = terrain.colors (50))# plot_dtm3d (dtm)

66krigagemkrigagemAlgoritmo de Interpolação EspacialDescriçãoEsta função é feita para ser usada em grid_terrain ou classify_ground. Ele implementa um algoritmopara interpolação espacial. A interpolação espacial é baseada na krigagem universal usando a função krigedo gstat. Este método combina a abordagem KNN com a abordagem de krigagem. Para cada pontode interesse, ele faz a krigagem do terreno usando os k pontos de solo vizinhos mais próximos. Este método é maisdifícil de manipular, mas também é o método mais avançado para interpolação de dados espaciais.Usokrigagem (modelo = gstat :: vgm (0,59, “Sph”, 874), k = 10L)ArgumentosmodeloUm modelo de variograma calculado com vgm. Se NULL, ele executa um normal ouprevisão de mínimos quadrados ponderados.knumérico. Número de k-vizinhos mais próximos. Padrão 10.Veja tambémOutros algoritmos de interpolação espacial: knnidw(), lata()Exemplos## Não correr:LASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (arquivo LAS)# plot (las)dtm = grid_terrain (las, algoritmo = kriging ())plot (dtm, col = terrain.colors (50))plot_dtm3d (dtm)## End (não executado)

RAPAZ67RAPAZDensidade da área foliarDescriçãoCalcula um perfil de densidade de área foliar com base no método de Bouvier et al. (ver referência)UsoLAD (z, dz = 1, k = 0,5, z0 = 2)Argumentoszvetor de coordenadas z positivasdznumérico. A espessura das camadas usadas (bin de altura)knumérico. é o coeficiente de extinçãoz0numérico. O limite inferior do perfilDetalhesA função avalia o número de pontos de laser que realmente alcançaram a camada z + dz e aquelesque passou pela camada [z, z + dz] (ver gap_fraction_profile) Em seguida, ele calcula o log destequantidade e divide-a pelo coeficiente de extinção k conforme descrito em Bouvier et al. Por definição, oa camada 0 sempre retornará infinito porque nenhum retorno passa pelo solo. Portanto, a camada0 é removido dos resultados retornados.ValorUm data.frame contendo as elevações do compartimento (z) e a densidade da área foliar para cada compartimento (lad)ReferênciasBouvier, M., Durrieu, S., Fournier, R. a, & Renaud, J. (2015). Generalizando modelos preditivos deAtributos de inventário florestal usando uma abordagem baseada em área com dados aerotransportados. Sensoriamento Remoto deEnvironment, 156, 322-334. http://doi.org/10.1016/j.rse.2014.10.004Veja tambémgap_fraction_profileExemplosz <- c (rnorm (1e4, 25, 6), rgamma (1e3, 1, 8) * 6, rgamma (5e2, 5,5) * 10)z <- z [z <45 & z> 0]rapaz <- LAD (z)plot (lad, type = “l”, xlab = “Elevation”, ylab = “Leaf area density”)

68Classe LASClasse LASUma classe S4 para representar um arquivo .las ou .lazDescriçãoA classe LAS é a representação de um arquivo las / laz de acordo com as especificações de formato de arquivo LAS.UsoLAS (dados, cabeçalho = lista (), proj4string = sp :: CRS (), verificação = TRUE, índice = NULL)Argumentosdadosum data.table contendo os dados de um arquivo las ou laz.cabeçalhouma lista ou um LASheader contendo o cabeçalho de um arquivo las ou laz.proj4stringstring de projeção da classe CRS-class.Verificalógico. Testes de conformidade durante a construção do objeto.índicelista com lista de dois elementos (sensor = 0L, índice = 0L). Veja indexação espacialDetalhesUm objeto LAS herda um objeto espacial de sp. Portanto, é um objeto espacial mais um data.table comos dados lidos de um arquivo las / laz e um LASheader (consulte a documentação ASPRS para o arquivo LASformato para mais informações). Porque os arquivos são padronizados, a tabela de atributos lidos deo arquivo las / laz também é padronizado. As colunas são nomeadas:• X (numérico)• Y (numérico)• Z (numérico)• gpstime (numérico)• Intensidade (inteiro)• ReturnNumber (inteiro)• NumberOfReturns (inteiro)• ScanDirectionFlag (inteiro)• EdgeOfFlightline (inteiro)• Classificação (inteiro)• Synthetic_flag (lógico)• Keypoint_flag (lógico)• Withheld_flag (lógico)• ScanAngleRank (inteiro)• ScanAngle (numérico)• UserData (inteiro)• PointSourceID (inteiro)• R, G, B (inteiro)• NIR (inteiro)

Classe LAS69ValorUm objeto da classe LASFunções• LAS: cria objetos da classe LAS. Os dados originais são atualizados por referência para quantizar ocoordenadas de acordo com o fator de escala do cabeçalho se nenhum cabeçalho for fornecido. Nesse casoo fator de escala é definido como 0,001Slotsbbox Objeto de matriz de classe, com caixa delimitadoraproj4string Objeto da classe CRS, string de projeçãodata Objeto da classe data.table. Dados de nuvem de pontos de acordo com o formato de arquivo LASheader Objeto da classe LASheader. cabeçalho do arquivo las de acordo com o formato de arquivo LASlista de índice. Veja indexação espacial.EstendeClasse Espacial, diretamente.Veja tambémreadLASExemplos# Leia um arquivo las / lazLASfile <- system.file (“extdata”, “exemplo.laz”, pacote = “rlas”)las <- readLAS (arquivo LAS)las# Criação de um objeto LAS a partir de dados externosdata <- data.frame (X = runif (100, 0, 100),Y = runif (100, 0, 100),Z = runif (100, 0, 20))# dados têm muitos dígitos decimaisdados# Crie um cabeçalho padrão e quantize * por referência *# as coordenadas para ajustar com os fatores de deslocamento e escalanuvem <- LAS (dados)# dados foram atualizados e as coordenadas foram quantizadasdadosnuvem# Tenha cuidado ao fornecer um cabeçalho, a função assume que# corresponde aos dados e não quantiza as coordenadas

70Classe LAScatalogdata <- data.frame (X = runif (100, 0, 100),Y = runif (100, 0, 100),Z = runif (100, 0, 20))header <- las @ header# Isso funciona, mas dispara avisos e cria um objeto LAS inválidonuvem <- LAS (dados, cabeçalho)las_check (nuvem)Classe LAScatalogUma classe S4 para representar um catálogo de arquivos .las ou .lazDescriçãoUm objeto LAScatalog é uma representação de um conjunto de arquivos las / laz. Um LAScatalog é uma maneira de gerenciare processar um conjunto de dados inteiro. Ele permite que o usuário processe uma grande área ou recorte dados seletivamentede uma grande área sem carregar todos os dados na memória do computador. Um LAScatalog pode ser construídocom a função readLAScatalog e é formalmente uma extensão de um SpatialPolygonsDataFramecontendo dados extras para permitir aos usuários maior controle sobre como o conjunto de dados é processado (consulte os detalhes).DetalhesUm LAScatalog é formalmente um SpatialPolygonsDataFrame estendido com novos slots que contêmopções de processamento. Em lidR, cada função que suporta um LAScatalog como entrada respeitará estesopções de processamento. Internamente, o processamento de um catálogo é quase sempre o mesmo e depende apenas de umpoucos passos:1. Defina os pedaços. Um pedaço é uma região de interesse (ROI) definida arbitrariamente do catálogo. Alto-juntos, os pedaços são um conjunto completo de ROIs que abrangem todo o conjunto de dados.2. Faça um loop em cada pedaço (em paralelo ou não).3. Para cada pedaço, carregue os pontos dentro da ROI em R, execute algumas funções R, retorne o ex-saída selecionada.4. Combine as saídas dos diferentes pedaços, uma vez que todos eles são processados ​​para construir um contínuosaída (parede a parede).Então, basicamente, um LAScatalog é um objeto que permite o processamento em lote, mas com a especificidade quelidR não faz um loop através dos arquivos las, mas executa um loop continuamente através de pedaços que não necessariamentecoincidir com o padrão do arquivo. Desta forma, lidR pode processar sequencialmente ROIs minúsculas, mesmo que cada arquivo possaser individualmente grande demais para caber na memória. É também por isso que a indexação de nuvem de pontos com arquivos lax podeacelerar significativamente o processamento.É importante notar que catálogos com arquivos que se sobrepõem não são suportados nativamentepor lidR. Ao encontrar tais conjuntos de dados, o usuário deve sempre filtrar quaisquer sobreposições, se possível.Isso é possível se os pontos sobrepostos forem marcados, por exemplo, no atributo ‘retido’. Oth-erwise, lidR não será capaz de processar o conjunto de dados corretamente.

Classe LAScatalog71Slotsprocessing_options list. Uma lista que contém algumas configurações que descrevem como o catálogo seráprocessado (consulte a seção dedicada).lista chunk_options. Uma lista que contém algumas configurações que descrevem como o catálogo será sub-dividido em blocos a serem processados ​​(consulte a seção dedicada).lista output_options. Uma lista que contém algumas configurações que descrevem como o catálogo retornará osaídas (consulte a seção dedicada).lista de opções_de_entrada. Uma lista de parâmetros a serem transmitidos ao readLAS (consulte a seção dedicada).lista de índice. Veja indexação espacial.Opções de processamentoO slot @processing_options contém uma lista de opções que determinam como os blocos (o subáreas que são processadas sequencialmente) são processadas.• progress: booleano. Exibe uma barra de progresso e um gráfico de progresso. O padrão é TRUE. Progressoa estimativa pode ser aprimorada instalando o progresso do pacote. Veja opt_progress.• stop_early: booleano. Pare o processamento se ocorrer um erro em um pedaço. Se FALSO o processopode ser executado até o fim, removendo os pedaços que falharam. O padrão é TRUE e o usuário deve ternenhuma razão para mudar isso. Veja opt_stop_early.• wall.to.wall lógico. O motor de processamento de catálogo sempre garante o retorno contínuosaída sem efeitos de borda, assumindo que o catálogo é um catálogo completo. Para fazer isso,algumas opções são verificadas internamente para proteger contra configurações incorretas, como buffer = 0 para umalgoritmo que requer um buffer. Em casos raros, pode ser útil desativar esses controles. E sewall.to.wall = Os controles FALSE estão desabilitados e as saídas de parede a parede não podem ser garantidas.Veja opt_wall_to_wallOpções de pedaçosO slot @chunk_options contém uma lista de opções que determinam como os blocos (as sub-áreas quesão processados ​​sequencialmente).• chunk_size: numérico. O tamanho dos blocos que serão processados ​​sequencialmente. Um tamanho pequenopermite que pequenas quantidades de dados sejam carregadas de uma vez, economizando memória do computador e vice-versa.O cálculo geralmente é mais rápido, mas usa muito mais memória. Se chunk_size = 0 o catálogoé processado sequencialmente por arquivo, ou seja, um pedaço é um arquivo. O padrão é 0, ou seja, o processamento padrãoo motor respeita o padrão de tiling existente. Veja opt_chunk_size.• buffer: numérico. Cada pedaço pode ser lido com um buffer extra ao seu redor para garantir que hajasem efeitos de borda entre dois blocos independentes e que a saída é contínua. Isto éobrigatório para alguns algoritmos. O padrão é 30. Consulte opt_chunk_buffer.• alinhamento: numérico. Um vetor de tamanho 2 (coordenadas xey, respectivamente) para alinhar o pedaçopadronizar. Por padrão, o alinhamento é feito ao longo de (0,0), o que significa que a borda do primeiro pedaçopertencerá a x = 0 ey = 0 e todos os outros blocos serão múltiplos do tamanho do bloco.Não é relevante se chunk_size = 0. Consulte opt_chunk_alignment.

72Classe LAScatalogOpções de saídaO slot @output_options contém uma lista de opções que determinam como os blocos (as sub-áreasque são processados ​​sequencialmente) são gravados. Por “escrito” queremos dizer escrito em arquivos ou escrito em Rmemória.• output_files: string. Se output_files = “”, as saídas são retornadas em R. Caso contrário, se output_filesé uma string em que as saídas serão gravadas em arquivos. Isso é útil se a saída for muito grande para ser refeitatransformou em R. Um caminho para um modelo de nome de arquivo sem extensão (o mecanismo adivinha isso para você) éesperado. Quando vários arquivos forem gravados, uma única string é fornecida com um modeloque é preenchido automaticamente. Por exemplo, os seguintes nomes de arquivo são possíveis:”/ home / user / als / normalized / file_ {ID} _segmented””C: / user / document / als / zone52_ {XLEFT} _ {YBOTTOM} _confidencial””C: / user / document / als / {ORIGINALFILNAME} _normalized”Esta opção irá gerar quantos nomes de arquivo forem necessários com nomes personalizados para cada arquivo. oA lista de modelos permitidos é descrita na documentação de cada função. Veja opt_output_files.• drivers: lista. Este contém todos os drivers necessários para escrever perfeitamente Raster *, Spatial *, sf,e objetos LAS. Recomenda-se que apenas usuários avançados alterem esta opção. Um dedicadopágina descreve os drivers em lidR-LAScatalog-drivers.• merge: booleano. Vários objetos são mesclados em um único objeto no final do processamento.Opções de entradaO slot @input_options contém uma lista de opções que são passadas para a função readLAS.Na verdade, a função readLAS não é chamada diretamente pelo usuário, mas pelo mecanismo de processamento interno.Os usuários podem propagar essas opções por meio das configurações do LAScatalog.• selecionar: string. A opção de seleção. Normalmente, esta opção não é respeitada porque cada funçãosabe quais dados devem ser carregados ou não. Isso está documentado em cada função. Veja opt_select.• filtro: string. A opção de filtro. Veja opt_filter.Exemplos## Não correr:# Construa um catálogoctg <- readLAScatalog (“filder / to / las / files /”)# Defina algumas opçõesopt_filter (ctg) <- “-keep_first”# Resumo fornece um resumo de como o catálogo será processadoresumo (ctg)# Podemos usar perfeitamente as funções lidRhmean <- grid_metrics (ctg, mean (Z), 20)ttops <- tree_detection (ctg, lmf (5))# Para configuração de pouca memória, provavelmente é aconselhável não carregar arquivos inteiros# e pedaços de processo em vez disso

LASheader73opt_chunk_size (ctg) <- 500# Às vezes, a saída provavelmente será muito grande# por exemplo, grande cobertura e pequena resoluçãodtm <- grid_terrain (ctg, 1, tin ())# Nesse caso, é aconselhável gravar a (s) saída (s) nos arquivosopt_output_files (ctg) <- “caminho / para / pasta / DTM_chunk_ {XLEFT} _ {YBOTTOM}”# Raster será gravado no disco. A lista de arquivos gravados é retornada# ou, neste caso específico, um mosaico raster virtual.dtm <- grid_terrain (ctg, 1, tin ())# Quando os pedaços são arquivos, os nomes originais dos arquivos podem ser preservadosopt_chunk_size (ctg) <- 0opt_output_files (ctg) <- “caminho / para / pasta / DTM_ {ORIGINALFILENAME}”dtm <- grid_terrain (ctg, 1, tin ())# Para algumas funções, os arquivos DEVEM ser gravados no disco. Na verdade, é certo que R não pode# trata de toda a saída.opt_chunk_size (ctg) <- 0opt_output_files (ctg) <- “caminho / para / pasta / {ORIGINALFILENAME} _norm”opt_laz_compression (ctg) <- TRUEnew_ctg <- normalize_height (ctg, tin ())# O usuário tem acesso ao mecanismo de catálogo por meio da função catalog_applyoutput <- catalog_apply (ctg, FUN, …)## End (não executado)LASheaderCrie um objeto LASheaderDescriçãoCrie um objeto LASheaderUsoLASheader (dados = lista ())Argumentosdadosuma lista contendo os dados do cabeçalho de um arquivo las.ValorUm objeto da classe LASheader

74las_checkClasse LASheaderUma classe S4 para representar o cabeçalho de arquivos .las ou .lazDescriçãoUma classe S4 para representar o cabeçalho de arquivos .las ou .laz de acordo com o formato de arquivo LAS especificadocátions. Um objeto LASheader contém uma lista no slot @PHB com os dados lidos do PúblicoBloco de cabeçalho e lista no slot @VLR com os dados lidos dos registros de comprimento variávelSlotsLista PHB. Representa o Bloco de Cabeçalho PúblicoLista VLR. Representa os Registros de Comprimento Variávellas_checkInspecione um objeto LASDescriçãoExecuta uma inspeção profunda de um objeto LAS ou LAScatalog e imprime um relatório.Para um objeto LAS, ele verifica:• se a nuvem de pontos é válida de acordo com a especificação las• se o cabeçalho é válido de acordo com as especificações• se a nuvem de pontos está de acordo com o cabeçalho• se a nuvem de pontos tiver pontos duplicados e pontos básicos degenerados• se o sistema de referência de coordenadas está registrado corretamente• se algum pré-processamento, como normalização ou filtragem de aterramento, já foi feito.Para um objeto LAScatalog, ele verifica:• se os cabeçalhos são consistentes entre os arquivos• se os arquivos estiverem sobrepostos• se algum pré-processamento, como normalização, já foi feito.Para os testes de pré-processamento, a função apenas faz uma estimativa e pode não estar correta.Usolas_check (las, imprimir = TRUE, …)

las_utilities75ArgumentoslasUm objeto da classe LAS ou LAScatalog.impressãológico. Por padrão, imprime um relatório na saída padrão. Se imprimir = FALSE ofunções retorna uma lista com dois elementos chamados ‘avisos’ e ‘erros’manter um vetor com os avisos e erros relatados….Use deep = TRUE apenas em um LAScatalog. Em vez de uma inspeção superficial, ele lêtodos os arquivos e realiza uma inspeção profunda.ValorUma lista com dois elementos denominados avisos e erros. Esta lista é retornada invisivelmente se print =VERDADEIRO. Se deep = TRUE, uma lista aninhada é retornada com um elemento por arquivo.Veja tambémOutros utilitários do las: las_utilitiesExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS)las_check (las)las_utilitiesUtilitários LASDescriçãoFerramentas para manipular objetos LAS mantendo a conformidade com a especificação ASPRSUsolas_rescale (las, xscale, yscale, zscale)las_reoffset (las, xoffset, yoffset, zoffset)las_quantize (las, by_reference = TRUE)las_update (las)quantize (x, escala, deslocamento, by_reference = TRUE, …)is.quantized (x, escala, deslocamento, …)count_not_quantized (x, escala, deslocamento)storable_coordinate_range (escala, deslocamento)

76las_utilitiesArgumentoslasUm objeto da classe LASxscale, yscale, zscaleescalar. Pode estar faltando se não for relevante.xoffset, yoffset, zoffsetescalar. Pode estar faltando se não for relevante.por referênciabool. Atualize os dados no local sem alocar nova memória.xnumérico. Vetor de coordenadasescala, deslocamentoescalar. escala e deslocamento…Não utilizado.DetalhesNa especificação do formato LAS, espera-se que as coordenadas sejam fornecidas com um certoprecisão, por exemplo, 0,01 para uma precisão de milímetro (ou milife), o que significa que um arquivo registra, por exemplo, 123,46não 123,45678. Além disso, as coordenadas são armazenadas como inteiros. Isso é possível com uma escala efator de deslocamento. Por exemplo, 123,46 com um deslocamento de 100 e um fator de escala de 0,01 é realmente armazenadocomo (123,46 – 100) / 0,01 = 2346. Armazenando 123,45678 com um fator de escala de 0,01 e um deslocamento de 100é inválido porque não se converte em um número inteiro: (123.45678-100) /0.01 = 2345.678. Tendoum objeto LAS inválido pode ser crítico em alguns aplicativos lidR. Ao gravar em um arquivo LAS,os usuários perderão a precisão extra sem aviso e alguns algoritmos em lidR usam o inteiroconversão para fazer computação baseada em inteiros e, assim, acelerar alguns algoritmos e usar menosmemória. A criação de um objeto LAS inválido pode causar problemas e saídas incorretas.Veja tambémOutros utilitários do las: las_check()ExemplosLASfile <- system.file (“extdata”, “exemplo.laz”, pacote = “rlas”)las = readLAS (arquivo LAS)# Modificação manual das coordenadas (por exemplo, rotação, realinhamento, …)las @ data $ X <- las @ data $ X + 2/3las @ data $ Y <- las @ data $ Y – 5/3# A nuvem de pontos não é mais válidalas_check (las)# É importante consertar issolas_quantize (las)# Agora o arquivo é quase válidolas_check (las)# Atualize o objeto para configurar os dados do cabeçalho atualizadoslas <- las_update (las)las_check (las)

li201277# Na prática, o código acima não é útil para usuários regulares porque os operadores# $ <- já realiza tais operações em tempo real. Assim, o seguinte# sintaxe deve ser preferida e retorna objetos válidos. Ferramentas anteriores# destinam-se a ser usados ​​apenas em casos muito específicos.las $ X <- las $ X + 2/3las $ Y <- las $ Y – 5/3# Redimensionar e deslocar, recalcular as coordenadas com# novas escalas e deslocamentos de acordo com a especificação LASlas <- las_rescale (las, xscale = 0,01, yscale = 0,01)las <- las_reoffset (las, xoffset = 300000, yoffset = 5248000)li2012Algoritmo de segmentação de árvore individualDescriçãoEstas funções são feitas para serem usadas em segment_trees. Ele implementa um algoritmo para segmentação de árvoreção baseada em Li et al. (2012) artigo (ver referência). Este método é um método de região de crescimentotrabalhando no nível da nuvem de pontos. É uma implementação, o mais estrita possível, feita pelo lidRautor, mas com a adição de um parâmetro hmin para evitar a segmentação excessiva para objetos que sãomuito baixo.Usoli2012 (dt1 = 1,5, dt2 = 2, R = 2, Zu = 15, hmin = 2, speed_up = 10)Argumentosdt1numérico. Limiar número 1. Consulte a página de referência 79 em Li et al. (2012). Padrãoé 1,5.dt2numérico. Limiar número 2. Consulte a página de referência 79 em Li et al. (2012). Padrãoé 2.Rnumérico. Raio de pesquisa. Consulte a página 79 em Li et al. (2012). O padrão é 2. Se R = 0todos os pontos são considerados automaticamente como máximos locais e a etapa de pesquisaé ignorado (muito mais rápido).Zunumérico. Se a elevação do ponto for maior que Zu, dt2 é usado, caso contrário, dt1 é usado.Consulte a página 79 em Li et al. (2012). O padrão é 15.hminnumérico. Altura mínima de uma árvore detectada. O padrão é 2.acelerarnumérico. Raio máximo de uma coroa. Qualquer valor maior que uma coroa é bomporque este parâmetro não afeta o resultado. No entanto, isso afeta muito ovelocidade de computação. Quanto menor o valor, mais rápido é o método. O padrão é 10.ReferênciasLi, W., Guo, Q., Jakubowski, MK, & Kelly, M. (2012). Um novo método para segmentação individualárvores da nuvem de pontos lidar. Photogrammetric Engineering & Remote Sensing, 78 (1), 75-84.

78lidR-LAScatalog-driversVeja tambémOutros algoritmos de segmentação de árvore individual: dalponte2016(), silva2016(), divisor de águas()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyz”, filter = “-drop_z_below 0”)col <- pastel.colors (200)las <- segment_trees (las, li2012 (dt1 = 1,4))#plot (las, color = “treeID”, colorPalette = col)lidR-LAScatalog-driversDrivers LAScatalogDescriçãoEste documento explica como os objetos são gravados no disco durante o processamento de um LAScatalog. Como homens-nado em LAScatalog de classe, os usuários podem definir um nome de arquivo modelo para armazenar as saídas no discode na memória R. Por padrão, os objetos LAS são armazenados em arquivos .las com writeLAS, Objetos Raster *são armazenados em arquivos .tif com writeRaster, Os objetos espaciais * são armazenados em arquivos .shp com writeOGR,Os objetos data.frame são armazenados em arquivos .csv com fwrite, e outros objetos não são suportados. Quão-sempre, os usuários podem modificar todas essas configurações padrão e até mesmo adicionar novos drivers. Esta página do manual explicaquão. Pode-se também consultar alguma documentação não oficial aqui ou aqui.Forma genérica de um driverUm driver é armazenado no slot @output_options de um LAScatalog. É uma lista que contém:write Uma função que recebe um objeto e um caminho e grava o objeto em um arquivo usando o caminho.A função também pode ter opções extras.extensão Uma string que fornece a extensão do arquivo.objeto Uma string que dá o nome do argumento usado para passar o objeto para escrever na funçãousado para escrever o objeto.caminho Uma string que dá o nome do argumento usado para passar o caminho do arquivo para escrever nofunção usada para escrever o objeto.param Uma lista rotulada de parâmetros extras para a função usada para escrever o objetoPor exemplo, o driver para escrever um Raster * éLista(write = raster :: writeRaster,extension = “.tif”,objeto = “x”,caminho = “nome do arquivo”,param = list (format = “GTiff”))

lidR-LAScatalog-drivers79E o driver para escrever um LAS éLista(write = lidR :: writeLAS,extension = “.las”,objeto = “las”,caminho = “arquivo”,param = list ())Modificar um driver (1/2)Os usuários podem modificar os drivers para gravar tipos de arquivo diferentes do padrão. Por exemplo, para escrever emGeoPackage em vez de shapefile, deve-se mudar o driver Spatial:ctg @ output_options $ drivers $ Spatial $ extension <- “.gpkg”Para gravar em arquivos .grd em vez de arquivos .tif, é necessário alterar o driver Raster:ctg @ output_options $ drivers $ Raster $ extension <- “.grd”ctg @ output_options $ drivers $ Raster $ param $ format <- “raster”Para gravar em arquivos .laz em vez de arquivos .las, é necessário alterar o driver LAS:ctg @ output_options $ drivers $ LAS $ extension <- “.laz”Adicionar um novo driverOs drivers permitem que objetos LAS, Spatial *, Raster * e data.frame sejam gravados. Ao usar omotor (catalog_apply) para construir novas ferramentas, os usuários podem precisar ser capazes de escrever outros objetos, comouma lista. Para fazer isso, os usuários precisam adicionar um elemento de lista em output_options:ctg @ output_options $ drivers $ list = list (write = base :: saveRDS,objeto = “objeto”,caminho = “arquivo”,extension = “.rds”,param = list (compress = TRUE))O LAScatalog agora tem um novo driver capaz de escrever uma lista.Modificar um driver (2/2)Também é possível sobrescrever completamente um driver existente. Por padrão, SpatialPointsDataFrameobjetos são escritos em shapefiles ESRI com writeOGR. writeOGR pode gravar em outros tipos de arquivo,como GeoPackage ou GeoJSON e até mesmo como objetos de banco de dados SQLlite. Mas não pode adicionar dados emum banco de dados SQLlite existente. Vamos criar nosso próprio driver para um SpatialPointsDataFrame. Primeiroprecisamos de uma função capaz de escrever e anexar um SpatialPointsDataFrame em um banco de dados SQLlitedo objeto e do caminho.

80lidR-paralelismodbWrite_SpatialPointsDataFrame = função (x, caminho, nome){x <- as.data.frame (x)con <- RSQLite :: dbConnect (RSQLite :: SQLite (), caminho)RSQLite :: dbWriteTable (con, nome, x, append = TRUE)RSQLite :: dbDisconnect (con)}Em seguida, criamos o driver. Os drivers definidos pelo usuário substituem os drivers padrão:ctg @ output_options $ drivers $ SpatialPointsDataFrame = list (write = dbWrite_SpatialPointsDataFrame,extension = “.sqlite”,objeto = “x”,caminho = “caminho”,param = list (name = “layername”))Então, para ter certeza de que não gravamos vários arquivos .sqlite, não usamos um nome de arquivo modelo.opt_output_files (ctg) <- paste0 (tempdir (), “/ mysqlitefile”)E todos os SpatialPointsDataFrame serão anexados em um único banco de dados.lidR-paralelismoCálculo paralelo em lidRDescriçãoEste documento explica como processar nuvens de pontos aproveitando o processamento paralelo nopacote lidR. O pacote lidR tem dois níveis de paralelismo, é por isso que é difícil entenderveja como funciona. Esta página tem como objetivo fornecer aos usuários uma visão geral clara de como tirar proveitode processamento multicore, mesmo que não se sintam confortáveis ​​com o conceito de paralelismo.Paralelismo baseado em algoritmoAo processar uma nuvem de pontos, estamos aplicando um algoritmo aos dados. Este algoritmo pode ou podenão ser nativamente paralelo. Em lidR, alguns algoritmos são totalmente calculados em paralelo, mas alguns não sãoporque eles não são paralelizáveis, enquanto alguns são apenas parcialmente paralelizados. Isso significa que algunspartes do código são calculadas em paralelo e outras não. Quando um algoritmo é nativoparalelo em lidR é sempre uma paralelização baseada em C ++ com OpenMP. A vantagem é que oa computação é mais rápida sem qualquer consequência para o uso da memória porque a memória é compartilhadaentre os processadores Em suma, o paralelismo baseado em algoritmo fornece um ganho significativo semqualquer custo para sua sessão R e seu sistema (mas, obviamente, há uma maior carga de trabalho para oprocessadores). Por padrão, lidR usa metade de seus núcleos, mas você pode controlar isso com set_lidr_threads.Por exemplo, o algoritmo lmf é nativamente paralelo. O código a seguir é calculado em paralelo:las <- readLAS (“arquivo.las”)tops <- tree_detection (las, lmf (2))

lidR-paralelismo81No entanto, como afirmado acima, nem todos os algoritmos são paralelizados ou mesmo paralelizáveis. Por exemplo,li2012 não está paralelizado. O código a seguir é calculado em série:las <- readLAS (“arquivo.las”)dtm <- segment_trees (las, li2012 ())Para saber quais algoritmos são paralelizados, os usuários podem consultar a documentação ou usar a funçãois.parallelised .is.parallel (lmf (2))#> VERDADEIROis.parallel (li2012 ()) #> FALSEparalelismo baseado em blocosAo processar um LAScatalog, o mecanismo interno divide o conjunto de dados em pedaços e cada pedaço élido e processado sequencialmente em um loop. Mas, na verdade, esse loop pode ser paralelizado com o futuropacote. Por padrão, os pedaços são processados ​​sequencialmente, mas podem ser processados ​​em paralelo porregistrar uma estratégia de avaliação. Por exemplo, o seguinte código é avaliado sequencialmente:ctg <- readLAScatalog (“pasta /”)out <- grid_metrics (ctg, média (Z))Mas este é avaliado em paralelo com dois núcleos:biblioteca (futuro)plano (multissessão, trabalhadores = 2L)ctg <- readLAScatalog (“pasta /”)out <- grid_metrics (ctg, média (Z))Com o paralelismo baseado em blocos, qualquer algoritmo pode ser paralelizado processando vários subconjuntos de umconjunto de dados. No entanto, há um alto custo associado a esse tipo de paralelismo. Ao processarvários pedaços de cada vez, o computador precisa carregar as nuvens de pontos correspondentes. Assumindo oo usuário processa blocos de um quilômetro quadrado em paralelo com 4 núcleos, em seguida, 4 blocos são carregados noMemória do computador. Isso pode ser muito e a aceleração não é garantida, pois há algunssobrecarga envolvida na leitura de vários arquivos ao mesmo tempo. Uma vez que este ponto é compreendido, baseado em chunkparalelismo é muito poderoso, uma vez que todos os algoritmos podem ser paralelizados, sejam ou nãonativamente paralelo.Paralelismo aninhado – parte 1As seções anteriores declararam que alguns algoritmos são nativamente paralelos, como lmf, e alguns não são,como li2012. De qualquer forma, os usuários podem dividir o conjunto de dados em blocos para processá-los simultaneamentecom o mecanismo de processamento LAScatalog. Vamos supor que o computador do usuário tenha quatro núcleos, o queacontece neste caso:biblioteca (futuro)plano (multissessão, trabalhadores = 4L)set_lidr_threads (4L)ctg <- readLAScatalog (“pasta /”)out <- árvore_detecção (ctg, lmf (2))

82lidR-paralelismoAqui, o catálogo será dividido em partes que serão processadas em paralelo. E cada computaçãoem si, implica uma tarefa paralela. Esta é uma tarefa de paralelismo aninhado e é ruim! Esperançosamente, o lidRO pacote trata de tais casos e escolhe por padrão dar precedência ao paralelismo baseado em blocos.Neste caso, os pedaços serão processados ​​em paralelo e os pontos serão processados ​​em série. oquestão de loops paralelos aninhados é irrelevante. O mecanismo de processamento de catálogo tem regras de precedênciaque são garantidos para evitar paralelismo aninhado. Esta regra de precedência visa (1) sempre funcionar (2)preservar os comportamentos do lidR versão 2.0.y.Paralelismo aninhado – parte 2Explicamos as regras de precedência. Mas, na verdade, o usuário pode ajustar o mecanismo com mais precisão. Vamosdefinir a seguinte função:myfun = function (cluster, …){las <- readLAS (cluster)if (is.empty (las)) return (NULL)las <- normalize_height (las, tin ())tops <- tree_detection (las, lmf (2))bbox <- extensão (cluster)tops <- crop (tops, bbox)retorno (topos)}out <- catalog_apply (ctg, myfun, ws = 5)Esta função usa dois algoritmos, um é parcialmente paralelizado (estanho) e outro é totalmente paralelizadolmf. O usuário pode usar manualmente o OpenMP e o futuro. Por padrão, o motor fornecerá pré-dence ao paralelismo baseado em chunk porque funciona em todos os casos, mas o usuário pode impor algooutro. A seguir, 2 trabalhadores são atribuídos ao futuro e 2 trabalhadores são atribuídos ao OpenMP.plano (multissessão, trabalhadores = 2L)set_lidr_threads (2L)catalog_apply (ctg, myfun, ws = 5)A regra é simples. Se o número de trabalhadores necessários for maior do que o número de trabalhadores disponíveisentão o OpenMP é desabilitado. Vamos supor que temos uma máquina quadcore:# 2 blocos 2 threads: OKplano (multissessão, trabalhadores = 2L)set_lidr_threads (2L)# 4 blocos 1 tópicos: OKplano (multissessão, trabalhadores = 4L)set_lidr_threads (1L)# 1 agrupa 4 tópicos: OKplano (sequencial)set_lidr_threads (4L)

lidR-índice espacial83# 3 pedaços 2 threads: NÃO OK# Necessita de 6 trabalhadores, threads OpenMP são definidos como 1, ou seja, processamento sequencialplano (multissessão, trabalhadores = 3L)set_lidr_threads (2L)lidR-índice espacialÍndice espacialDescriçãoEste documento explica como processar nuvens de pontos aproveitando os diferentes índices espaciaisdisponível no pacote lidR. lidR pode usar vários tipos de índices espaciais para aplicar algoritmos (queprecisa de uma indexação espacial) o mais rápido possível. A escolha do índice espacial depende do tipo denuvem de pontos que é processada e o algoritmo que é executado. lidR pode usar uma partição de grade, umpartição voxel, uma quadtree ou uma octree. Veja detalhes.Usosensor (las, h = FALSE)sensor (las) <- valoríndice (las, h = FALSE)índice (las) <- valorArgumentoslasUm objeto da classe LAS ou LAScatalog.hboleano. Legível por humanos. Tudo é armazenado como números inteiros que são entendidosinternamente. Use h = TRUE para saída legível pelo usuário.valorinteiro ou caractere. Um código para se referir a um tipo de sensor ou índice espacialtipo. Use um de “desconhecido”, “als”, “tls”, “uav”, “dap”, “multiespectral”para o tipo de sensor e um de “auto”, “gridpartition”, “voxelpartition”,”quadtree”, “octree” para o tipo de índice espacial.DetalhesDe lidR (> = 3.1.0), um objeto LAS registra o sensor usado para amostrar a nuvem de pontos (ALS, TLS,UAV, DAP), bem como o índice espacial que deve ser usado para processar a nuvem de pontos. Isso podeser definido manualmente pelo usuário, mas o mais simples é usar uma das funções read * LAS () . Por padrãouma nuvem de pontos é associada a um sensor e o melhor índice espacial é escolhido rapidamente dependendo deo algoritmo aplicado. É possível forçar o uso de um índice espacial específico.As informações relativas à indexação espacial são armazenadas no slot @index que contém uma lista com doiselementos:

84lidR-índice espacial• sensor: um número inteiro que registra o tipo de sensor• índice: um inteiro que registra o índice espacial a ser usadoPor padrão, o código do índice espacial é 0 (“automático”), o que significa que cada função é livre para escolher umíndice espacial diferente dependendo do sensor gravado. Se o código não for 0, cada função iráser forçado a usar o índice espacial que é imposto. Isso, obviamente, se aplica apenas a funções queusar indexação espacial.Os objetos LAScatalog também registram essas informações que são automaticamente propagadas para o objeto LASjects durante o processamento.Nota: antes da versão 3.1.0, nuvens de pontos eram consideradas ALS porque lidR era originalmenteprojetado para ALS. Consequentemente, por motivos de compatibilidade com versões anteriores, readLAS () ereadALSLAS () são realmente equivalentes. readLAS () marca a nuvem de pontos com sensor “desconhecido”enquanto readALSLAS () o marca com ‘ALS’. Ambos se comportam da mesma forma e isso é especialmente verdadeiro em comparaçãocom versões <3.1. Como consequência, o uso de readLAS () fornece o mesmo desempenho (sem degra-dação) do que nas versões anteriores, enquanto o uso de uma das funções read * LAS () pode melhorar odesempenho.ExemplosLASfile <- system.file (“extdata”, “exemplo.laz”, pacote = “rlas”)las <- readLAS (arquivo LAS)# Por padrão, o sensor e os códigos de índice espacial são 0sensor (las)índice (las)# Os códigos são usados ​​internamente e não devem ser conhecidos pelos usuários# Use a opção h para saída legível por humanossensor (las, h = TRUE)índice (las, h = TRUE)# A modificação do sensor permite que os usuários selecionem um índice espacial melhor# ao processar a nuvem de pontos.sensor (las) <- “tls”sensor (las, h = TRUE)índice (las, h = TRUE)# A modificação do índice espacial força os usuários a escolher um dos disponíveis# índices espaciais.index (las) <- “quadtree”sensor (las, h = TRUE)índice (las, h = TRUE)# A maneira mais simples de tirar proveito da indexação espacial apropriada é# para usar uma das funções read * LAS ().las <- readTLSLAS (arquivo LAS)sensor (las, h = TRUE)índice (las, h = TRUE)# Mas para algumas nuvens de pontos / algoritmos específicos, pode ser aconselhável forçar# o uso de um índice espacial específico para realizar o cálculo mais rápido

lidR-índice espacial85índice (las) <- “voxelpartition”índice (las, h = TRUE)# Com um LAScatalog, as informações de indexação espacial são propagadas para o# pedaços diferentesctg = readTLSLAScatalog (LASfile)índice (ctg) <- “voxelpartition”sensor (ctg, h = TRUE)índice (ctg, h = TRUE)# ==================# TESTES DE PERFORMANCE# ==================## Não correr:# Testes de desempenho em TLS# ————————# O pacote não inclui dados TLS# para que possamos gerar algo que pareça TLS# >>>>>>>>>>>X = runif (50, -25, 25)Y = runif (50, -25, 25)X = as.numeric (sapply (X, function (x) rnorm (2000, x, 2)))Y = as.numeric (sapply (Y, function (x) rnorm (2000, x, 2)))Z = abs (rnorm (comprimento (Y), 10, 5))veg = data.frame (X, Y, Z)X = runif (5000, -30, 30)Y = runif (5000, -30, 30)Z = runif (5000, 0, 1)ground = data.frame (X, Y, Z)X = runif (30, -30, 30)Y = runif (30, -30, 30)Z = runif (30, 0, 30)ruído = data.frame (X, Y, Z)las = LAS (rbind (solo, vegetais, ruído))# <<<<<<<<<<<<<<trama (las)# Se for lido com readALSLAS ()sensor (las) <- “als”system.time (classify_noise (las, sor (20, 8)))#> 1,5 seg# Se for lido com readTLSLAS ()sensor (las) <- “tls”system.time (classify_noise (las, sor (20, 8)))#> 0,6 seg# Testes de desempenho em ALS# ————————

86lidrpalettes# O pacote não inclui grandes dados ALS# para que possamos gerar algo que pareça ALS# >>>>>>>>>>>X = runif (4e5, 0, 1000)Y = runif (4e5, 0, 1000)Z = 40 * sin (0,01 * X) + 50 * cos (0,005 * Y) + abs (rnorm (comprimento (Y), 10, 5))veg = data.frame (X, Y, Z)X = runif (100, 0, 1000)Y = runif (100, 0, 1000)Z = 40 * sin (0,01 * X) + 50 * cos (0,005 * Y) + abs (rnorm (comprimento (Y), 10, 5)) + runif (100, 30, 70)ruído = data.frame (X, Y, Z)las = LAS (rbind (veg, ruído))# <<<<<<<<<<<<<<trama (las)# Se for lido com readALSLAS ()sensor (las) <- “als”system.time (classify_noise (las, sor (15, 8)))#> 3 s# Se for lido com readTLSLAS ()sensor (las) <- “tls”system.time (classify_noise (las, sor (15, 8)))#> 4,3 seg## End (não executado)lidrpalettesPaletasDescriçãoCrie um vetor de n cores contíguas (ou não)Usoheight.colors (n)forest.colors (n)random.colors (n)pastel.colors (n)ArgumentosnO número de cores (> 1) na paleta

lmf87lmfAlgoritmo de detecção de árvore individualDescriçãoEsta função é feita para ser usada em find_trees. Ele implementa um algoritmo para detecção de árvore baseadoem um filtro máximo local. O tamanho das janelas pode ser fixo ou variável e sua forma pode ser quadrada oucircular. O algoritmo interno funciona com um raster ou uma nuvem de pontos. É profundamente inspirado porPopescu & Wynne (2004) (ver referências).Usolmf (ws, hmin = 2, forma = c (“circular”, “quadrado”))Argumentoswsnumérico ou função. Comprimento ou diâmetro da janela móvel usada para detectaros máximos locais nas unidades dos dados de entrada (geralmente metros). Se for numéricoum tamanho de janela fixo é usado. Se for uma função, a função determina o tamanhoda janela em qualquer local do dossel. A função deve levar oaltura de um determinado pixel ou ponto como seu único argumento e retorna o tamanho desejadoda janela de pesquisa quando centralizado naquele pixel / ponto.hminnumérico. Altura mínima de uma árvore. Limiar abaixo do qual um pixel ou um pontonão pode ser um máximo local. O padrão é 2.formapersonagem. Forma da janela móvel usada para encontrar os máximos locais. Pode ser”quadrado” ou “circular”.ReferênciasPopescu, Sorin & Wynne, Randolph. (2004). Vendo as árvores na floresta: usando Lidar e Mul-Fusão de dados espectral com filtragem local e tamanho de janela variável para estimar a altura da árvore.Engenharia Fotogramétrica e Sensoriamento Remoto. 70. 589-604. 10.14358 / PERS.70.5.589.Veja tambémOutros algoritmos de detecção de árvore individual: manual()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyz”, filter = “-inside 481250 3812980 481300 3813050”)# point-cloud-based# =================# 5×5 m de tamanho de janela fixottops <- find_trees (las, lmf (5))

88manual#x <- plot (las)# add_treetops3d (x, ttops)# tamanho variável da janelaf <- função (x) {x * 0,07 + 3}ttops <- find_trees (las, lmf (f))#x <- plot (las)# add_treetops3d (x, ttops)# baseado em raster# ============chm <- grid_canopy (las, res = 1, p2r (0,15))ttops <- find_trees (chm, lmf (5))plot (chm, col = height.colors (30))plot (ttops, add = TRUE)# tamanho variável da janelaf <- função (x) {x * 0,07 + 3}ttops <- find_trees (chm, lmf (f))plot (chm, col = height.colors (30))plot (ttops, add = TRUE)manualAlgoritmo de detecção de árvore individualDescriçãoEsta função é feita para ser usada em find_trees. Ele implementa um algoritmo para detecção manual de árvore.Os usuários podem localizar as posições do topo da árvore manualmente e de forma interativa usando o mouse. Este é apenasadequado para parcelas de pequeno porte. Primeiro, a nuvem de pontos é exibida e, em seguida, o usuário é convidado a selecionar umregião retangular de interesse na cena usando o botão direito do mouse. Dentro da região selecionadao ponto mais alto será marcado como ‘topo da árvore’ na cena. Uma vez que todas as árvores são rotuladas de usuáriopode sair da ferramenta selecionando uma região vazia. Os pontos também podem ser não sinalizados. O objetivo desta ferramenta éprincipalmente para pequenas correções de saídas de árvore detectadas automaticamente.Usomanual (detectado = NULL, raio = 0,5, cor = “vermelho”, …)ArgumentosdetectouSpatialPointsDataFrame de copas de árvores já encontradas que precisam de correção manualção.raionumérico. Raio das esferas exibidas na nuvem de pontos (fins estéticossó).

merge_spatial89corpersonagem. Cor das esferas exibidas na nuvem de pontos (fins estéticossó)….parâmetros suplementares a serem passados ​​para o gráfico.Veja tambémOutros algoritmos de detecção de árvore individual: lmf()Exemplos## Não correr:LASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las = readLAS (arquivo LAS)# Detecção de árvore manual completattops = find_trees (las, manual ())# Detecção automática com correção manualttops = find_trees (las, lmf (5))ttops = find_trees (las, manual (ttops))## End (não executado)merge_spatialCombine uma nuvem de pontos com uma fonte de dados espaciaisDescriçãoCombine uma nuvem de pontos com uma fonte de dados espaciais. Ele adiciona um atributo ao longo de cada ponto com baseem um valor encontrado nos dados espaciais. As fontes de dados espaciais podem ser um SpatialPolygons *), um sfdata.frame ou um Raster *.• SpatialPolygons *, sf: verifica se os pontos pertencem a cada polígono. Se o parâmetroatributo é o nome de um atributo na tabela de atributos que atribui aos pontos quevalores desse atributo. Caso contrário, classifica os pontos como booleanos. TRUE se os pontos foremem um polígono, FALSO caso contrário.• RasterLayer: atribui a cada ponto o valor encontrado em cada pixel da RasterLayer.• RasterStack ou RasterBrick deve ter 3 canais para cores RGB. Ele coloriza o pontonuvem com valores RGB.Usomerge_spatial (las, source, attribute = NULL)

90normalize_heightArgumentoslasUm objeto da classe LASfonteUm objeto da classe SpatialPolygons * ou sf ou RasterLayer ou um RasterStackou RasterBrick com cores RGB.atributopersonagem. O nome de um atributo na tabela de atributos do shapefile ouo nome de uma nova coluna no objeto LAS. Não é relevante para colorização RGB.ValorUm objeto da classe LAS.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)shp<- system.file (“extdata”, “lake_polygons_UTM17.shp”, package = “lidR”)las<- readLAS (LASfile, filter = “-keep_random_fraction 0.1”)lagos <- sf :: st_read (shp)# O atributo “inlake” não existe no shapefile.# Os pontos são classificados como TRUE se estiverem em um polígonolas<- merge_spatial (las, lakes, “inlakes”)# Novo atributo embutido é adicionado.floresta <- filter_poi (las, inlakes == FALSE)#plot (floresta)# O atributo “LAKENAME_1” existe no shapefile.# Os pontos são classificados com os valores dos polígonoslas <- merge_spatial (las, lagos, “LAKENAME_1”)# Nova coluna LAKENAME_1 adicionada.normalize_heightRemova a topografia de uma nuvem de pontosDescriçãoSubtraia o modelo digital de terreno (DTM) da nuvem de pontos LiDAR para criar um conjunto de dados normalizado como solo em 0. O DTM pode se originar de um arquivo externo ou pode ser calculado pelo usuário. Podetambém pode ser calculado em tempo real. Neste caso, o algoritmo não usa dados rasterizados e cada pontoé interpolado. Não há imprecisão devido à discretização do terreno e à resolução deo terreno é virtualmente infinito.O quão bem as bordas do conjunto de dados são interpoladas depende do método de interpolação usado. Portanto,um buffer em torno da região de interesse é sempre recomendado para evitar efeitos de borda.O atributo Z do objeto LAS retornado é a elevação normalizada. Um novo atributo ‘Zref’registra os valores de elevação anteriores, o que permite o uso de unnormalize_height para restaurar a origemelevações do ponto final.

normalize_height91Usonormalize_height (las,algoritmo,na.rm = FALSE,use_class = c (2L, 9L),…,add_lasattribute = FALSE,Wdegenerated = TRUE)unnormalize_height (las)## Método S4 para assinatura LAS, RasterLayere1 – e2## Método S4 para assinatura LAS, lidRAlgorithme1 – e2ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmouma função de interpolação espacial. lidR tem estanho , krigagem , knnidw ou um RasterLayerrepresentando um modelo digital de terreno (pode ser calculado com grid_terrain)na.rmlógico. Ao usar um RasterLayer como DTM, por padrão, a função falha seum ponto cai em um pixel vazio porque uma elevação Z não pode ser NA. Se na.rm =Pontos TRUE com uma elevação de NA são filtrados. Tenha cuidado, isso cria uma cópiada nuvem de pontos.use_classvetor inteiro. Por padrão, o terreno é calculado usando pontos de solo (classe2) e pontos de água (classe 9). Relevante apenas para uma normalização sem um rasterDTM….Se o algoritmo for um RasterLayer, … é propagado para extrair. Normalmente umpode usar o método = “bilinear”.add_lasattributelógico. Por padrão, a elevação de nível acima é mantida em um novo atributo.No entanto, este novo atributo será eliminado no momento da gravação. Se TRUE é mantidocomo um atributo de extrabytes. Veja também add_lasattribute .Wdegeneradológico. A função sempre verifica e remove pontos de aterramento degenerados paracomputar o DTM para evitar comportamentos inesperados, como elevação infinita.Se TRUE, um aviso é lançado para alertar sobre a presença de solo degeneradopontos.e1um objeto LASe2RasterLayer representando um modelo digital de terreno (pode ser calculado com grid_terrain)ou uma função de interpolação espacial. lidR tem estanho , krigageme knnidw.

92normalize_heightValorSe a entrada for um objeto LAS, retorne um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.Veja tambémgrid_terrainOutro normalize: normalize_intensity()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (LASfile, filter = “-inside 273450 5274350 273550 5274450”)#plot (las)

normalize_intensity93# Primeira opção: usar um RasterLayer como DTM# ========================================================= ======dtm <- grid_terrain (las, 1, knnidw (k = 6L, p = 2))las <- normalize_height (las, dtm)plot (dtm)#plot (las)# restaurar elevações originaislas <- unnormalize_height (las)#plot (las)# operador – pode ser usado. Isso é equivalente ao anteriorlas <- las – dtm#plot (las)# restaurar elevações originaislas <- unnormalize_height (las)# Segunda opção: interpolar cada ponto (sem discretização)# ========================================================= ========las <- normalize_height (las, tin ())#plot (las)# operador – pode ser usado. Isso é equivalente ao anteriorlas <- unnormalize_height (las)las <- las – tin ()## Não correr:# Todas as sintaxes a seguir estão corretaslas <- normalize_height (las, knnidw ())las <- normalize_height (las, knnidw (k = 8, p = 2))las <- las – knnidw ()las <- las – knnidw (k = 8)las <- normalize_height (las, kriging ())las <- las – krigagem (k = 8)## End (não executado)normalize_intensityNormalizar intensidadeDescriçãoNormalize os valores de intensidade usando vários métodos.

94normalize_intensityUsonormalize_intensity (las, algoritmo)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmoum algoritmo de normalização de intensidade. lidR atualmente tem range_correction.ValorRetorna um objeto da classe LAS. O atributo ‘Intensidade’ registra a intensidade normalizada. Um extraatributo denominado ‘RawIntensity’ registra as intensidades originais.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer: Nenhum buffer necessário. Um buffer de 0 é usado e não pode ser alterado• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.Veja tambémOutro normalize: normalize_height()

p2r95Exemplos# Um arquivo válido devidamente preenchidoLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (arquivo LAS)# pmin = 15 porque é um arquivo extremamente pequeno# fortemente dizimado para reduzir seu tamanho. tem# na verdade, poucos retornos múltiplossensor <- track_sensor (las, Roussel2020 (pmin = 15))# Aqui, o efeito é virtualmente nulo porque o tamanho do# a amostra é muito pequena para notar qualquer efeito de intervalolas <- normalize_intensity (las, range_correction (sensor, Rs = 2000))p2rAlgoritmo de modelo de superfície digitalDescriçãoEsta função é feita para ser usada em grid_canopy. Ele implementa um algoritmo para superfície digitalcálculo do modelo baseado em um método de pontos-a-raster: para cada pixel do raster de saída, a funçãoção atribui a altura do ponto mais alto encontrado. O ajuste do subcírculo substitui cada ponto por8 pontos ao redor do original. Isso permite a ‘emulação’ virtual do fato de que um ponto lidarnão é um ponto como tal, mas mais realisticamente um disco. Este ajuste densifica a nuvem de pontos e oo modelo de dossel resultante é mais suave e contém menos ‘poços’ e pixels vazios.Usop2r (subcírculo = 0, na.fill = NULL)Argumentossubcírculonumérico. Raio dos círculos. Para obter menos pixels vazios, o algoritmo podesubstitua cada retorno por um círculo composto por 8 pontos (ver detalhes).na.fillfunção. Uma função que implementa um algoritmo para calcular interpo-solução para preencher o pixel vazio geralmente deixado por métodos de pontos para varredura. lidR temknnidw ,estanhoE krigagem (ver também grid_terrain para mais detalhes).Veja tambémOutros algoritmos de modelo de superfície digital: dsmtin(), pitfree()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (arquivo LAS)col <- height.colors (50)

96pitfree# Algoritmo de pontos para varredura com resolução de 1 metrochm <- grid_canopy (las, res = 1, p2r ())plot (chm, col = col)# Algoritmo Points-to-raster com resolução de 0,5 metros, substituindo cada um# ponto por um círculo de raio de 20 cm de 8 pontoschm <- grid_canopy (las, res = 0,5, p2r (0,2))plot (chm, col = col)## Não correr:chm <- grid_canopy (las, res = 0,5, p2r (0,2, na.fill = tin ()))plot (chm, col = col)## End (não executado)pitfreeAlgoritmo de modelo de superfície digitalDescriçãoEsta função é feita para ser usada em grid_canopy. Ele implementa o algoritmo livre de poço desenvolvido porKhosravipour et al. (2014), que se baseia no cálculo de um conjunto de triangulações clássicas emalturas diferentes (ver referências). O ajuste do subcírculo substitui cada ponto por 8 pontos ao redoro original. Isso permite a ‘emulação’ virtual do fato de que um ponto lidar não é um ponto comotal, mas mais realisticamente um disco. Este ajuste densifica a nuvem de pontos e o dossel resultanteo modelo é mais suave e contém menos ‘pits’ e pixels vazios.Usopitfree (limiares = c (0, 2, 5, 10, 15), max_edge = c (0, 1), subcírculo = 0)Argumentoslimiaresnumérico. Conjunto de limiares de altura de acordo com Khosravipour et al. (2014)descrição do algoritmo (ver referências)max_edgenumérico. Comprimento máximo da borda de um triângulo na triangulação de Delaunay. E seum triângulo tem um comprimento de aresta maior do que este valor, ele será removido. oo primeiro número é o valor para a triangulação clássica (limiar = 0, veja tambémdsmtin), o segundo número é o valor para o algoritmo sem poço (para limiares> 0). Se max_edge = 0, nenhum corte é feito (veja os exemplos).subcírculonumérico. raio dos círculos. Para obter menos pixels vazios, o algoritmo podesubstitua cada retorno por um círculo composto por 8 pontos (ver detalhes).ReferênciasKhosravipour, A., Skidmore, AK, Isenburg, M., Wang, T., & Hussin, YA (2014). Gerando poço-modelos de altura de dossel livre de lidar aerotransportado. Engenharia Fotogramétrica e Sensoriamento Remoto,80 (9), 863-872.

enredo97Veja tambémOutros algoritmos de modelo de superfície digital: dsmtin(), p2r()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)poi = “-drop_z_below 0 -inside 481280 3812940 481330 3812990″las <- readLAS (arquivo LAS, filtro = poi)col <- height.colors (50)# Triangulação básica e rasterização de primeiros retornoschm <- grid_canopy (las, res = 0,5, dsmtin ())plot (chm, col = col)# Khosravipour et al. algoritmo pitfreechm <- grid_canopy (las, res = 0,5, pitfree (c (0,2,5,10,15), c (0, 1,5)))plot (chm, col = col)## Não correr:# Subconjunto côncavo potencialmente complexo de nuvem de pontosx = c (481340, 481340, 481280, 481300, 481280, 481340)y = c (3812940, 3813000, 3813000, 3812960, 3812940, 3812940)las2 = clip_polygon (las, x, y)plot (las2)# Uma vez que a interpolação TIN é feita dentro do casco convexo da nuvem de pontos# pixels falsos são interpolados estritamente corretos de acordo com o método de interpolação# usado, mas sem sentido em nosso CHMchm <- grid_canopy (las2, res = 0,5, pitfree ())plot (chm, col = col)chm = grid_canopy (las2, res = 0,5, pitfree (max_edge = c (3, 1,5)))plot (chm, col = col)## End (não executado)enredoTrace um objeto LAS *DescriçãoPlot exibe uma janela 3D interativa baseada em rgl para objetos LASPlot exibe uma visão interativa para objetos LAScatalog com recursos de panorâmica e zoom baseadosno mapview. Se o sistema de referência de coordenadas (CRS) do LAScatalog não estiver vazio, o gráficopodem ser exibidos no topo dos mapas básicos (dados de satélite, elevação, rua e assim por diante).Plot exibe um objeto LASheader exatamente como exibe um objeto LAScatalog.

98enredoUsoplot (x, y, …)## Método S4 para assinatura LAS, ausenteenredo(x,y,color = “Z”,colorPalette = “auto”,bg = “preto”,trim = Inf,backend = “rgl”,clear_artifacts = TRUE,nbits = 16,eixo = FALSO,legenda = FALSE,adicionar = FALSO,…)## Método S4 para assinatura LAScatalog, ausenteplot (x, y, mapview = FALSE, chunk_pattern = FALSE, overlaps = FALSE, …)## Método S4 para assinatura LASheader, ausenteplot (x, y, mapview = FALSE, …)ArgumentosxUm objeto LAS *yNão utilizado (herdado da base R)…Será passado para points3d (LAS) ou plot se mapview = FALSE ou para mapview semapview = TRUE (LAScatalog).corpersonagens. O atributo usado para colorir a nuvem de pontos. O padrão são coordenadas Z.RGB é uma string permitida mesmo que se refira a três atributos simultaneamente.paleta de corespersonagens. Um vetor de cores, como o gerado por heat.colors, topo.colors,terrain.colors ou funções semelhantes. O padrão é “auto”, fornecendo umacoloração dependendo da cor do argumentobgA cor do plano de fundo. O padrão é preto.apararnumérico. Ativa o corte de valores quando outliers quebram o intervalo da paleta de cores.Cada ponto com um valor superior ao corte será plotado com a cor mais alta.Processo internopersonagem. Pode ser “rgl” ou “lidRviewer”. Se “rgl” for escolhido, o display confiano pacote rgl. Se “lidRviewer” for escolhido, ele depende do lidRviewerpacote, que é muito mais eficiente e pode lidar com milhões de pontos usandomenos memória. lidRviewer ainda não está disponível no CRAN e deve ser instaladodo github (consulte. https://github.com/Jean-Romain/lidRviewer)

plot.lasmetrics3d99clear_artifactslógico. É um problema conhecido e documentado que a visualização 3D com rglexibe artefatos. Os pontos parecem alinhados e / ou regularmente espaçados em alguma vistaângulos. Isso ocorre porque rgl calcula com flutuação de precisão única. Para consertar issoa nuvem de pontos é deslocada para (0,0) para reduzir o número de dígitos necessários para representarreenvie suas coordenadas. A desvantagem é que a nuvem de pontos não é traçada em seucoordenadas reais.nbitsinteiro. Se cor = RGB, ele assume que as cores RGB são codificadas em 16 bits como de-riscado na especificação do formato LAS. No entanto, isso nem sempre é respeitado.Se as cores forem armazenadas em 8 bits, defina este parâmetro como 8.eixológico. Exibir eixo em coordenadas XYZ.lendalógico. Exibe uma legenda de cor gradiente.adicionarSe for FALSO, o comportamento normal, caso contrário, deve ser a saída de uma função de gráfico anteriorpara permitir o alinhamento de uma segunda nuvem de pontos.visão do mapalógico. Se FALSE, o catálogo é exibido em um gráfico regular da base R.chunk_patternlógico. Exibe o padrão de bloco atual usado para processar o catálogo.sobreposiçõeslógico. Destaque as sobreposições entre os arquivos.ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (arquivo LAS)trama (las)plot (las, color = “Intensidade”)## Não correr:# Se outliers quebrarem a faixa de cores, use o parâmetro trimplot (las, color = “Intensity”, trim = 150)plot (las, color = “Classificação”)# Este conjunto de dados já está segmentado em árvoreplot (las, color = “treeID”)## End (não executado)# arquivo único LAScatalog usando dados fornecidos em lidRctg = readLAScatalog (LASfile)plot (ctg)plot.lasmetrics3dTraçar dados LiDAR voxelizadosDescriçãoEsta função implementa um método de plotagem 3D para objetos ‘lasmetrics3d’

100plot_3dUso## Método S3 para a classe lasmetrics3denredo(x,y,color = “Z”,colorPalette = height.colors (50),bg = “preto”,trim = Inf,…)ArgumentosxUm objeto da classe lasmetrics3dyNão utilizado (herdado da base R)corpersonagens. O campo usado para colorir os pontos. O padrão são coordenadas Z. Ou umvetor de cores.paleta de corespersonagens. Um nome de paleta de cores. O padrão é height.colors fornecida pelotampa do pacote RbgA cor do plano de fundo. O padrão é preto.apararnumérico. Ativa o corte de valores quando outliers quebram o intervalo da paleta de cores.O padrão é 1, o que significa que toda a gama de valores é usada para a corpaleta. 0,9 significa que 10 Neste caso, os valores superiores ao 90º percentilsão definidas para a cor mais alta. Eles não são removidos….Parâmetros suplementares para points3d se o método de exibição for “points”.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)lidar = readLAS (arquivo LAS)voxels = voxel_metrics (lidar, list (Imean = mean (Intensity)), res = 5)plot (voxels, color = “Imean”, colorPalette = heat.colors (50), trim = 60)plot_3dAdicionar um objeto espacial a uma cena de nuvem de pontosDescriçãoAdicione um objeto RasterLayer que representa um modelo digital de terreno ou um SpatialPointsDataFrameque representa o topo das árvores para uma cena de nuvem de pontos. Para adicionar elementos a uma cena com uma nuvem de pontos plotadacom a função plot de lidR, as funções add_ * tomam como primeiro argumento a saída da plotagemfunção (ver exemplos), porque a função de plotagem não plota as coordenadas reais do pontonuvem, mas valores compensados. Veja gráfico de função e seu argumento clear_artifacts para mais detalhes.Funciona apenas com rgl, ou seja, backend = “rgl” que é o padrão.

plot_3d101Usoplot_dtm3d (dtm, bg = “preto”, clear_artifacts = TRUE, …)add_dtm3d (x, dtm, …)add_treetops3d (x, ttops, z = “Z”, …)add_flightlines3d (x, flightlines, z = “Z”, …)ArgumentosdtmUm objeto da classe RasterLayerbgA cor do plano de fundo. O padrão é preto.clear_artifactslógico. É um problema conhecido e documentado que a visualização 3D com rglexibe artefatos. Os pontos e linhas estão posicionados de maneira incorreta no espaçoe, portanto, a renderização pode parecer falsa ou estranha. Isso ocorre porque rgl calculacom flutuação de precisão única. Para corrigir isso, os objetos são deslocados para (0,0) para reduziro número de dígitos necessários para representar suas coordenadas. A desvantagem é queos objetos não são plotados em suas coordenadas reais….Parâmetros complementares para surface3d ou spheres3d.xA saída do gráfico de função usado com um objeto LAS.ttopsUm SpatialPointsDataFrame que contém as coordenadas do topo das árvores.zpersonagem. O nome do atributo que contém a altura das copas das árvores oudas linhas de vôo.linhas de vôoUm SpatialPointsDataFrame que contém coordenadas de linhas de voo.ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (LASfile, filter = “-keep_xy 273450 273600 5274450 5274600”)dtm = grid_terrain (las, algoritmo = tin ())ttops <- find_trees (las, lmf (ws = 5))plot_dtm3d (dtm)x = plot (las)add_dtm3d (x, dtm)add_treetops3d (x, ttops)## Não correr:biblioteca (magrittr)plot (las)%>% add_dtm3d (dtm)%>% add_treetops3d (ttops)## End (não executado)

102pmfpmfAlgoritmo de Segmentação de SoloDescriçãoEsta função é feita para ser usada em classify_ground. Ele implementa um algoritmo para segmentaçãode pontos de base com base em um filtro morfológico progressivo. Este método é uma implementação deo Zhang et al. (2003) algoritmo (ver referência). Observe que esta não é uma implementação estrita deZhang et al. Este algoritmo funciona no nível da nuvem de pontos sem nenhum processo de rasterização. oO operador morfológico é aplicado na nuvem de pontos, não em um raster. Além disso, Zhang et al. propostoalgumas fórmulas (eq. 4, 5 e 7) para calcular a sequência de tamanhos e limites das janelas. Aqui,esses parâmetros são gratuitos e especificados pelo usuário. A função util_makeZhangParam permitecálculo dos parâmetros de acordo com o artigo original.Usopmf (ws, th)Argumentoswsnumérico. Sequência de tamanhos de janelas a serem usados ​​na filtragem de retornos de solo. oos valores devem ser positivos e nas mesmas unidades da nuvem de pontos (geralmente metros,ocasionalmente pés).ºnumérico. Sequência de alturas de limiar acima da superfície do solo parametrizadapara ser considerado um retorno ao solo. Os valores devem ser positivos e iguaisunidades como a nuvem de pontos.ReferênciasZhang, K., Chen, SC, Whitman, D., Shyu, ML, Yan, J., & Zhang, C. (2003). Um progressivo mor-filtro fológico para remover medições não terrestres de dados LIDAR aerotransportados. IEEE Transac-tions on Geoscience and Remote Sensing, 41 (4 PARTE I), 872-882. http: # doi.org / 10.1109 / TGRS.2003.810682.Veja tambémOutros algoritmos de segmentação de solo: csf()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (LASfile, select = “xyzrn”, filter = “-inside 273450 5274350 273550 5274450”)ws <- seq (3,12, 3)th <- seq (0,1, 1,5, comprimento.out = comprimento (ws))las <- classify_ground (las, pmf (ws, th))#plot (las, color = “Classificação”)

point_metrics103point_metricsMétricas baseadas em pontosDescriçãoCalcula uma série de estatísticas descritivas definidas pelo usuário para um conjunto de dados LiDAR para cada ponto. estefunção é muito semelhante a grid_metrics, mas calcula métricas para cada ponto com base em seu k-mais próximovizinhos ou sua vizinhança de esfera.Usopoint_metrics (las, func, k, r, xyz = FALSE, filter = NULL, …)ArgumentoslasUm objeto da classe LASfunçãoFórmula. Uma expressão a ser aplicada a cada vizinhança do ponto (ver seção”Função de parâmetro”).k, rinteiro e numérico, respectivamente, para os k-vizinhos mais próximos e o raio doesfera da vizinhança. Se k é dado e r está faltando, calcula com o knn,se r é dado e k está faltando computa com uma vizinhança de esfera, se k e rrecebem cálculos com o knn e um limite na distância de pesquisa.xyzlógico. As coordenadas de cada ponto são retornadas além de cada métrica. E sefilter = NULL coordenadas são referências às coordenadas originais e nãoocupar memória adicional. Se filter! = NULL obviamente ocupa memória.filtrofórmula de predicados lógicos. Permite que a função seja executada apenas em pontos deinteresse de forma otimizada. Veja exemplos….não utilizado.DetalhesQuando a vizinhança é conhecida, a função definida pelo usuário é alimentada com o ponto processado atual eseus k-1 vizinhos. O ponto atual sendo considerado como o vizinho 1 com uma distância de 0 para oponto de referência. Os pontos são ordenados por distância ao ponto central. Quando o bairro éem uma esfera, o ponto processado também é incluído na consulta, mas os pontos vêm em uma ordem aleatória.PerformancesÉ importante ter em mente que esta função é muito rápida para o recurso que fornece, ou seja, mapeamentouma função definida pelo usuário no nível do ponto usando gerenciamento de memória otimizado. No entanto, ainda éexigente computacionalmente.Para ajudar os usuários a ter uma ideia de quão exigente computacionalmente esta função é, vamos compará-lapara grid_metrics. Assumindo que queremos aplicar a média (Z) em uma placa de 1 km² com 1 ponto / m² com uma resoluçãode 20 m (células de 400 m²), então a média da função é chamada cerca de 2500 vezes (uma vez por célula). Emao contrário, com point_metrics, a média é chamada 1000000 vezes (uma vez por ponto). Então a função

104point_metricsdeverá ser mais de 400 vezes mais lento neste caso específico (mas não fornece o mesmocaracterística).É por isso que se espera que a função definida pelo usuário seja bem otimizada, caso contrário, pode drasticamentediminuir a velocidade dessa computação já pesada. Veja exemplos.Por último, mas não menos importante, grid_metrics () depende do pacote data.table para calcular um valor definido pelo usuáriofunção em cada pixel. point_metrics () depende de um método semelhante, mas com uma grande diferença: elenão depende de data.table e, portanto, não foi testado por muitos anos por milhares de pessoas.Por favor, reporte bugs, se houver.Parâmetro funcA função a ser aplicada a cada célula é uma função clássica (ver exemplos) que retorna umlista de métricas. Por exemplo, a seguinte função f está formada corretamente.f = função (x) {lista (média = média (x), máx = máx (x))}E pode ser aplicado tanto nas coordenadas Z quanto nas intensidades. Essas duas declarações sãoválido:point_metrics (las, ~ f (Z), k = 8)point_metrics (las, ~ f (Intensity), k = 5)Tudo que funciona em grid_metrics também deve funcionar em point_metrics, mas às vezes pode sersem significado. Por exemplo, calcular o quantil de elevação realmente não faz sentido aqui.Veja tambémOutras métricas: cloud_metrics(), grid_metrics(), hexbin_metrics(), árvore_métrica(), voxel_metrics()Exemplos## Não correr:LASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)# Leia apenas 0,5 pontos / m ^ 2 para os fins deste exemplolas = readLAS (LASfile, filter = “-thin_with_grid 2”)# Calcula os valores próprios da matriz de covariância do vizinho# aponta e aplica um teste sobre esses valores. Esta função simula o# shp_plane () algoritmo de segment_shape ()plane_metrics1 = function (x, y, z, th1 = 25, th2 = 6) {xyz <- cbind (x, y, z)cov_m <- cov (xyz)eigen_m <- eigen (cov_m) $ valoris_planar <- eigen_m [2]> (th1 * eigen_m [3]) && (th2 * eigen_m [2])> eigen_m [1]return (list (planar = is_planar))}# Aplicar uma função definida pelo usuário

point_metrics105M <- point_metrics (las, ~ plane_metrics1 (X, Y, Z), k = 25)#> Calculado em 6,3 segundos# Podemos verificar que ele retorna o mesmo que shp_planelas <- segment_shape (las, shp_plane (k = 25), “planar”)#> Calculado em 0,1 segundosall.equal (M $ planar, las $ planar)# Nesta fase, podemos ser inteligentes e descobrir que o gargalo é# o cálculo do valor próprio. Vamos escrever uma versão C ++ dele com# Rcpp e RcppArmadilloRcpp :: sourceCpp (code = “#include <RcppArmadillo.h>// [[Rcpp :: Depends (RcppArmadillo)]]// [[Rcpp :: export]]SEXP eigen_values ​​(arma :: mat A) {arma :: mat coeff;arma :: mat score;arma :: vec latent;arma :: princomp (coeficiente, pontuação, latente, A);return (Rcpp :: wrap (latente));} “)plane_metrics2 = function (x, y, z, th1 = 25, th2 = 6) {xyz <- cbind (x, y, z)eigen_m <- eigen_values ​​(xyz)is_planar <- eigen_m [2]> (th1 * eigen_m [3]) && (th2 * eigen_m [2])> eigen_m [1]return (list (planar = is_planar))}M <- point_metrics (las, ~ plane_metrics2 (X, Y, Z), k = 25)#> Calculado em 0,5 segundosall.equal (M $ planar, las $ planar)# Aqui podemos ver que a versão otimizada é muito melhor, mas ainda é 5 vezes mais lenta# por causa da sobrecarga de chamar funções R e alternar entre R e C ++.# Use o argumento de filtro para processar apenas os primeiros retornosM1 <- point_metrics (las, ~ plane_metrics2 (X, Y, Z), k = 25, filtro = ~ ReturnNumber == 1)dim (M1) # 13894 em vez de 17182 anteriormente.# é um equivalente otimizado para memória a:first = filter_first (las)M2 <- point_metrics (primeiro, ~ plane_metrics2 (X, Y, Z), k = 25)all.equal (M1, M2)## End (não executado)

106projeçãoimpressãoResumo e impressão para objetos LAS *DescriçãoResumo e impressão para objetos LAS *Usoimprimir (x, …)## Método S4 para assinatura LASresumo (objeto, …)## Método S4 para assinatura LASimprimir (x)## Método S4 para assinatura LAScatalogresumo (objeto, …)## Método S3 para a classe lidRAlgorithmimprimir (x, …)Argumentos…Não utilizadoobjeto, xUm objeto LAS * ou outros objetos relacionados a lidR.projeçãoObtenha ou defina a projeção de um objeto LAS *DescriçãoObtenha ou defina a projeção de um objeto LAS *.Usoepsg (objeto, …)epsg (objeto) <- valor## Método S4 para assinatura LASheaderepsg (objeto, …)## Método de substituição S4 para assinatura LASheader

projeção107epsg (objeto) <- valor## Método S4 para assinatura LASepsg (objeto)## Método de substituição S4 para assinatura LASepsg (objeto) <- valorwkt (objeto) <- valor## Método S4 para assinatura LASheaderwkt (obj)## Método de substituição S4 para assinatura LASheaderwkt (objeto) <- valor## Método S4 para assinatura LASwkt (obj)## Método de substituição S4 para assinatura LASwkt (objeto) <- valor## Método S4 para assinatura LASheaderprojeção (x, asText = TRUE)## Método S4 para assinatura LASprojeção (x, asText = TRUE)## Método de substituição S4 para assinatura LASprojeção (x) <- valor## Método S4 para assinatura LAScatalogprojeção (x, asText = TRUE)## Método S4 para assinatura LASheadercrs (x, asText = FALSE)## Método S4 para assinatura LAScrs (x, asText = FALSE)## Método de substituição S4 para assinatura LAScrs (x, …) <- valor## Método S4 para assinatura LAScatalogcrs (x, asText = FALSE)

108projeçãoArgumentosobjeto, x, objUm objeto da classe LAS ou eventualmente LASheader (usuários regulares não precisammanipular objetos LASheader)….Não utilizado.valorUm objeto CRS ou uma string proj4string ou string WKT ou um código EPSG.asTextlógico. Se TRUE, a projeção é retornada como texto. Caso contrário, um objeto CRS édevolvida.DetalhesExistem duas maneiras de armazenar o CRS de uma nuvem de pontos em um arquivo LAS:• Armazene um código EPSG (para LAS 1.0 a 1.3)• Armazene uma string WTK (para LAS 1.4)Por outro lado, os pacotes R sptial usam um proj4string para armazenar o CRS (mas o ecossistema épassando para WKT). É por isso que o CRS é duplicado em um objeto LAS. A informação pertencedentro do cabeçalho em um formato que pode ser escrito em um arquivo LAS e no slot proj4string em umformato que pode ser entendido por pacotes R.• projeção <-: atribui um CRS de um CRS (sp), um crs (sf), uma string WKT, uma proj4string ou umcódigo epsg. Ele atualiza o cabeçalho do objeto LAS com o código EPSG para formatos LAS<1.4 ou com uma string WKT para o formato LAS 1.4 e atualiza o slot proj4string.• projeção: retorna o CRS em formato sp• crs e crs <- são equivalentes a projeção e projeção <-• epsg <-, wkt <-: funções legadas substituídas por projeção <-• sf :: st_crs retorna o CRS no formato sf.• epsg: lê o código epsg do cabeçalho.• wkt: lê a string WKT do cabeçalho.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS)# Obtenha o código EPSG armazenado no cabeçalho (retorna 0 se não for registrado)epsg (las)# Obtenha a string WKT armazenada no cabeçalho (LAS> = 1.4)wkt (las)if (rgdal :: new_proj_and_gdal ()){# Obtenha o WKT do CRSsp :: wkt (crs (las))# CRS registrado é “NAD83 / UTM zona 17N”sf :: st_crs (las) $ input

aleatória109}# Substitui o CRS (mas não reprojeta)crs <- sp :: CRS (“+ init = epsg: 26918”)projeção (las) <- crssf :: st_crs (las) $ input# Usa o código EPSGprojeção (las) <- 26919sf :: st_crs (las) $ input# Usa um crs de sfcrs <- sf :: st_crs (3035)projeção (las) <- crsaleatóriaAlgoritmo de Decimação de Nuvem de PontosDescriçãoEsta função é feita para ser usada em decimate_points. Ele implementa um algoritmo que aleatoriamenteremove pontos ou pulsos para atingir a densidade desejada em toda a área (ver área)Usoaleatório (densidade, use_pulse = FALSE)Argumentosdensidadenumérico. A densidade de saída desejada.use_pulselógico. Decime removendo pulsos aleatórios em vez de pontos aleatórios (re-deve executar retrieve_pulses primeiro)Veja tambémOutros algoritmos de dizimação de nuvem de pontos: mais alto(), homogeneizar()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS, select = “xyz”)# Alcance uma densidade de pulso de 1 no conjunto de dados geralthinned1 = decimate_points (las, random (1))plot (grid_density (las))plot (grid_density (thinned1))

110range_correctionrange_correctionAlgoritmo de normalização de intensidadeDescriçãoEsta função é feita para ser usada em normalize_intensity. Ele corrige a intensidade com uma correção de intervalode acordo com a fórmula (ver referências):I norm = I obs (RRs) f )Para obter a correção de faixa, a posição do sensor deve ser conhecida em diferentes momentos discretos.Usando o ‘gpstime’ de cada ponto, a posição do sensor é interpolada a partir da referência euma correção de intervalo é aplicada.Usorange_correction (sensor, Rs, f = 2,3, gpstime = “gpstime”, elevação = “Z”)get_range (las, sensor, gpstime = “gpstime”, elevation = “Z”)ArgumentossensorObjeto SpatialPointsDataDrame contendo as coordenadas do sensor emdiferentes pontos de tempo t. O tempo e a elevação são armazenados como atributos (padrãoos nomes são ‘gpstime’ e ‘Z’). Pode ser calculado com track_sensor.Rsnumérico. Faixa de referência.fnumérico. Expoente. Normalmente entre 2 e 3 em contextos de vegetação.gpstime, elevaçãopersonagem. O nome dos atributos que armazenam o gpstime da posição ea elevação do sensor respectivamente. Se elevação = NULL as coordenadas Zsão pesquisados ​​na terceira coluna da matriz de coordenadas do SpatialPoints-Quadro de dados. Isso é útil se for lido em um formato que suporta 3 coordenadaspontos.lasum objeto da classe LAS. get_range () é uma função regular documentada aqui paraconveniência.ReferênciasGatziolis, D. (2011). Normalização de intensidade baseada em faixa dinâmica para retorno discreto, aerotransportadoLidar Data of Forest Canopies. Photogrammetric Engineering & Remote Sensing, 77 (3), 251–259.https://doi.org/10.14358/pers.77.3.251

rbind.LAS111Exemplos# Um arquivo válido devidamente preenchidoLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (arquivo LAS)# pmin = 15 porque é um arquivo extremamente pequeno# fortemente dizimado para reduzir seu tamanho. tem# na verdade, poucos retornos múltiplossensor <- track_sensor (las, Roussel2020 (pmin = 15))# Aqui, o efeito é virtualmente nulo porque o tamanho do# a amostra é muito pequena para notar qualquer efeito de intervalolas <- normalize_intensity (las, range_correction (sensor, Rs = 2000))# Isso pode ser útil para alguns aplicativosR = get_range (las, sensor)rbind.LASMesclar objetos LASDescriçãoMesclar objetos LASUso## Método S3 para classe LASrbind (…)Argumentos…Objetos LASreadLASLeia arquivos .las ou .lazDescriçãoLê arquivos .las ou .laz em um objeto da classe LAS. Se vários arquivos forem lidos ao mesmo tempo, o LAS retornadoobjeto é considerado como um arquivo LAS. Os parâmetros opcionais permitem ao usuário salvar um substancialquantidade de memória escolhendo carregar apenas os atributos ou pontos de interesse. Formatos LAS 1.1 para1.4 são suportados. Formato de registro de dados de ponto 0,1,2,3,5,6,7,8 são suportados.readLAS é a função original e sempre funciona. Usando uma das funções read * LAS adicionainformações para o objeto retornado para registrar um tipo de nuvem de pontos. Registrando o tipo de ponto correto

112readLASpode melhorar o desempenho de algumas funções, permitindo que os usuários selecionem um spa apropriadoíndice inicial. Veja indexação espacial. Observe que por motivos de compatibilidade legada e com versões anteriores,readLAS () e readALSLAS () são equivalentes porque lidR foi originalmente projetado para ALS eassim, a função original readLAS () foi (supostamente) usada para ALS. Lendo um conjunto de dados TLS comreadLAS () em vez de readTLSLAS () é perfeitamente válido e tem um desempenho semelhante às versões <= 3.0.0,sem degradação de desempenho nem melhorias.UsoreadLAS (arquivos, selecionar = “*”, filtro = “”)readALSLAS (arquivos, selecionar = “*”, filtro = “”)readTLSLAS (arquivos, selecionar = “*”, filtro = “”)readUAVLAS (arquivos, selecionar = “*”, filtro = “”)readDAPLAS (arquivos, selecionar = “*”, filtro = “”)readMSLAS (arquivos1, arquivos2, arquivos3, selecionar = “*”, filtro = “”)Argumentosarquivospersonagens. Caminho (s) para um ou vários arquivos. Também pode ser um objeto LAScatalog .selecionarpersonagem. Leia apenas os atributos de interesse para economizar memória (ver detalhes).filtropersonagem. Leia apenas os pontos de interesse para economizar memória (ver detalhes).arquivos1, arquivos2, arquivos3personagens. Caminho (s) para um ou vários arquivos. Cada argumento sendo um canal(consulte a seção ‘Dados multiespectrais’).DetalhesSelecionar: o argumento ‘selecionar’ especifica os dados que serão realmente carregados. Por exemplo, ‘xyzia’significa que as coordenadas x, y e z, a intensidade e o ângulo de varredura serão carregados. O sup-entradas portadas são t – gpstime, a – ângulo de varredura, i – intensidade, n – número de retornos, r – número de retorno,c – classificação, s – sinalizador sintético, k – sinalizador de ponto-chave, w – sinalizador retido, o – sinalizador de sobreposição (formato6+), u – dados do usuário, p – ID da fonte do ponto, e – borda da bandeira da linha de vôo, d – direção da bandeira de varredura, R -canal vermelho da cor RGB, G – canal verde da cor RGB, B – canal azul da cor RGB, N -canal de infravermelho próximo. C – canal do scanner (formato 6+). Também números de 1 a 9 para o extrabytes de números de dados de 1 a 9. 0 permite que todos os bytes extras sejam carregados e ‘*’ é o caractere curinga que permitetudo a ser carregado do arquivo LAS.Observe que x, y, z estão implícitos e sempre carregados. ‘xyzia’ é equivalente a ‘ia’.Filtro: o argumento ‘filtro’ permite filtrar a nuvem de pontos durante a leitura de arquivos. Isso é muitomais eficiente do que filter_poi de muitas maneiras. Se os filtros desejados forem conhecidos antes de ler o arquivo,os filtros internos devem ser sempre preferidos. Os filtros disponíveis são os da LASlib e podem serencontrado executando o seguinte comando: readLAS (filter = “-help”). (veja também rlas :: read.las)A partir da rlas v1.3.6, os comandos de transformação também podem ser passados ​​por meio do filtro de argumento.

readLAScatalog113ValorUm objeto LASDados multiespectraisOs dados do laser multiespectral são freqüentemente armazenados em 3 arquivos diferentes. Se este for o caso, readMSLAS lê oarquivos .las ou .laz de cada canal e os mescla em um objeto da classe LAS e cuida dosatribuindo um ID a cada canal. Se a nuvem de pontos multisprectral já estiver armazenada em um único arquivodeixe o arquivo2 e o arquivo3 ausentes.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS)las = readLAS (arquivo LAS, select = “xyz”)las = readLAS (LASfile, select = “xyzi”, filter = “-keep_first”)las = readLAS (LASfile, select = “xyziar”, filter = “-keep_first -drop_z_below 0”)# A negação de atributos também é possível (todos, exceto intensidade e ângulo)las = readLAS (arquivo LAS, select = “* -i -a”)readLAScatalogCrie um objeto da classe LAScatalogDescriçãoCrie um objeto da classe LAScatalog a partir de uma pasta ou coleção de nomes de arquivos. Um LAScatalog éuma representação de uma coleção de arquivos las / laz. Um computador não pode carregar todos os dados de uma vez. UMALAScatalog é uma maneira simples de gerenciar todos os arquivos sequencialmente. A maioria das funções de lidR podeser usado perfeitamente com um LAScatalog usando o mecanismo de processamento LAScatalog interno. Pegarvantagem do motor de processamento LAScatalog, o usuário deve primeiro ajustar algumas opções de processamentousando as funções apropriadas. É necessária uma leitura cuidadosa da documentação da classe LAScatalogpara usar a classe LAScatalog corretamente.readLAScatalog é a função original e sempre funciona. Usando um dos lidos * LAScatalogfunções adiciona informações ao objeto retornado para registrar um tipo de nuvem de pontos. Registrando o cor-tipo de ponto reto pode melhorar o desempenho de algumas funções, permitindo que os usuários selecionem um aplicativoíndice espacial adequado. Veja indexação espacial. Observe que por legado e para compatibilidade com versões anterioresrazões readLAScatalog () e readALSLAScatalog () são equivalentes porque lidR era originalmenteprojetado para ALS e, portanto, a função original readLAScatalog () foi (supostamente) usada paraALS.UsoreadLAScatalog (pasta,progresso = TRUE,

114readLAScatalogselect = “*”,filtro = “”,chunk_size = 0,chunk_buffer = 30,…)readALSLAScatalog (pasta,progresso = TRUE,select = “*”,filtro = “”,chunk_size = 0,chunk_buffer = 30,…)readTLSLAScatalog (pasta,progresso = TRUE,select = “*”,filtro = “”,chunk_size = 0,chunk_buffer = 30,…)readUAVLAScatalog (pasta,progresso = TRUE,select = “*”,filtro = “”,chunk_size = 0,chunk_buffer = 30,…)readDAPLAScatalog (pasta,progresso = TRUE,select = “*”,filtro = “”,chunk_size = 0,chunk_buffer = 30,…)catálogo (pasta, …)

readLASheader115Argumentospastacorda. O caminho de uma pasta contendo um conjunto de arquivos las / laz. Também pode ser um vetorde caminhos de arquivo.progresso, selecionar, filtrar, chunk_size, chunk_bufferAjuste de opções de processamento de fácil acesso. Veja LAScatalog-class e cata-log_options_tools .…Parâmetros extras para list.files. Normalmente recursivo = TRUE.ValorUm objeto LAScatalogExemplos# Um único arquivo LAScatalog usando os dados fornecidos com o pacoteLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)ctg = readLAScatalog (LASfile)plot (ctg)## Não correr:ctg <- readLAScatalog (“/ caminho / para / a / pasta / de / las / arquivos”)# O motor interno irá processar sequencialmente pedaços de tamanho 500 x 500 mopt_chunk_size (ctg) <- 500# O motor interno irá alinhar os pedaços de 500 x 500 m em x = 250 ey = 300opt_alignment (ctg) <- c (250, 300)# O mecanismo interno não exibirá uma estimativa de progressoopt_progress (ctg) <- FALSE# O mecanismo interno não retornará resultados em R. Em vez disso, gravará os resultados em arquivos.opt_output_files (ctg) <- “/ path / to / folder / template_filename_ {XBOTTOM} _ {ID}”# Mais detalhes na documentaçãoajuda (“classe LAScatalog”, “lidR”)help (“catalog_options_tools”, “lidR”)## End (não executado)readLASheaderLeia um cabeçalho de arquivo .las ou .lazDescriçãoLê um cabeçalho de arquivo .las ou .laz em um objeto da classe LASheader. Esta função lê estritamente ocabeçalho, enquanto a função readLAS pode alterar o cabeçalho para ajustar os dados reais carregados.

116retrieve_pulsesUsoreadLASheader (arquivo)ArgumentosArquivopersonagens. Caminho para um arquivo.ValorUm objeto LASheaderExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)header = readLASheader (LASfile)imprimir (cabeçalho)plot (cabeçalho)## Não correr:plot (cabeçalho, mapview = TRUE)## End (não executado)retrieve_pulsesRecupere pulsos, linhas de vôo ou linhas de varredura individuaisDescriçãoRecupere cada pulso individual, linha de vôo individual ou linha de varredura individual e atribua um número acada ponto. O objeto LAS deve ser devidamente preenchido de acordo com as especificações LAS, caso contrárioos usuários podem encontrar resultados inesperados.Usoretrieve_pulses (las)retrieve_flightlines (las, dt = 30)retrieve_scanlines (las)ArgumentoslasUm objeto LASdtnumérico. O intervalo de tempo limite usado para recuperar as linhas de voo

Roussel2020117Detalhesretrieve_pulses Recupera cada pulso individual. Ele usa o tempo do GPS. Um atributo pulseID éadicionado no objeto LASretrieve_scanlines Recupera cada scanline individual. Quando os dados são amostrados de acordo com umpadrão dente de serra (espelho oscilante), uma linha de varredura é uma linha ou linha de dados. A função dependeno campo GPS, hora de solicitar os dados. Então, o atributo ScanDirectionFlag é usado pararecuperar cada linha de varredura. Um atributo scanlineID é adicionado ao objeto LASretrieve_flightlines Recupera cada linha de vôo individual. Ele usa o tempo do GPS. Em um contínuoconjunto de dados, uma vez que os pontos são ordenados pelo tempo GPS, o tempo entre dois pontos consecutivosnão exceda alguns milissegundos. Se o tempo entre dois pontos consecutivos for muito longo, isso significaque o segundo ponto é de uma linha de vôo diferente. O limite padrão é 30 segundos. AO atributo flightlineID é adicionado ao objeto LAS.ValorUm objeto da classe LASExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS)las <- retrieve_pulses (las)laslas <- retrieve_flightlines (las)#plot (las, color = “flightlineID”)Roussel2020Algoritmo de rastreamento de sensorDescriçãoEsta função é feita para ser usada em track_sensor. Ele implementa um algoritmo de Roussel et al.2020 (ver referência) para rastreamento de sensor usando múltiplos retornos para estimar o posicionamento dosensor calculando a interseção no espaço das linhas que passam pelo primeiro e último retorno.UsoRoussel2020 (intervalo = 0,5, pmin = 50)Argumentosintervalonumérico. Intervalo usado para bin os tempos de gps e agrupar os pulsos para calcular umposição em um determinado momento t.pmininteiro. Número mínimo de pulsos necessários para estimar a posição de um sensor. Paraum determinado intervalo, a posição do sensor não é calculada se o número de pulsos formenor que pmin.

118rumple_indexDetalhesQuando vários retornos de um único pulso são detectados, o sensor calcula suas posições comoestando no centro da pegada e, portanto, todos alinhados. Por causa desse comportamento, uma linha desenhadaentre e além desses retornos deve cruzar o sensor. Assim, vários pulsos consecutivos emitidosem um intervalo curto (por exemplo, 0,5 segundos) pode ser usado para aproximar um ponto de interseção no céuque corresponde à posição do sensor, dado que o portador do sensor não se moveu muito durante esteintervalo. Um método de mínimos quadrados ponderados fornece uma aproximação da interseção, minimizandoa soma quadrada das distâncias entre o ponto de intersecção e todas as linhas.ReferênciasRoussel Jean-Romain, Bourdon Jean-François, Achim Alexis, (2020) Intensidade baseada em alcance nor-malização de dados ALS em áreas florestadas usando um método de rastreamento de sensor de múltiplos retornos(pré-impressão) Obtido em eartharxiv.org/k32qwExemplos# Um arquivo válido devidamente preenchidoLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (arquivo LAS)# pmin = 15 porque é um arquivo extremamente pequeno# fortemente dizimado para reduzir seu tamanho. tem# na verdade, poucos retornos múltiploslinhas de voo <- track_sensor (las, Roussel2020 (pmin = 15))plot (las @ header)plot (linhas de vôo, adicionar = TRUE)rumple_indexÍndice de rugosidadeDescriçãoCalcula a rugosidade de uma superfície como a razão entre sua área e sua área projetada noterra. Se a entrada for um objeto em grade (raster), a função calcula as superfícies usando o de Jennessalgoritmo (ver referências). Se a entrada for uma nuvem de pontos, a função usa uma triangulação de Delaunaydos pontos e calcula a área de cada triângulo.Usorumple_index (x, y = NULL, z = NULL, …)ArgumentosxUm ‘RasterLayer’ ou um vetor de coordenadas de x pontos.ynumérico. Se x é um vetor de coordenadas: as coordenadas y associadas.znumérico. Se x é um vetor de coordenadas: as coordenadas z associadas….não utilizado

segment_shapes119Valornumérico. O índice Rumple calculado.ReferênciasJenness, JS (2004). Calculando a área de superfície da paisagem a partir de modelos digitais de elevação. Animais selvagensSociety Bulletin, 32 (3), 829–839.Exemplosx <- runif (20, 0, 100)y <- runif (20, 0, 100)# Superfície perfeitamente plana, rumple_index = 1z <- rep (10, 20)índice_ rumple (x, y, z)# Superfície áspera, rumple_index> 1z <- runif (20, 0, 10)índice_ rumple (x, y, z)# Superfície mais áspera, rumple_index aumentaz <- runif (20, 0, 50)índice_ rumple (x, y, z)# A medida de rugosidade depende da escalaíndice_ rumple (x, y, z)índice_ rumple (x / 10, y / 10, z)# Use com um modelo de altura de dosselLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS)chm <- grid_canopy (las, 2, p2r ())rumple_index (chm)segment_shapesEstimativa da forma da vizinhança dos pontosDescriçãoCalcula os valores próprios da matriz de covariância dos pontos vizinhos usando váriosalgoritmos sible. Os pontos que atendem a um determinado critério com base no autovalor são rotulados comoaproximadamente coplanar / colinear ou qualquer outra forma suportada.Usosegment_shapes (las, algoritmo, atributo = “Forma”, filtro = NULL)

120segment_snagsArgumentoslasum objeto da classe LASalgoritmoUm algoritmo para detecção de formas. lidR tem: shp_plane , shp_hplane e shp_line.atributopersonagem. O nome da nova coluna a ser adicionada ao objeto LAS.filtrofórmula de predicados lógicos. Permite que a função seja executada apenas em pontos deinteresse de forma otimizada. Veja também exemplos.ValorUm objeto LAS com uma nova coluna nomeada após o atributo do argumento que indica esses pontosque fazem parte de uma vizinhança que tem aproximadamente a forma pesquisada (VERDADEIRO) ou não (FALSO).Exemplos## Não correr:LASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS)las <- segment_shapes (las, shp_plane (k = 15), “Coplanar”)#plot (las, color = “Coplanar”)# Solte o ponto de aterramento no tempo de execuçãolas <- segment_shapes (las, shp_plane (k = 15), “Coplanar”, filtro = ~ Classificação! = 2L)#plot (las, color = “Coplanar”)## End (não executado)segment_snagsClassificação SnagDescriçãoClassificação / segmentação de snag usando vários algoritmos possíveis (ver detalhes). A função em-tributa um número que identifica uma classe de obstáculo (atributo snagCls) para cada ponto da nuvem de pontos. oa classificação / segmentação é feita no nível da nuvem de pontos e atualmente apenas um algoritmo implementamentado, que usa limites de intensidade LiDAR e vizinhanças especificadas para diferenciare ramificam-se em pontos de folhagem (ver detalhes).Usosegment_snags (las, algoritmo, atributo = “snagCls”)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmofunção. Um algoritmo para segmentação de obstáculo. lidR tem wing2015.atributopersonagem. O objeto LAS retornado tem automaticamente um novo atributo (um novocoluna). Este parâmetro é o nome deste novo atributo.

segment_snags121ValorSe a entrada for um objeto LAS, retorne um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.Exemplos## Não correr:LASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyzi”, filter = “- keep_first”) # Wing também incluído -keep_single# Para o método Wing2015, forneça uma matriz de obstáculo BranchBolePtRatio condicional# limites de avaliação (ver Wing et al. 2015, Tabela 2, pág. 172)bbpr_thresholds <- matriz (c (0,80, 0,80, 0,70,0,85, 0,85, 0,60,0,80, 0,80, 0,60,0,90, 0,90, 0,55),

122segment_treesnrow = 3, ncol = 4)# Executar classificação de obstáculo e atribuir classes para cada pontolas <- segment_snags (las, wing2015 (neigh_radii = c (1.5, 1, 2), BBPRthrsh_mat = bbpr_thresholds))# Plote tudo, árvore e pontos de obstáculo …plot (las, color = “snagCls”, colorPalette = rainbow (5))# Filtre e plote apenas pontos de obstáculoobstáculos <- filter_poi (las, snagCls> 0)plot (snags, color = “snagCls”, colorPalette = rainbow (5) [- 1])# Wing et als (2015) métodos terminaram com a realização de segmentação de árvore no# nuvem de pontos classificada e filtrada usando o método de bacia hidrográfica## End (não executado)segment_treesSegmentação de árvore individualDescriçãoSegmentação de árvore individual com vários algoritmos possíveis. A nuvem de pontos retornada tem um novoAtributo de byte extra nomeado após o atributo de parâmetro, independentemente do algoritmo usado.Usosegment_trees (las, algorithm, attribute = “treeID”, uniqueness = “incremental”)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmofunção. Um algoritmo de segmentação de árvore individual. lidR has: dalponte2016,bacia hidrográfica ,li2012 e silva2016. Mais algoritmos experimentais podem ser encontradosno pacote lidRplugins.atributopersonagem. O objeto LAS retornado como um novo atributo de byte extra (em um novocoluna). Este parâmetro controla o nome do novo atributo. O padrão é”treeID”.singularidadepersonagem. Um método para calcular um ID exclusivo. Pode ser ‘incremental’, ‘gpstime’ou ‘bitmerge’. Consulte a seção ‘Unicidade’. Este recurso deve ser considerado como’experimental’.ValorSe a entrada for um objeto LAS, retorne um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.

segment_trees123SingularidadePor padrão, os IDs das árvores são numerados de 1 a n, sendo n o número de árvores encontradas. O problemacom tal numeração incremental é que, embora garanta que um ID único seja atribuído a cada árvoreem uma determinada nuvem de pontos, ele também garante a duplicação de IDs de árvore em diferentes blocos ou pedaços quandoprocessando um LAScatalog. Isso ocorre porque cada arquivo é processado independentemente dos outros epotencialmente em paralelo em computadores diferentes. Assim, o índice sempre reinicia em 1 em cada arquivo oupedaço. Pior, em um processo de segmentação de árvore, uma árvore que está localizada exatamente entre 2 arquivos terádois IDs diferentes para suas duas metades.É por isso que introduzimos algumas estratégias de exclusividade que são todas imperfeitas e que devem ser vistascomo experimental. Relate qualquer solução de problemas. Usar uma estratégia segura de exclusividade garante queárvores de arquivos diferentes não compartilharão os mesmos IDs. Além disso, também significa que duas metades de umárvore na borda de um bloco de processamento receberá o mesmo ID.Número incremental de 0 a n. Este método não garante a exclusividade dos IDs. Isto é ométodo legado.gpstime Este método usa gpstime do ponto mais alto de uma árvore (apex) para criar um ID exclusivo.Este ID não é um número inteiro, mas um número decimal de 64 bits que é subótimo, mas pelo menos éEspera-se que seja exclusivo se o atributo gpstime for consistente entre os arquivos. Se inconsistênciascom gpstime são relatados (por exemplo gpstime registra o horário da semana e foi redefinido para 0 emuma cobertura que leva mais de uma semana para ser concluída), há uma (baixa) probabilidade de obter IDerros de atribuição.bitmerge Este método usa as coordenadas XY do ponto mais alto (vértice) de uma árvore para criar umnúmero único com uma operação bit a bit. Primeiro, as coordenadas XY são convertidas em inteiros usandoas escalas e deslocamentos da nuvem de pontos. Em seguida, o ID é calculado com X * 2 ^ 32 + Y paracombine duas vezes os 32 bits de informação em um número de 64 bits. Por exemplo, se o ápice éem (10.32, 25.64) com um fator de escala de 0,01 e um deslocamento de 0, as coordenadas inteiras são X= 1032 e Y = 2564 e o ID é 4432406252036. Esses métodos retornam um número inteiro de 64 bitsmas como não existem inteiros de 64 bits em R, ele é convertido em um número decimal de 64 bits que égarantido como exclusivo se todos os arquivos tiverem os mesmos deslocamentos e fatores de escala.Todas as opções propostas são abaixo do ideal porque não garantem exclusividade em todoscasos (inconsistências na coleção de arquivos), ou eles implicam que os IDs são baseados em números não inteiros ounúmeros sem sentido. Mas, no mínimo, esperamos que isso funcione para casos simples.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.

124set_lidr_threadsOpções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las <- readLAS (LASfile, select = “xyz”, filter = “-drop_z_below 0”)# Usando Li et al. (2012)las <- segment_trees (las, li2012 (R = 3, speed_up = 5))plot (las, color = “treeID”)set_lidr_threadsDefina ou obtenha o número de fios que lidR deve usarDescriçãoDefina e obtenha o número de threads a serem usados ​​nas funções lidR que são paralelizadas com OpenMP.O valor padrão 0 significa utilizar toda a CPU disponível. get_lidr_threads () retorna o número detópicos que serão usados. Isso afeta o pacote lidR, mas também o pacote data.table internamentechamar setDTthreads porque várias funções de lidR dependem de data.table, mas isso não mudaO próprio R ou outros pacotes usando OpenMP.Usoset_lidr_threads (threads)get_lidr_threads ()ArgumentostópicosUm inteiro> = 0. Padrão 0 significa usar toda a CPU disponível e deixar o funcionamentosistema para multi-tarefa.

shape_detection125Veja tambémlidR-paralelismoshape_detectionAlgoritmos para detecção de forma da vizinhança do ponto localDescriçãoEssas funções são feitas para serem usadas em segment_shapes. Eles implementam algoritmos para locaisestimativa da forma da vizinhança.Usoshp_plane (th1 = 25, th2 = 6, k = 8)shp_hplane (th1 = 25, th2 = 6, th3 = 0,98, k = 8)shp_line (th1 = 10, k = 8)Argumentosth1, th2, th3numérico. Valores de limite (ver detalhes)kinteiro. Número de vizinhos usado para estimar o bairro.DetalhesA seguir, a1, a2, a3 denotam os autovalores da matriz de covariância do vizinhopontos em ordem crescente. th1, th2, th3 denotam um conjunto de valores de limiar. Os pontos são rotulados como TRUE seeles atendem aos seguintes critérios. Caso contrário, FALSE.shp_plane Detecção de planos com base nos critérios definidos por Limberger & Oliveira (2015) (ver referênciaences). Um ponto é rotulado como TRUE se a vizinhança for aproximadamente plana, isto é:a2> (th1 ∗ a1) e (th2 ∗ a2)> a3shp_hplane O mesmo que ‘plano’, mas com um teste extra na orientação do vetor Z docomponentes principais para testar a horizontalidade da superfície.a2> (th1 ∗ a1) e (th2 ∗ a2)> a3e | Z | > th3Em teoria | Z | deve ser exatamente igual a 1. Na prática, 0,98 ou 0,99 deve ser suficienteshp_line Detecção de linhas inspirado no critério Limberger & Oliveira (2015). Um ponto érotulado como TRUE se a vizinhança for aproximadamente linear, isto é:th1 ∗ a2 <a3andth1 ∗ a1 <a3

126silva2016ReferênciasLimberger, FA, & Oliveira, MM (2015). Detecção em tempo real de regiões planas em áreas não organizadasnuvens de pontos. Pattern Recognition, 48 (6), 2043–2053. https://doi.org/10.1016/j.patcog.2014.12.020silva2016Algoritmo de segmentação de árvore individualDescriçãoEstas funções são feitas para serem usadas em segment_trees. Ele implementa um algoritmo para segmentação de árvoreção baseada na Silva et al. (2016) artigo (ver referência). Este é um método simples baseado em seed +tesselação de voronoi (equivalente ao vizinho mais próximo). Este algoritmo é implementado no pacoterLiDAR. Esta versão não é a versão do rLiDAR. É um código escrito a partir do artigo original poro lidR cria e é consideravelmente (entre 250 e 1000 vezes) mais rápido.Usosilva2016 (chm, copas das árvores, max_cr_factor = 0,6, exclusão = 0,3, ID = “treeID”)ArgumentoschmRasterLayer. Imagem da copa. Pode ser calculado com grid_canopy ou lerde um arquivo externo.Copa das árvoresSpatialPointsDataFrame. Pode ser calculado com find_trees ou lido de umshapefile externo.max_cr_factornumérico. Valor máximo do diâmetro da copa dado como proporção da árvorealtura. O padrão é 0,6, o que significa 60% da altura da árvore.exclusãonumérico. Para cada árvore, pixels com uma elevação inferior à exclusão multi-dobrado pela altura da árvore será removido. Portanto, este número está entre 0e 1.EU IRIApersonagem. Se o SpatialPointsDataFrame contiver um atributo com o ID paracada árvore, o nome desta coluna. Dessa forma, os IDs originais serão preservados. E senão existe tal árvore de dados será numerada sequencialmente.DetalhesComo esse algoritmo funciona apenas em um CHM, não há necessidade real de uma nuvem de pontos. As vezeso usuário nem tem a nuvem de pontos que gerou o CHM. lidR é um ponto orientado para a nuvembiblioteca, razão pela qual este algoritmo deve ser usado em segment_trees para mesclar o resultado no pontonuvem. No entanto, o usuário pode usar isso como uma função autônoma como esta:chm = raster (“arquivo / para / a / chm /”)ttops = find_trees (chm, lmf (3))coroas = silva2016 (chm, ttops) ()

smooth_height127ReferênciasSilva, CA, Hudak, AT, Vierling, LA, Loudermilk, EL, O’Brien, JJ, Hiers, JK, Khos-Ravipour, A. (2016). Imputação de pinheiro de folha longa individual (Pinus palustris Mill.) Árvore emtributos de dados de campo e LiDAR. Canadian Journal of Remote Sensing, 42 (5), 554–573.https://doi.org/10.1080/07038992.2016.1196582.Veja tambémOutros algoritmos de segmentação de árvore individual: dalponte2016(), li2012(), divisor de águas()Outros algoritmos de segmentação de árvore baseados em raster: dalponte2016(), divisor de águas()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)poi <- “-drop_z_below 0 -inside 481280 3812940 481320 3812980″las <- readLAS (LASfile, select = “xyz”, filtro = poi)col <- pastel.colors (200)chm <- grid_canopy (las, res = 0,5, p2r (0,3))ker <- matriz (1,3,3)chm <- raster :: focal (chm, w = ker, fun = mean, na.rm = TRUE)ttops <- find_trees (chm, lmf (4, 2))las<- segment_trees (las, silva2016 (chm, ttops))#plot (las, color = “treeID”, colorPalette = col)smooth_heightSuavizar uma nuvem de pontosDescriçãoAlgoritmo de suavização baseado em nuvem de pontos. Dois métodos estão disponíveis: média dentro de uma janela eGaussiano liso dentro de uma janela. O atributo Z do objeto LAS retornado é o Z suavizado.Um novo atributo Zraw é adicionado para armazenar os valores originais e pode ser usado para restaurar a nuvem de pontoscom unsmooth_height.Usosmooth_height (las,Tamanho,método = c (“média”, “gaussiana”),forma = c (“círculo”, “quadrado”),sigma = tamanho / 6)unsmooth_height (las)

128sorArgumentoslasUm objeto da classe LASTamanhonumérico. O tamanho das janelas usadas para suavizar.métodopersonagem. Método de suavização. Pode ser ‘médio’ ou ‘gaussiano’.formapersonagem. A forma das janelas. Pode ser um círculo ou um quadrado.sigmanumérico. O desvio padrão da gaussiana se o método for gaussiano.DetalhesEste método não usa métodos baseados em raster para suavizar a nuvem de pontos. Esta é uma verdadeira nuvem de pontosalisamento. Não é realmente útil por si só, mas pode ser interessante em combinação com filtros comofilter_surfacepoints, por exemplo, para desenvolver novos algoritmos.ValorUm objeto da classe LAS.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS, select = “xyz”)las <- filter_surfacepoints (las, 1)#plot (las)las <- smooth_height (las, 5, “gaussian”, “circle”, sigma = 2)#plot (las)las <- unsmooth_height (las)#plot (las)sorAlgoritmo de segmentação de ruídoDescriçãoEsta função é feita para ser usada em classify_noise. Ele implementa um algoritmo para outliers (ruído)segmentação com base nos métodos de remoção estatística de outliers (SOR) descritos pela primeira vez no PCL li-brary e também implementado em CloudCompare (ver referências). Para cada ponto, ele calcula odistância média para todos os seus vizinhos k-mais próximos. Os pontos que estão além da distância médiamais um número de vezes (multiplicador) o desvio padrão é considerado ruído.Usosor (k = 10, m = 3, quantil = FALSO)

stdmetrics129Argumentosknumérico. O número de vizinhosmnumérico. Multiplicador. A distância máxima será: distância média + m * padrão deviação. Se quantil = TRUE, m se torna o limite de quantil.quantilboleano. Modificação do SOR original para usar um limite de quantil em vezde um multiplicador de desvio padrão. Neste caso, a distância máxima será:quantil (distâncias, probs = m)Referênciashttps://pointclouds.org/documentation/tutorials/statistically_outlier.htmlhttps://www.cloudcompare.org/doc/wiki/index.php?title=SOR_filterVeja tambémOutros algoritmos de segmentação de ruído: ivf()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las <- readLAS (LASfile, filter = “-inside 273450 5274350 273550 5274450”)# Adicione alguns outliers artificiais porque o original# conjunto de dados está limposet.seed (314)id = round (runif (20, 0, npoints (las)))set.seed (42)err = runif (20, -50, 50)las $ Z [id] = las $ Z [id] + errlas <- classify_noise (las, sor (15,7))stdmetricsFunções de métricas padrão predefinidasDescriçãoFunções predefinidas computáveis ​​em nível de pixel (grid_metrics), nível de célula hexagonal ( hexbin_metrics),nível de nuvem de pontos (cloud_metrics), nível de árvore ( tree_metrics) nível de voxel ( voxel_metrics) e apontarnível (point_metrics) Cada função vem com atalhos convenientes para codificação preguiçosa. O lidRO pacote visa fornecer uma maneira fácil de calcular métricas definidas pelo usuário, em vez de fornecê-las.No entanto, para eficiência e economia de tempo, um conjunto de métricas padrão foi predefinido (ver detalhes).

130stdmetricsUsostdmetrics (x, y, z, i, rn, classe, dz = 1, th = 2)stdmetrics_z (z, dz = 1, th = 2)stdmetrics_i (i, z = NULL, classe = NULL, rn = NULL)stdmetrics_rn (rn, classe = NULL)stdmetrics_pulse (pulseID, rn)stdmetrics_ctrl (x, y, z)stdtreemetrics (x, y, z)stdshapemetrics (x, y, z).stdmetrics.stdmetrics_z.stdmetrics_i.stdmetrics_rn.stdmetrics_pulse.stdmetrics_ctrl.stdtreemetrics.stdshapemetricsArgumentosx, y, z, iCoordenadas dos pontos, intensidadern, classeReturnNumber, Classificationdznumérico. Entropia métrica de espessura de camadaºnumérico. Limiar para métricas pzabovex. Pode ser um vetor para calcularvários limites.pulseIDO número que faz referência a cada pulsoFormatoUm objeto da fórmula de classe de comprimento 2.Um objeto da fórmula de classe de comprimento 2.Um objeto da fórmula de classe de comprimento 2.

stdmetrics131Um objeto da fórmula de classe de comprimento 2.Um objeto da fórmula de classe de comprimento 2.Um objeto da fórmula de classe de comprimento 2.Um objeto da fórmula de classe de comprimento 2.Um objeto da fórmula de classe de comprimento 2.DetalhesOs nomes das funções, seus parâmetros e os nomes de saída das métricas dependem de uma nomenclaturaescolhido por brevidade:• z: refere-se à elevação• i: refere-se à intensidade• rn: refere-se ao número de retorno• q: refere-se ao quantil• a: refere-se ao ScanAngleRank ou ScanAngle• n: refere-se a um número (uma contagem)• p: refere-se a uma porcentagemPor exemplo, a métrica denominada zq60 refere-se à elevação, quantil, 60 ou seja, o 60º percentil deelevações. O pground métrico refere-se a uma porcentagem. É a porcentagem de pontos classificados comoterra. A função stdmetric_i se refere a métricas de intensidade. Uma descrição de cadamétrica pode ser encontrada na página wiki lidR .Algumas funções possuem parâmetros opcionais. Se esses parâmetros não forem fornecidos, a função com-puta apenas um subconjunto das métricas existentes. Por exemplo, stdmetrics_i requer os valores de intensidade,mas se os valores de elevação também forem fornecidos, ele pode calcular métricas adicionais, comointensidade em um determinado percentual de altura.Cada função possui uma variável associada conveniente. É o nome da função, com um pontoantes do nome. Isso permite que a função seja usada sem escrever parâmetros. O custo de taluma característica é inflexibilidade. Corresponde a um comportamento predefinido (ver exemplos)stdmetrics é uma combinação de stdmetrics_ctrl + stdmetrics_z + stdmetrics_i + stdmetrics_rnstdtreemetrics é uma função especial que funciona com tree_metrics. Na verdade, não vai falhar comoutras funções, mas a saída faz mais sentido se calculada no nível da árvore individual.stdshapemetrics é um conjunto de recursos baseados em autovalores descritos em Lucas et al, 2019 (ver referênciaences).ReferênciasLucas, C., Bouten, W., Koma, Z., Kissling, WD, & Seijmonsbergen, AC (2019). Identificaçãode elementos lineares de vegetação em uma paisagem rural usando nuvens de ponto LiDAR. Sensoriamento remoto,11 (3), 292.

132stdmetricsVeja tambémcloud_metrics grid_metrics hexbin_metrics voxel_metrics tree_metrics point_metricsExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (LASfile, select = “*”, filter = “-keep_random_fraction 0.5”)# Todas as métricas predefinidasm1 <- grid_metrics (las, ~ stdmetrics (X, Y, Z, Intensity, ReturnNumber, Classification, dz = 1), res = 40)# Atalho convenientem2 <- grid_metrics (las, .stdmetrics, res = 40)# Métricas básicas de intensidadesm3 <- grid_metrics (las, ~ stdmetrics_i (Intensidade), res = 40)# Todas as métricas de intensidadesm4 <- grid_metrics (las, ~ stdmetrics_i (Intensidade, Z, Classificação, ReturnNumber), res = 40)# Atalho conveniente para o exemplo anteriorm5 <- grid_metrics (las, .stdmetrics_i, res = 40)# Funciona também com cloud_metrics e hexbin_metricsm6 <- cloud_metrics (las, .stdmetrics)m7 <- hexbin_metrics (las, .stdmetrics)# Combine algumas funções predefinidas com suas próprias novas métricas# Aqui, os atalhos convenientes não podem mais ser usados.myMetrics = função (z, i, rn){primeiro <- rn == 1Lzfirst <- z [primeiro]nfirst <- comprimento (zfirst)acima de 2 <- soma (z> 2)x <- acima de 2 / nprimeiro * 100Número de métricas de usuáriosmétricas <- lista (acima2aboven1st = x,# Número de retornos acima de 2 dividido pelo número de primeiros retornoszimean = média (z * i),# Produtos médios de z por intensidadezsqmean = sqrt (média (z ^ 2)) # Média quadrática de z)# Combinado com métricas padrãoreturn (c (metrics, stdmetrics_z (z)))}m10 <- grid_metrics (las, ~ myMetrics (Z, Intensity, ReturnNumber), res = 40)# Os usuários podem escrever seus próprios atalhos convenientes como este:

lata133.myMetrics = ~ myMetrics (Z, Intensity, ReturnNumber)m11 <- grid_metrics (las, .myMetrics, res = 40)lataAlgoritmo de Interpolação EspacialDescriçãoEsta função é feita para ser usada em grid_terrain ou normalize_height. Ele implementa um algoritmopara interpolação espacial. A interpolação espacial é baseada em uma triangulação de Delaunay, que realizauma interpolação linear dentro de cada triângulo. Normalmente, existem alguns pontos fora do casco convexo,determinado pelos pontos básicos na própria borda do conjunto de dados, que não podem ser interpolados com umtriangulação. A extrapolação é feita usando a abordagem do vizinho mais próximo.Usoestanho (…, extrapolar = knnidw (3, 1, 50))Argumentos…não utilizadoextrapolarNormalmente existem alguns pontos fora do casco convexo, determinados pelo solopontos na borda do conjunto de dados, que não podem ser interpolados com um trian-gulação. A extrapolação é feita usando a abordagem do vizinho mais próximo por padrãousando knnidw.Veja tambémOutros algoritmos de interpolação espacial: knnidw(), krigagem()ExemplosLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (LASfile, filter = “-inside 273450 5274350 273550 5274450”)#plot (las)dtm = grid_terrain (las, algoritmo = tin ())plot (dtm, col = terrain.colors (50))# plot_dtm3d (dtm)

134track_sensortrack_sensorReconstrua a trajetória do sensor LiDAR usando retornos múltiplosDescriçãoUse retornos múltiplos para estimar o posicionamento do sensor, calculando a interseção no espaçoda linha que passa pelo primeiro e último retorno. Para funcionar, esta função requer um conjunto de dados ondeos atributos ‘gpstime’, ‘ReturnNumber’, ‘NumberOfReturns’ e ‘PointSourceID’ estão corretamentepreenchido, caso contrário, a saída pode ser incorreta ou estranha. Para o processamento LAScatalog é recomendadorecomendado para usar grandes pedaços e grandes buffers (por exemplo, uma largura de faixa). A nuvem de pontos não deve sernormalizado.Usotrack_sensor (las,algoritmo,extra_check = TRUE,thin_pulse_with_time = 0,001,multi_pulse = FALSE)ArgumentoslasUm objeto da classe LAS ou LAScatalog.algoritmofunção. Um algoritmo para calcular o rastreamento do sensor. lidR implementos Rous-sel2020 e Gatziolis2019 (consulte a respectiva documentação e exemplos).extra_checkboleano. Os conjuntos de dados raramente são preenchidos com perfeição, levando a erros inesperados.São realizadas verificações demoradas de integridade de dados. Essas verificações podem serignorados, pois representam uma proporção significativa do tempo de cálculo.Consulte também a seção ‘Testes de integridade de dados’.thin_pulse_with_timenumérico. Na prática, não é útil calcular a posição usando todos os múltiplos re-voltas. É mais exigente computacionalmente, mas não necessariamente mais preciso.Isso mantém apenas um pulso a cada x segundos. Defina como 0 para usar todas as devoluções múltiplas.Use 0 se o arquivo já foi lido com filter = “-thin_pulses_with_time0,001 “.multi_pulselógico. VERDADEIRO apenas para sistemas com pulsos múltiplos. O ID de pulso deve ser registradono atributo UserData.ValorUm SpatialPointsDataFrame com a elevação Z armazenada na tabela de atributos. Informação sobreo intervalo de tempo e a pontuação do posicionamento (de acordo com o método utilizado) também estão na tabelade atributos.

track_sensor135Teste de integridade de dadosEm teoria, o rastreamento do sensor é um problema simples de resolver, desde que cada pulso seja devidamente identificadoa partir de um conjunto de dados bem preenchido. Na prática, muitos problemas podem surgir de conjuntos de dados que são pop-ulated incorretamente. Aqui está uma lista de problemas que podem acontecer. Aqueles com um * denotam problemasjá encontrado e verificado internamente para remover pontos estranhos:• ‘gpstime’ não registra a hora em que os pulsos foram emitidos e, portanto, os pulsos não são identificadostestável• * Um pulso (dois ou mais pontos que compartilham o mesmo tempo gp) é feito de pontos de diferenteslinhas de voo (PointSourceID diferente). Isso é impossível e denota um preenchimento incorretoAtributo PointSourceID.• ‘ReturnNumber’ e ‘NumberOfReturns’ estão erroneamente preenchidos com algum Return-Número> NumberOfReturn ou vários primeiros retornos por pulsosPor um determinado intervalo de tempo, quando pontos estranhos não são filtrados, a posição não é calculada para esteintervalo.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• output_files: Salvar resultados intermediários está desabilitado em ‘sensor_tracking’ porque a saídadeve ser pós-processado como um todo.• laz_compression: grava arquivos las ou laz• selecionar: não é compatível. É definido por padrão como “xyzrntp”• filtro: Leia apenas pontos de interesse. Por padrão, ele usa “-drop_single” e “-thin_pulses_with_time”para reduzir o número de pontos carregados.

136tree_metricsAutor (es)Jean-Francois Bourdon e Jean-Romain RousselExemplos# Um arquivo válido devidamente preenchidoLASfile <- system.file (“extdata”, “Topografia.laz”, pacote = “lidR”)las = readLAS (arquivo LAS,select = “xyzrntp”,filter = “-drop_single -thin_pulses_with_time 0,001”)#plot (las)# pmin = 15 porque é um arquivo extremamente pequeno# fortemente dizimado para reduzir seu tamanho. tem# na verdade, poucos retornos múltiploslinhas de voo <- track_sensor (las, Roussel2020 (pmin = 15))plot (las @ header)plot (linhas de vôo, adicionar = TRUE)#x <- plot (las)# add_flightlines3d (x, flightlines, radius = 10)## Não correr:# Com um LAScatalog “-drop_single” e “-thin_pulses_with_time”# são usados ​​por padrãoctg = readLAScatalog (“pasta /”)linhas de voo <- track_sensor (ctg, Roussel2020 (pmin = 15))enredo (linhas de voo)## End (não executado)tree_metricsCalcule métricas para cada árvoreDescriçãoUma vez que as árvores são segmentadas, ou seja, existem atributos na nuvem de pontos que fazem referência a cada árvore, compfornece um conjunto de estatísticas descritivas definidas pelo usuário para cada árvore individual. Esta é a “versão em árvore” degrid_metrics .Usotree_metrics (las, func = ~ max (Z), attribute = “treeID”)

tree_metrics137ArgumentoslasUm objeto da classe LAS ou LAScatalog.funçãoFórmula. Uma expressão a ser aplicada a cada árvore. Funciona como em grid_metricsvoxel_metrics ou delineate_crowns e computa, além de localizações de árvore aconjunto de métricas para cada árvore.atributopersonagem. O nome da coluna do atributo que contém os IDs da árvore. O padrão é”treeID”DetalhesPor padrão, a função calcula as coordenadas xyz do ponto mais alto de cada árvore e usa xycomo coordenadas de árvore em SpatialPoinsDataFrame. z é armazenado na tabela de atributos junto com oid de cada árvore. Todos os outros atributos são atributos definidos pelo usuário:As seguintes funções existentes contêm um pequeno conjunto de métricas predefinidas:• stdmetrics_treeOs usuários devem escrever suas próprias funções para criar suas próprias métricas. tree_metrics irá despachar oDados LiDAR para cada árvore segmentada na função definida pelo usuário. As funções são definidas sem oprecisa considerar cada árvore segmentada, ou seja, apenas a nuvem de pontos (ver exemplos).ValorUm SpatialPoinsDataFrame que faz referência à posição xy com uma tabela de atributos que associaa elevação z (pontos mais altos) das árvores e o id das árvores, mais as métricas definidas pelodo utilizador.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.Opções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.

138tree_metrics• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída: os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM}, {YTOP}, {XCENTER},{YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo), {ORIGINALFILENAME}.• select: Carrega apenas atributos de interesse.• filtro: Leia apenas pontos de interesse.Veja tambémOutras métricas: cloud_metrics(), grid_metrics(), hexbin_metrics(), point_metrics(), voxel_metrics()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)las = readLAS (LASfile, filter = “-drop_z_below 0”)# NOTA: Este conjunto de dados já está segmentado# plot (las, color = “treeID”, colorPalette = pastel.colors (200))# O padrão calcula apenas Z maxmetrics = tree_metrics (las)# Métricas definidas pelo usuário – altura média e intensidade média para cada árvoremetrics = tree_metrics (las, ~ list (Zmean = mean (Z), Imean = mean (Intensity)))# Defina sua nova função de métricasmyMetrics = função (z, i){metrics = list (imean = média (i),imax = max (i),npoint = comprimento (z))retorno (métricas)}metrics = tree_metrics (las, ~ myMetrics (Z, Intensity))# métricas predefinidas (consulte? stdmetrics)metrics = tree_metrics (las, .stdtreemetrics)

util_makeZhangParam139util_makeZhangParamParâmetros para filtro morfológico progressivoDescriçãoA função classify_ground com o filtro morfológico progressivo permite qualquer sequência deparâmetros. Esta função permite o cálculo das sequências usando as equações (4), (5) e (7)de Zhang et al. (ver referência e detalhes).Usoutil_makeZhangParam (b = 2,dh0 = 0,5,dhmax = 3,s = 1,max_ws = 20,exp = FALSE)Argumentosbnumérico. Este é o parâmetro b em Zhang et al. (2003) (eq. 4 e 5).dh0numérico. Este é dh 0 em Zhang et al. (2003) (eq. 7).dhmaxnumérico. Este é o dh max em Zhang et al. (2003) (eq. 7).snumérico. Isso está em Zhang et al. (2003) (eq. 7).max_wsnumérico. Tamanho máximo da janela a ser usado na filtragem de retornos de solo. estelimita o número de janelas criadas.explógico. O tamanho da janela pode ser aumentado linearmente ou exponencialmente (eq. 4 ou 5).DetalhesNo artigo original, a sequência de tamanhos das janelas é dada pela eq. 4 ou 5:w k = 2kb + 1ouw k = 2b k + 1No artigo original, a sequência limite é dada pela eq. 7:th k = s ∗ (w k – w k − 1 ) ∗ c + th 0

140VCIPorque a função classify_ground aplica a operação morfológica no nível da nuvem de pontoso parâmetro c é definido como 1 e não pode ser modificado.ValorUma lista com dois componentes: a sequência de tamanho das janelas e a sequência de limite.ReferênciasZhang, K., Chen, SC, Whitman, D., Shyu, ML, Yan, J., & Zhang, C. (2003). Um progressivo mor-filtro fológico para remover medições não terrestres de dados LIDAR aerotransportados. IEEE Transac-tions on Geoscience and Remote Sensing, 41 (4 PARTE I), 872-882. http: # doi.org / 10.1109 / TGRS.2003.810682.Exemplosp = util_makeZhangParam ()VCIÍndice de Complexidade VerticalDescriçãoUma normalização fixa da função de entropia (ver referências)UsoVCI (z, zmax, por = 1)Argumentoszvetor de coordenadas zzmaxnumérico. Usado para transformar a entropia da função para a função vci.denumérico. A espessura das camadas usadas (bin de altura)ValorUm número entre 0 e 1Referênciasvan Ewijk, KY, Treitz, PM, & Scott, NA (2011). Caracterizando a Sucessão Florestal na CentralOntário usando índices derivados de LAS. Engenharia Fotogramétrica e Sensoriamento Remoto, 77 (3),261-269. Obtido em <Go to ISI>: // WOS: 000288052100009Veja tambémentropia

voxelize_points141Exemplosz <- runif (10000, 0, 10)VCI (z, por = 1, zmax = 20)z <- abs (rnorm (10000, 10, 1))# esperado estar mais próximo de 0.VCI (z, por = 1, zmax = 20)voxelize_pointsVoxelize uma nuvem de pontosDescriçãoReduza o número de pontos através da voxelização da nuvem de pontos. Se a intensidade faz parte dos atributosé preservado e agregado como média (intensidade). Outros atributos não podem ser agregados e sãoperdido.Usovoxelize_points (las, res)ArgumentoslasUm objeto da classe LAS ou LAScatalog.resnumérico. A resolução dos voxels. res = 1 para voxels cúbicos 1x1x1. Op-opcionalmente res = c (1,2) para voxels não cúbicos (1x1x2 voxel cubóide).ValorSe a entrada for um objeto LAS, retorna um objeto LAS. Se a entrada for um LAScatalog, retorna um LAScatalog.Trabalhando com um LAScatalogEsta seção aparece em cada função que suporta um LAScatalog como entrada.Em lidR, quando a entrada de uma função é um LAScatalog, a função usa o processamento LAScatalogmotor. O usuário pode modificar as opções do motor usando as opções disponíveis. Uma leitura cuidadosa dea documentação do motor é recomendada antes de processar os catálogos LAS. Cada função lidRdeve vir com uma seção que documenta as opções de mecanismo com suporte.O motor LAScatalog suporta arquivos .lax que melhoram significativamente a velocidade de computação deconsultas espaciais usando um índice espacial. Os usuários realmente deveriam tirar proveito de arquivos .lax, mas isso não éobrigatório.

142voxel_metricsOpções de processamento suportadasOpções de processamento com suporte para um LAScatalog (em negrito). Para obter mais detalhes, consulte o LAScatalogdocumentação do motor:• tamanho do pedaço: quantos dados são carregados de uma vez.• Chunk buffer *: Obrigatório para obter uma saída contínua sem efeitos de borda. O buffer ésempre removido depois de processado e nunca será retornado em R ou em arquivos.• alinhamento de pedaços: Alinha os pedaços processados.• progresso: Exibe uma estimativa de progressão.• arquivos de saída *: Obrigatório porque a saída é provavelmente muito grande para ser retornada em R eprecisa ser escrito em arquivos las / laz. Os modelos suportados são {XLEFT}, {XRIGHT}, {YBOTTOM},{YTOP}, {XCENTER}, {YCENTER} {ID} e, se o tamanho do bloco for igual a 0 (processamento por arquivo),{ORIGINALFILENAME}.• selecionar: A função irá gravar arquivos equivalentes aos originais. Portanto, selecione = “*” enão pode ser mudado.• filtro: Leia apenas pontos de interesse.ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS, select = “xyz”)las2 = voxelize_points (las, 2)#plot (las2)voxel_metricsVoxelize o espaço e calcule as métricas para cada voxelDescriçãoEsta é uma versão 3D do grid_metrics. Ele cria uma matriz 3D de voxels com uma determinada resolução. istocria um voxel a partir da nuvem de pontos se houver pelo menos um ponto no voxel. Para cada voxel ofunção permite o cálculo de uma ou várias métricas derivadas da mesma forma que o grid_metricsfunções. A função irá despachar os dados LiDAR para cada voxel na função do usuário (vergrid_metrics)Usovoxel_metrics (las, func, res = 1, …, all_voxels = FALSE)

voxel_metrics143ArgumentoslasUm objeto da classe LAS.funçãoFórmula. Uma expressão a ser aplicada a cada voxel (ver também grid_metrics)resnumérico. A resolução dos voxels. res = 1 para voxels cúbicos 1x1x1. Op-opcionalmente res = c (1,2) para voxels não cúbicos (1x1x2 voxel cubóide)….Não utilizadoall_voxelsboleano. Por padrão, a função retorna apenas voxels que contêm 1 ou maispontos. Voxels vazios não existem porque as métricas são indefinidas. Se all_voxels= TRUE todos os voxels são retornados e as métricas são NA para voxels com 0 pontos.ValorEle retorna um data.table contendo as métricas de cada voxel. A mesa tem a classe lasmetrics3dpermitindo plotagem mais fácil. Também possui um atributo res que armazena a resolução.Veja tambémOutras métricas: cloud_metrics(), grid_metrics(), hexbin_metrics(), point_metrics(), árvore_métrica()ExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las <- readLAS (arquivo LAS)# Nuvem de pontos é voxelizada com resolução de 8 metros e em cada voxel# o número de pontos é calculado.vm <- voxel_metrics (las, ~ length (Z), 8)# Nuvem de pontos é voxelizada com resolução de 8 metros e em cada voxel# a intensidade média dos pontos é calculada.vm <- voxel_metrics (las, ~ mean (Intensity), 8)#plot (vm, color = “V1”, colorPalette = heat.colors (50), trim = 60)# Defina sua própria função métricamyMetrics = função (i){ret = list (npoints = comprimento (i),Quero dizer= média (i))retorno (ret)}voxels <- voxel_metrics (las, ~ myMetrics (Intensity), 8)#plot (voxels, color = “imean”, colorPalette = heat.colors (50), trim = 60)#etc.attr (voxels, “res”)

144bacia hidrográficabacia hidrográficaAlgoritmo de segmentação de árvore individualDescriçãoEsta função é feita para ser usada em segment_trees. Ele implementa um algoritmo para segmentação de árvorecom base em uma bacia hidrográfica ou em uma bacia hidrográfica controlada por um marcador.• A bacia hidrográfica simples é baseada no pacote biocondutor EBIimage. Você precisa instalar estepacote para executar este método (veja sua página no github) Internamente, a função EBImage :: watershedé chamado.• A bacia hidrográfica controlada por marcador é baseada no pacote do gerador de imagens e foi removida antes decausa imager é um pacote órfão.Usobacia hidrográfica (chm, th_tree = 2, tol = 1, ext = 1)mcwatershed (chm, copas das árvores, th_tree = 2, ID = “treeID”)ArgumentoschmRasterLayer. Imagem da copa. Pode ser calculado com grid_canopy ou lerde um arquivo externo.th_treenumérico. Limiar abaixo do qual um pixel não pode ser uma árvore. O padrão é 2.para mimnumérico. Tolerância, veja? EBImage :: bacia hidrográfica.extnumérico. veja? EBImage :: bacia hidrográfica.Copa das árvoresSpatialPointsDataFrame. Pode ser calculado com find_trees ou lido de umshapefile externo.EU IRIApersonagem. Se o SpatialPointsDataFrame contiver um atributo com o ID paracada árvore, o nome desta coluna. Dessa forma, os IDs originais serão preservados. E senão existe tal árvore de dados será numerada sequencialmente.DetalhesComo esse algoritmo funciona apenas em um CHM, não há necessidade real de uma nuvem de pontos. As vezeso usuário nem tem a nuvem de pontos que gerou o CHM. lidR é um ponto orientado para a nuvembiblioteca, razão pela qual este algoritmo deve ser usado em segment_trees para mesclar o resultado no pontonuvem. No entanto, o usuário pode usar isso como uma função autônoma como esta:chm = raster (“arquivo / para / a / chm /”)ttops = find_trees (chm, lmf (3))coroas = divisor de águas (chm) ()

wing2015145Veja tambémOutros algoritmos de segmentação de árvore individual: dalponte2016(), li2012(), silva2016()Outros algoritmos de segmentação de árvore baseados em raster: dalponte2016(), silva2016()ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)poi = “-drop_z_below 0 -inside 481280 3812940 481320 3812980″las <- readLAS (LASfile, select = “xyz”, filtro = poi)col <- pastel.colors (250)chm <- grid_canopy (las, res = 0,5, p2r (0,3))ker <- matriz (1,3,3)chm <- raster :: focal (chm, w = ker, fun = mean, na.rm = TRUE)las <- segment_trees (las, divisor de águas (chm))plot (las, color = “treeID”, colorPalette = col)wing2015Algoritmo de segmentação de obstáculosDescriçãoEsta função é feita para ser usada em segment_snags. Ele implementa um algoritmo para segmen-tação baseada em Wing et al (2015) (ver referências). Este é um algoritmo de filtragem automatizado queutiliza estatísticas de densidade e intensidade baseada em pontos lidar de vizinhança tridimensional para removerpontos lidar associados a árvores vivas e reter pontos lidar associados a obstáculos.Usowing2015 (neigh_radii = c (1,5, 1, 2),low_int_thrsh = 50,uppr_int_thrsh = 170,pt_den_req = 3,BBPRthrsh_mat = NULL)Argumentosneigh_radiinumérico. Um vetor de três raios usado para quantificar a vizinhança centrada na área localborhoods. Veja Wing et al. (2015) página de referência 171 e Figura 4. Os padrões são1,5, 1 e 2 para as vizinhanças da esfera, do cilindro pequeno e do cilindro grande,respectivamente.low_int_thrshnumérico. O valor de filtragem do limite de intensidade inferior. Veja Wing et al. (2015)página 171. O padrão é 50.

146wing2015uppr_int_thrsh numérico. O valor de filtragem do limite de intensidade superior. Veja Wing et al. (2015)página 171. O padrão é 170.pt_den_reqnumérico. Requisito de densidade de ponto com base na densidade de ponto de nível de gráfico definidaAulas. Veja Wing et al. (2015) página 172. O padrão é 3.BBPRthrsh_matmatriz. Uma matriz 3×4 fornecendo os quatro BBPR médios (ramal e ponto de fusterazão) valores para cada uma das três vizinhanças (esfera, pequeno cilindro ecilindro grande) a ser usado para avaliações condicionais e classificação noseguindo quatro classes de saliências: 1) saliências gerais 2) saliências pequenas 3) borda da coroa vivaprotuberância 4) protuberância da cobertura alta do dossel. Veja Wing et al. (2015) página 172 e Tabela 2.Esta matriz deve ser fornecida pelo usuário.DetalhesObserve que este algoritmo realiza estritamente uma classificação com base na entrada do usuário enquanto o originalmétodos de publicação também incluíram uma etapa de segmentação e alguns pré- (filtragem para o primeiro e únicoretorna apenas) e pós-processamento (filtragem apenas para os pontos classificados de obstáculo antes da segmentação)tarefas que agora devem ser realizadas pelo usuário. Além disso, esta implementação pode teralgumas diferenças em comparação com o método original devido a uma possível interpretação incorreta do Winget al. manuscrito, especificamente Tabela 2, onde apresentam quatro grupos de avaliações condicionaiscom sua densidade de pontos de vizinhança necessária e valores médios de BBPR (BBPR = ramo e fusteproporção de pontos; PDR = requisito de densidade de ponto).Este algoritmo atribui cada ponto na nuvem de pontos (coluna snagCls) aos cinco seguintesclasses de obstáculo:• 0: árvore viva – não é um obstáculo• 1: obstáculo geral – a mais ampla gama de situações de ponto de obstáculo• 2: pequenas saliências – saliências isoladas com densidades de ponto mais baixas• 3: protuberância da borda da copa viva – protuberâncias localizadas diretamente adjacentes ou se misturando às copas das árvores vivas• 4: protuberância da cobertura alta do dossel – protuberâncias que se projetam acima do dossel vivo em condições densas (por exemplo,cobertura do dossel> = 55%).Autor (es)Implementação por Andrew Sánchez Meador e Jean-Romain RousselReferênciasWing, Brian M .; Ritchie, Martin W .; Boston, Kevin; Cohen, Warren B .; Olsen, Michael J. 2015.Detecção individual de obstáculos usando dados lidar aerotransportados filtrados por atributos de vizinhança. Sensoriamento remotodo meio ambiente. 163: 165-179 https://doi.org/10.1016/j.rse.2015.03.013

writeLAS147ExemplosLASfile <- system.file (“extdata”, “MixedConifer.laz”, package = “lidR”)# Wing também incluiu -keep_singlepoi = “- keep_first -inside 481260 3812920 481310 3812960″las <- readLAS (LASfile, select = “xyzi”, filtro = poi)# Para o método Wing2015, forneça uma matriz de obstáculo BranchBolePtRatio condicional# limites de avaliação (ver Wing et al. 2015, Tabela 2, pág. 172)bbpr_thresholds <- matriz (c (0,80, 0,80, 0,70,0,85, 0,85, 0,60,0,80, 0,80, 0,60,0,90, 0,90, 0,55),nrow = 3, ncol = 4)# Executar classificação de obstáculo e atribuir classes para cada pontolas <- segment_snags (las, wing2015 (neigh_radii = c (1.5, 1, 2), BBPRthrsh_mat = bbpr_thresholds))# Plote tudo, árvore e pontos de obstáculo …#plot (las, color = “snagCls”, colorPalette = rainbow (5))# Filtre e plote apenas pontos de obstáculoobstáculos <- filter_poi (las, snagCls> 0)#plot (snags, color = “snagCls”, colorPalette = rainbow (5) [- 1])# Wing et als (2015) métodos terminaram com a realização de segmentação de árvore no# nuvem de pontos classificada e filtrada usando o método de bacia hidrográficawriteLASEscreva um arquivo .las ou .lazDescriçãoGrave um objeto LAS em um arquivo binário .las ou .laz (compactação especificada no nome do arquivo)UsowriteLAS (las, arquivo, índice = FALSE)Argumentoslasum objeto da classe LAS.Arquivopersonagem. Uma string de caracteres que nomeia um arquivo de saída.índiceboleano. Também escreva um arquivo lax para indexar os pontos nos arquivosValorNada. Esta função é usada para o efeito colateral de escrever um arquivo.

148$ <-, método LASExemplosLASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS)subconjunto = clip_rectangle (las, 684850, 5017850, 684900, 5017900)writeLAS (subconjunto, tempfile (fileext = “.laz”))$ <-, método LASMétodos herdados, mas modificados de spDescriçãoOs objetos LAS * são objetos espaciais , portanto, herdam vários métodos de sp. No entanto, alguns têmcomportamentos modificados para evitar algumas modificações irrelevantes. Na verdade, um objeto LAS * não pode conterqualquer coisa, pois o conteúdo é restrito pelas especificações do LAS. Se um usuário tentar usar um dessesfunções inadequadas um erro informativo será lançado.Uso## Método de substituição S4 para assinatura LASx $ nome <- valor## Método de substituição S4 para assinatura LAS, ANY, ausentex [[i, j]] <- valor## Método S4 para assinatura LAS, numérico, ANYXI]## Método S4 para assinatura LAScatalog, ANY, ANYx [i, j, …, drop = TRUE]## Método de substituição S4 para assinatura LAScatalog, ANY, ANYx [[i, j]] <- valor## Método de substituição S4 para assinatura LAScatalogx $ nome <- valorArgumentosxUm objeto LAS *nomeUma string literal de caracteres ou um nome (possivelmente entre aspas).valornormalmente um objeto R semelhante a um array de uma classe semelhante a x.Eustring, nome dos elementos a serem extraídos ou substituídos.jNão utilizado….Não utilizadosoltaNão utilizado

$ <-, método LAS149Exemplos## Não correr:LASfile <- system.file (“extdata”, “Megaplot.laz”, package = “lidR”)las = readLAS (arquivo LAS)las $ Z = 2Llas [[“Z”]] = 1:10las $ NewCol = 0las [[“NewCol”]] = 0## End (não executado)

Índice∗ elencoas.spatial, 10∗ conjuntos de dadosasprs, 10stdmetrics, 129∗ algoritmos de modelo de superfície digitaldsmtin, 40p2r, 95pitfree, 96∗ filtrosfilter_duplicates, 44filter_poi, 45filter_surfacepoints, 46filtros, 43∗ algoritmos de segmentação de solocsf, 30pmf, 102∗ algoritmos de detecção de árvore individuallmf, 87manual, 88∗ algoritmos de segmentação de árvore individualdalponte2016, 31li2012, 77silva2016, 126bacia hidrográfica, 144∗ las utilitieslas_check, 74las_utilities, 75∗ lidrpaletteslidrpalettes, 86∗ métricascloud_metrics, 28grid_metrics, 55hexbin_metrics, 60point_metrics, 103árvore_métrica, 136voxel_metrics, 142∗ algoritmos de segmentação de ruídoivf, 64sor, 128∗ normalizarnormalize_height, 90normalize_intensity, 93∗ algoritmos de eliminação de nuvem de pontosmais alto, 61homogeneizar, 62aleatório, 109∗ segmentação de árvore baseada em nuvem de pontosalgoritmosli2012, 77∗ alcancetrack_sensor, 134∗ algoritmos de segmentação de árvore baseados em rasterdalponte2016, 31silva2016, 126bacia hidrográfica, 144∗ bloqueia algoritmos de segmentaçãowing2015, 145∗ algoritmos de interpolação espacialknnidw, 65krigagem, 66lata, 133-, LAS, método RasterLayer(normalize_height), 90-, LAS, lidRAlgorithm-method(normalize_height), 90.stdmetrics (stdmetrics), 129.stdmetrics_ctrl (stdmetrics), 129.stdmetrics_i (stdmetrics), 129.stdmetrics_pulse (stdmetrics), 129.stdmetrics_rn (stdmetrics), 129.stdmetrics_z (stdmetrics), 129.stdshapemetrics (stdmetrics), 129.stdtreemetrics (stdmetrics), 129[, LAS, numérico, método ANY($ <-, método LAS), 148[, LAScatalog, ANY, ANY-método($ <-, método LAS), 148150

ÍNDICE151[[<-, LAS, ANY, método ausente($ <-, método LAS), 148[[<-, LAScatalog, ANY, ANY-método($ <-, método LAS), 148$ <-, método LAS, 148$ <-, método LAScatalog ($ <-, método LAS),148add_attribute, 6add_dtm3d (plot_3d), 100add_flightlines3d (plot_3d), 100add_lasattribute, 91add_lasattribute (add_attribute), 6add_lasattribute_manual(add_attribute), 6add_lasrgb (add_attribute), 6add_treetops3d (plot_3d), 100funções apropriadas, 113área, 8 , 109área, método LAS (área), 8área, método LAScatalog (área), 8área, método LASheader (área), 8as.list.LASheader, 9as.spatial, 10asprs, 10opções disponíveis, 20 , 23 , 24 , 27 , 33 , 35 ,45 ,52 ,54 ,56 ,59 ,92 ,94 ,121 ,123,135 ,137 ,141bbox, 13catálogo (readLAScatalog), 113opções de processamento de catálogo, 17catalog_apply, 12 , 79catalog_intersect, 16catalog_makechunks, 17catalog_options_tools, 18 , 115catalog_retile, 19catalog_sapply (catalog_apply), 12catalog_select, 21classify_ground, 22 , 30 , 66 , 102 , 139 , 140classify_noise, 24 , 64 , 128clipe, 25clip_circle (clipe), 25clip_polygon (clipe), 25clip_rectangle (clipe), 25clip_roi (clipe), 25clip_transect (clipe), 25cloud_metrics, 28 , 57 , 61 , 104 , 129 , 132,138 ,143côncavo, 35count_not_quantized (las_utilities), 75CRS, 69crs, método LAS (projeção), 106crs, método LAScatalog (projeção), 106crs, método LASheader (projeção), 106Classe CRS, 68crs <-, método LAS (projeção), 106csf, 22 , 30 , 102dalponte2016, 31 , 78 , 122 , 127 , 145data.table, 68 , 69decimar pontos, 33 , 46 , 61 , 62 , 109delineate_crowns, 34 , 137densidade (área), 8densidade, método LAS (área), 8densidade, método LAScatalog (área), 8densidade, método LASheader (área), 8preterido, 36dsmtin, 40 , 52 , 95– 97documentação do motor, 20 , 23 , 24 , 27 , 33,35 ,45 ,52 ,54 ,56 ,59 ,92 ,94 ,121,123 ,135 ,137 ,141entropia, 29 , 41 , 56 , 130 , 140epsg (projeção), 106epsg, método LAS (projeção), 106epsg, método LASheader (projeção), 106epsg <- (projeção), 106epsg <-, método LAS (projeção), 106epsg <-, método LASheader (projeção),106Extensão, 27extensão, 13extensão, método LAS, 42extensão, método LAScatalog(extensão, método LAS), 42extrair, 91filter_duplicates, 44 , 44 , 46 , 47filter_first (filtros), 43filter_firstlast (filtros), 43filter_firstofmany (filtros), 43filter_ground (filtros), 43filter_last (filtros), 43filter_nth (filtros), 43filter_poi, 44 , 45 , 45 , 47 , 112

152ÍNDICEfilter_single (filtros), 43filter_surfacepoints, 44– 46 , 46 , 128filtros, 43 , 45– 47find_localmaxima, 47find_trees, 31 , 47 , 48 , 87 , 88 , 126 , 144forest.colors (lidrpalettes), 86fwrite, 78gap_fraction_profile, 50 , 67Gatziolis2019, 51 , 134get_lidr_threads (set_lidr_threads), 124get_range (range_correction), 110grid_canopy, 31 , 40 , 52 , 95 , 96 , 126 , 144grid_density, 53grid_metrics, 28 , 29 , 35 , 53 , 54 , 55 , 57 , 60,61 ,103 ,104 ,129 ,132 ,136– 138,142 ,143grid_terrain, 58 , 65 , 66 , 91 , 92 , 95 , 133height.colors (lidrpalettes), 86hexbin, 60hexbin_metrics, 29 , 57 , 60 , 104 , 129 , 132 ,138 ,143mais alto, 33 , 46 , 61 , 62 , 109homogeneizar, 33 , 62 , 62 , 109índice (lidR-índice espacial), 83índice <- (lidR-índice espacial), 83cruzam, 16é, 63is.parallelised, 81is.quantized (las_utilities), 75ivf, 24 , 64 , 129knnidw, 58 , 65 , 66 , 91 , 95 , 133krige, 66krigagem, 58 , 65 , 66 , 91 , 95 , 133LAD, 29 , 50 , 56 , 67LAS, 6 , 7 , 22 , 24 , 26 , 33 , 35 , 43 , 44 , 46 , 52 , 54,55 ,58 ,75 ,83 ,91 ,94 ,97 ,111 ,113,120 ,122 ,134 ,137 ,141 ,147LAS (classe LAS), 68Classe LAS, 68las_check, 74 , 76las_quantize (las_utilities), 75las_reoffset (las_utilities), 75las_rescale (las_utilities), 75las_update (las_utilities), 75las_utilities, 75 , 75lasadd, 37lasadddata (obsoleto), 36lasaddextrabytes (obsoleto), 36lasaddextrabytes_manual (obsoleto), 36LASBRIGDE (asprs), 10LASBUILDING (asprs), 10LAScatalog, 12 , 17– 20 , 22– 24 , 26 , 27 , 33 , 35,44– 46 ,52 ,54– 56 ,58 ,59 ,75 ,83 ,84,91 ,92 ,94 ,97 ,112 ,113 ,120– 123,134 ,135 ,137 ,141Classe LAScatalog, 12Documentação da classe LAScatalog, 113Documentação do motor LAScatalog, 14 , 20,23 ,25 ,27 ,33 ,35 ,45 ,47 ,49 ,52 ,54,56 ,59 ,92 ,94 ,121 ,124 ,135 ,137,142LAScatalog-class, 27 , 70 , 78 , 115lascheck, 37lascheck (obsoleto), 36lasclip, 37lasclip (obsoleto), 36lasclipCircle (obsoleto), 36lasclipPolygon (obsoleto), 36lasclipRectangle (obsoleto), 36lasdetectshape, 37lasdetectshape (obsoleto), 36lasfilter, 37lasfilter (obsoleto), 36lasfilterdecimate (obsoleto), 36lasfilterduplicates (obsoleto), 36lasfilterfirst (obsoleto), 36lasfilterfirstlast (obsoleto), 36lasfilterfirstofmany (obsoleto), 36lasfilterground (obsoleto), 36lasfilterlast (obsoleto), 36lasfilternth (obsoleto), 36lasfiltersingle (obsoleto), 36lasfiltersurfacepoints, 37lasfiltersurfacepoints (obsoleto), 36lasflightline, 37lasflightline (obsoleto), 36LASGROUND (asprs), 10lasground, 37lasground (obsoleto), 36LASheader, 68 , 69 , 73 , 97 , 115Classe LASheader, 74LASHIGHVEGETATION (asprs), 10

ÍNDICE153LASKEYPOINT (asprs), 10LASLOWPOINT (asprs), 10LASLOWVEGETATION (asprs), 10LASMEDIUMVEGETATION (asprs), 10lasmergespatial, 37lasmergespatial (obsoleto), 36LASNOISE (asprs), 10LASNONCLASSIFIED (asprs), 10lasnormalize, 37lasnormalize (obsoleto), 36Laspulse, 37laspulse (obsoleto), 36LASRAIL (asprs), 10Lasrangecorrection, 37Lasrangecorrection (obsoleto), 36lasremoveextrabytes (obsoleto), 36lasreoffset, 37lasreoffset (obsoleto), 36lasrescale, 37lasrescale (obsoleto), 36LASROADSURFACE (asprs), 10lasscanline (obsoleto), 36lasscanlines, 37lassmooth, 37lassmooth (obsoleto), 36lassnags, 37lassnags (obsoleto), 36lastransform (obsoleto), 36LASTRANSMISSIONTOWER (asprs), 10lastrees, 37lastrees (obsoleto), 36LASUNCLASSIFIED (asprs), 10lasunnormalize (obsoleto), 36lasunsmooth (obsoleto), 36lasvoxelize, 37lasvoxelize (obsoleto), 36LASWATER (asprs), 10LASWIRECONDUCTOR (asprs), 10LASWIREGUARD (asprs), 10li2012, 32 , 77 , 81 , 122 , 127 , 145lidR (pacote lidR), 5lidR-LAScatalog-drivers, 72 , 78pacote lidR, 5lidR-paralelismo, 80 , 125lidR-índice espacial, 83lidrpalettes, 86list.files, 115lmf, 47 , 48 , 80 , 81 , 87 , 89manual, 48 , 87 , 88mapview, 97 , 98matriz, 27mcwatershed (bacia hidrográfica), 144merge_spatial, 89normalize_height, 65 , 90 , 94 , 133normalize_intensity, 92 , 93 , 110npoints (área), 8npoints, método LAS (área), 8npoints, método LAScatalog (área), 8npoints, método LASheader (área), 8opt_chunk_alignment, 71opt_chunk_alignment(catalog_options_tools), 18opt_chunk_alignment <-(catalog_options_tools), 18opt_chunk_buffer, 71opt_chunk_buffer(catalog_options_tools), 18opt_chunk_buffer <-(catalog_options_tools), 18opt_chunk_size, 71opt_chunk_size (catalog_options_tools),18opt_chunk_size <-(catalog_options_tools), 18opt_filter, 72opt_filter (catalog_options_tools), 18opt_filter <- (catalog_options_tools), 18opt_independent_files(catalog_options_tools), 18opt_independent_files <-(catalog_options_tools), 18opt_laz_compression(catalog_options_tools), 18opt_laz_compression <-(catalog_options_tools), 18opt_merge (catalog_options_tools), 18opt_merge <- (catalog_options_tools), 18opt_output_files, 72opt_output_files(catalog_options_tools), 18opt_output_files <-(catalog_options_tools), 18opt_progress, 71opt_progress (catalog_options_tools), 18

154ÍNDICEopt_progress <- (catalog_options_tools),18opt_select, 72opt_select (catalog_options_tools), 18opt_select <- (catalog_options_tools), 18opt_stop_early, 71opt_stop_early (catalog_options_tools),18opt_stop_early <-(catalog_options_tools), 18opt_wall_to_wall, 71opt_wall_to_wall(catalog_options_tools), 18opt_wall_to_wall <-(catalog_options_tools), 18p2r, 41 , 52 , 95 , 97pastel.colors (lidrpalettes), 86pitfree, 41 , 52 , 95 , 96plot, 22 , 89 , 97 , 98 , 100plot, LAS, método em falta (plot), 97plot, LAScatalog, método ausente (plot),97plot, LASheader, método ausente (plot), 97plot.lasmetrics3d, 99plot_3d, 100plot_dtm3d (plot_3d), 100pmf, 22 , 31 , 102point_metrics, 29 , 57 , 61 , 103 , 129 , 132,138 ,143pontos3d, 98 , 100Polígono, 27Polígonos, 27impressão, 106imprimir, método LAS (imprimir), 106print.lidRAlgorithm (imprimir), 106projeção, 106projeção, método LAS (projeção), 106projeção, método LAScatalog(projeção), 106projeção, método LASheader(projeção), 106projeção <-, método LAS (projeção),106quantize (las_utilities), 75aleatório, 33 , 62 , 109random.colors (lidrpalettes), 86range_correction, 94 , 110raster :: extensão, 43RasterLayer, 91rbind.LAS, 111leia * LAS (), 83readALSLAS (readLAS), 111readALSLAScatalog (readLAScatalog), 113readDAPLAS (readLAS), 111readDAPLAScatalog (readLAScatalog), 113readLAS, 13 , 69 , 71 , 72 , 111 , 115readLAScatalog, 70 , 113readLASheader, 115readMSLAS (readLAS), 111readTLSLAS (readLAS), 111readTLSLAScatalog (readLAScatalog), 113readUAVLAS (readLAS), 111readUAVLAScatalog (readLAScatalog), 113remove_lasattribute (add_attribute), 6retrieve_flightlines (retrieve_pulses),116retrieve_pulses, 62 , 109 , 116retrieve_scanlines (retrieve_pulses),116rlas :: read.las, 112Roussel2020, 117 , 134índice_ rumple, 118segment_shapes, 119 , 125segment_snags, 120 , 145segment_trees, 31 , 32 , 77 , 122 , 126 , 144sensor (lidR-índice espacial), 83sensor <- (lidR-índice espacial), 83sensor_tracking, 37sensor_tracking (obsoleto), 36set_lidr_threads, 80 , 124setDTthreads, 124detecção_forma, 125shp_hplane, 120shp_hplane (shape_detection), 125shp_line, 120shp_line (shape_detection), 125shp_plane, 120shp_plane (shape_detection), 125silva2016, 32 , 78 , 122 , 126 , 145SimpleFeature, 27smooth_height, 127sor, 24 , 64 , 128Espacial, 68 , 69 , 148indexação espacial, 68 , 69 , 71 , 112 , 113

ÍNDICE155SpatialPoints, 27SpatialPointsDataFrame, 27SpatialPolygons, 27SpatialPolygonsDataFrame, 27spheres3d, 101stdmetrics, 29 , 56 , 129stdmetrics_ctrl (stdmetrics), 129stdmetrics_i (stdmetrics), 129stdmetrics_pulse (stdmetrics), 129stdmetrics_rn (stdmetrics), 129stdmetrics_tree, 137stdmetrics_z (stdmetrics), 129stdshapemetrics (stdmetrics), 129stdtreemetrics (stdmetrics), 129storable_coordinate_range(las_utilities), 75resumo (impressão), 106resumo, método LAS (imprimir), 106resumo, método LAScatalog (imprimir), 106surface3d, 101estanho, 58 , 65 , 66 , 91 , 95 , 133track_sensor, 51 , 110 , 117 , 134árvore_detecção, 37tree_detection (obsoleto), 36tree_hull, 37tree_hulls (obsoleto), 36árvore_métrica, 29 , 35 , 57 , 61 , 104 , 129 , 131,132 ,136 ,143unnormalize_height, 90unnormalize_height (normalize_height),90unsmooth_height (smooth_height), 127util_makeZhangParam, 102 , 139VCI, 29 , 42 , 56 , 140vgm, 66voxel_metrics, 29 , 35 , 57 , 61 , 104 , 129 , 132,137 ,138 ,142voxelize_points, 141bacia hidrográfica, 32 , 78 , 122 , 127 , 144wing2015, 120 , 145wkt, método LAS (projeção), 106wkt, método LASheader (projeção), 106wkt <- (projeção), 106wkt <-, método LAS (projeção), 106wkt <-, método LASheader (projeção), 106escrever LAS, 7 , 78 , 147writeOGR, 78 , 79writeRaster, 78