EnMAP-Box 3 Documentation¶

The EnMAP-Box is a python plugin for QGIS, designed to process and visualise hyperspectral remote sensing data.

Get going with the Installation and the Getting Started chapter. Have a look at the Cookbook for usage examples!

Key features¶

Extend your QGIS for remote sensing image analysis
Add powerful tools to process and analyse imaging spectroscopy data
Integrate machine learning algorithms into your image classification and regression with Random Forests, Support Vector Machines and many more
Create and manage spectral libraries with attribute data
Develop your own image processing algorithms using a powerful Python API

News¶

EnMAP-Box Version 3.10 released¶

June 09, 2022

A new EnMAP-Box version has been released. A list of all improvements can be found in the changelog.

EnMAP-Box Version 3.9 released¶

Oct. 10, 2021

A new EnMAP-Box version has been released. A list of all improvements can be found in the changelog.

EnMAP-Box Workshop 2021¶

Jun, 07, 2021

The next EnMAP-Box workshop will be held online on 21-23 June, 2021. The workshop aims to demonstrate the current state of the EnMAP-Box by way of presentations, live demos with Q&A and self-paced tutorials. Registration for up to 250 participants is now open at the workshop website.

FOSSGIS 2021¶

Jun 09, 2021

Benjamin Jakimow presented how to use Spectral Libraries in QGIS using the EnMAP-Box (german).

EnMAP-Box Version 3.7 released¶

Oct. 27, 2020

A new EnMAP-Box version has been released. It includes product readers for EnMAP L1B, L2C and L2A, PRISMA L2D and DESIS L2A images, and a first version of Spectral Math in the QGIS Expression Builder. A list of all improvements can be found in the changelog.

FOSSGIS 2020¶

Andreas Rabe presented the EnMAP-Box at the FOSSGIS 2020 in Freiburg. See the full live-demo session here (german):

QGIS User Conference 2019¶

Two Presentations by EnMAP-Box developers Andreas Rabe and Benjamin Jakimow at the QGIS User conference in Coruña

About¶

The EnMAP-Box is a free and open source plugin for QGIS. It is designed to process imaging spectroscopy data and particularly developed to handle data from the upcoming EnMAP sensor. The two main goals of the development are to provide (i) state-of-the-art applications for the processing of high dimensional spectral and temporal remote sensing data and (ii) a graphical user interface (GUI) that enhances the GIS oriented visualization capabilities in QGIS by applications for visualization and exploration of multi-band remote sensing data and spectral libraries. Therefore, the algorithms provided in the EnMAP-Box will be of high value for many other, especially multi- and hyperspectral EO missions.

The EnMAP-Box plugin bridges and combines efficiently all advantages of QGIS (e.g. for visualization, vector data processing), packages like GDAL (for data IO or working with virtual raster files) and abundant libraries for Python (e.g. scikit-learn for EO data classification and PyQtGraph for fast and interactive chart drawing). The plugin consists of a (i) graphical user interface for hyperspectral data visualization and e.g. spectral library management, (ii) a set of algorithms, and (iii) a high-level application programming interface (EnMAP API).

The EnMAP-Box is developed at Humboldt-Universität zu Berlin and Universität Greifswald under contract by the Helmholtz Centre Potsdam GFZ and is part of the EnMAP Core Science Team activities. It is funded by the German Aerospace Centre (DLR) - Project Management Agency, granted by the Federal Ministry of Economic Affairs and Energy (BMWi; grant no. 50EE1923).

FAQ & Troubleshooting¶

Bug report & feedback¶

Note

Your feedback is more than welcome! In case you encounter any problems with the EnMAP-Box or have suggestions of any kind for improving it (or this documentation), please let us know!

Please report issues (bugs, suggestions etc.) via our issue tracker.

Contact¶

E-Mail: enmapbox@enmap.org

Newsletter: Subscribe to the EnMAP mailing list to be informed about new EnMAP-Box releases and other EnMAP related news at www.enmap.org/contact

FAQ¶

This is a list of Frequently Asked Questions about the EnMAP-Box. Feel free to suggest new entries!

How to cite the EnMAP-Box?

Please cite the EnMAP-Box as:

EnMAP-Box Developers (2019): EnMAP-Box 3 - A QGIS Plugin to process and visualize
hyperspectral remote sensing data. https://enmap-box.readthedocs.io

BibTeX:

@misc{enmapbox2019,
author = {EnMAP-Box Developers},
title = {EnMAP-Box 3 - A QGIS Plugin to process and visualize hyperspectral remote sensing data},
year = 2019,
url = {https://enmap-box.readthedocs.io}
}

For the general idea behind the EnMAP-Box please refer to:

van der Linden, S., Rabe, A., Held, M., Jakimow, B., Leitão, P., Okujeni, A., Schwieder, M.,
Suess, S., Hostert, P., 2015. The EnMAP-Box—A Toolbox and Application Programming Interface
for EnMAP Data Processing. Remote Sensing 7,
11249–11266. 10.3390/rs70911249.

How to install QGIS without administrative rights?

Yes, it is possible to install and run QGIS (and the EnMAP-Box) without admin rights. You just need to download and install Conda, where you can install QGIS as described here.

Installation: no module named pip

In case you run into problems during installation because pip is not available in your python environment (error message C:/.../python3.exe: No module named pip or similar), follow these steps (Windows):

Start the OSGeo4W installer from the OSGeo4W Shell by calling
```
setup
```
which will open the OSGeo4W Setup dialog.

Now navigate through the first pages of the dialog, by selecting the following settings:
- Advanced Installation Next
- Installation from Internet Next
- default OSGeo4W root directory Next
- local temp directory Next
- direct connection Next
- Select downloadsite http://download.osgeo.ogr Next
Then use the textbox to filter, select and install the following packages (see video below for help):
- python3-pip
- python3-setuptools
Click on the symbol once, which should usually change the Skip setting to installing the most recent version. Only AFTER having selected both packages, click Next.

Demonstration of package selection in the Setup
Click Finish when the installation is done.

Python package installation with requirements.txt does not work

Usually, all dependencies can be installed with one line:
```
python3 -m pip install -r https://bitbucket.org/hu-geomatics/enmap-box/raw/develop/requirements.txt
```
If the method above did not work for some reason, try installing the packages listed in the requirements.txt line by line, e.g. python3 -m pip install numpy and so on.

Installation: error ensomap / numba / TypeError jitdebug

EnSoMAP requires Numba, a JIT compiler that translates python code into fast machine code. Unfortunately, Numba is not part of a standard QGIS installation. Installing it afterwards can be tricky, in particular on the standard Windows and macOS QGIS installations. If you want to use EnSoMAP and numba, we therefore recommend to use a QGIS that was installed with Conda instead.
1. Install conda and create a conda environment with QGIS as described here.
2. Install Numba
```
(qgis_stable) $>conda install numba --channel=conda-forge
```
3. Start the conda QGIS by:
```
(qgis_stable) $>qgis
```
4. If not already done, install the EnMAP-Box to your Conda-QGIS with the QGIS Plugin Manager.

Image Cube tool missing qtopengl / Missing OpenGL / QtOpenGL packages

On some systems we experiences problems related to a missing OpenGL support (e.g Issue #299)
1. Ensure that you have installed OpenGL drivers that support your graphic card
2. Ensure that PyOpenGL is installed:: $ python3 -m pip install PyOpenGL
On Linux, it might be necessary to install the Python bindings for QtOpenGL in order to start the Image Cube tool.
```
sudo apt-get install python3-pyqt5.qtopengl
```

Error loading the plugin

In case of missing requirements you should see an error message like this

In that case please make sure you installed all missing packages, in this example pyqtgraph and sklearn are missing.

Exception: Unable to find full path for “dockpanel.ui”. Make its directory known to UI_DIRECTORIES

It’s likely that an update of the EnMAP-Box plugin failed to remove a previous version properly. The following workaround might help:
1. Navigate into the active QGIS profile folder. It can be opened via Settings > User Profiles > Open Active Profile Folder
2. Close QGIS. This is necessary to avoid any file handles on files or folders of the EnMAP-Box plugin.
3. Delete the EnMAP-Box plugin folder manually, e.g. default/python/plugins/enmapboxplugin if the active QGIS profile is ‘default’.
4. Restart QGIS and install the most-recent EnMAP-Box version This description was taken from https://bitbucket.org/hu-geomatics/enmap-box/issues/304/exception-unable-to-find-full-path-for

Known Issues¶

Here is a list of known issues, that aren’t fixed easily, and/or only affect a specific version of QGIS or operating system:

https://bitbucket.org/hu-geomatics/enmap-box/issues?component=known+issue&status=on+hold

How to contribute¶

The EnMAP-Box is a freely available, platform-independent software designed to process hyperspectral remote sensing data, and particularly developed to handle data from the EnMAP sensor.

The EnMAP-Box source code is hosted in a public git repository at https://bitbucket.org/hu-geomatics/enmap-box.

Approved QGIS plugin versions (“production releases”) are available in the QGIS Plugin Repository https://plugins.qgis.org/plugins/enmapboxplugin/.

The development of the EnMAP-Box is funded within the EnMAP scientific preparation program under the DLR Space Administration (mission lead) and GFZ Potsdam (scientific lead) with resources from the German Federal Ministry for Economic Affairs and Energy.

Everyone is welcome to contribute to the EnMAP-Box

Submit a bug report or feature request¶

In case you experience issues with the EnMAP-Box, do not hesitate to submit a ticket to our Issue Tracker. You are also welcome to post feature requests or pull requests.

It is recommended to check that your issue complies with the following rules before submitting:

Verify that your issue is not being currently addressed by other issues or pull requests.
If you are submitting a bug report, please:
- Report a short description how to reproduce it
- If an exception is raised, please provide the full traceback.
- If necessary, provide a link to the data that causes the bug
- If not feasible to include a reproducible snippet, please be specific about what part of the EnMAP-Box (functions, widget) are involved and the shape of the data
- Include your operating system type and version number of QGIS, Qt and the EnMAP-Box.
- Please ensure that code snippets and error messages are formatted in appropriate code blocks.
Note

You can use this Markdown syntax to style your issues.

Provide source code¶

If your are not an EnMAP-Box core developer, the preferred way to contribute your code code is to use pull requests.

Fork the EnMAP-Box repository
Clone your fork
Modify the source code
Commit your modifications
Push your modification to your fork and
Create a pull request

1. Create a fork on Bitbucket¶

Forking the EnMAP-box repository allows you to modify the EnMAP-Box code as you like and backup your contributions in a separated Bitbucket repository. To create a fork,

log in to bitbucket.org and visit https://bitbucket.org/hu-geomatics/enmap-box
Click ‘+’ and Fork this repository
Select a name and workspace for your EnMAP-Box fork, hereafter called enmap-box-fork

Create an EnMAP-Box fork in bitbucket.org

Please read https://confluence.atlassian.com/bitbucket/forking-a-repository-221449527.html for details how you can create your own fork of the EnMAP-Box repository.

Please note that forking in bitbucket.org does not copy git lfs tracked files: https://support.atlassian.com/bitbucket-cloud/docs/current-limitations-for-git-lfs-with-bitbucket/#Git-LFS-files-are-not-copied-when-a-repo-is-forked

2. Clone the forked EnMAP-Box repository¶

Clone enmap-box-fork to your local disk:

git clone git@bitbucket.com/myusername/enmap-box-fork.git -n

You might see some git lfs errors. Ignore them.

Go into the repository folder and force to checkout the develop branch.

cd enmap-box-fork git checkout develop -f

You can ignore smuge errors. Add the EnMAP-Box repository as upstream repository:

git remote add upstream https://bitbucket.org/hu-geomatics/enmap-box

Now fetch git lfs files from the upstream directory:

git lfs fetch upstream

Note

From now on, you can synchronize your fork with the EnMAP-Box repository by:

$git fetch upstream develop
$git merge upstream/develop

to get the latest updates from the develop branch. Call:

$git push

to upload them to the remote bitbucket.com/myusername/enmap-box-fork.git

Now install python requirements and run the initial setup for the EnMAP-Box repository, as described in Installation

3. Modify the local repository¶

As you like, you can continue modifying the EnMAP-Box code in the develop branch or create a new one ‘my_modifications’:

$ git checkout -b my_modifications

4. Commit your changes¶

Save your changes by committing them to your local repository:

$ git add modified_files
$ git commit -a -m 'added x, modified y and fixed z' -s

Please use signed commits to label your individual contribution visible. Even better, use GnuPG-signed commits (-S).

5. Push changes back to your fork¶

A push will upload your changes to bitbucket.com/myusername/enmap-box-fork.git:

$ git push

6. Create a pull request¶

Open the Bitbucket webpage of your fork and create a pull request. The pull request will inform us on the changed you made.

Before you create a pull request, please check the following:

make sure that every source code file provides a licence notice
make sure your code passes the tests and provide tests if your like to provide new functionality, like EnMAP-Box Applications
make sure your code is commented and documented
make sure your name is listed in the CONTRIBUTORS.md
update your feature branch to the current EnMAP-Box develop branch:
```
git fetch upstream develop
git merge upstream/develop
```
rebase your changes and push them to your forked repository:
```
git push -f
```
describe your pull request with a helpful title, e.g using the following labels:
- [feature] <title> a new feature
- [fix] <title> a fix for a known issue. If possible, please refer to existing issue numbers like in #123 #124.

Documentation¶

The EnMAP-Box documentation is based on Sphinx-build reStructured text and hosted at https://enmap-box.readthedocs.io .

The documentation source code, i.e. *.rst files, are hosted in the /source folder in https://github.com/EnMAP-Box/enmap-box-documentation

Please read https://github.com/EnMAP-Box/enmap-box-documentation#readme for how you can contribute to the EnMAP-Box documentation repository.

Licensing¶

The software produced for the EnMAP-Box is licensed according to the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License (SPDX short identifier: GPL-3.0), or (if desired) any later version. See either https://www.gnu.org/licenses/gpl-3.0.en.html or https://opensource.org/licenses/GPL-3.0 for further details of the license.

A copy of this license is part of the EnMAP-Box repository (LICENSE.txt) and delivered with each release of an EnMAP-Box plugin.

The EnMAP-Box documentation is published under the terms of the Creative Commons 1.0 Universal (CC0) License. See https://creativecommons.org/publicdomain/zero/1.0/legalcode for further details of the license.

Applying License Terms¶

Each source code contribution to the central repository should include a reference to the GPL-3 license terms at the beginning of the file:

"""
***************************************************************************
    <file name> - <short description>
    -----------------------------------------------------------------------
    begin                : <month and year of creation>
    copyright            : (C) <year> <creator>
    email                : <main address>

***************************************************************************
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
                                                                                                                                                 *
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this software. If not, see <http://www.gnu.org/licenses/>.
***************************************************************************
"""

An example from the source code can be found here: enmapbox/__init__.py

Images and other multimedia content from the EnMAP-Box documentation, i.e files within the EnMAP-Box repositories doc/source folder, are published under the terms of the CC0 license.

Contributor License Agreements (CLA)¶

The purpose of CLAs are to clearly define the terms under which intellectual property has been contributed to the EnMap-Box and thereby allow us to defend the project should there be a legal dispute regarding the software at some future time.

Individual Contributor License Agreement (ICLA)¶

The EnMap-Box Consortium desires that all maintainers and contributors of ideas, code, or documentation to the EnMAP-Box project complete, sign, and submit an ICLA.

A signed ICLA is required to be on file before an individual is given commit rights to the EnMap-Box repository. The ICLA form for filling and signing is available here.

The ICLA is not tied to any employer, so it is recommended to use one’s personal information, e.g. for email address in the contact details, rather than an email address provided by an employer.

Corporate Contributor License Agreement (CCLA)¶

For a corporation that has assigned employees to work on the EnMap-Box, a CCLA is available for contributing intellectual property via the corporation, that may have been assigned as part of an employment agreement.

Note that a CCLA does not remove the need for every developer to sign their own ICLA as an individual, which covers both contributions which are owned and those that are not owned by the corporation signing the CCLA.

The CCLA legally binds the corporation, so it must be signed by a person with authority to enter into legal contracts on behalf of the corporation. The CCLA form for filling and signing is available here.

Submitting License Agreements¶

Documents may be submitted by email and signed by hand or by electronic signature. The files should be named icla.pdf and icla.pdf.asc for individual agreements; ccla.pdf and ccla.pdf.asc for corporate agreements. Zip files, other archives, or links to files are not accepted. The files must be attached to the mail.

When submitting by email, please fill the form with a pdf viewer, then print, sign, scan all pages into a single pdf file, and attach the pdf file to an email to enmapbox@enmap.org. If possible, send the attachment from the email address in the document. Please send only one document per email.

If you prefer to sign electronically, please fill the form, save it locally (e.g. icla.pdf), and sign the file by preparing a detached PGP signature. For example, gpg –armor –detach-sign icla.pdf

The above will create a file icla.pdf.asc. Send both the file (icla.pdf) and signature (icla.pdf.asc) as attachments in the same email. Please send only one document (file plus signature) per email. Please do not submit your public key. Instead, please upload your public key to pgpkeys.mit.edu.

Developer Certificate of Origin (DCO)¶

Contributors who have not signed an ICLA are in a somewhat fuzzy spot. If they make a large contribution, or many contributions, then the EnMap-Box maintainers will likely ask to submit an ICLA. However, for small fixes, infrequent and other minimal or sporadic contributions the terms for licensing and intellectual property still must be clarified.

For this purpose, barriers for contributing are minimized and contributors pinky swear that they’re submitting their own work or rather certify that they adhere to the requirements of the DCO defined in version 1.1 or later at https://developercertificate.org/ by signing-off their pull requests or similar ways of contributing.

The DCO is very Git-centric, and it only relies on commit metadata.

Indeed, signing-off a commit is just about appending a Signed-off-by. For example a commit like:

$ git commit -m 'Fixes issue XYZ' -s

will create a commit message as in:

commit b2c150d3aa82f6583b9aadfecc5f8fa1c74aca09
Fixes issue XYZ
Signed-off-by: Erwin Gerwin <erwin.gerwin@streetcat.com>

Even this approach introduces a low barrier for contributions, it is very easy to use whatever email address you want for a commit, and the sign-off is just text. Since the issue of trust is important the use of GnuPG signatures in Git commits is recommended additionally, e.g. with:

$ git commit -s -S (makes GnuPG-signed commits, and)
$ git log --show-signature (shows GnuPG signatures in the log history)
$ git merge --verify-signatures branch (ensures that all commits are signed and valid before performing a merge)

Having to use GnuPG for all commits can be a bit daunting.

Tests and Continuous Integration¶

Please provide some tests that show if your source code works right. Unit tests should be located in the repositories enmapboxtesting folder.

To run all tests call:

$ set CI=True
$ python -m nose2 -s enmapboxtesting

Note

The environmental variable CI=True is used to inform test routines to not enter the GUI thread. If unset, some widgets might pop-up and wait for your input to terminate.

To run the unit tests in test_mytests.py, call:

$ python -m nose2 -s enmapboxtesting test_mytests

Roadmap¶

The development of the EnMAP-Box is based on the following schedule:

Date	Event / Phase
Jan/Feb 2021	Evaluation EnMAP-Box in Teaching
Mid Feb 2021	Feature Freeze EnMAP-Box 3.8
End Mar 2021	Release EnMAP-Box 3.8
Jul/Aug 2021	Evaluation EnMAP-Box in Teaching
Mid Aug 2021	Feature Freeze EnMAP-Box 3.9
End Sep 2021	Release EnMAP-Box 3.9
Jan/Feb 2022	Evaluation EnMAP-Box in Teaching
Mid Feb 2022	Feature Freeze EnMAP-Box 3.10
End Mar 2022	Release EnMAP-Box 3.10
Jul/Aug 2022	Evaluation EnMAP-Box in Teaching
Mid Aug 2022	Feature Freeze EnMAP-Box 3.11
End Sep 2022	Release EnMAP-Box 3.11

Released versions: https://plugins.qgis.org/plugins/enmapboxplugin/

Changelog: https://bitbucket.org/hu-geomatics/enmap-box/src/develop/CHANGELOG.md

Glossary¶

This glossary gives an overview of how specific terms are used inside the EnMAP-Box.

All the terms that relate to GIS in general should be consistent with the terms given by the QGIS user manual and GUI. Because the EnMAP-Box integrates into the QGIS GUI, we try to not (as far as possible) contradict or redefine terminology.

All terms that relate to machine learning should be consistent with the definitions given by Scikit-Learn and the Scikit-Learn glossary, because we wildly crosslink into the Scikit-Learn docs!

Index with all Terms¶

Index

GIS and Remote Sensing¶

attribute

A synonym for field.

attribute table

A tabulated data table associated with a vector layer. Table columns and rows are referred to as fields and geographic features respectively.

attribute value

Refers to a single cell value inside the attribute table of a vector layer.

band

A raster layer is composed of one or multiple bands.

categorized layer

A categorized vector layer or categorized raster layer.

categorized raster layer

A raster layer styled with a Paletted/Unique values renderer. The renderer defines the band with category values and a list of named and colored categories. Styles are usually stored as QML sidecar files. Category values don’t have to be strictly consecutive.

_images/categorized_raster_layer_styling.png

categorized vector layer

A vector layer styled with a Categorized renderer. The renderer defines the field storing the category values (numbers or strings; expressions not yet supported) and a list of named and colored categories. Styles are usually stored as QML sidecar files. Note that in case of numerical category values, the values don’t have to be strictly consecutive.

_images/categorized_vector_layer_styling.png

categorized spectral library

A spectral library that is also a categorized vector layer.

category

categories

A category has a value, a name and a color.

class

Synonym for category.

classification layer

A categorized raster layer that is assumed to represent a mapping of a contiguous area.

Note that there is currently no equivalent term for a contiguous vector polygon layer. We may introduce it in the future as needed. For now we expect users to rasterize such a vector layer into a raster layer.

class probability layer

A multi-band raster layer, where the bands represent class probabilities (values between 0 and 1) for a set of categories.

class fraction layer

A multi-band raster layer, where the bands represent class cover fractions (values between 0 and 1) for a set of categories.

color

An rgb-color, hex-color or int-color specified by a red, green and blue component. Learn more here: https://htmlcolorcodes.com/

continuous-valued raster layer

A raster layer, where each band represents a continuous-valued variable.

Variable names are given by the raster band names. Variable colors are given by the PAMRasterBand/Metadata “color” item (optional).

_images/continuous-valued_raster_layer.png

_images/continuous-valued_raster_layer_2.png

continuous-valued vector layer

A vector layer styled with a Graduated or a Diagrams renderer. Styles are usually stored as QML sidecar files.

A Graduated renderer specifies a single field used as continuous-valued variable. Variable name is given by the field name and color is given by the symbol color.

TODO: screenshot for graduated renderer (see issue #1038)

A Diagrams renderer specifies multiple fields used as continuous-valued variables. Variable names and colors is given by assigned attribute names and colors.

TODO: screenshot for diagrams renderer (see issue #1038)

_images/continuous-valued_vector_layer.png

_images/continuous-valued_vector_layer_2.png

continuous-valued layer

A continuous-valued vector layer or continuous-valued raster layer.

TODO: update screenshot (see issue #1038)

continuous-valued spectral library

A spectral library that is also a continuous-valued vector layer.

TODO: update screenshot (see issues #1036 and #1038)

continuous-valued variable

A continuous-valued variable has a name and (optional) a color.

field

Refers to a single column inside the attribute table of a vector layer.

A synonym for attribute.

geographic feature

Refers to a single row inside the attribute table of a vector layer. In a vector layer, a geographic feature is a logical element defined by a point, polyline or polygon.

Note that in the context of GIS, the epithet “geographic” in “geographic feature” is usually skipped. In the context of EnMAP-Box, and machine learning in general, the term “feature” is used differently.

See feature for details.

grid

A raster layer defining the spatial extent, coordinate reference system and the pixel size.

hex-color

A color specified by a 6-digit hex-color string, where each color component is represented by a two digit hexadecimal number, e.g. red #FF0000, green #00FF00, blue #0000FF, black #000000, white #FFFFFF and grey #808080.

int-color

A color specified by a single integer between 0 and 256^3 - 1, which can also be represented as a hex-color.

labeled layer

A categorized layer or a continuous-valued layer.

layer

A vector layer or a raster layer.

layer style

The style of a layer can be defined in the Layer Styling panel and the Styling tab of the Layer Properties dialog. Some applications and algorithms take advantage of style information, e.g. for extracting category names and colors.

mask layer

A mask raster layer or mask vector layer.

mask raster layer

A raster layer interpreted as a binary mask. All no data (zero, if missing), inf and nan pixel evaluate to false, all other to true. Note that only the first band used by the renderer is considered.

mask vector layer

A vector layer interpreted as a binary mask. Areas covered by a geometry evaluate to true, all other to false.

pickle file

A binary file ending on .pkl that contains a pickled Python object, usually a dictionary or list container. Pickle file content can be browsed via the EnMAP-Box Data Sources panel:

pixel profile

List of band values for a single pixel in a raster layer.

point layer

A vector layer with point geometries.

polygon layer

A vector layer with polygon geometries.

ployline layer

A vector layer with line geometries.

raster layer

Any raster file that can be opened in QGIS as QgsRasterLayer. Elsewhere known as an image.

regression layer

A continuous-valued raster layer that is assumed to represent a mapping of a contiguous area.

rgb-color

A color specified by a triplet of byte values (values between 0 and 255) representing the red, green and blue color components, e.g. red (255, 0, 0), green (0, 255, 0), blue (0, 0, 255), black (0, 0, 0), white (255, 255, 255) and grey (128, 128, 128).

RGB image

A 3-band byte raster layer with values ranging from 0 to 255.

spectral band

A band inside a spectral raster layer. A spectral band represents a measurement for a region of the electromagnetic spectrum around a specific center wavelength. The region is typically described by a spectral response function.

spectral library

A vector layer with at least one text, JSON or binary field that is designated to a Spectral Profiles editor. Such Spectral Profile fields can contain profile data. Additional metadata can be stored like in any other vector layer, e.g. in text and numeric fields.

Using a vector layer with multiple Spectral Profile fields, it possible to link different profiles to the same geographic feature, e.g. a white reference profile to a field spectrometer profile relating to the same spatial position.

A single profile is represented by a dictionary of the following values:

y: list of y values, required (e.g. surface reflectance)
x: list of x values, optional (e.g. wavelength)
xUnit: x value units, optional (e.g. nanometers)
yUnit: y value units, optional (e.g. ???)
bbl: optional list of bad band multiplier values

Depending on the selected data type of the spectral profile field, the dictionary is stored as plain JSON text or binarized JSON object.

See enmapbox.qgispluginsupport.qps.speclib.core.SpectralLibraryUtils for details.

spectral profile

A pixel profile in a spectral raster layer or a profile in a spectral library.

spectral raster layer

A raster layer with proper wavelength and wavelength units metadata, where the individual bands (i.e. spectral bands) represent measurements across the electromagnetic spectrum. The measurement vector of a single pixel is called a spectral profile)

spectral response function

The spectral response describes the sensitivity of a sensor to optical radiation of different wavelengths. In hyperspectral remote sensing, the spectral response function is often described by a single full-width-at-half-maximum value.

spectral response function library

A spectral library, where each profile represents the spectral response function of a spectral band.

stratification layer

A classification layer that is used to stratify an area into distinct subareas.

stratum

strata

A category of a classifcation layer that is used as a stratification layer. Conceptually, a stratum can be seen as a binary mask with all pixels inside the stratum evaluating to True and all other pixels evaluating to False.

table

A vector layer with (potentially) missing geometry.

Note that in case of missing geometry, the vector layer icon looks like a table and layer styling is disabled.

vector feature

Synonym for geographic feature.

vector layer

Any vector file that can be opened in QGIS as QgsVectorLayer.

Raster Metadata¶

Introduction

Raster metadata management is mainly based on the GDAL PAM (Persistent Auxiliary Metadata) model. Depending on the type of metadata, managing specific metadata item in the GUI or programmatically can differ. Details are explained in the specific term descriptions below.

In the GUI, most of the metadata items can be inspected in the Layer Properties dialog, under GDAL Metadata.

Alternatively, metadata can be managed inside a standard text editor, by opening the GDAL PAM *.aux.xml sidecar file. If the PAM file not already exists, you can create it manually, but usually, it is also created, when a raster file is opened inside QGIS. Here is an excerpt of the enmap_berlin.bsq.aux.xml PAM file:

<PAMDataset>
  <Metadata domain="ENVI">
    <MDI key="band_names">{band 8, band 9, band 10, band 11, band 12, band 13, band 14, band 15, band 16, band 17, band 18, band 19, band 20, band 21, band 22, band 23, band 24, band 25, band 26, band 27, band 28, band 29, band 30, band 31, band 32, band 33, band 34, band 35, band 36, band 37, band 38, band 39, band 40, band 41, band 42, band 43, band 44, band 45, band 46, band 47, band 48, band 49, band 50, band 51, band 52, band 53, band 54, band 55, band 56, band 57, band 58, band 59, band 60, band 61, band 62, band 63, band 64, band 65, band 66, band 67, band 68, band 69, band 70, band 71, band 72, band 73, band 74, band 75, band 76, band 77, band 91, band 92, band 93, band 94, band 95, band 96, band 97, band 98, band 99, band 100, band 101, band 102, band 103, band 104, band 105, band 106, band 107, band 108, band 109, band 110, band 111, band 112, band 113, band 114, band 115, band 116, band 117, band 118, band 119, band 120, band 121, band 122, band 123, band 124, band 125, band 126, band 127, band 144, band 145, band 146, band 147, band 148, band 149, band 150, band 151, band 152, band 153, band 154, band 155, band 156, band 157, band 158, band 159, band 160, band 161, band 162, band 163, band 164, band 165, band 166, band 167, band 168, band 195, band 196, band 197, band 198, band 199, band 200, band 201, band 202, band 203, band 204, band 205, band 206, band 207, band 208, band 209, band 210, band 211, band 212, band 213, band 214, band 215, band 216, band 217, band 218, band 219, band 220, band 221, band 222, band 223, band 224, band 225, band 226, band 227, band 228, band 229, band 230, band 231, band 232, band 233, band 234, band 235, band 236, band 237, band 238, band 239}</MDI>
    <MDI key="fwhm">{ 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005900, 0.005900, 0.006000, 0.006000, 0.006100, 0.006100, 0.006200, 0.006200, 0.006300, 0.006400, 0.006400, 0.006500, 0.006600, 0.006600, 0.006700, 0.006800, 0.006900, 0.006900, 0.007000, 0.007100, 0.007200, 0.007300, 0.007300, 0.007400, 0.007500, 0.007600, 0.007700, 0.007800, 0.007900, 0.007900, 0.008000, 0.008100, 0.008200, 0.008300, 0.008400, 0.008400, 0.008500, 0.008600, 0.008700, 0.008700, 0.008800, 0.008900, 0.008900, 0.009000, 0.009100, 0.009100, 0.009200, 0.009300, 0.009300, 0.009400, 0.009400, 0.009500, 0.009500, 0.009600, 0.009600, 0.009600, 0.009600, 0.009700, 0.009700, 0.009700, 0.011800, 0.011900, 0.012100, 0.012200, 0.012400, 0.012500, 0.012700, 0.012800, 0.012900, 0.013100, 0.013200, 0.013300, 0.013400, 0.013500, 0.013600, 0.013700, 0.013800, 0.013900, 0.014000, 0.014000, 0.014100, 0.014100, 0.014200, 0.014200, 0.014300, 0.014300, 0.014300, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.013700, 0.013600, 0.013600, 0.013500, 0.013500, 0.013400, 0.013400, 0.013300, 0.013200, 0.013200, 0.013100, 0.013100, 0.013000, 0.012900, 0.012900, 0.012800, 0.012800, 0.012700, 0.012700, 0.012600, 0.012500, 0.012500, 0.012400, 0.012400, 0.012300, 0.010900, 0.010800, 0.010800, 0.010700, 0.010700, 0.010600, 0.010600, 0.010500, 0.010500, 0.010400, 0.010400, 0.010400, 0.010300, 0.010300, 0.010200, 0.010200, 0.010100, 0.010100, 0.010100, 0.010000, 0.010000, 0.009900, 0.009900, 0.009900, 0.009800, 0.009800, 0.009700, 0.009700, 0.009700, 0.009600, 0.009600, 0.009600, 0.009500, 0.009500, 0.009400, 0.009400, 0.009400, 0.009300, 0.009300, 0.009300, 0.009200, 0.009200, 0.009100, 0.009100, 0.009100}</MDI>
    <MDI key="wavelength">{ 0.460000, 0.465000, 0.470000, 0.475000, 0.479000, 0.484000, 0.489000, 0.494000, 0.499000, 0.503000, 0.508000, 0.513000, 0.518000, 0.523000, 0.528000, 0.533000, 0.538000, 0.543000, 0.549000, 0.554000, 0.559000, 0.565000, 0.570000, 0.575000, 0.581000, 0.587000, 0.592000, 0.598000, 0.604000, 0.610000, 0.616000, 0.622000, 0.628000, 0.634000, 0.640000, 0.646000, 0.653000, 0.659000, 0.665000, 0.672000, 0.679000, 0.685000, 0.692000, 0.699000, 0.706000, 0.713000, 0.720000, 0.727000, 0.734000, 0.741000, 0.749000, 0.756000, 0.763000, 0.771000, 0.778000, 0.786000, 0.793000, 0.801000, 0.809000, 0.817000, 0.824000, 0.832000, 0.840000, 0.848000, 0.856000, 0.864000, 0.872000, 0.880000, 0.888000, 0.896000, 0.915000, 0.924000, 0.934000, 0.944000, 0.955000, 0.965000, 0.975000, 0.986000, 0.997000, 1.007000, 1.018000, 1.029000, 1.040000, 1.051000, 1.063000, 1.074000, 1.086000, 1.097000, 1.109000, 1.120000, 1.132000, 1.144000, 1.155000, 1.167000, 1.179000, 1.191000, 1.203000, 1.215000, 1.227000, 1.239000, 1.251000, 1.263000, 1.275000, 1.287000, 1.299000, 1.311000, 1.323000, 1.522000, 1.534000, 1.545000, 1.557000, 1.568000, 1.579000, 1.590000, 1.601000, 1.612000, 1.624000, 1.634000, 1.645000, 1.656000, 1.667000, 1.678000, 1.689000, 1.699000, 1.710000, 1.721000, 1.731000, 1.742000, 1.752000, 1.763000, 1.773000, 1.783000, 2.044000, 2.053000, 2.062000, 2.071000, 2.080000, 2.089000, 2.098000, 2.107000, 2.115000, 2.124000, 2.133000, 2.141000, 2.150000, 2.159000, 2.167000, 2.176000, 2.184000, 2.193000, 2.201000, 2.210000, 2.218000, 2.226000, 2.234000, 2.243000, 2.251000, 2.259000, 2.267000, 2.275000, 2.283000, 2.292000, 2.300000, 2.308000, 2.315000, 2.323000, 2.331000, 2.339000, 2.347000, 2.355000, 2.363000, 2.370000, 2.378000, 2.386000, 2.393000, 2.401000, 2.409000}</MDI>
    <MDI key="wavelength_units">Micrometers</MDI>
    ...
  </Metadata>
  <PAMRasterBand band="1">
    <Description>band 8 (0.460000 Micrometers)</Description>
    <NoDataValue>-9.90000000000000E+01</NoDataValue>
    <Metadata>
      <MDI key="wavelength">0.460000</MDI>
      <MDI key="wavelength_units">Micrometers</MDI>
    </Metadata>
  </PAMRasterBand>

  <PAMRasterBand band="1">
    ...
  </PAMRasterBand>

  ...

</PAMDataset>

For managing metadata programmatically, you can mostly use the GDAL API classes gdal.Datset and gdal.Band, or the EnMAP-Box API classes enmapboxprocessing.rasterreader.RasterReader and enmapboxprocessing.rasterreader.RasterWriter.

Warning

If you want to edit metadata in an editor or programmatically, be sure to first close the associated raster layer inside QGIS. Otherwise, QGIS will overwrite your changes again.

To examplify the API usage, we assume the following namespace setup throughout the rest of this section:

from osgeo import gdal
from enmapboxprocessing.rasterreader import RasterReader
from enmapboxprocessing.rasterwriter import RasterWriter
from enmapbox.exampledata import enmap

# use enmap_berlin.bsq raster layer as example dataset
dataset: gdal.Dataset = gdal.Open(enmap)
raster = RasterReader(enmap)

# assume we have a newly created gdal.Dataset object in update mode
newDataset: gdal.Dataset
newRaster = RasterWriter(newDataset)

# for band-wise interactions, we just use the first band
bandNo = 1

bad band

bad band list

bad band multiplier

bbl

The bad band multiplier value is indicating whether a band is usable (1) or not (0).

This information is derived from PAM/Band/Default/bbl. If that is undefined, it is derived by indexing the ENVI bad bands list from PAM/Dataset/ENVI/bbl. If that is also undefined, it is assumed, that the band is usable (i.e. value=1):

# get
>>>dataset.GetRasterBand(bandNo).GetMetadataItem('bbl')  # isn't sufficient in this case
>>>dataset.GetMetadataItem('bbl', 'ENVI')  # also not sufficient
>>>raster.badBandMultiplier(bandNo)  # this will correctly resolve the bad band multiplier
None
None
1

# set
>>>newDataset.GetRasterBand(bandNo).SetMetadataItem('bbl', '1')  # set for single band
>>>newDataset.SetMetadataItem('bbl', '{1, ...., 1}', 'ENVI')  # set for all bands at once
>>>newRaster.setBadBandMultiplier(1, bandNo)  # set for single band

band description

band name

The name of a band.

Usage example:

# get
>>>dataset.GetRasterBand(bandNo).GetDescription()
>>>raster.bandName(bandNo)
band 8 (0.460000 Micrometers)
band 8 (0.460000 Micrometers)

# set
>>>newDataset.GetRasterBand(bandNo).SetDescription('my band name')
>>>newRaster.setBandName('my band name', bandNo)

center wavelength

A synonym for wavelength.

fwhm

full-width-at-half-maximum

The full-width-half-maximum (FWHM) value of a spectral band is approximating the spectral response function as a normal distribution with a sigma = FWHM / 2.355. Units should be the same as those used for wavelength and set in the wavelength units item.

This information is derived from PAM/Band/Default/fwhm. If that is undefined, it is derived by indexing the ENVI fwhm list from PAM/Dataset/ENVI/fwhm:

# get
>>>dataset.GetRasterBand(bandNo).GetMetadataItem('fwhm')  # isn't sufficient in this case
>>>text = dataset.GetMetadataItem('fwhm', 'ENVI')  # this gives just a string with values for all bands
>>>text
>>>float(text.strip('{}').split(',')[bandNo - 1])  # extra processing required to unpack the band FWHM
>>>raster.badBandMultiplier(bandNo)  # in Nanometers (the default)
>>>raster.badBandMultiplier(bandNo, 'Micrometers')  #  in user-defined units
None
{ 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005800, 0.005900, 0.005900, 0.006000, 0.006000, 0.006100, 0.006100, 0.006200, 0.006200, 0.006300, 0.006400, 0.006400, 0.006500, 0.006600, 0.006600, 0.006700, 0.006800, 0.006900, 0.006900, 0.007000, 0.007100, 0.007200, 0.007300, 0.007300, 0.007400, 0.007500, 0.007600, 0.007700, 0.007800, 0.007900, 0.007900, 0.008000, 0.008100, 0.008200, 0.008300, 0.008400, 0.008400, 0.008500, 0.008600, 0.008700, 0.008700, 0.008800, 0.008900, 0.008900, 0.009000, 0.009100, 0.009100, 0.009200, 0.009300, 0.009300, 0.009400, 0.009400, 0.009500, 0.009500, 0.009600, 0.009600, 0.009600, 0.009600, 0.009700, 0.009700, 0.009700, 0.011800, 0.011900, 0.012100, 0.012200, 0.012400, 0.012500, 0.012700, 0.012800, 0.012900, 0.013100, 0.013200, 0.013300, 0.013400, 0.013500, 0.013600, 0.013700, 0.013800, 0.013900, 0.014000, 0.014000, 0.014100, 0.014100, 0.014200, 0.014200, 0.014300, 0.014300, 0.014300, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.014400, 0.013700, 0.013600, 0.013600, 0.013500, 0.013500, 0.013400, 0.013400, 0.013300, 0.013200, 0.013200, 0.013100, 0.013100, 0.013000, 0.012900, 0.012900, 0.012800, 0.012800, 0.012700, 0.012700, 0.012600, 0.012500, 0.012500, 0.012400, 0.012400, 0.012300, 0.010900, 0.010800, 0.010800, 0.010700, 0.010700, 0.010600, 0.010600, 0.010500, 0.010500, 0.010400, 0.010400, 0.010400, 0.010300, 0.010300, 0.010200, 0.010200, 0.010100, 0.010100, 0.010100, 0.010000, 0.010000, 0.009900, 0.009900, 0.009900, 0.009800, 0.009800, 0.009700, 0.009700, 0.009700, 0.009600, 0.009600, 0.009600, 0.009500, 0.009500, 0.009400, 0.009400, 0.009400, 0.009300, 0.009300, 0.009300, 0.009200, 0.009200, 0.009100, 0.009100, 0.009100}
0.0058
5.8
0.0058

# set
>>>newDataset.GetRasterBand(bandNo).SetMetadataItem('fwhm', '0.0058')  # set FWHM for single band
>>>newDataset.GetRasterBand(bandNo).SetMetadataItem('wavelength_units', 'Micrometers')  # also set the units
>>>newDataset.SetMetadataItem('fwhm', '{0.0058, ..., 0.0091}', 'ENVI')  # set FWHM for all bands at once
>>>newDataset.SetMetadataItem('wavelength_units', 'Micrometers', 'ENVI')  # also set the units
>>>newRaster.setFwhm(5.8, bandNo)  # set single band FWHM in Nanometers
>>>newRaster.setFwhm(0.0058, bandNo, 'Micrometers')  # set single band FWHM in user-defined units

no data value

The no data value of a band.

Usage example:

# get
>>>dataset.GetRasterBand(bandNo).GetNoDataValue()
>>>raster.noDataValue(bandNo)
>>>raster.noDataValue()  # if bandNo is skipped, it defaults to the first band
-99.0
-99.0
-99.0

# set
newDataset.GetRasterBand(bandNo).SetNoDataValue(-9999)
newRaster.setNoDataValue(-9999, bandNo)
newRaster.setNoDataValue(-9999)  # if bandNo is skipped, the no data value is applied to all bands

wavelength

The center wavelength value of a band. Units should be the same as those used for the fwhm and set in the wavelength units item.

This information is derived from PAM/Band/Default/wavelength. If that is undefined, it is derived by indexing the ENVI wavelength list from PAM/Dataset/ENVI/wavelength:

# get
>>>dataset.GetRasterBand(bandNo).GetMetadataItem('wavelength')  # this works, because the GDAL ENVI driver assigns those on-the-fly
>>>text = dataset.GetMetadataItem('fwhm', 'ENVI')  # this gives just a string with values for all bands
>>>text
>>>float(text.strip('{}').split(',')[bandNo - 1])  # extra processing required to unpack the band wavelength
>>>raster.wavelength(bandNo)  # in Nanometers (the default)
>>>raster.wavelength(bandNo, 'Micrometers')  #  in user-defined units
0.460000
{ 0.460000, 0.465000, 0.470000, 0.475000, 0.479000, 0.484000, 0.489000, 0.494000, 0.499000, 0.503000, 0.508000, 0.513000, 0.518000, 0.523000, 0.528000, 0.533000, 0.538000, 0.543000, 0.549000, 0.554000, 0.559000, 0.565000, 0.570000, 0.575000, 0.581000, 0.587000, 0.592000, 0.598000, 0.604000, 0.610000, 0.616000, 0.622000, 0.628000, 0.634000, 0.640000, 0.646000, 0.653000, 0.659000, 0.665000, 0.672000, 0.679000, 0.685000, 0.692000, 0.699000, 0.706000, 0.713000, 0.720000, 0.727000, 0.734000, 0.741000, 0.749000, 0.756000, 0.763000, 0.771000, 0.778000, 0.786000, 0.793000, 0.801000, 0.809000, 0.817000, 0.824000, 0.832000, 0.840000, 0.848000, 0.856000, 0.864000, 0.872000, 0.880000, 0.888000, 0.896000, 0.915000, 0.924000, 0.934000, 0.944000, 0.955000, 0.965000, 0.975000, 0.986000, 0.997000, 1.007000, 1.018000, 1.029000, 1.040000, 1.051000, 1.063000, 1.074000, 1.086000, 1.097000, 1.109000, 1.120000, 1.132000, 1.144000, 1.155000, 1.167000, 1.179000, 1.191000, 1.203000, 1.215000, 1.227000, 1.239000, 1.251000, 1.263000, 1.275000, 1.287000, 1.299000, 1.311000, 1.323000, 1.522000, 1.534000, 1.545000, 1.557000, 1.568000, 1.579000, 1.590000, 1.601000, 1.612000, 1.624000, 1.634000, 1.645000, 1.656000, 1.667000, 1.678000, 1.689000, 1.699000, 1.710000, 1.721000, 1.731000, 1.742000, 1.752000, 1.763000, 1.773000, 1.783000, 2.044000, 2.053000, 2.062000, 2.071000, 2.080000, 2.089000, 2.098000, 2.107000, 2.115000, 2.124000, 2.133000, 2.141000, 2.150000, 2.159000, 2.167000, 2.176000, 2.184000, 2.193000, 2.201000, 2.210000, 2.218000, 2.226000, 2.234000, 2.243000, 2.251000, 2.259000, 2.267000, 2.275000, 2.283000, 2.292000, 2.300000, 2.308000, 2.315000, 2.323000, 2.331000, 2.339000, 2.347000, 2.355000, 2.363000, 2.370000, 2.378000, 2.386000, 2.393000, 2.401000, 2.409000}
0.46
460.0
0.46

# set
>>>newDataset.GetRasterBand(bandNo).SetMetadataItem('wavelength', '0.46')  # set wavelength for single band
>>>newDataset.GetRasterBand(bandNo).SetMetadataItem('wavelength_units', 'Micrometers')  # also set the units
>>>newDataset.SetMetadataItem('fwhm', '{0.46, ..., 2.409}', 'ENVI')  # set wavelength for all bands at once            >>>newDataset.SetMetadataItem('wavelength_units', 'Micrometers', 'ENVI')  # also set the units
>>>newRaster.setWavelength(460, bandNo)  # set single band wavelength in Nanometers
>>>newRaster.setWavelength(0.46, bandNo, 'Micrometers')  # set single band wavelength in user-defined units

wavelength units

The wavelength units of a band. Valid units are Micrometers, um, Nanometers, nm.

This information is derived from PAM/Band/Default/wavelength_units. If that is undefined, it is derived from PAM/Dataset/ENVI/wavelength_units:

# get
>>>dataset.GetRasterBand(bandNo).GetMetadataItem('wavelength_units')  # this works, because the GDAL ENVI driver assigns those on-the-fly
>>>dataset.GetMetadataItem('wavelength_units', 'ENVI')
>>>raster.wavelengthUnits(bandNo)
Micrometers
Micrometers
Micrometers

# set
>>>newDataset.GetRasterBand(bandNo).SetMetadataItem('wavelength_units', 'Micrometers')  # set for single band
>>>newDataset.SetMetadataItem('wavelength_units', 'Micrometers', 'ENVI')  # set for the dataset

Note that when using the RasterWriter for setting wavelength or fwhm information, the wavelength units are also correctly specified at the same time.

Machine Learning¶

EnMAP-Box provides nearly all of it’s machine learning related functionality by using Scikit-Learn in the background. So we decided to also adopt related terminology and concepts as far as possible, while still retaining the connection to GIS and remote sensing in the broader context of being a QGIS plugin. Most of the following definitions are directly taken from the Scikit-Learn glossary as is, and only expanded if necessary.

classification

The process of identifying which category an object belongs to.

classifier

A supervised estimator with a finite set of discrete possible output values.

clusterer

An unsupervised estimator with a finite set of discrete output values.

clustering

The process of automatic grouping of similar objects into sets.

cross-validation

The training dataset is split into k smaller sets and the following procedure is followed for each of the k “folds”:

a model is trained using k-1 of the folds as training dataset
the resulting model is used to predict the targets of the remaining part of the dataset

The performance can now be calculated from the predictions for the whole training dataset.

This approach can be computationally expensive, but does not waste too much data (as is the case when fixing an arbitrary validation set), which is a major advantage in problems where the number of samples is very small.

dataset

A dataset is a complete representation of a learning problem, combining feature data X and target data y. Datasets are often split into sub-datasets. One common splitting technique is the train-test split, where a part of the dataset is held out as a so-called training dataset used for fitting the estimator and another part is held out as a test dataset used for a final evaluation.

When evaluating different settings (i.e. hyperparameters) for an estimator, yet another part of the dataset can be held out as a so-called validation dataset. Training proceeds on the training dataset, best parameters are found by evaluating against the validation dataset, and final evaluation can be done on the test dataset. Holding out a validation datase can be avoided by using cross-validation for hyperparameter tuning.

estimator

An object which manages the estimation of a model. The model is estimated as a deterministic function.

evaluation metric

Evaluation metrics give a measure of how well a model (e.g. a classifier or regressor) performs.

feature

feature vector

In QGIS and other GIS, the term feature is well defined as a logical element defined by a point, polyline or polygon inside a vector layer. In the context of the EnMAP-Box, we refere to it as geographic feature.

In machine learning, a feature is a component in a so-called feature vector, which is a list of numeric quantities representing a sample in a dataset. A set of samples with feature data X and associated target data y or Y form a dataset.

Elsewhere features are known as attributes, predictors, regressors, or independent variables. Estimators assume that features are numeric, finite and not missing. n_features indicates the number of features in a dataset.

n_features

The number of features in a dataset.

n_outputs

The number of outputs in a dataset.

n_samples

The number of samples in a dataset.

n_targets

Synonym for n_outputs.

output

Individual scalar/categorical variables per sample in the target.

Also called responses, tasks or targets.

regression

The process of predicting a continuous-valued attribute associated with an object.

regressor

A supervised estimator with continuous output values.

sample

We usually use this term as a noun to indicate a single feature vector.

Elsewhere a sample is called an instance, data point, or observation. n_samples indicates the number of samples in a dataset, being the number of rows in a data array X.

target

The dependent variable in supervised learning, passed as y to an estimator’s fit method.

Also known as dependent variable, outcome variable, response variable, ground truth or label.

test dataset

The dataset used for final evaluation.

training dataset

The dataset used for training.

transformer

An estimator that transforms the input, usually only feature data X, into some transformed space (conventionally notated as Xt).

validation dataset

The dataset used for finding best parameters (i.e. hyperparameter tuning).

X

Denotes data that is observed at training and prediction time, used as independent variables in learning. The notation is uppercase to denote that it is ordinarily a matrix.

y

Y

Denotes data that may be observed at training time as the dependent variable in learning, but which is unavailable at prediction time, and is usually the target of prediction. The notation may be uppercase to denote that it is a matrix, representing multi-output targets, for instance; but usually we use y and sometimes do so even when multiple outputs are assumed.

Installation¶

The EnMAP-Box is a plugin for QGIS and requires additional python packages that need to be installed independent from QGIS.

1. Install QGIS¶

Install QGIS version 3.24 or higher to run the EnMAP-Box. You can get QGIS here. Additional information on the installation process is provided in the QGIS Documentation.

In case you already have QGIS installed, you can skip this step.

MacOS¶

Before you can install QGIS from the downloaded disk image, you need to allow your macOS to install it:

Download the official all-in-one, signed installer here.
Extract the downloaded qgis-macos-pr.dmg and move it to your app folder
Installing or opening QGIS may raise a verification warning

In that case, open your system preferences, go to “Security & Privacy” -> “General” and allow QGIS to be opened anyway
Now you can start QGIS.app from your application folder.

2. Install required python packages¶

The EnMAP-Box core plugin requires several python packages:

numpy
scipy
scikit-learn
matplotlib
astropy (optional, relevant for certain processing algorithms)

In the following we demonstrate two variants for installing the required Python packages:

2.1 Package Installer¶

The EnMAP-Box includes a Package Installer that offers a more or less one-click solution to install required python packages. It can be accessed from the menu bar via Project ‣ Package Installer.

If you start the EnMAP-Box for the first time, you may see a warning. The Package Installer can also be opened by clicking Install Missing.

Use the Yes to All button to install all required python packages. Per default, this will install packages using pip into the user directory (as this does not require admin rights). It is also possible to install/update packages individually via the context menu inside the package list.

It might be necessary to restart QGIS and the EnMAP-Box.

2.2 Command-line¶

In case the Package Installer does not work for you or you do not want to use it, try installing the packages from the command-line. This variant may be more reliable. See OS specific instructions below:

Windows¶

Close QGIS, if it is open.
Run the OSGeo4W Shell as administrator (!!!). A convenient way to access the OSGeo4W Shell is from the start menu. Depending on the installation method you used to install QGIS, the shortcut will be listed under QGIS 3.xx (standalone installer) or OSGeo4W (network installer)

Hold Ctrl + Shift and click on the OSGeo4W Shell entry (or right-click and choose Run as administrator)
Activate the Python 3 environment by entering:
```
py3_env
```
Note

In more recent versions of QGIS the py3_env call might not be necessary or will simply not work. If so, just continue with the following step (4).
Install required python packages by entering:
```
python3 -m pip install -r https://bitbucket.org/hu-geomatics/enmap-box/raw/develop/requirements.txt
```
Now all packages will be installed automatically. After completion, the shell should show something like this:

If the package installation was successful, you can close the shell. The required packages are installed now and you can continue to start/install the EnMAP-Box.

Error

In case you run into problems because pip is not available in your python environment (error message C:/.../python3.exe: No module named pip or similar), follow these steps…

Linux¶

Close QGIS, if it is open.
Open the terminal and install all missing packages using pip:

Hint

Make sure to execute the pip command in the python environment QGIS is using (usually you can find out where python is located by running import sys; sys.executable in the QGIS Python Console). You then might have to change the python3 part in the snippet below with the explicit QGIS python path.

This also applies if you installed QGIS using flatpak, in that case install python modules as described here.
```
python3 -m pip install -r https://bitbucket.org/hu-geomatics/enmap-box/raw/develop/requirements.txt
```

Mac¶

To install single python packages like the astropy package, open the Terminal and call:

/Applications/QGIS.app/Contents/MacOS/bin/pip3 install astropy

To install all packages required, call:

/Applications/QGIS.app/Contents/MacOS/bin/pip3 install -r https://bitbucket.org/hu-geomatics/enmap-box/raw/develop/requirements.txt

More details on the QGIS packaging mechanism for macOS can be found here.

Error

See FAQ if you run into problems installing the packages.

3. Install or update the EnMAP-Box¶

Install from QGIS plugin repository¶

Open QGIS and go to Plugins ‣ Manage and Install Plugins ‣ All
In the search bar enter enmap or EnMAP-Box 3
Now the EnMAP-Box should be listed in the plugin list:

Select it and click Install plugin (or Upgrade in case you update to a new version)
Start the EnMAP-Box via the icon or from the menubar Raster ‣ EnMAP-Box
(Optional): You can download a test/demo dataset via Project ‣ Load Example Data

Experimental version

It is also possible to install the most recent develop version of the EnMAP-Box. To do so, make sure that the option Show also experimental plugins is activated in the plugin manager settings. Once activated, there is an additional button Install Experimental Plugin in the plugin manager.

Warning

As the experimental tag suggests, this version comes with the newest features and developments, but might also be prone to bugs and crashes.

Install older version¶

Go to the QGIS Python Plugins Repository https://plugins.qgis.org/plugins/enmapboxplugin/
Click on the Versions tab to see all available version.
Click on the desired version and on the next page click
It is recommended to uninstall previous EnMAP-Box versions (delete folder manually, or in QGIS via Plugins ‣ Manage and Install Plugins ‣ Installed ‣ EnMAP-Box 3 ‣ Uninstall plugin)
Open Plugins ‣ Manage and Install Plugins ‣ Install from ZIP.
Press … and select the downloaded zip file (enmapboxplugin.3.x.YYYYMMDDTHHMM.QGIS3.zip) and click Install plugin.
Start the EnMAP-Box via the icon or from the menubar Raster ‣ EnMAP-Box.

Getting Started¶

Info

This section is aimed at users with no previous EnMAP-Box experience. You will get a brief introduction into the main functionalities:

Getting to know the Graphical User Interface
Use an EnMAP-Box Application (Classification Workflow)
Use a Processing Algorithm

Primer¶

The EnMAP-Box can be divided into several major components. The Graphical User Interface (GUI) provides main access to all features and lets you manage and visualize raster and vector data as well as spectral libraries. From here you can access further Tools and Applications, which can be regarded as additional plugins that add specific functionalities such as plotting, metadata editing or raster algebra. Furthermore, the EnMAP-Box extents the QGIS Processing Toolbox with a comprehensive collection of various Processing Algorithms for (raster) data manipulation. ‘Underneath’ all this is the EnMAP-Box API, HUB-Workflow API and HUB-Datacube API, which are high-level application programming interfaces that allow more advanced users to operate EnMAP-Box functionalities directly from code or to build their own applications on top.

Launching the EnMAP-Box¶

Once you successfully installed the EnMAP-Box, you can access the plugin via the icon in the QGIS toolbar. Furthermore, the EnMAP-Box Processing Algorithms should also appear in the QGIS Processing Toolbox.

The Graphical User Interface (GUI) of the EnMAP-Box on first open

Tip

Have a look at the User Manual for a detailed description of the GUI.

Loading Testdata¶

Go to Project ‣ Load Example Data to load example datasets into you project (on first open, you will be asked whether to download the dataset, confirm with OK). The following datasets will be added (now they are listed in the Data Sources window):
- enmap_berlin.bsq
- hires_berlin.bsq
- landcover_berlin_point.gpkg
- landcover_berlin_polygon.gpkg
- library_berlin.sli

Tip

Have a look at the section Test dataset for further information on the dataset. In this section we will mainly work with enmap_berlin.bsq and landcover_berlin_point.gpkg

First Steps in the GUI¶

By default the example data is loaded into a single Map View. Let’s rearrange those for better visualisation and in order to get to know the GUI functionalities:

Click the ^{Open a map window} button to add a second map view. The window appears below the first map window.
We want to arrange the windows so that they are next to each other (horizontally). Click and hold on the blue area of Map #2 and drag it to the right of Map #1 (see figure below). The translucent blue rectangle indicates where the map window will be docked once you stop holding the left mouse button.
Now, in the Data Views window, expand the Map #1 list, so that you can see the individual layers. Select hires_berlin.bsq and drag the layer into Map #2 (you can drag them directly into the map views or the respective menu item under Data Views). You can remove library_berlin.sli and landcover_berlin_polygon.gpkg, since they are not needed here. Right-click on the layer in the Data Views panel and select Remove Layer.
In the next step we link both map views, so that zoom and center are synchronized between both. Go to View ‣ Set Map Linking and select ^{Link map scale and center}.
Move the map (using or holding mouse wheel) and see how both map views are synchronized.

Use an Application¶

In this section we will use the EnMAP-Box application Classification Workflow to classify the enmap_berlin.bsq image using a point vector dataset with the classes impervious, low vegetation, tree, soil, water and a random forest classifier.

Go to Applications ‣ Classification Workflow (Classic) to open the Classification Workflow application.
In the Type dropdown menu select Raster / Vector Classification.
Choose enmap_berlin.bsq as Raster and landcover_berlin_point.gpkg as Reference. Now the class names and colors become visible in the Sampling submenu.
Here you can alter the class colors and the class names or change the size of your sample. But for this tutorial use the default settings (sample size at 100%).

Tip

Find more information on the Classification Workflow application in the User Manual.
As Classifier choose RandomForestClassifier (which is the default setting).
Under Mapping you have to specify the raster which will be classified. We will choose the same raster we took the samples from, so select enmap_berlin.bsq as Raster.
Make sure to check the Classification output. Specify an output path and filename by pressing … or use the default, which will save the output to a temporary location.
Also select to perform a Cross-validation with n-folds. You can leave the number of folds at 3. Specify output path for the HTML report or use default (temporary directory).
Click the run button to start the classification.
Once the process has finished, the classification image will be listed in the Data Sources panel (if not, open it again via ). Also, the HTML report of the accuracy assessment will open automatically in the default web browser.

Screenshot of the Classification Performance HTML report
Now visualize the classification result side-by-side with the initial image. Therefore, right-click into Map #2 and select ‣ Clear. Drag the classification image from the Data Sources panel into Map #2

Screenshot of the Map Views: EnMAP image on the left and classification result on the right
In the Data Views panel, right-click on the classification layer and select Classification Statistics. This will show you an interactive plot with the different class counts

Use a Processing Algorithm¶

In this section we will use a processing algorithm from the EnMAP-Box algorithm provider. More precise, we are converting a polygon dataset holding information on different landcover types into a classification raster, i.e., we are going to rasterize the vector dataset.

First of all, make sure the Processing Toolbox window is opened. If not, activate it via View ‣ Panels ‣ Processing Toolbox
Open the Rasterize categorized vector layer algorithm under EnMAP-Box ‣ Raster Creation
Use the following settings:
- Categorized vector layer: landcover_berlin_polygon.gpkg
- Grid: enmap_berlin.bsq
Specify an output filepath under Output Classification and click Run

_images/example_rasterize_classification.png

Result of the Classification from Vector algorithm (right) and the input grid (left) and polygon dataset (middle)

Use the Spectral Library¶

In this section, we will use the spectral library to characterize and compare spectra of different surfaces. In the following, the enmap_berlin.bsq is used to explain how to collect spectra and edit their properties.

Open the spectral library window via View ‣ Add Spectral Library Window
Now you should see an empty window where all spectra can now be collected.
If not activated yet, enable the button in the menu bar and open a raster you want to collect spectra from in a Map Window.
Now you can generate spectra from the image by using the left mouse button and clicking in the opened image.
To display multiple spectra at the same time in the same spectral library, activate the Add profiles automatically button in the drop-down list.

Add information to the attribute table:

You can manage your spectra and add information, e.g. class name or description of the property.
Open the Attribute table view by clicking the symbol, then enable the Editing mode by activating the
Add a new field via

Example: Add a new text field (maximum 100 characters)
After the new column is added, you can add information by double-clicking it.
To delete a column, use the Delete field button

Cookbook¶

This section is a collection of ‘recipes’ for common tasks you can perform in the EnMAP-Box. For convenience the recipes might use and refer to the EnMAP-Box test dataset, but of course it is desired that you use your own data sets as well.

Todo

We will try to continuously update this section. If you miss topics, feel free to suggest new entries here!

Classification¶

This section will demonstrate the process of image classification using the test dataset. In this example we will use the processing algorithms only. For classification purposes you might also want to have a look at the Classification workflow application, which provides a convenient graphical user interface and manages all intermediate steps ‘under the hood’ (see also Getting Started).

Fit a Classifier¶

The first step towards image classification is to fit a classifier. The available algorithms are listed in the processing toolbox under EnMAP-Box ‣ Classification ‣ Fit […]. These Fit […] algorithms expect a raster dataset where samples are extracted from as first input (Raster). The second input is a classification raster which contains the class labels/target variable (Labels). Optionally you can include a mask layer. The output of those algorithms is a .pkl file, an intermediate exchange format which stores all relevant information and will be needed in the consecutive step.

Fit algorithms and their common window layout

Using vector datasets as reference and input for Labels :

Often reference datasets with class information are available as vector datasets, for example point shapefiles where class information is stored in the attribute table. In order to use this information in the Fit algorithm, the vector dataset has to be converted to a classification raster first. This can be done with the Classification from Vector algorithm (in the processing toolbox under EnMAP-Box ‣ Create Raster).

Example from test dataset: Multipoint layer with class information, coloured by level_2 attribute

Open EnMAP-Box ‣ Create Raster ‣ Classification from Vector
- Pixel Grid expects a raster layer that defines the target grid based on which the vector geometries will be rasterized
- Vector is the reference dataset which should be rasterized
- Class id attribute points to the field in the Vector layer which contains the class values (which will become the cell values in the raster)
- Minimal overall coverage, Minimal dominant coverage and Oversampling factor are important parameters when working with polygon geometries. For the example we will use a point vector layer, so you can stick with the default values.
- Output Classification: Output path for classification raster.
Using the test dataset, enter the following parameters:
Click Run

Side by side: Inputs and Output of Classification from Vector

The generated classification raster can now be used to fit a classifier.

Hint

In order for the Classification from Vector algorithm to know the class labels (names) and colors for rasterization you need to provide this information in a .json file which has the same basename and is located in the same directory as the underlying vector dataset. Otherwise random colors will be assigned and labels will be class 1, class 2, class 3 and so on.

For example, the .json file of the landcover_berlin_point.shp (landcover_berlin_point.json) looks like this:

{
  "level_1_id": {
    "categories":  [
      [0, "unclassified", [0, 0, 0]],
      [1, "impervious", [230, 0, 0]],
      [2, "vegetation", [56, 168, 0]],
      [3, "soil", [168, 112, 0]],
      [4, "water", [0,100,255]]
    ],
    "no data value": 0,
    "description": "Classification"
  },
  "level_2_id": {
    "categories":  [
      [0, "unclassified", [0, 0, 0]],
      [1, "impervious", [230, 0, 0]],
      [2, "low vegetation", [152, 230, 0]],
      [3, "tree", [38, 115, 0]],
      [4, "soil", [168, 112, 0]],
      [5, "water", [0,100,255]]
    ],
    "no data value": 0,
    "description": "Classification"
  }
}

Fit Classifier:

Go to EnMAP-Box ‣ Classification and select one of the Fit […] algorithms, for example Fit SVC
Now select enmap_berlin.bsq as Raster and the output of the Classification from Vector algorithm as Labels, leave the remaining parameters at default and specify an output path (Output Classifier) for the classifier file (.pkl).
Click Run.

Predict Classification¶

In this step the classification will be applied to an image, which is usually (but not necessarily) the same image used in the fitting of the classifier. The Predict Classification algorithm can be found in the same category (EnMAP-Box ‣ Classification).

Select the image you want to classify as Raster and the .pkl file from the previous step as Classifier.
For the test data this might look something like this:
Specify an output path for the classification image and click Run.
Now you should end up with a classified image

Accuracy Assessment¶

Todo

Under construction…

Tip

If you want to automatize workflows we suggest using the graphical modeler available in QGIS! See the Graphical Modeler recipe in the cookbook on how to create a graphical model for image classification.

Clip a raster with a vector¶

Clipping a raster to the bounds of a vector layer is fairly simple in the EnMAP-Box, since vector layers can be interpreted as masks.

Go to the Processing Algorithms and select Masking ‣ Apply Mask to Raster
Under Raster select the raster layer you want to clip, and under Mask select the vector layer.

Tip

If you want to invert the clip, which means that only pixels are included which are NOT within a polygon, simply activate the Invert Mask option.

Output example: Input raster (left), vector geometry for clipping (middle) and resulting output (right)

Attention

This method will just mask the raster according to the vector geometries, the extent will not be altered, which means the raster will not be cropped to the extent of the vector layer. You may use the Translate raster layer algorithm for this.

Clustering (kmeans)¶

Several clustering methods are available in the EnMAP-Box. You can find them in the Processing Toolbox under EnMAP-Box ‣ Clustering. The usual way to apply these methods is to use a Fit … algorithm first and then apply it to an image with Predict (unsupervised) classification layer.

This recipe demonstrates the basic workflow of applying clusterers using K-Means clustering (Fit KMeans) and the test dataset.

See also

You can find all the available clustering algorithms here.

Open the test dataset
In the processing toolbox go to EnMAP-Box ‣ Clustering ‣ Fit KMeans
- Specify enmap_berlin.bsq under Raster
- Under Output Clusterer specify an output file path and click Run
Now open EnMAP-Box ‣ Clustering ‣ Predict (unsupervised) classification layer
- Select enmap_berlin.bsq as input Raster
- Under Clusterer click … and select the output .pkl file from the Fit KMeans algorithm
- Specify an output filepath for the transformed raster under Clustering and click Run
EnMAP true color image (left) and kmeans cluster result with 8 clusters (right)

Tip

8 clusters is the default of the kmeans algorithm here, if you want to change the number of clusters, run the Fit Kmeans algorithm with a fewer number, by altering the KMeans() function in the Code window to KMeans(n_clusters=4). This will reduce the amount of clusters to 4.

Filtering¶

The EnMAP Box comes with a variety of filtering algorithms. You can find them in the processing toolbox under EnMAP-Box ‣ Convolution, Morphology and Filtering. In this section we will demonstrate how to apply them, by showing a spatial filter and a spectral filter.

Spatial Filter¶

Spatial filters apply a 2D kernel spatially (i.e. y/x dimensions) for each band.

Open the testdataset. In the processing toolbox go to EnMAP-Box ‣ Convolution, Morphology and Filtering ‣ Spatial Median Filter.

Select enmap_berlin.bsq as Raster
Use the default settings in the code window
Specify Output Raster, and click Run

Input image on the left (true color RGB), median filtered image on the right (same band combination)

Spectral Filter¶

In spectral filtering a 1D kernel is applied along the z dimension of the raster (bands). Mind that in some cases you will reduce the overall number of band values as values in the beginning and at the end will be set to nodata (depending on the kernel type and size).

Open the testdataset. In the processing toolbox go to EnMAP-Box ‣ Convolution, Morphology and Filtering ‣ Spectral Convolution Gaussian1DKernel.

Select enmap_berlin.bsq as Raster
In the code window, change stddev=1 to stddev=2
Specify Output Raster, and click Run

Spectral signature of a pixel, original vs filtered with a Gaussian1DKernel

Generic Filter (Majority)¶

With the Spatial Generic Filter Processing Algorithm you can use the scipy generic_filter function to write your own spatial filter functions.

In this example we will write a mode filter (also known as majority filter). This kind of filter is often used to smooth classification results (reduce salt-and-pepper effects in the image). It calculates the mode of all values in a specifiable neighborhood around a pixel (e.g. 3x3 pixel window) and assigns this value to the pixel.

In the Processing Toolbox go to and open Convolution, Morphology and Filtering ‣ Spatial Generic Filter
Select an input raster under Raster

In the Code text window you can enter python code. Delete the existing content and enter the following

from scipy.ndimage.filters import generic_filter
import numpy as np
from scipy.stats import mode

def filter_function(invalues):
   invalues_mode = mode(invalues, axis=None, nan_policy='omit')
   return invalues_mode[0]

function = lambda array: generic_filter(array, function=filter_function, size=3)

Specify the output raster location and click Run

Majority filter applied to classification image: original classification (left), majority filtered 3x3 window (middle), majority filtered 5x5 window (right)

Tip

Also have a look at the scipy.stats.mode documentation. You can change the window size by altering the size parameter in the generic_filter function.

You could further improve the function above by putting constraints on the definition of majority (for example, only update the original value if the frequency of the modal value is higher than 50 percent)

Graphical Modeler¶

Note

This section demonstrates how to use the Graphical Modeler in QGIS with EnMAP-Box processing algorithms in order to automate common workflows. Instead of manually clicking our way through the processing algorithms, we will build a model which combines all the steps of image classification and can potentially be reused and generalized for further applications.

You can find general information on the Graphical Modeler in the QGIS documentation.

Start the EnMAP-Box and load the test dataset under Project ‣ Load example data.
In the menubar go to Processing ‣ Graphical Modeler. In the Modeler you have two major items or building blocks, which are the Inputs and Alogrithms. The latter basically lists all algorithms available in the QGIS Processing Toolbox and the first lists all available types of inputs, which can be used by the processing algorithms.
For image classification we need at least an input raster and a reference dataset. In case of the EnMAP-Box testdata the reference dataset is a point shapefile. Under Inputs search for Raster Layer and select it (double-click or drag-and-drop). As Parameter Name you can for example choose input_image. Mind how this input graphically appears in the main window. Now again, look for Vector Layer, double-click, and assign a name, e.g. reference_vector.

Note

You can of course change the Parameter name as you wish, but it might be easier to follow this guide when you use the suggestions.
Add a Vector Field input to the model. Enter reference_field as Parameter name and reference_vector as Parent layer.
Now we need the Classification from Vector algorithm in order to rasterize the reference dataset. Find it in the Algorithms tab and select it. Now enter the following parameters:
- Pixel grid: input_image
- Vector: reference_vector
- Class id attribute: reference_field
- Minimal overall coverage: 0.0
- Minimal dominant coverage: 0.0
- Oversampling factor: 1
Caution

If you want to control the label names and colors of the output raster, you have to add a .json file to your vector dataset, see here. If you use the test dataset the json file is already supplied.
Now add the Fit RandomForestClassifier algorithm to your model. In the dialog, select input_image as Raster and under Labels select 'Output Classification' from algorithm 'Classification from Vector'. Leave the rest at default and click OK.
In the next step select the Predict Classification algorithm. Under Raster select input_image and under Classifier select 'Output Classifier' from algorithm 'Fit RandomForestClassifier' (click on the button and switch mode to Algorithm Output). Enter a name under Output Classification, e.g. predicted_image. Confirm with OK.
The model is already able to run and perform an image classification, but we will add the generation of an accuracy assessment: Look for the Algorithm Classification Performance and select it. Choose 'Output Classification' from algorithm 'Predict Classification' as Prediction and 'Output Classification' from algorithm 'Classification from Vector' as Reference. Specify a name under HTML Report, for example accuracy_assessment.
Under Model properties you can specify a name and a group for your model and save it.
Click the run button or press F5 to test your model. Use the following settings:
- input_image: enmap_berlin.bsq
- reference_vector: landcover_berlin_point.shp
- reference_field: level_2_id
Screenshot of the final model
After saving, your model will also appear in the Processing Toolbox:

… and can be openend as a regular processing algorithm:

Final remarks

Mind that this example was quite specific to the EnMAP test dataset. You might want to alter the model in a way that it is more generalizable or fitting for your specific use cases.
Also, consider extending the model inputs to have even more parameters to select from, e.g. by using the Number input type to make the parameter Minimal overall coverage from the algorithm Classification from Vector directly specifiable as a parameter in your model dialog.
Consider including a separate reference dataset as an additional selectable input parameter (for the accuracy assessment).

Map Algebra with ImageMath¶

You can open the ImageMath raster calculator under Applications ‣ ImageMath

Calculate NDVI¶

Make sure to open the testdatasets for this example
Specify the input and output parameters according to the screenshot below (you can of course alter the names, but make sure to also adapt them in the script)

Enter this code in the editor on the right side. You do not need to alter Output Grid and Processing for now.

# select the red band
red = enmap[38]
# select the nir band
nir = enmap[64]
# calculate ndvi
ndvi = (nir-red)/(nir+red)

Click the run button . The result should be listed in the Data Sources panel.

Mask raster with vector¶

Make sure to open the testdatasets for this example
Select enmap_berlin.bsq under Inputs and name it enmap. Further select landcover_berlin_polygon.shp and name it mask.
Under Outputs specify output path and file and name it result

Enter this code in the editor

result = enmap
# set all cells not covered by mask to nodata
result[:, mask[0] == 0] = noDataValue(enmap)
# specify nodata value
setNoDataValue(result, noDataValue(enmap))
# copy metadata to result raster
setMetadata(result, metadata(enmap))

Click the run button . The result should be listed in the Data Sources panel.

Using Raster math for performing both simple and complex raster arithmetics¶

Raster math is a powerful raster calculator inspired by the QGIS Raster calculator, the GDAL Raster calculator and ENVI Band Math. In addition to those tools, Raster math supports multi-band arrays, vector layer inputs, multi-line code snippets and metadata handling.

As a getting started, we load the EnMAP-Box testdata, open Raster math under Applications ‣ Raster math, load and execute the predefined NDVI code snippet:

Using simple expressions¶

Now we can use the Available data sources and the Operators buttons to quickly define an expression. Let’s just mask the enmap_berlin raster layer with the landcover_berlin_polygon vector layer.

In this expression, the enmap_berlin variable is a 3d numpy array with shape [177 bands, ysize, xsize] and landcover_berlin_polygon is a binary 0/1-valued rasterization of the vector geometries, also given as a 3d numpy array with shape [1 band, ysize, xsize].

Note that the output raster is correctly masked, but we haven’t set an appropriate no data value, nor have we taken care of wavelength information or any other source metadata.

Using multi-line code snippets and handle metadata¶

To enable more complex computations and metadata handling, we can use multi-line code snippets.

Let’s advance on the simple expression from above and improve it, by setting a no data value, and proper metadata handling.

Use the Available data sources and the Data / Metadata buttons to quickly define the code snippet.

Using individual bands by band index, band position or wavelength location¶

When using a raster layer inside a calculation, the default is to read all bands into memory. This can be really disadvantageous in case you only need two bands to calculate the NDVI.

For example, you can index into the enmap_berlin array to access the red and nir band:

# find bands
red = enmap_berlin[36]  # band 37 at 653 Nanometers
nir = enmap_berlin[65]  # band 66 at 864 Nanometers

# calculate NDVI
ndvi = (nir - red) / nir + red

But it would be more efficient to access those bands via the special @<band number> syntax. This way, only two bands are mapped into memory as individual arrays of shape [1 band, ysize, xsize]:

red = enmap_berlin@37
nir = enmap_berlin@66

In case of a spectral raster layer, bands can also be accessed via a target wavelength in Nanometers:

red = enmap_berlin@655nm
nir = enmap_berlin@865nm

You may use the Waveband locator for quickly selecting some predefined sensor waveband locations:

Using band masks¶

ToDo

Using advanced band subsetting¶

ToDo

Using special variables and logging feedback¶

ToDo

Running Raster math from command line¶

Like any other processing algorithm, Raster math can be executed from the command line. Here is a simple NDVI example:

Anaconda Prompt:

Activate your QGIS conda environment and use the qgis_process command line tool:

qgis_process run enmapbox:RasterMath -- code="(R1@865nm - R1@655nm) / (R1@865nm + R1@655nm)" R1=enmap_berlin.bsq outputRaster=c:/result/ndvi.tif

OSGeo4W Shell:

As an initial step, run qgis_process-qgis.bat to setup the environment. Now use the qgis_process command line tool:

qgis_process run enmapbox:RasterMath -- code="(R1@865nm - R1@655nm) / (R1@865nm + R1@655nm)" R1=enmap_berlin.bsq outputRaster=c:/result/ndvi.tif

Regression¶

This section will demonstrate a case of image regression using the test dataset. We will regress the sub-pixel fractions of impervious, vegetation, soil and water, derived from a high resolution land cover polygon vector dataset, against the spectral signature of an EnMAP image. So in this case we are performing a multi target regression (more than one response variable), but mind that single target regression works in the same way.

In a preliminary step we are going to convert the polygon dataset to a fraction raster dataset which fits the resolution of the EnMAP raster. This raster will be the regression target, where each band corresponds to the fraction of a landcover class from the polygon dataset inside an EnMAP pixel (so percentage of impervious, vegetation, soil and water, respectively).

In the processing toolbox go to EnMAP-Box ‣ Create Raster ‣ Fraction from Vector. Enter the following settings:
- Pixel Grid: enmap_berlin.bsq
- Vector: landcover_berlin_polygon.shp
- Class id attribute: level_1_id
- Minimal overall coverage: 0.7
- Oversampling factor: 5
- Output Fraction: Click on … and specify an output file path.
Click Run.

EnMAP-Box project showing the input EnMAP image and vector dataset (upper map panel) and the respective fraction bands for impervious, vegetation and soil (water is not shown here)
Now that we have a regression target raster we are going to fit a regression model. In the processing toolbox go to EnMAP-Box ‣ Regression ‣ Fit RandomForestRegressor.
- Select enmap_berlin.bsq as Raster and under Regression specify the output raster from step 1 (the regression target).
- Leave the rest at default and under Output Regressor specify an output file path and click Run
In the next step we will apply the regression to the image. Go to EnMAP-Box ‣ Regression ‣ Predict Regression. Select enmap_berlin.bsq as input Raster and under Regressor click … and select the output .pkl file from the Fit RandomForestRegressor algorithm. Specify an output path (Output Regression) and click Run.

EnMAP image in true colors (left) and RGB visualisation of the regression result (right) where red=impervious, green=vegetation, blue=soil

Transformation (PCA)¶

Several transformation methods are available in the EnMAP-Box. You can find them in the Processing Toolbox under EnMAP-Box ‣ Transformation. The usual way to apply these methods is to use a Fit … algorithm first and then apply it to an image with Transform raster layer.

This recipe demonstrates the basic workflow of applying transformations using a principle component analysis (Fit PCA) and the test dataset.

See also

You can find all the available transformation algorithms here.

Open the test dataset
In the processing toolbox go to EnMAP-Box ‣ Transformation ‣ Fit PCA
- Specify enmap_berlin.bsq under Raster
- Under Output Transformer specify an output file path and click Run
Now open EnMAP-Box ‣ Transformation ‣ Transform raster layer
- Select enmap_berlin.bsq as input Raster
- Under Transformer click … and select the output .pkl file from the Fit PCA algorithm
- Specify an output filepath for the transformed raster under Transformation and click Run
Results of a PCA transformation: input image on the upper left, RGB representation of the first 3 components on the upper right and singleband gray visualisation of the same components on the bottom.

Wavelength Information¶

If wavelength information is defined for each band of a raster image, the EnMAP-Box can use it to easily select pre-defined band combinations or to better compare spectral profiles of sensors with different number of bands.

The wavelength information needs to be defined similar to the ENVI metadata standard:

wavelength units defines the metric unit of the wavelength, e.g. nm, mu, cm,..
wavelength defines the band values in wavelength units, e.g. 450 nm.
fwhm defines the full width at half maximum in wavelength units

Wavelength information can be inspected with the Tools -> Metadata Viewer

In the QGIS python shell, wavelength information can be read as followed:

from enmapbox.gui.utils import parseWavelength, parseFWHM
source = 'path to raster file / QgsRasterLayer / GDAL DataSource'
wavelength, wavelength_unit = parseWavelength(source)
fwhm = parseFWHM(source)
print(wavelength)
print(wavelength_unit)
print(fwhm)

Internally, the EnMAP-Box reads wavelength information via the GDAL metadata model:

from osgeo import gdal
path = r'path to image'
dataset: gdal.DataSet = gdal.Open(path)
print(dataset.GetMetadataItem('wavelength_units', 'ENVI'))
print(dataset.GetMetadataItem('wavelengths', 'ENVI'))

Wavelength information can be set in the same way:

from osgeo import gdal
path = r'path to image'
dataset: gdal.DataSet = gdal.Open(path)
print(dataset.SetMetadataItem('wavelength_units', 'nm', 'ENVI'))
print(dataset.SetMetadataItem('wavelengths', '{490, 560, 665}', 'ENVI'))
dataset.FlushCache()
del dataset

Please note that this will only work if the image is not opened in QGIS!.

User Manual¶

The GUI¶

Toolbar¶

In the toolbar you can find the most common tasks. See table below for information on different buttons and their functionality.

Button	Button Name	Description
	Adds a data source	Here you can add data from different sources, e.g. raster and vector
	Open a map window	Opens a new Map Window
	Open a spectral library window	Opens a new spectral library window
	Open a text window	Opens a new text window, you can for example use it to store metadata, take notes etc.
	Pan Map	Moves the map. Can also be achieved by holding the mouse wheel
	Zoom In	Increases the zoom level. You can also scroll the mouse wheel forward.
	Zoom Out	Decreases the zoom level. You can also scroll the mouse wheel backwards.
	Zoom to native resolution	Zoom to the native resolution
	Zoom to full extent	Changes the zoom level of the map you click to show the full extent of all layers visualized in it
	Identify	Identify locations on the map where you click with the cursor. Use the three options on the right to specify what to identify
	option: Location value	Shows pixel values of all layers at the selected position
	option: Pixel profile	Opens spectral library window (if not opened yet) and plots the spectral profile of the selected pixel
	option: Center map	Moves the map center to the selected cursor location
	Specify the linking between different maps	Opens the Map Linking Dialog

Data Sources¶

The Data Sources panel lists the data in your current project, comparable to the Layers panel in QGIS. The following data types and their corresponding metadata are available:

Raster Data
- File size: Metadata on resolution and extent of the raster
- CRS: Shows Coordinate Reference System (CRS) information
- Bands: Information on overall number of bands as well as band-wise metadata such as name, class or wavelength (if available)
  Note
  
  Depending on the type, raster layers will be listed with different icons:
  - for default raster layers (continuous value range)
  - for mask raster layers
  - for classification raster layers
  Also see section on data types for further information.
Vector Data
- File size: Shows the file size and extent of the vector layer
- CRS: Shows Coordinate Reference System (CRS) information
- Features: Information on number of features and geometry types
- Fields: Attribute information, number of fields as well as field names and corresponding datatype
Spectral Libraries
- File size: Size of the file on hard disk
- Profiles: Shows the number of spectra in the library
Models

Buttons of the Data Sources panel:

Button	Description
	This button lets you add data from different sources, e.g. raster and vector. Same function as .
	Remove layers from the Data Sources panel. First select one or more and then click the remove button.
	Collapses the whole menu tree, so that only layer type groups are shown.
	Expands menu tree to show all branches.
	Synchronizes Data Sources with QGIS.

Tip

If you want to remove all layers at once, right-click in the Data Sources panel and and select Remove all DataSources
The EnMAP-Box also supports Tile-/Web Map Services (e.g. Google Satellite or OpenStreetMap) as a raster layer. Just add them to your QGIS project as you normally would, and then click the ^{Synchronize Data Sources with QGIS} button. Now they should appear in the data source panel and can be added to a Map View.

Data Views¶

The Data Views panel organizes the different windows and their content. You may change the name of a Window by double-clicking onto the name in the list.

Buttons of the Data Views panel:

Button	Description
	Open the Raster Layer Styling panel
	Remove layers from the Data Views panel. First select one or more and then click the remove button.
	Collapses the whole menu tree, so that only layer type groups are shown.
	Expands menu tree to show all branches.

Organization of the Data Views panel:

Example of how different window types and their contents are organized in the Data Views panel. In this case there are two Map Windows and one Spectral Library Window in the project.

Map Window

¶

The map window allows you to visualize raster and vector data. It is interactive, which means you can move the content or zoom in/out.

In order to add a new Map Window click the ^{Open a Map Window} button. Once you added a Map Window, it will be listed in the Data Views panel.
Add layers by either drag-and-dropping them into the Map Window (from the Data Sources list) or right-click onto the layer ‣ Open in existing map…
You can also directly create a new Map Window and open a layer by right-clicking the layer ‣ Open in new map

Linking¶

You can link multiple Map Windows with each other, so that the contents are synchronized. The following options are available:

Link map scale and center
Link map scale
Link map center

In order to link Map Windows, go to View ‣ Set Map Linking in the menu bar, which will open the following dialog:

Here you can specify the above mentioned link options between the Map Windows. You may either specify linkages between pairs or link all canvases at once (the All Canvases option is only specifiable when the number of Map Windows is > 2). Remove created links by clicking .

Demonstration of linking two Map Windows

Crosshair¶

Activate the crosshair by right-clicking into a Map Window and select Crosshair ‣ Show
You can alter the style of the crosshair by right-clicking into a Map Window and select Crosshair ‣ Style

Spectral Library Window

¶

See section on Spectral Libaries

Text Window

¶

Spectral Profile Sources¶

see Section on Spectral Profile Sources

Processing Toolbox¶

The processing toolbox is basically the same panel as in QGIS. Here you can find all EnMAP-Box processing algorithms listed under EnMAP-Box. In case it is closed/not visible you can open it by clicking the button in the menubar or View ‣ Panels ‣ QGIS Processing Toolbox.

See QGIS Documentation - The toolbox for further information.

Cursor Location Values¶

This tools lets you inspect the values of a layer or multiple layers at the location where you click in the map view. To select a location (e.g. pixel or feature) use the ^{Select Cursor Location} button together with the ^{Identify cursor location value} option activated and click somewhere in the map view.

The Cursor Location Value panel should open automatically and list the information for a selected location. The layers will be listed in the order they appear in the Map View. In case you do not see the panel, you can open it via View ‣ Panels ‣ Cursor Location Values.

By default, raster layer information will only be shown for the bands which are mapped to RGB. If you want to view all bands, change the Visible setting to All (right dropdown menu). Also, the first information is always the pixel coordinate (column, row).
You can select whether location information should be gathered for All layers or only the Top layer. You can further define whether you want to consider Raster and Vector layers, or Vector only and Raster only, respectively.
Coordinates of the selected location are shown in the x and y fields. You may change the coordinate system of the displayed coordinates via the ^{Select CRS} button (e.g. for switching to lat/long coordinates).

Spectral Libraries¶

A Spectral Library is a collection of profiles with arbitrary profile-wise data and metadata, stored as pickled dictionaries inside (multiple) binary fields. Dictionary items are:

x: list of x values (e.g. wavelength)
y: list of y values (e.g. surface reflectance)
xUnit: x value units (e.g. nanometers)
yUnit: y value units (e.g. ???)
bbl: the bad bands list

Spectral Library Window ¶

The Spectral Library Window can be used to visualize, collect and label spectra. It directly interacts with the Map Window(s), which means spectra can be directly collected from an image. Furthermore, external libraries (ENVI Spectral Library) can be imported.

Add a new spectral library window by using the Add Spectral Library Window button in the toolbar or open a new window from the menu bar View ‣ Add Spectral Library Window.

A new view appears where you can start to collect spectra.

Overview of the Spectral Library Window with several collected and labeled spectra and main tools

To import an existing library use the Import Spectral Library button.
Possible formats to be imported: ENVI Spectral Library, Geopackage, ASD Field Spectrometer measurements, Raster Layer.

You can also import ASD Field Spectrometer measurements and map and modify the imported profiles and attributes accordingly.

Buttons of the Spectral Library Window:

Button	Description
	Adds currently overlaid profiles to the spectral library
	Activate to add profiles automatically into the spectral library
	Import Spectral Library
	Save Spectral Library
	Activate to change spectra representation
	Activate to use colors from map vector symbology
	Enter the Spectral Library Layer Properties
	Toggle editing mode
	Toggle multi editing mode
	Save edits
	Reload the table
	Add feature
	Delete selected features
	Cut selected rows to clipboard
	Copy selected rows to clipboard
	Paste features from clipboard
	Select by Expression
	Selects all elements in the spectral library
	Inverts the current selection
	Remove selection (deselect everything)
	Move selection to the top
	Select / filter features using form
	Pan map to selected rows
	Zoom map to selected rows
	Add New field
	Delete field
	Conditional formatting
	Actions
	Switch to form view
	Switch to table view
	Spectral Processing Dialog
	Enables the calculation of new attribute fields

Spectral Profile Sources¶

This menu manages the connection between raster sources and spectral library windows.

Overview of the Spectral Profile Sources Window with two labeled spectra and main functionalities

Buttons of the Profile Sources

Button	Description
	add a new profile source entry
	remove selected entries

Profiles

Define the input data from where to take the spectral information from.

Style

Change style of displayed spectra, i.e. symbol and color

Source

Specify a source raster dataset
Double-clicking in the cell will open up a dropdown menu where you can select from all loaded raster datasets.

Sampling

Select Single Profile or Kernel by double-clicking into the cell.

Scaling

Choose how spectra are sampled.
Define the scaling factors by setting the Offset and Scale value.

Option	Description
SingleProfile	Extracts the spectral signature of the pixel at the selected location
Sample3x3	Extracts spectral signatures of the pixel at the selected location and its adjacent pixels in a 3x3 neighborhood.
Sample5x5	Extracts spectral signatures of the pixel at the selected location and its adjacent pixels in a 5x5 neighborhood.
Sample3x3Mean	Extracts the mean spectral signature of the pixel at the selected location and its adjacent pixels in a 3x3 neighborhood.
Sample5x5Mean	Extracts the mean spectral signature of the pixel at the selected location and its adjacent pixels in a 5x5 neighborhood.

Calculating profiles

Different spectral profiles can be calculated in the Spectral Profile Sources window.

Add a new column in the attribute table with a meaningful name and select Type Spectral Profile
In the Spectral Profile Sources window navigate to the newly created attribute, select the Source and switch from Single Profile to Kernel.
Choose the Kernel you want to use and the Aggregation method.

Collect spectra in the image and visualize the profiles in different colors using the visualization settings.
Change the color of the different profiles (see also section Colorize spectra by attribute).

Working with the Spectral Library¶

Collecting spectra¶

Make sure to enable the button in the menu bar and open a raster from which you want to collect spectra in a new Map Window.
Click on a desired location in the Map Window. The pixels spectral profile at this location will now be shown in the plot in the Library Window. Mind that this will only visualize the spectrum, but nothing is saved at this point.
To add/save a selected spectrum to the library, click the button: A new table entry on the right of the window is added.
If spectra should be added automatically to the library while a pixel is selected or clicked, enable the button.

Tip

Have a look at the Spectral Profile Sources window for more advanced settings collecting spectra.

If you want to only collect spectra for one class, e.g. water, define the class in the Spectral Profile Source view under the desired column name, e.g. level_1. If you now click into the image, the spectra is automatically added and named as water in the previously specified column.

_images/SpecLib_collectProfilesByName.gif

The attribute table¶

Adding information

Add additional fields to the table, e.g. in order to add information to every spectrum (id, name, classification label, …).
Enable the Editing mode by activating .
Now you can use the button to add a new field (mind the type!).

After the new column is added, you can add information by double-clicking it.
To delete a column, use the Delete field button
When you add a new attribute to the table, you can also choose to use it to store new spectral profiles by checking the Use to store spectral profiles checkbox.
String, text and binary format can be used to store spectral profiles.

Adding information through layer properties window

It is also possible to add new information to the attribute table in the Layer Properties of the Spectral Library.

Click on to open the spectral library properties.
Navigate to the Fields tab and add a new field.

Furthermore, you can define a default widget for the different columns in the attribute table.

Switch to the Attributes Form tab, select the desired column and choose a certain widget type, e.g. a default range, color, spectral profiles etc.

The field calculator

The field calculator allows you to modify or assess spectra and calculate new columns or modify existing ones.

Open the field calculator and search for spectralData or spectralMath in the Spectral Libraries tab.

SpectralMath allows you to modify spectral profiles with Python code.

To use the SpectralMath function, select a field from which the spectral profiles are to be taken, define an expression and the format, e.g. text or binary, in which the new profile is to be saved.

SpectralData returns spectral profile values.

Description	Example
Multiply the existing profiles	spectralMath(“profiles”, ‘y =2’, ‘text’)*
Create a new profile with x and y values	spectralMath(‘x,y=[1,2,3],[20,30,25]’)
Return spectral profile values from map with spectral data from spectral profiles in field column “profiles”	spectralData(“profiles”)
Return xUnit string of the spectral profile e.g. ‘nm’ for wavelength unit	spectralData(“profiles”)[‘xUnit’]

Selecting spectra

Spectra can be selected in the attribute table and in the plot window itself. Selected spectra will be highlighted (blue background in the table; thicker line in a different color in the plot window).

Hold the Shift key to select multiple spectra.
A selection can be removed by clicking the button.

Selected spectra can be removed by using the button.
Save the collected spectra with the Save Profiles in Spectral Library button.

Tip

You can inspect an individual value of a spectrum by holding the Alt key and clicking some position along the spectrum

You can also select and filter spectra with the common vector filter and selection tools, e.g. select spectra by expression:

Show coordinates of collected spectra in map view

Locations of spectra (if available) can be visualized as a point layer by right-clicking into the map window, and selecting Add Spectral Library

Visualization settings¶

Overview of the visualization settings in the Spectral Library window

The visualization settings of the spectral library allow you to customize the view according to your needs. You can either choose predefined themes, e.g. dark or bright. Or select the color that you want.

Moreover, activate or deactivate the crosshair and choose a color.
Once the crosshair ist activated and colored, you can move the crosshair via the control and arrow buttons on your keyboard and save a profile to the speclib with Ctrl + S.
The Current Profiles section shows you all the spectra that have been collected but do not yet appear in the attribute table. To add the spectra to the attribute table, first activate the button.

Changing the units

You can change the units of the axis by either right-clicking into the spectral library and navigating to the respective option. Or in the visualization settings under General Settings

Colorize spectra by attribute:

Spectra can be colorized according to their attributes, e.g. their class name.

In the Data Views section on the left, right click on the spectral library data that we are currently using and select the Layer Properties
Switch to the Symbology tab and select the Categorized renderer at the top
In the Column droplist select the desired column and click Classify
Confirm with Ok and close the window.

In the Spectral Library Window activate the visualization settings with the button.
Right-click on Color and select Use vector symbol colors .

Spectral Processing¶

The idea of spectral processing is to use the spectral profiles obtained from a raster image to test and modify raster algorithms, i.e. the spectral profiles are transferred to a temporary raster image and thus different algorithms can be calculated.

Each column of the spectral library attribute table is derived and translated into meaningful temporary raster image values, regardless of the column type.

Text fields (strings) are converted to a one-band classification grid, profile fields are translated to a multi-band grid, and numeric fields are converted to a 1-band grid.

To use the Spectral Processing tool open and choose the desired algorithm, e.g. Spectral resampling.
Select the input profiles to be translated to the temporary raster layer and specify the outputs. Select an existing field or enter a name to create a new field.

Labelled Spectral Library¶

The labelled spectral library extents the default .sli format by adding additional metadata information (e.g., class labels, class colors). This information is stored by adding a .csv and .json file to the default spectral library, so that the labelled spectral library consists of

.sli file (ENVI standard)
.hdr file (ENVI standard)
.csv file (containing the additional information)
- should be comma-separated csv
- should have same basename as .sli file
- first row stores the headers, where the first element has to be the spectra names as specified in the .hdr file:
- Example from the EnMAP-Box test dataset:

.json file (stores class name and class color information)

should have same basename as .sli file

class name and color information should be provided for every attribute in the csv:

{
  "attribute_name": {
    "categories":  [
      [0, "unclassified", [0, 0, 0]],
      [1, "class1", [230, 0, 0]],
      [2, "class2", [56, 168, 0]],
      [3, "class3", [168, 112, 0]],
      [4, "class4", [0,100,255]]
    ],
    "no data value": 0,
    "description": "Classification"
}

The keys categories, no data value and description should not be altered. But change attribute_name according to your data.
no data value should be supplied
Example from the EnMAP-Box test dataset:

Tools¶

Image Statistics¶

The image statistics tool provides access to basic summary statistics for each raster band. Those statistics are reported in a table and can be visualized as a histogram. It can be opened from the menu bar via Tools ‣ ImageStatistics

In order to calculate the statistics, select a desired raster dataset under Raster.
Optionally, you can specify a Mask in order to only include a subset of pixels.
Under Accuracy you can specify whether the statistics will be calculated based on a random subset of the data (Estimated) or using the complete dataset (Actual). Using a subset will be faster.
Histogram bins: Choose between different algorithms used to calculate the size/number of histogram bins.
Click the button to start the calculation of the image statistics.

Image Statistics tool
After the calculation is complete, a tabular representation of the results is shown.
In order to show a histogram of a bands value distribution, select a row in the table.
Multiple histograms can be plotted by activating the button
In order to show all possible histograms (i.e., one histogram for each band) click the button.
Check the button in order to only draw lines of the histogram (advised if multiple are plotted)

Scatterplot¶

The Scatterplot tool allows you to plot the values of two bands against each other. It can be opened from the menu bar via Tools ‣ Scatterplot. You can specify the following settings:

Band X: Choose the raster (first dropdown menu) and the band (second dropdown menu) to be plotted on the X-axis. Min and Max depict the limits of the axis. By default, Min and Max will be automatically derived. You can also manually specify the limits of the axis by entering another value.

Band Y: Same as above, just for the Y-axis.

Mask (optional): You can specify a mask here, so that pixels which are covered by the mask will not be included in the scatterplot.

Accuracy: Can either be set to Estimated (faster) or Actual (slower). Defines whether to use a subset of pixels for calculation or all of them.

Number of Bins: Defines the number of bins in x and y direction.

After you entered all settings, click the button to create the plot.

Screenshot of the Scatter Plot Tool

Scatterplot Navigation

The plot window is interactive, which means you can zoom in and out using the mouse.
Reset the plot window to the default zoom level by clicking the button in the lower left of the plot window.
Right-clicking inside the plot offers you several additional options.
Change the color scheme of the plot by right-clicking into the color bar on the right.

ROI

The ROI option allows you to select a rectangular region in the scatterplot, for which the density distribution will be displayed in a second plot window below.

Click the ROI button to open up the ROI functionality. Mind how a small rectangle appears at the bottom left of the plot (usually between the values 0 and 10, depending on your axis scaling you have to zoom in order to see it properly). Clicking and holding the circle allows you to change the rotation of the rectangle, while clicking and holding the square you can change the size of it.
Close the ROI mode by clicking on the ROI button again.

Metadata editor¶

Reclassify¶

The reclassify tool is a convenient graphical user interface for reclassifying classification rasters.

Specify the file you want to reclassify under Input File. Either use the dropdown menu to select one of the layers which are already loaded or use the button to open the file selection dialog.

Under Output Classification you can specify the classification scheme of the output classification which will be created.

You can import schemes from existing rasters or text files by clicking the button.
Use the button to manually add classes.
To remove entries select the respective rows and click the button.
So save a classification scheme select the desired classes (or use Crtl + A to select all) and click on the button.
Likewise, you can copy and paste classes by selecting them and clicking the ^{Copy Classes} ^{Paste Classes} buttons.

The table is sorted by the Label field in ascending order. The value in Label will become the pixel value of this class and can not be altered.
Double-click into the Name field in order to edit the class name.
Double-click into the Color field to pick a color.

Under Class Mapping you can reassign the old classes (From) to values of the new classification scheme (To)

Specify the output path for the reclassified image under Output File

Click OK to run the tool.

Image Cube¶

The Image Cube tool visualizes a raster image in an interactive 3D view:

Select the raster image.
Specify the:
- Top Plane renderer. It can be any raster renderer known from QIGS, e.g. a Multiband
  
  color renderer that shows the true color bands
- Cube & Slice renderer. This must be a render that uses a single band only, e.g. a Singleband grey or Pseudocolor renderer. It will colorize the band-related pixel values of the 3D image cube and planes relating to the X, Y or Z slice.
Press Load Data to (re)load and render the raster image values.

The 3D scene contains the following elements:

Top Plane - a raster layer for spatial orientation
Image Cube - a volumetric representation of the raster image, showing the raster bands on the z axis
X Slice - a slice along the raster’s X / column / sample dimension
Y Slice - a slice along the raster’s Y / row / line dimension
Z Slice - a slice along the raster’s Z / band dimension
Box (Image) - a 3D bounding box along the maximum image extent
Box (Subset) - a 3D bounding box to show the extent of the spatial subset that migh be used to focus on specific image areas

Virtual Raster Builder¶

See https://virtual-raster-builder.readthedocs.io/en/latest/

Applications¶

ImageMath¶

Regression-based unmixing (synthMix)¶

You can find the Regression-based unmixing in the menu bar Applications ‣ Regression-based unmixing (synthMix)

See also

Have a look at the Urban Unmixing Tutorial for a use case example of the Regression-based unmixing Application.

Input Parameters:

Inputs
- Endmember Library: Select spectral library
- Class Attribute: Specify the attribute which contains class/material information.
- Spectral Image: Specify spectral image on which unmixing should be applied.
Class Selection
- Target Classes : Specify the desired target classes (which are derived from the Class Attribute field specified above). Can be used to select only a subset of target classes from a spectral library.
Mixing Parameters
- Number of Synthetic Mixtures per Class: Amount of mixtures to be generated per class.
- Include Original Library Endmembers : Whether to include the original spectra in the training library.
- Mixing Complexity Probabilities: Defines the likelihood of creating a binary, ternary or fourfold mixture. For example, by specifing the probabilities as 0.5, 0.5, 0, it is equally likely that binary and ternary mixtures are created, whereas no fourfold mixtures will be generated. Enter decimals between 0.0-1.0 (all three probabilities need to sum up to 1).
  - 2EM: Likelihood of creating a binary mixture (2 endmembers)
  - 3EM: Likelihood of creating a ternary mixture (3 endmembers)
  - 4EM: Likelihood of creating a fourfold mixture (4 endmembers)
- Allow Within-Class Mixtures : Whether to allow mixtures between signatures of the same endmember.
- Class Probabilities (Proportional | Equalized): In case of proportional class probabilities the number of mixtures of a class in the output library will be proportional to the number of spectra in the input library of that class. In case of equalized, all classes will be represented equally.
Regression Algorithm

In the Regressor dropdown menu you can choose different regressors (e.g. Random Forest, Support Vector Regression, Kernel Ridge Regression)

Model parameters: Specify the parameters of the selected regressor.

Hint

Scikit-learn python syntax is used here, which means you can specify model parameters accordingly. Have a look at the scikit-learn documentation on the individual parameters, e.g. for the RandomForestRegressor

Use Ensemble : If enabled, more than one iteration of mixing, training and prediction will be performed. The results of each iteration will be combined into a final ensemble result (see Decision Fusion (Ensemble) on how results should be combined).

Ensemble Size: Specify the size of the ensemble (number of iterations).

Outputs

Folder: Specify an output folder where results will be written to.

Name: Basename of the output files

Advanced

Decision Fusion (Ensemble) (median | mean | iqr | std): Select one or multiple options of the kind of decision fusion (how individal predictions of the ensemble will be combined)

Save Check the following to save additional outputs …

Training Samples : Save the training samples

Predictions : Save the individual predictions of the ensemble

Models : Save the model files

Create Class Fraction RGB : Generates a RGB visualisation based on the weighted sum of class colors and corresponding fractions

Derive Classification from Fraction Map : Save classification from fraction map (class with the highest fraction will be assigned)

Run the regression-based unmixing

Once all parameters are entered, press the button to start the regression-based unmixing.

Classification Workflow¶

You can find this application in the menu bar Applications ‣ Classification Workflow

The Classification Workflow application let’s you easily perform classification analysis and mapping tasks using remote sensing data.

Quick Mapping¶

In the Quick Mapping section you can very easily define your training dataset, fit a classifier and predict a classification layer, with only a few clicks.

E.g. use EnMAP-Box testdata together with a Random Forest classifier:

For a more elaborated analysis see the Detailed Analysis section.

Detailed Analysis¶

In the Detailed Analysis section you have more control over individual analysis steps. When performing a detailed analysis, you can basically go through every subsection from left to right. But, depending on the usecase, it is also possible to skip individual steps you’re not interested in.

Dataset¶

You have various options to create a dataset for subsequent analysis: select a Source option and click create dataset to create a new dataset`.

In the Editor, category colors and names, and feature names can be changed and saved.

By using the various controls in the Draw samples section, you can easily define a training-test-split setup. The number of training and test samples to be drawn for each category are listed, and also editable, inside the Editor.

Click split dataset to perform the split, resulting in a training and a test dataset, that can be used in subsequent analysis.

Classifier¶

In the Classifier section you can either select a Predifined classifier or provide a user-defined Python Code snipped. See the https://scikit-learn.org/ documentation for a complete overview.

Click create classifier to create an (unfitted) classifier, that can be used in subsequent analysis.

Feature Clustering¶

In the Feature Clustering section you can perform an unsupervised Feature redundancy analysis, that clusters similar features together: select a Dataset, an Algorithm and click cluster features to create and an Output report.

After inspecting the report you can perform a Feature subset selection: select a suitable Number of features and click select features to create a training and a test dataset with fewer features, that are less correlated and can be used in subsequent analysis.

Feature Ranking¶

In the Feature Ranking section you can perform a supervised Feature importance analysis, that ranks features in terms of their importance for the classification task at hand: select a Dataset, an Algorithm and click :guilabel:`rank features to create and an Output report.

After inspecting the report you can perform a Feature subset selection: select a suitable Number of features and click select features to create a training and a test dataset with fewer features, that are most important and can be used in subsequent analysis.

Model¶

In the Model section you can perform Model fitting: select a Dataset and click fit classifier to create a fitted Output classifier, that is used in subsequent analysis.

For Model performance analysis select an Algorithm and click assess performance to create an Output report.

Classification¶

In the Classification section you can perform Map prediction: select a Raster layer with features that matches the features used in Model fitting. Click predict output products to create an Output classification layer and/or an Output class probability layer. Note that outputs are opened inside the EnMAP-Box Data Sources panel.

For Map accuracy and area estimation select a Ground truth categorized layer and click assess performance to create an Output report.

Settings¶

In the Settings section you can specify the Output directory (e.g. C:/Users/USERNAME/AppData/Local/Temp/EnMAPBox/ClassificationWorkflow), that is used as the default file destination path, when creating file outputs. Note that each output file wigdet (e.g. Output dataset) has a default basename (e.g. dataset.pkl), that is used to create a default file destination (e.g. C:/Users/USERNAME/AppData/Local/Temp/EnMAPBox/ClassificationWorkflow/dataset.pkl). If the default file destination already exists, the basename is enumerated (e.g. .dataset_2.pkl) to avoid overwriting existing outputs.

Log¶

Classification Workflow Classic¶

You can find this application in the menu bar Applications ‣ Classification Workflow Classic

Classification Workflow Application

See also

Have a look at the Getting Started for a use case example of the Classification Workflow Application.

Input Parameters:

Training Inputs
- Type
  
  Three different types of input data sources are supported and have to be specified beforehand in the dropdown menu. Depending on the selected input type the user interface shows different options.
  - Raster / Classification:
    - Raster: Specify input raster based on which samples will be drawn for training a classifier.
    - Classification: Specify input raster which holds class information.
  - Raster / Vector Classification:
    - Raster: Specify input raster based on which samples will be drawn for training a classifier.
    - Reference: Specify vector dataset with reference information. Has to have a column in the attribute table with a unique class identifier (numeric). The class colors and labels are derived from the current Symbology. To set or change those settings, click the button or go to the Layer Properties (Layer properties ‣ Symbology). The vector dataset is rasterized/burned on-the-fly onto the grid of the input raster in order to extract the sample. If the vector source is a polygon dataset, only polygons which cover more than 75% of a pixel in the target grid are rasterized.
  - labelled Library:
    - Library: Specify input spectral library.
Sampling

Once you specified all inputs in the Training inputs section, you can edit the class colors, names and class sample sizes in the Sampling submenu.

Note

If set, the class labels and color information is automatically retrieved from the layers current renderer settings (Layer properties ‣ Symbology).
- Sample size Specify the sample size per class, either relative in percent or in absolute pixel counts.
- The total sample size is shown below
- Save sample: Activate this option and specify an output path to save the sample as a raster.
Training
- In the Classifier dropdown menu you can choose different classifiers (e.g. Random Forest, Support Vector Machine)
- Model parameters: Specify the parameters of the selected classifier.
  
  Hint
  
  Scikit-learn python syntax is used here, which means you can specify model parameters accordingly. Have a look at the scikit-learn documentation on the individual parameters, e.g. for the RandomForestClassifier
- Save model: Activate this option to save the model file (.pkl) to disk.
Mapping
- Raster: Specify the raster you would like to apply the trained classifier to (usually -but not necessarily- this is the same as used for training)
- Mask: Specify a mask layer if you want to exclude certain areas from the prediction.
  - Outputs:
    
    Classification: Output path where to write the classification image to.
    
    Probability: Output path of the class probability image.
    
    Hint
    
    This outputs the result of a classifiers predict_proba method. Note that depending on the classifier this option might not be available or has to be activated in the model parameters (e.g. for the Support Vector Machine, the line svc = SVC(probability=False) has to be altered to svc = SVC(probability=True)
    
    RGB: Generates a RGB visualisation based on the weighted sum of class colors and class probabilities.
Cross-validation Accuracy Assessment
- Cross-validation with n-folds : Activate this setting to assess the accuracy of the classification by performing cross validation. Specify the desired number of folds (default: 3). HTML report will be generated at the specified output path.

Run the classification workflow

Once all parameters are entered, press the button to start the classification workflow.

Regression Workflow¶

You can find the Regression Workflow in the menu bar Applications ‣ Classification Workflow

See also

Have a look at the Biomass Mapping Tutorial for a use case example of the Regression Workflow Application.

Input Parameters:

Training Inputs
- Raster: Specify input raster based on which samples will be drawn for training a regressor.
- Reference: Specify vector or raster dataset with reference information (regression target). In case of vector input, dataset has to have a numeric column in the attribute table with a target variable of interest. This vector dataset is rasterized/burned on-the-fly onto the grid of the input raster in order to extract the sample. If the vector source is a polygon dataset, all pixels will be drawn which intersect the polygon.
- Attribute: Attribute field in the reference vector layer which contains the regression target variable.
Sampling
- Number of Strata : Specify the desired number of strata sampling. If you don’t want to use stratified sampling, just enter 1.
- Min & Max: Defines the value range in which samples should be drawn.
- Sample size : Specify the sample size per stratum, either relative in percent or in absolute pixel counts.
  
  Every stratum is listed below with the value range that is covered by this stratum depicted in square brackets (e.g., Stratum 1: [1.0, 4.33]). Furthermore, you can see and alter the number of pixels/samples for each stratum using the spinboxes.
- Save sample: Activate this option and specify an output path to save the sample as a raster.
Training
- In the Regressor dropdown menu you can choose different regressors (e.g. Random Forest, Support Vector Regression, Kernel Ridge Regression)
- Model parameters: Specify the parameters of the selected regressor.
  
  Hint
  
  Scikit-learn python syntax is used here, which means you can specify model parameters accordingly. Have a look at the scikit-learn documentation on the individual parameters, e.g. for the RandomForestRegressor
- Save model: Activate this option to save the model file (.pkl) to disk.
Mapping
- Input Raster: Specify the raster you would like to apply the trained regressor to (usually -but not necessarily- this is the same as used for training)
Cross-validation Accuracy Assessment
- Cross-validation with n-folds : Activate this setting to assess the accuracy of the regression by performing cross validation. Specify the desired number of folds (default: 3). HTML report will be generated at the specified output path.

Run the regression workflow

Once all parameters are entered, press the button to start the regression workflow.

EO Time Series Viewer¶

Please visit EO Time Series Viewer Documentation for more information.

Agricultural Applications¶

Please visit LMU Vegetation Apps Documentation for more information.

Processing Algorithms¶

Auxilliary¶

Create default paletted raster renderer¶

Create a paletted raster renderer from given categories and set it as the default style of the given raster layer. This will create/overwrite the QML sidecar file of the given raster layer.

Parameters

Raster layer [raster]: The raster layer for which to create the QML sidecar file.
Band [band]: The renderer band.
Categories [string]: Comma separated list of tuples with category value, name and color information. E.g. (1, ‘Urban’, ‘#FF0000’), (2, ‘Forest’, ‘#00FF00’), (3, ‘Water’, ‘#0000FF’)

Command-line usage

>qgis_process help enmapbox:CreateDefaultPalettedRasterRenderer:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
band: Band
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
categories: Categories
    Argument type:  string
    Acceptable values:
            - String value

----------------
Outputs
----------------

Classification¶

Class fraction layer from categorized vector layer¶

Rasterize a categorized vector layer into class fractions. Categories are rasterized at a x10 finer resolution and aggregated to class-wise fractions at destination resolution. This approach leads to fractions that are accurate to the percent.

Parameters

Categorized vector layer [vector]: A categorized vector layer to be rasterized.
Grid [raster]: The target grid.

Outputs

Output class fraction layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ClassFractionLayerFromCategorizedVectorLayer:

----------------
Arguments
----------------

categorizedVector: Categorized vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
grid: Grid
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
outputFraction: Output class fraction layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputFraction: <outputRaster>
    Output class fraction layer

Classification layer accuracy and area report (for simple random sampling)¶

Estimates map accuracy and area proportions for (simple) random sampling. We use the formulars for the stratified random sampling described in Stehman (2014): https://doi.org/10.1080/01431161.2014.930207. Note that (simple) random sampling is a special case of stratified random sampling, with exactly one stratum. Observed and predicted categories are matched by name.

Parameters

Predicted classification layer [raster]

A classification layer that is to be assessed.

Observed categorized layer [layer]

A categorized layer representing a (ground truth) observation sample, that was aquired using a (simple) random sampling approach.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:ClassificationLayerAccuracyAndAreaReportForSimpleRandomSampling:

----------------
Arguments
----------------

classification: Predicted classification layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
reference: Observed categorized layer
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outClassificationPerformance: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outClassificationPerformance: <outputHtml>
    Output report

Classification layer accuracy and area report (for stratified random sampling)¶

Estimates map accuracy and area proportions for stratified random sampling as described in Stehman (2014): https://doi.org/10.1080/01431161.2014.930207. Observed and predicted categories are matched by name.

Parameters

Predicted classification layer [raster]

A classification layer that is to be assessed.

Observed categorized layer [layer]

A categorized layer representing a (ground truth) observation sample, that was aquired using a stratified random sampling approach.

Stratification layer [layer]

A stratification layer that was used for drawing the observation sample. If not defined, the classification layer is used as stratification layer.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:ClassificationLayerAccuracyAndAreaReportForStratifiedRandomSampling:

----------------
Arguments
----------------

classification: Predicted classification layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
reference: Observed categorized layer
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
stratification: Stratification layer (optional)
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outClassificationPerformance: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outClassificationPerformance: <outputHtml>
    Output report

Classification layer from class probability/fraction layer¶

Creates classification layer from class probability layer or class fraction layer. Winner class is given by the class with maximum class probabiliy/fraction.

Parameters

Class probability layer [raster]: A class probability layer or class fraction layer to be classified.

Outputs

Output classification layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ClassificationLayerFromClassProbabilityfractionLayer:

----------------
Arguments
----------------

probability: Class probability layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
outputClassification: Output classification layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputClassification: <outputRaster>
    Output classification layer

Classification workflow¶

The classification workflow combines classifier fitting, map prediction and accuracy assessment.

Parameters

Training dataset [file]

Training dataset pickle file used for fitting the classifier.

Classifier [string]

Scikit-Learn Python code specifying a classifier.

Raster layer with features [raster]

A raster layer with bands used as features.

Number of cross-validation folds [number]

The number of folds used for assessing cross-validation performance.

Default: 10

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output classifier [fileDestination]: Destination pickle file.
Output classification layer [rasterDestination]: Raster file destination.
Output class probability layer [rasterDestination]: Raster file destination.
Output classifier performance report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:ClassificationWorkflow:

----------------
Arguments
----------------

dataset: Training dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
classifier: Classifier
    Argument type:  string
    Acceptable values:
            - String value
raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
nfold: Number of cross-validation folds (optional)
    Default value:  10
    Argument type:  number
    Acceptable values:
            - A numeric value
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file
outputClassification: Output classification layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputProbability: Output class probability layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputClassifierPerformance: Output classifier performance report (optional)
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier
outputClassification: <outputRaster>
    Output classification layer
outputProbability: <outputRaster>
    Output class probability layer
outputClassifierPerformance: <outputHtml>
    Output classifier performance report

Classifier performance report¶

Evaluates classifier performance.

Parameters

Classifier [file]

Classifier pickle file.

Test dataset [file]

Test dataset pickle file used for assessing the classifier performance.

Number of cross-validation folds [number]

The number of folds used for assessing cross-validation performance. If not specified (default), simple test performance is assessed.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:ClassifierPerformanceReport:

----------------
Arguments
----------------

classifier: Classifier
    Argument type:  file
    Acceptable values:
            - Path to a file
dataset: Test dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
nfold: Number of cross-validation folds (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputClassifierPerformance: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifierPerformance: <outputHtml>
    Output report

Fit CatBoostClassifier¶

Implementation of the scikit-learn API for CatBoost classifier.

Parameters

Classifier [string]

Scikit-learn python code. See CatBoostClassifier for information on different parameters.

Default:

from catboost import CatBoostClassifier
classifier = CatBoostClassifier(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitCatboostclassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from catboost import CatBoostClassifier
classifier = CatBoostClassifier(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit GaussianProcessClassifier¶

Gaussian process classification (GPC) based on Laplace approximation. The implementation is based on Algorithm 3.1, 3.2, and 5.1 of Gaussian Processes for Machine Learning (GPML) by Rasmussen and Williams. Internally, the Laplace approximation is used for approximating the non-Gaussian posterior by a Gaussian. Currently, the implementation is restricted to using the logistic link function. For multi-class classification, several binary one-versus rest classifiers are fitted. Note that this class thus does not implement a true multi-class Laplace approximation. See Gaussian Processes for further information.

Parameters

Classifier [string]

Scikit-learn python code. See GaussianProcessClassifier for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

gpc = GaussianProcessClassifier(RBF(), max_iter_predict=1)
classifier = make_pipeline(StandardScaler(), gpc)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitGaussianprocessclassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF

gpc = GaussianProcessClassifier(RBF(), max_iter_predict=1)
classifier = make_pipeline(StandardScaler(), gpc)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit generic classifier¶

A generic classifier.

Parameters

Classifier [string]

Scikit-learn python code.

Default:

from sklearn.dummy import DummyClassifier

classifier = DummyClassifier()

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitGenericClassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.dummy import DummyClassifier

classifier = DummyClassifier()
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit LGBMClassifier¶

Implementation of the scikit-learn API for LightGBM classifier.

Parameters

Classifier [string]

Scikit-learn python code. See LGBMClassifier for information on different parameters.

Default:

from lightgbm import LGBMClassifier
classifier = LGBMClassifier(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitLgbmclassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from lightgbm import LGBMClassifier
classifier = LGBMClassifier(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit LinearSVC¶

Linear Support Vector Classification. Similar to SVC with parameter kernel=’linear’, but implemented in terms of liblinear rather than libsvm, so it has more flexibility in the choice of penalties and loss functions and should scale better to large numbers of samples. This class supports both dense and sparse input and the multiclass support is handled according to a one-vs-the-rest scheme.

Parameters

Classifier [string]

Scikit-learn python code. See LinearSVC, GridSearchCV, StandardScaler for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC

svc = LinearSVC()
param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVC = GridSearchCV(cv=3, estimator=svc, scoring='f1_macro', param_grid=param_grid)
classifier = make_pipeline(StandardScaler(), tunedSVC)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitLinearsvc:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC

svc = LinearSVC()
param_grid = {'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVC = GridSearchCV(cv=3, estimator=svc, scoring='f1_macro', param_grid=param_grid)
classifier = make_pipeline(StandardScaler(), tunedSVC)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit LogisticRegression¶

Logistic Regression (aka logit, MaxEnt) classifier. In the multiclass case, the training algorithm uses the one-vs-rest (OvR) scheme if the ‘multi_class’ option is set to ‘ovr’, and uses the cross-entropy loss if the ‘multi_class’ option is set to ‘multinomial’.

Parameters

Classifier [string]

Scikit-learn python code. See LogisticRegression for information on different parameters.

Default:

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
logisticRegression = LogisticRegression()
classifier = make_pipeline(StandardScaler(), logisticRegression)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitLogisticregression:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
logisticRegression = LogisticRegression()
classifier = make_pipeline(StandardScaler(), logisticRegression)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit RandomForestClassifier¶

A random forest classifier. A random forest is a meta estimator that fits a number of decision tree classifiers on various sub-samples of the dataset and uses averaging to improve the predictive accuracy and control over-fitting. The sub-sample size is controlled with the max_samples parameter if bootstrap=True (default), otherwise the whole dataset is used to build each tree.

Parameters

Classifier [string]

Scikit-learn python code. See RandomForestClassifier for information on different parameters.

Default:

from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=100, oob_score=True)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitRandomforestclassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.ensemble import RandomForestClassifier
classifier = RandomForestClassifier(n_estimators=100, oob_score=True)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit SpectralAngleMapper¶

Spectral Angle Mapper (SAM). Samples are first normalizes to the unit sphere and then classified using nearest neighbour. See Docs Center > Using ENVI > Spectral Angle Mapper for a more details description.

Parameters

Classifier [string]

Scikit-learn python code. See Normalizer, KNeighborsClassifier for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import Normalizer
from sklearn.neighbors import KNeighborsClassifier

classifier = make_pipeline(Normalizer(), KNeighborsClassifier(n_neighbors=1))

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitSpectralanglemapper:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import Normalizer
from sklearn.neighbors import KNeighborsClassifier

classifier = make_pipeline(Normalizer(), KNeighborsClassifier(n_neighbors=1))
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit SVC (polynomial kernel)¶

C-Support Vector Classification. The implementation is based on libsvm. The fit time scales at least quadratically with the number of samples and may be impractical beyond tens of thousands of samples. The multiclass support is handled according to a one-vs-one scheme.

Parameters

Classifier [string]

Scikit-learn python code. See SVC, GridSearchCV, StandardScaler for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

svc = SVC(probability=False)
param_grid = {'kernel': ['poly'],
              'coef0': [0],
              'degree' : [3],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVC = GridSearchCV(cv=3, estimator=svc, scoring='f1_macro', param_grid=param_grid)
classifier = make_pipeline(StandardScaler(), tunedSVC)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitSvcPolynomialKernel:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

svc = SVC(probability=False)
param_grid = {'kernel': ['poly'],
              'coef0': [0],
              'degree' : [3],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVC = GridSearchCV(cv=3, estimator=svc, scoring='f1_macro', param_grid=param_grid)
classifier = make_pipeline(StandardScaler(), tunedSVC)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit SVC (RBF kernel)¶

C-Support Vector Classification. The implementation is based on libsvm. The fit time scales at least quadratically with the number of samples and may be impractical beyond tens of thousands of samples. The multiclass support is handled according to a one-vs-one scheme.

Parameters

Classifier [string]

Scikit-learn python code. See SVC, GridSearchCV, StandardScaler for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

svc = SVC(probability=False)
param_grid = {'kernel': ['rbf'],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVC = GridSearchCV(cv=3, estimator=svc, scoring='f1_macro', param_grid=param_grid)
classifier = make_pipeline(StandardScaler(), tunedSVC)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitSvcRbfKernel:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

svc = SVC(probability=False)
param_grid = {'kernel': ['rbf'],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVC = GridSearchCV(cv=3, estimator=svc, scoring='f1_macro', param_grid=param_grid)
classifier = make_pipeline(StandardScaler(), tunedSVC)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit XGBClassifier¶

Implementation of the scikit-learn API for XGBoost classification.

Parameters

Classifier [string]

Scikit-learn python code. See XGBClassifier for information on different parameters.

Default:

from xgboost import XGBClassifier
classifier = XGBClassifier(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitXgbclassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from xgboost import XGBClassifier
classifier = XGBClassifier(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Fit XGBRFClassifier¶

Implementation of the scikit-learn API for XGBoost random forest classification.

Parameters

Classifier [string]

Scikit-learn python code. See XGBRFClassifier for information on different parameters.

Default:

from xgboost import XGBRFClassifier
classifier = XGBRFClassifier(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output classifier [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitXgbrfclassifier:

----------------
Arguments
----------------

classifier: Classifier
    Default value:  from xgboost import XGBRFClassifier
classifier = XGBRFClassifier(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassifier: Output classifier
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassifier: <outputFile>
    Output classifier

Predict class probability layer¶

Uses a fitted classifier to predict class probability layer from a raster layer with features.

Parameters

Raster layer with features [raster]: A raster layer with bands used as features. Classifier features and raster bands are matched by name.
Classifier [file]: A fitted classifier.

Outputs

Output class probability layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:PredictClassProbabilityLayer:

----------------
Arguments
----------------

raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
classifier: Classifier
    Argument type:  file
    Acceptable values:
            - Path to a file
outputProbability: Output class probability layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputProbability: <outputRaster>
    Output class probability layer

Predict classification layer¶

Uses a fitted classifier to predict a classification layer from a raster layer with features. Used in the Cookbook Recipes: Classification, Graphical Modeler for information on different parameters.

Parameters

Raster layer with features [raster]: A raster layer with bands used as features. Classifier features and raster bands are matched by name to allow for classifiers trained on a subset of the raster bands. If raster bands and classifier features are not matching by name, but overall number of bands and features do match, raster bands are used in original order.
Classifier [file]: A fitted classifier.

Outputs

Output classification layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:PredictClassificationLayer:

----------------
Arguments
----------------

raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
classifier: Classifier
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassification: Output classification layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputClassification: <outputRaster>
    Output classification layer

Regression-based unmixing¶

Implementation of the regression-based unmixing approach “Ensemble Learning From Synthetically Mixed Training Data for Quantifying Urban Land Cover With Support Vector Regression” in IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, vol. 10, no. 4, pp. 1640-1650, April 2017.

Parameters

Endmember dataset [file]

A classification dataset with spectral endmembers used for synthetical mixing.

Raster layer [raster]

A raster layer to be unmixed.

Regressor [string]

Scikit-Learn Python code specifying a regressor.

Number of mixtures per class [number]

Number of mixtures per class.

Default: 1000

Proportion of background mixtures (%) [number]

Proportion of background mixtures.

Default: 0

Include original endmembers [boolean]

Whether to include the original library spectra into the dataset.

Default: True

Mixing complexity probabilities [string]

A list of probabilities for using 2, 3, 4, … endmember mixing models. Trailing 0 probabilities can be skipped. The default values of 0.5, 0.5,results in 50% 2-endmember and 50% 3-endmember models.

Default: 0.5, 0.5

Allow within-class mixtures [boolean]

Whether to allow mixtures with profiles belonging to the same class.

Default: True

Class probabilities [string]

A list of probabilities for drawing profiles from each class. If not specified, class probabilities are proportional to the class size.

Ensemble size [number]

Number of individual runs/predictions.

Default: 1

Robust decision fusion [boolean]

Whether to use median and IQR (interquartile range) aggregation for ensemble decicion fusion. The default is to use mean and standard deviation.

Default: False

Outputs

Output class fraction layer [rasterDestination]: Raster file destination.
Output classification layer [rasterDestination]: Raster file destination.
Output class fraction variation layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:RegressionbasedUnmixing:

----------------
Arguments
----------------

dataset: Endmember dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
regressor: Regressor
    Argument type:  string
    Acceptable values:
            - String value
n: Number of mixtures per class
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
background: Proportion of background mixtures (%)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
includeEndmember: Include original endmembers
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
mixingProbabilities: Mixing complexity probabilities (optional)
    Default value:  0.5, 0.5
    Argument type:  string
    Acceptable values:
            - String value
allowWithinClassMixtures: Allow within-class mixtures
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
classProbabilities: Class probabilities (optional)
    Argument type:  string
    Acceptable values:
            - String value
ensembleSize: Ensemble size
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
robustFusion: Robust decision fusion (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputFraction: Output class fraction layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputClassification: Output classification layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputFractionVariation: Output class fraction variation layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputFraction: <outputRaster>
    Output class fraction layer
outputClassification: <outputRaster>
    Output classification layer
outputFractionVariation: <outputRaster>
    Output class fraction variation layer

Clustering¶

Fit AffinityPropagation¶

Perform Affinity Propagation Clustering.

Parameters

Clusterer [string]

Scikit-learn python code. See AffinityPropagation for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import AffinityPropagation

affinityPropagation = AffinityPropagation()
clusterer = make_pipeline(StandardScaler(), affinityPropagation)

Training dataset [file]

Training dataset pickle file used for fitting the clusterer. If not specified, an unfitted clusterer is created.

Outputs

Output clusterer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitAffinitypropagation:

----------------
Arguments
----------------

clusterer: Clusterer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import AffinityPropagation

affinityPropagation = AffinityPropagation()
clusterer = make_pipeline(StandardScaler(), affinityPropagation)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClusterer: Output clusterer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClusterer: <outputFile>
    Output clusterer

Fit Birch¶

Implements the BIRCH clustering algorithm. It is a memory-efficient, online-learning algorithm provided as an alternative to MiniBatchKMeans. It constructs a tree data structure with the cluster centroids being read off the leaf. These can be either the final cluster centroids or can be provided as input to another clustering algorithm such as AgglomerativeClustering.

Parameters

Clusterer [string]

Scikit-learn python code. See Birch for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import Birch

birch = Birch(n_clusters=3)
clusterer = make_pipeline(StandardScaler(), birch)

Training dataset [file]

Training dataset pickle file used for fitting the clusterer. If not specified, an unfitted clusterer is created.

Outputs

Output clusterer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitBirch:

----------------
Arguments
----------------

clusterer: Clusterer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import Birch

birch = Birch(n_clusters=3)
clusterer = make_pipeline(StandardScaler(), birch)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClusterer: Output clusterer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClusterer: <outputFile>
    Output clusterer

Fit KMeans¶

K-Means clustering.

Parameters

Clusterer [string]

Scikit-learn python code. See KMeans for information on different parameters.

Default:

from sklearn.cluster import KMeans

clusterer = KMeans(n_clusters=8)

Training dataset [file]

Training dataset pickle file used for fitting the clusterer. If not specified, an unfitted clusterer is created.

Outputs

Output clusterer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitKmeans:

----------------
Arguments
----------------

clusterer: Clusterer
    Default value:  from sklearn.cluster import KMeans

clusterer = KMeans(n_clusters=8)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClusterer: Output clusterer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClusterer: <outputFile>
    Output clusterer

Fit MeanShift¶

Mean shift clustering using a flat kernel. Mean shift clustering aims to discover “blobs” in a smooth density of samples. It is a centroid-based algorithm, which works by updating candidates for centroids to be the mean of the points within a given region. These candidates are then filtered in a post-processing stage to eliminate near-duplicates to form the final set of centroids. Seeding is performed using a binning technique for scalability.

Parameters

Clusterer [string]

Scikit-learn python code. See MeanShift for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import MeanShift

meanShift = MeanShift()
clusterer = make_pipeline(StandardScaler(), meanShift)

Training dataset [file]

Training dataset pickle file used for fitting the clusterer. If not specified, an unfitted clusterer is created.

Outputs

Output clusterer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitMeanshift:

----------------
Arguments
----------------

clusterer: Clusterer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import MeanShift

meanShift = MeanShift()
clusterer = make_pipeline(StandardScaler(), meanShift)

    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClusterer: Output clusterer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClusterer: <outputFile>
    Output clusterer

Predict (unsupervised) classification layer¶

Uses a fitted clusterer to predict an (unsupervised) classification layer from a raster layer with features.

Parameters

Raster layer with features [raster]: A raster layer with bands used as features. Clusterer features and raster bands are matched by name to allow for clusterers trained on a subset of the raster bands. If raster bands and clusterer features are not matching by name, but overall number of bands and features do match, raster bands are used in original order.
Clusterer [file]: A fitted clusterer.

Outputs

Output classification layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:PredictUnsupervisedClassificationLayer:

----------------
Arguments
----------------

raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
clusterer: Clusterer
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassification: Output classification layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputClassification: <outputRaster>
    Output classification layer

Convolution, morphology and filtering¶

Spatial convolution Airy Disk filter¶

2D Airy Disk filter. This kernel models the diffraction pattern of a circular aperture. This kernel is normalized to a peak value of 1

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See AiryDisk2DKernel for information on different parameters.

Default:

from astropy.convolution import AiryDisk2DKernel
kernel = AiryDisk2DKernel(radius=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionAiryDiskFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import AiryDisk2DKernel
kernel = AiryDisk2DKernel(radius=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Box filter¶

2D Box filter. The Box filter or running mean is a smoothing filter. It is not isotropic and can produce artifact, when applied repeatedly to the same data.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Box2DKernel for information on different parameters.

Default:

from astropy.convolution import Box2DKernel
kernel = Box2DKernel(width=5)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionBoxFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Box2DKernel
kernel = Box2DKernel(width=5)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution custom filter¶

Create a spatial 2D filter kernel from list or array.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See CustomKernel for information on different parameters.

Default:

from astropy.convolution import CustomKernel
array = [[1, 1, 1],
         [1, 1, 1],
         [1, 1, 1]]
kernel = CustomKernel(array)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionCustomFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import CustomKernel
array = [[1, 1, 1],
         [1, 1, 1],
         [1, 1, 1]]
kernel = CustomKernel(array)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Gaussian filter¶

2D Gaussian filter. The Gaussian filter is a filter with great smoothing properties. It is isotropic and does not produce artifacts.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Gaussian2DKernel for information on different parameters.

Default:

from astropy.convolution import Gaussian2DKernel
kernel = Gaussian2DKernel(x_stddev=1, y_stddev=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionGaussianFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Gaussian2DKernel
kernel = Gaussian2DKernel(x_stddev=1, y_stddev=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Moffat filter¶

2D Moffat filter. This kernel is a typical model for a seeing limited PSF.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Moffat2DKernel for information on different parameters.

Default:

from astropy.convolution import Moffat2DKernel
kernel = Moffat2DKernel(gamma=2, alpha=2)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionMoffatFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Moffat2DKernel
kernel = Moffat2DKernel(gamma=2, alpha=2)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Ricker Wavelet filter¶

2D Ricker Wavelet filter kernel (sometimes known as a Mexican Hat kernel). The Ricker Wavelet, or inverted Gaussian-Laplace filter, is a bandpass filter. It smooths the data and removes slowly varying or constant structures (e.g. background). It is useful for peak or multi-scale detection.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See RickerWavelet2DKernel for information on different parameters.

Default:

from astropy.convolution import RickerWavelet2DKernel
kernel = RickerWavelet2DKernel(width=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionRickerWaveletFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import RickerWavelet2DKernel
kernel = RickerWavelet2DKernel(width=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution ring filter¶

2D Ring filter. The Ring filter kernel is the difference between two Top-Hat kernels of different width. This kernel is useful for, e.g., background estimation.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Ring2DKernel for information on different parameters.

Default:

from astropy.convolution import Ring2DKernel
kernel = Ring2DKernel(radius_in=3, width=2)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionRingFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Ring2DKernel
kernel = Ring2DKernel(radius_in=3, width=2)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Savitsky-Golay filter¶

2D Savitsky-Golay filter. See wikipedia for details.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See sgolay2d from the SciPy cookbook for information on different parameters.

Default:

from astropy.convolution import Kernel2D
from enmapboxprocessing.algorithm.spatialconvolutionsavitskygolay2dalgorithm import sgolay2d
kernel = Kernel2D(array=sgolay2d(window_size=11, order=3, derivative=None))

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionSavitskygolayFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Kernel2D
from enmapboxprocessing.algorithm.spatialconvolutionsavitskygolay2dalgorithm import sgolay2d
kernel = Kernel2D(array=sgolay2d(window_size=11, order=3, derivative=None))
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Top-Hat filter¶

2D Top-Hat filter. The Top-Hat filter is an isotropic smoothing filter. It can produce artifacts when applied repeatedly on the same data.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Tophat2DKernel for information on different parameters.

Default:

from astropy.convolution import Tophat2DKernel
kernel = Tophat2DKernel(radius=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionTophatFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Tophat2DKernel
kernel = Tophat2DKernel(radius=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial convolution Trapezoid filter¶

2D Trapezoid filter.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See TrapezoidDisk2DKernel for information on different parameters.

Default:

from astropy.convolution import TrapezoidDisk2DKernel
kernel = TrapezoidDisk2DKernel(radius=3, slope=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialConvolutionTrapezoidFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import TrapezoidDisk2DKernel
kernel = TrapezoidDisk2DKernel(radius=3, slope=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Gaussian Gradient Magnitude filter¶

Spatial Gaussian Gradient Magnitude filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See gaussian_gradient_magnitude for information on different parameters.

Default:

from scipy.ndimage.filters import gaussian_gradient_magnitude

function = lambda array: gaussian_gradient_magnitude(array, sigma=1)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialGaussianGradientMagnitudeFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import gaussian_gradient_magnitude

function = lambda array: gaussian_gradient_magnitude(array, sigma=1)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial generic filter¶

Spatial generic (user-defined) filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See generic_filter for information on different parameters.

Default:

from scipy.ndimage.filters import generic_filter
import numpy as np

def filter_function(invalues):
    # do whatever you want to create the output value, e.g. np.nansum
    outvalue = np.nansum(invalues)  # replace this line with your code!
    return outvalue

function = lambda array: generic_filter(array, function=filter_function, size=3)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialGenericFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import generic_filter
import numpy as np

def filter_function(invalues):
    # do whatever you want to create the output value, e.g. np.nansum
    outvalue = np.nansum(invalues)  # replace this line with your code!
    return outvalue

function = lambda array: generic_filter(array, function=filter_function, size=3)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Laplace filter¶

Spatial Laplace filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See laplace for information on different parameters.

Default:

from scipy.ndimage.filters import laplace

function = lambda array: laplace(array)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialLaplaceFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import laplace

function = lambda array: laplace(array)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Maximum filter¶

Spatial Maximum filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See maximum_filter for information on different parameters.

Default:

from scipy.ndimage.filters import maximum_filter

function = lambda array: maximum_filter(array, size=3)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMaximumFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import maximum_filter

function = lambda array: maximum_filter(array, size=3)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Median filter¶

Spatial Median filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See median_filter for information on different parameters.

Default:

from scipy.ndimage.filters import median_filter

function = lambda array: median_filter(array, size=3)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMedianFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import median_filter

function = lambda array: median_filter(array, size=3)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Minimum filter¶

Spatial Minimum filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See minimum_filter for information on different parameters.

Default:

from scipy.ndimage.filters import minimum_filter

function = lambda array: minimum_filter(array, size=3)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMinimumFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import minimum_filter

function = lambda array: minimum_filter(array, size=3)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Binary Closing filter¶

Spatial morphological Binary Closing filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import binary_closing, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_closing(array, structure=structure, iterations=1)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBinaryClosingFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import binary_closing, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_closing(array, structure=structure, iterations=1)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Binary Dilation filter¶

Spatial morphological Binary Dilation filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import binary_dilation, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_dilation(array, structure=structure, iterations=1)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBinaryDilationFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import binary_dilation, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_dilation(array, structure=structure, iterations=1)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Binary Erosion filter¶

Spatial morphological Binary Erosion filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import binary_erosion, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_erosion(array, structure=structure, iterations=1)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBinaryErosionFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import binary_erosion, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_erosion(array, structure=structure, iterations=1)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Binary Fill Holes filter¶

Spatial morphological Binary Fill Holes filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import binary_fill_holes, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_fill_holes(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBinaryFillHolesFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import binary_fill_holes, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_fill_holes(array, structure=structure)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Binary Opening filter¶

Spatial morphological Binary Opening filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import binary_opening, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_opening(array, structure=structure, iterations=1)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBinaryOpeningFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import binary_opening, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_opening(array, structure=structure, iterations=1)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Binary Propagation filter¶

Spatial morphological Binary Propagation filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import binary_propagation, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_propagation(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBinaryPropagationFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import binary_propagation, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: binary_propagation(array, structure=structure)

    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Black Top-Hat filter¶

Spatial morphological Black Top-Hat filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import black_tophat, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: black_tophat(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalBlackTophatFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import black_tophat, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: black_tophat(array, structure=structure)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Gradient filter¶

Spatial morphological Gradient filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See binary_closing, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import morphological_gradient, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: morphological_gradient(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalGradientFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import morphological_gradient, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: morphological_gradient(array, structure=structure)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Grey Dilation filter¶

Spatial morphological Grey Dilation filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See grey_dilation, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import grey_dilation, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: grey_dilation(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalGreyDilationFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import grey_dilation, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: grey_dilation(array, structure=structure)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Grey Erosion filter¶

Spatial morphological Grey Erosion filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See grey_erosion, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import grey_erosion, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: grey_erosion(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalGreyErosionFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import grey_erosion, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: grey_erosion(array, structure=structure)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Grey Opening filter¶

Spatial morphological Grey Opening filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See grey_opening, generate_binary_structure, iterate_structure for information on different parameters.

Default:

from scipy.ndimage.morphology import grey_opening, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: grey_opening(array, structure=structure)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalGreyOpeningFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import grey_opening, generate_binary_structure, iterate_structure

structure = generate_binary_structure(rank=2, connectivity=1)
structure = iterate_structure(structure=structure, iterations=1)
function = lambda array: grey_opening(array, structure=structure)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological Laplace filter¶

Spatial morphological Laplace filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See morphological_laplace for information on different parameters.

Default:

from scipy.ndimage.morphology import morphological_laplace

function = lambda array: morphological_laplace(array, size=(3, 3))

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalLaplaceFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import morphological_laplace

function = lambda array: morphological_laplace(array, size=(3, 3))
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial morphological White Top-Hat filter¶

Spatial morphological White Top-Hat filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See scipy.ndimage.white_tophat for information on different parameters.

Default:

from scipy.ndimage.morphology import white_tophat

function = lambda array: white_tophat(array, size=(3, 3))

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialMorphologicalWhiteTophatFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.morphology import white_tophat

function = lambda array: white_tophat(array, size=(3, 3))
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Percentile filter¶

Spatial Percentile filter.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See percentile_filter for information on different parameters.

Default:

from scipy.ndimage.filters import percentile_filter

function = lambda array: percentile_filter(array, percentile=50, size=3)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialPercentileFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import percentile_filter

function = lambda array: percentile_filter(array, percentile=50, size=3)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Prewitt filter¶

Spatial Prewitt filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See prewitt for information on different parameters.

Default:

from scipy.ndimage.filters import prewitt

function = lambda array: prewitt(array, axis=0)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialPrewittFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import prewitt

function = lambda array: prewitt(array, axis=0)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spatial Sobel filter¶

Spatial Sobel filter. See Wikipedia for general information.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code. See sobel for information on different parameters.

Default:

from scipy.ndimage.filters import sobel

function = lambda array: sobel(array, axis=0)

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpatialSobelFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  from scipy.ndimage.filters import sobel

function = lambda array: sobel(array, axis=0)
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spectral convolution Box filter¶

1D Box filter. The Box filter or running mean is a smoothing filter. It is not isotropic and can produce artifacts, when applied repeatedly to the same data.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Box1DKernel for information on different parameters.

Default:

from astropy.convolution import Box1DKernel
kernel = Box1DKernel(width=5)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralConvolutionBoxFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Box1DKernel
kernel = Box1DKernel(width=5)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spectral convolution Gaussian filter¶

1D Gaussian filter. The Gaussian filter is a filter with great smoothing properties. It is isotropic and does not produce artifacts.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Gaussian1DKernel for information on different parameters.

Default:

from astropy.convolution import Gaussian1DKernel
kernel = Gaussian1DKernel(stddev=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralConvolutionGaussianFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Gaussian1DKernel
kernel = Gaussian1DKernel(stddev=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spectral convolution Ricker Wavelet filter¶

1D Ricker Wavelet filter kernel (sometimes known as a Mexican Hat kernel). The Ricker Wavelet, or inverted Gaussian-Laplace filter, is a bandpass filter. It smooths the data and removes slowly varying or constant structures (e.g. background). It is useful for peak or multi-scale detection.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See RickerWavelet1DKernel for information on different parameters.

Default:

from astropy.convolution import RickerWavelet1DKernel
kernel = RickerWavelet1DKernel(width=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralConvolutionRickerWaveletFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import RickerWavelet1DKernel
kernel = RickerWavelet1DKernel(width=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spectral convolution Savitsky-Golay filter¶

1D Savitsky-Golay filter. See wikipedia for details.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See scipy.signal.savgol_coeffs for information on different parameters.

Default:

from astropy.convolution import Kernel1D
from scipy.signal import savgol_coeffs
kernel = Kernel1D(array=savgol_coeffs(window_length=11, polyorder=3, deriv=0))

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralConvolutionSavitskygolayFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Kernel1D
from scipy.signal import savgol_coeffs
kernel = Kernel1D(array=savgol_coeffs(window_length=11, polyorder=3, deriv=0))
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Spectral convolution Trapezoid filter¶

1D Trapezoid filter.

Parameters

Raster layer [raster]

Raster layer to be filtered.

Kernel [string]

Python code. See Trapezoid1DKernel for information on different parameters.

Default:

from astropy.convolution import Trapezoid1DKernel
kernel = Trapezoid1DKernel(width=3, slope=1)

Normalize kernel [boolean]

Whether to normalize the kernel to have a sum of one.

Default: False

Interpolate no data pixel [boolean]

Whether to interpolate no data pixel. Will result in renormalization of the kernel at each position ignoring pixels with no data values.

Default: True

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralConvolutionTrapezoidFilter:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
kernel: Kernel
    Default value:  from astropy.convolution import Trapezoid1DKernel
kernel = Trapezoid1DKernel(width=3, slope=1)
    Argument type:  string
    Acceptable values:
            - String value
normalize: Normalize kernel
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
interpolate: Interpolate no data pixel
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Dataset creation¶

Create classification dataset (from categorized raster layer and feature raster)¶

Create a classification dataset by sampling data for pixels that match the given categories and store the result as a pickle file. If the layer is not categorized, or the band with class values is selected manually, categories are derived from sampled data itself. To be more precise: i) category values are derived from unique raster band values (after excluding no data or zero data pixel), ii) category names are set equal to the category values, and iii) category colors are picked randomly.

Parameters

Categorized raster layer [raster]: Categorized raster layer specifying sample locations and target data y. If required, the layer is reprojected and resampled internally to match the feature raster grid.
Raster layer with features [raster]: Raster layer used for sampling feature data X.
Band with class values [band]: Band with class values. If not selected, the band defined by the renderer is used. If that is also not specified, the first band is used.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromCategorizedRasterLayerAndFeatureRaster:

----------------
Arguments
----------------

categorizedRaster: Categorized raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
featureRaster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
categoryBand: Band with class values (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create classification dataset (from categorized spectral library)¶

Create a classification dataset from spectral profiles that matches the given categories and store the result as a pickle file. If the spectral library is not categorized, or the field with class values is selected manually, categories are derived from target data y. To be more precise: i) category values are derived from unique attribute values (after excluding no data or zero data values), ii) category names are set equal to the category values, and iii) category colors are picked randomly.

Parameters

Categorized spectral library [vector]: Categorized spectral library with feature data X (i.e. spectral profiles) and target data y. It is assumed, but not enforced, that the spectral characteristics of all spectral profiles match. If not all spectral profiles share the same number of spectral bands, an error is raised.
Field with class values [field]: Field with class values used as target data y. If not selected, the field defined by the renderer is used. If that is also not specified, an error is raised.
Field with spectral profiles used as features [field]: Field with spectral profiles used as feature data X. If not selected, the default field named “profiles” is used. If that is also not available, an error is raised.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromCategorizedSpectralLibrary:

----------------
Arguments
----------------

categorizedLibrary: Categorized spectral library
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
categoryField: Field with class values (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
field: Field with spectral profiles used as features (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create classification dataset (from categorized vector layer and feature raster)¶

Create a classification dataset by sampling data for pixels that match the given categories and store the result as a pickle file. If the layer is not categorized, or the field with class values is selected manually, categories are derived from the sampled target data y. To be more precise: i) category values are derived from unique attribute values (after excluding no data or zero data values), ii) category names are set equal to the category values, and iii) category colors are picked randomly.

Parameters

Categorized vector layer [vector]

Categorized vector layer specifying sample locations and target data y. If required, the layer is reprojected and rasterized internally to match the feature raster grid.

Raster layer with features [raster]

Raster layer used for sampling feature data X.

Field with class values [field]

Field with class values used as target data y. If not selected, the field defined by the renderer is used. If that is also not specified, an error is raised.

Minimum pixel coverage [number]

Exclude all pixel where (polygon) coverage is smaller than given threshold.

Default: 50

Majority voting [boolean]

Whether to use majority voting. Turn off to use simple nearest neighbour resampling, which is much faster, but may result in highly inaccurate class decisions.

Default: True

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromCategorizedVectorLayerAndFeatureRaster:

----------------
Arguments
----------------

categorizedVector: Categorized vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureRaster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
categoryField: Field with class values (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
coverage: Minimum pixel coverage
    Default value:  50
    Argument type:  number
    Acceptable values:
            - A numeric value
majorityVoting: Majority voting
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create classification dataset (from categorized vector layer with attribute table)¶

Create a classification dataset from attribute table rows that matches the given categories and store the result as a pickle file. If the layer is not categorized, or the field with class values is selected manually, categories are derived from the target data y. To be more precise: i) category values are derived from unique attribute values (after excluding no data or zero data values), ii) category names are set equal to the category values, and iii) category colors are picked randomly.

Parameters

Categorized vector layer [vector]: Categorized vector layer specifying feature data X and target data y.
Fields with features [field]: Fields with values used as feature data X.
Field with class values [field]: Field with class values used as target data y. If not selected, the field defined by the renderer is used. If that is also not specified, an error is raised.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromCategorizedVectorLayerWithAttributeTable:

----------------
Arguments
----------------

categorizedVector: Categorized vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureFields: Fields with features
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
categoryField: Field with class values (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create classification dataset (from Python code)¶

Create a classification dataset from Python code and store the result as a pickle file.

Parameters

Code [string]

Python code specifying the classification dataset.

Default:

from enmapboxprocessing.typing import Number, List, Category, ClassifierDump

# specify categories and feature names
categories: List[Category] = [
    Category(value=1, name='class 1', color='#ff0000'),
    Category(value=2, name='class 2', color='#00ff00')
]
features: List[str] = ['Feature 1', 'Feature 2', 'Feature 3']

# specify features X as 2d-array with shape (samples, features)
X: List[List[Number]] = [
    [1, 2, 3],
    [4, 5, 6]
]
# specify targets y as 2d-array with shape (samples, 1)
y: List[List[int]] = [
    [1], [2]
]

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromPythonCode:

----------------
Arguments
----------------

code: Code
    Default value:  from enmapboxprocessing.typing import Number, List, Category, ClassifierDump

# specify categories and feature names
categories: List[Category] = [
    Category(value=1, name='class 1', color='#ff0000'),
    Category(value=2, name='class 2', color='#00ff00')
]
features: List[str] = ['Feature 1', 'Feature 2', 'Feature 3']

# specify features X as 2d-array with shape (samples, features)
X: List[List[Number]] = [
    [1, 2, 3],
    [4, 5, 6]
]
# specify targets y as 2d-array with shape (samples, 1)
y: List[List[int]] = [
    [1], [2]
]

    Argument type:  string
    Acceptable values:
            - String value
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create classification dataset (from table with categories and feature fields)¶

Create a classification dataset from attribute table rows that match the given categories and store the result as a pickle file.

Parameters

Table [vector]: Table with feature data X and target data y.
Fields with features [field]: Fields used as features. Values may be given as strings, but must be castable to float.
Field with class values [field]: Field used as class value.
Field with class names [field]: Field used as class name. If not specified, class values are used as class names.
Field with class colors [field]: Field used as class color. Values may be given as hex-colors, rgb-colors or int-colors.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromTableWithCategoriesAndFeatureFields:

----------------
Arguments
----------------

table: Table
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureFields: Fields with features
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
valueField: Field with class values
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
nameField: Field with class names (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
colorField: Field with class colors (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create classification dataset (from text files)¶

Create a classification dataset from tabulated text files and store the result as a pickle file. The format matches that of the FORCE Higher Level Sampling Submodule. Example files (force_features.csv and force_labels.csv) can be found in the EnMAP-Box testdata folder).

Parameters

File with features [file]: Text file with tabulated feature data X (no headers). Each row represents the feature vector of a sample.
File with class values [file]: Text file with tabulated target data y (no headers). Each row represents the class value of a sample.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateClassificationDatasetFromTextFiles:

----------------
Arguments
----------------

featureFile: File with features
    Argument type:  file
    Acceptable values:
            - Path to a file
valueFile: File with class values
    Argument type:  file
    Acceptable values:
            - Path to a file
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create regression dataset (from continuous-valued layer with attribute table)¶

Create a regression dataset from attribute table rows that matches the given target variables and store the result as a pickle file.

Parameters

Continuous-valued vector layer [vector]: Continuous-valued vector layer specifying feature data X and target data y.
Fields with features [field]: Fields with values used as feature data X.
Fields with targets [field]: Fields with values used as used as target data y. If not selected, the fields defined by the renderer are used. If those are also not specified, an error is raised.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromContinuousvaluedLayerWithAttributeTable:

----------------
Arguments
----------------

continuousVector: Continuous-valued vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureFields: Fields with features
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
targetFields: Fields with targets (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputRegressionDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressionDataset: <outputFile>
    Output dataset

Create regression dataset (from continuous-valued raster layer and feature raster)¶

Create a regression dataset by sampling data for labeled pixels and store the result as a pickle file.

Parameters

Continuous-valued raster layer [raster]: Continuous-valued raster layer specifying sample locations and target data Y.If required, the layer is reprojected and resampled internally to match the feature raster grid.
Raster layer with features [raster]: Raster layer used for sampling feature data X.
Targets [band]: Bands with continuous-valued variables used as targets. An empty selection defaults to all bands in native order.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromContinuousvaluedRasterLayerAndFeatureRaster:

----------------
Arguments
----------------

continuousRaster: Continuous-valued raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
featureRaster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
targets: Targets (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Create regression dataset (from continuous-valued spectral library)¶

Create a regression dataset from spectral profiles that matches the given target variables and store the result as a pickle file.

Parameters

Continuous-valued spectral library [vector]: Continuous-valued spectral library with feature data X (i.e. spectral profiles) and target data y. It is assumed, but not enforced, that the spectral characteristics of all spectral profiles match. If not all spectral profiles share the same number of spectral bands, an error is raised.
Fields with target values [field]: Fields with continuous-valued values used as target data y. If not selected, the fields defined by the renderer is used. If those are also not specified, an error is raised.
Field with spectral profiles used as features [field]: Field with spectral profiles used as feature data X. If not selected, the default field named “profiles” is used. If that is also not available, an error is raised.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromContinuousvaluedSpectralLibrary:

----------------
Arguments
----------------

continuousLibrary: Continuous-valued spectral library
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
targetFields: Fields with target values (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
field: Field with spectral profiles used as features (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputRegressionDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressionDataset: <outputFile>
    Output dataset

Create regression dataset (from continuous-valued vector layer and feature raster)¶

Create a regression dataset by sampling data and store the result as a pickle file.

Parameters

Continuous-valued vector layer [vector]: Continuous-valued vector layer specifying sample locations and target data y. If required, the layer is reprojected and rasterized internally to match the feature raster grid.
Raster layer with features [raster]: Raster layer used for sampling feature data X.
Fields with targets [field]: Fields used as target data y. If not selected, the fields defined by the renderer are used. If those are also not specified, an error is raised.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromContinuousvaluedVectorLayerAndFeatureRaster:

----------------
Arguments
----------------

continuousVector: Continuous-valued vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureRaster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
targetFields: Fields with targets (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputRegressionDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressionDataset: <outputFile>
    Output dataset

Create regression dataset (from Python code)¶

Create a regression dataset from Python code and store the result as a pickle file.

Parameters

Code [string]

Python code specifying the regression dataset.

Default:

from enmapboxprocessing.typing import Number, List, Target, RegressorDump

# specify targets and feature names
targets: List[Target] = [
    Target(name='variable 1', color='#ff0000'),
    Target(name='variable 2', color='#00ff00')
]
features: List[str] = ['Feature 1', 'Feature 2', 'Feature 3']

# specify features X as 2d-array with shape (samples, features)
X: List[List[Number]] = [
    [1, 2, 3],
    [4, 5, 6]
]
# specify targets y as 2d-array with shape (samples, targets)
y: List[List[float]] = [
    [1.1, 1.2], [2.1, 2.2]
]

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromPythonCode:

----------------
Arguments
----------------

code: Code
    Default value:  from enmapboxprocessing.typing import Number, List, Target, RegressorDump

# specify targets and feature names
targets: List[Target] = [
    Target(name='variable 1', color='#ff0000'),
    Target(name='variable 2', color='#00ff00')
]
features: List[str] = ['Feature 1', 'Feature 2', 'Feature 3']

# specify features X as 2d-array with shape (samples, features)
X: List[List[Number]] = [
    [1, 2, 3],
    [4, 5, 6]
]
# specify targets y as 2d-array with shape (samples, targets)
y: List[List[float]] = [
    [1.1, 1.2], [2.1, 2.2]
]

    Argument type:  string
    Acceptable values:
            - String value
outputRegressionDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressionDataset: <outputFile>
    Output dataset

Create regression dataset (from table with target and feature fields)¶

Create a regression dataset from attribute table rows and store the result as a pickle file.

Parameters

Table [vector]: Table with feature data X and target data y.
Fields with features [field]: Fields used as features. Values may be given as strings, but must be castable to float.
Fields with targets [field]: Fields used as targets. Values may be given as strings, but must be castable to float.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromTableWithTargetAndFeatureFields:

----------------
Arguments
----------------

table: Table
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureFields: Fields with features
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
targetFields: Fields with targets
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputRegressionDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressionDataset: <outputFile>
    Output dataset

Create regression dataset (from text files)¶

Create a regression dataset from tabulated text files and store the result as a pickle file. The format matches that of the FORCE Higher Level Sampling Submodule. Example files (force_features.csv and force_labels.csv) can be found in the EnMAP-Box testdata folder).

Parameters

File with features [file]: Text file with tabulated feature data X (no headers). Each row represents the feature vector of a sample.
File with target values [file]: Text file with tabulated target data y (no headers). Each row represents the target values of a sample.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetFromTextFiles:

----------------
Arguments
----------------

featureFile: File with features
    Argument type:  file
    Acceptable values:
            - Path to a file
valueFile: File with target values
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressionDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressionDataset: <outputFile>
    Output dataset

Create regression dataset (SynthMix from classification dataset)¶

Create synthetically mixed regression datasets, one for each category. Results are stored as <category.name>.pkl files inside the destination folder.

Parameters

Classification dataset [file]

A classification dataset with spectral endmembers used for synthetical mixing.

Number of mixtures per class [number]

Number of mixtures per class

Default: 1000

Proportion of background mixtures (%) [number]

Proportion of background mixtures.

Default: 0

Include original endmembers [boolean]

Whether to include the original library spectra into the dataset.

Default: True

Mixing complexity probabilities [string]

A list of probabilities for using 2, 3, 4, … endmember mixing models. Trailing 0 probabilities can be skipped. The default values of 0.5, 0.5,results in 50% 2-endmember and 50% 3-endmember models.

Default: 0.5, 0.5

Allow within-class mixtures [boolean]

Whether to allow mixtures with profiles belonging to the same class.

Default: True

Class probabilities [string]

A list of probabilities for drawing profiles from each class. If not specified, class probabilities are proportional to the class size.

Outputs

Output folder [folderDestination]: Folder destination.

Command-line usage

>qgis_process help enmapbox:CreateRegressionDatasetSynthmixFromClassificationDataset:

----------------
Arguments
----------------

dataset: Classification dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
n: Number of mixtures per class
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
background: Proportion of background mixtures (%)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
includeEndmember: Include original endmembers
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
mixingProbabilities: Mixing complexity probabilities (optional)
    Default value:  0.5, 0.5
    Argument type:  string
    Acceptable values:
            - String value
allowWithinClassMixtures: Allow within-class mixtures
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
classProbabilities: Class probabilities (optional)
    Argument type:  string
    Acceptable values:
            - String value
outputFolder: Output folder
    Argument type:  folderDestination
    Acceptable values:
            - Path for an existing or new folder

----------------
Outputs
----------------

outputFolder: <outputFolder>
    Output folder

Create unsupervised dataset (from feature raster)¶

Create an unsupervised dataset by sampling data from valid pixels and store the result as a pickle file. A pixel is concidered valid, if the pixel profile is free of no data values, and not excluded by the (optionally) selected mask layer.

Parameters

Raster layer with features [raster]

Raster layer used for sampling feature data X.

Mask layer [layer]

A mask layer for limitting sample locations.

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 0

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateUnsupervisedDatasetFromFeatureRaster:

----------------
Arguments
----------------

featureRaster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
mask: Mask layer (optional)
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
sampleSize: Sample size (optional)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
outputUnsupervisedDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputUnsupervisedDataset: <outputFile>
    Output dataset

Create unsupervised dataset (from Python code)¶

Create an unsupervised dataset from Python code and store the result as a pickle file.

Parameters

Code [string]

Python code specifying the unsupervised dataset.

Default:

from enmapboxprocessing.typing import Number, List

# specify feature names
features: List[str] = ['Feature 1', 'Feature 2', 'Feature 3']

# specify features X as 2d-array with shape (samples, features)
X: List[List[Number]] = [
    [1, 2, 3],
    [4, 5, 6]
]

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateUnsupervisedDatasetFromPythonCode:

----------------
Arguments
----------------

code: Code
    Default value:  from enmapboxprocessing.typing import Number, List

# specify feature names
features: List[str] = ['Feature 1', 'Feature 2', 'Feature 3']

# specify features X as 2d-array with shape (samples, features)
X: List[List[Number]] = [
    [1, 2, 3],
    [4, 5, 6]
]

    Argument type:  string
    Acceptable values:
            - String value
outputUnsupervisedDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputUnsupervisedDataset: <outputFile>
    Output dataset

Create unsupervised dataset (from spectral library)¶

Create an unsupervised dataset from spectral profiles and store the result as a pickle file.

Parameters

Spectral library [vector]: Spectral library with feature data X (i.e. spectral profiles). It is assumed, but not enforced, that the spectral characteristics of all spectral profiles match. If not all spectral profiles share the same number of spectral bands, an error is raised.
Field with spectral profiles used as features [field]: Field with spectral profiles used as feature data X. If not selected, the default field named “profiles” is used. If that is also not available, an error is raised.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateUnsupervisedDatasetFromSpectralLibrary:

----------------
Arguments
----------------

library: Spectral library
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
field: Field with spectral profiles used as features (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputUnsupervisedDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputUnsupervisedDataset: <outputFile>
    Output dataset

Create unsupervised dataset (from text file)¶

Create an unsupervised dataset from a tabulated text file and store the result as a pickle file. The format matches that of the FORCE Higher Level Sampling Submodule. An example file (force_features.csv) can be found in the EnMAP-Box testdata folder).

Parameters

File with features [file]: Text file with tabulated feature data X (no headers). Each row represents the feature vector of a sample.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateUnsupervisedDatasetFromTextFile:

----------------
Arguments
----------------

featureFile: File with features
    Argument type:  file
    Acceptable values:
            - Path to a file
outputUnsupervisedDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputUnsupervisedDataset: <outputFile>
    Output dataset

Create unsupervised dataset (from vector layer with attribute table)¶

Create an unsupervised dataset from attribute table and store the result as a pickle file.

Parameters

Vector layer [vector]: Vector layer specifying feature data X.
Fields with features [field]: Fields with values used as feature data X.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:CreateUnsupervisedDatasetFromVectorLayerWithAttributeTable:

----------------
Arguments
----------------

vector: Vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
featureFields: Fields with features
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputUnsupervisedDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputUnsupervisedDataset: <outputFile>
    Output dataset

Merge classification datasets¶

Merges a list of classification datasets.

Parameters

Datasets [multilayer]: Classification datasets to be merged.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:MergeClassificationDatasets:

----------------
Arguments
----------------

datasets: Datasets
    Argument type:  multilayer
outputClassificationDataset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputClassificationDataset: <outputFile>
    Output dataset

Random samples from classification dataset¶

Split a dataset by randomly drawing samples.

Parameters

Classification dataset [file]

Classification dataset pickle file with feature data X and target data y to draw from.

Number of samples per category [string]

Number of samples to draw from each category. Set a single value N to draw N samples for each category. Set a list of values N1, N2, … Ni, … to draw Ni samples for category i.

Draw with replacement [boolean]

Whether to draw samples with replacement.

Default: False

Draw proportional [boolean]

Whether to interprete number of samples N or Ni as percentage to be drawn from each category.

Default: False

Random seed [number]

The seed for the random generator can be provided.

Outputs

Output dataset [fileDestination]: Destination pickle file.Stores sampled data.
Output dataset complement [fileDestination]: Destination pickle file.Stores remaining data that was not sampled.

Command-line usage

>qgis_process help enmapbox:RandomSamplesFromClassificationDataset:

----------------
Arguments
----------------

dataset: Classification dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
n: Number of samples per category
    Argument type:  string
    Acceptable values:
            - String value
replace: Draw with replacement
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
proportional: Draw proportional
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
seed: Random seed (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
outputDatasetRandomSample: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file
outputDatasetRandomSampleComplement: Output dataset complement (optional)
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputDatasetRandomSample: <outputFile>
    Output dataset
outputDatasetRandomSampleComplement: <outputFile>
    Output dataset complement

Random samples from regression dataset¶

Split a dataset by randomly drawing samples.

Parameters

Regression dataset [file]

Regression dataset pickle file with feature data X and target data y to draw from.

Number of stratification bins [number]

Number of bins used to stratify the target range.

Default: 1

Number of samples per bin [string]

Number of samples to draw from each bin. Set a single value N to draw N samples for each bin. Set a list of values N1, N2, … Ni, … to draw Ni samples for bin i.

Draw with replacement [boolean]

Whether to draw samples with replacement.

Default: False

Draw proportional [boolean]

Whether to interprete number of samples N or Ni as percentage to be drawn from each bin.

Default: False

Random seed [number]

The seed for the random generator can be provided.

Outputs

Output dataset [fileDestination]: Destination pickle file.Stores sampled data.
Output dataset complement [fileDestination]: Destination pickle file.Stores remaining data that was not sampled.

Command-line usage

>qgis_process help enmapbox:RandomSamplesFromRegressionDataset:

----------------
Arguments
----------------

dataset: Regression dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
bins: Number of stratification bins
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
n: Number of samples per bin
    Argument type:  string
    Acceptable values:
            - String value
replace: Draw with replacement
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
proportional: Draw proportional
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
seed: Random seed (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
outputDatasetRandomSample: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file
outputDatasetRandomSampleComplement: Output dataset complement (optional)
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputDatasetRandomSample: <outputFile>
    Output dataset
outputDatasetRandomSampleComplement: <outputFile>
    Output dataset complement

Select features from dataset¶

Subset and/or reorder features in feature data X.

Parameters

Dataset [file]: Dataset pickle file to select features from.
Selected features [string]: Comma separated list of feature names or positions. E.g. use <code>1, ‘Feature 2’, 3</code> to select the first three features.

Outputs

Output dataset [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:SelectFeaturesFromDataset:

----------------
Arguments
----------------

dataset: Dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
featureList: Selected features
    Argument type:  string
    Acceptable values:
            - String value
outputDatasetFeatureSubset: Output dataset
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputDatasetFeatureSubset: <outputFile>
    Output dataset

Export data¶

Save spectral library as GeoJSON file¶

Save a spectral library as a human-readable GeoJSON text file. All binary profile fields will be converted into human-readable dictionary strings.

Parameters

Spectral library [vector]: The spectral library to be stored as GeoJSON text file.

Outputs

Output file [fileDestination]: Destination GeoJSON file.

Command-line usage

>qgis_process help enmapbox:SaveSpectralLibraryAsGeojsonFile:

----------------
Arguments
----------------

library: Spectral library
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
outputFile: Output file
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputFile: <outputFile>
    Output file

Feature selection¶

Classifier feature ranking (permutation importance)¶

Permutation feature importance is a model inspection technique that is especially useful for non-linear or opaque estimators. The permutation feature importance is defined to be the decrease in a model score when a single feature value is randomly shuffled. This procedure breaks the relationship between the feature and the target, thus the drop in the model score is indicative of how much the model depends on the feature. This technique benefits from being model agnostic and can be calculated many times with different permutations of the feature.

Parameters

Classifier [file]

Classifier pickle file. In case of an unfitted classifier, also specify a training dataset.

Training dataset [file]

Training dataset pickle file used for (re-)fitting the classifier. Can be skipped in case of a fitted classifier.

Test dataset [file]

Test dataset pickle file used for performance evaluation. If skipped, the training dataset is used.

Evaluation metric [enum]

An evaluation metric to use. See Metrics and scoring: quantifying the quality of predictions for further information.

Default: 7

Number of repetitions [number]

Number of times to permute a feature.

Default: 10

Random seed [number]

The seed for the random generator can be provided.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:ClassifierFeatureRankingPermutationImportance:

----------------
Arguments
----------------

classifier: Classifier
    Argument type:  file
    Acceptable values:
            - Path to a file
trainDataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
testDataset: Test dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
evaluationMetric: Evaluation metric
    Default value:  7
    Argument type:  enum
    Available values:
            - 0: accuracy
            - 1: balanced_accuracy
            - 2: top_k_accuracy
            - 3: average_precision
            - 4: neg_brier_score
            - 5: f1
            - 6: f1_micro
            - 7: f1_macro
            - 8: f1_weighted
            - 9: f1_samples
            - 10: neg_log_loss
            - 11: precision
            - 12: recall
            - 13: jaccard
            - 14: roc_auc
            - 15: roc_auc_ovr
            - 16: roc_auc_ovo
            - 17: roc_auc_ovr_weighted
            - 18: roc_auc_ovo_weighted
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
repeats: Number of repetitions
    Default value:  10
    Argument type:  number
    Acceptable values:
            - A numeric value
seed: Random seed (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputPermutationImportanceRanking: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputPermutationImportanceRanking: <outputHtml>
    Output report

Hierarchical feature clustering¶

Evaluate feature multicollinearity by performing hierarchical/agglomerative clustering with Ward linkage using squared Spearman rank-order correlation as distance between features. The result report includes i) pairwise squared Spearman rank-order correlation matrix, ii) clustering dendrogram, iii) inter-cluster correlation distribution, iv) intra-cluster correlation distribution, and v) a clustering hierarchy table detailing selected cluster representatives for each cluster size n. For further analysis, all relevant results are also stored as a JSON sidecar file next to the report.

Parameters

Dataset [file]

Dataset pickle file with feature data X to be evaluated.

Do not report plots [boolean]

Skip the creation of plots, which can take a lot of time for large features sets.

Default: False

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:HierarchicalFeatureClustering:

----------------
Arguments
----------------

dataset: Dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
noPlot: Do not report plots
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputHierarchicalFeatureClustering: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputHierarchicalFeatureClustering: <outputHtml>
    Output report

Import data¶

Import DESIS L1B product¶

Prepare a spectral raster layer from the given product. Wavelength and FWHM information is set and data is scaled according to data gain/offset values.

Parameters

Metadata file [file]: The metadata XML file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata XML file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportDesisL1BProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputDesisL1CRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputDesisL1CRaster: <outputRaster>
    Output raster layer

Import DESIS L1C product¶

Prepare a spectral raster layer from the given product. Wavelength and FWHM information is set and data is scaled according to data gain/offset values. Note that the DESIS L1C spectral data file is band interleaved by pixel and compressed, which is very disadvantageous for visualization in QGIS / EnMAP-Box. For faster exploration concider saving the resulting VRT raster layer as GTiff format via the “Translate raster layer” algorithm.

Parameters

Metadata file [file]: The metadata XML file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata XML file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportDesisL1CProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputDesisL1CRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputDesisL1CRaster: <outputRaster>
    Output raster layer

Import DESIS L2A product¶

Prepare a spectral raster layer from the given product. Wavelength and FWHM information is set and data is scaled into the 0 to 10000 range. Note that the DESIS L2D spectral data file is band interleaved by pixel and compressed, which is very disadvantageous for visualization in QGIS / EnMAP-Box. For faster exploration concider saving the resulting VRT raster layer as GTiff format via the “Translate raster layer” algorithm.

Parameters

Metadata file [file]: The metadata XML file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata XML file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportDesisL2AProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputDesisL2ARaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputDesisL2ARaster: <outputRaster>
    Output raster layer

Import EnMAP L1B product¶

Prepare VNIR and SWIR spectral raster layer from the given product. Wavelength and FWHM information is set and data is scaled according to data gain/offset values.

Parameters

Metadata file [file]: The metadata XML file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata XML file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output VNIR raster layer [rasterDestination]: Raster file destination.
Output SWIR raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportEnmapL1BProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputEnmapL1BRasterVnir: Output VNIR raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputEnmapL1BRasterSwir: Output SWIR raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputEnmapL1BRasterVnir: <outputRaster>
    Output VNIR raster layer
outputEnmapL1BRasterSwir: <outputRaster>
    Output SWIR raster layer

Import EnMAP L1C product¶

Prepare a spectral raster layer from the given product. Wavelength and FWHM information is set and data is scaled according to data gain/offset values.

Parameters

Metadata file [file]: The metadata XML file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata XML file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportEnmapL1CProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputEnmapL1CRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputEnmapL1CRaster: <outputRaster>
    Output raster layer

Import EnMAP L2A product¶

Prepare a spectral raster layer from the given product. Wavelength and FWHM information is set and data is scaled into the 0 to 10000 range.

Parameters

Metadata file [file]: The metadata XML file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata XML file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportEnmapL2AProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputEnmapL2ARaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputEnmapL2ARaster: <outputRaster>
    Output raster layer

Import Landsat L2 product¶

Prepare a spectral raster layer from the given product. Wavelength information is set and data is scaled into the 0 to 1 range.Supports Landsat 4 to 9, collection 1 and 2.

Parameters

Metadata file [file]: The *.MTL.txt metadata file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata MTL.txt file directly from your system file browser onto the EnMAP-Box map view area.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportLandsatL2Product:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
outputLandsatL2Raster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputLandsatL2Raster: <outputRaster>
    Output raster layer

Import PRISMA L1 product¶

Import PRISMA L1 product from HE5 file to QGIS/GDAL conform GTiff/VRT file format.Note that for the spectral cube and error matrix, the interleave is transposed and stored as GTiff to enable proper visualization in QGIS.All other sub-datasets are stored as light-weight VRT files. For further details visit the PRISMA Documentation Area.

Parameters

File [file]

The HE5 product file. The main data contained in the PRS_L1_HRC Swath is the Radiometric Calibrated Coregistersed Hyperspectral Cube. All bands of VNIR Cube and all bands of SWIR Cube are keystone corrected with respect to VNIR Cube band 128 only considering shift Across track. The PRS_L1_PCO Swath basically contains the Radiometric Calibrated Coregistered Panchromatic Image. The PAN Cube is coregistered with respect to VNIR Cube taking into account of the Along Track coregistration. PAN Cube also takes into account the Across track offset PAN – VNIR. All pixel of PAN Cube are keystone corrected with respect to VNIR Cube band 128 only considering shift Across track. Instead of executing this algorithm, you may drag&drop the HE5 file directly from your system file browser on the EnMAP-Box map view area.

Spectral region [enum]

Spectral region to be imported.

Default: 0

Outputs

Output VNIR/SWIR Cube raster layer [rasterDestination]: VNIR/SWIR Cube GTiff raster file destination.
Output PAN raster layer [rasterDestination]: PAN VRT raster file destination.
Output Cloud Mask raster layer [rasterDestination]: Cloud Mask VRT raster file destination.
Output Land Cover Mask raster layer [rasterDestination]: Land Cover Mask VRT raster file destination.
Output Sun Glint Mask raster layer [rasterDestination]: Sun Glint Mask VRT raster file destination.
Output VNIR/SWIR Error Matrix raster layer [rasterDestination]: VNIR/SWIR Pixel Error Matrix GTiff raster file destination.
Output VNIR/SWIR Geolocation Fields raster layer [rasterDestination]: VNIR/SWIR Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output PAN Geolocation Fields raster layer [rasterDestination]: PAN Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output PAN Error Matrix raster layer [rasterDestination]: PAN Pixel Error Matrix VRT raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportPrismaL1Product:

----------------
Arguments
----------------

file: File
    Argument type:  file
    Acceptable values:
            - Path to a file
spectralRegion: Spectral region
    Default value:  0
    Argument type:  enum
    Available values:
            - 0: VNIR/SWIR combined
            - 1: VNIR only
            - 2: SWIR only
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputPrismaL1_spectralCube: Output VNIR/SWIR Cube raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_panCube: Output PAN raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_cloudMask: Output Cloud Mask raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_landCoverMask: Output Land Cover Mask raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_sunGlintMask: Output Sun Glint Mask raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrisma1_spectralErrorMatrix: Output VNIR/SWIR Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_spectralGeolocationFields: Output VNIR/SWIR Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_panGeolocationFields: Output PAN Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL1_panErrorMatrix: Output PAN Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputPrismaL1_spectralCube: <outputRaster>
    Output VNIR/SWIR Cube raster layer
outputPrismaL1_panCube: <outputRaster>
    Output PAN raster layer
outputPrismaL1_cloudMask: <outputRaster>
    Output Cloud Mask raster layer
outputPrismaL1_landCoverMask: <outputRaster>
    Output Land Cover Mask raster layer
outputPrismaL1_sunGlintMask: <outputRaster>
    Output Sun Glint Mask raster layer
outputPrisma1_spectralErrorMatrix: <outputRaster>
    Output VNIR/SWIR Error Matrix raster layer
outputPrismaL1_spectralGeolocationFields: <outputRaster>
    Output VNIR/SWIR Geolocation Fields raster layer
outputPrismaL1_panGeolocationFields: <outputRaster>
    Output PAN Geolocation Fields raster layer
outputPrismaL1_panErrorMatrix: <outputRaster>
    Output PAN Error Matrix raster layer

Import PRISMA L2B product¶

Import PRISMA L2B product from HE5 file to QGIS/GDAL conform GTiff/VRT file format.Note that for the spectral cube and error matrix, the interleave is transposed and stored as GTiff to enable proper visualization in QGIS.All other sub-datasets are stored as light-weight VRT files. For further details visit the PRISMA Documentation Area.

Parameters

File [file]

The HE5 product file. The main data contained in the PRS_L2B_HCO Swath is the surface spectral radiance Coregistersed Hyperspectral Cube (in instrument geometric reference). The main data contained in the PRS_L2B_PCO Swath is the surface panchromatic reflectance image (in instrument geometric reference). Instead of executing this algorithm, you may drag&drop the HE5 file directly from your system file browser on the EnMAP-Box map view area.

Spectral region [enum]

Spectral region to be imported.

Default: 0

Outputs

Output VNIR/SWIR Cube raster layer [rasterDestination]: VNIR/SWIR Cube GTiff raster file destination.
Output PAN raster layer [rasterDestination]: PAN VRT raster file destination.
Output VNIR/SWIR Error Matrix raster layer [rasterDestination]: VNIR/SWIR Pixel Error Matrix GTiff raster file destination.
Output VNIR/SWIR Geolocation Fields raster layer [rasterDestination]: VNIR/SWIR Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output VNIR/SWIR Geometric Fields raster layer [rasterDestination]: VNIR/SWIR Geometric Fields VRT raster file destination. Includes Observing Angle, Relative Azimuth Angle and Solar Zenith Angle bands.
Output PAN Geolocation Fields raster layer [rasterDestination]: PAN Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output PAN Error Matrix raster layer [rasterDestination]: PAN Pixel Error Matrix VRT raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportPrismaL2BProduct:

----------------
Arguments
----------------

file: File
    Argument type:  file
    Acceptable values:
            - Path to a file
spectralRegion: Spectral region
    Default value:  0
    Argument type:  enum
    Available values:
            - 0: VNIR/SWIR combined
            - 1: VNIR only
            - 2: SWIR only
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputPrismaL2B_spectralCube: Output VNIR/SWIR Cube raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2B_panCube: Output PAN raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrisma2B_spectralErrorMatrix: Output VNIR/SWIR Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2B_spectralGeolocationFields: Output VNIR/SWIR Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2B_spectralGeometricFields: Output VNIR/SWIR Geometric Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2B_panGeolocationFields: Output PAN Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2B_panErrorMatrix: Output PAN Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputPrismaL2B_spectralCube: <outputRaster>
    Output VNIR/SWIR Cube raster layer
outputPrismaL2B_panCube: <outputRaster>
    Output PAN raster layer
outputPrisma2B_spectralErrorMatrix: <outputRaster>
    Output VNIR/SWIR Error Matrix raster layer
outputPrismaL2B_spectralGeolocationFields: <outputRaster>
    Output VNIR/SWIR Geolocation Fields raster layer
outputPrismaL2B_spectralGeometricFields: <outputRaster>
    Output VNIR/SWIR Geometric Fields raster layer
outputPrismaL2B_panGeolocationFields: <outputRaster>
    Output PAN Geolocation Fields raster layer
outputPrismaL2B_panErrorMatrix: <outputRaster>
    Output PAN Error Matrix raster layer

Import PRISMA L2C product¶

Import PRISMA L2C product from HE5 file to QGIS/GDAL conform GTiff/VRT file format.Note that for the spectral cube and error matrix, the interleave is transposed and stored as GTiff to enable proper visualization in QGIS.All other sub-datasets are stored as light-weight VRT files. For further details visit the PRISMA Documentation Area.

Parameters

File [file]

The HE5 product file. The main data contained in the PRS_L2C_HRO Swath is the surface spectral reflectance Coregistersed Hyperspectral Cube (in instrument geometric reference). The main data contained in the PRS_L2C_PCO Swath is the surface panchromatic reflectance image (in instrument geometric reference). Instead of executing this algorithm, you may drag&drop the HE5 file directly from your system file browser on the EnMAP-Box map view area.

Spectral region [enum]

Spectral region to be imported.

Default: 0

Outputs

Output VNIR/SWIR Cube raster layer [rasterDestination]: VNIR/SWIR Cube GTiff raster file destination.
Output PAN raster layer [rasterDestination]: PAN VRT raster file destination.
Output VNIR/SWIR Error Matrix raster layer [rasterDestination]: VNIR/SWIR Pixel Error Matrix GTiff raster file destination.
Output VNIR/SWIR Geolocation Fields raster layer [rasterDestination]: VNIR/SWIR Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output VNIR/SWIR Geometric Fields raster layer [rasterDestination]: VNIR/SWIR Geometric Fields VRT raster file destination. Includes Observing Angle, Relative Azimuth Angle and Solar Zenith Angle bands.
Output PAN Geolocation Fields raster layer [rasterDestination]: PAN Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output PAN Error Matrix raster layer [rasterDestination]: PAN Pixel Error Matrix VRT raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportPrismaL2CProduct:

----------------
Arguments
----------------

file: File
    Argument type:  file
    Acceptable values:
            - Path to a file
spectralRegion: Spectral region
    Default value:  0
    Argument type:  enum
    Available values:
            - 0: VNIR/SWIR combined
            - 1: VNIR only
            - 2: SWIR only
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputPrismaL2C_spectralCube: Output VNIR/SWIR Cube raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2C_panCube: Output PAN raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrisma2C_spectralErrorMatrix: Output VNIR/SWIR Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2C_spectralGeolocationFields: Output VNIR/SWIR Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2C_spectralGeometricFields: Output VNIR/SWIR Geometric Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2C_panGeolocationFields: Output PAN Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2C_panErrorMatrix: Output PAN Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputPrismaL2C_spectralCube: <outputRaster>
    Output VNIR/SWIR Cube raster layer
outputPrismaL2C_panCube: <outputRaster>
    Output PAN raster layer
outputPrisma2C_spectralErrorMatrix: <outputRaster>
    Output VNIR/SWIR Error Matrix raster layer
outputPrismaL2C_spectralGeolocationFields: <outputRaster>
    Output VNIR/SWIR Geolocation Fields raster layer
outputPrismaL2C_spectralGeometricFields: <outputRaster>
    Output VNIR/SWIR Geometric Fields raster layer
outputPrismaL2C_panGeolocationFields: <outputRaster>
    Output PAN Geolocation Fields raster layer
outputPrismaL2C_panErrorMatrix: <outputRaster>
    Output PAN Error Matrix raster layer

Import PRISMA L2D product¶

Import PRISMA L2D product from HE5 file to QGIS/GDAL conform GTiff/VRT file format with proper coordinate reference system.Note that for the spectral cube and error matrix, the interleave is transposed and stored as GTiff to enable proper visualization in QGIS.All other sub-datasets are stored as light-weight VRT files. For further details visit the PRISMA Documentation Area.

Parameters

File [file]

The HE5 product file. The main data contained in the PRS_L2d_HCO Swath is the surface spectral reflectance Coregistersed Hyperspectral Cube (in instrument geometric reference). The main data contained in the PRS_L2d_PCO Swath is the surface panchromatic reflectance image (in instrument geometric reference). Instead of executing this algorithm, you may drag&drop the HE5 file directly from your system file browser on the EnMAP-Box map view area.

Spectral region [enum]

Spectral region to be imported.

Default: 0

Bad band threshold [number]

If the proportion of erroneous pixels in the VNIR/SWIR Pixel Error Matrix,exceeds the bad band threshold (a value between 0 and 1), the band is marked as a bad band. If specified, Output VNIR/SWIR Error Matrix raster layer needs to be specified as well.

Select bad pixel [enum]

Pixels concidered to be erroneous.

Default: [0]

Outputs

Output VNIR/SWIR Cube raster layer [rasterDestination]: VNIR/SWIR Cube GTiff raster file destination. The surface spectral reflectance Coregistersed Hyperspectral Cube (in instrument geometric reference).
Output PAN raster layer [rasterDestination]: PAN VRT raster file destination. The surface panchromatic reflectance image (in instrument geometric reference).
Output VNIR/SWIR Geolocation Fields raster layer [rasterDestination]: VNIR/SWIR Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output VNIR/SWIR Geometric Fields raster layer [rasterDestination]: VNIR/SWIR Geometric Fields VRT raster file destination. Includes Observing Angle, Relative Azimuth Angle and Solar Zenith Angle bands.
Output VNIR/SWIR Error Matrix raster layer [rasterDestination]: VNIR/SWIR Pixel Error Matrix GTiff raster file destination.
Output PAN Geolocation Fields raster layer [rasterDestination]: PAN Geolocation Fields VRT raster file destination. Includes Latitude and Longitude bands.
Output PAN Error Matrix raster layer [rasterDestination]: PAN Pixel Error Matrix VRT raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportPrismaL2DProduct:

----------------
Arguments
----------------

file: File
    Argument type:  file
    Acceptable values:
            - Path to a file
spectralRegion: Spectral region
    Default value:  0
    Argument type:  enum
    Available values:
            - 0: VNIR/SWIR combined
            - 1: VNIR only
            - 2: SWIR only
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
badBandThreshold: Bad band threshold (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
badPixelType: Select bad pixel (optional)
    Default value:
    Argument type:  enum
    Available values:
            - 0: Invalid pixel from L1 product
            - 1: Negative value after atmospheric correction
            - 2: Saturated value after atmospheric correction
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputPrismaL2D_spectralCube: Output VNIR/SWIR Cube raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2D_panCube: Output PAN raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2D_spectralGeolocationFields: Output VNIR/SWIR Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2D_spectralGeometricFields: Output VNIR/SWIR Geometric Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2D_spectralErrorMatrix: Output VNIR/SWIR Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2D_panGeolocationFields: Output PAN Geolocation Fields raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputPrismaL2D_panErrorMatrix: Output PAN Error Matrix raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputPrismaL2D_spectralCube: <outputRaster>
    Output VNIR/SWIR Cube raster layer
outputPrismaL2D_panCube: <outputRaster>
    Output PAN raster layer
outputPrismaL2D_spectralGeolocationFields: <outputRaster>
    Output VNIR/SWIR Geolocation Fields raster layer
outputPrismaL2D_spectralGeometricFields: <outputRaster>
    Output VNIR/SWIR Geometric Fields raster layer
outputPrismaL2D_spectralErrorMatrix: <outputRaster>
    Output VNIR/SWIR Error Matrix raster layer
outputPrismaL2D_panGeolocationFields: <outputRaster>
    Output PAN Geolocation Fields raster layer
outputPrismaL2D_panErrorMatrix: <outputRaster>
    Output PAN Error Matrix raster layer

Import Sentinel-2 L2A product¶

Prepare a spectral raster layer from the given product. Wavelength information is set and data is scaled into the 0 to 10000 range.

Parameters

Metadata file [file]

The MTD_MSIL2A.xml metadata file associated with the product. Instead of executing this algorithm, you may drag&drop the metadata file directly from your system file browser onto the EnMAP-Box map view area.

Band list [enum]

Bands to be stacked together. Defaults to all 10m and 20m bands ordered by center wavelength. Note that the destination pixel size matches the smallest/finest pixel size over all selected bands.

Default: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ImportSentinel2L2AProduct:

----------------
Arguments
----------------

file: Metadata file
    Argument type:  file
    Acceptable values:
            - Path to a file
bandList: Band list (optional)
    Default value:
    Argument type:  enum
    Available values:
            - 0: B1, Coastal aerosol (443 Nanometers)[60 Meter]
            - 1: B2, Blue (492 Nanometers)[10 Meter]
            - 2: B3, Green (560 Nanometers)[10 Meter]
            - 3: B4, Red (665 Nanometers)[10 Meter]
            - 4: B5, Vegetation red edge (704 Nanometers)[20 Meter]
            - 5: B6, Vegetation red edge (741 Nanometers)[20 Meter]
            - 6: B7, Vegetation red edge (783 Nanometers)[20 Meter]
            - 7: B8, NIR (833 Nanometers)[10 Meter]
            - 8: B8A, Narrow NIR (865 Nanometers)[20 Meter]
            - 9: B9, Water vapour (945 Nanometers)[60 Meter]
            - 10: B11, SWIR (1614 Nanometers)[20 Meter]
            - 11: B12, SWIR (2202 Nanometers)[20 Meter]
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputSentinel2L2ARaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputSentinel2L2ARaster: <outputRaster>
    Output raster layer

Masking¶

Apply mask layer to raster layer¶

Areas where the mask layer evaluates to false are set to the source no data value (0, if undefined).

Parameters

Raster layer [raster]: Source raster layer.
Mask layer [layer]: A mask layer.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ApplyMaskLayerToRasterLayer:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
mask: Mask layer
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Create mask raster layer¶

Create a mask raster layer by applying a user-defined evaluation function band-wise to a source raster layer.

Parameters

Raster layer [raster]

Raster layer to be processed band-wise.

Function [string]

Python code defining the evaluation function. The defined function must return a binary-valued array with same shape as the input array.

Default:

import numpy as np

def function(array: np.ndarray, noDataValue: float):

    # if source no data value is not defined, use zero as no data value
    if noDataValue is None:
        noDataValue = 0

    # mask no data pixel
    marray = np.not_equal(array, noDataValue)

    # mask inf and nan pixel
    marray[np.logical_not(np.isfinite(array))] = 0

    # include further masking criteria here
    pass

    return marray

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:CreateMaskRasterLayer:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Function
    Default value:  import numpy as np

def function(array: np.ndarray, noDataValue: float):

    # if source no data value is not defined, use zero as no data value
    if noDataValue is None:
        noDataValue = 0

    # mask no data pixel
    marray = np.not_equal(array, noDataValue)

    # mask inf and nan pixel
    marray[np.logical_not(np.isfinite(array))] = 0

    # include further masking criteria here
    pass

    return marray
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Layer to mask raster layer¶

Interprete a layer as a mask layer.

Parameters

Layer [layer]: A layer to be interpreted as a mask layer.
Grid [raster]: The target grid. Can be skipped if the source layer is a raster layer.

Outputs

Output mask raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:LayerToMaskRasterLayer:

----------------
Arguments
----------------

raster: Layer
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
grid: Grid (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
outputMask: Output mask raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputMask: <outputRaster>
    Output mask raster layer

Raster analysis¶

Aggregate raster layer bands¶

Compute various aggregation functions over all bands, while ignoring no data values.

Parameters

Raster layer [raster]: A raster layer with bands to be aggregated.
Aggregation functions [enum]: Functions to be used. Number and order of selected functions equals number and order of output bands.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:AggregateRasterLayerBands:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
function: Aggregation functions
    Argument type:  enum
    Available values:
            - 0: arithmetic mean
            - 1: standard deviation
            - 2: variance
            - 3: minimum
            - 4: median
            - 5: maximum
            - 6: sum
            - 7: product
            - 8: range
            - 9: interquartile range
            - 10: any true
            - 11: all true
            - 12: arg minimum
            - 13: arg maximum
            - 14: 0-th percentile
            - 15: 1-th percentile
            - 16: 2-th percentile
            - 17: 3-th percentile
            - 18: 4-th percentile
            - 19: 5-th percentile
            - 20: 6-th percentile
            - 21: 7-th percentile
            - 22: 8-th percentile
            - 23: 9-th percentile
            - 24: 10-th percentile
            - 25: 11-th percentile
            - 26: 12-th percentile
            - 27: 13-th percentile
            - 28: 14-th percentile
            - 29: 15-th percentile
            - 30: 16-th percentile
            - 31: 17-th percentile
            - 32: 18-th percentile
            - 33: 19-th percentile
            - 34: 20-th percentile
            - 35: 21-th percentile
            - 36: 22-th percentile
            - 37: 23-th percentile
            - 38: 24-th percentile
            - 39: 25-th percentile
            - 40: 26-th percentile
            - 41: 27-th percentile
            - 42: 28-th percentile
            - 43: 29-th percentile
            - 44: 30-th percentile
            - 45: 31-th percentile
            - 46: 32-th percentile
            - 47: 33-th percentile
            - 48: 34-th percentile
            - 49: 35-th percentile
            - 50: 36-th percentile
            - 51: 37-th percentile
            - 52: 38-th percentile
            - 53: 39-th percentile
            - 54: 40-th percentile
            - 55: 41-th percentile
            - 56: 42-th percentile
            - 57: 43-th percentile
            - 58: 44-th percentile
            - 59: 45-th percentile
            - 60: 46-th percentile
            - 61: 47-th percentile
            - 62: 48-th percentile
            - 63: 49-th percentile
            - 64: 50-th percentile
            - 65: 51-th percentile
            - 66: 52-th percentile
            - 67: 53-th percentile
            - 68: 54-th percentile
            - 69: 55-th percentile
            - 70: 56-th percentile
            - 71: 57-th percentile
            - 72: 58-th percentile
            - 73: 59-th percentile
            - 74: 60-th percentile
            - 75: 61-th percentile
            - 76: 62-th percentile
            - 77: 63-th percentile
            - 78: 64-th percentile
            - 79: 65-th percentile
            - 80: 66-th percentile
            - 81: 67-th percentile
            - 82: 68-th percentile
            - 83: 69-th percentile
            - 84: 70-th percentile
            - 85: 71-th percentile
            - 86: 72-th percentile
            - 87: 73-th percentile
            - 88: 74-th percentile
            - 89: 75-th percentile
            - 90: 76-th percentile
            - 91: 77-th percentile
            - 92: 78-th percentile
            - 93: 79-th percentile
            - 94: 80-th percentile
            - 95: 81-th percentile
            - 96: 82-th percentile
            - 97: 83-th percentile
            - 98: 84-th percentile
            - 99: 85-th percentile
            - 100: 86-th percentile
            - 101: 87-th percentile
            - 102: 88-th percentile
            - 103: 89-th percentile
            - 104: 90-th percentile
            - 105: 91-th percentile
            - 106: 92-th percentile
            - 107: 93-th percentile
            - 108: 94-th percentile
            - 109: 95-th percentile
            - 110: 96-th percentile
            - 111: 97-th percentile
            - 112: 98-th percentile
            - 113: 99-th percentile
            - 114: 100-th percentile
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Convex hull and continuum-removal¶

Calculate convex hull and continuum-removed raster layers.

Parameters

Raster layer [raster]

Raster layer with spectral profiles.

X units [enum]

The x units used for convex hull calculations. In case of Nanometers, only spectral bands are used.

Default: 0

Outputs

Output convex hull raster layer [rasterDestination]: Raster file destination.
Output continuum removed raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:ConvexHullAndContinuumremoval:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
xUnits: X units
    Default value:  0
    Argument type:  enum
    Available values:
            - 0: Band numbers
            - 1: Nanometers
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputConvexHull: Output convex hull raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputContinuumRemoved: Output continuum removed raster layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputConvexHull: <outputRaster>
    Output convex hull raster layer
outputContinuumRemoved: <outputRaster>
    Output continuum removed raster layer

Create spectral indices¶

Create a stack of Awesome Spectral Indices and/or custom indices. Credits: the Awesome Spectral Indices project provides a ready-to-use curated list of Spectral Indices for Remote Sensing applications, maintained by David Montero Loaiza.

Parameters

Raster layer [raster]

A spectral raster layer.

Indices [string]

The list of indices to be created. Usage examples: Create (predefined) NDVI: <code>NDVI</code> Create stack of NDVI and EVI: <code>NDVI, EVI</code> Create custom index: <code>MyNDVI = (N - R) / (N + R)</code> See the full list of predefined Awesome Spectral Indices.

Default: NDVI

Scale factor [number]

Spectral reflectance scale factor. Some indices require data to be scaled into the 0 to 1 range. If your data is scaled differently, specify an appropriate scale factor.E.g. for Int16 data scaled into the 0 to 10000 range, use a value of 10000.

Outputs

Output VRT layer [rasterDestination]: VRT file destination.

Command-line usage

>qgis_process help enmapbox:CreateSpectralIndices:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
indices: Indices
    Default value:  NDVI
    Argument type:  string
    Acceptable values:
            - String value
scale: Scale factor (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
A: Aerosols band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
B: Blue band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
G: Green band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
R: Red band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
RE1: Red Edge 1 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
RE2: Red Edge 2 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
RE3: Red Edge 3 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
RE4: Red Edge 4 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
N: NIR band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
S1: SWIR 1 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
S2: SWIR 2 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
T1: Thermal 1 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
T2: Thermal 2 band (optional)
    Default value:  -1
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
L: Canopy background adjustment (optional)
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
g: Gain factor (optional)
    Default value:  2.5
    Argument type:  number
    Acceptable values:
            - A numeric value
C1: Coefficient 1 for the aerosol resistance term (optional)
    Default value:  6
    Argument type:  number
    Acceptable values:
            - A numeric value
C2: Coefficient 2 for the aerosol resistance term (optional)
    Default value:  7.5
    Argument type:  number
    Acceptable values:
            - A numeric value
cexp: Exponent used for OCVI (optional)
    Default value:  1.16
    Argument type:  number
    Acceptable values:
            - A numeric value
nexp: Exponent used for GDVI (optional)
    Default value:  2
    Argument type:  number
    Acceptable values:
            - A numeric value
alpha: Weighting coefficient used for WDRVI (optional)
    Default value:  0.1
    Argument type:  number
    Acceptable values:
            - A numeric value
gamma: Weighting coefficient used for ARVI (optional)
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
sla: Soil line slope (optional)
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
slb: Soil line intercept (optional)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
outputVrt: Output VRT layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputVrt: <outputRaster>
    Output VRT layer

Raster layer zonal aggregation¶

Aggregates raster layer pixel profiles by categories.

Parameters

Raster layer [raster]: Raster layer to be aggregated.
Categorized raster layer [raster]: Categorized raster layer specifying the zones.

Outputs

Output table [vectorDestination]: Table file destination.

Command-line usage

>qgis_process help enmapbox:RasterLayerZonalAggregation:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
categorizedRaster: Categorized raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
outputTable: Output table
    Argument type:  vectorDestination
    Acceptable values:
            - Path for new vector layer

----------------
Outputs
----------------

outputTable: <outputVector>
    Output table

Raster math¶

Perform mathematical calculations on raster layer and vector layer data. Use any NumPy-based arithmetic, or even arbitrary Python code. See the RasterMath cookbook recipe for detailed usage instructions.

Parameters

Code [string]

The mathematical calculation to be performed on the selected input arrays. Select inputs in the available data sources section or use the raster layer R1, …, R10 and vector layer V1, …, V10. In the code snippets section you can find some prepdefined code snippets ready to use. See the RasterMath cookbook recipe for detailed usage instructions.

Grid [raster]

The destination grid. If not specified, the grid of the first raster layer is used.

32-bit floating-point inputs [boolean]

Whether to cast inputs to 32-bit floating point.

Default: True

Block overlap [number]

The number of columns and rows to read from the neighbouring blocks. Needs to be specified only when performing spatial operations, to avoid artifacts at block borders.

Monolithic processing [boolean]

Whether to read all data for the full extent at once, instead of block-wise processing. This may be useful for some spatially unbound operations, like segmentation or region growing, when calculating global statistics, or if RAM is not an issue at all.

Default: False

Raster layers mapped to RS [multilayer]

Additional list of raster layers mapped to a list variable RS.

Outputs

Output raster layer [rasterDestination]: Raster file destination for writing the default output variable. Additional outputs are written into the same directory. See the RasterMath cookbook recipe for detailed usage instructions.

Command-line usage

>qgis_process help enmapbox:RasterMath:

----------------
Arguments
----------------

code: Code
    Argument type:  string
    Acceptable values:
            - String value
grid: Grid (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
floatInput: 32-bit floating-point inputs
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
overlap: Block overlap (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
monolithic: Monolithic processing (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
R1: Raster layer mapped to R1 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R2: Raster layer mapped to R2 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R3: Raster layer mapped to R3 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R4: Raster layer mapped to R4 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R5: Raster layer mapped to R5 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R6: Raster layer mapped to R6 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R7: Raster layer mapped to R7 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R8: Raster layer mapped to R8 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R9: Raster layer mapped to R9 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
R10: Raster layer mapped to R10 (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
V1: Vector layer mapped to V1 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V2: Vector layer mapped to V2 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V3: Vector layer mapped to V3 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V4: Vector layer mapped to V4 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V5: Vector layer mapped to V5 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V6: Vector layer mapped to V6 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V7: Vector layer mapped to V7 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V8: Vector layer mapped to V8 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V9: Vector layer mapped to V9 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
V10: Vector layer mapped to V10 (optional)
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
RS: Raster layers mapped to RS (optional)
    Argument type:  multilayer
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Sample raster layer values¶

Creates a new point layer with the same attributes of the input layer and the raster values corresponding to the pixels covered by polygons or point location. The resulting point vector contains 1) all input attributes from the Locations vector, 2) attributes SAMPLE_{i}, one for each input raster band, 3) two attributes PIXEL_X, PIXEL_Y for storing the raster pixel locations (zero-based),and 4), in case of polygon locations, an attribute COVER for storing the pixel coverage (%). Note that we assume non-overlapping feature geometries! In case of overlapping geometries, split the Locations layer into non-overlapping subsets, perform the sampling for each subset individually, and finally concatenate the results.

Parameters

Raster layer [raster]

A raster layer to sample data from.

Vector layer [vector]

A vector layer defining the locations to sample.

Pixel coverage (%) [range]

Samples with polygon pixel coverage outside the given range are excluded. This parameter has no effect in case of point locations.

Default: [50, 100]

Outputs

Output point layer [vectorDestination]: Vector file destination.

Command-line usage

>qgis_process help enmapbox:SampleRasterLayerValues:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
vector: Vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
coverageRange: Pixel coverage (%) (optional)
    Default value:
    Argument type:  range
    Acceptable values:
            - Two comma separated numeric values, e.g. '1,10'
outputPointsData: Output point layer
    Argument type:  vectorDestination
    Acceptable values:
            - Path for new vector layer

----------------
Outputs
----------------

outputPointsData: <outputVector>
    Output point layer

VRT band math¶

Create a single-band VRT raster layer specifying a VRT Python Pixel Function. Use any NumPy-based arithmetic, or even arbitrary Python code.

Parameters

Raster layer [raster]

Input raster layer.

Selected bands [band]

List of input bands.

Code [string]

The mathematical calculation to be performed on the selected input bands in_ar.Result must be copied to out_ar. For detailed usage information read the VRT Python Pixel Function docs.

Data type [enum]

Output data type.

Default: 5

No data value [number]

Output no data value.

Band name [string]

Output band name.

Buffer radius [number]

The number of columns and rows to read from the neighbouring blocks. Needs to be specified only when performing spatial operations, to avoid artifacts at block borders.

Outputs

Output VRT layer [rasterDestination]: VRT file destination.

Command-line usage

>qgis_process help enmapbox:VrtBandMath:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
bandList: Selected bands
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
code: Code
    Argument type:  string
    Acceptable values:
            - String value
dataType: Data type (optional)
    Default value:  5
    Argument type:  enum
    Available values:
            - 0: Byte
            - 1: Int16
            - 2: UInt16
            - 3: UInt32
            - 4: Int32
            - 5: Float32
            - 6: Float64
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
noData: No data value (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
bandName: Band name (optional)
    Argument type:  string
    Acceptable values:
            - String value
overlap: Buffer radius (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
outputVrt: Output VRT layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputVrt: <outputRaster>
    Output VRT layer

Raster conversion¶

Create RGB image from class probability/fraction layer¶

Create an RGB image from a class fraction layer or class probability layer.The RGB pixel color of a single pixel is given by the weighted mean of the given category colors.The weights are given by class fractions/probabilities (i.e. values between 0 and 1). For example, pure pixels with cover fractions of 1 appear in its pure category color. A mixed-pixel with a 50% fractions in two categories colored in red and green,appears in a dull yellow ( 0.5 x (255, 0, 0) + 0.5 x (0, 255, 0) = (127, 127, 0) ).

Parameters

Class probability/fraction layer [raster]: A class fraction layer or class probability layer used as weights for calculating final pixel colors.
Colors [string]: Comma separated list of hex-color strings (e.g. ‘#FF0000’ for red) representing (pure) category colors, one color for each band in the given class probability/fraction layer. If not specified, colors have to be specified by a categorized layer (Colors from categorized layer).
Colors from categorized layer [layer]: A categorized layer with (pure) category colors, one category for each band in the given class probability/fraction layer. If not specified, colors have to be specified by list (Colors).

Outputs

Output RGB image [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:CreateRgbImageFromClassProbabilityfractionLayer:

----------------
Arguments
----------------

probability: Class probability/fraction layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
colors: Colors (optional)
    Argument type:  string
    Acceptable values:
            - String value
colorsLayer: Colors from categorized layer (optional)
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
outputRGBImage: Output RGB image
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRGBImage: <outputRaster>
    Output RGB image

Save raster layer as¶

Saves a raster layer as a GeoTiff, ENVI or VRT file. This is a slimmed down version of the more powerful “Translate raster layer” algorithm.

Parameters

Raster layer [raster]

Source raster layer.

Copy metadata [boolean]

Whether to copy metadata from source to destination.

Default: True

Copy style [boolean]

Whether to copy style from source to destination.

Default: True

Output options [string]

Output format and creation options.

Default: **

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SaveRasterLayerAs:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
copyMetadata: Copy metadata
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
copyStyle: Copy style
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
creationProfile: Output options (optional)
    Default value:
    Argument type:  string
    Acceptable values:
            - String value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Translate categorized raster layer¶

Translates categorized raster layer into target grid. Resampling is done via a two-step majority voting approach. First, the categorized raster layer is resampled at x10 finer resolution, and subsequently aggregated back to the target resolution using majority voting. This approach leads to pixel-wise class decisions that are accurate to the percent.

Parameters

Categorized raster layer [raster]

A categorized raster layer to be resampled.

Grid [raster]

The target grid.

Majority voting [boolean]

Whether to use majority voting. Turn off to use simple nearest neighbour resampling, which is much faster, but may result in highly inaccurate decisions.

Default: True

Outputs

Output categorized raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:TranslateCategorizedRasterLayer:

----------------
Arguments
----------------

categorizedRaster: Categorized raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
grid: Grid
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
majorityVoting: Majority voting
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputTranslatedCategorizedRaster: Output categorized raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputTranslatedCategorizedRaster: <outputRaster>
    Output categorized raster layer

Translate raster layer¶

Convert raster data between different formats, potentially performing some operations like spatial subsetting, spatial resampling, reprojection, band subsetting, band reordering, data scaling, no data value specification, and data type conversion.

Parameters

Raster layer [raster]

Source raster layer.

Selected bands [band]

Bands to subset and rearrange. An empty selection defaults to all bands in native order.

Grid [raster]

The destination grid.

Copy metadata [boolean]

Whether to copy GDAL metadata from source to destination.

Default: False

Copy style [boolean]

Whether to copy style from source to destination.

Default: False

Exclude bad bands [boolean]

Whether to exclude bad bands (given by BBL metadata item inside ENVI domain). Also see The ENVI Header Format for more details: https://www.l3harrisgeospatial.com/docs/ENVIHeaderFiles.html

Default: False

Write ENVI header [boolean]

Whether to write an ENVI header *.hdr sidecar file with spectral metadata required for proper visualization in ENVI software.

Default: True

Spectral raster layer for band subsetting [raster]

A spectral raster layer used for specifying a band subset by matching the center wavelength.

Selected spectral bands [band]

Spectral bands used to match source raster bands.An empty selection defaults to all bands in native order.

Data offset value [number]

A data offset value applied to each band.

Data gain/scale value [number]

A data gain/scale value applied to each band.

Spatial extent [extent]

Spatial extent for clipping the destination grid, which is given by the source Raster or the selected Grid. In both cases, the extent is aligned with the actual pixel grid to avoid subpixel shifts.

Column subset [range]

Column subset range in pixels to extract.

Row subset [range]

Rows subset range in pixels to extract.

Resample algorithm [enum]

Spatial resample algorithm.

Default: 0

Source no data value [number]

The value to be used instead of the original raster layer no data value.

No data value [number]

The value to be used instead of the default destination no data value.

Unset source no data value [boolean]

Whether to unset (i.e. not use) the source no data value.

Default: False

Unset no data value [boolean]

Whether to unset the destination no data value.

Default: False

Working Data type [enum]

Working data type that is applied before resampling.

Data type [enum]

Output data type.

Output options [string]

Output format and creation options.

Default: **

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:TranslateRasterLayer:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
bandList: Selected bands (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
grid: Grid (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
copyMetadata: Copy metadata
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
copyStyle: Copy style
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
excludeBadBands: Exclude bad bands
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
writeEnviHeader: Write ENVI header
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
spectralSubset: Spectral raster layer for band subsetting (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
spectralBandList: Selected spectral bands (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
offset: Data offset value (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
scale: Data gain/scale value (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
extent: Spatial extent (optional)
    Argument type:  extent
    Acceptable values:
            - A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'
            - Path to a layer. The extent of the layer is used.
sourceColumns: Column subset (optional)
    Argument type:  range
    Acceptable values:
            - Two comma separated numeric values, e.g. '1,10'
sourceRows: Row subset (optional)
    Argument type:  range
    Acceptable values:
            - Two comma separated numeric values, e.g. '1,10'
resampleAlg: Resample algorithm
    Default value:  0
    Argument type:  enum
    Available values:
            - 0: NearestNeighbour
            - 1: Bilinear
            - 2: Cubic
            - 3: CubicSpline
            - 4: Lanczos
            - 5: Average
            - 6: Mode
            - 7: Min
            - 8: Q1
            - 9: Med
            - 10: Q3
            - 11: Max
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
sourceNoData: Source no data value (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
noData: No data value (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
unsetSourceNoData: Unset source no data value
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
unsetNoData: Unset no data value
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
workingType: Working Data type (optional)
    Argument type:  enum
    Available values:
            - 0: Byte
            - 1: Int16
            - 2: UInt16
            - 3: UInt32
            - 4: Int32
            - 5: Float32
            - 6: Float64
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
dataType: Data type (optional)
    Argument type:  enum
    Available values:
            - 0: Byte
            - 1: Int16
            - 2: UInt16
            - 3: UInt32
            - 4: Int32
            - 5: Float32
            - 6: Float64
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
creationProfile: Output options (optional)
    Default value:
    Argument type:  string
    Acceptable values:
            - String value
outputTranslatedRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputTranslatedRaster: <outputRaster>
    Output raster layer

Write ENVI header¶

Write/update the ENVI *.hdr header file to enable full compatibility to the ENVI software. The header file stores wavelength, FWHM and bad band multiplier (BBL) information.

Parameters

Raster layer [raster]: Source GeoTiff /ENVI raster layer.

Command-line usage

>qgis_process help enmapbox:WriteEnviHeader:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer

----------------
Outputs
----------------

Raster miscellaneous¶

Create grid¶

Create an empty raster that can be used as a grid.

Parameters

CRS [crs]

Destination coordinate reference system.

Extent [extent]

Destination extent.

Size units [enum]

Units to use when defining target raster size/resolution.

Width / horizontal resolution [number]

Target width if size units is “Pixels”, or horizontal resolution if size units is “Georeferenced units”.

Default: 0

Height / vertical resolution [number]

Target height if size units is “Pixels”, or vertical resolution if size units is “Georeferenced units”.

Default: 0

Outputs

Output grid [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:CreateGrid:

----------------
Arguments
----------------

crs: CRS
    Argument type:  crs
    Acceptable values:
            - CRS as an auth ID (e.g. 'EPSG:3111')
            - CRS as a PROJ4 string (e.g. 'PROJ4:…')
            - CRS as a WKT string (e.g. 'WKT:…')
            - Path to a layer. The CRS of the layer is used.
extent: Extent
    Argument type:  extent
    Acceptable values:
            - A comma delimited string of x min, x max, y min, y max. E.g. '4,10,101,105'
            - Path to a layer. The extent of the layer is used.
unit: Size units
    Argument type:  enum
    Available values:
            - 0: Pixels
            - 1: Georeferenced units
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
width: Width / horizontal resolution
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
hight: Height / vertical resolution
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
outputGrid: Output grid
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputGrid: <outputRaster>
    Output grid

Edit raster source band properties¶

Set band properties for the given GDAL raster source. Be sure to close the raster in QGIS beforehand.

Parameters

GDAL raster source [file]: GDAL raster source.
Band names [string]: List of band name strings (e.g”.
Center wavelength values [string]: List of band center wavelength values in nanometers. Use nan value to unset property.
Full width at half maximum (FWHM) values [string]: List of band FWHM values in nanometers. Use nan value to unset property.
Bad band multipliers [string]: List of bad band multiplier values (BBL).
Start times [string]: List of band start time timestamps strings. Format is: 2009-08-20T09:44:50. Use empty string to unset property
End times [string]: List of band end time timestamps strings. Format is: 2009-08-20T09:44:50. Use empty string to unset property
Offsets [string]: List of band data offset values.
Scales [string]: List of band data scale/gain values.
No data values [string]: List of band no data values. Use None to unset property.

Command-line usage

>qgis_process help enmapbox:EditRasterSourceBandProperties:

----------------
Arguments
----------------

source: GDAL raster source
    Argument type:  file
    Acceptable values:
            - Path to a file
names: Band names (optional)
    Argument type:  string
    Acceptable values:
            - String value
wavelengths: Center wavelength values (optional)
    Argument type:  string
    Acceptable values:
            - String value
fwhms: Full width at half maximum (FWHM) values (optional)
    Argument type:  string
    Acceptable values:
            - String value
badBandMultipliers: Bad band multipliers (optional)
    Argument type:  string
    Acceptable values:
            - String value
startTimes: Start times (optional)
    Argument type:  string
    Acceptable values:
            - String value
endTimes: End times (optional)
    Argument type:  string
    Acceptable values:
            - String value
offsets: Offsets (optional)
    Argument type:  string
    Acceptable values:
            - String value
scales: Scales (optional)
    Argument type:  string
    Acceptable values:
            - String value
noDataValues: No data values (optional)
    Argument type:  string
    Acceptable values:
            - String value

----------------
Outputs
----------------

Stack raster layers¶

Stack raster layers and store the result as a VRT file.This is a slimmed down version of the more powerful/complicated GDAL “Build virtual raster” algorithm. If you also want to delete or rearrange individually bands, just use the “Subset raster layer bands” algorithm afterwards.

Parameters

Raster layers [multilayer]: Source raster layers.
Grid [raster]: Reference grid specifying the destination extent, pixel size and projection. If not defined, gdal.BuildVrt defaults are used.
Band [number]: Specify a band number used for stacking, instead of using all bands.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:StackRasterLayers:

----------------
Arguments
----------------

rasters: Raster layers
    Argument type:  multilayer
grid: Grid (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
band: Band (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Subset raster layer bands¶

Subsets raster layer bands and stores the result as a VRT file.This is a slimmed down version of the more powerful “Translate raster layer” algorithm.

Parameters

Raster layer [raster]

Source raster layer.

Selected bands [band]

Bands to subset and rearrange. An empty selection defaults to all bands in native order.

Exclude bad bands [boolean]

Whether to exclude bad bands.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SubsetRasterLayerBands:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
bandList: Selected bands (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
excludeBadBands: Exclude bad bands
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Raster projections¶

Geolocate raster layer¶

Geolocate a raster layer using geolocation arrays. See Geolocation Arrays in the GDAL documentation for details on the concept and parameters.

Parameters

Raster layer [raster]

A raster layer to be geolocated.

X locations raster layer [raster]

A raster layer containing the x geolocation array.

Y locations raster layer [raster]

A raster layer containing the y geolocation array.

Grid [raster]

The destination grid. If skipped, the grid CRS is set to the CRS of the geolocation arrays, extent and resolution is controlled by gdal.Warp defaults.

Locations CRS [crs]

The coordinate reference system of the geolocation arrays.

Default: <QgsCoordinateReferenceSystem: EPSG:4326>

No data value [number]

Value used to fill no data regions introduced by warping.

X locations band [band]

The x coordinates band.

Y locations band [band]

The y coordinates band.

Pixel offset [number]

Pixel offset into geo-located data of left geolocation pixel.

Default: 0

Line offset [number]

Line offset into geo-located data of top geolocation pixel.

Default: 0

Pixel step [number]

Each geolocation pixel represents this many geolocated pixels.

Default: 1

Line step [number]

Each geolocation pixel represents this many geolocated lines.

Default: 1

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:GeolocateRasterLayer:

----------------
Arguments
----------------

raster: Raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
xRaster: X locations raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
yRaster: Y locations raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
grid: Grid (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
crs: Locations CRS (optional)
    Default value:  EPSG:4326
    Argument type:  crs
    Acceptable values:
            - CRS as an auth ID (e.g. 'EPSG:3111')
            - CRS as a PROJ4 string (e.g. 'PROJ4:…')
            - CRS as a WKT string (e.g. 'WKT:…')
            - Path to a layer. The CRS of the layer is used.
noDataValue: No data value (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
xBand: X locations band (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
yBand: Y locations band (optional)
    Argument type:  band
    Acceptable values:
            - Integer value representing an existing raster band number
pixelOffset: Pixel offset (optional)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
lineOffset: Line offset (optional)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
pixelStep: Pixel step (optional)
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
lineStep: Line step (optional)
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
outputGeolocatedRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputGeolocatedRaster: <outputRaster>
    Output raster layer

Regression¶

Fit CatBoostRegressor¶

Implementation of the scikit-learn API for CatBoost regressor.

Parameters

Regressor [string]

Scikit-learn python code. See CatBoostRegressor for information on different parameters.

Default:

from catboost import CatBoostRegressor
regressor = CatBoostRegressor(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitCatboostregressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from catboost import CatBoostRegressor
regressor = CatBoostRegressor(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit GaussianProcessRegressor¶

Gaussian process regression (GPR).

Parameters

Regressor [string]

Scikit-learn python code. See GaussianProcessRegressor for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF

gpr = GaussianProcessRegressor(RBF())
regressor = make_pipeline(StandardScaler(), gpr)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitGaussianprocessregressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF

gpr = GaussianProcessRegressor(RBF())
regressor = make_pipeline(StandardScaler(), gpr)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit generic regressor¶

A generic regressor.

Parameters

Regressor [string]

Scikit-learn python code.

Default:

from sklearn.dummy import DummyRegressor

classifier = DummyRegressor()

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitGenericRegressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.dummy import DummyRegressor

classifier = DummyRegressor()
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit KernelRidge¶

Kernel ridge regression. Kernel ridge regression (KRR) combines ridge regression (linear least squares with l2-norm regularization) with the kernel trick. It thus learns a linear function in the space induced by the respective kernel and the data. For non-linear kernels, this corresponds to a non-linear function in the original space. The form of the model learned by KRR is identical to support vector regression (SVR). However, different loss functions are used: KRR uses squared error loss while support vector regression uses epsilon-insensitive loss, both combined with l2 regularization. In contrast to SVR, fitting a KRR model can be done in closed-form and is typically faster for medium-sized datasets. On the other hand, the learned model is non-sparse and thus slower than SVR, which learns a sparse model for epsilon > 0, at prediction-time.

Parameters

Regressor [string]

Scikit-learn python code. See KernelRidge for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.kernel_ridge import KernelRidge

krr = KernelRidge()
param_grid = {'kernel': ['rbf'],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedKRR = GridSearchCV(cv=3, estimator=krr, scoring='neg_mean_absolute_error', param_grid=param_grid)
regressor = make_pipeline(StandardScaler(), tunedKRR)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitKernelridge:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.kernel_ridge import KernelRidge

krr = KernelRidge()
param_grid = {'kernel': ['rbf'],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'alpha': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedKRR = GridSearchCV(cv=3, estimator=krr, scoring='neg_mean_absolute_error', param_grid=param_grid)
regressor = make_pipeline(StandardScaler(), tunedKRR)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit LGBMRegressor¶

Implementation of the scikit-learn API for LightGBM regressor.

Parameters

Regressor [string]

Scikit-learn python code. See LGBMRegressor for information on different parameters.

Default:

from lightgbm import LGBMRegressor

regressor = LGBMRegressor(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitLgbmregressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from lightgbm import LGBMRegressor

regressor = LGBMRegressor(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit LinearRegression¶

Ordinary least squares Linear Regression. LinearRegression fits a linear model with coefficients w = (w1, …, wp) to minimize the residual sum of squares between the observed targets in the dataset, and the targets predicted by the linear approximation.

Parameters

Regressor [string]

Scikit-learn python code. See LinearRegression for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

linearRegression = LinearRegression()
regressor = make_pipeline(StandardScaler(), linearRegression)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitLinearregression:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

linearRegression = LinearRegression()
regressor = make_pipeline(StandardScaler(), linearRegression)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit LinearSVR¶

Linear Support Vector Regression. Similar to SVR with parameter kernel=’linear’, but implemented in terms of liblinear rather than libsvm, so it has more flexibility in the choice of penalties and loss functions and should scale better to large numbers of samples.

Parameters

Regressor [string]

Scikit-learn python code. See LinearSVR for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.multioutput import MultiOutputRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVR

svr = LinearSVR()
param_grid = {'epsilon': [0.], 'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVR = GridSearchCV(cv=3, estimator=svr, scoring='neg_mean_absolute_error', param_grid=param_grid)
scaledAndTunedSVR = make_pipeline(StandardScaler(), tunedSVR)
regressor = MultiOutputRegressor(scaledAndTunedSVR)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitLinearsvr:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.multioutput import MultiOutputRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVR

svr = LinearSVR()
param_grid = {'epsilon': [0.], 'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVR = GridSearchCV(cv=3, estimator=svr, scoring='neg_mean_absolute_error', param_grid=param_grid)
scaledAndTunedSVR = make_pipeline(StandardScaler(), tunedSVR)
regressor = MultiOutputRegressor(scaledAndTunedSVR)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit PLSRegression¶

Partial Least Squares regression.

Parameters

Regressor [string]

Scikit-learn python code. See PLSRegression for information on different parameters.

Default:

from sklearn.cross_decomposition import PLSRegression

regressor = PLSRegression(n_components=2)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitPlsregression:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.cross_decomposition import PLSRegression

regressor = PLSRegression(n_components=2)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit RandomForestRegressor¶

A random forest regressor. A random forest is a meta estimator that fits a number of classifying decision trees on various sub-samples of the dataset and uses averaging to improve the predictive accuracy and control over-fitting. The sub-sample size is controlled with the max_samples parameter if bootstrap=True (default), otherwise the whole dataset is used to build each tree.

Parameters

Regressor [string]

Scikit-learn python code. See RandomForestRegressor for information on different parameters.

Default:

from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators=100, oob_score=True)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitRandomforestregressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.ensemble import RandomForestRegressor
regressor = RandomForestRegressor(n_estimators=100, oob_score=True)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit SVR (polynomial kernel)¶

Epsilon-Support Vector Regression. The free parameters in the model are C and epsilon. The implementation is based on libsvm. The fit time complexity is more than quadratic with the number of samples which makes it hard to scale to datasets with more than a couple of 10000 samples.

Parameters

Regressor [string]

Scikit-learn python code. See SVR, GridSearchCV, StandardScaler for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR

svr = SVR()
param_grid = {'kernel': ['poly'],
              'epsilon': 0.,
              'coef0': [0],
              'degree': [3],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVR = GridSearchCV(cv=3, estimator=svr, scoring='neg_mean_absolute_error', param_grid=param_grid)
regressor = make_pipeline(StandardScaler(), tunedSVR)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitSvrPolynomialKernel:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR

svr = SVR()
param_grid = {'kernel': ['poly'],
              'epsilon': 0.,
              'coef0': [0],
              'degree': [3],
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVR = GridSearchCV(cv=3, estimator=svr, scoring='neg_mean_absolute_error', param_grid=param_grid)
regressor = make_pipeline(StandardScaler(), tunedSVR)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit SVR (RBF kernel)¶

Epsilon-Support Vector Regression. The free parameters in the model are C and epsilon. The implementation is based on libsvm. The fit time complexity is more than quadratic with the number of samples which makes it hard to scale to datasets with more than a couple of 10000 samples.

Parameters

Regressor [string]

Scikit-learn python code. See SVR, GridSearchCV, StandardScaler for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR

svr = SVR()
param_grid = {'kernel': ['rbf'],
              'epsilon': 0.,
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVR = GridSearchCV(cv=3, estimator=svr, scoring='neg_mean_absolute_error', param_grid=param_grid)
regressor = make_pipeline(StandardScaler(), tunedSVR)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitSvrRbfKernel:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR

svr = SVR()
param_grid = {'kernel': ['rbf'],
              'epsilon': 0.,
              'gamma': [0.001, 0.01, 0.1, 1, 10, 100, 1000],
              'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
tunedSVR = GridSearchCV(cv=3, estimator=svr, scoring='neg_mean_absolute_error', param_grid=param_grid)
regressor = make_pipeline(StandardScaler(), tunedSVR)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit XGBRegressor¶

Implementation of the scikit-learn API for XGBoost regression.

Parameters

Regressor [string]

Scikit-learn python code. See XGBRegressor for information on different parameters.

Default:

from xgboost import XGBRegressor

regressor = XGBRegressor(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitXgbregressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from xgboost import XGBRegressor

regressor = XGBRegressor(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Fit XGBRFRegressor¶

Implementation of the scikit-learn API for XGBoost random forest regression.

Parameters

Regressor [string]

Scikit-learn python code. See XGBRFRegressor for information on different parameters.

Default:

from xgboost import XGBRFRegressor

regressor = XGBRFRegressor(n_estimators=100)

Training dataset [file]

Training dataset pickle file used for fitting the classifier. If not specified, an unfitted classifier is created.

Outputs

Output regressor [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitXgbrfregressor:

----------------
Arguments
----------------

regressor: Regressor
    Default value:  from xgboost import XGBRFRegressor

regressor = XGBRFRegressor(n_estimators=100)
    Argument type:  string
    Acceptable values:
            - String value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor

Predict regression layer¶

Uses a fitted regressor to predict a regression layer from a raster layer with features.

Parameters

Raster layer with features [raster]: A raster layer with bands used as features. Regressor features and raster bands are matched by name.
Regressor [file]: A fitted regressor.

Outputs

Output regression layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:PredictRegressionLayer:

----------------
Arguments
----------------

raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
regressor: Regressor
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRegression: Output regression layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRegression: <outputRaster>
    Output regression layer

Receiver operating characteristic (ROC) and detection error tradeoff (DET) curves¶

Compute receiver operating characteristic (ROC) and detection error tradeoff (DET) curves. For more details see the Scikit-Learn user guide: Receiver operating characteristic (ROC) and Detection error tradeoff (DET). Note that observed classes and predicted class probabilities are matched by name.

Parameters

Class probability layer [raster]

A class probability layer that is to be assessed.

Observed categorized layer [layer]

A categorized layer representing a (ground truth) observation sample.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:ReceiverOperatingCharacteristicRocAndDetectionErrorTradeoffDetCurves:

----------------
Arguments
----------------

regression: Class probability layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
reference: Observed categorized layer
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outRocCurve: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outRocCurve: <outputHtml>
    Output report

Regression layer accuracy report¶

Estimates map accuracy.We use the formulars as described in Scikit-Learn Regression metrics user guide. Observed and predicted target variables are matched by name.

Parameters

Regression layer [raster]

A regression layer that is to be assessed.

Observed continuous-valued layer [layer]

A continuous-valued layer representing a (ground truth) observation sample.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:RegressionLayerAccuracyReport:

----------------
Arguments
----------------

regression: Regression layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
reference: Observed continuous-valued layer
    Argument type:  layer
    Acceptable values:
            - Path to a vector, raster or mesh layer
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outRegressionPerformance: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outRegressionPerformance: <outputHtml>
    Output report

Regression workflow¶

The regression workflow combines regressor fitting, map prediction and accuracy assessment.

Parameters

Training dataset [file]

Training dataset pickle file used for fitting the regressor.

Regressor [string]

Scikit-Learn Python code specifying a regressor.

Raster layer with features [raster]

A raster layer with bands used as features.

Number of cross-validation folds [number]

The number of folds used for assessing cross-validation performance.

Default: 10

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output regressor [fileDestination]: Destination pickle file.
Output regression layer [rasterDestination]: Raster file destination.
Output regressor performance report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:RegressionWorkflow:

----------------
Arguments
----------------

dataset: Training dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
regressor: Regressor
    Argument type:  string
    Acceptable values:
            - String value
raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
nfold: Number of cross-validation folds (optional)
    Default value:  10
    Argument type:  number
    Acceptable values:
            - A numeric value
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRegressor: Output regressor
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file
outputRegression: Output regression layer (optional)
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer
outputRegressorPerformance: Output regressor performance report (optional)
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressor: <outputFile>
    Output regressor
outputRegression: <outputRaster>
    Output regression layer
outputRegressorPerformance: <outputHtml>
    Output regressor performance report

Regressor performance report¶

Evaluates regressor performance.

Parameters

Regressor [file]

Regressor pickle file.

Test dataset [file]

Test dataset pickle file used for assessing the regressor performance.

Number of cross-validation folds [number]

The number of folds used for assessing cross-validation performance. If not specified (default), simple test performance is assessed.

Open output report in webbrowser after running algorithm [boolean]

Whether to open the output report in the web browser.

Default: True

Outputs

Output report [fileDestination]: Output report file destination.

Command-line usage

>qgis_process help enmapbox:RegressorPerformanceReport:

----------------
Arguments
----------------

regressor: Regressor
    Argument type:  file
    Acceptable values:
            - Path to a file
dataset: Test dataset
    Argument type:  file
    Acceptable values:
            - Path to a file
nfold: Number of cross-validation folds (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
openReport: Open output report in webbrowser after running algorithm
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRegressorPerformance: Output report
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputRegressorPerformance: <outputHtml>
    Output report

Spectral resampling¶

Spectral resampling (to custom sensor)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

# Place response function definition here. Should look something like this:
responses = OrderedDict()

# Option 1: Use band name as dict-key,
#           together with fully defined list of (<wavelength>, <response>) tuples as dict-value.
#           Define <response> as values between 0 and 1 for each whole nanometer <wavelength>.
responses['Blue'] = [(443, 0.001), (444, 0.002), ..., (509, 1.0), ..., (518, 0.002), (519, 0.001)]
responses['Green'] = [(519, 0.001), (520, 0.002), ..., (550, 1.0), ..., (597, 0.003), (598, 0.001)]
...
# Option 2: Use band center wavelength as dict-key,
#           together with band full width at half maximum (FWHM) as dict-value.
#           The response function is modelled as an RBF around the center wavelength with a width of FWHM / 2.355.
#           See https://en.wikipedia.org/wiki/Full_width_at_half_maximum for details.
responses[460] = 5.8
...
responses[2409] = 9.1

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToCustomSensor:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

# Place response function definition here. Should look something like this:
responses = OrderedDict()

# Option 1: Use band name as dict-key,
#           together with fully defined list of (<wavelength>, <response>) tuples as dict-value.
#           Define <response> as values between 0 and 1 for each whole nanometer <wavelength>.
responses['Blue'] = [(443, 0.001), (444, 0.002), ..., (509, 1.0), ..., (518, 0.002), (519, 0.001)]
responses['Green'] = [(519, 0.001), (520, 0.002), ..., (550, 1.0), ..., (597, 0.003), (598, 0.001)]
...
# Option 2: Use band center wavelength as dict-key,
#           together with band full width at half maximum (FWHM) as dict-value.
#           The response function is modelled as an RBF around the center wavelength with a width of FWHM / 2.355.
#           See https://en.wikipedia.org/wiki/Full_width_at_half_maximum for details.
responses[460] = 5.8
...
responses[2409] = 9.1

    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to DESIS HSI)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the DESIS mission website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
wavelength = [402.0, 404.2, 406.8, 409.3, 411.8, 414.3, 416.9, 419.4, 422.0, 424.6, 427.3, 429.8, 432.4, 434.9, 437.5, 439.9, 442.5, 445.1, 447.8, 450.3, 452.9, 455.6, 458.2, 460.7, 463.3, 465.8, 468.3, 470.7, 473.4, 475.9, 478.5, 481.3, 483.8, 486.4, 489.0, 491.6, 494.0, 496.5, 499.2, 501.8, 504.3, 506.9, 509.5, 512.2, 514.7, 517.2, 519.6, 522.2, 524.7, 527.3, 529.7, 532.3, 534.9, 537.5, 540.2, 542.7, 545.2, 547.7, 550.3, 552.9, 555.5, 558.1, 560.6, 563.2, 565.8, 568.4, 571.0, 573.5, 576.1, 578.6, 581.1, 583.7, 586.3, 588.8, 591.3, 594.0, 596.6, 599.1, 601.6, 604.2, 606.8, 609.2, 611.8, 614.3, 616.9, 619.5, 622.1, 624.7, 627.2, 629.7, 632.2, 634.7, 637.2, 639.8, 642.3, 644.9, 647.5, 650.0, 652.6, 655.2, 657.7, 660.2, 662.8, 665.3, 667.9, 670.5, 673.1, 675.8, 678.4, 680.9, 683.5, 685.9, 688.4, 690.9, 693.5, 696.2, 698.8, 701.5, 703.9, 706.7, 709.4, 711.8, 714.0, 716.4, 718.9, 721.6, 724.2, 726.9, 729.4, 732.1, 734.4, 736.9, 739.5, 742.0, 744.5, 747.2, 749.7, 752.3, 755.2, 757.7, 760.3, 763.0, 765.0, 767.5, 770.3, 772.7, 775.4, 778.0, 780.5, 783.0, 785.6, 788.2, 790.6, 793.1, 795.9, 798.4, 801.2, 804.0, 806.7, 809.1, 811.7, 814.3, 816.9, 819.8, 822.8, 824.2, 827.2, 829.2, 832.2, 834.9, 836.7, 840.1, 842.0, 844.7, 847.7, 850.0, 852.4, 855.4, 857.9, 860.3, 862.9, 865.4, 868.0, 870.6, 873.2, 875.8, 878.8, 881.5, 883.1, 885.3, 888.1, 890.9, 894.1, 896.0, 898.3, 901.2, 903.7, 906.0, 908.7, 911.6, 914.8, 916.6, 918.4, 921.0, 923.9, 927.1, 929.6, 931.9, 934.5, 937.3, 939.4, 942.0, 944.7, 947.3, 949.6, 951.9, 954.2, 957.3, 959.6, 962.3, 965.5, 968.1, 970.4, 972.9, 976.0, 978.7, 980.0, 981.9, 984.8, 988.9, 991.6, 993.1, 995.6, 997.9, 999.5]
fwhm = [2.4, 3.6, 3.8, 3.8, 3.6, 3.8, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.2, 3.2, 3.0, 3.2, 3.4, 3.2, 3.4, 3.4, 3.4, 3.6, 3.4, 3.4, 3.2, 3.2, 3.4, 3.2, 3.2, 3.4, 3.4, 3.4, 3.2, 3.2, 3.2, 3.2, 3.2, 3.2, 3.4, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.6, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.6, 3.6, 3.6, 3.4, 3.4, 3.4, 3.6, 3.6, 3.6, 3.6, 3.6, 3.6, 3.4, 3.4, 3.4, 3.4, 3.6, 3.6, 3.6, 3.6, 3.6, 3.4, 3.6, 3.6, 3.4, 3.4, 3.6, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.2, 3.4, 3.4, 3.4, 3.4, 3.6, 3.6, 3.4, 3.6, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.4, 3.4, 3.2, 3.4, 3.4, 3.4, 3.6, 3.6, 3.8, 3.6, 3.6, 4.0, 4.0, 3.8, 3.4, 3.4, 3.6, 3.4, 3.4, 3.2, 3.2, 3.4, 3.4, 3.2, 3.4, 3.4, 3.4, 3.4, 3.6, 3.4, 3.4, 3.6, 3.0, 3.4, 3.4, 3.4, 3.4, 3.6, 3.2, 3.4, 3.2, 3.4, 3.2, 3.4, 3.4, 3.4, 3.2, 3.0, 3.0, 3.0, 3.0, 3.0, 3.2, 3.6, 3.2, 3.0, 3.6, 2.8, 3.6, 2.6, 3.0, 3.4, 2.8, 3.4, 3.4, 3.0, 3.2, 3.2, 3.2, 3.0, 3.4, 3.2, 3.4, 3.4, 3.4, 3.6, 4.0, 3.0, 3.0, 3.4, 3.6, 3.6, 3.6, 3.2, 3.2, 3.6, 3.6, 3.0, 4.0, 4.0, 3.8, 3.0, 3.6, 4.0, 3.6, 3.4, 3.4, 3.2, 3.8, 3.4, 3.2, 3.8, 3.6, 3.6, 3.6, 3.0, 3.6, 3.4, 3.4, 3.4, 3.6, 3.8, 3.6, 3.4, 4.8, 3.6, 2.8, 4.0, 6.6, 4.2, 3.4, 3.0, 3.4, 3.4, 3.0]
for w, f in zip(wavelength, fwhm):
    responses[w] = f

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToDesisHsi:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
wavelength = [402.0, 404.2, 406.8, 409.3, 411.8, 414.3, 416.9, 419.4, 422.0, 424.6, 427.3, 429.8, 432.4, 434.9, 437.5, 439.9, 442.5, 445.1, 447.8, 450.3, 452.9, 455.6, 458.2, 460.7, 463.3, 465.8, 468.3, 470.7, 473.4, 475.9, 478.5, 481.3, 483.8, 486.4, 489.0, 491.6, 494.0, 496.5, 499.2, 501.8, 504.3, 506.9, 509.5, 512.2, 514.7, 517.2, 519.6, 522.2, 524.7, 527.3, 529.7, 532.3, 534.9, 537.5, 540.2, 542.7, 545.2, 547.7, 550.3, 552.9, 555.5, 558.1, 560.6, 563.2, 565.8, 568.4, 571.0, 573.5, 576.1, 578.6, 581.1, 583.7, 586.3, 588.8, 591.3, 594.0, 596.6, 599.1, 601.6, 604.2, 606.8, 609.2, 611.8, 614.3, 616.9, 619.5, 622.1, 624.7, 627.2, 629.7, 632.2, 634.7, 637.2, 639.8, 642.3, 644.9, 647.5, 650.0, 652.6, 655.2, 657.7, 660.2, 662.8, 665.3, 667.9, 670.5, 673.1, 675.8, 678.4, 680.9, 683.5, 685.9, 688.4, 690.9, 693.5, 696.2, 698.8, 701.5, 703.9, 706.7, 709.4, 711.8, 714.0, 716.4, 718.9, 721.6, 724.2, 726.9, 729.4, 732.1, 734.4, 736.9, 739.5, 742.0, 744.5, 747.2, 749.7, 752.3, 755.2, 757.7, 760.3, 763.0, 765.0, 767.5, 770.3, 772.7, 775.4, 778.0, 780.5, 783.0, 785.6, 788.2, 790.6, 793.1, 795.9, 798.4, 801.2, 804.0, 806.7, 809.1, 811.7, 814.3, 816.9, 819.8, 822.8, 824.2, 827.2, 829.2, 832.2, 834.9, 836.7, 840.1, 842.0, 844.7, 847.7, 850.0, 852.4, 855.4, 857.9, 860.3, 862.9, 865.4, 868.0, 870.6, 873.2, 875.8, 878.8, 881.5, 883.1, 885.3, 888.1, 890.9, 894.1, 896.0, 898.3, 901.2, 903.7, 906.0, 908.7, 911.6, 914.8, 916.6, 918.4, 921.0, 923.9, 927.1, 929.6, 931.9, 934.5, 937.3, 939.4, 942.0, 944.7, 947.3, 949.6, 951.9, 954.2, 957.3, 959.6, 962.3, 965.5, 968.1, 970.4, 972.9, 976.0, 978.7, 980.0, 981.9, 984.8, 988.9, 991.6, 993.1, 995.6, 997.9, 999.5]
fwhm = [2.4, 3.6, 3.8, 3.8, 3.6, 3.8, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.2, 3.2, 3.0, 3.2, 3.4, 3.2, 3.4, 3.4, 3.4, 3.6, 3.4, 3.4, 3.2, 3.2, 3.4, 3.2, 3.2, 3.4, 3.4, 3.4, 3.2, 3.2, 3.2, 3.2, 3.2, 3.2, 3.4, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.6, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.6, 3.6, 3.6, 3.4, 3.4, 3.4, 3.6, 3.6, 3.6, 3.6, 3.6, 3.6, 3.4, 3.4, 3.4, 3.4, 3.6, 3.6, 3.6, 3.6, 3.6, 3.4, 3.6, 3.6, 3.4, 3.4, 3.6, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.2, 3.4, 3.4, 3.4, 3.4, 3.6, 3.6, 3.4, 3.6, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.4, 3.6, 3.6, 3.4, 3.4, 3.4, 3.4, 3.2, 3.4, 3.4, 3.4, 3.6, 3.6, 3.8, 3.6, 3.6, 4.0, 4.0, 3.8, 3.4, 3.4, 3.6, 3.4, 3.4, 3.2, 3.2, 3.4, 3.4, 3.2, 3.4, 3.4, 3.4, 3.4, 3.6, 3.4, 3.4, 3.6, 3.0, 3.4, 3.4, 3.4, 3.4, 3.6, 3.2, 3.4, 3.2, 3.4, 3.2, 3.4, 3.4, 3.4, 3.2, 3.0, 3.0, 3.0, 3.0, 3.0, 3.2, 3.6, 3.2, 3.0, 3.6, 2.8, 3.6, 2.6, 3.0, 3.4, 2.8, 3.4, 3.4, 3.0, 3.2, 3.2, 3.2, 3.0, 3.4, 3.2, 3.4, 3.4, 3.4, 3.6, 4.0, 3.0, 3.0, 3.4, 3.6, 3.6, 3.6, 3.2, 3.2, 3.6, 3.6, 3.0, 4.0, 4.0, 3.8, 3.0, 3.6, 4.0, 3.6, 3.4, 3.4, 3.2, 3.8, 3.4, 3.2, 3.8, 3.6, 3.6, 3.6, 3.0, 3.6, 3.4, 3.4, 3.4, 3.6, 3.8, 3.6, 3.4, 4.8, 3.6, 2.8, 4.0, 6.6, 4.2, 3.4, 3.0, 3.4, 3.4, 3.0]
for w, f in zip(wavelength, fwhm):
    responses[w] = f
    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to EnMAP)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the EnMAP mission website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
wavelength = [460, 465, 470, 475, 479, 484, 489, 494, 499, 503, 508, 513, 518, 523, 528, 533, 538, 543, 549, 554, 559, 565, 570, 575, 581, 587, 592, 598, 604, 610, 616, 622, 628, 634, 640, 646, 653, 659, 665, 672, 679, 685, 692, 699, 706, 713, 720, 727, 734, 741, 749, 756, 763, 771, 778, 786, 793, 801, 809, 817, 824, 832, 840, 848, 856, 864, 872, 880, 888, 896, 915, 924, 934, 944, 955, 965, 975, 986, 997, 1007, 1018, 1029, 1040, 1051, 1063, 1074, 1086, 1097, 1109, 1120, 1132, 1144, 1155, 1167, 1179, 1191, 1203, 1215, 1227, 1239, 1251, 1263, 1275, 1287, 1299, 1311, 1323, 1522, 1534, 1545, 1557, 1568, 1579, 1590, 1601, 1612, 1624, 1634, 1645, 1656, 1667, 1678, 1689, 1699, 1710, 1721, 1731, 1742, 1752, 1763, 1773, 1783, 2044, 2053, 2062, 2071, 2080, 2089, 2098, 2107, 2115, 2124, 2133, 2141, 2150, 2159, 2167, 2176, 2184, 2193, 2201, 2210, 2218, 2226, 2234, 2243, 2251, 2259, 2267, 2275, 2283, 2292, 2300, 2308, 2315, 2323, 2331, 2339, 2347, 2355, 2363, 2370, 2378, 2386, 2393, 2401, 2409]
fwhm = [5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.9, 5.9, 6.0, 6.0, 6.1, 6.1, 6.2, 6.2, 6.3, 6.4, 6.4, 6.5, 6.6, 6.6, 6.7, 6.8, 6.9, 6.9, 7.0, 7.1, 7.2, 7.3, 7.3, 7.4, 7.5, 7.6, 7.7, 7.8, 7.9, 7.9, 8.0, 8.1, 8.2, 8.3, 8.4, 8.4, 8.5, 8.6, 8.7, 8.7, 8.8, 8.9, 8.9, 9.0, 9.1, 9.1, 9.2, 9.3, 9.3, 9.4, 9.4, 9.5, 9.5, 9.6, 9.6, 9.6, 9.6, 9.7, 9.7, 9.7, 11.8, 11.9, 12.1, 12.2, 12.4, 12.5, 12.7, 12.8, 12.9, 13.1, 13.2, 13.3, 13.4, 13.5, 13.6, 13.7, 13.8, 13.9, 14.0, 14.0, 14.1, 14.1, 14.2, 14.2, 14.3, 14.3, 14.3, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 13.7, 13.6, 13.6, 13.5, 13.5, 13.4, 13.4, 13.3, 13.2, 13.2, 13.1, 13.1, 13.0, 12.9, 12.9, 12.8, 12.8, 12.7, 12.7, 12.6, 12.5, 12.5, 12.4, 12.4, 12.3, 10.9, 10.8, 10.8, 10.7, 10.7, 10.6, 10.6, 10.5, 10.5, 10.4, 10.4, 10.4, 10.3, 10.3, 10.2, 10.2, 10.1, 10.1, 10.1, 10.0, 10.0, 9.9, 9.9, 9.9, 9.8, 9.8, 9.7, 9.7, 9.7, 9.6, 9.6, 9.6, 9.5, 9.5, 9.4, 9.4, 9.4, 9.3, 9.3, 9.3, 9.2, 9.2, 9.1, 9.1, 9.1]
for w, f in zip(wavelength, fwhm):
    responses[w] = f

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToEnmap:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
wavelength = [460, 465, 470, 475, 479, 484, 489, 494, 499, 503, 508, 513, 518, 523, 528, 533, 538, 543, 549, 554, 559, 565, 570, 575, 581, 587, 592, 598, 604, 610, 616, 622, 628, 634, 640, 646, 653, 659, 665, 672, 679, 685, 692, 699, 706, 713, 720, 727, 734, 741, 749, 756, 763, 771, 778, 786, 793, 801, 809, 817, 824, 832, 840, 848, 856, 864, 872, 880, 888, 896, 915, 924, 934, 944, 955, 965, 975, 986, 997, 1007, 1018, 1029, 1040, 1051, 1063, 1074, 1086, 1097, 1109, 1120, 1132, 1144, 1155, 1167, 1179, 1191, 1203, 1215, 1227, 1239, 1251, 1263, 1275, 1287, 1299, 1311, 1323, 1522, 1534, 1545, 1557, 1568, 1579, 1590, 1601, 1612, 1624, 1634, 1645, 1656, 1667, 1678, 1689, 1699, 1710, 1721, 1731, 1742, 1752, 1763, 1773, 1783, 2044, 2053, 2062, 2071, 2080, 2089, 2098, 2107, 2115, 2124, 2133, 2141, 2150, 2159, 2167, 2176, 2184, 2193, 2201, 2210, 2218, 2226, 2234, 2243, 2251, 2259, 2267, 2275, 2283, 2292, 2300, 2308, 2315, 2323, 2331, 2339, 2347, 2355, 2363, 2370, 2378, 2386, 2393, 2401, 2409]
fwhm = [5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.8, 5.9, 5.9, 6.0, 6.0, 6.1, 6.1, 6.2, 6.2, 6.3, 6.4, 6.4, 6.5, 6.6, 6.6, 6.7, 6.8, 6.9, 6.9, 7.0, 7.1, 7.2, 7.3, 7.3, 7.4, 7.5, 7.6, 7.7, 7.8, 7.9, 7.9, 8.0, 8.1, 8.2, 8.3, 8.4, 8.4, 8.5, 8.6, 8.7, 8.7, 8.8, 8.9, 8.9, 9.0, 9.1, 9.1, 9.2, 9.3, 9.3, 9.4, 9.4, 9.5, 9.5, 9.6, 9.6, 9.6, 9.6, 9.7, 9.7, 9.7, 11.8, 11.9, 12.1, 12.2, 12.4, 12.5, 12.7, 12.8, 12.9, 13.1, 13.2, 13.3, 13.4, 13.5, 13.6, 13.7, 13.8, 13.9, 14.0, 14.0, 14.1, 14.1, 14.2, 14.2, 14.3, 14.3, 14.3, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 14.4, 13.7, 13.6, 13.6, 13.5, 13.5, 13.4, 13.4, 13.3, 13.2, 13.2, 13.1, 13.1, 13.0, 12.9, 12.9, 12.8, 12.8, 12.7, 12.7, 12.6, 12.5, 12.5, 12.4, 12.4, 12.3, 10.9, 10.8, 10.8, 10.7, 10.7, 10.6, 10.6, 10.5, 10.5, 10.4, 10.4, 10.4, 10.3, 10.3, 10.2, 10.2, 10.1, 10.1, 10.1, 10.0, 10.0, 9.9, 9.9, 9.9, 9.8, 9.8, 9.7, 9.7, 9.7, 9.6, 9.6, 9.6, 9.5, 9.5, 9.4, 9.4, 9.4, 9.3, 9.3, 9.3, 9.2, 9.2, 9.1, 9.1, 9.1]
for w, f in zip(wavelength, fwhm):
    responses[w] = f
    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to Landsat 4/5 TM)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the Landsat missions website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
responses['Blue'] = [(421, 0.001), (422, 0.001), (423, 0.001), (424, 0.001), (425, 0.001), (426, 0.002), (427, 0.002), (428, 0.002), (429, 0.003), (430, 0.003), (431, 0.005), (432, 0.007), (433, 0.01), (434, 0.013), (435, 0.017), (436, 0.02), (437, 0.025), (438, 0.031), (439, 0.037), (440, 0.042), (441, 0.048), (442, 0.053), (443, 0.059), (444, 0.064), (445, 0.07), (446, 0.083), (447, 0.121), (448, 0.172), (449, 0.273), (450, 0.372), (451, 0.442), (452, 0.514), (453, 0.579), (454, 0.628), (455, 0.711), (456, 0.732), (457, 0.742), (458, 0.75), (459, 0.755), (460, 0.756), (461, 0.766), (462, 0.776), (463, 0.786), (464, 0.797), (465, 0.807), (466, 0.812), (467, 0.817), (468, 0.822), (469, 0.827), (470, 0.829), (471, 0.831), (472, 0.833), (473, 0.835), (474, 0.838), (475, 0.846), (476, 0.853), (477, 0.861), (478, 0.868), (479, 0.876), (480, 0.883), (481, 0.886), (482, 0.888), (483, 0.891), (484, 0.893), (485, 0.896), (486, 0.898), (487, 0.901), (488, 0.903), (489, 0.905), (490, 0.908), (491, 0.918), (492, 0.928), (493, 0.938), (494, 0.948), (495, 0.952), (496, 0.956), (497, 0.961), (498, 0.965), (499, 0.97), (500, 0.979), (501, 0.987), (502, 0.994), (503, 1.0), (504, 0.999), (505, 0.99), (506, 0.963), (507, 0.936), (508, 0.909), (509, 0.881), (510, 0.852), (511, 0.824), (512, 0.81), (513, 0.796), (514, 0.779), (515, 0.756), (516, 0.707), (517, 0.596), (518, 0.497), (519, 0.413), (520, 0.329), (521, 0.245), (522, 0.137), (523, 0.105), (524, 0.094), (525, 0.083), (526, 0.072), (527, 0.061), (528, 0.055), (529, 0.052), (530, 0.049), (531, 0.045), (532, 0.041), (533, 0.038), (534, 0.034), (535, 0.031), (536, 0.027), (537, 0.024), (538, 0.022), (539, 0.019), (540, 0.017), (541, 0.015), (542, 0.013), (543, 0.011), (544, 0.01), (545, 0.009), (546, 0.007), (547, 0.006), (548, 0.006), (549, 0.006), (550, 0.005), (551, 0.005), (552, 0.005), (553, 0.005), (554, 0.005), (555, 0.004), (556, 0.004), (557, 0.004), (558, 0.004), (559, 0.004), (560, 0.003), (561, 0.003), (562, 0.003), (563, 0.003), (564, 0.002), (565, 0.002), (566, 0.002), (567, 0.002), (568, 0.002), (569, 0.001), (570, 0.001)]
responses['Green'] = [(502, 0.002), (503, 0.003), (504, 0.007), (505, 0.009), (506, 0.011), (507, 0.014), (508, 0.016), (509, 0.019), (510, 0.022), (511, 0.024), (512, 0.027), (513, 0.03), (514, 0.032), (515, 0.035), (516, 0.05), (517, 0.066), (518, 0.091), (519, 0.12), (520, 0.152), (521, 0.191), (522, 0.231), (523, 0.271), (524, 0.312), (525, 0.353), (526, 0.392), (527, 0.43), (528, 0.468), (529, 0.507), (530, 0.537), (531, 0.561), (532, 0.577), (533, 0.591), (534, 0.605), (535, 0.619), (536, 0.633), (537, 0.647), (538, 0.661), (539, 0.675), (540, 0.69), (541, 0.7), (542, 0.711), (543, 0.721), (544, 0.732), (545, 0.743), (546, 0.753), (547, 0.764), (548, 0.775), (549, 0.786), (550, 0.797), (551, 0.803), (552, 0.809), (553, 0.815), (554, 0.821), (555, 0.826), (556, 0.832), (557, 0.837), (558, 0.843), (559, 0.848), (560, 0.854), (561, 0.859), (562, 0.865), (563, 0.871), (564, 0.873), (565, 0.874), (566, 0.875), (567, 0.877), (568, 0.878), (569, 0.879), (570, 0.88), (571, 0.881), (572, 0.882), (573, 0.883), (574, 0.884), (575, 0.885), (576, 0.886), (577, 0.887), (578, 0.891), (579, 0.896), (580, 0.9), (581, 0.905), (582, 0.909), (583, 0.914), (584, 0.932), (585, 0.944), (586, 0.954), (587, 0.963), (588, 0.971), (589, 0.977), (590, 0.982), (591, 0.988), (592, 0.994), (593, 0.999), (594, 1.0), (595, 0.999), (596, 0.998), (597, 0.995), (598, 0.98), (599, 0.964), (600, 0.949), (601, 0.927), (602, 0.894), (603, 0.862), (604, 0.829), (605, 0.796), (606, 0.747), (607, 0.672), (608, 0.597), (609, 0.521), (610, 0.467), (611, 0.413), (612, 0.359), (613, 0.304), (614, 0.249), (615, 0.206), (616, 0.181), (617, 0.156), (618, 0.131), (619, 0.108), (620, 0.097), (621, 0.087), (622, 0.076), (623, 0.066), (624, 0.055), (625, 0.052), (626, 0.049), (627, 0.045), (628, 0.042), (629, 0.039), (630, 0.036), (631, 0.032), (632, 0.029), (633, 0.026), (634, 0.023), (635, 0.021), (636, 0.019), (637, 0.017), (638, 0.015), (639, 0.013), (640, 0.011), (641, 0.01), (642, 0.009), (643, 0.008), (644, 0.006), (645, 0.005), (646, 0.003), (647, 0.002), (648, 0.001)]
responses['Red'] = [(563, 0.001), (564, 0.001), (565, 0.001), (566, 0.001), (567, 0.001), (568, 0.001), (569, 0.002), (570, 0.002), (571, 0.002), (572, 0.002), (573, 0.002), (574, 0.002), (575, 0.002), (576, 0.002), (577, 0.002), (578, 0.002), (579, 0.002), (580, 0.002), (581, 0.002), (582, 0.002), (583, 0.002), (584, 0.002), (585, 0.002), (586, 0.002), (587, 0.002), (588, 0.002), (589, 0.002), (590, 0.003), (591, 0.003), (592, 0.003), (593, 0.004), (594, 0.004), (595, 0.004), (596, 0.005), (597, 0.006), (598, 0.007), (599, 0.008), (600, 0.009), (601, 0.011), (602, 0.014), (603, 0.016), (604, 0.019), (605, 0.023), (606, 0.027), (607, 0.03), (608, 0.034), (609, 0.038), (610, 0.041), (611, 0.045), (612, 0.062), (613, 0.081), (614, 0.101), (615, 0.12), (616, 0.14), (617, 0.16), (618, 0.18), (619, 0.24), (620, 0.327), (621, 0.414), (622, 0.449), (623, 0.471), (624, 0.492), (625, 0.514), (626, 0.535), (627, 0.557), (628, 0.579), (629, 0.601), (630, 0.623), (631, 0.65), (632, 0.687), (633, 0.737), (634, 0.787), (635, 0.803), (636, 0.818), (637, 0.835), (638, 0.849), (639, 0.86), (640, 0.871), (641, 0.883), (642, 0.894), (643, 0.906), (644, 0.912), (645, 0.917), (646, 0.922), (647, 0.928), (648, 0.933), (649, 0.939), (650, 0.944), (651, 0.943), (652, 0.942), (653, 0.942), (654, 0.941), (655, 0.94), (656, 0.939), (657, 0.938), (658, 0.937), (659, 0.936), (660, 0.935), (661, 0.937), (662, 0.939), (663, 0.943), (664, 0.948), (665, 0.954), (666, 0.959), (667, 0.965), (668, 0.97), (669, 0.975), (670, 0.979), (671, 0.983), (672, 0.987), (673, 0.99), (674, 0.997), (675, 0.996), (676, 0.998), (677, 1.0), (678, 0.998), (679, 0.996), (680, 0.994), (681, 0.973), (682, 0.973), (683, 0.974), (684, 0.964), (685, 0.945), (686, 0.927), (687, 0.908), (688, 0.871), (689, 0.822), (690, 0.773), (691, 0.687), (692, 0.594), (693, 0.505), (694, 0.433), (695, 0.361), (696, 0.289), (697, 0.223), (698, 0.188), (699, 0.152), (700, 0.116), (701, 0.106), (702, 0.095), (703, 0.084), (704, 0.074), (705, 0.063), (706, 0.057), (707, 0.054), (708, 0.051), (709, 0.048), (710, 0.045), (711, 0.042), (712, 0.039), (713, 0.036), (714, 0.033), (715, 0.03), (716, 0.027), (717, 0.024), (718, 0.022), (719, 0.021), (720, 0.02), (721, 0.018), (722, 0.017), (723, 0.015), (724, 0.014), (725, 0.012), (726, 0.011), (727, 0.01), (728, 0.009), (729, 0.007), (730, 0.006), (731, 0.006), (732, 0.005), (733, 0.005), (734, 0.005), (735, 0.005), (736, 0.004), (737, 0.004), (738, 0.004), (739, 0.003), (740, 0.003), (741, 0.003), (742, 0.002), (743, 0.002), (744, 0.002), (745, 0.002), (746, 0.001)]
responses['NIR'] = [(727, 0.001), (728, 0.001), (729, 0.002), (730, 0.002), (731, 0.003), (732, 0.003), (733, 0.004), (734, 0.004), (735, 0.005), (736, 0.005), (737, 0.006), (738, 0.006), (739, 0.007), (740, 0.007), (741, 0.008), (742, 0.008), (743, 0.009), (744, 0.009), (745, 0.01), (746, 0.012), (747, 0.014), (748, 0.016), (749, 0.018), (750, 0.02), (751, 0.022), (752, 0.025), (753, 0.028), (754, 0.031), (755, 0.034), (756, 0.042), (757, 0.05), (758, 0.058), (759, 0.066), (760, 0.074), (761, 0.083), (762, 0.09), (763, 0.099), (764, 0.121), (765, 0.143), (766, 0.165), (767, 0.187), (768, 0.216), (769, 0.251), (770, 0.286), (771, 0.322), (772, 0.357), (773, 0.393), (774, 0.428), (775, 0.464), (776, 0.5), (777, 0.544), (778, 0.587), (779, 0.63), (780, 0.673), (781, 0.717), (782, 0.76), (783, 0.795), (784, 0.822), (785, 0.849), (786, 0.876), (787, 0.902), (788, 0.917), (789, 0.932), (790, 0.946), (791, 0.956), (792, 0.963), (793, 0.97), (794, 0.976), (795, 0.983), (796, 0.986), (797, 0.99), (798, 0.993), (799, 0.997), (800, 1.0), (801, 0.997), (802, 0.994), (803, 0.992), (804, 0.989), (805, 0.986), (806, 0.983), (807, 0.98), (808, 0.977), (809, 0.974), (810, 0.971), (811, 0.968), (812, 0.965), (813, 0.962), (814, 0.959), (815, 0.956), (816, 0.953), (817, 0.95), (818, 0.947), (819, 0.945), (820, 0.942), (821, 0.939), (822, 0.936), (823, 0.933), (824, 0.93), (825, 0.93), (826, 0.932), (827, 0.934), (828, 0.936), (829, 0.938), (830, 0.94), (831, 0.942), (832, 0.944), (833, 0.946), (834, 0.948), (835, 0.95), (836, 0.952), (837, 0.954), (838, 0.956), (839, 0.958), (840, 0.96), (841, 0.962), (842, 0.964), (843, 0.966), (844, 0.968), (845, 0.97), (846, 0.972), (847, 0.974), (848, 0.976), (849, 0.978), (850, 0.98), (851, 0.978), (852, 0.977), (853, 0.975), (854, 0.974), (855, 0.973), (856, 0.971), (857, 0.97), (858, 0.967), (859, 0.965), (860, 0.963), (861, 0.96), (862, 0.959), (863, 0.959), (864, 0.959), (865, 0.96), (866, 0.961), (867, 0.962), (868, 0.963), (869, 0.964), (870, 0.965), (871, 0.967), (872, 0.968), (873, 0.965), (874, 0.963), (875, 0.96), (876, 0.955), (877, 0.95), (878, 0.945), (879, 0.94), (880, 0.935), (881, 0.929), (882, 0.922), (883, 0.915), (884, 0.908), (885, 0.901), (886, 0.894), (887, 0.887), (888, 0.88), (889, 0.873), (890, 0.866), (891, 0.865), (892, 0.864), (893, 0.858), (894, 0.846), (895, 0.834), (896, 0.823), (897, 0.811), (898, 0.8), (899, 0.789), (900, 0.779), (901, 0.733), (902, 0.688), (903, 0.643), (904, 0.578), (905, 0.509), (906, 0.44), (907, 0.371), (908, 0.321), (909, 0.275), (910, 0.23), (911, 0.185), (912, 0.156), (913, 0.13), (914, 0.105), (915, 0.084), (916, 0.074), (917, 0.064), (918, 0.054), (919, 0.044), (920, 0.034), (921, 0.031), (922, 0.027), (923, 0.024), (924, 0.02), (925, 0.017), (926, 0.015), (927, 0.013), (928, 0.012), (929, 0.01), (930, 0.008), (931, 0.008), (932, 0.007), (933, 0.007), (934, 0.006), (935, 0.006), (936, 0.005), (937, 0.005), (938, 0.005), (939, 0.004), (940, 0.004), (941, 0.003), (942, 0.003), (943, 0.002), (944, 0.002), (945, 0.002), (946, 0.001)]
responses['SWIR-1'] = [(1512, 0.001), (1513, 0.001), (1514, 0.001), (1515, 0.001), (1516, 0.001), (1517, 0.001), (1518, 0.002), (1519, 0.002), (1520, 0.002), (1521, 0.002), (1522, 0.003), (1523, 0.004), (1524, 0.004), (1525, 0.005), (1526, 0.006), (1527, 0.007), (1528, 0.007), (1529, 0.008), (1530, 0.009), (1531, 0.01), (1532, 0.012), (1533, 0.013), (1534, 0.015), (1535, 0.016), (1536, 0.018), (1537, 0.019), (1538, 0.021), (1539, 0.022), (1540, 0.024), (1541, 0.028), (1542, 0.033), (1543, 0.038), (1544, 0.043), (1545, 0.048), (1546, 0.057), (1547, 0.067), (1548, 0.077), (1549, 0.087), (1550, 0.098), (1551, 0.114), (1552, 0.132), (1553, 0.151), (1554, 0.17), (1555, 0.189), (1556, 0.208), (1557, 0.228), (1558, 0.247), (1559, 0.267), (1560, 0.287), (1561, 0.312), (1562, 0.34), (1563, 0.368), (1564, 0.396), (1565, 0.425), (1566, 0.454), (1567, 0.483), (1568, 0.512), (1569, 0.541), (1570, 0.571), (1571, 0.598), (1572, 0.625), (1573, 0.653), (1574, 0.68), (1575, 0.708), (1576, 0.732), (1577, 0.755), (1578, 0.777), (1579, 0.8), (1580, 0.824), (1581, 0.842), (1582, 0.858), (1583, 0.874), (1584, 0.89), (1585, 0.907), (1586, 0.916), (1587, 0.924), (1588, 0.93), (1589, 0.934), (1590, 0.939), (1591, 0.943), (1592, 0.947), (1593, 0.946), (1594, 0.943), (1595, 0.94), (1596, 0.937), (1597, 0.934), (1598, 0.933), (1599, 0.933), (1600, 0.933), (1601, 0.931), (1602, 0.929), (1603, 0.928), (1604, 0.928), (1605, 0.928), (1606, 0.928), (1607, 0.928), (1608, 0.928), (1609, 0.933), (1610, 0.94), (1611, 0.944), (1612, 0.947), (1613, 0.949), (1614, 0.952), (1615, 0.955), (1616, 0.958), (1617, 0.961), (1618, 0.963), (1619, 0.966), (1620, 0.969), (1621, 0.972), (1622, 0.975), (1623, 0.978), (1624, 0.98), (1625, 0.983), (1626, 0.985), (1627, 0.988), (1628, 0.989), (1629, 0.989), (1630, 0.988), (1631, 0.987), (1632, 0.986), (1633, 0.985), (1634, 0.984), (1635, 0.983), (1636, 0.981), (1637, 0.98), (1638, 0.979), (1639, 0.978), (1640, 0.977), (1641, 0.976), (1642, 0.975), (1643, 0.974), (1644, 0.973), (1645, 0.972), (1646, 0.971), (1647, 0.97), (1648, 0.969), (1649, 0.969), (1650, 0.968), (1651, 0.967), (1652, 0.967), (1653, 0.968), (1654, 0.97), (1655, 0.971), (1656, 0.973), (1657, 0.975), (1658, 0.977), (1659, 0.979), (1660, 0.98), (1661, 0.982), (1662, 0.983), (1663, 0.985), (1664, 0.986), (1665, 0.988), (1666, 0.988), (1667, 0.987), (1668, 0.986), (1669, 0.985), (1670, 0.984), (1671, 0.984), (1672, 0.983), (1673, 0.983), (1674, 0.982), (1675, 0.982), (1676, 0.981), (1677, 0.981), (1678, 0.98), (1679, 0.98), (1680, 0.979), (1681, 0.979), (1682, 0.978), (1683, 0.978), (1684, 0.977), (1685, 0.977), (1686, 0.976), (1687, 0.976), (1688, 0.975), (1689, 0.975), (1690, 0.974), (1691, 0.975), (1692, 0.977), (1693, 0.978), (1694, 0.98), (1695, 0.982), (1696, 0.983), (1697, 0.985), (1698, 0.987), (1699, 0.988), (1700, 0.99), (1701, 0.99), (1702, 0.991), (1703, 0.992), (1704, 0.993), (1705, 0.993), (1706, 0.994), (1707, 0.995), (1708, 0.995), (1709, 0.996), (1710, 0.997), (1711, 0.998), (1712, 0.998), (1713, 0.999), (1714, 0.999), (1715, 1.0), (1716, 0.999), (1717, 0.998), (1718, 0.996), (1719, 0.995), (1720, 0.993), (1721, 0.992), (1722, 0.99), (1723, 0.988), (1724, 0.986), (1725, 0.974), (1726, 0.982), (1727, 0.98), (1728, 0.978), (1729, 0.976), (1730, 0.975), (1731, 0.973), (1732, 0.971), (1733, 0.969), (1734, 0.967), (1735, 0.965), (1736, 0.963), (1737, 0.961), (1738, 0.96), (1739, 0.958), (1740, 0.956), (1741, 0.955), (1742, 0.954), (1743, 0.953), (1744, 0.953), (1745, 0.952), (1746, 0.951), (1747, 0.95), (1748, 0.95), (1749, 0.949), (1750, 0.948), (1751, 0.951), (1752, 0.954), (1753, 0.957), (1754, 0.961), (1755, 0.964), (1756, 0.965), (1757, 0.964), (1758, 0.962), (1759, 0.961), (1760, 0.96), (1761, 0.957), (1762, 0.953), (1763, 0.948), (1764, 0.944), (1765, 0.94), (1766, 0.931), (1767, 0.92), (1768, 0.909), (1769, 0.898), (1770, 0.887), (1771, 0.868), (1772, 0.846), (1773, 0.823), (1774, 0.801), (1775, 0.779), (1776, 0.752), (1777, 0.723), (1778, 0.695), (1779, 0.666), (1780, 0.637), (1781, 0.607), (1782, 0.577), (1783, 0.547), (1784, 0.516), (1785, 0.486), (1786, 0.456), (1787, 0.425), (1788, 0.395), (1789, 0.365), (1790, 0.334), (1791, 0.313), (1792, 0.296), (1793, 0.279), (1794, 0.262), (1795, 0.245), (1796, 0.228), (1797, 0.211), (1798, 0.194), (1799, 0.177), (1800, 0.16), (1801, 0.149), (1802, 0.141), (1803, 0.133), (1804, 0.125), (1805, 0.117), (1806, 0.109), (1807, 0.101), (1808, 0.093), (1809, 0.085), (1810, 0.077), (1811, 0.072), (1812, 0.069), (1813, 0.066), (1814, 0.063), (1815, 0.06), (1816, 0.057), (1817, 0.054), (1818, 0.051), (1819, 0.048), (1820, 0.045), (1821, 0.042), (1822, 0.04), (1823, 0.038), (1824, 0.036), (1825, 0.033), (1826, 0.031), (1827, 0.029), (1828, 0.027), (1829, 0.025), (1830, 0.022), (1831, 0.021), (1832, 0.021), (1833, 0.02), (1834, 0.02), (1835, 0.019), (1836, 0.019), (1837, 0.018), (1838, 0.018), (1839, 0.017), (1840, 0.016), (1841, 0.016), (1842, 0.015), (1843, 0.015), (1844, 0.014), (1845, 0.014), (1846, 0.013), (1847, 0.013), (1848, 0.012), (1849, 0.012), (1850, 0.011), (1851, 0.01), (1852, 0.01), (1853, 0.01), (1854, 0.009), (1855, 0.009), (1856, 0.009), (1857, 0.008), (1858, 0.008), (1859, 0.008), (1860, 0.007), (1861, 0.007), (1862, 0.007), (1863, 0.006), (1864, 0.006), (1865, 0.005), (1866, 0.005), (1867, 0.005), (1868, 0.004), (1869, 0.004), (1870, 0.004), (1871, 0.003), (1872, 0.003), (1873, 0.003), (1874, 0.002), (1875, 0.002), (1876, 0.002), (1877, 0.001)]
responses['SWIR-2'] = [(1956, 0.001), (1957, 0.001), (1958, 0.001), (1959, 0.002), (1960, 0.002), (1961, 0.002), (1962, 0.002), (1963, 0.002), (1964, 0.002), (1965, 0.003), (1966, 0.003), (1967, 0.003), (1968, 0.003), (1969, 0.003), (1970, 0.004), (1971, 0.004), (1972, 0.004), (1973, 0.004), (1974, 0.004), (1975, 0.004), (1976, 0.005), (1977, 0.005), (1978, 0.005), (1979, 0.005), (1980, 0.005), (1981, 0.006), (1982, 0.006), (1983, 0.006), (1984, 0.006), (1985, 0.006), (1986, 0.007), (1987, 0.007), (1988, 0.007), (1989, 0.007), (1990, 0.007), (1991, 0.008), (1992, 0.008), (1993, 0.008), (1994, 0.008), (1995, 0.008), (1996, 0.009), (1997, 0.009), (1998, 0.009), (1999, 0.009), (2000, 0.009), (2001, 0.01), (2002, 0.01), (2003, 0.011), (2004, 0.011), (2005, 0.012), (2006, 0.012), (2007, 0.013), (2008, 0.013), (2009, 0.014), (2010, 0.014), (2011, 0.015), (2012, 0.015), (2013, 0.016), (2014, 0.016), (2015, 0.017), (2016, 0.017), (2017, 0.018), (2018, 0.018), (2019, 0.019), (2020, 0.019), (2021, 0.021), (2022, 0.023), (2023, 0.024), (2024, 0.026), (2025, 0.027), (2026, 0.029), (2027, 0.031), (2028, 0.032), (2029, 0.034), (2030, 0.036), (2031, 0.037), (2032, 0.039), (2033, 0.041), (2034, 0.042), (2035, 0.044), (2036, 0.046), (2037, 0.047), (2038, 0.049), (2039, 0.051), (2040, 0.052), (2041, 0.054), (2042, 0.056), (2043, 0.057), (2044, 0.059), (2045, 0.061), (2046, 0.062), (2047, 0.064), (2048, 0.066), (2049, 0.068), (2050, 0.069), (2051, 0.072), (2052, 0.075), (2053, 0.078), (2054, 0.081), (2055, 0.084), (2056, 0.087), (2057, 0.09), (2058, 0.093), (2059, 0.096), (2060, 0.1), (2061, 0.105), (2062, 0.109), (2063, 0.115), (2064, 0.12), (2065, 0.125), (2066, 0.13), (2067, 0.135), (2068, 0.14), (2069, 0.145), (2070, 0.15), (2071, 0.16), (2072, 0.17), (2073, 0.18), (2074, 0.19), (2075, 0.2), (2076, 0.211), (2077, 0.221), (2078, 0.231), (2079, 0.241), (2080, 0.251), (2081, 0.265), (2082, 0.28), (2083, 0.294), (2084, 0.308), (2085, 0.323), (2086, 0.337), (2087, 0.352), (2088, 0.366), (2089, 0.38), (2090, 0.395), (2091, 0.409), (2092, 0.424), (2093, 0.438), (2094, 0.453), (2095, 0.467), (2096, 0.482), (2097, 0.496), (2098, 0.511), (2099, 0.526), (2100, 0.54), (2101, 0.556), (2102, 0.571), (2103, 0.586), (2104, 0.602), (2105, 0.617), (2106, 0.633), (2107, 0.648), (2108, 0.664), (2109, 0.679), (2110, 0.695), (2111, 0.71), (2112, 0.726), (2113, 0.742), (2114, 0.758), (2115, 0.773), (2116, 0.789), (2117, 0.805), (2118, 0.821), (2119, 0.837), (2120, 0.853), (2121, 0.864), (2122, 0.876), (2123, 0.887), (2124, 0.898), (2125, 0.91), (2126, 0.915), (2127, 0.92), (2128, 0.925), (2129, 0.931), (2130, 0.936), (2131, 0.939), (2132, 0.941), (2133, 0.944), (2134, 0.947), (2135, 0.95), (2136, 0.95), (2137, 0.95), (2138, 0.95), (2139, 0.95), (2140, 0.951), (2141, 0.95), (2142, 0.95), (2143, 0.95), (2144, 0.949), (2145, 0.949), (2146, 0.946), (2147, 0.944), (2148, 0.941), (2149, 0.938), (2150, 0.936), (2151, 0.937), (2152, 0.939), (2153, 0.941), (2154, 0.942), (2155, 0.944), (2156, 0.944), (2157, 0.945), (2158, 0.945), (2159, 0.946), (2160, 0.946), (2161, 0.947), (2162, 0.947), (2163, 0.947), (2164, 0.948), (2165, 0.948), (2166, 0.951), (2167, 0.953), (2168, 0.956), (2169, 0.959), (2170, 0.962), (2171, 0.965), (2172, 0.967), (2173, 0.97), (2174, 0.973), (2175, 0.976), (2176, 0.979), (2177, 0.982), (2178, 0.985), (2179, 0.988), (2180, 0.991), (2181, 0.994), (2182, 0.996), (2183, 0.997), (2184, 0.997), (2185, 0.998), (2186, 0.998), (2187, 0.998), (2188, 0.999), (2189, 0.999), (2190, 0.999), (2191, 1.0), (2192, 1.0), (2193, 0.999), (2194, 0.999), (2195, 0.998), (2196, 0.998), (2197, 0.997), (2198, 0.997), (2199, 0.996), (2200, 0.995), (2201, 0.995), (2202, 0.995), (2203, 0.995), (2204, 0.994), (2205, 0.994), (2206, 0.994), (2207, 0.993), (2208, 0.993), (2209, 0.993), (2210, 0.993), (2211, 0.992), (2212, 0.992), (2213, 0.992), (2214, 0.991), (2215, 0.991), (2216, 0.991), (2217, 0.99), (2218, 0.99), (2219, 0.99), (2220, 0.989), (2221, 0.989), (2222, 0.989), (2223, 0.988), (2224, 0.988), (2225, 0.987), (2226, 0.981), (2227, 0.975), (2228, 0.969), (2229, 0.962), (2230, 0.956), (2231, 0.955), (2232, 0.953), (2233, 0.952), (2234, 0.95), (2235, 0.949), (2236, 0.947), (2237, 0.946), (2238, 0.945), (2239, 0.943), (2240, 0.942), (2241, 0.94), (2242, 0.938), (2243, 0.936), (2244, 0.934), (2245, 0.932), (2246, 0.93), (2247, 0.928), (2248, 0.926), (2249, 0.924), (2250, 0.922), (2251, 0.922), (2252, 0.921), (2253, 0.92), (2254, 0.92), (2255, 0.919), (2256, 0.919), (2257, 0.918), (2258, 0.917), (2259, 0.917), (2260, 0.916), (2261, 0.915), (2262, 0.914), (2263, 0.914), (2264, 0.913), (2265, 0.912), (2266, 0.911), (2267, 0.91), (2268, 0.909), (2269, 0.908), (2270, 0.906), (2271, 0.905), (2272, 0.903), (2273, 0.901), (2274, 0.9), (2275, 0.898), (2276, 0.896), (2277, 0.895), (2278, 0.893), (2279, 0.892), (2280, 0.89), (2281, 0.883), (2282, 0.876), (2283, 0.87), (2284, 0.863), (2285, 0.856), (2286, 0.849), (2287, 0.842), (2288, 0.836), (2289, 0.829), (2290, 0.822), (2291, 0.816), (2292, 0.809), (2293, 0.803), (2294, 0.796), (2295, 0.79), (2296, 0.783), (2297, 0.777), (2298, 0.77), (2299, 0.764), (2300, 0.757), (2301, 0.751), (2302, 0.746), (2303, 0.74), (2304, 0.734), (2305, 0.728), (2306, 0.728), (2307, 0.728), (2308, 0.734), (2309, 0.741), (2310, 0.747), (2311, 0.754), (2312, 0.76), (2313, 0.766), (2314, 0.772), (2315, 0.778), (2316, 0.784), (2317, 0.79), (2318, 0.793), (2319, 0.802), (2320, 0.808), (2321, 0.819), (2322, 0.83), (2323, 0.841), (2324, 0.852), (2325, 0.857), (2326, 0.863), (2327, 0.868), (2328, 0.874), (2329, 0.874), (2330, 0.874), (2331, 0.874), (2332, 0.875), (2333, 0.868), (2334, 0.861), (2335, 0.854), (2336, 0.836), (2337, 0.819), (2338, 0.801), (2339, 0.748), (2340, 0.695), (2341, 0.669), (2342, 0.642), (2343, 0.616), (2344, 0.59), (2345, 0.564), (2346, 0.537), (2347, 0.511), (2348, 0.484), (2349, 0.458), (2350, 0.431), (2351, 0.409), (2352, 0.386), (2353, 0.364), (2354, 0.342), (2355, 0.319), (2356, 0.296), (2357, 0.274), (2358, 0.251), (2359, 0.229), (2360, 0.206), (2361, 0.193), (2362, 0.18), (2363, 0.167), (2364, 0.154), (2365, 0.141), (2366, 0.128), (2367, 0.115), (2368, 0.102), (2369, 0.089), (2370, 0.076), (2371, 0.072), (2372, 0.068), (2373, 0.063), (2374, 0.059), (2375, 0.055), (2376, 0.05), (2377, 0.046), (2378, 0.042), (2379, 0.037), (2380, 0.033), (2381, 0.031), (2382, 0.029), (2383, 0.026), (2384, 0.024), (2385, 0.022), (2386, 0.02), (2387, 0.018), (2388, 0.015), (2389, 0.013), (2390, 0.011), (2391, 0.01), (2392, 0.01), (2393, 0.009), (2394, 0.009), (2395, 0.008), (2396, 0.008), (2397, 0.007), (2398, 0.007), (2399, 0.006), (2400, 0.005), (2401, 0.005), (2402, 0.004), (2403, 0.004), (2404, 0.003), (2405, 0.003), (2406, 0.002), (2407, 0.002), (2408, 0.001)]

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToLandsat45Tm:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
responses['Blue'] = [(421, 0.001), (422, 0.001), (423, 0.001), (424, 0.001), (425, 0.001), (426, 0.002), (427, 0.002), (428, 0.002), (429, 0.003), (430, 0.003), (431, 0.005), (432, 0.007), (433, 0.01), (434, 0.013), (435, 0.017), (436, 0.02), (437, 0.025), (438, 0.031), (439, 0.037), (440, 0.042), (441, 0.048), (442, 0.053), (443, 0.059), (444, 0.064), (445, 0.07), (446, 0.083), (447, 0.121), (448, 0.172), (449, 0.273), (450, 0.372), (451, 0.442), (452, 0.514), (453, 0.579), (454, 0.628), (455, 0.711), (456, 0.732), (457, 0.742), (458, 0.75), (459, 0.755), (460, 0.756), (461, 0.766), (462, 0.776), (463, 0.786), (464, 0.797), (465, 0.807), (466, 0.812), (467, 0.817), (468, 0.822), (469, 0.827), (470, 0.829), (471, 0.831), (472, 0.833), (473, 0.835), (474, 0.838), (475, 0.846), (476, 0.853), (477, 0.861), (478, 0.868), (479, 0.876), (480, 0.883), (481, 0.886), (482, 0.888), (483, 0.891), (484, 0.893), (485, 0.896), (486, 0.898), (487, 0.901), (488, 0.903), (489, 0.905), (490, 0.908), (491, 0.918), (492, 0.928), (493, 0.938), (494, 0.948), (495, 0.952), (496, 0.956), (497, 0.961), (498, 0.965), (499, 0.97), (500, 0.979), (501, 0.987), (502, 0.994), (503, 1.0), (504, 0.999), (505, 0.99), (506, 0.963), (507, 0.936), (508, 0.909), (509, 0.881), (510, 0.852), (511, 0.824), (512, 0.81), (513, 0.796), (514, 0.779), (515, 0.756), (516, 0.707), (517, 0.596), (518, 0.497), (519, 0.413), (520, 0.329), (521, 0.245), (522, 0.137), (523, 0.105), (524, 0.094), (525, 0.083), (526, 0.072), (527, 0.061), (528, 0.055), (529, 0.052), (530, 0.049), (531, 0.045), (532, 0.041), (533, 0.038), (534, 0.034), (535, 0.031), (536, 0.027), (537, 0.024), (538, 0.022), (539, 0.019), (540, 0.017), (541, 0.015), (542, 0.013), (543, 0.011), (544, 0.01), (545, 0.009), (546, 0.007), (547, 0.006), (548, 0.006), (549, 0.006), (550, 0.005), (551, 0.005), (552, 0.005), (553, 0.005), (554, 0.005), (555, 0.004), (556, 0.004), (557, 0.004), (558, 0.004), (559, 0.004), (560, 0.003), (561, 0.003), (562, 0.003), (563, 0.003), (564, 0.002), (565, 0.002), (566, 0.002), (567, 0.002), (568, 0.002), (569, 0.001), (570, 0.001)]
responses['Green'] = [(502, 0.002), (503, 0.003), (504, 0.007), (505, 0.009), (506, 0.011), (507, 0.014), (508, 0.016), (509, 0.019), (510, 0.022), (511, 0.024), (512, 0.027), (513, 0.03), (514, 0.032), (515, 0.035), (516, 0.05), (517, 0.066), (518, 0.091), (519, 0.12), (520, 0.152), (521, 0.191), (522, 0.231), (523, 0.271), (524, 0.312), (525, 0.353), (526, 0.392), (527, 0.43), (528, 0.468), (529, 0.507), (530, 0.537), (531, 0.561), (532, 0.577), (533, 0.591), (534, 0.605), (535, 0.619), (536, 0.633), (537, 0.647), (538, 0.661), (539, 0.675), (540, 0.69), (541, 0.7), (542, 0.711), (543, 0.721), (544, 0.732), (545, 0.743), (546, 0.753), (547, 0.764), (548, 0.775), (549, 0.786), (550, 0.797), (551, 0.803), (552, 0.809), (553, 0.815), (554, 0.821), (555, 0.826), (556, 0.832), (557, 0.837), (558, 0.843), (559, 0.848), (560, 0.854), (561, 0.859), (562, 0.865), (563, 0.871), (564, 0.873), (565, 0.874), (566, 0.875), (567, 0.877), (568, 0.878), (569, 0.879), (570, 0.88), (571, 0.881), (572, 0.882), (573, 0.883), (574, 0.884), (575, 0.885), (576, 0.886), (577, 0.887), (578, 0.891), (579, 0.896), (580, 0.9), (581, 0.905), (582, 0.909), (583, 0.914), (584, 0.932), (585, 0.944), (586, 0.954), (587, 0.963), (588, 0.971), (589, 0.977), (590, 0.982), (591, 0.988), (592, 0.994), (593, 0.999), (594, 1.0), (595, 0.999), (596, 0.998), (597, 0.995), (598, 0.98), (599, 0.964), (600, 0.949), (601, 0.927), (602, 0.894), (603, 0.862), (604, 0.829), (605, 0.796), (606, 0.747), (607, 0.672), (608, 0.597), (609, 0.521), (610, 0.467), (611, 0.413), (612, 0.359), (613, 0.304), (614, 0.249), (615, 0.206), (616, 0.181), (617, 0.156), (618, 0.131), (619, 0.108), (620, 0.097), (621, 0.087), (622, 0.076), (623, 0.066), (624, 0.055), (625, 0.052), (626, 0.049), (627, 0.045), (628, 0.042), (629, 0.039), (630, 0.036), (631, 0.032), (632, 0.029), (633, 0.026), (634, 0.023), (635, 0.021), (636, 0.019), (637, 0.017), (638, 0.015), (639, 0.013), (640, 0.011), (641, 0.01), (642, 0.009), (643, 0.008), (644, 0.006), (645, 0.005), (646, 0.003), (647, 0.002), (648, 0.001)]
responses['Red'] = [(563, 0.001), (564, 0.001), (565, 0.001), (566, 0.001), (567, 0.001), (568, 0.001), (569, 0.002), (570, 0.002), (571, 0.002), (572, 0.002), (573, 0.002), (574, 0.002), (575, 0.002), (576, 0.002), (577, 0.002), (578, 0.002), (579, 0.002), (580, 0.002), (581, 0.002), (582, 0.002), (583, 0.002), (584, 0.002), (585, 0.002), (586, 0.002), (587, 0.002), (588, 0.002), (589, 0.002), (590, 0.003), (591, 0.003), (592, 0.003), (593, 0.004), (594, 0.004), (595, 0.004), (596, 0.005), (597, 0.006), (598, 0.007), (599, 0.008), (600, 0.009), (601, 0.011), (602, 0.014), (603, 0.016), (604, 0.019), (605, 0.023), (606, 0.027), (607, 0.03), (608, 0.034), (609, 0.038), (610, 0.041), (611, 0.045), (612, 0.062), (613, 0.081), (614, 0.101), (615, 0.12), (616, 0.14), (617, 0.16), (618, 0.18), (619, 0.24), (620, 0.327), (621, 0.414), (622, 0.449), (623, 0.471), (624, 0.492), (625, 0.514), (626, 0.535), (627, 0.557), (628, 0.579), (629, 0.601), (630, 0.623), (631, 0.65), (632, 0.687), (633, 0.737), (634, 0.787), (635, 0.803), (636, 0.818), (637, 0.835), (638, 0.849), (639, 0.86), (640, 0.871), (641, 0.883), (642, 0.894), (643, 0.906), (644, 0.912), (645, 0.917), (646, 0.922), (647, 0.928), (648, 0.933), (649, 0.939), (650, 0.944), (651, 0.943), (652, 0.942), (653, 0.942), (654, 0.941), (655, 0.94), (656, 0.939), (657, 0.938), (658, 0.937), (659, 0.936), (660, 0.935), (661, 0.937), (662, 0.939), (663, 0.943), (664, 0.948), (665, 0.954), (666, 0.959), (667, 0.965), (668, 0.97), (669, 0.975), (670, 0.979), (671, 0.983), (672, 0.987), (673, 0.99), (674, 0.997), (675, 0.996), (676, 0.998), (677, 1.0), (678, 0.998), (679, 0.996), (680, 0.994), (681, 0.973), (682, 0.973), (683, 0.974), (684, 0.964), (685, 0.945), (686, 0.927), (687, 0.908), (688, 0.871), (689, 0.822), (690, 0.773), (691, 0.687), (692, 0.594), (693, 0.505), (694, 0.433), (695, 0.361), (696, 0.289), (697, 0.223), (698, 0.188), (699, 0.152), (700, 0.116), (701, 0.106), (702, 0.095), (703, 0.084), (704, 0.074), (705, 0.063), (706, 0.057), (707, 0.054), (708, 0.051), (709, 0.048), (710, 0.045), (711, 0.042), (712, 0.039), (713, 0.036), (714, 0.033), (715, 0.03), (716, 0.027), (717, 0.024), (718, 0.022), (719, 0.021), (720, 0.02), (721, 0.018), (722, 0.017), (723, 0.015), (724, 0.014), (725, 0.012), (726, 0.011), (727, 0.01), (728, 0.009), (729, 0.007), (730, 0.006), (731, 0.006), (732, 0.005), (733, 0.005), (734, 0.005), (735, 0.005), (736, 0.004), (737, 0.004), (738, 0.004), (739, 0.003), (740, 0.003), (741, 0.003), (742, 0.002), (743, 0.002), (744, 0.002), (745, 0.002), (746, 0.001)]
responses['NIR'] = [(727, 0.001), (728, 0.001), (729, 0.002), (730, 0.002), (731, 0.003), (732, 0.003), (733, 0.004), (734, 0.004), (735, 0.005), (736, 0.005), (737, 0.006), (738, 0.006), (739, 0.007), (740, 0.007), (741, 0.008), (742, 0.008), (743, 0.009), (744, 0.009), (745, 0.01), (746, 0.012), (747, 0.014), (748, 0.016), (749, 0.018), (750, 0.02), (751, 0.022), (752, 0.025), (753, 0.028), (754, 0.031), (755, 0.034), (756, 0.042), (757, 0.05), (758, 0.058), (759, 0.066), (760, 0.074), (761, 0.083), (762, 0.09), (763, 0.099), (764, 0.121), (765, 0.143), (766, 0.165), (767, 0.187), (768, 0.216), (769, 0.251), (770, 0.286), (771, 0.322), (772, 0.357), (773, 0.393), (774, 0.428), (775, 0.464), (776, 0.5), (777, 0.544), (778, 0.587), (779, 0.63), (780, 0.673), (781, 0.717), (782, 0.76), (783, 0.795), (784, 0.822), (785, 0.849), (786, 0.876), (787, 0.902), (788, 0.917), (789, 0.932), (790, 0.946), (791, 0.956), (792, 0.963), (793, 0.97), (794, 0.976), (795, 0.983), (796, 0.986), (797, 0.99), (798, 0.993), (799, 0.997), (800, 1.0), (801, 0.997), (802, 0.994), (803, 0.992), (804, 0.989), (805, 0.986), (806, 0.983), (807, 0.98), (808, 0.977), (809, 0.974), (810, 0.971), (811, 0.968), (812, 0.965), (813, 0.962), (814, 0.959), (815, 0.956), (816, 0.953), (817, 0.95), (818, 0.947), (819, 0.945), (820, 0.942), (821, 0.939), (822, 0.936), (823, 0.933), (824, 0.93), (825, 0.93), (826, 0.932), (827, 0.934), (828, 0.936), (829, 0.938), (830, 0.94), (831, 0.942), (832, 0.944), (833, 0.946), (834, 0.948), (835, 0.95), (836, 0.952), (837, 0.954), (838, 0.956), (839, 0.958), (840, 0.96), (841, 0.962), (842, 0.964), (843, 0.966), (844, 0.968), (845, 0.97), (846, 0.972), (847, 0.974), (848, 0.976), (849, 0.978), (850, 0.98), (851, 0.978), (852, 0.977), (853, 0.975), (854, 0.974), (855, 0.973), (856, 0.971), (857, 0.97), (858, 0.967), (859, 0.965), (860, 0.963), (861, 0.96), (862, 0.959), (863, 0.959), (864, 0.959), (865, 0.96), (866, 0.961), (867, 0.962), (868, 0.963), (869, 0.964), (870, 0.965), (871, 0.967), (872, 0.968), (873, 0.965), (874, 0.963), (875, 0.96), (876, 0.955), (877, 0.95), (878, 0.945), (879, 0.94), (880, 0.935), (881, 0.929), (882, 0.922), (883, 0.915), (884, 0.908), (885, 0.901), (886, 0.894), (887, 0.887), (888, 0.88), (889, 0.873), (890, 0.866), (891, 0.865), (892, 0.864), (893, 0.858), (894, 0.846), (895, 0.834), (896, 0.823), (897, 0.811), (898, 0.8), (899, 0.789), (900, 0.779), (901, 0.733), (902, 0.688), (903, 0.643), (904, 0.578), (905, 0.509), (906, 0.44), (907, 0.371), (908, 0.321), (909, 0.275), (910, 0.23), (911, 0.185), (912, 0.156), (913, 0.13), (914, 0.105), (915, 0.084), (916, 0.074), (917, 0.064), (918, 0.054), (919, 0.044), (920, 0.034), (921, 0.031), (922, 0.027), (923, 0.024), (924, 0.02), (925, 0.017), (926, 0.015), (927, 0.013), (928, 0.012), (929, 0.01), (930, 0.008), (931, 0.008), (932, 0.007), (933, 0.007), (934, 0.006), (935, 0.006), (936, 0.005), (937, 0.005), (938, 0.005), (939, 0.004), (940, 0.004), (941, 0.003), (942, 0.003), (943, 0.002), (944, 0.002), (945, 0.002), (946, 0.001)]
responses['SWIR-1'] = [(1512, 0.001), (1513, 0.001), (1514, 0.001), (1515, 0.001), (1516, 0.001), (1517, 0.001), (1518, 0.002), (1519, 0.002), (1520, 0.002), (1521, 0.002), (1522, 0.003), (1523, 0.004), (1524, 0.004), (1525, 0.005), (1526, 0.006), (1527, 0.007), (1528, 0.007), (1529, 0.008), (1530, 0.009), (1531, 0.01), (1532, 0.012), (1533, 0.013), (1534, 0.015), (1535, 0.016), (1536, 0.018), (1537, 0.019), (1538, 0.021), (1539, 0.022), (1540, 0.024), (1541, 0.028), (1542, 0.033), (1543, 0.038), (1544, 0.043), (1545, 0.048), (1546, 0.057), (1547, 0.067), (1548, 0.077), (1549, 0.087), (1550, 0.098), (1551, 0.114), (1552, 0.132), (1553, 0.151), (1554, 0.17), (1555, 0.189), (1556, 0.208), (1557, 0.228), (1558, 0.247), (1559, 0.267), (1560, 0.287), (1561, 0.312), (1562, 0.34), (1563, 0.368), (1564, 0.396), (1565, 0.425), (1566, 0.454), (1567, 0.483), (1568, 0.512), (1569, 0.541), (1570, 0.571), (1571, 0.598), (1572, 0.625), (1573, 0.653), (1574, 0.68), (1575, 0.708), (1576, 0.732), (1577, 0.755), (1578, 0.777), (1579, 0.8), (1580, 0.824), (1581, 0.842), (1582, 0.858), (1583, 0.874), (1584, 0.89), (1585, 0.907), (1586, 0.916), (1587, 0.924), (1588, 0.93), (1589, 0.934), (1590, 0.939), (1591, 0.943), (1592, 0.947), (1593, 0.946), (1594, 0.943), (1595, 0.94), (1596, 0.937), (1597, 0.934), (1598, 0.933), (1599, 0.933), (1600, 0.933), (1601, 0.931), (1602, 0.929), (1603, 0.928), (1604, 0.928), (1605, 0.928), (1606, 0.928), (1607, 0.928), (1608, 0.928), (1609, 0.933), (1610, 0.94), (1611, 0.944), (1612, 0.947), (1613, 0.949), (1614, 0.952), (1615, 0.955), (1616, 0.958), (1617, 0.961), (1618, 0.963), (1619, 0.966), (1620, 0.969), (1621, 0.972), (1622, 0.975), (1623, 0.978), (1624, 0.98), (1625, 0.983), (1626, 0.985), (1627, 0.988), (1628, 0.989), (1629, 0.989), (1630, 0.988), (1631, 0.987), (1632, 0.986), (1633, 0.985), (1634, 0.984), (1635, 0.983), (1636, 0.981), (1637, 0.98), (1638, 0.979), (1639, 0.978), (1640, 0.977), (1641, 0.976), (1642, 0.975), (1643, 0.974), (1644, 0.973), (1645, 0.972), (1646, 0.971), (1647, 0.97), (1648, 0.969), (1649, 0.969), (1650, 0.968), (1651, 0.967), (1652, 0.967), (1653, 0.968), (1654, 0.97), (1655, 0.971), (1656, 0.973), (1657, 0.975), (1658, 0.977), (1659, 0.979), (1660, 0.98), (1661, 0.982), (1662, 0.983), (1663, 0.985), (1664, 0.986), (1665, 0.988), (1666, 0.988), (1667, 0.987), (1668, 0.986), (1669, 0.985), (1670, 0.984), (1671, 0.984), (1672, 0.983), (1673, 0.983), (1674, 0.982), (1675, 0.982), (1676, 0.981), (1677, 0.981), (1678, 0.98), (1679, 0.98), (1680, 0.979), (1681, 0.979), (1682, 0.978), (1683, 0.978), (1684, 0.977), (1685, 0.977), (1686, 0.976), (1687, 0.976), (1688, 0.975), (1689, 0.975), (1690, 0.974), (1691, 0.975), (1692, 0.977), (1693, 0.978), (1694, 0.98), (1695, 0.982), (1696, 0.983), (1697, 0.985), (1698, 0.987), (1699, 0.988), (1700, 0.99), (1701, 0.99), (1702, 0.991), (1703, 0.992), (1704, 0.993), (1705, 0.993), (1706, 0.994), (1707, 0.995), (1708, 0.995), (1709, 0.996), (1710, 0.997), (1711, 0.998), (1712, 0.998), (1713, 0.999), (1714, 0.999), (1715, 1.0), (1716, 0.999), (1717, 0.998), (1718, 0.996), (1719, 0.995), (1720, 0.993), (1721, 0.992), (1722, 0.99), (1723, 0.988), (1724, 0.986), (1725, 0.974), (1726, 0.982), (1727, 0.98), (1728, 0.978), (1729, 0.976), (1730, 0.975), (1731, 0.973), (1732, 0.971), (1733, 0.969), (1734, 0.967), (1735, 0.965), (1736, 0.963), (1737, 0.961), (1738, 0.96), (1739, 0.958), (1740, 0.956), (1741, 0.955), (1742, 0.954), (1743, 0.953), (1744, 0.953), (1745, 0.952), (1746, 0.951), (1747, 0.95), (1748, 0.95), (1749, 0.949), (1750, 0.948), (1751, 0.951), (1752, 0.954), (1753, 0.957), (1754, 0.961), (1755, 0.964), (1756, 0.965), (1757, 0.964), (1758, 0.962), (1759, 0.961), (1760, 0.96), (1761, 0.957), (1762, 0.953), (1763, 0.948), (1764, 0.944), (1765, 0.94), (1766, 0.931), (1767, 0.92), (1768, 0.909), (1769, 0.898), (1770, 0.887), (1771, 0.868), (1772, 0.846), (1773, 0.823), (1774, 0.801), (1775, 0.779), (1776, 0.752), (1777, 0.723), (1778, 0.695), (1779, 0.666), (1780, 0.637), (1781, 0.607), (1782, 0.577), (1783, 0.547), (1784, 0.516), (1785, 0.486), (1786, 0.456), (1787, 0.425), (1788, 0.395), (1789, 0.365), (1790, 0.334), (1791, 0.313), (1792, 0.296), (1793, 0.279), (1794, 0.262), (1795, 0.245), (1796, 0.228), (1797, 0.211), (1798, 0.194), (1799, 0.177), (1800, 0.16), (1801, 0.149), (1802, 0.141), (1803, 0.133), (1804, 0.125), (1805, 0.117), (1806, 0.109), (1807, 0.101), (1808, 0.093), (1809, 0.085), (1810, 0.077), (1811, 0.072), (1812, 0.069), (1813, 0.066), (1814, 0.063), (1815, 0.06), (1816, 0.057), (1817, 0.054), (1818, 0.051), (1819, 0.048), (1820, 0.045), (1821, 0.042), (1822, 0.04), (1823, 0.038), (1824, 0.036), (1825, 0.033), (1826, 0.031), (1827, 0.029), (1828, 0.027), (1829, 0.025), (1830, 0.022), (1831, 0.021), (1832, 0.021), (1833, 0.02), (1834, 0.02), (1835, 0.019), (1836, 0.019), (1837, 0.018), (1838, 0.018), (1839, 0.017), (1840, 0.016), (1841, 0.016), (1842, 0.015), (1843, 0.015), (1844, 0.014), (1845, 0.014), (1846, 0.013), (1847, 0.013), (1848, 0.012), (1849, 0.012), (1850, 0.011), (1851, 0.01), (1852, 0.01), (1853, 0.01), (1854, 0.009), (1855, 0.009), (1856, 0.009), (1857, 0.008), (1858, 0.008), (1859, 0.008), (1860, 0.007), (1861, 0.007), (1862, 0.007), (1863, 0.006), (1864, 0.006), (1865, 0.005), (1866, 0.005), (1867, 0.005), (1868, 0.004), (1869, 0.004), (1870, 0.004), (1871, 0.003), (1872, 0.003), (1873, 0.003), (1874, 0.002), (1875, 0.002), (1876, 0.002), (1877, 0.001)]
responses['SWIR-2'] = [(1956, 0.001), (1957, 0.001), (1958, 0.001), (1959, 0.002), (1960, 0.002), (1961, 0.002), (1962, 0.002), (1963, 0.002), (1964, 0.002), (1965, 0.003), (1966, 0.003), (1967, 0.003), (1968, 0.003), (1969, 0.003), (1970, 0.004), (1971, 0.004), (1972, 0.004), (1973, 0.004), (1974, 0.004), (1975, 0.004), (1976, 0.005), (1977, 0.005), (1978, 0.005), (1979, 0.005), (1980, 0.005), (1981, 0.006), (1982, 0.006), (1983, 0.006), (1984, 0.006), (1985, 0.006), (1986, 0.007), (1987, 0.007), (1988, 0.007), (1989, 0.007), (1990, 0.007), (1991, 0.008), (1992, 0.008), (1993, 0.008), (1994, 0.008), (1995, 0.008), (1996, 0.009), (1997, 0.009), (1998, 0.009), (1999, 0.009), (2000, 0.009), (2001, 0.01), (2002, 0.01), (2003, 0.011), (2004, 0.011), (2005, 0.012), (2006, 0.012), (2007, 0.013), (2008, 0.013), (2009, 0.014), (2010, 0.014), (2011, 0.015), (2012, 0.015), (2013, 0.016), (2014, 0.016), (2015, 0.017), (2016, 0.017), (2017, 0.018), (2018, 0.018), (2019, 0.019), (2020, 0.019), (2021, 0.021), (2022, 0.023), (2023, 0.024), (2024, 0.026), (2025, 0.027), (2026, 0.029), (2027, 0.031), (2028, 0.032), (2029, 0.034), (2030, 0.036), (2031, 0.037), (2032, 0.039), (2033, 0.041), (2034, 0.042), (2035, 0.044), (2036, 0.046), (2037, 0.047), (2038, 0.049), (2039, 0.051), (2040, 0.052), (2041, 0.054), (2042, 0.056), (2043, 0.057), (2044, 0.059), (2045, 0.061), (2046, 0.062), (2047, 0.064), (2048, 0.066), (2049, 0.068), (2050, 0.069), (2051, 0.072), (2052, 0.075), (2053, 0.078), (2054, 0.081), (2055, 0.084), (2056, 0.087), (2057, 0.09), (2058, 0.093), (2059, 0.096), (2060, 0.1), (2061, 0.105), (2062, 0.109), (2063, 0.115), (2064, 0.12), (2065, 0.125), (2066, 0.13), (2067, 0.135), (2068, 0.14), (2069, 0.145), (2070, 0.15), (2071, 0.16), (2072, 0.17), (2073, 0.18), (2074, 0.19), (2075, 0.2), (2076, 0.211), (2077, 0.221), (2078, 0.231), (2079, 0.241), (2080, 0.251), (2081, 0.265), (2082, 0.28), (2083, 0.294), (2084, 0.308), (2085, 0.323), (2086, 0.337), (2087, 0.352), (2088, 0.366), (2089, 0.38), (2090, 0.395), (2091, 0.409), (2092, 0.424), (2093, 0.438), (2094, 0.453), (2095, 0.467), (2096, 0.482), (2097, 0.496), (2098, 0.511), (2099, 0.526), (2100, 0.54), (2101, 0.556), (2102, 0.571), (2103, 0.586), (2104, 0.602), (2105, 0.617), (2106, 0.633), (2107, 0.648), (2108, 0.664), (2109, 0.679), (2110, 0.695), (2111, 0.71), (2112, 0.726), (2113, 0.742), (2114, 0.758), (2115, 0.773), (2116, 0.789), (2117, 0.805), (2118, 0.821), (2119, 0.837), (2120, 0.853), (2121, 0.864), (2122, 0.876), (2123, 0.887), (2124, 0.898), (2125, 0.91), (2126, 0.915), (2127, 0.92), (2128, 0.925), (2129, 0.931), (2130, 0.936), (2131, 0.939), (2132, 0.941), (2133, 0.944), (2134, 0.947), (2135, 0.95), (2136, 0.95), (2137, 0.95), (2138, 0.95), (2139, 0.95), (2140, 0.951), (2141, 0.95), (2142, 0.95), (2143, 0.95), (2144, 0.949), (2145, 0.949), (2146, 0.946), (2147, 0.944), (2148, 0.941), (2149, 0.938), (2150, 0.936), (2151, 0.937), (2152, 0.939), (2153, 0.941), (2154, 0.942), (2155, 0.944), (2156, 0.944), (2157, 0.945), (2158, 0.945), (2159, 0.946), (2160, 0.946), (2161, 0.947), (2162, 0.947), (2163, 0.947), (2164, 0.948), (2165, 0.948), (2166, 0.951), (2167, 0.953), (2168, 0.956), (2169, 0.959), (2170, 0.962), (2171, 0.965), (2172, 0.967), (2173, 0.97), (2174, 0.973), (2175, 0.976), (2176, 0.979), (2177, 0.982), (2178, 0.985), (2179, 0.988), (2180, 0.991), (2181, 0.994), (2182, 0.996), (2183, 0.997), (2184, 0.997), (2185, 0.998), (2186, 0.998), (2187, 0.998), (2188, 0.999), (2189, 0.999), (2190, 0.999), (2191, 1.0), (2192, 1.0), (2193, 0.999), (2194, 0.999), (2195, 0.998), (2196, 0.998), (2197, 0.997), (2198, 0.997), (2199, 0.996), (2200, 0.995), (2201, 0.995), (2202, 0.995), (2203, 0.995), (2204, 0.994), (2205, 0.994), (2206, 0.994), (2207, 0.993), (2208, 0.993), (2209, 0.993), (2210, 0.993), (2211, 0.992), (2212, 0.992), (2213, 0.992), (2214, 0.991), (2215, 0.991), (2216, 0.991), (2217, 0.99), (2218, 0.99), (2219, 0.99), (2220, 0.989), (2221, 0.989), (2222, 0.989), (2223, 0.988), (2224, 0.988), (2225, 0.987), (2226, 0.981), (2227, 0.975), (2228, 0.969), (2229, 0.962), (2230, 0.956), (2231, 0.955), (2232, 0.953), (2233, 0.952), (2234, 0.95), (2235, 0.949), (2236, 0.947), (2237, 0.946), (2238, 0.945), (2239, 0.943), (2240, 0.942), (2241, 0.94), (2242, 0.938), (2243, 0.936), (2244, 0.934), (2245, 0.932), (2246, 0.93), (2247, 0.928), (2248, 0.926), (2249, 0.924), (2250, 0.922), (2251, 0.922), (2252, 0.921), (2253, 0.92), (2254, 0.92), (2255, 0.919), (2256, 0.919), (2257, 0.918), (2258, 0.917), (2259, 0.917), (2260, 0.916), (2261, 0.915), (2262, 0.914), (2263, 0.914), (2264, 0.913), (2265, 0.912), (2266, 0.911), (2267, 0.91), (2268, 0.909), (2269, 0.908), (2270, 0.906), (2271, 0.905), (2272, 0.903), (2273, 0.901), (2274, 0.9), (2275, 0.898), (2276, 0.896), (2277, 0.895), (2278, 0.893), (2279, 0.892), (2280, 0.89), (2281, 0.883), (2282, 0.876), (2283, 0.87), (2284, 0.863), (2285, 0.856), (2286, 0.849), (2287, 0.842), (2288, 0.836), (2289, 0.829), (2290, 0.822), (2291, 0.816), (2292, 0.809), (2293, 0.803), (2294, 0.796), (2295, 0.79), (2296, 0.783), (2297, 0.777), (2298, 0.77), (2299, 0.764), (2300, 0.757), (2301, 0.751), (2302, 0.746), (2303, 0.74), (2304, 0.734), (2305, 0.728), (2306, 0.728), (2307, 0.728), (2308, 0.734), (2309, 0.741), (2310, 0.747), (2311, 0.754), (2312, 0.76), (2313, 0.766), (2314, 0.772), (2315, 0.778), (2316, 0.784), (2317, 0.79), (2318, 0.793), (2319, 0.802), (2320, 0.808), (2321, 0.819), (2322, 0.83), (2323, 0.841), (2324, 0.852), (2325, 0.857), (2326, 0.863), (2327, 0.868), (2328, 0.874), (2329, 0.874), (2330, 0.874), (2331, 0.874), (2332, 0.875), (2333, 0.868), (2334, 0.861), (2335, 0.854), (2336, 0.836), (2337, 0.819), (2338, 0.801), (2339, 0.748), (2340, 0.695), (2341, 0.669), (2342, 0.642), (2343, 0.616), (2344, 0.59), (2345, 0.564), (2346, 0.537), (2347, 0.511), (2348, 0.484), (2349, 0.458), (2350, 0.431), (2351, 0.409), (2352, 0.386), (2353, 0.364), (2354, 0.342), (2355, 0.319), (2356, 0.296), (2357, 0.274), (2358, 0.251), (2359, 0.229), (2360, 0.206), (2361, 0.193), (2362, 0.18), (2363, 0.167), (2364, 0.154), (2365, 0.141), (2366, 0.128), (2367, 0.115), (2368, 0.102), (2369, 0.089), (2370, 0.076), (2371, 0.072), (2372, 0.068), (2373, 0.063), (2374, 0.059), (2375, 0.055), (2376, 0.05), (2377, 0.046), (2378, 0.042), (2379, 0.037), (2380, 0.033), (2381, 0.031), (2382, 0.029), (2383, 0.026), (2384, 0.024), (2385, 0.022), (2386, 0.02), (2387, 0.018), (2388, 0.015), (2389, 0.013), (2390, 0.011), (2391, 0.01), (2392, 0.01), (2393, 0.009), (2394, 0.009), (2395, 0.008), (2396, 0.008), (2397, 0.007), (2398, 0.007), (2399, 0.006), (2400, 0.005), (2401, 0.005), (2402, 0.004), (2403, 0.004), (2404, 0.003), (2405, 0.003), (2406, 0.002), (2407, 0.002), (2408, 0.001)]

    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to Landsat 7 ETM+)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the Landsat missions website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
responses['Blue'] = [(435, 0.016), (436, 0.027), (437, 0.048), (438, 0.094), (439, 0.167), (440, 0.287), (441, 0.459), (442, 0.605), (443, 0.728), (444, 0.769), (445, 0.792), (446, 0.821), (447, 0.857), (448, 0.857), (449, 0.862), (450, 0.839), (451, 0.845), (452, 0.81), (453, 0.802), (454, 0.804), (455, 0.779), (456, 0.798), (457, 0.816), (458, 0.876), (459, 0.888), (460, 0.901), (461, 0.918), (462, 0.896), (463, 0.903), (464, 0.888), (465, 0.89), (466, 0.863), (467, 0.86), (468, 0.842), (469, 0.866), (470, 0.875), (471, 0.881), (472, 0.888), (473, 0.898), (474, 0.879), (475, 0.884), (476, 0.907), (477, 0.928), (478, 0.932), (479, 0.955), (480, 0.958), (481, 0.948), (482, 0.952), (483, 0.956), (484, 0.98), (485, 0.98), (486, 0.975), (487, 0.973), (488, 0.977), (489, 0.958), (490, 0.965), (491, 0.957), (492, 0.952), (493, 0.973), (494, 0.974), (495, 0.995), (496, 0.986), (497, 0.986), (498, 0.994), (499, 1.0), (500, 0.99), (501, 0.99), (502, 0.976), (503, 0.983), (504, 0.976), (505, 0.983), (506, 0.96), (507, 0.973), (508, 0.964), (509, 0.975), (510, 0.96), (511, 0.932), (512, 0.853), (513, 0.684), (514, 0.486), (515, 0.293), (516, 0.15), (517, 0.073), (518, 0.036), (519, 0.019), (520, 0.009)]
responses['Green'] = [(502, 0.001), (503, 0.002), (504, 0.002), (505, 0.003), (506, 0.005), (507, 0.009), (508, 0.014), (509, 0.024), (510, 0.026), (511, 0.041), (512, 0.06), (513, 0.088), (514, 0.126), (515, 0.174), (516, 0.236), (517, 0.308), (518, 0.388), (519, 0.472), (520, 0.552), (521, 0.621), (522, 0.676), (523, 0.716), (524, 0.743), (525, 0.759), (526, 0.769), (527, 0.779), (528, 0.79), (529, 0.805), (530, 0.822), (531, 0.842), (532, 0.861), (533, 0.878), (534, 0.893), (535, 0.905), (536, 0.916), (537, 0.924), (538, 0.933), (539, 0.942), (540, 0.947), (541, 0.951), (542, 0.953), (543, 0.952), (544, 0.951), (545, 0.952), (546, 0.951), (547, 0.951), (548, 0.952), (549, 0.952), (550, 0.953), (551, 0.951), (552, 0.95), (553, 0.95), (554, 0.951), (555, 0.954), (556, 0.96), (557, 0.966), (558, 0.968), (559, 0.965), (560, 0.959), (561, 0.951), (562, 0.944), (563, 0.937), (564, 0.932), (565, 0.933), (566, 0.935), (567, 0.937), (568, 0.94), (569, 0.945), (570, 0.951), (571, 0.955), (572, 0.957), (573, 0.956), (574, 0.957), (575, 0.955), (576, 0.952), (577, 0.954), (578, 0.958), (579, 0.963), (580, 0.973), (581, 0.981), (582, 0.988), (583, 0.995), (584, 1.0), (585, 1.0), (586, 0.994), (587, 0.983), (588, 0.969), (589, 0.954), (590, 0.942), (591, 0.936), (592, 0.932), (593, 0.928), (594, 0.924), (595, 0.912), (596, 0.883), (597, 0.834), (598, 0.763), (599, 0.674), (600, 0.574), (601, 0.473), (602, 0.38), (603, 0.3), (604, 0.235), (605, 0.185), (606, 0.146), (607, 0.117), (608, 0.094), (609, 0.077), (610, 0.062), (611, 0.052), (612, 0.042), (613, 0.033), (614, 0.026), (615, 0.021), (616, 0.016), (617, 0.012), (618, 0.009), (619, 0.007), (620, 0.005), (621, 0.004), (622, 0.003), (623, 0.002), (624, 0.001)]
responses['Red'] = [(619, 0.001), (620, 0.002), (621, 0.003), (622, 0.006), (623, 0.013), (624, 0.025), (625, 0.047), (626, 0.083), (627, 0.137), (628, 0.211), (629, 0.306), (630, 0.419), (631, 0.545), (632, 0.674), (633, 0.788), (634, 0.873), (635, 0.921), (636, 0.941), (637, 0.943), (638, 0.942), (639, 0.939), (640, 0.937), (641, 0.935), (642, 0.935), (643, 0.938), (644, 0.943), (645, 0.949), (646, 0.953), (647, 0.961), (648, 0.968), (649, 0.971), (650, 0.973), (651, 0.974), (652, 0.972), (653, 0.969), (654, 0.963), (655, 0.958), (656, 0.956), (657, 0.955), (658, 0.955), (659, 0.956), (660, 0.962), (661, 0.969), (662, 0.977), (663, 0.983), (664, 0.988), (665, 0.993), (666, 0.996), (667, 0.997), (668, 0.999), (669, 1.0), (670, 1.0), (671, 0.998), (672, 0.996), (673, 0.995), (674, 0.993), (675, 0.992), (676, 0.991), (677, 0.989), (678, 0.988), (679, 0.984), (680, 0.977), (681, 0.97), (682, 0.96), (683, 0.949), (684, 0.94), (685, 0.932), (686, 0.919), (687, 0.898), (688, 0.863), (689, 0.809), (690, 0.729), (691, 0.625), (692, 0.506), (693, 0.382), (694, 0.272), (695, 0.183), (696, 0.12), (697, 0.079), (698, 0.053), (699, 0.036), (700, 0.025), (701, 0.02), (702, 0.014), (703, 0.01), (704, 0.007)]
responses['NIR'] = [(741, 0.001), (742, 0.002), (743, 0.002), (744, 0.003), (745, 0.004), (746, 0.003), (747, 0.003), (748, 0.002), (749, 0.002), (750, 0.001), (751, 0.014), (752, 0.018), (753, 0.022), (754, 0.027), (755, 0.032), (756, 0.038), (757, 0.047), (758, 0.056), (759, 0.069), (760, 0.069), (761, 0.083), (762, 0.099), (763, 0.121), (764, 0.146), (765, 0.175), (766, 0.209), (767, 0.248), (768, 0.294), (769, 0.346), (770, 0.402), (771, 0.463), (772, 0.523), (773, 0.588), (774, 0.649), (775, 0.705), (776, 0.757), (777, 0.797), (778, 0.827), (779, 0.853), (780, 0.871), (781, 0.884), (782, 0.892), (783, 0.899), (784, 0.903), (785, 0.908), (786, 0.911), (787, 0.916), (788, 0.92), (789, 0.925), (790, 0.926), (791, 0.927), (792, 0.927), (793, 0.929), (794, 0.932), (795, 0.93), (796, 0.926), (797, 0.926), (798, 0.925), (799, 0.928), (800, 0.925), (801, 0.926), (802, 0.928), (803, 0.928), (804, 0.928), (805, 0.923), (806, 0.92), (807, 0.919), (808, 0.914), (809, 0.91), (810, 0.908), (811, 0.905), (812, 0.903), (813, 0.904), (814, 0.902), (815, 0.909), (816, 0.917), (817, 0.92), (818, 0.928), (819, 0.938), (820, 0.946), (821, 0.953), (822, 0.962), (823, 0.969), (824, 0.971), (825, 0.971), (826, 0.97), (827, 0.969), (828, 0.969), (829, 0.97), (830, 0.967), (831, 0.969), (832, 0.968), (833, 0.963), (834, 0.965), (835, 0.967), (836, 0.965), (837, 0.963), (838, 0.958), (839, 0.95), (840, 0.949), (841, 0.943), (842, 0.933), (843, 0.929), (844, 0.928), (845, 0.925), (846, 0.924), (847, 0.927), (848, 0.932), (849, 0.934), (850, 0.943), (851, 0.952), (852, 0.956), (853, 0.966), (854, 0.977), (855, 0.985), (856, 0.99), (857, 0.992), (858, 0.993), (859, 0.994), (860, 0.998), (861, 0.996), (862, 0.992), (863, 0.991), (864, 0.992), (865, 0.994), (866, 0.993), (867, 0.997), (868, 0.997), (869, 0.996), (870, 0.998), (871, 0.999), (872, 1.0), (873, 0.999), (874, 0.996), (875, 0.991), (876, 0.99), (877, 0.991), (878, 0.985), (879, 0.978), (880, 0.969), (881, 0.955), (882, 0.937), (883, 0.916), (884, 0.892), (885, 0.868), (886, 0.845), (887, 0.824), (888, 0.811), (889, 0.807), (890, 0.819), (891, 0.841), (892, 0.868), (893, 0.892), (894, 0.892), (895, 0.854), (896, 0.77), (897, 0.644), (898, 0.501), (899, 0.365), (900, 0.256), (901, 0.177), (902, 0.122), (903, 0.085), (904, 0.061), (905, 0.044), (906, 0.032), (907, 0.025), (908, 0.019), (909, 0.014), (910, 0.011), (911, 0.011), (912, 0.008), (913, 0.006), (914, 0.005)]
responses['SWIR-1'] = [(1508, 0.001), (1509, 0.001), (1510, 0.001), (1511, 0.007), (1512, 0.013), (1513, 0.01), (1514, 0.006), (1515, 0.012), (1516, 0.008), (1517, 0.003), (1518, 0.009), (1519, 0.015), (1520, 0.013), (1521, 0.012), (1522, 0.018), (1523, 0.024), (1524, 0.032), (1525, 0.04), (1526, 0.041), (1527, 0.049), (1528, 0.057), (1529, 0.067), (1530, 0.076), (1531, 0.087), (1532, 0.097), (1533, 0.109), (1534, 0.12), (1535, 0.148), (1536, 0.176), (1537, 0.196), (1538, 0.215), (1539, 0.244), (1540, 0.274), (1541, 0.306), (1542, 0.339), (1543, 0.393), (1544, 0.428), (1545, 0.462), (1546, 0.481), (1547, 0.499), (1548, 0.529), (1549, 0.558), (1550, 0.578), (1551, 0.598), (1552, 0.616), (1553, 0.634), (1554, 0.65), (1555, 0.667), (1556, 0.686), (1557, 0.704), (1558, 0.714), (1559, 0.724), (1560, 0.737), (1561, 0.75), (1562, 0.764), (1563, 0.778), (1564, 0.793), (1565, 0.808), (1566, 0.817), (1567, 0.825), (1568, 0.838), (1569, 0.851), (1570, 0.859), (1571, 0.867), (1572, 0.872), (1573, 0.878), (1574, 0.884), (1575, 0.893), (1576, 0.902), (1577, 0.901), (1578, 0.901), (1579, 0.899), (1580, 0.896), (1581, 0.896), (1582, 0.897), (1583, 0.893), (1584, 0.89), (1585, 0.895), (1586, 0.899), (1587, 0.891), (1588, 0.884), (1589, 0.88), (1590, 0.876), (1591, 0.872), (1592, 0.867), (1593, 0.87), (1594, 0.873), (1595, 0.873), (1596, 0.872), (1597, 0.875), (1598, 0.879), (1599, 0.877), (1600, 0.874), (1601, 0.868), (1602, 0.861), (1603, 0.86), (1604, 0.859), (1605, 0.868), (1606, 0.877), (1607, 0.878), (1608, 0.879), (1609, 0.889), (1610, 0.899), (1611, 0.897), (1612, 0.895), (1613, 0.893), (1614, 0.896), (1615, 0.9), (1616, 0.898), (1617, 0.897), (1618, 0.907), (1619, 0.917), (1620, 0.919), (1621, 0.921), (1622, 0.924), (1623, 0.926), (1624, 0.928), (1625, 0.929), (1626, 0.937), (1627, 0.945), (1628, 0.946), (1629, 0.947), (1630, 0.947), (1631, 0.948), (1632, 0.951), (1633, 0.955), (1634, 0.954), (1635, 0.952), (1636, 0.961), (1637, 0.969), (1638, 0.964), (1639, 0.96), (1640, 0.961), (1641, 0.962), (1642, 0.961), (1643, 0.959), (1644, 0.969), (1645, 0.978), (1646, 0.969), (1647, 0.96), (1648, 0.957), (1649, 0.955), (1650, 0.954), (1651, 0.952), (1652, 0.951), (1653, 0.951), (1654, 0.951), (1655, 0.952), (1656, 0.952), (1657, 0.954), (1658, 0.956), (1659, 0.95), (1660, 0.944), (1661, 0.939), (1662, 0.935), (1663, 0.934), (1664, 0.933), (1665, 0.931), (1666, 0.928), (1667, 0.935), (1668, 0.942), (1669, 0.945), (1670, 0.948), (1671, 0.945), (1672, 0.942), (1673, 0.938), (1674, 0.933), (1675, 0.939), (1676, 0.944), (1677, 0.946), (1678, 0.948), (1679, 0.947), (1680, 0.945), (1681, 0.944), (1682, 0.943), (1683, 0.947), (1684, 0.951), (1685, 0.955), (1686, 0.96), (1687, 0.964), (1688, 0.965), (1689, 0.967), (1690, 0.969), (1691, 0.971), (1692, 0.972), (1693, 0.974), (1694, 0.982), (1695, 0.991), (1696, 0.993), (1697, 0.995), (1698, 0.997), (1699, 0.999), (1700, 0.998), (1701, 0.996), (1702, 0.995), (1703, 0.994), (1704, 0.997), (1705, 1.0), (1706, 0.997), (1707, 0.994), (1708, 0.988), (1709, 0.983), (1710, 0.987), (1711, 0.99), (1712, 0.989), (1713, 0.988), (1714, 0.987), (1715, 0.989), (1716, 0.992), (1717, 0.989), (1718, 0.986), (1719, 0.984), (1720, 0.981), (1721, 0.982), (1722, 0.983), (1723, 0.979), (1724, 0.976), (1725, 0.978), (1726, 0.97), (1727, 0.969), (1728, 0.968), (1729, 0.964), (1730, 0.96), (1731, 0.952), (1732, 0.944), (1733, 0.933), (1734, 0.921), (1735, 0.902), (1736, 0.883), (1737, 0.864), (1738, 0.845), (1739, 0.818), (1740, 0.791), (1741, 0.751), (1742, 0.711), (1743, 0.674), (1744, 0.638), (1745, 0.608), (1746, 0.577), (1747, 0.547), (1748, 0.505), (1749, 0.462), (1750, 0.428), (1751, 0.393), (1752, 0.359), (1753, 0.325), (1754, 0.296), (1755, 0.267), (1756, 0.239), (1757, 0.212), (1758, 0.193), (1759, 0.175), (1760, 0.159), (1761, 0.142), (1762, 0.127), (1763, 0.111), (1764, 0.097), (1765, 0.084), (1766, 0.08), (1767, 0.077), (1768, 0.067), (1769, 0.058), (1770, 0.053), (1771, 0.049), (1772, 0.045), (1773, 0.042), (1774, 0.041), (1775, 0.039), (1776, 0.036), (1777, 0.034), (1778, 0.027), (1779, 0.02), (1780, 0.021), (1781, 0.021), (1782, 0.021), (1783, 0.022), (1784, 0.016), (1785, 0.011), (1786, 0.012), (1787, 0.012), (1788, 0.008), (1789, 0.004), (1790, 0.006), (1791, 0.008), (1792, 0.004)]
responses['SWIR-2'] = [(2015, 0.002), (2016, 0.002), (2017, 0.002), (2018, 0.002), (2019, 0.007), (2020, 0.012), (2021, 0.01), (2022, 0.009), (2023, 0.008), (2024, 0.007), (2025, 0.009), (2026, 0.011), (2027, 0.015), (2028, 0.02), (2029, 0.019), (2030, 0.017), (2031, 0.023), (2032, 0.03), (2033, 0.032), (2034, 0.035), (2035, 0.037), (2036, 0.041), (2037, 0.044), (2038, 0.047), (2039, 0.051), (2040, 0.058), (2041, 0.065), (2042, 0.072), (2043, 0.08), (2044, 0.084), (2045, 0.088), (2046, 0.095), (2047, 0.102), (2048, 0.117), (2049, 0.133), (2050, 0.149), (2051, 0.165), (2052, 0.188), (2053, 0.204), (2054, 0.22), (2055, 0.242), (2056, 0.264), (2057, 0.29), (2058, 0.316), (2059, 0.342), (2060, 0.367), (2061, 0.394), (2062, 0.421), (2063, 0.452), (2064, 0.484), (2065, 0.519), (2066, 0.554), (2067, 0.59), (2068, 0.63), (2069, 0.67), (2070, 0.677), (2071, 0.683), (2072, 0.707), (2073, 0.73), (2074, 0.743), (2075, 0.756), (2076, 0.762), (2077, 0.767), (2078, 0.781), (2079, 0.794), (2080, 0.784), (2081, 0.774), (2082, 0.775), (2083, 0.776), (2084, 0.783), (2085, 0.789), (2086, 0.775), (2087, 0.78), (2088, 0.784), (2089, 0.781), (2090, 0.778), (2091, 0.773), (2092, 0.768), (2093, 0.765), (2094, 0.762), (2095, 0.762), (2096, 0.761), (2097, 0.766), (2098, 0.77), (2099, 0.775), (2100, 0.775), (2101, 0.77), (2102, 0.764), (2103, 0.774), (2104, 0.784), (2105, 0.788), (2106, 0.792), (2107, 0.803), (2108, 0.814), (2109, 0.804), (2110, 0.794), (2111, 0.809), (2112, 0.825), (2113, 0.821), (2114, 0.817), (2115, 0.811), (2116, 0.806), (2117, 0.819), (2118, 0.82), (2119, 0.821), (2120, 0.836), (2121, 0.852), (2122, 0.842), (2123, 0.832), (2124, 0.834), (2125, 0.836), (2126, 0.843), (2127, 0.85), (2128, 0.853), (2129, 0.855), (2130, 0.859), (2131, 0.862), (2132, 0.857), (2133, 0.853), (2134, 0.862), (2135, 0.871), (2136, 0.848), (2137, 0.865), (2138, 0.882), (2139, 0.878), (2140, 0.875), (2141, 0.868), (2142, 0.86), (2143, 0.858), (2144, 0.856), (2145, 0.872), (2146, 0.887), (2147, 0.868), (2148, 0.85), (2149, 0.861), (2150, 0.872), (2151, 0.879), (2152, 0.868), (2153, 0.857), (2154, 0.861), (2155, 0.865), (2156, 0.866), (2157, 0.867), (2158, 0.869), (2159, 0.871), (2160, 0.877), (2161, 0.882), (2162, 0.876), (2163, 0.87), (2164, 0.87), (2165, 0.869), (2166, 0.873), (2167, 0.875), (2168, 0.877), (2169, 0.872), (2170, 0.868), (2171, 0.874), (2172, 0.88), (2173, 0.878), (2174, 0.877), (2175, 0.873), (2176, 0.87), (2177, 0.874), (2178, 0.878), (2179, 0.879), (2180, 0.88), (2181, 0.874), (2182, 0.868), (2183, 0.881), (2184, 0.875), (2185, 0.87), (2186, 0.863), (2187, 0.856), (2188, 0.859), (2189, 0.863), (2190, 0.863), (2191, 0.863), (2192, 0.86), (2193, 0.857), (2194, 0.85), (2195, 0.844), (2196, 0.852), (2197, 0.859), (2198, 0.858), (2199, 0.857), (2200, 0.854), (2201, 0.852), (2202, 0.859), (2203, 0.866), (2204, 0.867), (2205, 0.868), (2206, 0.862), (2207, 0.856), (2208, 0.856), (2209, 0.856), (2210, 0.847), (2211, 0.854), (2212, 0.861), (2213, 0.862), (2214, 0.862), (2215, 0.851), (2216, 0.84), (2217, 0.848), (2218, 0.856), (2219, 0.847), (2220, 0.838), (2221, 0.847), (2222, 0.856), (2223, 0.837), (2224, 0.839), (2225, 0.84), (2226, 0.842), (2227, 0.826), (2228, 0.835), (2229, 0.844), (2230, 0.836), (2231, 0.827), (2232, 0.835), (2233, 0.842), (2234, 0.832), (2235, 0.822), (2236, 0.832), (2237, 0.843), (2238, 0.833), (2239, 0.823), (2240, 0.839), (2241, 0.854), (2242, 0.839), (2243, 0.846), (2244, 0.853), (2245, 0.854), (2246, 0.854), (2247, 0.859), (2248, 0.865), (2249, 0.869), (2250, 0.873), (2251, 0.871), (2252, 0.869), (2253, 0.867), (2254, 0.865), (2255, 0.879), (2256, 0.893), (2257, 0.891), (2258, 0.89), (2259, 0.89), (2260, 0.898), (2261, 0.906), (2262, 0.915), (2263, 0.924), (2264, 0.922), (2265, 0.92), (2266, 0.921), (2267, 0.922), (2268, 0.931), (2269, 0.939), (2270, 0.928), (2271, 0.916), (2272, 0.928), (2273, 0.94), (2274, 0.93), (2275, 0.936), (2276, 0.942), (2277, 0.949), (2278, 0.957), (2279, 0.956), (2280, 0.954), (2281, 0.952), (2282, 0.951), (2283, 0.952), (2284, 0.954), (2285, 0.96), (2286, 0.966), (2287, 0.97), (2288, 0.975), (2289, 0.98), (2290, 0.985), (2291, 0.978), (2292, 0.971), (2293, 0.973), (2294, 0.972), (2295, 0.97), (2296, 0.982), (2297, 0.993), (2298, 0.994), (2299, 0.996), (2300, 0.989), (2301, 0.983), (2302, 0.977), (2303, 0.972), (2304, 0.986), (2305, 1.0), (2306, 0.999), (2307, 0.998), (2308, 0.985), (2309, 0.971), (2310, 0.968), (2311, 0.967), (2312, 0.967), (2313, 0.965), (2314, 0.962), (2315, 0.956), (2316, 0.949), (2317, 0.936), (2318, 0.923), (2319, 0.926), (2320, 0.929), (2321, 0.923), (2322, 0.917), (2323, 0.934), (2324, 0.919), (2325, 0.903), (2326, 0.914), (2327, 0.926), (2328, 0.921), (2329, 0.916), (2330, 0.929), (2331, 0.942), (2332, 0.933), (2333, 0.924), (2334, 0.922), (2335, 0.92), (2336, 0.891), (2337, 0.863), (2338, 0.844), (2339, 0.824), (2340, 0.775), (2341, 0.729), (2342, 0.684), (2343, 0.633), (2344, 0.583), (2345, 0.531), (2346, 0.48), (2347, 0.429), (2348, 0.378), (2349, 0.326), (2350, 0.275), (2351, 0.254), (2352, 0.233), (2353, 0.202), (2354, 0.171), (2355, 0.131), (2356, 0.121), (2357, 0.111), (2358, 0.096), (2359, 0.081), (2360, 0.075), (2361, 0.069), (2362, 0.057), (2363, 0.046), (2364, 0.038), (2365, 0.029), (2366, 0.034), (2367, 0.038), (2368, 0.018), (2369, 0.0), (2370, 0.013), (2371, 0.029), (2372, 0.023), (2373, 0.016), (2374, 0.009), (2375, 0.013), (2376, 0.017), (2377, 0.01), (2378, 0.003), (2379, 0.009), (2380, 0.015), (2381, 0.007)]
# responses['Pan'] = [(502, 0.001), (503, 0.005), (504, 0.008), (505, 0.018), (506, 0.027), (507, 0.046), (508, 0.066), (509, 0.108), (510, 0.15), (511, 0.22), (512, 0.289), (513, 0.368), (514, 0.447), (515, 0.502), (516, 0.556), (517, 0.575), (518, 0.594), (519, 0.596), (520, 0.599), (521, 0.6), (522, 0.6), (523, 0.604), (524, 0.607), (525, 0.609), (526, 0.612), (527, 0.613), (528, 0.615), (529, 0.613), (530, 0.61), (531, 0.607), (532, 0.604), (533, 0.603), (534, 0.602), (535, 0.604), (536, 0.605), (537, 0.61), (538, 0.614), (539, 0.62), (540, 0.627), (541, 0.632), (542, 0.637), (543, 0.64), (544, 0.643), (545, 0.645), (546, 0.646), (547, 0.645), (548, 0.643), (549, 0.638), (550, 0.632), (551, 0.63), (552, 0.627), (553, 0.625), (554, 0.623), (555, 0.625), (556, 0.626), (557, 0.63), (558, 0.634), (559, 0.638), (560, 0.642), (561, 0.648), (562, 0.655), (563, 0.663), (564, 0.672), (565, 0.678), (566, 0.683), (567, 0.688), (568, 0.692), (569, 0.694), (570, 0.697), (571, 0.699), (572, 0.7), (573, 0.701), (574, 0.702), (575, 0.705), (576, 0.708), (577, 0.71), (578, 0.712), (579, 0.712), (580, 0.713), (581, 0.715), (582, 0.716), (583, 0.717), (584, 0.718), (585, 0.718), (586, 0.718), (587, 0.714), (588, 0.71), (589, 0.709), (590, 0.707), (591, 0.706), (592, 0.705), (593, 0.703), (594, 0.701), (595, 0.703), (596, 0.705), (597, 0.711), (598, 0.718), (599, 0.724), (600, 0.73), (601, 0.736), (602, 0.742), (603, 0.746), (604, 0.75), (605, 0.753), (606, 0.757), (607, 0.76), (608, 0.763), (609, 0.763), (610, 0.764), (611, 0.76), (612, 0.755), (613, 0.752), (614, 0.748), (615, 0.745), (616, 0.742), (617, 0.737), (618, 0.733), (619, 0.731), (620, 0.729), (621, 0.729), (622, 0.728), (623, 0.729), (624, 0.73), (625, 0.731), (626, 0.732), (627, 0.732), (628, 0.733), (629, 0.734), (630, 0.734), (631, 0.738), (632, 0.742), (633, 0.745), (634, 0.748), (635, 0.75), (636, 0.751), (637, 0.753), (638, 0.755), (639, 0.757), (640, 0.758), (641, 0.759), (642, 0.76), (643, 0.763), (644, 0.767), (645, 0.768), (646, 0.769), (647, 0.771), (648, 0.773), (649, 0.776), (650, 0.779), (651, 0.78), (652, 0.781), (653, 0.782), (654, 0.783), (655, 0.785), (656, 0.787), (657, 0.789), (658, 0.791), (659, 0.792), (660, 0.793), (661, 0.793), (662, 0.792), (663, 0.791), (664, 0.791), (665, 0.791), (666, 0.792), (667, 0.794), (668, 0.796), (669, 0.797), (670, 0.798), (671, 0.799), (672, 0.801), (673, 0.803), (674, 0.804), (675, 0.806), (676, 0.808), (677, 0.812), (678, 0.815), (679, 0.817), (680, 0.82), (681, 0.824), (682, 0.827), (683, 0.828), (684, 0.829), (685, 0.831), (686, 0.834), (687, 0.836), (688, 0.838), (689, 0.84), (690, 0.842), (691, 0.845), (692, 0.847), (693, 0.85), (694, 0.853), (695, 0.854), (696, 0.856), (697, 0.859), (698, 0.862), (699, 0.865), (700, 0.868), (701, 0.869), (702, 0.871), (703, 0.873), (704, 0.876), (705, 0.88), (706, 0.883), (707, 0.885), (708, 0.886), (709, 0.889), (710, 0.892), (711, 0.893), (712, 0.894), (713, 0.895), (714, 0.896), (715, 0.896), (716, 0.896), (717, 0.895), (718, 0.894), (719, 0.894), (720, 0.894), (721, 0.894), (722, 0.894), (723, 0.895), (724, 0.895), (725, 0.896), (726, 0.896), (727, 0.897), (728, 0.898), (729, 0.899), (730, 0.9), (731, 0.901), (732, 0.903), (733, 0.903), (734, 0.904), (735, 0.903), (736, 0.903), (737, 0.903), (738, 0.902), (739, 0.901), (740, 0.9), (741, 0.898), (742, 0.897), (743, 0.896), (744, 0.896), (745, 0.893), (746, 0.891), (747, 0.885), (748, 0.88), (749, 0.88), (750, 0.879), (751, 0.88), (752, 0.88), (753, 0.877), (754, 0.873), (755, 0.873), (756, 0.873), (757, 0.875), (758, 0.877), (759, 0.878), (760, 0.88), (761, 0.88), (762, 0.88), (763, 0.882), (764, 0.885), (765, 0.887), (766, 0.888), (767, 0.89), (768, 0.892), (769, 0.893), (770, 0.893), (771, 0.898), (772, 0.902), (773, 0.905), (774, 0.908), (775, 0.91), (776, 0.913), (777, 0.916), (778, 0.92), (779, 0.92), (780, 0.92), (781, 0.919), (782, 0.918), (783, 0.917), (784, 0.916), (785, 0.916), (786, 0.916), (787, 0.918), (788, 0.919), (789, 0.919), (790, 0.918), (791, 0.918), (792, 0.917), (793, 0.916), (794, 0.916), (795, 0.916), (796, 0.915), (797, 0.916), (798, 0.918), (799, 0.923), (800, 0.927), (801, 0.928), (802, 0.928), (803, 0.93), (804, 0.932), (805, 0.938), (806, 0.943), (807, 0.947), (808, 0.952), (809, 0.955), (810, 0.957), (811, 0.96), (812, 0.962), (813, 0.965), (814, 0.969), (815, 0.97), (816, 0.97), (817, 0.971), (818, 0.972), (819, 0.975), (820, 0.977), (821, 0.978), (822, 0.979), (823, 0.98), (824, 0.981), (825, 0.984), (826, 0.987), (827, 0.989), (828, 0.992), (829, 0.994), (830, 0.997), (831, 0.998), (832, 0.998), (833, 0.999), (834, 1.0), (835, 0.998), (836, 0.996), (837, 0.995), (838, 0.995), (839, 0.995), (840, 0.994), (841, 0.993), (842, 0.992), (843, 0.992), (844, 0.992), (845, 0.993), (846, 0.994), (847, 0.993), (848, 0.992), (849, 0.989), (850, 0.987), (851, 0.982), (852, 0.978), (853, 0.973), (854, 0.968), (855, 0.965), (856, 0.962), (857, 0.96), (858, 0.957), (859, 0.953), (860, 0.949), (861, 0.943), (862, 0.937), (863, 0.933), (864, 0.928), (865, 0.924), (866, 0.92), (867, 0.916), (868, 0.911), (869, 0.909), (870, 0.907), (871, 0.906), (872, 0.905), (873, 0.905), (874, 0.906), (875, 0.909), (876, 0.911), (877, 0.916), (878, 0.922), (879, 0.931), (880, 0.94), (881, 0.951), (882, 0.962), (883, 0.97), (884, 0.977), (885, 0.978), (886, 0.979), (887, 0.968), (888, 0.957), (889, 0.926), (890, 0.895), (891, 0.841), (892, 0.787), (893, 0.717), (894, 0.647), (895, 0.572), (896, 0.496), (897, 0.429), (898, 0.363), (899, 0.31), (900, 0.258), (901, 0.219), (902, 0.181), (903, 0.154), (904, 0.127), (905, 0.108), (906, 0.089), (907, 0.075), (908, 0.062), (909, 0.053), (910, 0.044)]

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToLandsat7Etm:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
responses['Blue'] = [(435, 0.016), (436, 0.027), (437, 0.048), (438, 0.094), (439, 0.167), (440, 0.287), (441, 0.459), (442, 0.605), (443, 0.728), (444, 0.769), (445, 0.792), (446, 0.821), (447, 0.857), (448, 0.857), (449, 0.862), (450, 0.839), (451, 0.845), (452, 0.81), (453, 0.802), (454, 0.804), (455, 0.779), (456, 0.798), (457, 0.816), (458, 0.876), (459, 0.888), (460, 0.901), (461, 0.918), (462, 0.896), (463, 0.903), (464, 0.888), (465, 0.89), (466, 0.863), (467, 0.86), (468, 0.842), (469, 0.866), (470, 0.875), (471, 0.881), (472, 0.888), (473, 0.898), (474, 0.879), (475, 0.884), (476, 0.907), (477, 0.928), (478, 0.932), (479, 0.955), (480, 0.958), (481, 0.948), (482, 0.952), (483, 0.956), (484, 0.98), (485, 0.98), (486, 0.975), (487, 0.973), (488, 0.977), (489, 0.958), (490, 0.965), (491, 0.957), (492, 0.952), (493, 0.973), (494, 0.974), (495, 0.995), (496, 0.986), (497, 0.986), (498, 0.994), (499, 1.0), (500, 0.99), (501, 0.99), (502, 0.976), (503, 0.983), (504, 0.976), (505, 0.983), (506, 0.96), (507, 0.973), (508, 0.964), (509, 0.975), (510, 0.96), (511, 0.932), (512, 0.853), (513, 0.684), (514, 0.486), (515, 0.293), (516, 0.15), (517, 0.073), (518, 0.036), (519, 0.019), (520, 0.009)]
responses['Green'] = [(502, 0.001), (503, 0.002), (504, 0.002), (505, 0.003), (506, 0.005), (507, 0.009), (508, 0.014), (509, 0.024), (510, 0.026), (511, 0.041), (512, 0.06), (513, 0.088), (514, 0.126), (515, 0.174), (516, 0.236), (517, 0.308), (518, 0.388), (519, 0.472), (520, 0.552), (521, 0.621), (522, 0.676), (523, 0.716), (524, 0.743), (525, 0.759), (526, 0.769), (527, 0.779), (528, 0.79), (529, 0.805), (530, 0.822), (531, 0.842), (532, 0.861), (533, 0.878), (534, 0.893), (535, 0.905), (536, 0.916), (537, 0.924), (538, 0.933), (539, 0.942), (540, 0.947), (541, 0.951), (542, 0.953), (543, 0.952), (544, 0.951), (545, 0.952), (546, 0.951), (547, 0.951), (548, 0.952), (549, 0.952), (550, 0.953), (551, 0.951), (552, 0.95), (553, 0.95), (554, 0.951), (555, 0.954), (556, 0.96), (557, 0.966), (558, 0.968), (559, 0.965), (560, 0.959), (561, 0.951), (562, 0.944), (563, 0.937), (564, 0.932), (565, 0.933), (566, 0.935), (567, 0.937), (568, 0.94), (569, 0.945), (570, 0.951), (571, 0.955), (572, 0.957), (573, 0.956), (574, 0.957), (575, 0.955), (576, 0.952), (577, 0.954), (578, 0.958), (579, 0.963), (580, 0.973), (581, 0.981), (582, 0.988), (583, 0.995), (584, 1.0), (585, 1.0), (586, 0.994), (587, 0.983), (588, 0.969), (589, 0.954), (590, 0.942), (591, 0.936), (592, 0.932), (593, 0.928), (594, 0.924), (595, 0.912), (596, 0.883), (597, 0.834), (598, 0.763), (599, 0.674), (600, 0.574), (601, 0.473), (602, 0.38), (603, 0.3), (604, 0.235), (605, 0.185), (606, 0.146), (607, 0.117), (608, 0.094), (609, 0.077), (610, 0.062), (611, 0.052), (612, 0.042), (613, 0.033), (614, 0.026), (615, 0.021), (616, 0.016), (617, 0.012), (618, 0.009), (619, 0.007), (620, 0.005), (621, 0.004), (622, 0.003), (623, 0.002), (624, 0.001)]
responses['Red'] = [(619, 0.001), (620, 0.002), (621, 0.003), (622, 0.006), (623, 0.013), (624, 0.025), (625, 0.047), (626, 0.083), (627, 0.137), (628, 0.211), (629, 0.306), (630, 0.419), (631, 0.545), (632, 0.674), (633, 0.788), (634, 0.873), (635, 0.921), (636, 0.941), (637, 0.943), (638, 0.942), (639, 0.939), (640, 0.937), (641, 0.935), (642, 0.935), (643, 0.938), (644, 0.943), (645, 0.949), (646, 0.953), (647, 0.961), (648, 0.968), (649, 0.971), (650, 0.973), (651, 0.974), (652, 0.972), (653, 0.969), (654, 0.963), (655, 0.958), (656, 0.956), (657, 0.955), (658, 0.955), (659, 0.956), (660, 0.962), (661, 0.969), (662, 0.977), (663, 0.983), (664, 0.988), (665, 0.993), (666, 0.996), (667, 0.997), (668, 0.999), (669, 1.0), (670, 1.0), (671, 0.998), (672, 0.996), (673, 0.995), (674, 0.993), (675, 0.992), (676, 0.991), (677, 0.989), (678, 0.988), (679, 0.984), (680, 0.977), (681, 0.97), (682, 0.96), (683, 0.949), (684, 0.94), (685, 0.932), (686, 0.919), (687, 0.898), (688, 0.863), (689, 0.809), (690, 0.729), (691, 0.625), (692, 0.506), (693, 0.382), (694, 0.272), (695, 0.183), (696, 0.12), (697, 0.079), (698, 0.053), (699, 0.036), (700, 0.025), (701, 0.02), (702, 0.014), (703, 0.01), (704, 0.007)]
responses['NIR'] = [(741, 0.001), (742, 0.002), (743, 0.002), (744, 0.003), (745, 0.004), (746, 0.003), (747, 0.003), (748, 0.002), (749, 0.002), (750, 0.001), (751, 0.014), (752, 0.018), (753, 0.022), (754, 0.027), (755, 0.032), (756, 0.038), (757, 0.047), (758, 0.056), (759, 0.069), (760, 0.069), (761, 0.083), (762, 0.099), (763, 0.121), (764, 0.146), (765, 0.175), (766, 0.209), (767, 0.248), (768, 0.294), (769, 0.346), (770, 0.402), (771, 0.463), (772, 0.523), (773, 0.588), (774, 0.649), (775, 0.705), (776, 0.757), (777, 0.797), (778, 0.827), (779, 0.853), (780, 0.871), (781, 0.884), (782, 0.892), (783, 0.899), (784, 0.903), (785, 0.908), (786, 0.911), (787, 0.916), (788, 0.92), (789, 0.925), (790, 0.926), (791, 0.927), (792, 0.927), (793, 0.929), (794, 0.932), (795, 0.93), (796, 0.926), (797, 0.926), (798, 0.925), (799, 0.928), (800, 0.925), (801, 0.926), (802, 0.928), (803, 0.928), (804, 0.928), (805, 0.923), (806, 0.92), (807, 0.919), (808, 0.914), (809, 0.91), (810, 0.908), (811, 0.905), (812, 0.903), (813, 0.904), (814, 0.902), (815, 0.909), (816, 0.917), (817, 0.92), (818, 0.928), (819, 0.938), (820, 0.946), (821, 0.953), (822, 0.962), (823, 0.969), (824, 0.971), (825, 0.971), (826, 0.97), (827, 0.969), (828, 0.969), (829, 0.97), (830, 0.967), (831, 0.969), (832, 0.968), (833, 0.963), (834, 0.965), (835, 0.967), (836, 0.965), (837, 0.963), (838, 0.958), (839, 0.95), (840, 0.949), (841, 0.943), (842, 0.933), (843, 0.929), (844, 0.928), (845, 0.925), (846, 0.924), (847, 0.927), (848, 0.932), (849, 0.934), (850, 0.943), (851, 0.952), (852, 0.956), (853, 0.966), (854, 0.977), (855, 0.985), (856, 0.99), (857, 0.992), (858, 0.993), (859, 0.994), (860, 0.998), (861, 0.996), (862, 0.992), (863, 0.991), (864, 0.992), (865, 0.994), (866, 0.993), (867, 0.997), (868, 0.997), (869, 0.996), (870, 0.998), (871, 0.999), (872, 1.0), (873, 0.999), (874, 0.996), (875, 0.991), (876, 0.99), (877, 0.991), (878, 0.985), (879, 0.978), (880, 0.969), (881, 0.955), (882, 0.937), (883, 0.916), (884, 0.892), (885, 0.868), (886, 0.845), (887, 0.824), (888, 0.811), (889, 0.807), (890, 0.819), (891, 0.841), (892, 0.868), (893, 0.892), (894, 0.892), (895, 0.854), (896, 0.77), (897, 0.644), (898, 0.501), (899, 0.365), (900, 0.256), (901, 0.177), (902, 0.122), (903, 0.085), (904, 0.061), (905, 0.044), (906, 0.032), (907, 0.025), (908, 0.019), (909, 0.014), (910, 0.011), (911, 0.011), (912, 0.008), (913, 0.006), (914, 0.005)]
responses['SWIR-1'] = [(1508, 0.001), (1509, 0.001), (1510, 0.001), (1511, 0.007), (1512, 0.013), (1513, 0.01), (1514, 0.006), (1515, 0.012), (1516, 0.008), (1517, 0.003), (1518, 0.009), (1519, 0.015), (1520, 0.013), (1521, 0.012), (1522, 0.018), (1523, 0.024), (1524, 0.032), (1525, 0.04), (1526, 0.041), (1527, 0.049), (1528, 0.057), (1529, 0.067), (1530, 0.076), (1531, 0.087), (1532, 0.097), (1533, 0.109), (1534, 0.12), (1535, 0.148), (1536, 0.176), (1537, 0.196), (1538, 0.215), (1539, 0.244), (1540, 0.274), (1541, 0.306), (1542, 0.339), (1543, 0.393), (1544, 0.428), (1545, 0.462), (1546, 0.481), (1547, 0.499), (1548, 0.529), (1549, 0.558), (1550, 0.578), (1551, 0.598), (1552, 0.616), (1553, 0.634), (1554, 0.65), (1555, 0.667), (1556, 0.686), (1557, 0.704), (1558, 0.714), (1559, 0.724), (1560, 0.737), (1561, 0.75), (1562, 0.764), (1563, 0.778), (1564, 0.793), (1565, 0.808), (1566, 0.817), (1567, 0.825), (1568, 0.838), (1569, 0.851), (1570, 0.859), (1571, 0.867), (1572, 0.872), (1573, 0.878), (1574, 0.884), (1575, 0.893), (1576, 0.902), (1577, 0.901), (1578, 0.901), (1579, 0.899), (1580, 0.896), (1581, 0.896), (1582, 0.897), (1583, 0.893), (1584, 0.89), (1585, 0.895), (1586, 0.899), (1587, 0.891), (1588, 0.884), (1589, 0.88), (1590, 0.876), (1591, 0.872), (1592, 0.867), (1593, 0.87), (1594, 0.873), (1595, 0.873), (1596, 0.872), (1597, 0.875), (1598, 0.879), (1599, 0.877), (1600, 0.874), (1601, 0.868), (1602, 0.861), (1603, 0.86), (1604, 0.859), (1605, 0.868), (1606, 0.877), (1607, 0.878), (1608, 0.879), (1609, 0.889), (1610, 0.899), (1611, 0.897), (1612, 0.895), (1613, 0.893), (1614, 0.896), (1615, 0.9), (1616, 0.898), (1617, 0.897), (1618, 0.907), (1619, 0.917), (1620, 0.919), (1621, 0.921), (1622, 0.924), (1623, 0.926), (1624, 0.928), (1625, 0.929), (1626, 0.937), (1627, 0.945), (1628, 0.946), (1629, 0.947), (1630, 0.947), (1631, 0.948), (1632, 0.951), (1633, 0.955), (1634, 0.954), (1635, 0.952), (1636, 0.961), (1637, 0.969), (1638, 0.964), (1639, 0.96), (1640, 0.961), (1641, 0.962), (1642, 0.961), (1643, 0.959), (1644, 0.969), (1645, 0.978), (1646, 0.969), (1647, 0.96), (1648, 0.957), (1649, 0.955), (1650, 0.954), (1651, 0.952), (1652, 0.951), (1653, 0.951), (1654, 0.951), (1655, 0.952), (1656, 0.952), (1657, 0.954), (1658, 0.956), (1659, 0.95), (1660, 0.944), (1661, 0.939), (1662, 0.935), (1663, 0.934), (1664, 0.933), (1665, 0.931), (1666, 0.928), (1667, 0.935), (1668, 0.942), (1669, 0.945), (1670, 0.948), (1671, 0.945), (1672, 0.942), (1673, 0.938), (1674, 0.933), (1675, 0.939), (1676, 0.944), (1677, 0.946), (1678, 0.948), (1679, 0.947), (1680, 0.945), (1681, 0.944), (1682, 0.943), (1683, 0.947), (1684, 0.951), (1685, 0.955), (1686, 0.96), (1687, 0.964), (1688, 0.965), (1689, 0.967), (1690, 0.969), (1691, 0.971), (1692, 0.972), (1693, 0.974), (1694, 0.982), (1695, 0.991), (1696, 0.993), (1697, 0.995), (1698, 0.997), (1699, 0.999), (1700, 0.998), (1701, 0.996), (1702, 0.995), (1703, 0.994), (1704, 0.997), (1705, 1.0), (1706, 0.997), (1707, 0.994), (1708, 0.988), (1709, 0.983), (1710, 0.987), (1711, 0.99), (1712, 0.989), (1713, 0.988), (1714, 0.987), (1715, 0.989), (1716, 0.992), (1717, 0.989), (1718, 0.986), (1719, 0.984), (1720, 0.981), (1721, 0.982), (1722, 0.983), (1723, 0.979), (1724, 0.976), (1725, 0.978), (1726, 0.97), (1727, 0.969), (1728, 0.968), (1729, 0.964), (1730, 0.96), (1731, 0.952), (1732, 0.944), (1733, 0.933), (1734, 0.921), (1735, 0.902), (1736, 0.883), (1737, 0.864), (1738, 0.845), (1739, 0.818), (1740, 0.791), (1741, 0.751), (1742, 0.711), (1743, 0.674), (1744, 0.638), (1745, 0.608), (1746, 0.577), (1747, 0.547), (1748, 0.505), (1749, 0.462), (1750, 0.428), (1751, 0.393), (1752, 0.359), (1753, 0.325), (1754, 0.296), (1755, 0.267), (1756, 0.239), (1757, 0.212), (1758, 0.193), (1759, 0.175), (1760, 0.159), (1761, 0.142), (1762, 0.127), (1763, 0.111), (1764, 0.097), (1765, 0.084), (1766, 0.08), (1767, 0.077), (1768, 0.067), (1769, 0.058), (1770, 0.053), (1771, 0.049), (1772, 0.045), (1773, 0.042), (1774, 0.041), (1775, 0.039), (1776, 0.036), (1777, 0.034), (1778, 0.027), (1779, 0.02), (1780, 0.021), (1781, 0.021), (1782, 0.021), (1783, 0.022), (1784, 0.016), (1785, 0.011), (1786, 0.012), (1787, 0.012), (1788, 0.008), (1789, 0.004), (1790, 0.006), (1791, 0.008), (1792, 0.004)]
responses['SWIR-2'] = [(2015, 0.002), (2016, 0.002), (2017, 0.002), (2018, 0.002), (2019, 0.007), (2020, 0.012), (2021, 0.01), (2022, 0.009), (2023, 0.008), (2024, 0.007), (2025, 0.009), (2026, 0.011), (2027, 0.015), (2028, 0.02), (2029, 0.019), (2030, 0.017), (2031, 0.023), (2032, 0.03), (2033, 0.032), (2034, 0.035), (2035, 0.037), (2036, 0.041), (2037, 0.044), (2038, 0.047), (2039, 0.051), (2040, 0.058), (2041, 0.065), (2042, 0.072), (2043, 0.08), (2044, 0.084), (2045, 0.088), (2046, 0.095), (2047, 0.102), (2048, 0.117), (2049, 0.133), (2050, 0.149), (2051, 0.165), (2052, 0.188), (2053, 0.204), (2054, 0.22), (2055, 0.242), (2056, 0.264), (2057, 0.29), (2058, 0.316), (2059, 0.342), (2060, 0.367), (2061, 0.394), (2062, 0.421), (2063, 0.452), (2064, 0.484), (2065, 0.519), (2066, 0.554), (2067, 0.59), (2068, 0.63), (2069, 0.67), (2070, 0.677), (2071, 0.683), (2072, 0.707), (2073, 0.73), (2074, 0.743), (2075, 0.756), (2076, 0.762), (2077, 0.767), (2078, 0.781), (2079, 0.794), (2080, 0.784), (2081, 0.774), (2082, 0.775), (2083, 0.776), (2084, 0.783), (2085, 0.789), (2086, 0.775), (2087, 0.78), (2088, 0.784), (2089, 0.781), (2090, 0.778), (2091, 0.773), (2092, 0.768), (2093, 0.765), (2094, 0.762), (2095, 0.762), (2096, 0.761), (2097, 0.766), (2098, 0.77), (2099, 0.775), (2100, 0.775), (2101, 0.77), (2102, 0.764), (2103, 0.774), (2104, 0.784), (2105, 0.788), (2106, 0.792), (2107, 0.803), (2108, 0.814), (2109, 0.804), (2110, 0.794), (2111, 0.809), (2112, 0.825), (2113, 0.821), (2114, 0.817), (2115, 0.811), (2116, 0.806), (2117, 0.819), (2118, 0.82), (2119, 0.821), (2120, 0.836), (2121, 0.852), (2122, 0.842), (2123, 0.832), (2124, 0.834), (2125, 0.836), (2126, 0.843), (2127, 0.85), (2128, 0.853), (2129, 0.855), (2130, 0.859), (2131, 0.862), (2132, 0.857), (2133, 0.853), (2134, 0.862), (2135, 0.871), (2136, 0.848), (2137, 0.865), (2138, 0.882), (2139, 0.878), (2140, 0.875), (2141, 0.868), (2142, 0.86), (2143, 0.858), (2144, 0.856), (2145, 0.872), (2146, 0.887), (2147, 0.868), (2148, 0.85), (2149, 0.861), (2150, 0.872), (2151, 0.879), (2152, 0.868), (2153, 0.857), (2154, 0.861), (2155, 0.865), (2156, 0.866), (2157, 0.867), (2158, 0.869), (2159, 0.871), (2160, 0.877), (2161, 0.882), (2162, 0.876), (2163, 0.87), (2164, 0.87), (2165, 0.869), (2166, 0.873), (2167, 0.875), (2168, 0.877), (2169, 0.872), (2170, 0.868), (2171, 0.874), (2172, 0.88), (2173, 0.878), (2174, 0.877), (2175, 0.873), (2176, 0.87), (2177, 0.874), (2178, 0.878), (2179, 0.879), (2180, 0.88), (2181, 0.874), (2182, 0.868), (2183, 0.881), (2184, 0.875), (2185, 0.87), (2186, 0.863), (2187, 0.856), (2188, 0.859), (2189, 0.863), (2190, 0.863), (2191, 0.863), (2192, 0.86), (2193, 0.857), (2194, 0.85), (2195, 0.844), (2196, 0.852), (2197, 0.859), (2198, 0.858), (2199, 0.857), (2200, 0.854), (2201, 0.852), (2202, 0.859), (2203, 0.866), (2204, 0.867), (2205, 0.868), (2206, 0.862), (2207, 0.856), (2208, 0.856), (2209, 0.856), (2210, 0.847), (2211, 0.854), (2212, 0.861), (2213, 0.862), (2214, 0.862), (2215, 0.851), (2216, 0.84), (2217, 0.848), (2218, 0.856), (2219, 0.847), (2220, 0.838), (2221, 0.847), (2222, 0.856), (2223, 0.837), (2224, 0.839), (2225, 0.84), (2226, 0.842), (2227, 0.826), (2228, 0.835), (2229, 0.844), (2230, 0.836), (2231, 0.827), (2232, 0.835), (2233, 0.842), (2234, 0.832), (2235, 0.822), (2236, 0.832), (2237, 0.843), (2238, 0.833), (2239, 0.823), (2240, 0.839), (2241, 0.854), (2242, 0.839), (2243, 0.846), (2244, 0.853), (2245, 0.854), (2246, 0.854), (2247, 0.859), (2248, 0.865), (2249, 0.869), (2250, 0.873), (2251, 0.871), (2252, 0.869), (2253, 0.867), (2254, 0.865), (2255, 0.879), (2256, 0.893), (2257, 0.891), (2258, 0.89), (2259, 0.89), (2260, 0.898), (2261, 0.906), (2262, 0.915), (2263, 0.924), (2264, 0.922), (2265, 0.92), (2266, 0.921), (2267, 0.922), (2268, 0.931), (2269, 0.939), (2270, 0.928), (2271, 0.916), (2272, 0.928), (2273, 0.94), (2274, 0.93), (2275, 0.936), (2276, 0.942), (2277, 0.949), (2278, 0.957), (2279, 0.956), (2280, 0.954), (2281, 0.952), (2282, 0.951), (2283, 0.952), (2284, 0.954), (2285, 0.96), (2286, 0.966), (2287, 0.97), (2288, 0.975), (2289, 0.98), (2290, 0.985), (2291, 0.978), (2292, 0.971), (2293, 0.973), (2294, 0.972), (2295, 0.97), (2296, 0.982), (2297, 0.993), (2298, 0.994), (2299, 0.996), (2300, 0.989), (2301, 0.983), (2302, 0.977), (2303, 0.972), (2304, 0.986), (2305, 1.0), (2306, 0.999), (2307, 0.998), (2308, 0.985), (2309, 0.971), (2310, 0.968), (2311, 0.967), (2312, 0.967), (2313, 0.965), (2314, 0.962), (2315, 0.956), (2316, 0.949), (2317, 0.936), (2318, 0.923), (2319, 0.926), (2320, 0.929), (2321, 0.923), (2322, 0.917), (2323, 0.934), (2324, 0.919), (2325, 0.903), (2326, 0.914), (2327, 0.926), (2328, 0.921), (2329, 0.916), (2330, 0.929), (2331, 0.942), (2332, 0.933), (2333, 0.924), (2334, 0.922), (2335, 0.92), (2336, 0.891), (2337, 0.863), (2338, 0.844), (2339, 0.824), (2340, 0.775), (2341, 0.729), (2342, 0.684), (2343, 0.633), (2344, 0.583), (2345, 0.531), (2346, 0.48), (2347, 0.429), (2348, 0.378), (2349, 0.326), (2350, 0.275), (2351, 0.254), (2352, 0.233), (2353, 0.202), (2354, 0.171), (2355, 0.131), (2356, 0.121), (2357, 0.111), (2358, 0.096), (2359, 0.081), (2360, 0.075), (2361, 0.069), (2362, 0.057), (2363, 0.046), (2364, 0.038), (2365, 0.029), (2366, 0.034), (2367, 0.038), (2368, 0.018), (2369, 0.0), (2370, 0.013), (2371, 0.029), (2372, 0.023), (2373, 0.016), (2374, 0.009), (2375, 0.013), (2376, 0.017), (2377, 0.01), (2378, 0.003), (2379, 0.009), (2380, 0.015), (2381, 0.007)]
# responses['Pan'] = [(502, 0.001), (503, 0.005), (504, 0.008), (505, 0.018), (506, 0.027), (507, 0.046), (508, 0.066), (509, 0.108), (510, 0.15), (511, 0.22), (512, 0.289), (513, 0.368), (514, 0.447), (515, 0.502), (516, 0.556), (517, 0.575), (518, 0.594), (519, 0.596), (520, 0.599), (521, 0.6), (522, 0.6), (523, 0.604), (524, 0.607), (525, 0.609), (526, 0.612), (527, 0.613), (528, 0.615), (529, 0.613), (530, 0.61), (531, 0.607), (532, 0.604), (533, 0.603), (534, 0.602), (535, 0.604), (536, 0.605), (537, 0.61), (538, 0.614), (539, 0.62), (540, 0.627), (541, 0.632), (542, 0.637), (543, 0.64), (544, 0.643), (545, 0.645), (546, 0.646), (547, 0.645), (548, 0.643), (549, 0.638), (550, 0.632), (551, 0.63), (552, 0.627), (553, 0.625), (554, 0.623), (555, 0.625), (556, 0.626), (557, 0.63), (558, 0.634), (559, 0.638), (560, 0.642), (561, 0.648), (562, 0.655), (563, 0.663), (564, 0.672), (565, 0.678), (566, 0.683), (567, 0.688), (568, 0.692), (569, 0.694), (570, 0.697), (571, 0.699), (572, 0.7), (573, 0.701), (574, 0.702), (575, 0.705), (576, 0.708), (577, 0.71), (578, 0.712), (579, 0.712), (580, 0.713), (581, 0.715), (582, 0.716), (583, 0.717), (584, 0.718), (585, 0.718), (586, 0.718), (587, 0.714), (588, 0.71), (589, 0.709), (590, 0.707), (591, 0.706), (592, 0.705), (593, 0.703), (594, 0.701), (595, 0.703), (596, 0.705), (597, 0.711), (598, 0.718), (599, 0.724), (600, 0.73), (601, 0.736), (602, 0.742), (603, 0.746), (604, 0.75), (605, 0.753), (606, 0.757), (607, 0.76), (608, 0.763), (609, 0.763), (610, 0.764), (611, 0.76), (612, 0.755), (613, 0.752), (614, 0.748), (615, 0.745), (616, 0.742), (617, 0.737), (618, 0.733), (619, 0.731), (620, 0.729), (621, 0.729), (622, 0.728), (623, 0.729), (624, 0.73), (625, 0.731), (626, 0.732), (627, 0.732), (628, 0.733), (629, 0.734), (630, 0.734), (631, 0.738), (632, 0.742), (633, 0.745), (634, 0.748), (635, 0.75), (636, 0.751), (637, 0.753), (638, 0.755), (639, 0.757), (640, 0.758), (641, 0.759), (642, 0.76), (643, 0.763), (644, 0.767), (645, 0.768), (646, 0.769), (647, 0.771), (648, 0.773), (649, 0.776), (650, 0.779), (651, 0.78), (652, 0.781), (653, 0.782), (654, 0.783), (655, 0.785), (656, 0.787), (657, 0.789), (658, 0.791), (659, 0.792), (660, 0.793), (661, 0.793), (662, 0.792), (663, 0.791), (664, 0.791), (665, 0.791), (666, 0.792), (667, 0.794), (668, 0.796), (669, 0.797), (670, 0.798), (671, 0.799), (672, 0.801), (673, 0.803), (674, 0.804), (675, 0.806), (676, 0.808), (677, 0.812), (678, 0.815), (679, 0.817), (680, 0.82), (681, 0.824), (682, 0.827), (683, 0.828), (684, 0.829), (685, 0.831), (686, 0.834), (687, 0.836), (688, 0.838), (689, 0.84), (690, 0.842), (691, 0.845), (692, 0.847), (693, 0.85), (694, 0.853), (695, 0.854), (696, 0.856), (697, 0.859), (698, 0.862), (699, 0.865), (700, 0.868), (701, 0.869), (702, 0.871), (703, 0.873), (704, 0.876), (705, 0.88), (706, 0.883), (707, 0.885), (708, 0.886), (709, 0.889), (710, 0.892), (711, 0.893), (712, 0.894), (713, 0.895), (714, 0.896), (715, 0.896), (716, 0.896), (717, 0.895), (718, 0.894), (719, 0.894), (720, 0.894), (721, 0.894), (722, 0.894), (723, 0.895), (724, 0.895), (725, 0.896), (726, 0.896), (727, 0.897), (728, 0.898), (729, 0.899), (730, 0.9), (731, 0.901), (732, 0.903), (733, 0.903), (734, 0.904), (735, 0.903), (736, 0.903), (737, 0.903), (738, 0.902), (739, 0.901), (740, 0.9), (741, 0.898), (742, 0.897), (743, 0.896), (744, 0.896), (745, 0.893), (746, 0.891), (747, 0.885), (748, 0.88), (749, 0.88), (750, 0.879), (751, 0.88), (752, 0.88), (753, 0.877), (754, 0.873), (755, 0.873), (756, 0.873), (757, 0.875), (758, 0.877), (759, 0.878), (760, 0.88), (761, 0.88), (762, 0.88), (763, 0.882), (764, 0.885), (765, 0.887), (766, 0.888), (767, 0.89), (768, 0.892), (769, 0.893), (770, 0.893), (771, 0.898), (772, 0.902), (773, 0.905), (774, 0.908), (775, 0.91), (776, 0.913), (777, 0.916), (778, 0.92), (779, 0.92), (780, 0.92), (781, 0.919), (782, 0.918), (783, 0.917), (784, 0.916), (785, 0.916), (786, 0.916), (787, 0.918), (788, 0.919), (789, 0.919), (790, 0.918), (791, 0.918), (792, 0.917), (793, 0.916), (794, 0.916), (795, 0.916), (796, 0.915), (797, 0.916), (798, 0.918), (799, 0.923), (800, 0.927), (801, 0.928), (802, 0.928), (803, 0.93), (804, 0.932), (805, 0.938), (806, 0.943), (807, 0.947), (808, 0.952), (809, 0.955), (810, 0.957), (811, 0.96), (812, 0.962), (813, 0.965), (814, 0.969), (815, 0.97), (816, 0.97), (817, 0.971), (818, 0.972), (819, 0.975), (820, 0.977), (821, 0.978), (822, 0.979), (823, 0.98), (824, 0.981), (825, 0.984), (826, 0.987), (827, 0.989), (828, 0.992), (829, 0.994), (830, 0.997), (831, 0.998), (832, 0.998), (833, 0.999), (834, 1.0), (835, 0.998), (836, 0.996), (837, 0.995), (838, 0.995), (839, 0.995), (840, 0.994), (841, 0.993), (842, 0.992), (843, 0.992), (844, 0.992), (845, 0.993), (846, 0.994), (847, 0.993), (848, 0.992), (849, 0.989), (850, 0.987), (851, 0.982), (852, 0.978), (853, 0.973), (854, 0.968), (855, 0.965), (856, 0.962), (857, 0.96), (858, 0.957), (859, 0.953), (860, 0.949), (861, 0.943), (862, 0.937), (863, 0.933), (864, 0.928), (865, 0.924), (866, 0.92), (867, 0.916), (868, 0.911), (869, 0.909), (870, 0.907), (871, 0.906), (872, 0.905), (873, 0.905), (874, 0.906), (875, 0.909), (876, 0.911), (877, 0.916), (878, 0.922), (879, 0.931), (880, 0.94), (881, 0.951), (882, 0.962), (883, 0.97), (884, 0.977), (885, 0.978), (886, 0.979), (887, 0.968), (888, 0.957), (889, 0.926), (890, 0.895), (891, 0.841), (892, 0.787), (893, 0.717), (894, 0.647), (895, 0.572), (896, 0.496), (897, 0.429), (898, 0.363), (899, 0.31), (900, 0.258), (901, 0.219), (902, 0.181), (903, 0.154), (904, 0.127), (905, 0.108), (906, 0.089), (907, 0.075), (908, 0.062), (909, 0.053), (910, 0.044)]
    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to Landsat 8/9 OLI)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the Landsat missions website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
# responses['Coastal aerosol'] = [(429, 0.002), (430, 0.003), (431, 0.008), (432, 0.025), (433, 0.086), (434, 0.254), (435, 0.518), (436, 0.765), (437, 0.909), (438, 0.958), (439, 0.977), (440, 0.984), (441, 0.989), (442, 0.987), (443, 0.994), (444, 0.993), (445, 1.0), (446, 0.997), (447, 0.983), (448, 0.973), (449, 0.906), (450, 0.746), (451, 0.471), (452, 0.226), (453, 0.093), (454, 0.037), (455, 0.015), (456, 0.006), (457, 0.002)]
responses['Blue'] = [(443, 0.001), (444, 0.002), (445, 0.004), (446, 0.007), (447, 0.013), (448, 0.027), (449, 0.059), (450, 0.131), (451, 0.271), (452, 0.494), (453, 0.724), (454, 0.858), (455, 0.894), (456, 0.903), (457, 0.911), (458, 0.91), (459, 0.899), (460, 0.898), (461, 0.89), (462, 0.884), (463, 0.877), (464, 0.881), (465, 0.875), (466, 0.88), (467, 0.887), (468, 0.892), (469, 0.888), (470, 0.861), (471, 0.849), (472, 0.841), (473, 0.828), (474, 0.844), (475, 0.866), (476, 0.868), (477, 0.89), (478, 0.913), (479, 0.91), (480, 0.919), (481, 0.932), (482, 0.932), (483, 0.954), (484, 0.956), (485, 0.962), (486, 0.956), (487, 0.953), (488, 0.979), (489, 0.989), (490, 0.986), (491, 0.989), (492, 0.982), (493, 0.969), (494, 0.967), (495, 0.977), (496, 0.989), (497, 0.981), (498, 0.967), (499, 0.955), (500, 0.964), (501, 0.966), (502, 0.967), (503, 0.982), (504, 0.982), (505, 0.966), (506, 0.963), (507, 0.972), (508, 0.996), (509, 1.0), (510, 0.956), (511, 0.845), (512, 0.535), (513, 0.191), (514, 0.048), (515, 0.014), (516, 0.005), (517, 0.003), (518, 0.002), (519, 0.001)]
responses['Green'] = [(519, 0.001), (520, 0.002), (521, 0.003), (522, 0.003), (523, 0.005), (524, 0.007), (525, 0.01), (526, 0.016), (527, 0.026), (528, 0.041), (529, 0.071), (530, 0.123), (531, 0.212), (532, 0.354), (533, 0.546), (534, 0.741), (535, 0.865), (536, 0.927), (537, 0.955), (538, 0.954), (539, 0.959), (540, 0.961), (541, 0.965), (542, 0.97), (543, 0.952), (544, 0.961), (545, 0.978), (546, 0.978), (547, 0.977), (548, 0.981), (549, 0.991), (550, 1.0), (551, 0.992), (552, 0.983), (553, 0.984), (554, 0.978), (555, 0.965), (556, 0.957), (557, 0.946), (558, 0.948), (559, 0.959), (560, 0.967), (561, 0.978), (562, 0.966), (563, 0.953), (564, 0.958), (565, 0.97), (566, 0.979), (567, 0.983), (568, 0.981), (569, 0.975), (570, 0.967), (571, 0.979), (572, 0.978), (573, 0.976), (574, 0.974), (575, 0.98), (576, 0.969), (577, 0.969), (578, 0.968), (579, 0.983), (580, 0.98), (581, 0.964), (582, 0.969), (583, 0.984), (584, 0.987), (585, 0.974), (586, 0.946), (587, 0.904), (588, 0.809), (589, 0.685), (590, 0.525), (591, 0.345), (592, 0.19), (593, 0.088), (594, 0.035), (595, 0.014), (596, 0.006), (597, 0.003), (598, 0.001)]
responses['Red'] = [(628, 0.002), (629, 0.004), (630, 0.007), (631, 0.015), (632, 0.03), (633, 0.067), (634, 0.149), (635, 0.3), (636, 0.527), (637, 0.764), (638, 0.905), (639, 0.948), (640, 0.951), (641, 0.947), (642, 0.952), (643, 0.963), (644, 0.975), (645, 0.984), (646, 0.984), (647, 0.983), (648, 0.983), (649, 0.974), (650, 0.959), (651, 0.956), (652, 0.956), (653, 0.953), (654, 0.957), (655, 0.982), (656, 1.0), (657, 0.992), (658, 0.985), (659, 0.982), (660, 0.977), (661, 0.973), (662, 0.981), (663, 0.997), (664, 0.992), (665, 0.981), (666, 0.964), (667, 0.962), (668, 0.971), (669, 0.967), (670, 0.967), (671, 0.95), (672, 0.849), (673, 0.609), (674, 0.316), (675, 0.124), (676, 0.046), (677, 0.018), (678, 0.007), (679, 0.003), (680, 0.001)]
responses['NIR'] = [(838, 0.001), (839, 0.002), (840, 0.003), (841, 0.005), (842, 0.007), (843, 0.011), (844, 0.017), (845, 0.028), (846, 0.048), (847, 0.084), (848, 0.145), (849, 0.25), (850, 0.404), (851, 0.583), (852, 0.745), (853, 0.89), (854, 0.96), (855, 0.987), (856, 0.973), (857, 0.981), (858, 0.996), (859, 1.0), (860, 0.99), (861, 0.981), (862, 0.976), (863, 0.972), (864, 0.957), (865, 0.951), (866, 0.947), (867, 0.953), (868, 0.951), (869, 0.948), (870, 0.94), (871, 0.951), (872, 0.956), (873, 0.966), (874, 0.97), (875, 0.937), (876, 0.891), (877, 0.789), (878, 0.635), (879, 0.448), (880, 0.289), (881, 0.175), (882, 0.1), (883, 0.058), (884, 0.035), (885, 0.021), (886, 0.012), (887, 0.008), (888, 0.005), (889, 0.003), (890, 0.002), (891, 0.001)]
responses['SWIR-1'] = [(1524, 0.001), (1525, 0.001), (1526, 0.002), (1527, 0.002), (1528, 0.002), (1529, 0.002), (1530, 0.003), (1531, 0.003), (1532, 0.004), (1533, 0.004), (1534, 0.005), (1535, 0.006), (1536, 0.006), (1537, 0.007), (1538, 0.008), (1539, 0.01), (1540, 0.011), (1541, 0.012), (1542, 0.014), (1543, 0.016), (1544, 0.019), (1545, 0.022), (1546, 0.026), (1547, 0.03), (1548, 0.035), (1549, 0.04), (1550, 0.048), (1551, 0.055), (1552, 0.066), (1553, 0.076), (1554, 0.089), (1555, 0.102), (1556, 0.12), (1557, 0.139), (1558, 0.163), (1559, 0.188), (1560, 0.22), (1561, 0.253), (1562, 0.291), (1563, 0.33), (1564, 0.376), (1565, 0.421), (1566, 0.474), (1567, 0.526), (1568, 0.579), (1569, 0.632), (1570, 0.677), (1571, 0.721), (1572, 0.755), (1573, 0.788), (1574, 0.821), (1575, 0.854), (1576, 0.873), (1577, 0.892), (1578, 0.9), (1579, 0.907), (1580, 0.913), (1581, 0.919), (1582, 0.923), (1583, 0.927), (1584, 0.927), (1585, 0.926), (1586, 0.925), (1587, 0.924), (1588, 0.924), (1589, 0.924), (1590, 0.923), (1591, 0.921), (1592, 0.922), (1593, 0.923), (1594, 0.925), (1595, 0.927), (1596, 0.935), (1597, 0.943), (1598, 0.944), (1599, 0.946), (1600, 0.946), (1601, 0.946), (1602, 0.947), (1603, 0.948), (1604, 0.95), (1605, 0.953), (1606, 0.951), (1607, 0.95), (1608, 0.953), (1609, 0.956), (1610, 0.959), (1611, 0.962), (1612, 0.96), (1613, 0.958), (1614, 0.96), (1615, 0.961), (1616, 0.961), (1617, 0.96), (1618, 0.961), (1619, 0.961), (1620, 0.965), (1621, 0.968), (1622, 0.969), (1623, 0.971), (1624, 0.974), (1625, 0.977), (1626, 0.979), (1627, 0.981), (1628, 0.981), (1629, 0.981), (1630, 0.989), (1631, 0.996), (1632, 0.998), (1633, 1.0), (1634, 1.0), (1635, 1.0), (1636, 0.997), (1637, 0.993), (1638, 0.986), (1639, 0.979), (1640, 0.967), (1641, 0.955), (1642, 0.936), (1643, 0.917), (1644, 0.879), (1645, 0.841), (1646, 0.797), (1647, 0.752), (1648, 0.694), (1649, 0.637), (1650, 0.573), (1651, 0.51), (1652, 0.452), (1653, 0.394), (1654, 0.343), (1655, 0.292), (1656, 0.251), (1657, 0.211), (1658, 0.181), (1659, 0.151), (1660, 0.128), (1661, 0.107), (1662, 0.091), (1663, 0.075), (1664, 0.064), (1665, 0.053), (1666, 0.045), (1667, 0.037), (1668, 0.032), (1669, 0.026), (1670, 0.023), (1671, 0.019), (1672, 0.016), (1673, 0.013), (1674, 0.011), (1675, 0.01), (1676, 0.008), (1677, 0.007), (1678, 0.006), (1679, 0.005), (1680, 0.004), (1681, 0.004), (1682, 0.003), (1683, 0.003), (1684, 0.002), (1685, 0.002), (1686, 0.002), (1687, 0.001), (1688, 0.001)]
responses['SWIR-2'] = [(2051, 0.001), (2052, 0.001), (2053, 0.001), (2054, 0.002), (2055, 0.002), (2056, 0.002), (2057, 0.002), (2058, 0.002), (2059, 0.003), (2060, 0.003), (2061, 0.003), (2062, 0.004), (2063, 0.004), (2064, 0.005), (2065, 0.005), (2066, 0.006), (2067, 0.006), (2068, 0.007), (2069, 0.008), (2070, 0.009), (2071, 0.01), (2072, 0.011), (2073, 0.012), (2074, 0.014), (2075, 0.015), (2076, 0.017), (2077, 0.019), (2078, 0.021), (2079, 0.023), (2080, 0.026), (2081, 0.029), (2082, 0.032), (2083, 0.035), (2084, 0.04), (2085, 0.045), (2086, 0.051), (2087, 0.056), (2088, 0.063), (2089, 0.07), (2090, 0.079), (2091, 0.089), (2092, 0.101), (2093, 0.113), (2094, 0.128), (2095, 0.145), (2096, 0.162), (2097, 0.18), (2098, 0.203), (2099, 0.227), (2100, 0.254), (2101, 0.281), (2102, 0.311), (2103, 0.343), (2104, 0.377), (2105, 0.413), (2106, 0.45), (2107, 0.489), (2108, 0.522), (2109, 0.555), (2110, 0.593), (2111, 0.634), (2112, 0.663), (2113, 0.69), (2114, 0.722), (2115, 0.757), (2116, 0.776), (2117, 0.793), (2118, 0.814), (2119, 0.836), (2120, 0.846), (2121, 0.854), (2122, 0.868), (2123, 0.884), (2124, 0.886), (2125, 0.886), (2126, 0.895), (2127, 0.907), (2128, 0.91), (2129, 0.911), (2130, 0.918), (2131, 0.926), (2132, 0.93), (2133, 0.932), (2134, 0.937), (2135, 0.941), (2136, 0.943), (2137, 0.943), (2138, 0.943), (2139, 0.943), (2140, 0.945), (2141, 0.948), (2142, 0.949), (2143, 0.95), (2144, 0.95), (2145, 0.949), (2146, 0.953), (2147, 0.957), (2148, 0.953), (2149, 0.947), (2150, 0.949), (2151, 0.953), (2152, 0.951), (2153, 0.947), (2154, 0.947), (2155, 0.947), (2156, 0.952), (2157, 0.958), (2158, 0.953), (2159, 0.946), (2160, 0.948), (2161, 0.951), (2162, 0.952), (2163, 0.952), (2164, 0.949), (2165, 0.945), (2166, 0.943), (2167, 0.94), (2168, 0.943), (2169, 0.948), (2170, 0.945), (2171, 0.94), (2172, 0.939), (2173, 0.938), (2174, 0.942), (2175, 0.947), (2176, 0.947), (2177, 0.944), (2178, 0.947), (2179, 0.952), (2180, 0.949), (2181, 0.945), (2182, 0.94), (2183, 0.934), (2184, 0.935), (2185, 0.939), (2186, 0.939), (2187, 0.939), (2188, 0.935), (2189, 0.929), (2190, 0.927), (2191, 0.926), (2192, 0.931), (2193, 0.937), (2194, 0.934), (2195, 0.928), (2196, 0.931), (2197, 0.936), (2198, 0.936), (2199, 0.934), (2200, 0.935), (2201, 0.938), (2202, 0.946), (2203, 0.957), (2204, 0.956), (2205, 0.952), (2206, 0.957), (2207, 0.963), (2208, 0.964), (2209, 0.964), (2210, 0.964), (2211, 0.962), (2212, 0.963), (2213, 0.964), (2214, 0.962), (2215, 0.961), (2216, 0.959), (2217, 0.958), (2218, 0.958), (2219, 0.958), (2220, 0.953), (2221, 0.947), (2222, 0.952), (2223, 0.959), (2224, 0.96), (2225, 0.96), (2226, 0.955), (2227, 0.948), (2228, 0.952), (2229, 0.959), (2230, 0.961), (2231, 0.961), (2232, 0.956), (2233, 0.949), (2234, 0.953), (2235, 0.96), (2236, 0.964), (2237, 0.967), (2238, 0.964), (2239, 0.96), (2240, 0.965), (2241, 0.973), (2242, 0.978), (2243, 0.981), (2244, 0.983), (2245, 0.984), (2246, 0.985), (2247, 0.985), (2248, 0.991), (2249, 1.0), (2250, 0.998), (2251, 0.993), (2252, 0.992), (2253, 0.993), (2254, 0.996), (2255, 1.0), (2256, 0.999), (2257, 0.997), (2258, 0.994), (2259, 0.991), (2260, 0.988), (2261, 0.984), (2262, 0.986), (2263, 0.989), (2264, 0.985), (2265, 0.978), (2266, 0.975), (2267, 0.973), (2268, 0.974), (2269, 0.977), (2270, 0.976), (2271, 0.975), (2272, 0.974), (2273, 0.974), (2274, 0.968), (2275, 0.96), (2276, 0.957), (2277, 0.955), (2278, 0.955), (2279, 0.956), (2280, 0.947), (2281, 0.937), (2282, 0.922), (2283, 0.907), (2284, 0.895), (2285, 0.884), (2286, 0.855), (2287, 0.824), (2288, 0.785), (2289, 0.744), (2290, 0.699), (2291, 0.652), (2292, 0.603), (2293, 0.553), (2294, 0.503), (2295, 0.453), (2296, 0.404), (2297, 0.356), (2298, 0.316), (2299, 0.278), (2300, 0.245), (2301, 0.212), (2302, 0.186), (2303, 0.162), (2304, 0.141), (2305, 0.122), (2306, 0.107), (2307, 0.092), (2308, 0.08), (2309, 0.069), (2310, 0.061), (2311, 0.053), (2312, 0.046), (2313, 0.04), (2314, 0.036), (2315, 0.031), (2316, 0.028), (2317, 0.024), (2318, 0.021), (2319, 0.019), (2320, 0.017), (2321, 0.015), (2322, 0.013), (2323, 0.011), (2324, 0.01), (2325, 0.009), (2326, 0.008), (2327, 0.007), (2328, 0.006), (2329, 0.006), (2330, 0.005), (2331, 0.004), (2332, 0.004), (2333, 0.003), (2334, 0.003), (2335, 0.003), (2336, 0.002), (2337, 0.002), (2338, 0.002), (2339, 0.002), (2340, 0.001), (2341, 0.001)]
# responses['Pan'] = [(490, 0.001), (491, 0.002), (492, 0.003), (493, 0.004), (494, 0.006), (495, 0.009), (496, 0.016), (497, 0.023), (498, 0.043), (499, 0.067), (500, 0.124), (501, 0.196), (502, 0.323), (503, 0.472), (504, 0.598), (505, 0.715), (506, 0.776), (507, 0.817), (508, 0.832), (509, 0.838), (510, 0.849), (511, 0.862), (512, 0.863), (513, 0.86), (514, 0.859), (515, 0.858), (516, 0.857), (517, 0.856), (518, 0.858), (519, 0.863), (520, 0.861), (521, 0.856), (522, 0.853), (523, 0.85), (524, 0.853), (525, 0.857), (526, 0.859), (527, 0.86), (528, 0.862), (529, 0.863), (530, 0.86), (531, 0.855), (532, 0.864), (533, 0.879), (534, 0.886), (535, 0.889), (536, 0.895), (537, 0.902), (538, 0.906), (539, 0.909), (540, 0.912), (541, 0.914), (542, 0.91), (543, 0.903), (544, 0.909), (545, 0.92), (546, 0.922), (547, 0.919), (548, 0.913), (549, 0.905), (550, 0.893), (551, 0.879), (552, 0.877), (553, 0.879), (554, 0.878), (555, 0.876), (556, 0.873), (557, 0.869), (558, 0.875), (559, 0.885), (560, 0.89), (561, 0.893), (562, 0.886), (563, 0.874), (564, 0.876), (565, 0.882), (566, 0.891), (567, 0.901), (568, 0.904), (569, 0.903), (570, 0.908), (571, 0.914), (572, 0.915), (573, 0.913), (574, 0.916), (575, 0.92), (576, 0.921), (577, 0.921), (578, 0.924), (579, 0.929), (580, 0.93), (581, 0.93), (582, 0.938), (583, 0.949), (584, 0.947), (585, 0.94), (586, 0.941), (587, 0.944), (588, 0.946), (589, 0.947), (590, 0.942), (591, 0.936), (592, 0.94), (593, 0.947), (594, 0.942), (595, 0.934), (596, 0.934), (597, 0.938), (598, 0.941), (599, 0.944), (600, 0.952), (601, 0.964), (602, 0.967), (603, 0.968), (604, 0.968), (605, 0.968), (606, 0.965), (607, 0.961), (608, 0.957), (609, 0.953), (610, 0.949), (611, 0.946), (612, 0.948), (613, 0.952), (614, 0.955), (615, 0.956), (616, 0.959), (617, 0.963), (618, 0.964), (619, 0.964), (620, 0.966), (621, 0.969), (622, 0.973), (623, 0.977), (624, 0.978), (625, 0.978), (626, 0.974), (627, 0.969), (628, 0.97), (629, 0.972), (630, 0.973), (631, 0.973), (632, 0.97), (633, 0.966), (634, 0.966), (635, 0.967), (636, 0.967), (637, 0.966), (638, 0.972), (639, 0.981), (640, 0.981), (641, 0.978), (642, 0.974), (643, 0.971), (644, 0.963), (645, 0.953), (646, 0.953), (647, 0.958), (648, 0.964), (649, 0.971), (650, 0.969), (651, 0.965), (652, 0.967), (653, 0.971), (654, 0.974), (655, 0.977), (656, 0.983), (657, 0.99), (658, 0.988), (659, 0.984), (660, 0.988), (661, 0.996), (662, 0.999), (663, 1.0), (664, 1.0), (665, 0.999), (666, 0.998), (667, 0.997), (668, 0.993), (669, 0.987), (670, 0.986), (671, 0.986), (672, 0.956), (673, 0.914), (674, 0.78), (675, 0.61), (676, 0.439), (677, 0.267), (678, 0.167), (679, 0.094), (680, 0.058), (681, 0.035), (682, 0.023), (683, 0.015), (684, 0.011), (685, 0.008), (686, 0.006), (687, 0.004), (688, 0.003), (689, 0.002), (690, 0.002)]

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToLandsat89Oli:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
# responses['Coastal aerosol'] = [(429, 0.002), (430, 0.003), (431, 0.008), (432, 0.025), (433, 0.086), (434, 0.254), (435, 0.518), (436, 0.765), (437, 0.909), (438, 0.958), (439, 0.977), (440, 0.984), (441, 0.989), (442, 0.987), (443, 0.994), (444, 0.993), (445, 1.0), (446, 0.997), (447, 0.983), (448, 0.973), (449, 0.906), (450, 0.746), (451, 0.471), (452, 0.226), (453, 0.093), (454, 0.037), (455, 0.015), (456, 0.006), (457, 0.002)]
responses['Blue'] = [(443, 0.001), (444, 0.002), (445, 0.004), (446, 0.007), (447, 0.013), (448, 0.027), (449, 0.059), (450, 0.131), (451, 0.271), (452, 0.494), (453, 0.724), (454, 0.858), (455, 0.894), (456, 0.903), (457, 0.911), (458, 0.91), (459, 0.899), (460, 0.898), (461, 0.89), (462, 0.884), (463, 0.877), (464, 0.881), (465, 0.875), (466, 0.88), (467, 0.887), (468, 0.892), (469, 0.888), (470, 0.861), (471, 0.849), (472, 0.841), (473, 0.828), (474, 0.844), (475, 0.866), (476, 0.868), (477, 0.89), (478, 0.913), (479, 0.91), (480, 0.919), (481, 0.932), (482, 0.932), (483, 0.954), (484, 0.956), (485, 0.962), (486, 0.956), (487, 0.953), (488, 0.979), (489, 0.989), (490, 0.986), (491, 0.989), (492, 0.982), (493, 0.969), (494, 0.967), (495, 0.977), (496, 0.989), (497, 0.981), (498, 0.967), (499, 0.955), (500, 0.964), (501, 0.966), (502, 0.967), (503, 0.982), (504, 0.982), (505, 0.966), (506, 0.963), (507, 0.972), (508, 0.996), (509, 1.0), (510, 0.956), (511, 0.845), (512, 0.535), (513, 0.191), (514, 0.048), (515, 0.014), (516, 0.005), (517, 0.003), (518, 0.002), (519, 0.001)]
responses['Green'] = [(519, 0.001), (520, 0.002), (521, 0.003), (522, 0.003), (523, 0.005), (524, 0.007), (525, 0.01), (526, 0.016), (527, 0.026), (528, 0.041), (529, 0.071), (530, 0.123), (531, 0.212), (532, 0.354), (533, 0.546), (534, 0.741), (535, 0.865), (536, 0.927), (537, 0.955), (538, 0.954), (539, 0.959), (540, 0.961), (541, 0.965), (542, 0.97), (543, 0.952), (544, 0.961), (545, 0.978), (546, 0.978), (547, 0.977), (548, 0.981), (549, 0.991), (550, 1.0), (551, 0.992), (552, 0.983), (553, 0.984), (554, 0.978), (555, 0.965), (556, 0.957), (557, 0.946), (558, 0.948), (559, 0.959), (560, 0.967), (561, 0.978), (562, 0.966), (563, 0.953), (564, 0.958), (565, 0.97), (566, 0.979), (567, 0.983), (568, 0.981), (569, 0.975), (570, 0.967), (571, 0.979), (572, 0.978), (573, 0.976), (574, 0.974), (575, 0.98), (576, 0.969), (577, 0.969), (578, 0.968), (579, 0.983), (580, 0.98), (581, 0.964), (582, 0.969), (583, 0.984), (584, 0.987), (585, 0.974), (586, 0.946), (587, 0.904), (588, 0.809), (589, 0.685), (590, 0.525), (591, 0.345), (592, 0.19), (593, 0.088), (594, 0.035), (595, 0.014), (596, 0.006), (597, 0.003), (598, 0.001)]
responses['Red'] = [(628, 0.002), (629, 0.004), (630, 0.007), (631, 0.015), (632, 0.03), (633, 0.067), (634, 0.149), (635, 0.3), (636, 0.527), (637, 0.764), (638, 0.905), (639, 0.948), (640, 0.951), (641, 0.947), (642, 0.952), (643, 0.963), (644, 0.975), (645, 0.984), (646, 0.984), (647, 0.983), (648, 0.983), (649, 0.974), (650, 0.959), (651, 0.956), (652, 0.956), (653, 0.953), (654, 0.957), (655, 0.982), (656, 1.0), (657, 0.992), (658, 0.985), (659, 0.982), (660, 0.977), (661, 0.973), (662, 0.981), (663, 0.997), (664, 0.992), (665, 0.981), (666, 0.964), (667, 0.962), (668, 0.971), (669, 0.967), (670, 0.967), (671, 0.95), (672, 0.849), (673, 0.609), (674, 0.316), (675, 0.124), (676, 0.046), (677, 0.018), (678, 0.007), (679, 0.003), (680, 0.001)]
responses['NIR'] = [(838, 0.001), (839, 0.002), (840, 0.003), (841, 0.005), (842, 0.007), (843, 0.011), (844, 0.017), (845, 0.028), (846, 0.048), (847, 0.084), (848, 0.145), (849, 0.25), (850, 0.404), (851, 0.583), (852, 0.745), (853, 0.89), (854, 0.96), (855, 0.987), (856, 0.973), (857, 0.981), (858, 0.996), (859, 1.0), (860, 0.99), (861, 0.981), (862, 0.976), (863, 0.972), (864, 0.957), (865, 0.951), (866, 0.947), (867, 0.953), (868, 0.951), (869, 0.948), (870, 0.94), (871, 0.951), (872, 0.956), (873, 0.966), (874, 0.97), (875, 0.937), (876, 0.891), (877, 0.789), (878, 0.635), (879, 0.448), (880, 0.289), (881, 0.175), (882, 0.1), (883, 0.058), (884, 0.035), (885, 0.021), (886, 0.012), (887, 0.008), (888, 0.005), (889, 0.003), (890, 0.002), (891, 0.001)]
responses['SWIR-1'] = [(1524, 0.001), (1525, 0.001), (1526, 0.002), (1527, 0.002), (1528, 0.002), (1529, 0.002), (1530, 0.003), (1531, 0.003), (1532, 0.004), (1533, 0.004), (1534, 0.005), (1535, 0.006), (1536, 0.006), (1537, 0.007), (1538, 0.008), (1539, 0.01), (1540, 0.011), (1541, 0.012), (1542, 0.014), (1543, 0.016), (1544, 0.019), (1545, 0.022), (1546, 0.026), (1547, 0.03), (1548, 0.035), (1549, 0.04), (1550, 0.048), (1551, 0.055), (1552, 0.066), (1553, 0.076), (1554, 0.089), (1555, 0.102), (1556, 0.12), (1557, 0.139), (1558, 0.163), (1559, 0.188), (1560, 0.22), (1561, 0.253), (1562, 0.291), (1563, 0.33), (1564, 0.376), (1565, 0.421), (1566, 0.474), (1567, 0.526), (1568, 0.579), (1569, 0.632), (1570, 0.677), (1571, 0.721), (1572, 0.755), (1573, 0.788), (1574, 0.821), (1575, 0.854), (1576, 0.873), (1577, 0.892), (1578, 0.9), (1579, 0.907), (1580, 0.913), (1581, 0.919), (1582, 0.923), (1583, 0.927), (1584, 0.927), (1585, 0.926), (1586, 0.925), (1587, 0.924), (1588, 0.924), (1589, 0.924), (1590, 0.923), (1591, 0.921), (1592, 0.922), (1593, 0.923), (1594, 0.925), (1595, 0.927), (1596, 0.935), (1597, 0.943), (1598, 0.944), (1599, 0.946), (1600, 0.946), (1601, 0.946), (1602, 0.947), (1603, 0.948), (1604, 0.95), (1605, 0.953), (1606, 0.951), (1607, 0.95), (1608, 0.953), (1609, 0.956), (1610, 0.959), (1611, 0.962), (1612, 0.96), (1613, 0.958), (1614, 0.96), (1615, 0.961), (1616, 0.961), (1617, 0.96), (1618, 0.961), (1619, 0.961), (1620, 0.965), (1621, 0.968), (1622, 0.969), (1623, 0.971), (1624, 0.974), (1625, 0.977), (1626, 0.979), (1627, 0.981), (1628, 0.981), (1629, 0.981), (1630, 0.989), (1631, 0.996), (1632, 0.998), (1633, 1.0), (1634, 1.0), (1635, 1.0), (1636, 0.997), (1637, 0.993), (1638, 0.986), (1639, 0.979), (1640, 0.967), (1641, 0.955), (1642, 0.936), (1643, 0.917), (1644, 0.879), (1645, 0.841), (1646, 0.797), (1647, 0.752), (1648, 0.694), (1649, 0.637), (1650, 0.573), (1651, 0.51), (1652, 0.452), (1653, 0.394), (1654, 0.343), (1655, 0.292), (1656, 0.251), (1657, 0.211), (1658, 0.181), (1659, 0.151), (1660, 0.128), (1661, 0.107), (1662, 0.091), (1663, 0.075), (1664, 0.064), (1665, 0.053), (1666, 0.045), (1667, 0.037), (1668, 0.032), (1669, 0.026), (1670, 0.023), (1671, 0.019), (1672, 0.016), (1673, 0.013), (1674, 0.011), (1675, 0.01), (1676, 0.008), (1677, 0.007), (1678, 0.006), (1679, 0.005), (1680, 0.004), (1681, 0.004), (1682, 0.003), (1683, 0.003), (1684, 0.002), (1685, 0.002), (1686, 0.002), (1687, 0.001), (1688, 0.001)]
responses['SWIR-2'] = [(2051, 0.001), (2052, 0.001), (2053, 0.001), (2054, 0.002), (2055, 0.002), (2056, 0.002), (2057, 0.002), (2058, 0.002), (2059, 0.003), (2060, 0.003), (2061, 0.003), (2062, 0.004), (2063, 0.004), (2064, 0.005), (2065, 0.005), (2066, 0.006), (2067, 0.006), (2068, 0.007), (2069, 0.008), (2070, 0.009), (2071, 0.01), (2072, 0.011), (2073, 0.012), (2074, 0.014), (2075, 0.015), (2076, 0.017), (2077, 0.019), (2078, 0.021), (2079, 0.023), (2080, 0.026), (2081, 0.029), (2082, 0.032), (2083, 0.035), (2084, 0.04), (2085, 0.045), (2086, 0.051), (2087, 0.056), (2088, 0.063), (2089, 0.07), (2090, 0.079), (2091, 0.089), (2092, 0.101), (2093, 0.113), (2094, 0.128), (2095, 0.145), (2096, 0.162), (2097, 0.18), (2098, 0.203), (2099, 0.227), (2100, 0.254), (2101, 0.281), (2102, 0.311), (2103, 0.343), (2104, 0.377), (2105, 0.413), (2106, 0.45), (2107, 0.489), (2108, 0.522), (2109, 0.555), (2110, 0.593), (2111, 0.634), (2112, 0.663), (2113, 0.69), (2114, 0.722), (2115, 0.757), (2116, 0.776), (2117, 0.793), (2118, 0.814), (2119, 0.836), (2120, 0.846), (2121, 0.854), (2122, 0.868), (2123, 0.884), (2124, 0.886), (2125, 0.886), (2126, 0.895), (2127, 0.907), (2128, 0.91), (2129, 0.911), (2130, 0.918), (2131, 0.926), (2132, 0.93), (2133, 0.932), (2134, 0.937), (2135, 0.941), (2136, 0.943), (2137, 0.943), (2138, 0.943), (2139, 0.943), (2140, 0.945), (2141, 0.948), (2142, 0.949), (2143, 0.95), (2144, 0.95), (2145, 0.949), (2146, 0.953), (2147, 0.957), (2148, 0.953), (2149, 0.947), (2150, 0.949), (2151, 0.953), (2152, 0.951), (2153, 0.947), (2154, 0.947), (2155, 0.947), (2156, 0.952), (2157, 0.958), (2158, 0.953), (2159, 0.946), (2160, 0.948), (2161, 0.951), (2162, 0.952), (2163, 0.952), (2164, 0.949), (2165, 0.945), (2166, 0.943), (2167, 0.94), (2168, 0.943), (2169, 0.948), (2170, 0.945), (2171, 0.94), (2172, 0.939), (2173, 0.938), (2174, 0.942), (2175, 0.947), (2176, 0.947), (2177, 0.944), (2178, 0.947), (2179, 0.952), (2180, 0.949), (2181, 0.945), (2182, 0.94), (2183, 0.934), (2184, 0.935), (2185, 0.939), (2186, 0.939), (2187, 0.939), (2188, 0.935), (2189, 0.929), (2190, 0.927), (2191, 0.926), (2192, 0.931), (2193, 0.937), (2194, 0.934), (2195, 0.928), (2196, 0.931), (2197, 0.936), (2198, 0.936), (2199, 0.934), (2200, 0.935), (2201, 0.938), (2202, 0.946), (2203, 0.957), (2204, 0.956), (2205, 0.952), (2206, 0.957), (2207, 0.963), (2208, 0.964), (2209, 0.964), (2210, 0.964), (2211, 0.962), (2212, 0.963), (2213, 0.964), (2214, 0.962), (2215, 0.961), (2216, 0.959), (2217, 0.958), (2218, 0.958), (2219, 0.958), (2220, 0.953), (2221, 0.947), (2222, 0.952), (2223, 0.959), (2224, 0.96), (2225, 0.96), (2226, 0.955), (2227, 0.948), (2228, 0.952), (2229, 0.959), (2230, 0.961), (2231, 0.961), (2232, 0.956), (2233, 0.949), (2234, 0.953), (2235, 0.96), (2236, 0.964), (2237, 0.967), (2238, 0.964), (2239, 0.96), (2240, 0.965), (2241, 0.973), (2242, 0.978), (2243, 0.981), (2244, 0.983), (2245, 0.984), (2246, 0.985), (2247, 0.985), (2248, 0.991), (2249, 1.0), (2250, 0.998), (2251, 0.993), (2252, 0.992), (2253, 0.993), (2254, 0.996), (2255, 1.0), (2256, 0.999), (2257, 0.997), (2258, 0.994), (2259, 0.991), (2260, 0.988), (2261, 0.984), (2262, 0.986), (2263, 0.989), (2264, 0.985), (2265, 0.978), (2266, 0.975), (2267, 0.973), (2268, 0.974), (2269, 0.977), (2270, 0.976), (2271, 0.975), (2272, 0.974), (2273, 0.974), (2274, 0.968), (2275, 0.96), (2276, 0.957), (2277, 0.955), (2278, 0.955), (2279, 0.956), (2280, 0.947), (2281, 0.937), (2282, 0.922), (2283, 0.907), (2284, 0.895), (2285, 0.884), (2286, 0.855), (2287, 0.824), (2288, 0.785), (2289, 0.744), (2290, 0.699), (2291, 0.652), (2292, 0.603), (2293, 0.553), (2294, 0.503), (2295, 0.453), (2296, 0.404), (2297, 0.356), (2298, 0.316), (2299, 0.278), (2300, 0.245), (2301, 0.212), (2302, 0.186), (2303, 0.162), (2304, 0.141), (2305, 0.122), (2306, 0.107), (2307, 0.092), (2308, 0.08), (2309, 0.069), (2310, 0.061), (2311, 0.053), (2312, 0.046), (2313, 0.04), (2314, 0.036), (2315, 0.031), (2316, 0.028), (2317, 0.024), (2318, 0.021), (2319, 0.019), (2320, 0.017), (2321, 0.015), (2322, 0.013), (2323, 0.011), (2324, 0.01), (2325, 0.009), (2326, 0.008), (2327, 0.007), (2328, 0.006), (2329, 0.006), (2330, 0.005), (2331, 0.004), (2332, 0.004), (2333, 0.003), (2334, 0.003), (2335, 0.003), (2336, 0.002), (2337, 0.002), (2338, 0.002), (2339, 0.002), (2340, 0.001), (2341, 0.001)]
# responses['Pan'] = [(490, 0.001), (491, 0.002), (492, 0.003), (493, 0.004), (494, 0.006), (495, 0.009), (496, 0.016), (497, 0.023), (498, 0.043), (499, 0.067), (500, 0.124), (501, 0.196), (502, 0.323), (503, 0.472), (504, 0.598), (505, 0.715), (506, 0.776), (507, 0.817), (508, 0.832), (509, 0.838), (510, 0.849), (511, 0.862), (512, 0.863), (513, 0.86), (514, 0.859), (515, 0.858), (516, 0.857), (517, 0.856), (518, 0.858), (519, 0.863), (520, 0.861), (521, 0.856), (522, 0.853), (523, 0.85), (524, 0.853), (525, 0.857), (526, 0.859), (527, 0.86), (528, 0.862), (529, 0.863), (530, 0.86), (531, 0.855), (532, 0.864), (533, 0.879), (534, 0.886), (535, 0.889), (536, 0.895), (537, 0.902), (538, 0.906), (539, 0.909), (540, 0.912), (541, 0.914), (542, 0.91), (543, 0.903), (544, 0.909), (545, 0.92), (546, 0.922), (547, 0.919), (548, 0.913), (549, 0.905), (550, 0.893), (551, 0.879), (552, 0.877), (553, 0.879), (554, 0.878), (555, 0.876), (556, 0.873), (557, 0.869), (558, 0.875), (559, 0.885), (560, 0.89), (561, 0.893), (562, 0.886), (563, 0.874), (564, 0.876), (565, 0.882), (566, 0.891), (567, 0.901), (568, 0.904), (569, 0.903), (570, 0.908), (571, 0.914), (572, 0.915), (573, 0.913), (574, 0.916), (575, 0.92), (576, 0.921), (577, 0.921), (578, 0.924), (579, 0.929), (580, 0.93), (581, 0.93), (582, 0.938), (583, 0.949), (584, 0.947), (585, 0.94), (586, 0.941), (587, 0.944), (588, 0.946), (589, 0.947), (590, 0.942), (591, 0.936), (592, 0.94), (593, 0.947), (594, 0.942), (595, 0.934), (596, 0.934), (597, 0.938), (598, 0.941), (599, 0.944), (600, 0.952), (601, 0.964), (602, 0.967), (603, 0.968), (604, 0.968), (605, 0.968), (606, 0.965), (607, 0.961), (608, 0.957), (609, 0.953), (610, 0.949), (611, 0.946), (612, 0.948), (613, 0.952), (614, 0.955), (615, 0.956), (616, 0.959), (617, 0.963), (618, 0.964), (619, 0.964), (620, 0.966), (621, 0.969), (622, 0.973), (623, 0.977), (624, 0.978), (625, 0.978), (626, 0.974), (627, 0.969), (628, 0.97), (629, 0.972), (630, 0.973), (631, 0.973), (632, 0.97), (633, 0.966), (634, 0.966), (635, 0.967), (636, 0.967), (637, 0.966), (638, 0.972), (639, 0.981), (640, 0.981), (641, 0.978), (642, 0.974), (643, 0.971), (644, 0.963), (645, 0.953), (646, 0.953), (647, 0.958), (648, 0.964), (649, 0.971), (650, 0.969), (651, 0.965), (652, 0.967), (653, 0.971), (654, 0.974), (655, 0.977), (656, 0.983), (657, 0.99), (658, 0.988), (659, 0.984), (660, 0.988), (661, 0.996), (662, 0.999), (663, 1.0), (664, 1.0), (665, 0.999), (666, 0.998), (667, 0.997), (668, 0.993), (669, 0.987), (670, 0.986), (671, 0.986), (672, 0.956), (673, 0.914), (674, 0.78), (675, 0.61), (676, 0.439), (677, 0.267), (678, 0.167), (679, 0.094), (680, 0.058), (681, 0.035), (682, 0.023), (683, 0.015), (684, 0.011), (685, 0.008), (686, 0.006), (687, 0.004), (688, 0.003), (689, 0.002), (690, 0.002)]
    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to PRISMA)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the PRISMA mission website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
wavelength = [402.4, 411.3, 419.4, 427.0, 434.3, 441.7, 449.0, 456.4, 463.7, 470.9, 478.2, 485.4, 492.7, 500.1, 507.7, 515.2, 522.9, 530.7, 538.5, 546.5, 554.6, 562.7, 571.0, 579.4, 587.8, 596.5, 605.4, 614.2, 623.2, 632.1, 641.3, 650.8, 660.3, 669.8, 679.5, 689.4, 699.1, 709.0, 719.2, 729.2, 739.4, 749.7, 760.1, 770.5, 780.9, 791.4, 801.9, 812.5, 823.1, 833.8, 844.4, 855.2, 865.9, 876.6, 887.3, 898.0, 908.6, 919.2, 929.4, 939.9, 951.4, 962.3, 972.6, 943.0, 951.0, 959.5, 969.4, 978.7, 988.4, 998.4, 1008.2, 1018.0, 1028.8, 1037.8, 1047.4, 1057.4, 1067.6, 1078.0, 1088.6, 1099.1, 1109.7, 1120.5, 1131.1, 1141.9, 1152.5, 1163.5, 1174.5, 1185.4, 1196.2, 1207.1, 1217.7, 1229.0, 1240.1, 1250.8, 1262.3, 1273.3, 1284.3, 1295.2, 1306.0, 1317.0, 1328.1, 1338.9, 1349.6, 1360.8, 1372.7, 1383.0, 1394.5, 1405.4, 1416.3, 1427.1, 1438.2, 1448.9, 1459.1, 1469.7, 1480.6, 1491.2, 1501.8, 1512.4, 1523.0, 1533.6, 1544.0, 1554.6, 1565.1, 1575.4, 1585.6, 1596.0, 1606.2, 1616.6, 1626.8, 1636.9, 1647.0, 1656.8, 1667.0, 1677.1, 1687.2, 1697.0, 1706.8, 1716.6, 1726.4, 1736.3, 1745.9, 1755.5, 1765.3, 1774.9, 1784.4, 1793.7, 1803.4, 1812.8, 1822.1, 1831.7, 1841.0, 1850.3, 1859.3, 1868.0, 1878.5, 1886.8, 1895.8, 1904.6, 1914.0, 1923.1, 1932.0, 1940.8, 1949.6, 1958.4, 1967.1, 1975.8, 1984.5, 1993.3, 2001.8, 2010.4, 2019.0, 2027.5, 2036.0, 2044.4, 2052.8, 2061.1, 2069.5, 2077.8, 2086.1, 2094.4, 2102.5, 2110.8, 2119.0, 2127.1, 2135.2, 2143.2, 2151.1, 2159.3, 2167.3, 2175.1, 2183.2, 2190.8, 2198.9, 2206.6, 2214.3, 2222.2, 2229.8, 2237.6, 2245.2, 2252.8, 2260.6, 2268.0, 2275.8, 2283.3, 2290.6, 2298.3, 2305.5, 2312.9, 2320.6, 2327.6, 2335.2, 2342.6, 2349.6, 2357.0, 2364.4, 2371.3, 2378.5, 2385.8, 2392.8, 2399.8, 2407.3, 2414.2, 2421.0, 2428.4, 2435.3, 2442.2, 2448.9, 2456.3, 2462.8, 2469.4, 2476.8, 2483.6, 2490.0, 2496.9]
fwhm = [11.4, 10.6, 9.8, 9.4, 9.3, 9.2, 9.1, 9.1, 9.0, 9.0, 9.0, 9.0, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 10.0, 10.1, 10.2, 10.3, 10.4, 10.5, 10.8, 11.0, 11.0, 11.2, 11.2, 11.5, 11.6, 11.7, 11.8, 12.0, 12.1, 12.0, 12.4, 12.4, 12.4, 12.5, 12.6, 12.8, 12.7, 12.8, 12.8, 12.9, 12.9, 13.0, 13.0, 13.1, 13.1, 13.2, 13.1, 13.1, 13.1, 13.1, 12.9, 12.8, 13.2, 13.5, 13.0, 12.9, 10.9, 11.0, 12.0, 12.1, 12.2, 12.3, 12.7, 12.4, 13.0, 13.0, 13.3, 13.5, 13.7, 13.9, 14.0, 14.1, 14.1, 14.4, 14.0, 14.3, 14.1, 14.3, 14.7, 14.3, 14.4, 14.3, 14.6, 14.4, 14.7, 14.4, 14.7, 14.9, 14.6, 14.5, 14.4, 14.5, 14.6, 14.7, 14.4, 14.5, 15.1, 14.5, 14.8, 14.2, 14.4, 14.3, 14.1, 14.7, 13.9, 13.7, 14.2, 14.2, 14.0, 14.1, 14.0, 13.9, 13.9, 13.7, 13.9, 13.7, 13.6, 13.6, 13.6, 13.5, 13.7, 13.3, 13.2, 13.2, 12.6, 13.4, 12.9, 13.0, 13.1, 13.0, 12.7, 12.6, 12.7, 12.9, 12.9, 12.4, 12.3, 12.5, 12.5, 12.3, 12.2, 12.9, 12.2, 12.4, 12.4, 12.1, 11.1, 12.5, 11.6, 11.5, 12.5, 11.6, 12.0, 11.6, 11.8, 11.5, 11.4, 11.5, 11.4, 11.6, 11.2, 11.4, 11.2, 11.3, 11.0, 11.3, 10.9, 11.0, 10.9, 11.1, 10.9, 11.0, 10.8, 10.8, 10.8, 10.8, 10.6, 10.7, 10.5, 10.6, 10.8, 10.2, 10.7, 10.3, 10.3, 10.6, 10.1, 10.4, 10.1, 10.3, 10.3, 10.1, 10.2, 10.2, 9.9, 10.2, 9.8, 10.0, 10.0, 9.7, 10.1, 9.8, 9.7, 10.1, 9.6, 9.6, 10.0, 9.5, 9.5, 9.6, 9.7, 9.3, 9.6, 9.7, 9.0, 9.7, 9.5, 9.4, 8.8, 9.4, 9.5, 8.9, 9.1, 9.7, 9.0, 9.0, 9.5]
for w, f in zip(wavelength, fwhm):
    responses[w] = f

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToPrisma:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
wavelength = [402.4, 411.3, 419.4, 427.0, 434.3, 441.7, 449.0, 456.4, 463.7, 470.9, 478.2, 485.4, 492.7, 500.1, 507.7, 515.2, 522.9, 530.7, 538.5, 546.5, 554.6, 562.7, 571.0, 579.4, 587.8, 596.5, 605.4, 614.2, 623.2, 632.1, 641.3, 650.8, 660.3, 669.8, 679.5, 689.4, 699.1, 709.0, 719.2, 729.2, 739.4, 749.7, 760.1, 770.5, 780.9, 791.4, 801.9, 812.5, 823.1, 833.8, 844.4, 855.2, 865.9, 876.6, 887.3, 898.0, 908.6, 919.2, 929.4, 939.9, 951.4, 962.3, 972.6, 943.0, 951.0, 959.5, 969.4, 978.7, 988.4, 998.4, 1008.2, 1018.0, 1028.8, 1037.8, 1047.4, 1057.4, 1067.6, 1078.0, 1088.6, 1099.1, 1109.7, 1120.5, 1131.1, 1141.9, 1152.5, 1163.5, 1174.5, 1185.4, 1196.2, 1207.1, 1217.7, 1229.0, 1240.1, 1250.8, 1262.3, 1273.3, 1284.3, 1295.2, 1306.0, 1317.0, 1328.1, 1338.9, 1349.6, 1360.8, 1372.7, 1383.0, 1394.5, 1405.4, 1416.3, 1427.1, 1438.2, 1448.9, 1459.1, 1469.7, 1480.6, 1491.2, 1501.8, 1512.4, 1523.0, 1533.6, 1544.0, 1554.6, 1565.1, 1575.4, 1585.6, 1596.0, 1606.2, 1616.6, 1626.8, 1636.9, 1647.0, 1656.8, 1667.0, 1677.1, 1687.2, 1697.0, 1706.8, 1716.6, 1726.4, 1736.3, 1745.9, 1755.5, 1765.3, 1774.9, 1784.4, 1793.7, 1803.4, 1812.8, 1822.1, 1831.7, 1841.0, 1850.3, 1859.3, 1868.0, 1878.5, 1886.8, 1895.8, 1904.6, 1914.0, 1923.1, 1932.0, 1940.8, 1949.6, 1958.4, 1967.1, 1975.8, 1984.5, 1993.3, 2001.8, 2010.4, 2019.0, 2027.5, 2036.0, 2044.4, 2052.8, 2061.1, 2069.5, 2077.8, 2086.1, 2094.4, 2102.5, 2110.8, 2119.0, 2127.1, 2135.2, 2143.2, 2151.1, 2159.3, 2167.3, 2175.1, 2183.2, 2190.8, 2198.9, 2206.6, 2214.3, 2222.2, 2229.8, 2237.6, 2245.2, 2252.8, 2260.6, 2268.0, 2275.8, 2283.3, 2290.6, 2298.3, 2305.5, 2312.9, 2320.6, 2327.6, 2335.2, 2342.6, 2349.6, 2357.0, 2364.4, 2371.3, 2378.5, 2385.8, 2392.8, 2399.8, 2407.3, 2414.2, 2421.0, 2428.4, 2435.3, 2442.2, 2448.9, 2456.3, 2462.8, 2469.4, 2476.8, 2483.6, 2490.0, 2496.9]
fwhm = [11.4, 10.6, 9.8, 9.4, 9.3, 9.2, 9.1, 9.1, 9.0, 9.0, 9.0, 9.0, 9.2, 9.3, 9.4, 9.5, 9.6, 9.7, 9.8, 10.0, 10.1, 10.2, 10.3, 10.4, 10.5, 10.8, 11.0, 11.0, 11.2, 11.2, 11.5, 11.6, 11.7, 11.8, 12.0, 12.1, 12.0, 12.4, 12.4, 12.4, 12.5, 12.6, 12.8, 12.7, 12.8, 12.8, 12.9, 12.9, 13.0, 13.0, 13.1, 13.1, 13.2, 13.1, 13.1, 13.1, 13.1, 12.9, 12.8, 13.2, 13.5, 13.0, 12.9, 10.9, 11.0, 12.0, 12.1, 12.2, 12.3, 12.7, 12.4, 13.0, 13.0, 13.3, 13.5, 13.7, 13.9, 14.0, 14.1, 14.1, 14.4, 14.0, 14.3, 14.1, 14.3, 14.7, 14.3, 14.4, 14.3, 14.6, 14.4, 14.7, 14.4, 14.7, 14.9, 14.6, 14.5, 14.4, 14.5, 14.6, 14.7, 14.4, 14.5, 15.1, 14.5, 14.8, 14.2, 14.4, 14.3, 14.1, 14.7, 13.9, 13.7, 14.2, 14.2, 14.0, 14.1, 14.0, 13.9, 13.9, 13.7, 13.9, 13.7, 13.6, 13.6, 13.6, 13.5, 13.7, 13.3, 13.2, 13.2, 12.6, 13.4, 12.9, 13.0, 13.1, 13.0, 12.7, 12.6, 12.7, 12.9, 12.9, 12.4, 12.3, 12.5, 12.5, 12.3, 12.2, 12.9, 12.2, 12.4, 12.4, 12.1, 11.1, 12.5, 11.6, 11.5, 12.5, 11.6, 12.0, 11.6, 11.8, 11.5, 11.4, 11.5, 11.4, 11.6, 11.2, 11.4, 11.2, 11.3, 11.0, 11.3, 10.9, 11.0, 10.9, 11.1, 10.9, 11.0, 10.8, 10.8, 10.8, 10.8, 10.6, 10.7, 10.5, 10.6, 10.8, 10.2, 10.7, 10.3, 10.3, 10.6, 10.1, 10.4, 10.1, 10.3, 10.3, 10.1, 10.2, 10.2, 9.9, 10.2, 9.8, 10.0, 10.0, 9.7, 10.1, 9.8, 9.7, 10.1, 9.6, 9.6, 10.0, 9.5, 9.5, 9.6, 9.7, 9.3, 9.6, 9.7, 9.0, 9.7, 9.5, 9.4, 8.8, 9.4, 9.5, 8.9, 9.1, 9.7, 9.0, 9.0, 9.5]
for w, f in zip(wavelength, fwhm):
    responses[w] = f
    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to response function library)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution, with spectral response function stored inside a spectral library. Each spectral profile defines a destination spectral band.

Parameters

Spectral raster layer [raster]: A spectral raster layer to be resampled.
Spectral response function library [vector]: A spectral response function library defining the destination sensor.
Field with spectral profiles used as features [field]: Field with spectral profiles used as spectral response functions. If not selected, the default field is used. If that is also not specified, an error is raised.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToResponseFunctionLibrary:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
library: Spectral response function library
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
field: Field with spectral profiles used as features (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to Sentinel-2 MSI)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution. For more information see the Sentinel-2 missions website.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral response function [string]

Python code specifying the spectral response function.

Default:

from collections import OrderedDict

responses = OrderedDict()
# responses['B1 - Coastal aerosol'] = [(412, 0.002), (413, 0.004), (414, 0.004), (415, 0.004), (416, 0.006), (417, 0.004), (418, 0.003), (419, 0.001), (420, 0.002), (421, 0.001), (422, 0.001), (423, 0.0), (424, 0.0), (425, 0.001), (426, 0.001), (427, 0.002), (428, 0.002), (429, 0.004), (430, 0.029), (431, 0.119), (432, 0.324), (433, 0.573), (434, 0.715), (435, 0.762), (436, 0.789), (437, 0.809), (438, 0.811), (439, 0.824), (440, 0.854), (441, 0.871), (442, 0.887), (443, 0.926), (444, 0.982), (445, 1.0), (446, 0.975), (447, 0.936), (448, 0.89), (449, 0.85), (450, 0.826), (451, 0.784), (452, 0.614), (453, 0.33), (454, 0.124), (455, 0.044), (456, 0.015)]
responses['B2 - Blue'] = [(439, 0.01), (440, 0.03), (441, 0.027), (442, 0.024), (443, 0.02), (444, 0.023), (445, 0.025), (446, 0.017), (447, 0.021), (448, 0.016), (449, 0.021), (450, 0.018), (451, 0.018), (452, 0.018), (453, 0.019), (454, 0.019), (455, 0.027), (456, 0.043), (457, 0.072), (458, 0.154), (459, 0.328), (460, 0.553), (461, 0.71), (462, 0.753), (463, 0.752), (464, 0.757), (465, 0.763), (466, 0.762), (467, 0.785), (468, 0.815), (469, 0.862), (470, 0.893), (471, 0.92), (472, 0.919), (473, 0.913), (474, 0.9), (475, 0.89), (476, 0.882), (477, 0.876), (478, 0.884), (479, 0.907), (480, 0.932), (481, 0.939), (482, 0.944), (483, 0.922), (484, 0.886), (485, 0.847), (486, 0.813), (487, 0.782), (488, 0.773), (489, 0.772), (490, 0.787), (491, 0.812), (492, 0.846), (493, 0.888), (494, 0.928), (495, 0.951), (496, 0.966), (497, 0.969), (498, 0.966), (499, 0.958), (500, 0.954), (501, 0.952), (502, 0.957), (503, 0.966), (504, 0.977), (505, 0.977), (506, 0.974), (507, 0.959), (508, 0.935), (509, 0.902), (510, 0.872), (511, 0.844), (512, 0.823), (513, 0.815), (514, 0.821), (515, 0.84), (516, 0.87), (517, 0.915), (518, 0.961), (519, 0.992), (520, 1.0), (521, 0.984), (522, 0.911), (523, 0.74), (524, 0.504), (525, 0.305), (526, 0.18), (527, 0.107), (528, 0.066), (529, 0.042), (530, 0.027), (531, 0.014), (532, 0.003)]
responses['B3 - Green'] = [(538, 0.014), (539, 0.034), (540, 0.073), (541, 0.154), (542, 0.317), (543, 0.553), (544, 0.749), (545, 0.849), (546, 0.898), (547, 0.922), (548, 0.926), (549, 0.911), (550, 0.888), (551, 0.865), (552, 0.847), (553, 0.839), (554, 0.845), (555, 0.862), (556, 0.888), (557, 0.924), (558, 0.96), (559, 0.987), (560, 1.0), (561, 0.999), (562, 0.981), (563, 0.945), (564, 0.898), (565, 0.856), (566, 0.818), (567, 0.789), (568, 0.765), (569, 0.75), (570, 0.751), (571, 0.761), (572, 0.782), (573, 0.799), (574, 0.81), (575, 0.814), (576, 0.774), (577, 0.629), (578, 0.404), (579, 0.215), (580, 0.107), (581, 0.048), (582, 0.018), (583, 0.001)]
responses['B4 - Red'] = [(646, 0.001), (647, 0.026), (648, 0.117), (649, 0.391), (650, 0.75), (651, 0.945), (652, 0.98), (653, 0.994), (654, 1.0), (655, 0.995), (656, 0.991), (657, 0.977), (658, 0.941), (659, 0.879), (660, 0.816), (661, 0.773), (662, 0.754), (663, 0.76), (664, 0.783), (665, 0.81), (666, 0.836), (667, 0.861), (668, 0.886), (669, 0.911), (670, 0.934), (671, 0.95), (672, 0.959), (673, 0.96), (674, 0.959), (675, 0.958), (676, 0.955), (677, 0.944), (678, 0.895), (679, 0.744), (680, 0.477), (681, 0.23), (682, 0.08), (683, 0.026), (684, 0.004)]
responses['B5 - Red edge 1'] = [(695, 0.028), (696, 0.124), (697, 0.394), (698, 0.761), (699, 0.971), (700, 0.999), (701, 1.0), (702, 0.994), (703, 0.983), (704, 0.967), (705, 0.948), (706, 0.927), (707, 0.904), (708, 0.886), (709, 0.867), (710, 0.791), (711, 0.588), (712, 0.263), (713, 0.057), (714, 0.006)]
responses['B6 - Red edge 2'] = [(731, 0.002), (732, 0.055), (733, 0.258), (734, 0.647), (735, 0.892), (736, 0.902), (737, 0.915), (738, 0.941), (739, 0.963), (740, 0.975), (741, 0.977), (742, 0.987), (743, 1.0), (744, 0.989), (745, 0.972), (746, 0.901), (747, 0.607), (748, 0.205), (749, 0.027)]
responses['B7 - Red edge 3'] = [(770, 0.012), (771, 0.052), (772, 0.166), (773, 0.369), (774, 0.637), (775, 0.861), (776, 0.97), (777, 0.991), (778, 0.999), (779, 1.0), (780, 0.977), (781, 0.926), (782, 0.866), (783, 0.82), (784, 0.794), (785, 0.791), (786, 0.804), (787, 0.819), (788, 0.826), (789, 0.82), (790, 0.792), (791, 0.721), (792, 0.588), (793, 0.414), (794, 0.231), (795, 0.099), (796, 0.027), (797, 0.005)]
responses['B8 - NIR'] = [(774, 0.007), (775, 0.018), (776, 0.032), (777, 0.053), (778, 0.083), (779, 0.127), (780, 0.196), (781, 0.302), (782, 0.436), (783, 0.571), (784, 0.698), (785, 0.803), (786, 0.891), (787, 0.953), (788, 0.989), (789, 1.0), (790, 0.988), (791, 0.964), (792, 0.942), (793, 0.937), (794, 0.942), (795, 0.954), (796, 0.968), (797, 0.98), (798, 0.985), (799, 0.986), (800, 0.984), (801, 0.978), (802, 0.977), (803, 0.978), (804, 0.981), (805, 0.988), (806, 0.989), (807, 0.986), (808, 0.981), (809, 0.971), (810, 0.957), (811, 0.939), (812, 0.917), (813, 0.896), (814, 0.873), (815, 0.852), (816, 0.825), (817, 0.801), (818, 0.782), (819, 0.764), (820, 0.75), (821, 0.739), (822, 0.731), (823, 0.723), (824, 0.725), (825, 0.726), (826, 0.723), (827, 0.722), (828, 0.716), (829, 0.712), (830, 0.708), (831, 0.702), (832, 0.699), (833, 0.701), (834, 0.707), (835, 0.718), (836, 0.731), (837, 0.748), (838, 0.768), (839, 0.784), (840, 0.797), (841, 0.803), (842, 0.805), (843, 0.802), (844, 0.797), (845, 0.789), (846, 0.777), (847, 0.765), (848, 0.751), (849, 0.737), (850, 0.723), (851, 0.704), (852, 0.684), (853, 0.665), (854, 0.647), (855, 0.63), (856, 0.616), (857, 0.602), (858, 0.59), (859, 0.58), (860, 0.571), (861, 0.561), (862, 0.552), (863, 0.546), (864, 0.54), (865, 0.535), (866, 0.531), (867, 0.53), (868, 0.53), (869, 0.53), (870, 0.532), (871, 0.533), (872, 0.532), (873, 0.533), (874, 0.532), (875, 0.531), (876, 0.53), (877, 0.53), (878, 0.533), (879, 0.537), (880, 0.542), (881, 0.549), (882, 0.555), (883, 0.56), (884, 0.558), (885, 0.548), (886, 0.531), (887, 0.508), (888, 0.478), (889, 0.451), (890, 0.428), (891, 0.411), (892, 0.4), (893, 0.401), (894, 0.408), (895, 0.421), (896, 0.43), (897, 0.425), (898, 0.391), (899, 0.33), (900, 0.257), (901, 0.182), (902, 0.117), (903, 0.07), (904, 0.043), (905, 0.026), (906, 0.016), (907, 0.004)]
responses['B8A - Narrow NIR'] = [(847, 0.002), (848, 0.002), (849, 0.013), (850, 0.026), (851, 0.053), (852, 0.108), (853, 0.222), (854, 0.397), (855, 0.61), (856, 0.817), (857, 0.932), (858, 0.972), (859, 0.975), (860, 0.975), (861, 0.973), (862, 0.976), (863, 0.98), (864, 0.987), (865, 0.991), (866, 0.997), (867, 1.0), (868, 0.999), (869, 0.996), (870, 0.995), (871, 1.0), (872, 0.996), (873, 0.924), (874, 0.741), (875, 0.49), (876, 0.25), (877, 0.112), (878, 0.048), (879, 0.023), (880, 0.011), (881, 0.001)]
# responses['B9 - Water vapour'] = [(932, 0.017), (933, 0.061), (934, 0.174), (935, 0.389), (936, 0.665), (937, 0.875), (938, 0.937), (939, 0.968), (940, 0.989), (941, 0.995), (942, 1.0), (943, 0.978), (944, 0.981), (945, 0.992), (946, 0.988), (947, 0.994), (948, 0.983), (949, 0.978), (950, 0.95), (951, 0.953), (952, 0.922), (953, 0.856), (954, 0.71), (955, 0.464), (956, 0.215), (957, 0.065), (958, 0.016)]
# responses['B10 - Cirrus'] = [(1350, 0.001), (1351, 0.002), (1352, 0.004), (1353, 0.008), (1354, 0.019), (1355, 0.045), (1356, 0.102), (1357, 0.201), (1358, 0.342), (1359, 0.506), (1360, 0.662), (1361, 0.783), (1362, 0.861), (1363, 0.91), (1364, 0.942), (1365, 0.962), (1366, 0.974), (1367, 0.982), (1368, 0.988), (1369, 0.993), (1370, 0.996), (1371, 0.999), (1372, 1.0), (1373, 0.999), (1374, 0.996), (1375, 0.991), (1376, 0.985), (1377, 0.978), (1378, 0.97), (1379, 0.961), (1380, 0.949), (1381, 0.933), (1382, 0.915), (1383, 0.894), (1384, 0.869), (1385, 0.831), (1386, 0.765), (1387, 0.655), (1388, 0.508), (1389, 0.351), (1390, 0.219), (1391, 0.127), (1392, 0.068), (1393, 0.033), (1394, 0.014), (1395, 0.005), (1396, 0.002), (1397, 0.001)]
responses['B11 - SWIR-1'] = [(1551, 0.001), (1552, 0.002), (1553, 0.002), (1554, 0.004), (1555, 0.005), (1556, 0.008), (1557, 0.013), (1558, 0.019), (1559, 0.028), (1560, 0.04), (1561, 0.055), (1562, 0.075), (1563, 0.101), (1564, 0.135), (1565, 0.183), (1566, 0.247), (1567, 0.331), (1568, 0.43), (1569, 0.538), (1570, 0.647), (1571, 0.744), (1572, 0.815), (1573, 0.859), (1574, 0.88), (1575, 0.887), (1576, 0.889), (1577, 0.891), (1578, 0.898), (1579, 0.907), (1580, 0.917), (1581, 0.927), (1582, 0.935), (1583, 0.942), (1584, 0.948), (1585, 0.951), (1586, 0.954), (1587, 0.956), (1588, 0.958), (1589, 0.961), (1590, 0.963), (1591, 0.966), (1592, 0.968), (1593, 0.971), (1594, 0.973), (1595, 0.976), (1596, 0.979), (1597, 0.98), (1598, 0.981), (1599, 0.981), (1600, 0.981), (1601, 0.981), (1602, 0.981), (1603, 0.98), (1604, 0.981), (1605, 0.983), (1606, 0.985), (1607, 0.988), (1608, 0.99), (1609, 0.992), (1610, 0.993), (1611, 0.993), (1612, 0.99), (1613, 0.987), (1614, 0.984), (1615, 0.98), (1616, 0.976), (1617, 0.973), (1618, 0.97), (1619, 0.968), (1620, 0.966), (1621, 0.966), (1622, 0.966), (1623, 0.967), (1624, 0.97), (1625, 0.973), (1626, 0.979), (1627, 0.983), (1628, 0.988), (1629, 0.992), (1630, 0.995), (1631, 0.998), (1632, 0.999), (1633, 0.999), (1634, 0.999), (1635, 0.999), (1636, 0.999), (1637, 1.0), (1638, 1.0), (1639, 1.0), (1640, 1.0), (1641, 0.997), (1642, 0.992), (1643, 0.986), (1644, 0.979), (1645, 0.97), (1646, 0.961), (1647, 0.953), (1648, 0.947), (1649, 0.942), (1650, 0.939), (1651, 0.935), (1652, 0.928), (1653, 0.912), (1654, 0.881), (1655, 0.825), (1656, 0.743), (1657, 0.642), (1658, 0.534), (1659, 0.427), (1660, 0.324), (1661, 0.234), (1662, 0.164), (1663, 0.11), (1664, 0.072), (1665, 0.046), (1666, 0.029), (1667, 0.019), (1668, 0.013), (1669, 0.009), (1670, 0.007), (1671, 0.005), (1672, 0.003), (1673, 0.002), (1674, 0.002), (1675, 0.001), (1676, 0.001)]
responses['B12 - SWIR-2'] = [(2079, 0.001), (2080, 0.003), (2081, 0.004), (2082, 0.007), (2083, 0.008), (2084, 0.008), (2085, 0.009), (2086, 0.009), (2087, 0.01), (2088, 0.011), (2089, 0.012), (2090, 0.013), (2091, 0.015), (2092, 0.017), (2093, 0.02), (2094, 0.023), (2095, 0.028), (2096, 0.033), (2097, 0.04), (2098, 0.049), (2099, 0.06), (2100, 0.073), (2101, 0.091), (2102, 0.111), (2103, 0.137), (2104, 0.168), (2105, 0.203), (2106, 0.243), (2107, 0.285), (2108, 0.327), (2109, 0.368), (2110, 0.408), (2111, 0.445), (2112, 0.477), (2113, 0.503), (2114, 0.525), (2115, 0.543), (2116, 0.557), (2117, 0.569), (2118, 0.579), (2119, 0.589), (2120, 0.599), (2121, 0.61), (2122, 0.621), (2123, 0.634), (2124, 0.649), (2125, 0.664), (2126, 0.68), (2127, 0.696), (2128, 0.712), (2129, 0.727), (2130, 0.741), (2131, 0.757), (2132, 0.772), (2133, 0.786), (2134, 0.798), (2135, 0.81), (2136, 0.82), (2137, 0.829), (2138, 0.837), (2139, 0.844), (2140, 0.851), (2141, 0.853), (2142, 0.855), (2143, 0.856), (2144, 0.858), (2145, 0.86), (2146, 0.861), (2147, 0.863), (2148, 0.865), (2149, 0.867), (2150, 0.87), (2151, 0.874), (2152, 0.879), (2153, 0.882), (2154, 0.886), (2155, 0.889), (2156, 0.893), (2157, 0.897), (2158, 0.9), (2159, 0.903), (2160, 0.905), (2161, 0.906), (2162, 0.906), (2163, 0.906), (2164, 0.905), (2165, 0.905), (2166, 0.904), (2167, 0.903), (2168, 0.903), (2169, 0.902), (2170, 0.902), (2171, 0.903), (2172, 0.904), (2173, 0.905), (2174, 0.906), (2175, 0.908), (2176, 0.91), (2177, 0.913), (2178, 0.916), (2179, 0.918), (2180, 0.921), (2181, 0.924), (2182, 0.927), (2183, 0.93), (2184, 0.932), (2185, 0.934), (2186, 0.936), (2187, 0.937), (2188, 0.938), (2189, 0.938), (2190, 0.938), (2191, 0.94), (2192, 0.943), (2193, 0.943), (2194, 0.943), (2195, 0.942), (2196, 0.941), (2197, 0.938), (2198, 0.937), (2199, 0.935), (2200, 0.933), (2201, 0.927), (2202, 0.921), (2203, 0.915), (2204, 0.911), (2205, 0.908), (2206, 0.907), (2207, 0.908), (2208, 0.911), (2209, 0.916), (2210, 0.923), (2211, 0.921), (2212, 0.919), (2213, 0.919), (2214, 0.921), (2215, 0.925), (2216, 0.928), (2217, 0.932), (2218, 0.937), (2219, 0.941), (2220, 0.947), (2221, 0.951), (2222, 0.954), (2223, 0.957), (2224, 0.96), (2225, 0.963), (2226, 0.965), (2227, 0.966), (2228, 0.967), (2229, 0.966), (2230, 0.965), (2231, 0.965), (2232, 0.964), (2233, 0.962), (2234, 0.959), (2235, 0.957), (2236, 0.955), (2237, 0.954), (2238, 0.953), (2239, 0.952), (2240, 0.952), (2241, 0.952), (2242, 0.953), (2243, 0.954), (2244, 0.957), (2245, 0.961), (2246, 0.964), (2247, 0.968), (2248, 0.973), (2249, 0.977), (2250, 0.983), (2251, 0.987), (2252, 0.991), (2253, 0.994), (2254, 0.997), (2255, 0.999), (2256, 1.0), (2257, 1.0), (2258, 0.999), (2259, 0.997), (2260, 0.994), (2261, 0.99), (2262, 0.984), (2263, 0.976), (2264, 0.968), (2265, 0.958), (2266, 0.948), (2267, 0.938), (2268, 0.928), (2269, 0.917), (2270, 0.906), (2271, 0.894), (2272, 0.882), (2273, 0.869), (2274, 0.855), (2275, 0.841), (2276, 0.826), (2277, 0.81), (2278, 0.792), (2279, 0.772), (2280, 0.749), (2281, 0.72), (2282, 0.688), (2283, 0.651), (2284, 0.61), (2285, 0.566), (2286, 0.521), (2287, 0.475), (2288, 0.429), (2289, 0.386), (2290, 0.342), (2291, 0.301), (2292, 0.263), (2293, 0.228), (2294, 0.196), (2295, 0.168), (2296, 0.145), (2297, 0.125), (2298, 0.108), (2299, 0.094), (2300, 0.082), (2301, 0.072), (2302, 0.063), (2303, 0.055), (2304, 0.048), (2305, 0.043), (2306, 0.039), (2307, 0.035), (2308, 0.032), (2309, 0.03), (2310, 0.027), (2311, 0.026), (2312, 0.024), (2313, 0.022), (2314, 0.019), (2315, 0.016), (2316, 0.011), (2317, 0.007), (2318, 0.007), (2319, 0.005), (2320, 0.002)]

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToSentinel2Msi:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
response: Spectral response function
    Default value:  from collections import OrderedDict

responses = OrderedDict()
# responses['B1 - Coastal aerosol'] = [(412, 0.002), (413, 0.004), (414, 0.004), (415, 0.004), (416, 0.006), (417, 0.004), (418, 0.003), (419, 0.001), (420, 0.002), (421, 0.001), (422, 0.001), (423, 0.0), (424, 0.0), (425, 0.001), (426, 0.001), (427, 0.002), (428, 0.002), (429, 0.004), (430, 0.029), (431, 0.119), (432, 0.324), (433, 0.573), (434, 0.715), (435, 0.762), (436, 0.789), (437, 0.809), (438, 0.811), (439, 0.824), (440, 0.854), (441, 0.871), (442, 0.887), (443, 0.926), (444, 0.982), (445, 1.0), (446, 0.975), (447, 0.936), (448, 0.89), (449, 0.85), (450, 0.826), (451, 0.784), (452, 0.614), (453, 0.33), (454, 0.124), (455, 0.044), (456, 0.015)]
responses['B2 - Blue'] = [(439, 0.01), (440, 0.03), (441, 0.027), (442, 0.024), (443, 0.02), (444, 0.023), (445, 0.025), (446, 0.017), (447, 0.021), (448, 0.016), (449, 0.021), (450, 0.018), (451, 0.018), (452, 0.018), (453, 0.019), (454, 0.019), (455, 0.027), (456, 0.043), (457, 0.072), (458, 0.154), (459, 0.328), (460, 0.553), (461, 0.71), (462, 0.753), (463, 0.752), (464, 0.757), (465, 0.763), (466, 0.762), (467, 0.785), (468, 0.815), (469, 0.862), (470, 0.893), (471, 0.92), (472, 0.919), (473, 0.913), (474, 0.9), (475, 0.89), (476, 0.882), (477, 0.876), (478, 0.884), (479, 0.907), (480, 0.932), (481, 0.939), (482, 0.944), (483, 0.922), (484, 0.886), (485, 0.847), (486, 0.813), (487, 0.782), (488, 0.773), (489, 0.772), (490, 0.787), (491, 0.812), (492, 0.846), (493, 0.888), (494, 0.928), (495, 0.951), (496, 0.966), (497, 0.969), (498, 0.966), (499, 0.958), (500, 0.954), (501, 0.952), (502, 0.957), (503, 0.966), (504, 0.977), (505, 0.977), (506, 0.974), (507, 0.959), (508, 0.935), (509, 0.902), (510, 0.872), (511, 0.844), (512, 0.823), (513, 0.815), (514, 0.821), (515, 0.84), (516, 0.87), (517, 0.915), (518, 0.961), (519, 0.992), (520, 1.0), (521, 0.984), (522, 0.911), (523, 0.74), (524, 0.504), (525, 0.305), (526, 0.18), (527, 0.107), (528, 0.066), (529, 0.042), (530, 0.027), (531, 0.014), (532, 0.003)]
responses['B3 - Green'] = [(538, 0.014), (539, 0.034), (540, 0.073), (541, 0.154), (542, 0.317), (543, 0.553), (544, 0.749), (545, 0.849), (546, 0.898), (547, 0.922), (548, 0.926), (549, 0.911), (550, 0.888), (551, 0.865), (552, 0.847), (553, 0.839), (554, 0.845), (555, 0.862), (556, 0.888), (557, 0.924), (558, 0.96), (559, 0.987), (560, 1.0), (561, 0.999), (562, 0.981), (563, 0.945), (564, 0.898), (565, 0.856), (566, 0.818), (567, 0.789), (568, 0.765), (569, 0.75), (570, 0.751), (571, 0.761), (572, 0.782), (573, 0.799), (574, 0.81), (575, 0.814), (576, 0.774), (577, 0.629), (578, 0.404), (579, 0.215), (580, 0.107), (581, 0.048), (582, 0.018), (583, 0.001)]
responses['B4 - Red'] = [(646, 0.001), (647, 0.026), (648, 0.117), (649, 0.391), (650, 0.75), (651, 0.945), (652, 0.98), (653, 0.994), (654, 1.0), (655, 0.995), (656, 0.991), (657, 0.977), (658, 0.941), (659, 0.879), (660, 0.816), (661, 0.773), (662, 0.754), (663, 0.76), (664, 0.783), (665, 0.81), (666, 0.836), (667, 0.861), (668, 0.886), (669, 0.911), (670, 0.934), (671, 0.95), (672, 0.959), (673, 0.96), (674, 0.959), (675, 0.958), (676, 0.955), (677, 0.944), (678, 0.895), (679, 0.744), (680, 0.477), (681, 0.23), (682, 0.08), (683, 0.026), (684, 0.004)]
responses['B5 - Red edge 1'] = [(695, 0.028), (696, 0.124), (697, 0.394), (698, 0.761), (699, 0.971), (700, 0.999), (701, 1.0), (702, 0.994), (703, 0.983), (704, 0.967), (705, 0.948), (706, 0.927), (707, 0.904), (708, 0.886), (709, 0.867), (710, 0.791), (711, 0.588), (712, 0.263), (713, 0.057), (714, 0.006)]
responses['B6 - Red edge 2'] = [(731, 0.002), (732, 0.055), (733, 0.258), (734, 0.647), (735, 0.892), (736, 0.902), (737, 0.915), (738, 0.941), (739, 0.963), (740, 0.975), (741, 0.977), (742, 0.987), (743, 1.0), (744, 0.989), (745, 0.972), (746, 0.901), (747, 0.607), (748, 0.205), (749, 0.027)]
responses['B7 - Red edge 3'] = [(770, 0.012), (771, 0.052), (772, 0.166), (773, 0.369), (774, 0.637), (775, 0.861), (776, 0.97), (777, 0.991), (778, 0.999), (779, 1.0), (780, 0.977), (781, 0.926), (782, 0.866), (783, 0.82), (784, 0.794), (785, 0.791), (786, 0.804), (787, 0.819), (788, 0.826), (789, 0.82), (790, 0.792), (791, 0.721), (792, 0.588), (793, 0.414), (794, 0.231), (795, 0.099), (796, 0.027), (797, 0.005)]
responses['B8 - NIR'] = [(774, 0.007), (775, 0.018), (776, 0.032), (777, 0.053), (778, 0.083), (779, 0.127), (780, 0.196), (781, 0.302), (782, 0.436), (783, 0.571), (784, 0.698), (785, 0.803), (786, 0.891), (787, 0.953), (788, 0.989), (789, 1.0), (790, 0.988), (791, 0.964), (792, 0.942), (793, 0.937), (794, 0.942), (795, 0.954), (796, 0.968), (797, 0.98), (798, 0.985), (799, 0.986), (800, 0.984), (801, 0.978), (802, 0.977), (803, 0.978), (804, 0.981), (805, 0.988), (806, 0.989), (807, 0.986), (808, 0.981), (809, 0.971), (810, 0.957), (811, 0.939), (812, 0.917), (813, 0.896), (814, 0.873), (815, 0.852), (816, 0.825), (817, 0.801), (818, 0.782), (819, 0.764), (820, 0.75), (821, 0.739), (822, 0.731), (823, 0.723), (824, 0.725), (825, 0.726), (826, 0.723), (827, 0.722), (828, 0.716), (829, 0.712), (830, 0.708), (831, 0.702), (832, 0.699), (833, 0.701), (834, 0.707), (835, 0.718), (836, 0.731), (837, 0.748), (838, 0.768), (839, 0.784), (840, 0.797), (841, 0.803), (842, 0.805), (843, 0.802), (844, 0.797), (845, 0.789), (846, 0.777), (847, 0.765), (848, 0.751), (849, 0.737), (850, 0.723), (851, 0.704), (852, 0.684), (853, 0.665), (854, 0.647), (855, 0.63), (856, 0.616), (857, 0.602), (858, 0.59), (859, 0.58), (860, 0.571), (861, 0.561), (862, 0.552), (863, 0.546), (864, 0.54), (865, 0.535), (866, 0.531), (867, 0.53), (868, 0.53), (869, 0.53), (870, 0.532), (871, 0.533), (872, 0.532), (873, 0.533), (874, 0.532), (875, 0.531), (876, 0.53), (877, 0.53), (878, 0.533), (879, 0.537), (880, 0.542), (881, 0.549), (882, 0.555), (883, 0.56), (884, 0.558), (885, 0.548), (886, 0.531), (887, 0.508), (888, 0.478), (889, 0.451), (890, 0.428), (891, 0.411), (892, 0.4), (893, 0.401), (894, 0.408), (895, 0.421), (896, 0.43), (897, 0.425), (898, 0.391), (899, 0.33), (900, 0.257), (901, 0.182), (902, 0.117), (903, 0.07), (904, 0.043), (905, 0.026), (906, 0.016), (907, 0.004)]
responses['B8A - Narrow NIR'] = [(847, 0.002), (848, 0.002), (849, 0.013), (850, 0.026), (851, 0.053), (852, 0.108), (853, 0.222), (854, 0.397), (855, 0.61), (856, 0.817), (857, 0.932), (858, 0.972), (859, 0.975), (860, 0.975), (861, 0.973), (862, 0.976), (863, 0.98), (864, 0.987), (865, 0.991), (866, 0.997), (867, 1.0), (868, 0.999), (869, 0.996), (870, 0.995), (871, 1.0), (872, 0.996), (873, 0.924), (874, 0.741), (875, 0.49), (876, 0.25), (877, 0.112), (878, 0.048), (879, 0.023), (880, 0.011), (881, 0.001)]
# responses['B9 - Water vapour'] = [(932, 0.017), (933, 0.061), (934, 0.174), (935, 0.389), (936, 0.665), (937, 0.875), (938, 0.937), (939, 0.968), (940, 0.989), (941, 0.995), (942, 1.0), (943, 0.978), (944, 0.981), (945, 0.992), (946, 0.988), (947, 0.994), (948, 0.983), (949, 0.978), (950, 0.95), (951, 0.953), (952, 0.922), (953, 0.856), (954, 0.71), (955, 0.464), (956, 0.215), (957, 0.065), (958, 0.016)]
# responses['B10 - Cirrus'] = [(1350, 0.001), (1351, 0.002), (1352, 0.004), (1353, 0.008), (1354, 0.019), (1355, 0.045), (1356, 0.102), (1357, 0.201), (1358, 0.342), (1359, 0.506), (1360, 0.662), (1361, 0.783), (1362, 0.861), (1363, 0.91), (1364, 0.942), (1365, 0.962), (1366, 0.974), (1367, 0.982), (1368, 0.988), (1369, 0.993), (1370, 0.996), (1371, 0.999), (1372, 1.0), (1373, 0.999), (1374, 0.996), (1375, 0.991), (1376, 0.985), (1377, 0.978), (1378, 0.97), (1379, 0.961), (1380, 0.949), (1381, 0.933), (1382, 0.915), (1383, 0.894), (1384, 0.869), (1385, 0.831), (1386, 0.765), (1387, 0.655), (1388, 0.508), (1389, 0.351), (1390, 0.219), (1391, 0.127), (1392, 0.068), (1393, 0.033), (1394, 0.014), (1395, 0.005), (1396, 0.002), (1397, 0.001)]
responses['B11 - SWIR-1'] = [(1551, 0.001), (1552, 0.002), (1553, 0.002), (1554, 0.004), (1555, 0.005), (1556, 0.008), (1557, 0.013), (1558, 0.019), (1559, 0.028), (1560, 0.04), (1561, 0.055), (1562, 0.075), (1563, 0.101), (1564, 0.135), (1565, 0.183), (1566, 0.247), (1567, 0.331), (1568, 0.43), (1569, 0.538), (1570, 0.647), (1571, 0.744), (1572, 0.815), (1573, 0.859), (1574, 0.88), (1575, 0.887), (1576, 0.889), (1577, 0.891), (1578, 0.898), (1579, 0.907), (1580, 0.917), (1581, 0.927), (1582, 0.935), (1583, 0.942), (1584, 0.948), (1585, 0.951), (1586, 0.954), (1587, 0.956), (1588, 0.958), (1589, 0.961), (1590, 0.963), (1591, 0.966), (1592, 0.968), (1593, 0.971), (1594, 0.973), (1595, 0.976), (1596, 0.979), (1597, 0.98), (1598, 0.981), (1599, 0.981), (1600, 0.981), (1601, 0.981), (1602, 0.981), (1603, 0.98), (1604, 0.981), (1605, 0.983), (1606, 0.985), (1607, 0.988), (1608, 0.99), (1609, 0.992), (1610, 0.993), (1611, 0.993), (1612, 0.99), (1613, 0.987), (1614, 0.984), (1615, 0.98), (1616, 0.976), (1617, 0.973), (1618, 0.97), (1619, 0.968), (1620, 0.966), (1621, 0.966), (1622, 0.966), (1623, 0.967), (1624, 0.97), (1625, 0.973), (1626, 0.979), (1627, 0.983), (1628, 0.988), (1629, 0.992), (1630, 0.995), (1631, 0.998), (1632, 0.999), (1633, 0.999), (1634, 0.999), (1635, 0.999), (1636, 0.999), (1637, 1.0), (1638, 1.0), (1639, 1.0), (1640, 1.0), (1641, 0.997), (1642, 0.992), (1643, 0.986), (1644, 0.979), (1645, 0.97), (1646, 0.961), (1647, 0.953), (1648, 0.947), (1649, 0.942), (1650, 0.939), (1651, 0.935), (1652, 0.928), (1653, 0.912), (1654, 0.881), (1655, 0.825), (1656, 0.743), (1657, 0.642), (1658, 0.534), (1659, 0.427), (1660, 0.324), (1661, 0.234), (1662, 0.164), (1663, 0.11), (1664, 0.072), (1665, 0.046), (1666, 0.029), (1667, 0.019), (1668, 0.013), (1669, 0.009), (1670, 0.007), (1671, 0.005), (1672, 0.003), (1673, 0.002), (1674, 0.002), (1675, 0.001), (1676, 0.001)]
responses['B12 - SWIR-2'] = [(2079, 0.001), (2080, 0.003), (2081, 0.004), (2082, 0.007), (2083, 0.008), (2084, 0.008), (2085, 0.009), (2086, 0.009), (2087, 0.01), (2088, 0.011), (2089, 0.012), (2090, 0.013), (2091, 0.015), (2092, 0.017), (2093, 0.02), (2094, 0.023), (2095, 0.028), (2096, 0.033), (2097, 0.04), (2098, 0.049), (2099, 0.06), (2100, 0.073), (2101, 0.091), (2102, 0.111), (2103, 0.137), (2104, 0.168), (2105, 0.203), (2106, 0.243), (2107, 0.285), (2108, 0.327), (2109, 0.368), (2110, 0.408), (2111, 0.445), (2112, 0.477), (2113, 0.503), (2114, 0.525), (2115, 0.543), (2116, 0.557), (2117, 0.569), (2118, 0.579), (2119, 0.589), (2120, 0.599), (2121, 0.61), (2122, 0.621), (2123, 0.634), (2124, 0.649), (2125, 0.664), (2126, 0.68), (2127, 0.696), (2128, 0.712), (2129, 0.727), (2130, 0.741), (2131, 0.757), (2132, 0.772), (2133, 0.786), (2134, 0.798), (2135, 0.81), (2136, 0.82), (2137, 0.829), (2138, 0.837), (2139, 0.844), (2140, 0.851), (2141, 0.853), (2142, 0.855), (2143, 0.856), (2144, 0.858), (2145, 0.86), (2146, 0.861), (2147, 0.863), (2148, 0.865), (2149, 0.867), (2150, 0.87), (2151, 0.874), (2152, 0.879), (2153, 0.882), (2154, 0.886), (2155, 0.889), (2156, 0.893), (2157, 0.897), (2158, 0.9), (2159, 0.903), (2160, 0.905), (2161, 0.906), (2162, 0.906), (2163, 0.906), (2164, 0.905), (2165, 0.905), (2166, 0.904), (2167, 0.903), (2168, 0.903), (2169, 0.902), (2170, 0.902), (2171, 0.903), (2172, 0.904), (2173, 0.905), (2174, 0.906), (2175, 0.908), (2176, 0.91), (2177, 0.913), (2178, 0.916), (2179, 0.918), (2180, 0.921), (2181, 0.924), (2182, 0.927), (2183, 0.93), (2184, 0.932), (2185, 0.934), (2186, 0.936), (2187, 0.937), (2188, 0.938), (2189, 0.938), (2190, 0.938), (2191, 0.94), (2192, 0.943), (2193, 0.943), (2194, 0.943), (2195, 0.942), (2196, 0.941), (2197, 0.938), (2198, 0.937), (2199, 0.935), (2200, 0.933), (2201, 0.927), (2202, 0.921), (2203, 0.915), (2204, 0.911), (2205, 0.908), (2206, 0.907), (2207, 0.908), (2208, 0.911), (2209, 0.916), (2210, 0.923), (2211, 0.921), (2212, 0.919), (2213, 0.919), (2214, 0.921), (2215, 0.925), (2216, 0.928), (2217, 0.932), (2218, 0.937), (2219, 0.941), (2220, 0.947), (2221, 0.951), (2222, 0.954), (2223, 0.957), (2224, 0.96), (2225, 0.963), (2226, 0.965), (2227, 0.966), (2228, 0.967), (2229, 0.966), (2230, 0.965), (2231, 0.965), (2232, 0.964), (2233, 0.962), (2234, 0.959), (2235, 0.957), (2236, 0.955), (2237, 0.954), (2238, 0.953), (2239, 0.952), (2240, 0.952), (2241, 0.952), (2242, 0.953), (2243, 0.954), (2244, 0.957), (2245, 0.961), (2246, 0.964), (2247, 0.968), (2248, 0.973), (2249, 0.977), (2250, 0.983), (2251, 0.987), (2252, 0.991), (2253, 0.994), (2254, 0.997), (2255, 0.999), (2256, 1.0), (2257, 1.0), (2258, 0.999), (2259, 0.997), (2260, 0.994), (2261, 0.99), (2262, 0.984), (2263, 0.976), (2264, 0.968), (2265, 0.958), (2266, 0.948), (2267, 0.938), (2268, 0.928), (2269, 0.917), (2270, 0.906), (2271, 0.894), (2272, 0.882), (2273, 0.869), (2274, 0.855), (2275, 0.841), (2276, 0.826), (2277, 0.81), (2278, 0.792), (2279, 0.772), (2280, 0.749), (2281, 0.72), (2282, 0.688), (2283, 0.651), (2284, 0.61), (2285, 0.566), (2286, 0.521), (2287, 0.475), (2288, 0.429), (2289, 0.386), (2290, 0.342), (2291, 0.301), (2292, 0.263), (2293, 0.228), (2294, 0.196), (2295, 0.168), (2296, 0.145), (2297, 0.125), (2298, 0.108), (2299, 0.094), (2300, 0.082), (2301, 0.072), (2302, 0.063), (2303, 0.055), (2304, 0.048), (2305, 0.043), (2306, 0.039), (2307, 0.035), (2308, 0.032), (2309, 0.03), (2310, 0.027), (2311, 0.026), (2312, 0.024), (2313, 0.022), (2314, 0.019), (2315, 0.016), (2316, 0.011), (2317, 0.007), (2318, 0.007), (2319, 0.005), (2320, 0.002)]

    Argument type:  string
    Acceptable values:
            - String value
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Spectral resampling (to spectral raster layer wavelength and FWHM)¶

Spectrally resample a spectral raster layer by applying spectral response function convolution, with spectral response function derived from wavelength and FWHM information stored inside a spectral raster layer.

Parameters

Spectral raster layer [raster]

A spectral raster layer to be resampled.

Spectral raster layer with wavelength and FWHM [raster]

A spectral raster layer with center wavelength and FWHM information defining the destination sensor.

Save spectral response function [boolean]

Whether to save the spectral response function library as *.srf.gpkg sidecar file.

Default: False

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:SpectralResamplingToSpectralRasterLayerWavelengthAndFwhm:

----------------
Arguments
----------------

raster: Spectral raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
responseRaster: Spectral raster layer with wavelength and FWHM
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
saveResponseFunction: Save spectral response function (optional)
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputResampledRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputResampledRaster: <outputRaster>
    Output raster layer

Transformation¶

Fit FactorAnalysis¶

Factor Analysis. A simple linear generative model with Gaussian latent variables. The observations are assumed to be caused by a linear transformation of lower dimensional latent factors and added Gaussian noise. Without loss of generality the factors are distributed according to a Gaussian with zero mean and unit covariance. The noise is also zero mean and has an arbitrary diagonal covariance matrix. If we would restrict the model further, by assuming that the Gaussian noise is even isotropic (all diagonal entries are the same) we would obtain ProbabilisticPCA. FactorAnalysis performs a maximum likelihood estimate of the so-called loading matrix, the transformation of the latent variables to the observed ones, using SVD based approach.

Parameters

Transformer [string]

Scikit-learn python code. See FactorAnalysis for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import FactorAnalysis

factorAnalysis = FactorAnalysis(n_components=3)
transformer = make_pipeline(StandardScaler(), factorAnalysis)

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitFactoranalysis:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import FactorAnalysis

factorAnalysis = FactorAnalysis(n_components=3)
transformer = make_pipeline(StandardScaler(), factorAnalysis)
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit FastICA¶

FastICA: a fast algorithm for Independent Component Analysis.

Parameters

Transformer [string]

Scikit-learn python code. See FastICA for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import FastICA

fastICA = FastICA(n_components=3)
transformer = make_pipeline(StandardScaler(), fastICA)

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitFastica:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import FastICA

fastICA = FastICA(n_components=3)
transformer = make_pipeline(StandardScaler(), fastICA)
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit FeatureAgglomeration¶

Agglomerate features. Recursively merges pair of clusters of features.

Parameters

Transformer [string]

Scikit-learn python code. See FeatureAgglomeration for information on different parameters.

Default:

from sklearn.cluster import FeatureAgglomeration

transformer = FeatureAgglomeration(n_clusters=3)

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitFeatureagglomeration:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.cluster import FeatureAgglomeration

transformer = FeatureAgglomeration(n_clusters=3)

    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit KernelPCA¶

Kernel Principal component analysis (KPCA). Non-linear dimensionality reduction through the use of kernels

Parameters

Transformer [string]

Scikit-learn python code. See PCA for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import KernelPCA

kernelPCA = KernelPCA(n_components=3, fit_inverse_transform=True)
transformer = make_pipeline(StandardScaler(), kernelPCA)

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitKernelpca:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import KernelPCA

kernelPCA = KernelPCA(n_components=3, fit_inverse_transform=True)
transformer = make_pipeline(StandardScaler(), kernelPCA)
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit MaxAbsScaler¶

Scale each feature by its maximum absolute value. This estimator scales and translates each feature individually such that the maximal absolute value of each feature in the training set will be 1.0.

Parameters

Transformer [string]

Scikit-learn python code. See MaxAbsScaler for information on different parameters.

Default:

from sklearn.preprocessing import MaxAbsScaler

transformer = MaxAbsScaler()

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitMaxabsscaler:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.preprocessing import MaxAbsScaler

transformer = MaxAbsScaler()
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit MinMaxScaler¶

Transform features by scaling each feature to a given range. This estimator scales and translates each feature individually such that it is in the given range on the training set, e.g. between zero and one.

Parameters

Transformer [string]

Scikit-learn python code. See MinMaxScaler for information on different parameters.

Default:

from sklearn.preprocessing import MinMaxScaler

transformer = MinMaxScaler(feature_range=(0, 1), clip=False)

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitMinmaxscaler:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.preprocessing import MinMaxScaler

transformer = MinMaxScaler(feature_range=(0, 1), clip=False)
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit Normalizer¶

Normalize samples individually to unit norm. Each sample (i.e. each row of the data matrix) with at least one non zero component is rescaled independently of other samples so that its norm (l1, l2 or inf) equals one.

Parameters

Transformer [string]

Scikit-learn python code. See Normalizer for information on different parameters.

Default:

from sklearn.preprocessing import Normalizer

transformer = Normalizer()

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitNormalizer:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.preprocessing import Normalizer

transformer = Normalizer()
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit PCA¶

Principal component analysis (PCA). Linear dimensionality reduction using Singular Value Decomposition of the data to project it to a lower dimensional space. The input data is centered but not scaled for each feature before applying the SVD.

Parameters

Transformer [string]

Scikit-learn python code. See PCA for information on different parameters.

Default:

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

pca = PCA(n_components=0.95)
transformer = make_pipeline(StandardScaler(), pca)

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitPca:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

pca = PCA(n_components=0.95)
transformer = make_pipeline(StandardScaler(), pca)
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit QuantileTransformer¶

Transform features using quantiles information. This method transforms the features to follow a uniform or a normal distribution. Therefore, for a given feature, this transformation tends to spread out the most frequent values. It also reduces the impact of (marginal) outliers: this is therefore a robust preprocessing scheme. The transformation is applied on each feature independently. First an estimate of the cumulative distribution function of a feature is used to map the original values to a uniform distribution. The obtained values are then mapped to the desired output distribution using the associated quantile function. Features values of new/unseen data that fall below or above the fitted range will be mapped to the bounds of the output distribution. Note that this transform is non-linear. It may distort linear correlations between variables measured at the same scale but renders variables measured at different scales more directly comparable.

Parameters

Transformer [string]

Scikit-learn python code. See QuantileTransformer for information on different parameters.

Default:

from sklearn.preprocessing import QuantileTransformer

transformer = QuantileTransformer()

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitQuantiletransformer:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.preprocessing import QuantileTransformer

transformer = QuantileTransformer()
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit RobustScaler¶

Scale features using statistics that are robust to outliers. This Scaler removes the median and scales the data according to the quantile range (defaults to IQR: Interquartile Range). The IQR is the range between the 1st quartile (25th quantile) and the 3rd quartile (75th quantile). Centering and scaling happen independently on each feature by computing the relevant statistics on the samples in the training set. Median and interquartile range are then stored to be used on later data using the transform method. Standardization of a dataset is a common requirement for many machine learning estimators. Typically this is done by removing the mean and scaling to unit variance. However, outliers can often influence the sample mean / variance in a negative way. In such cases, the median and the interquartile range often give better results.

Parameters

Transformer [string]

Scikit-learn python code. See RobustScaler for information on different parameters.

Default:

from sklearn.preprocessing import RobustScaler

transformer = RobustScaler(quantile_range=(25, 75))

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitRobustscaler:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.preprocessing import RobustScaler

transformer = RobustScaler(quantile_range=(25, 75))
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Fit StandardScaler¶

Standardize features by removing the mean and scaling to unit variance. The standard score of a sample x is calculated as: z = (x - u) / s where u is the mean of the training samples or zero if with_mean=False, and s is the standard deviation of the training samples or one if with_std=False. Centering and scaling happen independently on each feature by computing the relevant statistics on the samples in the training set. Mean and standard deviation are then stored to be used on later data using transform. Standardization of a dataset is a common requirement for many machine learning estimators: they might behave badly if the individual features do not more or less look like standard normally distributed data (e.g. Gaussian with 0 mean and unit variance). For instance many elements used in the objective function of a learning algorithm (such as the RBF kernel of Support Vector Machines or the L1 and L2 regularizers of linear models) assume that all features are centered around 0 and have variance in the same order. If a feature has a variance that is orders of magnitude larger that others, it might dominate the objective function and make the estimator unable to learn from other features correctly as expected.

Parameters

Transformer [string]

Scikit-learn python code. See StandardScaler for information on different parameters.

Default:

from sklearn.preprocessing import StandardScaler

transformer = StandardScaler()

Raster layer with features [raster]

Raster layer with feature data X used for fitting the transformer. Mutually exclusive with parameter: Training dataset

Sample size [number]

Approximate number of samples drawn from raster. If 0, whole raster will be used. Note that this is only a hint for limiting the number of rows and columns.

Default: 1000

Training dataset [file]

Training dataset pickle file used for fitting the transformer. Mutually exclusive with parameter: Raster layer with features

Outputs

Output transformer [fileDestination]: Destination pickle file.

Command-line usage

>qgis_process help enmapbox:FitStandardscaler:

----------------
Arguments
----------------

transformer: Transformer
    Default value:  from sklearn.preprocessing import StandardScaler

transformer = StandardScaler()
    Argument type:  string
    Acceptable values:
            - String value
featureRaster: Raster layer with features (optional)
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
sampleSize: Sample size (optional)
    Default value:  1000
    Argument type:  number
    Acceptable values:
            - A numeric value
dataset: Training dataset (optional)
    Argument type:  file
    Acceptable values:
            - Path to a file
outputTransformer: Output transformer
    Argument type:  fileDestination
    Acceptable values:
            - Path for new file

----------------
Outputs
----------------

outputTransformer: <outputFile>
    Output transformer

Inverse transform raster layer¶

Uses a fitted transformer to inverse transform a raster layer.

Parameters

Raster layer with features [raster]: The raster layer to be inverse transformed.
Transformer [file]: A fitted transformer.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:InverseTransformRasterLayer:

----------------
Arguments
----------------

raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
transformer: Transformer
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Transform raster layer¶

Uses a fitted transformer to transform a raster layer.

Parameters

Raster layer with features [raster]: The raster layer to be transformed. Transformer features and raster bands are matched by name.
Transformer [file]: A fitted transformer.

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:TransformRasterLayer:

----------------
Arguments
----------------

raster: Raster layer with features
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
transformer: Transformer
    Argument type:  file
    Acceptable values:
            - Path to a file
outputRaster: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRaster: <outputRaster>
    Output raster layer

Vector conversion¶

Rasterize categorized vector layer¶

Rasterize a categorized vector layer into a categorized raster layer. Output category names and colors are given by the source layer. Resampling is done via a two-step majority voting approach. First, the categorized raster layer is resampled at x10 finer resolution, and subsequently aggregated back to the target resolution using majority voting. This approach leads to pixel-wise class decisions that are accurate to the percent.

Parameters

Categorized vector layer [vector]

A categorized vector layer to be rasterized.

Grid [raster]

The target grid.

Minimum pixel coverage [number]

Exclude all pixel where (polygon) coverage is smaller than given threshold.

Default: 50

Majority voting [boolean]

Whether to use majority voting. Turn off to use simple nearest neighbour resampling, which is much faster, but may result in highly inaccurate class decisions.

Default: True

Outputs

Output categorized raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:RasterizeCategorizedVectorLayer:

----------------
Arguments
----------------

categorizedVector: Categorized vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
grid: Grid
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
coverage: Minimum pixel coverage
    Default value:  50
    Argument type:  number
    Acceptable values:
            - A numeric value
majorityVoting: Majority voting
    Default value:  true
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
outputRasterizedCategories: Output categorized raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRasterizedCategories: <outputRaster>
    Output categorized raster layer

Rasterize vector layer¶

Converts vector geometries (points, lines and polygons) into a raster grid.

Parameters

Vector layer [vector]

A vector layer to be rasterized.

Grid [raster]

The target grid.

Init value [number]

Pre-initialization value for the output raster layer.

Default: 0

Burn value [number]

Fixed value to burn into each pixel, which is touched (point, line) or where the center is covered (polygon) by a geometry.

Default: 1

Burn attribute [field]

Numeric vector field to use as burn values.

Burn feature ID [boolean]

Whether to use the feature ID as burn values. Initial value is set to -1. Data type is set to Int32.

Default: False

Add value [boolean]

Whether to add up existing values instead of replacing them.

Default: False

All touched [boolean]

Enables the ALL_TOUCHED rasterization option so that all pixels touched by lines or polygons will be updated, not just those on the line render path, or whose center point is within the polygon.

Default: False

Data type [enum]

Output data type.

Default: 5

Outputs

Output raster layer [rasterDestination]: Raster file destination.

Command-line usage

>qgis_process help enmapbox:RasterizeVectorLayer:

----------------
Arguments
----------------

vector: Vector layer
    Argument type:  vector
    Acceptable values:
            - Path to a vector layer
grid: Grid
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
initValue: Init value
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
burnValue: Burn value
    Default value:  1
    Argument type:  number
    Acceptable values:
            - A numeric value
burnAttribute: Burn attribute (optional)
    Argument type:  field
    Acceptable values:
            - The name of an existing field
            - ; delimited list of existing field names
burnFid: Burn feature ID
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
addValue: Add value
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
allTouched: All touched
    Default value:  false
    Argument type:  boolean
    Acceptable values:
            - 1 for true/yes
            - 0 for false/no
dataType: Data type
    Default value:  5
    Argument type:  enum
    Available values:
            - 0: Byte
            - 1: Int16
            - 2: UInt16
            - 3: UInt32
            - 4: Int32
            - 5: Float32
            - 6: Float64
    Acceptable values:
            - Number of selected option, e.g. '1'
            - Comma separated list of options, e.g. '1,3'
outputRasterizedVector: Output raster layer
    Argument type:  rasterDestination
    Acceptable values:
            - Path for new raster layer

----------------
Outputs
----------------

outputRasterizedVector: <outputRaster>
    Output raster layer

Vector creation¶

Random points from categorized raster layer¶

This algorithm creates a new point layer with a given number of random points, all of them within the categories of the given categorized raster layer.

Parameters

Categorized raster layer [raster]

A categorized raster layer to draw points from.

Number of points per category [string]

Number of points to draw from each category. Set a single value N to draw N points for each category. Set a list of values N1, N2, … Ni, … to draw Ni points for category i.

Minimum distance between points (in meters) [number]

A minimum (Euclidean) distance between points can be specified.

Default: 0

Minimum distance between points inside category (in meters) [number]

A minimum (Euclidean) distance between points in a category can be specified.

Default: 0

Random seed [number]

The seed for the random generator can be provided.

Outputs

Output point layer [vectorDestination]: Vector file destination.

Command-line usage

>qgis_process help enmapbox:RandomPointsFromCategorizedRasterLayer:

----------------
Arguments
----------------

stratification: Categorized raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
n: Number of points per category
    Argument type:  string
    Acceptable values:
            - String value
distanceGlobal: Minimum distance between points (in meters)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
distanceStatum: Minimum distance between points inside category (in meters)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
seed: Random seed (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
outputPoints: Output point layer
    Argument type:  vectorDestination
    Acceptable values:
            - Path for new vector layer

----------------
Outputs
----------------

outputPoints: <outputVector>
    Output point layer

Random points from mask raster layer¶

This algorithm creates a new point layer with a given number of random points, all of them in the area where the given mask evaluates to true.

Parameters

Mask raster layer [raster]

A mask raster layer to draw locations from.

Number of points [number]

Number of points to be drawn.

Minimum distance between points (in meters) [number]

A minimum distance between points can be specified. A point will not be added if there is an already generated point within this (Euclidean) distance from the generated location.

Default: 0

Random seed [number]

The seed for the random generator can be provided.

Outputs

Output point layer [vectorDestination]: Vector file destination.

Command-line usage

>qgis_process help enmapbox:RandomPointsFromMaskRasterLayer:

----------------
Arguments
----------------

mask: Mask raster layer
    Argument type:  raster
    Acceptable values:
            - Path to a raster layer
n: Number of points
    Argument type:  number
    Acceptable values:
            - A numeric value
distance: Minimum distance between points (in meters)
    Default value:  0
    Argument type:  number
    Acceptable values:
            - A numeric value
seed: Random seed (optional)
    Argument type:  number
    Acceptable values:
            - A numeric value
outputPoints: Output point layer
    Argument type:  vectorDestination
    Acceptable values:
            - Path for new vector layer

----------------
Outputs
----------------

outputPoints: <outputVector>
    Output point layer

Test dataset¶

Note

For opening the test dataset go to the menubar Project ‣ Load Example Data

If you try to open the test dataset for the first time, you will be asked to download the data from the repository:

After you downloaded the dataset, you can also use the processing algorithm Open Test Maps (in Auxillary) to open the dataset.

EnMAP (30m; 177 bands):

File name: enmap_berlin.bsq

Simulated EnMAP data (based on 3.6m HyMap imagery) acquired in August 2009 over south eastern part of Berlin. It has a spectral resolution of 177 bands and a spatial resolution of 30m.

HyMap (3.6m; Blue, Green, Red bands)

File name: hires_berlin.bsq

HyMap image acquired in August 2009 over south eastern part of Berlin. This dataset was reduced to 3 bands for true color display. The spatial resolution is 3.6m.

LandCover Vector Layer (Polygon):

File name: landcover_berlin_polygon.gpkg

Polygon vector geopackage containing land cover information on three classification levels. Derived from very high resolution aerial imagery and cadastral datasets.

Level 1 classes: Impervious, Vegetation, Soil, Water

Level 2 classes: Impervious, Low Vegetation, Soil, Tree, Water

Level 3 classes: Roof, Pavement, Low Vegetation, Soil, Tree, Water

LandCover Vector Layer (Point):

File name: landcover_berlin_point.shp

Point vector geopackage containing land cover information on two classification levels.

Level 1 classes: Impervious, Vegetation, Soil, Water

Level 2 classes: Impervious, Low Vegetation, Soil, Tree, Water

Spectral Library:

File name: library_berlin.sli

Spectral library with 75 spectra (material level, level 2 and level 3 class information)

library_berlin.sli opened in the EnMAP-Box Spectral Library Window

Application Tutorials¶

Regression-based unmixing of urban land cover¶

Authors: Akpona Okujeni, Sam Cooper, Patrick Hostert, Clemens Jaenicke, Benjamin Jakimow, Andreas Rabe, Fabian Thiel & Sebastian van der Linden

Publication date: 05/02/2019

Latest update: 19/03/2020

Introduction¶

1. Background¶

This tutorial is part of the HYPERedu online learning platform, an education initiative within the EnMAP mission hosted on EO College. HYPERedu provides annotated slide collections and hands-on tutorials using the open-source EnMAP-Box software, targeting basic principles, methods as well as applications of imaging spectroscopy.

Annotated slide collections for the tutorial Regression-based unmixing of urban land cover and a software description unit for the EnMAP-Box are provided here:

2. Content¶

Land cover fraction mapping based on unmixing is well suited to describe the composition of surface types in heterogeneous environments. Especially when using coarser spatial resolution satellite data with a high share of mixed pixels, fraction mapping is more useful than a discrete classification. This, for example, applies to the use of 30 m resolution imagery from the forthcoming spaceborne imaging spectrometer mission EnMAP for urban mapping.

This tutorial focuses on regression-based unmixing of urban land cover using synthetically mixed training data from spectral libraries. Hyperspectral images from the airborne HyMap and the spaceborne EnMAP sensor (here simulated from HyMap), a corresponding spectral library, and reference land cover information are used for different exercises within this tutorial. These aim at providing both a theoretical background related to challenges in urban mapping and a hands-on training for working with the EnMAP-Box.

3. Requirements¶

This tutorial requires at least version 3.6 of the EnMAP-Box 3. There might be some minor changes for higher versions (e.g., changed menu labels, added parameter options, etc.).

4. Further Reading¶

We recommend [1] for a comprehensive overview on imaging spectroscopy of urban environments and [2] & [3] for detailed introductions into the regression-based unmixing approach using synthetically mixed training data from spectral libraries.

[1]	van der Linden, et al. (2018). Imaging Spectroscopy of Urban Environments. Surveys in Geophysics, 1–18.

[2]	Okujeni, A., et al. (2013). Support vector regression and synthetically mixed training data for quantifying urban land cover. Remote Sensing of Environment, 137, 184-197

[3]	Okujeni, A., et al. (2017). Ensemble learning from synthetically mixed training data for quantifying urban land cover with support vector regression. IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, 10, 1640-1650

4. Data¶

You can download the data here: https://box.hu-berlin.de/f/3c3f7b76d91b4bd2a688/?dl=1

The tutorial dataset contains an EnMAP-image (simulation) covering an area along the urban gradient of Berlin, Germany, a second hyperspectral image at higher spatial resolution (HyMap, 3.6 m), a spectral library and detailed land cover reference information.

Data type	Filename	Description
Raster	`hymap_berlin.bsq`	Airborne hyperspectral data from the HyMap sensor with a spatial resolution of 3.6m, 111 bands and 346x3200 pixels (ENVI Standard Band Sequential `bsq`)
Raster	`enmap_berlin.bsq`	Spaceborne hyperspectral data from the EnMAP sensor (here simulated from HyMAP) with a spatial resolution of 30m, 177 bands and 220x400 pixels (ENVI Standard Band Sequential `bsq`)
Spectral library	`library_berlin.sli`	Urban spectral library with 75 pure surface materials categorized in a hierarchical class scheme. The Library was developed from the HyMap image and spectrally resampled to the EnMAP sensor (ENVI spectral library `sli` with metadata extensions `csv` & `json`)
Vector	`landcover_berlin.shp`	Detailed land cover reference information categorized in a hierarchical class scheme (ESRI Shapefile `shp` with QGIS layer style file `qml` and metadata extension `json`)

The tutorial dataset is a subset extracted from the Berlin-Urban-Gradient dataset [4]. Please cite the dataset as follows:

[4]	Okujeni, Akpona; van der Linden, Sebastian; Hostert, Patrick (2016): Berlin-Urban-Gradient dataset 2009 - An EnMAP Preparatory Flight Campaign (Datasets). V. 1.2. GFZ Data Services. http://doi.org/10.5880/enmap.2016.008

Exercise A: Urban land cover¶

Description

Airborne imaging spectroscopy data is well suited for urban mapping. The high spectral and spatial resolution enhances the separability of surface types and preserves the spatial detail of many urban features. This exercise…

provides an insight into how urban areas are depicted by airborne hyperspectral images and introduces a hierarchical classification scheme commonly adopted for urban mapping
introduces basic functionalities of the EnMAP-Box. You will get to know the graphical user interface, and you will learn how to load data, visualize raster and vector data, and use the basic navigation tools

Duration: 15 min

1. Start the EnMAP-Box¶

Start QGIS and click the icon in the toolbar to open the EnMAP-Box. The GUI of the EnMAP-Box consists of a Menu and a Toolbar, panels for Data Sources and Data Views, and the QGIS Processing Toolbox including the EnMAP-Box geoalgorithms.

2. Load data¶

The EnMAP-Box offers simple drag & drop capabilities to load data from an external explorer. Drag the following datasets from your explorer into the Data Sources panel:
- Raster: hymap_berlin.bsq, enmap_berlin.bsq
- Vector: landcover_berlin.shp
- Spectral library: library_berlin.sli

3. Visualize raster and vector data¶

The EnMAP-Box offers Map Windows (Map #) for visualizing raster and vector data. Click the icon and drag the following datasets from the Data Sources panel into Map #1:
- hymap_berlin.bsq
- landcover_berlin.shp
Map #1 now appears in the Data Views panel, where the visibility, order and properties of datasets can be modified. Unfold Map #1:
- To change the order of stacked layers, drag one layer on top or below another one. Arrange the layer stack so that landcover_berlin.shp is displayed on top of hymap_berlin.bsq.
- To assign a multibandcolor RGB combination to a raster image, right click on the dataset, select Layer Properties and navigate to Band selection. You can now select predefined composites (RGB, nIR, swIR), or manually select your bands using the slider or dropdown lists. Display hymap_berlin.bsq as true color composite, by selecting R-G-B.
- You can specify things like contrast enhancement and data stretch under Layer properties ‣ Symbology.
- The symbology of landcover_berlin.shp is predefined by a QGIS layer style file (.qml). To change this symbology, right click on the vector layer, select Layer Properties and navigate to Symbology in the LayerProperties window. You can now change the symbology in accordance to the QGIS functionality. Use the Column and Classify options to explore the information content of the attribute table landcover_berlin.shp.

4. Basic navigation tools¶

The Toolbar offers common navigation tools for exploring visualized datasets. Make yourself familiar with the following navigation tools: Note that the mouse wheel can be used alternatively for zooming (roll mouse wheel forward/backward) and panning (press and hold mouse wheel).
Make yourself familiar with the crosshair functionality. To show/hide the crosshair, to change the style, or to display the pixel cell of a selected layer, right click within MAP #1 and select Crosshair.

Learning activities:

A1: Visually explore the airborne hyperspectral image (hymap_berlin.bsq). What major land cover types do you observe along Berlin’s urban-gradient?

click to expand...

Major land cover types: buildings/roofs, paved areas (e.g., streets, backyards), trees (e.g., park trees, street trees), grass (e.g., lawns, soccer field), crops (on agricultural sites), bare soil (e.g., agricultural sites, construction sites), and water (e.g., lakes, swimming pools).
A2: Explore the land cover reference data (landcover_berlin.shp) and draw a flowchart of the hierarchical classification scheme stored in the attribute table.

click to expand...

Exercise B: Spectral mixing¶

Description

Forthcoming spaceborne imaging spectroscopy missions create new opportunities for global urban mapping. However, the step to satellite observations brings with it coarser spatial resolution, resulting in a loss in spatial detail and an increase in the number of mixed pixels. This exercise…

provides an insight into how urban areas will be depicted by spaceborne hyperspectral images and illustrates challenges related to spectral mixing when using such data for urban mapping
introduces additional basic functionalities of the EnMAP-Box. You will learn how to work with multiple map views, and how to visualize image spectra using Spectral Library Windows

Duration: 15 min

1. Multiple map views¶

Close Map #1 from the previous exercise by using the icon on the blue Map #1 title bar.
The EnMAP-Box enables users to work with multiple Map Windows, which can be flexibly organized and geospatially linked. Open two new Map Windows. For horizontal arrangement, click and hold on the blue Map #2 title bar and drag it to the right edge of Map #1. A transparent blue rectangle appears indicating the docking position once you stop holding the mouse button.

Display hymap_berlin.bsq and enmap_berlin.bsq as RGB composite of your choice in Map #1 and Map #2, respectively.
For geospatial linking, click on View in the Menu and select Set Map Linking. In the Map Linking window, select the ^{Link Map Scale and Center} option and close the dialog.

2. Visualize image spectra¶

The EnMAP-Box offers Spectral Library Windows (SpectralLibrary #) for visualizing spectra and handling their metadata. To visualize image spectra, activate the Identify tool together with the Identify raster profiles option. Click on an image pixel. SpectralLibrary #1 opens automatically displaying the respective pixel spectrum (green line). The plotted spectrum always refers to the top-most raster layer of the respective Map Window you click on (unless you change this in the Spectral Profile Sources panel).
Make yourself familiar with the following tools in the Spectral Library #1 toolbar:
- The icon adds a plotted spectrum to a collection. Each collected spectrum (white line) gets an entry in the attribute table with a predefined name (filename and id).
- By clicking next to the icon you can activate the ^{Add Profiles automatically} mode, which will automatically add spectra to the collection when clicking on image pixels.
- The icon switches on the editing mode. You can now edit the attribute table (e.g. edit the name of a spectrum), add or delete colums using the icons, etc.
- You can delete selected spectra in editing mode using the icon (hold Ctrl or Shift to select multiple rows).
- The icon saves a spectrum or a collection of spectra as a spectral library. Further information on spectral libraries and library formats will follow in Exercise C.

Learning activities

B1: Visually compare the airborne and spaceborne hyperspectral images (hymap_berlin.bsq, enmap_berlin.bsq). How much of the spatial detail is lost when stepping from airborne to spaceborne scale?

click to expand...

The spatial detail of most urban features (e.g., buildings, streets, trees along streets or in private gardens) disappears due to spatial aggregation at spaceborne scale. However, large homogenous urban features (e.g., waterbodies, sport grounds, tree stand in parks) remain apparent.
B2: Provide an average estimate on the percentage of pixels covered by 1, 2, 3, and 4 or more land cover classes for both images. Use level 3 of the classification scheme for your estimate. You may use the reference land cover information (landcover_berlin.shp) for orientation.

click to expand...
B3: Compare pairs of spectra from the airborne and spaceborne hyperspectral images (hymap_berlin.bsq, enmap_berlin.bsq). For which urban surface materials is it still possible to collect pure spectra at spaceborne scale, and for which not?

click to expand...

Pure spectra can be collected for homogenous urban surfaces with a patch size of ~100 x 100 m and larger (e.g., roofing material spectra for large industrial buildings, ground paving material spectra for yards of industrial complexes, grass spectra on lawns or soccer fields, tree spectra in dense stands, water spectra from water bodies). Pure spectra cannot be collected for urban surfaces with a patch size below ~100 x 100 m (i.e., for most roofing materials, street asphalt, street trees).

Exercise C: Urban spectral libraries¶

Description

Urban spectral libraries are collections of pure surface spectra (endmembers) representing the spectral diversity and variability of urban land cover types at high spectral resolution. Library spectra are commonly based on laboratory, field, or image data, and are well suited for library-based mapping approaches such as unmixing. This exercise…

provides an insight into the design of urban spectral libraries and illustrates challenges related to within-class variability and between-class similarity during urban mapping
targets the handling of spectral libraries in the EnMAP-Box. You will get to know the spectral library format used in the EnMAP-Box, and learn how to load and visualize external urban spectral libraries and associated metadata

Duration: 15 min

1. Labeled spectral libraries¶

The EnMAP-Box makes use of labeled spectral libraries, which extend the standard ENVI Spectral Library (SLI) and associated header (HDR) by additional attribute information, e.g., class labels, class colors, description, etc. This information is stored in an ASCII Comma Separated Value (CSV) file and in a JavaScript Object Notation (JSON) file. The CSV file includes an attribute table for each library spectrum (the column ‘spectra names’ links the CSV with the HDR). The JSON file contains the unique attributes of given attribute columns.
Open the library_berlin.hdr, library_berlin.csv, and library_berlin.json files with a text editor and get familiar with the spectral library format used in the EnMAP-Box and the hierarchical classification scheme stored in the attribute information.

2. Spectral library handling¶

Close all Map and Spectral Library Windows from the previous exercise.
To load the urban spectral library, click on the icon to open a new Spectral Library Window and drag library_berlin.sli from the Data Sources panel into SpectralLibrary #1. Get familiar with the representation of the spectral library and the attribute table.
By default, only 64 spectra will be displayed at once in the plot window. To change this number, right-click in the plot area, go to Others ‣ Max. Profiles and enter a higher number, e.g. 75 (total number of spectra in library_berlin.sli)
To display a subset of spectra in a separate Library Window…
- Select the spectra of interest by clicking on their corresponding row numbers (use Ctrl or Shift to select multiple rows). To select spectra with the same attributes, prior sorting of the attribute table by clicking on the corresponding column header is recommended. You can also select the spectra directly in the plot window.
- Click on the icon in the toolbar (or Ctrl+C) to copy the selected spectra to clipboard.
- Open a second Spectra Library Window. Similar to the work with multiple Map Windows, Spectral Library Windows can be arranged according to the user needs.
- Switch on the editing mode in the SpectralLibrary #2 toolbar and use the icon (or Ctrl+V) to paste the copied spectra into SpectralLibrary #2. Switch off the editing mode.

_images/07_spectrallibraryhandling_new.png

Learning activities

C1: Load the urban spectral library (library_berlin.sli) and display each level 3 class in a separate Spectral Library Window. How diverse is each class with regard to within-class variability?

click to expand...

The roof class shows a very high within-class variability. The classes pavement, low vegetation, and tree show a high within-class variability. The classes soil and water show a rather low within-class variability.
C2: List classes which show a high between-class similarity and provide an explanation.

click to expand...

The classes roof and pavement are highly similar with regard to the following surface materials: bitumen vs. asphalt, red clay tiles vs. red sand, grey roofing materials (most likely concrete) vs concrete. The classes roof and soil are highly similar with regard to the following surface materials: concrete vs. bare soil, red clay tiles vs. bare soil. The classes low vegetation and tree are highly similar regarding the following vegetation types: darker grass types (clover, agricultural grassland) vs. brighter trees.

Exercise D: Regression-based unmixing¶

Description

To utilize data from forthcoming spaceborne imaging spectrometer missions for mapping the land cover composition of urban areas, unmixing is more useful than a discrete classification. This exercise…

introduces a regression-based unmixing approach for land cover fraction mapping. The approach successfully copes with spectral diversity, variably and mixing, and makes use of synthetic mixtures from spectral libraries for regression model training
demonstrates the work with the ‘Regression-based unmixing (synthMix)’ application of the EnMAP-Box

Duration: 30 min

1. Introduction¶

The training of regression models with synthetically mixed data from spectral libraries for land cover fraction mapping is implemented as the Regression-based unmixing (synthMix) application in the EnMAP-Box 3. The workflow of the unmixing approach comprises the following steps:

Step 1: An endmember library with associated class labels is used to randomly create a synthetically mixed dataset, i.e., pairs of mixed spectra and mixing fractions, for each class.

Step 2: The synthetically mixed dataset is used to train a regression model for each class.

Step 3: The regression model is applied to an image to derive a fraction map for each class.

The approach can be embedded into an ensemble framework, i.e., steps 1-3 are iterated n-times and the final fraction map for each class is created by combining the intermediate maps. The ensemble modeling allows the inclusion of a multitude of different types of synthetic mixtures into the unmixing process while keeping the training sample size low.

2. Start the application¶

Click on Applications in the Menu and select Regression-based unmixing (synthMix). The graphical widget of the Regression-based unmixing (synthMix) consists of sections for specifying Inputs, for target Class Selection, for setting Mixing Parameters, for selecting the Regression Algorithm, and for specifying the Outputs.

3. Inputs and class selection¶

The specification of input data is the start of the unmixing process. This includes an Endmember Library with associated class labels (see Exercise 3), where the Class Attribute drop menu specifies the attribute column associated with the class labels, and the Spectral Image to unmix.
Select / specify the following inputs:
- Endmember Library: library_berlin.sli
- Class Attribute: level_1
- Spectral Image: enmap_berlin.bsq
The selection of the classes of interest, i.e., Target Classes, is the next step of the unmixing process. Synthetically mixed data, regression models, and fraction maps are only created for target classes. Spectra of excluded classes are still used as background signatures in the synthetic mixing process.
Select the following Target Classes: impervious, vegetation, soil, water (all level 1 classes)

4. Mixing parameters¶

The mixing parameters steer the process of generating the synthetically mixed data from the endmember library. The Number of Synthetic Mixtures per Class specifies the total number of mixtures per class to be created. The check option to Include Original Library Endmembers allows to append the endmember library to the synthetically mixed data, with fractions of either 0% or 100% of a respective target class.

The synthetic mixing process itself is randomized. That is, to generate a synthetic mixture…
- … a mixing complexity is randomly assigned. The mixing complexity defines the number of endmembers contributing to a mixture (e.g., 2EM, 3EM). The random selection is steered by user-defined Mixing Complexity Probabilities (e.g., 2EM=0.6, 3EM=0.4 means that there is a 60% likelihood that the mixture is made up of two endmembers and a 40% likelihood that the mixture is made up of three endmembers). The implementation allows the definition of probabilities for 2EM, 3EM and 4EM. Note that probabilities must sum up to 1.
- … endmembers are randomly drawn from the library. The number of endmembers is based on the previously assigned mixing complexity. The first endmember is always drawn from the target class. The following endmembers are drawn based on Class Probabilities, which are either proportional (class proportions within the library) or equalized (all classes with the same likelihood). The Allow Within-Class Mixtures check option allows the user to decide whether multiple endmembers of the same class can be drawn to create a mixture.
- … random mixing fractions between 0 and 1 (0-100%) are randomly assigned to the previously drawn endmembers. The total sum of fractions is always 1 (100%).
- … endmembers are linearly mixed based on the mixing fractions to create the mixture.

Select the following mixing parameters:
- Number of Synthetic Mixtures per Class: 1000 (default)
- Include Original Library Endmembers: Yes (default)
- Mixing Complexity Probabilities: 2EM= 0.4, 3EM= 0.4, 4EM= 0.2
- Allow Within-Class Mixtures: Yes (default)
- Class Probabilities: Proportional (default)

5. Regression Algorithm¶

The selection of the regression algorithm and the setting up of the ensemble are the next steps in the unmixing process. The EnMAP-Box makes use of the scikit-learn library (see https://scikit-learn.org/stable/index.html) to implement several state-of-the-art algorithms offered in the Regressor drop menu. Note that the different algorithms lead to varying accuracies and processing times, particularly when embedding the unmixing process into an ensemble. To do so, activate Use Ensemble and set the Ensemble Size.

Select the following regression settings:
- Regressor: RandomForestRegression (default, due to the low processing time)
- Use Ensemble: Yes (default), Ensemble Size: 3 (default)

6. Outputs¶

The specification of the outputs is the final step in the unmixing process. By default, the final fraction map is the only output:
- Folder: Specifies the output folder where results are saved.
- Name: Specifies the base name of the final fraction map. We add the suffix ‘_mean’ to this file as the default ensemble decision fusion is based on averaging.
The advanced options allow user to save additional files created during the unmixing process, and to derive additional maps from the final fraction map.
- Decision Fusion (Ensemble): Selection of different statistics to evaluate the ensemble output. The following statistics are implemented: mean (default, suffix ‘_mean’), median (suffix ‘_median’), inter quartile range (suffix ‘_iqr’), and standard deviation (suffix ‘_std’).
- Save: Check to save Training Samples, Predictions, and Models. These outputs will be stored for each class and with a suffix ‘_run’ for each ensemble iteration in separate subfolders.
- Create Class Fraction RGB: Check to create a RGB class representation of the final fraction map. The RGB color of a specific pixel is the weighted mean value of the original class colors, where the weights are given by the corresponding class fractions.
- Derive Classification from Fraction Map: Check to derive a discrete classification map from the final fraction map. The winner class per pixel corresponds to the maximum class fraction.
Specify the following outputs (and skip the advanced options):
- Folder: path to your working folder
- Name: fraction_level1_estimation.bsq

7. Run the application¶

Click on the button to run the application. The outputs appear in the Data Sources panel.

8. Visualize the urban land cover fraction map¶

Display the newly created fraction_level1_estimation.bsq. The file consists of 4 bands, where each band represents a fraction map of the defined target classes. Display the fraction map in a useful render style and appropriate contrast stretch:
- e.g., as multibandcolor RGB composite of three target classes in a single Map Window. For stretching fraction maps to the full range of possible fraction, set Min = 0 and Max = 1.
- e.g., as singlegray image per target class in multiple Map Windows. For stretching fraction maps to the full range of possible fraction, set Min = 0 and Max = 1.
Visually explore your fraction map. You may open enmap_berlin.bsq in a separate Map Window for comparison. You may use the Identify tool together with the Identify cursor location values option to display fraction values of pixels.

Learning activities

D1: Visually explore the fraction map (fraction_level1_estimation.bsq). How are level 1 land cover distributed across the urban gradient. Are the fraction values physically plausible?

click to expand...

High impervious fractions can be observed in the city center. A general increase in vegetation cover and decrease in impervious cover is observed when moving towards suburban areas. Soil is only abundant on single patches, e.g., along rail tracks or on construction sites. Fractions for each class are in the physically meaningful range between 0 and 1. The sum of fractions per pixel over all classes is, however, often larger than 1.
D2: Do you observe an over- or underestimation of fractions for specific land cover types indicating errors in map?

click to expand...

Soil fractions are overestimated by around 20%, particularly for areas where red clay tiles / bitumen / asphalt mixtures are apparent but no soil surfaces. Water fractions are overestimated by around 20% throughout the city on all impervious surfaces.

Exercise E: Validation of fraction maps¶

Description

Validation of fraction maps is commonly conducted by comparison of estimated and reference fractions using scatterplots and statistical measures (e.g., mean absolute error, root mean squared error, R², slope and intercept of a linear fitted regression model). This exercise……

illustrates the validation procedure for fraction maps
introduces EnMAP-Box geoalgorithms for producing reference fractions from high resolution land cover information and for statistical accuracy assessment of fraction maps.

Duration: 15 min

1. Create reference fraction map¶

A reference fraction map is created by rasterizing available reference land cover information to the pixel grid of the estimated fraction map. To obtain reasonable fractions, the reference land cover information needs to be at a significantly higher spatial resolution than the pixel grid. To create reference fractions, use the following processing algorithm Create Raster ‣ Fraction from Vector.
Enter the following data / parameters (use the tool tips for their description):
- Pixel Grid: fraction_level1_estimation.bsq
- Vector: berlin_landcover.shp
- Class id attribute: level_1_id
- Minimal overall coverage: 0.95
- Oversampling factor: 5
- Output fraction: …path to your working folder…/fraction_level1_reference.bsq
Run the process.

2. Statistical validation of fraction maps¶

The Regression Performance algorithm in the Accuracy Assessment tools of the EnMAP-Box geoalgorithms implements the accuracy assessment for quantitative data. Scatterplots and statistical measures are reported in an HTML report. Run the Regression Performance algorithm with the following inputs:
- Prediction: fraction_level1_estimation.bsq
- Reference: berlin_level1_reference.bsq
Make yourself familiar with the HTML report.

Learning activities

E1: Visually compare your estimated fraction map (fraction_level1_estimation.bsq) with the reference fraction map (berlin_level1_reference.bsq). Do both maps show a good agreement in terms of spatial patterns or are there areas with large differences?
E2: Discuss the accuracy of your fraction map. What are the accuracies for the different classes and which classes show striking errors like underestimation or overestimations of fractions?

Additional Exercises¶

Additional learning activities

AE1: Repeat Exercises D & E using the two other class schemes (level 2, level 3) stored in the spectral library metadata and the land cover reference information. How do the accuracies vary and where are the limitations in mapping the more detailed class levels?
AE2: Explore the effects of changing the mixing parameters on the mapping accuracy of the level 2 classes. For more direct comparison, we recommend to alter only one parameter at a time. We further recommend to use the Random Forest Regression due to the low processing time. For example, …
- change the Number of Synthetic Mixtures per Class: e.g. 10 vs. 1000 vs. 2000
- do not Include Original Library Endmembers
- change the Mixing Complexity Probabilities: e.g. only 2EM vs. only 3EM vs. only 4EM
- change the Ensemble Size: e.g. 1 vs. 10 vs. 20
AE3: Compare the performance of the different regression algorithms offered in the EnMAP-Box. Please note that the other regressors have significantly longer processing times.

Regression-based mapping of forest aboveground biomass¶

Authors: Sam Cooper, Akpona Okujeni, Patrick Hostert, Clemens Jaenicke, Benjamin Jakimow, Andreas Rabe, Fabian Thiel & Sebastian van der Linden

Publication date: 03/07/2020

Last update: 02/08/2022

Introduction¶

1. Background¶

This tutorial is part of the HYPERedu online learning platform, an education initiative within the EnMAP mission hosted on EO College. HYPERedu provides annotated slide collections and hands-on tutorials using the open-source EnMAP-Box software, targeting basic principles, methods as well as applications of imaging spectroscopy.

Annotated slide collections for the tutorial Regression-based mapping of forest aboveground biomass and a software description unit for the EnMAP-Box are provided here:

2. Content¶

Forest aboveground biomass (AGB) is a measure of the living and dead plant material in a given area. As such, it is often used for forest management, assessing fire potential, and is an important metric used in modelling carbon and nutrient cycles. AGB can be directly measured at a plot level by harvesting and weighing vegetation, but this is both an expensive and highly invasive process. Through the use of statistical modelling and remotely sensed imagery, AGB can be mapped across broad, spatially continuous areas using only a small number of directly measured reference plots. This tutorial focuses on regression-based modeling of forest AGB using the EnMAP-Box. A hyperspectral image mosaic from the EnMAP sensor (here simulated from AVIRIS imagery) and a corresponding vector dataset containing plot-based AGB references are used for this tutorial. The aim is to provide an introduction into the functionality of the EnMAP-Box, as well as hands-on training for implementing regression-based mapping.

3. Requirements¶

This tutorial requires at least version 3.10 of the EnMAP-Box 3. There might be some minor changes for higher versions (e.g., changed menu labels, added parameter options, etc.).

4. Further reading¶

We recommend [1] and [2] for a comprehensive overview of imaging spectroscopy of terrestrial ecosystems, [3] for an overview of remote sensing of forest AGB and [4] for a companion study using the same data.

[1]	Foerster, S., Guanter, L., Lopez, T., Moreno, J., Rast, M., Schaepman, M.E. (2019) Exploring the Earth System with Imaging Spectroscopy. Springer International Publishing

[2]	Thenkabail, P. S., & Lyon, J. G. (2016). Hyperspectral remote sensing of vegetation. CRC press.

[3]	Lu, D., Chen, Q., Wang, G., Liu, L., Li, G., & Moran, E. (2016). A survey of remote sensing-based aboveground biomass estimation methods in forest ecosystems. International Journal of Digital Earth, 9(1), 63-105.

[4]	Cooper, S., Okujeni, A., Pflugmacher, D., van der Linden, S., & Hostert, P. (2021). Combining simulated hyperspectral EnMAP and Landsat time series for forest aboveground biomass mapping. International Journal of Applied Earth Observation and Geoinformation, 98.

5. Data¶

You can download the data for this exercise here: https://box.hu-berlin.de/f/d73fa3ba95c143388832/?dl=1

The tutorial data contains a simulated hyperspectral EnMAP image, plot-based AGB references as well as a land cover map for a small study area located in Sonoma County, California, USA. The simulated EnMAP image is a subset extracted from the “2013 Simulated EnMAP Mosaics for the San Francisco Bay Area, USA” dataset [5]. AGB reference data was sampled from an existing LiDAR derived AGB map [6]. The land cover map was taken from the 2011 National Landcover Database (NLCD) [7].

Data type	Filename	Description
Raster	`enmap_sonoma.bsq`	Simulated spaceborne hyperspectral data from the EnMAP sensor with a spatial resolution of 30m, 195 bands, and 1000x200 pixels (ENVI Standard Band Sequential `bsq`)
Raster	`nlcd_sonoma.bsq`	National Land Cover Database 30m classification for the study region (ENVI Standard Band Sequential `bsq`)
Vector	`agb_sonoma.gpkg`	343 AGB reference points sampled from the existing LiDAR derived AGB map (GeoPackage `gpkg`)

[5]	Dubayah, R.O., A. Swatantran, W. Huang, L. Duncanson, H. Tang, K. Johnson, J.O. Dunne, and G.C. Hurtt. 2017. CMS: LiDAR-derived Biomass, Canopy Height and Cover, Sonoma County, California, 2013. ORNL DAAC, Oak Ridge, Tennessee, USA. https://doi.org/10.3334/ORNLDAAC/1523

[6]	Cooper, S.; Okujeni, A.; Jänicke, C.; Segl, K.; van der Linden, S.; Hostert, P. (2020): 2013 Simulated EnMAP Mosaics for the San Francisco Bay Area, USA. GFZ Data Services. https://doi.org/10.5880/enmap.2020.002

[7]	Multi-Resolution Land Characteristics Consortium (MRLC) (2018). National Land Cover Database 2011 (NLCD 2011). Multi-Resolution Land Characteristics Consortium (MRLC). https://data.nal.usda.gov/dataset/national-land-cover-database-2011-nlcd-2011. Accessed 2022-08-08.

Exercise A: Getting started with the EnMAP-Box¶

Description

This exercise introduces basic functionalities of the EnMAP-Box for this tutorial. You will get to know the graphical user interface and will learn how to load data, visualize raster and vector data, and use the basic navigation tools. Additionally, you will learn to work with multiple map views and how to visualize image spectra using Spectral Library Windows.

Duration: 30 min

1. Start the EnMAP-Box¶

Start QGIS and click the icon in the toolbar to open the EnMAP-Box. The GUI of the EnMAP-Box consists of a Menu and a Toolbar as well as panels for Data Sources and Data Views.
The QGIS Processing Toolbox including the EnMAP-Box algorithms can be optionally added to the GUI by clicking on View in the Menu and by checking the Processing Toolbox from the Panel list.

2. Load data¶

To load new datasets into the EnMAP-Box, click the icon and navigate to the file directory containing your data. Select agb_sonoma.gpkg from the Open data source dialogue and select Open.
Alternatively, the EnMAP-Box offers simple drag & drop capabilities to load data from an external file manager (e.g. Windows File Explorer). Load enmap_sonoma.bsq by dragging and dropping the file from your file manager into the Data Sources panel.
All data currently open in the EnMAP-Box will appear in the Data Sources panel.

3. Visualize raster data¶

The EnMAP-Box offers Map Views (Map #) for visualizing raster and vector data. Click the icon to open a new Map View and drag enmap_sonoma.bsq from the Data Sources panel into Map #1.
- In addition to a new Map View opening, a corresponding Data View entry is created in the Data Views panel which shows all data currently loaded in a given Map View.
- The enmap_sonoma.bsq image will be displayed as true color RGB composite. True color rendering is based on predefined RGB band combinations (R: 658 nm, G: 569 nm, B: 479 nm) stored in the QGIS Style File enmap_sonoma.qml.

Tip

If the raster image has wavelength information associated with it, you may also select an RGB combination from different custom RGB band combinations (True Color, Colored IR, SWIR-NIR-R or NIR-SWIR-R). Right click on the dataset in the Data Views panel, select Layer Properties and navigate to Raster Band. Don’t forget to choose appropriate Min/Max Value Settings.

4. Basic navigation tools¶

The Toolbar offers common navigation tools for exploring visualized datasets. Make yourself familiar with the following navigation tools:
Note that the mouse wheel can be used alternatively for zooming (roll mouse wheel forward/backward) and panning (press and hold mouse wheel).
For a better orientation when exploring visualized raster images, you may switch on the crosshairs (right click into Map View and activate Crosshair ‣ Show.
Make yourself familiar with the icon on the toolbar to view pixel values of the displayed raster. Note: ^{Identify Cursor Info} must be activated to access this tool. When activated and used, a new Cursor Location Values window will open displaying data from the selected pixel. This tool similarly works for viewing attribute information of displayed vector data.

5. Multiple map views¶

The EnMAP-Box enables users to work with multiple Map Views, which can be flexibly organized and geospatially linked.
Open a new Map View (Map #2) by clicking the icon.

Note

A new Data view appears corresponding to the newly added Map View.
Display enmap_sonoma.bsq as an RGB composite of your choice in Map #2.

Tip

When loading a raster image to a map view, you may also right click the filename in the Data Sources panel and select either Open in existing map or Open in new map. If the raster image has wavelength information associated with it, you may also select a predefined composite from the context menu.

For geospatial linking, click on View in the Menu and select Set Map Linking. In the Map Linking window, select the Link Map Scale and Center option and close the dialog. You may also right click a map window and select Link with other maps to initialize the linking process.

Tip

Map Windows can be re-arranged by clicking on the blue Map title bar (Map #) and dragging it to the desired position. A transparent blue rectangle will appear indicating the docking position once you release the mouse button. You may also undock map views from the EnMAP-Box window by selecting float_window from the blue Map title bar. To re-dock a Map View, click and drag the blue Map title bar to an open Map View already docked in the EnMAP-Box window.

6. Visualize vector data¶

Close Map #2 from the previous step.
Load agb_sonoma.gpkg to Map #1.
To change the order of stacked layers, go to the Data Views panel and drag one layer on top or below another one. Arrange the layer stack so that agb_sonoma.gpkg is displayed on top of enmap_sonoma.bsq.
By default, vector files are displayed with a single uniform symbol. To change this symbology, right click on agb_sonoma.gpkg in the Data Views panel, select Layer Properties and navigate to Symbology in the Layer Properties window. You can now change the symbology in accordance to the QGIS functionality.
- Select Graduated from the dropdown menu, and select biomass in Value and Color in Method.
- Set the Color ramp to run from white to green.
- Press Classify and then OK to display the biomass values associated with each point.

7. Extract & visualize image spectra¶

The EnMAP-Box offers Spectral Library Windows (SpectralLibrary #) for visualizing spectra and handling their metadata.
This tool may also be used to extract and visualize spectra which are spatially associated with vector data open in the EnMAP-Box, i.e., the AGB reference points. To do this, open a new Spectral Library window by selecting the icon on the toolbar.
Next, import spectral profiles from other sources by clicking at the icon in the SpectralLibrary #1 menu. Specify the following settings:
- Format = Raster Layer
- Options: Raster = enmap_sonoma.bsq, Vector = agb_sonoma.gpkg
- Field Value Import: Click on the icon, select biomass and click OK.
Terminate the Import Spectral Profile dialogue with OK. A spectral library is automatically built based on the geographic location of each point in the vector file. The associated attribute information is displayed in the table on the right.
In Exercise B, you will learn how to create regression models based on the illustrated spectra and related AGB quantities to predict AGB across the whole image.

Learning Activities

A1: What land cover types are present in the imagery? How are the AGB reference plots distributed throughout the scene?
A2: What different information can you see when switching from a true color composite to a NIR false color composite?

Exercise B: Regression based mapping of AGB¶

Description

One of the strengths of remote sensing comes from its ability to take high-quality plot measurements of a variable of interest and building statistical models with which wall to wall maps of this variable can be created. One of the most common ways of doing this is to create regression models based on the optical properties of the training data and applying it to large scale imagery. This exercise …

Introduces a regression-based mapping approach for taking plot measurements of AGB and generating spatial AGB estimates using an input raster of hyperspectral imagery.
Demonstrates the Regression Dataset Manager and the Regression Workflow applications of the EnMAP-Box.

Duration: 20 min

1. Use the Regression Dataset Manager for data preparation¶

The Regression Dataset Manager offers different options to prepare data for the Regression Workflow application. In the context of this tutorial, you will create a Regression Dataset from a raster and a vector layer containing the spectral features (independent variable) and the target variable (dependent variable), respectively. The regression dataset will be stored as pickle file (.pkl).
Open enmap_sonoma.bsq and agb_sonoma.gpkg in a single Map Window. Close all other opened Map and Spectral Library Windows.
Click on Applications in the Menu and select Regression Dataset Manager.
To create the Regression Dataset from a raster and a vector layer, click on the icon and choose Create regression dataset (from continuous-valued vector layer and feature raster). A new widget will be opened. Run the dialog with the following inputs:
- Continuous-valued vector layer: select agb_sonoma.gpkg
- Raster layer with features: select enmap_sonoma.bsq
- Fields with targets: select attribute biomass
- Output Data: select … ‣ Save to File… and define an output path and file name (e.g. agb_regression_data.pkl).
After running the dialog, agb_regression_data.pkl will be opened under Models in the Data Sources panel. Close the Regression Dataset Manager.

Tip

The Regression Dataset Manager offers different random sampling options, e.g. for splitting Regression data into training and validation data. Once the Regression data is prepared, you can access these options through the Random Sample button.

2. Use the Regression Workflow for estimating AGB¶

The Regression Workflow application offers several state-of-the-art regression algorithms from the scikit-learn library (see https://scikit-learn.org/stable/index.html) for predicting continuous variables. The application further includes an optional cross-validation for assessing model performances.
Click on Applications in the Menu and select Regression Workflow to open the regression application.
- Choose agb_regression_data.pkl as Training dataset.
- Select RandomForestRegressor (default, due to the low processing time) as Regressor, and use the default model parameters. Note that the different algorithms provided lead to varying accuracies and processing times. Refer to the scikit-learn documentation for more information.
- Raster layer with features specifies the raster image to which the regression model will be applied. Select enmap_sonoma.bsq. Specify output path and file name (e.g. agb_estimation.bsq) under Output regressor layer to save the result in your working directory.
- To make use of a cross-validation, set the Number of cross-validation folds to 10 (default) and leave the Open output performance report option checked. Specify output path and file name (e.g. agb_estimation_cv.html) under Output regressor performance report to save the report in your working directory.
- The regression model can be optionally saved, e.g. for applying the model again to a dataset. Specify output path and file name (e.g. agb_rfmodel.pkl) under Output regressor to save the result in your working directory.
- Click run to start the Regression Workflow.

Tip

All processing options of the Regression Workflow that are labeled as [optional] can be disregarded by setting the Output to Skip Output.

3. Assess the model performance for AGB estimation¶

After running the Regression Workflow, the performance report with scatterplots and statistical measures will be opened in your default web browser.
Based on the 10-fold cross-validation, you can now access the performance of your model to predict AGB.

4. Visualize AGB results¶

After running the Regression Workflow, all outputs will appear in the Data Sources panel.
Close all opened Map/SpectralLibrary Windows. Open enmap_sonoma.bsq as an RGB composite of your choice in Map #1.
Open the agb_estimation.bsq in a new Map View and link to the Map #1. Use the Layer Properties to change the color ramp to white-green (Singleband pseudocolor).

Learning Activities¶

Learning Activities

B1: What general trends do you see in the biomass estimations? How do they compare to landscape features seen in the EnMAP imagery?
B2: Discuss the accuracy results, both in terms of the statistical measures, as well as the form of the scatterplot and histograms.

Exercise C: Compare AGB estimates with the NDVI¶

Description

In this exercise, you will learn how to use the ImageMath application to calculate a NDVI map and generate a forest mask based on the NLCD land cover map. Based on the forest area only, you will then assess the AGB prediction from Exercise B relative to the NDVI using the Scatter Plot Tool.

Duration: 30 min

1. Introduction to ImageMath¶

The ImageMath tool in the EnMAP-Box allows users to apply a mathematical operation, python function or user defined function to an image. In the following sections, you will utilize standard numpy array processing protocols
- to calculate a NDVI map from two bands of our EnMAP imagery,
- to generate a forest mask from the NLCD land cover map,
- and to apply a forest mask to both the NDVI and AGB maps.
Close all opened Map/Spectral Library Windows. Display enmap_sonoma.bsq, nlcd_sonoma.bsq and agb_estimation.bsq in a single or in multiple Map Views.
Open the ImageMath application by going to Applications then selecting ImageMath
ImageMath consists of several panels:
- Inputs: defines input variables and variable names.
- Outputs: defines output variable names and locations to be saved to.
- Code editor: Text editor in which programmatic manipulation of the input datasets can be defined using Python scripting syntax.
- Output Grid: Allows users to manually set the output grid.
- Processing: Allows users to select block sizes for processing large datasets with limited memory.
- Log Window: Displays the status (and error messages) of executed code.
- Additionally, a tab for Routines allows users to select a number of common python-based tools for manipulating spatial datasets with linked documentation.

2. Calculate NDVI¶

The Normalized Difference Vegetation Index (NDVI) is a commonly used vegetation index that is correlated with both vegetation cover and AGB. The formula for NDVI is:

\[NDVI = \frac{NIR-Red}{NIR+Red}\]

where NIR is the near-infrared band reflectance (~850nm) and Red is the red band reflectance (~660nm). We will now calculate NDVI from the EnMAP imagery using ImageMath.
In the Inputs panel, select enmap_sonoma.bsq from the dropdown menu. The variable name is automatically taken from the filename, but may be changed if desired.
In the Code Editor, define the RED and NIR bands in our EnMAP imagery. These correspond to bands 42 and 73, respectively, and we can define them using python indexing syntax (i.e. 0 indexed array slicing):
```
RED = enmap_sonoma[41]
NIR = enmap_sonoma[72]
```
Next, we define the formula we wish to run:
```
NDVI = (NIR - RED)/(NIR + RED)
```
In the Outputs panel, define the output variable name as NDVI, and select an output file path and file name (e.g. ndvi.bsq).
Finally, click on the button to run the script. A new raster dataset ndvi.bsq will appear in the Data Sources panel.

Attention

Input and output variable names in the Code Editor must exactly match corresponding names deﬁned in the Inputs and Outputs panels.

3. Create a forest mask¶

As the model was trained using AGB reference plots from forest areas, only limited inference can be made of the non-forest AGB estimates. We will therefore apply a forest mask to our AGB map as well as to the NDVI map. The forest mask will be generated based on the available NLCD land cover map.
Below are the NLCD classes and color legend represented in the raster data. We will consider any pixel to be forest which is labelled as Deciduous (41), Evergreen (42), or Mixed (43) forest according to the NLCD classification.

Open the ImageMath application and set nlcd_sonoma.bsq as the input file.

Enter the following code into the code editor:

Forest_Mask = nlcd_sonoma
forest_classes = [42, 43, 44]

for x in range(Forest_Mask.shape[1]):
    for y in range(Forest_Mask.shape[2]):
        if Forest_Mask[0, x, y] in forest_classes:
            Forest_Mask[0, x, y] = 0
        else:
            Forest_Mask[0, x, y] = 1

Line by line, this
1. Copies the NLCD information to a new object we will manipulate to create the mask
2. Creates a list of classes which we consider forest
3. Loops through the x dimension of the raster. For each loop, x will be an integer representing the current location in the x dimension.
4. Loops through the y dimension of the raster. For each loop, y will be an integer representing the current location in the y dimension. These two loops allow us to look at each element in the array individually. While numpy offers more efficient ways to analyse arrays (See section C4), this is one basic approach.
5. Check if the element at the current x and y position is in the forest_classes list
6. If it is, set that value to 0
7. If it is not
8. Set that value to 1
Set Forest_Mask as the output and deﬁne the path and file name (e.g. forest_mask.bsq) for saving the result.
Run the script by clicking .
A new raster dataset forest_mask.bsq will appear in the Data Sources panel. The resulting mask now has a value of 0 for forested pixels, and 1 for non-forested pixels.

4. Apply the forest mask¶

Open the ImageMath application and set agb_estimation.bsq, ndvi.bsq and forest_mask.bsq as the input files. Note that these datasets need to be opened in a single or in multiple Map Views to make them selectable input files.
Enter the following code into the Code Editor to apply the forest mask to the AGB and NDVI images.

Forest_Mask = forest_mask.astype(bool)

AGB_Masked = agb_estimation
AGB_Masked[Forest_Mask] = -99
setNoDataValue(AGB_Masked, -99)

NDVI_Masked = ndvi
NDVI_Masked[Forest_Mask] = -99
setNoDataValue(NDVI_Masked, -99)

Line by line, this script:
1. Sets the mask to a Boolean data type (i.e. True/False). The mask file contains binary values where 0 indicates forest (i.e. non-masked pixels) and 1 indicates non-forest (i.e. pixels to be ignored). In Python, 1 also represents True while 0 represents False, and by setting the datatype to bool, we explicitly tell Python to treat these values in this manner.
2. Copies the AGB values to a new array.
3. Steps through each value in the new array and sets the value to -99 if the mask value is True. In numpy array speak, this line can therefore read: “For each value in AGB_Masked, if the corresponding value in Forest_Mask is True (i.e. non-forest), then set that value to -99”. If the mask value is False (i.e. forested), nothing will happen, and the biomass value will remain in the array.
4. Sets the no data value for the masked array to -99. This helps the EnMAP-Box to automatically display the data correctly, and since it is not a realistic value for both AGB and NDVI, we can safely ignore it.
5. Steps 2-4 are then repeated for NDVI.
Set AGB_Masked and NDVI_Masked as the outputs and define the path and the file names (e.g. agb_estimation_masked.bsq, ndvi_masked.bsq) for saving results.
Run the script by clicking . The new raster datasets agb_estimation_masked.bsq and ndvi_masked.bsq will appear in the Data Source panel.

5. Visualize AGB vs. NDVI with the Scatter Plot tool¶

Close all Map Views.
Open an RGB composite of enmap_sonoma.bsq in Map #1.
Display agb_estimation_masked.bsq and ndvi_masked.bsq in Map#2 and Map#3, respectively and use the Layer Properties to change the color ramp of both maps to white-green. Link all Map Views.

To investigate the relationship between estimated AGB and NDVI, we will make use of the EnMAP-Box’s Scatter Plot tool. This is one of several tools integrated into the EnMAP-Box to support data visualization and assessment
Open the Scatter Plot tool by going to Tools then selecting Scatter Plot.
- Select agb_estimation_masked.bsq and Band 1 for specifying X values and ndvi_masked.bsq and Band 1 for specifying Y values. If a selected raster has multiple bands, you would specify the desired band from the dropdown.
- Click on Apply to visualize the Scatter Plot.
The Settings offer different options for visualizing the scatter plot.
- You may change the Min and Max values, Coloring or Cumulative count cut options to improve your visualization.
- Under Extent you may choose Current canvas or Whole raster to display data of the current map canvas only or to display all raster data. Choose Whole raster.
- Under Accuracy you may choose to display Estimated or Actual. Actual will display all available data, while Estimated will only display a random subset. For large raster extents, Estimated is much faster, and for that reason is the default. Leave Accuracy as Estimated.
- Click on Apply to update the Scatter Plot. If Live update is checked, visualization of the scatter plot will be automatically updated.
The Analytics offers options to assess the relationship between x and y values.
- The 1:1 line represents the linear 1:1 relationship between the two variables of the same unit if they were perfectly correlated.
- The Fitted line represents the linear regression line fitted between the actual data from the two variables. The linear regression function, the coefficient of determination (r^2) and the Root Mean Squared Error (rmse) will be additionally displayed. Activate the Min-max line by checking the box to its left.

Learning Activities¶

C1: Why was it necessary to mask the AGB results?
C2: What relationships can you see between AGB and NDVI? Do these relationships hold true if you look at the un-masked AGB and NDVI maps?
C3: Given the relationships between AGB and NDVI, do you think NDVI could be used to map AGB? What limitations would you expect from such a model?

Additional Exercises¶

Learning Activities

AE1: Use the Image Statistics tool in the Tools menu to look at the band statistics for the biomass predictions both with and without the tree mask applied.
AE2: Because we randomly subsetted the training data prior to model training, the performance of the model has an element of uncertainty to it. To better understand this, rerun the regression workflow 3-5 times. Then use the ImageMath tool to calculate the average estimate and variance. How does running the regression in such an ensemble approach affect the results? What is the spatial pattern of variation in estimates?
AE3: Rerun regression (Exercise B) using NDVI as the input rather than the hyperspectral imagery.

Ocean Colour analysis with ONNS¶

Ocean Colour analysis with the OLCI Neural Network Swarm (ONNS)

Overview¶

About¶

Satellites observe the oceans, coasts and inland waters. Water quality parameters can be estimated from ocean colour using the in-water algorithm ONNS, which has been developed at the Institute of Coastal Research at the Helmholtz-Zentrum Geesthacht. The EnMAP-Box is a free and open source plug-in for QGIS to visualize and process satellite remote sensing data with special emphasis to the hyperspectral EnMAP sensor. The following tutorial describes the usability and functionality of the Python-based ONNS processing tool in the EnMAP-Box.

Background¶

In opposite to most other remote sensing applications it is not the water surface itself that determines the reflectance (ocean colour), it is the upper layer of the water body beneath. Water is transparent for light in the visible spectral range. Sunlight is absorbed and scattered along the water column, whereby four constituents are usually differentiated: pure water itself, phytoplankton particles, sediments, and coloured dissolved organic matter (CDOM). The composition of the water constituents determines the light penetration depth and portion of the backscattered light. The remote sensing signal contains the backscattered light from the top layer only, approximately until a depth where only 90 % of the spectral sunlight is still present (the 90%-depth). This information-containing water depth can be up to 60 m for clear oceanic waters (spectral maximum around 450 nm), few metres for coastal waters (spectral maximum at 600 nm) or even few centimetres for very turbid waters. By the way – photosynthesis of phytoplankton is only possible with sufficient sunlight roughly until the 1%-depth, also referred to as euphotic depth.

The primary aim of ocean colour remote sensing is to quantify the water constituents, i.e. the phytoplankton biomass in terms of their Chlorophyll-a pigment content, Chl [mg m ⁻³], total (organic + inorganic) suspended matter concentration, TSM [g m ^-3], and CDOM absorption at 440 nm, a _cdom (440) [m ^-1]. Beyond this, additional water mass-characterizing optical parameters, e.g. absorption and scattering properties, can be estimated. Hyperspectral information, as provided by the EnMAP mission, allow further differentiation of spectral features associated to algae types (phytoplankton groups) or sediment properties.

The present tutorial is an overview about the usage and functionality of the water algorithm implemented in the EnMAP-Box. The processor contains three main steps: the atmospheric correction, an optical water type classification, and the application of suitable in-water algorithms. Ocean, coastal and inland water bodies can be characterized by means of these algorithms. The core in-water processor including optical water type classification is the ONNS (OLCI Neural Network Swarm) algorithm [1] version 0.9. It is an EnMAP-precursor algorithm, which is specially developed for data evaluation of the multi-spectral Ocean and Land Colour Instrument (OLCI) on board Sentinel-3. Satellite data from other ocean colour sensors can be analysed as well by means of an intermediate band-shifting procedure [2]. Atmospheric correction must be provided before utilization of the in-water algorithm, different models are available for this, e.g. Polymer [3] or C2RCC [4] (but may lead to different retrieval results). Alternatively, in situ remote-sensing reflectance data (in a txt-format) can be processed.

The ONNS algorithm itself consists of several blended neural networks that are specialized for 13 different optical water classes. These comprise clearest natural waters but also extreme absorbing or scattering waters. Considered Chlorophyll-a concentrations reach up to 200 mg m ⁻³, non-algae particle concentrations up to 1,500 g m ⁻³, and CDOM absorption coefficient at 440 nm is up to 20 m ⁻¹. The algorithm generates different concentrations of water constituents, inherent and apparent optical properties, and a color index. In addition, all products are delivered with an uncertainty estimate.

References¶

[1]	Hieronymi, M., D. Müller, and R. Doerffer (2017), The OLCI Neural Network Swarm (ONNS): A bio-geo-optical algorithm for open ocean and coastal waters, Frontiers in Marine Science, 4 (140). (https://www.frontiersin.org/articles/10.3389/fmars.2017.00140/full)

[2]	Hieronymi, M. (2019), Spectral band adaptation of ocean color sensors for applicability of the multi-water biogeo-optical algorithm ONNS, Optics Express, 27 (12), A707-A724. (https://www.osapublishing.org/oe/abstract.cfm?uri=oe-27-12-A707)

[3]	Steinmetz, F., P. Y. Deschamps, and D. Ramon (2011), Atmospheric correction in presence of sun glint: application to MERIS, Optics Express, 19(10), 9783-9800. (https://www.osapublishing.org/oe/abstract.cfm?uri=oe-19-10-9783)

[4]

Brockmann, C., R. Doerffer, M. Peters, K. Stelzer, S. Embacher, and A. Ruescas (2016), Evolution of the C2RCC neural network for Sentinel 2 and 3 for the retrieval of ocean colour products in normal and extreme optically complex waters, In Proc. Of the Living Planet Symposium, Vol. 740, p. 54. (https://www.brockmann-consult.de/wp-content/uploads/2017/11/sco1_12brockmann.pdf)

Data¶

Test data¶

You can download the test data here: https://bitbucket.org/janzandr/onns_for_enmap-box/downloads/S3A_OL_2_WFRC8R_20160720T093421_20160720T093621_20171002T063739_0119_006_307______MR1_R_NT_002_sylt.nc

The present version of the ONNS algorithm is able to process atmospherically corrected data of different ocean colour sensors, namely OLCI, MERIS, MODIS and VIIRS. The corresponding data format must be NETCDF4. Moreover, ONNS can handle tabulated remote-sensing reflectances at selected wavebands of OLCI, SeaWiFS, MODIS, MERIS, OCM-2, VIIRS, SGLI, GOCI-2, EnMAP or PACE/OCI (text format).

One example of (C2RCC) atmospherically corrected Sentinel-3A/OLCI data is provided. The sub-scene shows the coastal waters off the island Sylt in the German Bight, North Sea (2016-07-20, 09:34 UTC): S3A_OL_2_WFRC8R_20160720T093421_20160720T093621_20171002T063739_0119_006_307______MR1_R_NT_002_sylt.nc

Note that processing of a satellite scenes may take a long time depending on the number of valid water pixels.

Figure 1: Sentinel-3A/OLCI top-of-atmosphere image with marked area of provided sub-scene (contains modified Copernicus Sentinel data [2016] processed by ESA/EUMETSAT/HZG).

ONNS output¶

The minimum output of the water algorithm ONNS contains 12 typical ocean colour products each with an estimate of their associated uncertainties:

Concentration of Chlorophyll-a, Chl [mg m ⁻³],
Concentration of inorganic suspended matter (minerals), ISM [g m ^-3],
Absorption coefficient of CDOM at 440 nm, a _cdom (440) [m ^-1],
Absorption coefficient of phytoplankton particles at 440 nm, a _p (440) [m ^-1],
Absorption coefficient of minerals at 440 nm, a _m (440) [m ^-1`],
Absorption coefficient of detritus plus gelbstoff at 412 nm, a _dg (412) [m ^-1],
Scattering coefficient of phytoplankton particles at 440 nm, b _p (440) [m ^-1],
Scattering coefficient of minerals at 440 nm, b _m (440) [m ^-1]`,
Total backscattering coefficient of all particles (organic and inorganic) at 510 nm, b _bp (510) [m ^-1],
Downwelling diffuse attenuation coefficient at 490 nm, K _d (490) [m ^-1],
Upwelling diffuse attenuation coefficient at 490 nm, K _u (490) [m ^-1] and
Forel-Ule number, FU [-].

The standard output contains additional derived properties, such as total absorption and scattering coefficients at 440 nm, optical dominance at 440 nm as well as estimated concentration of dissolved organic carbon (DOC [mg m ^-3]). In addition, input remote-sensing reflectances and some information on the optical water types (OWT) are provided. In a third saving option, excessive information on OWT classification can be stored.

Estimated Chlorophyll-a concentration, CDOM absorption and particulate backscattering from the Sentinel-3 OLCI test scene

Usage¶

ONNS GUI¶

Satellite data, e.g. Level-2 products of Sentinel-3/OLCI, are often available in NETCDF4 format, which can be visualized and processed by means of the QGIS/EnMAP-Box as raster layer. It is possible to process atmospherically corrected satellite ocean colour data with the ONNS algorithm via the EnMAP-Box processing tools (EnMAP-Box ‣ Water ‣ ONNS).

_images/Screenshot_EnMAP-Box_with_ONNS.png

Overview of available processing tools in the EnMAP-Box. The raster layer data show remote-sensing reflectance at 510 nm.

GUI of the ONNS algorithm

_images/EnMAP_ONNS_GUI_after_processing.png

GUI of the ONNS algorithm upon completion of the processing.

Depending on the size of the satellite scene, processing may take a few minutes up to some hours. The results are saved in NETCDF4 format and can be viewed and transferred for example as raster layer.

Credits¶

Development Lead¶

Martin Hieronymi (martin.hieronymi@hzg.de)

Institute of Coastal Research, Helmholtz-Zentrum Geesthacht

Contributors¶

Hajo Krasemann (Helmholtz-Zentrum Geesthacht)

Andreas Rabe (Humboldt-Universität zu Berlin)

Funding¶

EnGeoMAP Tutorial¶

EnGeoMAP Base (ver. 3.0)¶

The EnMAP Geological Mapper for Mineral Classification (EnGeoMAP)¶

Authors: Christian Mielke, Friederike Koerting, Friederike Klos, Nicole Koellner, Christian Rogass, Nina K. Boesche, Helge Daempfling, Saeid Asadzadeh

Contributions from Agnieszka Kuras

Introduction to EnGeoMAP¶

1. Background¶

The EnMAP geological mapper (EnGeoMAP), as part of the EnMAP Box (see Figure 1) is an expert-system-based tool for the characterization of surface cover types from hyperspectral EnMAP data. The software requires as user input spectral reflectance data cubes, a spectral library of endmembers that are to be identified, and a user supplied color scheme as shown in Figure 2. It has to be noted that EnGeoMAP is optimized for the Windows 10 Version of QGIS. There is currently no guarantee for it to function under different platforms. The necessary spectral library files may be prepared by the EnMAP Box spectral library wizard or by any software that is able to write spectral library files as band sequential (BSQ). Please see Figure 2 for a generic template of the spectral library header file and the corresponding color legend file. The entries of the spectral library are plotted as well according to the RGB color code from the CSV file. EnGeoMAP uses a partitioned geometric method and continuum removal for feature retrieval from the spectral library file as well as the for the image spectra. Therefore, additional atmospheric features in the reflectance data from over or underestimation of the atmospheric water vapor (e.g. at 940 nm and at 1130 nm) need to be clipped and interpolated in both: the image spectra and the spectral library. Otherwise they would also be incorporated in the geometric feature retrieval process (see Figure 3) and may lead to erroneous results in the material similarity scores and resulting data products.

Figure 1 EnGeoMAP user interface with example setup.

2. Requirements¶

This tutorial requires at least version 3.7.2.XX of the EnMAP-Box.

3. References and Further Reading¶

Clark, R.N.; Swayze, G.A.; Livo, K.E.; Kokaly, R.F.; Sutley, S.J.; Dalton, J.B.; McDougal, R.R.; Gent, C.A. Imaging spectroscopy: Earth and planetary remote sensing with the USGS Tetracorder and expert systems. J. Geophys. Res. Planets 2003, 108.
Kokaly, R.F. Spectroscopic remote sensing for material identification, vegetation characterization, and mapping. Proc. SPIE 2012, 8390.
Clark, R.N.; Swayze, G.A.; Wise, R.; Livo, E.; Hoefen, T.M.; Kokaly, R.F.; Sutley, S.J. USGS Digital Spectral Library Splib06a; U.S. Geological Survey: Denver, CO, USA, 2007.
Mielke, C.; Rogass, C.; Boesche, N.; Segl, K.; Altenberger, U. EnGeoMAP 2.0—Automated Hyperspectral Mineral Identification for the German EnMAP Space Mission. Remote Sens. 2016, 8, 127.

4. Data¶

For a template on how the data should look like please download the test data here: ‘ https://nextcloud.gfz-potsdam.de/s/y4FsWzSPBpAW4Aj’ The dataset contains a hyperspectral EO-1 Hyperion image showing the Gamsberg Mine prior to its opening and a spectral field library and csv file. The spectral library header (*.hdr) is already modified so that the file type parameter (file type=) is set to “ENVI Standard”.

Figure 2 shows a standard layout for the .csv-file and the spectral library.

Figure 2 Illustration of the basic input data type requirements for the spectral library and the csv legend color file.

Figure 3 Field spectrum of a weathered shist from Gamsberg, showing the extracted characteristic absorption features (F) as well as reflectance peaks (PF) of the spectrum in addition to the upper and lower hulls that have been used for the extraction of the features.

The Software¶

This section describes the necessary requirements to the input data and potential pitfalls during the processing. EnGeoMAP has been designed to work with EnMAP data only. However, it works for most full range hyperspectral sensor suites as well, provided that VNIR and SWIR data is available. More experienced users are encouraged to modify the source code to their own needs to adapt for special sensor setups (e.g. VNIR sensor only data). The general workflow is shown in Figure 4.

Figure 4 Basic processing workflow for EnGeoMAP with modules, input and output highlighted.

1. Theoretical Background¶

This is a basic process for any laboratory technician working with spectroscopy. The comparisons and material characterization have mostly been done by visual inspection and interpretation in the past. Therefore, systems that built on top of this expert knowledge, have been termed expert systems e.g. USGS Tetracorder and MICA [1,2]. They are a basic necessity to process the vast amount of spectra from imaging and non-imaging spectroscopy systems today. A key to the success of these expert systems, such as the USGS Tetracorder and MICA [1,2] are the accompanying standard spectral libraries [3] that may be used for the material characterization process, together with their characteristic absorption feature tables that define the position of the characteristic absorption features of each of the spectral library entries. The table, as well as the spectral library need to be extended manually each time new reference spectra are added. EnGeoMAP [4] with its automatic feature extraction algorithm does not require an expert table for feature retrieval. It only requires a user supplied reference library, as described above. It may, therefore, be seen as an automated expert system that aims to formalize the feature extraction skill of a trained spectral laboratory technician. In its last version EnGeoMAP only used the characteristic absorption features, for a spectral characterization of the material. Its current version also provides the user with the possibility to extract and use local reflectance peaks in the material characterization process in addition to the absorption features (please tick upper + lower hull as in Figure 1). The option upper hull on its own extracts absorption features only and corresponds to the previous version of EnGeoMAP (v 2.0). Figure 4 shows a diagram with the basic workflow of EnGeoMAP. The preprocessing module extracts the characteristic absorption features and, if chosen by the user, additional characteristic reflectance peaks. These are then used in a weighted fitting operation in the spectral module, to calculate the material similarity scores of the unknown pixel spectrum to the reference library. According to those fit values a user defined minimum fit threshold may now be applied to only use those library spectra in a bound value least squares unmixing that are above that threshold (see Figure 1 option: Minimum threshold weighted fitting). The resulting unmix result as well as the correlation data cube are sorted in descending order. The first band of each of the sorted results is then used in the spatial module together with the csv file to provide a best fit (highest correlation score) material map and highest abundance (highest bvls fraction) to provide a color coded map of the best fit and highest abundance results from the data. Additional ancillary data for further data processing is provided as well (e.g.: spectral contrast, bvls residuals, etc.), see Table 1 for an overview over the provided data products.

2. Data Preparation¶

The reflectance data for processing with EnGeoMAP has to be of high quality, as already stated above. Any form of atmospheric processing residual, or sensor overlap will have a direct negative impact on the data products of EnGeoMAP. Overlapping bands need to be removed from the dataset i.e. the wavelength succession vector in the header files need to be strictly ascending. Figure 5 shows problems related to image spectra from hyperspectral data, that may occur in your data as well and that need to be mitigated prior to the analysis with EnGeoMAP. Here we see two overall noisy spectra, which have been acquired during unfavorable acquisition conditions (e.g. low sun angle, considerable off-NADIR pointing of the sensor). Clipping and interpolation need to be done in both water vapor residuals at 940nm and at 1130nm to assure an artifact-reduced analysis result. Adaptive filtering may also be a good advice to further reduce noise and slighter artifacts. The spectral library header (*.hdr) needs to be modified in the sense that the file type parameter (file type=) should be set to “ENVI Standard” to avoid File I/O errors with GDAL. Please also note that the scaling of your data is correct: nm is recommended for the wavelength units, as well as float or unsigned integer from 0-10000 (standard for many imaging spectrometers) for the reflectance values.

Figure 5: Illustration of residual atmospheric water vapor in overall noisy spectra, which have been acquired under unfavorable acquisition conditions.

3. The Front End¶

The GUI provides users with the possibility for basic data input and parameter settings. The three main input fields are for the location of the user input files. As shown in Figure 6 below. The user preference parameters are minimum reflectance threshold in the VNIR and SWIR regions. They should be as low as possible for data with a good SNR. The minimum fit threshold describes the lower cutoff value for the minimum acceptable valid spectral correlation value between the image spectrum and the library spectra. Values below the threshold are set to zero. The upper hull option only uses concave features in the weighted fitting process only, which corresponds to the standard version of EnGeoMAP (v 2.0), whilst the upper and lower hull takes into account both concave and convex features, as shown in Figure 3.

Figure 6 Illustration of the GUI with the most important user inputs explained.

4. The Results¶

Data products of EnGeoMAP are identifiable by their suffixes to the original filename (basename), see Table 1 for a short overview over the suffixes. The important part is to identify the major data products that are of use to basic users. These products are named (correlation_result, corresponding to a cube of correlation layers to the spectral library entries) and (abundance, corresponding to a cube of abundance layers to the spectral library entries), together with the corresponding RGB images in Tiff format. All other data products are aimed at more experienced users in imaging spectroscopy (e.g. the contrast measures). They may directly explain potentially erroneous results in the best fit and abundance maps. No data values are visible via -999 in parts of the data, as already highlighted in Table 1.

Table 1 EnGeoMAP Data Product Specifications¶
Filename(filename_suffix_describes_product)	Description
_peaks_	Data products based on local reflectance peaks only. (e.g. green peak vegetation, red peak hematite)
_average_	Data products based on average correlation scores of local reflectance peaks (e.g. green peak vegetation, red peak hematite) and characteristic absorption features.
_best_matches_	Data products based on sorted correlation scores (the first band contains the highest score values, the second the second highest scores …)
_median_filtered_	Data products which have been median filtered
_correlation_result_	Raw correlation scores from the spectral module for characteristic absorption features only.
_best_fit_	Results relating to the highest correlation score (Band 1 of best matches)
_abundance_	BVLS Results
_highest_abundance_	Data products based on sorted BVLS scores (the first band contains the highest score values, the second the second highest scores …)
_abundance_result_	Raw BVLS scores from the spectral module for characteristic absorption features only.
_geotiff_	Standard RGB color maps assigned from the sorted Band 1 of the best_matches results using the .csv colorfile May be directly viewed with the image viewer of your choice.
_indices_	Indices of the material with respect to the sorted correlation/abundance order. Please note that -999 represents a no data placeholder.
_coleur_files_.hdr	Class images, may be used for a quick legend generation within the QGIS map composer. Class image colors are, however, unreliable, use only geotiff for map display!
_albedo_narea_contrast_	Albedo versus feature area map.
_albedo_ndepth_contrast_	Albedo versus maximum feature depths map.
cum_depth_/cum_peak	Sum of feature/peak area.
_swirpos_of_max_abs_	Position of deepest SWIR feature (VNIR is analouge)
_swirdepth_of_max_abs_	Peakvalue of deepest SWIR feature (VNIR is analouge)

Literature¶

Clark, R.N.; Swayze, G.A.; Livo, K.E.; Kokaly, R.F.; Sutley, S.J.; Dalton, J.B.; McDougal, R.R.; Gent, C.A. Imaging spectroscopy: Earth and planetary remote sensing with the USGS Tetracorder and expert systems. J. Geophys. Res. Planets 2003, 108.
Kokaly, R.F. Spectroscopic remote sensing for material identification, vegetation characterization, and mapping. Proc. SPIE 2012, 8390.
Clark, R.N.; Swayze, G.A.; Wise, R.; Livo, E.; Hoefen, T.M.; Kokaly, R.F.; Sutley, S.J. USGS Digital Spectral Library Splib06a; U.S. Geological Survey: Denver, CO, USA, 2007.
Mielke, C.; Rogass, C.; Boesche, N.; Segl, K.; Altenberger, U. EnGeoMAP 2.0—Automated Hyperspectral Mineral Identification for the German EnMAP Space Mission. Remote Sens. 2016, 8, 127.

Workshop Tutorials¶

12th EARSeL Imaging Spectroscopy Workshop - Part I: Introduction into the EnMAP-Box¶

Authors: Andreas Rabe

Date: 17/06/2022

EnMAP-Box 3: version 3.10

QGIS: version 3.24

Introduction¶

Abstract

In this tutorial we will show the basic components of the EnMAP-Box. Participants will learn how to manage, visualize and process raster and vector data inside the EnMAP-Box. We will detail the multiple-viewer concept of the EnMAP-Box, that allows the exploration of data in different visualizations at the same time. Here we will especially highlight, how we capitalize on the spectral characteristics of optical (hyperspectral) EO data, e.g. by correctly plotting pixel profiles against the given center wavelength, or by quickly selecting target bands for visualization. Finally, we will perform a Classification Analysis Workflow using PRISMA or (simulated) EnMAP data to illustrate EO data processing.

Requirements

This tutorial requires version 3.10+ of the EnMAP-Box 3 running in QGIS 3.24+.

Data

You can download the data for this exercise here: https://box.hu-berlin.de/f/2ecf8943d6fa4474bf38/?dl=1

The tutorial dataset contains a PRISMA L2D image over Berlin, Germany, as well as a point based landcover reference sample.

Type	Filename	Description
Raster	`PRS_L2D_STD_20201107101404_20201107101408_0001_SPECTRAL.tif`	Surface reflectance, coregistersed, hyperspectral cube from the PRISMA sensor with a spatial resolution of 30m, 234 bands, and 1281x1238 pixels
Vector	`landcover_berlin_point.gpkg`	58 landcover reference points

For more details on PRISMA data see: https://prisma.asi.it/

Exercise A: Visualize PRISMA data inside the EnMAP-Box¶

Open the PRISMA raster

In the EnMAP-Box, open the PRS_L2D_STD_20201107101404_20201107101408_0001_SPECTRAL.tif raster and visualize it in a map view using drag&drop.

Style the PRISMA layer using an RGB visualization

We can improve the visualization using the Raster Layer Styling panel.

As the PRISMA layer contains information about the center wavelength location for each band, we can directly choose from a list of predefined RGB band combinations, e.g. Natural color (R-G-B) for showing Red band, Green band and Blue band as an RGB visualization, or Agricultural 1 (S1-N-B) for showing SWIR 1 band, NIR band Blue band as an RGB visualization.

Use the A, B, …, S2 buttons, to select individual PRISMA bands that best match the predefined broad bands from the Sentinel-2 sensor, e.g. N is associated with the Sentinel-2 NIR band at 833 nanometers.

Use the widgets in the Min / Max Value Settings to interactively alter and improve the contrast stretch.

Use a singleband gray visualization to identify bad bands

Due to atmospheric conditions, the PRISMA raster may contain bad bands, which can be identified easily using a singleband gray visualization.

In the Raster Layer Styling panel select the Gray tab to change the visualization.

Use the band selection slider or the band selection combobox (together with the Arrow-Up and Arrow-Down keys) to browse the PRISMA bands and identify potential bad bands.

As before, you can also use the A, B, …, S2 buttons.

Plot spectral profiles and show cursor location values

Use the Identify map tool to plot PRISMA spectral profiles and query band values for the selected location.

In the Spectral Profile Sources panel you can easily alter the plot style.

Exercise B: Perform a land cover classification¶

Derive a landcover map for the PRISMA raster

Use the Classification workflow algorithm to perform a full landcover classification. This includes training data preparation, fitting a Random Forest Classifier, and predicting landcover classes and class probabilities.

The original PRISMA raster and the derived classification and class probabilities can be visualized next to each other using multiple map views.

Finally, visualize the probabilities for the classes impervious, tree and water as RGB multiband color.

Visualize the predicted maps

Use the Classification Statistics app to visualize the derived classification map.

Use the Class Fraction/Probability Statistics app to visualize the derived class probability map.

View the fitted Random Forest Classifier model

The training data and the fitted model can be explored inside the Data Sources panel.

Last Update: 2020-08-12

Installation¶

Overview¶

If you like to develop an EnMAP-Box application, or more general, a QGIS and Qt application, we recommend to use a state-of-the-art Integrated Development Environment (IDE) like PyCharm. It offers run-time debugging, code completion, spell-checking, syntax highlighting, SCM support, unit-testing and many other helpful things.

1. Have Git installed¶

If not, download and install Git from https://git-scm.com/downloads

Check if git is installed to your local shell, e.g. as:

C:\Windows\System32>git --version
git version 2.26.0.windows.1

2. Clone this repository¶

Clone the EnMAP-Box repository (or a fork) to your local my_repositories folder and update its submodules by:

cd my_repositories
git clone --recurse-submodules git@bitbucket.org:hu-geomatics/enmap-box.git
cd enmap-box
git config --local include.path ../.gitconfig

The last line ensures that pull requests will update submodules as well.

Now you can use git pull to update your local copy of the EnMAP-Box repository:

cd my_repositories/enmap-box
git pull

Tip

Replace the repo uri with that of your EnMAP-Box repo fork, if you like to provide code via pull requests.

3. Setup a QGIS environment¶

This section gives examples how you can setup a QGIS & EnMAP-Box development used by PyCharm on different platforms.

a) OSGeo4W (Windows)¶

1. Install or update packages¶

Install QGIS using the OSGeo4W Network installer https://qgis.org/en/site/forusers/download.html
Install the OSGeo4W environment to a folder of choice (preferably one you have permanent writing access to). In following this is called OSGeo4W.

Start the OSGeo4W Setup.
Go forward to these steps by clicking next. Usually the default settings should be fine
- ‘Advanced Install’
- ‘Install from Internet’
- ‘Root Directory’ (should be your OSGEO4W directory)
- Select Local Package Directory (default)
- Select Your Internet Connect (default Direct Connection)
- Choose A Download Site (default http://download.osgeo.org )
Select Packages to install / update

Package Note

qgis recent official QGIS version

python3-scikit-learn
Press Next to install packages / updates

2. Setup development environment¶

Copy the qgis-env.bat and start_pycharm.bat from https://bitbucket.org/hu-geomatics/enmap-box/src/develop/scripts/OSGeo4W/ to a local folder, e.g. your windows desktop

Modify the qgis-env.bat config section to fit to your local environment, i.e. set the correct paths to your local OSGeoW installation and PyCharm executable

@echo off

:: ### CONFIG SECTION ###
:: root of local OSGEO4W installation
set OSGEO4W_ROOT=D:\OSGeo4W
:: PyCharm executable, adjust for version updates
set PYCHARM_EXE="C:\Program Files (x86)\JetBrains\PyCharm 2022.1.2\bin\pycharm64.exe"

:: git binaries and git lfs binaries
set BIN_GIT=C:\Program Files\Git\bin
set BIN_LFS=C:\Program Files\Git LFS

Call start_pycharm.bat to open PyCharm within the latest QGIS release. You can modify the start script to start a different QGIS build. E.g.

call "%~dp0\qgis-env.bat" qgis-ltr
start "PYCHARM" /B %PYCHARM_EXE%

will start the QGIS Long Term Release (if installed) instead of the latest QGIS release (qgis).

Possible QGIS versions provided by the OSGeo4W installer are:

Build	Description
qgis	QGIS Desktop (latest release)
qgis-ltr	QGIS Desktop (long term release)
qgis-dev	QGIS nightly build of the development branch
qgis-rel-dev	QGIS nightly build of the latest release branch

b) Linux¶

Install QGI as described in https://qgis.org/en/site/forusers/download.html

c) macOS¶

Install QGIS as described in https://qgis.org/en/site/forusers/download.html

d) Docker¶

tbd.

e) Setup Conda (all platforms)¶

Warning

Installing QGIS via conda is not officially supported by the QGIS core development team. The QGIS versions available in conda can therefore differ from the official QGIS versions.

At this date (2022-01-18) conda is stucked at QGIS 3.18, which the official QGIS is at 3.22

The installation of QGIS within a conda / anaconda environment is (almost) the same on macOS, windows or linux. Using conda it is often much easier to install additional python packages while admin rights are not required.`

Make sure conda is installed on your system.
Create a new conda environment named qgis_stable as specified in conda_environment.yml:

conda env create --name qgis_stable --file https://bitbucket.org/hu-geomatics/enmap-box/raw/develop/conda_environment.yml

Tip

Depending on the components and applications you like to use, it might be required to install more packages. If you cloned the EnMAP-Box repository you can also point to the local conda_environment.yml. Edit the --name or the YAML file itself as you wish. For more information on creating and managing conda environments visit the conda documentation

Activate the new environment
```
conda activate qgis_stable
```
Now you can start `QGIS`_, the Qt Designer and Qt Assistant from your conda shell:
```
qgis
designer
assistant
```
To easily start applications like PyCharm in this environment, which have not been installed by conda, you might define an alias during the activation of the environment.
- Create an activation script and define an alias for PyCharm:
  
  Windows: <your conda installation>/envs/qgis_stable/etc/conda/activate.d/pycharm-activate.bat
  @echo off doskey pycharm="<path to pycharm executable>"
  MacOS: <your conda installation>/envs/qgis_stable/etc.conda/activate.d/pycharm-activate.sh
  alias pycharm='open -a PyCharm\ CE.app'
- For completeness, also create a deactivation script:
  
  Windows: <your conda installation>/envs/qgis_stable/etc/conda/deactivate.d/others-deactivate.bat
  @echo off doskey pycharm=
  MacOS/Linux: <your conda installation>/envs/qgis_stable/etc.conda/deactivate.d/pycharm-deactivate.sh
  alias pycharm=

4. Setup PyCharm¶

Start PyCharm and add my_repositories/enmap-box as new project via File > Open File or Project
If this is not already the case, tell PyCharm where to find your Git-executable. Open File > Settings > Version Control > Git to set Path to Git executable. Press Test to check the used Git version.

Set the Git executable used by PyCharm
Tip

Use where to return the path of a git-executable that is available in your DOS/Linux/macOS shell
```
(qgis_stable) C:\>where git
C:\Users\geo_beja\AppData\Local\Programs\Git\cmd\git.exe
```
Switch to Project: enmap-box > Project Interpreter and select the QGIS python as python interpreter.

Add the qgis_stable python to the list of python interpreters

Select the qgis_stable python as project interpreter

Switch to Project Structure and add the QGIS python folder as additional project content root.

OSGeo4W	`<your OSGeo4W folder>\bin\python`
Linux	`/usr/bin/python3`
macOS	`/Application/QGIS.app/Contents/MacOS/bin/python3`
conda (win)	`<your conda installation>/envs/qgis_stable/Library/python`
conda (linux)	`<your conda installation>/envs/qgis_stable/share/qgis/python`
conda (macOS)	`<your conda installation>/envs/qgis_stable/QGIS.app/Contents/MacOS/../Resources/python`

Right-click on the plugins subfolder and select Sources. This makes QGIS internal plugins like the “processing” plugin available to PyCharm.

Now the PyQGIS API is available to your Python installation.

Tip

The same way allows you to include other directories to your project’s PYTHONPATH, e.g. to make code available from other folder or repositories.

_images/pycharm_project_content_roots.png

Use qgis_stable/Library/python as additional content root

PyCharm and PyQGIS may need the environmental variable QGIS_PREFIX_PATH. Typical paths are:

QGIS Installation	QGIS_PREFIX_PATH
OSGeo4W	<OSGeo4W>/apps/qgis
Linux
conda (Windows)	<conda installation>\envs\qgis_stable\Library
conda (Linux)	<conda installation>/envs/qgis_stable
conda (macOS)	<conda installation>/envs/qgis_stable/QGIS.app/Contents/Resources

If not already set in the environment from which you started PyCharm, you can set it explicitly. Open Run > Debug … > Edit Configurations and add the QGIS_PREFIX_PATH to the User environmental variables. This way PyCharm runs python files in a environment with QGIS_PREFIX_PATH defined.

Also define the Environment variables for the Python console. Go to File > Settings > Build, Execution, Deployment > Console > Python Console and add QGIS_PREFIX_PATH to the Environment variables.

You may also modify the shell used in your PyCharm terminal to use the QGIS environment. Open Tools > Terminal and set the shell path to, for example:

QGIS Installation	Terminal path
OSGeo4W	`cmd.exe "/K" qgis_env.bat` (see above how to create the `qgis_env.bat`)
conda (Windows)	`cmd.exe "/K" <conda installation>\Scripts\activate.bat qgis_stable`

How to use the conda terminal in PyCharm

Test the Python environment

To check if the QGIS API is available, open a Python Console and import the QgsApplication object.

from qgis.core import QgsApplication
QgsApplication.instance() is None

The output should return True, as we have not initialized any QgsApplication.

Now check if we can use the EnMAP-Box API to start the EnMAP-Box

import enmapbox
enmapbox.run()

This should initialize a new QgsApplication and start the EnMAP-Box. The outputs printed to the python shell should look like:

Application state:
QGIS_PREFIX_PATH env var:               D:\miniconda3\envs\qgis_stable\Library
Prefix:         D:\miniconda3\envs\qgis_stable\Library
Plugin Path:            D:\miniconda3\envs\qgis_stable\Library/plugins
Package Data Path:      D:\miniconda3\envs\qgis_stable\Library/.
Active Theme Name:
Active Theme Path:      D:\miniconda3\envs\qgis_stable\Library/./resources/themes\\icons/
Default Theme Path:     :/images/themes/default/
SVG Search Paths:       D:\miniconda3\envs\qgis_stable\Library/./svg/
        C:\Users\geo_beja\AppData\Local\Temp\QGIS-PythonTestConfigPathp1k7w_s_\profiles\default/svg/
User DB Path:   D:\miniconda3\envs\qgis_stable\Library/./resources/qgis.db
Auth DB Path:   C:\Users\geo_beja\AppData\Local\Temp\QGIS-PythonTestConfigPathp1k7w_s_\profiles\default/qgis-auth.db

If the terminal environment was setup well, you can start the EnMAP-Box from the Terminal window as well by

(qgis_stable) ..\enmap-box>python enmapbox

Other Tools¶

The Qt company provides several tools to that help to create Qt applications and are useful for PyQt and PyQGIS users as well.

Qt Assistant¶

The Qt Assistant allows you to browse fast and offline through Qt help files (*.qch). These files exists for all Qt classes and the QGIS API. They can be generated event with Sphinx, which allows you to provide your own source-code documentation as .qch file as well.

Start the Qt Assistant, e.g. from your PyCharm terminal:
```
(qgis_stable) $>assistant
```
Download the *.qch* files which contain:
- the Qt API documentation files: https://github.com/PierreRaybaut/PyQtdoc
- the QGIS API documentation qgis.qch
Go to Preferences > Add and add the following *.qch files

File Documentation

qgis.qch qgis.core, qgis.gui

qtcore.qch Qt5.QtCore

qtgui.qch Qt5.QtGui

qtwidgets.qch Qt5.QtWidgets

Now you can explore the Qt (Q...) and QGIS (Qgs...) classes

Qt Designer¶

The Qt Designer is a powerful tool to create GUI frontends by drawing, drag and drop. Created GUI form files are saved in a XML file ending with *.ui. These can be called from python to automatically create the entire GUI backend, e.g. windows and buttons defined with the Qt Designer.

You can start the Qt Designer from your PyCharm terminal by:

(qgis_stable) $>designer

Qt Designer showing the metadataeditor.ui for the Metadata editor.

Qt Creator¶

Qt Creator is the one-in-all IDE to develop Qt C++ applications. It includes the functionality covered by Qt Assistant (here called Help) and Qt Designer (here called form designer) and helps to browse C++ code. It is the preferred tool to explore the QGIS C++ source code, for example if you like to better understand what it does behind the QGIS python API.

Qt and the Qt Creator are available at https://www.qt.io/download. Ensure to install the code documentation for the same Qt version used by QGIS.

Qt Creator with opened metadataeditor.ui.

OSGeo4W for Devs¶

If you work on windows and want to test your code based on nightly builds of the upcoming QGIS version, or like to inspect/debug the QGIS C++ API at runtime, you might use the OSGeo4W installer to setup your development environment:

Setup Environment¶

Download the (new) OSGeo4W installer (osgeo4w-setup.exe from https://www.qgis.org/en/site/forusers/download.html )
Install the nightly build branch qgis-dev and related debug symbols qgis-dev-pdb.
Install other required packages, e.g. pip3 etc. Later on. In case of missing packages, search and install via OSGeo4W installer first. If not available there, use the OSGeo4W shell and call pip.

Create a qgis-dev-env.bat to setup your QGIS environment

set OSGEO4W_ROOT=D:\OSGeo4W
set QGISDISTR=qgis-dev
set DIR_GIT=C:\Program Files\Git\cmd
set DIR_LFS=C:\Program Files\Git LFS
:: add GIT and LFS to path

call "%OSGEO4W_ROOT%\bin\o4w_env.bat"
path %OSGEO4W_ROOT%\apps\%QGISDISTR%\bin;%DIR_GIT%;%DIR_LFS%;%PATH%

set QGIS_PREFIX_PATH=%OSGEO4W_ROOT:\=/%/apps/%QGISDISTR%
set GDAL_FILENAME_IS_UTF8=YES
rem Set VSI cache to be used as buffer, see #6448
set VSI_CACHE=TRUE
set VSI_CACHE_SIZE=1000000
set QT_PLUGIN_PATH=%OSGEO4W_ROOT%\apps\%QGISDISTR%\qtplugins;%OSGEO4W_ROOT%\apps\qt5\plugins
set PYTHONPATH=%OSGEO4W_ROOT%\apps\%QGISDISTR%\python;%OSGEO4W_ROOT%\apps\%QGISDISTR%\python\plugins;%PYTHONPATH%

Don’t forget to make git and git-lfs available in this environment.

Create a qgis-dev-pycharm.bat in the same folder as qgis-dev.bat that starts PyCharm

call "%~dp0\QGIS-dev.bat"
set PYCHARM_EXE="C:\Program Files (x86)\JetBrains\PyCharm 2020.3.4\bin\pycharm64.exe"

start "PYCHARM" /B %PYCHARM_EXE%

:: uncomment to start QGIS
:: start "QGIS" /B "%OSGEO4W_ROOT%\bin%QGISDISTR%-bin.exe" %*

Call qgis-dev-pycharm.bat to start PyCharm and set your project settings to:

Project Interpreter: <OSGEO4W>binpython.exe

Using the OSGeo4W python as project interpreter.
Terminal Shell Path: cmd.exe “/K” <your path to>qgis-dev.bat (this is why we created two batch files. qgis-dev.bat setups the environment, but does not start any app)

The qgis-dev.bat will be called when starting the terminal
add <OSGEO4W>appsqgis-devpython and <OSGEO4W>appsqgis-devpythonplugins as source folders

Adding the QGIS python and pythonplugins folder as content roots.

Debug QGIS with Visual Studio¶

Clone the QGIS repo and checkout the latest master
Install Visual Studio and open the QGIS repo
Start a QGIS desktop, e.g. with qgis-dev from the OSGeo4W shell
Attach the Visual Studio debugger to a QGIS desktop instance

Open Debug > Attach to Process (CTRL+ALT+P)
Filter available processes by ‘QGIS’ and, e.g., select qgis-dev-bin.exe
Press the Attach button

References¶

Git -the simple guide (no deep shit) http://rogerdudler.github.io/git-guide/
Qt5 C++ API https://doc.qt.io/qt-5/
QGIS C++ API https://qgis.org/api/
QGIS Python https://qgis.org/pyqgis
QGIS Python developer cookbook https://docs.qgis.org/3.4/en/docs/pyqgis_developer_cookbook

EnMAP-Box repository¶

The EnMAP-Box source code is hosted in a Git repository at https://bitbucket.org/hu-geomatics/enmap-box

Structure¶

Overview¶

The repository contains the following files and folders:

Folder/File	Purpose
doc/	EnMAP-Box Sphinx *.rst documentation
doc_*/	Deprecated doc folders (will be removed)
enmapbox/	EnMAP-Box source code
enmapboxtesting/	Unit tests
scripts/	Scripts to maintain the repository and build the EnMAP-Box QGIS Plugin
examples/	Code examples how to use the EnMAP-Box API
examples/minimumexample/	Exemplary EnMAP-Box Application
site-packages/	Other python libraries the EnMAP-Box depends on
snippets/	Small source code snippets.
CHANGELOG
LICENCE.txt
LICENCE.md
README.md
__init__.py
CONTRIBUTORS.md
index.html
requirements.txt
requirements_developer.txt
setup.py	required for read-the-docs installation
.gitignore	defines files that should be ignored by the repository
.gitattributes	defines binary files that are stored with git-lfs
.readthedocs.yml

Scripts for Developers¶

The scripts directory contains scrips to support developers. Ensure that this folder is part of your python path, e.g add it as source in your PyCharm project (left-mouse, mark directory as source):

Script	Purpose
`scripts/setup_repository.py`	Creates resource files etc. required to test the EnMAP-Box by calling other scripts
`scripts/create_plugin.py`	Create the EnMAP-Box Plugin ZIP file.
`scripts/create_plugin.py`	Create the two shell-scripts `runtests.bat` and `runtests.sh` to run unit tests.
`scripts/install_testdata.py`	Downloads and installs the EnMAP-Box testdata and qgisresources
`scripts/compile_resourcefiles.py`	Complies EnMAP-Box resources (.svg, .png) into *_rc.py files
`scripts/iconselect.py`	Opens a browser to show EnMAP-Box and QGIS resources, e.g. icons

Generated Folders¶

Some directories and files are not part of the repository and explicitly ignore in the .gitignore file, but required or created during the development process. These are:

enmapboxtestdata/	Official EnMAP-Box testdata. Not part of repository code, can be installed calling `scripts/install:_testdata.py`.
enmapboxunittestdata/	Unit test testdata. Not part of repository code, can be installed calling `scripts/install:_testdata.py`.
qgisresources/	QGIS resources compiled as python modules. Read here for details.
deploy/	Builds of the EnMAP-Box plugin.
deploy/enmapboxplugin	Folder with last EnMAP-Box Plugin build.
deploy/enmapboxplugin.3.X…zip	Zipped version of a EnMAP-box Plugin build.

Install the EnMAP-Box repository¶

Open your shell, clone the EnMAP-Box repository including its submodules:

cd <my_repositories>
git clone --recurse-submodules git@bitbucket.org:hu-geomatics/enmap-box.git
cd enmapbox
git config --local include.path ../.gitconfig

Add <my_repositories>/enmapbox/ as source location to your PyCharm project

(instead of that in your QGIS active profile!)
(Optional) install the QGIS source code repository.
For the next step, but also if you like to discover the QGIS ++ code, it is recommended to install the QGIS repository as well. Some EnMAP-Box scripts can use data from the QGIS source code, e.g. to show images that otherwise are available on runtime in the QGIS Desktop application only.
cd <my_repositories> git clone https://github.com/qgis/QGIS.git
Now define a environmental variable QGIS_REPO in the IDE / PyCharm startup script (4. Setup PyCharm)

OS Command

Windows set QGIS_REPO=<my_repositories/QGIS>

Linux /macOS DIR_REPO=<my_repositories/QGIS> export QGIS_REPO
Run scripts/setup_repository.py to create Qt resource modules and perform a dependency check.

The EnMAP-Box uses the Qt resource system (see https://doc.qt.io/qt-5/resources.html for details) to access icons. This step creates for each Qt resource file (filename.qrc) a corresponding python module (filename.py) that contains a binary encrypted description of resources (icons, images, etc.). During startup, these resources are loaded and can be accessed by resource path strings.

The EnMAP-Box re-uses several icons provided by the QGIS desktop application. For example, the QGIS icon for raster layers is available at :/images/themes/default/mIconPolygonLayer.svg and can be visualized in the QGIS python shell as followed:
icon = QIcon(r':/images/themes/default/mIconRaster.svg') label = QLabel() label.setPixmap(icon.pixmap(QSize(150,150))) label.show()
The QGIS icon for raster (mIconRaster.svg)
If we start and develop application from inside PyCharm, we usually don’t have access to QGIS desktop application resources. However, if you have downloaded the QGIS repository as described above, scripts/setup_repository.py will look for it, compile the resource files and write them into folder enmap-box/qgisresources.

Install / Update EnMAP-Box Testdata¶

The most-recent EnMAP-Box testdata is hosted on https://bitbucket.org/hu-geomatics/enmap-box-testdata/get/master.zip If missing or outdatet, it will be downloaded and installed after a user clicks on Project > Load Example Data. The downloaded data will be extracted into <root>/enmapboxtestdata, with <root> either being the EnMAP-Box repository folder or the QGIS plugin installation folder.

The testdata can be download explicitly:

import enmapbox.dependencycheck
enmapbox.dependencycheck.installTestData(ask=False, overwrite_existing=True)

Get Updates from other Repositories¶

The EnMAP-Box includes source-code from external code repositories. They are defined as submodules in .gitmodules, e.g. like:

[submodule "enmapbox/qgispluginsupport"]
    path = enmapbox/qgispluginsupport
    url = git://github.com/EnMAP-Box/qgispluginsupport.git
    pushurl = git@github.com:EnMAP-Box/qgispluginsupport.git
    branch = master

Updating submodules from its origin lication (url) can be done by: .. code-block:: bash

cd enmapbox git submodule update –remote

Pushing local modification into a new branch of the submodule’s origin can be done with:

cd <path/submodule>
git add .
git commit -m "my changes"
git push -u origin HEAD:my_update_branch

Build and publish the EnMAP-Box¶

Build the EnMAP-Box Plugin¶

Building the EnMAP-Box plugin is done by creating a zip file which the QGIS Plugin Manager can use to install the EnMAP-Box. This requires that you have setup your development environment as described in the installation for developers

Calling:

python scripts/create_plugin.py

creates or updates the folder deploy with:

the folder enmapboxplugin. It contains the plugin code and additional files
a file named like enmapboxplugin.3.7.20190214T1125.develop.zip. This is the enmapboxplugin` folder compresses as zip file, which can be used by the QGIS Plugin Installer to install the EnMAP-Box.

Using the -t keyword adds the EnMAP-Box test data, so that you can use and test the EnMAP-Box in QGIS with having example data already installed.

Note

The <subsubversion> consists of <date>T<time>.<active branch> and is generated automatically.

This helps to generate, test and differentiate between EnMAP-Box versions of different development steps.

A successful build ends with a printout like:

### To update/install the EnMAP-Box, run this command on your QGIS Python shell:

from pyplugin_installer.installer import pluginInstaller
pluginInstaller.installFromZipFile(r"C:\Users\user\Repositories\QGIS_Plugins\enmap-box\deploy\enmapboxplugin.3.5.20191030T0634.develop.zip")
#### Close (and restart manually)

QProcess.startDetached(QgsApplication.arguments()[0], [])
QgsApplication.quit()

## press ENTER

Copy and run it in your QGIS python shell to install the build EnMAP-Box plugin and restart QGIS. Alternatively, you can install the plugin in QGIS with a few mouse clicks more by:

Open the QGIS Plugin Manager
Install from ZIP with the created ZIP file
Restart QGIS to account for activate changes in python code

Build the EnMAP-Box documentation¶

To create the HTML based documentation on your local system call:

cd doc
make html

This creates the folder doc/build with the HTML documentation. To view the documentation, just open doc/build/html/index.html in your webbrowser of choice.

Publish the EnMAP-Box¶

Official EnMAP-Box plugin master versions are named like enmapboxplugin.3.3.20190214T1125.master.zip. They need to be uploaded to http://plugins.qgis.org/plugins/ using an OSGeo account.

Other versions, e.g. development snapshots are named like enmapboxplugin.3.3.20190214T1125.develop.zip or enmapboxplugin.3.3.20190214T1125.my_feature_branch.zip and might be distributed using the repositories download section https://bitbucket.org/hu-geomatics/enmap-box/downloads/.

Updates to the EnMAP-Box documentation (folder doc/source) are detected by readthedocs when pushed to the develop or master branch of the EnMAP-Box repository.

Dev Cookbook¶

EnMAP Cookbook¶

The following examples show how to interact with the EnMAP-Box GUI. They are available unittest TestCases in examples/api_examples.py

Important

For simplicity, we always import the following Qt and QGIS libraries globally:

from qgis.core import *
from qgis.gui import *
from qgis.PyQt.QtWidgets import *
from qgis.PyQt.QtGui import *
from qgis.PyQt.QtCore import *

So we can use several classes like QgsMapCanvas or QWidget and do not need to import them explicitly.

1. Start the EnMAP-Box¶

As we like to start our examples from an IDE like PyCharm, we first need to start a QgsApplication. It provides the main GUI loop that receives user interactions, like mouse clicks and keyboard entries:

from enmapbox.testing import start_app
qgsApp = start_app()

Now we can start and open the EnMAP-Box and load some example data:

from enmapbox import EnMAPBox
enmapBox = EnMAPBox(None)
enmapBox.openExampleData()
qgsApp.exec_()

If we would’nt call the GUI loop with qgsApp.exec_(), our program will terminate immediately.

The EnMAPBox object is a singleton, which means that there exist only one EnMAPBox instance. You can connect to a running EnMAP-Box instance like this:

from enmapbox import EnMAPBox
enmapBox = EnMAPBox.instance()
print(enmapBox)

Finally, shut down the EnMAP-Box instance:

enmapBox = EnMAPBox.instance()
enmapBox.close()

2. Data Sources¶

Add Data Sources¶

The EnMAP-Box differentiates between Raster, Vector, Spectral Libraries and other data sources. To add new data sources, you just need to provide a file-path or other unique resource identifier via enmapBox.addSource(r'uri')

enmapBox = EnMAPBox.instance()

# add some data sources
from enmapboxtestdata import enmap as pathRasterSource
from enmapboxtestdata import landcover_polygons as pathVectorSource
from enmapboxtestdata import library as pathSpectralLibrary

#add a single source
enmapBox.addSource(pathRasterSource)

#add a list of sources
enmapBox.addSources([pathVectorSource, pathSpectralLibrary])

A the EnMAP-Box uses the QGIS API to visualize spatial data, we can add OpenGIS Web Services (OWS) like Web Map Services (WMS) and Web Feature Services (WFS) as well:

  wmsUri = 'referer=OpenStreetMap%20contributors,%20under%20ODbL&type=xyz&url=http://tiles.wmflabs.org/hikebike/%7Bz%7D/%7Bx%7D/%7By%7D.png&zmax=17&zmin=1'
  wfsUri = r'restrictToRequestBBOX=''1'' srsname=''EPSG:25833'' typename=''fis:re_postleit'' url=''http://fbinter.stadt-berlin.de/fb/wfs/geometry/senstadt/re_postleit'' version=''auto'''
  enmapBox.addSource(wmsUri, name="Open Street Map")
  enmapBox.addSource(wfsUri, name='Berlin PLZ')

.. image:: ../img/gstart_datasources.png
   :width: 100%

List Existing Data Sources¶

You can iterate over all or specific type of data sources:

for source in enmapBox.dataSources():
    print(source)

for source in enmapBox.dataSources('RASTER'):
    print(source)

Remove Data Sources¶

Data sources can be removed by its source path:

enmapBox = EnMAPBox.instance()
enmapBox.removeSource('source_path')

# or remove multiple sources
enmapBox.removeSources(['list-of-source_path'])

Data Sources are unique¶

EnMAP-Box Data sources are unique; which means that only one data source refers to the same source path. Adding the same source multiple times does not change the total number of data sources:

from enmapbox import EnMAPBox
from enmapboxtestdata import enmap

enmapBox = EnMAPBox(None)
enmapBox.addSource(enmap)
print('# data sources: {}'.format(len(enmapBox.dataSources())))

# add the same source again
enmapBox.addSource(enmap)
print('# data sources: {}'.format(len(enmapBox.dataSources())))

Note

Data sources are internally described by the enmapbox.gui.datasources.DataSource class.
A DataSource object stores information on the data source uri, name, type and its creation date.

Receive data source changes:¶

The Qt Signals sigDataSourceAdded and sigDataSourceAdded can be used to be informed on changes of the EnMAP-Box data sources:

from enmapbox import EnMAPBox

enmapBox = EnMAPBox(None)
enmapBox.sigDataSourceAdded.connect(lambda uri:print('DataSource added: {}'.format(uri)))
enmapBox.sigDataSourceRemoved.connect(lambda uri: print('DataSource removed: {}'.format(uri)))

Overwriting a file source and adding it again to the EnMAP-Box will remove the data source first and add it’s again. This allows to react on changes and to ensure data integrity, e.g. to account for changes in file size and metadata.

Create a text file and add it to the EnMAP-Box:

import tempfile, os, time
tempDir = tempfile.mkdtemp()
pathFile = os.path.join(tempDir, 'testfile.txt')

with open(pathFile, 'w', encoding='utf-8') as f:
    f.write('First version')

assert os.path.isfile(pathFile)
enmapBox.addSource(pathFile)
assert len(enmapBox.dataSources()) == 1

This creates a printout like:

DataSource added: C:\Users\user\AppData\Local\Temp\tmp4gjczg1u\testfile.txt

Wait a while, then overwrite the text file and add it again:

time.sleep(2)

with open(pathFile, 'w', encoding='utf-8') as f:
    f.write('Second version')

assert os.path.exists(pathFile)
enmapBox.addSource(pathFile)
assert len(enmapBox.dataSources()) == 1

The shell printouts should be like:

DataSource removed: C:\Users\user\AppData\Local\Temp\tmp4gjczg1u\testfile.txt
DataSource added: C:\Users\user\AppData\Local\Temp\tmp4gjczg1u\testfile.txt

3. Dock Windows¶

The EnMAP-Box Docks to visualize spatial data and spectral libraries. Docks are based on the pyqtgraphDock which inherits QDockWidget, but can be arranged much more flexible, e.g. in nested layouts. We use these Docks as containers for specialized widgets, in particular the enmapbox.gui.mapcanvas.MapCanvas (as MapDock) and the SpectralLibraryWidget (SpectralLibraryDock).

You can create new docks with EnMAPBox.createDock('<dockType>'):

from enmapbox.gui.enmapboxgui import EnMAPBox, Dock, MapDock, SpectralLibraryDock
enmapBox = EnMAP-Box.instance()

enmapBox.createDock('MAP')  # a spatial map
enmapBox.createDock('SPECLIB') # a spectral library
enmapBox.createDock('TEXT') # a text editor
enmapBox.createDock('WEBVIEW') # a browser
enmapBox.createDock('MIME') # a window to drop mime data (for developers)

Dock titles, visibility and behaviour can be modified:

# modify dock properties
mapDock1 = enmapBox.createDock('MAP')
mapDock2 = enmapBox.createDock('MAP')
mapDock3 = enmapBox.createDock('MAP')

# set dock title
mapDock1.setTitle('Map 1 (fixed)')
mapDock2.setTitle('Map 2 (floated)')
mapDock3.setTitle('Map 3 (hidden)')

mapDock2.float()
mapDock3.setVisible(False)

Three map docks. Map 3 is hidden and therefore visible in the dock manager panel only.

Docks can be accessed similar to DataSources:

from enmapbox.gui.docks import Dock, SpectralLibraryDock
for dock in enmapBox.dockManager().docks():
    assert isinstance(dock, Dock)
    print(dock)

The dockType keyword serves as filter:

# list map docks only
for dock in enmapBox.dockManager().docks(dockType='MAP'):
    assert isinstance(dock, Dock)
    print(dock)

# list all spectral library docks
for dock in enmapBox.dockManager().docks(dockType='SPELCIB'):
    assert isinstance(dock, Dock)
    print(dock)

5. Map Tools¶

QgsMapTools control what happens when a user clicks into a QgsMapCanvas, e.g. to zoom in or zoom out. You can set the current map tool as followed:

from enmapbox.gui import MapTools
enmapBox.setMapTool(MapTools.ZoomIn)

The map tool will be set to all MapCanvases known to the EnMAP-Box, in particular those in MapDocks. Possible map tools are:

Key (str)	Key (Enum)	Description
`PAN`	`MapTools.Pan`	Activate pan tool to move the map
`ZOOM_IN`	`MapTools.ZoomIn`	Zoom in
`ZOOM_OUT`	`MapTools.ZoomOut`	Zoom Out
`ZOOM_FULL`	`MapTools.Zoom Full`	Zoom to the full extend
`ZOOM_PIXEL_SCALE`	`MapTools.ZoomPixelScale`	Raster pixel have same size like screen pixel
`CURSOR_LOCATION`	`MapTools.CursorLocation`	Select cursor location information

Map tool icons to pan, zoom in, out, full extent and pixel scale, and to get cursor location information.

6. Spatial Points and Extents¶

Working with spatial data often requires to convert coordinates between different coordinate reference systems (CRS). The EnMAP-Box classes SpatialPoint and SpatialExtent inherit QgsPointXY and QgsRectangle, respectively and enhance their parent classes by keeping a reference on the QgsCoordinateReferenceSystem used to specify the coordinates.

Retrieve a QgsRasterLayer center coordinate and convert it into geographic lat/lon coordinates:

from enmapboxtestdata import enmap
from enmapbox.gui import SpatialPoint

layer = QgsRasterLayer(enmap)
point = SpatialPoint.fromMapLayerCenter(layer)

targetCrs = QgsCoordinateReferenceSystem('EPSG:4326')

print('Original CRS: "{}"'.format(layer.crs().description()))
print('QgsPointXY  : {}'.format(QgsPointXY(point)))
print('SpatialPoint: {}\n'.format(point))

pointTargetCRS = point.toCrs(targetCrs)
print('Target CRS  : "{}"'.format(targetCrs.description()))
print('QgsPointXY  : {}'.format(QgsPointXY(pointTargetCRS)))
print('SpatialPoint: {}\n'.format(pointTargetCRS))

Same can be done with map layer extents:

from enmapbox.gui import SpatialExtent
extent = SpatialExtent.fromLayer(layer)
print('Original CRS: "{}"'.format(layer.crs().description()))
print('QgsRectangle : {}'.format(QgsRectangle(extent)))
print('SpatialExtent: {}'.format(extent))

extentTargetCRS = point.toCrs(targetCrs)
print('Target CRS: "{}"'.format(targetCrs.description()))
print('QgsRectangle : {}'.format(QgsPointXY(pointTargetCRS)))
print('SpatialExtent: {}'.format(extentTargetCRS))

Note

Be aware that some CRS transformations are not possible and might cause errors. This might happen in particular when transforming coordinates from regional projected CRS, like an UTM Zone, into a CRS that is defined for another region of the world.

7. Map Locations and Spectral Profiles¶

The EnMAP-Box emits a sigCurrentLocationChanged signal if the Identify map tool is activated and user left-clicks on a map canvas.

_images/enmapbox_toolbar_identify_location.png

from enmapbox.gui import MapTools, SpatialPoint

def printLocation(spatialPoint:SpatialPoint):
    print('Mouse clicked on {}'.format(spatialPoint))

enmapBox.sigCurrentLocationChanged.connect(printLocation)

The overloaded sigCurrentLocationChanged signature can be used to get the map canvas instance where the location was selected from:

def printLocationAndCanvas(spatialPoint: SpatialPoint, canvas:QgsMapCanvas):
    print('Mouse clicked on {} in {}'.format(spatialPoint, canvas))

enmapBox.sigCurrentLocationChanged[SpatialPoint, QgsMapCanvas].connect(printLocationAndCanvas)

If “Identify raster profile” is activated, the EnMAP-Box extracts SpectralProfiles from the raster layer(s) below the mouse-click location. These spectra can be received from the sigCurrentSpectraChanged signal:

_images/enmapbox_toolbar_identify_spectral_profiles.png

def printSpectralProfiles(currentSpectra:list):

    print('{} SpectralProfiles collected'.format(len(currentSpectra)))
    for i, p in enumerate(currentSpectra):
        assert isinstance(p, QgsFeature)
        p = SpectralProfile.fromSpecLibFeature(p)
        assert isinstance(p, SpectralProfile)
        print('{}: {}'.format(i+1, p.values()['y']))

enmapBox.sigCurrentSpectraChanged.connect(printSpectralProfiles)

The last cursor location and/or spectral profiles are saved and can be accessed:

print('Last location: {}'.format(enmapBox.currentLocation()))
print('Last SpectralProfile: {}'.format(enmapBox.currentSpectra()))

Create EnMAP-Box Applications¶

Applications for the EnMAP-Box define an EnMAPBoxApplication instance that describes basic information like the Applications name and how a user can start it. The following examples are taken from the examples/minimumexample package, which you might copy and modify to implement own EnMAPBox Applications.

1. Initialize a new EnMAP-Box Application¶

An EnMAP-Box application inherits from EnMAPBoxApplication and defines basic information like a name and version. The variable license defaults to GNU GPL-3, but might be changed:

from qgis.PyQt.QtGui import QIcon
from qgis.PyQt.QtWidgets import QMenu, QAction, QWidget, QHBoxLayout, QLabel, QPushButton
from enmapbox.gui.applications import EnMAPBoxApplication
from qgis.core import *


VERSION = '0.0.1'
LICENSE = 'GNU GPL-3'
APP_DIR = os.path.dirname(__file__)

APP_NAME = 'My First EnMAPBox App'

class ExampleEnMAPBoxApp(EnMAPBoxApplication):
    """
    This Class inherits from an EnMAPBoxApplication
    """
    def __init__(self, enmapBox, parent=None):
        super(ExampleEnMAPBoxApp, self).__init__(enmapBox, parent=parent)

        #specify the name of this app
        self.name = APP_NAME

        #specify a version string

        self.version = VERSION

        #specify a licence under which you distribute this application
        self.licence = LICENSE

2. Define an Menu¶

To become accessible via a menu of the EnMAP-Box, the application needs to implement EnMAPBoxApplication.menu(…) to return a QAction or (better) a QMenu with multiple QActions. By default, the returned object is added to the EnMAP-Box “Application” menu from where users can start the QAction that you defined:

def menu(self, appMenu):
    """
    Returns a QMenu that will be added to the parent `appMenu`
    :param appMenu:
    :return: QMenu
    """
    assert isinstance(appMenu, QMenu)
    """
    Specify menu, submenus and actions that become accessible from the EnMAP-Box GUI
    :return: the QMenu or QAction to be added to the "Applications" menu.
    """

    # this way you can add your QMenu/QAction to an other menu entry, e.g. 'Tools'
    # appMenu = self.enmapbox.menu('Tools')

    menu = appMenu.addMenu('My Example App')
    menu.setIcon(self.icon())

    #add a QAction that starts a process of your application.
    #In this case it will open your GUI.
    a = menu.addAction('Show ExampleApp GUI')
    assert isinstance(a, QAction)
    a.triggered.connect(self.startGUI)
    appMenu.addMenu(menu)

    return menu

3. Define QgsProcessingAlgorithms for the EnMAPBoxAlgorithm Provider¶

Your Application might provide one or multiple QgsProcessingAlgorithms for the QGIS Processing Framework. This way your algorithms become visible in the QGIS Processing Toolbox and can be used in the QGIS Model Builder. To add your QgsProcessingAlgorithms to the EnMAP-Box Algorithm Provider implement EnMAPBoxApplication.processingAlgorithms(…).

For the sake of simplicity, let’s define a simple function and a QgsProcessingAlgorithm to call it:

def exampleAlgorithm(*args, **kwds)->list:
    """
    An dummy algorithm that prints the provided arguments and keywords and returns its inputs.
    """
    print('Start exampleAlgorithm...')

    text = ['Arguments: {}'.format(len(args))]
    for i, a in enumerate(args):
        text.append('Argument {} = {}'.format(i+1, str(a)))

    text.append('Keywords: {}'.format(len(kwds)))
    for key, parameter in kwds.items():
        text.append('{} = {}'.format(key, parameter))
    print('\n'.join(text))
    print('exampleAlgorithm finished')

    return args, kwds


class ExampleProcessingAlgorithm(QgsProcessingAlgorithm):
    """
    Exemplary implementation of a QgsProcessingAlgorithm.
    See https://qgis.org/api/classQgsProcessingAlgorithm.html for API documentation
    """
    def __init__(self):
        super(ExampleProcessingAlgorithm, self).__init__()

    def createInstance(self)->QgsProcessingAlgorithm:
        """
        Creates a new instance of the algorithm class.
        :return: QgsProcessingAlgorithm
        """
        return ExampleProcessingAlgorithm()

    def name(self)->str:
        return 'examplealgorithm'

    def displayName(self):
        return 'Minimal Example Algorithm'

    def groupId(self)->str:
        """
        Returns the unique ID of the group this algorithm belongs to.
        :return: str
        """
        return GROUP_ID

    def group(self)->str:
        """
        Returns the name of the group this algorithm belongs to.
        :return: str
        """
        return APP_NAME

    def initAlgorithm(self, configuration:dict=None):
        """
        Initializes the algorithm using the specified configuration.
        :param configuration: dict
        """
        self.addParameter(QgsProcessingParameterRasterLayer('pathInput', 'The Input Dataset'))
        self.addParameter(QgsProcessingParameterNumber('value','The value', QgsProcessingParameterNumber.Double, 1, False, 0.00, 999999.99))
        self.addParameter(QgsProcessingParameterRasterDestination('pathOutput', 'The Output Dataset'))

    def processAlgorithm(self, parameters:dict, context:QgsProcessingContext, feedback:QgsProcessingFeedback):
        """
        Runs the algorithm using the specified parameters.
        :param parameters: dict
        :param context: QgsProcessingContext
        :param feedback: QgsProcessingFeedback
        :return: dict
        """
        assert isinstance(parameters, dict)
        assert isinstance(context, QgsProcessingContext)
        assert isinstance(feedback, QgsProcessingFeedback)

        args, kwds  = exampleAlgorithm(parameters)

        outputs = {'args' : args, 'kwds': kwds}
        return outputs

Now define EnMAPBoxApplication.processingAlgorithms(…) to add the ExampleProcessingAlgorithm to the EnMAPBoxProcessingProvider:

def processingAlgorithms(self)->list:
    """
    This function returns the QGIS Processing Framework algorithms specified by your application
    :return: [list-of-QgsProcessingAlgorithms]
    """

    return [ExampleProcessingAlgorithm()]

Calling the ExampleProcessingAlgorithm from the QGIS Processing Toolbox should now create a printout on your python console like:

Parameters:
pathInput = <qgis._core.QgsRasterLayer object at 0x0000018AA3C47A68>
pathOutput = <QgsProcessingOutputLayerDefinition {'sink':C:/Users/ivan_ivanowitch/AppData/Local/Temp/processing_cb76d9820fc64087aa8264f0f8505334/642d8e0abb764557881346399dda9c68/pathOutput.bsq, 'createOptions': {'fileEncoding': 'System'}}>
value = 1.0

4. Create a Graphical User Interface¶

The startGUI() function is used to open the graphical user interface. A very simple GUI could be:

def onButtonClicked():
    print('Button was pressed')

w = QWidget()
w.setLayout(QVBoxLayout())
w.layout().addWidget(QLabel('Hello World'))
btn = QPushButton()
btn.setText('click me')
btn.clicked.connect(onButtonClicked)
w.layout().addWidget(btn)
w.show()

A GUI quickly becomes complex if programmed line-by-line only. We prefer to use the QDesigner. It allows to draw the GUI frontend which then is saved as *.ui XML file. This file can be translated into the PyQt code where you just write the backend.

List of environmental variables¶

Warning

This will be changed soon

The following environmental variables can be set to change the starting behaviour of the EnMAP-Box.

Name	Values, * = Default	Description
EMB_LOAD_PF	TRUE*/FALSE	Load QGIS processing framework.
EMB_LOAD_EA	TRUE*/FALSE	Loads external applications.
EMB_DEBUG	TRUE/FALSE*	Enable additional debug printouts.
EMB_SPLASHSCREEN	TRUE*/FALSE	Splashscreen on EnMAP-Box start.
EMB_MESSAGE_TIMEOUT	integer	Timeout in seconds for popup messages in the message bar.
EMB_APPLICATION_PATH	string	list of directories (separated by ‘;’ or ‘n’ (newline)) to load EnMAPBoxApplications from.

Further links and sources¶

https://docs.python.org/devguide

Git for Beginners¶

PyQGIS¶

Python Code Documentation¶

RFC list¶

This section is a collection of request for comments (RFC).

RFC 1: Enhanced GDAL PAM for QGIS Raster Layers¶

Author: Andreas Janz

Contact: andreas.janz@geo.hu-berlin.de

Started: 2021-12-23

Last modified: 2022-01-10

Status: Proposed

Summary¶

It is proposed that the well known GDAL raster metadata handling is extented to QgsRasterLayer objects via the custom layer property interface. This approach is refered to as QGIS PAM (in analogy to the existing GDAL PAM).

By default, information is fetched from QGIS PAM first, and, if not available, from GDAL PAM as usual.

Edits to QGIS PAM are stored as map layer custom properties (QgsMapLayer.customProperties), which are stored in-memory at the layer object, inside the QGIS project, and inside layer QML style file.

API support for QGIS PAM management will be implemented in the enmapboxprocessing.rasterreader.RasterReader class.

Motivation¶

GDAL organises raster metadata in a PAM (Persistent Auxiliary Metadata) *.aux.xml file. Reading and writing GDAL PAM items is done via gdal.Dataset and gdal.Band objects.

Currently we restrict metadata handling to GDAL raster. Metadata IO is implemented using the GDAL API:

On the dataset level we use:

value = gdal.Dataset.GetMetadataItem(key, domain)
valueDict = gdal.Dataset.GetMetadata(domain)
valuesDictDict = gdal.Dataset.GetMetadata_Dict()

gdal.Dataset.SetMetadataItem(key, value, domain)
gdal.Dataset.SetMetadata(valueDict, domain)
gdal.Dataset.SetMetadata_Dict(valueDictDict)

On the band level we use:

value = gdal.Band.GetMetadataItem(key, domain)
valueDict = gdal.Band.GetMetadata(domain)
valuesDictDict = gdal.Band.GetMetadata_Dict()

gdal.Band.SetMetadataItem(key, value, domain)
gdal.Band.SetMetadata(valueDict, domain)
gdal.Band.SetMetadata_Dict(valueDictDict)

This is fully sufficient for raster processing, but can be limiting in GUI applications, where we usually don’t use gdal.Dataset, but QgsRasterLayer objects.

Problem: QgsRasterLayer class can’t access GDAL PAM directly. We need to re-open the layer source via gdal.Open, which is usually fine for read-access. But when writing new items to the GDAL PAM aux.xml file, the approach fails, because QGIS will overwrite the aux.xml file again, when the QgsRasterLayer object is closed.

Approach¶

We introduce another level of abstraction on top of GDAL PAM, using QGIS custom properties (i.e. QGIS PAM)

On the dataset level we use the following standardized property key format:

value = layer.customProperty('QGISPAM/dataset/<domain>/<key>')

layer.setCustomProperty('QGISPAM/dataset/<domain>/<key>', value)

On the band level we use:

value = layer.customProperty('QGISPAM/band/<bandNo>/<domain>/<key>')

layer.setCustomProperty('QGISPAM/band/<bandNo>/<domain>/<key>', value)

An application that queries metadata from a raster source should use the following priorities:

Check QGIS PAM first.
If not found, check GDAL PAM afterwards.
If still not found, use a suitable fallback value.

Technically: QGIS PAM shadows GDAL PAM

Guide line 1:: If you need to set metadata in a processing algorithm: set it to GDAL PAM, so that GDAL can read it later!
Guide line 2:: If you need to set/update metadata in a GUI application: set it to QGIS PAM.

Implementation¶

Technically, we don’t need any new functions or methods, because we fully rely on the layer custom property interface.

But, the handling of property keys, and QGIS PAM over GDAL PAM priority, can be tedious and should be encapsulated in utils functions or methods. An example implementation is given by the RasterReader class.

On the dataset level we can use:

from enmapboxprocessing.rasterreader import RasterReader

reader = RasterReader(layer)
value = reader.metadataItem(key, domain)

reader.setMetadataItem(key, value, domain)

On the band level we use:

from enmapboxprocessing.rasterreader import RasterReader

reader = RasterReader(layer)
value = reader.metadataItem(key, domain, bandNo)

reader.setMetadataItem(key, value, domain, bandNo)

Also check out the RasterReader unittests: https://bitbucket.org/hu-geomatics/enmap-box/src/develop/enmapboxprocessing/test/test_rasterreaderrfc1.py

RFC 2: Spectral Properties¶

Author: Andreas Janz

Contact: andreas.janz@geo.hu-berlin.de

Started: 2021-12-23

Last modified: 2021-12-24

Status: Proposed

Summary¶

It is proposed to implement functions or methods for reading and writing spectral properties from/to QGIS PAM. Relevant items are: center wavelength, wavelength units, full width at half maximum (fwhm) and bad band multiplier values.

Both, QGIS and GDAL, don’t have a concept for spectral property management. In GDAL we have rudimentary support for ENVI files. We currently use the ENVI format as a conceptual base for spectral property handling in the EnMAP-Box.

The here proposed approach will integrate spectral property handling into QGIS PAM management, while honoring the well known ENVI format and naming conventions. This allows to set/update spectral properties for QgsRasterLayer objects, which is critical for GUI applications.

API support will be implemented in the enmapboxprocessing.rasterreader.RasterReader class.

Motivation¶

GDAL has rudimentary support for spectral properties specified inside ENVI *.hdr header files:

ENVI
...
wavelength units = Micrometers
wavelength = {0.46, 0.465, 0.47, ..., 2.393, 2.401, 2.409}
fwhm = {0.0058, 0.0058, 0.0058, ..., 0.0091, 0.0091, 0.0091}
bbl = {1, 1, 1, ..., 1, 1, 1}

GDAL will dump all items into the ENVI dataset domain, including relevant spectral properties like the list of center wavelength, the wavelength units, the list of full width at half maximum (fwhm) values, and the list of bad band multipliers (bbl):

<Metadata domain="ENVI">
  ...
  <MDI key="fwhm">{ 0.005800, 0.005800, 0.005800, ..., , 0.009100, 0.009100, 0.009100}</MDI>
  <MDI key="wavelength">{ 0.46, 0.465, 0.47, ..., 2.393, 2.401, 2.409}</MDI>
  <MDI key="bbl">{ 1, 1, 1, ..., 1, 1, 1}</MDI>
  <MDI key="wavelength_units">Micrometers</MDI>
</Metadata>

GDAL will store the wavelength units inside the default dataset domain:

<Metadata>
  <MDI key="wavelength_units">Micrometers</MDI>
</Metadata>

For each band, GDAL will store center wavelength and wavelength units inside the band default domain:

<PAMRasterBand band="1">
  <Metadata>
    <MDI key="wavelength">0.46</MDI>
    <MDI key="wavelength_units">Micrometers</MDI>
  </Metadata>
</PAMRasterBand>
<PAMRasterBand band="2">
  <Metadata>
    <MDI key="wavelength">0.465</MDI>
    <MDI key="wavelength_units">Micrometers</MDI>
  </Metadata>
</PAMRasterBand>
...

Given that ENVI specific behaviour, we propose the following approach for fetching band-specific spectral properties.

Approach¶

Band-wise spectral properties like wavelength, wavelength units, full width at half maximum (fwhm), and bad band multiplier values, are fetched with the following priorisation:

1. Look at QGIS PAM band default domain. This is mainly relevant for GUI applications, where we need to set/update spectral properties using QgsRasterLayer objects:

wavelengthUnits = layer.customProperty('QGISPAM/band/42//wavelength_units')
wavelength = layer.customProperty('QGISPAM/band/42//wavelength')
fwhm = layer.customProperty('QGISPAM/band/42//fwhm')
badBandMultiplier = layer.customProperty('QGISPAM/band/42//bad_band_multiplier')

2. Look at GDAL PAM band default domain. This follows the behaviour of the ENVI driver, that sets wavelength and wavelength units to this location. We consequently also look for fwhm and bad band multiplier here:

wavelengthUnits = gdalDataset.GetRasterBand(42).GetMetadataItem('wavelength_units')
wavelength = gdalDataset.GetRasterBand(42).GetMetadataItem('wavelength')
fwhm = gdalDataset.GetRasterBand(42).GetMetadataItem('fwhm')
badBandMultiplier = gdalDataset.GetRasterBand(42).GetMetadataItem('bbl')

3. Look at GDAL PAM dataset ENVI domain. This follows the behaviour of the ENVI driver, that sets lists of wavelength, fwhm and bad band multipliers (bbl) and the wavelength units to this location:

wavelengthUnit = gdalDataset.GetMetadataItem('wavelength_unit', 'ENVI')
wavelength = parseEnviString(gdalDataset.GetMetadataItem('wavelength', 'ENVI'))[42 - 1]
fwhm = parseEnviString(gdalDataset.GetMetadataItem('fwhm', 'ENVI'))[42 - 1]
badBandMultiplier = parseEnviString(gdalDataset.GetMetadataItem('bbl', 'ENVI'))[42 - 1]

4. Look at GDAL PAM dataset default domain:: This follows the behaviour of the ENVI driver, that set the wavelength units to this location. We consequently also look for lists of wavelength, fwhm and bad band multipliers (bbl) here:

wavelengthUnit = gdalDataset.GetMetadataItem('wavelength_unit')
wavelengthList = parseEnviString(gdalDataset.GetMetadataItem('wavelength'))[42 - 1]
badBandMultiplier = parseEnviString(gdalDataset.GetMetadataItem('bbl'))[42 - 1]

Note that the parseEnviString function is assumed to parse ENVI list string like ‘{1, 2, 3}’ into Python lists like [1, 2, 3].

Guide line 1:: If you need to set band-wise spectral properties in a processing algorithm: set it to the GDAL PAM band default domain. This way, i) the information is accessible with the GDAL API, and ii) consecutive band subsetting via gdal.Translate and gdal.BuildVrt can easily copy the band domains to the destination dataset.
Guide line 2:: If you need to set/update metadata in a GUI application: set it to QGIS PAM. This is most flexible and secure. The spectral properties are i) available as custom layer properties, ii) stored in the QGIS project, and iii) can be saved to QML layer style files.
Guide line 3:: Do not update GDAL PAM *.aux.xml file, while the corresponding source is opened as a QgsRasterLayer in QGIS. QGIS will potentially overwrite any changes, when closing the layer.

Implementation¶

Technically, we don’t need any new functions or methods, because we fully rely on QGIS PAM.

But, the handling of property keys, and the assurance of fetching priorities, can be tedious and should be encapsulated in util functions or methods. An example implementation is given by the RasterReader class.

To query spectral properties for band 42 (in nanometers), we can use:

from enmapboxprocessing.rasterreader import RasterReader

reader = RasterReader(layer)
wavelength = reader.wavelength(42)
fwhm = reader.fwhm(42)
badBandMultiplier = reader.badBandMultiplier(42)

The destination wavelength units (default is nanometers) can also be stated:

wavelengthInNanometers = reader.wavelength(42, 'nanometers')
wavelengthInMicrometers = reader.wavelength(42, 'micrometers')
wavelengthInMillimeters = reader.wavelength(42, 'millimeters')
wavelengthInMeter = reader.wavelength(42, 'meters')

To find the band closest to 850 nanometers use:

bandNo = reader.findWavelength(850)
bandNo = reader.findWavelength(0.850, 'micrometers')

Also check out the RasterReader unittests: https://bitbucket.org/hu-geomatics/enmap-box/src/develop/enmapboxprocessing/test/test_rasterreaderrfc2.py

RFC 3: Temporal Properties¶

Author: Andreas Janz

Contact: andreas.janz@geo.hu-berlin.de

Started: 2021-12-24

Last modified: 2021-12-26

Status: Proposed

Summary¶

It is proposed to implement functions or methods for reading and writing temporal properties from/to QGIS PAM, while also concidering the existing QgsRasterLayerTemporalProperties layer properties for QgsRasterLayer.

A survey of software (QGIS, GDAL, ENVI, Google Earth Engine) and EO product metadata formats (Landsat, Sentinel-2, EnMAP, DESIS) shows that there is no clear naming convention for temporal properties. We observe two types of temporal annotation: a) specification of a scene center time, and b) specification of a temporal range (start time and end time).

The specification of scene center time may be sufficient for individual images (e.g. a single Landsat scene), but is not suitable for larger area products like daily MODIS composite products, or other derived cloud-free composites using scenes from a temporal range (e.g. a full year).

Thus, we propose to use the more general temporal range concept. Usecases where a center time is sufficient, may just specify the start time.

We further propose to support spectral-temporal timeseries stacks (e.g. a stack of Landsat images, or a stack of cloud-free full-year NDVI composites). This would allow proper plotting of spectral-temporal timeseries profiles, which is currently (v3.9) not well supported in the EnMAP-Box.

API support will be implemented in the enmapboxprocessing.rasterreader.RasterReader class.

Motivation¶

Temporal property naming convensions in software and EO product metadata formats are quite diverse.

QGIS

QGIS has functionality for managing temporal properties (QgsRasterLayerTemporalProperties) of a QgsRasterLayer:

>>>layer.temporalProperties()
>>>layer.temporalProperties().fixedTemporalRange()
>>>layer.temporalProperties().fixedTemporalRange().begin()
>>>layer.temporalProperties().fixedTemporalRange().end()
<qgis._core.QgsRasterLayerTemporalProperties object>
<qgis._core.QgsDateTimeRange object>
PyQt5.QtCore.QDateTime(2021, 12, 24, 0, 0, 0, 0)
PyQt5.QtCore.QDateTime(2021, 12, 25, 0, 0, 0, 0)

GDAL

The GDAL Raster Data Model suggests to specify ACQUISITIONDATETIME as dataset-level IMAGERY-domain metadata:

# see https://gdal.org/user/raster_data_model.html#imagery-domain-remote-sensing
<PAMDataset>
  <Metadata domain="IMAGERY">
    <MDI key="ACQUISITIONDATETIME">2021-12-24T12:30:42.123</MDI>
  </Metadata>

ENVI files may specify the acquisition time as dataset-level ENVI-domain metadata:

<PAMDataset>
  <Metadata domain="ENVI">
    <MDI key="acquisition_time">2021-12-24T12:30:42.123</MDI>
  </Metadata>

GeoTiff files may specify the TIFFTAG_DATETIME baseline TIFF tag as dataset-level metadata:

<PAMDataset>
  <Metadata>
    <MDI key="TIFFTAG_DATETIME">2019:12:12 19:10:18</MDI>
  </Metadata>

Since some software use the TIFFTAG_DATETIME to store file creation/manipulation time, and EO data provider don’t use it to specify acquisition time, we propose to ignore it.

Google Earth Engine

Google Earth Engine images specify system:time_start and system:time_end properties in milliseconds since Unix Epoch (1970-01-01T00:00:00):

Image MODIS/006/MOD09GA/2012_03_09
    properties
        system:time_start: 1331251200000        # 2012-03-09T00:00:00
        system:time_end: 1331337600000          # 2012-03-10T00:00:00

Landsat products

Landsat products specify DATE_ACQUIRED and SCENE_CENTER_TIME properties in the *MTL.txt metadata file:

GROUP = LANDSAT_METADATA_FILE
  GROUP = IMAGE_ATTRIBUTES
    DATE_ACQUIRED = 2021-07-24
    SCENE_CENTER_TIME = "09:56:22.1248370Z"

Sentinel-2 products

Sentinel-2 products specify PRODUCT_START_TIME and PRODUCT_STOP_TIME properties in the MTD_MSIL2A.xml metadata file:

<n1:Level-2A_User_Product ...
    <n1:General_Info>
        <Product_Info>
            <PRODUCT_START_TIME>2020-08-16T10:10:31.024Z</PRODUCT_START_TIME>
            <PRODUCT_STOP_TIME>2020-08-16T10:10:31.024Z</PRODUCT_STOP_TIME>

EnMAP and DESIS products

EnMAP and DESIS products specify startTime and endTime properties in the METADATA.xml metadata file:

<hsi_doc ...>
  <base>
    <temporalCoverage>
      <startTime>2019-12-03T02:14:39.035473Z</startTime>
      <endTime>2019-12-03T02:14:43.381243Z</endTime>

PRISMA products

PRISMA products specify Product_StartTime and Product_StopTime properties in each HE5 sub-dataset:

Product_StartTime=2020-11-07T10:14:04.343999
Product_StopTime=2020-11-07T10:14:08.649690

The survey shows that there is no clear naming convention for temporal properties. We observe two types of temporal annotation: a) specification of a scene center time, and b) specification of a temporal range (start time and end time).

All formats only take single scene images into account. None of the formats is suitable for specifying temporal properties of a timeseries stack (e.g. a stack of Landsat images, or a stack of cloud-free full-year NDVI composites), where each band may have an individual temporal range.

The here proposed approach will integrate temporal property handling into QGIS PAM management, while honoring well known software format and naming conventions, and available QgsRasterLayerTemporalProperties information. This allows to set/update temporal properties for QgsRasterLayer objects, which is critical for GUI applications. It also takes care of information stored as GDAL PAM.

A key feature is the support for timeseries stacks, that is a prerequisite for proper plotting of spectral-temporal timeseries data, which is not well supported in the EnMAP-Box. We currently (v3.9) only support single content timeseries stacks (e.g. a stack of NDVI bands). where time information is specified as decimal years in the ENVI-domain wavelength item. This quite hacky approach is well known in the ENVI Classic community for creating temporal profile plots.

We propose the following approach for fetching band-specific temporal properties.

Approach¶

Band-wise temporal start time and end time properties are fetched with the following priorisation:

1. Look at QGIS PAM band-level default-domain. This is mainly relevant for GUI applications, where we need to set/update temporal properties using QgsRasterLayer objects:

startTime: QDateTime = layer.customProperty('QGISPAM/band/42//start_time')
endTime = layer.customProperty('QGISPAM/band/42//end_time')

Look at GDAL PAM band-level default-domain:

startTime = parseDateTimeString(gdalDataset.GetRasterBand(42).GetMetadataItem('start_time'))
endTime = parseDateTimeString(gdalDataset.GetRasterBand(42).GetMetadataItem('end_time'))

3. Look at GDAL PAM dataset-level IMAGERY-domain. This follows the GDAL Raster Data Model specification, that assumes the ACQUISITIONDATETIME to be set to this location:

centerTime = parseDateTimeString(gdalDataset.GetMetadataItem('ACQUISITIONDATETIME', 'IMAGERY'))

3. Look at GDAL PAM dataset-level ENVI-domain. This follows the behaviour of the ENVI driver, that sets the acquisition time to this location:

centerTime = parseDateTimeString(gdalDataset.GetMetadataItem('acquisition_time', 'ENVI'))

Note that the parseDateTimeString function is assumed to parse timestamps into QDateTime objects. It is proposed to support the following formats:

2021-12-24                  # date
2021-12-24T12:30:42.123...  # date time
1640349042123               # Unix epoche timestamp in milliseconds since 1970-01-01T00:00:00.000

Also note that we don’t support the various sensor product and software naming conventions presented in the survey above. We assume that the acquisition time is properly set to the GDAL PAM dataset-level IMAGERY-domain during product import.

Guide line 1:: If you need to set band-wise temporal properties in a processing algorithm: set it to the GDAL PAM band-level default-domain. This way, i) the information is accessible with the GDAL API, and ii) consecutive band subsetting via gdal.Translate and gdal.BuildVrt can easily copy the band domains to the destination dataset.
Guide line 2:: If you need to set/update metadata in a GUI application: set it to QGIS PAM. This is most flexible and secure. The temporal properties are i) available as custom layer properties, ii) stored in the QGIS project, and iii) can be saved to QML layer style files.
Guide line 3:: Do not update GDAL PAM *.aux.xml file, while the corresponding source is opened as a QgsRasterLayer in QGIS. QGIS will potentially overwrite any changes, when closing the layer.

Implementation¶

Technically, we don’t need any new functions or methods, because we fully rely on QGIS PAM and the QgsRasterLayerTemporalProperties.

But, the handling of property keys, and the assurance of fetching priorities, can be tedious and should be encapsulated in util functions or methods. An example implementation is given by the RasterReader class.

To query temporal properties for band 42, we can use:

from enmapboxprocessing.rasterreader import RasterReader

reader = RasterReader(layer)
startTime = reader.startTime(42)
endTime = reader.endTime(42)
centerTime = reader.centerTime(42)  # derives temporal range center time

In case of a standart image, where all bands share the same time range, you may skip the band number:

startTime = reader.startTime()
endTime = reader.endTime()
centerTime = reader.centerTime()

To set temporal properties use:

# for band 42
reader.setStartTime(startTime, 42)
reader.setEndTime(endTime, 42)

# for each band
reader.setStartTime(startTime)
reader.setEndTime(endTime)

Find the band whose center time is closest to christmas eve. If multiple bands match, the first is returned.:

bandNo = reader.findCenterTime(QDateTime(2021, 12, 24, 18, 00))

Use temporal properties and spectral properties (see RFC 2) together for a full description of a spectral-temporal timeseries:

for bandNo in range(1, layer.bandCount() + 1):
    startTime, endTime = reader.temporalRange(bandNo)
    centerTime = reader.centerTime(bandNo)
    wavelength = reader.wavelength(bandNo)
    print(startTime, endTime, centerTime, wavelength)

Also check out the RasterReader unittests: https://bitbucket.org/hu-geomatics/enmap-box/src/develop/enmapboxprocessing/test/test_rasterreaderrfc3.py

RFC 4: Band Properties¶

Author: Andreas Janz

Contact: andreas.janz@geo.hu-berlin.de

Started: 2022-01-09

Last modified: 2022-01-10

Status: Proposed

Summary¶

It is proposed to implement functions or methods for reading and writing band properties from/to QGIS PAM.

So far we identified the following band properties to be required or useful:

band name
Spectral Properties (see RFC 2): wavelength, wavelength units, fwhm, bad band multiplier
Temporal Properties (see RFC 3): start time, end time
Data Properties: offset, scale, no data value

API support will be implemented in the enmapboxprocessing.rasterreader.RasterReader class.

GUI support will be implemented in the qps.layerconfigwidgets.rasterbands.RasterBandPropertiesConfigWidget class.

Motivation¶

Band property management is a cruitial, but a not well support raster layer preparation step in QGIS and the EnMAP-Box.

We need for example:

band name information to subset or match raster bands by name instead of band numbers, and for setting proper names for reports
wavelength information for plotting spectral profiles
time information for plotting temporal profiles
bad band multipliers to exclude noisy bands from specific plotting/analysis tasks
data offset and scale information for scaling data stored as integer into 0 to 1 reflectance range

Spectral and Temporal Properties is already detailed in RFC 2 and 3.

Note that band no data value handling is fully supported by QGIS API directly via QgsRasterDataProvider methods: setNoDataValue, setUserNoDataValue, setUseSourceNoDataValue, sourceHasNoDataValue, sourceNoDataValue, userNoDataValues, useSourceNoDataValue.

Problem: Band name, offset and scale information can be accessed via QgsRasterLayer methods, but can’t be modified. This is especially limiting in GUI applications, where we usually have a read-only handle to a raster source that we aren’t supposed to modify.

The here proposed approach will integrate band property handling into QGIS PAM management. This allows to set/update band properties for QgsRasterLayer objects, which is critical for GUI applications. It also takes care of information stored as GDAL PAM.

We propose the following approach for fetching band-specific properties.

Approach¶

Note that fetching Spectral and Temporal Properties is already detailed in RFC 2 and 3.

Band-wise properties are fetched with the following priorisation.

1. Look at QGIS PAM band-level default-domain. This is mainly relevant for GUI applications, where we need to set/update band properties using QgsRasterLayer objects:

bandName: str = layer.customProperty('QGISPAM/band/42//name')
offset: floast = layer.customProperty('QGISPAM/band/42//offset')
scale: float = layer.customProperty('QGISPAM/band/42//scale')

Note that those information is only concidered by EnMAP-Box applications and algorithms and always ignored by QGIS and GDAL. To manifest those changes you are required to translate the layer to an intermediate VRT using the EnMAP-Box Translate raster layer algorithm, which will transfer all QGIS PAM information to GDAL PAM.

2. Use QgsRasterLayer and QgsRasterDataProvider methods for accessing the band name, offset and scale:: This is mainly relevant for processing algorithms:

bandName = layer.bandName(42)
offset = layer.dataProvider().bandOffset(42)
scale = layer.dataProvider().bandScale(42)

Note that when reading raster band data, the application or algorithm is responsible for properly applying the band offset and scale. Notice that GDAL won’t scale data automatically, when calling gdal.Band.ReadAsArray(). On the contrary, QGIS will automatically scale the data using the QgsRasterDataProvider.bandOffset and QgsRasterDataProvider.bandScale information, but will ignore potential modifications stored in QGIS PAM.

For that reason, we highly encourage the use of the RasterReader.array methode for reading raster data, which will take care of all the data scaling details.

Guide line 1:: If you need to set band-wise properties in a processing algorithm: set it to the GDAL PAM band-level default-domain or use approriate gdal.Band methods. This way, i) the information is accessible with the GDAL API, and ii) consecutive band subsetting via gdal.Translate and gdal.BuildVrt can easily copy the band domains to the destination dataset.
Guide line 2:: If you need to set/update band properties in a GUI application: set it to QGIS PAM. This is most flexible and secure. The band properties are i) available as custom layer properties, ii) stored in the QGIS project, and iii) can be saved to QML layer style files. Note that those modifications are only used by EnMAP-Box applications and algorithms, QGIS and GDAL will ignore it! To manifest those changes in GDAL PAM, translate the layer to an intermediate VRT using the EnMAP-Box Translate raster layer algorithm.
Guide line 3:: Do not update GDAL PAM *.aux.xml file, while the corresponding source is opened as a QgsRasterLayer in QGIS. QGIS will potentially overwrite any changes, when closing the layer.

Implementation¶

Technically, we don’t need any new functions or methods, because we fully rely on existing QGIS/GDAL API functionality.

But, the handling of property keys, the assurance of fetching priorities, and proper data scaling, can be tedious and should be encapsulated in util functions or methods. An example implementation is given by the RasterReader class.

Note that Spectral and Temporal Properties is already detailed in RFC 2 and 3.

To query band properties for band 42, we can use:

from enmapboxprocessing.rasterreader import RasterReader

reader = RasterReader(layer)
bandName = reader.bandName(42)
bandOffset = reader.bandOffset(42)
bandScale = reader.bandScale(42)

To set band properties use:

reader.setBandName('band 42 (0.685000 Micrometers)', 42)
reader.setBandOffset(0, 42)
reader.setBandScale(10000, 42)

To read (scaled) band data use:

array = reader.array(bandList=[42])
maskArray = reader.maskArray(array, bandList=[42])

Also check out the RasterReader unittests: https://bitbucket.org/hu-geomatics/enmap-box/src/develop/enmapboxprocessing/test/test_rasterreaderrfc4.py

File	Documentation
qgis.qch	qgis.core, qgis.gui
qtcore.qch	Qt5.QtCore
qtgui.qch	Qt5.QtGui
qtwidgets.qch	Qt5.QtWidgets

OS	Command
Windows	set QGIS_REPO=<my_repositories/QGIS>
Linux /macOS	DIR_REPO=<my_repositories/QGIS> export QGIS_REPO

EnMAP-Box 3 Documentation¶

Key features¶

Related websites¶

News¶

EnMAP-Box Version 3.10 released¶

EnMAP-Box Version 3.9 released¶

EnMAP-Box Workshop 2021¶

FOSSGIS 2021¶

EnMAP-Box Version 3.7 released¶

FOSSGIS 2020¶

QGIS User Conference 2019¶

About¶

FAQ & Troubleshooting¶

Bug report & feedback¶

Contact¶

FAQ¶

Known Issues¶

How to contribute¶

Submit a bug report or feature request¶

Provide source code¶

1. Create a fork on Bitbucket¶

2. Clone the forked EnMAP-Box repository¶

3. Modify the local repository¶

4. Commit your changes¶

5. Push changes back to your fork¶

6. Create a pull request¶

Documentation¶

Licensing¶

Applying License Terms¶

Contributor License Agreements (CLA)¶

Tests and Continuous Integration¶

Roadmap¶

Glossary¶

Index with all Terms¶

GIS and Remote Sensing¶

Raster Metadata¶

Machine Learning¶

Installation¶

1. Install QGIS¶

MacOS¶

2. Install required python packages¶

2.1 Package Installer¶

2.2 Command-line¶

3. Install or update the EnMAP-Box¶

Install from QGIS plugin repository¶

Install older version¶

Getting Started¶

Primer¶

Launching the EnMAP-Box¶

Loading Testdata¶

First Steps in the GUI¶

Use an Application¶

Use a Processing Algorithm¶

Use the Spectral Library¶

Cookbook¶

Classification¶

Fit a Classifier¶

Predict Classification¶

Accuracy Assessment¶

Clip a raster with a vector¶

Clustering (kmeans)¶

Filtering¶

Spatial Filter¶

Spectral Filter¶

Generic Filter (Majority)¶

Graphical Modeler¶

Map Algebra with ImageMath¶

Calculate NDVI¶

Mask raster with vector¶

Using Raster math for performing both simple and complex raster arithmetics¶

Using simple expressions¶

Using multi-line code snippets and handle metadata¶

Using individual bands by band index, band position or wavelength location¶

Using band masks¶

Using advanced band subsetting¶

Using special variables and logging feedback¶

Running Raster math from command line¶

Regression¶

Transformation (PCA)¶

Wavelength Information¶