lidR Package

https://r-lidar.github.io/lidRbook
Admin
A guide to the lidR R package for manipulating and visualizing airborne laser scanning (ALS) data,...
Tokens:42,399
Snippets:242
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Read LAS Catalog with Sample Data

Source: https://r-lidar.github.io/lidRbook/engine

Reads a LAScatalog from a specific directory containing sample data. This example uses a collection of nine 500x500m files.

```R
ctg <- readLAScatalog("data/ENGINE/catalog/")
```

--------------------------------

### lidRviewer Installation

Source: https://r-lidar.github.io/lidRbook/view

Provides instructions on how to install the `lidRviewer` package, which is not available on CRAN and must be installed from a specific R-universe repository.

```APIDOC
Package: lidRviewer

Installation:
  Not on CRAN.
  Install from R-universe:
  install.packages('lidRviewer', repos = 'https://r-lidar.r-universe.dev')
```

--------------------------------

### Custom Ground Classification Algorithm

Source: https://r-lidar.github.io/lidRbook/gnd

Demonstrates how to integrate a custom ground classification algorithm into the `lidR` workflow. This example shows the syntax for applying a user-defined method with parameters.

```R
las <- classify_ground(las, algorithm = my_new_method(param1 = 0.05))
```

--------------------------------

### Read and Plot LAS Data

Source: https://r-lidar.github.io/lidRbook/dtm

Loads a LAS file from the lidR package's example data and displays the point cloud. This is a foundational step before DTM generation.

```R
LASfile <- system.file("extdata", "Topography.laz", package="lidR")
las <- readLAS(LASfile, select = "xyzc")
plot(las, size = 3, bg = "white")
```

--------------------------------

### LAScatalog Summary Example

Source: https://r-lidar.github.io/lidRbook/engine

Demonstrates the output of the `summary()` function applied to a LAScatalog object, displaying key processing options, extent, coordinate reference system, area, point density, number of files, and driver configurations.

```R
summary(ctg)
#> class       : LAScatalog (v1.0 format 1)
#> extent      : 338000, 339500, 5238000, 5239500 (xmin, xmax, ymin, ymax)
#> coord. ref. : WGS 84 / UTM zone 19N
#> area        : 2.25 km²
#> points      : 9.45 million points
#> density     : 4.2 points/m²
#> density     : 3.4 pulses/m²
#> num. files  : 9
#> proc. opt.  : buffer: 10 | chunk: 250
#> input opt.  : select: * | filter: -keep_class 2
#> output opt. : on disk | w2w guaranteed | merging enabled
#> drivers     :
#>  - Raster : format = GTiff  NAflag = -999999
#>  - stars : NA_value = -999999
#>  - Spatial : overwrite = FALSE
#>  - SpatRaster : overwrite = FALSE  NAflag = -999999
#>  - SpatVector : overwrite = FALSE
#>  - LAS : no parameter
#>  - sf : quiet = TRUE
#>  - data.frame : no parameter
```

--------------------------------

### Example of Integrating a New Algorithm (mba)

Source: https://r-lidar.github.io/lidRbook/plugins

Illustrates how a newly created algorithm, such as 'mba' for bicubic spline interpolation, can be integrated into lidR functions like rasterize_terrain, making it usable in the same way as built-in algorithms.

```R
dtm <- rasterize_terrain(las, algorithm = mba(n = 1, h = 8))
```

--------------------------------

### Read LAS with Multiple Filter Options

Source: https://r-lidar.github.io/lidRbook/io

Shows how to apply multiple filter commands simultaneously when reading a LAS file. This example keeps only the first returns and filters points based on Z-coordinates, demonstrating efficient data subsetting at read time.

```R
las <-  readLAS("file.las", filter = "-keep_first -drop_z_below 5 -drop_z_above 50")
```

--------------------------------

### Install lidR Dependencies on Ubuntu

Source: https://r-lidar.github.io/lidRbook/index

Installs necessary external libraries required for building and running the lidR package on Ubuntu Linux systems. These dependencies are crucial for proper functionality.

```Shell
sudo apt-get install libgdal-dev libgeos++-dev libudunits2-dev libproj-dev libx11-dev libgl1-mesa-dev libglu1-mesa-dev libfreetype6-dev libxt-dev libfftw3-dev
```

--------------------------------

### Install lidR Dependencies on Fedora

Source: https://r-lidar.github.io/lidRbook/index

This command installs essential development libraries on Fedora systems required for compiling and using the lidR R package. It includes packages for GDAL, GEOS, UDUNITS-2, PROJ, OpenGL, FreeType, and JPEG.

```bash
sudo dnf install gdal-devel geos-devel udunits2-devel proj-devel mesa-libGL-devel mesa-libGLU-devel freetype-devel libjpeg-turbo-devel
```

--------------------------------

### Inefficient Multi-step Processing Example

Source: https://r-lidar.github.io/lidRbook/engine2

Demonstrates a less optimal approach to processing LAS data, involving separate normalization and colorization steps. This method reads the point cloud twice and requires intermediate file storage, highlighting the inefficiencies that the LAScatalog engine aims to solve.

