@wemap/geo 12.10.4 → 12.10.8-alpha.0

package/package.json

@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "12.10.4",
+    "version": "12.10.8-alpha.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -40,6 +40,10 @@
         "@types/geojson": "^7946.0.14",
         "jsdom-global": "^3.0.2"
     },
+    "files": [
+        "dist",
+        "index.ts"
+    ],
     "exports": {
         ".": {
             "types": "./index.ts",
@@ -48,5 +52,5 @@
         },
         "./tests/*": "./tests/*"
     },
-    "gitHead": "3bbef0e77b4af2df051ec488c8707827a2df43f4"
+    "gitHead": "fcf82e31b4b60a8fb006488b337a800f79304722"
 }

package/src/Constants.ts

@@ -1,26 +0,0 @@
-export const R_MAJOR = 6378137.0;
-export const R_MINOR = 6356752.3142;
-export const EARTH_GRAVITY = 9.80665;
-
-/**
- * latitude and longitude epsilon in degrees
- * 1e-8° correspond to ~1mm at latitude = 0
- */
-export const EPS_DEG_MM = 1e-8;
-
-/**
- * epsilon in meters which corresponds to 1 millimeter
- */
-export const EPS_MM = 1e-3;
-
-
-export const ELLIPSOID_FLATNESS = (R_MAJOR - R_MINOR) / R_MAJOR;
-
-export const ECCENTRICITY = Math.sqrt(ELLIPSOID_FLATNESS * (2 - ELLIPSOID_FLATNESS));
-export const ECCENTRICITY_2 = ECCENTRICITY * ECCENTRICITY;
-
-export const R_MAJOR_2 = R_MAJOR * R_MAJOR;
-export const R_MAJOR_4 = R_MAJOR_2 * R_MAJOR_2;
-export const R_MINOR_2 = R_MINOR * R_MINOR;
-export const R_MINOR_4 = R_MINOR_2 * R_MINOR_2;
-export const CIRCUMFERENCE = R_MAJOR * 2 * Math.PI;

package/src/Utils.spec.ts

