Enum TaskOperation 

pub enum TaskOperation {
    Filter {
        expression: String,
    },
    CalculateIndex {
        index_type: String,
        bands: Vec<usize>,
    },
    Reproject {
        target_epsg: i32,
    },
    Resample {
        width: usize,
        height: usize,
        method: String,
    },
    Clip {
        min_x: f64,
        min_y: f64,
        max_x: f64,
        max_y: f64,
    },
    Convolve {
        kernel: Vec<f64>,
        kernel_width: usize,
        kernel_height: usize,
    },
    Custom {
        name: String,
        params: String,
    },
}

Type of geospatial operation to perform.

Variants

Filter

Apply a filter to data.

Fields

expression: String

Filter expression.

CalculateIndex

Calculate a raster index (NDVI, NDWI, etc.).

Fields

index_type: String

Index type.

bands: Vec<usize>

Band indices for calculation.

Reproject

Reproject data to a different CRS.

Fields

target_epsg: i32

Target EPSG code.

Resample

Resample raster data.

Fields

width: usize

Target width.

height: usize

Target height.

method: String

Resampling method.

Clip

Clip data to a bounding box.

Fields

min_x: f64

Minimum X coordinate.

min_y: f64

Minimum Y coordinate.

max_x: f64

Maximum X coordinate.

max_y: f64

Maximum Y coordinate.

Convolve

Apply a convolution kernel.

Fields

kernel: Vec<f64>

Kernel values.

kernel_width: usize

Kernel width.

kernel_height: usize

Kernel height.

Custom

Custom user-defined operation.

Fields

name: String

Operation name.

params: String

JSON-serialized parameters.

Trait Implementations

impl Clone for TaskOperation

fn clone(&self) -> TaskOperation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskOperation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskOperation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for TaskOperation

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

where __S: Serializer,

Serialize this value into the given Serde serializer.