Merge pull request #29 from sentinel-hub/feature/find-flyover-times-coverage

Feature/find flyovers coverage

Author: sinergise-anze

README.md

@@ -141,17 +141,17 @@ We can always use layer to search for data availability:
 
   const maxCloudCoverPercent = 50;
   const layerS2L2A = new S2L2ALayer(instanceId, 'S2L2A', null, null, null, null, null, maxCloudCoverPercent);
-  const tilesS2L2A = layerS2L2A.findTiles(bbox, fromDate, toDate, maxCount, offset);
-  const flyoverIntervalsS2L2A = layerS2L2A.findFlyoverIntervals(tilesS2L2A.tiles);
+  const { tiles, hasMore } = layerS2L2A.findTiles(bbox, fromDate, toDate, maxCount, offset);
+  const flyoversS2L2A = layerS2L2A.findFlyovers(bbox, fromDate, toDate);
   const dates = layerS2L2A.findDatesUTC(bbox, fromDate, toDate);
 
   const layerS1 = new S1GRDAWSEULayer(
     instanceId, 'LayerS1GRD',
     null, null, null, null, null, null, null, null,
     true, BackscatterCoeff.GAMMA0_ELLIPSOID, OrbitDirection.ASCENDING
   );
-  const tilesS1 = layerS1.findTiles(bbox, fromDate, toDate, maxCount, offset);
-  const flyoverIntervalsS1 = layerS1.findFlyoverIntervals(tilesS1.tiles);
+  const { tiles: tilesS1 } = layerS1.findTiles(bbox, fromDate, toDate, maxCount, offset);
+  const flyoversS1 = layerS1.findFlyovers(bbox, fromDate, toDate);
 ```
 
 ## Backwards compatibility

example/node/index.js

@@ -110,30 +110,44 @@ async function run() {
 
   // get tiles and flyover intervals for S2 L2A layer
   const layerS2L2A = new S2L2ALayer(instanceId, s2l2aLayerId);
-  const tilesS2L2A = await layerS2L2A.findTiles(
+  const { tiles: tilesS2L2A, hasMore } = await layerS2L2A.findTiles(
     getMapParams.bbox,
     getMapParams.fromTime,
     getMapParams.toTime,
     20,
     0,
-    100,
   );
   printOut('tiles for S2 L2A:', tilesS2L2A);
-  const flyoverIntervalsS2L2A = layerS2L2A.findFlyoverIntervals(tilesS2L2A.tiles);
-  printOut('flyover intervals for S2 L2A:', flyoverIntervalsS2L2A);
+  printOut('hasMore:', hasMore);
+
+  const flyoversS2L2A = await layerS2L2A.findFlyovers(
+    getMapParams.bbox,
+    getMapParams.fromTime,
+    getMapParams.toTime,
+    10,
+    50,
+  );
+  printOut('flyovers for S2 L2A:', flyoversS2L2A);
 
   // get tiles and flyover intervals for S1 GRD Layer
-  const tilesS1GRD = await layerS1.findTiles(
+  const { tiles: tilesS1GRD, hasMore: hasMoreS1 } = await layerS1.findTiles(
     getMapParams.bbox,
     getMapParams.fromTime,
     getMapParams.toTime,
     10,
     0,
-    OrbitDirection.ASCENDING,
   );
   printOut('tiles for S1 GRD:', tilesS1GRD);
-  const flyoverIntervalsS1GRD = layerS1.findFlyoverIntervals(tilesS1GRD.tiles);
-  printOut('flyover intervals for S1 GRD:', flyoverIntervalsS1GRD);
+  printOut('hasMore for S1:', hasMoreS1);
+
+  const flyoversS1GRD = await layerS1.findFlyovers(
+    getMapParams.bbox,
+    getMapParams.fromTime,
+    getMapParams.toTime,
+    10,
+    50,
+  );
+  printOut('flyovers for S1 GRD:', flyoversS1GRD);
 
   // finally, display the image:
   const imageUrl = await layerS2L2A.getMapUrl(getMapParams, ApiType.WMS);

package-lock.json

@@ -5,7 +5,10 @@
   "module": "dist/sentinelHub.esm.js",
   "browser": "dist/sentinelHub.umd.js",
   "dependencies": {
+    "@turf/area": "^6.0.1",
     "@turf/helpers": "^6.1.4",
+    "@turf/intersect": "^6.1.3",
+    "@turf/union": "^5.1.5",
     "@types/xml2js": "^0.4.4",
     "axios": "^0.18.1",
     "query-string": "^6.4.2",
@@ -14,9 +17,9 @@
   "devDependencies": {
     "@babel/core": "^7.8.3",
     "@storybook/html": "^5.3.3",
+    "@types/jest": "^25.1.3",
     "@typescript-eslint/eslint-plugin": "^1.9.0",
     "@typescript-eslint/parser": "^1.9.0",
-    "@types/jest": "^25.1.2",
     "babel-loader": "^8.0.6",
     "dotenv": "^8.2.0",
     "eslint": "^5.16.0",

package.json

@@ -0,0 +1,7 @@
+declare module '@turf/union' {
+  import { MultiPolygon, Polygon } from '@turf/helpers';
+  export default function union(
+    poly1: Polygon | MultiPolygon,
+    poly2: Polygon | MultiPolygon,
+  ): Polygon | MultiPolygon;
+}

src/customTypings/@turf/union/index.d.ts

@@ -4,6 +4,12 @@ import { GetMapParams, ApiType, Tile, PaginatedTiles, FlyoverInterval } from 'sr
 import { BBox } from 'src/bbox';
 import { Dataset } from 'src/layer/dataset';
 import { RequestConfig } from 'src/utils/axiosInterceptors';
+import intersect from '@turf/intersect';
+import area from '@turf/area';
+import union from '@turf/union'; // @turf/union is missing types definitions, we supply them separately
+
+import { Polygon, MultiPolygon } from '@turf/helpers';
+import { CRS_EPSG4326 } from 'src/crs';
 
 export class AbstractLayer {
   public title: string | null = null;
@@ -44,41 +50,104 @@ export class AbstractLayer {
     throw new Error('Not implemented yet');
   }
 
-  public findFlyoverIntervals(tiles: Tile[]): FlyoverInterval[] {
+  public async findFlyovers(
+    bbox: BBox,
+    fromTime: Date,
+    toTime: Date,
+    maxFindTilesRequests: number = 50,
+    tilesPerRequest: number = 50,
+  ): Promise<FlyoverInterval[]> {
     if (!this.dataset || !this.dataset.orbitTimeMinutes) {
       throw new Error('Orbit time is needed for grouping tiles into flyovers.');
     }
 
+    if (bbox.crs !== CRS_EPSG4326) {
+      throw new Error('Currently, only EPSG:4326 in findFlyovers');
+    }
+
+    let tiles: Tile[] = [];
+    for (let i = 0; i < maxFindTilesRequests; i++) {
+      const { tiles: partialTiles, hasMore } = await this.findTiles(
+        bbox,
+        fromTime,
+        toTime,
+        tilesPerRequest,
+        i * tilesPerRequest,
+      );
+      tiles = tiles.concat(partialTiles);
+      if (!hasMore) {
+        break;
+      }
+      if (i + 1 === maxFindTilesRequests) {
+        throw new Error(
+          `Could not fetch all the tiles in [${maxFindTilesRequests}] requests for [${tilesPerRequest}] tiles`,
+        );
+      }
+    }
+
     tiles.sort((a, b) => a.sensingTime.getTime() - b.sensingTime.getTime());
     let orbitTimeMS = this.dataset.orbitTimeMinutes * 60 * 1000;
     let flyoverIntervals: FlyoverInterval[] = [];
 
-    let j = 0;
-    for (let i = 0; i < tiles.length; i++) {
-      if (i === 0) {
-        flyoverIntervals[j] = {
-          fromTime: tiles[i].sensingTime,
-          toTime: tiles[i].sensingTime,
+    let flyoverIndex = 0;
+    let currentFlyoverGeometry = null;
+    for (let tileIndex = 0; tileIndex < tiles.length; tileIndex++) {
+      if (tileIndex === 0) {
+        flyoverIntervals[flyoverIndex] = {
+          fromTime: tiles[tileIndex].sensingTime,
+          toTime: tiles[tileIndex].sensingTime,
+          coveragePercent: 0,
         };
+        currentFlyoverGeometry = tiles[tileIndex].geometry;
         continue;
       }
 
-      const prevDateMS = tiles[i - 1].sensingTime.getTime();
-      const currDateMS = tiles[i].sensingTime.getTime();
+      const prevDateMS = tiles[tileIndex - 1].sensingTime.getTime();
+      const currDateMS = tiles[tileIndex].sensingTime.getTime();
       const diffMS = Math.abs(prevDateMS - currDateMS);
 
       if (diffMS < orbitTimeMS) {
-        flyoverIntervals[j].toTime = tiles[i].sensingTime;
+        flyoverIntervals[flyoverIndex].toTime = tiles[tileIndex].sensingTime;
+        currentFlyoverGeometry = union(currentFlyoverGeometry, tiles[tileIndex].geometry);
       } else {
-        j++;
-        flyoverIntervals[j] = {
-          fromTime: tiles[i].sensingTime,
-          toTime: tiles[i].sensingTime,
+        flyoverIntervals[flyoverIndex].coveragePercent = this.calculateCoveragePercent(
+          bbox,
+          currentFlyoverGeometry,
+        );
+        flyoverIndex++;
+        flyoverIntervals[flyoverIndex] = {
+          fromTime: tiles[tileIndex].sensingTime,
+          toTime: tiles[tileIndex].sensingTime,
+          coveragePercent: 0,
         };
+        currentFlyoverGeometry = tiles[tileIndex].geometry;
       }
     }
+    if (flyoverIntervals.length > 0) {
+      flyoverIntervals[flyoverIndex].coveragePercent = this.calculateCoveragePercent(
+        bbox,
+        currentFlyoverGeometry,
+      );
+    }
     return flyoverIntervals;
   }
 
+  private calculateCoveragePercent(bbox: BBox, flyoverGeometry: Polygon | MultiPolygon): number {
+    const bboxGeometry: Polygon = {
+      type: 'Polygon',
+      coordinates: [
+        [
+          [bbox.minX, bbox.minY],
+          [bbox.maxX, bbox.minY],
+          [bbox.maxX, bbox.maxY],
+          [bbox.minX, bbox.maxY],
+          [bbox.minX, bbox.minY],
+        ],
+      ],
+    };
+    const bboxedFlyoverGeometry = intersect(bboxGeometry, flyoverGeometry);
+    return (area(bboxedFlyoverGeometry) / area(bboxGeometry)) * 100;
+  }
+
   public async updateLayerFromServiceIfNeeded(): Promise<void> {}
 }

src/layer/AbstractLayer.ts

@@ -62,6 +62,7 @@ export type PaginatedTiles = {
 export type FlyoverInterval = {
   fromTime: Date;
   toTime: Date;
+  coveragePercent: number;
 };
 
 export type MimeType =