@@ -1,183 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-
-import { sampleRoute, simplifyRoute, trimRoute } from './Utils.js';
-import Coordinates from './coordinates/Coordinates.js';
-
-const expect = chai.expect;
-
-describe('Geo Utils', () => {
-
-    it('sampleRoute', () => {
-
-        chai.use(chaiAlmost(1e-3));
-
-        let samples;
-
-        const p1 = new Coordinates(45.0, 5.0);
-        const p2 = p1.destinationPoint(100, Math.PI / 4);
-        const p3 = p2.destinationPoint(49.9, Math.PI / 2);
-        const route = [p1, p2, p3];
-
-        samples = sampleRoute(route);
-        expect(samples.length).equals(Math.ceil(149.9 / 0.7));
-        for (let i = 0; i < samples.length - 1; i++) {
-            // Ignore the crow flies for the turn
-            if (i === Math.floor(100 / 0.7)) {
-                i++;
-            }
-            expect(samples[i].distanceTo(samples[i + 1])).to.almost.equal(0.7);
-        }
-
-        samples = sampleRoute(route, 10);
-        expect(samples.length).equals(15);
-        for (let i = 0; i < samples.length - 1; i++) {
-            expect(samples[i].distanceTo(samples[i + 1])).to.almost.equal(i === 14 ? 9.9 : 10);
-        }
-
-        samples = sampleRoute(route, 10, 0, 99.9);
-        expect(samples.length).equals(10);
-
-        samples = sampleRoute(route, 10, 50, 12);
-        expect(samples.length).equals(2);
-
-        samples = sampleRoute(route, 10, 50, 100);
-        expect(samples.length).equals(10);
-
-        samples = sampleRoute(route, 10, 110, 12);
-        expect(samples.length).equals(2);
-
-    });
-
-    it('trimRoute', () => {
-
-        chai.use(chaiAlmost(1e-3));
-
-        let newRoute;
-
-        const p1 = new Coordinates(45.0, 5.0);
-        const p2 = p1.destinationPoint(100, Math.PI / 4);
-        const p3 = p2.destinationPoint(49.9, Math.PI / 2);
-        const route = [p1, p2, p3];
-
-        expect(() => trimRoute(route, new Coordinates(0, 0))).throw(Error);
-        expect(() => trimRoute([p1], p1)).throw(Error);
-
-        newRoute = trimRoute(route);
-        expect(newRoute.length).equals(3);
-        for (let i = 0; i < newRoute.length - 1; i++) {
-            expect(newRoute[i].equals(route[i])).true;
-        }
-
-        newRoute = trimRoute(route, p1, 100);
-        expect(newRoute.length).equals(2);
-        expect(newRoute[0].equals(p1)).true;
-        expect(newRoute[1].equals(p2)).true;
-
-        newRoute = trimRoute(route, p1, 90);
-        expect(newRoute.length).equals(2);
-        expect(newRoute[0].equals(p1)).true;
-        expect(newRoute[1].equals(p1.destinationPoint(90, Math.PI / 4))).true;
-
-        newRoute = trimRoute(route, p2, 10);
-        expect(newRoute.length).equals(2);
-        expect(newRoute[0].equals(p2)).true;
-        expect(newRoute[1].equals(p2.destinationPoint(10, Math.PI / 2))).true;
-
-        const p4 = p1.destinationPoint(20, Math.PI / 4);
-        newRoute = trimRoute(route, p4);
-        expect(newRoute.length).equals(3);
-        expect(newRoute[0].equals(p4)).true;
-        expect(newRoute[1].equals(p2)).true;
-        expect(newRoute[2].equals(p3)).true;
-
-        const p5 = p2.destinationPoint(20, Math.PI / 2);
-        newRoute = trimRoute(route, p4, 100);
-        expect(newRoute.length).equals(3);
-        expect(newRoute[0].equals(p4)).true;
-        expect(newRoute[1].equals(p2)).true;
-        expect(newRoute[2].equals(p5)).true;
-
-        newRoute = trimRoute(route, p4, 200);
-        expect(newRoute.length).equals(3);
-        expect(newRoute[0].equals(p4)).true;
-        expect(newRoute[1].equals(p2)).true;
-        expect(newRoute[2].equals(p3)).true;
-    });
-
-    it('simplifyRoute', () => {
-
-        let route, routeSimplified;
-
-        route = [
-            new Coordinates(48.756308386983484, 2.0549525696601694),
-            new Coordinates(48.75630194782273, 2.054987452552288),
-            new Coordinates(48.756294588780854, 2.055026521391461),
-            new Coordinates(48.7563159759933, 2.0550474511267316),
-            new Coordinates(48.756350241508265, 2.0550837293345348)
-        ];
-
-        routeSimplified = simplifyRoute(route);
-        expect(routeSimplified.length).equal(3);
-        expect(routeSimplified).to.include(route[0]);
-        expect(routeSimplified).to.not.include(route[1]);
-        expect(routeSimplified).to.include(route[2]);
-        expect(routeSimplified).to.not.include(route[3]);
-        expect(routeSimplified).to.include(route[4]);
-
-
-        route = [
-            new Coordinates(48.75627274161895, 2.054974197053283),
-            new Coordinates(48.756269751891594, 2.0549905921869933),
-            new Coordinates(48.756274912970845, 2.054992757591672),
-            new Coordinates(48.75628117553095, 2.0549584148199345),
-            new Coordinates(48.756276014452325, 2.054956249415256),
-            new Coordinates(48.75627274161895, 2.054974197053283)
-        ];
-
-        routeSimplified = simplifyRoute(route);
-        expect(routeSimplified.length).equal(5);
-        expect(routeSimplified).to.not.include(route[0]);
-        expect(routeSimplified).to.not.include(route[5]);
-
-    });
-
-
-    it('geolocationPositionToUserPosition', () => {
-
-        let route, routeSimplified;
-
-        route = [
-            new Coordinates(48.756308386983484, 2.0549525696601694),
-            new Coordinates(48.75630194782273, 2.054987452552288),
-            new Coordinates(48.756294588780854, 2.055026521391461),
-            new Coordinates(48.7563159759933, 2.0550474511267316),
-            new Coordinates(48.756350241508265, 2.0550837293345348)
-        ];
-
-        routeSimplified = simplifyRoute(route);
-        expect(routeSimplified.length).equal(3);
-        expect(routeSimplified).to.include(route[0]);
-        expect(routeSimplified).to.not.include(route[1]);
-        expect(routeSimplified).to.include(route[2]);
-        expect(routeSimplified).to.not.include(route[3]);
-        expect(routeSimplified).to.include(route[4]);
-
-
-        route = [
-            new Coordinates(48.75627274161895, 2.054974197053283),
-            new Coordinates(48.756269751891594, 2.0549905921869933),
-            new Coordinates(48.756274912970845, 2.054992757591672),
-            new Coordinates(48.75628117553095, 2.0549584148199345),
-            new Coordinates(48.756276014452325, 2.054956249415256),
-            new Coordinates(48.75627274161895, 2.054974197053283)
-        ];
-
-        routeSimplified = simplifyRoute(route);
-        expect(routeSimplified.length).equal(5);
-        expect(routeSimplified).to.not.include(route[0]);
-        expect(routeSimplified).to.not.include(route[5]);
-
-    });
-});

