Struct Expression 

pub struct Expression {
    pub params: Box<ExpressionParameters>,
    pub sources: Box<SingleRasterSource>,
    pub type: Type,
}

Expression : The Expression operator performs a pixel-wise mathematical expression on one or more bands of a raster source. The expression is specified as a user-defined script in a very simple language. The output is a raster time series with the result of the expression and with time intervals that are the same as for the inputs. Users can specify an output data type. Internally, the expression is evaluated using floating-point numbers. An example usage scenario is to calculate NDVI for a red and a near-infrared raster channel. The expression uses a raster source with two bands, referred to as A and B, and calculates the formula (A - B) / (A + B). When the temporal resolution is months, our output NDVI will also be a monthly time series. ## Types The following describes the types used in the parameters. ### Expression Expressions are simple scripts to perform pixel-wise computations. One can refer to the raster inputs as A for the first raster band, B for the second, and so on. Furthermore, expressions can check with A IS NODATA, B IS NODATA, etc. for NO DATA values. This is important if mapNoData is set to true. Otherwise, NO DATA values are mapped automatically to the output NO DATA value. Finally, the value NODATA can be used to output NO DATA. Users can think of this implicit function signature for, e.g., two inputs: rust,ignore fn (A: f64, B: f64) -> f64 As a start, expressions contain algebraic operations and mathematical functions. rust,ignore (A + B) / 2 In addition, branches can be used to check for conditions. rust,ignore if A IS NODATA { B } else { A } Function calls can be used to access utility functions. rust,ignore max(A, 0) Currently, the following functions are available: - abs(a): absolute value - min(a, b), min(a, b, c): minimum value - max(a, b), max(a, b, c): maximum value - sqrt(a): square root - ln(a): natural logarithm - log10(a): base 10 logarithm - cos(a), sin(a), tan(a), acos(a), asin(a), atan(a): trigonometric functions - pi(), e(): mathematical constants - round(a), ceil(a), floor(a): rounding functions - mod(a, b): division remainder - to_degrees(a), to_radians(a): conversion to degrees or radians To generate more complex expressions, it is possible to have variable assignments. rust,ignore let mean = (A + B) / 2; let coefficient = 0.357; mean * coefficient Note, that all assignments are separated by semicolons. However, the last expression must be without a semicolon.

Fields

params: Box<ExpressionParameters>

sources: Box<SingleRasterSource>

type: Type

Implementations

impl Expression

pub fn new( params: ExpressionParameters, sources: SingleRasterSource, type: Type, ) -> Expression

The Expression operator performs a pixel-wise mathematical expression on one or more bands of a raster source. The expression is specified as a user-defined script in a very simple language. The output is a raster time series with the result of the expression and with time intervals that are the same as for the inputs. Users can specify an output data type. Internally, the expression is evaluated using floating-point numbers. An example usage scenario is to calculate NDVI for a red and a near-infrared raster channel. The expression uses a raster source with two bands, referred to as A and B, and calculates the formula (A - B) / (A + B). When the temporal resolution is months, our output NDVI will also be a monthly time series. ## Types The following describes the types used in the parameters. ### Expression Expressions are simple scripts to perform pixel-wise computations. One can refer to the raster inputs as A for the first raster band, B for the second, and so on. Furthermore, expressions can check with A IS NODATA, B IS NODATA, etc. for NO DATA values. This is important if mapNoData is set to true. Otherwise, NO DATA values are mapped automatically to the output NO DATA value. Finally, the value NODATA can be used to output NO DATA. Users can think of this implicit function signature for, e.g., two inputs: rust,ignore fn (A: f64, B: f64) -> f64 As a start, expressions contain algebraic operations and mathematical functions. rust,ignore (A + B) / 2 In addition, branches can be used to check for conditions. rust,ignore if A IS NODATA { B } else { A } Function calls can be used to access utility functions. rust,ignore max(A, 0) Currently, the following functions are available: - abs(a): absolute value - min(a, b), min(a, b, c): minimum value - max(a, b), max(a, b, c): maximum value - sqrt(a): square root - ln(a): natural logarithm - log10(a): base 10 logarithm - cos(a), sin(a), tan(a), acos(a), asin(a), atan(a): trigonometric functions - pi(), e(): mathematical constants - round(a), ceil(a), floor(a): rounding functions - mod(a, b): division remainder - to_degrees(a), to_radians(a): conversion to degrees or radians To generate more complex expressions, it is possible to have variable assignments. rust,ignore let mean = (A + B) / 2; let coefficient = 0.357; mean * coefficient Note, that all assignments are separated by semicolons. However, the last expression must be without a semicolon.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expression

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Expression

fn default() -> Expression

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expression

fn eq(&self, other: &Expression) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expression

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expression