wbt_nim

    Dark Mode
Search:
Group by:

This library provides an application programming interface (API) into the WhiteboxTools library. WhiteboxTools is an advanced geospatial data analysis platform created by Prof. John Lindsay at the University of Guelph's Geomorphometry and Hydrogeomatics Research Group (GHRG). For more details, see the WhiteboxTools User Manual The WhiteboxTools executable must be copied into the same folder as this code.

import wbt_nim
import options, strformat, strutils

proc main() =
  # Create a new WhiteboxTools object
  var wbt = newWhiteboxTools()
  
  # Tell the wbt object where to find the WhiteboxTools executable.
  # If you don't do this, it assumes that it is in the same directory as
  # your Nim code.
  wbt.setExecutableDirectory("/Users/johnlindsay/Documents/programming/whitebox-tools/")
  
  # Set the working directory
  let wd = "/Users/johnlindsay/Documents/data/LakeErieLidar/"
  wbt.setWorkingDirectory(wd)
  
  # Set the verbose mode. By default it is 'true', which prints all output
  # from WBT. If you need to make it less chatty, set it to false.
  wbt.setVerboseMode(false)
  
  # By default, all GeoTiff outputs of tools will be compressed. You can
  # modify this with the following:
  wbt.setCompressRasters(false)
  
  # Print out the version of WBT:
  echo(wbt.getVersionInfo())
  
  # WhiteboxTools is open-access software. If you'd like to see the source
  # code for any tool, simply use the following:
  discard wbt.viewCode("balanceContrastEnhancement")
  
  # To get a brief description of a tool and it's parameters:
  echo(wbt.getToolHelp("breachDepressionsLeastCost"))
  
  # If you'd like to see more detailed help documentation:
  discard wbt.viewHelpPage("breachDepressionsLeastCost")
  # This will open the default browser and navigate to the relevant tool help.
  
  # Here's an example of how to run a tool:
  if wbt.hillshade(
      dem="90m_DEM.tif",
      output="tmp1.tif",
      azimuth=180.0,
      altitude=45.0,
      zFactor=1.0
  ) != 0:
      echo("Error while running hillshade.")
  
  # If you haven't previously set the working directory, you need to include
  # full file path names.

Procs

proc newWhiteboxTools(): WhiteboxTools {...}{.raises: [OSError], tags: [ReadIOEffect].}
Creates a new WhiteboxTools object to interface with the WhiteboxTools library. The working directory is initially set to the current directory. The WhiteboxTools executable is assumed to be within the same directory as this application.
proc setWorkingDirectory(self: var WhiteboxTools; wd: string) {...}{.raises: [], tags: [].}
Sets the working directory, i.e. the directory in which the data files are located. By setting the working directory, tool input parameters that are files need only specify the file name rather than the complete file path.
proc getWorkingDirectory(self: WhiteboxTools): string {...}{.raises: [], tags: [].}
Returns the current working directory.
proc setExecutableDirectory(self: var WhiteboxTools; dir: string) {...}{.raises: [], tags: [].}
Sets the directory to the WhiteboxTools executable file.
proc getExecutableDirectory(self: WhiteboxTools): string {...}{.raises: [], tags: [].}
Returns the directory to the WhiteboxTools executable file.
proc setVerboseMode(self: var WhiteboxTools; val: bool) {...}{.raises: [], tags: [].}
Sets verbose mode. If verbose mode is false, tools will not print output messages. Tools will frequently provide substantial feedback while they are operating, e.g. updating progress for various sub-routines. When the user has scripted a workflow that ties many tools in sequence, this level of tool output can be problematic. By setting verbose mode to false, these messages are suppressed and tools run as background processes.
proc getVerboseMode(self: WhiteboxTools): bool {...}{.raises: [], tags: [].}
Returns the current verbose mode.
proc setCallback(self: var WhiteboxTools; callback: proc (line: string)) {...}{.raises: [],
    tags: [].}
