Merge pull request #304 from tyrossel/densifiers

feat: add Densifiers

Author: gberaudo

demos/schm/demo.js

@@ -2,6 +2,7 @@
 import TrackManager from '../../src/interaction/TrackManager.ts';
 import GraphHopperRouter from '../../src/router/GraphHopperRouter.ts';
 import GraphhopperSnapper from '../../src/snapper/GraphHopperSnapper.ts';
+import UnsnappedDensifier from '../../src/densifier/UnsnappedDensifier.ts';
 import {ExtractFromSegmentProfiler, FallbackProfiler, SwisstopoProfiler} from '../../src/profiler/index.ts';
 import {styleFunction} from './style';
 import {createMap} from './swisstopo';
@@ -43,6 +44,8 @@ async function main() {
     ]
   });
 
+const densifier = new UnsnappedDensifier({ });
+
   /**
    * @param {MapBrowserEvent} mapBrowserEvent
    * @param {string} pointType
@@ -57,6 +60,7 @@ async function main() {
     router: router,
     snapper: snapper,
     profiler: profiler,
+    densifier: densifier,
     trackLayer: trackLayer,
     shadowTrackLayer: shadowTrackLayer,
     style: styleFunction,

src/densifier/SnappedDensifier.ts

@@ -0,0 +1,96 @@
+import type Feature from 'ol/Feature.js';
+import type LineString from 'ol/geom/LineString.js';
+import {Densifier} from './index';
+
+import {MAX_POINTS_PER_REQUEST} from '../profiler/SwisstopoProfiler';
+import {Coordinate, distance} from 'ol/coordinate';
+
+const AT_LEAST_A_POINT_EVERY_N_METERS = 10;
+const MAX_POINT_DISTANCE_FOR_A_TRACK = 80;
+const EXTRA_DISTANCE = 6; //
+
+type SnappedDensifierOptions = {
+  /** The wanted distance between two adjacent points */
+  optimalPointDistance?: number;
+
+  /** The greatest distance between two adjacent points */
+  maxPointDistance?: number;
+
+  /**
+   * The maximal number of points allowed for the new geometry
+   * If this number is reached, the original coordinates will be kept
+   */
+  maxPoints?: number;
+
+  /** no points will be inserted if one exists at that extra distance */
+  extraDistance?: number;
+};
+
+/**
+ * This densifier will insert points to an geometry to increase the point density according to the parameters.
+ *
+ * WARNING:: It is assumed that the map projection is in meters, like EPSG:3857 or EPSG:2056, as the
+ * euclidian distance is used to compute the new points.
+ */
+export default class SnappedDensifier implements Densifier {
+  private optimalPointDistance: number;
+  private maxPointDistance?: number = MAX_POINTS_PER_REQUEST;
+  private maxPoints?: number = MAX_POINTS_PER_REQUEST * 2;
+  private extraDistance?: number = EXTRA_DISTANCE;
+
+  constructor(parameters: SnappedDensifierOptions) {
+    this.optimalPointDistance = parameters.optimalPointDistance ?? AT_LEAST_A_POINT_EVERY_N_METERS;
+    this.maxPointDistance = parameters.maxPointDistance ?? MAX_POINT_DISTANCE_FOR_A_TRACK;
+  }
+
+  densify(segment: Feature<LineString>): void {
+    let interval = this.optimalPointDistance;
+    const geometry = segment.getGeometry();
+    const coordinates = geometry.getCoordinates();
+    const numberOfPoints = coordinates.length;
+    if (numberOfPoints >= this.maxPoints) return;
+
+    let retry = false;
+    do {
+      try {
+        const newCoordinates = [];
+        const optimalPointDistancePlusExtra = this.optimalPointDistance + this.extraDistance;
+        let previousCoordinate: Coordinate;
+        let addedCount = 0;
+        for (const coordinate of coordinates) {
+          if (addedCount === 0) {
+            newCoordinates.push(coordinate);
+            addedCount += 1;
+            previousCoordinate = coordinate;
+            continue;
+          }
+          const xDiff = coordinate[0] - previousCoordinate[0];
+          const yDiff = coordinate[1] - previousCoordinate[1];
+          let dist = distance(coordinate, previousCoordinate);
+          if (dist > optimalPointDistancePlusExtra) {
+            const stepVector = [(interval * xDiff) / dist, (interval * yDiff) / dist];
+            while (dist > optimalPointDistancePlusExtra) {
+              previousCoordinate = [
+                previousCoordinate[0] + stepVector[0],
+                previousCoordinate[1] + stepVector[1],
+              ];
+              dist -= interval;
+              newCoordinates.push(previousCoordinate);
+              addedCount += 1;
+              if (addedCount > this.maxPoints) throw new Error();
+            }
+          }
+          newCoordinates.push(coordinate);
+          previousCoordinate = coordinate;
+          addedCount += 1;
+          if (addedCount > this.maxPoints) throw new Error();
+        }
+        geometry.setCoordinates(newCoordinates);
+      } catch {
+        interval *= 2; // Double the interval on error
+        retry = true; // Set retry flag to true to retry the loop
+      }
+    } while (retry && interval <= this.maxPointDistance);
+    console.error('Failed to insert points, Keeping the original ones');
+  }
+}

