WhiteboxTools User Manual

WhiteboxTools Version 0.10
Dr. John B. Lindsay © 2017-2018
Geomorphometry and Hydrogeomatics Research Group
University of Guelph
Guelph, Canada
September 16, 2018

1. Introduction

WhiteboxTools is an advanced geospatial data analysis platform developed by Prof. John Lindsay (webpage; jblindsay) at the University of Guelph’s Geomorphometry and Hydrogeomatics Research Group (GHRG). The project began in January 2017 and quickly evolved in terms of its analytical capabilities. WhiteboxTools can be used to perform common geographical information systems (GIS) analysis operations, such as cost-distance analysis, distance buffering, and raster reclassification. Remote sensing and image processing tasks include image enhancement (e.g. panchromatic sharpening, contrast adjustments), image mosaicking, numerous filtering operations, simple classification (k-means clustering), and common image transformations. WhiteboxTools also contains advanced tooling for spatial hydrological analysis (e.g. flow-accumulation, watershed delineation, stream network analysis, sink removal), terrain analysis (e.g. common terrain indices such as slope, curvatures, wetness index, hillshading; hypsometric analysis; multi-scale topographic position analysis), and LiDAR data processing. LiDAR point clouds can be interrogated (LidarInfo, LidarHistogram), segmented, tiled and joined, analyzed for outliers, interpolated to rasters (DEMs, intensity images), and ground-points can be classified or filtered. WhiteboxTools is not a cartographic or spatial data visualization package; instead it is meant to serve as an analytical backend for other data visualization software, mainly GIS.

In this manual, WhiteboxTools refers to the standalone geospatial analysis library, a collection of tools contained within a compiled binary executable command-line program and the associated Python scripts that are distributed alongside the binary file (e.g. whitebox_tools.py and wb_runner.py). Whitebox Geospatial Analysis Tools and Whitebox GAT refer to the GIS software, which includes a user-interface (front-end), point-and-click tool interfaces, and cartographic data visualization capabilities.

Although WhiteboxTools was first developed with to serve as a source of plugin tools for the Whitebox Geospatial Analysis Tools (GAT) open-source GIS project, the tools contained in the library are stand-alone and can run outside of the larger Whitebox GAT project. See Interacting With WhiteboxTools From the Command Prompt for further details. There have been a large number of requests to call Whitebox GAT tools and functionality from outside of the Whitebox GAT user-interface (e.g. from Python automation scripts). WhiteboxTools is intended to meet these usage requirements. For example, a WhiteboxTools plug-in for QGIS is available.

The current version of Whitebox GAT contains many equivelent tools to those found in the WhiteboxTools library, although they are developed using the Java programming language. A future version of Whitebox GAT will replace these previous tools with the new WhiteboxTools backend. This transition will occur over the next several releases. Eventually most of the approximately 450 tools contained within Whitebox GAT will be ported to WhiteboxTools. In addition to separating the processing capabilities and the user-interface (and thereby reducing the reliance on Java), this migration should significantly improve processing efficiency. This is because Rust, the programming language used to develop WhiteboxTools, is generally faster than the equivalent Java code and because many of the WhiteboxTools functions are designed to process data in parallel wherever possible. In contrast, the older Java codebase included largely single-threaded applications.

In addition to Whitebox GAT, the WhiteboxTools project is related to other GHRG software projects including, the GoSpatial project, which has similar goals but is designed using the Go programming language instead of Rust. WhiteboxTools has however superseded the GoSpatial project, having subsumed all of its functionality. GoSpatial users should now transition to WhiteboxTools.

2. Downloads and Installation

WhiteboxTools is a stand-alone executable command-line program with no actual installation. Simply download the appropriate file for your system and decompress the folder. Pre-compiled binaries can be downloaded from the Geomorphometry and Hydrogeomatics Research Group software web site for various supported operating systems. Depending on your operating system, you may need to grant the WhiteboxTools executable file execution privileges before running it. If you intend to use the Python programming interface for WhiteboxTools you will need to have Python 3 installed.

It is likely that WhiteboxTools will work on a wider variety of operating systems and architectures than those of the distributed pre-compiled binaries. If you do not find your operating system/architecture in the list of available WhiteboxTool binaries, then compilation from source code will be necessary. WhiteboxTools can be compiled from the source code with the following steps:

1. Install the Rust compiler; Rustup is recommended for this purpose. Further instruction can be found at this link.

2. Download the WhiteboxTools source code. To download the code, click the green Clone or download button on the GitHub repository site.

3. Decompress the zipped download file.

4. Open a terminal (command prompt) window and change the working directory to the whitebox_tools sub-folder, which is contained within the decompressed downloaded Whitebox GAT folder:

>> cd /path/to/folder/whitebox_tools/

5. Finally, use the rust package manager Cargo, which will be installed alongside Rust, to compile the executable:

>> cargo build --release

Depending on your system, the compilation may take several minutes. When completed, the compiled binary executable file will be contained within the whitebox_tools/target/release/ folder. Type ./whitebox_tools --help at the command prompt (after changing the directory to the containing folder) for information on how to run the executable from the terminal.

The ‘>>’ is shorthand used in this document to denote the command prompt and is not intended to be typed.

Be sure to follow the instructions for installing Rust carefully. In particular, if you are installing on Microsoft Windows, you must have a linker installed prior to installing the Rust compiler (rustc). The Rust webpage recommends either the MS Visual C++ 2015 Build Tools or the GNU equivalent and offers details for each installation approach. You should also consider using RustUp to install the Rust compiler.

3. Supported Data Formats

The WhiteboxTools library can currently support reading/writing raster data in GeoTIFF (.tif), Whitebox GAT(.tas and .dep), ESRI (ArcGIS) ASCII (.txt) and binary (.flt and .hdr), GRASS GIS, Idrisi (.rdc and .rst), SAGA GIS (binary–.sdat and .sgrd–and ASCII formats), and Surfer 7 (.grd) data formats. The BigTIFF (64-bit) format is not currently supported. The library is primarily tested using Whitebox raster and GeoTIFF data sets and if you encounter issues when reading/writing data in other formats, you should report the issue. Please note that there are no plans to incorporate third-party libraries, like GDAL, in the project given the design goal of keeping a pure (or as close as possible) Rust codebase without third-party dependencies. This design greatly simplifies installation of the library.

Please note that throughout this manual code examples that manipulate raster files all use the GeoTIFF format (.tif) but any of the supported file extensions can be used in its place.

At present, there is limited ability in WhiteboxTools to work with vector geospatial data. Shapefiles geometries (.shp) and attributes (.dbf) can be read and some tools take vector inputs. There is currently no support for writing vector data although this feature is being actively developed. Other vector data formats may be added in the future.

LiDAR data can be read/written in the common LAS data format. WhiteboxTools can read and write LAS files that have been compressed (zipped with a .zip extension) using the common DEFLATE algorithm. Note that only LAS file should be contained within a zipped archive file. The compressed LiDAR format LAZ and ESRI LiDAR format are not currently supported by the library. The following is an example of running a LiDAR tool using zipped input/output files:

>>./whitebox_tools -r=LidarTophatTransform -v --wd="/path/to/data/"
-i="input.las.zip" -o="output.las.zip" --radius=10.0

Note that the double extensions (.las.zip) in the above command are not necessary and are only used for convenience of keeping track of LiDAR data sets (i.e. .zip extensions work too). The extra work of decoding/encoding compressed files does add additional processing time, although the Rust compression library that is used is highly efficient and usually only adds a few seconds to tool run times. Zipping LAS files frequently results 40-60% smaller binary files, making the additional processing time worthwhile for larger LAS file data sets with massive storage requirements.

4. Interacting With WhiteboxTools From the Command Prompt

WhiteboxTools is a command-line program and can be run either by calling it from a terminal application with appropriate commands and arguments, or, more conveniently, by calling it from a script. The following commands are recognized by the WhiteboxTools library:

Generally, the Unix convention is that single-letter arguments (options) use a single hyphen (e.g. -h) while word-arguments (longer, more descriptive argument names) use double hyphens (e.g. --help). The same rule is used for passing arguments to tools as well. Use the --toolhelp argument to print information about a specific tool (e.g. --toolhelp=Clump).

Tool names can be specified either using the snake_case or CamelCase convention (e.g. lidar_info or LidarInfo).

The following is an example of calling the WhiteboxTools binary executable file directly from the command prompt:

>>./whitebox_tools --wd='/Users/johnlindsay/Documents/data/' ^
--run=DevFromMeanElev --input='DEM clipped.tif' ^
--output='DEV raster.tif' -v

Notice the quotation marks (single or double) used around directories and filenames, and string tool arguments in general. After the --run flag, used to call a tool, a series of tool-specific flags are provided to indicate the values of various input parameters. Note that the order of these flags is unimportant. Use the ‘-v’ flag (run in verbose mode) to force the tool to print output to the command prompt. Please note that the whitebox_tools executable file must have permission to be executed; on some systems, this may require setting special permissions. Also, the above example uses the forward slash character (/), the directory path separator used on unix based systems. On Windows, users should use the back slash character (\) instead. Also, it is sometimes necessary to break (^) commands across multiple lines, as above, in order to better fit with the documents format. Actual command prompts (>>) should be contained to a single line.

5. Interacting With WhiteboxTools Through Python Scripting

By combining the WhiteboxTools library with a high-level scripting language, such as Python, users are capable of creating powerful stand-alone geospatial applications and workflow automation scripts. In fact, WhiteboxTools functionality can be called from many different programming languages. However, given the prevalent use of the Python language in the geospatial fields, the library is distributed with several resources specifically aimed at Python scripting. This section focuses on how Python programming can be used to interact with the WhiteboxTools library.

Note that all of the following material assumes the user system is configured with Python 3. The code snippets below are not guaranteed to work with older versions of the language.

5.1 Using the whitebox_tools.py script

Interacting with WhiteboxTools from Python scripts is easy. To begin, each script must start by importing the WhiteboxTools class, contained with the whitebox_tools.py script; a new WhiteboxTools object can then be created:

from WBT.whitebox_tools import WhiteboxTools

wbt = WhiteboxTools()

