@scoova/mgl 1.0.0

package/src/symbol/grid_index.ts

@@ -0,0 +1,414 @@
+import type {OverlapMode} from '../style/style_layer/overlap_mode';
+
+type QueryArgs = {
+    hitTest: boolean;
+    overlapMode?: OverlapMode;
+    circle?: {
+        x: number;
+        y: number;
+        radius: number;
+    };
+    seenUids: {
+        box: {
+            [_: number]: boolean;
+        };
+        circle: {
+            [_: number]: boolean;
+        };
+    };
+};
+
+type QueryResult<T> = {
+    key: T;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+
+/**
+ * A key for the grid
+ */
+export type GridKey = {
+    overlapMode?: OverlapMode;
+}
+
+function overlapAllowed(overlapA: OverlapMode, overlapB: OverlapMode): boolean {
+    let allowed = true;
+
+    if (overlapA === 'always') {
+        // symbol A using 'always' overlap - allowed to overlap anything.
+    } else if (overlapA === 'never' || overlapB === 'never') {
+        // symbol A using 'never' overlap - can't overlap anything
+        // symbol A using 'cooperative' overlap - can overlap 'always' or 'cooperative' symbol; can't overlap 'never'
+        allowed = false;
+    }
+
+    return allowed;
+}
+
+/**
+ * @internal
+ * GridIndex is a data structure for testing the intersection of
+ * circles and rectangles in a 2d plane.
+ * It is optimized for rapid insertion and querying.
+ * GridIndex splits the plane into a set of "cells" and keeps track
+ * of which geometries intersect with each cell. At query time,
+ * full geometry comparisons are only done for items that share
+ * at least one cell. As long as the geometries are relatively
+ * uniformly distributed across the plane, this greatly reduces
+ * the number of comparisons necessary.
+ */
+export class GridIndex<T extends GridKey> {
+    circleKeys: Array<T>;
+    boxKeys: Array<T>;
+    boxCells: Array<Array<number>>;
+    circleCells: Array<Array<number>>;
+    bboxes: Array<number>;
+    circles: Array<number>;
+    xCellCount: number;
+    yCellCount: number;
+    width: number;
+    height: number;
+    xScale: number;
+    yScale: number;
+    boxUid: number;
+    circleUid: number;
+
+    constructor (width: number, height: number, cellSize: number) {
+        const boxCells = this.boxCells = [];
+        const circleCells = this.circleCells = [];
+
+        // More cells -> fewer geometries to check per cell, but items tend
+        // to be split across more cells.
+        // Sweet spot allows most small items to fit in one cell
+        this.xCellCount = Math.ceil(width / cellSize);
+        this.yCellCount = Math.ceil(height / cellSize);
+
+        for (let i = 0; i < this.xCellCount * this.yCellCount; i++) {
+            boxCells.push([]);
+            circleCells.push([]);
+        }
+        this.circleKeys = [];
+        this.boxKeys = [];
+        this.bboxes = [];
+        this.circles = [];
+
+        this.width = width;
+        this.height = height;
+        this.xScale = this.xCellCount / width;
+        this.yScale = this.yCellCount / height;
+        this.boxUid = 0;
+        this.circleUid = 0;
+    }
+
+    keysLength() {
+        return this.boxKeys.length + this.circleKeys.length;
+    }
+
+    insert(key: T, x1: number, y1: number, x2: number, y2: number) {
+        this._forEachCell(x1, y1, x2, y2, this._insertBoxCell, this.boxUid++);
+        this.boxKeys.push(key);
+        this.bboxes.push(x1);
+        this.bboxes.push(y1);
+        this.bboxes.push(x2);
+        this.bboxes.push(y2);
+    }
+
+    insertCircle(key: T, x: number, y: number, radius: number) {
+        // Insert circle into grid for all cells in the circumscribing square
+        // It's more than necessary (by a factor of 4/PI), but fast to insert
+        this._forEachCell(x - radius, y - radius, x + radius, y + radius, this._insertCircleCell, this.circleUid++);
+        this.circleKeys.push(key);
+        this.circles.push(x);
+        this.circles.push(y);
+        this.circles.push(radius);
+    }
+
+    private _insertBoxCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, uid: number) {
+        this.boxCells[cellIndex].push(uid);
+    }
+
+    private _insertCircleCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, uid: number)  {
+        this.circleCells[cellIndex].push(uid);
+    }
+
+    private _query(x1: number, y1: number, x2: number, y2: number, hitTest: boolean, overlapMode: OverlapMode, predicate?: (key: T) => boolean): Array<QueryResult<T>> {
+        if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+            return [];
+        }
+        const result: Array<QueryResult<T>> = [];
+        if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
+            if (hitTest) {
+                // Covers the entire grid, so collides with everything
+                return [{
+                    key: null,
+                    x1,
+                    y1,
+                    x2,
+                    y2
+                }];
+            }
+            for (let boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
+                result.push({
+                    key: this.boxKeys[boxUid],
+                    x1: this.bboxes[boxUid * 4],
+                    y1: this.bboxes[boxUid * 4 + 1],
+                    x2: this.bboxes[boxUid * 4 + 2],
+                    y2: this.bboxes[boxUid * 4 + 3]
+                });
+            }
+            for (let circleUid = 0; circleUid < this.circleKeys.length; circleUid++) {
+                const x = this.circles[circleUid * 3];
+                const y = this.circles[circleUid * 3 + 1];
+                const radius = this.circles[circleUid * 3 + 2];
+                result.push({
+                    key: this.circleKeys[circleUid],
+                    x1: x - radius,
+                    y1: y - radius,
+                    x2: x + radius,
+                    y2: y + radius
+                });
+            }
+        } else {
+            const queryArgs: QueryArgs = {
+                hitTest,
+                overlapMode,
+                seenUids: {box: {}, circle: {}}
+            };
+            this._forEachCell(x1, y1, x2, y2, this._queryCell, result, queryArgs, predicate);
+        }
+
+        return result;
+    }
+
+    query(x1: number, y1: number, x2: number, y2: number): Array<QueryResult<T>> {
+        return this._query(x1, y1, x2, y2, false, null);
+    }
+
+    hitTest(x1: number, y1: number, x2: number, y2: number, overlapMode: OverlapMode, predicate?: (key: T) => boolean): boolean {
+        return this._query(x1, y1, x2, y2, true, overlapMode, predicate).length > 0;
+    }
+
+    hitTestCircle(x: number, y: number, radius: number, overlapMode: OverlapMode, predicate?: (key: T) => boolean): boolean {
+        // Insert circle into grid for all cells in the circumscribing square
+        // It's more than necessary (by a factor of 4/PI), but fast to insert
+        const x1 = x - radius;
+        const x2 = x + radius;
+        const y1 = y - radius;
+        const y2 = y + radius;
+        if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+            return false;
+        }
+
+        // Box query early exits if the bounding box is larger than the grid, but we don't do
+        // the equivalent calculation for circle queries because early exit is less likely
+        // and the calculation is more expensive
+        const result: boolean[] = [];
+        const queryArgs: QueryArgs = {
+            hitTest: true,
+            overlapMode,
+            circle: {x, y, radius},
+            seenUids: {box: {}, circle: {}}
+        };
+        this._forEachCell(x1, y1, x2, y2, this._queryCellCircle, result, queryArgs, predicate);
+        return result.length > 0;
+    }
+
+    private _queryCell(x1: number, y1: number, x2: number, y2: number, cellIndex: number, result: Array<QueryResult<T>>, queryArgs: QueryArgs, predicate?: (key: T) => boolean): boolean {
+        const {seenUids, hitTest, overlapMode} = queryArgs;
+        const boxCell = this.boxCells[cellIndex];
+
+        if (boxCell !== null) {
+            const bboxes = this.bboxes;
+            for (const boxUid of boxCell) {
+                if (!seenUids.box[boxUid]) {
+                    seenUids.box[boxUid] = true;
+                    const offset = boxUid * 4;
+                    const key = this.boxKeys[boxUid];
+
+                    if ((x1 <= bboxes[offset + 2]) &&
+                        (y1 <= bboxes[offset + 3]) &&
+                        (x2 >= bboxes[offset + 0]) &&
+                        (y2 >= bboxes[offset + 1]) &&
+                        (!predicate || predicate(key))) {
+                        if (!hitTest || !overlapAllowed(overlapMode, key.overlapMode)) {
+                            result.push({
+                                key,
+                                x1: bboxes[offset],
+                                y1: bboxes[offset + 1],
+                                x2: bboxes[offset + 2],
+                                y2: bboxes[offset + 3]
+                            });
+                            if (hitTest) {
+                                // true return value stops the query after first match
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const circleCell = this.circleCells[cellIndex];
+        if (circleCell !== null) {
+            const circles = this.circles;
+            for (const circleUid of circleCell) {
+                if (!seenUids.circle[circleUid]) {
+                    seenUids.circle[circleUid] = true;
+                    const offset = circleUid * 3;
+                    const key = this.circleKeys[circleUid];
+
+                    if (this._circleAndRectCollide(
+                        circles[offset],
+                        circles[offset + 1],
+                        circles[offset + 2],
+                        x1,
+                        y1,
+                        x2,
+                        y2) &&
+                        (!predicate || predicate(key))) {
+                        if (!hitTest || !overlapAllowed(overlapMode, key.overlapMode)) {
+                            const x = circles[offset];
+                            const y = circles[offset + 1];
+                            const radius = circles[offset + 2];
+                            result.push({
+                                key,
+                                x1: x - radius,
+                                y1: y - radius,
+                                x2: x + radius,
+                                y2: y + radius
+                            });
+                            if (hitTest) {
+                                // true return value stops the query after first match
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // false return to continue query
+        return false;
+    }
+
+    private _queryCellCircle(x1: number, y1: number, x2: number, y2: number, cellIndex: number, result: Array<boolean>, queryArgs: QueryArgs, predicate?: (key: T) => boolean): boolean {
+        const {circle, seenUids, overlapMode} = queryArgs;
+        const boxCell = this.boxCells[cellIndex];
+
+        if (boxCell !== null) {
+            const bboxes = this.bboxes;
+            for (const boxUid of boxCell) {
+                if (!seenUids.box[boxUid]) {
+                    seenUids.box[boxUid] = true;
+                    const offset = boxUid * 4;
+                    const key = this.boxKeys[boxUid];
+                    if (this._circleAndRectCollide(
+                        circle.x,
+                        circle.y,
+                        circle.radius,
+                        bboxes[offset + 0],
+                        bboxes[offset + 1],
+                        bboxes[offset + 2],
+                        bboxes[offset + 3]) &&
+                        (!predicate || predicate(key)) &&
+                        !overlapAllowed(overlapMode, key.overlapMode)) {
+                        result.push(true);
+                        return true;
+                    }
+                }
+            }
+        }
+
+        const circleCell = this.circleCells[cellIndex];
+        if (circleCell !== null) {
+            const circles = this.circles;
+            for (const circleUid of circleCell) {
+                if (!seenUids.circle[circleUid]) {
+                    seenUids.circle[circleUid] = true;
+                    const offset = circleUid * 3;
+                    const key = this.circleKeys[circleUid];
+                    if (this._circlesCollide(
+                        circles[offset],
+                        circles[offset + 1],
+                        circles[offset + 2],
+                        circle.x,
+                        circle.y,
+                        circle.radius) &&
+                        (!predicate || predicate(key)) &&
+                        !overlapAllowed(overlapMode, key.overlapMode)) {
+                        result.push(true);
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    private _forEachCell<TArg>(
+        x1: number,
+        y1: number,
+        x2: number,
+        y2: number,
+        fn: (x1: number, y1: number, x2: number, y2: number, cellIndex: number, arg1: TArg, arg2?: QueryArgs, predicate?: (key: T) => boolean) => boolean | void,
+        arg1: TArg,
+        arg2?: QueryArgs,
+        predicate?: (key: T) => boolean) {
+        const cx1 = this._convertToXCellCoord(x1);
+        const cy1 = this._convertToYCellCoord(y1);
+        const cx2 = this._convertToXCellCoord(x2);
+        const cy2 = this._convertToYCellCoord(y2);
+
+        for (let x = cx1; x <= cx2; x++) {
+            for (let y = cy1; y <= cy2; y++) {
+                const cellIndex = this.xCellCount * y + x;
+                if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) return;
+            }
+        }
+    }
+
+    private _convertToXCellCoord(x: number) {
+        return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
+    }
+
+    private _convertToYCellCoord(y: number) {
+        return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
+    }
+
+    private _circlesCollide(x1: number, y1: number, r1: number, x2: number, y2: number, r2: number): boolean {
+        const dx = x2 - x1;
+        const dy = y2 - y1;
+        const bothRadii = r1 + r2;
+        return (bothRadii * bothRadii) > (dx * dx + dy * dy);
+    }
+
+    private _circleAndRectCollide(
+        circleX: number,
+        circleY: number,
+        radius: number,
+        x1: number,
+        y1: number,
+        x2: number,
+        y2: number
+    ): boolean {
+        const halfRectWidth = (x2 - x1) / 2;
+        const distX = Math.abs(circleX - (x1 + halfRectWidth));
+        if (distX > (halfRectWidth + radius)) {
+            return false;
+        }
+
+        const halfRectHeight = (y2 - y1) / 2;
+        const distY = Math.abs(circleY - (y1 + halfRectHeight));
+        if (distY > (halfRectHeight + radius)) {
+            return false;
+        }
+
+        if (distX <= halfRectWidth || distY <= halfRectHeight) {
+            return true;
+        }
+
+        const dx = distX - halfRectWidth;
+        const dy = distY - halfRectHeight;
+        return (dx * dx + dy * dy <= (radius * radius));
+    }
+}

package/src/symbol/merge_lines.test.ts

@@ -0,0 +1,30 @@
+import {mergeLines} from './merge_lines';
+import Point from '@mapbox/point-geometry';
+
+function makeFeatures(lines) {
+    const features = [];
+    for (const line of lines) {
+        const points = [];
+        for (let j = 1; j < line.length; j++) {
+            points.push(new Point(line[j], 0));
+        }
+        features.push({text: line[0], geometry: [points]});
+    }
+    return features;
+}
+
+describe('mergeLines', () => {
+    test('mergeLines merges lines with the same text', () => {
+        expect(
+            mergeLines(makeFeatures([['a', 0, 1, 2], ['b', 4, 5, 6], ['a', 8, 9], ['a', 2, 3, 4], ['a', 6, 7, 8], ['a', 5, 6]]))
+        ).toEqual(makeFeatures([['a', 0, 1, 2, 3, 4], ['b', 4, 5, 6], ['a', 5, 6, 7, 8, 9]]));
+    });
+
+    test('mergeLines handles merge from both ends', () => {
+        expect(mergeLines(makeFeatures([['a', 0, 1, 2], ['a', 4, 5, 6], ['a', 2, 3, 4]]))).toEqual(makeFeatures([['a', 0, 1, 2, 3, 4, 5, 6]]));
+    });
+
+    test('mergeLines handles circular lines', () => {
+        expect(mergeLines(makeFeatures([['a', 0, 1, 2], ['a', 2, 3, 4], ['a', 4, 0]]))).toEqual(makeFeatures([['a', 0, 1, 2, 3, 4, 0]]));
+    });
+});

package/src/symbol/merge_lines.ts

@@ -0,0 +1,80 @@
+import type {SymbolFeature} from '../data/bucket/symbol_bucket';
+
+export function mergeLines(features: Array<SymbolFeature>): Array<SymbolFeature> {
+    const leftIndex: {[_: string]: number} = {};
+    const rightIndex: {[_: string]: number} = {};
+    const mergedFeatures = [];
+    let mergedIndex = 0;
+
+    function add(k) {
+        mergedFeatures.push(features[k]);
+        mergedIndex++;
+    }
+
+    function mergeFromRight(leftKey: string, rightKey: string, geom) {
+        const i = rightIndex[leftKey];
+        delete rightIndex[leftKey];
+        rightIndex[rightKey] = i;
+
+        mergedFeatures[i].geometry[0].pop();
+        mergedFeatures[i].geometry[0] = mergedFeatures[i].geometry[0].concat(geom[0]);
+        return i;
+    }
+
+    function mergeFromLeft(leftKey: string, rightKey: string, geom) {
+        const i = leftIndex[rightKey];
+        delete leftIndex[rightKey];
+        leftIndex[leftKey] = i;
+
+        mergedFeatures[i].geometry[0].shift();
+        mergedFeatures[i].geometry[0] = geom[0].concat(mergedFeatures[i].geometry[0]);
+        return i;
+    }
+
+    function getKey(text, geom, onRight?) {
+        const point = onRight ? geom[0][geom[0].length - 1] : geom[0][0];
+        return `${text}:${point.x}:${point.y}`;
+    }
+
+    for (let k = 0; k < features.length; k++) {
+        const feature = features[k];
+        const geom = feature.geometry;
+        const text = feature.text ? feature.text.toString() : null;
+
+        if (!text) {
+            add(k);
+            continue;
+        }
+
+        const leftKey = getKey(text, geom),
+            rightKey = getKey(text, geom, true);
+
+        if ((leftKey in rightIndex) && (rightKey in leftIndex) && (rightIndex[leftKey] !== leftIndex[rightKey])) {
+            // found lines with the same text adjacent to both ends of the current line, merge all three
+            const j = mergeFromLeft(leftKey, rightKey, geom);
+            const i = mergeFromRight(leftKey, rightKey, mergedFeatures[j].geometry);
+
+            delete leftIndex[leftKey];
+            delete rightIndex[rightKey];
+
+            rightIndex[getKey(text, mergedFeatures[i].geometry, true)] = i;
+            mergedFeatures[j].geometry = null;
+
+        } else if (leftKey in rightIndex) {
+            // found mergeable line adjacent to the start of the current line, merge
+            mergeFromRight(leftKey, rightKey, geom);
+
+        } else if (rightKey in leftIndex) {
+            // found mergeable line adjacent to the end of the current line, merge
+            mergeFromLeft(leftKey, rightKey, geom);
+
+        } else {
+            // no adjacent lines, add as a new item
+            add(k);
+            leftIndex[leftKey] = mergedIndex - 1;
+            rightIndex[rightKey] = mergedIndex - 1;
+        }
+    }
+
+    return mergedFeatures.filter((f) => f.geometry);
+}

package/src/symbol/one_em.ts

@@ -0,0 +1,3 @@
+// ONE_EM constant used to go between "em" units used in style spec and "points" used internally for layout
+
+export default 24;

package/src/symbol/opacity_state.ts

@@ -0,0 +1,23 @@
+import {register} from '../util/web_worker_transfer';
+
+export class OpacityState {
+    opacity: number;
+    targetOpacity: number;
+    time: number;
+
+    constructor() {
+        this.opacity = 0;
+        this.targetOpacity = 0;
+        this.time = 0;
+    }
+
+    clone() {
+        const clone = new OpacityState();
+        clone.opacity = this.opacity;
+        clone.targetOpacity = this.targetOpacity;
+        clone.time = this.time;
+        return clone;
+    }
+}
+
+register('OpacityState', OpacityState);

package/src/symbol/path_interpolator.test.ts

@@ -0,0 +1,134 @@
+import Point from '@mapbox/point-geometry';
+import {PathInterpolator} from './path_interpolator';
+
+describe('PathInterpolator', () => {
+
+    const pointEquals = (p0, p1) => {
+        const e = 0.000001;
+        return Math.abs(p0.x - p1.x) < e && Math.abs(p0.y - p1.y) < e;
+    };
+
+    test('Interpolate single segment path', () => {
+        const line = [
+            new Point(0, 0),
+            new Point(10, 0)
+        ];
+
+        const interpolator = new PathInterpolator(line);
+
+        expect(interpolator.lerp(0.0)).toEqual(line[0]);
+        expect(interpolator.lerp(0.5)).toEqual(new Point(5, 0));
+        expect(interpolator.lerp(1.0)).toEqual(line[1]);
+    });
+
+    test('t < 0', () => {
+        const line = [
+            new Point(0, 0),
+            new Point(10, 0)
+        ];
+
+        const interpolator = new PathInterpolator(line);
+        expect(interpolator.lerp(-100.0)).toEqual(line[0]);
+    });
+
+    test('t > 0', () => {
+        const line = [
+            new Point(0, 0),
+            new Point(10, 0)
+        ];
+
+        const interpolator = new PathInterpolator(line);
+        expect(interpolator.lerp(100.0)).toEqual(line[1]);
+    });
+
+    test('Interpolate multi-segment path', () => {
+        const line = [
+            new Point(-3, 3),
+            new Point(-1, 3),
+            new Point(-1, -2),
+            new Point(2, -2),
+            new Point(2, 1),
+            new Point(-3, 1)
+        ];
+
+        const interpolator = new PathInterpolator(line);
+        expect(pointEquals(interpolator.lerp(1.0), new Point(-3, 1))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.95), new Point(-2.1, 1))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.5), new Point(1, -2))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.25), new Point(-1, 0.5))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.1), new Point(-1.2, 3))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.0), new Point(-3, 3))).toBeTruthy();
+    });
+
+    test('Small padding', () => {
+        const line = [
+            new Point(-4, 1),
+            new Point(4, 1)
+        ];
+
+        const padding = 0.5;
+        const interpolator = new PathInterpolator(line, padding);
+
+        expect(pointEquals(interpolator.lerp(0.0), new Point(-3.5, 1))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.25), new Point(-1.75, 1))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.5), new Point(0, 1))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(1.0), new Point(3.5, 1))).toBeTruthy();
+    });
+
+    test('Padding cannot be larger than the length / 2', () => {
+        const line = [
+            new Point(-3, 0),
+            new Point(3, 0)
+        ];
+
+        const padding = 10.0;
+        const interpolator = new PathInterpolator(line, padding);
+
+        expect(pointEquals(interpolator.lerp(0.0), new Point(0, 0))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.4), new Point(0, 0))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(1.0), new Point(0, 0))).toBeTruthy();
+    });
+
+    test('Single point path', () => {
+        const interpolator = new PathInterpolator([new Point(0, 0)]);
+        expect(pointEquals(interpolator.lerp(0), new Point(0, 0))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(1.0), new Point(0, 0))).toBeTruthy();
+    });
+
+    test('Interpolator instance can be reused by calling reset()', () => {
+        const line0 = [
+            new Point(0, 0),
+            new Point(10, 0)
+        ];
+
+        const line1 = [
+            new Point(-10, 10),
+            new Point(10, -10)
+        ];
+
+        const interpolator = new PathInterpolator(line0);
+
+        expect(interpolator.lerp(0.0)).toEqual(line0[0]);
+        expect(interpolator.lerp(0.5)).toEqual(new Point(5, 0));
+        expect(interpolator.lerp(1.0)).toEqual(line0[1]);
+
+        interpolator.reset(line1);
+        expect(pointEquals(interpolator.lerp(0.0), line1[0])).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.5), new Point(0, 0))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(1.0), line1[1])).toBeTruthy();
+    });
+
+    test('Path with zero length segment', () => {
+        const line = [
+            new Point(-1, 0),
+            new Point(1, 0),
+            new Point(1, 0)
+        ];
+
+        const interpolator = new PathInterpolator(line);
+        expect(pointEquals(interpolator.lerp(0), line[0])).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(0.5), new Point(0, 0))).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(1), line[1])).toBeTruthy();
+        expect(pointEquals(interpolator.lerp(1), line[2])).toBeTruthy();
+    });
+});