surtgis-core 0.14.8

Core types and traits for SurtGis geospatial library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! # SurtGis Core
//!
//! Core types, traits and I/O for the SurtGis geospatial library.
//!
//! This crate provides:
//! - `Raster<T>`: Generic raster grid type
//! - `GeoTransform`: Affine transformation for georeferencing
//! - `CRS`: Coordinate Reference System handling
//! - Algorithm traits for consistent API
//! - I/O for common geospatial formats

pub mod crs;
pub mod error;
pub mod io;
pub mod mosaic;
pub mod raster;
pub mod resample;
pub mod streaming;
pub mod vector;

pub use crs::CRS;
pub use error::{Error, Result};
pub use mosaic::{MosaicOptions, mosaic};
pub use raster::{GeoTransform, Raster, RasterElement};
pub use resample::{ResampleMethod, resample_to_grid};
pub use streaming::{StripProcessor, WindowAlgorithm};

/// Prelude for convenient imports
pub mod prelude {
    pub use crate::Algorithm;
    pub use crate::crs::CRS;
    pub use crate::error::{Error, Result};
    pub use crate::raster::{GeoTransform, Raster, RasterElement};
}

/// Core trait for all algorithms in SurtGis.
///
/// Algorithms are pure functions that transform input data according to parameters.
pub trait Algorithm {
    /// Input type for the algorithm
    type Input;
    /// Output type for the algorithm
    type Output;
    /// Parameters controlling algorithm behavior
    type Params: Default;
    /// Error type for algorithm execution
    type Error: std::error::Error;

    /// Returns the algorithm name
    fn name(&self) -> &'static str;

    /// Returns a description of what the algorithm does
    fn description(&self) -> &'static str;

    /// Execute the algorithm
    fn execute(
        &self,
        input: Self::Input,
        params: Self::Params,
    ) -> std::result::Result<Self::Output, Self::Error>;

    /// Execute with default parameters
    fn execute_default(
        &self,
        input: Self::Input,
    ) -> std::result::Result<Self::Output, Self::Error> {
        self.execute(input, Self::Params::default())
    }
}

/// Marker trait for algorithms that can be parallelized
pub trait ParallelAlgorithm: Algorithm {
    /// Execute in parallel using available cores
    fn execute_parallel(
        &self,
        input: Self::Input,
        params: Self::Params,
    ) -> std::result::Result<Self::Output, Self::Error>;
}