Depending on the relative location of the WhiteboxTools directory and the script file that you are importing to, the import statement may need to be altered slightly. In the above script, it is assumed that the folder containing the WhiteboxTools files (including the whitebox_tools Python script) is named WBT (Line 1) and that the calling script that is importing WhiteboxTools is located in the parent directory of WBT. See An Example WhiteboxTools Python Project for more details on project set-up. The use of wbt to designate the WhiteboxTools object variable in the above script (Line 3) is just the convention used in this manual and other project resources. In fact, any variable name can be used for this purpose.

The WhiteboxTools class expects to find the WhiteboxTools executable file (whitebox_tools.exe on Windows and whitebox_tools on other platforms) within the same directory (WBT) as the whitebox_tools.py script. If the binary file is located in a separate directory, you will need to set the executable directory as follows:

wbt.set_whitebox_dir('/local/path/to/whitebox/binary/')
# Or alternatively...
wbt.exe_path = '/local/path/to/whitebox/binary/'

Individual tools can be called using the convenience methods provided in the WhiteboxTools class:

# This line performs a 5 x 5 mean filter on 'inFile.tif':
wbt.mean_filter('/file/path/inFile.tif', '/file/path/outFile.tif', 5, 5)

Each tool has a cooresponding convenience method. The listing of tools in this manual includes information about each tool’s Python convienience method, including default parameter values. Parameters with default values may be optionally left off of function calls. In addition to the convenience methods, tools can be called using the run_tool() method, specifying the tool name and a list of tool arguments.

source = "source.tif"
cost = "cost.tif"
out_accum = "accum.tif"
out_backlink = "backlink.tif"
args = []
args.append("--source='{}'".format(source))
args.append("--cost='{}'".format(cost))
args.append("--out_accum='{}'".format(out_accum))
args.append("--out_backlink='{}'".format(out_backlink))
self.run_tool('cost_distance', args)

Each of the tool-specific convenience methods collect their parameters into a properly formated list and then ultimately call the run_tools() method. Notice that while internally whitebox_tools.exe uses CamelCase (e.g. MeanFilter) to denote tool names, the Python interface of whitebox_tools.py uses snake_case (e.g. mean_filter), according to Python style conventions. The only exceptions are tools with names that clash with Python keywords (e.g. And(), Not(), and Or()).

The return value can be used to check for errors during operation:

if wbt.ruggedness_index('/path/DEM.tif', '/path/ruggedness.tif') != 0:
    # Non-zero returns indicate an error.
    print('ERROR running ruggedness_index')

If your data files tend to be burried deeply in layers of sub-directories, specifying complete file names as input parameters can be tedius. In this case, the best option is setting the working directory before calling tools:

from whitebox_tools import WhiteboxTools

wbt = WhiteboxTools()
wbt.work_dir = "/path/to/data/" # Sets the Whitebox working directory

# Because the working directory has been set, file arguments can be
# specified simply using file names, without paths.
wbt.d_inf_flow_accumulation("DEM.tif", "output.tif", log=True)

An advanced text editor, such as VS Code or Atom, can provide hints and autocompletion for available tool convenience methods and their parameters, including default values (Figure 1).

Sometimes it can be useful to print a complete list of available tools:

print(wbt.list_tools()) # List all tools in WhiteboxTools

The list_tools() method also takes an optional keywords list to search for tools:

# Lists tools with 'lidar' or 'LAS' in tool name or description.
print(wbt.list_tools(['lidar', 'LAS']))

To retrieve more detailed information for a specific tool, use the tool_help() method:

print(wbt.tool_help("elev_percentile"))

tool_help() prints tool details including a description, tool parameters (and their flags), and example usage at the command line prompt. The above statement prints this report:

ElevPercentile
Description:
Calculates the elevation percentile raster from a DEM.
Toolbox: Geomorphometric Analysis
Parameters:

Flag               Description
-----------------  -----------
-i, --input, --dem Input raster DEM file.
-o, --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.

Example usage:
>>./whitebox_tools -r=ElevPercentile -v --wd="/path/to/data/" --dem=DEM.tif
>>-o=output.tif --filterx=25

A note on default parameter values

Each tool contains one or more parameters with default values. These will always be listed after any input parameters that do not have default values. You do not need to specify a parameter with a default value if you accept the default. That is, unless you intend to specify an input value different from the default, you may leave these parameters off of the function call. However, be mindful of the fact that Python assigns values to parameters based on order, unless parameter names are specified.

Consider the Hillshade tool as an example. The User Manual gives the following function definition for the tool:

hillshade(
dem,
output,
azimuth=315.0,
altitude=30.0,
zfactor=1.0,
callback=default_callback)

The dem and output parameters do not have default values and must be specified every time you call this function. Each of the remaining parameters have default values and can, optionally, be left off of calls to the hillshade function. As an example, say I want to accept the default values for all the parameters except altitude. I would then need to use the named-parameter form of the function call:

wbt.hillshade(
"DEM.tif",
"hillshade.tif",
altitude=20.0)

If I hadn’t specified the parameter name for altitude, Python would have assumed that the value 20.0 should be assigned to the third parameter, azimuth.

5.2 Handling tool output

Tools will frequently print text to the standard output during their execution, including warnings, progress updates and other notifications. Sometimes, when users run many tools in complex workflows and in batch mode, these output messages can be undesirable. Most tools will have their outputs suppressed by setting the verbose mode to False as follows:

wbt.set_verbose_mode(False)
# Or, alternatively...
wbt.verbose = False

Alternatively, it may be helpful to capture the text output of a tool for custom processing. This is achieved by specifying a custom callback function to the tool’s convenience function:

# This callback function suppresses printing progress updates,
# which always use the '%' character. The callback function
# approach is flexible and allows for any level of complex
# interaction with tool outputs.
def my_callback(value):
    if not "%" in value:
        print(value)

wbt.slope('DEM.tif', 'slope_raster.tif', callback=my_callback)

Every convienience function takes an optional callback as the last parameter. The default callback simply prints tool outputs to the standard output without any additional processing. Callback functions can serve as a means of cancelling operations:

def my_callback(value):
    if user_selected_cancel_btn: # Assumes a 'Cancel' button on a GUI
        print('Cancelling operation...')
        wbt.cancel_op = True
    else:
        print(value)

wbt.breach_depressions('DEM.tif', 'DEM_breached.tif', callback=my_callback)

5.3 Additional functions in whitebox_tools.py

The whitebox_tools.py script provides several other functions for interacting with the WhiteboxTools library, including:

# Print the WhiteboxTools help...a listing of available commands
print(wbt.help())

# Print the WhiteboxTools license
print(wbt.license())

# Print the WhiteboxTools version
print("Version information: {}".format(wbt.version()))

# Get the toolbox associated with a tool
tb = wbt.toolbox('lidar_info')

# Retrieve a JSON object of a tool's parameters.
tp = tool_parameters('raster_histogram')

# Opens a browser and navigates to a tool's source code in the
# WhiteboxTools GitHub repository
wbt.view_code('watershed')

For a working example of how to call functions and run tools from Python, see the whitebox_example.py Python script, which is distributed with the WhiteboxTools library.

5.4 An example WhiteboxTools Python project

In this section, we will create a Python project that utilizes the WhiteboxTools library to interpolate a LiDAR point-cloud, to process the resulting digital elevation model (DEM) to make it suitable for hydrological applications, and to perform a simple flow-accumulation operation. I suggest using an advanced coding text editor, such as Visual Studio Code or Atom, for this tutorial, but Python code can be written using any basic text editor.

Begin by creating a dedicated project directory called FlowAccumExample and copy WhiteboxTools binary file (i.e. the compressed file downloaded from the Geomorphometry & Hydrogeomatics Research Group website) into this folder. Using the decompression software on your computer, decompress (i.e. an operation sometimes called unzipping) the file into the newly created FlowAccumExample directory. You will find the compressed file contains a folder with contents similar to Figure 2.

The folder contains a number of files, including the WhiteboxTools executable file, the whitebox_tools.py python script, the WhiteboxTools Runner (wb_runner.py; see below), and this user manual. It is likely that the folder has a name that reflects the operating system and architecture that the binary file was compiled for (e.g. WhiteboxTools_darwin_amd64). Rename this directory to WBT. Also note, depending on your decompression software, it may be the case that the contents of the WBT folder itself contains a sub-directory that actually holds these files. If this is the case, be sure to move the contents of the sub-directory into the WBT parent directory.

Using your text editor, create a new Python script file, called FlowAccumulation.py within the FlowAccumExample directory. We will begin by importing the WhiteboxTools class from the whitebox_tools.py script contained within the WBT sub-directory. Unfortunately, Python’s module system is only able to import classes and function definitions declared in external Python scripts if these external files are contained somewhere on the Python path or in the directory containing the script file into which you are importing. This is important because based on the project structure that we have established, the whitebox_tools.py script is actually contained within a sub-directory of the FlowAccumExample directory and is therefore not directly accessible, unless you have previously installed the script on the Python path. Another, perhaps easier solution to this problem is to create a file named __init__.py (those are two leading and trailing underscore characters) within the FlowAccumExample directory. The presence of this empty file will make Python treat the WBT directory as containing packages, in this case, the whitebox_tools package. For more information, see the Python documentation on modules and packages.

At this stage, you should have a project directory structure like that of the Figure 3.

Many operating systems will disallow the execution of files that are downloaded directly from the Internet. As such, it is possible that you will need to explicitly give the whitebox_tools.exe permission to execute on your computer (Note: here we are referring to the compiled WhiteboxTools binary file and not the similarly named Python script whitebox_tools.py also contained in the folder). The procedure for doing this depends on your specific operating system. On MacOS, for example, this is usually achieved using the ‘Security & Privacy’ tab under ‘System Preferences’. To test whether whitebox_tools.exe has permission to run on your system, double-click the file. If the file is configured to execute, a command terminal will automatically open and the WhiteboxTools help documentation and a listing of the available tools will be printed. If this does not occur, you likely need to give the file permission to execute.

Using your text editor, you may now add the following lines to the FlowAccumulation.py file.

from WBT.whitebox_tools import WhiteboxTools

wbt = WhiteboxTools()

In the import statement, WBT is a reference to the package folder containing the WhiteboxTools files; whitebox_tools is a reference to the whitebox_tools.py script contained with this package folder; and WhiteboxTools is a reference to the WhiteboxTools class contained within this script file. Please note that if you named your directory containing the WhiteboxTools files something other than WBT, you would need to alter the import statement accordingly.

