23350791305

Committed 20 Mar 2026 03:50PM UTC coverage: 87.499%. First build

Build # 23350791305

Build Type

Pull #1114

github

Committed by

web-flow

Commit Message

Merge f761e15e8 into dccacebf2

Pull Request Pull Request #1114: feat: STAC dataset import

Coverage Stats

600 of 1796 new or added lines in 12 files covered. (33.41%)

113849 of 130114 relevant lines covered (87.5%)

497584.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.5

/services/src/api/model/processing_graphs/mod.rs

#![allow(clippy::needless_for_each)] // TODO: remove when clippy is fixed for utoipa <https://github.com/juhaku/utoipa/issues/1420>

// use crate::api::model::processing_graphs::{
//     processing::{Expression, ExpressionParameters, RasterVectorJoin, RasterVectorJoinParameters},
//     source::{GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters},
// };
use geoengine_operators::{
    engine::{
        PlotOperator as OperatorsPlotOperator, RasterOperator as OperatorsRasterOperator,
        TypedOperator as OperatorsTypedOperator, VectorOperator as OperatorsVectorOperator,
    },
    mock::MockPointSource as OperatorsMockPointSource,
    plot::{Histogram as OperatorsHistogram, Statistics as OperatorsStatistics},
    processing::{
        BandFilter as OperatorsBandFilter, Expression as OperatorsExpression,
        Interpolation as OperatorsInterpolation, RasterStacker as OperatorsRasterStacker,
        RasterTypeConversion as OperatorsRasterTypeConversion,
        RasterVectorJoin as OperatorsRasterVectorJoin, Reprojection as OperatorsReprojection,
        TemporalRasterAggregation as OperatorsTemporalRasterAggregation,
    },
    source::{
        GdalSource as OperatorsGdalSource, MultiBandGdalSource as OperatorsMultiBandGdalSource,
    },
};
use serde::{Deserialize, Serialize};
use utoipa::{OpenApi, ToSchema};

mod macros;
mod parameters;
mod plots;
mod processing;
mod source;
mod source_parameters;

// TODO: avoid exporting them to outside of API module
#[cfg(test)]
pub(crate) use crate::api::model::processing_graphs::parameters::SpatialBoundsDerive;
pub(crate) use crate::api::model::processing_graphs::{
    plots::{Histogram, HistogramParameters, Statistics, StatisticsParameters},
    processing::{
        Aggregation, BandFilter, BandFilterParameters, BandsByNameOrIndex,
        DeriveOutRasterSpecsSource, Expression, ExpressionParameters, Interpolation,
        InterpolationMethod, InterpolationParameters, InterpolationResolution, RasterStacker,
        RasterStackerParameters, RasterTypeConversion, RasterTypeConversionParameters,
        RasterVectorJoin, RasterVectorJoinParameters, RenameBands, Reprojection,
        ReprojectionParameters, TemporalRasterAggregation, TemporalRasterAggregationParameters,
    },
    source::{
        GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters,
        MultiBandGdalSource,
    },
    source_parameters::{
        MultipleRasterOrSingleVectorOperator, MultipleRasterOrSingleVectorSource,
        MultipleRasterSources,
        SingleRasterOrVectorOperator, SingleRasterOrVectorSource, SingleRasterSource,
        SingleVectorMultipleRasterSources,
    },
};

/// Operator outputs are distinguished by their data type.
/// There are `raster`, `vector` and `plot` operators.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(tag = "type", content = "operator")]
pub enum TypedOperator {
    Vector(VectorOperator),
    Raster(RasterOperator),
    Plot(PlotOperator),
}

/// An operator that produces raster data.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(rename_all = "camelCase", untagged)]
#[schema(discriminator = "type")]
pub enum RasterOperator {
    BandFilter(BandFilter),
    Expression(Expression),
    GdalSource(GdalSource),
    Interpolation(Interpolation),
    MultiBandGdalSource(MultiBandGdalSource),
    RasterStacker(RasterStacker),
    RasterTypeConversion(RasterTypeConversion),
    Reprojection(Reprojection),
    TemporalRasterAggregation(TemporalRasterAggregation),
}