package/src/Utils.ts

@@ -1,218 +0,0 @@
-/* eslint-disable max-statements */
-
-import { deg2rad, positiveMod } from '@wemap/maths';
-import { EPS_MM } from './Constants.js';
-
-import Coordinates from './coordinates/Coordinates.js';
-import UserPosition from './coordinates/UserPosition.js';
-import Level from './coordinates/Level.js';
-import { Level_t } from './types.js';
-
-export type RouteSample = Coordinates & { bearing: number };
-
-/**
- * Sample a route of Coordinates
- * @param route ordered points
- * @param stepSize step size to sample
- * @param maxLength max route length to sample
- */
-export function sampleRoute(
-    route: Coordinates[],
-    stepSize = 0.7,
-    startSampling = 0,
-    length = Number.MAX_VALUE
-) {
-
-    const endSampling = startSampling + length;
-
-    const sampledRoute = [];
-
-    let lastSample: RouteSample;
-
-    let totalDistanceTraveled = 0;
-    let distanceToNextSample = 0;
-    let startFound = false;
-
-    for (let segmentIndex = 0; segmentIndex < route.length - 1; segmentIndex++) {
-
-        const p1 = route[segmentIndex];
-        const p2 = route[segmentIndex + 1];
-        const segmentSize = p1.distanceTo(p2);
-        const segmentBearing = p1.bearingTo(p2);
-
-        let distanceTraveledOnSegment = 0;
-
-        if (!startFound) {
-            if (startSampling < totalDistanceTraveled + segmentSize) {
-                startFound = true;
-                distanceToNextSample = startSampling - totalDistanceTraveled;
-            } else {
-                totalDistanceTraveled += segmentSize;
-                continue;
-            }
-        }
-
-        lastSample = Object.assign(p1.clone(), { bearing: segmentBearing });
-        while (distanceTraveledOnSegment + distanceToNextSample < segmentSize
-            && totalDistanceTraveled + distanceToNextSample <= endSampling) {
-
-            const newPoint = lastSample.destinationPoint(distanceToNextSample, segmentBearing) as RouteSample;
-            newPoint.bearing = segmentBearing;
-            sampledRoute.push(newPoint);
-            lastSample = newPoint;
-
-            distanceTraveledOnSegment += distanceToNextSample;
-            totalDistanceTraveled += distanceToNextSample;
-            distanceToNextSample = stepSize;
-        }
-
-        if (totalDistanceTraveled + distanceToNextSample > endSampling) {
-            break;
-        }
-
-        const rest = segmentSize - distanceTraveledOnSegment;
-        totalDistanceTraveled += rest;
-        distanceToNextSample -= rest;
-    }
-
-    return sampledRoute;
-}
-
-/**
- * Trim a route of Coordinates
- * @param {Array.<Coordinates>} route ordered points
- * @param {Coordinates} startPosition position where the trim starts. startPosition has to be on the route.
- * @param {*} maxLength max route length
- */
-export function trimRoute(route: Coordinates[], startPosition = route[0], length = Number.MAX_VALUE) {
-
-    const newRoute = [];
-    let previousPoint: Coordinates | null = null;
-
-    let currentPointIndex;
-    let cumulativeDistance = 0;
-
-    if (route.length <= 1) {
-        throw new Error('Route must have at least 2 points');
-    }
-
-    for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
-
-        const p1 = route[currentPointIndex - 1];
-        const p2 = route[currentPointIndex];
-
-        if (Coordinates.equals(startPosition, p1)) {
-            newRoute.push(p1);
-            previousPoint = p1;
-            break;
-        }
-
-        const proj = startPosition.getSegmentProjection(p1, p2);
-        if (proj && Coordinates.equals(startPosition, proj) && !proj.equals(p2)) {
-            newRoute.push(proj);
-            previousPoint = proj;
-            break;
-        }
-    }
-
-    if (!newRoute.length) {
-        throw new Error('startPosition is not on the route');
-    }
-
-    while (previousPoint && currentPointIndex < route.length) {
-        const currentPoint = route[currentPointIndex];
-        const dist = previousPoint.distanceTo(currentPoint);
-        if (cumulativeDistance + dist >= length
-            || Math.abs(cumulativeDistance + dist - length) <= EPS_MM) {
-            const bearing = previousPoint.bearingTo(currentPoint);
-            const remainingLength = length - cumulativeDistance;
-            const end = previousPoint.destinationPoint(remainingLength, bearing);
-            newRoute.push(end);
-            break;
-        }
-        newRoute.push(currentPoint);
-        previousPoint = currentPoint;
-        cumulativeDistance += dist;
-        currentPointIndex++;
-    }
-
-    return newRoute;
-}
-
-
-export function simplifyRoute(coords: Coordinates[], 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[positiveMod(i - 1, len)];
-        const p1 = coords[i];
-        const p2 = coords[positiveMod(i + 1, len)];
-
-        const seg1Dir = p0.bearingTo(p1);
-        const seg2Dir = p1.bearingTo(p2);
-
-        if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
-            newRoute = newRoute.filter(coord => coord !== p1);
-        }
-    }
-
-    if (isClosed) {
-        newRoute.push(newRoute[0]);
-    }
-
-    return newRoute;
-}
-
-export function geolocationPositionToUserPosition(geolocationPosition: GeolocationPosition) {
-    if (geolocationPosition === null) {
-        return null;
-    }
-
-    const { latitude, longitude, accuracy, heading } = geolocationPosition.coords;
-
-    const userPosition = new UserPosition(latitude, longitude);
-    userPosition.time = geolocationPosition.timestamp;
-    userPosition.accuracy = accuracy;
-    userPosition.bearing = heading ? deg2rad(heading) : null;
-    return userPosition;
-}
-
-export function calcDistance(coords: Coordinates[]) {
-    return coords.reduce((acc, coords, idx, arr) =>
-        acc + (idx ? arr[idx - 1].distanceTo(coords) : 0), 0);
-}
-
-
-export function createSegmentsAtLevel(itineraryCoords: Coordinates[], segmentsLevel: Level_t, useMultiLevelSegments = true) {
-
-    const itineraryCoordsLength = itineraryCoords.length;
-    let previousLevelCorrespond = false;
-
-    const segments: Coordinates[][] = [];
-    let coordinates: Coordinates[] = [];
-    for (let i = 0; i < itineraryCoordsLength; i++) {
-        const coords = itineraryCoords[i];
-        const levelCorrespond = Level.intersect(segmentsLevel, coords.level);
-
-        if (useMultiLevelSegments && !levelCorrespond && previousLevelCorrespond) {
-            coordinates.push(coords);
-        } else if (levelCorrespond) {
-            if (!previousLevelCorrespond) {
-                coordinates = [];
-                segments.push(coordinates);
-                if (useMultiLevelSegments && i !== 0) {
-                    coordinates.push(itineraryCoords[i - 1]);
-                }
-            }
-            coordinates.push(coords);
-        }
-
-        previousLevelCorrespond = levelCorrespond;
-    }
-    return segments;
-}