```R
opt_output_files(ctg) <- paste0(tempdir(), "/{*}_normalized") # specify output normalized las disk save location
ctg_norm <- normalize_height(ctg, tin()) # normalize

# loop through catalog files and apply rgb colour
rgb <- terra::rast("rgb.tif")
for (file in ctg$filename)
{
  newname <-  tools::file_path_sans_ext(basename(file))
  newname <- paste0("folder/", newname, "_colored.laz")
  las <- readLAS(file)
  las <- merge_spatial(las, rgb)
  writeLAS(las, newname)
}
```

--------------------------------

### Install lidR R Package

Source: https://r-lidar.github.io/lidRbook/index

Installs the lidR package from CRAN using the install.packages function in R. This is the primary method for obtaining the package for use in R environments.

```R
install.packages("lidR")
```

--------------------------------

### Compare tree detection with different window sizes

Source: https://r-lidar.github.io/lidRbook/itd

This example demonstrates the impact of the window size parameter (`ws`) in the Local Maximum Filter (LMF) on tree detection. It compares results from `ws = 3` meters (potentially over-detecting) and `ws = 11` meters (potentially under-detecting) by plotting the detected tree tops on the CHM.

```R
ttops_3m <- locate_trees(las, lmf(ws = 3))
ttops_11m <- locate_trees(las, lmf(ws = 11))

par(mfrow=c(1,2))
plot(chm, col = height.colors(50))
plot(sf::st_geometry(ttops_3m), add = TRUE, pch = 3)
plot(chm, col = height.colors(50))
plot(sf::st_geometry(ttops_11m), add = TRUE, pch = 3)
```

--------------------------------

### Get Help for LAS Read Filters

Source: https://r-lidar.github.io/lidRbook/io

Retrieves the full list of available filter commands for the `readLAS` function. This is useful for understanding all filtering capabilities provided by the underlying LASlib.

```R
readLAS(filter = "-help")
```

--------------------------------

### R: Use mba Algorithm for DTM Rasterization

Source: https://r-lidar.github.io/lidRbook/plugins

Shows a practical example of using the 'mba' algorithm with lidR functions. It reads a LAS file, applies the 'mba' algorithm to 'rasterize_terrain', and then plots the resulting Digital Terrain Model (DTM).

```R
LASfile <- system.file("extdata", "Topography.laz", package="lidR")
las <- readLAS(LASfile)
dtm <- rasterize_terrain(las, algorithm = mba())
plot(dtm, col = gray(1:50/50))
```

--------------------------------

### Classify Ground Without Output Path (Error Example)

Source: https://r-lidar.github.io/lidRbook/engine

Illustrates the error handling when `classify_ground` is called on a `LAScatalog` without a specified output file template. The function enforces the provision of an output path to avoid memory exhaustion, returning an error if none is found.

```R
opt_output_files(ctg) <- ""
classified_ctg <- classify_ground(ctg, csf())
#> Error: This function requires that the LAScatalog provides an output file template.
```

--------------------------------

### Classify Ground with Tuned CSF Parameters

Source: https://r-lidar.github.io/lidRbook/gnd

Applies the Cloth Simulation Filtering (CSF) algorithm with custom parameters to improve ground classification accuracy. This example demonstrates tuning `sloop_smooth`, `class_threshold`, `cloth_resolution`, and `time_step` for better results on specific datasets.

```R
mycsf <- csf(sloop_smooth = TRUE, class_threshold = 1, cloth_resolution = 1, time_step = 1)
las <- classify_ground(las, mycsf)
```

--------------------------------

### Process Independent Files for Ground Inventories

Source: https://r-lidar.github.io/lidRbook/engine

Configures `catalog_retile` for independent files, typical for ground inventories. It disables chunking, buffering, and wall-to-wall processing to ensure each file is processed individually without aggregation, preventing errors with overlapping data. The example then uses `rasterize_terrain` on this collection.

```R
opt_chunk_size(rois) <- 0 # processing by files
opt_chunk_buffer(rois) <- 0 # no buffer
opt_wall_to_wall(rois) <- FALSE # disable internal checks to ensure a valid output. Free wheel mode
opt_merge(rois) <- FALSE
opt_output_files(rois) <- ""

dtm <- rasterize_terrain(rois, 1, tin())
plot(dtm[[1]], col = gray(1:50/50))
```

--------------------------------

### R: Performance Comparison for point_metrics (TLS vs ALS)

Source: https://r-lidar.github.io/lidRbook/spatialindex

Compares the processing time of the `point_metrics()` function using a terrestrial (TLS) point cloud versus an airborne (ALS) point cloud read with the generic `readLAS()` function. This example illustrates an approximately 8-fold processing time reduction when using `readTLSLAS()` for TLS data.

```R
system.time(point_metrics(las, r = 1, ~length(Z)))
#> utilisateur     système      écoulé
#>       3.616       0.000       3.616
system.time(point_metrics(tls, r = 1, ~length(Z)))
#> utilisateur     système      écoulé
#>       1.012       0.000       1.013
```

