@wemap/geo 10.1.0 → 10.3.0

package/index.d.ts

@@ -1,6 +1,10 @@
 import { Quaternion_t, Vector3_t } from '@wemap/maths';
 declare module '@wemap/geo' {
 
+    /*************
+     * Coordinates
+     *************/
+
     export type Level_t = null | number | [number, number];
 
     export class Level {
@@ -64,29 +68,6 @@ declare module '@wemap/geo' {
         static fromCompressedJson(json: CoordinatesCompressedJson): Coordinates;
     }
 
-    export type AttitudeJson = Quaternion_t
-        | { q: Quaternion_t, time?: number, accuracy?: number };
-
-    export class Attitude {
-        constructor(quaternion: Quaternion_t, time?: number, accuracy?: number);
-        get quaternion(): Quaternion_t;
-        set quaternion(quaternion: Quaternion_t);
-        get time(): number;
-        set time(time: number);
-        get accuracy(): number;
-        set accuracy(accuracy: number);
-        get eulerAngles(): [number, number, number];
-        get eulerAnglesDegrees(): [number, number, number];
-        get heading(): number;
-        get headingDegrees(): number;
-        equals(other: Attitude): boolean;
-        toJson(): AttitudeJson;
-        clone(): Attitude;
-        static unitary(): Attitude;
-        static equals(attitude1: Attitude, attitude2: Attitude): boolean;
-        static fromJson(json: AttitudeJson): Attitude;
-        static diff(attitudeStart: Attitude, attitudeEnd: Attitude): Attitude;
-    }
 
     export class GeoRef {
         origin: Coordinates;
@@ -96,6 +77,7 @@ declare module '@wemap/geo' {
         localToWorld(localPosition: [number, number, number]): Coordinates;
         worldToLocal(coords: Coordinates): [number, number, number];
         toJson(): object;
+
         static fromJson(json: object): GeoRef;
     }
 
@@ -107,22 +89,22 @@ declare module '@wemap/geo' {
 
     export class UserPosition extends Coordinates {
 
-        constructor(lat: number, lng: number, alt?: number, level?: Level_t,
-            time?: number, accuracy?: number, bearing?: number);
+        constructor(lat: number, lng: number, alt?: number | null, level?: Level_t,
+            time?: number | null, accuracy?: number | null, bearing?: number | null);
 
-        get time(): number;
-        set time(time: number);
-        get accuracy(): number;
-        set accuracy(accuracy: number);
-        get bearing(): number;
-        set bearing(bearing: number);
+        get time(): number | null;
+        set time(time: number | null);
+        get accuracy(): number | null;
+        set accuracy(accuracy: number | null);
+        get bearing(): number | null;
+        set bearing(bearing: number | null);
 
         fromCoordinates(coords: Coordinates): UserPosition;
         clone(): UserPosition;
-        static equals(pos1: Coordinates, pos2: Coordinates, eps?: number, epsAlt?: number): boolean;
         equals(other: Coordinates, eps?: number, epsAlt?: number): boolean;
-
         toJson(): UserPositionJson;
+
+        static equals(pos1: Coordinates, pos2: Coordinates, eps?: number, epsAlt?: number): boolean;
         static fromJson(json: UserPositionJson): UserPosition;
     }
 
@@ -136,4 +118,273 @@ declare module '@wemap/geo' {
         position: UserPosition,
     };
 
+    export class RelativePosition {
+        constructor(x: number, y: number, z: number,
+            time?: number | null, accuracy?: number | null, bearing?: number | null);
+
+        get x(): number;
+        set x(x: number);
+        get y(): number;
+        set y(y: number);
+        get z(): number;
+        set z(z: number);
+        get time(): number | null;
+        set time(time: number | null);
+        get accuracy(): number | null;
+        set accuracy(accuracy: number | null);
+        get bearing(): number | null;
+        set bearing(bearing: number | null);
+
+        clone(): RelativePosition;
+        equals(other: RelativePosition, eps?: number): boolean;
+        toJson(): object;
+
+        static equals(pos1: RelativePosition, pos2: RelativePosition, eps?: number): boolean;
+        static fromJson(json: object): RelativePosition;
+    }
+
+    export class GeoRelativePosition extends RelativePosition { }
+
+    export class BoundingBox {
+        northEast: Coordinates;
+        southWest: Coordinates;
+
+        constructor(northEast: Coordinates, southWest: Coordinates);
+
+        get center(): Coordinates;
+        getSouthWest(): Coordinates;
+        getNorthEast(): Coordinates;
+        getNorthWest(): Coordinates;
+        getSouthEast(): Coordinates;
+        getWest(): number;
+        getSouth(): number;
+        getEast(): number;
+        getNorth(): number;
+
+        contains(point: Coordinates): boolean;
+        extend(obj: Coordinates | BoundingBox): BoundingBox;
+        extendsWithMeasure(measure: number): BoundingBox;
+        pad(bufferRatio: number): BoundingBox;
+        equals(other: BoundingBox): boolean;
+        toArray(): [number, number, number, number];
+
+        static equals(bb1: BoundingBox, bb2: BoundingBox): boolean;
+        static fromArray(wsenBounds: [number, number, number, number]): BoundingBox;
+    }
+
+    /*********
+     * Graph
+     *********/
+
+    export class GraphNode<T> {
+        edges: GraphEdge<T>[];
+        builtFrom: T | null;
+        io: boolean;
+
+        constructor(coords: Coordinates, builtFrom: T | null);
+
+        get coords(): Coordinates;
+        set coords(coords: Coordinates);
+
+        distanceTo(other: GraphNode<T>): number;
+        bearingTo(other: GraphNode<T>): number;
+        equals(other: GraphNode<T>): boolean;
+        clone(): GraphNode<T>;
+        toJson(): object;
+
+        static fromJson<T>(json: object): GraphNode<T>;
+        static generateNodesLevels<T>(nodes: GraphNode<T>[]): void;
+    }
+
+    export class GraphEdge<T> {
+        builtFrom: T | null;
+        isOneway: boolean;
+
+        constructor(node1: GraphNode<T>, node2: GraphNode<T>, level?: Level_t | null, builtFrom?: T | null);
+
+        get node1(): GraphNode<T>;
+        set node1(node: GraphNode<T>);
+        get node2(): GraphNode<T>;
+        set node2(node: GraphNode<T>);
+        get level(): Level_t;
+        set level(level: Level_t);
+        get bearing(): number;
+        get length(): number;
+
+        equals(other: GraphEdge<T>): boolean;
+        clone(): GraphEdge<T>;
+    }
+
+    export class GraphProjection<T> {
+        origin: Coordinates;
+        distanceFromNearestElement: number;
+        projection: Coordinates;
+        nearestElement: GraphNode<T> | GraphEdge<T>;
+    }
+
+    export class Network<T> {
+
+        nodes: GraphNode<T>[];
+        edges: GraphEdge<T>[];
+
+        constructor(nodes: GraphNode<T>[], edges: GraphEdge<T>[]);
+
+        getNodeByCoords(coords: Coordinates): GraphNode<T> | undefined;
+        getEdgeByNodes(node1: GraphNode<T>, node2: GraphNode<T>): GraphEdge<T> | undefined;
+        getBoundingBox(extendedMeasure: number | undefined): BoundingBox;
+        getEdgesAtLevel(targetLevel: Level, useMultiLevelEdges: boolean): GraphEdge<T>;
+        toDetailedString(
+            _nodeToStringFn: (node: GraphNode<T>) => string,
+            _edgeToStringFn: (node: GraphEdge<T>) => string
+        ): string;
+        toCompressedJson(): object;
+
+        static fromCompressedJson<T>(json: object): Network<T>;
+        static fromCoordinates<T>(segments: Coordinates[][]): Network<T>;
+    }
+
+    export function getEdgeByNodes<T>(
+        edges: GraphEdge<T>[], node1: GraphNode<T>, node2: GraphNode<T>
+    ): GraphNode<T> | undefined;
+
+    export class MapMatching<T> {
+        constructor(network?: Network<T>);
+
+        set maxAngleBearing(maxAngleBearing: number);
+        get maxAngleBearing(): number;
+        set maxDistance(maxDistance: number);
+        get maxDistance(): number;
+        set network(network: Network<T> | null);
+        get network(): Network<T>;
+
+        getProjection(
+            location: Coordinates,
+            useDistance?: boolean,
+            useBearing?: boolean,
+            useMultiLevelSegments?: boolean,
+            acceptEdgeFn?: (edge: GraphEdge<T>) => boolean
+        ): GraphProjection<T> | null;
+    }
+
+    /*************
+     * Rotations
+     *************/
+
+
+    export type AttitudeJson = Quaternion_t
+        | { q: Quaternion_t, time?: number, accuracy?: number };
+
+    export class Attitude {
+
+        constructor(quaternion: Quaternion_t, time?: number, accuracy?: number);
+
+        get quaternion(): Quaternion_t;
+        set quaternion(quaternion: Quaternion_t);
+        get time(): number;
+        set time(time: number);
+        get accuracy(): number;
+        set accuracy(accuracy: number);
+        get eulerAngles(): [number, number, number];
+        get eulerAnglesDegrees(): [number, number, number];
+        get heading(): number;
+        get headingDegrees(): number;
+
+        equals(other: Attitude): boolean;
+        toJson(): AttitudeJson;
+        clone(): Attitude;
+
+        static unitary(): Attitude;
+        static equals(attitude1: Attitude, attitude2: Attitude): boolean;
+        static fromJson(json: AttitudeJson): Attitude;
+        static diff(attitudeStart: Attitude, attitudeEnd: Attitude): Attitude;
+    }
+
+    export class AbsoluteHeading {
+        constructor(heading: number, time?: number | null, accuracy?: number | null);
+
+        get heading(): number;
+        set heading(heading: number);
+        get time(): number | null;
+        set time(heading: number | null);
+        get accuracy(): number | null;
+        set accuracy(heading: number | null);
+
+        toAttitude(): Attitude;
+        equals(other: AbsoluteHeading | null): boolean;
+        toJson(): object;
+        clone(): AbsoluteHeading;
+
+        static equals(heading1: AbsoluteHeading | null, heading2: AbsoluteHeading | null): boolean;
+        static fromJson(json: object): AbsoluteHeading;
+    }
+
+    /***********
+     * Router
+     ***********/
+
+    export class GraphItinerary<T> {
+        start: Coordinates;
+        end: Coordinates;
+        nodes: GraphNode<T>[];
+        edges: GraphEdge<T>[];
+        edgesWeights: number[];
+
+        static fromNetworkNodes<T>(
+            networkNodes: GraphNode<T>[],
+            edgesWeight: number[]
+        ): GraphItinerary<T>;
+    }
+
+    export class GraphRouter<T> {
+        constructor(network: Network<T>);
+        getShortestPath(
+            start: GraphNode<T> | Coordinates,
+            end: GraphNode<T> | Coordinates,
+            options?: GraphRouterOptions<T>
+        ): GraphItinerary<T>;
+    }
+
+    export class GraphRouterOptions<T> {
+        projectionMaxDistance: number;
+        weightEdgeFn: (edge: GraphEdge<T>) => number;
+        acceptEdgeFn: (edge: GraphEdge<T>) => boolean;
+    }
+
+    export class NoRouteFoundError<T> {
+        constructor(
+            start: GraphNode<T> | Coordinates,
+            end: GraphNode<T> | Coordinates,
+            details?: string
+        );
+        get startStr(): string;
+        get endStr(): string;
+        get message(): string;
+    }
+
+
+    /***********
+     *  Utils
+     ***********/
+
+    export function sampleRoute(
+        route: Coordinates[],
+        stepSize?: number,
+        startSampling?: number,
+        length?: number
+    ): Coordinates[];
+
+    export function trimRoute(
+        route: Coordinates[],
+        startPosition?: Coordinates,
+        length?: number
+    ): Coordinates[];
+
+    export function simplifyRoute(
+        coords: Coordinates[],
+        precisionAngle?: number
+    ): Coordinates;
+
+    export function geolocationPositionToUserPosition(
+        geolocationPosition: GeolocationPosition | null
+    ): UserPosition | null;
 }

package/package.json

@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "10.1.0",
+    "version": "10.3.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -29,7 +29,7 @@
     "license": "ISC",
     "dependencies": {
         "@wemap/logger": "^10.0.0",
-        "@wemap/maths": "^10.0.0"
+        "@wemap/maths": "^10.3.0"
     },
-    "gitHead": "881fa193f9c7bd2ea6a202bb207ca97cc0bac2dd"
+    "gitHead": "2435b4a1c0218f56a87ff1768e197f8cb738aa4d"
 }

package/src/graph/GraphProjection.js

@@ -1,6 +1,6 @@
 import Coordinates from '../coordinates/Coordinates.js';
-import Edge from './GraphEdge.js';
-import Node from './GraphNode.js';
+import GraphEdge from './GraphEdge.js';
+import GraphNode from './GraphNode.js';
 
 class GraphProjection {
 
@@ -13,7 +13,7 @@ class GraphProjection {
     /** @type {Coordinates} */
     projection;
 
-    /** @type {Node|Edge} */
+    /** @type {GraphNode|GraphEdge} */
     nearestElement;
 
 }

package/src/graph/Network.js

@@ -195,9 +195,9 @@ class Network {
 
     /**
      * Create edges From MultiLevel Itinerary for a given level
-     * @param {Level} targetLevel level for selection.
+     * @param {null|number|[number, number]} targetLevel level for selection.
      * @param {Boolean} useMultiLevelEdges use segments which intersect both levels (stairs, elevators...)
-     * @returns {GraphEdge[]} Ordered edges
+     * @returns {GraphEdge<T>[]} Ordered edges
      */
     getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
         return this.edges.filter(

package/src/router/GraphRouterOptions.js

@@ -8,7 +8,7 @@ class GraphRouterOptions {
     /** @type {number} in meters */
     projectionMaxDistance = 50;
 
-    /** @type {function(GraphEdge<T>):boolean} */
+    /** @type {function(GraphEdge<T>):number} */
     weightEdgeFn = edge => edge.length;
 
     /** @type {function(GraphEdge<T>):boolean} */

package/src/router/NoRouteFoundError.js

@@ -1,4 +1,4 @@
-import Node from '../graph/GraphNode.js';
+import GraphNode from '../graph/GraphNode.js';
 
 class NoRouteFoundError extends Error {
 
@@ -10,8 +10,8 @@ class NoRouteFoundError extends Error {
     }
 
     get startStr() {
-        if (this.start instanceof Node) {
-            return `Node ${this.start.coords.toString()}`;
+        if (this.start instanceof GraphNode) {
+            return `GraphNode ${this.start.coords.toString()}`;
         }
 
         // if (this.start instanceof Coordinates) {
@@ -19,8 +19,8 @@ class NoRouteFoundError extends Error {
     }
 
     get endStr() {
-        if (this.end instanceof Node) {
-            return `Node ${this.end.coords.toString()}`;
+        if (this.end instanceof GraphNode) {
+            return `GraphNode ${this.end.coords.toString()}`;
         }
 
         // if (this.end instanceof Coordinates) {