clean up

Author: michaelmattig

operators/src/adapters/raster_subquery/raster_subquery_reprojection.rs

@@ -95,7 +95,16 @@ where
             self.state.out_spatial_grid.geo_transform()
         );
 
-        // why is this none?
+        // TODO: instead of producing an empty stream if the query does not intersect the data or projection,
+        // we need to actually perform the query in order to give the nodata tiles the correct time interval
+        // because all tiles in a time step need the same temporal validity, even across diferent quereis
+
+        // so we need a way to reliably query the source in such cases that ensures no data tiles are produced.
+        // what to do in cases where the bbox coordinates cannot be reprojected?
+        // - query the data bbox but discard the data?
+        // - implement a special empty bbox query that makes sure to produce empty tiles but correct time intervals?
+        // - ideally: implement a way to query the time intervals of the source data and produce empty tiles accordingly
+
         let valid_pixel_bounds = dbg!(
             dbg!(
                 self.state
@@ -106,35 +115,17 @@ where
             .and_then(|b| b.intersection(&query_rect.spatial_query.grid_bounds()))
         );
 
-        log::debug!(
-            "ÖÖÖÖÖ valid_pixel_bounds {:?} -> {:?}",
-            tile_info.global_pixel_bounds(),
-            valid_pixel_bounds
-        );
-
         let valid_spatial_bounds = valid_pixel_bounds.map(|pb| {
             self.state
                 .out_spatial_grid
                 .geo_transform()
                 .grid_to_spatial_bounds(&pb)
         });
 
-        log::debug!(
-            "ÖÖÖÖÖ valid_spatial_bounds {:?} -> {:?}",
-            query_rect.spatial_query.grid_bounds(),
-            valid_spatial_bounds
-        );
-
         if let Some(bounds) = valid_spatial_bounds {
             let proj = CoordinateProjector::from_known_srs(self.out_srs, self.in_srs)?;
             let projected_bounds = bounds.reproject(&proj);
 
-            log::debug!(
-                "ÖÖÖÖÖ projected_bounds {:?} -> {:?}",
-                bounds,
-                projected_bounds
-            );
-
             match projected_bounds {
                 Ok(pb) => {
                     dbg!("produce something");
@@ -154,13 +145,6 @@ where
             }
         } else {
             dbg!("output query rectangle is not valid in source projection => produce empty tile");
-            log::debug!(
-                "ÖÖÖÖÖ output query rectangle is not valid in source projection => produce empty tile {:?}",
-                self.state
-                    .out_spatial_grid
-                    .geo_transform()
-                    .grid_to_spatial_bounds(&query_rect.spatial_query.grid_bounds())
-            );
 
             // output query rectangle is not valid in source projection => produce empty tile
             Ok(None)

operators/src/adapters/sparse_tiles_fill_adapter.rs

@@ -284,7 +284,6 @@ impl<T: Pixel> StateContainer<T> {
 
     fn set_current_time_from_initial_tile(&mut self, first_tile_time: TimeInterval) {
         debug_assert!(first_tile_time.end() > first_tile_time.start());
-        debug_assert!(first_tile_time.end() != first_tile_time.start() + 1);
         // if we know a bound we must use it to set the current time
         let start_data_bound = self.data_time_bounds.start();
         let requested_start = self.requested_time_bounds.start();
@@ -322,15 +321,13 @@ impl<T: Pixel> StateContainer<T> {
             TimeInterval::new(self.data_time_bounds.start(), self.data_time_bounds.end()).unwrap(),
         );
         debug_assert!(!self.current_time.unwrap().is_instant());
-        // debug_assert!(self.current_time.unwrap().end() != self.current_time.unwrap().start() + 1);
     }
 
     fn update_current_time(&mut self, new_time: TimeInterval) {
         debug_assert!(
             !new_time.is_instant(),
             "Tile time is the data validity and must not be an instant!"
         );
-        debug_assert!(new_time.end() != new_time.start() + 1);
 
         if let Some(old_time) = self.current_time {
             if old_time == new_time {

operators/src/processing/downsample/mod.rs

@@ -256,8 +256,6 @@ where
         query: RasterQueryRectangle,
         ctx: &'a dyn QueryContext,
     ) -> Result<BoxStream<'a, Result<Self::Output>>> {
-        log::debug!("ÖÖÖÖÖÖ Downsampling query: {:?}", query);
-
         // do not interpolate if the source resolution is already fine enough
 
         let in_spatial_grid = self.source.result_descriptor().spatial_grid_descriptor();
@@ -405,7 +403,6 @@ impl<T: Pixel> FoldTileAccu for DownsampleAccu<T> {
 
     async fn into_tile(self) -> Result<RasterTile2D<Self::RasterType>> {
         debug_assert!(self.time.unwrap().end() > self.time.unwrap().start());
-        debug_assert!(self.time.unwrap().end() != self.time.unwrap().start() + 1);
         // TODO: later do conversation of accu into tile here
 
         let output_tile = RasterTile2D::new_with_tile_info(

operators/src/processing/reprojection.rs

@@ -638,8 +638,6 @@ where
         query: RasterQueryRectangle,
         ctx: &'a dyn QueryContext,
     ) -> Result<BoxStream<'a, Result<Self::Output>>> {
-        log::debug!("ÖÖÖÖÖÖ Reprojection query: {:?}", query);
-
         let state = self.state;
 
         // setup the subquery
@@ -682,9 +680,8 @@ mod tests {
     use crate::mock::MockFeatureCollectionSource;
     use crate::mock::{MockRasterSource, MockRasterSourceParams};
     use crate::source::{
-        FileNotFoundHandling, GdalDatasetGeoTransform, GdalDatasetParameters,
-        GdalLoadingInfoTemporalSlice, GdalMetaDataList, GdalMetaDataRegular, GdalMetaDataStatic,
-        GdalSourceTimePlaceholder, TimeReference,
+        FileNotFoundHandling, GdalDatasetGeoTransform, GdalDatasetParameters, GdalMetaDataRegular,
+        GdalMetaDataStatic, GdalSourceTimePlaceholder, TimeReference,
     };
     use crate::util::gdal::add_ndvi_dataset;
     use crate::{
@@ -1483,6 +1480,7 @@ mod tests {
 
         for r in result {
             assert!(r.is_empty());
+            assert_eq!(r.time, time_interval);
         }
     }
 
@@ -1754,125 +1752,4 @@ mod tests {
             GridBoundingBox2D::new_min_max(-1405, 1405, -1410, 1409).unwrap()
         );
     }
-
-    #[tokio::test]
-    async fn it_sets_correct_temporal_validity_for_partially_undefined_source_regions() -> Result<()>
-    {
-        let tile_size_in_pixels = [600, 600].into(); //TODO ??
-        let data_geo_transform =
-            GeoTransform::new(Coordinate2D::new(399_960.000, 5700_000.000), 1098., -1098.);
-        let data_bounds = GridBoundingBox2D::new([0, 0], [99, 99]).unwrap();
-        let result_descriptor = RasterResultDescriptor {
-            data_type: RasterDataType::U8,
-            spatial_reference: SpatialReference::new(SpatialReferenceAuthority::Epsg, 32632).into(),
-            time: None,
-            spatial_grid: SpatialGridDescriptor::source_from_parts(data_geo_transform, data_bounds),
-            bands: RasterBandDescriptors::new_single_band(),
-        };
-
-        dbg!(result_descriptor.spatial_grid);
-
-        let m = GdalMetaDataList {
-            result_descriptor: result_descriptor.clone(),
-            params: vec![GdalLoadingInfoTemporalSlice {
-                time: TimeInterval::new_unchecked(
-                    TimeInstance::from_str("2022-02-01T00:00:00.000Z").unwrap(),
-                    TimeInstance::from_str("2022-03-01T00:00:00.000Z").unwrap(),
-                ),
-                params: Some(GdalDatasetParameters {
-                    file_path: test_data!(
-                        "raster/sentinel2/S2B_32UMB_20220129_0_L2A__B02.tif_downsampled.tif"
-                    )
-                    .into(),
-                    rasterband_channel: 1,
-                    geo_transform: GdalDatasetGeoTransform {
-                        origin_coordinate: data_geo_transform.origin_coordinate,
-                        x_pixel_size: data_geo_transform.x_pixel_size(),
-                        y_pixel_size: data_geo_transform.y_pixel_size(),
-                    },
-                    width: data_bounds.axis_size_x(),
-                    height: data_bounds.axis_size_y(),
-                    file_not_found_handling: FileNotFoundHandling::Error,
-                    no_data_value: Some(0.),
-                    properties_mapping: None,
-                    gdal_open_options: None,
-                    gdal_config_options: None,
-                    allow_alphaband_as_mask: true,
-                    retry: None,
-                }),
-                cache_ttl: CacheTtlSeconds::default(),
-            }],
-        };
-
-        let tiling_spec = TilingSpecification::new(tile_size_in_pixels);
-        let mut exe_ctx = MockExecutionContext::new_with_tiling_spec(tiling_spec);
-
-        let id: DataId = DatasetId::new().into();
-        let name = NamedData::with_system_name("s2");
-        exe_ctx.add_meta_data(id.clone(), name.clone(), Box::new(m));
-
-        let gdal_op = GdalSource {
-            params: GdalSourceParameters::new(name),
-        }
-        .boxed();
-
-        let initialized_operator = RasterOperator::boxed(Reprojection {
-            params: ReprojectionParams {
-                target_spatial_reference: SpatialReference::epsg_4326(),
-                derive_out_spec: DeriveOutRasterSpecsSource::DataBounds,
-            },
-            sources: SingleRasterOrVectorSource {
-                source: gdal_op.into(),
-            },
-        })
-        .initialize(WorkflowOperatorPath::initialize_root(), &exe_ctx)
-        .await?;
-
-        let qp = initialized_operator
-            .query_processor()
-            .unwrap()
-            .get_u8()
-            .unwrap();
-
-        let qr = qp.result_descriptor();
-
-        dbg!(qr.spatial_grid);
-        let query_ctx = exe_ctx.mock_query_context(TestDefault::test_default());
-
-        // query with Germany bbox which is partially outside of 32632 projection
-        let request_bounds = SpatialPartition2D::new(
-            Coordinate2D::new(5.98865807458, 54.983104153),
-            Coordinate2D::new(15.0169958839, 47.3024876979),
-        )?;
-
-        let query_tiling_pixel_grid = qr
-            .spatial_grid_descriptor()
-            .tiling_grid_definition(tiling_spec)
-            .tiling_spatial_grid_definition()
-            .spatial_bounds_to_compatible_spatial_grid(request_bounds);
-
-        let query_rect = RasterQueryRectangle::new_with_grid_bounds(
-            query_tiling_pixel_grid.grid_bounds(),
-            TimeInterval::new_instant(TimeInstance::from_str("2022-02-01T00:00:00.000Z").unwrap())
-                .unwrap(),
-            BandSelection::first(),
-        );
-
-        dbg!(&query_rect);
-
-        let qs = qp.raster_query(query_rect, &query_ctx).await.unwrap();
-
-        let tiles = qs
-            .map(Result::unwrap)
-            .collect::<Vec<RasterTile2D<u8>>>()
-            .await;
-
-        for r in tiles {
-            dbg!(r.time, r.is_empty());
-        }
-
-        assert!(false);
-
-        Ok(())
-    }
 }

operators/src/source/gdal_source/loading_info.rs

@@ -303,10 +303,6 @@ impl MetaData<GdalLoadingInfo, RasterResultDescriptor, RasterQueryRectangle> for
         let known_time_before = known_time_start.unwrap_or(TimeInstance::MIN);
         let known_time_after = known_time_end.unwrap_or(TimeInstance::MAX);
 
-        log::debug!(
-            "ÄÄÄÄÄÄ known_time_before: {known_time_before}, known_time_after: {known_time_after}",
-        );
-
         Ok(GdalLoadingInfo::new(
             GdalLoadingInfoTemporalSliceIterator::Static {
                 parts: data.into_iter(),

services/examples/force-import.rs

@@ -1,4 +1,4 @@
-use chrono::{NaiveDate, TimeZone, naive};
+use chrono::{NaiveDate, TimeZone};
 use gdal::vector::{Defn, Feature, FieldDefn, LayerOptions, OGRFieldType};
 use gdal::{Dataset as GdalDataset, DriverManager, Metadata};
 use geoengine_datatypes::primitives::{CacheTtlSeconds, DateTime, TimeInstance, TimeInterval};

services/src/api/handlers/wms.rs

@@ -28,7 +28,6 @@ use snafu::ensure;
 use std::str::FromStr;
 use std::time::Duration;
 use tracing::debug;
-use tracing_subscriber::field::debug;
 use uuid::Uuid;
 
 pub(crate) fn init_wms_routes<C>(cfg: &mut web::ServiceConfig)
@@ -277,15 +276,10 @@ async fn wms_map_handler<C: ApplicationContext>(
             request.crs.ok_or(error::Error::MissingSpatialReference)?;
 
         let request_bounds: SpatialPartition2D = request.bbox.bounds(request_spatial_ref)?;
-
-        debug!("WMS request bounds: {:?}", request_bounds);
-
         let x_request_res = request_bounds.size_x() / f64::from(request.width);
         let y_request_res = request_bounds.size_y() / f64::from(request.height);
         let request_resolution = SpatialResolution::new(x_request_res.abs(), y_request_res.abs())?;
 
-        debug!("WMS request resolution: {:?}", request_resolution);
-
         let raster_colorizer = raster_colorizer_from_style(&request.styles)?;
 
         let ctx = app_ctx.session_context(session);
@@ -357,7 +351,7 @@ async fn wms_map_handler<C: ApplicationContext>(
             query_tiling_pixel_grid.grid_bounds(),
             request.time.unwrap_or_else(default_time_from_config).into(),
             attributes,
-        ); // <-- this one 
+        );
 
         debug!("WMS query rect: {:?}", query_rect);