--------------------------------

### R: Test `norm_color` with Missing Output Path

Source: https://r-lidar.github.io/lidRbook/engine2

This R code snippet demonstrates the failure of the `norm_color` function when an output file template is not provided to the `LAScatalog`. The test case shows how the function, due to the `need_output_file = TRUE` option, throws an informative error, preventing execution and guiding the user to set the output path.

```R
opt_output_files(ctg) <- ""
ctg_norm_colored <- norm_color(ctg, rgbmap)
#> Error: This function requires that the LAScatalog provides an output file template.
```

--------------------------------

### Custom Metric Calculation and Visualization

Source: https://r-lidar.github.io/lidRbook/metrics

Illustrates how to define and apply custom metrics to lidar data using lidR functions. This example calculates the average intensity ('avgI') for different spatial units (pixels, crowns, hexagons) and visualizes the results using base R plotting. It requires reading a LAS file and specifying the metric calculation and resolution/geometry.

```R
LASfile <- system.file("extdata", "MixedConifer.laz", package ="lidR")
las <- readLAS(LASfile)

m <- ~list(avgI = mean(Intensity))

a <- pixel_metrics(las, m, res = 5)
b <- crown_metrics(las, m, geom = "point")
c <- crown_metrics(las, m, geom = "convex")
d <- hexagon_metrics(las, m, area = 25)

par(mfrow=c(2,2))
plot(a, col = heat.colors(15), legend = FALSE)
plot(b["avgI"], pal = heat.colors, pch = 19, cex = 1, axes = TRUE, key.pos = NULL, reset = FALSE)
plot(c["avgI"], pal = heat.colors, axes = TRUE, key.pos = NULL, reset = FALSE)
plot(d["avgI"], pal = heat.colors, axes = TRUE, key.pos = NULL, reset = FALSE)
```

--------------------------------

### R: Instantiate and Inspect lidR Algorithm

Source: https://r-lidar.github.io/lidRbook/plugins

Demonstrates how to instantiate the 'mba' algorithm with specific parameters (e.g., h = 6) and inspect the resulting object. The output shows the algorithm's class, purpose, compatibility, and configured parameters.

```R
algo <- mba(h = 6)
algo
```

--------------------------------

### Normalize Intensity Values

Source: https://r-lidar.github.io/lidRbook/outbox

Clips intensity values that exceed 255 to 255. This is a simplification for the example to ensure intensities fit within a standard color range.

```R
las@data[Intensity > 255L, Intensity := 255L]
```

--------------------------------

### Plot LAS Catalog (Sample Data)

Source: https://r-lidar.github.io/lidRbook/engine

Visualizes the sample LAScatalog, showing the spatial layout of the nine included LAS files.

```R
plot(ctg)
```

--------------------------------

### LAScatalog Initialization and Plotting

Source: https://r-lidar.github.io/lidRbook/engine2

Shows how to read a LAScatalog from a directory and visualize its spatial extent. This is a foundational step for applying processing functions to a collection of LAS files.

```R
ctg <- readLAScatalog("data/ENGINE/catalog/")
plot(ctg)
```

--------------------------------

### SpatialIndex C++ Class API Reference

Source: https://r-lidar.github.io/lidRbook/spatialindex

This section outlines the public interface of the `lidR::SpatialIndex` C++ class. It details the available constructors for initializing the index and the public methods for performing spatial queries like nearest neighbor search (`knn`) and range queries (`lookup`).

```APIDOC
SpatialIndex Class API:

Constructors:
  SpatialIndex(const Rcpp::S4 las);
    - Initializes the spatial index with a given LAS object.
  SpatialIndex(const Rcpp::S4 las, const std::vector<bool>& filter);
    - Initializes the spatial index with a LAS object and an optional filter.

Public Members (Methods):
  template<typename T> void lookup(T& shape, std::vector<PointXYZ>& res);
    - Queries the index for points within a user-defined shape.
    - T: Type representing the query shape (e.g., Circle).
    - res: Vector to store the resulting PointXYZ objects.

  void knn(const PointXY& p, const unsigned int k, std::vector<PointXYZ>& res);
    - Finds the k nearest neighbors to a 2D point.
    - p: The 2D query point.
    - k: The number of nearest neighbors to find.
    - res: Vector to store the resulting PointXYZ objects.

  void knn(const PointXYZ& p, const unsigned int k, std::vector<PointXYZ>& res);
    - Finds the k nearest neighbors to a 3D point.
    - p: The 3D query point.
    - k: The number of nearest neighbors to find.
    - res: Vector to store the resulting PointXYZ objects.

  void knn(const PointXY& p, const unsigned int k, const double r, std::vector<PointXYZ>& res);
    - Finds the k nearest neighbors to a 2D point within a specified radius.
    - p: The 2D query point.
    - k: The number of nearest neighbors to find.
    - r: The maximum radius for neighbors.
    - res: Vector to store the resulting PointXYZ objects.

Note: The `SpatialIndex` can be a grid partition, voxel partition, quadtree, or octree depending on how it was initialized.
```

