29286368238

Committed 13 Jul 2026 09:26PM UTC coverage: 87.77% (-0.004%) from 87.774%

Build # 29286368238

Build Type

Pull #1199

github

Committed by

web-flow

Commit Message

Merge 4072667e2 into 94c12fa63

Pull Request Pull Request #1199: fix: add resolution to python down/up sampling operators

Coverage Stats

72 of 97 new or added lines in 5 files covered. (74.23%)

2 existing lines in 1 file now uncovered.

121730 of 138692 relevant lines covered (87.77%)

471978.02 hits per line

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

96.08

/geoengine/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, Downsampling as OperatorsDownsampling,
        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,
        OgrSource as OperatorsOgrSource,
    },
};
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, Downsampling, DownsamplingMethod, DownsamplingParameters,
        DownsamplingResolution, Expression, ExpressionParameters, Interpolation,
        InterpolationMethod, InterpolationParameters, InterpolationResolution, RasterStacker,
        RasterStackerParameters, RasterTypeConversion, RasterTypeConversionParameters,
        RasterVectorJoin, RasterVectorJoinParameters, RenameBands, Reprojection,
        ReprojectionParameters, TemporalRasterAggregation, TemporalRasterAggregationParameters,
    },
    source::{
        GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters,
        MultiBandGdalSource, OgrSource, OgrSourceParameters,
    },
    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 {
    #[schema(title = "TypedVectorOperator")]
    Vector(VectorOperator),
    #[schema(title = "TypedRasterOperator")]
    Raster(RasterOperator),
    #[schema(title = "TypedPlotOperator")]
    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),
    Downsampling(Downsampling),
    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),
    OgrSource(OgrSource),
    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> {
        // TODO: Missing raster operator mappings (operators crate -> OpenAPI model):
        // [ ] BandNeighborhoodAggregate
        // [ ] BandwiseExpression
        // [ ] NeighborhoodAggregate
        // [ ] Onnx
        // [ ] RasterScaling
        // [ ] Rasterization
        // [ ] Reflectance
        // [ ] Radiance
        // [ ] Temperature
        // [ ] TimeShift
        match operator {
            RasterOperator::BandFilter(band_filter) => {
                OperatorsBandFilter::try_from(band_filter).map(OperatorsRasterOperator::boxed)
            }
            RasterOperator::Downsampling(downsampling) => {
                OperatorsDownsampling::try_from(downsampling).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> {
        // TODO: Missing vector operator mappings (operators crate -> OpenAPI model):
        // [ ] ColumnRangeFilter
        // [ ] CsvSource
        // [ ] LineSimplification
        // [ ] MockDatasetDataSource
        // [ ] PointInPolygonFilter
        // [ ] TimeProjection
        // [ ] TimeShift
        // [ ] VectorExpression
        // [ ] VectorJoin
        // [ ] VisualPointClustering
        match operator {
            VectorOperator::MockPointSource(mock_point_source) => {
                OperatorsMockPointSource::try_from(mock_point_source)
                    .map(OperatorsVectorOperator::boxed)
            }
            VectorOperator::OgrSource(ogr_source) => {
                OperatorsOgrSource::try_from(ogr_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> {
        // TODO: Missing plot operator mappings (operators crate -> OpenAPI model):
        // [ ] BoxPlot
        // [ ] ClassHistogram
        // [ ] FeatureAttributeValuesOverTime
        // [ ] MeanRasterPixelValuesOverTime
        // [ ] PieChart
        // [ ] ScatterPlot
        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,
    OgrSource,
    OgrSourceParameters,
    // Processing
    Aggregation,
    BandFilter,
    BandFilterParameters,
    BandsByNameOrIndex,
    DeriveOutRasterSpecsSource,
    Downsampling,
    DownsamplingMethod,
    DownsamplingParameters,
    DownsamplingResolution,
    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, Downsampling as OperatorsDownsampling,
16	Expression as OperatorsExpression, Interpolation as OperatorsInterpolation,
17	RasterStacker as OperatorsRasterStacker,
18	RasterTypeConversion as OperatorsRasterTypeConversion,
19	RasterVectorJoin as OperatorsRasterVectorJoin, Reprojection as OperatorsReprojection,
20	TemporalRasterAggregation as OperatorsTemporalRasterAggregation,
21	},
22	source::{
23	GdalSource as OperatorsGdalSource, MultiBandGdalSource as OperatorsMultiBandGdalSource,
24	OgrSource as OperatorsOgrSource,
25	},
26	};
27	use serde::{Deserialize, Serialize};
28	use utoipa::{OpenApi, ToSchema};
29
30	mod macros;
31	mod parameters;
32	mod plots;
33	mod processing;
34	mod source;
35	mod source_parameters;
36
37	// TODO: avoid exporting them to outside of API module
38	#[cfg(test)]
39	pub(crate) use crate::api::model::processing_graphs::parameters::SpatialBoundsDerive;
40	pub(crate) use crate::api::model::processing_graphs::{
41	plots::{Histogram, HistogramParameters, Statistics, StatisticsParameters},
42	processing::{
43	Aggregation, BandFilter, BandFilterParameters, BandsByNameOrIndex,
44	DeriveOutRasterSpecsSource, Downsampling, DownsamplingMethod, DownsamplingParameters,
45	DownsamplingResolution, Expression, ExpressionParameters, Interpolation,
46	InterpolationMethod, InterpolationParameters, InterpolationResolution, RasterStacker,
47	RasterStackerParameters, RasterTypeConversion, RasterTypeConversionParameters,
48	RasterVectorJoin, RasterVectorJoinParameters, RenameBands, Reprojection,
49	ReprojectionParameters, TemporalRasterAggregation, TemporalRasterAggregationParameters,
50	},
51	source::{
52	GdalSource, GdalSourceParameters, MockPointSource, MockPointSourceParameters,
53	MultiBandGdalSource, OgrSource, OgrSourceParameters,
54	},
55	source_parameters::{
56	MultipleRasterOrSingleVectorOperator, MultipleRasterOrSingleVectorSource,
57	MultipleRasterSources, SingleRasterOrVectorOperator, SingleRasterOrVectorSource,
58	SingleRasterSource, SingleVectorMultipleRasterSources,
59	},
60	};
61
62	/// Operator outputs are distinguished by their data type.
63	/// There are `raster`, `vector` and `plot` operators.
64	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
65	#[serde(tag = "type", content = "operator")]
66	pub enum TypedOperator {
67	#[schema(title = "TypedVectorOperator")]
68	Vector(VectorOperator),
69	#[schema(title = "TypedRasterOperator")]
70	Raster(RasterOperator),
71	#[schema(title = "TypedPlotOperator")]
72	Plot(PlotOperator),
73	}
74
75	/// An operator that produces raster data.
76	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
77	#[serde(rename_all = "camelCase", untagged)]
78	#[schema(discriminator = "type")]
79	pub enum RasterOperator {
80	BandFilter(BandFilter),
81	Downsampling(Downsampling),
82	Expression(Expression),
83	GdalSource(GdalSource),
84	Interpolation(Interpolation),
85	MultiBandGdalSource(MultiBandGdalSource),
86	RasterStacker(RasterStacker),
87	RasterTypeConversion(RasterTypeConversion),
88	Reprojection(Reprojection),
89	TemporalRasterAggregation(TemporalRasterAggregation),
90	}
91
92	/// An operator that produces vector data.
93	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
94	#[serde(rename_all = "camelCase", untagged)]
95	#[schema(discriminator = "type")]
96	pub enum VectorOperator {
97	MockPointSource(MockPointSource),
98	OgrSource(OgrSource),
99	RasterVectorJoin(RasterVectorJoin),
100	Reprojection(Reprojection),
101	}
102
103	/// An operator that produces plot data.
104	#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, ToSchema)]
105	#[serde(rename_all = "camelCase", untagged)]
106	#[schema(discriminator = "type")]
107	pub enum PlotOperator {
108	Histogram(Histogram),
109	Statistics(Statistics),
110	}
111
112	impl TryFrom<RasterOperator> for Box<dyn OperatorsRasterOperator> {
113	type Error = anyhow::Error;
114	fn try_from(operator: RasterOperator) -> Result<Self, Self::Error> {	103✔
115	// TODO: Missing raster operator mappings (operators crate -> OpenAPI model):
116	// [ ] BandNeighborhoodAggregate
117	// [ ] BandwiseExpression
118	// [ ] NeighborhoodAggregate
119	// [ ] Onnx
120	// [ ] RasterScaling
121	// [ ] Rasterization
122	// [ ] Reflectance
123	// [ ] Radiance
124	// [ ] Temperature
125	// [ ] TimeShift
126	match operator {	103✔
127	RasterOperator::BandFilter(band_filter) => {	2✔
128	OperatorsBandFilter::try_from(band_filter).map(OperatorsRasterOperator::boxed)	2✔
129	}
NEW 130	RasterOperator::Downsampling(downsampling) => {	×
NEW 131	OperatorsDownsampling::try_from(downsampling).map(OperatorsRasterOperator::boxed)	×
132	}
133	RasterOperator::Expression(expression) => {	1✔
134	OperatorsExpression::try_from(expression).map(OperatorsRasterOperator::boxed)	1✔
135	}
136	RasterOperator::GdalSource(gdal_source) => {	77✔
137	OperatorsGdalSource::try_from(gdal_source).map(OperatorsRasterOperator::boxed)	77✔
138	}
139	RasterOperator::Interpolation(interpolation) => {	1✔
140	OperatorsInterpolation::try_from(interpolation).map(OperatorsRasterOperator::boxed)	1✔
141	}
142	RasterOperator::MultiBandGdalSource(gdal_source) => {	7✔
143	OperatorsMultiBandGdalSource::try_from(gdal_source)	7✔
144	.map(OperatorsRasterOperator::boxed)	7✔
145	}
146	RasterOperator::RasterStacker(raster_stacker) => {	3✔
147	OperatorsRasterStacker::try_from(raster_stacker).map(OperatorsRasterOperator::boxed)	3✔
148	}
149	RasterOperator::RasterTypeConversion(type_conversion) => {	1✔
150	OperatorsRasterTypeConversion::try_from(type_conversion)	1✔
151	.map(OperatorsRasterOperator::boxed)	1✔
152	}
153	RasterOperator::Reprojection(reprojection) => {	10✔
154	OperatorsReprojection::try_from(reprojection).map(OperatorsRasterOperator::boxed)	10✔
155	}
156	RasterOperator::TemporalRasterAggregation(aggregation) => {	1✔
157	OperatorsTemporalRasterAggregation::try_from(aggregation)	1✔
158	.map(OperatorsRasterOperator::boxed)	1✔
159	}
160	}
161	}	103✔
162	}
163
164	impl TryFrom<VectorOperator> for Box<dyn OperatorsVectorOperator> {
165	type Error = anyhow::Error;
166	fn try_from(operator: VectorOperator) -> Result<Self, Self::Error> {	15✔
167	// TODO: Missing vector operator mappings (operators crate -> OpenAPI model):
168	// [ ] ColumnRangeFilter
169	// [ ] CsvSource
170	// [ ] LineSimplification
171	// [ ] MockDatasetDataSource
172	// [ ] PointInPolygonFilter
173	// [ ] TimeProjection
174	// [ ] TimeShift
175	// [ ] VectorExpression
176	// [ ] VectorJoin
177	// [ ] VisualPointClustering
178	match operator {	15✔
179	VectorOperator::MockPointSource(mock_point_source) => {	8✔
180	OperatorsMockPointSource::try_from(mock_point_source)	8✔
181	.map(OperatorsVectorOperator::boxed)	8✔
182	}
183	VectorOperator::OgrSource(ogr_source) => {	5✔
184	OperatorsOgrSource::try_from(ogr_source).map(OperatorsVectorOperator::boxed)	5✔
185	}
186	VectorOperator::RasterVectorJoin(rvj) => {	1✔
187	OperatorsRasterVectorJoin::try_from(rvj).map(OperatorsVectorOperator::boxed)	1✔
188	}
189	VectorOperator::Reprojection(reprojection) => {	1✔
190	OperatorsReprojection::try_from(reprojection).map(OperatorsVectorOperator::boxed)	1✔
191	}
192	}
193	}	15✔
194	}
195
196	impl TryFrom<PlotOperator> for Box<dyn OperatorsPlotOperator> {
197	type Error = anyhow::Error;
198	fn try_from(operator: PlotOperator) -> Result<Self, Self::Error> {	4✔
199	// TODO: Missing plot operator mappings (operators crate -> OpenAPI model):
200	// [ ] BoxPlot
201	// [ ] ClassHistogram
202	// [ ] FeatureAttributeValuesOverTime
203	// [ ] MeanRasterPixelValuesOverTime
204	// [ ] PieChart
205	// [ ] ScatterPlot
206	match operator {	4✔
207	PlotOperator::Histogram(histogram) => {	1✔
208	OperatorsHistogram::try_from(histogram).map(OperatorsPlotOperator::boxed)	1✔
209	}
210	PlotOperator::Statistics(statistics) => {	3✔
211	OperatorsStatistics::try_from(statistics).map(OperatorsPlotOperator::boxed)	3✔
212	}
213	}
214	}	4✔
215	}
216
217	impl TryFrom<TypedOperator> for OperatorsTypedOperator {
218	type Error = anyhow::Error;
219	fn try_from(operator: TypedOperator) -> Result<Self, Self::Error> {	71✔
220	match operator {	71✔
221	TypedOperator::Raster(raster_operator) => Ok(Self::Raster(raster_operator.try_into()?)),	62✔
222	TypedOperator::Vector(vector_operator) => Ok(Self::Vector(vector_operator.try_into()?)),	7✔
223	TypedOperator::Plot(plot_operator) => Ok(Self::Plot(plot_operator.try_into()?)),	2✔
224	}
225	}	71✔
226	}
227
228	#[derive(OpenApi)]
229	#[openapi(components(schemas(
230	// General
231	PlotOperator,
232	TypedOperator,
233	VectorOperator,
234	// Source
235	GdalSource,
236	GdalSourceParameters,
237	MockPointSource,
238	MockPointSourceParameters,
239	MultiBandGdalSource,
240	OgrSource,
241	OgrSourceParameters,
242	// Processing
243	Aggregation,
244	BandFilter,
245	BandFilterParameters,
246	BandsByNameOrIndex,
247	DeriveOutRasterSpecsSource,
248	Downsampling,
249	DownsamplingMethod,
250	DownsamplingParameters,
251	DownsamplingResolution,
252	Expression,
253	ExpressionParameters,
254	Interpolation,
255	InterpolationMethod,
256	InterpolationParameters,
257	InterpolationResolution,
258	RasterOperator,
259	RasterStacker,
260	RasterStackerParameters,
261	RasterTypeConversion,
262	RasterTypeConversionParameters,
263	RasterVectorJoin,
264	RasterVectorJoinParameters,
265	RenameBands,
266	Reprojection,
267	ReprojectionParameters,
268	TemporalRasterAggregation,
269	TemporalRasterAggregationParameters,
270	// Plots
271	Histogram,
272	HistogramParameters,
273	Statistics,
274	StatisticsParameters,
275	// Source Parameters
276	MultipleRasterOrSingleVectorOperator,
277	MultipleRasterOrSingleVectorSource,
278	MultipleRasterSources,
279	SingleRasterOrVectorOperator,
280	SingleRasterOrVectorSource,
281	SingleRasterSource,
282	SingleVectorMultipleRasterSources,
283
284	)))]
285	pub struct OperatorsApi;

geo-engine / geoengine / 29286368238

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