ol 10.6.2-dev.1753992384159 → 10.6.2-dev.1754054564182

package/interaction/Draw.d.ts

@@ -165,10 +165,7 @@ export type Options = {
  * Coordinate type when drawing points.
  */
 export type PointCoordType = import("../coordinate.js").Coordinate;
-/**
- * Coordinate type when drawing lines.
- */
-export type LineCoordType = Array<import("../coordinate.js").Coordinate>;
+export type LineCoordType = import("./tracing.js").LineCoordType;
 /**
  * Coordinate type when drawing polygons.
  */
@@ -177,44 +174,8 @@ export type PolyCoordType = Array<Array<import("../coordinate.js").Coordinate>>;
  * Types used for drawing coordinates.
  */
 export type SketchCoordType = PointCoordType | LineCoordType | PolyCoordType;
-export type TraceState = {
-    /**
-     * Tracing active.
-     */
-    active: boolean;
-    /**
-     * The initially clicked pixel location.
-     */
-    startPx?: import("../pixel.js").Pixel | undefined;
-    /**
-     * Targets available for tracing.
-     */
-    targets?: TraceTarget[] | undefined;
-    /**
-     * The index of the currently traced target.  A value of -1 indicates
-     * that no trace target is active.
-     */
-    targetIndex?: number | undefined;
-};
-export type TraceTarget = {
-    /**
-     * Target coordinates.
-     */
-    coordinates: Array<import("../coordinate.js").Coordinate>;
-    /**
-     * The target coordinates are a linear ring.
-     */
-    ring: boolean;
-    /**
-     * The index of first traced coordinate.  A fractional index represents an
-     * edge intersection.  Index values for rings will wrap (may be negative or larger than coordinates length).
-     */
-    startIndex: number;
-    /**
-     * The index of last traced coordinate.  Details from startIndex also apply here.
-     */
-    endIndex: number;
-};
+export type TraceState = import("./tracing.js").TraceState;
+export type TraceTarget = import("./tracing.js").TraceTarget;
 /**
  * Function that takes an array of coordinates and an optional existing geometry
  * and a projection as arguments, and returns a geometry. The optional existing
@@ -227,26 +188,6 @@ export type GeometryFunction = (arg0: SketchCoordType, arg1: import("../geom/Sim
  * cousins.
  */
 export type Mode = "Point" | "LineString" | "Polygon" | "Circle";
-export type TraceTargetUpdateInfo = {
-    /**
-     * The new target index.
-     */
-    index: number;
-    /**
-     * The new segment end index.
-     */
-    endIndex: number;
-};
-export type PointSegmentRelationship = {
-    /**
-     * The closest point expressed as a fraction along the segment length.
-     */
-    along: number;
-    /**
-     * The squared distance of the point to the segment.
-     */
-    squaredDistance: number;
-};
 /**
  * *
  */

package/interaction/Draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Draw.d.ts","sourceRoot":"","sources":["Draw.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Draw.d.ts","sourceRoot":"","sources":["Draw.js"],"names":[],"mappings":"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"}

package/interaction/Draw.js

@@ -25,7 +25,6 @@ import {
 } from '../extent.js';
 import {FALSE, TRUE} from '../functions.js';
 import Circle from '../geom/Circle.js';
-import GeometryCollection from '../geom/GeometryCollection.js';
 import LineString from '../geom/LineString.js';
 import MultiLineString from '../geom/MultiLineString.js';
 import MultiPoint from '../geom/MultiPoint.js';
@@ -34,12 +33,17 @@ import Point from '../geom/Point.js';
 import Polygon, {fromCircle, makeRegular} from '../geom/Polygon.js';
 import {getStrideForLayout} from '../geom/SimpleGeometry.js';
 import VectorLayer from '../layer/Vector.js';
-import {clamp, squaredDistance, toFixed} from '../math.js';
 import {fromUserCoordinate, getUserProjection} from '../proj.js';
 import VectorSource from '../source/Vector.js';
 import {createEditingStyle} from '../style/Style.js';
 import PointerInteraction from './Pointer.js';
 import InteractionProperty from './Property.js';
+import {
+  getCoordinate,
+  getTraceTargetUpdate,
+  getTraceTargets,
+  interpolateCoordinate,
+} from './tracing.js';
 
 /**
  * @typedef {Object} Options
@@ -115,8 +119,7 @@ import InteractionProperty from './Property.js';
  */
 
 /**
- * Coordinate type when drawing lines.
- * @typedef {Array<import("../coordinate.js").Coordinate>} LineCoordType
+ * @typedef {import('./tracing.js').LineCoordType} LineCoordType
  */
 
 /**
@@ -129,23 +132,9 @@ import InteractionProperty from './Property.js';
  * @typedef {PointCoordType|LineCoordType|PolyCoordType} SketchCoordType
  */
 
-/**
- * @typedef {Object} TraceState
- * @property {boolean} active Tracing active.
- * @property {import("../pixel.js").Pixel} [startPx] The initially clicked pixel location.
- * @property {Array<TraceTarget>} [targets] Targets available for tracing.
- * @property {number} [targetIndex] The index of the currently traced target.  A value of -1 indicates
- * that no trace target is active.
- */
+/** @typedef {import('./tracing.js').TraceState} TraceState */
 
-/**
- * @typedef {Object} TraceTarget
- * @property {Array<import("../coordinate.js").Coordinate>} coordinates Target coordinates.
- * @property {boolean} ring The target coordinates are a linear ring.
- * @property {number} startIndex The index of first traced coordinate.  A fractional index represents an
- * edge intersection.  Index values for rings will wrap (may be negative or larger than coordinates length).
- * @property {number} endIndex The index of last traced coordinate.  Details from startIndex also apply here.
- */
+/** @typedef {import('./tracing.js').TraceTarget} TraceTarget */
 
 /**
  * Function that takes an array of coordinates and an optional existing geometry
@@ -209,371 +198,6 @@ export class DrawEvent extends Event {
   }
 }
 
-/**
- * @param {import("../coordinate.js").Coordinate} coordinate The coordinate.
- * @param {Array<Feature>} features The candidate features.
- * @return {Array<TraceTarget>} The trace targets.
- */
-function getTraceTargets(coordinate, features) {
-  /**
-   * @type {Array<TraceTarget>}
-   */
-  const targets = [];
-
-  for (let i = 0; i < features.length; ++i) {
-    const feature = features[i];
-    const geometry = feature.getGeometry();
-    appendGeometryTraceTargets(coordinate, geometry, targets);
-  }
-
-  return targets;
-}
-
-/**
- * @param {import("../coordinate.js").Coordinate} a One coordinate.
- * @param {import("../coordinate.js").Coordinate} b Another coordinate.
- * @return {number} The squared distance between the two coordinates.
- */
-function getSquaredDistance(a, b) {
-  return squaredDistance(a[0], a[1], b[0], b[1]);
-}
-
-/**
- * @param {LineCoordType} coordinates The ring coordinates.
- * @param {number} index The index.  May be wrapped.
- * @return {import("../coordinate.js").Coordinate} The coordinate.
- */
-function getCoordinate(coordinates, index) {
-  const count = coordinates.length;
-  if (index < 0) {
-    return coordinates[index + count];
-  }
-  if (index >= count) {
-    return coordinates[index - count];
-  }
-  return coordinates[index];
-}
-
-/**
- * Get the cumulative squared distance along a ring path.  The end index index may be "wrapped" and it may
- * be less than the start index to indicate the direction of travel.  The start and end index may have
- * a fractional part to indicate a point between two coordinates.
- * @param {LineCoordType} coordinates Ring coordinates.
- * @param {number} startIndex The start index.
- * @param {number} endIndex The end index.
- * @return {number} The cumulative squared distance along the ring path.
- */
-function getCumulativeSquaredDistance(coordinates, startIndex, endIndex) {
-  let lowIndex, highIndex;
-  if (startIndex < endIndex) {
-    lowIndex = startIndex;
-    highIndex = endIndex;
-  } else {
-    lowIndex = endIndex;
-    highIndex = startIndex;
-  }
-  const lowWholeIndex = Math.ceil(lowIndex);
-  const highWholeIndex = Math.floor(highIndex);
-
-  if (lowWholeIndex > highWholeIndex) {
-    // both start and end are on the same segment
-    const start = interpolateCoordinate(coordinates, lowIndex);
-    const end = interpolateCoordinate(coordinates, highIndex);
-    return getSquaredDistance(start, end);
-  }
-
-  let sd = 0;
-
-  if (lowIndex < lowWholeIndex) {
-    const start = interpolateCoordinate(coordinates, lowIndex);
-    const end = getCoordinate(coordinates, lowWholeIndex);
-    sd += getSquaredDistance(start, end);
-  }
-
-  if (highWholeIndex < highIndex) {
-    const start = getCoordinate(coordinates, highWholeIndex);
-    const end = interpolateCoordinate(coordinates, highIndex);
-    sd += getSquaredDistance(start, end);
-  }
-
-  for (let i = lowWholeIndex; i < highWholeIndex - 1; ++i) {
-    const start = getCoordinate(coordinates, i);
-    const end = getCoordinate(coordinates, i + 1);
-    sd += getSquaredDistance(start, end);
-  }
-
-  return sd;
-}
-
-/**
- * @param {import("../coordinate.js").Coordinate} coordinate The coordinate.
- * @param {import("../geom/Geometry.js").default} geometry The candidate geometry.
- * @param {Array<TraceTarget>} targets The trace targets.
- */
-function appendGeometryTraceTargets(coordinate, geometry, targets) {
-  if (geometry instanceof LineString) {
-    appendTraceTarget(coordinate, geometry.getCoordinates(), false, targets);
-    return;
-  }
-  if (geometry instanceof MultiLineString) {
-    const coordinates = geometry.getCoordinates();
-    for (let i = 0, ii = coordinates.length; i < ii; ++i) {
-      appendTraceTarget(coordinate, coordinates[i], false, targets);
-    }
-    return;
-  }
-  if (geometry instanceof Polygon) {
-    const coordinates = geometry.getCoordinates();
-    for (let i = 0, ii = coordinates.length; i < ii; ++i) {
-      appendTraceTarget(coordinate, coordinates[i], true, targets);
-    }
-    return;
-  }
-  if (geometry instanceof MultiPolygon) {
-    const polys = geometry.getCoordinates();
-    for (let i = 0, ii = polys.length; i < ii; ++i) {
-      const coordinates = polys[i];
-      for (let j = 0, jj = coordinates.length; j < jj; ++j) {
-        appendTraceTarget(coordinate, coordinates[j], true, targets);
-      }
-    }
-    return;
-  }
-  if (geometry instanceof GeometryCollection) {
-    const geometries = geometry.getGeometries();
-    for (let i = 0; i < geometries.length; ++i) {
-      appendGeometryTraceTargets(coordinate, geometries[i], targets);
-    }
-    return;
-  }
-  // other types cannot be traced
-}
-
-/**
- * @typedef {Object} TraceTargetUpdateInfo
- * @property {number} index The new target index.
- * @property {number} endIndex The new segment end index.
- */
-
-/**
- * @type {TraceTargetUpdateInfo}
- */
-const sharedUpdateInfo = {index: -1, endIndex: NaN};
-
-/**
- * @param {import("../coordinate.js").Coordinate} coordinate The coordinate.
- * @param {TraceState} traceState The trace state.
- * @param {import("../Map.js").default} map The map.
- * @param {number} snapTolerance The snap tolerance.
- * @return {TraceTargetUpdateInfo} Information about the new trace target.  The returned
- * object is reused between calls and must not be modified by the caller.
- */
-function getTraceTargetUpdate(coordinate, traceState, map, snapTolerance) {
-  const x = coordinate[0];
-  const y = coordinate[1];
-
-  let closestTargetDistance = Infinity;
-
-  let newTargetIndex = -1;
-  let newEndIndex = NaN;
-
-  for (
-    let targetIndex = 0;
-    targetIndex < traceState.targets.length;
-    ++targetIndex
-  ) {
-    const target = traceState.targets[targetIndex];
-    const coordinates = target.coordinates;
-
-    let minSegmentDistance = Infinity;
-    let endIndex;
-    for (
-      let coordinateIndex = 0;
-      coordinateIndex < coordinates.length - 1;
-      ++coordinateIndex
-    ) {
-      const start = coordinates[coordinateIndex];
-      const end = coordinates[coordinateIndex + 1];
-      const rel = getPointSegmentRelationship(x, y, start, end);
-      if (rel.squaredDistance < minSegmentDistance) {
-        minSegmentDistance = rel.squaredDistance;
-        endIndex = coordinateIndex + rel.along;
-      }
-    }
-
-    if (minSegmentDistance < closestTargetDistance) {
-      closestTargetDistance = minSegmentDistance;
-      if (target.ring && traceState.targetIndex === targetIndex) {
-        // same target, maintain the same trace direction
-        if (target.endIndex > target.startIndex) {
-          // forward trace
-          if (endIndex < target.startIndex) {
-            endIndex += coordinates.length;
-          }
-        } else if (target.endIndex < target.startIndex) {
-          // reverse trace
-          if (endIndex > target.startIndex) {
-            endIndex -= coordinates.length;
-          }
-        }
-      }
-      newEndIndex = endIndex;
-      newTargetIndex = targetIndex;
-    }
-  }
-
-  const newTarget = traceState.targets[newTargetIndex];
-  let considerBothDirections = newTarget.ring;
-  if (traceState.targetIndex === newTargetIndex && considerBothDirections) {
-    // only consider switching trace direction if close to the start
-    const newCoordinate = interpolateCoordinate(
-      newTarget.coordinates,
-      newEndIndex,
-    );
-    const pixel = map.getPixelFromCoordinate(newCoordinate);
-    if (distance(pixel, traceState.startPx) > snapTolerance) {
-      considerBothDirections = false;
-    }
-  }
-
-  if (considerBothDirections) {
-    const coordinates = newTarget.coordinates;
-    const count = coordinates.length;
-    const startIndex = newTarget.startIndex;
-    const endIndex = newEndIndex;
-    if (startIndex < endIndex) {
-      const forwardDistance = getCumulativeSquaredDistance(
-        coordinates,
-        startIndex,
-        endIndex,
-      );
-      const reverseDistance = getCumulativeSquaredDistance(
-        coordinates,
-        startIndex,
-        endIndex - count,
-      );
-      if (reverseDistance < forwardDistance) {
-        newEndIndex -= count;
-      }
-    } else {
-      const reverseDistance = getCumulativeSquaredDistance(
-        coordinates,
-        startIndex,
-        endIndex,
-      );
-      const forwardDistance = getCumulativeSquaredDistance(
-        coordinates,
-        startIndex,
-        endIndex + count,
-      );
-      if (forwardDistance < reverseDistance) {
-        newEndIndex += count;
-      }
-    }
-  }
-
-  sharedUpdateInfo.index = newTargetIndex;
-  sharedUpdateInfo.endIndex = newEndIndex;
-  return sharedUpdateInfo;
-}
-
-/**
- * @param {import("../coordinate.js").Coordinate} coordinate The clicked coordinate.
- * @param {Array<import("../coordinate.js").Coordinate>} coordinates The geometry component coordinates.
- * @param {boolean} ring The coordinates represent a linear ring.
- * @param {Array<TraceTarget>} targets The trace targets.
- */
-function appendTraceTarget(coordinate, coordinates, ring, targets) {
-  const x = coordinate[0];
-  const y = coordinate[1];
-  for (let i = 0, ii = coordinates.length - 1; i < ii; ++i) {
-    const start = coordinates[i];
-    const end = coordinates[i + 1];
-    const rel = getPointSegmentRelationship(x, y, start, end);
-    if (rel.squaredDistance === 0) {
-      const index = i + rel.along;
-      targets.push({
-        coordinates: coordinates,
-        ring: ring,
-        startIndex: index,
-        endIndex: index,
-      });
-      return;
-    }
-  }
-}
-
-/**
- * @typedef {Object} PointSegmentRelationship
- * @property {number} along The closest point expressed as a fraction along the segment length.
- * @property {number} squaredDistance The squared distance of the point to the segment.
- */
-
-/**
- * @type {PointSegmentRelationship}
- */
-const sharedRel = {along: 0, squaredDistance: 0};
-
-/**
- * @param {number} x The point x.
- * @param {number} y The point y.
- * @param {import("../coordinate.js").Coordinate} start The segment start.
- * @param {import("../coordinate.js").Coordinate} end The segment end.
- * @return {PointSegmentRelationship} The point segment relationship.  The returned object is
- * shared between calls and must not be modified by the caller.
- */
-function getPointSegmentRelationship(x, y, start, end) {
-  const x1 = start[0];
-  const y1 = start[1];
-  const x2 = end[0];
-  const y2 = end[1];
-  const dx = x2 - x1;
-  const dy = y2 - y1;
-  let along = 0;
-  let px = x1;
-  let py = y1;
-  if (dx !== 0 || dy !== 0) {
-    along = clamp(((x - x1) * dx + (y - y1) * dy) / (dx * dx + dy * dy), 0, 1);
-    px += dx * along;
-    py += dy * along;
-  }
-
-  sharedRel.along = along;
-  sharedRel.squaredDistance = toFixed(squaredDistance(x, y, px, py), 10);
-  return sharedRel;
-}
-
-/**
- * @param {LineCoordType} coordinates The coordinates.
- * @param {number} index The index.  May be fractional and may wrap.
- * @return {import("../coordinate.js").Coordinate} The interpolated coordinate.
- */
-function interpolateCoordinate(coordinates, index) {
-  const count = coordinates.length;
-
-  let startIndex = Math.floor(index);
-  const along = index - startIndex;
-  if (startIndex >= count) {
-    startIndex -= count;
-  } else if (startIndex < 0) {
-    startIndex += count;
-  }
-
-  let endIndex = startIndex + 1;
-  if (endIndex >= count) {
-    endIndex -= count;
-  }
-
-  const start = coordinates[startIndex];
-  const x0 = start[0];
-  const y0 = start[1];
-  const end = coordinates[endIndex];
-  const dx = end[0] - x0;
-  const dy = end[1] - y0;
-
-  return [x0 + dx * along, y0 + dy * along];
-}
-
 /***
  * @template Return
  * @typedef {import("../Observable").OnSignature<import("../Observable").EventTypes, import("../events/Event.js").default, Return> &
@@ -1136,7 +760,7 @@ class Draw extends PointerInteraction {
     if (targets.length) {
       this.traceState_ = {
         active: true,
-        startPx: event.pixel.slice(),
+        startCoord: event.coordinate.slice(),
         targets: targets,
         targetIndex: -1,
       };
@@ -1261,7 +885,8 @@ class Draw extends PointerInteraction {
 
     if (traceState.targetIndex === -1) {
       // check if we are ready to pick a target
-      if (distance(traceState.startPx, event.pixel) < this.snapTolerance_) {
+      const startPx = event.map.getPixelFromCoordinate(traceState.startCoord);
+      if (distance(startPx, event.pixel) < this.snapTolerance_) {
         return;
       }
     }