--------------------------------

### Read and Plot LAS Data

Source: https://r-lidar.github.io/lidRbook/point_metrics

Reads a LAS file into an R object and displays a basic plot of the point cloud. This is a common starting point for point cloud processing tasks.

```R
las <- readLAS("data/chap11/building_WilliamsAZ_Urban_normalized.laz")
plot(las, size = 3)
```

--------------------------------

### Extract Single ROI from LAS Object

Source: https://r-lidar.github.io/lidRbook/engine

Extracts a circular region of interest (ROI) from a LAS object loaded into memory. This function is a starting point for exploring the LAScatalog engine's capabilities.

```R
plot <- clip_circle(las, x = 338700, y = 5238650, radius = 15)
```

--------------------------------

### R: Basic file loop for LAS processing (Bad Practice)

Source: https://r-lidar.github.io/lidRbook/engine

This R code demonstrates a basic `for` loop to process individual LAS files sequentially. It highlights a common but inefficient and problematic approach for large datasets, as it lacks spatial context and buffering, leading to artifacts at file edges.

```R
files <- list.files("folder/")
for (file in files) {
  las <- readLAS(file)
  output <- do.something(las)
  write(output, "path/to/output.ext")
}
```

--------------------------------

### point_metrics(): Filtering Outliers

Source: https://r-lidar.github.io/lidRbook/point_metrics

Illustrates how to compute metrics while excluding specific points (e.g., outliers) using the `filter` argument in `point_metrics()`. No metric is computed for outliers, and they are not used to get the local neighborhood of the other points.

```R
metrics <- point_metrics(las, ~list(imean = mean(Intensity)), k = 7, filter = ~Intensity < 100 ) # calculate mean intensity and exclude outliers
```

--------------------------------

### Define Custom Voxel Metrics Function

Source: https://r-lidar.github.io/lidRbook/voxel_metrics

Defines a user-created function to calculate custom metrics for points within each voxel. This example calculates the minimum, mean, maximum, and standard deviation of the Intensity attribute.

```R
custom_metrics <- function(x) { # user-defined function
  m <- list(
    i_min = min(x),
    i_mean = mean(x),
    i_max = max(x),
    i_sd = sd(x)
  )
  return(m) # output
}
```

--------------------------------

### Classify Ground with Output Files

Source: https://r-lidar.github.io/lidRbook/engine

Demonstrates using the `classify_ground` function with a `LAScatalog` and specifying an output file template using `opt_output_files`. This ensures that the processed point cloud data is saved to disk as LAS files, preventing potential memory issues.

```R
opt_output_files(ctg) <- paste0(tempdir(), "{*}_classified")
classified_ctg <- classify_ground(ctg, csf())
```

--------------------------------

### Area Based Approach with Pixel Metrics

Source: https://r-lidar.github.io/lidRbook/engine

Applies an area-based approach using `pixel_metrics` to compute statistics (e.g., mean Z) over specified raster cells. This example demonstrates its use with pre-selected and filtered catalog data.

```R
opt_select(ctg_norm) <- "xyz"
hmean <- pixel_metrics(ctg_norm, ~mean(Z), 10)
```

```R
opt_select(ctg_norm) <- "xyz"
opt_filter(ctg_norm) <- "-keep_first"
hmean <- pixel_metrics(ctg_norm, ~mean(Z), 10)

plot(hmean, col = height.colors(25))
```

--------------------------------

### Locate Trees and Display Results

Source: https://r-lidar.github.io/lidRbook/engine

Demonstrates how to use the `locate_trees()` function to detect individual trees from a normalized lidar catalog (`ctg_norm`). It shows how to display the resulting point features and their attributes, including the initial tree IDs.

```R
ttops <- locate_trees(ctg_norm, lmf(4))
ttops
#> Simple feature collection with 102492 features and 2 fields
#> Geometry type: POINT
#> Dimension:     XY
#> Bounding box:  xmin: 338000 ymin: 5238000 xmax: 339500 ymax: 5239500
#> Projected CRS: WGS 84 / UTM zone 19N
#> First 10 features:
#>    treeID      Z                 geometry
#> 1       1 17.441 POINT (338007.6 5238481)
#> 2       2 16.313 POINT (338012.7 5238481)
#> 3       3 16.342 POINT (338007.1 5238488)
#> 4       4 16.199 POINT (338007.4 5238491)
#> 5       5 14.140 POINT (338002.9 5238497)
#> 6       6 18.999 POINT (338019.3 5238496)
#> 7       7 16.330 POINT (338012.1 5238499)
#> 8       8 18.669   POINT (338018 5238492)
#> 9       9 18.508 POINT (338016.3 5238493)
#> 10     10 17.622 POINT (338014.6 5238491)
plot(ttops["Z"], cex = 0.001, pch = 19, pal = height.colors, nbreaks = 30)
```

--------------------------------