Sets the callback used for handling tool text outputs.
proc setDefaultCallback(self: var WhiteboxTools) {...}{.raises: [], tags: [].}
Sets the callback used for handling tool text outputs to the default, which simply prints any tool output to stdout.
proc setCompressRasters(self: var WhiteboxTools; val: bool) {...}{.raises: [], tags: [].}
Sets the flag used by WhiteboxTools to determine whether to use compression for output rasters. This is only valid for GeoTIFF tool outputs.
proc getCompressRasters(self: WhiteboxTools): bool {...}{.raises: [], tags: [].}
Returns the current compress raster flag value.
proc setCancelOp(self: var WhiteboxTools; val: bool) {...}{.raises: [], tags: [].}
Sets the cancel flag.
proc getCancelOp(self: WhiteboxTools): bool {...}{.raises: [], tags: [].}
Returns the current cancel flag value.
proc getLicense(self: WhiteboxTools): string {...}{.
    raises: [Exception, Defect, IOError, OSError, ValueError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Retrieves the license information for WhiteboxTools.
proc getVersionInfo(self: WhiteboxTools): string {...}{.
    raises: [Exception, Defect, IOError, OSError, ValueError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Retrieves the version information for WhiteboxTools.
proc help(self: WhiteboxTools): string {...}{.raises: [Exception, Defect, IOError, OSError,
    ValueError], tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Retrieves the help description for WhiteboxTools.
proc listTools(self: WhiteboxTools): string {...}{.
    raises: [Exception, Defect, IOError, OSError, ValueError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Returns a listing of each available tool and a brief tool description for each entry.
proc getToolHelp(self: WhiteboxTools; toolName: string): string {...}{.
    raises: [Exception, Defect, IOError, OSError, ValueError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Retrieves the help description for a specific tool.
proc getToolParameters(self: WhiteboxTools; toolName: string): string {...}{.
    raises: [Exception, Defect, IOError, OSError, ValueError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Retrieves the tool parameter descriptions for a specific tool.
proc getToolbox(self: WhiteboxTools; toolName: string): string {...}{.
    raises: [Exception, Defect, IOError, OSError, ValueError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Retrieves the tool parameter descriptions for a specific tool.
proc viewCode(self: WhiteboxTools; toolName: string): string {...}{.
    raises: [ValueError, Exception, Defect, IOError, OSError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Returns and navigates to the URL of the source code for a specific tool on the projects source code repository.
proc viewHelpPage(self: WhiteboxTools; toolName: string): string {...}{.
    raises: [ValueError, Exception, Defect, IOError, OSError],
    tags: [ExecIOEffect, ReadIOEffect, RootEffect].}
Returns and navigates to the URL of the help within the user manual for a specific tool on the projects source code repository.
proc absoluteValue(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the absolute value of every cell in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc adaptiveFilter(self: var WhiteboxTools; input: string; output: string;
                   filterx: int = 11; filtery: int = 11; threshold: float = 2.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an adaptive filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • threshold: Difference from mean threshold, in standard deviations.
proc add(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an addition operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc addPointCoordinatesToTable(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Modifies the attribute table of a point vector by adding fields containing each point's X and Y coordinates. See here for more details.

Keyword arguments:

  • input: Input vector Points file.
proc aggregateRaster(self: var WhiteboxTools; input: string; output: string;
                    agg_factor: int = 2; type_val: string = "mean"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Aggregates a raster to a lower resolution. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • agg_factor: Aggregation factor, in pixels.
  • type_val: Statistic used to fill output pixels.
proc And(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a logical AND operator on two Boolean raster images. See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file.
  • output: Output raster file.
proc anova(self: var WhiteboxTools; input: string; features: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an analysis of variance (ANOVA) test on a raster dataset. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • features: Feature definition (or class) raster.
  • output: Output HTML file.
proc arcCos(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the inverse cosine (arccos) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc arcSin(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the inverse sine (arcsin) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc arcTan(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the inverse tangent (arctan) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc arcosh(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the inverse hyperbolic cosine (arcosh) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc arsinh(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the inverse hyperbolic sine (arsinh) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc artanh(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the inverse hyperbolic tangent (arctanh) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc asciiToLas(self: var WhiteboxTools; inputs: string; pattern: string;
               proj: string = ""): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Converts one or more ASCII files containing LiDAR points into LAS files. See here for more details.

Keyword arguments:

  • inputs: Input LiDAR ASCII files (.csv).
  • pattern: Input field pattern.
  • proj: Well-known-text string or EPSG code describing projection.
proc aspect(self: var WhiteboxTools; dem: string; output: string; zfactor: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates an aspect raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc atan2(self: var WhiteboxTools; input_y: string; input_x: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the 2-argument inverse tangent (atan2). See here for more details.

Keyword arguments:

  • input_y: Input y raster file or constant value (rise).
  • input_x: Input x raster file or constant value (run).
  • output: Output raster file.
proc attributeCorrelation(self: var WhiteboxTools; input: string; output: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a correlation analysis on attribute fields from a vector database. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc attributeCorrelationNeighbourhoodAnalysis(self: var WhiteboxTools;
    input: string; field1: string; field2: string; radius = none(float);
    min_points = none(int); stat: string = "pearson"): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a correlation on two input vector attributes within a neighbourhood search windows. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • field1: First input field name (dependent variable) in attribute table.
  • field2: Second input field name (independent variable) in attribute table.
  • radius: Search Radius (in map units).
  • min_points: Minimum number of points.
  • stat: Correlation type; one of 'pearson' (default) and 'spearman'.
proc attributeHistogram(self: var WhiteboxTools; input: string; field: string;
                       output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a histogram for the field values of a vector's attribute table. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • field: Input field name in attribute table.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc attributeScattergram(self: var WhiteboxTools; input: string; fieldx: string;
                         fieldy: string; output: string; trendline: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a scattergram for two field values of a vector's attribute table. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • fieldx: Input field name in attribute table for the x-axis.
  • fieldy: Input field name in attribute table for the y-axis.
  • output: Output HTML file (default name will be based on input file if unspecified).
  • trendline: Draw the trendline.
proc averageFlowpathSlope(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Measures the average slope gradient from each grid cell to all upslope divide cells. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc averageNormalVectorAngularDeviation(self: var WhiteboxTools; dem: string;
                                        output: string; filter: int = 11): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the circular variance of aspect at a scale for a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filter: Size of the filter kernel.
proc averageOverlay(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the average for each grid cell from a group of raster images. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc averageUpslopeFlowpathLength(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Measures the average length of all upslope flowpaths draining each grid cell. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc balanceContrastEnhancement(self: var WhiteboxTools; input: string;
                               output: string; band_mean: float = 100.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a balance contrast enhancement on a colour-composite image of multispectral data. See here for more details.

Keyword arguments:

  • input: Input colour composite image file.
  • output: Output raster file.
  • band_mean: Band mean value.
proc basins(self: var WhiteboxTools; d8_pntr: string; output: string;
           esri_pntr: bool = false): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Identifies drainage basins that drain to the DEM edge. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc bilateralFilter(self: var WhiteboxTools; input: string; output: string;
                    sigma_dist: float = 0.75; sigma_int: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

A bilateral filter is an edge-preserving smoothing filter introduced by Tomasi and Manduchi (1998). See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • sigma_dist: Standard deviation in distance in pixels.
  • sigma_int: Standard deviation in intensity in pixels.
proc blockMaximumGridding(self: var WhiteboxTools; input: string; field: string;
                         use_z: bool = false; output: string; cell_size = none(float);
                         base: string = ""): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a raster grid based on a set of vector points and assigns grid values using a block maximum scheme. See here for more details.

Keyword arguments:

  • input: Input vector Points file.
  • field: Input field name in attribute table.
  • use_z: Use z-coordinate instead of field?
  • output: Output raster file.
  • cell_size: Optionally specified cell size of output raster. Not used when base raster is specified.
  • base: Optionally specified input base raster file. Not used when a cell size is specified.
proc blockMinimumGridding(self: var WhiteboxTools; input: string; field: string;
                         use_z: bool = false; output: string; cell_size = none(float);
                         base: string = ""): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a raster grid based on a set of vector points and assigns grid values using a block minimum scheme. See here for more details.

Keyword arguments:

  • input: Input vector Points file.
  • field: Input field name in attribute table.
  • use_z: Use z-coordinate instead of field?
  • output: Output raster file.
  • cell_size: Optionally specified cell size of output raster. Not used when base raster is specified.
  • base: Optionally specified input base raster file. Not used when a cell size is specified.
proc boundaryShapeComplexity(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the complexity of the boundaries of raster polygons. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc breachDepressions(self: var WhiteboxTools; dem: string; output: string;
                      max_depth = none(float); max_length = none(float);
                      flat_increment = none(float); fill_pits: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Breaches all of the depressions in a DEM using Lindsay's (2016) algorithm. This should be preferred over depression filling in most cases. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • max_depth: Optional maximum breach depth (default is Inf).
  • max_length: Optional maximum breach channel length (in grid cells; default is Inf).
  • flat_increment: Optional elevation increment applied to flat areas.
  • fill_pits: Optional flag indicating whether to fill single-cell pits.
proc breachDepressionsLeastCost(self: var WhiteboxTools; dem: string; output: string;
                               dist: int; max_cost = none(float);
                               min_dist: bool = true; flat_increment = none(float);
                               fill: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Breaches the depressions in a DEM using a least-cost pathway method. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • dist: Maximum search distance for breach paths in cells.
  • max_cost: Optional maximum breach cost (default is Inf).
  • min_dist: Optional flag indicating whether to minimize breach distances.
  • flat_increment: Optional elevation increment applied to flat areas.
  • fill: Optional flag indicating whether to fill any remaining unbreached depressions.
proc breachSingleCellPits(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Removes single-cell pits from an input DEM by breaching. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc bufferRaster(self: var WhiteboxTools; input: string; output: string; size: float;
                 gridcells = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Maps a distance-based buffer around each non-background (non-zero/non-nodata) grid cell in an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • size: Buffer size.
  • gridcells: Optional flag to indicate that the 'size' threshold should be measured in grid cells instead of the default map units.
proc burnStreamsAtRoads(self: var WhiteboxTools; dem: string; streams: string;
                       roads: string; output: string; width = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Burns-in streams at the sites of road embankments. See here for more details.

Keyword arguments:

  • dem: Input raster digital elevation model (DEM) file.
  • streams: Input vector streams file.
  • roads: Input vector roads file.
  • output: Output raster file.
  • width: Maximum road embankment width, in map units
proc ceil(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the smallest (closest to negative infinity) value that is greater than or equal to the values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc centroid(self: var WhiteboxTools; input: string; output: string; text_output: bool): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the centroid, or average location, of raster polygon objects. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • text_output: Optional text output.
proc centroidVector(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifes the centroid point of a vector polyline or polygon feature or a group of vector points. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector file.
proc changeVectorAnalysis(self: var WhiteboxTools; date1: string; date2: string;
                         magnitude: string; direction: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a change vector analysis on a two-date multi-spectral dataset. See here for more details.

Keyword arguments:

  • date1: Input raster files for the earlier date.
  • date2: Input raster files for the later date.
  • magnitude: Output vector magnitude raster file.
  • direction: Output vector Direction raster file.
proc circularVarianceOfAspect(self: var WhiteboxTools; dem: string; output: string;
                             filter: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the circular variance of aspect at a scale for a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filter: Size of the filter kernel.
proc classifyBuildingsInLidar(self: var WhiteboxTools; input: string;
                             buildings: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Reclassifies a LiDAR points that lie within vector building footprints. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • buildings: Input vector polygons file.
  • output: Output LiDAR file.
proc classifyOverlapPoints(self: var WhiteboxTools; input: string; output: string;
                          resolution: float = 2.0; filter: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Classifies or filters LAS points in regions of overlapping flight lines. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • resolution: The size of the square area used to evaluate nearby points in the LiDAR data.
  • filter: Filter out points from overlapping flightlines? If false, overlaps will simply be classified.
proc cleanVector(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Removes null features and lines/polygons with fewer than the required number of vertices. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector file.
proc clip(self: var WhiteboxTools; input: string; clip: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Extract all the features, or parts of features, that overlap with the features of the clip vector. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • clip: Input clip polygon vector file.
  • output: Output vector file.
proc clipLidarToPolygon(self: var WhiteboxTools; input: string; polygons: string;
                       output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Clips a LiDAR point cloud to a vector polygon or polygons. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • polygons: Input vector polygons file.
  • output: Output LiDAR file.
proc clipRasterToPolygon(self: var WhiteboxTools; input: string; polygons: string;
                        output: string; maintain_dimensions: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Clips a raster to a vector polygon. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • polygons: Input vector polygons file.
  • output: Output raster file.
  • maintain_dimensions: Maintain input raster dimensions?
proc closing(self: var WhiteboxTools; input: string; output: string; filterx: int = 11;
            filtery: int = 11): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

A closing is a mathematical morphology operation involving an erosion (min filter) of a dilation (max filter) set. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc clump(self: var WhiteboxTools; input: string; output: string; diag: bool = true;
          zero_back: bool): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Groups cells that form discrete areas, assigning them unique identifiers. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • diag: Flag indicating whether diagonal connections should be considered.
  • zero_back: Flag indicating whether zero values should be treated as a background.
proc compactnessRatio(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the compactness ratio (A/P), a measure of shape complexity, for vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc conservativeSmoothingFilter(self: var WhiteboxTools; input: string;
                                output: string; filterx: int = 3; filtery: int = 3): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a conservative-smoothing filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc constructVectorTIN(self: var WhiteboxTools; input: string; field: string = "";
                       use_z: bool = false; output: string;
                       max_triangle_edge_length = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a vector triangular irregular network (TIN) for a set of vector points. See here for more details.

Keyword arguments:

  • input: Input vector points file.
  • field: Input field name in attribute table.
  • use_z: Use the 'z' dimension of the Shapefile's geometry instead of an attribute field?
  • output: Output vector polygon file.
  • max_triangle_edge_length: Optional maximum triangle edge length; triangles larger than this size will not be gridded.
proc contoursFromPoints(self: var WhiteboxTools; input: string; field: string = "";
                       use_z: bool = false; output: string;
                       max_triangle_edge_length = none(float);
                       interval: float = 10.0; base: float = 0.0; smooth: int = 5): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a contour coverage from a set of input points. See here for more details.

Keyword arguments:

  • input: Input vector points file.
  • field: Input field name in attribute table.
  • use_z: Use the 'z' dimension of the Shapefile's geometry instead of an attribute field?
  • output: Output vector lines file.
  • max_triangle_edge_length: Optional maximum triangle edge length; triangles larger than this size will not be gridded.
  • interval: Contour interval.
  • base: Base contour height.
  • smooth: Smoothing filter size (in num. points), e.g. 3, 5, 7, 9, 11...
proc contoursFromRaster(self: var WhiteboxTools; input: string; output: string;
                       interval: float = 10.0; base: float = 0.0; smooth: int = 9;
                       tolerance: float = 10.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Derives a vector contour coverage from a raster surface. See here for more details.

Keyword arguments:

  • input: Input surface raster file.
  • output: Output vector contour file.
  • interval: Contour interval.
  • base: Base contour height.
  • smooth: Smoothing filter size (in num. points), e.g. 3, 5, 7, 9, 11...
  • tolerance: Tolerance factor, in degrees (0-45); determines generalization level.
proc convertNodataToZero(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts nodata values in a raster to zero. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc convertRasterFormat(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts raster data from one format to another. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc cornerDetection(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies corner patterns in boolean images using hit-and-miss pattern matching. See here for more details.

Keyword arguments:

  • input: Input boolean image.
  • output: Output raster file.
proc correctVignetting(self: var WhiteboxTools; input: string; pp: string;
                      output: string; focal_length: float = 304.8;
                      image_width: float = 228.6; n: float = 4.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Corrects the darkening of images towards corners. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • pp: Input principal point file.
  • output: Output raster file.
  • focal_length: Camera focal length, in millimeters.
  • image_width: Distance between photograph edges, in millimeters.
  • n: The 'n' parameter.
proc cos(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the cosine (cos) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc cosh(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the hyperbolic cosine (cosh) of each values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc costAllocation(self: var WhiteboxTools; source: string; backlink: string;
                   output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Identifies the source cell to which each grid cell is connected by a least-cost pathway in a cost-distance analysis. See here for more details.

Keyword arguments:

  • source: Input source raster file.
  • backlink: Input backlink raster file generated by the cost-distance tool.
  • output: Output raster file.
proc costDistance(self: var WhiteboxTools; source: string; cost: string;
                 out_accum: string; out_backlink: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs cost-distance accumulation on a cost surface and a group of source cells. See here for more details.

Keyword arguments:

  • source: Input source raster file.
  • cost: Input cost (friction) raster file.
  • out_accum: Output cost accumulation raster file.
  • out_backlink: Output backlink raster file.
proc costPathway(self: var WhiteboxTools; destination: string; backlink: string;
                output: string; zero_background: bool): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs cost-distance pathway analysis using a series of destination grid cells. See here for more details.

Keyword arguments:

  • destination: Input destination raster file.
  • backlink: Input backlink raster file generated by the cost-distance tool.
  • output: Output cost pathway raster file.
  • zero_background: Flag indicating whether zero values should be treated as a background.
proc countIf(self: var WhiteboxTools; inputs: string; output: string; value: float): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Counts the number of occurrences of a specified value in a cell-stack of rasters. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
  • value: Search value (e.g. countif value = 5.0).
proc createColourComposite(self: var WhiteboxTools; red: string; green: string;
                          blue: string; opacity: string = ""; output: string;
                          enhance: bool = true; zeros: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a colour-composite image from three bands of multispectral imagery. See here for more details.

Keyword arguments:

  • red: Input red band image file.
  • green: Input green band image file.
  • blue: Input blue band image file.
  • opacity: Input opacity band image file (optional).
  • output: Output colour composite file.
  • enhance: Optional flag indicating whether a balance contrast enhancement is performed.
  • zeros: Optional flag to indicate if zeros are nodata values.
proc createHexagonalVectorGrid(self: var WhiteboxTools; input: string; output: string;
                              width: float; orientation: string = "horizontal"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a hexagonal vector grid. See here for more details.

Keyword arguments:

  • input: Input base file.
  • output: Output vector polygon file.
  • width: The grid cell width.
  • orientation: Grid Orientation, 'horizontal' or 'vertical'.
proc createPlane(self: var WhiteboxTools; base: string; output: string;
                gradient: float = 15.0; aspect: float = 90.0; constant: float = 0.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a raster image based on the equation for a simple plane. See here for more details.

Keyword arguments:

  • base: Input base raster file.
  • output: Output raster file.
  • gradient: Slope gradient in degrees (-85.0 to 85.0).
  • aspect: Aspect (direction) in degrees clockwise from north (0.0-360.0).
  • constant: Constant value.
proc createRectangularVectorGrid(self: var WhiteboxTools; input: string;
                                output: string; width: float; height: float;
                                xorig: float = 0; yorig: float = 0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a rectangular vector grid. See here for more details.

Keyword arguments:

  • input: Input base file.
  • output: Output vector polygon file.
  • width: The grid cell width.
  • height: The grid cell height.
  • xorig: The grid origin x-coordinate.
  • yorig: The grid origin y-coordinate.
proc crispnessIndex(self: var WhiteboxTools; input: string; output: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the Crispness Index, which is used to quantify how crisp (or conversely how fuzzy) a probability image is. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Optional output html file (default name will be based on input file if unspecified).
proc crossTabulation(self: var WhiteboxTools; input1: string; input2: string;
                    output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a cross-tabulation on two categorical images. See here for more details.

Keyword arguments:

  • input1: Input raster file 1.
  • input2: Input raster file 1.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc csvPointsToVector(self: var WhiteboxTools; input: string; output: string;
                      xfield: int = 0; yfield: int = 1; epsg = none(int)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts a CSV text file to vector points. See here for more details.

Keyword arguments:

  • input: Input CSV file (i.e. source of data to be imported).
  • output: Output vector file.
  • xfield: X field number (e.g. 0 for first field).
  • yfield: Y field number (e.g. 1 for second field).
  • epsg: EPSG projection (e.g. 2958).
proc cumulativeDistribution(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts a raster image to its cumulative distribution function. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc d8FlowAccumulation(self: var WhiteboxTools; input: string; output: string;
                       out_type: string = "cells"; log = none(bool); clip = none(bool);
                       pntr = none(bool); esri_pntr: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates a D8 flow accumulation raster from an input DEM or flow pointer. See here for more details.

Keyword arguments:

  • input: Input raster DEM or D8 pointer file.
  • output: Output raster file.
  • out_type: Output type; one of 'cells' (default), 'catchment area', and 'specific contributing area'.
  • log: Optional flag to request the output be log-transformed.
  • clip: Optional flag to request clipping the display max by 1%.
  • pntr: Is the input raster a D8 flow pointer rather than a DEM?
  • esri_pntr: Input D8 pointer uses the ESRI style scheme.
proc d8MassFlux(self: var WhiteboxTools; dem: string; loading: string;
               efficiency: string; absorption: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a D8 mass flux calculation. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • loading: Input loading raster file.
  • efficiency: Input efficiency raster file.
  • absorption: Input absorption raster file.
  • output: Output raster file.
proc d8Pointer(self: var WhiteboxTools; dem: string; output: string;
              esri_pntr: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates a D8 flow pointer raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc dInfFlowAccumulation(self: var WhiteboxTools; input: string; output: string;
                         out_type: string = "Specific Contributing Area";
                         threshold = none(float); log = none(bool); clip = none(bool);
                         pntr = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates a D-infinity flow accumulation raster from an input DEM. See here for more details.

Keyword arguments:

  • input: Input raster DEM or D-infinity pointer file.
  • output: Output raster file.
  • out_type: Output type; one of 'cells', 'sca' (default), and 'ca'.
  • threshold: Optional convergence threshold parameter, in grid cells; default is inifinity.
  • log: Optional flag to request the output be log-transformed.
  • clip: Optional flag to request clipping the display max by 1%.
  • pntr: Is the input raster a D-infinity flow pointer rather than a DEM?
proc dInfMassFlux(self: var WhiteboxTools; dem: string; loading: string;
                 efficiency: string; absorption: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a D-infinity mass flux calculation. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • loading: Input loading raster file.
  • efficiency: Input efficiency raster file.
  • absorption: Input absorption raster file.
  • output: Output raster file.
proc dInfPointer(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates a D-infinity flow pointer (flow direction) raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc decrement(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Decreases the values of each grid cell in an input raster by 1.0 (see also InPlaceSubtract). See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc depthInSink(self: var WhiteboxTools; dem: string; output: string;
                zero_background = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Measures the depth of sinks (depressions) in a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • zero_background: Flag indicating whether the background value of zero should be used.
proc devFromMeanElev(self: var WhiteboxTools; dem: string; output: string;
                    filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates deviation from mean elevation. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc diffFromMeanElev(self: var WhiteboxTools; dem: string; output: string;
                     filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates difference from mean elevation (equivalent to a high-pass filter). See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc diffOfGaussianFilter(self: var WhiteboxTools; input: string; output: string;
                         sigma1: float = 2.0; sigma2: float = 4.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a Difference of Gaussian (DoG) filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • sigma1: Standard deviation distance in pixels.
  • sigma2: Standard deviation distance in pixels.
proc difference(self: var WhiteboxTools; input: string; overlay: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Outputs the features that occur in one of the two vector inputs but not both, i.e. no overlapping features. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • overlay: Input overlay vector file.
  • output: Output vector file.
proc directDecorrelationStretch(self: var WhiteboxTools; input: string;
                               output: string; k: float = 0.5; clip: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a direct decorrelation stretch enhancement on a colour-composite image of multispectral data. See here for more details.

Keyword arguments:

  • input: Input colour composite image file.
  • output: Output raster file.
  • k: Achromatic factor (k) ranges between 0 (no effect) and 1 (full saturation stretch), although typical values range from 0.3 to 0.7.
  • clip: Optional percent to clip the upper tail by during the stretch.
proc directionalRelief(self: var WhiteboxTools; dem: string; output: string;
                      azimuth: float = 0.0; max_dist = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates relief for cells in an input DEM for a specified direction. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • azimuth: Wind azimuth in degrees.
  • max_dist: Optional maximum search distance (unspecified if none; in xy units).
proc dissolve(self: var WhiteboxTools; input: string; field: string = ""; output: string;
             snap: float = 0.0): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Removes the interior, or shared, boundaries within a vector polygon coverage. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • field: Dissolve field attribute (optional).
  • output: Output vector file.
  • snap: Snap tolerance.
proc distanceToOutlet(self: var WhiteboxTools; d8_pntr: string; streams: string;
                     output: string; esri_pntr: bool = false;
                     zero_background = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the distance of stream grid cells to the channel network outlet cell. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc diversityFilter(self: var WhiteboxTools; input: string; output: string;
                    filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns each cell in the output grid the number of different values in a moving window centred on each grid cell in the input raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc divide(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a division operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc downslopeDistanceToStream(self: var WhiteboxTools; dem: string; streams: string;
                              output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Measures distance to the nearest downslope stream cell. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • streams: Input raster streams file.
  • output: Output raster file.
proc downslopeFlowpathLength(self: var WhiteboxTools; d8_pntr: string;
                            watersheds: string = ""; weights: string = "";
                            output: string; esri_pntr: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the downslope flowpath length from each cell to basin outlet. See here for more details.

Keyword arguments:

  • d8_pntr: Input D8 pointer raster file.
  • watersheds: Optional input watershed raster file.
  • weights: Optional input weights raster file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc downslopeIndex(self: var WhiteboxTools; dem: string; output: string;
                   drop: float = 2.0; out_type: string = "tangent"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the Hjerdt et al. (2004) downslope index. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • drop: Vertical drop value (default is 2.0).
  • out_type: Output type, options include 'tangent', 'degrees', 'radians', 'distance' (default is 'tangent').
proc edgeDensity(self: var WhiteboxTools; dem: string; output: string; filter: int = 11;
                norm_diff: float = 5.0; zfactor: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the density of edges, or breaks-in-slope within DEMs. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filter: Size of the filter kernel.
  • norm_diff: Maximum difference in normal vectors, in degrees.
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc edgePreservingMeanFilter(self: var WhiteboxTools; input: string; output: string;
                             filter: int = 11; threshold: float): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a simple edge-preserving mean filter on an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filter: Size of the filter kernel.
  • threshold: Maximum difference in values.
proc edgeProportion(self: var WhiteboxTools; input: string; output: string;
                   output_text = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculate the proportion of cells in a raster polygon that are edge cells. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • output_text: flag indicating whether a text report should also be output.
proc elevAbovePit(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculate the elevation of each grid cell above the nearest downstream pit cell or grid edge cell. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc elevPercentile(self: var WhiteboxTools; dem: string; output: string;
                   filterx: int = 11; filtery: int = 11; sig_digits: int = 2): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the elevation percentile raster from a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • sig_digits: Number of significant digits.
proc elevRelativeToMinMax(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the elevation of a location relative to the minimum and maximum elevations in a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc elevRelativeToWatershedMinMax(self: var WhiteboxTools; dem: string;
                                  watersheds: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the elevation of a location relative to the minimum and maximum elevations in a watershed. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • watersheds: Input raster watersheds file.
  • output: Output raster file.
proc elevationAboveStream(self: var WhiteboxTools; dem: string; streams: string;
                         output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the elevation of cells above the nearest downslope stream cell. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • streams: Input raster streams file.
  • output: Output raster file.
proc elevationAboveStreamEuclidean(self: var WhiteboxTools; dem: string;
                                  streams: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the elevation of cells above the nearest (Euclidean distance) stream cell. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • streams: Input raster streams file.
  • output: Output raster file.
proc eliminateCoincidentPoints(self: var WhiteboxTools; input: string; output: string;
                              tolerance: float): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Removes any coincident, or nearly coincident, points from a vector points file. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector polygon file.
  • tolerance: The distance tolerance for points.
proc elongationRatio(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the elongation ratio for vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc embossFilter(self: var WhiteboxTools; input: string; output: string;
                 direction: string = "n"; clip: float = 0.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an emboss filter on an image, similar to a hillshade operation. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • direction: Direction of reflection; options include 'n', 's', 'e', 'w', 'ne', 'se', 'nw', 'sw'
  • clip: Optional amount to clip the distribution tails by, in percent.
proc equalTo(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a equal-to comparison operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc erase(self: var WhiteboxTools; input: string; erase: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Removes all the features, or parts of features, that overlap with the features of the erase vector polygon. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • erase: Input erase polygon vector file.
  • output: Output vector file.
proc erasePolygonFromLidar(self: var WhiteboxTools; input: string; polygons: string;
                          output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Erases (cuts out) a vector polygon or polygons from a LiDAR point cloud. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • polygons: Input vector polygons file.
  • output: Output LiDAR file.
proc erasePolygonFromRaster(self: var WhiteboxTools; input: string; polygons: string;
                           output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Erases (cuts out) a vector polygon from a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • polygons: Input vector polygons file.
  • output: Output raster file.
proc euclideanAllocation(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Assigns grid cells in the output raster the value of the nearest target cell in the input image, measured by the Shih and Wu (2004) Euclidean distance transform. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc euclideanDistance(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the Shih and Wu (2004) Euclidean distance transform. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc exp(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the exponential (base e) of values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc exp2(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the exponential (base 2) of values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc exportTableToCsv(self: var WhiteboxTools; input: string; output: string;
                     headers: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Exports an attribute table to a CSV text file. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output raster file.
  • headers: Export field names as file header?
proc extendVectorLines(self: var WhiteboxTools; input: string; output: string;
                      dist: float; extend: string = "both ends"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Extends vector lines by a specified distance. See here for more details.

Keyword arguments:

  • input: Input vector polyline file.
  • output: Output vector polyline file.
  • dist: The distance to extend.
  • extend: Extend direction, 'both ends' (default), 'line start', 'line end'.
proc extractNodes(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts vector lines or polygons into vertex points. See here for more details.

Keyword arguments:

  • input: Input vector lines or polygon file.
  • output: Output vector points file.
proc extractRasterValuesAtPoints(self: var WhiteboxTools; inputs: string;
                                points: string; out_text: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Extracts the values of raster(s) at vector point locations. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • points: Input vector points file.
  • out_text: Output point values as text? Otherwise, the only output is to to the points file's attribute table.
proc extractStreams(self: var WhiteboxTools; flow_accum: string; output: string;
                   threshold: float; zero_background = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Extracts stream grid cells from a flow accumulation raster. See here for more details.

Keyword arguments:

  • flow_accum: Input raster D8 flow accumulation file.
  • output: Output raster file.
  • threshold: Threshold in flow accumulation values for channelization.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc extractValleys(self: var WhiteboxTools; dem: string; output: string;
                   variant: string = "LQ"; line_thin: bool = true; filter: int = 5): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies potential valley bottom grid cells based on local topolography alone. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • variant: Options include 'LQ' (lower quartile), 'JandR' (Johnston and Rosenfeld), and 'PandD' (Peucker and Douglas); default is 'LQ'.
  • line_thin: Optional flag indicating whether post-processing line-thinning should be performed.
  • filter: Optional argument (only used when variant='lq') providing the filter size, in grid cells, used for lq-filtering (default is 5).
proc fD8FlowAccumulation(self: var WhiteboxTools; dem: string; output: string;
                        out_type: string = "specific contributing area";
                        exponent: float = 1.1; threshold = none(float);
                        log = none(bool); clip = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates an FD8 flow accumulation raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • out_type: Output type; one of 'cells', 'specific contributing area' (default), and 'catchment area'.
  • exponent: Optional exponent parameter; default is 1.1.
  • threshold: Optional convergence threshold parameter, in grid cells; default is inifinity.
  • log: Optional flag to request the output be log-transformed.
  • clip: Optional flag to request clipping the display max by 1%.
proc fD8Pointer(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates an FD8 flow pointer raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc farthestChannelHead(self: var WhiteboxTools; d8_pntr: string; streams: string;
                        output: string; esri_pntr: bool = false;
                        zero_background = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the distance to the furthest upstream channel head for each stream cell. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc fastAlmostGaussianFilter(self: var WhiteboxTools; input: string; output: string;
                             sigma: float = 1.8): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a fast approximate Gaussian filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • sigma: Standard deviation distance in pixels.
proc featurePreservingSmoothing(self: var WhiteboxTools; dem: string; output: string;
                               filter: int = 11; norm_diff: float = 15.0;
                               num_iter: int = 3; max_diff: float = 0.5;
                               zfactor: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Reduces short-scale variation in an input DEM using a modified Sun et al. (2007) algorithm. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filter: Size of the filter kernel.
  • norm_diff: Maximum difference in normal vectors, in degrees.
  • num_iter: Number of iterations.
  • max_diff: Maximum allowable absolute elevation change (optional).
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc fetchAnalysis(self: var WhiteboxTools; dem: string; output: string;
                  azimuth: float = 0.0; hgt_inc: float = 0.05): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an analysis of fetch or upwind distance to an obstacle. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • azimuth: Wind azimuth in degrees in degrees.
  • hgt_inc: Height increment value.
proc fillBurn(self: var WhiteboxTools; dem: string; streams: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Burns streams into a DEM using the FillBurn (Saunders, 1999) method. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • streams: Input vector streams file.
  • output: Output raster file.
proc fillDepressions(self: var WhiteboxTools; dem: string; output: string;
                    fix_flats: bool = true; flat_increment = none(float);
                    max_depth = none(float)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Fills all of the depressions in a DEM. Depression breaching should be preferred in most cases. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • fix_flats: Optional flag indicating whether flat areas should have a small gradient applied.
  • flat_increment: Optional elevation increment applied to flat areas.
  • max_depth: Optional maximum depression depth to fill.
proc fillDepressionsPlanchonAndDarboux(self: var WhiteboxTools; dem: string;
                                      output: string; fix_flats: bool = true;
                                      flat_increment = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Fills all of the depressions in a DEM using the Planchon and Darboux (2002) method. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • fix_flats: Optional flag indicating whether flat areas should have a small gradient applied.
  • flat_increment: Optional elevation increment applied to flat areas.
proc fillDepressionsWangAndLiu(self: var WhiteboxTools; dem: string; output: string;
                              fix_flats: bool = true; flat_increment = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Fills all of the depressions in a DEM using the Wang and Liu (2006) method. Depression breaching should be preferred in most cases. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • fix_flats: Optional flag indicating whether flat areas should have a small gradient applied.
  • flat_increment: Optional elevation increment applied to flat areas.
proc fillMissingData(self: var WhiteboxTools; input: string; output: string;
                    filter: int = 11; weight: float = 2.0; no_edges: bool = true): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Fills NoData holes in a DEM. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filter: Filter size (cells).
  • weight: IDW weight value.
  • no_edges: Optional flag indicating whether to exclude NoData cells in edge regions.
proc fillSingleCellPits(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Raises pit cells to the elevation of their lowest neighbour. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc filterLidarClasses(self: var WhiteboxTools; input: string; output: string;
                       exclude_cls: string = ""): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Removes points in a LAS file with certain specified class values. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • exclude_cls: Optional exclude classes from interpolation; Valid class values range from 0 to 18, based on LAS specifications. Example, --exclude_cls='3,4,5,6,7,18'.
proc filterLidarScanAngles(self: var WhiteboxTools; input: string; output: string;
                          threshold: float): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Removes points in a LAS file with scan angles greater than a threshold. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • threshold: Scan angle threshold.
proc findFlightlineEdgePoints(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies points along a flightline's edge in a LAS file. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output file.
proc findLowestOrHighestPoints(self: var WhiteboxTools; input: string; output: string;
                              out_type: string = "lowest"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Locates the lowest and/or highest valued cells in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output vector points file.
  • out_type: Output type; one of 'area' (default) and 'volume'.
proc findMainStem(self: var WhiteboxTools; d8_pntr: string; streams: string;
                 output: string; esri_pntr: bool = false; zero_background = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Finds the main stem, based on stream lengths, of each stream network. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc findNoFlowCells(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Finds grid cells with no downslope neighbours. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc findParallelFlow(self: var WhiteboxTools; d8_pntr: string; streams: string;
                     output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Finds areas of parallel flow in D8 flow direction rasters. See here for more details.

Keyword arguments:

  • d8_pntr: Input D8 pointer raster file.
  • streams: Input raster streams file.
  • output: Output raster file.
proc findPatchOrClassEdgeCells(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Finds all cells located on the edge of patch or class features. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc findRidges(self: var WhiteboxTools; dem: string; output: string;
               line_thin: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Identifies potential ridge and peak grid cells. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • line_thin: Optional flag indicating whether post-processing line-thinning should be performed.
proc flattenLakes(self: var WhiteboxTools; dem: string; lakes: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Flattens lake polygons in a raster DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • lakes: Input lakes vector polygons file.
  • output: Output raster file.
proc flightlineOverlap(self: var WhiteboxTools; input: string = ""; output: string = "";
                      resolution: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Reads a LiDAR (LAS) point file and outputs a raster containing the number of overlapping flight lines in each grid cell. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output file.
  • resolution: Output raster's grid resolution.
proc flipImage(self: var WhiteboxTools; input: string; output: string;
              direction: string = "vertical"): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Reflects an image in the vertical or horizontal axis. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • direction: Direction of reflection; options include 'v' (vertical), 'h' (horizontal), and 'b' (both).
proc floodOrder(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Assigns each DEM grid cell its order in the sequence of inundations that are encountered during a search starting from the edges, moving inward at increasing elevations. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc floor(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the largest (closest to positive infinity) value that is less than or equal to the values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc flowAccumulationFullWorkflow(self: var WhiteboxTools; dem: string;
                                 out_dem: string; out_pntr: string;
                                 out_accum: string; out_type: string = "Specific Contributing Area";
                                 log = none(bool); clip = none(bool);
                                 esri_pntr: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Resolves all of the depressions in a DEM, outputting a breached DEM, an aspect-aligned non-divergent flow pointer, and a flow accumulation raster. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_dem: Output raster DEM file.
  • out_pntr: Output raster flow pointer file.
  • out_accum: Output raster flow accumulation file.
  • out_type: Output type; one of 'cells', 'sca' (default), and 'ca'.
  • log: Optional flag to request the output be log-transformed.
  • clip: Optional flag to request clipping the display max by 1%.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc flowLengthDiff(self: var WhiteboxTools; d8_pntr: string; output: string;
                   esri_pntr: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the local maximum absolute difference in downslope flowpath length, useful in mapping drainage divides and ridges. See here for more details.

Keyword arguments:

  • d8_pntr: Input D8 pointer raster file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc gammaCorrection(self: var WhiteboxTools; input: string; output: string;
                    gamma: float = 0.5): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a gamma correction on an input images. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • gamma: Gamma value.
proc gaussianContrastStretch(self: var WhiteboxTools; input: string; output: string;
                            num_tones: int = 256): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a Gaussian contrast stretch on input images. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • num_tones: Number of tones in the output image.
proc gaussianFilter(self: var WhiteboxTools; input: string; output: string;
                   sigma: float = 0.75): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a Gaussian filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • sigma: Standard deviation distance in pixels.
proc greaterThan(self: var WhiteboxTools; input1: string; input2: string;
                output: string; incl_equals = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a greater-than comparison operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
  • incl_equals: Perform a greater-than-or-equal-to operation.
proc hackStreamOrder(self: var WhiteboxTools; d8_pntr: string; streams: string;
                    output: string; esri_pntr: bool = false;
                    zero_background = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns the Hack stream order to each tributary in a stream network. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc heightAboveGround(self: var WhiteboxTools; input: string = ""; output: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Normalizes a LiDAR point cloud, providing the height above the nearest ground-classified point. See here for more details.

Keyword arguments:

  • input: Input LiDAR file (including extension).
  • output: Output raster file (including extension).
proc highPassFilter(self: var WhiteboxTools; input: string; output: string;
                   filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a high-pass filter on an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc highPassMedianFilter(self: var WhiteboxTools; input: string; output: string;
                         filterx: int = 11; filtery: int = 11; sig_digits: int = 2): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a high pass median filter on an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • sig_digits: Number of significant digits.
proc highestPosition(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies the stack position of the maximum value within a raster stack on a cell-by-cell basis. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc hillshade(self: var WhiteboxTools; dem: string; output: string;
              azimuth: float = 315.0; altitude: float = 30.0; zfactor: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates a hillshade raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • azimuth: Illumination source azimuth in degrees.
  • altitude: Illumination source altitude in degrees.
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc hillslopes(self: var WhiteboxTools; d8_pntr: string; streams: string;
               output: string; esri_pntr: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Identifies the individual hillslopes draining to each link in a stream network. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc histogramEqualization(self: var WhiteboxTools; input: string; output: string;
                          num_tones: int = 256): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a histogram equalization contrast enhancment on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • num_tones: Number of tones in the output image.
proc histogramMatching(self: var WhiteboxTools; input: string; histo_file: string;
                      output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Alters the statistical distribution of a raster image matching it to a specified PDF. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • histo_file: Input reference probability distribution function (pdf) text file.
  • output: Output raster file.
proc histogramMatchingTwoImages(self: var WhiteboxTools; input1: string;
                               input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

This tool alters the cumulative distribution function of a raster image to that of another image. See here for more details.

Keyword arguments:

  • input1: Input raster file to modify.
  • input2: Input reference raster file.
  • output: Output raster file.
proc holeProportion(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the proportion of the total area of a polygon's holes relative to the area of the polygon's hull. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc horizonAngle(self: var WhiteboxTools; dem: string; output: string;
                 azimuth: float = 0.0; max_dist = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates horizon angle (maximum upwind slope) for each grid cell in an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • azimuth: Wind azimuth in degrees.
  • max_dist: Optional maximum search distance (unspecified if none; in xy units).
proc hortonStreamOrder(self: var WhiteboxTools; d8_pntr: string; streams: string;
                      output: string; esri_pntr: bool = false;
                      zero_background = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns the Horton stream order to each tributary in a stream network. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc hypsometricAnalysis(self: var WhiteboxTools; inputs: string;
                        watershed: string = ""; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates a hypsometric curve for one or more DEMs. See here for more details.

Keyword arguments:

  • inputs: Input DEM files.
  • watershed: Input watershed files (optional).
  • output: Output HTML file (default name will be based on input file if unspecified).
proc idwInterpolation(self: var WhiteboxTools; input: string; field: string;
                     use_z: bool = false; output: string; weight: float = 2.0;
                     radius = none(float); min_points = none(int);
                     cell_size = none(float); base: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Interpolates vector points into a raster surface using an inverse-distance weighted scheme. See here for more details.

Keyword arguments:

  • input: Input vector Points file.
  • field: Input field name in attribute table.
  • use_z: Use z-coordinate instead of field?
  • output: Output raster file.
  • weight: IDW weight value.
  • radius: Search Radius in map units.
  • min_points: Minimum number of points.
  • cell_size: Optionally specified cell size of output raster. Not used when base raster is specified.
  • base: Optionally specified input base raster file. Not used when a cell size is specified.
proc ihsToRgb(self: var WhiteboxTools; intensity: string; hue: string;
             saturation: string; red: string = ""; green: string = ""; blue: string = "";
             output: string = ""): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Converts intensity, hue, and saturation (IHS) images into red, green, and blue (RGB) images. See here for more details.

Keyword arguments:

  • intensity: Input intensity file.
  • hue: Input hue file.
  • saturation: Input saturation file.
  • red: Output red band file. Optionally specified if colour-composite not specified.
  • green: Output green band file. Optionally specified if colour-composite not specified.
  • blue: Output blue band file. Optionally specified if colour-composite not specified.
  • output: Output colour-composite file. Only used if individual bands are not specified.
proc imageAutocorrelation(self: var WhiteboxTools; inputs: string;
                         contiguity: string = "Rook"; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs Moran's I analysis on two or more input images. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • contiguity: Contiguity type.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc imageCorrelation(self: var WhiteboxTools; inputs: string; output: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs image correlation on two or more input images. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc imageCorrelationNeighbourhoodAnalysis(self: var WhiteboxTools; input1: string;
    input2: string; output1: string; output2: string; filter: int = 11;
    stat: string = "pearson"): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs image correlation on two input images neighbourhood search windows. See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file.
  • output1: Output correlation (r-value or rho) raster file.
  • output2: Output significance (p-value) raster file.
  • filter: Size of the filter kernel.
  • stat: Correlation type; one of 'pearson' (default) and 'spearman'.
proc imageRegression(self: var WhiteboxTools; input1: string; input2: string;
                    output: string; out_residuals: string = "";
                    standardize = none(bool); scattergram = none(bool);
                    num_samples: int = 1000): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs image regression analysis on two input images. See here for more details.

Keyword arguments:

  • input1: Input raster file (independent variable, X).
  • input2: Input raster file (dependent variable, Y).
  • output: Output HTML file for regression summary report.
  • out_residuals: Output raster regression resdidual file.
  • standardize: Optional flag indicating whether to standardize the residuals map.
  • scattergram: Optional flag indicating whether to output a scattergram.
  • num_samples: Number of samples used to create scattergram
proc imageStackProfile(self: var WhiteboxTools; inputs: string; points: string;
                      output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Plots an image stack profile (i.e. signature) for a set of points and multispectral images. See here for more details.

Keyword arguments:

  • inputs: Input multispectral image files.
  • points: Input vector points file.
  • output: Output HTML file.
proc impoundmentSizeIndex(self: var WhiteboxTools; dem: string; output: string;
                         out_type: string = "mean depth"; damlength: float): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the impoundment size resulting from damming a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output file.
  • out_type: Output type; one of 'mean depth' (default), 'volume', 'area', 'max depth'.
  • damlength: Maximum length of the dam.
proc inPlaceAdd(self: var WhiteboxTools; input1: string; input2: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an in-place addition operation (input1 += input2). See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file or constant value.
proc inPlaceDivide(self: var WhiteboxTools; input1: string; input2: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an in-place division operation (input1 /= input2). See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file or constant value.
proc inPlaceMultiply(self: var WhiteboxTools; input1: string; input2: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an in-place multiplication operation (input1 * = input2). See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file or constant value.
proc inPlaceSubtract(self: var WhiteboxTools; input1: string; input2: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs an in-place subtraction operation (input1 -= input2). See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file or constant value.
proc increment(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Increases the values of each grid cell in an input raster by 1.0. (see also InPlaceAdd) See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc insertDams(self: var WhiteboxTools; dem: string; dam_pts: string; output: string;
               damlength: float): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the impoundment size resulting from damming a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • dam_pts: Input vector dam points file.
  • output: Output file.
  • damlength: Maximum length of the dam.
proc integerDivision(self: var WhiteboxTools; input1: string; input2: string;
                    output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs an integer division operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc integralImage(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Transforms an input image (summed area table) into its integral image equivalent. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc intersect(self: var WhiteboxTools; input: string; overlay: string; output: string;
              snap: float = 0.0): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Identifies the parts of features in common between two input vector layers. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • overlay: Input overlay vector file.
  • output: Output vector file.
  • snap: Snap tolerance.
proc isNoData(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies NoData valued pixels in an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc isobasins(self: var WhiteboxTools; dem: string; output: string; size: int): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Divides a landscape into nearly equal sized drainage basins (i.e. watersheds). See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • size: Target basin size, in grid cells.
proc jensonSnapPourPoints(self: var WhiteboxTools; pour_pts: string; streams: string;
                         output: string; snap_dist: float): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Moves outlet points used to specify points of interest in a watershedding operation to the nearest stream cell. See here for more details.

Keyword arguments:

  • pour_pts: Input vector pour points (outlet) file.
  • streams: Input raster streams file.
  • output: Output vector file.
  • snap_dist: Maximum snap distance in map units.
proc joinTables(self: var WhiteboxTools; input1: string; pkey: string; input2: string;
               fkey: string; import_field: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Merge a vector's attribute table with another table based on a common field. See here for more details.

Keyword arguments:

  • input1: Input primary vector file (i.e. the table to be modified).
  • pkey: Primary key field.
  • input2: Input foreign vector file (i.e. source of data to be imported).
  • fkey: Foreign key field.
  • import_field: Imported field (all fields will be imported if not specified).
proc kMeansClustering(self: var WhiteboxTools; inputs: string; output: string;
                     out_html: string = ""; classes: int; max_iterations: int = 10;
                     class_change: float = 2.0; initialize: string = "diagonal";
                     min_class_size: int = 10): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a k-means clustering operation on a multi-spectral dataset. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
  • out_html: Output HTML report file.
  • classes: Number of classes
  • max_iterations: Maximum number of iterations
  • class_change: Minimum percent of cells changed between iterations before completion
  • initialize: How to initialize cluster centres?
  • min_class_size: Minimum class size, in pixels
proc kNearestMeanFilter(self: var WhiteboxTools; input: string; output: string;
                       filterx: int = 11; filtery: int = 11; k: int = 5): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

A k-nearest mean filter is a type of edge-preserving smoothing filter. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • k: k-value in pixels; this is the number of nearest-valued neighbours to use.
proc kappaIndex(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a kappa index of agreement (KIA) analysis on two categorical raster files. See here for more details.

Keyword arguments:

  • input1: Input classification raster file.
  • input2: Input reference raster file.
  • output: Output HTML file.
proc ksTestForNormality(self: var WhiteboxTools; input: string; output: string;
                       num_samples = none(int)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Evaluates whether the values in a raster are normally distributed. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output HTML file.
  • num_samples: Number of samples. Leave blank to use whole image.
proc laplacianFilter(self: var WhiteboxTools; input: string; output: string;
                    variant: string = "3x3(1)"; clip: float = 0.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a Laplacian filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • variant: Optional variant value. Options include 3x3(1), 3x3(2), 3x3(3), 3x3(4), 5x5(1), and 5x5(2) (default is 3x3(1)).
  • clip: Optional amount to clip the distribution tails by, in percent.
proc laplacianOfGaussianFilter(self: var WhiteboxTools; input: string; output: string;
                              sigma: float = 0.75): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a Laplacian-of-Gaussian (LoG) filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • sigma: Standard deviation in pixels.
proc lasToAscii(self: var WhiteboxTools; inputs: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Converts one or more LAS files into ASCII text files. See here for more details.

Keyword arguments:

  • inputs: Input LiDAR files.
proc lasToMultipointShapefile(self: var WhiteboxTools; input: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts one or more LAS files into MultipointZ vector Shapefiles. When the input parameter is not specified, the tool grids all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
proc lasToShapefile(self: var WhiteboxTools; input: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts one or more LAS files into a vector Shapefile of POINT ShapeType. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
proc lasToZlidar(self: var WhiteboxTools; inputs: string = ""; outdir: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts one or more LAS files into the zlidar compressed LiDAR data format. See here for more details.

Keyword arguments:

  • inputs: Input LAS files.
  • outdir: Output directory into which zlidar files are created. If unspecified, it is assumed to be the same as the inputs.
proc layerFootprint(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a vector polygon footprint of the area covered by a raster grid or vector layer. See here for more details.

Keyword arguments:

  • input: Input raster or vector file.
  • output: Output vector polygon file.
proc leeSigmaFilter(self: var WhiteboxTools; input: string; output: string;
                   filterx: int = 11; filtery: int = 11; sigma: float = 10.0; m: float = 5.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a Lee (Sigma) smoothing filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • sigma: Sigma value should be related to the standarad deviation of the distribution of image speckle noise.
  • m: M-threshold value the minimum allowable number of pixels within the intensity range
proc lengthOfUpstreamChannels(self: var WhiteboxTools; d8_pntr: string;
                             streams: string; output: string;
                             esri_pntr: bool = false; zero_background = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the total length of channels upstream. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • output: Output raster file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
  • zero_background: Flag indicating whether a background value of zero should be used.
proc lessThan(self: var WhiteboxTools; input1: string; input2: string; output: string;
             incl_equals = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a less-than comparison operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
  • incl_equals: Perform a less-than-or-equal-to operation.
proc lidarBlockMaximum(self: var WhiteboxTools; input: string = ""; output: string = "";
                      resolution: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a block-maximum raster from an input LAS file. When the input/output parameters are not specified, the tool grids all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output file.
  • resolution: Output raster's grid resolution.
proc lidarBlockMinimum(self: var WhiteboxTools; input: string = ""; output: string = "";
                      resolution: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a block-minimum raster from an input LAS file. When the input/output parameters are not specified, the tool grids all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output file.
  • resolution: Output raster's grid resolution.
proc lidarClassifySubset(self: var WhiteboxTools; base: string; subset: string;
                        output: string; subset_class: float;
                        nonsubset_class = none(float)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Classifies the values in one LiDAR point cloud that correpond with points in a subset cloud. See here for more details.

Keyword arguments:

  • base: Input base LiDAR file.
  • subset: Input subset LiDAR file.
  • output: Output LiDAR file.
  • subset_class: Subset point class value (must be 0-18; see LAS specifications).
  • nonsubset_class: Non-subset point class value (must be 0-18; see LAS specifications).
proc lidarColourize(self: var WhiteboxTools; in_lidar: string; in_image: string;
                   output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Adds the red-green-blue colour fields of a LiDAR (LAS) file based on an input image. See here for more details.

Keyword arguments:

  • in_lidar: Input LiDAR file.
  • in_image: Input colour image file.
  • output: Output LiDAR file.
proc lidarElevationSlice(self: var WhiteboxTools; input: string; output: string;
                        minz = none(float); maxz = none(float); class = none(bool);
                        inclassval: int = 2; outclassval: int = 1): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Outputs all of the points within a LiDAR (LAS) point file that lie between a specified elevation range. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • minz: Minimum elevation value (optional).
  • maxz: Maximum elevation value (optional).
  • class: Optional boolean flag indicating whether points outside the range should be retained in output but reclassified.
  • inclassval: Optional parameter specifying the class value assigned to points within the slice.
  • outclassval: Optional parameter specifying the class value assigned to points within the slice.
proc lidarGroundPointFilter(self: var WhiteboxTools; input: string; output: string;
                           radius: float = 2.0; min_neighbours: int = 0;
                           slope_threshold: float = 45.0;
                           height_threshold: float = 1.0; classify: bool = true;
                           slope_norm: bool = true;
                           height_above_ground: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies ground points within LiDAR dataset using a slope-based method. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • radius: Search Radius.
  • min_neighbours: The minimum number of neighbouring points within search areas. If fewer points than this threshold are idenfied during the fixed-radius search, a subsequent kNN search is performed to identify the k number of neighbours.
  • slope_threshold: Maximum inter-point slope to be considered an off-terrain point.
  • height_threshold: Inter-point height difference to be considered an off-terrain point.
  • classify: Classify points as ground (2) or off-ground (1).
  • slope_norm: Perform initial ground slope normalization?
  • height_above_ground: Transform output to height above average ground elevation?
proc lidarHexBinning(self: var WhiteboxTools; input: string; output: string;
                    width: float; orientation: string = "horizontal"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Hex-bins a set of LiDAR points. See here for more details.

Keyword arguments:

  • input: Input base file.
  • output: Output vector polygon file.
  • width: The grid cell width.
  • orientation: Grid Orientation, 'horizontal' or 'vertical'.
proc lidarHillshade(self: var WhiteboxTools; input: string; output: string;
                   azimuth: float = 315.0; altitude: float = 30.0; radius: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates a hillshade value for points within a LAS file and stores these data in the RGB field. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output file.
  • azimuth: Illumination source azimuth in degrees.
  • altitude: Illumination source altitude in degrees.
  • radius: Search Radius.
proc lidarHistogram(self: var WhiteboxTools; input: string; output: string;
                   parameter: string = "elevation"; clip: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a histogram of LiDAR data. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output HTML file (default name will be based on input file if unspecified).
  • parameter: Parameter; options are 'elevation' (default), 'intensity', 'scan angle', 'class'.
  • clip: Amount to clip distribution tails (in percent).
proc lidarIdwInterpolation(self: var WhiteboxTools; input: string = "";
                          output: string = ""; parameter: string = "elevation";
                          returns: string = "all"; resolution: float = 1.0;
                          weight: float = 1.0; radius: float = 2.5;
                          exclude_cls: string = ""; minz = none(float);
                          maxz = none(float)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Interpolates LAS files using an inverse-distance weighted (IDW) scheme. When the input/output parameters are not specified, the tool interpolates all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file (including extension).
  • output: Output raster file (including extension).
  • parameter: Interpolation parameter; options are 'elevation' (default), 'intensity', 'class', 'return_number', 'number_of_returns', 'scan angle', 'rgb', 'user data'.
  • returns: Point return types to include; options are 'all' (default), 'last', 'first'.
  • resolution: Output raster's grid resolution.
  • weight: IDW weight value.
  • radius: Search Radius.
  • exclude_cls: Optional exclude classes from interpolation; Valid class values range from 0 to 18, based on LAS specifications. Example, --exclude_cls='3,4,5,6,7,18'.
  • minz: Optional minimum elevation for inclusion in interpolation.
  • maxz: Optional maximum elevation for inclusion in interpolation.
proc lidarInfo(self: var WhiteboxTools; input: string; output: string = "";
              vlr: bool = true; geokeys: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Prints information about a LiDAR (LAS) dataset, including header, point return frequency, and classification data and information about the variable length records (VLRs) and geokeys. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output HTML file for summary report.
  • vlr: Flag indicating whether or not to print the variable length records (VLRs).
  • geokeys: Flag indicating whether or not to print the geokeys.
proc lidarJoin(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Joins multiple LiDAR (LAS) files into a single LAS file. See here for more details.

Keyword arguments:

  • inputs: Input LiDAR files.
  • output: Output LiDAR file.
proc lidarKappaIndex(self: var WhiteboxTools; input1: string; input2: string;
                    output: string; class_accuracy: string; resolution: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a kappa index of agreement (KIA) analysis on the classifications of two LAS files. See here for more details.

Keyword arguments:

  • input1: Input LiDAR classification file.
  • input2: Input LiDAR reference file.
  • output: Output HTML file.
  • class_accuracy: Output classification accuracy raster file.
  • resolution: Output raster's grid resolution.
proc lidarNearestNeighbourGridding(self: var WhiteboxTools; input: string = "";
                                  output: string = "";
                                  parameter: string = "elevation";
                                  returns: string = "all"; resolution: float = 1.0;
                                  radius: float = 2.5; exclude_cls: string = "";
                                  minz = none(float); maxz = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Grids LAS files using nearest-neighbour scheme. When the input/output parameters are not specified, the tool grids all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file (including extension).
  • output: Output raster file (including extension).
  • parameter: Interpolation parameter; options are 'elevation' (default), 'intensity', 'class', 'return_number', 'number_of_returns', 'scan angle', 'rgb', 'user data'.
  • returns: Point return types to include; options are 'all' (default), 'last', 'first'.
  • resolution: Output raster's grid resolution.
  • radius: Search Radius.
  • exclude_cls: Optional exclude classes from interpolation; Valid class values range from 0 to 18, based on LAS specifications. Example, --exclude_cls='3,4,5,6,7,18'.
  • minz: Optional minimum elevation for inclusion in interpolation.
  • maxz: Optional maximum elevation for inclusion in interpolation.
proc lidarPointDensity(self: var WhiteboxTools; input: string = ""; output: string = "";
                      returns: string = "all"; resolution: float = 1.0;
                      radius: float = 2.5; exclude_cls: string = ""; minz = none(float);
                      maxz = none(float)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the spatial pattern of point density for a LiDAR data set. When the input/output parameters are not specified, the tool grids all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file (including extension).
  • output: Output raster file (including extension).
  • returns: Point return types to include; options are 'all' (default), 'last', 'first'.
  • resolution: Output raster's grid resolution.
  • radius: Search radius.
  • exclude_cls: Optional exclude classes from interpolation; Valid class values range from 0 to 18, based on LAS specifications. Example, --exclude_cls='3,4,5,6,7,18'.
  • minz: Optional minimum elevation for inclusion in interpolation.
  • maxz: Optional maximum elevation for inclusion in interpolation.
proc lidarPointStats(self: var WhiteboxTools; input: string = "";
                    resolution: float = 1.0; num_points: bool = true;
                    num_pulses = none(bool); avg_points_per_pulse: bool = true;
                    z_range = none(bool); intensity_range = none(bool);
                    predom_class = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates several rasters summarizing the distribution of LAS point data. When the input/output parameters are not specified, the tool works on all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • resolution: Output raster's grid resolution.
  • num_points: Flag indicating whether or not to output the number of points (returns) raster.
  • num_pulses: Flag indicating whether or not to output the number of pulses raster.
  • avg_points_per_pulse: Flag indicating whether or not to output the average number of points (returns) per pulse raster.
  • z_range: Flag indicating whether or not to output the elevation range raster.
  • intensity_range: Flag indicating whether or not to output the intensity range raster.
  • predom_class: Flag indicating whether or not to output the predominant classification raster.
proc lidarRansacPlanes(self: var WhiteboxTools; input: string; output: string;
                      radius: float = 2.0; num_iter: int = 50; num_samples: int = 5;
                      threshold: float = 0.35; model_size: int = 8;
                      max_slope: float = 80.0; classify: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a RANSAC analysis to identify points within a LiDAR point cloud that belong to linear planes. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • radius: Search Radius.
  • num_iter: Number of iterations.
  • num_samples: Number of sample points on which to build the model.
  • threshold: Threshold used to determine inlier points.
  • model_size: Acceptable model size.
  • max_slope: Maximum planar slope.
  • classify: Classify points as ground (2) or off-ground (1).
proc lidarRbfInterpolation(self: var WhiteboxTools; input: string = "";
                          output: string = ""; parameter: string = "elevation";
                          returns: string = "all"; resolution: float = 1.0;
                          num_points: int = 20; exclude_cls: string = "";
                          minz = none(float); maxz = none(float);
                          func_type: string = "ThinPlateSpline";
                          poly_order: string = "none"; weight: float = 5): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Interpolates LAS files using a radial basis function (RBF) scheme. When the input/output parameters are not specified, the tool interpolates all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file (including extension).
  • output: Output raster file (including extension).
  • parameter: Interpolation parameter; options are 'elevation' (default), 'intensity', 'class', 'return_number', 'number_of_returns', 'scan angle', 'rgb', 'user data'.
  • returns: Point return types to include; options are 'all' (default), 'last', 'first'.
  • resolution: Output raster's grid resolution.
  • num_points: Number of points.
  • exclude_cls: Optional exclude classes from interpolation; Valid class values range from 0 to 18, based on LAS specifications. Example, --exclude_cls='3,4,5,6,7,18'.
  • minz: Optional minimum elevation for inclusion in interpolation.
  • maxz: Optional maximum elevation for inclusion in interpolation.
  • func_type: Radial basis function type; options are 'ThinPlateSpline' (default), 'PolyHarmonic', 'Gaussian', 'MultiQuadric', 'InverseMultiQuadric'.
  • poly_order: Polynomial order; options are 'none' (default), 'constant', 'affine'.
  • weight: Weight parameter used in basis function.
proc lidarRemoveDuplicates(self: var WhiteboxTools; input: string; output: string;
                          include_z: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Removes duplicate points from a LiDAR data set. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • include_z: Include z-values in point comparison?
proc lidarRemoveOutliers(self: var WhiteboxTools; input: string; output: string;
                        radius: float = 2.0; elev_diff: float = 50.0;
                        use_median = none(bool); classify: bool = true): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Removes outliers (high and low points) in a LiDAR point cloud. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • radius: Search Radius.
  • elev_diff: Max. elevation difference.
  • use_median: Optional flag indicating whether to use the difference from median elevation rather than mean.
  • classify: Classify points as ground (2) or off-ground (1).
proc lidarRooftopAnalysis(self: var WhiteboxTools; input: string = "";
                         buildings: string; output: string; radius: float = 2.0;
                         num_iter: int = 50; num_samples: int = 10;
                         threshold: float = 0.15; model_size: int = 15;
                         max_slope: float = 65.0; norm_diff: float = 10.0;
                         azimuth: float = 180.0; altitude: float = 30.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies roof segments in a LiDAR point cloud. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • buildings: Input vector build footprint polygons file.
  • output: Output vector polygon file.
  • radius: Search Radius.
  • num_iter: Number of iterations.
  • num_samples: Number of sample points on which to build the model.
  • threshold: Threshold used to determine inlier points.
  • model_size: Acceptable model size.
  • max_slope: Maximum planar slope.
  • norm_diff: Maximum difference in normal vectors, in degrees.
  • azimuth: Illumination source azimuth in degrees.
  • altitude: Illumination source altitude in degrees.
proc lidarSegmentation(self: var WhiteboxTools; input: string; output: string;
                      radius: float = 2.0; num_iter: int = 50; num_samples: int = 10;
                      threshold: float = 0.15; model_size: int = 15;
                      max_slope: float = 80.0; norm_diff: float = 10.0;
                      maxzdiff: float = 1.0; classes: bool = false; ground: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Segments a LiDAR point cloud based on differences in the orientation of fitted planar surfaces and point proximity. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • radius: Search Radius.
  • num_iter: Number of iterations.
  • num_samples: Number of sample points on which to build the model.
  • threshold: Threshold used to determine inlier points.
  • model_size: Acceptable model size.
  • max_slope: Maximum planar slope.
  • norm_diff: Maximum difference in normal vectors, in degrees.
  • maxzdiff: Maximum difference in elevation (z units) between neighbouring points of the same segment.
  • classes: Segments don't cross class boundaries.
  • ground: Classify the largest segment as ground points?
proc lidarSegmentationBasedFilter(self: var WhiteboxTools; input: string;
                                 output: string; radius: float = 5.0;
                                 norm_diff: float = 2.0; maxzdiff: float = 1.0;
                                 classify = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies ground points within LiDAR point clouds using a segmentation based approach. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output file.
  • radius: Search Radius.
  • norm_diff: Maximum difference in normal vectors, in degrees.
  • maxzdiff: Maximum difference in elevation (z units) between neighbouring points of the same segment.
  • classify: Classify points as ground (2) or off-ground (1).
proc lidarTINGridding(self: var WhiteboxTools; input: string = ""; output: string = "";
                     parameter: string = "elevation"; returns: string = "all";
                     resolution: float = 1.0; exclude_cls: string = "";
                     minz = none(float); maxz = none(float);
                     max_triangle_edge_length = none(float)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a raster grid based on a Delaunay triangular irregular network (TIN) fitted to LiDAR points. See here for more details.

Keyword arguments:

  • input: Input LiDAR file (including extension).
  • output: Output raster file (including extension).
  • parameter: Interpolation parameter; options are 'elevation' (default), 'intensity', 'class', 'return_number', 'number_of_returns', 'scan angle', 'rgb', 'user data'.
  • returns: Point return types to include; options are 'all' (default), 'last', 'first'.
  • resolution: Output raster's grid resolution.
  • exclude_cls: Optional exclude classes from interpolation; Valid class values range from 0 to 18, based on LAS specifications. Example, --exclude_cls='3,4,5,6,7,18'.
  • minz: Optional minimum elevation for inclusion in interpolation.
  • maxz: Optional maximum elevation for inclusion in interpolation.
  • max_triangle_edge_length: Optional maximum triangle edge length; triangles larger than this size will not be gridded.
proc lidarThin(self: var WhiteboxTools; input: string; output: string;
              resolution: float = 2.0; method_val: string = "lowest";
              save_filtered: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Thins a LiDAR point cloud, reducing point density. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • resolution: The size of the square area used to evaluate nearby points in the LiDAR data.
  • method_val: Point selection method; options are 'first', 'last', 'lowest' (default), 'highest', 'nearest'.
  • save_filtered: Save filtered points to seperate file?
proc lidarThinHighDensity(self: var WhiteboxTools; input: string; output: string;
                         resolution: float = 1.0; density: float;
                         save_filtered: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Thins points from high density areas within a LiDAR point cloud. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • resolution: Output raster's grid resolution.
  • density: Max. point density (points / m^3).
  • save_filtered: Save filtered points to seperate file?
proc lidarTile(self: var WhiteboxTools; input: string; width: float = 1000.0;
              height: float = 1000.0; origin_x: float = 0.0; origin_y: float = 0.0;
              min_points: int = 2): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Tiles a LiDAR LAS file into multiple LAS files. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • width: Width of tiles in the X dimension; default 1000.0.
  • height: Height of tiles in the Y dimension.
  • origin_x: Origin point X coordinate for tile grid.
  • origin_y: Origin point Y coordinate for tile grid.
  • min_points: Minimum number of points contained in a tile for it to be saved.
proc lidarTileFootprint(self: var WhiteboxTools; input: string = ""; output: string;
                       hull: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a vector polygon of the convex hull of a LiDAR point cloud. When the input/output parameters are not specified, the tool works with all LAS files contained within the working directory. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output vector polygon file.
  • hull: Identify the convex hull around points.
proc lidarTophatTransform(self: var WhiteboxTools; input: string; output: string;
                         radius: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a white top-hat transform on a Lidar dataset; as an estimate of height above ground, this is useful for modelling the vegetation canopy. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • radius: Search Radius.
proc lineDetectionFilter(self: var WhiteboxTools; input: string; output: string;
                        variant: string = "vertical"; absvals = none(bool);
                        clip: float = 0.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a line-detection filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • variant: Optional variant value. Options include 'v' (vertical), 'h' (horizontal), '45', and '135' (default is 'v').
  • absvals: Optional flag indicating whether outputs should be absolute values.
  • clip: Optional amount to clip the distribution tails by, in percent.
proc lineIntersections(self: var WhiteboxTools; input1: string; input2: string;
                      output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Identifies points where the features of two vector line layers intersect. See here for more details.

Keyword arguments:

  • input1: Input vector polyline file.
  • input2: Input vector polyline file.
  • output: Output vector point file.
proc lineThinning(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs line thinning a on Boolean raster image; intended to be used with the RemoveSpurs tool. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc linearityIndex(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the linearity index for vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc linesToPolygons(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts vector polylines to polygons. See here for more details.

Keyword arguments:

  • input: Input vector line file.
  • output: Output vector polygon file.
proc listUniqueValues(self: var WhiteboxTools; input: string; field: string;
                     output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Lists the unique values contained in a field witin a vector's attribute table. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • field: Input field name in attribute table.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc ln(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the natural logarithm of values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc log10(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the base-10 logarithm of values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc log2(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Returns the base-2 logarithm of values in a raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc longProfile(self: var WhiteboxTools; d8_pntr: string; streams: string; dem: string;
                output: string; esri_pntr: bool = false): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Plots the stream longitudinal profiles for one or more rivers. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • streams: Input raster streams file.
  • dem: Input raster DEM file.
  • output: Output HTML file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc longProfileFromPoints(self: var WhiteboxTools; d8_pntr: string; points: string;
                          dem: string; output: string; esri_pntr: bool = false): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Plots the longitudinal profiles from flow-paths initiating from a set of vector points. See here for more details.

Keyword arguments:

  • d8_pntr: Input raster D8 pointer file.
  • points: Input vector points file.
  • dem: Input raster DEM file.
  • output: Output HTML file.
  • esri_pntr: D8 pointer uses the ESRI style scheme.
proc longestFlowpath(self: var WhiteboxTools; dem: string; basins: string;
                    output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Delineates the longest flowpaths for a group of subbasins or watersheds. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • basins: Input raster basins file.
  • output: Output vector file.
proc lowestPosition(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Identifies the stack position of the minimum value within a raster stack on a cell-by-cell basis. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc mDInfFlowAccumulation(self: var WhiteboxTools; dem: string; output: string;
                          out_type: string = "specific contributing area";
                          exponent: float = 1.1; threshold = none(float);
                          log = none(bool); clip = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates an FD8 flow accumulation raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • out_type: Output type; one of 'cells', 'specific contributing area' (default), and 'catchment area'.
  • exponent: Optional exponent parameter; default is 1.1.
  • threshold: Optional convergence threshold parameter, in grid cells; default is inifinity.
  • log: Optional flag to request the output be log-transformed.
  • clip: Optional flag to request clipping the display max by 1%.
proc majorityFilter(self: var WhiteboxTools; input: string; output: string;
                   filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns each cell in the output grid the most frequently occurring value (mode) in a moving window centred on each grid cell in the input raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc max(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a MAX operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc maxAbsoluteOverlay(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Evaluates the maximum absolute value for each grid cell from a stack of input rasters. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc maxAnisotropyDev(self: var WhiteboxTools; dem: string; out_mag: string;
                     out_scale: string; min_scale: int = 3; max_scale: int;
                     step: int = 2): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the maximum anisotropy (directionality) in elevation deviation over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_mag: Output raster DEVmax magnitude file.
  • out_scale: Output raster DEVmax scale file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc maxAnisotropyDevSignature(self: var WhiteboxTools; dem: string; points: string;
                              output: string; min_scale: int = 1; max_scale: int;
                              step: int = 1): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the anisotropy in deviation from mean for points over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • points: Input vector points file.
  • output: Output HTML file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc maxBranchLength(self: var WhiteboxTools; dem: string; output: string;
                    log = none(bool)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Lindsay and Seibert's (2013) branch length index is used to map drainage divides or ridge lines. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • log: Optional flag to request the output be log-transformed.
proc maxDifferenceFromMean(self: var WhiteboxTools; dem: string; out_mag: string;
                          out_scale: string; min_scale: int; max_scale: int;
                          step: int = 1): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the maximum difference from mean elevation over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_mag: Output raster DIFFmax magnitude file.
  • out_scale: Output raster DIFFmax scale file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc maxDownslopeElevChange(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the maximum downslope change in elevation between a grid cell and its eight downslope neighbors. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc maxElevDevSignature(self: var WhiteboxTools; dem: string; points: string;
                        output: string; min_scale: int; max_scale: int; step: int = 10): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the maximum elevation deviation over a range of spatial scales and for a set of points. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • points: Input vector points file.
  • output: Output HTML file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc maxElevationDeviation(self: var WhiteboxTools; dem: string; out_mag: string;
                          out_scale: string; min_scale: int; max_scale: int;
                          step: int = 1): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the maximum elevation deviation over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_mag: Output raster DEVmax magnitude file.
  • out_scale: Output raster DEVmax scale file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc maxOverlay(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Evaluates the maximum value for each grid cell from a stack of input rasters. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc maxUpslopeFlowpathLength(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Measures the maximum length of all upslope flowpaths draining each grid cell. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc maximumFilter(self: var WhiteboxTools; input: string; output: string;
                  filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns each cell in the output grid the maximum value in a moving window centred on each grid cell in the input raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc meanFilter(self: var WhiteboxTools; input: string; output: string;
               filterx: int = 3; filtery: int = 3): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a mean filter (low-pass filter) on an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc medianFilter(self: var WhiteboxTools; input: string; output: string;
                 filterx: int = 11; filtery: int = 11; sig_digits: int = 2): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a median filter on an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • sig_digits: Number of significant digits.
proc medoid(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the medoid for a series of vector features contained in a shapefile. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector file.
proc mergeLineSegments(self: var WhiteboxTools; input: string; output: string;
                      snap: float = 0.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Merges vector line segments into larger features. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector file.
  • snap: Snap tolerance.
proc mergeTableWithCsv(self: var WhiteboxTools; input: string; pkey: string;
                      csv: string; fkey: string; import_field: string = ""): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Merge a vector's attribute table with a table contained within a CSV text file. See here for more details.

Keyword arguments:

  • input: Input primary vector file (i.e. the table to be modified).
  • pkey: Primary key field.
  • csv: Input CSV file (i.e. source of data to be imported).
  • fkey: Foreign key field.
  • import_field: Imported field (all fields will be imported if not specified).
proc mergeVectors(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Combines two or more input vectors of the same ShapeType creating a single, new output vector. See here for more details.

Keyword arguments:

  • inputs: Input vector files.
  • output: Output vector file.
proc min(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a MIN operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc minAbsoluteOverlay(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Evaluates the minimum absolute value for each grid cell from a stack of input rasters. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc minDownslopeElevChange(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the minimum downslope change in elevation between a grid cell and its eight downslope neighbors. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc minMaxContrastStretch(self: var WhiteboxTools; input: string; output: string;
                          min_val: float; max_val: float; num_tones: int = 256): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a min-max contrast stretch on an input greytone image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • min_val: Lower tail clip value.
  • max_val: Upper tail clip value.
  • num_tones: Number of tones in the output image.
proc minOverlay(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Evaluates the minimum value for each grid cell from a stack of input rasters. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
proc minimumBoundingBox(self: var WhiteboxTools; input: string; output: string;
                       criterion: string = "area"; features: bool = true): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a vector minimum bounding rectangle around vector features. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector polygon file.
  • criterion: Minimization criterion; options include 'area' (default), 'length', 'width', and 'perimeter'.
  • features: Find the minimum bounding rectangles around each individual vector feature
proc minimumBoundingCircle(self: var WhiteboxTools; input: string; output: string;
                          features: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Delineates the minimum bounding circle (i.e. smallest enclosing circle) for a group of vectors. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector polygon file.
  • features: Find the minimum bounding circle around each individual vector feature
proc minimumBoundingEnvelope(self: var WhiteboxTools; input: string; output: string;
                            features: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a vector axis-aligned minimum bounding rectangle (envelope) around vector features. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector polygon file.
  • features: Find the minimum bounding envelop around each individual vector feature
proc minimumConvexHull(self: var WhiteboxTools; input: string; output: string;
                      features: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a vector convex polygon around vector features. See here for more details.

Keyword arguments:

  • input: Input vector file.
  • output: Output vector polygon file.
  • features: Find the hulls around each vector feature
proc minimumFilter(self: var WhiteboxTools; input: string; output: string;
                  filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns each cell in the output grid the minimum value in a moving window centred on each grid cell in the input raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc modifiedKMeansClustering(self: var WhiteboxTools; inputs: string; output: string;
                             out_html: string = ""; start_clusters: int = 1000;
                             merge_dist = none(float); max_iterations: int = 10;
                             class_change: float = 2.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a modified k-means clustering operation on a multi-spectral dataset. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
  • out_html: Output HTML report file.
  • start_clusters: Initial number of clusters
  • merge_dist: Cluster merger distance
  • max_iterations: Maximum number of iterations
  • class_change: Minimum percent of cells changed between iterations before completion
proc modifyNoDataValue(self: var WhiteboxTools; input: string;
                      new_value: float = -32768.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Converts nodata values in a raster to zero. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • new_value: New NoData value.
proc modulo(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a modulo operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc mosaic(self: var WhiteboxTools; inputs: string = ""; output: string;
           method_val: string = "nn"): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Mosaics two or more images together. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output raster file.
  • method_val: Resampling method; options include 'nn' (nearest neighbour), 'bilinear', and 'cc' (cubic convolution)
proc mosaicWithFeathering(self: var WhiteboxTools; input1: string; input2: string;
                         output: string; method_val: string = "cc";
                         weight: float = 4.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Mosaics two images together using a feathering technique in overlapping areas to reduce edge-effects. See here for more details.

Keyword arguments:

  • input1: Input raster file to modify.
  • input2: Input reference raster file.
  • output: Output raster file.
  • method_val: Resampling method; options include 'nn' (nearest neighbour), 'bilinear', and 'cc' (cubic convolution)
  • weight:
proc multiPartToSinglePart(self: var WhiteboxTools; input: string; output: string;
                          exclude_holes: bool = true): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Converts a vector file containing multi-part features into a vector containing only single-part features. See here for more details.

Keyword arguments:

  • input: Input vector line or polygon file.
  • output: Output vector line or polygon file.
  • exclude_holes: Exclude hole parts from the feature splitting? (holes will continue to belong to their features in output.)
proc multiply(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a multiplication operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc multiscaleElevationPercentile(self: var WhiteboxTools; dem: string;
                                  out_mag: string; out_scale: string;
                                  sig_digits: int = 3; min_scale: int = 4;
                                  step: int = 1; num_steps: int = 10;
                                  step_nonlinearity: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates surface roughness over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_mag: Output raster roughness magnitude file.
  • out_scale: Output raster roughness scale file.
  • sig_digits: Number of significant digits.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
  • num_steps: Number of steps
  • step_nonlinearity: Step nonlinearity factor (1.0-2.0 is typical)
proc multiscaleRoughness(self: var WhiteboxTools; dem: string; out_mag: string;
                        out_scale: string; min_scale: int = 1; max_scale: int;
                        step: int = 1): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates surface roughness over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_mag: Output raster roughness magnitude file.
  • out_scale: Output raster roughness scale file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc multiscaleRoughnessSignature(self: var WhiteboxTools; dem: string;
                                 points: string; output: string; min_scale: int = 1;
                                 max_scale: int; step: int = 1): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the surface roughness for points over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • points: Input vector points file.
  • output: Output HTML file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • max_scale: Maximum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
proc multiscaleStdDevNormals(self: var WhiteboxTools; dem: string; out_mag: string;
                            out_scale: string; min_scale: int = 1; step: int = 1;
                            num_steps: int = 10; step_nonlinearity: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates surface roughness over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • out_mag: Output raster roughness magnitude file.
  • out_scale: Output raster roughness scale file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
  • num_steps: Number of steps
  • step_nonlinearity: Step nonlinearity factor (1.0-2.0 is typical)
proc multiscaleStdDevNormalsSignature(self: var WhiteboxTools; dem: string;
                                     points: string; output: string;
                                     min_scale: int = 1; step: int = 1;
                                     num_steps: int = 10;
                                     step_nonlinearity: float = 1.0): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the surface roughness for points over a range of spatial scales. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • points: Input vector points file.
  • output: Output HTML file.
  • min_scale: Minimum search neighbourhood radius in grid cells.
  • step: Step size as any positive non-zero integer.
  • num_steps: Number of steps
  • step_nonlinearity: Step nonlinearity factor (1.0-2.0 is typical)
proc multiscaleTopographicPositionImage(self: var WhiteboxTools; local: string;
                                       meso: string; broad: string; output: string;
                                       lightness: float = 1.2): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a multiscale topographic position image from three DEVmax rasters of differing spatial scale ranges. See here for more details.

Keyword arguments:

  • local: Input local-scale topographic position (DEVmax) raster file.
  • meso: Input meso-scale topographic position (DEVmax) raster file.
  • broad: Input broad-scale topographic position (DEVmax) raster file.
  • output: Output raster file.
  • lightness: Image lightness value (default is 1.2).
proc narrownessIndex(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the narrowness of raster polygons. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc naturalNeighbourInterpolation(self: var WhiteboxTools; input: string;
                                  field: string = ""; use_z: bool = false;
                                  output: string; cell_size = none(float);
                                  base: string = ""; clip: bool = true): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a raster grid based on Sibson's natural neighbour method. See here for more details.

Keyword arguments:

  • input: Input vector points file.
  • field: Input field name in attribute table.
  • use_z: Use the 'z' dimension of the Shapefile's geometry instead of an attribute field?
  • output: Output raster file.
  • cell_size: Optionally specified cell size of output raster. Not used when base raster is specified.
  • base: Optionally specified input base raster file. Not used when a cell size is specified.
  • clip: Clip the data to the convex hull of the points?
proc nearestNeighbourGridding(self: var WhiteboxTools; input: string; field: string;
                             use_z: bool = false; output: string;
                             cell_size = none(float); base: string = "";
                             max_dist = none(float)): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates a raster grid based on a set of vector points and assigns grid values using the nearest neighbour. See here for more details.

Keyword arguments:

  • input: Input vector Points file.
  • field: Input field name in attribute table.
  • use_z: Use z-coordinate instead of field?
  • output: Output raster file.
  • cell_size: Optionally specified cell size of output raster. Not used when base raster is specified.
  • base: Optionally specified input base raster file. Not used when a cell size is specified.
  • max_dist: Maximum search distance (optional)
proc negate(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Changes the sign of values in a raster or the 0-1 values of a Boolean raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
proc newRasterFromBase(self: var WhiteboxTools; base: string; output: string;
                      value: string = "nodata"; data_type: string = "float"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a new raster using a base image. See here for more details.

Keyword arguments:

  • base: Input base raster file.
  • output: Output raster file.
  • value: Constant value to fill raster with; either 'nodata' or numeric value.
  • data_type: Output raster data type; options include 'double' (64-bit), 'float' (32-bit), and 'integer' (signed 16-bit) (default is 'float').
proc normalVectors(self: var WhiteboxTools; input: string; output: string;
                  radius: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates normal vectors for points within a LAS file and stores these data (XYZ vector components) in the RGB field. See here for more details.

Keyword arguments:

  • input: Input LiDAR file.
  • output: Output LiDAR file.
  • radius: Search Radius.
proc normalizedDifferenceIndex(self: var WhiteboxTools; input1: string;
                              input2: string; output: string; clip: float = 0.0;
                              correction: float = 0.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculate a normalized-difference index (NDI) from two bands of multispectral image data. See here for more details.

Keyword arguments:

  • input1: Input image 1 (e.g. near-infrared band).
  • input2: Input image 2 (e.g. red band).
  • output: Output raster file.
  • clip: Optional amount to clip the distribution tails by, in percent.
  • correction: Optional adjustment value (e.g. 1, or 0.16 for the optimal soil adjusted vegetation index, OSAVI).
proc Not(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a logical NOT operator on two Boolean raster images. See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file.
  • output: Output raster file.
proc notEqualTo(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a not-equal-to comparison operation on two rasters or a raster and a constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc numDownslopeNeighbours(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the number of downslope neighbours to each grid cell in a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc numInflowingNeighbours(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Computes the number of inflowing neighbours to each cell in an input DEM based on the D8 algorithm. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc numUpslopeNeighbours(self: var WhiteboxTools; dem: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the number of upslope neighbours to each grid cell in a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
proc olympicFilter(self: var WhiteboxTools; input: string; output: string;
                  filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs an olympic smoothing filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc opening(self: var WhiteboxTools; input: string; output: string; filterx: int = 11;
            filtery: int = 11): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

An opening is a mathematical morphology operation involving a dilation (max filter) of an erosion (min filter) set. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc Or(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a logical OR operator on two Boolean raster images. See here for more details.

Keyword arguments:

  • input1: Input raster file.
  • input2: Input raster file.
  • output: Output raster file.
proc pairedSampleTTest(self: var WhiteboxTools; input1: string; input2: string;
                      output: string; num_samples = none(int)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a 2-sample K-S test for significant differences on two input rasters. See here for more details.

Keyword arguments:

  • input1: First input raster file.
  • input2: Second input raster file.
  • output: Output HTML file.
  • num_samples: Number of samples. Leave blank to use whole image.
proc panchromaticSharpening(self: var WhiteboxTools; red: string = "";
                           green: string = ""; blue: string = "";
                           composite: string = ""; pan: string; output: string;
                           method_val: string = "brovey"): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Increases the spatial resolution of image data by combining multispectral bands with panchromatic data. See here for more details.

Keyword arguments:

  • red: Input red band image file. Optionally specified if colour-composite not specified.
  • green: Input green band image file. Optionally specified if colour-composite not specified.
  • blue: Input blue band image file. Optionally specified if colour-composite not specified.
  • composite: Input colour-composite image file. Only used if individual bands are not specified.
  • pan: Input panchromatic band file.
  • output: Output colour composite file.
  • method_val: Options include 'brovey' (default) and 'ihs'
proc patchOrientation(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the orientation of vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc pennockLandformClass(self: var WhiteboxTools; dem: string; output: string;
                         slope: float = 3.0; prof: float = 0.1; plan: float = 0.0;
                         zfactor: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Classifies hillslope zones based on slope, profile curvature, and plan curvature. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • slope: Slope threshold value, in degrees (default is 3.0)
  • prof: Profile curvature threshold value (default is 0.1)
  • plan: Plan curvature threshold value (default is 0.0).
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc percentElevRange(self: var WhiteboxTools; dem: string; output: string;
                     filterx: int = 3; filtery: int = 3): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates percent of elevation range from a DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc percentEqualTo(self: var WhiteboxTools; inputs: string; comparison: string;
                   output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the percentage of a raster stack that have cell values equal to an input on a cell-by-cell basis. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • comparison: Input comparison raster file.
  • output: Output raster file.
proc percentGreaterThan(self: var WhiteboxTools; inputs: string; comparison: string;
                       output: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the percentage of a raster stack that have cell values greather than an input on a cell-by-cell basis. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • comparison: Input comparison raster file.
  • output: Output raster file.
proc percentLessThan(self: var WhiteboxTools; inputs: string; comparison: string;
                    output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the percentage of a raster stack that have cell values less than an input on a cell-by-cell basis. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • comparison: Input comparison raster file.
  • output: Output raster file.
proc percentageContrastStretch(self: var WhiteboxTools; input: string; output: string;
                              clip: float = 1.0; tail: string = "both";
                              num_tones: int = 256): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a percentage linear contrast stretch on input images. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • clip: Optional amount to clip the distribution tails by, in percent.
  • tail: Specified which tails to clip; options include 'upper', 'lower', and 'both' (default is 'both').
  • num_tones: Number of tones in the output image.
proc percentileFilter(self: var WhiteboxTools; input: string; output: string;
                     filterx: int = 11; filtery: int = 11; sig_digits: int = 2): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a percentile filter on an input image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
  • sig_digits: Number of significant digits.
proc perimeterAreaRatio(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the perimeter-area ratio of vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc pickFromList(self: var WhiteboxTools; inputs: string; pos_input: string;
                 output: string): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Outputs the value from a raster stack specified by a position raster. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • pos_input: Input position raster file.
  • output: Output raster file.
proc planCurvature(self: var WhiteboxTools; dem: string; output: string;
                  zfactor: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates a plan (contour) curvature raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc polygonArea(self: var WhiteboxTools; input: string): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the area of vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc polygonLongAxis(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

This tool can be used to map the long axis of polygon features. See here for more details.

Keyword arguments:

  • input: Input vector polygons file.
  • output: Output vector polyline file.
proc polygonPerimeter(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the perimeter of vector polygons. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
proc polygonShortAxis(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

This tool can be used to map the short axis of polygon features. See here for more details.

Keyword arguments:

  • input: Input vector polygons file.
  • output: Output vector polyline file.
proc polygonize(self: var WhiteboxTools; inputs: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a polygon layer from two or more intersecting line features contained in one or more input vector line files. See here for more details.

Keyword arguments:

  • inputs: Input vector polyline file.
  • output: Output vector polygon file.
proc polygonsToLines(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Converts vector polygons to polylines. See here for more details.

Keyword arguments:

  • input: Input vector polygon file.
  • output: Output vector lines file.
proc power(self: var WhiteboxTools; input1: string; input2: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Raises the values in grid cells of one rasters, or a constant value, by values in another raster or constant value. See here for more details.

Keyword arguments:

  • input1: Input raster file or constant value.
  • input2: Input raster file or constant value.
  • output: Output raster file.
proc prewittFilter(self: var WhiteboxTools; input: string; output: string;
                  clip: float = 0.0): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Performs a Prewitt edge-detection filter on an image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • clip: Optional amount to clip the distribution tails by, in percent.
proc principalComponentAnalysis(self: var WhiteboxTools; inputs: string;
                               output: string; num_comp = none(int);
                               standardized = none(bool)): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Performs a principal component analysis (PCA) on a multi-spectral dataset. See here for more details.

Keyword arguments:

  • inputs: Input raster files.
  • output: Output HTML report file.
  • num_comp: Number of component images to output; <= to num. input images
  • standardized: Perform standardized PCA?
proc printGeoTiffTags(self: var WhiteboxTools; input: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Prints the tags within a GeoTIFF. See here for more details.

Keyword arguments:

  • input: Input GeoTIFF file.
proc profile(self: var WhiteboxTools; lines: string; surface: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Plots profiles from digital surface models. See here for more details.

Keyword arguments:

  • lines: Input vector line file.
  • surface: Input raster surface file.
  • output: Output HTML file.
proc profileCurvature(self: var WhiteboxTools; dem: string; output: string;
                     zfactor: float = 1.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates a profile curvature raster from an input DEM. See here for more details.

Keyword arguments:

  • dem: Input raster DEM file.
  • output: Output raster file.
  • zfactor: Optional multiplier for when the vertical and horizontal units are not the same.
proc quantiles(self: var WhiteboxTools; input: string; output: string;
              num_quantiles: int = 5): byte {...}{.raises: [ValueError], tags: [ExecIOEffect,
    ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Transforms raster values into quantiles. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • num_quantiles: Number of quantiles.
proc radialBasisFunctionInterpolation(self: var WhiteboxTools; input: string;
                                     field: string; use_z: bool = false;
                                     output: string; radius = none(float);
                                     min_points = none(int);
                                     func_type: string = "ThinPlateSpline";
                                     poly_order: string = "none";
                                     weight: float = 0.1; cell_size = none(float);
                                     base: string = ""): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Interpolates vector points into a raster surface using a radial basis function scheme. See here for more details.

Keyword arguments:

  • input: Input vector points file.
  • field: Input field name in attribute table.
  • use_z: Use z-coordinate instead of field?
  • output: Output raster file.
  • radius: Search Radius (in map units).
  • min_points: Minimum number of points.
  • func_type: Radial basis function type; options are 'ThinPlateSpline' (default), 'PolyHarmonic', 'Gaussian', 'MultiQuadric', 'InverseMultiQuadric'.
  • poly_order: Polynomial order; options are 'none' (default), 'constant', 'affine'.
  • weight: Weight parameter used in basis function.
  • cell_size: Optionally specified cell size of output raster. Not used when base raster is specified.
  • base: Optionally specified input base raster file. Not used when a cell size is specified.
proc radiusOfGyration(self: var WhiteboxTools; input: string; output: string;
                     text_output: bool): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Calculates the distance of cells from their polygon's centroid. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • text_output: Optional text output.
proc raiseWalls(self: var WhiteboxTools; input: string; breach: string = ""; dem: string;
               output: string; height: float = 100.0): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Raises walls in a DEM along a line or around a polygon, e.g. a watershed. See here for more details.

Keyword arguments:

  • input: Input vector lines or polygons file.
  • breach: Optional input vector breach lines.
  • dem: Input raster DEM file.
  • output: Output raster file.
  • height: Wall height.
proc randomField(self: var WhiteboxTools; base: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates an image containing random values. See here for more details.

Keyword arguments:

  • base: Input raster file.
  • output: Output raster file.
proc randomSample(self: var WhiteboxTools; base: string; output: string;
                 num_samples: int = 1000): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Creates an image containing randomly located sample grid cells with unique IDs. See here for more details.

Keyword arguments:

  • base: Input raster file.
  • output: Output raster file.
  • num_samples: Number of samples
proc rangeFilter(self: var WhiteboxTools; input: string; output: string;
                filterx: int = 11; filtery: int = 11): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assigns each cell in the output grid the range of values in a moving window centred on each grid cell in the input raster. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • filterx: Size of the filter kernel in the x-direction.
  • filtery: Size of the filter kernel in the y-direction.
proc rasterArea(self: var WhiteboxTools; input: string; output: string = "";
               out_text: bool; units: string = "grid cells"; zero_back: bool): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Calculates the area of polygons or classes within a raster image. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • out_text: Would you like to output polygon areas to text?
  • units: Area units; options include 'grid cells' and 'map units'.
  • zero_back: Flag indicating whether zero values should be treated as a background.
proc rasterCellAssignment(self: var WhiteboxTools; input: string; output: string;
                         assign: string = "column"): byte {...}{.raises: [ValueError], tags: [
    ExecIOEffect, ReadEnvEffect, RootEffect, WriteIOEffect, ReadIOEffect].}

Assign row or column number to cells. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output raster file.
  • assign: Which variable would you like to assign to grid cells? Options include 'column', 'row', 'x', and 'y'.
proc rasterHistogram(self: var WhiteboxTools; input: string; output: string): byte {...}{.
    raises: [ValueError], tags: [ExecIOEffect, ReadEnvEffect, RootEffect,
                              WriteIOEffect, ReadIOEffect].}

Creates a histogram from raster values. See here for more details.

Keyword arguments:

  • input: Input raster file.
  • output: Output HTML file (default name will be based on input file if unspecified).
proc rasterPerimeter(self: var WhiteboxTools; input: string; output: string = "";
                    out_text: bool; units: string = "grid cells"; zero_back: bool): byte {...}{.
    raises: [ValueError], ta