package/src/coordinates/BoundingBox.spec.ts

@@ -1,198 +0,0 @@
-/* eslint-disable max-nested-callbacks */
-import { Vector4_t } from '@wemap/maths';
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-
-import BoundingBox from './BoundingBox.js';
-import Coordinates from './Coordinates.js';
-
-const expect = chai.expect;
-chai.use(chaiAlmost());
-
-let boundingBox: BoundingBox;
-const northEast = new Coordinates(10, 40);
-const southWest = new Coordinates(-5, -20);
-
-const checkBounds = (bb: BoundingBox, [north, east, south, west]: Vector4_t) => {
-    return north === bb.northEast.lat
-        && east === bb.northEast.lng
-        && south === bb.southWest.lat
-        && west === bb.southWest.lng;
-};
-
-describe('Bounding Box', () => {
-
-    it('creation', () => {
-        expect(() => new BoundingBox(new Coordinates(10, -20), new Coordinates(-5, 40))).not.throw(Error);
-        expect(() => new BoundingBox(new Coordinates(-5, -20), new Coordinates(10, 40))).is.throw(Error);
-
-        boundingBox = new BoundingBox(northEast, southWest);
-        expect(boundingBox.northEast).equals(northEast);
-        expect(boundingBox.southWest).equals(southWest);
-
-        const boundingBox2 = BoundingBox.fromArray([-20, -5, 40, 10]);
-        expect(boundingBox2.equals(boundingBox)).is.true;
-    });
-
-
-    it('equals', () => {
-        boundingBox = new BoundingBox(northEast, southWest);
-        expect(boundingBox.equals(new BoundingBox(
-            new Coordinates(10, 40), new Coordinates(-5, -20)
-        ))).true;
-        expect(BoundingBox.equals(boundingBox, new BoundingBox(
-            new Coordinates(10, 40), new Coordinates(-5, -20)
-        ))).true;
-        expect(BoundingBox.equals(boundingBox, new BoundingBox(
-            new Coordinates(10, 10), new Coordinates(-5, -20)
-        ))).false;
-        expect(BoundingBox.equals(boundingBox, new BoundingBox(
-            new Coordinates(10, 40), new Coordinates(-15, -20)
-        ))).false;
-    });
-
-    it('bounds', () => {
-        boundingBox = new BoundingBox(northEast, southWest);
-        expect(boundingBox.getNorth()).equals(northEast.lat);
-        expect(boundingBox.getEast()).equals(northEast.lng);
-        expect(boundingBox.getSouth()).equals(southWest.lat);
-        expect(boundingBox.getWest()).equals(southWest.lng);
-        expect(Coordinates.equals(boundingBox.getNorthEast(), northEast)).true;
-        expect(Coordinates.equals(boundingBox.getSouthWest(), southWest)).true;
-        expect(Coordinates.equals(boundingBox.getNorthWest(),
-            new Coordinates(northEast.lat, southWest.lng))).true;
-        expect(Coordinates.equals(boundingBox.getSouthEast(),
-            new Coordinates(southWest.lat, northEast.lng))).true;
-    });
-
-
-    it('center', () => {
-        boundingBox = new BoundingBox(northEast, southWest);
-        const center = boundingBox.center;
-        expect(center.lat).equals(2.5);
-        expect(center.lng).equals(10);
-    });
-
-
-    it('contains', () => {
-        boundingBox = new BoundingBox(northEast, southWest);
-        expect(boundingBox.contains(new Coordinates(0, 0))).true;
-        expect(boundingBox.contains(new Coordinates(10, 0))).true;
-        expect(boundingBox.contains(new Coordinates(0, 10))).true;
-        expect(boundingBox.contains(new Coordinates(-10, 0))).false;
-        expect(boundingBox.contains(new Coordinates(0, -10))).true;
-        expect(boundingBox.contains(new Coordinates(50, 50))).false;
-        expect(boundingBox.contains(new Coordinates(-50, 50))).false;
-        expect(boundingBox.contains(new Coordinates(50, -50))).false;
-        expect(boundingBox.contains(new Coordinates(-50, -50))).false;
-    });
-
-    it('extend', () => {
-        boundingBox = new BoundingBox(northEast, southWest);
-        expect(checkBounds(
-            boundingBox.extend(new Coordinates(0, 0)),
-            [10, 40, -5, -20]
-        )).true;
-        expect(checkBounds(
-            boundingBox.extend(new Coordinates(20, 0)),
-            [20, 40, -5, -20]
-        )).true;
-        expect(checkBounds(
-            boundingBox.extend(new Coordinates(20, 40)),
-            [20, 40, -5, -20]
-        )).true;
-        expect(checkBounds(
-            boundingBox.extend(new Coordinates(30, 40)),
-            [30, 40, -5, -20]
-        )).true;
-
-        boundingBox = new BoundingBox(northEast, southWest);
-        boundingBox.extend(new BoundingBox(
-            new Coordinates(10, 10), new Coordinates(-10, -10)
-        ));
-        expect(checkBounds(boundingBox, [10, 40, -10, -20])).true;
-
-        boundingBox = new BoundingBox(northEast, northEast);
-        boundingBox.extend(new BoundingBox(northEast, southWest));
-        expect(checkBounds(boundingBox, [10, 40, -5, -20])).true;
-    });
-
-
-    it('extend with measure', () => {
-        let measure, extended;
-
-        boundingBox = new BoundingBox(northEast, southWest);
-        measure = 50000;
-        extended = boundingBox.extendsWithMeasure(measure);
-        expect(new Coordinates(extended.northEast.lat, northEast.lng).distanceTo(northEast))
-            .be.closeTo(measure, 0.05 * measure);
-        expect(new Coordinates(northEast.lat, extended.northEast.lng).distanceTo(northEast))
-            .be.closeTo(measure, 0.05 * measure);
-        expect(new Coordinates(extended.southWest.lat, southWest.lng).distanceTo(southWest))
-            .be.closeTo(measure, 0.05 * measure);
-        expect(new Coordinates(southWest.lat, extended.southWest.lng).distanceTo(southWest))
-            .be.closeTo(measure, 0.05 * measure);
-
-
-        boundingBox = new BoundingBox(northEast, southWest);
-        measure = 50;
-        extended = boundingBox.extendsWithMeasure(measure);
-        expect(new Coordinates(extended.northEast.lat, northEast.lng).distanceTo(northEast))
-            .be.closeTo(measure, 0.05 * measure);
-        expect(new Coordinates(northEast.lat, extended.northEast.lng).distanceTo(northEast))
-            .be.closeTo(measure, 0.05 * measure);
-        expect(new Coordinates(extended.southWest.lat, southWest.lng).distanceTo(southWest))
-            .be.closeTo(measure, 0.05 * measure);
-        expect(new Coordinates(southWest.lat, extended.southWest.lng).distanceTo(southWest))
-            .be.closeTo(measure, 0.05 * measure);
-    });
-
-    it('pad', () => {
-
-        let distBefore, distAfter;
-
-        boundingBox = new BoundingBox(northEast, southWest);
-        const bufferRatio = 0.3;
-        const extended = new BoundingBox(northEast, southWest).pad(bufferRatio);
-
-
-        distBefore = new Coordinates(boundingBox.getNorth(), boundingBox.getWest()).distanceTo(
-            new Coordinates(boundingBox.getNorth(), boundingBox.getEast())
-        );
-        distAfter = new Coordinates(extended.getNorth(), extended.getWest()).distanceTo(
-            new Coordinates(extended.getNorth(), extended.getEast())
-        );
-        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
-
-
-        distBefore = new Coordinates(boundingBox.getSouth(), boundingBox.getWest()).distanceTo(
-            new Coordinates(boundingBox.getSouth(), boundingBox.getEast())
-        );
-        distAfter = new Coordinates(extended.getSouth(), extended.getWest()).distanceTo(
-            new Coordinates(extended.getSouth(), extended.getEast())
-        );
-        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
-
-
-        distBefore = new Coordinates(boundingBox.getNorth(), boundingBox.getEast()).distanceTo(
-            new Coordinates(boundingBox.getSouth(), boundingBox.getEast())
-        );
-        distAfter = new Coordinates(extended.getNorth(), extended.getEast()).distanceTo(
-            new Coordinates(extended.getSouth(), extended.getEast())
-        );
-        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
-
-
-        distBefore = new Coordinates(boundingBox.getNorth(), boundingBox.getWest()).distanceTo(
-            new Coordinates(boundingBox.getSouth(), boundingBox.getWest())
-        );
-        distAfter = new Coordinates(extended.getNorth(), extended.getWest()).distanceTo(
-            new Coordinates(extended.getSouth(), extended.getWest())
-        );
-        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
-    });
-
-    it('toArray', () => {
-        expect(new BoundingBox(northEast, southWest).toArray()).deep.equals([-20, -5, 40, 10]);
-    });
-});