Visit the Geomorphometry and Hydrogeomatics Research Group website and download the St. Elis Mountains and Gulf of Alaska sample data set (StElisAk.las) from the WhiteboxTools section of the site. This file contains a LiDAR point cloud that has been previously filtered to remove points associated with non-ground returns, mainly trees (Figure 4). Create a sub-directory within the project folder called ‘data’ and copy StElisAk.las into the folder.

Now we can complete our flow accumulation analysis with the following code:

import os
from WBT.whitebox_tools import WhiteboxTools

wbt = WhiteboxTools()

# Set the working directory, i.e. the folder containing the data,
# to the 'data' sub-directory.
wbt.work_dir = os.path.dirname(os.path.abspath(__file__)) + "/data/"

# When you're running mulitple tools, the outputs can be a tad
# chatty. In this case, you may want to suppress the output by
# setting the verbose mode to False.
# wbt.verbose = False

# Interpolate the LiDAR data using an inverse-distance weighting
# (IDW) scheme.
print("Interpolating DEM...")
wbt.lidar_idw_interpolation(
i="StElisAk.las",
output="raw_dem.tif",
parameter="elevation",
returns="last",
resolution=1.0,
weight=1.0,
radius=2.5
)

# The resulting DEM will contain NoData gaps. We need to fill
# these in by interpolating across the gap.
print("Filling missing data...")
wbt.fill_missing_data(
i="raw_dem.tif",
output="dem_nodata_filled.tif",
filter=11
)

# This DEM will contain grid cells that have no lower neighbours.
# This condition is unsuited for flow-path modelling applications
# because these operations assume that each interior cell in the
# DEM has at least one downslope neighour. We'll use an operation
# called depression breaching to 'fix' the elevations within the
# DEM to enforce continuous flow.
print("Performing flow enforcement...")
wbt.breach_depressions(
dem="dem_nodata_filled.tif",
output="dem_hydro_enforced.tif"
)

# Lastly, perform the flow accumulation operation using the
# D-infinity flow algorithm.
print("Performing flow accumulation...")
wbt.d_inf_flow_accumulation(
dem="dem_hydro_enforced.tif",
output="flow_accum.tif",
log=True
)

print("Complete!")

To run the above script, open a terminal (command prompt), cd to the script containing folder, and run the following command:

>>python FlowAccumulation.py

If Python 3 is not your default Python version, substitute python3 for python in the above command line. The final D-infinity flow accumulation raster can be displayed in any GIS software of choice and should look similar to Figure 5.

6. WhiteboxTools Runner

There is a Python script contained within the WhiteboxTools directory called ‘wb_runner.py’. This script is intended to provide a very basic user-interface, WhiteboxTools Runner, for running the tools contained within the WhiteboxTools library. The user-interface uses Python’s TkInter GUI library and is cross-platform. The user interface is currently experimental and is under heavy testing. Please report any issues that you experience in using it.

The WhiteboxTools Runner does not rely on the Whitebox GAT user interface at all and can therefore be used indepedent of the larger project. The script must be run from a directory that also contains the ‘whitebox_tools.py’ Python script and the ‘whitebox_tools’ executable file. There are plans to link tool help documentation in WhiteboxTools Runner and to incorporate toolbox information, rather than one large listing of available tools.

7. WhiteboxTools QGIS Plugin

WhiteboxTools functionality can also be accessed conveniently through the popular open-source geospatial software QGIS. QGIS developer Alexander Bruy maintains a plugin for the toolbox called Whitebox For Processing. Detailed instructions for installing and setting-up the QGIS toolbox can be found on the site.

8. Available Tools

Eventually most of Whitebox GAT’s approximately 400 tools will be ported to WhiteboxTools, although this is an immense task. Opportunities to parallelize algorithms will be sought during porting. All new plugin tools will be added to Whitebox GAT using this library of functions.

The library currently contains more than 345 tools, which are each grouped into themed toolboxes including: Data Tools, Geomorphometric Analysis (i.e. digital terrain analysis), GIS Analysis, Hydrological Analysis, Image Analysis, LiDAR Analysis, Mathematical and Statistical Analysis, and Stream Network Analysis. To retrieve detailed information about a tool’s input arguments and example usage, either use the toolhelp command from the terminal, or the tool_help('tool_name') function from the whitebox_tools.py script. The following is a complete listing of available tools, with brief descriptions, tool parameter, and example usage.

8.1 Data Tools

8.1.1 ConvertNodataToZero

Converts nodata values in a raster to zero..

Parameters:

Python function:

convert_nodata_to_zero(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ConvertNodataToZero -v ^
--wd="/path/to/data/" --input=in.tif -o=NewRaster.tif 

8.1.2 ConvertRasterFormat

Converts raster data from one format to another..

Parameters:

Python function:

convert_raster_format(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ConvertRasterFormat -v ^
--wd="/path/to/data/" --input=DEM.tif -o=output.tif 

8.1.3 ExportTableToCsv

Exports an attribute table to a CSV text file..

Parameters:

Python function:

export_table_to_csv(
    i, 
    output, 
    headers=True, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ExportTableToCsv -v ^
--wd="/path/to/data/" -i=lines.shp -o=output.csv --headers 

8.1.4 IdwInterpolation

Interpolates vector points into a raster surface using an inverse-distance weighted scheme..

Parameters:

Python function:

idw_interpolation(
    i, 
    field, 
    output, 
    use_z=False, 
    weight=2.0, 
    radius=None, 
    min_points=None, 
    cell_size=None, 
    base=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=IdwInterpolation -v ^
--wd="/path/to/data/" -i=points.shp --field=ELEV -o=output.tif ^
--assign=min --nodata ^
--cell_size=10.0
        >>./whitebox_tools -r=IdwInterpolation ^
-v --wd="/path/to/data/" -i=points.shp --field=FID ^
-o=output.tif --assign=last --base=existing_raster.tif 

8.1.5 NewRasterFromBase

Creates a new raster using a base image..

Parameters:

Python function:

new_raster_from_base(
    base, 
    output, 
    value="nodata", 
    data_type="float", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=NewRasterFromBase -v ^
--wd="/path/to/data/" --base=base.tif -o=NewRaster.tif ^
--value=0.0 --data_type=integer
>>./whitebox_tools ^
-r=NewRasterFromBase -v --wd="/path/to/data/" --base=base.tif ^
-o=NewRaster.tif --value=nodata 

8.1.6 PolygonsToLines

Converts vector polygons to polylines..

Parameters:

Python function:

polygons_to_lines(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PolygonsToLines -v ^
--wd="/path/to/data/" -i=input.shp -o=output.shp 

8.1.7 PrintGeoTiffTags

Prints the tags within a GeoTIFF..

Parameters:

Python function:

print_geo_tiff_tags(
    i, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PrintGeoTiffTags -v ^
--wd="/path/to/data/" --input=DEM.tiff 

8.1.8 ReinitializeAttributeTable

Reinitializes a vector’s attribute table deleting all fields but the feature ID (FID)..

Parameters:

Python function:

reinitialize_attribute_table(
    i, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ReinitializeAttributeTable -v ^
--wd="/path/to/data/" -i=input.shp 

8.1.9 SetNodataValue

Assign a specified value in an input image to the NoData value..

Parameters:

Python function:

set_nodata_value(
    i, 
    output, 
    back_value=0.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=SetNodataValue -v --wd="/path/to/data/" ^
-i=in.tif -o=newRaster.tif --back_value=1.0 

8.1.10 VectorLinesToRaster

Converts a vector containing polylines into a raster..

Parameters:

Python function:

vector_lines_to_raster(
    i, 
    output, 
    field="FID", 
    nodata=True, 
    cell_size=None, 
    base=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=VectorLinesToRaster -v ^
--wd="/path/to/data/" -i=lines.shp --field=ELEV -o=output.tif ^
--nodata --cell_size=10.0
        >>./whitebox_tools ^
-r=VectorLinesToRaster -v --wd="/path/to/data/" -i=lines.shp ^
--field=FID -o=output.tif --base=existing_raster.tif 

8.1.11 VectorPointsToRaster

Converts a vector containing points into a raster..

Parameters:

Python function:

vector_points_to_raster(
    i, 
    output, 
    field="FID", 
    assign="last", 
    nodata=True, 
    cell_size=None, 
    base=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=VectorPointsToRaster -v ^
--wd="/path/to/data/" -i=points.shp --field=ELEV -o=output.tif ^
--assign=min --nodata ^
--cell_size=10.0
        >>./whitebox_tools ^
-r=VectorPointsToRaster -v --wd="/path/to/data/" -i=points.shp ^
--field=FID -o=output.tif --assign=last ^
--base=existing_raster.tif 

8.1.12 VectorPolygonsToRaster

Converts a vector containing polygons into a raster..

Parameters:

Python function:

vector_polygons_to_raster(
    i, 
    output, 
    field="FID", 
    nodata=True, 
    cell_size=None, 
    base=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=VectorPolygonsToRaster -v ^
--wd="/path/to/data/" -i=lakes.shp --field=ELEV -o=output.tif ^
--nodata --cell_size=10.0
        >>./whitebox_tools ^
-r=VectorPolygonsToRaster -v --wd="/path/to/data/" ^
-i=lakes.shp --field=ELEV -o=output.tif ^
--base=existing_raster.tif 

8.2 GIS Analysis

8.2.1 AggregateRaster

Aggregates a raster to a lower resolution..

Parameters:

Python function:

aggregate_raster(
    i, 
    output, 
    agg_factor=2, 
    type="mean", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=AggregateRaster -v ^
--wd="/path/to/data/" -i=input.tif -o=output.tif ^
--output_text 

8.2.2 Centroid

Calculates the centroid, or average location, of raster polygon objects..

Parameters:

Python function:

centroid(
    i, 
    output, 
    text_output=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Centroid -v --wd="/path/to/data/" ^
-i=polygons.tif -o=output.tif
>>./whitebox_tools -r=Centroid ^
-v --wd="/path/to/data/" -i=polygons.tif -o=output.tif ^
--text_output 

8.2.3 Clump

Groups cells that form physically discrete areas, assigning them unique identifiers..

Parameters:

Python function:

clump(
    i, 
    output, 
    diag=True, 
    zero_back=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Clump -v --wd="/path/to/data/" ^
-i=input.tif -o=output.tif --diag 

8.2.4 CreatePlane

Creates a raster image based on the equation for a simple plane..

Parameters:

Python function:

create_plane(
    base, 
    output, 
    gradient=15.0, 
    aspect=90.0, 
    constant=0.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CreatePlane -v --wd="/path/to/data/" ^
--base=base.tif -o=NewRaster.tif --gradient=15.0 ^
--aspect=315.0 

8.2.5 ExtractRasterValuesAtPoints

Extracts the values of raster(s) at vector point locations..

Parameters:

Python function:

extract_raster_values_at_points(
    inputs, 
    points, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ExtractRasterValuesAtPoints -v ^
--wd="/path/to/data/" -i='image1.tif;image2.tif;image3.tif' ^
-points=points.shp 

8.2.6 FindLowestOrHighestPoints

Locates the lowest and/or highest valued cells in a raster..

Parameters:

Python function:

find_lowest_or_highest_points(
    i, 
    output, 
    out_type="lowest", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FindLowestOrHighestPoints -v ^
--wd="/path/to/data/" --input=DEM.tif -o=out.shp ^
--out_type=highest 

8.2.7 RasterCellAssignment

Assign row or column number to cells..

Parameters:

Python function:

raster_cell_assignment(
    i, 
    output, 
    assign="column", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RasterCellAssignment -v ^
--wd="/path/to/data/" -i='input.tif' -o=output.tif ^
--assign='column' 

8.2.8 Reclass

Reclassifies the values in a raster image..

Parameters:

Python function:

reclass(
    i, 
    output, 
    reclass_vals, 
    assign_mode=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Reclass -v --wd="/path/to/data/" ^
-i='input.tif' -o=output.tif ^
--reclass_vals='0.0;0.0;1.0;1.0;1.0;2.0'
>>./whitebox_tools ^
-r=Reclass -v --wd="/path/to/data/" -i='input.tif' ^
-o=output.tif --reclass_vals='10;1;20;2;30;3;40;4' ^
--assign_mode 

8.2.9 ReclassEqualInterval

Reclassifies the values in a raster image based on equal-ranges..

Parameters:

Python function:

reclass_equal_interval(
    i, 
    output, 
    interval=10.0, 
    start_val=None, 
    end_val=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ReclassEqualInterval -v ^
--wd="/path/to/data/" -i='input.tif' -o=output.tif ^
--interval=10.0 --start_val=0.0 

8.2.10 ReclassFromFile

Reclassifies the values in a raster image using reclass ranges in a text file..

Parameters:

Python function:

reclass_from_file(
    i, 
    reclass_file, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ReclassFromFile -v ^
--wd="/path/to/data/" -i='input.tif' ^
--reclass_file='reclass.txt' -o=output.tif 

8.3 GIS Analysis => Distance Tools

8.3.1 BufferRaster

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

Parameters:

Python function:

buffer_raster(
    i, 
    output, 
    size, 
    gridcells=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=BufferRaster -v --wd="/path/to/data/" ^
-i=DEM.tif -o=output.tif 

8.3.2 CostAllocation

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

Parameters:

Python function:

cost_allocation(
    source, 
    backlink, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CostAllocation -v --wd="/path/to/data/" ^
--source='source.tif' --backlink='backlink.tif' ^
-o='output.tif' 

8.3.3 CostDistance

Performs cost-distance accumulation on a cost surface and a group of source cells..

Parameters:

Python function:

cost_distance(
    source, 
    cost, 
    out_accum, 
    out_backlink, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CostDistance -v --wd="/path/to/data/" ^
--source=src.tif --cost=cost.tif --out_accum=accum.tif ^
--out_backlink=backlink.tif 

8.3.4 CostPathway

Performs cost-distance pathway analysis using a series of destination grid cells..

Parameters:

Python function:

cost_pathway(
    destination, 
    backlink, 
    output, 
    zero_background=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CostPathway -v --wd="/path/to/data/" ^
--destination=dst.tif --backlink=backlink.tif ^
--output=cost_path.tif 

8.3.5 EuclideanAllocation

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..

Parameters:

Python function:

euclidean_allocation(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=EuclideanAllocation -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.3.6 EuclideanDistance

Calculates the Shih and Wu (2004) Euclidean distance transform..

Parameters:

Python function:

euclidean_distance(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=EuclideanDistance -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.4 GIS Analysis => Overlay Tools

8.4.1 AverageOverlay

Calculates the average for each grid cell from a group of raster images..

Parameters:

Python function:

average_overlay(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=AverageOverlay -v --wd='/path/to/data/' ^
-i='image1.dep;image2.dep;image3.tif' -o=output.tif 

8.4.2 ClipRasterToPolygon

Clips a raster to a vector polygon..

Parameters:

Python function:

clip_raster_to_polygon(
    i, 
    polygons, 
    output, 
    maintain_dimensions=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ClipRasterToPolygon -v ^
--wd="/path/to/data/" -i=raster.tif --polygons=poly.shp ^
-o=output.tif --maintain_dimensions 

8.4.3 CountIf

Counts the number of occurrences of a specified value in a cell-stack of rasters..

Parameters:

Python function:

count_if(
    inputs, 
    output, 
    value, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CountIf -v --wd='/path/to/data/' ^
-i='image1.dep;image2.dep;image3.tif' -o=output.tif ^
--value=5.0 

8.4.4 ErasePolygonFromRaster

Erases (cuts out) a vector polygon from a raster..

Parameters:

Python function:

erase_polygon_from_raster(
    i, 
    polygons, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ErasePolygonFromRaster -v ^
--wd="/path/to/data/" -i='DEM.tif' --polygons='lakes.shp' ^
-o='output.tif' 

8.4.5 HighestPosition

Identifies the stack position of the maximum value within a raster stack on a cell-by-cell basis..

Parameters:

Python function:

highest_position(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=HighestPosition -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
-o=output.tif 

8.4.6 LowestPosition

Identifies the stack position of the minimum value within a raster stack on a cell-by-cell basis..

Parameters:

Python function:

lowest_position(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=LowestPosition -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' -o=output.tif 

8.4.7 MaxAbsoluteOverlay

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

Parameters:

Python function:

max_absolute_overlay(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxAbsoluteOverlay -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
-o=output.tif 

8.4.8 MaxOverlay

Evaluates the maximum value for each grid cell from a stack of input rasters..

Parameters:

Python function:

max_overlay(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxOverlay -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' -o=output.tif 

8.4.9 MinAbsoluteOverlay

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

Parameters:

Python function:

min_absolute_overlay(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MinAbsoluteOverlay -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
-o=output.tif 

8.4.10 MinOverlay

Evaluates the minimum value for each grid cell from a stack of input rasters..

Parameters:

Python function:

min_overlay(
    inputs, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MinOverlay -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' -o=output.tif 

8.4.11 PercentEqualTo

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

Parameters:

Python function:

percent_equal_to(
    inputs, 
    comparison, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PercentEqualTo -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' --comparison='comp.tif' ^
-o='output.tif' 

8.4.12 PercentGreaterThan

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

Parameters:

Python function:

percent_greater_than(
    inputs, 
    comparison, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PercentGreaterThan -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
--comparison='comp.tif' -o='output.tif' 

8.4.13 PercentLessThan

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

Parameters:

Python function:

percent_less_than(
    inputs, 
    comparison, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PercentLessThan -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
--comparison='comp.tif' -o='output.tif' 

8.4.14 PickFromList

Outputs the value from a raster stack specified by a position raster..

Parameters:

Python function:

pick_from_list(
    inputs, 
    pos_input, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PickFromList -v --wd='/path/to/data/' ^
--pos_input=position.tif -i='image1.tif;image2.tif;image3.tif' ^
-o=output.tif 

8.4.15 WeightedOverlay

Performs a weighted sum on multiple input rasters after converting each image to a common scale. The tool performs a multi-criteria evaluation (MCE)..

Parameters:

Python function:

weighted_overlay(
    factors, 
    weights, 
    output, 
    cost=None, 
    constraints=None, 
    scale_max=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=WeightedOverlay -v ^
--wd='/path/to/data/' ^
--factors='image1.tif;image2.tif;image3.tif' ^
--weights='0.3;0.2;0.5' --cost='false;false;true' -o=output.tif ^
--scale_max=100.0 

8.4.16 WeightedSum

Performs a weighted-sum overlay on multiple input raster images..

Parameters:

Python function:

weighted_sum(
    inputs, 
    weights, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=WeightedSum -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' --weights='0.3;0.2;0.5' ^
-o=output.tif 

8.5 GIS Analysis => Patch Shape Tools

8.5.1 EdgeProportion

Calculate the proportion of cells in a raster polygon that are edge cells..

Parameters:

Python function:

edge_proportion(
    i, 
    output, 
    output_text=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=EdgeProportion -v --wd="/path/to/data/" ^
-i=input.tif -o=output.tif --output_text 

8.5.2 FindPatchOrClassEdgeCells

Finds all cells located on the edge of patch or class features..

Parameters:

Python function:

find_patch_or_class_edge_cells(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FindPatchOrClassEdgeCells -v ^
--wd="/path/to/data/" -i=input.tif -o=output.tif 

8.5.3 RadiusOfGyration

Calculates the distance of cells from their polygon’s centroid..

Parameters:

Python function:

radius_of_gyration(
    i, 
    output, 
    text_output=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RadiusOfGyration -v ^
--wd="/path/to/data/" -i=polygons.tif -o=output.tif ^
--text_output 

8.6 GIS Tools

8.6.1 CreateHexagonalVectorGrid

Creates a hexagonal vector grid..

Parameters:

Python function:

create_hexagonal_vector_grid(
    i, 
    output, 
    width, 
    orientation="horizontal", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CreateHexagonalVectorGrid -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp --width=10.0 ^
--orientation=vertical 

8.6.2 CreateRectangularVectorGrid

Creates a rectangular vector grid..

Parameters:

Python function:

create_rectangular_vector_grid(
    i, 
    output, 
    width, 
    height, 
    xorig=0, 
    yorig=0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CreateRectangularVectorGrid -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp --width=10.0 ^
--height=10.0 --xorig=0.0 --yorig=0.0 

8.6.3 EliminateCoincidentPoints

Removes any coincident, or nearly coincident, points from a vector points file..

Parameters:

Python function:

eliminate_coincident_points(
    i, 
    output, 
    tolerance, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=EliminateCoincidentPoints -v ^
--wd="/path/to/data/" -i=input_file.shp -o=out_file.shp ^
--tolerance=0.01 

8.6.4 ExtractNodes

Converts vector lines or polygons into vertex points..

Parameters:

Python function:

extract_nodes(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ExtractNodes -v --wd="/path/to/data/" ^
-i=file.shp -o=outfile.shp 

8.6.5 MinimumBoundingBox

Creates a vector minimum bounding rectangle around vector features..

Parameters:

Python function:

minimum_bounding_box(
    i, 
    output, 
    features=True, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MinimumBoundingBox -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp --features 

8.6.6 MinimumConvexHull

Creates a vector convex polygon around vector features..

Parameters:

Python function:

minimum_convex_hull(
    i, 
    output, 
    features=True, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MinimumConvexHull -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp --features 

8.6.7 PolygonLongAxis

This tool can be used to map the long axis of polygon features..

Parameters:

Python function:

polygon_long_axis(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PolygonLongAxis -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp 

8.6.8 PolygonShortAxis

This tool can be used to map the short axis of polygon features..

Parameters:

Python function:

polygon_short_axis(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PolygonShortAxis -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp 

8.6.9 VectorHexBinning

Hex-bins a set of vector points..

Parameters:

Python function:

vector_hex_binning(
    i, 
    output, 
    width, 
    orientation="horizontal", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=VectorHexBinning -v ^
--wd="/path/to/data/" -i=file.shp -o=outfile.shp --width=10.0 ^
--orientation=vertical 

8.7 Geomorphometric Analysis

8.7.1 Aspect

Calculates an aspect raster from an input DEM..

Parameters:

Python function:

aspect(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Aspect -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.7.2 DevFromMeanElev

Calculates deviation from mean elevation..

Parameters:

Python function:

dev_from_mean_elev(
    dem, 
    output, 
    filterx=11, 
    filtery=11, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DevFromMeanElev -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--filter=25 

8.7.3 DiffFromMeanElev

Calculates difference from mean elevation (equivalent to a high-pass filter)..

Parameters:

Python function:

diff_from_mean_elev(
    dem, 
    output, 
    filterx=11, 
    filtery=11, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DiffFromMeanElev -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--filter=25 

8.7.4 DirectionalRelief

Calculates relief for cells in an input DEM for a specified direction..

Parameters:

Python function:

directional_relief(
    dem, 
    output, 
    azimuth=0.0, 
    max_dist=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DirectionalRelief -v ^
--wd="/path/to/data/" -i='input.tif' -o=output.tif ^
--azimuth=315.0 

8.7.5 DownslopeIndex

Calculates the Hjerdt et al. (2004) downslope index..

Parameters:

Python function:

downslope_index(
    dem, 
    output, 
    drop=2.0, 
    out_type="tangent", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DownslopeIndex -v --wd="/path/to/data/" ^
--dem=pointer.tif -o=dsi.tif --drop=5.0 --out_type=distance 

8.7.6 DrainagePreservingSmoothing

Reduces short-scale variation in an input DEM while preserving breaks-in-slope and small drainage features using a modified Sun et al. (2007) algorithm..

Parameters:

Python function:

drainage_preserving_smoothing(
    dem, 
    output, 
    filter=11, 
    norm_diff=8.0, 
    num_iter=5, 
    reduction=80.0, 
    dfm=0.15, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DrainagePreservingSmoothing -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif --filter=15 ^
--norm_diff=20.0 --num_iter=4 --reduction=90.0 --dfm=0.15 

8.7.7 ElevAbovePit

Calculate the elevation of each grid cell above the nearest downstream pit cell or grid edge cell..

Parameters:

Python function:

elev_above_pit(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ElevAbovePit -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.7.8 ElevPercentile

Calculates the elevation percentile raster from a DEM..

Parameters:

Python function:

elev_percentile(
    dem, 
    output, 
    filterx=11, 
    filtery=11, 
    sig_digits=2, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ElevPercentile -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif --filter=25 

8.7.9 ElevRelativeToMinMax

Calculates the elevation of a location relative to the minimum and maximum elevations in a DEM..

Parameters:

Python function:

elev_relative_to_min_max(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ElevRelativeToMinMax -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.7.10 ElevRelativeToWatershedMinMax

Calculates the elevation of a location relative to the minimum and maximum elevations in a watershed..

Parameters:

Python function:

elev_relative_to_watershed_min_max(
    dem, 
    watersheds, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ElevRelativeToWatershedMinMax -v ^
--wd="/path/to/data/" --dem=DEM.tif --watersheds=watershed.tif ^
-o=output.tif 

8.7.11 FeaturePreservingDenoise

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

Parameters:

Python function:

feature_preserving_denoise(
    dem, 
    output, 
    filter=11, 
    norm_diff=8.0, 
    num_iter=5, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FeaturePreservingDenoise -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif --filter=15 ^
--norm_diff=20.0 --num_iter=4 

8.7.12 FetchAnalysis

Performs an analysis of fetch or upwind distance to an obstacle..

Parameters:

Python function:

fetch_analysis(
    dem, 
    output, 
    azimuth=0.0, 
    hgt_inc=0.05, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FetchAnalysis -v --wd="/path/to/data/" ^
-i='input.tif' -o=output.tif --azimuth=315.0 

8.7.13 FillMissingData

Fills nodata holes in a DEM..

Parameters:

Python function:

fill_missing_data(
    i, 
    output, 
    filter=11, 
    weight=2.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FillMissingData -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif --filter=25 ^
--weight=1.0 

8.7.14 FindRidges

Identifies potential ridge and peak grid cells..

Parameters:

Python function:

find_ridges(
    dem, 
    output, 
    line_thin=True, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FindRidges -v --wd="/path/to/data/" ^
--dem=pointer.tif -o=out.tif --line_thin 

8.7.15 Hillshade

Calculates a hillshade raster from an input DEM..

Parameters:

Python function:

hillshade(
    dem, 
    output, 
    azimuth=315.0, 
    altitude=30.0, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Hillshade -v --wd="/path/to/data/" ^
-i=DEM.tif -o=output.tif --azimuth=315.0 --altitude=30.0 

8.7.16 HorizonAngle

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

Parameters:

Python function:

horizon_angle(
    dem, 
    output, 
    azimuth=0.0, 
    max_dist=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=HorizonAngle -v --wd="/path/to/data/" ^
-i='input.tif' -o=output.tif --azimuth=315.0 

8.7.17 HypsometricAnalysis

Calculates a hypsometric curve for one or more DEMs..

Parameters:

Python function:

hypsometric_analysis(
    inputs, 
    output, 
    watershed=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=HypsometricAnalysis -v ^
--wd="/path/to/data/" -i="DEM1.tif;DEM2.tif" ^
--watershed="ws1.tif;ws2.tif" -o=outfile.html 

8.7.18 MaxAnisotropyDev

Calculates the maximum anisotropy (directionality) in elevation deviation over a range of spatial scales..

Parameters:

Python function:

max_anisotropy_dev(
    dem, 
    out_mag, 
    out_scale, 
    max_scale, 
    min_scale=3, 
    step=2, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxAnisotropyDev -v ^
--wd="/path/to/data/" --dem=DEM.tif --out_mag=DEVmax_mag.tif ^
--out_scale=DEVmax_scale.tif --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.19 MaxAnisotropyDevSignature

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

Parameters:

Python function:

max_anisotropy_dev_signature(
    dem, 
    points, 
    output, 
    max_scale, 
    min_scale=1, 
    step=1, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxAnisotropyDevSignature -v ^
--wd="/path/to/data/" --dem=DEM.tif --points=sites.shp ^
--output=roughness.html --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.20 MaxBranchLength

Lindsay and Seibert’s (2013) branch length index is used to map drainage divides or ridge lines..

Parameters:

Python function:

max_branch_length(
    dem, 
    output, 
    log=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxBranchLength -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.7.21 MaxDifferenceFromMean

Calculates the maximum difference from mean elevation over a range of spatial scales..

Parameters:

Python function:

max_difference_from_mean(
    dem, 
    out_mag, 
    out_scale, 
    min_scale, 
    max_scale, 
    step=1, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxDifferenceFromMean -v ^
--wd="/path/to/data/" --dem=DEM.tif --out_mag=DEVmax_mag.tif ^
--out_scale=DEVmax_scale.tif --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.22 MaxDownslopeElevChange

Calculates the maximum downslope change in elevation between a grid cell and its eight downslope neighbors..

Parameters:

Python function:

max_downslope_elev_change(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxDownslopeElevChange -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=out.tif 

8.7.23 MaxElevDevSignature

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

Parameters:

Python function:

max_elev_dev_signature(
    dem, 
    points, 
    output, 
    min_scale, 
    max_scale, 
    step=10, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxElevDevSignature -v ^
--wd="/path/to/data/" --dem=DEM.tif --points=sites.tif ^
--output=topo_position.html --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.24 MaxElevationDeviation

Calculates the maximum elevation deviation over a range of spatial scales..

Parameters:

Python function:

max_elevation_deviation(
    dem, 
    out_mag, 
    out_scale, 
    min_scale, 
    max_scale, 
    step=1, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxElevationDeviation -v ^
--wd="/path/to/data/" --dem=DEM.tif --out_mag=DEVmax_mag.tif ^
--out_scale=DEVmax_scale.tif --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.25 MinDownslopeElevChange

Calculates the minimum downslope change in elevation between a grid cell and its eight downslope neighbors..

Parameters:

Python function:

min_downslope_elev_change(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MinDownslopeElevChange -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=out.tif 

8.7.26 MultiscaleRoughness

Calculates surface roughness over a range of spatial scales..

Parameters:

Python function:

multiscale_roughness(
    dem, 
    out_mag, 
    out_scale, 
    max_scale, 
    min_scale=1, 
    step=1, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MultiscaleRoughness -v ^
--wd="/path/to/data/" --dem=DEM.tif --out_mag=roughness_mag.tif ^
--out_scale=roughness_scale.tif --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.27 MultiscaleRoughnessSignature

Calculates the surface roughness for points over a range of spatial scales..

Parameters:

Python function:

multiscale_roughness_signature(
    dem, 
    points, 
    output, 
    max_scale, 
    min_scale=1, 
    step=1, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MultiscaleRoughnessSignature -v ^
--wd="/path/to/data/" --dem=DEM.tif --points=sites.shp ^
--output=roughness.html --min_scale=1 --max_scale=1000 ^
--step=5 

8.7.28 MultiscaleTopographicPositionImage

Creates a multiscale topographic position image from three DEVmax rasters of differing spatial scale ranges..

Parameters:

Python function:

multiscale_topographic_position_image(
    local, 
    meso, 
    broad, 
    output, 
    lightness=1.2, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MultiscaleTopographicPositionImage -v ^
--wd="/path/to/data/" --local=DEV_local.tif --meso=DEV_meso.tif ^
--broad=DEV_broad.tif -o=output.tif --lightness=1.5 

8.7.29 NumDownslopeNeighbours

Calculates the number of downslope neighbours to each grid cell in a DEM..

Parameters:

Python function:

num_downslope_neighbours(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=NumDownslopeNeighbours -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.7.30 NumUpslopeNeighbours

Calculates the number of upslope neighbours to each grid cell in a DEM..

Parameters:

Python function:

num_upslope_neighbours(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=NumUpslopeNeighbours -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.7.31 PennockLandformClass

Classifies hillslope zones based on slope, profile curvature, and plan curvature..

Parameters:

Python function:

pennock_landform_class(
    dem, 
    output, 
    slope=3.0, 
    prof=0.1, 
    plan=0.0, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PennockLandformClass -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif --slope=3.0 ^
--prof=0.1 --plan=0.0 

8.7.32 PercentElevRange

Calculates percent of elevation range from a DEM..

Parameters:

Python function:

percent_elev_range(
    dem, 
    output, 
    filterx=3, 
    filtery=3, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PercentElevRange -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif --filter=25 

8.7.33 PlanCurvature

Calculates a plan (contour) curvature raster from an input DEM..

Parameters:

Python function:

plan_curvature(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=PlanCurvature -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.7.34 Profile

Plots profiles from digital surface models..

Parameters:

Python function:

profile(
    lines, 
    surface, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Profile -v --wd="/path/to/data/" ^
--lines=profile.shp --surface=dem.tif -o=profile.html 

8.7.35 ProfileCurvature

Calculates a profile curvature raster from an input DEM..

Parameters:

Python function:

profile_curvature(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ProfileCurvature -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.7.36 RelativeAspect

Calculates relative aspect (relative to a user-specified direction) from an input DEM..

Parameters:

Python function:

relative_aspect(
    dem, 
    output, 
    azimuth=0.0, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RelativeAspect -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif --azimuth=180.0 

8.7.37 RelativeStreamPowerIndex

Calculates the relative stream power index..

Parameters:

Python function:

relative_stream_power_index(
    sca, 
    slope, 
    output, 
    exponent=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RelativeStreamPowerIndex -v ^
--wd="/path/to/data/" --sca='flow_accum.tif' ^
--slope='slope.tif' -o=output.tif --exponent=1.1 

8.7.38 RelativeTopographicPosition

Calculates the relative topographic position index from a DEM..

Parameters:

Python function:

relative_topographic_position(
    dem, 
    output, 
    filterx=11, 
    filtery=11, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RelativeTopographicPosition -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--filter=25 

8.7.39 RemoveOffTerrainObjects

Removes off-terrain objects from a raster digital elevation model (DEM)..

Parameters:

Python function:

remove_off_terrain_objects(
    dem, 
    output, 
    filter=11, 
    slope=15.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RemoveOffTerrainObjects -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=bare_earth_DEM.tif ^
--filter=25 --slope=10.0 

8.7.40 RuggednessIndex

Calculates the Riley et al.’s (1999) terrain ruggedness index from an input DEM..

Parameters:

Python function:

ruggedness_index(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RuggednessIndex -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.7.41 SedimentTransportIndex

Calculates the sediment transport index..

Parameters:

Python function:

sediment_transport_index(
    sca, 
    slope, 
    output, 
    sca_exponent=0.4, 
    slope_exponent=1.3, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=SedimentTransportIndex -v ^
--wd="/path/to/data/" --sca='flow_accum.tif' ^
--slope='slope.tif' -o=output.tif --sca_exponent=0.5 ^
--slope_exponent=1.0 

8.7.42 Slope

Calculates a slope raster from an input DEM..

Parameters:

Python function:

slope(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Slope -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.7.43 SlopeVsElevationPlot

Creates a slope vs. elevation plot for one or more DEMs..

Parameters:

Python function:

slope_vs_elevation_plot(
    inputs, 
    output, 
    watershed=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=SlopeVsElevationPlot -v ^
--wd="/path/to/data/" -i="DEM1.tif;DEM2.tif" ^
--watershed="ws1.tif;ws2.tif" -o=outfile.html 

8.7.44 StandardDeviationOfSlope

Calculates the standard deviation of slope from an input DEM..

Parameters:

Python function:

standard_deviation_of_slope(
    i, 
    output, 
    zfactor=1.0, 
    filterx=11, 
    filtery=11, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=StandardDeviationOfSlope -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.7.45 TangentialCurvature

Calculates a tangential curvature raster from an input DEM..

Parameters:

Python function:

tangential_curvature(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=TangentialCurvature -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.7.46 TotalCurvature

Calculates a total curvature raster from an input DEM..

Parameters:

Python function:

total_curvature(
    dem, 
    output, 
    zfactor=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=TotalCurvature -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.7.47 Viewshed

Identifies the viewshed for a point or set of points..

Parameters:

Python function:

viewshed(
    dem, 
    stations, 
    output, 
    height=2.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Viewshed -v --wd="/path/to/data/" ^
--dem='dem.tif' --stations='stations.shp' -o=output.tif ^
--height=10.0 

8.7.48 VisibilityIndex

Estimates the relative visibility of sites in a DEM..

Parameters:

Python function:

visibility_index(
    dem, 
    output, 
    height=2.0, 
    res_factor=2, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=VisibilityIndex -v ^
--wd="/path/to/data/" --dem=dem.tif -o=output.tif ^
--height=10.0 --res_factor=4 

8.7.49 WetnessIndex

Calculates the topographic wetness index, Ln(A / tan(slope))..

Parameters:

Python function:

wetness_index(
    sca, 
    slope, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=WetnessIndex -v --wd="/path/to/data/" ^
--sca='flow_accum.tif' --slope='slope.tif' -o=output.tif 

8.8 Hydrological Analysis

8.8.1 AverageFlowpathSlope

Measures the average slope gradient from each grid cell to all upslope divide cells..

Parameters:

Python function:

average_flowpath_slope(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=AverageFlowpathSlope -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.8.2 AverageUpslopeFlowpathLength

Measures the average length of all upslope flowpaths draining each grid cell..

Parameters:

Python function:

average_upslope_flowpath_length(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=AverageUpslopeFlowpathLength -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.8.3 Basins

Identifies drainage basins that drain to the DEM edge..

Parameters:

Python function:

basins(
    d8_pntr, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Basins -v --wd="/path/to/data/" ^
--d8_pntr='d8pntr.tif' -o='output.tif' 

8.8.4 BreachDepressions

Breaches all of the depressions in a DEM using Lindsay’s (2016) algorithm. This should be preferred over depression filling in most cases..

Parameters:

Python function:

breach_depressions(
    dem, 
    output, 
    max_depth=None, 
    max_length=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=BreachDepressions -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.8.5 BreachSingleCellPits

Removes single-cell pits from an input DEM by breaching..

Parameters:

Python function:

breach_single_cell_pits(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=BreachSingleCellPits -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif 

8.8.6 D8FlowAccumulation

Calculates a D8 flow accumulation raster from an input DEM..

Parameters:

Python function:

d8_flow_accumulation(
    dem, 
    output, 
    out_type="specific contributing area", 
    log=False, 
    clip=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=D8FlowAccumulation -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.dtifep ^
--out_type='cells'
>>./whitebox_tools -r=D8FlowAccumulation -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--out_type='specific catchment area' --log --clip 

8.8.7 D8MassFlux

Performs a D8 mass flux calculation..

Parameters:

Python function:

d8_mass_flux(
    dem, 
    loading, 
    efficiency, 
    absorption, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=D8MassFlux -v --wd="/path/to/data/" ^
--dem=DEM.tif --loading=load.tif --efficiency=eff.tif ^
--absorption=abs.tif -o=output.tif 

8.8.8 D8Pointer

Calculates a D8 flow pointer raster from an input DEM..

Parameters:

Python function:

d8_pointer(
    dem, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=D8Pointer -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.8.9 DInfFlowAccumulation

Calculates a D-infinity flow accumulation raster from an input DEM..

Parameters:

Python function:

d_inf_flow_accumulation(
    dem, 
    output, 
    out_type="Specific Contributing Area", 
    threshold=None, 
    log=False, 
    clip=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DInfFlowAccumulation -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--out_type=sca
>>./whitebox_tools -r=DInfFlowAccumulation -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--out_type=sca --threshold=10000 --log --clip 

8.8.10 DInfMassFlux

Performs a D-infinity mass flux calculation..

Parameters:

Python function:

d_inf_mass_flux(
    dem, 
    loading, 
    efficiency, 
    absorption, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DInfMassFlux -v --wd="/path/to/data/" ^
--dem=DEM.tif --loading=load.tif --efficiency=eff.tif ^
--absorption=abs.tif -o=output.tif 

8.8.11 DInfPointer

Calculates a D-infinity flow pointer (flow direction) raster from an input DEM..

Parameters:

Python function:

d_inf_pointer(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DInfPointer -v --wd="/path/to/data/" ^
--dem=DEM.tif 

8.8.12 DepthInSink

Measures the depth of sinks (depressions) in a DEM..

Parameters:

Python function:

depth_in_sink(
    dem, 
    output, 
    zero_background=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DepthInSink -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif --zero_background 

8.8.13 DownslopeDistanceToStream

Measures distance to the nearest downslope stream cell..

Parameters:

Python function:

downslope_distance_to_stream(
    dem, 
    streams, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DownslopeDistanceToStream -v ^
--wd="/path/to/data/" --dem='dem.tif' --streams='streams.tif' ^
-o='output.tif' 

8.8.14 DownslopeFlowpathLength

Calculates the downslope flowpath length from each cell to basin outlet..

Parameters:

Python function:

downslope_flowpath_length(
    d8_pntr, 
    output, 
    watersheds=None, 
    weights=None, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DownslopeFlowpathLength -v ^
--wd="/path/to/data/" --d8_pntr=pointer.tif ^
-o=flowpath_len.tif
>>./whitebox_tools ^
-r=DownslopeFlowpathLength -v --wd="/path/to/data/" ^
--d8_pntr=pointer.tif --watersheds=basin.tif ^
--weights=weights.tif -o=flowpath_len.tif --esri_pntr 

8.8.15 ElevationAboveStream

Calculates the elevation of cells above the nearest downslope stream cell..

Parameters:

Python function:

elevation_above_stream(
    dem, 
    streams, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ElevationAboveStream -v ^
--wd="/path/to/data/" --dem='dem.tif' --streams='streams.tif' ^
-o='output.tif' 

8.8.16 ElevationAboveStreamEuclidean

Calculates the elevation of cells above the nearest (Euclidean distance) stream cell..

Parameters:

Python function:

elevation_above_stream_euclidean(
    dem, 
    streams, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ElevationAboveStreamEuclidean -v ^
--wd="/path/to/data/" -i=DEM.tif --streams=streams.tif ^
-o=output.tif 

8.8.17 Fd8FlowAccumulation

Calculates an FD8 flow accumulation raster from an input DEM..

Parameters:

Python function:

fd8_flow_accumulation(
    dem, 
    output, 
    out_type="specific contributing area", 
    exponent=1.1, 
    threshold=None, 
    log=False, 
    clip=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FD8FlowAccumulation -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--out_type='cells'
>>./whitebox_tools -r=FD8FlowAccumulation -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--out_type='catchment area' --exponent=1.5 --threshold=10000 ^
--log --clip 

8.8.18 Fd8Pointer

Calculates an FD8 flow pointer raster from an input DEM..

Parameters:

Python function:

fd8_pointer(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FD8Pointer -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.8.19 FillBurn

Burns streams into a DEM using the FillBurn (Saunders, 1999) method..

Parameters:

Python function:

fill_burn(
    dem, 
    streams, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FillBurn -v --wd="/path/to/data/" ^
--dem=DEM.tif --streams=streams.shp -o=dem_burned.tif 

8.8.20 FillDepressions

Fills all of the depressions in a DEM. Depression breaching should be preferred in most cases..

Parameters:

Python function:

fill_depressions(
    dem, 
    output, 
    fix_flats=True, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FillDepressions -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif ^
--fix_flats 

8.8.21 FillSingleCellPits

Raises pit cells to the elevation of their lowest neighbour..

Parameters:

Python function:

fill_single_cell_pits(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FillSingleCellPits -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=NewRaster.tif 

8.8.22 FindNoFlowCells

Finds grid cells with no downslope neighbours..

Parameters:

Python function:

find_no_flow_cells(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FindNoFlowCells -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=NewRaster.tif 

8.8.23 FindParallelFlow

Finds areas of parallel flow in D8 flow direction rasters..

Parameters:

Python function:

find_parallel_flow(
    d8_pntr, 
    streams, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FindParallelFlow -v ^
--wd="/path/to/data/" --d8_pntr=pointer.tif ^
-o=out.tif
>>./whitebox_tools -r=FindParallelFlow -v ^
--wd="/path/to/data/" --d8_pntr=pointer.tif -o=out.tif ^
--streams='streams.tif' 

8.8.24 FlattenLakes

Flattens lake polygons in a raster DEM..

Parameters:

Python function:

flatten_lakes(
    dem, 
    lakes, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FlattenLakes -v --wd="/path/to/data/" ^
--dem='DEM.tif' --lakes='lakes.shp' -o='output.tif' 

8.8.25 FloodOrder

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..

Parameters:

Python function:

flood_order(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FloodOrder -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.8.26 FlowAccumulationFullWorkflow

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

Parameters:

Python function:

flow_accumulation_full_workflow(
    dem, 
    out_dem, 
    out_pntr, 
    out_accum, 
    out_type="Specific Contributing Area", 
    log=False, 
    clip=False, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FlowAccumulationFullWorkflow -v ^
--wd="/path/to/data/" --dem='DEM.tif' ^
--out_dem='DEM_filled.tif' --out_pntr='pointer.tif' ^
--out_accum='accum.tif' --out_type=sca --log --clip 

8.8.27 FlowLengthDiff

Calculates the local maximum absolute difference in downslope flowpath length, useful in mapping drainage divides and ridges..

Parameters:

Python function:

flow_length_diff(
    d8_pntr, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FlowLengthDiff -v --wd="/path/to/data/" ^
--d8_pntr=pointer.tif -o=output.tif 

8.8.28 Hillslopes

Identifies the individual hillslopes draining to each link in a stream network..

Parameters:

Python function:

hillslopes(
    d8_pntr, 
    streams, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Hillslopes -v --wd="/path/to/data/" ^
--d8_pntr='d8pntr.tif' --streams='streams.tif' ^
-o='output.tif' 

8.8.29 ImpoundmentIndex

Calculates the impoundment size resulting from damming a DEM..

Parameters:

Python function:

impoundment_index(
    dem, 
    output, 
    damlength, 
    out_type="depth", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ImpoundmentIndex -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=out.tif ^
--out_type=depth --damlength=11 

8.8.30 Isobasins

Divides a landscape into nearly equal sized drainage basins (i.e. watersheds)..

Parameters:

Python function:

isobasins(
    dem, 
    output, 
    size, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Isobasins -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif --size=1000 

8.8.31 JensonSnapPourPoints

Moves outlet points used to specify points of interest in a watershedding operation to the nearest stream cell..

Parameters:

Python function:

jenson_snap_pour_points(
    pour_pts, 
    streams, 
    output, 
    snap_dist, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=JensonSnapPourPoints -v ^
--wd="/path/to/data/" --pour_pts='pour_pts.shp' ^
--streams='streams.tif' -o='output.shp' --snap_dist=15.0 

8.8.32 MaxUpslopeFlowpathLength

Measures the maximum length of all upslope flowpaths draining each grid cell..

Parameters:

Python function:

max_upslope_flowpath_length(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=MaxUpslopeFlowpathLength -v ^
--wd="/path/to/data/" -i=DEM.tif ^
-o=output.tif
>>./whitebox_tools -r=MaxUpslopeFlowpathLength -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=output.tif --log ^
--clip 

8.8.33 NumInflowingNeighbours

Computes the number of inflowing neighbours to each cell in an input DEM based on the D8 algorithm..

Parameters:

Python function:

num_inflowing_neighbours(
    dem, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=NumInflowingNeighbours -v ^
--wd="/path/to/data/" -i=DEM.tif -o=output.tif 

8.8.34 RaiseWalls

Raises walls in a DEM along a line or around a polygon, e.g. a watershed..

Parameters:

Python function:

raise_walls(
    i, 
    dem, 
    output, 
    breach=None, 
    height=100.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RaiseWalls -v --wd="/path/to/data/" ^
-i=watershed.shp --dem=dem.tif -o=output.tif ^
--height=25.0
>>./whitebox_tools -r=RaiseWalls -v ^
--wd="/path/to/data/" -i=watershed.shp --breach=outlet.shp ^
--dem=dem.tif -o=output.tif --height=25.0 

8.8.35 Rho8Pointer

Calculates a stochastic Rho8 flow pointer raster from an input DEM..

Parameters:

Python function:

rho8_pointer(
    dem, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Rho8Pointer -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif 

8.8.36 Sink

Identifies the depressions in a DEM, giving each feature a unique identifier..

Parameters:

Python function:

sink(
    dem, 
    output, 
    zero_background=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Sink -v --wd="/path/to/data/" ^
--dem=DEM.tif -o=output.tif --zero_background 

8.8.37 SnapPourPoints

Moves outlet points used to specify points of interest in a watershedding operation to the cell with the highest flow accumulation in its neighbourhood..

Parameters:

Python function:

snap_pour_points(
    pour_pts, 
    flow_accum, 
    output, 
    snap_dist, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=SnapPourPoints -v --wd="/path/to/data/" ^
--pour_pts='pour_pts.shp' --flow_accum='d8accum.tif' ^
-o='output.shp' --snap_dist=15.0 

8.8.38 StochasticDepressionAnalysis

Preforms a stochastic analysis of depressions within a DEM..

Parameters:

Python function:

stochastic_depression_analysis(
    dem, 
    output, 
    rmse, 
    range, 
    iterations=1000, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=StochasticDepressionAnalysis -v ^
--wd="/path/to/data/" --dem=DEM.tif -o=out.tif --rmse=10.0 ^
--range=850.0 --iterations=2500 

8.8.39 StrahlerOrderBasins

Identifies Strahler-order basins from an input stream network..

Parameters:

Python function:

strahler_order_basins(
    d8_pntr, 
    streams, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=StrahlerOrderBasins -v ^
--wd="/path/to/data/" --d8_pntr='d8pntr.tif' ^
--streams='streams.tif' -o='output.tif' 

8.8.40 Subbasins

Identifies the catchments, or sub-basin, draining to each link in a stream network..

Parameters:

Python function:

subbasins(
    d8_pntr, 
    streams, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Subbasins -v --wd="/path/to/data/" ^
--d8_pntr='d8pntr.tif' --streams='streams.tif' ^
-o='output.tif' 

8.8.41 TraceDownslopeFlowpaths

Traces downslope flowpaths from one or more target sites (i.e. seed points)..

Parameters:

Python function:

trace_downslope_flowpaths(
    seed_pts, 
    d8_pntr, 
    output, 
    esri_pntr=False, 
    zero_background=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=TraceDownslopeFlowpaths -v ^
--wd="/path/to/data/" --seed_pts=seeds.shp ^
--flow_dir=flow_directions.tif --output=flow_paths.tif 

8.8.42 UnnestBasins

Extract whole watersheds for a set of outlet points..

Parameters:

Python function:

unnest_basins(
    d8_pntr, 
    pour_pts, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=UnnestBasins -v --wd="/path/to/data/" ^
--d8_pntr='d8pntr.tif' --pour_pts='pour_pts.shp' ^
-o='output.tif' 

8.8.43 Watershed

Identifies the watershed, or drainage basin, draining to a set of target cells..

Parameters:

Python function:

watershed(
    d8_pntr, 
    pour_pts, 
    output, 
    esri_pntr=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Watershed -v --wd="/path/to/data/" ^
--d8_pntr='d8pntr.tif' --pour_pts='pour_pts.shp' ^
-o='output.tif' 

8.9 Image Processing Tools

8.9.1 ChangeVectorAnalysis

Performs a change vector analysis on a two-date multi-spectral dataset..

Parameters:

Python function:

change_vector_analysis(
    date1, 
    date2, 
    magnitude, 
    direction, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ChangeVectorAnalysis -v ^
--wd="/path/to/data/" ^
--date1='d1_band1.tif;d1_band2.tif;d1_band3.tif' ^
--date2='d2_band1.tif;d2_band2.tif;d2_band3.tif' ^
--magnitude=mag_out.tif --direction=dir_out.tif 

8.9.2 Closing

A closing is a mathematical morphology operating involving an erosion (min filter) of a dilation (max filter) set..

Parameters:

Python function:

closing(
    i, 
    output, 
    filterx=11, 
    filtery=11, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Closing -v --wd="/path/to/data/" ^
-i=image.tif -o=output.tif --filter=25 

8.9.3 CreateColourComposite

Creates a colour-composite image from three bands of multispectral imagery..

Parameters:

Python function:

create_colour_composite(
    red, 
    green, 
    blue, 
    output, 
    opacity=None, 
    enhance=True, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CreateColourComposite -v ^
--wd="/path/to/data/" --red=band3.tif --green=band2.tif ^
--blue=band1.tif -o=output.tif
>>./whitebox_tools ^
-r=CreateColourComposite -v --wd="/path/to/data/" ^
--red=band3.tif --green=band2.tif --blue=band1.tif ^
--opacity=a.tif -o=output.tif 

8.9.4 FlipImage

Reflects an image in the vertical or horizontal axis..

Parameters:

Python function:

flip_image(
    i, 
    output, 
    direction="vertical", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=FlipImage -v --wd="/path/to/data/" ^
--input=in.tif -o=out.tif --direction=h 

8.9.5 IhsToRgb

Converts intensity, hue, and saturation (IHS) images into red, green, and blue (RGB) images..

Parameters:

Python function:

ihs_to_rgb(
    intensity, 
    hue, 
    saturation, 
    red=None, 
    green=None, 
    blue=None, 
    output=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=IhsToRgb -v --wd="/path/to/data/" ^
--intensity=intensity.tif --hue=hue.tif ^
--saturation=saturation.tif --red=band3.tif --green=band2.tif ^
--blue=band1.tif
>>./whitebox_tools -r=IhsToRgb -v ^
--wd="/path/to/data/" --intensity=intensity.tif --hue=hue.tif ^
--saturation=saturation.tif --composite=image.tif 

8.9.6 ImageStackProfile

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

Parameters:

Python function:

image_stack_profile(
    inputs, 
    points, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ImageStackProfile -v ^
--wd="/path/to/data/" -i='image1.tif;image2.tif;image3.tif' ^
--points=pts.shp -o=output.html 

8.9.7 IntegralImage

Transforms an input image (summed area table) into its integral image equivalent..

Parameters:

Python function:

integral_image(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=IntegralImage -v --wd="/path/to/data/" ^
-i=image.tif -o=output.tif 

8.9.8 KMeansClustering

Performs a k-means clustering operation on a multi-spectral dataset..

Parameters:

Python function:

k_means_clustering(
    inputs, 
    output, 
    classes, 
    out_html=None, 
    max_iterations=10, 
    class_change=2.0, 
    initialize="diagonal", 
    min_class_size=10, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=KMeansClustering -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
-o=output.tif --out_html=report.html --classes=15 ^
--max_iterations=25 --class_change=1.5 --initialize='random' ^
--min_class_size=500 

8.9.9 LineThinning

Performs line thinning a on Boolean raster image; intended to be used with the RemoveSpurs tool..

Parameters:

Python function:

line_thinning(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=LineThinning -v --wd="/path/to/data/" ^
--input=DEM.tif -o=output.tif 

8.9.10 ModifiedKMeansClustering

Performs a modified k-means clustering operation on a multi-spectral dataset..

Parameters:

Python function:

modified_k_means_clustering(
    inputs, 
    output, 
    out_html=None, 
    start_clusters=1000, 
    merger_dist=None, 
    max_iterations=10, 
    class_change=2.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ModifiedKMeansClustering -v ^
--wd='/path/to/data/' -i='image1.tif;image2.tif;image3.tif' ^
-o=output.tif --out_html=report.html --start_clusters=100 ^
--merger_dist=30.0 --max_iterations=25 --class_change=1.5 

8.9.11 Mosaic

Mosaics two or more images together..

Parameters:

Python function:

mosaic(
    inputs, 
    output, 
    method="cc", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Mosaic -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' -o=dest.tif ^
--method='cc 

8.9.12 NormalizedDifferenceVegetationIndex

Calculates the normalized difference vegetation index (NDVI) from near-infrared and red imagery..

Parameters:

Python function:

normalized_difference_vegetation_index(
    nir, 
    red, 
    output, 
    clip=0.0, 
    osavi=False, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=NormalizedDifferenceVegetationIndex -v ^
--wd="/path/to/data/" --nir=band4.tif --red=band3.tif ^
-o=output.tif
>>./whitebox_tools ^
-r=NormalizedDifferenceVegetationIndex -v --wd="/path/to/data/" ^
--nir=band4.tif --red=band3.tif -o=output.tif --clip=1.0 ^
--osavi 

8.9.13 Opening

An opening is a mathematical morphology operating involving a dilation (max filter) of an erosion (min filter) set..

Parameters:

Python function:

opening(
    i, 
    output, 
    filterx=11, 
    filtery=11, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Opening -v --wd="/path/to/data/" ^
-i=image.tif -o=output.tif --filter=25 

8.9.14 RemoveSpurs

Removes the spurs (pruning operation) from a Boolean line image.; intended to be used on the output of the LineThinning tool..

Parameters:

Python function:

remove_spurs(
    i, 
    output, 
    iterations=10, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RemoveSpurs -v --wd="/path/to/data/" ^
--input=DEM.tif -o=output.tif --iterations=10 

8.9.15 Resample

Resamples one or more input images into a destination image..

Parameters:

Python function:

resample(
    inputs, 
    destination, 
    method="cc", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=Resample -v --wd='/path/to/data/' ^
-i='image1.tif;image2.tif;image3.tif' --destination=dest.tif ^
--method='cc 

8.9.16 RgbToIhs

Converts red, green, and blue (RGB) images into intensity, hue, and saturation (IHS) images..

Parameters:

Python function:

rgb_to_ihs(
    intensity, 
    hue, 
    saturation, 
    red=None, 
    green=None, 
    blue=None, 
    composite=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=RgbToIhs -v --wd="/path/to/data/" ^
--red=band3.tif --green=band2.tif --blue=band1.tif ^
--intensity=intensity.tif --hue=hue.tif ^
--saturation=saturation.tif
>>./whitebox_tools -r=RgbToIhs -v ^
--wd="/path/to/data/" --composite=image.tif ^
--intensity=intensity.tif --hue=hue.tif ^
--saturation=saturation.tif 

8.9.17 SplitColourComposite

This tool splits an RGB colour composite image into seperate multispectral images..

Parameters:

Python function:

split_colour_composite(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=SplitColourComposite -v ^
--wd="/path/to/data/" -i=input.tif -o=output.tif 

8.9.18 ThickenRasterLine

Thickens single-cell wide lines within a raster image..

Parameters:

Python function:

thicken_raster_line(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ThickenRasterLine -v ^
--wd="/path/to/data/" --input=DEM.tif -o=output.tif 

8.9.19 TophatTransform

Performs either a white or black top-hat transform on an input image..

Parameters:

Python function:

tophat_transform(
    i, 
    output, 
    filterx=11, 
    filtery=11, 
    variant="white", 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=TophatTransform -v ^
--wd="/path/to/data/" -i=image.tif -o=output.tif --filter=25 

8.9.20 WriteFunctionMemoryInsertion

Performs a write function memory insertion for single-band multi-date change detection..

Parameters:

Python function:

write_function_memory_insertion(
    input1, 
    input2, 
    output, 
    input3=None, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=WriteFunctionMemoryInsertion -v ^
--wd="/path/to/data/" -i1=input1.tif -i2=input2.tif ^
-o=output.tif 

8.10 Image Processing Tools => Filters

8.10.1 AdaptiveFilter

Performs an adaptive filter on an image..

Parameters:

Python function:

adaptive_filter(
    i, 
    output, 
    filterx=11, 
    filtery=11, 
    threshold=2.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=AdaptiveFilter -v --wd="/path/to/data/" ^
-i=DEM.tif -o=output.tif --filter=25 --threshold = 2.0 

8.10.2 BilateralFilter

A bilateral filter is an edge-preserving smoothing filter introduced by Tomasi and Manduchi (1998)..

Parameters:

Python function:

bilateral_filter(
    i, 
    output, 
    sigma_dist=0.75, 
    sigma_int=1.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=BilateralFilter -v ^
--wd="/path/to/data/" -i=image.tif -o=output.tif ^
--sigma_dist=2.5 --sigma_int=4.0 

8.10.3 ConservativeSmoothingFilter

Performs a conservative-smoothing filter on an image..

Parameters:

Python function:

conservative_smoothing_filter(
    i, 
    output, 
    filterx=3, 
    filtery=3, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=ConservativeSmoothingFilter -v ^
--wd="/path/to/data/" -i=image.tif -o=output.tif --filter=25 

8.10.4 CornerDetection

Identifies corner patterns in boolean images using hit-and-miss pattern mattching..

Parameters:

Python function:

corner_detection(
    i, 
    output, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=CornerDetection -v ^
--wd="/path/to/data/" -i=image.tif -o=output.tif --sigma=2.0 

8.10.5 DiffOfGaussianFilter

Performs a Difference of Gaussian (DoG) filter on an image..

Parameters:

Python function:

diff_of_gaussian_filter(
    i, 
    output, 
    sigma1=2.0, 
    sigma2=4.0, 
    callback=default_callback)

Command-line Interface:

>>./whitebox_tools -r=DiffOfGaussianFilter -v ^
--wd="/path/to/data/" -i=image.tif -o=output.tif --sigma1=2.0 ^
--sigma2=4.0 

8.10.6 DiversityFilter

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..

Parameters: