eorst 1.0.0

Earth Observation and Remote Sensing Toolkit - library for raster processing pipelines
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

# EORST - Earth Observation and Remote Sensing Toolkit

A Rust library for simplifying raster processing pipelines in Earth observation workflows.

## Quick Start

```toml
[dependencies]
eorst = "1.0"
```

## Highlights

- **Parallel read/write** - Block-based parallel processing with rayon
- **On-the-fly reprojection** - Automatic image alignment and coordinate transformation
- **Point sampling** - Efficient raster value extraction at point locations
- **Time series analysis** - Multi-temporal data handling
- **Band math** - Built-in arithmetic operations on raster bands
- **ML integration** - Optional LightGBM and OpenCV support

## Example

### From STAC Query (ODC-style workflow)

```rust
use rss_core::{query::ImageQueryBuilder, qvf::Collection, DEA};
use eorst::{RasterDatasetBuilder, RasterDataset};
use chrono::NaiveDate;
use std::path::PathBuf;

// Query satellite imagery from a STAC catalog
let query = ImageQueryBuilder::new(
    DEA,
    Collection::Sentinel2,
    rss_core::utils::Intersects::Scene(vec!["56jns".to_string()]),
)
.start_date(NaiveDate::parse_from_str("2022-01-01", "%Y-%m-%d").unwrap())
.end_date(NaiveDate::parse_from_str("2022-06-01", "%Y-%m-%d").unwrap())
.cloudcover((rss_core::utils::Cmp::Less, 10))
.canonical_bands(["red", "nir"])
.build();

// Download and create a RasterDataset
let feature_collection = query.get(&PathBuf::from("/tmp"), None, None)?;
let rds = RasterDatasetBuilder::from_stac_query(&feature_collection)
    .block_size(eorst::utils::BlockSize { rows: 2048, cols: 2048 })
    .build();

// Process with `apply` - receives RasterDataBlock with metadata
rds.apply::<i16>(
    |block| {
        // Select layers by name using the Select trait
        let red = block.select_layers(&["red"])?;
        let nir = block.select_layers(&["nir"])?;
        
        // Compute NDVI: (NIR - Red) / (NIR + Red)
        let ndvi = (&nir.data - &red.data) / (&nir.data + &red.data + 1e-10);
        Ok(ndvi.insert_axis(ndarray::Axis(1)))
    },
    4,  // number of CPU threads
    &PathBuf::from("ndvi.tif"),
)?;
```

### From Local Files with Layer Selection

```rust
use eorst::{RasterDatasetBuilder, DataSourceBuilder, Select};
use ndarray::Array4;
use std::path::PathBuf;

// Load specific bands with custom names
let data_source = DataSourceBuilder::from_file(&PathBuf::from("path/to/raster.tif"))
    .bands(vec![3, 4])           // Band indices
    .set_names(vec!["red", "nir"])  // Assign names
    .build();

let rds = RasterDatasetBuilder::from_source(&data_source)
    .block_size(eorst::utils::BlockSize { cols: 256, rows: 256 })
    .build();

// Process with automatic layer selection by name
rds.apply::<i16>(
    |block| {
        // No need to remember indices - use semantic names!
        let data = block.select_layers(&["nir"])?;  // Get NIR band
        Ok(data.data * 2)  // Double the NIR values
    },
    2,
    &PathBuf::from("output.tif"),
)?;
```

## Documentation

Full documentation: https://docs.rs/eorst

See also: [EORST Documentation Site](https://docs.rs/eorst/latest/eorst/docs/index.html)

## Features

| Feature | Description |
|---------|-------------|
| `use_opencv` | Computer vision operations (erosion, dilation, etc.) |
| `use_lgbm` | LightGBM machine learning integration |
| `use_polars` | Polars DataFrame support for zonal statistics |
| `use_rss` | rss_core integration for remote sensing workflows |

## License

LGPL-3.0-or-later