### Create .lax spatial index file with rlas

Source: https://r-lidar.github.io/lidRbook/spatialindex

Demonstrates how to create a .lax spatial index file for a LAS file using the rlas package in R. This index enables faster spatial queries without reading the entire LAS file.

```R
rlas::writelax("file.las")
```

--------------------------------

### Configure Output Files and Run Detection

Source: https://r-lidar.github.io/lidRbook/engine

Shows how to configure `lidR` to write output files to a specified directory using `opt_output_files()` and then run `locate_trees()` with reproducible IDs. The function returns a vector of file paths for the generated output.

```R
opt_output_files(ctg_norm) <- paste0(tempdir(), "/{*}")
locate_trees(ctg_norm, lmf(4), uniqueness = "bitmerge")
#> [1] "/tmp/Rtmp2DfSGa/tiles_338000_5238000_1_norm.shp"
#> [2] "/tmp/Rtmp2DfSGa/tiles_338000_5238500_1_norm.shp"
#> [3] "/tmp/Rtmp2DfSGa/tiles_338000_5239000_1_norm.shp"
#> [4] "/tmp/Rtmp2DfSGa/tiles_338500_5238000_1_norm.shp"
#> [5] "/tmp/Rtmp2DfSGa/tiles_338500_5238500_1_norm.shp"
#> [6] "/tmp/Rtmp2DfSGa/tiles_338500_5239000_1_norm.shp"
#> [7] "/tmp/Rtmp2DfSGa/tiles_339000_5238000_1_norm.shp"
#> [8] "/tmp/Rtmp2DfSGa/tiles_339000_5238500_1_norm.shp"
#> [9] "/tmp/Rtmp2DfSGa/tiles_339000_5239000_1_norm.shp"
```

--------------------------------

### Compute Crown Metrics and Visualize Convex Hull Area

Source: https://r-lidar.github.io/lidRbook/itd

Computes crown metrics for segmented trees using the crown_metrics function in lidR. This example calculates the convex hull area for each tree and visualizes the distribution of these areas.

```R
crowns <- crown_metrics(las, func = .stdtreemetrics, geom = "convex")
plot(crowns["convhull_area"], main = "Crown area (convex hull)")
```

--------------------------------

### Map Predictive Model per Pixel (R)

Source: https://r-lidar.github.io/lidRbook/grid_metrics

Applies a predictive model, defined as a formula, to LiDAR data at a specified pixel resolution (20m). This example shows how to map forest inventory attributes by combining ALS variables, demonstrating the flexibility of `pixel_metrics` for spatial prediction.

```R
prediction <- pixel_metrics(las, ~0.7018 * sum(Z > 2)/length(Z) + 0.9268 *max(Z), 20) # predicting model mapping
plot(prediction, col = height.colors(50)) # some plotting
```

--------------------------------

### LAScatalog Object Representation (Sample Data)

Source: https://r-lidar.github.io/lidRbook/engine

Displays the summary information for a LAScatalog object created from sample data, showing its properties like extent, CRS, area, and file count.

```R
ctg
#> class       : LAScatalog (v1.0 format 1)
#> extent      : 338000, 339500, 5238000, 5239500 (xmin, xmax, ymin, ymax)
#> coord. ref. : WGS 84 / UTM zone 19N
#> area        : 2.25 km²
#> points      : 9.45 million points
#> density     : 4.2 points/m²
#> density     : 3.4 pulses/m²
#> num. files  : 9
```

--------------------------------

### Read and Visualize LAS Catalog

Source: https://r-lidar.github.io/lidRbook/modelling

Reads a directory of LAS/LAZ files into a `LAScatalog` object for efficient processing. Includes printing summary information and plotting the catalog's spatial extent.

```R
ctg <- readLAScatalog("folder/")
print(ctg)
plot(ctg)
```

--------------------------------

### CHM Post-processing with terra Package

Source: https://r-lidar.github.io/lidRbook/dsm

Shows how to post-process a Canopy Height Model (CHM) generated by `lidR` using the `terra` package. This example includes filling missing values (NA) and smoothing the CHM using focal operations.

```R
fill.na <- function(x, i=5) { if (is.na(x)[i]) { return(mean(x, na.rm = TRUE)) } else { return(x[i]) }}
w <- matrix(1, 3, 3)

chm <- rasterize_canopy(las, res = 0.5, algorithm = p2r(subcircle = 0.15), pkg = "terra")
filled <- terra::focal(chm, w, fun = fill.na)
smoothed <- terra::focal(chm, w, fun = mean, na.rm = TRUE)

chms <- c(chm, filled, smoothed)
names(chms) <- c("Base", "Filled", "Smoothed")
plot(chms, col = col)
```

--------------------------------

### Create Buffered Ground Returns in Parallel

Source: https://r-lidar.github.io/lidRbook/engine

Combines options to generate a buffered set of small files containing only ground returns, processed in parallel using the `future` package. It sets output file names, buffer size, chunk size, and filters for class 2 (ground).

```R
library(future)
plan(multisession)

opt_output_files(ctg) <- paste0(tempdir(), "/{XLEFT}_{YBOTTOM}_first_buffered")
opt_chunk_buffer(ctg) <- 10
opt_chunk_size(ctg) <- 250
opt_filter(ctg) <- "-keep_class 2"
newctg <- catalog_retile(ctg)
plot(newctg)
```

--------------------------------

### Calculate Custom Voxel Metrics

Source: https://r-lidar.github.io/lidRbook/voxel_metrics

Applies a user-defined function to calculate custom metrics for each voxel. This example uses the `custom_metrics` function to compute statistics (min, mean, max, sd) of the Intensity attribute for points within each 4x4x4 meter voxel.

```R
vox_met <- voxel_metrics(las, ~custom_metrics(Intensity), 4) # calculate voxel metrics
```

--------------------------------

### Calculate Multiple Cloud Metrics with .stdmetrics_z

Source: https://r-lidar.github.io/lidRbook/cloud_metrics

Shows how to compute a comprehensive suite of 36 standard metrics for a point cloud using `cloud_metrics` with the `.stdmetrics_z` function. The output is a list containing various height-related metrics.

```R
metrics <- cloud_metrics(las, func = .stdmetrics_z)
str(head(metrics)) # output is a list
#> List of 6
#>  $ zmax    : num 30
#>  $ zmean   : num 13.3
#>  $ zsd     : num 7.45
#>  $ zskew   : num -0.476
#>  $ zkurt   : num 2.08
#>  $ zentropy: num 0.903
```

--------------------------------

### R Sequential Scan for Spatial Query

Source: https://r-lidar.github.io/lidRbook/spatialindex

Demonstrates a basic R implementation of a sequential scan to find points within a circular radius. This method involves calculating the distance from every point to the query center, which is computationally expensive for large datasets.

```R
p = c(300, 350)
R = 25
X = runif(1e4, 0, 1000)
Y = runif(1e4, 0, 1000)
query = sqrt((X - p[1])^2 + (Y - p[2])^2) < R
Xq = X[query]
Yq = Y[query]
```

--------------------------------

### Interactive Point Cloud Viewer with lidRviewer

Source: https://r-lidar.github.io/lidRbook/view

Demonstrates how to load the lidRviewer package and use its enhanced plot() function for interactive point cloud visualization. It highlights features like rotation, zooming, panning, and various colorization options, comparing its capabilities to the rgl package.

```R
library(lidRviewer)

# Load your LAS object (e.g., las)
# plot(las)

# Example of interactive commands:
# Rotate with left mouse button.
# Zoom with mouse wheel.
# Pan with right mouse button.
# Colorize with RGB: 'r', 'g', or 'b'
# Colorize with Z: 'z'
# Colorize with Intensity: 'i'
# Colorize with Classification: 'c'
# Change point size: '+' or '-'
# Enable/disable eye-dome lighting: 'l'
# Adjust point display budget: 'ctrl' + 'wheel'
```

--------------------------------

### Calculate Standard Metrics per Pixel (R)

Source: https://r-lidar.github.io/lidRbook/grid_metrics

Illustrates using a predefined set of standard metrics, accessible via `.stdmetrics`, with the `pixel_metrics` function. This enables the efficient calculation of numerous common metrics that summarize point distribution, intensity, and return structure across specified pixel resolutions.

```R
metrics <- pixel_metrics(las, .stdmetrics, 10) # calculate standard metrics
plot(metrics, col = height.colors(50))
```

--------------------------------

### R: Classify Ground Points using PMF (Single Parameters)

Source: https://r-lidar.github.io/lidRbook/gnd

Applies the Progressive Morphological Filter (PMF) algorithm to classify ground points in a LAS object. This example uses single values for the window size (ws) and threshold height (th) parameters.

```R
LASfile <- system.file("extdata", "Topography.laz", package="lidR")
las <- readLAS(LASfile, select = "xyzrn")
las <- classify_ground(las, algorithm = pmf(ws = 5, th = 3))
```

--------------------------------

### Applying Generic Normalization and Coloring Functions

Source: https://r-lidar.github.io/lidRbook/engine2

Demonstrates how to use the created generic `norm_color` function on both a `LAS` object and a `LAScatalog` object, showcasing its versatility.

```R
las_norm_colored <-  norm_color(las, rgbmap)

opt_output_files(ctg) <- paste0(tempdir(), "/{*}_norm_rgb")
ctg_norm_colored <-  norm_color(ctg, rgbmap)
```

--------------------------------

### Load sf Package for Spatial Data

Source: https://r-lidar.github.io/lidRbook/modelling

Loads the 'sf' package, which is essential for handling and manipulating spatial data in R. This is a common first step when working with geospatial datasets like shapefiles or spatial plots.

```R
library(sf)
```

--------------------------------

### R: Performance Comparison for segment_shapes (TLS vs ALS)

Source: https://r-lidar.github.io/lidRbook/spatialindex