src/densifier/UnsnappedDensifier.ts

@@ -0,0 +1,71 @@
+import type Feature from 'ol/Feature.js';
+import type LineString from 'ol/geom/LineString.js';
+import {Densifier} from './index';
+import {distance} from 'ol/coordinate';
+
+const MAX_POINT_DISTANCE_FOR_A_TRACK = 10;
+const DEFAULT_MAX_POINTS = 200;
+
+type UnsnappedDensifierOptions = {
+  /**
+   * The distance between two points in the new geometry.
+   *
+   */
+  distance?: number;
+
+  /** The maximal number of points allowed for the new geometry */
+  maxPoints?: number;
+};
+
+/**
+ * This Densifier only applies on unsnapped segments, and will split it into subsegment by creating
+ * new points on the line, so that the distance between points is not more that `distance`
+ * (in meters).
+ *
+ * The parameter `maxPoints` overrides `maxPointDistance`, and creates a hard limit on the number of
+ * points created in the new segment.
+ *
+ * If the segment already contains points in between, they are discarded and a new straight segment
+ * between the start and the end of the line is returned.
+ *
+ * WARNING:: It is assumed that the map projection is in meters, like EPSG:3857 or EPSG:2056, as the
+ * euclidian distance is used to compute the new points.
+ */
+export default class UnsnappedDensifier implements Densifier {
+  private distance: number;
+  private maxPoints: number;
+
+  constructor(parameters: UnsnappedDensifierOptions) {
+    this.distance = parameters.distance || MAX_POINT_DISTANCE_FOR_A_TRACK;
+    this.maxPoints = parameters.maxPoints || DEFAULT_MAX_POINTS;
+  }
+
+  densify(segment: Feature<LineString>): void {
+    if (segment.get('snapped')) {
+      console.log('Segment is snapped, skipped densifier');
+      return;
+    }
+
+    const geometry = segment.getGeometry();
+    const coordinates = geometry.getCoordinates();
+
+    const start = coordinates[0];
+    const end = coordinates[coordinates.length - 1];
+
+    const segment_distance = distance(start, end);
+    const xDiff = end[0] - start[0];
+    const yDiff = end[1] - start[1];
+    const nSubSegments = Math.ceil(segment_distance / this.distance);
+    const nPoints = Math.min(this.maxPoints, nSubSegments + 1);
+    const newCoords = new Array(nPoints);
+    newCoords[0] = start;
+    for (let i = 1; i < nPoints - 1; i++) {
+      const x = start[0] + (xDiff * i) / nPoints;
+      const y = start[1] + (yDiff * i) / nPoints;
+      newCoords[i] = [x, y];
+    }
+    newCoords[nPoints - 1] = end;
+
+    geometry.setCoordinates(newCoords);
+  }
+}

src/densifier/index.ts

@@ -0,0 +1,22 @@
+export {default as UnsnappedDensifier} from './UnsnappedDensifier';
+export {default as SnappedDensifier} from './SnappedDensifier';
+
+import type Feature from 'ol/Feature.js';
+import type LineString from 'ol/geom/LineString.js';
+
+/**
+ * A Densifier is an object that can modify the geometry of a segment by modifying its coordinates.
+ * It takes a segment as input, and modifies it in place.
+ *
+ * It is called between the router and the profiler.
+ *
+ * The densification process is used:
+ * - when a segment is added to the line
+ * - when a segment is modified
+ *
+ * However, the densification is not applied when a feature is restored, as no modifications are
+ * expected.
+ */
+export interface Densifier {
+  densify(segment: Feature<LineString>): void;
+}

src/interaction/TrackData.ts

@@ -158,7 +158,7 @@ export default class TrackData {
     }
   }
 
-  /*
+  /**
    * Add a new control point at the end.
    */
   pushControlPoint(point: Feature<Point>): AddedControlPoint {
@@ -185,7 +185,7 @@ export default class TrackData {
     throw new Error('Internal error: incorrect length');
   }
 
-  /*
+  /**
    * Deletes the supplied point and all adjacent segments.
    * Creates a new segment if the deleted point had two neighbors.
    * Updates first/last subtype if needed.
@@ -269,7 +269,7 @@ export default class TrackData {
     this.pois.sort((a, b) => a.get('index') - b.get('index'));
   }
 
-  /*
+  /**
    * Remove the last control point.
    */
   deleteLastControlPoint(): Feature<Point | LineString>[] {
@@ -315,7 +315,7 @@ export default class TrackData {
     return this.controlPoints.length > 0 || this.segments.length > 0 || this.pois.length > 0;
   }
 
-  /*
+  /**
    * Deletes the supplied point.
    */
   deletePOI(point: Feature<Point>) {

src/interaction/TrackDensifyer.ts

@@ -23,6 +23,7 @@ import {SelectEvent} from 'ol/interaction/Select';
 import type {Coordinate} from 'ol/coordinate';
 import type {FeatureType} from './TrackData';
 import type {Snapper} from 'src/snapper';
+import { Densifier } from 'src/densifier';
 
 export type TrackMode = 'edit' | '';
 export type TrackSubMode = 'addpoi' | 'editpoi' | '';
@@ -50,7 +51,12 @@ export interface Options {
    * The profiler instance to add 3d coordinates to segments.
    */
   profiler: Profiler
-  style: StyleLike | FlatStyleLike
+  /**
+   * The densifier to use to modify the line geometries
+   * If not provided, the track will not be densified.
+   */
+  densifier?: Densifier;
+  style: StyleLike | FlatStyleLike;
   /**
    * Condition to remove a point (control point or POI). Default is click.
    */
@@ -97,6 +103,7 @@ export default class TrackManager<POIMeta> {
     return this.router_;
   }
   private snapper_: Snapper;
+  private densifier_: Densifier | undefined;
   get snapper(): Snapper {
     return this.snapper_;
   }
@@ -119,8 +126,10 @@ export default class TrackManager<POIMeta> {
     this.router_ = options.router;
     this.snapper_ = options.snapper;
     this.profiler_ = options.profiler;
+    this.densifier_ = options.densifier;
     this.updater_ = new TrackUpdater({
       profiler: this.profiler_,
+      densifier: this.densifier_,
       router: this.router_,
       trackData: this.trackData_
     });
@@ -163,6 +172,8 @@ export default class TrackManager<POIMeta> {
         this.source_.addFeature(segment);
         await this.router_.snapSegment(segment, pointFrom, pointTo);
         this.updater_.equalizeCoordinates(pointFrom);
+
+        if (this.densifier_) this.densifier_.densify(segment);
         await this.profiler_.computeProfile(segment);
         // FIXME: setZ ?
         this.onTrackChanged_();
@@ -409,7 +420,9 @@ export default class TrackManager<POIMeta> {
     // should parse features first, compute profile, and then replace the trackdata and add history
     const parsedFeatures = this.trackData_.parseFeatures(features);
     this.source_.addFeatures(features);
-    const profileRequests = parsedFeatures.segments.map(segment => this.profiler_.computeProfile(segment));
+    const profileRequests = parsedFeatures.segments.map((segment) =>
+      this.profiler_.computeProfile(segment)
+    );
     await Promise.all(profileRequests);
     this.trackData_.restoreParsedFeatures(parsedFeatures);
   }
@@ -601,4 +614,4 @@ export default class TrackManager<POIMeta> {
     this.source_.changed();
     this.shadowTrackLayer_.getSource().changed();
   }
-}
+}