exactextractr

https://isciences.gitlab.io/exactextractr/
Admin
An R package that quickly and accurately summarizes raster values over polygonal areas (zonal...
Tokens:103,242
Snippets:1,017
Trust Score:7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Optional Configuration Selection Start

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Conditional compilation block for selecting the optional-lite configuration.

```c++
#if !defined( optional_CONFIG_SELECT_OPTIONAL )
```

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

### Enter Traversal

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes the entry point of a traversal with a coordinate and a side. Throws an error if the traversal has already been started.

```cpp
void Traversal::enter(const Coordinate &c, Side s) {
        if (!m_coords.empty()) {
            throw std::runtime_error("Traversal already started");
        }
        add(c);
        m_entry = s;
    }
```

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

### Optional-Lite Header Guard Start

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Defines the header guard for the optional-lite library.

```c++
#ifndef NONSTD_OPTIONAL_LITE_HPP
```

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

### Calculate Coverage Fraction Example

Source: https://isciences.gitlab.io/exactextractr/reference/coverage_fraction.html

Demonstrates how to use the `coverage_fraction` function with a raster layer and a simple polygon. The result is a raster layer showing the fractional coverage.

```R
rast <- raster::raster(matrix(1:100, ncol=10), xmn=0, ymn=0, xmx=10, ymx=10)
poly <- sf::st_as_sfc('POLYGON ((2 2, 7 6, 4 9, 2 2))')

cov_frac <- coverage_fraction(rast, poly)[[1]]
```

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

### Example Usage of coverage_fraction

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Demonstrates how to use the coverage_fraction function with a RasterLayer and an sf polygon object. The result is a list containing a RasterLayer of coverage fractions.

```r
rast <- raster::raster(matrix(1:100, ncol=10), xmn=0, ymn=0, xmx=10, ymx=10)
poly <- sf::st_as_sfc('POLYGON ((2 2, 7 6, 4 9, 2 2))')
cov_frac <- coverage_fraction(rast, poly)[[1]]
```

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

### Get Ring Grid from LineString and Geometry Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Derives a grid for a ring (linestring) by first getting the bounding box of the linestring and then applying the box grid logic.

```cpp
static Grid<infinite_extent> get_ring_grid(GEOSContextHandle_t context, const GEOSGeometry* ls, const Grid<infinite_extent> & geometry_grid) {
        return get_box_grid(geos_get_box(context, ls), geometry_grid);
    }
```

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

### Start Reading Raster Data

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initiates reading of the input raster 'x' and 'weights' if provided. This is a preliminary step before performing statistical calculations.

```R
x <- .startReading(x)
weights <- .startReading(weights)
```

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

### Get X Resolution

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the resolution in the x-direction (column spacing).

```c++
        double xres() const {
            return m_grid.dx();
        }
```

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

### Get Number of Columns

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the total number of columns in the grid. This includes any padding.

```cpp
size_t cols() const { return m_num_cols; }
```

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

### Flood Fill Algorithm Implementation

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Implements a flood fill algorithm starting from a given pixel. It uses a queue to manage locations to visit and updates the matrix with a specified fill value.

```cpp
template<typename T>
void flood_from_pixel(Matrix<T> &arr, size_t i, size_t j, T fill_value) {
    std::queue<std::pair<size_t, size_t> > locations;

    locations.emplace(i, j);

    while (!locations.empty()) {
        i = locations.front().first;
        j = locations.front().second;
        locations.pop();

        if (arr(i, j) == fill_value) {
            // ... (rest of the implementation would follow)
```

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

### Get Y Values for Grid Rows

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the y-values from a raster for a given grid's rows. It uses the grid.y_for_row function to get y-coordinates for each row.

```cpp
Rcpp::NumericVector y(grid.rows());
for (size_t i = 0; i < grid.rows(); i++) {
  y[i] = grid.y_for_row(i);
}
```

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

### Get Geometry Grid with GEOS Geometry

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates an infinite extent geometry grid from a raster grid and a GEOS geometry. Throws an exception for empty geometries.

```cpp
static Grid<infinite_extent> get_geometry_grid(const Grid<bounded_extent> &raster_grid, GEOSContextHandle_t context, const GEOSGeometry* g) {
        if (GEOSisEmpty_r(context, g)) {
            throw std::invalid_argument("Can't get statistics for empty geometry");
        }
        Box region = processing_region(raster_grid.extent(), geos_get_component_boxes(context, g));
        if (!region.empty()) {
            return make_infinite(raster_grid.shrink_to_fit(region));
        } else {
            return Grid<infinite_extent>::make_empty();
        }
    }
```

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

### Get Lower-Right Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the lower-right coordinate of the box.

```C++
Coordinate lower_right() const {
            return Coordinate{xmax, ymin};
        }
```

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

### Declare Prepare Method

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Declares a private method to prepare data for quantile queries.

```c++
        void prepare() const;
```

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

### Get Lower-Left Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the lower-left coordinate of the box.

```C++
Coordinate lower_left() const {
            return Coordinate{xmin, ymin};
        }
```

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

### Get Upper-Right Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the upper-right coordinate of the box.

```C++
Coordinate upper_right() const {
            return Coordinate{xmax, ymax};
        }
```

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

### Return True for Compatibility

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Indicates that the grids are compatible based on the preceding checks.

```cpp
return true;
```

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

### Get Upper-Left Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the upper-left coordinate of the box.

```C++
Coordinate upper_left() const {
            return Coordinate{xmin, ymax};
        }
```

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

### Initialize Weights Raster Source

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a raster source for weights using a unique pointer. This is done when weights are provided as a raster.

```cpp
rweights = std::make_unique<S4RasterSource>(weights_s4, default_weight);

```

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

### Get Y Resolution

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the resolution in the y-direction (row spacing).

```c++
        double yres() const {
            return m_grid.dy();
        }
```

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

### Include Grid and Matrix Headers

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Includes custom headers for Grid and Matrix functionalities.

```c++
#include "grid.h"
#include "matrix.h"
```

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

### Get Number of Columns

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the number of columns in the raster.

```c++
        size_t cols() const {
            return m_grid.cols();
        }
```

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

### Strategy Initialization with Terra

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes processing strategies, including 'check_block_size' and 'eager_load', if the 'terra' package is available. Otherwise, initializes with an empty vector.

```R
if (requireNamespace('terra', quietly = TRUE)) {
    strategies <- c('check_block_size', 'eager_load')
  } else {
    strategies = c()
  }
```

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

### Get Number of Rows

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the number of rows in the raster.

```c++
        size_t rows() const {
            return m_grid.rows();
        }
```

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

### Create Empty Weights Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes an empty grid for weights. This is used when weights are not explicitly provided but might be calculated.

```cpp
auto weights_grid = exactextract::Grid<bounded_extent>::make_empty();

```

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

### Get Number of Columns

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the number of columns in the matrix.

```cpp
size_t cols() const { return m_cols; }
```

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

### Get Number of Rows

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the number of rows in the matrix.

```cpp
size_t rows() const { return m_rows; }
```

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

### Using std::nullopt with optional

Source: https://isciences.gitlab.io/exactextractr/coverage.html

This snippet demonstrates the use of std::nullopt when std::optional is available.

```c++
    using std::nullopt;
```

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

### Create GEOSCoordSequence with Size and Dimensions

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a GEOSCoordSequence with a specified size and dimensions, returning a smart pointer.

```cpp
#include <memory>
#include <geos_c.h>

using seq_ptr_r = std::unique_ptr<GEOSCoordSequence, std::function<void(GEOSCoordSequence*)>>;

inline seq_ptr_r
    GEOSCoordSeq_create_ptr(GEOSContextHandle_t context, unsigned int size, unsigned int dims) {
    return geos_ptr(context, GEOSCoordSeq_create_r(context, size, dims));
}
```

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

### Include Standard Libraries

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Includes necessary standard C++ libraries for array, math, and limits.

```c++
#include <array>
#include <cmath>
#include <limits>
```

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

### Get Row Pointer

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns a pointer to the beginning of a specific row.

```cpp
T* row(size_t row) {
            return &(m_data[row*m_cols]);
        }
```

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

### Get Column Offset

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the column offset for a given geometry grid.

```cpp
size_t j0 = ring_grid.col_offset(m_geometry_grid);
```

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

### Raster Constructor with Box, Rows, and Columns

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs a Raster object with a specified Box, number of rows, and columns. Initializes the abstract raster with a grid derived from the box and dimensions, and creates an empty Matrix of the specified size.

```cpp
Raster(const Box & box, size_t nrow, size_t ncol) :
                AbstractRaster<T>(Grid<bounded_extent>(box, (box.xmax-box.xmin) / ncol, (box.ymax-box.ymin) / nrow)),
                m_values{nrow, ncol}
                {}
```

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

### Raster Iterator Begin Method

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns an iterator pointing to the beginning of the raster data (first row, first column).

```cpp
Iterator begin() const {
            return Iterator(this, 0, 0);
        }
```

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

### Get Row Offset

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the row offset for a given geometry grid.

```cpp
size_t i0 = ring_grid.row_offset(m_geometry_grid);
```

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

### Get Grid Reference

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns a constant reference to the underlying Grid object.

```c++
        const Grid<bounded_extent>& grid() const {
            return m_grid;
        }
```

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

### License Header - ExactExtract Raster Area (Alternative)

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Alternative Apache 2.0 license header for C++ source files, with different copyright year.

```cpp
// Copyright (c) 2018-2022 ISciences, LLC.
// All rights reserved.
//
// This software is licensed under the Apache License, Version 2.0 (the "License").
// You may not use this file except in compliance with the License. You may
// obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

```

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

### Get Maximum Y Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the maximum y-coordinate of the raster's extent.

```c++
        double ymax() const {
            return m_grid.ymax();
        }
```

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

### Project License Information

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Provides the Apache License, Version 2.0 details for the project, outlining usage rights and restrictions.

```text
# Copyright (c) 2022 ISciences, LLC.
# All rights reserved.
#
# This software is licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License. You may
# obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
```

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

### Get Minimum Y Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the minimum y-coordinate of the raster's extent.

```c++
        double ymin() const {
            return m_grid.ymin();
        }
```

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

### Get Geometry Grid with Box

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates an infinite extent geometry grid from a raster grid and a bounding box. Returns an empty grid if the box does not intersect the raster extent.

```cpp
static Grid<infinite_extent> get_geometry_grid(const Grid<bounded_extent> & raster_grid, const Box & box) {
        auto region = box.intersection(raster_grid.extent());
        if (!region.empty()) {
            return make_infinite(raster_grid.shrink_to_fit(region));
        } else {
            return Grid<infinite_extent>::make_empty();
        }
    }
```

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

### Optional Std Configuration

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Defines the standard configuration option for optional-lite.

```c++
#define optional_OPTIONAL_STD      2
```

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

### Get Maximum Y-coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the maximum y-coordinate of the grid's extent.

```cpp
double ymax() const { return m_extent.ymax; }
```

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

### Comment on Weighted Quantile Algorithm

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Provides a reference for the weighted quantile calculation algorithm.

```c++
        // Compute weighted quantiles based on https://stats.stackexchange.com/a/13223
```

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

### Get Minimum Y-coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the minimum y-coordinate of the grid's extent.

```cpp
double ymin() const { return m_extent.ymin; }
```

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

### ExactExtractr C++ Header Includes

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Includes necessary headers for Rcpp integration, memory management, GEOS library, and internal ExactExtractr utilities.

```cpp
// [[Rcpp::plugins("cpp14")]]
#include <Rcpp.h>
#include <memory>
#include "geos_r.h"
#include "raster_utils.h"
#include "s4_raster_source.h"
#include "exactextract/src/geos_utils.h"
#include "exactextract/src/grid.h"
#include "exactextract/src/matrix.h"
#include "exactextract/src/raster_cell_intersection.h"
#include "exactextract/src/raster_source.h"
#include "exactextract/src/raster_stats.h"
#include <vector>
#include <string>

```

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

### Get Maximum X-coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the maximum x-coordinate of the grid's extent.

```cpp
double xmax() const { return m_extent.xmax; }
```

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

### Get Minimum X-coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the minimum x-coordinate of the grid's extent.

```cpp
double xmin() const { return m_extent.xmin; }
```

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

### Stringify Macro Helper

Source: https://isciences.gitlab.io/exactextractr/coverage.html

A helper macro for stringifying preprocessor tokens.

```c++
#define optional_STRINGIFY(  x )  optional_STRINGIFY_( x )
```

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

### Initialize Raster Reading

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Prepares a raster object for reading. Supports both BasicRaster and SpatRaster objects.

```R
.startReading <- function(r) {
  if(inherits(r, 'BasicRaster')) {
    return(raster::readStart(r))
  } else if (inherits(r, 'SpatRaster')) {
    terra::readStart(r)
  }
  return(r)
}
```

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

### Get Maximum X Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the maximum x-coordinate of the raster's extent.

```c++
        double xmax() const {
            return m_grid.xmax();
        }
```

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

### Include CMath Header

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Includes the C++ standard math library.

```c++
#include <cmath>
```

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

### Create Grid from Extent and Resolution

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a Grid object using provided extent and resolution vectors.

```cpp
Grid make_grid(const Rcpp::NumericVector & extent,
        const Rcpp::NumericVector & res)
{
    return {{
        extent[0],
        extent[1],
        extent[2],
        extent[3]
    },
    res[0],
    res[1]
  };
}
```

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

### Get Minimum X Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the minimum x-coordinate of the raster's extent.

```c++
        double xmin() const {
            return m_grid.xmin();
        }
```

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

### Get Raw Data Pointer

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns a pointer to the underlying data array of the matrix.

```cpp
T* data() {
            return m_data.get();
        }
```

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

### Include Initializer List Header

Source: https://isciences.gitlab.io/exactextractr/coverage.html

This snippet shows how to include the <initializer_list> header. It is used in contexts where initializer lists are required.

```c++
#include <initializer_list>
```

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

### Get Grid Cell Height (dy)

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the height of a single grid cell.

```cpp
double dy() const { return m_dy; }
```

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

### Get Grid Cell Width (dx)

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the width of a single grid cell.

```cpp
double dx() const { return m_dx; }
```

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

### Default Constructor

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructor initializing the raster with a grid and default nodata values.

```c++
        explicit AbstractRaster(const Grid<bounded_extent> & ex) :
            m_grid{ex},
            m_nodata{std::is_floating_point<T>::value ? std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::min()},
            m_has_nodata{false}
            {}
```

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

### Mark Query as Not Ready

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Sets the flag indicating that the quantile query is not ready.

```c++
            m_ready_to_query = false;
```

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

### Get Number of Rows

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the total number of rows in the grid. This includes any padding.

```cpp
size_t rows() const { return m_num_rows; }
```

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

### Include Algorithm Header

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Includes the C++ standard algorithm library.

```c++
#include <algorithm>
```

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

### Initialize Raster Source with Weights

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes a S4RasterSource with specified weights and a default weight value. This is used when raster-based weighting is required.

```cpp
rweights = std::make_unique<S4RasterSource>(weights_s4, default_weight);
```

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

### Get Last Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the last coordinate added to the traversal. Assumes the traversal is not empty.

```cpp
const Coordinate &Traversal::last_coordinate() const {
        return m_coords.at(m_coords.size() - 1);
    }
```

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

### Get Y Values from Raster

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the y-coordinates of cells from a raster object for each cell in a given grid.

```cpp
Rcpp::NumericVector get_y_values(Rcpp::S4 & rast, exactextract::Grid<exactextract::bounded_extent> grid);
```

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

### Stringify Macro Implementation

Source: https://isciences.gitlab.io/exactextractr/coverage.html

The core macro that converts a preprocessor token into a string literal.

```c++
#define optional_STRINGIFY_( x )  #x
```

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

### Matrix Constructor with Zero Initialization

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs a Matrix with specified rows and columns, initializing all elements to zero. Use when a zero-initialized matrix is required.

```C++
Matrix(size_t rows, size_t cols) :
            m_rows{rows},
            m_cols{cols}
        {
            if (m_rows > 0 && m_cols > 0) {
                // new T[]() initializes to zero
                m_data = std::unique_ptr<T[]>(new T[m_rows * m_cols]());
            }
        }
```

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

### Getting Weight Raster Value

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the weight value from a weight raster for a given cell.

```cpp
if (wv.get(i, j, weight)) {
```

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

### Get Nodata Value

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the nodata value of the raster. Behavior is undefined if has_nodata() is false.

```c++
        T nodata() const { return m_nodata; }
```

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

### Raster Constructor with Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs a Raster object from an existing Grid. Initializes the abstract raster with the provided grid and creates an empty Matrix with dimensions matching the grid.

```cpp
explicit Raster(const Grid<bounded_extent> & ex) :
            AbstractRaster<T>(ex),
            m_values{ex.rows(), ex.cols()}
            {}
```

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

### Clang Diagnostic Pragma

Source: https://isciences.gitlab.io/exactextractr/coverage.html

This snippet shows the pragma to pop diagnostic settings for Clang compilers.

```c
# pragma clang diagnostic pop
```

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

### Get Total Number of Elements

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Calculates and returns the total number of elements (rows * columns).

```c++
        size_t size() const {
            return rows() * cols();
        }
```

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

### Get Y-coordinate for Row

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Calculates the y-coordinate corresponding to the center of a given row, accounting for padding.

```cpp
double y_for_row(size_t row) const { return m_extent.ymax - ((row - extent_tag::padding) + 0.5) * m_dy; }
```

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

### Create and Populate Result Matrix

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes a matrix with zeros to store the results and then populates it with computed statistics. It ensures that only relevant columns are updated based on the unique values present in the results for each geometry.

```R
result_mat <- matrix(0.0, nrow = length(geoms), ncol = nrow(result_cols))
for (i in seq_along(results)) {
  cols <- consistent_cols | result_cols$base_value %in% attr(results[[i]], 'unique_values')
  result_mat[i, cols] <- results[[i]]
}
colnames(result_mat) <- result_cols$colname
```

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

### Constructor with Nodata Value

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructor initializing the raster with a grid and a specified nodata value.

```c++
        AbstractRaster(const Grid<bounded_extent> & ex, const T& nodata_val) : m_grid{ex}, m_nodata{nodata_val}, m_has_nodata{true}  {}
```

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

### Get X-coordinate for Column

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Calculates the x-coordinate corresponding to the center of a given column, accounting for padding.

```cpp
double x_for_col(size_t col) const { return m_extent.xmin + ((col - extent_tag::padding) + 0.5) * m_dx; }
```

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

### Create a Raster Object

Source: https://isciences.gitlab.io/exactextractr/coverage.html

This snippet demonstrates how to create a basic raster object using the raster package, which can then be used with exactextractr.

```r
rast <- raster::raster(matrix(1:100, ncol=10), xmn=0, ymn=0, xmx=10, ymx=10)
```

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

### Get Exit Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the exit coordinate of the traversal. Throws an error if the traversal has not yet exited.

```cpp
const Coordinate &Traversal::exit_coordinate() const {
        if (!exited()) {
            throw std::runtime_error("Can't get exit coordinate from incomplete traversal.");
        }
        return last_coordinate();
    }
```

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

### Get Cell Numbers from Raster

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the cell numbers from a raster object for each cell in a given grid.

```cpp
Rcpp::NumericVector get_cell_numbers(Rcpp::S4 & rast, exactextract::Grid<exactextract::bounded_extent> grid);
```

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

### Matrix Constructor with Specific Value Initialization

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs a Matrix with specified rows, columns, and an initial value for all elements. Use when all elements need to be set to a particular value upon creation.

```C++
Matrix(size_t rows, size_t cols, T value) :
                m_rows{rows},
                m_cols{cols}
        {
            if (m_rows > 0 && m_cols > 0) {
                // new T[] does not initialize
                m_data = std::unique_ptr<T[]>(new T[m_rows * m_cols]);
            }
            std::fill(m_data.get(), m_data.get() + m_rows*m_cols, value);
        }
```

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

### Getting Raster Value

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the value from a raster at specified coordinates if coverage percentage is greater than zero.

```cpp
if (pct_cov > 0 && rv.get(i, j, val)) {
```

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

### Crop Grid to Box

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a new grid by cropping the current grid to a specified bounding box. Returns an empty grid if the box does not intersect.

```cpp
Grid<extent_tag> crop(const Box & b) const {
            if (extent().intersects(b)) {
                return shrink_to_fit(b.intersection(extent()));
            } else {
                return make_empty();
            }
        }
```

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

### Initialize Optional Value

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs an optional object with a given value. Asserts that the optional does not already have a value.

```cpp
void initialize( V && value )
    {
        assert( ! has_value()  );
        contained.construct_value( std::move( value ) );
        has_value_ = true;
    }
```

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

### Get Grid Size

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Calculates and returns the total number of cells in the grid by multiplying rows and columns.

```cpp
size_t size() const { return rows()*cols(); }
```

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

### Prepare Weighted Quantiles

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Sorts elements by their x-value and calculates cumulative weights. This is a prerequisite for quantile calculation.

```cpp
void WeightedQuantiles::prepare() const {
        std::sort(m_elems.begin(), m_elems.end(), [](const elem_t &a, const elem_t &b) {
            return a.x < b.x;
        });
        m_sum_w = 0;
        for (size_t i = 0; i < m_elems.size(); i++) {
            m_sum_w += m_elems[i].w;
            if (i == 0) {
                m_elems[i].s = 0;
                m_elems[i].cumsum = m_elems[i].w;
            } else {
                m_elems[i].cumsum = m_elems[i - 1].cumsum + m_elems[i].w;
            }
        }
    }
```

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

### Get Raster Resolution

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the resolution (x and y) of a raster object. Supports BasicRaster and SpatRaster types.

```R
.res <- function(r) {
  if (inherits(r, 'BasicRaster')) {
    raster::res(r)
  } else if (inherits(r, 'SpatRaster')) {
    terra::res(r)
  } else {
    stop('Unknown type: ', class(r))
  }
}
```

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

### Optional-Lite Version Macro

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Defines the full version string for optional-lite using stringification.

```c++
#define optional_lite_VERSION  optional_STRINGIFY(optional_lite_MAJOR) "." optional_STRINGIFY(optional_lite_MINOR) "." optional_STRINGIFY(optional_lite_PATCH)
```

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

### Get Row Index from Y Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Converts a y-coordinate to a row index, supporting both BasicRaster and SpatRaster objects.

```R
.rowFromY <- function(r, y) {
  if (inherits(r, 'BasicRaster')) {
    raster::rowFromY(r, y)
  } else if (inherits(r, 'SpatRaster')) {
    terra::rowFromY(r, y)
  } else {
    stop('Unknown type: ', class(r))
  }
}
```

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

### Instantiate and Validate Shrunk Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a new Grid object using the reduced box dimensions and then validates that the new grid's extents do not exceed the provided box extents. Throws an error if validation fails.

```C++
Grid<extent_tag> reduced{reduced_box, m_dx, m_dy};
if (b.xmin < reduced.xmin() || b.ymin < reduced.ymin() || b.xmax > reduced.xmax() || b.ymax > reduced.ymax()) {
    throw std::runtime_error("Shrink operation failed.");
}
return reduced;
```

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

### Get Y Coordinate from Row Index

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Converts a row index to a y-coordinate, handling both BasicRaster and SpatRaster objects.

```R
.yFromRow <- function(r, row) {
  if (inherits(r, 'BasicRaster')) {
    raster::yFromRow(r, row)
  } else if (inherits(r, 'SpatRaster')) {
    terra::yFromRow(r, row)
  } else {
    stop('Unknown type: ', class(r))
  }
}
```

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

### Get Number of Layers

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the number of layers in a raster object, supporting both BasicRaster and SpatRaster types.

```R
.numLayers <- function(r) {
  if(inherits(r, 'BasicRaster')) {
    return(raster::nlayers(r))
  } else if (inherits(r, 'SpatRaster')) {
    return(terra::nlyr(r))
  } else {
    stop('Unknown type: ', class(r))
  }
}
```

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

### Get Stat Value from RasterStats

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves a specific statistical value from the RasterStats object. This value is then assigned to the output.

```C++
values_out(row, col) = get_stat_value(stats, stat_name);
```

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

### Optional Default Configuration

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Defines the default configuration option for optional-lite.

```c++
#define optional_OPTIONAL_DEFAULT  0
```

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

### Matrix Constructor from Vector of Vectors

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs a Matrix from a 2D vector, initializing elements to zero and then populating them. Assumes the input vector is not empty and all inner vectors have the same size.

```C++
explicit Matrix(const std::vector<std::vector<T>> & data) :
            m_rows{data.size()},
            m_cols{data[0].size()}
        {
            m_data = std::unique_ptr<T[]>(new T[m_rows*m_cols]());
            auto lastpos = m_data.get();
            for (auto& row : data) {

```

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

### Get Last Traversal

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the last traversal from the list of traversals. Assumes at least one traversal exists.

```cpp
Traversal &Cell::last_traversal() {
        return m_traversals.at(m_traversals.size() - 1);
    }
```

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

### Make optional with initializer list (C++11)

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates an optional object using an initializer list and forwarded arguments. Requires C++11 or greater.

```cpp
#if optional_CPP11_OR_GREATER

template< typename T, typename U, typename... Args >
optional_constexpr optional<T> make_optional( std::initializer_list<U> il, Args&&... args )
{
    return optional<T>( nonstd_lite_in_place(T), il, std::forward<Args>(args)...);
}
#endif
```

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

### Get Last Traversal Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the last coordinate from the current traversal. Used to check if the traversal is at the boundary.

```cpp
const Coordinate &last = last_traversal().last_coordinate();
```

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

### Raster Constructor with Values and Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructs a Raster object using a Matrix of values and a Grid. Initializes the abstract raster with the provided grid and moves the values into the Raster.

```cpp
Raster(Matrix<T>&& values, const Grid<bounded_extent> & g) :
            AbstractRaster<T>(g),
            m_values{std::move(values)} {}
```

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

### Get Mutable Reference to Value

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns a mutable reference to the contained value. This allows modification of the contained value.

```cpp
value_type & value() optional_ref_qual
    {
        return * value_ptr();
    }
```

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

### Make optional with arguments (C++11)

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates an optional object by forwarding arguments to its constructor. Requires C++11 or greater.

```cpp
#if optional_CPP11_OR_GREATER

template< typename T, typename...Args >
optional_constexpr optional<T> make_optional( Args&&... args )
{
    return optional<T>( nonstd_lite_in_place(T), std::forward<Args>(args)...);
}
#endif
```

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

### Get Bounding Box of Geometry

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Calculates the bounding box for a given geometry object using the GEOS handle.

```cpp
auto bbox = exactextract::geos_get_box(geos.handle, geom.get());
```

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

### Optional-lite alignment configuration

Source: https://isciences.gitlab.io/exactextractr/coverage.html

This comment indicates a section for configuring alignment for optional-lite.

```c++
// optional-lite alignment configuration:
```

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

### Get Number of Layers from Raster

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the number of layers from a raster object. Essential for iterating through raster bands.

```cpp
int src_nlayers = get_nlayers(rast);

```

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

### FloodFill Constructor

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes the FloodFill class with a GEOS context, geometry, and grid extent. It prepares the geometry for spatial queries.

```cpp
#include <geos_c.h>
#include "grid.h"
#include "floodfill.h"
#include "geos_utils.h"

namespace exactextract {
    FloodFill::FloodFill(GEOSContextHandle_t context, const GEOSGeometry *g, const Grid<bounded_extent> &extent) :
            m_extent{extent},
            m_geos_context{context},
            m_g{nullptr},
            m_pg{nullptr} {
        geom_ptr_r ring_copy = geos_ptr(context, GEOSGeom_clone_r(context, g));
        m_g = geos_ptr(context, GEOSGeom_createPolygon_r(context, ring_copy.release(), nullptr, 0));
        m_pg = GEOSPrepare_ptr(context, m_g.get());
    }
}

```

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

### Get Grid Extent

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns a constant reference to the Box object representing the grid's spatial extent.

```cpp
const Box& extent() const { return m_extent; }
```

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

### Using std::swap with optional

Source: https://isciences.gitlab.io/exactextractr/coverage.html

This snippet illustrates the use of std::swap for optional values.

```c++
    using std::swap;
```

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

### Get Column Index from X Coordinate

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Converts an x-coordinate to a column index, supporting both BasicRaster and SpatRaster objects.

```R
.colFromX <- function(r, x) {
  if (inherits(r, 'BasicRaster')) {
    raster::colFromX(r, x)
  } else if (inherits(r, 'SpatRaster')) {
    terra::colFromX(r, x)
  } else {
    stop('Unknown type: ', class(r))
  }
}
```

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

### Get X Coordinate from Column Index

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Converts a column index to an x-coordinate, handling both BasicRaster and SpatRaster objects.

```R
.xFromCol <- function(r, col) {
  if (inherits(r, 'BasicRaster')) {
    raster::xFromCol(r, col)
  } else if (inherits(r, 'SpatRaster')) {
    terra::xFromCol(r, col)
  } else {
    stop('Unknown type: ', class(r))
  }
}
```

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

### Box Make Empty Method

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Static method to create an empty Box.

```cpp
static Box make_empty() {
```

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

### Optional vs. Nullopt Comparisons

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Defines comparison operators for checking equality and inequality between an optional value and nullopt.

```cpp
template< typename T >
inline optional_constexpr bool operator>( nullopt_t /*unused*/, optional<T> const & /*unused*/ ) optional_noexcept
{
    return false;
}
```

```cpp
template< typename T >
inline optional_constexpr bool operator>=( optional<T> const & /*unused*/, nullopt_t /*unused*/ ) optional_noexcept
{
    return true;
}
```

```cpp
template< typename T >
inline optional_constexpr bool operator>=( nullopt_t /*unused*/, optional<T> const & x ) optional_noexcept
{
    return (!x);
}
```

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

### Exit Traversal

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Records the exit point of a traversal with a coordinate and a side. This function assumes the traversal has already been started.

```cpp
void Traversal::exit(const Coordinate &c, Side s) {
        add(c);
        m_exit = s;
    }
```

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

### Load Raster and Plot

Source: https://isciences.gitlab.io/exactextractr/articles/vig1_population.html

Loads the EU-DEM elevation raster and plots it along with concelho boundaries. This sets up the spatial data for analysis.

```r
elev <- raster(system.file('sao_miguel/eu_dem_v11.tif', package = 'exactextractr'))

plot(elev, axes = FALSE, box = FALSE)
plot(st_geometry(concelhos), add = TRUE)
```

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

### Element Constructor

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Constructor for the elem_t structure, initializing value, weight, cumulative sum, and sort key.

```c++
            elem_t(double _x, double _w) : x(_x), w(_w), cumsum(0), s(0) {}
```

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

### Get Cell Area in C++

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Calculates and returns the area of the cell. Relies on the bounding box's area calculation.

```cpp
double Cell::area() const {
        return m_box.area();
    }
```

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

### Include C++17 utility header

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Includes the <utility> header for C++17 features, specifically for in-place construction.

```c++
#if optional_CPP17_OR_GREATER
#include <utility>
#endif
```

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

### Get Cell Width in C++

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the width of the cell. This is a simple getter for the cell's bounding box width.

```cpp
double Cell::width() const {
        return m_box.width();
    }
```

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

### Coordinate Constructor

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes a Coordinate object with specified x and y values.

```cpp
Coordinate(double p_x, double p_y) : x{p_x}, y{p_y} {}
```

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

### Get Cell Height in C++

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the height of the cell. This is a simple getter for the cell's bounding box height.

```cpp
double Cell::height() const {
        return m_box.height();
    }
```

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

### Initialize Progress Update

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Initializes a progress update function based on the provided progress indicator and the number of geometries to process.

```R
update_progress <- .createProgress(progress, length(geoms))
```

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

### Get Raster Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns the grid associated with the RasterSource. The grid defines the spatial extent and resolution of the raster data.

```C++
const exactextract::Grid<exactextract::bounded_extent> &grid() const {
    return m_grid;
  }
```

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

### Get Pointer to Value (Non-Const)

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Returns a non-const pointer to the contained value if it exists. This allows modification of the contained value.

```cpp
value_type * value_ptr()
    {
        return as<value_type>();
    }
```

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

### Create GEOSGeometry Pointer

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a GEOSGeometry pointer with a custom deleter for automatic destruction.

```cpp
#include <memory>
#include <functional>
#include <geos_c.h>

using geom_ptr_r = std::unique_ptr<GEOSGeometry, std::function<void(GEOSGeometry*)>>;

inline geom_ptr_r geos_ptr(GEOSContextHandle_t context, GEOSGeometry* geom) {
    auto deleter = [context](GEOSGeometry* g){ GEOSGeom_destroy_r(context, g); };
    return geom_ptr_r{geom, deleter};
}
```

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

### Transform Weights to Coverage Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Creates a RasterView for weights and converts them to a numeric vector aligned with the coverage grid. Necessary when weights and coverage grids differ.

```cpp
RasterView<double> rt (*r, cov_grid);
          weight_vec = as_vector(rt);
```

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

### Get Coverage Grid

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the grid object from the coverage fractions. This grid represents the spatial layout of the intersection results.

```cpp
auto& cov_grid = coverage_fractions.grid();

```

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

### Get Bounding Box from Geometry

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Extracts the bounding box of a geometry. This is useful for defining spatial extents and for clipping operations.

```cpp
auto bbox = exactextract::geos_get_box(geos.handle, geom.get());

```

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

### C++ RasterStats begin() and end() Methods

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Provides methods to obtain iterators for the beginning and end of the RasterStats frequency data. These are essential for range-based for loops and other iterator-based operations.

```cpp
Iterator begin() const {
            return Iterator(m_freq.cbegin());
        }
        Iterator end() const {
            return Iterator(m_freq.cend());
        }
```

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

### Get Weights Raster Number of Layers

Source: https://isciences.gitlab.io/exactextractr/coverage.html

Retrieves the number of layers from the weights raster. Used to determine the dimensionality of weights.

```cpp
int weights_nlayers = get_nlayers(weights_s4);

```
Tokens:
Raw