Compares the processing time of the `segment_shapes()` function using a terrestrial (TLS) point cloud versus an airborne (ALS) point cloud read with the generic `readLAS()` function. The example shows a significant speedup when using the correct `readTLSLAS()` function for TLS data.

```R
system.time(segment_shapes(las, shp_plane(k = 15), "Coplanar"))
#> utilisateur     système      écoulé
#>       1.419       0.000       0.289
system.time(segment_shapes(tls, shp_plane(k = 15), "Coplanar"))
#> utilisateur     système      écoulé
#>       0.838       0.000       0.159
```

--------------------------------

### Analyze Computed Metrics and Model Fit

Source: https://r-lidar.github.io/lidRbook/cloud_metrics

Shows the first few rows of the computed metrics data, including derived metrics like zsd and zmax. It also displays the summary of a linear model built using these metrics and the VOI, illustrating the relationship between them.

```R
head(metrics[,1:8])
#> Simple feature collection with 5 features and 8 fields
#> Geometry type: POINT
#> Dimension:     XY
#> Bounding box:  xmin: 684838.9 ymin: 5017796 xmax: 684976.6 ymax: 5017958
#> Projected CRS: NAD83 / UTM zone 17N
#>   IDPEP       VOI  zmax     zmean      zsd      zskew    zkurt  zentropy
#> 1 PEPQ1 14.157140 26.51 15.266532 7.501101 -0.9581676 2.687772 0.8737729
#> 2 PEPQ2 12.720584 25.21 16.672082 6.047432 -1.1462600 3.621553 0.8650151
#> 3 PEPQ3 11.396656 26.18 16.021130 6.527808 -0.6480083 2.423936 0.9338795
#> 4 PEPQ4 11.597471 25.56 12.650627 6.382219 -0.2211468 2.577838 0.9059746
#> 5 PEPQ5  8.263425 21.15  8.158578 5.836870  0.2195201 2.083665 0.9278232
#>                   geometry
#> 1 POINT (684976.6 5017821)
#> 2 POINT (684923.9 5017958)
#> 3 POINT (684838.9 5017942)
#> 4   POINT (684855 5017891)
#> 5   POINT (684944 5017796)

model <- lm(VOI~zsd+zmax, data = metrics)
summary(model)
#> 
#> Call:
#> lm(formula = VOI ~ zsd + zmax, data = metrics)
#> 
#> Residuals:
#>       1       2       3       4       5
#>  0.4529  1.2803 -1.1660 -0.3993 -0.1680
#> 
#> Coefficients:
#>             Estimate Std. Error t value Pr(>|t|)
#> (Intercept) -11.6898     7.7171  -1.515    0.269
#> zsd           0.9381     1.4239   0.659    0.578
#> zmax          0.6925     0.4220   1.641    0.242
#> 
#> Residual standard error: 1.302 on 2 degrees of freedom
#> Multiple R-squared:  0.8212, Adjusted R-squared:  0.6424
#> F-statistic: 4.592 on 2 and 2 DF,  p-value: 0.1788
```

--------------------------------

### DAP/UAV Spatial Indexing: Grid vs Voxel Partition

Source: https://r-lidar.github.io/lidRbook/spatialindex

Demonstrates using grid partition and voxel partition indexes for DAP and UAV data, comparing computation times for `segment_shapes` with `shp_plane`. Shows comparable performance between the two partition types for this task.

```R
las <- readLAS("data/chap11/building_WilliamsAZ_Urban_normalized.laz")

index(las) <- "gridpartition"
system.time(segment_shapes(las, shp_plane(k = 20), "planar", filter = ~Classification != LASGROUND))
#> utilisateur     système      écoulé
#>       1.557       0.004       0.326

index(las) <- "voxelpartition"
system.time(segment_shapes(las, shp_plane(k = 20), "planar", filter = ~Classification != LASGROUND))
#> utilisateur     système      écoulé
#>       1.668       0.000       0.330
```

--------------------------------

### Compare Tree Segmentations: dalponte2016 vs li2012 (R)

Source: https://r-lidar.github.io/lidRbook/itd

Compares tree segmentation results from a raster-based method (dalponte2016) and a point cloud-based method (li2012) within the lidR package. It shows how to apply different algorithms to a point cloud and assign unique attributes for comparison.

```R
algo1 <- dalponte2016(chm_p2r_05_smoothed, ttops_chm_p2r_05_smoothed)
algo2 <- li2012()
las <- segment_trees(las, algo1, attribute = "IDdalponte")
las <- segment_trees(las, algo2, attribute = "IDli")

x <- plot(las, bg = "white", size = 4, color = "IDdalponte", colorPalette = pastel.colors(200))
plot(las, add = x + c(100,0), bg = "white", size = 4, color = "IDli", colorPalette = pastel.colors(200))
```

--------------------------------

### Multilevel B-Spline Approximation (MBA) DTM Generation

Source: https://r-lidar.github.io/lidRbook/dtm