/// An operator that produces vector data.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(rename_all = "camelCase", untagged)]
#[schema(discriminator = "type")]
pub enum VectorOperator {
    MockPointSource(MockPointSource),
    RasterVectorJoin(RasterVectorJoin),
    Reprojection(Reprojection),
}

/// An operator that produces plot data.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
#[serde(rename_all = "camelCase", untagged)]
#[schema(discriminator = "type")]
pub enum PlotOperator {
    Histogram(Histogram),
    Statistics(Statistics),
}

impl TryFrom<RasterOperator> for Box<dyn OperatorsRasterOperator> {
    type Error = anyhow::Error;
    fn try_from(operator: RasterOperator) -> Result<Self, Self::Error> {
        match operator {
            RasterOperator::BandFilter(band_filter) => {
                OperatorsBandFilter::try_from(band_filter).map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::Expression(expression) => {
                OperatorsExpression::try_from(expression).map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::GdalSource(gdal_source) => {
                OperatorsGdalSource::try_from(gdal_source).map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::Interpolation(interpolation) => {
                OperatorsInterpolation::try_from(interpolation).map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::MultiBandGdalSource(gdal_source) => OperatorsMultiBandGdalSource::try_from(
                gdal_source,
            )
            .map(OperatorsRasterOperator::boxed),
            RasterOperator::RasterStacker(raster_stacker) => {
                OperatorsRasterStacker::try_from(raster_stacker)
                    .map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::RasterTypeConversion(type_conversion) => {
                OperatorsRasterTypeConversion::try_from(type_conversion)
                    .map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::Reprojection(reprojection) => {
                OperatorsReprojection::try_from(reprojection).map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::TemporalRasterAggregation(aggregation) => {
                OperatorsTemporalRasterAggregation::try_from(aggregation)
                    .map(OperatorsRasterOperator::boxed)
            }
        }
    }
}

impl TryFrom<VectorOperator> for Box<dyn OperatorsVectorOperator> {
    type Error = anyhow::Error;
    fn try_from(operator: VectorOperator) -> Result<Self, Self::Error> {
        match operator {
            VectorOperator::MockPointSource(mock_point_source) => {
                OperatorsMockPointSource::try_from(mock_point_source)
                    .map(OperatorsVectorOperator::boxed)
            }
            VectorOperator::RasterVectorJoin(rvj) => {
                OperatorsRasterVectorJoin::try_from(rvj).map(OperatorsVectorOperator::boxed)
            }
            VectorOperator::Reprojection(reprojection) => {
                OperatorsReprojection::try_from(reprojection).map(OperatorsVectorOperator::boxed)
            }
        }
    }
}

impl TryFrom<PlotOperator> for Box<dyn OperatorsPlotOperator> {
    type Error = anyhow::Error;
    fn try_from(operator: PlotOperator) -> Result<Self, Self::Error> {
        match operator {
            PlotOperator::Histogram(histogram) => {
                OperatorsHistogram::try_from(histogram).map(OperatorsPlotOperator::boxed)
            }
            PlotOperator::Statistics(statistics) => {
                OperatorsStatistics::try_from(statistics).map(OperatorsPlotOperator::boxed)
            }
        }
    }
}

impl TryFrom<TypedOperator> for OperatorsTypedOperator {
    type Error = anyhow::Error;
    fn try_from(operator: TypedOperator) -> Result<Self, Self::Error> {
        match operator {
            TypedOperator::Raster(raster_operator) => Ok(Self::Raster(raster_operator.try_into()?)),
            TypedOperator::Vector(vector_operator) => Ok(Self::Vector(vector_operator.try_into()?)),
            TypedOperator::Plot(plot_operator) => Ok(Self::Plot(plot_operator.try_into()?)),
        }
    }
}

#[derive(OpenApi)]
#[openapi(components(schemas(
    // General
    PlotOperator,
    TypedOperator,
    VectorOperator,
    // Source
    GdalSource,
    GdalSourceParameters,
    MockPointSource,
    MockPointSourceParameters,
    MultiBandGdalSource,
    // Processing
    Aggregation,
    BandFilter,
    BandFilterParameters,
    BandsByNameOrIndex,
    DeriveOutRasterSpecsSource,
    Expression,
    ExpressionParameters,
    Interpolation,
    InterpolationMethod,
    InterpolationParameters,
    InterpolationResolution,
    RasterOperator,
    RasterStacker,
    RasterStackerParameters,
    RasterTypeConversion,
    RasterTypeConversionParameters,
    RasterVectorJoin,
    RasterVectorJoinParameters,
    RenameBands,
    Reprojection,
    ReprojectionParameters,
    TemporalRasterAggregation,
    TemporalRasterAggregationParameters,
    // Plots
    Histogram,
    HistogramParameters,
    Statistics,
    StatisticsParameters,
    // Source Parameters
    MultipleRasterOrSingleVectorOperator,
    MultipleRasterOrSingleVectorSource,
    MultipleRasterSources,
    SingleRasterOrVectorOperator,
    SingleRasterOrVectorSource,
    SingleRasterSource,
    SingleVectorMultipleRasterSources,

)))]
pub struct OperatorsApi;

1	#![allow(clippy::needless_for_each)] // TODO: remove when clippy is fixed for utoipa <https://github.com/juhaku/utoipa/issues/1420>
2
3	// use crate::api::model::processing_graphs::{
4	// processing::{Expression, ExpressionParameters, RasterVectorJoin, RasterVectorJoinParameters},
5	// source::{GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters},
6	// };
7	use geoengine_operators::{
8	engine::{
9	PlotOperator as OperatorsPlotOperator, RasterOperator as OperatorsRasterOperator,
10	TypedOperator as OperatorsTypedOperator, VectorOperator as OperatorsVectorOperator,
11	},
12	mock::MockPointSource as OperatorsMockPointSource,
13	plot::{Histogram as OperatorsHistogram, Statistics as OperatorsStatistics},
14	processing::{
15	BandFilter as OperatorsBandFilter, Expression as OperatorsExpression,
16	Interpolation as OperatorsInterpolation, RasterStacker as OperatorsRasterStacker,
17	RasterTypeConversion as OperatorsRasterTypeConversion,
18	RasterVectorJoin as OperatorsRasterVectorJoin, Reprojection as OperatorsReprojection,
19	TemporalRasterAggregation as OperatorsTemporalRasterAggregation,
20	},
21	source::{
22	GdalSource as OperatorsGdalSource, MultiBandGdalSource as OperatorsMultiBandGdalSource,
23	},
24	};
25	use serde::{Deserialize, Serialize};
26	use utoipa::{OpenApi, ToSchema};
27
28	mod macros;
29	mod parameters;
30	mod plots;
31	mod processing;
32	mod source;
33	mod source_parameters;
34
35	// TODO: avoid exporting them to outside of API module
36	#[cfg(test)]
37	pub(crate) use crate::api::model::processing_graphs::parameters::SpatialBoundsDerive;
38	pub(crate) use crate::api::model::processing_graphs::{
39	plots::{Histogram, HistogramParameters, Statistics, StatisticsParameters},
40	processing::{
41	Aggregation, BandFilter, BandFilterParameters, BandsByNameOrIndex,
42	DeriveOutRasterSpecsSource, Expression, ExpressionParameters, Interpolation,
43	InterpolationMethod, InterpolationParameters, InterpolationResolution, RasterStacker,
44	RasterStackerParameters, RasterTypeConversion, RasterTypeConversionParameters,
45	RasterVectorJoin, RasterVectorJoinParameters, RenameBands, Reprojection,
46	ReprojectionParameters, TemporalRasterAggregation, TemporalRasterAggregationParameters,
47	},
48	source::{
49	GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters,
50	MultiBandGdalSource,
51	},
52	source_parameters::{
53	MultipleRasterOrSingleVectorOperator, MultipleRasterOrSingleVectorSource,
54	MultipleRasterSources,
55	SingleRasterOrVectorOperator, SingleRasterOrVectorSource, SingleRasterSource,
56	SingleVectorMultipleRasterSources,
57	},
58	};
59
60	/// Operator outputs are distinguished by their data type.
61	/// There are `raster`, `vector` and `plot` operators.
62	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
63	#[serde(tag = "type", content = "operator")]
64	pub enum TypedOperator {
65	Vector(VectorOperator),
66	Raster(RasterOperator),
67	Plot(PlotOperator),
68	}
69
70	/// An operator that produces raster data.
71	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
72	#[serde(rename_all = "camelCase", untagged)]
73	#[schema(discriminator = "type")]
74	pub enum RasterOperator {
75	BandFilter(BandFilter),
76	Expression(Expression),
77	GdalSource(GdalSource),
78	Interpolation(Interpolation),
79	MultiBandGdalSource(MultiBandGdalSource),
80	RasterStacker(RasterStacker),
81	RasterTypeConversion(RasterTypeConversion),
82	Reprojection(Reprojection),
83	TemporalRasterAggregation(TemporalRasterAggregation),
84	}
85
86	/// An operator that produces vector data.
87	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
88	#[serde(rename_all = "camelCase", untagged)]
89	#[schema(discriminator = "type")]
90	pub enum VectorOperator {
91	MockPointSource(MockPointSource),
92	RasterVectorJoin(RasterVectorJoin),
93	Reprojection(Reprojection),
94	}
95
96	/// An operator that produces plot data.
97	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
98	#[serde(rename_all = "camelCase", untagged)]
99	#[schema(discriminator = "type")]
100	pub enum PlotOperator {
101	Histogram(Histogram),
102	Statistics(Statistics),
103	}
104
105	impl TryFrom<RasterOperator> for Box<dyn OperatorsRasterOperator> {
106	type Error = anyhow::Error;
107	fn try_from(operator: RasterOperator) -> Result<Self, Self::Error> {	47✔
108	match operator {	47✔
NEW 109	RasterOperator::BandFilter(band_filter) => {	×
NEW 110	OperatorsBandFilter::try_from(band_filter).map(OperatorsRasterOperator::boxed)	×
111	}
112	RasterOperator::Expression(expression) => {	×
113	OperatorsExpression::try_from(expression).map(OperatorsRasterOperator::boxed)	×
114	}
115	RasterOperator::GdalSource(gdal_source) => {	41✔
116	OperatorsGdalSource::try_from(gdal_source).map(OperatorsRasterOperator::boxed)	41✔
117	}
NEW 118	RasterOperator::Interpolation(interpolation) => {	×
NEW 119	OperatorsInterpolation::try_from(interpolation).map(OperatorsRasterOperator::boxed)	×
120	}
121	RasterOperator::MultiBandGdalSource(gdal_source) => OperatorsMultiBandGdalSource::try_from(	4✔
122	gdal_source,	4✔
123	)
124	.map(OperatorsRasterOperator::boxed),	4✔
125	RasterOperator::RasterStacker(raster_stacker) => {	2✔
126	OperatorsRasterStacker::try_from(raster_stacker)	2✔
127	.map(OperatorsRasterOperator::boxed)	2✔
128	}
NEW 129	RasterOperator::RasterTypeConversion(type_conversion) => {	×
NEW 130	OperatorsRasterTypeConversion::try_from(type_conversion)	×
NEW 131	.map(OperatorsRasterOperator::boxed)	×
132	}
NEW 133	RasterOperator::Reprojection(reprojection) => {	×
NEW 134	OperatorsReprojection::try_from(reprojection).map(OperatorsRasterOperator::boxed)	×
135	}
NEW 136	RasterOperator::TemporalRasterAggregation(aggregation) => {	×
NEW 137	OperatorsTemporalRasterAggregation::try_from(aggregation)	×
NEW 138	.map(OperatorsRasterOperator::boxed)	×
139	}
140	}
141	}	47✔
142	}
143
144	impl TryFrom<VectorOperator> for Box<dyn OperatorsVectorOperator> {
145	type Error = anyhow::Error;
146	fn try_from(operator: VectorOperator) -> Result<Self, Self::Error> {	9✔
147	match operator {	9✔
148	VectorOperator::MockPointSource(mock_point_source) => {	8✔
149	OperatorsMockPointSource::try_from(mock_point_source)	8✔
150	.map(OperatorsVectorOperator::boxed)	8✔
151	}
152	VectorOperator::RasterVectorJoin(rvj) => {	×
153	OperatorsRasterVectorJoin::try_from(rvj).map(OperatorsVectorOperator::boxed)	×
154	}
155	VectorOperator::Reprojection(reprojection) => {	1✔
156	OperatorsReprojection::try_from(reprojection).map(OperatorsVectorOperator::boxed)	1✔
157	}
158	}
159	}	9✔
160	}
161
162	impl TryFrom<PlotOperator> for Box<dyn OperatorsPlotOperator> {
163	type Error = anyhow::Error;
164	fn try_from(operator: PlotOperator) -> Result<Self, Self::Error> {	1✔
165	match operator {	1✔
166	PlotOperator::Histogram(histogram) => {	×
167	OperatorsHistogram::try_from(histogram).map(OperatorsPlotOperator::boxed)	×
168	}
169	PlotOperator::Statistics(statistics) => {	1✔
170	OperatorsStatistics::try_from(statistics).map(OperatorsPlotOperator::boxed)	1✔
171	}
172	}
173	}	1✔
174	}
175
176	impl TryFrom<TypedOperator> for OperatorsTypedOperator {
177	type Error = anyhow::Error;
178	fn try_from(operator: TypedOperator) -> Result<Self, Self::Error> {	32✔
179	match operator {	32✔
180	TypedOperator::Raster(raster_operator) => Ok(Self::Raster(raster_operator.try_into()?)),	27✔
181	TypedOperator::Vector(vector_operator) => Ok(Self::Vector(vector_operator.try_into()?)),	4✔
182	TypedOperator::Plot(plot_operator) => Ok(Self::Plot(plot_operator.try_into()?)),	1✔
183	}
184	}	32✔
185	}
186
187	#[derive(OpenApi)]
188	#[openapi(components(schemas(
189	// General
190	PlotOperator,
191	TypedOperator,
192	VectorOperator,
193	// Source
194	GdalSource,
195	GdalSourceParameters,
196	MockPointSource,
197	MockPointSourceParameters,
198	MultiBandGdalSource,
199	// Processing
200	Aggregation,
201	BandFilter,
202	BandFilterParameters,
203	BandsByNameOrIndex,
204	DeriveOutRasterSpecsSource,
205	Expression,
206	ExpressionParameters,
207	Interpolation,
208	InterpolationMethod,
209	InterpolationParameters,
210	InterpolationResolution,
211	RasterOperator,
212	RasterStacker,
213	RasterStackerParameters,
214	RasterTypeConversion,
215	RasterTypeConversionParameters,
216	RasterVectorJoin,
217	RasterVectorJoinParameters,
218	RenameBands,
219	Reprojection,
220	ReprojectionParameters,
221	TemporalRasterAggregation,
222	TemporalRasterAggregationParameters,
223	// Plots
224	Histogram,
225	HistogramParameters,
226	Statistics,
227	StatisticsParameters,
228	// Source Parameters
229	MultipleRasterOrSingleVectorOperator,
230	MultipleRasterOrSingleVectorSource,
231	MultipleRasterSources,
232	SingleRasterOrVectorOperator,
233	SingleRasterOrVectorSource,
234	SingleRasterSource,
235	SingleVectorMultipleRasterSources,
236
237	)))]
238	pub struct OperatorsApi;

geo-engine / geoengine / 23350791305

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous