@wemap/geo 11.0.0-alpha.16 → 11.0.0-alpha.2

package/dist/index.js

@@ -1,15 +1,11 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const maths = require("@wemap/maths");
-const Logger = require("@wemap/logger");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
+import { wrap, deg2rad, rad2deg, Quaternion, Vector3, positiveMod, Rotations, diffAngleLines } from "@wemap/maths";
+import Logger from "@wemap/logger";
 const R_MAJOR = 6378137;
 const R_MINOR = 63567523142e-4;
 const EARTH_GRAVITY = 9.80665;
@@ -331,7 +327,7 @@ class Coordinates {
   }
   wrap() {
     if (this._lng <= -180 || this._lng > 180) {
-      this._lng = maths.wrap(this._lng, -180, 180);
+      this._lng = wrap(this._lng, -180, 180);
     }
   }
   static equals(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
@@ -355,8 +351,8 @@ class Coordinates {
     const dR = distance / R_MAJOR;
     const cosDr = Math.cos(dR);
     const sinDr = Math.sin(dR);
-    const phi1 = maths.deg2rad(this.lat);
-    const lambda1 = maths.deg2rad(this.lng);
+    const phi1 = deg2rad(this.lat);
+    const lambda1 = deg2rad(this.lng);
     const phi2 = Math.asin(
       Math.sin(phi1) * cosDr + Math.cos(phi1) * sinDr * Math.cos(bearing)
     );
@@ -364,8 +360,8 @@ class Coordinates {
       Math.sin(bearing) * sinDr * Math.cos(phi1),
       cosDr - Math.sin(phi1) * Math.sin(phi2)
     );
-    this.lat = maths.rad2deg(phi2);
-    this.lng = maths.rad2deg(lambda2);
+    this.lat = rad2deg(phi2);
+    this.lng = rad2deg(lambda2);
     if (elevation !== null) {
       if (this.alt === null) {
         throw new Error("Point altitude is not defined");
@@ -379,13 +375,13 @@ class Coordinates {
     const lng1 = this.lng;
     const lat2 = location2.lat;
     const lng2 = location2.lng;
-    const dlat = maths.deg2rad(lat2 - lat1);
-    const dlng = maths.deg2rad(lng2 - lng1);
+    const dlat = deg2rad(lat2 - lat1);
+    const dlng = deg2rad(lng2 - lng1);
     const dlngsin = Math.sin(dlng / 2);
     const dlatsin = Math.sin(dlat / 2);
-    const lat1rad = maths.deg2rad(lat1);
+    const lat1rad = deg2rad(lat1);
     const lat1cos = Math.cos(lat1rad);
-    const lat2rad = maths.deg2rad(lat2);
+    const lat2rad = deg2rad(lat2);
     const lat2cos = Math.cos(lat2rad);
     const angle = dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin;
     const tangy = Math.sqrt(angle);
@@ -397,9 +393,9 @@ class Coordinates {
     return point1.distanceTo(point2);
   }
   bearingTo(location2) {
-    const lat1 = maths.deg2rad(this.lat);
-    const lat2 = maths.deg2rad(location2.lat);
-    const diffLng = maths.deg2rad(location2.lng - this.lng);
+    const lat1 = deg2rad(this.lat);
+    const lat2 = deg2rad(location2.lat);
+    const diffLng = deg2rad(location2.lng - this.lng);
     return Math.atan2(
       Math.sin(diffLng) * Math.cos(lat2),
       Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(diffLng)
@@ -409,19 +405,19 @@ class Coordinates {
     return point1.bearingTo(point2);
   }
   get enuToEcefRotation() {
-    const rot1 = maths.Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + maths.deg2rad(this.lng));
-    const rot2 = maths.Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - maths.deg2rad(this.lat));
-    return maths.Quaternion.multiply(rot1, rot2);
+    const rot1 = Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + deg2rad(this.lng));
+    const rot2 = Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - deg2rad(this.lat));
+    return Quaternion.multiply(rot1, rot2);
   }
   get ecefToEnuRotation() {
-    const rot1 = maths.Quaternion.fromAxisAngle([1, 0, 0], maths.deg2rad(this.lat) - Math.PI / 2);
-    const rot2 = maths.Quaternion.fromAxisAngle([0, 0, 1], -maths.deg2rad(this.lng) - Math.PI / 2);
-    return maths.Quaternion.multiply(rot1, rot2);
+    const rot1 = Quaternion.fromAxisAngle([1, 0, 0], deg2rad(this.lat) - Math.PI / 2);
+    const rot2 = Quaternion.fromAxisAngle([0, 0, 1], -deg2rad(this.lng) - Math.PI / 2);
+    return Quaternion.multiply(rot1, rot2);
   }
   get ecef() {
     if (!this._ecef) {
-      const lat = maths.deg2rad(this.lat);
-      const lng = maths.deg2rad(this.lng);
+      const lat = deg2rad(this.lat);
+      const lng = deg2rad(this.lng);
       const alt = this.alt || 0;
       const x = (R_MAJOR + alt) * Math.cos(lat) * Math.cos(lng);
       const y = (R_MAJOR + alt) * Math.cos(lat) * Math.sin(lng);
@@ -439,21 +435,21 @@ class Coordinates {
     const lat = Math.atan2(z, p);
     const alt = p / Math.cos(lat) - R_MAJOR;
     lng = lng % (2 * Math.PI);
-    const newPoint = new Coordinates(maths.rad2deg(lat), maths.rad2deg(lng), alt);
+    const newPoint = new Coordinates(rad2deg(lat), rad2deg(lng), alt);
     newPoint._ecef = ecef;
     return newPoint;
   }
   getSegmentProjection(p1, p2) {
-    const a = maths.Vector3.normalize(p1.ecef);
-    const b = maths.Vector3.normalize(p2.ecef);
-    const c = maths.Vector3.normalize(this.ecef);
-    const G = maths.Vector3.cross(a, b);
-    if (maths.Vector3.norm(G) === 0) {
+    const a = Vector3.normalize(p1.ecef);
+    const b = Vector3.normalize(p2.ecef);
+    const c = Vector3.normalize(this.ecef);
+    const G = Vector3.cross(a, b);
+    if (Vector3.norm(G) === 0) {
       return null;
     }
-    const F = maths.Vector3.cross(c, G);
-    const t = maths.Vector3.normalize(maths.Vector3.cross(G, F));
-    const posECEF = maths.Vector3.multiplyScalar(t, R_MAJOR);
+    const F = Vector3.cross(c, G);
+    const t = Vector3.normalize(Vector3.cross(G, F));
+    const posECEF = Vector3.multiplyScalar(t, R_MAJOR);
     const poseCoordinates = Coordinates.fromECEF(posECEF);
     let alt;
     if (p1.alt !== null && p2.alt !== null) {
@@ -688,14 +684,14 @@ function trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
   }
   return newRoute;
 }
-function simplifyRoute(coords, precisionAngle = maths.deg2rad(5)) {
+function simplifyRoute(coords, precisionAngle = deg2rad(5)) {
   const isClosed = coords[0].equals(coords[coords.length - 1]);
   let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
   const len = newRoute.length;
   for (let i = isClosed ? 0 : 1; i < len; i++) {
-    const p0 = coords[maths.positiveMod(i - 1, len)];
+    const p0 = coords[positiveMod(i - 1, len)];
     const p1 = coords[i];
-    const p2 = coords[maths.positiveMod(i + 1, len)];
+    const p2 = coords[positiveMod(i + 1, len)];
     const seg1Dir = p0.bearingTo(p1);
     const seg2Dir = p1.bearingTo(p2);
     if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
@@ -715,7 +711,7 @@ function geolocationPositionToUserPosition(geolocationPosition) {
   const userPosition = new UserPosition(latitude, longitude);
   userPosition.time = geolocationPosition.timestamp;
   userPosition.accuracy = accuracy;
-  userPosition.bearing = heading ? maths.deg2rad(heading) : null;
+  userPosition.bearing = heading ? deg2rad(heading) : null;
   return userPosition;
 }
 function calcDistance(coords) {
@@ -904,19 +900,19 @@ class GeoRef {
     this.origin = origin;
   }
   localToWorld(localPosition) {
-    const enuTranslationScaled = maths.Vector3.multiplyScalar(localPosition, this.scale);
-    const rotationOffset = maths.Quaternion.fromAxisAngle([0, 0, 1], this.heading);
-    const enuToEcefRotationOrigin = maths.Quaternion.multiply(rotationOffset, this.origin.enuToEcefRotation);
-    const ecefTranslation = maths.Quaternion.rotate(enuToEcefRotationOrigin, enuTranslationScaled);
-    const ecef = maths.Vector3.sum(this.origin.ecef, ecefTranslation);
+    const enuTranslationScaled = Vector3.multiplyScalar(localPosition, this.scale);
+    const rotationOffset = Quaternion.fromAxisAngle([0, 0, 1], this.heading);
+    const enuToEcefRotationOrigin = Quaternion.multiply(rotationOffset, this.origin.enuToEcefRotation);
+    const ecefTranslation = Quaternion.rotate(enuToEcefRotationOrigin, enuTranslationScaled);
+    const ecef = Vector3.sum(this.origin.ecef, ecefTranslation);
     return Coordinates.fromECEF(ecef);
   }
   worldToLocal(coords) {
-    const rotationOffset = maths.Quaternion.fromAxisAngle([0, 0, 1], -this.heading);
-    const ecefToEnuRotationOrigin = maths.Quaternion.multiply(this.origin.ecefToEnuRotation, rotationOffset);
-    const ecefTranslation = maths.Vector3.subtract(coords.ecef, this.origin.ecef);
-    const ecefTranslationScaled = maths.Vector3.multiplyScalar(ecefTranslation, 1 / this.scale);
-    return maths.Quaternion.rotate(ecefToEnuRotationOrigin, ecefTranslationScaled);
+    const rotationOffset = Quaternion.fromAxisAngle([0, 0, 1], -this.heading);
+    const ecefToEnuRotationOrigin = Quaternion.multiply(this.origin.ecefToEnuRotation, rotationOffset);
+    const ecefTranslation = Vector3.subtract(coords.ecef, this.origin.ecef);
+    const ecefTranslationScaled = Vector3.multiplyScalar(ecefTranslation, 1 / this.scale);
+    return Quaternion.rotate(ecefToEnuRotationOrigin, ecefTranslationScaled);
   }
   toJson() {
     return {
@@ -950,7 +946,7 @@ class Attitude {
     return this._quaternion;
   }
   set quaternion(quaternion) {
-    if (Math.abs(1 - maths.Quaternion.norm(quaternion)) > 1e-4) {
+    if (Math.abs(1 - Quaternion.norm(quaternion)) > 1e-4) {
       throw new Error("quaternion is not a unit quaternion");
     }
     this._quaternion = quaternion;
@@ -974,25 +970,25 @@ class Attitude {
   }
   get eulerAngles() {
     if (this._eulerAngles === null) {
-      this._eulerAngles = maths.Rotations.quaternionToEulerZXY(this.quaternion);
+      this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion);
     }
     return this._eulerAngles;
   }
   get eulerAnglesDegrees() {
-    return this.eulerAngles.map((x) => maths.rad2deg(x));
+    return this.eulerAngles.map((x) => rad2deg(x));
   }
   get heading() {
     if (this._heading === null) {
       let offset = 0;
       if (typeof window !== "undefined" && window && window.orientation) {
-        offset = maths.deg2rad(window.orientation);
+        offset = deg2rad(window.orientation);
       }
-      this._heading = maths.Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
+      this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
     }
     return this._heading;
   }
   get headingDegrees() {
-    return maths.rad2deg(this.heading);
+    return rad2deg(this.heading);
   }
   static equals(att1, att2) {
     if (att1 === null && att1 === att2) {
@@ -1004,7 +1000,7 @@ class Attitude {
     if (att1 === att2) {
       return true;
     }
-    return maths.Quaternion.equals(att1.quaternion, att2.quaternion);
+    return Quaternion.equals(att1.quaternion, att2.quaternion);
   }
   equals(other) {
     return Attitude.equals(this, other);
@@ -1029,8 +1025,8 @@ class Attitude {
     return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
   }
   static diff(attitudeStart, attitudeEnd) {
-    const quaternionDiff = maths.Quaternion.multiply(
-      maths.Quaternion.inverse(attitudeStart.quaternion),
+    const quaternionDiff = Quaternion.multiply(
+      Quaternion.inverse(attitudeStart.quaternion),
       attitudeEnd.quaternion
     );
     let timeDiff = null;
@@ -1064,7 +1060,7 @@ class AbsoluteHeading {
   }
   toAttitude() {
     return new Attitude(
-      maths.Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
+      Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
       this.time,
       this.accuracy
     );
@@ -1394,12 +1390,7 @@ Nodes
       network.nodes.push(newNode);
       return newNode;
     };
-    const createEdgeFromNodes = (node1, node2) => new GraphEdge(
-      node1,
-      node2,
-      Level.union(node1.coords.level, node2.coords.level),
-      null
-    );
+    const createEdgeFromNodes = (node1, node2) => new GraphEdge(node1, node2, Level.union(node1.coords.level, node2.coords.level), null);
     for (const segment of segments) {
       let previousNode = null;
       for (const coords of segment) {
@@ -1466,7 +1457,7 @@ const _MapMatching = class {
     }
     if (useBearing) {
       if (checkEdge) {
-        const diffAngle = maths.diffAngleLines(edge.bearing, location.bearing);
+        const diffAngle = diffAngleLines(edge.bearing, location.bearing);
         if (diffAngle > this._maxAngleBearing) {
           checkEdge = false;
         }
@@ -1596,7 +1587,7 @@ class GraphItinerary {
       const prevNode = arr[idx - 1];
       const edge = getEdgeByNodes(prevNode.edges, prevNode, node);
       if (!edge) {
-        Logger__default.default.error("Cannot retrieve edge to create itinerary");
+        Logger.error("Cannot retrieve edge to create itinerary");
         return;
       }
       const newEdge = new GraphEdge(
@@ -1728,7 +1719,7 @@ class GraphRouter {
   createNodeInsideEdge(edge, point) {
     const a = edge.node1;
     const b = edge.node2;
-    const m = new GraphNode(point, null);
+    const m = new GraphNode(point, edge.builtFrom);
     m.coords.level = edge.level;
     const u = edge.clone();
     u.node1 = a;
@@ -1824,25 +1815,27 @@ class GraphRouter {
     return GraphItinerary.fromNetworkNodes(start.coords, end.coords, path, edgesWeights);
   }
 }
-exports.AbsoluteHeading = AbsoluteHeading;
-exports.Attitude = Attitude;
-exports.BoundingBox = BoundingBox;
-exports.Constants = Constants;
-exports.Coordinates = Coordinates;
-exports.GeoRef = GeoRef;
-exports.GeoRelativePosition = GeoRelativePosition;
-exports.GraphEdge = GraphEdge;
-exports.GraphItinerary = GraphItinerary;
-exports.GraphNode = GraphNode;
-exports.GraphProjection = GraphProjection;
-exports.GraphRouter = GraphRouter;
-exports.GraphRouterOptions = GraphRouterOptions;
-exports.GraphUtils = GraphUtils;
-exports.Level = Level;
-exports.MapMatching = MapMatching;
-exports.Network = Network;
-exports.NoRouteFoundError = NoRouteFoundError;
-exports.RelativePosition = RelativePosition;
-exports.UserPosition = UserPosition;
-exports.Utils = Utils;
+export {
+  AbsoluteHeading,
+  Attitude,
+  BoundingBox,
+  Constants,
+  Coordinates,
+  GeoRef,
+  GeoRelativePosition,
+  GraphEdge,
+  GraphItinerary,
+  GraphNode,
+  GraphProjection,
+  GraphRouter,
+  GraphRouterOptions,
+  GraphUtils,
+  Level,
+  MapMatching,
+  Network,
+  NoRouteFoundError,
+  RelativePosition,
+  UserPosition,
+  Utils
+};
 //# sourceMappingURL=index.js.map