Generates a Digital Terrain Model (DTM) using a Multilevel B-Spline Approximation (MBA) algorithm. This method is presented as an alternative spatial interpolation technique. The example demonstrates its integration with the `rasterize_terrain` function from the lidR package, leveraging the 'MBA' R package.

```R
dtm_mba <- rasterize_terrain(las, algorithm = mba())
plot_dtm3d(dtm_mba, bg = "white")
```

--------------------------------

### Visualize Intensity Distributions

Source: https://r-lidar.github.io/lidRbook/outbox

Generates density plots for intensity values, separated by scanner channel, to visualize the distribution of intensities across different spectral bands.

```R
library(ggplot2)
ggplot(las@data) +
  aes(x = Intensity, fill = as.factor(ScannerChannel)) +
  geom_density(alpha = 0.5) +
  theme_minimal() +
  theme(legend.position = c(.9, .90),
        legend.title = element_blank())
```

--------------------------------

### Print LAS Object Summary

Source: https://r-lidar.github.io/lidRbook/io

Prints a concise summary of the loaded `LAS` object, displaying key information such as the LAS version, memory usage, spatial extent, coordinate reference system, area, number of points, and density.

```R
print(las)
```

--------------------------------

### Create Collection of First Returns with catalog_retile

Source: https://r-lidar.github.io/lidRbook/engine

Shows how to use `catalog_retile()` with `opt_filter("-keep_first")` to generate a new collection containing only first returns. This is noted as less useful in `lidR` itself but potentially useful for other software.

```R
opt_chunk_buffer(ctg) <- 0
opt_chunk_size(ctg) <- 0
opt_output_files(ctg) <- paste0(tempdir(), "/{ORIGINALFILENAME}_first")
opt_filter(ctg) <- "-keep_first"
first <- catalog_retile(ctg)
```

--------------------------------

### Generate DTM using TIN Algorithm

Source: https://r-lidar.github.io/lidRbook/dtm

Generates a Digital Terrain Model (DTM) using the Triangular Irregular Network (TIN) algorithm. The `rasterize_terrain` function is used with the `tin()` method. The example highlights potential edge artifacts due to extrapolation outside the convex hull, suggesting the use of a buffer in real-world applications.

```R
dtm_tin <- rasterize_terrain(las, res = 1, algorithm = tin())
plot_dtm3d(dtm_tin, bg = "white")
```

--------------------------------

### RGB Raster Loading and Visualization

Source: https://r-lidar.github.io/lidRbook/engine2

Demonstrates loading an RGB raster file using the terra package and plotting it to visualize aerial imagery. This is often used in conjunction with LAS data for tasks like colorization.

```R
rgbmap <- terra::rast("data/ENGINE/catalog/rgb.tif")
terra::plotRGB(rgbmap)
```

--------------------------------

### TLS Spatial Indexing: Quadtree vs Octree

Source: https://r-lidar.github.io/lidRbook/spatialindex

Demonstrates registering a quadtree and octree index for TLS data and comparing computation times for `classify_noise` using `sor()`. Shows that octree is no longer supported, and quadtree is used for TLS processing.

```R
file <- system.file("extdata", "pine_plot.laz", package="TreeLS")
las <- readLAS(file, select='xyz')
#> Error: File does not exist.

index(las) <- "quadtree"
system.time(classify_noise(las, sor()))
#> utilisateur     système      écoulé
#>       2.387       0.000       0.506

index(las) <- "octree"
system.time(classify_noise(las, sor()))
#> Error in eval(expr, envir, enclos): Error: octree no longer supported.
#> Chronométrage arrêté à : 0.001 0 0.001
```

--------------------------------

### Performance Comparison: clip_circle vs clip_disc

Source: https://r-lidar.github.io/lidRbook/spatialindex

This R code compares the execution time of a sequential point filtering function (`clip_circle`) against a function using the spatial index (`clip_disc`). It demonstrates that for multiple queries, the spatial index approach offers significant performance improvements.

```R
n = 50
x = runif(n, 338000, 338500)
y = runif(n, 5238500, 5239000)

system.time(for (i in 1:n) u = clip_circle(las, x[i], y[i], 10))
#> utilisateur     système      écoulé
#>       1.550       0.063       1.216
system.time(for (i in 1:n) u = clip_disc(las, index, x[i], y[i], 10))
#> utilisateur     système      écoulé
#>       0.191       0.000       0.099
```

--------------------------------

### Read and Plot Multi-spectral LAS Data

Source: https://r-lidar.github.io/lidRbook/point_metrics

Demonstrates reading multiple LAS files, each representing a different spectral wavelength, into a single multi-spectral LAS object using `readMSLAS`. It then visualizes the point cloud, coloring points by their scanner channel.

```R
f1 <- "data/chap11/PR1107_c1_ar_c.laz"
f2 <- "data/chap11/PR1107_c2_ar_c.laz"
f3 <- "data/chap11/PR1107_c3_ar_c.laz"
las <- readMSLAS(f1, f2, f3,  filter = "-keep_z_below 300")
plot(las, color = "ScannerChannel", size = 5)
```
Tokens:
Raw