archive-gh-me/mapillary-js
1
0
Fork 0
mirror of https://github.com/mapillary/mapillary-js.git synced 2026-01-25 14:07:28 +00:00
Code Issues Projects Releases Wiki Activity

refactor: rename interfaces for clarity

Browse Source
This commit is contained in:
Oscar Lorentzon 2021-03-16 10:53:21 +01:00
parent dd2fc56539
commit 297d8ebffd
279 changed files with 3649 additions and 3637 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
jest.config.js
View File

@ -4,8 +4,10 @@ export default {
"<rootDir>/src/**/*",
],
coveragePathIgnorePatterns: [
"<rootDir>/src/Mapillary.js",
"<rootDir>/src/api/ents/",
"<rootDir>/src/export/",
"<rootDir>/src/component/shaders/",
"<rootDir>/src/Mapillary.js",
"interfaces"
],
coverageProvider: "v8",

4
spec/Bootstrap.ts
View File

@ -2,7 +2,7 @@ import { ComponentService } from "../src/component/ComponentService";
import { MarkerSet } from "../src/component/marker/MarkerSet";
import { Graph } from "../src/graph/Graph";
import { TraversingState } from "../src/state/states/TraversingState";
import { IInterpolator } from "../src/utils/interfaces/IInterpolator";
import { Interpolator } from "../src/state/interfaces/IInterpolator";
type Item = {
lat: number;
@ -39,7 +39,7 @@ class SpatialIndexMock<T extends Item> {
class CoverMock { public activate(): void { /* noop */ } }
class InterpolatorMock implements IInterpolator {
class InterpolatorMock implements Interpolator {
public solve(x: number): number { return x; }
}

14
spec/api/APIWrapper.spec.ts
View File

@ -2,9 +2,9 @@ import { empty as observableEmpty, Observable } from "rxjs";
import { catchError } from "rxjs/operators";
import { APIWrapper } from "../../src/api/APIWrapper";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { ISequence } from "../../src/api/interfaces/ISequence";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { SequenceEnt } from "../../src/api/ents/SequenceEnt";
import { DataProvider } from "../helper/ProviderHelper";
describe("APIWrapperctor", () => {
@ -32,7 +32,7 @@ describe("APIWrapperimageByKeyFill$", () => {
api.imageByKeyFill$([key])
.subscribe(
(result: { [key: string]: IFillNode }): void => {
(result: { [key: string]: SpatialImageEnt }): void => {
expect(result).toBeDefined();
expect(providerSpy.calls.count()).toBe(1);
@ -91,7 +91,7 @@ describe("APIWrapperimageByKeyFull$", () => {
api.imageByKeyFull$([key])
.subscribe(
(result: { [key: string]: IFillNode }): void => {
(result: { [key: string]: SpatialImageEnt }): void => {
expect(result).toBeDefined();
expect(providerSpy.calls.count()).toBe(1);
@ -150,7 +150,7 @@ describe("APIWrapperimagesByH$", () => {
api.imagesByH$(h)
.subscribe(
(result: { [key: string]: { [index: string]: ICoreNode } }): void => {
(result: { [key: string]: { [index: string]: CoreImageEnt } }): void => {
expect(result).toBeDefined();
expect(providerSpy.calls.count()).toBe(1);
@ -209,7 +209,7 @@ describe("APIWrappersequenceByKey$", () => {
api.sequenceByKey$([skey])
.subscribe(
(result: { [key: string]: ISequence }): void => {
(result: { [key: string]: SequenceEnt }): void => {
expect(result).toBeDefined();
expect(providerSpy.calls.count()).toBe(1);

38
spec/api/FalcorDataProvider.spec.ts
View File

@ -1,12 +1,12 @@
import * as pako from "pako";
import * as falcor from "falcor";
import { FalcorDataProvider } from "../../src/api/FalcorDataProvider";
import { IClusterReconstruction } from "../../src/api/interfaces/IClusterReconstruction";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { ISequence } from "../../src/api/interfaces/ISequence";
import { ReconstructionEnt } from "../../src/api/ents/ReconstructionEnt";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { ModelCreator } from "../../src/api/ModelCreator";
import { MapillaryError } from "../../src/error/MapillaryError";
import { SequenceEnt } from "../../src/api/ents/SequenceEnt";
describe("FalcorDataProvider.ctor", () => {
it("should create a data provider", () => {
@ -41,7 +41,7 @@ describe("FalcorDataProvider.getFillImages", () => {
provider.getFillImages([key])
.then(
(result: { [key: string]: IFillNode }): void => {
(result: { [key: string]: SpatialImageEnt }): void => {
expect(result).toBeDefined();
expect(modelSpy.calls.count()).toBe(1);
@ -196,7 +196,7 @@ describe("FalcorDataProvider.getFullImages", () => {
provider.getFullImages([key])
.then(
(result: { [key: string]: IFillNode }): void => {
(result: { [key: string]: SpatialImageEnt }): void => {
expect(result).toBeDefined();
expect(spy.calls.count()).toBe(1);
@ -268,7 +268,7 @@ describe("FalcorDataProvider.getFullImages", () => {
provider.getFullImages([key])
.then(
(result: { [key: string]: IFillNode }): void => { return; },
(result: { [key: string]: SpatialImageEnt }): void => { return; },
(error: Error): void => {
expect(invalidateSpy.calls.count()).toBe(1);
expect(invalidateSpy.calls.first().args.length).toBe(1);
@ -308,7 +308,7 @@ describe("FalcorDataProvider.getCoreImages", () => {
provider.getCoreImages(h)
.then(
(result: { [key: string]: { [index: string]: ICoreNode } }): void => {
(result: { [key: string]: { [index: string]: CoreImageEnt } }): void => {
expect(result).toBeDefined();
expect(spy.calls.count()).toBe(1);
@ -348,7 +348,7 @@ describe("FalcorDataProvider.getCoreImages", () => {
provider.getCoreImages(h)
.then(
(result: { [key: string]: { [index: string]: ICoreNode } }): void => { return; },
(result: { [key: string]: { [index: string]: CoreImageEnt } }): void => { return; },
(error: Error): void => {
expect(invalidateSpy.calls.count()).toBe(1);
expect(invalidateSpy.calls.first().args.length).toBe(1);
@ -386,7 +386,7 @@ describe("FalcorDataProvider.getCoreImages", () => {
provider.getCoreImages(h)
.then(
(result: { [key: string]: { [index: string]: ICoreNode } }): void => {
(result: { [key: string]: { [index: string]: CoreImageEnt } }): void => {
expect(result).toBeDefined();
expect(result[h]).toBeDefined();
@ -423,7 +423,7 @@ describe("FalcorDataProvider.getSequences", () => {
provider.getSequences([skey])
.then(
(result: { [key: string]: ISequence }): void => {
(result: { [key: string]: SequenceEnt }): void => {
expect(result).toBeDefined();
expect(spy.calls.count()).toBe(1);
@ -463,7 +463,7 @@ describe("FalcorDataProvider.getSequences", () => {
provider.getSequences([skey])
.then(
(result: { [key: string]: ISequence }): void => { return; },
(result: { [key: string]: SequenceEnt }): void => { return; },
(error: Error): void => {
expect(invalidateSpy.calls.count()).toBe(1);
expect(invalidateSpy.calls.first().args.length).toBe(1);
@ -504,7 +504,7 @@ describe("FalcorDataProvider.getSequences", () => {
provider.getSequences([skey])
.then(
(result: { [key: string]: ISequence }): void => {
(result: { [key: string]: SequenceEnt }): void => {
expect(result).toBeDefined();
expect(result[skey]).toBeDefined();
expect(result[skey].key).toBe(skey);
@ -542,7 +542,7 @@ describe("FalcorDataProvider.getSequences", () => {
provider.getSequences([skey])
.then(
(result: { [key: string]: ISequence }): void => {
(result: { [key: string]: SequenceEnt }): void => {
expect(result).toBeDefined();
expect(result[skey]).toBeDefined();
expect(result[skey].key).toBe(skey);
@ -579,7 +579,7 @@ describe("FalcorDataProvider.getSequences", () => {
provider.getSequences([skey])
.then(
(result: { [key: string]: ISequence }): void => {
(result: { [key: string]: SequenceEnt }): void => {
expect(result).toBeDefined();
expect(result[skey]).toBeDefined();
expect(result[skey].key).toBe(skey);
@ -763,11 +763,11 @@ describe("FalcorDataProvider.getClusterReconstruction", () => {
provider.getClusterReconstruction("url")
.then(
(r: IClusterReconstruction): void => {
(r: ReconstructionEnt): void => {
expect(r.points).toEqual({});
expect(r.reference_lla.altitude).toBe(1);
expect(r.reference_lla.latitude).toBe(2);
expect(r.reference_lla.longitude).toBe(3);
expect(r.reference.alt).toBe(1);
expect(r.reference.lat).toBe(2);
expect(r.reference.lon).toBe(3);
done();
});

6
spec/api/FalcorDataProviderUrls.spec.ts
View File

@ -1,12 +1,12 @@
import { FalcorDataProviderUrls } from "../../src/api/FalcorDataProvider";
import { IFalcorDataProviderOptions } from "../../src/api/interfaces/IFalcorDataProviderOptions";
import { FalcorDataProviderOptions } from "../../src/api/interfaces/FalcorDataProviderOptions";
describe("DataProviderUrls.ctor", () => {
it("should set all option properties", () => {
const options: IFalcorDataProviderOptions = {
const options: FalcorDataProviderOptions = {
apiHost: "test-api",
clientToken: "ct",
clusterReconstructionHost: "test-cluster",
reconstructionHost: "test-cluster",
imageHost: "test-image",
imageTileHost: "test-image-tile",
meshHost: "test-mesh",

8
spec/api/S2GeometryProvider.spec.ts
View File

@ -1,6 +1,6 @@
import { S2 } from "s2-geometry";
import { ICellCorners } from "../../src/api/interfaces/ICellCorners";
import { ILatLon } from "../../src/api/interfaces/ILatLon";
import { CellCorners } from "../../src/api/interfaces/CellCorners";
import { LatLonEnt } from "../../src/api/ents/LatLonEnt";
import { S2GeometryProvider } from "../../src/api/S2GeometryProvider";
import { MapillaryError } from "../../src/error/MapillaryError";
import { GeoCoords } from "../../src/geo/GeoCoords";
@ -217,7 +217,7 @@ describe("S2GeometryProvider.getCorners", () => {
it("should be correctly placed relative to each other", () => {
const geometry: S2GeometryProvider = new S2GeometryProvider();
const latLons: ILatLon[] = [
const latLons: LatLonEnt[] = [
{ lat: 0, lon: 0 },
{ lat: 45, lon: 0 },
{ lat: 0, lon: 45 },
@ -232,7 +232,7 @@ describe("S2GeometryProvider.getCorners", () => {
for (let latLon of latLons) {
const cellId: string = geometry.latLonToCellId(latLon);
const corners: ICellCorners = geometry.getCorners(cellId);
const corners: CellCorners = geometry.getCorners(cellId);
expect(corners.se.lat).toBeLessThan(corners.ne.lat);
expect(corners.se.lat).toBeLessThan(corners.nw.lat);

14
spec/component/Component.spec.ts
View File

@ -1,16 +1,16 @@
import { skip } from "rxjs/operators";
import { Component } from "../../src/component/Component";
import { IComponentConfiguration } from "../../src/component/interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "../../src/component/interfaces/ComponentConfiguration";
interface ITestConfiguration extends IComponentConfiguration {
interface TestConfiguration extends ComponentConfiguration {
test?: string;
}
class TestComponent extends Component<ITestConfiguration> {
class TestComponent extends Component<TestConfiguration> {
protected _activate(): void { /*noop*/ }
protected _deactivate(): void { /*noop*/ }
protected _getDefaultConfiguration(): ITestConfiguration {
protected _getDefaultConfiguration(): TestConfiguration {
return {};
}
}
@ -29,7 +29,7 @@ describe("Component.configuration$", () => {
component.configuration$
.subscribe(
(configuration: IComponentConfiguration): void => {
(configuration: ComponentConfiguration): void => {
expect(Object.keys(configuration).length).toBe(0);
});
});
@ -40,7 +40,7 @@ describe("Component.configuration$", () => {
component.configuration$.pipe(
skip(1))
.subscribe(
(configuration: ITestConfiguration): void => {
(configuration: TestConfiguration): void => {
expect(Object.keys(configuration).length).toBe(1);
expect(configuration.test).toBe("test");
done();
@ -55,7 +55,7 @@ describe("Component.configuration$", () => {
component.configuration$.pipe(
skip(2))
.subscribe(
(configuration: ITestConfiguration): void => {
(configuration: TestConfiguration): void => {
expect(Object.keys(configuration).length).toBe(1);
expect(configuration.test).toBe("testchanged");
done();

26
spec/component/direction/DirectionDOMRenderer.spec.ts
View File

@ -6,15 +6,15 @@ import { NodeHelper } from "../../helper/NodeHelper";
import { Navigator } from "../../../src/viewer/Navigator";
import { Node } from "../../../src/graph/Node";
import { DirectionDOMRenderer } from "../../../src/component/direction/DirectionDOMRenderer";
import { IDirectionConfiguration } from "../../../src/component/interfaces/IDirectionConfiguration";
import { DirectionConfiguration } from "../../../src/component/interfaces/DirectionConfiguration";
import { RenderCamera } from "../../../src/render/RenderCamera";
import { IFrame } from "../../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../../src/state/interfaces/AnimationFrame";
import { FrameHelper } from "../../helper/FrameHelper";
import { RenderMode } from "../../../src/render/RenderMode";
describe("DirectionDOMRenderer.ctor", () => {
it("should be defined", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -34,7 +34,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should not need render when constructed", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -46,7 +46,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should need render when node is set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -63,7 +63,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should not need render after rendering", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -88,7 +88,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should not need render when setting render camera without node set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -105,7 +105,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should not need render when setting configuration without node set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -120,7 +120,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should not need render when resizing without node set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -134,7 +134,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should need render when setting changed render camera if node is set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -158,7 +158,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
expect(renderer.needsRender).toBe(false);
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Fill);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.state.camera.up.fromArray([0, 0, 1]);
frame.state.camera.lookat.fromArray([1, 1, 0]);
renderCamera.setFrame(frame);
@ -168,7 +168,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should need render when setting changed configuration if node is set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,
@ -198,7 +198,7 @@ describe("DirectionDOMRenderer.needsRender", () => {
});
it("should need render when resizing if node is set", () => {
let configuration: IDirectionConfiguration = {
let configuration: DirectionConfiguration = {
distinguishSequence: false,
maxWidth: 200,
minWidth: 100,

56
spec/component/keyboard/KeyPlayHandler.spec.ts
View File

@ -9,24 +9,24 @@ import { NodeHelper } from "../../helper/NodeHelper";
import { Navigator } from "../../../src/viewer/Navigator";
import { Node } from "../../../src/graph/Node";
import { Component } from "../../../src/component/Component";
import { IComponentConfiguration } from "../../../src/component/interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "../../../src/component/interfaces/ComponentConfiguration";
import { KeyPlayHandler } from "../../../src/component/keyboard/KeyPlayHandler";
import { IEdgeStatus } from "../../../src/graph/interfaces/IEdgeStatus";
import { NavigationEdgeStatus } from "../../../src/graph/interfaces/NavigationEdgeStatus";
import { State } from "../../../src/state/State";
import { Container } from "../../../src/viewer/Container";
import { EdgeDirection } from "../../../src/graph/edge/EdgeDirection";
import { NavigationDirection } from "../../../src/graph/edge/NavigationDirection";
interface ITestConfiguration extends IComponentConfiguration {
interface TestConfiguration extends ComponentConfiguration {
test: boolean;
}
class TestComponent extends Component<ITestConfiguration> {
class TestComponent extends Component<TestConfiguration> {
constructor(name: string, container: Container, navigator: Navigator) {
super(name, container, navigator);
}
protected _activate(): void { /* noop */ }
protected _deactivate(): void { /* noop */ }
protected _getDefaultConfiguration(): ITestConfiguration { return { test: false }; }
protected _getDefaultConfiguration(): TestConfiguration { return { test: false }; }
}
describe("KeyPlayHandler.ctor", () => {
@ -92,12 +92,12 @@ describe("KeyPlayHandler.enable", () => {
it("should not prevent default if modifier key is pressed", () => {
(<Subject<boolean>>navigatorMock.playService.playing$).next(true);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
(<Subject<number>>navigatorMock.playService.speed$).next(0.5);
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
const node: Node = nodeHelper.createNode();
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node);
sequenceEdgesSubject.next({ cached: false, edges: [] });
@ -130,12 +130,12 @@ describe("KeyPlayHandler.enable", () => {
it("should change speed if `>` or `<` is pressed", () => {
(<Subject<boolean>>navigatorMock.playService.playing$).next(true);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
(<Subject<number>>navigatorMock.playService.speed$).next(0.5);
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
const node: Node = nodeHelper.createNode();
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node);
sequenceEdgesSubject.next({ cached: false, edges: [] });
@ -162,12 +162,12 @@ describe("KeyPlayHandler.enable", () => {
it("should change direction when not playing", () => {
(<Subject<boolean>>navigatorMock.playService.playing$).next(true);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
(<Subject<number>>navigatorMock.playService.speed$).next(0.5);
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
const node: Node = nodeHelper.createNode();
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node);
sequenceEdgesSubject.next({ cached: false, edges: [] });
@ -181,18 +181,18 @@ describe("KeyPlayHandler.enable", () => {
expect(setDirectionSpy.calls.count()).toBe(0);
(<Subject<boolean>>navigatorMock.playService.playing$).next(false);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
(<Subject<KeyboardEvent>>containerMock.keyboardService.keyDown$).next(shiftKeyboardEvent);
expect(shiftPreventDefaultSpy.calls.count()).toBe(2);
expect(setDirectionSpy.calls.count()).toBe(1);
expect(setDirectionSpy.calls.argsFor(0)[0]).toBe(EdgeDirection.Prev);
expect(setDirectionSpy.calls.argsFor(0)[0]).toBe(NavigationDirection.Prev);
(<Subject<boolean>>navigatorMock.playService.playing$).next(false);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Prev);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Prev);
(<Subject<KeyboardEvent>>containerMock.keyboardService.keyDown$).next(shiftKeyboardEvent);
expect(shiftPreventDefaultSpy.calls.count()).toBe(3);
expect(setDirectionSpy.calls.count()).toBe(2);
expect(setDirectionSpy.calls.argsFor(1)[0]).toBe(EdgeDirection.Next);
expect(setDirectionSpy.calls.argsFor(1)[0]).toBe(NavigationDirection.Next);
});
it("should play when stopped edge direction exist and stop when playing", () => {
@ -201,13 +201,13 @@ describe("KeyPlayHandler.enable", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
const node: Node = nodeHelper.createNode();
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node);
sequenceEdgesSubject.next({ cached: false, edges: [] });
(<Subject<boolean>>navigatorMock.playService.playing$).next(false);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
(<Subject<number>>navigatorMock.playService.speed$).next(0.5);
const spacebarKeyboardEvent: KeyboardEvent = EventHelper.createKeyboardEvent("keyDown", { key: " " });
@ -217,13 +217,13 @@ describe("KeyPlayHandler.enable", () => {
expect(playSpy.calls.count()).toBe(0);
expect(stopSpy.calls.count()).toBe(0);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
sequenceEdgesSubject.next({
cached: true,
edges: [{
data: { direction: EdgeDirection.Next, worldMotionAzimuth: 0 },
from: node.key,
to: "toKey",
data: { direction: NavigationDirection.Next, worldMotionAzimuth: 0 },
source: node.key,
target: "toKey",
}],
});
(<Subject<KeyboardEvent>>containerMock.keyboardService.keyDown$).next(spacebarKeyboardEvent);
@ -245,13 +245,13 @@ describe("KeyPlayHandler.enable", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Earth);
const node: Node = nodeHelper.createNode();
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node);
sequenceEdgesSubject.next({ cached: false, edges: [] });
(<Subject<boolean>>navigatorMock.playService.playing$).next(false);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
(<Subject<number>>navigatorMock.playService.speed$).next(0.5);
const spacebarKeyboardEvent: KeyboardEvent = EventHelper.createKeyboardEvent("keyDown", { key: " " });
@ -261,13 +261,13 @@ describe("KeyPlayHandler.enable", () => {
expect(playSpy.calls.count()).toBe(0);
expect(stopSpy.calls.count()).toBe(0);
(<Subject<EdgeDirection>>navigatorMock.playService.direction$).next(EdgeDirection.Next);
(<Subject<NavigationDirection>>navigatorMock.playService.direction$).next(NavigationDirection.Next);
sequenceEdgesSubject.next({
cached: true,
edges: [{
data: { direction: EdgeDirection.Next, worldMotionAzimuth: 0 },
from: node.key,
to: "toKey",
data: { direction: NavigationDirection.Next, worldMotionAzimuth: 0 },
source: node.key,
target: "toKey",
}],
});
(<Subject<KeyboardEvent>>containerMock.keyboardService.keyDown$).next(spacebarKeyboardEvent);

8
spec/component/keyboard/KeyZoomHandler.spec.ts
View File

@ -11,24 +11,24 @@ import { TransformHelper } from "../../helper/TransformHelper";
import { Navigator } from "../../../src/viewer/Navigator";
import { Transform } from "../../../src/geo/Transform";
import { Component } from "../../../src/component/Component";
import { IComponentConfiguration } from "../../../src/component/interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "../../../src/component/interfaces/ComponentConfiguration";
import { KeyZoomHandler } from "../../../src/component/keyboard/KeyZoomHandler";
import { ViewportCoords } from "../../../src/geo/ViewportCoords";
import { RenderCamera } from "../../../src/render/RenderCamera";
import { Container } from "../../../src/viewer/Container";
import { RenderMode } from "../../../src/render/RenderMode";
interface ITestConfiguration extends IComponentConfiguration {
interface TestConfiguration extends ComponentConfiguration {
test: boolean;
}
class TestComponent extends Component<ITestConfiguration> {
class TestComponent extends Component<TestConfiguration> {
constructor(name: string, container: Container, navigator: Navigator) {
super(name, container, navigator);
}
protected _activate(): void { /* noop */ }
protected _deactivate(): void { /* noop */ }
protected _getDefaultConfiguration(): ITestConfiguration { return { test: false }; }
protected _getDefaultConfiguration(): TestConfiguration { return { test: false }; }
}
describe("KeyZoomHandler.ctor", () => {

4
spec/component/marker/Marker.spec.ts
View File

@ -1,9 +1,9 @@
import * as THREE from "three";
import { ILatLon } from "../../../src/api/interfaces/ILatLon";
import { LatLonEnt } from "../../../src/api/ents/LatLonEnt";
import { Marker } from "../../../src/component/marker/marker/Marker";
class TestMarker extends Marker {
constructor(id: string, latLon: ILatLon) { super(id, latLon); }
constructor(id: string, latLon: LatLonEnt) { super(id, latLon); }
protected _createGeometry(position: number[]): void {
this._geometry = new THREE.Object3D();
this._geometry.position.fromArray(position);

4
spec/component/marker/MarkerScene.spec.ts
View File

@ -1,10 +1,10 @@
import * as THREE from "three";
import { ILatLon } from "../../../src/api/interfaces/ILatLon";
import { LatLonEnt } from "../../../src/api/ents/LatLonEnt";
import { Marker } from "../../../src/component/marker/marker/Marker";
import { MarkerScene } from "../../../src/component/marker/MarkerScene";
class TestMarker extends Marker {
constructor(id: string, latLon: ILatLon) { super(id, latLon); }
constructor(id: string, latLon: LatLonEnt) { super(id, latLon); }
protected _createGeometry(position: number[]): void { /* noop */ }
protected _disposeGeometry(): void { /* noop */ }
protected _getInteractiveObjects(): THREE.Object3D[] { return []; }

4
spec/component/marker/MarkerSet.spec.ts
View File

@ -3,12 +3,12 @@ bootstrap();
import { first } from "rxjs/operators";
import { Subscription } from "rxjs";
import { ILatLon } from "../../../src/api/interfaces/ILatLon";
import { LatLonEnt } from "../../../src/api/ents/LatLonEnt";
import { Marker } from "../../../src/component/marker/marker/Marker";
import { MarkerSet } from "../../../src/component/marker/MarkerSet";
class TestMarker extends Marker {
constructor(id: string, latLon: ILatLon) { super(id, latLon); }
constructor(id: string, latLon: LatLonEnt) { super(id, latLon); }
protected _createGeometry(position: number[]): void { /* noop */ }
protected _disposeGeometry(): void { /* noop */ }
protected _getInteractiveObjects(): THREE.Object3D[] { return []; }

18
spec/component/mouse/DragPanHandler.spec.ts
View File

@ -17,7 +17,7 @@ import { DragPanHandler } from "../../../src/component/mouse/DragPanHandler";
import { Spatial } from "../../../src/geo/Spatial";
import { ViewportCoords } from "../../../src/geo/ViewportCoords";
import { RenderCamera } from "../../../src/render/RenderCamera";
import { IFrame } from "../../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../../src/state/interfaces/AnimationFrame";
import { Container } from "../../../src/viewer/Container";
import { RenderMode } from "../../../src/render/RenderMode";
@ -219,8 +219,8 @@ describe("DragPanHandler.enable", () => {
testComponent.activate();
handler.enable();
const frame: IFrame = new FrameHelper().createFrame();
(<Subject<IFrame>>navigatorMock.stateService.currentState$).next(frame);
const frame: AnimationFrame = new FrameHelper().createFrame();
(<Subject<AnimationFrame>>navigatorMock.stateService.currentState$).next(frame);
(<Subject<[GraphNode, Transform, number][]>>navigatorMock.panService.panNodes$).next([]);
@ -257,8 +257,8 @@ describe("DragPanHandler.enable", () => {
testComponent.activate();
handler.enable();
const frame: IFrame = new FrameHelper().createFrame();
(<Subject<IFrame>>navigatorMock.stateService.currentState$).next(frame);
const frame: AnimationFrame = new FrameHelper().createFrame();
(<Subject<AnimationFrame>>navigatorMock.stateService.currentState$).next(frame);
(<Subject<[GraphNode, Transform, number][]>>navigatorMock.panService.panNodes$).next([]);
@ -296,8 +296,8 @@ describe("DragPanHandler.enable", () => {
testComponent.activate();
handler.enable();
const frame: IFrame = new FrameHelper().createFrame();
(<Subject<IFrame>>navigatorMock.stateService.currentState$).next(frame);
const frame: AnimationFrame = new FrameHelper().createFrame();
(<Subject<AnimationFrame>>navigatorMock.stateService.currentState$).next(frame);
(<Subject<[GraphNode, Transform, number][]>>navigatorMock.panService.panNodes$).next([]);
@ -336,8 +336,8 @@ describe("DragPanHandler.enable", () => {
testComponent.activate();
handler.enable();
const frame: IFrame = new FrameHelper().createFrame();
(<Subject<IFrame>>navigatorMock.stateService.currentState$).next(frame);
const frame: AnimationFrame = new FrameHelper().createFrame();
(<Subject<AnimationFrame>>navigatorMock.stateService.currentState$).next(frame);
(<Subject<[GraphNode, Transform, number][]>>navigatorMock.panService.panNodes$).next([]);

6
spec/component/popup/Popup.spec.ts
View File

@ -1,5 +1,5 @@
import { take } from "rxjs/operators";
import { IPopupOffset } from "../../../src/component/popup/interfaces/IPopupOffset";
import { PopupOffset } from "../../../src/component/popup/interfaces/PopupOffset";
import { Popup } from "../../../src/component/popup/popup/Popup";
import { ViewportCoords } from "../../../src/geo/ViewportCoords";
import { RenderCamera } from "../../../src/render/RenderCamera";
@ -519,7 +519,7 @@ describe("Popup.offset", () => {
const viewportCoords: ViewportCoords = new ViewportCoords();
spyOn(viewportCoords, "basicToCanvasSafe").and.returnValue([40, 60]);
const offset: IPopupOffset = {
const offset: PopupOffset = {
bottom: [0, 1],
bottomLeft: [2, 3],
bottomRight: [4, 5],
@ -548,7 +548,7 @@ describe("Popup.offset", () => {
const viewportCoords: ViewportCoords = new ViewportCoords();
spyOn(viewportCoords, "basicToCanvasSafe").and.returnValue([40, 60]);
const offset: IPopupOffset = {
const offset: PopupOffset = {
bottom: [-0, -1],
bottomLeft: [-2, -3],
bottomRight: [-4, -5],

10
spec/component/popup/PopupComponent.spec.ts
View File

@ -7,7 +7,7 @@ import { ContainerMockCreator } from "../../helper/ContainerMockCreator";
import { NavigatorMockCreator } from "../../helper/NavigatorMockCreator";
import { Popup } from "../../../src/component/popup/popup/Popup";
import { PopupComponent } from "../../../src/component/popup/PopupComponent";
import { ISize } from "../../../src/render/interfaces/ISize";
import { ViewportSize } from "../../../src/render/interfaces/ViewportSize";
import { RenderCamera } from "../../../src/render/RenderCamera";
import { Container } from "../../../src/viewer/Container";
@ -287,7 +287,7 @@ describe("PopupComponent.updateAdded", () => {
popupComponent.activate();
(<Subject<RenderCamera>>containerMock.renderService.renderCamera$).next(null);
(<Subject<ISize>>containerMock.renderService.size$).next(null);
(<Subject<ViewportSize>>containerMock.renderService.size$).next(null);
(<Subject<Transform>>navigatorMock.stateService.currentTransform$).next(null);
popupComponent.add([popup]);
@ -313,7 +313,7 @@ describe("PopupComponent.updateAdded", () => {
popupComponent.activate();
(<Subject<RenderCamera>>containerMock.renderService.renderCamera$).next(null);
(<Subject<ISize>>containerMock.renderService.size$).next(null);
(<Subject<ViewportSize>>containerMock.renderService.size$).next(null);
(<Subject<Transform>>navigatorMock.stateService.currentTransform$).next(null);
popupComponent.add([popup]);
@ -345,7 +345,7 @@ describe("PopupComponent.updateAll", () => {
popupComponent.activate();
(<Subject<RenderCamera>>containerMock.renderService.renderCamera$).next(null);
(<Subject<ISize>>containerMock.renderService.size$).next(null);
(<Subject<ViewportSize>>containerMock.renderService.size$).next(null);
(<Subject<Transform>>navigatorMock.stateService.currentTransform$).next(null);
expect(updateSpy.calls.count()).toBe(1);
@ -373,7 +373,7 @@ describe("PopupComponent.updateAll", () => {
popupComponent.deactivate();
(<Subject<RenderCamera>>containerMock.renderService.renderCamera$).next(null);
(<Subject<ISize>>containerMock.renderService.size$).next(null);
(<Subject<ViewportSize>>containerMock.renderService.size$).next(null);
(<Subject<Transform>>navigatorMock.stateService.currentTransform$).next(null);
expect(updateSpy.calls.count()).toBe(0);

30
spec/component/sequence/SequenceComponent.spec.ts
View File

@ -11,9 +11,9 @@ import { Node } from "../../../src/graph/Node";
import { SequenceComponent } from "../../../src/component/sequence/SequenceComponent";
import { SequenceDOMRenderer } from "../../../src/component/sequence/SequenceDOMRenderer";
import { GraphMode } from "../../../src/graph/GraphMode";
import { IEdgeStatus } from "../../../src/graph/interfaces/IEdgeStatus";
import { NavigationEdgeStatus } from "../../../src/graph/interfaces/NavigationEdgeStatus";
import { Sequence } from "../../../src/graph/Sequence";
import { ISize } from "../../../src/render/interfaces/ISize";
import { ViewportSize } from "../../../src/render/interfaces/ViewportSize";
import { State } from "../../../src/state/State";
import { Container } from "../../../src/viewer/Container";
@ -132,7 +132,7 @@ describe("SequenceComponent.activate", () => {
const node1: Node = nodeHelper.createNode();
mockCreator.mockProperty(node1, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node1, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node1, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node1, "key", "nodeKey1");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node1);
@ -141,7 +141,7 @@ describe("SequenceComponent.activate", () => {
const node2: Node = nodeHelper.createNode();
mockCreator.mockProperty(node2, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node2, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node2, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node2, "key", "nodeKey2");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node2);
@ -150,7 +150,7 @@ describe("SequenceComponent.activate", () => {
const node3: Node = nodeHelper.createNode();
mockCreator.mockProperty(node3, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node3, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node3, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node3, "key", "nodeKey2");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node3);
@ -171,7 +171,7 @@ describe("SequenceComponent.activate", () => {
const node1: Node = nodeHelper.createNode();
mockCreator.mockProperty(node1, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node1, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node1, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node1, "key", "nodeKey1");
mockCreator.mockProperty(node1, "sequenceKey", "sequenceKey1");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node1);
@ -181,7 +181,7 @@ describe("SequenceComponent.activate", () => {
const node2: Node = nodeHelper.createNode();
mockCreator.mockProperty(node2, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node2, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node2, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node2, "key", "nodeKey2");
mockCreator.mockProperty(node2, "sequenceKey", "sequenceKey1");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node2);
@ -190,7 +190,7 @@ describe("SequenceComponent.activate", () => {
const node3: Node = nodeHelper.createNode();
mockCreator.mockProperty(node3, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node3, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node3, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node3, "key", "nodeKey3");
mockCreator.mockProperty(node3, "sequenceKey", "sequenceKey2");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node3);
@ -215,7 +215,7 @@ describe("SequenceComponent.activate", () => {
const node1: Node = nodeHelper.createNode();
mockCreator.mockProperty(node1, "spatialEdges", { cached: false, edges: [] });
mockCreator.mockProperty(node1, "sequenceEdges$", new Subject<IEdgeStatus>());
mockCreator.mockProperty(node1, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
mockCreator.mockProperty(node1, "key", "nodeKey1");
mockCreator.mockProperty(node1, "sequenceKey", "sequenceKey1");
(<Subject<Node>>navigatorMock.stateService.currentNode$).next(node1);
@ -270,7 +270,7 @@ describe("SequenceComponent.activate", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
(<Subject<number>>navigatorMock.playService.speed$).next(1);
(<Subject<ISize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
(<Subject<ViewportSize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
const node1: Node = nodeHelper.createNode();
mockCreator.mockProperty(node1, "spatialEdges", { cached: false, edges: [] });
@ -303,7 +303,7 @@ describe("SequenceComponent.activate", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
(<Subject<number>>navigatorMock.playService.speed$).next(1);
(<Subject<ISize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
(<Subject<ViewportSize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
const sequenceKey1: string = "sequenceKey1";
const nodeKey1: string = "nodeKey1";
@ -343,7 +343,7 @@ describe("SequenceComponent.activate", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
(<Subject<number>>navigatorMock.playService.speed$).next(1);
(<Subject<ISize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
(<Subject<ViewportSize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
const sequenceKey1: string = "sequenceKey1";
const nodeKey1: string = "nodeKey1";
@ -397,7 +397,7 @@ describe("SequenceComponent.activate", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
(<Subject<number>>navigatorMock.playService.speed$).next(1);
(<Subject<ISize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
(<Subject<ViewportSize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
const sequenceKey1: string = "sequenceKey1";
const sequenceKey2: string = "sequenceKey2";
@ -463,7 +463,7 @@ describe("SequenceComponent.activate", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
(<Subject<number>>navigatorMock.playService.speed$).next(1);
(<Subject<ISize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
(<Subject<ViewportSize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
const sequenceKey1: string = "sequenceKey1";
const nodeKey1: string = "nodeKey1";
@ -513,7 +513,7 @@ describe("SequenceComponent.activate", () => {
(<Subject<State>>navigatorMock.stateService.state$).next(State.Traversing);
(<Subject<number>>navigatorMock.playService.speed$).next(1);
(<Subject<ISize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
(<Subject<ViewportSize>>containerMock.renderService.size$).next({ height: 1, width: 1 });
const sequenceKey1: string = "sequenceKey1";
const nodeKey1: string = "nodeKey1";

16
spec/component/spatialData/SpatialDataCache.spec.ts
View File

@ -3,7 +3,7 @@ import { Subject } from "rxjs";
import { Node } from "../../../src/graph/Node";
import { FalcorDataProvider } from "../../../src/api/FalcorDataProvider";
import { GeohashGeometryProvider } from "../../../src/api/GeohashGeometryProvider";
import { IClusterReconstruction } from "../../../src/api/interfaces/IClusterReconstruction";
import { ReconstructionEnt } from "../../../src/api/ents/ReconstructionEnt";
import { SpatialDataCache } from "../../../src/component/spatialdata/SpatialDataCache";
import { GraphService } from "../../../src/graph/GraphService";
import { GraphServiceMockCreator } from "../../helper/GraphServiceMockCreator";
@ -172,7 +172,7 @@ describe("SpatialDataCache.cacheReconstructions$", () => {
let emitCount: number = 0;
cache.cacheClusterReconstructions$(hash)
.subscribe(
(r: IClusterReconstruction): void => {
(r: ReconstructionEnt): void => {
expect(r.key).toBe(node.clusterKey);
emitCount++;
},
@ -263,7 +263,7 @@ describe("SpatialDataCache.cacheReconstructions$", () => {
let resolver: Function;
const promise: any = {
then: (resolve: (value: IClusterReconstruction) => void): void => {
then: (resolve: (value: ReconstructionEnt) => void): void => {
resolver = resolve;
},
};
@ -402,12 +402,12 @@ describe("SpatialDataCache.updateCell$", () => {
});
describe("SpatialDataCache.updateReconstructions$", () => {
const createCluster = (key: string): IClusterReconstruction => {
const createCluster = (key: string): ReconstructionEnt => {
return {
cameras: {},
key,
points: {},
reference_lla: { latitude: 0, longitude: 0, altitude: 0 },
reference: { lat: 0, lon: 0, alt: 0 },
shots: {},
}
}
@ -418,7 +418,7 @@ describe("SpatialDataCache.updateReconstructions$", () => {
{ clientToken: "cid" }, geometryProvider);
spyOn(dataProvider, "getClusterReconstruction").and
.returnValue(
new Promise<IClusterReconstruction>(() => { /* noop */ }));
new Promise<ReconstructionEnt>(() => { /* noop */ }));
const graphService = new GraphServiceMockCreator().create();
const cache = new SpatialDataCache(graphService, dataProvider);
@ -432,7 +432,7 @@ describe("SpatialDataCache.updateReconstructions$", () => {
let resolver: Function;
const promise: any = {
then: (resolve: (value: IClusterReconstruction) => void): void => {
then: (resolve: (value: ReconstructionEnt) => void): void => {
resolver = resolve;
},
};
@ -472,7 +472,7 @@ describe("SpatialDataCache.updateReconstructions$", () => {
let resolver: Function;
const promise: any = {
then: (resolve: (value: IClusterReconstruction) => void): void => {
then: (resolve: (value: ReconstructionEnt) => void): void => {
resolver = resolve;
},
};

6
spec/component/tag/CreateHandlerBase.spec.ts
View File

@ -3,7 +3,7 @@ import { Navigator } from "../../../src/viewer/Navigator";
import { ContainerMockCreator } from "../../helper/ContainerMockCreator";
import { NavigatorMockCreator } from "../../helper/NavigatorMockCreator";
import { Component } from "../../../src/component/Component";
import { ITagConfiguration } from "../../../src/component/interfaces/ITagConfiguration";
import { TagConfiguration } from "../../../src/component/interfaces/TagConfiguration";
import { CreateHandlerBase } from "../../../src/component/tag/handlers/CreateHandlerBase";
import { TagCreator } from "../../../src/component/tag/TagCreator";
import { ViewportCoords } from "../../../src/geo/ViewportCoords";
@ -19,10 +19,10 @@ class CreateTestHandler extends CreateHandlerBase {
protected _getNameExtension(): string { return "create-test"; }
}
class TestComponent extends Component<ITagConfiguration> {
class TestComponent extends Component<TagConfiguration> {
protected _activate(): void { /*noop*/ }
protected _deactivate(): void { /*noop*/ }
protected _getDefaultConfiguration(): ITagConfiguration { return {}; }
protected _getDefaultConfiguration(): TagConfiguration { return {}; }
}
describe("CreateHandlerBase.ctor", () => {

6
spec/component/tag/CreatePointHandler.spec.ts
View File

@ -5,7 +5,7 @@ import { NavigatorMockCreator } from "../../helper/NavigatorMockCreator";
import { Navigator } from "../../../src/viewer/Navigator";
import { Component } from "../../../src/component/Component";
import { ITagConfiguration } from "../../../src/component/interfaces/ITagConfiguration";
import { TagConfiguration } from "../../../src/component/interfaces/TagConfiguration";
import { PointGeometry } from "../../../src/component/tag/geometry/PointGeometry";
import { CreatePointHandler } from "../../../src/component/tag/handlers/CreatePointHandler";
import { TagCreator } from "../../../src/component/tag/TagCreator";
@ -13,10 +13,10 @@ import { ViewportCoords } from "../../../src/geo/ViewportCoords";
import { Container } from "../../../src/viewer/Container";
import { Geometry } from "../../../src/component/tag/geometry/Geometry";
class TestComponent extends Component<ITagConfiguration> {
class TestComponent extends Component<TagConfiguration> {
protected _activate(): void { /*noop*/ }
protected _deactivate(): void { /*noop*/ }
protected _getDefaultConfiguration(): ITagConfiguration { return {}; }
protected _getDefaultConfiguration(): TagConfiguration { return {}; }
}
describe("CreatePointHandler.ctor", () => {

4
spec/component/tag/TagScene.spec.ts
View File

@ -4,7 +4,7 @@ import { RectGeometry } from "../../../src/component/tag/geometry/RectGeometry";
import { RenderTag } from "../../../src/component/tag/tag/RenderTag";
import { Tag } from "../../../src/component/tag/tag/Tag";
import { TagScene } from "../../../src/component/tag/TagScene";
import { ISize } from "../../../src/render/interfaces/ISize";
import { ViewportSize } from "../../../src/render/interfaces/ViewportSize";
import { ISpriteAtlas } from "../../../src/viewer/interfaces/ISpriteAtlas";
describe("TagScene.ctor", () => {
@ -36,7 +36,7 @@ class TestTag extends Tag {
class TestRenderTag extends RenderTag<Tag> {
public dispose(): void { /*noop*/ }
public getDOMObjects(atlas: ISpriteAtlas, camera: THREE.Camera, size: ISize): vd.VNode[] { return []; }
public getDOMObjects(atlas: ISpriteAtlas, camera: THREE.Camera, size: ViewportSize): vd.VNode[] { return []; }
public getGLObjects(): THREE.Object3D[] { return []; }
public getRetrievableObjects(): THREE.Object3D[] { return []; }
}

12
spec/component/utils/HandlerBase.spec.ts
View File

@ -4,27 +4,27 @@ import { NavigatorMockCreator } from "../../helper/NavigatorMockCreator";
import { Navigator } from "../../../src/viewer/Navigator";
import { Component } from "../../../src/component/Component";
import { IComponentConfiguration } from "../../../src/component/interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "../../../src/component/interfaces/ComponentConfiguration";
import { HandlerBase } from "../../../src/component/utils/HandlerBase";
import { Container } from "../../../src/viewer/Container";
interface ITestConfiguration extends IComponentConfiguration {
interface TestConfiguration extends ComponentConfiguration {
test: boolean;
}
class TestComponent extends Component<ITestConfiguration> {
class TestComponent extends Component<TestConfiguration> {
constructor(name: string, container: Container, navigator: Navigator) {
super(name, container, navigator);
}
protected _activate(): void { /* noop */ }
protected _deactivate(): void { /* noop */ }
protected _getDefaultConfiguration(): ITestConfiguration { return { test: false }; }
protected _getDefaultConfiguration(): TestConfiguration { return { test: false }; }
}
class TestHandler extends HandlerBase<ITestConfiguration> {
class TestHandler extends HandlerBase<TestConfiguration> {
protected _disable(): void { /* noop */ }
protected _enable(): void { /* noop */ }
protected _getConfiguration(enable: boolean): ITestConfiguration { return { test: enable }; }
protected _getConfiguration(enable: boolean): TestConfiguration { return { test: enable }; }
}
describe("HandlerBase.ctor", () => {

54
spec/geo/GeoCoords.spec.ts
View File

@ -1,5 +1,5 @@
import { GeoCoords } from "../../src/geo/GeoCoords";
import { ILatLonAlt } from "../../src/geo/interfaces/ILatLonAlt";
import { LatLonAltEnt } from "../../src/api/ents/LatLonAltEnt";
let precision: number = 8;
@ -14,7 +14,7 @@ describe("GeoCoords.geodeticToEcef", () => {
});
it("should convert Equator - Greenwich to X axis value", () => {
let position: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let position: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let ecef: number[] = geoCoords.geodeticToEcef(position.lat, position.lon, position.alt);
@ -24,7 +24,7 @@ describe("GeoCoords.geodeticToEcef", () => {
});
it("should convert positions on Equator to WGS84 a distance", () => {
let position1: ILatLonAlt = { alt: 0, lat: 0, lon: 90 };
let position1: LatLonAltEnt = { alt: 0, lat: 0, lon: 90 };
let ecef1: number[] = geoCoords.geodeticToEcef(position1.lat, position1.lon, position1.alt);
@ -32,7 +32,7 @@ describe("GeoCoords.geodeticToEcef", () => {
expect(ecef1[1]).toBeCloseTo(wgs84a, precision);
expect(ecef1[2]).toBeCloseTo(0, precision);
let position2: ILatLonAlt = { alt: 0, lat: 0, lon: 180 };
let position2: LatLonAltEnt = { alt: 0, lat: 0, lon: 180 };
let ecef2: number[] = geoCoords.geodeticToEcef(position2.lat, position2.lon, position2.alt);
@ -40,7 +40,7 @@ describe("GeoCoords.geodeticToEcef", () => {
expect(ecef2[1]).toBeCloseTo(0, precision);
expect(ecef2[2]).toBeCloseTo(0, precision);
let position3: ILatLonAlt = { alt: 0, lat: 0, lon: -90 };
let position3: LatLonAltEnt = { alt: 0, lat: 0, lon: -90 };
let ecef3: number[] = geoCoords.geodeticToEcef(position3.lat, position3.lon, position3.alt);
@ -50,7 +50,7 @@ describe("GeoCoords.geodeticToEcef", () => {
});
it("should convert random Equator postion correctly", () => {
let position: ILatLonAlt = { alt: 0, lat: 0, lon: 35.6589 };
let position: LatLonAltEnt = { alt: 0, lat: 0, lon: 35.6589 };
let ecef: number[] = geoCoords.geodeticToEcef(position.lat, position.lon, position.alt);
@ -60,7 +60,7 @@ describe("GeoCoords.geodeticToEcef", () => {
});
it("should convert value with altitude correctly", () => {
let position: ILatLonAlt = { alt: 452.43537987, lat: 0, lon: 0 };
let position: LatLonAltEnt = { alt: 452.43537987, lat: 0, lon: 0 };
let ecef: number[] = geoCoords.geodeticToEcef(position.lat, position.lon, position.alt);
@ -70,7 +70,7 @@ describe("GeoCoords.geodeticToEcef", () => {
});
it("should convert North Pole value correctly", () => {
let position: ILatLonAlt = { alt: 0, lat: 90, lon: 0 };
let position: LatLonAltEnt = { alt: 0, lat: 90, lon: 0 };
let ecef: number[] = geoCoords.geodeticToEcef(position.lat, position.lon, position.alt);
@ -80,7 +80,7 @@ describe("GeoCoords.geodeticToEcef", () => {
});
it("should convert back and forth between WGS84 and ECEF and correspond", () => {
let position: ILatLonAlt = { alt: 25.34543543, lat: 12.469889789, lon: -33.34589734 };
let position: LatLonAltEnt = { alt: 25.34543543, lat: 12.469889789, lon: -33.34589734 };
let ecef: number[] = geoCoords.geodeticToEcef(position.lat, position.lon, position.alt);
let rePosition: number[] = geoCoords.ecefToGeodetic(ecef[0], ecef[1], ecef[2]);
@ -166,7 +166,7 @@ describe("GeoCoords.ecefToEnu", () => {
});
it("should convert to ECEF position corresponding to geodetic to ENU at origin", () => {
let ref: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let ref: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let ecef: number[] = [wgs84a, 0, 0];
let enu: number[] = geoCoords.ecefToEnu(ecef[0], ecef[1], ecef[2], ref.lat, ref.lon, ref.alt);
@ -177,7 +177,7 @@ describe("GeoCoords.ecefToEnu", () => {
});
it("should convert positions on Equator to ENU positions at origin", () => {
let ref1: ILatLonAlt = { alt: 0, lat: 0, lon: 90 };
let ref1: LatLonAltEnt = { alt: 0, lat: 0, lon: 90 };
let ecef1: number[] = [0, wgs84a, 0];
let enu1: number[] = geoCoords.ecefToEnu(ecef1[0], ecef1[1], ecef1[2], ref1.lat, ref1.lon, ref1.alt);
@ -186,7 +186,7 @@ describe("GeoCoords.ecefToEnu", () => {
expect(enu1[1]).toBeCloseTo(0, precision);
expect(enu1[2]).toBeCloseTo(0, precision);
let ref2: ILatLonAlt = { alt: 0, lat: 0, lon: 180 };
let ref2: LatLonAltEnt = { alt: 0, lat: 0, lon: 180 };
let ecef2: number[] = [-wgs84a, 0, 0];
let enu2: number[] = geoCoords.ecefToEnu(ecef2[0], ecef2[1], ecef2[2], ref2.lat, ref2.lon, ref2.alt);
@ -195,7 +195,7 @@ describe("GeoCoords.ecefToEnu", () => {
expect(enu2[1]).toBeCloseTo(0, precision);
expect(enu2[2]).toBeCloseTo(0, precision);
let ref3: ILatLonAlt = { alt: 0, lat: 0, lon: -90 };
let ref3: LatLonAltEnt = { alt: 0, lat: 0, lon: -90 };
let ecef3: number[] = [0, -wgs84a, 0];
let enu3: number[] = geoCoords.ecefToEnu(ecef3[0], ecef3[1], ecef3[2], ref3.lat, ref3.lon, ref3.alt);
@ -206,7 +206,7 @@ describe("GeoCoords.ecefToEnu", () => {
});
it("should convert ECEF position with altitude to ENU with correct z-value", () => {
let ref: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let ref: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let altitude: number = 5.38973284;
let ecef: number[] = [wgs84a + altitude, 0, 0];
@ -219,7 +219,7 @@ describe("GeoCoords.ecefToEnu", () => {
});
it("should convert ECEF position with translation to correct ENU position", () => {
let ref: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let ref: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let translation: number = 1.38973284;
let ecef: number[] = [wgs84a, translation, translation];
@ -240,7 +240,7 @@ describe("GeoCoords.enuToEcef", () => {
});
it("should convert to ENU position at origin to ECEF X-value", () => {
let ref: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let ref: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let enu: number[] = [0, 0, 0];
let ecef: number[] = geoCoords.enuToEcef(enu[0], enu[1], enu[2], ref.lat, ref.lon, ref.alt);
@ -251,7 +251,7 @@ describe("GeoCoords.enuToEcef", () => {
});
it("should convert to ENU position with up value to ECEF X-value", () => {
let ref: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let ref: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let enu: number[] = [0, 0, 7.3823847239847];
let ecef: number[] = geoCoords.enuToEcef(enu[0], enu[1], enu[2], ref.lat, ref.lon, ref.alt);
@ -262,7 +262,7 @@ describe("GeoCoords.enuToEcef", () => {
});
it("should convert ECEF position with translation to correct ENU position", () => {
let ref: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let ref: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let translation: number = -2.34875843758493;
let enu: number[] = [translation, translation, 0];
@ -283,8 +283,8 @@ describe("GeoCoords.geodeticToEnu", () => {
});
it("should convert to ENU position at origin when lla is at reference", () => {
let ref: ILatLonAlt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let lla: ILatLonAlt = { alt: ref.alt, lat: ref.lat, lon: ref.lon };
let ref: LatLonAltEnt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let lla: LatLonAltEnt = { alt: ref.alt, lat: ref.lat, lon: ref.lon };
let enu: number[] = geoCoords.geodeticToEnu(lla.lat, lla.lon, lla.alt, ref.lat, ref.lon, ref.alt);
@ -294,10 +294,10 @@ describe("GeoCoords.geodeticToEnu", () => {
});
it("should convert to ENU z value corresponding to diff with reference lla", () => {
let ref: ILatLonAlt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let ref: LatLonAltEnt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let altTranslation: number = 4.4556433242;
let lla: ILatLonAlt = { alt: ref.alt + altTranslation, lat: ref.lat, lon: ref.lon };
let lla: LatLonAltEnt = { alt: ref.alt + altTranslation, lat: ref.lat, lon: ref.lon };
let enu: number[] = geoCoords.geodeticToEnu(lla.lat, lla.lon, lla.alt, ref.lat, ref.lon, ref.alt);
@ -307,8 +307,8 @@ describe("GeoCoords.geodeticToEnu", () => {
});
it("should convert back and forth between WGS84 and ENU and correspond", () => {
let ref: ILatLonAlt = { alt: -3.645563324, lat: 13.469889789, lon: 92.376689734 };
let lla: ILatLonAlt = { alt: ref.alt + 20, lat: ref.lat - 0.01, lon: ref.lon + 0.01 };
let ref: LatLonAltEnt = { alt: -3.645563324, lat: 13.469889789, lon: 92.376689734 };
let lla: LatLonAltEnt = { alt: ref.alt + 20, lat: ref.lat - 0.01, lon: ref.lon + 0.01 };
let enu: number[] = geoCoords.geodeticToEnu(lla.lat, lla.lon, lla.alt, ref.lat, ref.lon, ref.alt);
let reLla: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], ref.lat, ref.lon, ref.alt);
@ -327,7 +327,7 @@ describe("GeoCoords.enuToGeodetic", () => {
});
it("should convert to reference WGS84 when ENU position is origin", () => {
let ref: ILatLonAlt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let ref: LatLonAltEnt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let enu: number[] = [0, 0, 0];
let lla: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], ref.lat, ref.lon, ref.alt);
@ -338,7 +338,7 @@ describe("GeoCoords.enuToGeodetic", () => {
});
it("should convert to reference WGS84 at correct altitude when ENU position has non zero z value", () => {
let ref: ILatLonAlt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let ref: LatLonAltEnt = { alt: 12.523892390, lat: 12.9450823, lon: 133.34589734 };
let enu: number[] = [0, 0, 5.234872384927];
let lla: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], ref.lat, ref.lon, ref.alt);
@ -349,7 +349,7 @@ describe("GeoCoords.enuToGeodetic", () => {
});
it("should convert back and forth between ENU and WGS84 and correspond", () => {
let ref: ILatLonAlt = { alt: 7.34543543, lat: -52.469889789, lon: -113.34589734 };
let ref: LatLonAltEnt = { alt: 7.34543543, lat: -52.469889789, lon: -113.34589734 };
let enu: number[] = [12.435534543, -55.34242121, 5.98023489];
let lla: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], ref.lat, ref.lon, ref.alt);

56
spec/geo/Transform.spec.ts
View File

@ -5,7 +5,7 @@ import { GeoHelper } from "../helper/GeoHelper";
import { Node } from "../../src/graph/Node";
import { Transform } from "../../src/geo/Transform";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
describe("Transform.rt", () => {
@ -22,7 +22,7 @@ describe("Transform.rt", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -64,7 +64,7 @@ describe("Transform.rt", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -106,7 +106,7 @@ describe("Transform.rt", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -148,7 +148,7 @@ describe("Transform.rt", () => {
let t: number[] = [10, 20, 30];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -200,7 +200,7 @@ describe("Transform.srt", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.atomic_scale = 1;
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -243,7 +243,7 @@ describe("Transform.srt", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.atomic_scale = 3;
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -286,7 +286,7 @@ describe("Transform.srt", () => {
let t: number[] = [-10, 20, -30];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.atomic_scale = 0.5;
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -338,7 +338,7 @@ describe("Transform.basicWidth", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.width = width;
fillNode.orientation = 1;
node.makeFull(fillNode);
@ -362,7 +362,7 @@ describe("Transform.basicWidth", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.height = height;
fillNode.orientation = 5;
node.makeFull(fillNode);
@ -394,7 +394,7 @@ describe("Transform.basicHeight", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.height = height;
fillNode.orientation = 1;
node.makeFull(fillNode);
@ -418,7 +418,7 @@ describe("Transform.basicHeight", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.width = width;
fillNode.orientation = 5;
node.makeFull(fillNode);
@ -449,7 +449,7 @@ describe("Transform.width", () => {
let node: Node = new Node(helper.createCoreNode());
const fillNode: IFillNode = helper.createFillNode();
const fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.width = 0;
node.makeFull(fillNode);
@ -472,7 +472,7 @@ describe("Transform.width", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.width = width;
node.makeFull(fillNode);
@ -501,7 +501,7 @@ describe("Transform.height", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.height = -1;
fillNode.orientation = 1;
node.makeFull(fillNode);
@ -525,7 +525,7 @@ describe("Transform.height", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.height = height;
fillNode.orientation = 1;
node.makeFull(fillNode);
@ -555,7 +555,7 @@ describe("Transform.focal", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
let transform: Transform = new Transform(
@ -577,7 +577,7 @@ describe("Transform.focal", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.cfocal = focal;
node.makeFull(fillNode);
@ -606,7 +606,7 @@ describe("Transform.orientation", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
let transform: Transform = new Transform(
@ -628,7 +628,7 @@ describe("Transform.orientation", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.orientation = 3;
node.makeFull(fillNode);
@ -678,7 +678,7 @@ describe("Transform.scale", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.atomic_scale = 0.4;
node.makeFull(fillNode);
@ -759,7 +759,7 @@ describe("Transform.unprojectSfM", () => {
let t: number[] = geoHelper.getTranslation(r, C);
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -809,7 +809,7 @@ describe("Transform.unprojectSfM", () => {
let t: number[] = [0, 0, 0];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = r;
node.makeFull(fillNode);
@ -899,7 +899,7 @@ describe("Transform.unprojectBasic", () => {
let t: number[] = [10, 20, 30];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = [0.1, 0.2, 0.3];
fillNode.orientation = 1;
node.makeFull(fillNode);
@ -928,7 +928,7 @@ describe("Transform.unprojectBasic", () => {
let t: number[] = [10, 20, 30];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = [0.1, 0.2, 0.3];
fillNode.orientation = 3;
node.makeFull(fillNode);
@ -957,7 +957,7 @@ describe("Transform.unprojectBasic", () => {
let t: number[] = [10, 20, 30];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = [0.1, 0.2, 0.3];
fillNode.orientation = 6;
node.makeFull(fillNode);
@ -986,7 +986,7 @@ describe("Transform.unprojectBasic", () => {
let t: number[] = [10, 20, 30];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = [0.1, 0.2, 0.3];
fillNode.orientation = 8;
node.makeFull(fillNode);
@ -1015,7 +1015,7 @@ describe("Transform.unprojectBasic", () => {
let t: number[] = [5, 15, 2];
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.c_rotation = [0.5, -0.2, 0.3];
fillNode.camera_projection_type = "equirectangular";

214
spec/graph/FilterCreator.spec.ts
View File

@ -1,7 +1,7 @@
import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { FilterCreator, FilterFunction } from "../../src/graph/FilterCreator";
/**
@ -28,10 +28,10 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "skey";
let filter: FilterFunction = creator.createFilter(["==", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = sequenceKey;
coreNode2.sequence_key = sequenceKey + "w";
@ -60,10 +60,10 @@ describe("FilterCreator.createFilter", () => {
let node3: Node = new Node(helper.createCoreNode());
let node4: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt;
fillNode2.captured_at = capturedAt + 1;
@ -91,10 +91,10 @@ describe("FilterCreator.createFilter", () => {
let node3: Node = new Node(helper.createCoreNode());
let node4: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
fillNode1.user.key = null;
fillNode2.user.key = "ukey";
@ -126,10 +126,10 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "skey";
let filter: FilterFunction = creator.createFilter(["!=", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = sequenceKey;
coreNode2.sequence_key = sequenceKey + "w";
@ -158,10 +158,10 @@ describe("FilterCreator.createFilter", () => {
let node3: Node = new Node(helper.createCoreNode());
let node4: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt;
fillNode2.captured_at = capturedAt + 1;
@ -189,10 +189,10 @@ describe("FilterCreator.createFilter", () => {
let node3: Node = new Node(helper.createCoreNode());
let node4: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
fillNode1.user.key = null;
fillNode2.user.key = "ukey";
@ -230,11 +230,11 @@ describe("FilterCreator.createFilter", () => {
let node4: Node = new Node(helper.createCoreNode());
let node5: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode5: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
let fillNode5: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt - 1;
fillNode2.captured_at = capturedAt;
@ -261,11 +261,11 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "0";
let filter: FilterFunction = creator.createFilter([">", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode5: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
let coreNode5: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "-1";
coreNode2.sequence_key = sequenceKey;
@ -306,11 +306,11 @@ describe("FilterCreator.createFilter", () => {
let node4: Node = new Node(helper.createCoreNode());
let node5: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode5: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
let fillNode5: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt - 1;
fillNode2.captured_at = capturedAt;
@ -337,11 +337,11 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "0";
let filter: FilterFunction = creator.createFilter([">=", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode5: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
let coreNode5: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "-1";
coreNode2.sequence_key = sequenceKey;
@ -382,11 +382,11 @@ describe("FilterCreator.createFilter", () => {
let node4: Node = new Node(helper.createCoreNode());
let node5: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode5: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
let fillNode5: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt - 1;
fillNode2.captured_at = capturedAt;
@ -413,11 +413,11 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "0";
let filter: FilterFunction = creator.createFilter(["<", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode5: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
let coreNode5: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "-1";
coreNode2.sequence_key = sequenceKey;
@ -458,11 +458,11 @@ describe("FilterCreator.createFilter", () => {
let node4: Node = new Node(helper.createCoreNode());
let node5: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode5: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
let fillNode5: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt - 1;
fillNode2.captured_at = capturedAt;
@ -489,11 +489,11 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "0";
let filter: FilterFunction = creator.createFilter(["<=", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode5: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
let coreNode5: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "-1";
coreNode2.sequence_key = sequenceKey;
@ -534,11 +534,11 @@ describe("FilterCreator.createFilter", () => {
let node4: Node = new Node(helper.createCoreNode());
let node5: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode5: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
let fillNode5: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt - 1;
fillNode2.captured_at = capturedAt;
@ -565,11 +565,11 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "0";
let filter: FilterFunction = creator.createFilter(["in", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode5: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
let coreNode5: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "-1";
coreNode2.sequence_key = sequenceKey;
@ -595,9 +595,9 @@ describe("FilterCreator.createFilter", () => {
let filter: FilterFunction = creator.createFilter(["in", "sequenceKey", null]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "1";
coreNode2.sequence_key = null;
@ -621,9 +621,9 @@ describe("FilterCreator.createFilter", () => {
let node2: Node = new Node(helper.createCoreNode());
let node3: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = 0;
fillNode2.captured_at = 1;
@ -651,10 +651,10 @@ describe("FilterCreator.createFilter", () => {
let node3: Node = new Node(helper.createCoreNode());
let node4: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = 0;
fillNode2.captured_at = 1;
@ -692,11 +692,11 @@ describe("FilterCreator.createFilter", () => {
let node4: Node = new Node(helper.createCoreNode());
let node5: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode5: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
let fillNode5: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = capturedAt - 1;
fillNode2.captured_at = capturedAt;
@ -723,11 +723,11 @@ describe("FilterCreator.createFilter", () => {
let sequenceKey: string = "0";
let filter: FilterFunction = creator.createFilter(["!in", "sequenceKey", sequenceKey]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode4: ICoreNode = helper.createCoreNode();
let coreNode5: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
let coreNode4: CoreImageEnt = helper.createCoreNode();
let coreNode5: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "-1";
coreNode2.sequence_key = sequenceKey;
@ -753,9 +753,9 @@ describe("FilterCreator.createFilter", () => {
let filter: FilterFunction = creator.createFilter(["!in", "sequenceKey", null]);
let coreNode1: ICoreNode = helper.createCoreNode();
let coreNode2: ICoreNode = helper.createCoreNode();
let coreNode3: ICoreNode = helper.createCoreNode();
let coreNode1: CoreImageEnt = helper.createCoreNode();
let coreNode2: CoreImageEnt = helper.createCoreNode();
let coreNode3: CoreImageEnt = helper.createCoreNode();
coreNode1.sequence_key = "1";
coreNode2.sequence_key = null;
@ -779,9 +779,9 @@ describe("FilterCreator.createFilter", () => {
let node2: Node = new Node(helper.createCoreNode());
let node3: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = 0;
fillNode2.captured_at = 1;
@ -809,10 +809,10 @@ describe("FilterCreator.createFilter", () => {
let node3: Node = new Node(helper.createCoreNode());
let node4: Node = new Node(helper.createCoreNode());
let fillNode1: IFillNode = helper.createFillNode();
let fillNode2: IFillNode = helper.createFillNode();
let fillNode3: IFillNode = helper.createFillNode();
let fillNode4: IFillNode = helper.createFillNode();
let fillNode1: SpatialImageEnt = helper.createFillNode();
let fillNode2: SpatialImageEnt = helper.createFillNode();
let fillNode3: SpatialImageEnt = helper.createFillNode();
let fillNode4: SpatialImageEnt = helper.createFillNode();
fillNode1.captured_at = 0;
fillNode2.captured_at = 1;
@ -842,7 +842,7 @@ describe("FilterCreator.createFilter", () => {
let creator: FilterCreator = new FilterCreator();
let node: Node = new Node(helper.createCoreNode());
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.captured_at = 1;
node.makeFull(fillNode);

816
spec/graph/Graph.spec.ts
View File

File diff suppressed because it is too large Load Diff

4
spec/graph/GraphCalculator.spec.ts
View File

@ -1,4 +1,4 @@
import { ILatLon } from "../../src/api/interfaces/ILatLon";
import { LatLonEnt } from "../../src/api/ents/LatLonEnt";
import { GeoCoords } from "../../src/geo/GeoCoords";
import { GraphCalculator } from "../../src/graph/GraphCalculator";
@ -22,7 +22,7 @@ describe("GraphCalculator.boundingBoxCorners", () => {
let calculator: GraphCalculator = new GraphCalculator(geoCoords);
let threshold: number = 1;
let bbox: [ILatLon, ILatLon] = calculator.boundingBoxCorners({ lat: 0, lon: 0 }, threshold);
let bbox: [LatLonEnt, LatLonEnt] = calculator.boundingBoxCorners({ lat: 0, lon: 0 }, threshold);
expect(bbox.length).toBe(2);
expect(bbox[0].lat).toBe(-1);

14
spec/graph/GraphService.spec.ts
View File

@ -17,11 +17,11 @@ import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { APIWrapper } from "../../src/api/APIWrapper";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { Graph } from "../../src/graph/Graph";
import { GraphMode } from "../../src/graph/GraphMode";
import { GraphService } from "../../src/graph/GraphService";
import { IEdgeStatus } from "../../src/graph/interfaces/IEdgeStatus";
import { NavigationEdgeStatus } from "../../src/graph/interfaces/NavigationEdgeStatus";
import { Sequence } from "../../src/graph/Sequence";
import { DataProvider } from "../helper/ProviderHelper";
@ -455,10 +455,10 @@ describe("GraphService.graphMode$", () => {
class TestNode extends Node {
private _assetsCached: boolean;
private _sequenceEdges: IEdgeStatus;
private _spatialEdges: IEdgeStatus;
private _sequenceEdges: NavigationEdgeStatus;
private _spatialEdges: NavigationEdgeStatus;
constructor(core: ICoreNode) {
constructor(core: CoreImageEnt) {
super(core);
this._assetsCached = false;
@ -474,11 +474,11 @@ class TestNode extends Node {
this._assetsCached = value;
}
public get sequenceEdges(): IEdgeStatus {
public get sequenceEdges(): NavigationEdgeStatus {
return this._sequenceEdges;
}
public get spatialEdges(): IEdgeStatus {
public get spatialEdges(): NavigationEdgeStatus {
return this._spatialEdges;
}
}

48
spec/graph/Node.spec.ts
View File

@ -1,8 +1,8 @@
import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { IMesh } from "../../src/api/interfaces/IMesh";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { MeshEnt } from "../../src/api/ents/MeshEnt";
import { NodeCache } from "../../src/graph/NodeCache";
describe("Node", () => {
@ -13,7 +13,7 @@ describe("Node", () => {
});
it("should create a node", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
expect(node).toBeDefined();
@ -28,12 +28,12 @@ describe("Node.full", () => {
});
it("should make node full", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
expect(node.full).toBe(false);
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
@ -41,7 +41,7 @@ describe("Node.full", () => {
});
it("should throw when fill is null", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
expect(() => { node.makeFull(null); }).toThrowError(Error);
@ -56,9 +56,9 @@ describe("Node.dispose", () => {
});
it("should clear core and fill properties", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
node.dispose();
@ -69,7 +69,7 @@ describe("Node.dispose", () => {
});
it("should dipose cache", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let nodeCache: NodeCache = new NodeCache(undefined);
@ -92,14 +92,14 @@ describe("Node.uncache", () => {
});
it("should handle when cache is not initilized", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
node.uncache();
});
it("should dispose node cache", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let nodeCache: NodeCache = new NodeCache(undefined);
@ -114,7 +114,7 @@ describe("Node.uncache", () => {
});
it("should be able to initialize cache again after uncache", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let nodeCache: NodeCache = new NodeCache(undefined);
@ -137,16 +137,16 @@ describe("Node.merged", () => {
});
it("should not be merged when not full", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
expect(node.merged).toBe(false);
});
it("should not be merged because merge version is zero", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.merge_version = 0;
@ -156,9 +156,9 @@ describe("Node.merged", () => {
});
it("should be merged because merge version present and larger than zero", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
fillNode.merge_version = 7;
@ -176,7 +176,7 @@ describe("Node.assetsCached", () => {
});
it("should not be cached when core", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
expect(node.assetsCached).toBe(false);
@ -184,7 +184,7 @@ describe("Node.assetsCached", () => {
class NodeCacheMock extends NodeCache {
protected _overridingImage: HTMLImageElement;
protected _overridingMesh: IMesh;
protected _overridingMesh: MeshEnt;
constructor() { super(undefined); }
@ -196,19 +196,19 @@ describe("Node.assetsCached", () => {
this._overridingImage = value;
}
public get mesh(): IMesh {
public get mesh(): MeshEnt {
return this._overridingMesh;
}
public set mesh(value: IMesh) {
public set mesh(value: MeshEnt) {
this._overridingMesh = value;
}
}
it("should be cached when assets set", () => {
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
let node: Node = new Node(coreNode);
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
let nodeCache: NodeCacheMock = new NodeCacheMock();

74
spec/graph/NodeCache.spec.ts
View File

@ -1,8 +1,8 @@
import { first, skip } from "rxjs/operators";
import { FalcorDataProvider } from "../../src/api/FalcorDataProvider";
import { EdgeDirection } from "../../src/graph/edge/EdgeDirection";
import { IEdge } from "../../src/graph/edge/interfaces/IEdge";
import { IEdgeStatus } from "../../src/graph/interfaces/IEdgeStatus";
import { NavigationDirection } from "../../src/graph/edge/NavigationDirection";
import { NavigationEdge } from "../../src/graph/edge/interfaces/NavigationEdge";
import { NavigationEdgeStatus } from "../../src/graph/interfaces/NavigationEdgeStatus";
import { NodeCache } from "../../src/graph/NodeCache";
import { ImageSize } from "../../src/viewer/ImageSize";
import { MockCreator } from "../helper/MockCreator";
@ -37,7 +37,7 @@ describe("NodeCache.sequenceEdges$", () => {
nodeCache.sequenceEdges$.pipe(
first())
.subscribe(
(edgeStatus: IEdgeStatus): void => {
(edgeStatus: NavigationEdgeStatus): void => {
expect(edgeStatus.cached).toBe(false);
expect(edgeStatus.edges.length).toBe(0);
@ -48,24 +48,24 @@ describe("NodeCache.sequenceEdges$", () => {
it("should emit cached non empty edge status when sequence edges cached", (done: Function) => {
let nodeCache: NodeCache = new NodeCache(undefined);
let sequenceEdge: IEdge = {
let sequenceEdge: NavigationEdge = {
data: {
direction: EdgeDirection.Next,
direction: NavigationDirection.Next,
worldMotionAzimuth: 0,
},
from: "key1",
to: "key2",
source: "key1",
target: "key2",
};
nodeCache.sequenceEdges$.pipe(
skip(1),
first())
.subscribe(
(edgeStatus: IEdgeStatus): void => {
(edgeStatus: NavigationEdgeStatus): void => {
expect(edgeStatus.cached).toBe(true);
expect(edgeStatus.edges.length).toBe(1);
expect(edgeStatus.edges[0].from).toBe(sequenceEdge.from);
expect(edgeStatus.edges[0].to).toBe(sequenceEdge.to);
expect(edgeStatus.edges[0].source).toBe(sequenceEdge.source);
expect(edgeStatus.edges[0].target).toBe(sequenceEdge.target);
expect(edgeStatus.edges[0].data.direction).toBe(sequenceEdge.data.direction);
expect(edgeStatus.edges[0].data.worldMotionAzimuth).toBe(sequenceEdge.data.worldMotionAzimuth);
@ -80,20 +80,20 @@ describe("NodeCache.resetSequenceEdges", () => {
it("should reset the sequence edges", () => {
let nodeCache: NodeCache = new NodeCache(undefined);
let sequenceEdge: IEdge = {
let sequenceEdge: NavigationEdge = {
data: {
direction: EdgeDirection.Next,
direction: NavigationDirection.Next,
worldMotionAzimuth: null,
},
from: "key1",
to: "key2",
source: "key1",
target: "key2",
};
nodeCache.cacheSequenceEdges([sequenceEdge]);
expect(nodeCache.sequenceEdges.cached).toBe(true);
expect(nodeCache.sequenceEdges.edges.length).toBe(1);
expect(nodeCache.sequenceEdges.edges[0].from).toBe(sequenceEdge.from);
expect(nodeCache.sequenceEdges.edges[0].source).toBe(sequenceEdge.source);
nodeCache.resetSequenceEdges();
@ -109,7 +109,7 @@ describe("NodeCache.spatialEdges$", () => {
nodeCache.spatialEdges$.pipe(
first())
.subscribe(
(edgeStatus: IEdgeStatus): void => {
(edgeStatus: NavigationEdgeStatus): void => {
expect(edgeStatus.cached).toBe(false);
expect(edgeStatus.edges.length).toBe(0);
@ -120,24 +120,24 @@ describe("NodeCache.spatialEdges$", () => {
it("should emit cached non empty edge status when spatial edges cached", (done: Function) => {
let nodeCache: NodeCache = new NodeCache(undefined);
let spatialEdge: IEdge = {
let spatialEdge: NavigationEdge = {
data: {
direction: EdgeDirection.StepForward,
direction: NavigationDirection.StepForward,
worldMotionAzimuth: 0,
},
from: "key1",
to: "key2",
source: "key1",
target: "key2",
};
nodeCache.spatialEdges$.pipe(
skip(1),
first())
.subscribe(
(edgeStatus: IEdgeStatus): void => {
(edgeStatus: NavigationEdgeStatus): void => {
expect(edgeStatus.cached).toBe(true);
expect(edgeStatus.edges.length).toBe(1);
expect(edgeStatus.edges[0].from).toBe(spatialEdge.from);
expect(edgeStatus.edges[0].to).toBe(spatialEdge.to);
expect(edgeStatus.edges[0].source).toBe(spatialEdge.source);
expect(edgeStatus.edges[0].target).toBe(spatialEdge.target);
expect(edgeStatus.edges[0].data.direction).toBe(spatialEdge.data.direction);
expect(edgeStatus.edges[0].data.worldMotionAzimuth).toBe(spatialEdge.data.worldMotionAzimuth);
@ -152,20 +152,20 @@ describe("NodeCache.resetSpatialEdges", () => {
it("should reset the spatial edges", () => {
let nodeCache: NodeCache = new NodeCache(undefined);
let spatialEdge: IEdge = {
let spatialEdge: NavigationEdge = {
data: {
direction: EdgeDirection.StepForward,
direction: NavigationDirection.StepForward,
worldMotionAzimuth: 0,
},
from: "key1",
to: "key2",
source: "key1",
target: "key2",
};
nodeCache.cacheSpatialEdges([spatialEdge]);
expect(nodeCache.spatialEdges.cached).toBe(true);
expect(nodeCache.spatialEdges.edges.length).toBe(1);
expect(nodeCache.spatialEdges.edges[0].from).toBe(spatialEdge.from);
expect(nodeCache.spatialEdges.edges[0].source).toBe(spatialEdge.source);
nodeCache.resetSpatialEdges();
@ -178,22 +178,22 @@ describe("NodeCache.dispose", () => {
it("should clear all properties", () => {
let nodeCache: NodeCache = new NodeCache(undefined);
let sequencEdge: IEdge = {
let sequencEdge: NavigationEdge = {
data: {
direction: EdgeDirection.StepForward,
direction: NavigationDirection.StepForward,
worldMotionAzimuth: 0,
},
from: "key1",
to: "key2",
source: "key1",
target: "key2",
};
let spatialEdge: IEdge = {
let spatialEdge: NavigationEdge = {
data: {
direction: EdgeDirection.StepForward,
direction: NavigationDirection.StepForward,
worldMotionAzimuth: 0,
},
from: "key1",
to: "key2",
source: "key1",
target: "key2",
};
nodeCache.cacheSequenceEdges([sequencEdge]);

4
spec/graph/Sequence.spec.ts
View File

@ -1,11 +1,11 @@
import { ISequence } from "../../src/api/interfaces/ISequence";
import { SequenceEnt } from "../../src/api/ents/SequenceEnt";
import { Sequence } from "../../src/graph/Sequence";
describe("Sequence", () => {
let sequence: Sequence;
beforeEach(() => {
let response: ISequence = {
let response: SequenceEnt = {
key: "A",
keys: ["B", "C", "D", "E"],
};

182
spec/graph/edge/EdgeCalculator.Pano.spec.ts
View File

@ -2,9 +2,9 @@ import { Node } from "../../../src/graph/Node";
import { EdgeCalculator } from "../../../src/graph/edge/EdgeCalculator";
import { EdgeCalculatorDirections } from "../../../src/graph/edge/EdgeCalculatorDirections";
import { EdgeCalculatorSettings } from "../../../src/graph/edge/EdgeCalculatorSettings";
import { IPotentialEdge } from "../../../src/graph/edge/interfaces/IPotentialEdge";
import { PotentialEdge } from "../../../src/graph/edge/interfaces/PotentialEdge";
import { EdgeCalculatorHelper } from "../../helper/EdgeCalculatorHelper";
import { EdgeDirection } from "../../../src/graph/edge/EdgeDirection";
import { NavigationDirection } from "../../../src/graph/edge/NavigationDirection";
describe("EdgeCalculator.computeSphericalEdges", () => {
let edgeCalculator: EdgeCalculator;
@ -14,7 +14,7 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge1: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -52,8 +52,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should have a spherical edge irrespective of rotation", () => {
@ -65,8 +65,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should not have a spherical edge with to long distance", () => {
@ -91,7 +91,7 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdges = edgeCalculator.computeSphericalEdges(node, [potentialEdge1]);
for (let sphericalEdge of sphericalEdges) {
expect(sphericalEdge.data.direction === EdgeDirection.Spherical).toBe(false);
expect(sphericalEdge.data.direction === NavigationDirection.Spherical).toBe(false);
}
});
@ -112,8 +112,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -152,8 +152,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should have a spherical edge closest to preferred distance", () => {
@ -166,8 +166,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should have a spherical edge with same sequence", () => {
@ -180,8 +180,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should have a spherical edge with same sequence", () => {
@ -194,8 +194,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should have a spherical edge with smallest motion change", () => {
@ -208,8 +208,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
});
@ -222,10 +222,10 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge3: IPotentialEdge;
let potentialEdge4: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
let potentialEdge3: PotentialEdge;
let potentialEdge4: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -276,8 +276,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge4.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge4.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should have a spherical edge in four directions", () => {
@ -302,12 +302,12 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
for (let key of keys) {
let edge = null;
for (let sphericalEdge of sphericalEdges) {
if (sphericalEdge.to === key) {
if (sphericalEdge.target === key) {
edge = sphericalEdge;
}
}
expect(edge.data.direction).toBe(EdgeDirection.Spherical);
expect(edge.data.direction).toBe(NavigationDirection.Spherical);
}
});
@ -331,12 +331,12 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
for (let key of keys) {
let edge = null;
for (let sphericalEdge of sphericalEdges) {
if (sphericalEdge.to === key) {
if (sphericalEdge.target === key) {
edge = sphericalEdge;
}
}
expect(edge.data.direction).toBe(EdgeDirection.Spherical);
expect(edge.data.direction).toBe(NavigationDirection.Spherical);
}
});
@ -352,8 +352,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
});
@ -365,7 +365,7 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge1: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -402,8 +402,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step left edge", () => {
@ -416,8 +416,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepLeft);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepLeft);
});
it("should have a step left edge for direction change", () => {
@ -430,8 +430,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepLeft);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepLeft);
});
it("should have a step right edge", () => {
@ -444,8 +444,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepRight);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepRight);
});
it("should have a step right edge for direction change", () => {
@ -458,8 +458,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepRight);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepRight);
});
it("should have a step backward edge", () => {
@ -472,8 +472,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepBackward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepBackward);
});
it("should have a step backward edge for direction change", () => {
@ -486,8 +486,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepBackward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepBackward);
});
it("should have a step forward edge in opposite motion direction", () => {
@ -500,8 +500,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge in perpendicular motion direction", () => {
@ -514,8 +514,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge in perpendicular motion direction", () => {
@ -528,8 +528,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should not have a step forward edge when turn is to large", () => {
@ -577,8 +577,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -619,8 +619,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should prefer a step forward edge with preferred distance", () => {
@ -633,8 +633,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should prefer a step forward edge with smaller motion change", () => {
@ -647,8 +647,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should prefer a step forward edge with smaller motion change", () => {
@ -661,8 +661,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should prefer a step forward edge with same merge connected component", () => {
@ -675,8 +675,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
});
@ -689,10 +689,10 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge3: IPotentialEdge;
let potentialEdge4: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
let potentialEdge3: PotentialEdge;
let potentialEdge4: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -742,14 +742,14 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
expect(sphericalEdges.length).toBe(4);
for (let sphericalEdge of sphericalEdges) {
if (sphericalEdge.to === potentialEdge1.key) {
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
} else if (sphericalEdge.to === potentialEdge2.key) {
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepLeft);
} else if (sphericalEdge.to === potentialEdge3.key) {
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepBackward);
} else if (sphericalEdge.to === potentialEdge4.key) {
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepRight);
if (sphericalEdge.target === potentialEdge1.key) {
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
} else if (sphericalEdge.target === potentialEdge2.key) {
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepLeft);
} else if (sphericalEdge.target === potentialEdge3.key) {
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepBackward);
} else if (sphericalEdge.target === potentialEdge4.key) {
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepRight);
}
}
});
@ -769,8 +769,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should not have a step left or right edge based on step forward edges", () => {
@ -791,8 +791,8 @@ describe("EdgeCalculator.computeSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.StepForward);
});
});
@ -804,8 +804,8 @@ describe("EdgeCalculator.computePerspectiveToSphericalEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -841,8 +841,8 @@ describe("EdgeCalculator.computePerspectiveToSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge1.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should not return a spherical edge when node is spherical", () => {
@ -869,8 +869,8 @@ describe("EdgeCalculator.computePerspectiveToSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should return the spherical edge preferring forward motion", () => {
@ -883,8 +883,8 @@ describe("EdgeCalculator.computePerspectiveToSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
it("should return the spherical edge preferring same connected component", () => {
@ -897,7 +897,7 @@ describe("EdgeCalculator.computePerspectiveToSphericalEdges", () => {
let sphericalEdge = sphericalEdges[0];
expect(sphericalEdge.to).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(EdgeDirection.Spherical);
expect(sphericalEdge.target).toBe(potentialEdge2.key);
expect(sphericalEdge.data.direction).toBe(NavigationDirection.Spherical);
});
});

30
spec/graph/edge/EdgeCalculator.Sequence.spec.ts
View File

@ -1,8 +1,8 @@
import { EdgeCalculator } from "../../../src/graph/edge/EdgeCalculator";
import { EdgeCalculatorDirections } from "../../../src/graph/edge/EdgeCalculatorDirections";
import { EdgeCalculatorSettings } from "../../../src/graph/edge/EdgeCalculatorSettings";
import { EdgeDirection } from "../../../src/graph/edge/EdgeDirection";
import { IEdge } from "../../../src/graph/edge/interfaces/IEdge";
import { NavigationDirection } from "../../../src/graph/edge/NavigationDirection";
import { NavigationEdge } from "../../../src/graph/edge/interfaces/NavigationEdge";
import { Node } from "../../../src/graph/Node";
import { Sequence } from "../../../src/graph/Sequence";
import { EdgeCalculatorHelper } from "../../helper/EdgeCalculatorHelper";
@ -52,14 +52,14 @@ describe("EdgeCalculator.computeSequenceEdges", () => {
let node: Node = helper.createFullNode(key, { alt: 0, lat: 0, lon: 0 }, sequenceKey, [0, 0, 0]);
let sequence: Sequence = new Sequence({ key: sequenceKey, keys: [key, nextKey] });
let sequenceEdges: IEdge[] = edgeCalculator.computeSequenceEdges(node, sequence);
let sequenceEdges: NavigationEdge[] = edgeCalculator.computeSequenceEdges(node, sequence);
expect(sequenceEdges.length).toBe(1);
let sequenceEdge: IEdge = sequenceEdges[0];
let sequenceEdge: NavigationEdge = sequenceEdges[0];
expect(sequenceEdge.to).toBe(nextKey);
expect(sequenceEdge.data.direction).toBe(EdgeDirection.Next);
expect(sequenceEdge.target).toBe(nextKey);
expect(sequenceEdge.data.direction).toBe(NavigationDirection.Next);
});
it("should return a prev edge", () => {
@ -70,14 +70,14 @@ describe("EdgeCalculator.computeSequenceEdges", () => {
let node: Node = helper.createFullNode(key, { alt: 0, lat: 0, lon: 0 }, sequenceKey, [0, 0, 0]);
let sequence: Sequence = new Sequence({ key: sequenceKey, keys: [prevKey, key] });
let sequenceEdges: IEdge[] = edgeCalculator.computeSequenceEdges(node, sequence);
let sequenceEdges: NavigationEdge[] = edgeCalculator.computeSequenceEdges(node, sequence);
expect(sequenceEdges.length).toBe(1);
let sequenceEdge: IEdge = sequenceEdges[0];
let sequenceEdge: NavigationEdge = sequenceEdges[0];
expect(sequenceEdge.to).toBe(prevKey);
expect(sequenceEdge.data.direction).toBe(EdgeDirection.Prev);
expect(sequenceEdge.target).toBe(prevKey);
expect(sequenceEdge.data.direction).toBe(NavigationDirection.Prev);
});
it("should return a prev and a next edge", () => {
@ -90,15 +90,15 @@ describe("EdgeCalculator.computeSequenceEdges", () => {
let node: Node = helper.createFullNode(key, { alt: 0, lat: 0, lon: 0 }, sequenceKey, [0, 0, 0]);
let sequence: Sequence = new Sequence({ key: sequenceKey, keys: [prevKey, key, nextKey] });
let sequenceEdges: IEdge[] = edgeCalculator.computeSequenceEdges(node, sequence);
let sequenceEdges: NavigationEdge[] = edgeCalculator.computeSequenceEdges(node, sequence);
expect(sequenceEdges.length).toBe(2);
for (let sequenceEdge of sequenceEdges) {
if (sequenceEdge.to === prevKey) {
expect(sequenceEdge.data.direction).toBe(EdgeDirection.Prev);
} else if (sequenceEdge.to === nextKey) {
expect(sequenceEdge.data.direction).toBe(EdgeDirection.Next);
if (sequenceEdge.target === prevKey) {
expect(sequenceEdge.data.direction).toBe(NavigationDirection.Prev);
} else if (sequenceEdge.target === nextKey) {
expect(sequenceEdge.data.direction).toBe(NavigationDirection.Next);
}
}
});

82
spec/graph/edge/EdgeCalculator.Similar.spec.ts
View File

@ -1,9 +1,9 @@
import { EdgeCalculator } from "../../../src/graph/edge/EdgeCalculator";
import { EdgeCalculatorDirections } from "../../../src/graph/edge/EdgeCalculatorDirections";
import { EdgeCalculatorSettings } from "../../../src/graph/edge/EdgeCalculatorSettings";
import { EdgeDirection } from "../../../src/graph/edge/EdgeDirection";
import { IEdge } from "../../../src/graph/edge/interfaces/IEdge";
import { IPotentialEdge } from "../../../src/graph/edge/interfaces/IPotentialEdge";
import { NavigationDirection } from "../../../src/graph/edge/NavigationDirection";
import { NavigationEdge } from "../../../src/graph/edge/interfaces/NavigationEdge";
import { PotentialEdge } from "../../../src/graph/edge/interfaces/PotentialEdge";
import { Node } from "../../../src/graph/Node";
import { EdgeCalculatorHelper } from "../../helper/EdgeCalculatorHelper";
@ -16,7 +16,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge: IPotentialEdge;
let potentialEdge: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -51,14 +51,14 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(1);
let similarEdge: IEdge = similarEdges[0];
let similarEdge: NavigationEdge = similarEdges[0];
expect(similarEdge.to).toBe(potentialEdge.key);
expect(similarEdge.data.direction).toBe(EdgeDirection.Similar);
expect(similarEdge.target).toBe(potentialEdge.key);
expect(similarEdge.data.direction).toBe(NavigationDirection.Similar);
});
it("should not have a similar edge if sequence is missing on potential edge", () => {
@ -66,7 +66,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = true;
potentialEdge.sequenceKey = null;
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(0);
});
@ -76,7 +76,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameSequence = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(0);
});
@ -86,7 +86,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameSequence = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(0);
});
@ -95,7 +95,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = false;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(1);
});
@ -104,7 +104,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(1);
});
@ -116,7 +116,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(0);
});
@ -128,7 +128,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(0);
});
@ -141,14 +141,14 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameMergeCC = true;
potentialEdge.sequenceKey = "other";
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(1);
let similarEdge: IEdge = similarEdges[0];
let similarEdge: NavigationEdge = similarEdges[0];
expect(similarEdge.to).toBe(potentialEdge.key);
expect(similarEdge.data.direction).toBe(EdgeDirection.Similar);
expect(similarEdge.target).toBe(potentialEdge.key);
expect(similarEdge.data.direction).toBe(NavigationDirection.Similar);
});
it("should not have a similar edge for the same user within min time diff", () => {
@ -161,7 +161,7 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameUser = true;
potentialEdge.capturedAt = 1050;
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(0);
});
@ -176,19 +176,19 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge.sameUser = true;
potentialEdge.capturedAt = 1200;
let similarEdges: IEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
let similarEdges: NavigationEdge[] = edgeCalculator.computeSimilarEdges(node, [potentialEdge]);
expect(similarEdges.length).toBe(1);
let similarEdge: IEdge = similarEdges[0];
let similarEdge: NavigationEdge = similarEdges[0];
expect(similarEdge.to).toBe(potentialEdge.key);
expect(similarEdge.data.direction).toBe(EdgeDirection.Similar);
expect(similarEdge.target).toBe(potentialEdge.key);
expect(similarEdge.data.direction).toBe(NavigationDirection.Similar);
});
it("should have a multiple similar edges from different sequences", () => {
let potentialEdge1: IPotentialEdge = helper.createPotentialEdge();
let potentialEdge2: IPotentialEdge = helper.createPotentialEdge();
let potentialEdge1: PotentialEdge = helper.createPotentialEdge();
let potentialEdge2: PotentialEdge = helper.createPotentialEdge();
potentialEdge1.key = "k1";
potentialEdge1.sameMergeCC = true;
@ -198,20 +198,20 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge2.sameMergeCC = true;
potentialEdge2.sequenceKey = "s2";
let similarEdges: IEdge[] =
let similarEdges: NavigationEdge[] =
edgeCalculator.computeSimilarEdges(node, [potentialEdge1, potentialEdge2]);
expect(similarEdges.length).toBe(2);
for (let similarEdge of similarEdges) {
expect(similarEdge.data.direction).toBe(EdgeDirection.Similar);
expect(similarEdge.data.direction).toBe(NavigationDirection.Similar);
}
for (let key of [potentialEdge1.key, potentialEdge2.key]) {
let count: number = 0;
for (let similarEdge of similarEdges) {
if (similarEdge.to === key) {
if (similarEdge.target === key) {
count++;
}
}
@ -221,8 +221,8 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
});
it("should have only one similar edge for a sequence based on distance", () => {
let potentialEdge1: IPotentialEdge = helper.createPotentialEdge();
let potentialEdge2: IPotentialEdge = helper.createPotentialEdge();
let potentialEdge1: PotentialEdge = helper.createPotentialEdge();
let potentialEdge2: PotentialEdge = helper.createPotentialEdge();
potentialEdge1.key = "k1";
potentialEdge1.distance = 2;
@ -234,20 +234,20 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge2.sameMergeCC = true;
potentialEdge2.sequenceKey = "s1";
let similarEdges: IEdge[] =
let similarEdges: NavigationEdge[] =
edgeCalculator.computeSimilarEdges(node, [potentialEdge1, potentialEdge2]);
expect(similarEdges.length).toBe(1);
let similarEdge: IEdge = similarEdges[0];
let similarEdge: NavigationEdge = similarEdges[0];
expect(similarEdge.to).toBe(potentialEdge2.key);
expect(similarEdge.data.direction).toBe(EdgeDirection.Similar);
expect(similarEdge.target).toBe(potentialEdge2.key);
expect(similarEdge.data.direction).toBe(NavigationDirection.Similar);
});
it("should have only one similar edge for a sequence based on rotation", () => {
let potentialEdge1: IPotentialEdge = helper.createPotentialEdge();
let potentialEdge2: IPotentialEdge = helper.createPotentialEdge();
let potentialEdge1: PotentialEdge = helper.createPotentialEdge();
let potentialEdge2: PotentialEdge = helper.createPotentialEdge();
potentialEdge1.key = "k1";
potentialEdge1.rotation = 2;
@ -259,14 +259,14 @@ describe("EdgeCalculator.computeSimilarEdges", () => {
potentialEdge2.sameMergeCC = true;
potentialEdge2.sequenceKey = "s1";
let similarEdges: IEdge[] =
let similarEdges: NavigationEdge[] =
edgeCalculator.computeSimilarEdges(node, [potentialEdge1, potentialEdge2]);
expect(similarEdges.length).toBe(1);
let similarEdge: IEdge = similarEdges[0];
let similarEdge: NavigationEdge = similarEdges[0];
expect(similarEdge.to).toBe(potentialEdge2.key);
expect(similarEdge.data.direction).toBe(EdgeDirection.Similar);
expect(similarEdge.target).toBe(potentialEdge2.key);
expect(similarEdge.data.direction).toBe(NavigationDirection.Similar);
});
});

152
spec/graph/edge/EdgeCalculator.Step.spec.ts
View File

@ -1,9 +1,9 @@
import { EdgeCalculator } from "../../../src/graph/edge/EdgeCalculator";
import { EdgeCalculatorDirections } from "../../../src/graph/edge/EdgeCalculatorDirections";
import { EdgeCalculatorSettings } from "../../../src/graph/edge/EdgeCalculatorSettings";
import { EdgeDirection } from "../../../src/graph/edge/EdgeDirection";
import { IEdge } from "../../../src/graph/edge/interfaces/IEdge";
import { IPotentialEdge } from "../../../src/graph/edge/interfaces/IPotentialEdge";
import { NavigationDirection } from "../../../src/graph/edge/NavigationDirection";
import { NavigationEdge } from "../../../src/graph/edge/interfaces/NavigationEdge";
import { PotentialEdge } from "../../../src/graph/edge/interfaces/PotentialEdge";
import { Node } from "../../../src/graph/Node";
import { EdgeCalculatorHelper } from "../../helper/EdgeCalculatorHelper";
@ -15,14 +15,14 @@ describe("EdgeCalculator.computeStepEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge: IPotentialEdge;
let potentialEdge: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
directions = new EdgeCalculatorDirections();
directions.steps[EdgeDirection.StepForward].useFallback = true;
directions.steps[EdgeDirection.StepBackward].useFallback = false;
directions.steps[NavigationDirection.StepForward].useFallback = true;
directions.steps[NavigationDirection.StepBackward].useFallback = false;
edgeCalculator = new EdgeCalculator(settings, directions);
@ -45,59 +45,59 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should have a step forward edge", () => {
potentialEdge.motionChange = 0;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step left edge", () => {
potentialEdge.motionChange = Math.PI / 2;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepLeft);
expect(stepEdge.target).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepLeft);
});
it("should have a step right edge", () => {
potentialEdge.motionChange = -Math.PI / 2;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepRight);
expect(stepEdge.target).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepRight);
});
it("should have a step back edge", () => {
potentialEdge.motionChange = Math.PI;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepBackward);
expect(stepEdge.target).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepBackward);
});
it("should not have any edges because potential is spherical", () => {
potentialEdge.spherical = true;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -105,7 +105,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should not have any edges because of max distance", () => {
potentialEdge.distance = settings.stepMaxDistance + 1;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -113,7 +113,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should not have any edges because of direction change", () => {
potentialEdge.directionChange = settings.stepMaxDirectionChange + Math.PI / 18;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -121,7 +121,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should not have any edges because of negative direction change", () => {
potentialEdge.directionChange = -settings.stepMaxDirectionChange - Math.PI / 18;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -129,7 +129,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should not have any edges because of drift", () => {
potentialEdge.motionChange = settings.stepMaxDrift + Math.PI / 18;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -137,7 +137,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should not have any edges because of negative drift", () => {
potentialEdge.motionChange = -settings.stepMaxDrift - Math.PI / 18;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -146,7 +146,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
potentialEdge.distance = settings.stepMaxDistance + 1;
potentialEdge.motionChange = 0;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(
node,
[potentialEdge],
potentialEdge.key,
@ -154,17 +154,17 @@ describe("EdgeCalculator.computeStepEdges", () => {
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should not fallback to previous node with disabled fallback setting", () => {
potentialEdge.distance = settings.stepMaxDistance + 1;
potentialEdge.motionChange = Math.PI;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(
node,
[potentialEdge],
null,
@ -176,7 +176,7 @@ describe("EdgeCalculator.computeStepEdges", () => {
it("should not have any edges if node is spherical", () => {
node = helper.createDefaultNode(true);
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge], null, null);
expect(stepEdges.length).toBe(0);
});
@ -190,8 +190,8 @@ describe("EdgeCalculator.computeStepEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -212,84 +212,84 @@ describe("EdgeCalculator.computeStepEdges", () => {
potentialEdge1.distance = settings.stepPreferredDistance + 1;
potentialEdge2.distance = settings.stepPreferredDistance;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge based on preferred distance", () => {
potentialEdge1.distance = settings.stepPreferredDistance - 1;
potentialEdge2.distance = settings.stepPreferredDistance;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge for smallest motion change", () => {
potentialEdge1.motionChange = settings.stepMaxDrift / 2;
potentialEdge2.motionChange = settings.stepMaxDrift / 4;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge for smallest motion change", () => {
potentialEdge1.motionChange = -settings.stepMaxDrift / 2;
potentialEdge2.motionChange = -settings.stepMaxDrift / 4;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge for smallest vertical motion change", () => {
potentialEdge1.verticalMotion = settings.stepMaxDrift / 2;
potentialEdge2.verticalMotion = settings.stepMaxDrift / 4;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge for smallest vertical motion change", () => {
potentialEdge1.verticalMotion = -settings.stepMaxDrift / 2;
potentialEdge2.verticalMotion = -settings.stepMaxDrift / 4;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge for smallest combined motion change", () => {
@ -299,55 +299,55 @@ describe("EdgeCalculator.computeStepEdges", () => {
potentialEdge2.motionChange = -settings.stepMaxDrift / 3;
potentialEdge2.verticalMotion = -settings.stepMaxDrift / 3;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge with the same sequence", () => {
potentialEdge1.sameSequence = false;
potentialEdge2.sameSequence = true;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge with the same merge cc", () => {
potentialEdge1.sameMergeCC = false;
potentialEdge2.sameMergeCC = true;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
it("should have a step forward edge with smallest rotation", () => {
potentialEdge1.rotation = 0.2;
potentialEdge2.rotation = 0.1;
let stepEdges: IEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
let stepEdges: NavigationEdge[] = edgeCalculator.computeStepEdges(node, [potentialEdge1, potentialEdge2], null, null);
expect(stepEdges.length).toBe(1);
let stepEdge: IEdge = stepEdges[0];
let stepEdge: NavigationEdge = stepEdges[0];
expect(stepEdge.to).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(EdgeDirection.StepForward);
expect(stepEdge.target).toBe(potentialEdge2.key);
expect(stepEdge.data.direction).toBe(NavigationDirection.StepForward);
});
});

92
spec/graph/edge/EdgeCalculator.Turn.spec.ts
View File

@ -1,9 +1,9 @@
import { EdgeCalculator } from "../../../src/graph/edge/EdgeCalculator";
import { EdgeCalculatorDirections } from "../../../src/graph/edge/EdgeCalculatorDirections";
import { EdgeCalculatorSettings } from "../../../src/graph/edge/EdgeCalculatorSettings";
import { EdgeDirection } from "../../../src/graph/edge/EdgeDirection";
import { IEdge } from "../../../src/graph/edge/interfaces/IEdge";
import { IPotentialEdge } from "../../../src/graph/edge/interfaces/IPotentialEdge";
import { NavigationDirection } from "../../../src/graph/edge/NavigationDirection";
import { NavigationEdge } from "../../../src/graph/edge/interfaces/NavigationEdge";
import { PotentialEdge } from "../../../src/graph/edge/interfaces/PotentialEdge";
import { Node } from "../../../src/graph/Node";
import { EdgeCalculatorHelper } from "../../helper/EdgeCalculatorHelper";
@ -15,7 +15,7 @@ describe("EdgeCalculator.computeTurnEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge: IPotentialEdge;
let potentialEdge: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -42,7 +42,7 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge.directionChange = Math.PI / 2;
potentialEdge.spherical = true;
let stepEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
let stepEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
expect(stepEdges.length).toBe(0);
});
@ -50,40 +50,40 @@ describe("EdgeCalculator.computeTurnEdges", () => {
it("should have a turn left edge", () => {
potentialEdge.directionChange = Math.PI / 2;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnLeft);
expect(turnEdge.target).toBe(potentialEdge.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnLeft);
});
it("should have a turn right edge", () => {
potentialEdge.directionChange = -Math.PI / 2;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnRight);
expect(turnEdge.target).toBe(potentialEdge.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnRight);
});
it("should have a u-turn edge", () => {
potentialEdge.directionChange = Math.PI;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnU);
expect(turnEdge.target).toBe(potentialEdge.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnU);
});
it("should not have a u-turn edge when node is spherical", () => {
@ -91,7 +91,7 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge.directionChange = Math.PI;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge]);
expect(turnEdges.length).toBe(0);
});
@ -105,8 +105,8 @@ describe("EdgeCalculator.computeTurnEdges", () => {
let helper: EdgeCalculatorHelper;
let node: Node;
let potentialEdge1: IPotentialEdge;
let potentialEdge2: IPotentialEdge;
let potentialEdge1: PotentialEdge;
let potentialEdge2: PotentialEdge;
beforeEach(() => {
settings = new EdgeCalculatorSettings();
@ -133,14 +133,14 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge2.directionChange = Math.PI / 2;
potentialEdge2.sameSequence = true;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnLeft);
expect(turnEdge.target).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnLeft);
});
it("should have a turn left with the same merge cc", () => {
@ -150,14 +150,14 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge2.directionChange = Math.PI / 2;
potentialEdge2.sameMergeCC = true;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnLeft);
expect(turnEdge.target).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnLeft);
});
it("should have a turn left edge with the smallest distance", () => {
@ -167,19 +167,19 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge2.directionChange = Math.PI / 2;
potentialEdge2.distance = 3;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnLeft);
expect(turnEdge.target).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnLeft);
});
it("should have a turn left edge with the smallest motion difference", () => {
let motionChange: number =
directions.turns[EdgeDirection.TurnLeft].motionChange;
directions.turns[NavigationDirection.TurnLeft].motionChange;
potentialEdge1.directionChange = Math.PI / 2;
potentialEdge1.motionChange = 0.9 * motionChange;
@ -187,14 +187,14 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge2.directionChange = Math.PI / 2;
potentialEdge2.motionChange = motionChange;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnLeft);
expect(turnEdge.target).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnLeft);
});
it("should have a turn left edge for rig setup with smallest direction change", () => {
@ -204,14 +204,14 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge2.distance = 0.5 * settings.turnMaxRigDistance;
potentialEdge2.directionChange = 1.1 * settings.turnMinRigDirectionChange;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnLeft);
expect(turnEdge.target).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnLeft);
});
it("should have a turn right edge for rig setup with smallest direction change", () => {
@ -221,14 +221,14 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge2.distance = 0.5 * settings.turnMaxRigDistance;
potentialEdge2.directionChange = -1.1 * settings.turnMinRigDirectionChange;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(1);
let turnEdge: IEdge = turnEdges[0];
let turnEdge: NavigationEdge = turnEdges[0];
expect(turnEdge.to).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(EdgeDirection.TurnRight);
expect(turnEdge.target).toBe(potentialEdge2.key);
expect(turnEdge.data.direction).toBe(NavigationDirection.TurnRight);
});
it("should not have a turn left edge for rig with too small angle", () => {
@ -238,7 +238,7 @@ describe("EdgeCalculator.computeTurnEdges", () => {
potentialEdge1.distance = 0.5 * settings.turnMaxRigDistance;
potentialEdge1.directionChange = -0.9 * settings.turnMinRigDirectionChange;
let turnEdges: IEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
let turnEdges: NavigationEdge[] = edgeCalculator.computeTurnEdges(node, [potentialEdge1, potentialEdge2]);
expect(turnEdges.length).toBe(0);
});

224
spec/graph/edge/EdgeCalculator.spec.ts
View File

@ -1,8 +1,8 @@
import { GeoCoords } from "../../../src/geo/GeoCoords";
import { ILatLonAlt } from "../../../src/geo/interfaces/ILatLonAlt";
import { LatLonAltEnt } from "../../../src/api/ents/LatLonAltEnt";
import { Spatial } from "../../../src/geo/Spatial";
import { EdgeCalculator } from "../../../src/graph/edge/EdgeCalculator";
import { IPotentialEdge } from "../../../src/graph/edge/interfaces/IPotentialEdge";
import { PotentialEdge } from "../../../src/graph/edge/interfaces/PotentialEdge";
import { Node } from "../../../src/graph/Node";
import { EdgeCalculatorHelper } from "../../helper/EdgeCalculatorHelper";
@ -44,15 +44,15 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [0, -Math.PI / 2, 0], 2, "perspective", 0, 0);
let enu: number[] = [10, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [0, -Math.PI / 2, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(0);
@ -63,20 +63,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [0, -Math.PI / 2, 0]);
let enu: number[] = [10, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [0, -Math.PI / 2, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.distance).toBeCloseTo(10, precision);
@ -95,15 +95,15 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let sequenceKey: string = "skey";
let edgeKey: string = "edgeKey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [0, -Math.PI / 2, 0]);
let enu: number[] = [10, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, null, [0, -Math.PI / 2, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
@ -114,20 +114,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [0, -Math.PI / 2, 0]);
let enu: number[] = [3, -4, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [0, -Math.PI / 2, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.distance).toBeCloseTo(5, precision);
@ -138,20 +138,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [0, -Math.PI / 2, 0]);
let enu: number[] = [5, 5, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [0, -Math.PI / 2, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.motionChange).toBeCloseTo(Math.PI / 4, precision);
@ -162,20 +162,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [Math.PI / 2, 0, 0]);
let enu: number[] = [5, 5, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [Math.PI / 2, 0, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.motionChange).toBeCloseTo(-Math.PI / 4, precision);
@ -186,20 +186,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [Math.PI / 2, 0, 0]);
let enu: number[] = [0, -10, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [Math.PI / 2, 0, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(Math.abs(potentialEdge.motionChange)).toBeCloseTo(Math.PI, precision);
@ -210,20 +210,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [Math.PI / 2, 0, 0]);
let enu: number[] = [3, 4, 5];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [Math.PI / 2, 0, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.verticalMotion).toBeCloseTo(Math.PI / 4, precision);
@ -234,20 +234,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, [Math.PI / 2, 0, 0]);
let enu: number[] = [-3, 4, -5];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, [Math.PI / 2, 0, 0]);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.verticalMotion).toBeCloseTo(-Math.PI / 4, precision);
@ -258,20 +258,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(Math.PI / 2));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.directionChange).toBeCloseTo(Math.PI / 2, precision);
@ -282,20 +282,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(-Math.PI / 2));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.directionChange).toBeCloseTo(-Math.PI / 2, precision);
@ -306,20 +306,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(Math.PI / 4));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(-3 * Math.PI / 4));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(Math.abs(potentialEdge.directionChange)).toBeCloseTo(Math.PI, precision);
@ -330,20 +330,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(Math.PI / 4));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(Math.PI / 4, Math.PI / 4));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.verticalDirectionChange).toBeCloseTo(Math.PI / 4, precision);
@ -354,20 +354,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(Math.PI / 4, 5 * Math.PI / 12));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(Math.PI / 4, 7 * Math.PI / 12));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.verticalDirectionChange).toBeCloseTo(-Math.PI / 6, precision);
@ -378,20 +378,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(Math.PI / 2, Math.PI / 6));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(Math.PI / 2, 2 * Math.PI / 3));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.rotation).toBeCloseTo(Math.PI / 2, precision);
@ -407,20 +407,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let theta: number = spatial.relativeRotationAngle(r1, r2);
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, r1);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, r2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.rotation).toBeCloseTo(theta, precision);
@ -434,20 +434,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let r1: number[] = [0, 0, 0];
let r2: number[] = [0, 0, 0];
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, r1);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, r2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.worldMotionAzimuth).toBeCloseTo(0, precision);
@ -461,20 +461,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let r1: number[] = [0, 0, 0];
let r2: number[] = [0, 0, 0];
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, r1);
let enu: number[] = [0, 1, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, r2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.worldMotionAzimuth).toBeCloseTo(Math.PI / 2, precision);
@ -488,20 +488,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let r1: number[] = [0, 0, 0];
let r2: number[] = [0, 0, 0];
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, r1);
let enu: number[] = [-1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, r2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(Math.abs(potentialEdge.worldMotionAzimuth)).toBeCloseTo(Math.PI, precision);
@ -515,20 +515,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let r1: number[] = [0, 0, 0];
let r2: number[] = [0, 0, 0];
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, r1);
let enu: number[] = [0, -1, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, r2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.worldMotionAzimuth).toBeCloseTo(-Math.PI / 2, precision);
@ -542,20 +542,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let r1: number[] = [0, 0, 0];
let r2: number[] = [0, 0, 0];
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, r1);
let enu: number[] = [1, 1, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, r2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.worldMotionAzimuth).toBeCloseTo(Math.PI / 4, precision);
@ -566,20 +566,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(0));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.sameSequence).toBe(true);
@ -591,20 +591,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let sequenceKey: string = "skey";
let edgeSequenceKey: string = "edgeSkey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0));
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, edgeSequenceKey, createRotationVector(0));
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.sameSequence).toBe(false);
@ -617,20 +617,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let mergeCC: number = 45;
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0), mergeCC);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(0), mergeCC);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.sameMergeCC).toBe(true);
@ -644,20 +644,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let mergeCC1: number = 45;
let mergeCC2: number = 22;
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0), mergeCC1);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(0), mergeCC2);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.sameMergeCC).toBe(false);
@ -668,20 +668,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0), null);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(0), null);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.sameMergeCC).toBe(true);
@ -692,20 +692,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0), 467);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(0), null);
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.sameMergeCC).toBe(false);
@ -716,20 +716,20 @@ describe("EdgeCalculator.getPotentialEdges", () => {
let edgeKey: string = "edgeKey";
let sequenceKey: string = "skey";
let lla: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let lla: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let node: Node = helper.createFullNode(key, lla, sequenceKey, createRotationVector(0), 467);
let enu: number[] = [1, 0, 0];
let geodetic: number[] = geoCoords.enuToGeodetic(enu[0], enu[1], enu[2], lla.lat, lla.lon, lla.alt);
let edgeLla: ILatLonAlt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeLla: LatLonAltEnt = { alt: geodetic[2], lat: geodetic[0], lon: geodetic[1] };
let edgeNode: Node = helper.createFullNode(edgeKey, edgeLla, sequenceKey, createRotationVector(0), 435, "equirectangular");
let potentialEdges: IPotentialEdge[] =
let potentialEdges: PotentialEdge[] =
edgeCalculator.getPotentialEdges(node, [edgeNode], []);
expect(potentialEdges.length).toBe(1);
let potentialEdge: IPotentialEdge = potentialEdges[0];
let potentialEdge: PotentialEdge = potentialEdges[0];
expect(potentialEdge.key).toBe(edgeKey);
expect(potentialEdge.spherical).toBe(true);

6
spec/helper/DOMRendererMockCreator.ts
View File

@ -1,6 +1,6 @@
import { Subject } from "rxjs";
import { DOMRenderer } from "../../src/render/DOMRenderer";
import { IVNodeHash } from "../../src/render/interfaces/IVNodeHash";
import { VirtualNodeHash } from "../../src/render/interfaces/VirtualNodeHash";
import { MockCreator } from "./MockCreator";
import { MockCreatorBase } from "./MockCreatorBase";
@ -9,8 +9,8 @@ export class DOMRendererMockCreator extends MockCreatorBase<DOMRenderer> {
public create(): DOMRenderer {
const mock: DOMRenderer = new MockCreator().create(DOMRenderer, "DOMRenderer");
this._mockProperty(mock, "element$", new Subject<IVNodeHash>());
this._mockProperty(mock, "render$", new Subject<IVNodeHash>());
this._mockProperty(mock, "element$", new Subject<VirtualNodeHash>());
this._mockProperty(mock, "render$", new Subject<VirtualNodeHash>());
return mock;
}

26
spec/helper/EdgeCalculatorHelper.ts
View File

@ -1,12 +1,12 @@
import { Node } from "../../src/graph/Node";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { ILatLonAlt } from "../../src/geo/interfaces/ILatLonAlt";
import { IPotentialEdge } from "../../src/graph/edge/interfaces/IPotentialEdge";
import { CameraProjectionType } from "../../src/api/interfaces/CameraProjectionType";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { LatLonAltEnt } from "../../src/api/ents/LatLonAltEnt";
import { PotentialEdge } from "../../src/graph/edge/interfaces/PotentialEdge";
import { CameraType } from "../../src/geo/interfaces/CameraType";
export class EdgeCalculatorHelper {
public createPotentialEdge(key: string = "pkey"): IPotentialEdge {
public createPotentialEdge(key: string = "pkey"): PotentialEdge {
return {
capturedAt: 0,
directionChange: 0,
@ -27,10 +27,10 @@ export class EdgeCalculatorHelper {
public createCoreNode(
key: string,
latLonAlt: ILatLonAlt,
latLonAlt: LatLonAltEnt,
sequenceKey: string): Node {
let coreNode: ICoreNode = {
let coreNode: CoreImageEnt = {
cl: { lat: latLonAlt.lat, lon: latLonAlt.lon },
key: key,
l: { lat: latLonAlt.lat, lon: latLonAlt.lon },
@ -42,17 +42,17 @@ export class EdgeCalculatorHelper {
public createFullNode(
key: string = "key",
latLonAlt: ILatLonAlt = { alt: 0, lat: 0, lon: 0 },
latLonAlt: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 },
sequenceKey: string = "skey",
r: number[] = [0, 0, 0],
mergeCC: number = 2,
cameraType: CameraProjectionType = "perspective",
cameraType: CameraType = "perspective",
capturedAt: number = 0,
mergeVersion: number = 1): Node {
let node: Node = this.createCoreNode(key, latLonAlt, sequenceKey);
let fillNode: IFillNode = {
let fillNode: SpatialImageEnt = {
atomic_scale: 0,
c_rotation: r,
ca: 0,
@ -79,9 +79,9 @@ export class EdgeCalculatorHelper {
public createDefaultNode(spherical: boolean = false): Node {
let key: string = "key";
let sequenceKey: string = "skey";
let latLonAlt: ILatLonAlt = { alt: 0, lat: 0, lon: 0 };
let latLonAlt: LatLonAltEnt = { alt: 0, lat: 0, lon: 0 };
let cameraType: CameraProjectionType = spherical ?
let cameraType: CameraType = spherical ?
"equirectangular" :
null;

6
spec/helper/FrameHelper.ts
View File

@ -1,17 +1,17 @@
import { NodeHelper } from "./NodeHelper";
import { TransformHelper } from "./TransformHelper";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { State } from "../../src/state/State";
import { Camera } from "../../src/geo/Camera";
import { CameraProjectionType } from "../../src/api/interfaces/CameraProjectionType";
import { CameraType } from "../../src/geo/interfaces/CameraType";
export class FrameHelper {
private _nodeHelper: NodeHelper = new NodeHelper();
private _transformHelper: TransformHelper = new TransformHelper();
public createFrame(
cameraType: CameraProjectionType = "perspective"): IFrame {
cameraType: CameraType = "perspective"): AnimationFrame {
const currentNode =
this._nodeHelper.createNode(cameraType);

4
spec/helper/GLRendererMockCreator.ts
View File

@ -1,6 +1,6 @@
import { Subject } from "rxjs";
import { GLRenderer } from "../../src/render/GLRenderer";
import { IGLRenderHash } from "../../src/render/interfaces/IGLRenderHash";
import { GLRenderHash } from "../../src/render/interfaces/IGLRenderHash";
import { MockCreator } from "./MockCreator";
import { MockCreatorBase } from "./MockCreatorBase";
@ -10,7 +10,7 @@ export class GLRendererMockCreator extends MockCreatorBase<GLRenderer> {
const mock: GLRenderer = new MockCreator().create(GLRenderer, "GLRenderer");
this._mockProperty(mock, "webGLRenderer$", new Subject<THREE.WebGLRenderer>());
this._mockProperty(mock, "render$", new Subject<IGLRenderHash>());
this._mockProperty(mock, "render$", new Subject<GLRenderHash>());
this._mockProperty(mock, "postrender$", new Subject<void>());
return mock;

18
spec/helper/NodeHelper.ts
View File

@ -1,7 +1,7 @@
import { CameraProjectionType } from "../../src/api/interfaces/CameraProjectionType";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { IFullNode } from "../../src/api/interfaces/IFullNode";
import { CameraType } from "../../src/geo/interfaces/CameraType";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { ImageEnt } from "../../src/api/ents/ImageEnt";
import { Node } from "../../src/graph/Node";
export class NodeHelper {
@ -11,7 +11,7 @@ export class NodeHelper {
private _userKey: string = "ukey";
private _username: string = "uname";
public createCoreNode(): ICoreNode {
public createCoreNode(): CoreImageEnt {
return {
cl: { lat: 0, lon: 0 },
key: this._nodeKey,
@ -20,7 +20,7 @@ export class NodeHelper {
};
}
public createFillNode(): IFillNode {
public createFillNode(): SpatialImageEnt {
return {
atomic_scale: 0,
c_rotation: [0, 0, 0],
@ -42,7 +42,7 @@ export class NodeHelper {
};
}
public createFullNode(): IFullNode {
public createFullNode(): ImageEnt {
return {
atomic_scale: 0,
c_rotation: [0, 0, 0],
@ -68,7 +68,7 @@ export class NodeHelper {
};
}
public createNode(cameraType: CameraProjectionType = "perspective"): Node {
public createNode(cameraType: CameraType = "perspective"): Node {
let fullNode = this.createFullNode();
fullNode.camera_projection_type = cameraType;
let node = new Node(fullNode);
@ -77,7 +77,7 @@ export class NodeHelper {
}
public createUnmergedNode(): Node {
let fullNode: IFullNode = this.createFullNode();
let fullNode: ImageEnt = this.createFullNode();
fullNode.atomic_scale = undefined;
fullNode.ca = undefined;

4
spec/helper/PlayServiceMockCreator.ts
View File

@ -1,5 +1,5 @@
import { Subject } from "rxjs";
import { EdgeDirection } from "../../src/graph/edge/EdgeDirection";
import { NavigationDirection } from "../../src/graph/edge/NavigationDirection";
import { PlayService } from "../../src/viewer/PlayService";
import { MockCreator } from "./MockCreator";
@ -9,7 +9,7 @@ export class PlayServiceMockCreator extends MockCreatorBase<PlayService> {
public create(): PlayService {
const mock: PlayService = new MockCreator().create(PlayService, "PlayService");
this._mockProperty(mock, "direction$", new Subject<EdgeDirection>());
this._mockProperty(mock, "direction$", new Subject<NavigationDirection>());
this._mockProperty(mock, "playing$", new Subject<boolean>());
this._mockProperty(mock, "speed$", new Subject<boolean>());

8
spec/helper/StateServiceMockCreator.ts
View File

@ -5,8 +5,8 @@ import { MockCreatorBase } from "./MockCreatorBase";
import { Node } from "../../src/graph/Node";
import { Transform } from "stream";
import { ILatLonAlt } from "../../src/geo/interfaces/ILatLonAlt";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { LatLonAltEnt } from "../../src/api/ents/LatLonAltEnt";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { State } from "../../src/state/State";
import { StateService } from "../../src/state/StateService";
@ -18,11 +18,11 @@ export class StateServiceMockCreator extends MockCreatorBase<StateService> {
this._mockProperty(mock, "currentKey$", new Subject<Node>());
this._mockProperty(mock, "currentNode$", new Subject<Node>());
this._mockProperty(mock, "currentNodeExternal$", new Subject<Node>());
this._mockProperty(mock, "currentState$", new Subject<IFrame>());
this._mockProperty(mock, "currentState$", new Subject<AnimationFrame>());
this._mockProperty(mock, "currentTransform$", new Subject<Transform>());
this._mockProperty(mock, "inMotion$", new Subject<boolean>());
this._mockProperty(mock, "inTranslation$", new Subject<boolean>());
this._mockProperty(mock, "reference$", new Subject<ILatLonAlt>());
this._mockProperty(mock, "reference$", new Subject<LatLonAltEnt>());
this._mockProperty(mock, "state$", new Subject<State>());
return mock;

8
spec/helper/TestComponent.ts
View File

@ -1,17 +1,17 @@
import { Component } from "../../src/component/Component";
import { IComponentConfiguration } from "../../src/component/interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "../../src/component/interfaces/ComponentConfiguration";
import { Container } from "../../src/viewer/Container";
import { Navigator } from "../../src/viewer/Navigator";
export interface ITestConfiguration extends IComponentConfiguration {
export interface TestConfiguration extends ComponentConfiguration {
test: boolean;
}
export class TestComponent extends Component<ITestConfiguration> {
export class TestComponent extends Component<TestConfiguration> {
constructor(name: string, container: Container, navigator: Navigator) {
super(name, container, navigator);
}
protected _activate(): void { /* noop */ }
protected _deactivate(): void { /* noop */ }
protected _getDefaultConfiguration(): ITestConfiguration { return { test: false }; }
protected _getDefaultConfiguration(): TestConfiguration { return { test: false }; }
}

4
spec/helper/TransformHelper.ts
View File

@ -1,12 +1,12 @@
import { NodeHelper } from "./NodeHelper";
import { Transform } from "../../src/geo/Transform";
import { CameraProjectionType } from "../../src/api/interfaces/CameraProjectionType";
import { CameraType } from "../../src/geo/interfaces/CameraType";
export class TransformHelper {
private _nodeHelper: NodeHelper = new NodeHelper();
public createTransform(
cameraType: CameraProjectionType = "perspective"): Transform {
cameraType: CameraType = "perspective"): Transform {
const node = this._nodeHelper
.createNode(cameraType);

82
spec/render/GLRenderer.spec.ts
View File

@ -4,20 +4,20 @@ import { map } from "rxjs/operators";
import * as THREE from "three";
import { GLRenderer } from "../../src/render/GLRenderer";
import { GLRenderStage } from "../../src/render/GLRenderStage";
import { IGLRender } from "../../src/render/interfaces/IGLRender";
import { IGLRenderFunction } from "../../src/render/interfaces/IGLRenderFunction";
import { IGLRenderHash } from "../../src/render/interfaces/IGLRenderHash";
import { ISize } from "../../src/render/interfaces/ISize";
import { GLFrameRenderer } from "../../src/render/interfaces/GLFrameRenderer";
import { GLRenderFunction } from "../../src/render/interfaces/GLRenderFunction";
import { GLRenderHash } from "../../src/render/interfaces/IGLRenderHash";
import { ViewportSize } from "../../src/render/interfaces/ViewportSize";
import { RenderCamera } from "../../src/render/RenderCamera";
import { RenderMode } from "../../src/render/RenderMode";
import { RenderService } from "../../src/render/RenderService";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { FrameHelper } from "../helper/FrameHelper";
import { RendererMock } from "../helper/WebGLRenderer";
class RenderServiceMock extends RenderService {
private _sizeMock$: Subject<ISize> = new Subject<ISize>();
private _sizeMock$: Subject<ViewportSize> = new Subject<ViewportSize>();
private _renderModeMock$: Subject<RenderMode> = new Subject<RenderMode>();
private _renderCameraFrameMock$: Subject<RenderCamera> = new Subject<RenderCamera>();
@ -25,11 +25,11 @@ class RenderServiceMock extends RenderService {
super(element, observableEmpty(), RenderMode.Letterbox);
}
public get size$(): Subject<ISize> {
public get size$(): Subject<ViewportSize> {
return this._sizeMock$;
}
public set size$(value: Subject<ISize>) {
public set size$(value: Subject<ViewportSize>) {
this._sizeMock$ = value;
}
@ -79,23 +79,23 @@ describe("GLRenderer.ctor", () => {
});
describe("GLRenderer.renderer", () => {
let createGLRenderHash: (frameId: number, needsRender: boolean, name?: string) => IGLRenderHash =
(frameId: number, needsRender: boolean, name?: string): IGLRenderHash => {
let renderFunction: IGLRenderFunction =
let createGLRenderHash: (frameId: number, needsRender: boolean, name?: string) => GLRenderHash =
(frameId: number, needsRender: boolean, name?: string): GLRenderHash => {
let renderFunction: GLRenderFunction =
(pc: THREE.PerspectiveCamera, r: THREE.WebGLRenderer): void => {
r.render(new THREE.Scene(), pc);
};
let render: IGLRender = {
let render: GLFrameRenderer = {
frameId: frameId,
needsRender: needsRender,
render: renderFunction,
stage: GLRenderStage.Background,
};
let renderHash: IGLRenderHash = {
let renderHash: GLRenderHash = {
name: name != null ? name : "mock",
render: render,
renderer: render,
};
return renderHash;
@ -108,7 +108,7 @@ describe("GLRenderer.renderer", () => {
let canvas = document.createElement("canvas");
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let glRenderer: GLRenderer = new GLRenderer(canvas, document.createElement("div"), renderServiceMock);
let renderHash: IGLRenderHash = createGLRenderHash(0, true);
let renderHash: GLRenderHash = createGLRenderHash(0, true);
glRenderer.render$.next(renderHash);
@ -124,11 +124,11 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let glRenderer: GLRenderer = new GLRenderer(canvas, document.createElement("div"), renderServiceMock);
let renderHash: IGLRenderHash = createGLRenderHash(0, true);
let renderHash: GLRenderHash = createGLRenderHash(0, true);
glRenderer.render$.next(renderHash);
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 0;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$.next(renderCamera);
@ -145,11 +145,11 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let glRenderer: GLRenderer = new GLRenderer(canvas, document.createElement("div"), renderServiceMock);
let renderHash: IGLRenderHash = createGLRenderHash(0, true);
let renderHash: GLRenderHash = createGLRenderHash(0, true);
glRenderer.render$.next(renderHash);
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 0;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$.next(renderCamera);
@ -164,9 +164,9 @@ describe("GLRenderer.renderer", () => {
spyOn(rendererMock, "render");
spyOn(THREE, "WebGLRenderer").and.returnValue(<THREE.WebGLRenderer>rendererMock);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
let frame$: BehaviorSubject<IFrame> = new BehaviorSubject<IFrame>(frame);
let frame$: BehaviorSubject<AnimationFrame> = new BehaviorSubject<AnimationFrame>(frame);
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
@ -178,8 +178,8 @@ describe("GLRenderer.renderer", () => {
frame$.pipe(
map(
(f: IFrame): IGLRenderHash => {
let renderHash: IGLRenderHash = createGLRenderHash(f.id, true);
(f: AnimationFrame): GLRenderHash => {
let renderHash: GLRenderHash = createGLRenderHash(f.id, true);
return renderHash;
}))
@ -200,9 +200,9 @@ describe("GLRenderer.renderer", () => {
spyOn(rendererMock, "clear");
spyOn(THREE, "WebGLRenderer").and.returnValue(<THREE.WebGLRenderer>rendererMock);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
let frame$: BehaviorSubject<IFrame> = new BehaviorSubject<IFrame>(frame);
let frame$: BehaviorSubject<AnimationFrame> = new BehaviorSubject<AnimationFrame>(frame);
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
@ -214,8 +214,8 @@ describe("GLRenderer.renderer", () => {
let frameSubscription: Subscription = frame$.pipe(
map(
(f: IFrame): IGLRenderHash => {
let renderHash: IGLRenderHash = createGLRenderHash(f.id, true);
(f: AnimationFrame): GLRenderHash => {
let renderHash: GLRenderHash = createGLRenderHash(f.id, true);
return renderHash;
}))
@ -239,7 +239,7 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
renderCamera.setFrame(frame);
@ -268,7 +268,7 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$ = new BehaviorSubject<RenderCamera>(renderCamera);
@ -295,7 +295,7 @@ describe("GLRenderer.renderer", () => {
spyOn(rendererMock, "setClearColor");
spyOn(THREE, "WebGLRenderer").and.returnValue(<THREE.WebGLRenderer>rendererMock);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
@ -326,7 +326,7 @@ describe("GLRenderer.renderer", () => {
spyOn(rendererMock, "setClearColor");
spyOn(THREE, "WebGLRenderer").and.returnValue(<THREE.WebGLRenderer>rendererMock);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
@ -362,7 +362,7 @@ describe("GLRenderer.renderer", () => {
spyOn(rendererMock, "setClearColor");
spyOn(THREE, "WebGLRenderer").and.returnValue(<THREE.WebGLRenderer>rendererMock);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
@ -403,7 +403,7 @@ describe("GLRenderer.renderer", () => {
spyOn(rendererMock, "setClearColor");
spyOn(THREE, "WebGLRenderer").and.returnValue(<THREE.WebGLRenderer>rendererMock);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
@ -437,7 +437,7 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$ = new BehaviorSubject<RenderCamera>(renderCamera);
@ -466,7 +466,7 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$ = new BehaviorSubject<RenderCamera>(renderCamera);
@ -497,7 +497,7 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$ = new BehaviorSubject<RenderCamera>(renderCamera);
@ -505,8 +505,8 @@ describe("GLRenderer.renderer", () => {
let canvas = document.createElement("canvas");
let glRenderer: GLRenderer = new GLRenderer(canvas, document.createElement("div"), renderServiceMock);
let renderHash1: IGLRenderHash = createGLRenderHash(frame.id, true, hash1);
let renderHash2: IGLRenderHash = createGLRenderHash(frame.id, true, hash2);
let renderHash1: GLRenderHash = createGLRenderHash(frame.id, true, hash1);
let renderHash2: GLRenderHash = createGLRenderHash(frame.id, true, hash2);
glRenderer.render$.next(renderHash1);
glRenderer.render$.next(renderHash2);
@ -544,7 +544,7 @@ describe("GLRenderer.renderer", () => {
let renderServiceMock: RenderServiceMock = new RenderServiceMock(document.createElement("div"));
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 1;
renderCamera.setFrame(frame);
renderServiceMock.renderCameraFrame$ = new BehaviorSubject<RenderCamera>(renderCamera);
@ -552,8 +552,8 @@ describe("GLRenderer.renderer", () => {
let canvas = document.createElement("canvas");
let glRenderer: GLRenderer = new GLRenderer(canvas, document.createElement("div"), renderServiceMock);
let renderHash1: IGLRenderHash = createGLRenderHash(frame.id, true, hash1);
let renderHash2: IGLRenderHash = createGLRenderHash(frame.id, true, hash2);
let renderHash1: GLRenderHash = createGLRenderHash(frame.id, true, hash1);
let renderHash2: GLRenderHash = createGLRenderHash(frame.id, true, hash2);
glRenderer.render$.next(renderHash1);
glRenderer.render$.next(renderHash2);

10
spec/render/RenderCamera.spec.ts
View File

@ -1,6 +1,6 @@
import { RenderCamera } from "../../src/render/RenderCamera";
import { RenderMode } from "../../src/render/RenderMode";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { FrameHelper } from "../helper/FrameHelper";
describe("RenderCamera.ctor", () => {
@ -63,7 +63,7 @@ describe("RenderCamera.setRenderMode", () => {
renderCamera.setRenderMode(RenderMode.Fill);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
renderCamera.setFrame(frame);
expect(renderCamera.changed).toBe(true);
@ -88,7 +88,7 @@ describe("RenderCamera.setFrame", () => {
it("should not be changed when not updated", () => {
let renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Letterbox);
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
renderCamera.setFrame(frame);
expect(renderCamera.changed).toBe(true);
@ -113,7 +113,7 @@ describe("RenderCamera.setFrame", () => {
renderCamera.setSize({ width: 1, height: 1 });
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = 0;
renderCamera.setFrame(frame);
frame.id = 1;
@ -186,7 +186,7 @@ describe("RenderCamera.perspective.fov", () => {
const fov: number = renderCamera.perspective.fov;
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.state.zoom = 1;
renderCamera.setFrame(frame);

46
spec/render/RenderService.spec.ts
View File

@ -2,16 +2,16 @@ import { empty as observableEmpty, Subject } from "rxjs";
import { skip, first, take, count } from "rxjs/operators";
import { Camera } from "../../src/geo/Camera";
import { ISize } from "../../src/render/interfaces/ISize";
import { ViewportSize } from "../../src/render/interfaces/ViewportSize";
import { RenderCamera } from "../../src/render/RenderCamera";
import { RenderMode } from "../../src/render/RenderMode";
import { RenderService } from "../../src/render/RenderService";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { FrameHelper } from "../helper/FrameHelper";
const createFrame: (frameId: number, alpha?: number, camera?: Camera) => IFrame =
(frameId: number, alpha?: number, camera?: Camera): IFrame => {
const frame: IFrame = new FrameHelper().createFrame();
const createFrame: (frameId: number, alpha?: number, camera?: Camera) => AnimationFrame =
(frameId: number, alpha?: number, camera?: Camera): AnimationFrame => {
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.id = frameId;
frame.state.alpha = alpha != null ? alpha : 0;
@ -89,7 +89,7 @@ describe("RenderService.size", () => {
renderService.size$.pipe(
first())
.subscribe(
(size: ISize): void => {
(size: ViewportSize): void => {
expect(size).toBeDefined();
done();
@ -104,7 +104,7 @@ describe("RenderService.size", () => {
renderService.size$.pipe(
first())
.subscribe(
(size: ISize): void => {
(size: ViewportSize): void => {
expect(size.width).toBe(0);
expect(size.height).toBe(0);
@ -120,7 +120,7 @@ describe("RenderService.size", () => {
renderService.size$.pipe(
take(2))
.subscribe(
(size: ISize): void => { return; },
(size: ViewportSize): void => { return; },
(e: Error): void => { return; },
(): void => { done(); });
@ -137,7 +137,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should be defined", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -157,7 +157,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should be changed for first frame", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -177,7 +177,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should not be changed for two identical frames", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -199,7 +199,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should be changed for alpha changes between two frames", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -221,7 +221,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should be changed for camera changes between two frames", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -246,7 +246,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should be changed for resize", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -270,7 +270,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should be changed for changed render mode", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -294,7 +294,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should have correct render mode when changed before subscribe", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -316,7 +316,7 @@ describe("RenderService.renderCameraFrame", () => {
it("should emit once for each frame", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = createRenderCameraMock();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox, renderCamera);
@ -345,7 +345,7 @@ describe("RenderService.renderCameraFrame", () => {
describe("RenderService.renderCamera$", () => {
it("should be defined", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Fill);
@ -366,7 +366,7 @@ describe("RenderService.renderCamera$", () => {
it("should only emit when camera has changed", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Fill);
@ -405,7 +405,7 @@ describe("RenderService.renderCamera$", () => {
appendChild(htmlElement: HTMLElement): void { return; },
};
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
let renderService: RenderService = new RenderService(element, frame$, RenderMode.Letterbox);
@ -425,7 +425,7 @@ describe("RenderService.renderCamera$", () => {
describe("RenderService.bearing$", () => {
it("should be defined", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Fill);
@ -445,7 +445,7 @@ describe("RenderService.bearing$", () => {
it("should be 90 degrees", (done: Function) => {
let element: HTMLDivElement = document.createElement("div");
let frame$: Subject<IFrame> = new Subject<IFrame>();
let frame$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const renderCamera: RenderCamera = new RenderCamera(1, 1, RenderMode.Fill);
@ -460,7 +460,7 @@ describe("RenderService.bearing$", () => {
done();
});
let frame: IFrame = createFrame(0);
let frame: AnimationFrame = createFrame(0);
frame.state.camera.lookat.set(1, 0, 0);
frame$.next(frame);

86
spec/state/StateBase.spec.ts
View File

@ -1,10 +1,10 @@
import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { IFullNode } from "../../src/api/interfaces/IFullNode";
import { IRotation } from "../../src/state/interfaces/IRotation";
import { IState } from "../../src/state/interfaces/IState";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { ImageEnt } from "../../src/api/ents/ImageEnt";
import { EulerRotation } from "../../src/state/interfaces/EulerRotation";
import { IStateBase } from "../../src/state/interfaces/IStateBase";
import { StateBase } from "../../src/state/states/StateBase";
import { Camera } from "../../src/geo/Camera";
import { TransitionMode } from "../../src/state/TransitionMode";
@ -15,9 +15,9 @@ class TestStateBase extends StateBase {
public waitInteractively(): StateBase { return null; }
public move(delta: number): void { return; }
public moveTo(position: number): void { return; }
public rotate(delta: IRotation): void { return; }
public rotateUnbounded(delta: IRotation): void { return; }
public rotateWithoutInertia(delta: IRotation): void { return; }
public rotate(delta: EulerRotation): void { return; }
public rotateUnbounded(delta: EulerRotation): void { return; }
public rotateWithoutInertia(delta: EulerRotation): void { return; }
public rotateBasic(basicRotation: number[]): void { return; }
public rotateBasicUnbounded(basic: number[]): void { return; }
public rotateBasicWithoutInertia(basic: number[]): void { return; }
@ -34,7 +34,7 @@ class TestStateBase extends StateBase {
}
class TestNode extends Node {
constructor(core: ICoreNode) {
constructor(core: CoreImageEnt) {
super(core);
}
@ -47,7 +47,7 @@ class TestNode extends Node {
}
}
let createState: () => IState = (): IState => {
let createState: () => IStateBase = (): IStateBase => {
return {
alpha: 1,
camera: new Camera(),
@ -69,12 +69,12 @@ let createFullNode: () => Node = (): Node => {
describe("StateBase.transitionMode", () => {
it("should set transition mode", () => {
const state1: IState = createState();
const state1: IStateBase = createState();
const stateBase1: TestStateBase = new TestStateBase(state1);
expect(stateBase1.transitionMode).toBe(TransitionMode.Default);
const state2: IState = createState();
const state2: IStateBase = createState();
state2.transitionMode = TransitionMode.Instantaneous;
const stateBase2: TestStateBase = new TestStateBase(state2);
@ -84,25 +84,25 @@ describe("StateBase.transitionMode", () => {
describe("StateBase.motionlessTransition", () => {
it("should be false if not both nodes set", () => {
const state: IState = createState();
const state: IStateBase = createState();
const stateBase: TestStateBase = new TestStateBase(state);
expect(stateBase.motionlessTransition()).toBe(false);
});
it("should be false if nodes in same connected component", () => {
const state: IState = createState();
const state: IStateBase = createState();
const stateBase: TestStateBase = new TestStateBase(state);
const helper: NodeHelper = new NodeHelper();
const fullNode1: IFullNode = helper.createFullNode();
const fullNode1: ImageEnt = helper.createFullNode();
fullNode1.merge_cc = 1;
fullNode1.merge_version = 1;
const node1: Node = new TestNode(fullNode1);
node1.makeFull(fullNode1);
const fullNode2: IFullNode = helper.createFullNode();
const fullNode2: ImageEnt = helper.createFullNode();
fullNode2.merge_cc = 1;
fullNode2.merge_version = 1;
const node2: Node = new TestNode(fullNode2);
@ -115,19 +115,19 @@ describe("StateBase.motionlessTransition", () => {
});
it("should be true if instantaneous transition mode", () => {
const state: IState = createState();
const state: IStateBase = createState();
state.transitionMode = TransitionMode.Instantaneous;
const stateBase: TestStateBase = new TestStateBase(state);
const helper: NodeHelper = new NodeHelper();
const fullNode1: IFullNode = helper.createFullNode();
const fullNode1: ImageEnt = helper.createFullNode();
fullNode1.merge_cc = 1;
fullNode1.merge_version = 1;
const node1: Node = new TestNode(fullNode1);
node1.makeFull(fullNode1);
const fullNode2: IFullNode = helper.createFullNode();
const fullNode2: ImageEnt = helper.createFullNode();
fullNode2.merge_cc = 1;
fullNode2.merge_version = 1;
const node2: Node = new TestNode(fullNode2);
@ -142,7 +142,7 @@ describe("StateBase.motionlessTransition", () => {
describe("StateBase.set", () => {
it("should set current node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let node: Node = createFullNode();
@ -154,7 +154,7 @@ describe("StateBase.set", () => {
});
it("should set multiple nodes", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
stateBase.set([
@ -177,14 +177,14 @@ describe("StateBase.remove", () => {
});
it("should throw when removing negative number", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
expect((): void => { stateBase.remove(-1); }).toThrowError(Error);
});
it("should throw when removing current node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let node: Node = createFullNode();
@ -194,7 +194,7 @@ describe("StateBase.remove", () => {
});
it("should throw when removing previous node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
@ -205,11 +205,11 @@ describe("StateBase.remove", () => {
});
it("should remove one node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -226,11 +226,11 @@ describe("StateBase.remove", () => {
});
it("should remove multiple nodes", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -260,7 +260,7 @@ describe("StateBase.clear", () => {
});
it("should clear empty state without affecting it", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
stateBase.clear();
@ -269,11 +269,11 @@ describe("StateBase.clear", () => {
});
it("should remove one previous node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -290,11 +290,11 @@ describe("StateBase.clear", () => {
});
it("should remove multiple previous nodes", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -316,11 +316,11 @@ describe("StateBase.clear", () => {
});
it("should remove one coming node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -337,11 +337,11 @@ describe("StateBase.clear", () => {
});
it("should remove multiple coming nodes", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -363,11 +363,11 @@ describe("StateBase.clear", () => {
});
it("should remove one previous and one coming node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -393,7 +393,7 @@ describe("StateBase.clearPrior", () => {
});
it("should clear prior of empty state without affecting it", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
stateBase.clearPrior();
@ -402,11 +402,11 @@ describe("StateBase.clearPrior", () => {
});
it("should remove one previous node", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());
@ -423,11 +423,11 @@ describe("StateBase.clearPrior", () => {
});
it("should remove multiple previous nodes", () => {
let state: IState = createState();
let state: IStateBase = createState();
let stateBase: TestStateBase = new TestStateBase(state);
let coreNode: ICoreNode = helper.createCoreNode();
let coreNode: CoreImageEnt = helper.createCoreNode();
coreNode.key = "currentNode";
let node: TestNode = new TestNode(coreNode);
node.makeFull(helper.createFillNode());

32
spec/state/TraversingState.spec.ts
View File

@ -6,8 +6,8 @@ import * as THREE from "three";
import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { IState } from "../../src/state/interfaces/IState";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { IStateBase } from "../../src/state/interfaces/IStateBase";
import { TraversingState } from "../../src/state/states/TraversingState";
import { Camera } from "../../src/geo/Camera";
import { TransitionMode } from "../../src/state/TransitionMode";
@ -17,7 +17,7 @@ const transformHelper = new TransformHelper();
describe("TraversingState.ctor", () => {
it("should be defined", () => {
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: new Camera(),
currentIndex: -1,
@ -76,7 +76,7 @@ describe("TraversingState.currentCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -89,7 +89,7 @@ describe("TraversingState.currentCamera.lookat", () => {
let traversingState: TestTraversingState = new TestTraversingState(state);
let node: TestNode = new TestNode();
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
traversingState.set([node]);
@ -108,7 +108,7 @@ describe("TraversingState.currentCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -121,12 +121,12 @@ describe("TraversingState.currentCamera.lookat", () => {
let traversingState: TestTraversingState = new TestTraversingState(state);
let previousNode: TestNode = new TestNode();
let previousFillNode: IFillNode = helper.createFillNode();
let previousFillNode: SpatialImageEnt = helper.createFillNode();
previousFillNode.c_rotation = [Math.PI, 0, 0];
previousNode.makeFull(previousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentNode.makeFull(currentFillNode);
traversingState.set([previousNode]);
@ -146,7 +146,7 @@ describe("TraversingState.currentCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -159,12 +159,12 @@ describe("TraversingState.currentCamera.lookat", () => {
let traversingState: TestTraversingState = new TestTraversingState(state);
let previousNode: TestNode = new TestNode();
let preivousFillNode: IFillNode = helper.createFillNode();
let preivousFillNode: SpatialImageEnt = helper.createFillNode();
preivousFillNode.c_rotation = [Math.PI, 0, 0];
previousNode.makeFull(preivousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentFillNode.camera_projection_type = "equirectangular";
currentNode.makeFull(currentFillNode);
@ -198,7 +198,7 @@ describe("TraversingState.previousCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -211,7 +211,7 @@ describe("TraversingState.previousCamera.lookat", () => {
let traversingState: TestTraversingState = new TestTraversingState(state);
let node: TestNode = new TestNode();
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
traversingState.set([node]);
@ -230,7 +230,7 @@ describe("TraversingState.previousCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -243,12 +243,12 @@ describe("TraversingState.previousCamera.lookat", () => {
let traversingState: TestTraversingState = new TestTraversingState(state);
let previousNode: TestNode = new TestNode();
let previousFillNode: IFillNode = helper.createFillNode();
let previousFillNode: SpatialImageEnt = helper.createFillNode();
previousFillNode.c_rotation = [Math.PI, 0, 0];
previousNode.makeFull(previousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentNode.makeFull(currentFillNode);
traversingState.set([previousNode]);

38
spec/state/WaitingState.spec.ts
View File

@ -3,8 +3,8 @@ import * as THREE from "three";
import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { IFillNode } from "../../src/api/interfaces/IFillNode";
import { IState } from "../../src/state/interfaces/IState";
import { SpatialImageEnt } from "../../src/api/ents/SpatialImageEnt";
import { IStateBase } from "../../src/state/interfaces/IStateBase";
import { WaitingState } from "../../src/state/states/WaitingState";
import { Camera } from "../../src/geo/Camera";
import { TransitionMode } from "../../src/state/TransitionMode";
@ -14,7 +14,7 @@ const transformHelper = new TransformHelper();
describe("WaitingState.ctor", () => {
it("should be defined", () => {
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: new Camera(),
currentIndex: -1,
@ -73,7 +73,7 @@ describe("WaitingState.currentCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -86,7 +86,7 @@ describe("WaitingState.currentCamera.lookat", () => {
let waitingState: TestWaitingState = new TestWaitingState(state);
let node: TestNode = new TestNode();
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
waitingState.set([node]);
@ -105,7 +105,7 @@ describe("WaitingState.currentCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -118,12 +118,12 @@ describe("WaitingState.currentCamera.lookat", () => {
let waitingState: TestWaitingState = new TestWaitingState(state);
let previousNode: TestNode = new TestNode();
let previousFillNode: IFillNode = helper.createFillNode();
let previousFillNode: SpatialImageEnt = helper.createFillNode();
previousFillNode.c_rotation = [Math.PI, 0, 0];
previousNode.makeFull(previousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentNode.makeFull(currentFillNode);
waitingState.set([previousNode]);
@ -143,7 +143,7 @@ describe("WaitingState.currentCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -156,12 +156,12 @@ describe("WaitingState.currentCamera.lookat", () => {
let waitingState: TestWaitingState = new TestWaitingState(state);
let previousNode: TestNode = new TestNode();
let previousFillNode: IFillNode = helper.createFillNode();
let previousFillNode: SpatialImageEnt = helper.createFillNode();
previousFillNode.c_rotation = [Math.PI, 0, 0];
previousNode.makeFull(previousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentFillNode.camera_projection_type = "equirectangular";
currentNode.makeFull(currentFillNode);
@ -199,7 +199,7 @@ describe("WaitingState.previousCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -212,7 +212,7 @@ describe("WaitingState.previousCamera.lookat", () => {
let waitingState: TestWaitingState = new TestWaitingState(state);
let node: TestNode = new TestNode();
let fillNode: IFillNode = helper.createFillNode();
let fillNode: SpatialImageEnt = helper.createFillNode();
node.makeFull(fillNode);
waitingState.set([node]);
@ -231,7 +231,7 @@ describe("WaitingState.previousCamera.lookat", () => {
camera.position.fromArray([10, 10, 0]);
camera.lookat.fromArray([15, 15, 0]);
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -244,11 +244,11 @@ describe("WaitingState.previousCamera.lookat", () => {
let waitingState: TestWaitingState = new TestWaitingState(state);
let previousNode: TestNode = new TestNode();
let previousFillNode: IFillNode = helper.createFillNode();
let previousFillNode: SpatialImageEnt = helper.createFillNode();
previousNode.makeFull(previousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentFillNode.c_rotation = [Math.PI, 0, 0];
currentNode.makeFull(currentFillNode);
@ -267,7 +267,7 @@ describe("WaitingState.previousCamera.lookat", () => {
it("should correspond to direction of current camera when spherical and previous node set", () => {
let camera: Camera = new Camera();
let state: IState = {
let state: IStateBase = {
alpha: 1,
camera: camera,
currentIndex: -1,
@ -280,13 +280,13 @@ describe("WaitingState.previousCamera.lookat", () => {
let waitingState: TestWaitingState = new TestWaitingState(state);
let previousNode: TestNode = new TestNode();
let previousFillNode: IFillNode = helper.createFillNode();
let previousFillNode: SpatialImageEnt = helper.createFillNode();
previousFillNode.camera_projection_type = "equirectangular";
previousNode.makeFull(previousFillNode);
let currentNode: TestNode = new TestNode();
let currentFillNode: IFillNode = helper.createFillNode();
let currentFillNode: SpatialImageEnt = helper.createFillNode();
currentFillNode.c_rotation = [0.2, 0.3, 0.4];
currentNode.makeFull(currentFillNode);

24
spec/tiles/TextureProvider.spec.ts
View File

@ -2,7 +2,7 @@ import { empty as observableEmpty } from "rxjs";
import * as THREE from "three";
import { ImageTileLoader } from "../../src/tiles/ImageTileLoader";
import { ImageTileStore } from "../../src/tiles/ImageTileStore";
import { IRegionOfInterest } from "../../src/tiles/interfaces/IRegionOfInterest";
import { TileRegionOfInterest } from "../../src/tiles/interfaces/TileRegionOfInterest";
import { TextureProvider } from "../../src/tiles/TextureProvider";
import { MockCreator } from "../helper/MockCreator";
@ -77,7 +77,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 0, maxY: 0, minX: 0, minY: 0 },
pixelHeight: 1 / height,
pixelWidth: 1 / width,
@ -129,7 +129,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 0, minY: 0 },
pixelHeight: 1 / height / 4,
pixelWidth: 1 / width / 4,
@ -181,7 +181,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 0, minY: 0 },
pixelHeight: 2 / height,
pixelWidth: 2 / width,
@ -233,7 +233,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 0, minY: 0 },
pixelHeight: 2,
pixelWidth: 2,
@ -285,7 +285,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 1, minY: 0 },
pixelHeight: 1 / height / 2,
pixelWidth: 1 / width / 2,
@ -337,7 +337,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 0, minY: 1 },
pixelHeight: 1 / height / 2,
pixelWidth: 1 / width / 2,
@ -389,7 +389,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 1, minY: 1 },
pixelHeight: 1 / height / 2,
pixelWidth: 1 / width / 2,
@ -441,7 +441,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 0, minY: 0 },
pixelHeight: 1 / tileSize,
pixelWidth: 1 / tileSize,
@ -493,7 +493,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 1, maxY: 1, minX: 0, minY: 0 },
pixelHeight: 2 / tileSize,
pixelWidth: 2 / tileSize,
@ -545,7 +545,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 0.75, maxY: 0.25, minX: 0.25, minY: 0 },
pixelHeight: 1 / width,
pixelWidth: 1 / height,
@ -606,7 +606,7 @@ describe("TextureProvider.setRegionOfInterest", () => {
imageTileStore,
rendererMock);
let roi: IRegionOfInterest = {
let roi: TileRegionOfInterest = {
bbox: { maxX: 0.25, maxY: 0.75, minX: 0, minY: 0.25 },
pixelHeight: 1 / width,
pixelWidth: 1 / height,

4
spec/utils/Urls.spec.ts
View File

@ -1,9 +1,9 @@
import { Urls } from "../../src/utils/Urls";
import { IUrlOptions } from "../../src/viewer/interfaces/IUrlOptions";
import { UrlOptions } from "../../src/viewer/interfaces/UrlOptions";
describe("Urls.setOptions", () => {
it("should set all option properties", () => {
const options: IUrlOptions = {
const options: UrlOptions = {
exploreHost: "test-explore",
scheme: "test-scheme",
};

54
spec/viewer/CacheService.spec.ts
View File

@ -8,12 +8,12 @@ import { NodeHelper } from "../helper/NodeHelper";
import { Node } from "../../src/graph/Node";
import { APIWrapper } from "../../src/api/APIWrapper";
import { FalcorDataProvider } from "../../src/api/FalcorDataProvider";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { Graph } from "../../src/graph/Graph";
import { GraphMode } from "../../src/graph/GraphMode";
import { GraphService } from "../../src/graph/GraphService";
import { ICurrentState } from "../../src/state/interfaces/ICurrentState";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { IAnimationState } from "../../src/state/interfaces/IAnimationState";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { State } from "../../src/state/State";
import { StateService } from "../../src/state/StateService";
import { CacheService } from "../../src/viewer/CacheService";
@ -68,20 +68,20 @@ describe("CacheService.started", () => {
});
class TestStateService extends StateService {
private _overridingCurrentState$: Subject<IFrame>;
private _overridingCurrentState$: Subject<AnimationFrame>;
constructor(currentState$: Subject<IFrame>) {
constructor(currentState$: Subject<AnimationFrame>) {
super();
this._overridingCurrentState$ = currentState$;
}
public get currentState$(): Subject<IFrame> {
public get currentState$(): Subject<AnimationFrame> {
return this._overridingCurrentState$;
}
}
const createState: () => ICurrentState = (): ICurrentState => {
const createState: () => IAnimationState = (): IAnimationState => {
return {
alpha: 0,
camera: null,
@ -114,7 +114,7 @@ describe("CacheService.start", () => {
const graphService: GraphService = new GraphService(graph);
graphService.setGraphMode(GraphMode.Spatial);
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const uncacheSpy: jasmine.Spy = spyOn(graphService, "uncache$");
@ -125,15 +125,15 @@ describe("CacheService.start", () => {
cacheService.start();
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const coreNode2: ICoreNode = helper.createCoreNode();
const coreNode2: CoreImageEnt = helper.createCoreNode();
coreNode2.key = "node2";
const node2: Node = new Node(coreNode2);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1, node2];
state.currentNode = node1;
@ -156,7 +156,7 @@ describe("CacheService.start", () => {
const graphService: GraphService = new GraphService(graph);
graphService.setGraphMode(GraphMode.Sequence);
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const uncacheSpy: jasmine.Spy = spyOn(graphService, "uncache$");
@ -167,16 +167,16 @@ describe("CacheService.start", () => {
cacheService.start();
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const coreNode2: ICoreNode = helper.createCoreNode();
const coreNode2: CoreImageEnt = helper.createCoreNode();
coreNode2.key = "node2";
coreNode2.sequence_key = "sequence2";
const node2: Node = new Node(coreNode2);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1, node2];
state.currentNode = node1;
@ -202,7 +202,7 @@ describe("CacheService.start", () => {
graphService.setGraphMode(GraphMode.Spatial);
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const cacheNodeSpy: jasmine.Spy = spyOn(graphService, "cacheNode$");
@ -213,15 +213,15 @@ describe("CacheService.start", () => {
cacheService.start();
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const coreNode2: ICoreNode = helper.createCoreNode();
const coreNode2: CoreImageEnt = helper.createCoreNode();
coreNode2.key = "node2";
const node2: Node = new Node(coreNode2);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1, node2];
state.currentNode = node1;
@ -245,7 +245,7 @@ describe("CacheService.start", () => {
graphService.setGraphMode(GraphMode.Sequence);
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const cacheNodeSpy: jasmine.Spy = spyOn(graphService, "cacheNode$");
@ -256,19 +256,19 @@ describe("CacheService.start", () => {
cacheService.start();
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const coreNode2: ICoreNode = helper.createCoreNode();
const coreNode2: CoreImageEnt = helper.createCoreNode();
coreNode2.key = "node2";
const node2: Node = new Node(coreNode2);
const coreNode3: ICoreNode = helper.createCoreNode();
const coreNode3: CoreImageEnt = helper.createCoreNode();
coreNode3.key = "node3";
const node3: Node = new Node(coreNode3);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1, node2, node3];
state.currentNode = node2;
state.currentIndex = 1;
@ -295,7 +295,7 @@ describe("CacheService.start", () => {
spyOn(graphService, "uncache$").and.returnValue(observableOf<void>(null));
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const cacheNodeSpy: jasmine.Spy = spyOn(graphService, "cacheNode$");
@ -304,11 +304,11 @@ describe("CacheService.start", () => {
cacheService.start();
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1];
state.currentNode = node1;
state.currentIndex = 0;

16
spec/viewer/ComponentController.spec.ts
View File

@ -10,23 +10,23 @@ import { NodeMockCreator } from "../helper/NodeMockCreator";
import { MockCreator } from "../helper/MockCreator";
import { ComponentService } from "../../src/component/ComponentService";
import { CoverComponent } from "../../src/component/CoverComponent";
import { ICoverConfiguration, CoverState } from "../../src/component/interfaces/ICoverConfiguration";
import { CoverConfiguration, CoverState } from "../../src/component/interfaces/CoverConfiguration";
import { Container } from "../../src/viewer/Container";
import { Observer } from "../../src/viewer/Observer";
import { EventEmitter } from "../../src/utils/EventEmitter";
import { ComponentController } from "../../src/viewer/ComponentController";
import { Viewer } from "../../src/viewer/Viewer";
import { Component } from "../../src/component/Component";
import { IComponentConfiguration } from "../../src/component/interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "../../src/component/interfaces/ComponentConfiguration";
class ComponentMock extends Component<IComponentConfiguration> {
class ComponentMock extends Component<ComponentConfiguration> {
protected static _cn: string = "mock";
public static get componentName(): string {
return this._cn;
};
protected _activate(): void { /*noop*/ }
protected _deactivate(): void { /*noop*/ }
protected _getDefaultConfiguration(): IComponentConfiguration {
protected _getDefaultConfiguration(): ComponentConfiguration {
return {};
}
}
@ -74,7 +74,7 @@ ComponentService.register(ZC);
class CoverComponentMock extends CoverComponent {
protected _activate(): void { /*noop*/ }
protected _deactivate(): void { /*noop*/ }
protected _getDefaultConfiguration(): IComponentConfiguration {
protected _getDefaultConfiguration(): ComponentConfiguration {
return {};
}
}
@ -203,7 +203,7 @@ describe("ComponentController.navigable", () => {
skip(1), // skip initial default configuration
take(1))
.subscribe(
(c: ICoverConfiguration): void => {
(c: CoverConfiguration): void => {
expect(c.key).toBe(key);
});
@ -253,11 +253,11 @@ describe("ComponentController.navigable", () => {
let configurationCount: number = 0;
coverComponent.configuration$.pipe(
first(
(c: ICoverConfiguration): boolean => {
(c: CoverConfiguration): boolean => {
return c.state === CoverState.Hidden;
}))
.subscribe(
(c: ICoverConfiguration): void => {
(c: CoverConfiguration): void => {
configurationCount++;
expect(c.key).toBe(key);
});

12
spec/viewer/CustomRenderer.spec.ts
View File

@ -12,7 +12,7 @@ import { ContainerMockCreator } from "../helper/ContainerMockCreator";
import { MockCreator } from "../helper/MockCreator";
import { NavigatorMockCreator } from "../helper/NavigatorMockCreator";
import { RendererMock } from "../helper/WebGLRenderer";
import { ILatLonAlt } from "../../src/geo/interfaces/ILatLonAlt";
import { LatLonAltEnt } from "../../src/api/ents/LatLonAltEnt";
import { RenderCamera } from "../../src/render/RenderCamera";
import { RenderMode } from "../../src/render/RenderMode";
@ -99,7 +99,7 @@ describe("CustomRenderer.add", () => {
spyOn(rendererMock, "getContext").and.returnValue(contextMock);
(<Subject<WebGLRenderer>>container.glRenderer.webGLRenderer$)
.next(rendererMock);
(<Subject<ILatLonAlt>>navigator.stateService.reference$)
(<Subject<LatLonAltEnt>>navigator.stateService.reference$)
.next(referenceMock);
});
@ -134,7 +134,7 @@ describe("CustomRenderer.add", () => {
spyOn(rendererMock, "getContext").and.returnValue(contextMock);
(<Subject<WebGLRenderer>>container.glRenderer.webGLRenderer$)
.next(rendererMock);
(<Subject<ILatLonAlt>>navigator.stateService.reference$)
(<Subject<LatLonAltEnt>>navigator.stateService.reference$)
.next(referenceMock);
expect(invokeCount).toBe(0);
@ -172,9 +172,9 @@ describe("CustomRenderer.add", () => {
(<Subject<WebGLRenderer>>container.glRenderer.webGLRenderer$)
.next(rendererMock);
(<Subject<ILatLonAlt>>navigator.stateService.reference$)
(<Subject<LatLonAltEnt>>navigator.stateService.reference$)
.next(referenceMock);
(<Subject<ILatLonAlt>>navigator.stateService.reference$)
(<Subject<LatLonAltEnt>>navigator.stateService.reference$)
.next(referenceMock);
expect(invokeCount).toBe(1);
@ -215,7 +215,7 @@ describe("CustomRenderer.add", () => {
spyOn(rendererMock, "getContext").and.returnValue(contextMock);
(<Subject<WebGLRenderer>>container.glRenderer.webGLRenderer$)
.next(rendererMock);
(<Subject<ILatLonAlt>>navigator.stateService.reference$)
(<Subject<LatLonAltEnt>>navigator.stateService.reference$)
.next(referenceMock);
const renderCameraMock = new RenderCamera(1, 1, RenderMode.Fill);

38
spec/viewer/Navigator.spec.ts
View File

@ -17,19 +17,19 @@ import { Navigator } from "../../src/viewer/Navigator";
import { Node } from "../../src/graph/Node";
import { APIWrapper } from "../../src/api/APIWrapper";
import { FalcorDataProvider } from "../../src/api/FalcorDataProvider";
import { ICoreNode } from "../../src/api/interfaces/ICoreNode";
import { CoreImageEnt } from "../../src/api/ents/CoreImageEnt";
import { Graph } from "../../src/graph/Graph";
import { GraphService } from "../../src/graph/GraphService";
import { ICurrentState } from "../../src/state/interfaces/ICurrentState";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { IAnimationState } from "../../src/state/interfaces/IAnimationState";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { State } from "../../src/state/State";
import { StateService } from "../../src/state/StateService";
import { CacheService } from "../../src/viewer/CacheService";
import { LoadingService } from "../../src/viewer/LoadingService";
import { AbortMapillaryError } from "../../src/error/AbortMapillaryError";
import { EdgeDirection } from "../../src/graph/edge/EdgeDirection";
import { NavigationDirection } from "../../src/graph/edge/NavigationDirection";
const createState: () => ICurrentState = (): ICurrentState => {
const createState: () => IAnimationState = (): IAnimationState => {
return {
alpha: 0,
camera: null,
@ -406,15 +406,15 @@ describe("Navigator.movedToKey$", () => {
});
class TestStateService extends StateService {
private _overridingCurrentState$: Subject<IFrame>;
private _overridingCurrentState$: Subject<AnimationFrame>;
constructor(currentState$: Subject<IFrame>) {
constructor(currentState$: Subject<AnimationFrame>) {
super();
this._overridingCurrentState$ = currentState$;
}
public get currentState$(): Subject<IFrame> {
public get currentState$(): Subject<AnimationFrame> {
return this._overridingCurrentState$;
}
}
@ -572,7 +572,7 @@ describe("Navigator.setFilter$", () => {
const graphService: GraphService = new GraphService(graph);
const loadingService: LoadingService = new LoadingService();
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const cacheService: CacheService = new CacheService(graphService, stateService);
@ -613,7 +613,7 @@ describe("Navigator.setFilter$", () => {
navigator.moveToKey$("key").subscribe(() => { /*noop*/ });
const coreNode0: ICoreNode = helper.createCoreNode();
const coreNode0: CoreImageEnt = helper.createCoreNode();
coreNode0.key = "node0";
const node0: Node = new Node(coreNode0);
@ -635,15 +635,15 @@ describe("Navigator.setFilter$", () => {
done();
});
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const coreNode2: ICoreNode = helper.createCoreNode();
const coreNode2: CoreImageEnt = helper.createCoreNode();
coreNode2.key = "node2";
const node2: Node = new Node(coreNode2);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1, node2];
currentStateSubject$.next({ fps: 60, id: 0, state: state });
@ -716,7 +716,7 @@ describe("Navigator.setToken$", () => {
const graphService: GraphService = new GraphService(graph);
const loadingService: LoadingService = new LoadingService();
const currentStateSubject$: Subject<IFrame> = new Subject<IFrame>();
const currentStateSubject$: Subject<AnimationFrame> = new Subject<AnimationFrame>();
const stateService: TestStateService = new TestStateService(currentStateSubject$);
const cacheService: CacheService = new CacheService(graphService, stateService);
@ -758,7 +758,7 @@ describe("Navigator.setToken$", () => {
navigator.moveToKey$("key").subscribe(() => { /*noop*/ });
const coreNode0: ICoreNode = helper.createCoreNode();
const coreNode0: CoreImageEnt = helper.createCoreNode();
coreNode0.key = "node0";
const node0: Node = new Node(coreNode0);
@ -786,15 +786,15 @@ describe("Navigator.setToken$", () => {
done();
});
const coreNode1: ICoreNode = helper.createCoreNode();
const coreNode1: CoreImageEnt = helper.createCoreNode();
coreNode1.key = "node1";
const node1: Node = new Node(coreNode1);
const coreNode2: ICoreNode = helper.createCoreNode();
const coreNode2: CoreImageEnt = helper.createCoreNode();
coreNode2.key = "node2";
const node2: Node = new Node(coreNode2);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [node1, node2];
currentStateSubject$.next({ fps: 60, id: 0, state: state });
@ -861,7 +861,7 @@ describe("Navigator.setToken$", () => {
stateService,
cacheService);
navigator.moveDir$(EdgeDirection.Next)
navigator.moveDir$(NavigationDirection.Next)
.subscribe(
undefined,
(e: Error): void => {

26
spec/viewer/PanService.spec.ts
View File

@ -3,9 +3,9 @@ import { skip } from "rxjs/operators";
import { Node } from "../../src/graph/Node";
import { Transform } from "../../src/geo/Transform";
import { ILatLonAlt } from "../../src/geo/interfaces/ILatLonAlt";
import { LatLonAltEnt } from "../../src/api/ents/LatLonAltEnt";
import { GraphService } from "../../src/graph/GraphService";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { StateService } from "../../src/state/StateService";
import { PanService } from "../../src/viewer/PanService";
import { FrameHelper } from "../helper/FrameHelper";
@ -40,9 +40,9 @@ describe("PanService.panNodes$", () => {
done();
});
(<Subject<IFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<AnimationFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<Node>>stateService.currentNode$).next(new NodeHelper().createNode());
(<Subject<ILatLonAlt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
(<Subject<LatLonAltEnt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
});
it("should emit", (done: Function) => {
@ -63,9 +63,9 @@ describe("PanService.panNodes$", () => {
done();
});
(<Subject<IFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<AnimationFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<Node>>stateService.currentNode$).next(new NodeHelper().createNode());
(<Subject<ILatLonAlt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
(<Subject<LatLonAltEnt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
cacheBoundingBoxSubject.next([]);
});
@ -87,9 +87,9 @@ describe("PanService.panNodes$", () => {
done();
});
(<Subject<IFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<AnimationFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<Node>>stateService.currentNode$).next(new NodeHelper().createUnmergedNode());
(<Subject<ILatLonAlt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
(<Subject<LatLonAltEnt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
cacheBoundingBoxSubject.next([]);
});
@ -112,9 +112,9 @@ describe("PanService.panNodes$", () => {
emitCount++;
});
(<Subject<IFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<AnimationFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<Node>>stateService.currentNode$).next(new NodeHelper().createNode());
(<Subject<ILatLonAlt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
(<Subject<LatLonAltEnt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
erroredCacheBoundingBoxSubject.error(new Error());
expect(emitCount).toBe(1);
@ -123,7 +123,7 @@ describe("PanService.panNodes$", () => {
(<jasmine.Spy>graphService.cacheBoundingBox$).and.returnValue(cacheBoundingBoxSubject);
(<Subject<Node>>stateService.currentNode$).next(new NodeHelper().createNode());
(<Subject<ILatLonAlt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
(<Subject<LatLonAltEnt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
cacheBoundingBoxSubject.next([]);
@ -150,9 +150,9 @@ describe("PanService.panNodes$", () => {
done();
});
(<Subject<IFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<AnimationFrame>>stateService.currentState$).next(new FrameHelper().createFrame());
(<Subject<Node>>stateService.currentNode$).next(new NodeHelper().createNode());
(<Subject<ILatLonAlt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
(<Subject<LatLonAltEnt>>stateService.reference$).next({ alt: 0, lat: 0, lon: 0 });
cacheBoundingBoxSubject.next([]);
});
});

208
spec/viewer/PlayService.spec.ts
View File

@ -15,19 +15,19 @@ import { FrameHelper } from "../helper/FrameHelper";
import { Node } from "../../src/graph/Node";
import { APIWrapper } from "../../src/api/APIWrapper";
import { FalcorDataProvider } from "../../src/api/FalcorDataProvider";
import { IFullNode } from "../../src/api/interfaces/IFullNode";
import { ImageEnt } from "../../src/api/ents/ImageEnt";
import { Graph } from "../../src/graph/Graph";
import { GraphMode } from "../../src/graph/GraphMode";
import { GraphService } from "../../src/graph/GraphService";
import { IEdgeStatus } from "../../src/graph/interfaces/IEdgeStatus";
import { NavigationEdgeStatus } from "../../src/graph/interfaces/NavigationEdgeStatus";
import { NodeCache } from "../../src/graph/NodeCache";
import { Sequence } from "../../src/graph/Sequence";
import { ICurrentState } from "../../src/state/interfaces/ICurrentState";
import { IFrame } from "../../src/state/interfaces/IFrame";
import { IAnimationState } from "../../src/state/interfaces/IAnimationState";
import { AnimationFrame } from "../../src/state/interfaces/AnimationFrame";
import { State } from "../../src/state/State";
import { StateService } from "../../src/state/StateService";
import { PlayService } from "../../src/viewer/PlayService";
import { EdgeDirection } from "../../src/graph/edge/EdgeDirection";
import { NavigationDirection } from "../../src/graph/edge/NavigationDirection";
describe("PlayService.ctor", () => {
it("should be defined when constructed", () => {
@ -53,8 +53,8 @@ describe("PlayService.ctor", () => {
playService.speed$).pipe(
first())
.subscribe(
([d, p, s]: [EdgeDirection, boolean, number]): void => {
expect(d).toBe(EdgeDirection.Next);
([d, p, s]: [NavigationDirection, boolean, number]): void => {
expect(d).toBe(NavigationDirection.Next);
expect(p).toBe(false);
expect(s).toBe(0.5);
@ -199,7 +199,7 @@ describe("PlayService.speed$", () => {
});
});
let createState: () => ICurrentState = (): ICurrentState => {
let createState: () => IAnimationState = (): IAnimationState => {
return {
alpha: 0,
camera: null,
@ -260,13 +260,13 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(observableOf([]));
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.state.currentNode.initializeCache(new NodeCache(undefined));
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
frame.state.currentNode.cacheSequenceEdges([]);
@ -281,7 +281,7 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(observableOf([]));
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
@ -300,17 +300,17 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(new Subject<Node[]>());
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
const node: Node = frame.state.currentNode;
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
sequenceEdgesSubject.error(new Error());
@ -324,7 +324,7 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(observableOf([]));
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
let firstEmit: boolean = true;
playService.playing$.pipe(
@ -345,9 +345,9 @@ describe("PlayService.play", () => {
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
frame.state.currentNode.initializeCache(new NodeCache(undefined));
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
frame.state.currentNode.cacheSequenceEdges([]);
});
@ -360,17 +360,17 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(observableOf([]));
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
const node: Node = frame.state.currentNode;
node.initializeCache(new NodeCache(undefined));
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
sequenceEdgesSubject.next({ cached: false, edges: [] });
@ -390,16 +390,16 @@ describe("PlayService.play", () => {
const cacheBoundingBoxSubject: Subject<Node[]> = new Subject<Node[]>();
spyOn(graphService, "cacheBoundingBox$").and.returnValue(cacheBoundingBoxSubject);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
const node: Node = frame.state.currentNode;
node.initializeCache(new NodeCache(undefined));
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
const prevFullNode: IFullNode = new NodeHelper().createFullNode();
const prevFullNode: ImageEnt = new NodeHelper().createFullNode();
prevFullNode.captured_at = -1;
const prevNode: Node = new Node(prevFullNode);
prevNode.makeFull(prevFullNode);
@ -408,7 +408,7 @@ describe("PlayService.play", () => {
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
sequenceEdgesSubject.next({ cached: false, edges: [] });
@ -438,24 +438,24 @@ describe("PlayService.play", () => {
const appendNodesSpy: jasmine.Spy = <jasmine.Spy>stateService.appendNodes;
appendNodesSpy.and.stub();
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const cameraUuid: string = "camera_uuid";
const sequenceKey1: string = "sequence1";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.captured_at = 0;
currentFullNode.captured_with_camera_uuid = cameraUuid;
currentFullNode.key = "currKey";
currentFullNode.sequence_key = sequenceKey1;
const currentNode: Node = new Node(currentFullNode);
currentNode.makeFull(currentFullNode);
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(currentNode, "sequenceEdges$", sequenceEdgesSubject);
const prevFullNode: IFullNode = new NodeHelper().createFullNode();
const prevFullNode: ImageEnt = new NodeHelper().createFullNode();
prevFullNode.captured_at = -1;
prevFullNode.captured_with_camera_uuid = cameraUuid;
prevFullNode.key = "prevKey";
@ -463,20 +463,20 @@ describe("PlayService.play", () => {
const prevNode: Node = new Node(prevFullNode);
prevNode.makeFull(prevFullNode);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [prevNode, currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
state.currentIndex = 1;
(<Subject<IFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
(<Subject<AnimationFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
sequenceEdgesSubject.next({ cached: true, edges: [] });
expect(stopSpy.calls.count()).toBe(0);
const bridgeFullNode: IFullNode = new NodeHelper().createFullNode();
const bridgeFullNode: ImageEnt = new NodeHelper().createFullNode();
bridgeFullNode.captured_at = 1;
bridgeFullNode.captured_with_camera_uuid = cameraUuid;
bridgeFullNode.key = "bridgeKey";
@ -511,24 +511,24 @@ describe("PlayService.play", () => {
const appendNodesSpy: jasmine.Spy = <jasmine.Spy>stateService.appendNodes;
appendNodesSpy.and.stub();
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const cameraUuid: string = "camera_uuid";
const sequenceKey1: string = "sequence1";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.captured_at = -1;
currentFullNode.captured_with_camera_uuid = cameraUuid;
currentFullNode.key = "currKey";
currentFullNode.sequence_key = sequenceKey1;
const currentNode: Node = new Node(currentFullNode);
currentNode.makeFull(currentFullNode);
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(currentNode, "sequenceEdges$", sequenceEdgesSubject);
const prevFullNode: IFullNode = new NodeHelper().createFullNode();
const prevFullNode: ImageEnt = new NodeHelper().createFullNode();
prevFullNode.captured_at = 0;
prevFullNode.captured_with_camera_uuid = cameraUuid;
prevFullNode.key = "prevKey";
@ -536,14 +536,14 @@ describe("PlayService.play", () => {
const prevNode: Node = new Node(prevFullNode);
prevNode.makeFull(prevFullNode);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [prevNode, currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
state.currentIndex = 1;
(<Subject<IFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
(<Subject<AnimationFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
sequenceEdgesSubject.next({ cached: true, edges: [] });
@ -552,7 +552,7 @@ describe("PlayService.play", () => {
const cacheBoudndingBoxNodex: Node[] = [1, -3, -5]
.map(
(capturedAt: number): Node => {
const bridgeFullNode: IFullNode = new NodeHelper().createFullNode();
const bridgeFullNode: ImageEnt = new NodeHelper().createFullNode();
bridgeFullNode.captured_at = capturedAt;
bridgeFullNode.captured_with_camera_uuid = cameraUuid;
bridgeFullNode.key = "bridgeKey";
@ -563,7 +563,7 @@ describe("PlayService.play", () => {
return bridgeNode;
});
const sameSequenceFullNode: IFullNode = new NodeHelper().createFullNode();
const sameSequenceFullNode: ImageEnt = new NodeHelper().createFullNode();
sameSequenceFullNode.captured_at = -2;
sameSequenceFullNode.captured_with_camera_uuid = cameraUuid;
sameSequenceFullNode.key = "bridgeKey";
@ -601,31 +601,31 @@ describe("PlayService.play", () => {
const appendNodesSpy: jasmine.Spy = <jasmine.Spy>stateService.appendNodes;
appendNodesSpy.and.stub();
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const cameraUuid: string = "camera_uuid";
const sequenceKey1: string = "sequence1";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.captured_at = 0;
currentFullNode.captured_with_camera_uuid = cameraUuid;
currentFullNode.key = "currKey";
currentFullNode.sequence_key = sequenceKey1;
const currentNode: Node = new Node(currentFullNode);
currentNode.makeFull(currentFullNode);
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(currentNode, "sequenceEdges$", sequenceEdgesSubject);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
state.currentIndex = 0;
(<Subject<IFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
(<Subject<AnimationFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
sequenceEdgesSubject.next({ cached: true, edges: [] });
@ -648,28 +648,28 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(new Subject<Node[]>());
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
const node: Node = frame.state.currentNode;
node.initializeCache(new NodeCache(undefined));
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
const fullToNode: IFullNode = nodeHelper.createFullNode();
const fullToNode: ImageEnt = nodeHelper.createFullNode();
fullToNode.key = "toKey";
const toNode: Node = new Node(fullToNode);
sequenceEdgesSubject.next({
cached: true,
edges: [{
data: { direction: EdgeDirection.Next, worldMotionAzimuth: 0 },
from: node.key,
to: toNode.key,
data: { direction: NavigationDirection.Next, worldMotionAzimuth: 0 },
source: node.key,
target: toNode.key,
}],
});
@ -700,28 +700,28 @@ describe("PlayService.play", () => {
spyOn(graphService, "cacheSequenceNodes$").and.returnValue(new Subject<Sequence>());
spyOn(graphService, "cacheBoundingBox$").and.returnValue(new Subject<Node[]>());
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
playService.play();
const frame: IFrame = new FrameHelper().createFrame();
const frame: AnimationFrame = new FrameHelper().createFrame();
const node: Node = frame.state.currentNode;
node.initializeCache(new NodeCache(undefined));
const sequenceEdgesSubject: Subject<IEdgeStatus> = new Subject<IEdgeStatus>();
const sequenceEdgesSubject: Subject<NavigationEdgeStatus> = new Subject<NavigationEdgeStatus>();
new MockCreator().mockProperty(node, "sequenceEdges$", sequenceEdgesSubject);
(<Subject<IFrame>>stateService.currentState$).next(frame);
(<Subject<AnimationFrame>>stateService.currentState$).next(frame);
const fullToNode: IFullNode = nodeHelper.createFullNode();
const fullToNode: ImageEnt = nodeHelper.createFullNode();
fullToNode.key = "toKey";
const toNode: Node = new Node(fullToNode);
sequenceEdgesSubject.next({
cached: true,
edges: [{
data: { direction: EdgeDirection.Next, worldMotionAzimuth: 0 },
from: node.key,
to: toNode.key,
data: { direction: NavigationDirection.Next, worldMotionAzimuth: 0 },
source: node.key,
target: toNode.key,
}],
});
@ -737,7 +737,7 @@ describe("PlayService.play", () => {
it("should cache sequence when in spatial graph mode", () => {
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
// Set speed to zero so that graph mode is set to spatial when calling play
playService.setSpeed(0);
@ -749,7 +749,7 @@ describe("PlayService.play", () => {
playService.play();
const currentNode: Node = nodeHelper.createNode();
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const currentNodeSubject: Subject<Node> = <Subject<Node>>stateService.currentNode$;
currentNodeSubject.next(currentNode);
@ -764,7 +764,7 @@ describe("PlayService.play", () => {
it("should cache sequence nodes when in sequence graph mode", () => {
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
// Set speed to one so that graph mode is set to sequence when calling play
playService.setSpeed(1);
@ -776,7 +776,7 @@ describe("PlayService.play", () => {
playService.play();
const currentNode: Node = nodeHelper.createNode();
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const currentNodeSubject: Subject<Node> = <Subject<Node>>stateService.currentNode$;
currentNodeSubject.next(currentNode);
@ -793,7 +793,7 @@ describe("PlayService.play", () => {
graphService.setGraphMode(GraphMode.Spatial);
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
const cacheSequenceSubject: Subject<Sequence> = new Subject<Sequence>();
spyOn(graphService, "cacheSequence$").and.returnValue(cacheSequenceSubject);
@ -802,11 +802,11 @@ describe("PlayService.play", () => {
const sequenceKey: string = "sequenceKey";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.sequence_key = sequenceKey;
currentFullNode.key = "node0";
const currentNode: Node = new Node(currentFullNode);
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const prevNodeKey: string = "node1";
@ -820,13 +820,13 @@ describe("PlayService.play", () => {
const cacheNodeSubject: Subject<Node> = new Subject<Node>();
cacheNodeSpy.and.returnValue(cacheNodeSubject);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
(<Subject<IFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
(<Subject<AnimationFrame>>stateService.currentState$).next({ fps: 60, id: 0, state: state });
expect(cacheNodeSpy.calls.count()).toBe(0);
@ -837,7 +837,7 @@ describe("PlayService.play", () => {
graphService.setGraphMode(GraphMode.Spatial);
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
const cacheSequenceSubject: Subject<Sequence> = new Subject<Sequence>();
spyOn(graphService, "cacheSequence$").and.returnValue(cacheSequenceSubject);
@ -846,11 +846,11 @@ describe("PlayService.play", () => {
const sequenceKey: string = "sequenceKey";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.sequence_key = sequenceKey;
currentFullNode.key = "node0";
const currentNode: Node = new Node(currentFullNode);
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const nextNodeKey: string = "node1";
@ -864,13 +864,13 @@ describe("PlayService.play", () => {
const cacheNodeSubject: Subject<Node> = new Subject<Node>();
cacheNodeSpy.and.returnValue(cacheNodeSubject);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
const currentStateSubject$: Subject<IFrame> = <Subject<IFrame>>stateService.currentState$;
const currentStateSubject$: Subject<AnimationFrame> = <Subject<AnimationFrame>>stateService.currentState$;
currentStateSubject$.next({ fps: 60, id: 0, state: state });
cacheNodeSubject.next(new NodeHelper().createNode());
@ -885,7 +885,7 @@ describe("PlayService.play", () => {
graphService.setGraphMode(GraphMode.Spatial);
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Prev);
playService.setDirection(NavigationDirection.Prev);
const cacheSequenceSubject: Subject<Sequence> = new Subject<Sequence>();
spyOn(graphService, "cacheSequence$").and.returnValue(cacheSequenceSubject);
@ -894,11 +894,11 @@ describe("PlayService.play", () => {
const sequenceKey: string = "sequenceKey";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.sequence_key = sequenceKey;
currentFullNode.key = "node0";
const currentNode: Node = new Node(currentFullNode);
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const prevNodeKey: string = "node1";
@ -912,13 +912,13 @@ describe("PlayService.play", () => {
const cacheNodeSubject: Subject<Node> = new Subject<Node>();
cacheNodeSpy.and.returnValue(cacheNodeSubject);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
const currentStateSubject$: Subject<IFrame> = <Subject<IFrame>>stateService.currentState$;
const currentStateSubject$: Subject<AnimationFrame> = <Subject<AnimationFrame>>stateService.currentState$;
currentStateSubject$.next({ fps: 60, id: 0, state: state });
cacheNodeSubject.next(new NodeHelper().createNode());
@ -937,7 +937,7 @@ describe("PlayService.play", () => {
graphService.setGraphMode(GraphMode.Spatial);
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
const cacheSequenceSubject: Subject<Sequence> = new Subject<Sequence>();
spyOn(graphService, "cacheSequence$").and.returnValue(cacheSequenceSubject);
@ -946,12 +946,12 @@ describe("PlayService.play", () => {
const sequenceKey: string = "sequenceKey";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.sequence_key = sequenceKey;
currentFullNode.key = "node0";
const currentNode: Node = new Node(currentFullNode);
currentNode.makeFull(currentFullNode);
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const nextNodeKey: string = "node1";
@ -965,16 +965,16 @@ describe("PlayService.play", () => {
const cacheNodeSubject: Subject<Node> = new Subject<Node>();
cacheNodeSpy.and.returnValue(cacheNodeSubject);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
const currentStateSubject$: Subject<IFrame> = <Subject<IFrame>>stateService.currentState$;
const currentStateSubject$: Subject<AnimationFrame> = <Subject<AnimationFrame>>stateService.currentState$;
currentStateSubject$.next({ fps: 60, id: 0, state: state });
const nextFullNode: IFullNode = new NodeHelper().createFullNode();
const nextFullNode: ImageEnt = new NodeHelper().createFullNode();
nextFullNode.sequence_key = sequenceKey;
nextFullNode.key = nextNodeKey;
const nextNode: Node = new Node(nextFullNode);
@ -995,7 +995,7 @@ describe("PlayService.play", () => {
graphService.setGraphMode(GraphMode.Spatial);
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
const cacheSequenceSubject: Subject<Sequence> = new Subject<Sequence>();
spyOn(graphService, "cacheSequence$").and.returnValue(cacheSequenceSubject);
@ -1004,20 +1004,20 @@ describe("PlayService.play", () => {
const sequenceKey: string = "sequenceKey";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.sequence_key = sequenceKey;
currentFullNode.key = "node0";
const currentNode: Node = new Node(currentFullNode);
currentNode.makeFull(currentFullNode);
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const nextNodeKey: string = "node1";
const nextFullNode: IFullNode = new NodeHelper().createFullNode();
const nextFullNode: ImageEnt = new NodeHelper().createFullNode();
nextFullNode.sequence_key = sequenceKey;
nextFullNode.key = nextNodeKey;
const nextNode: Node = new Node(nextFullNode);
nextNode.makeFull(nextFullNode);
new MockCreator().mockProperty(nextNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(nextNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const currentNodeSubject: Subject<Node> = <Subject<Node>>stateService.currentNode$;
currentNodeSubject.next(currentNode);
@ -1029,13 +1029,13 @@ describe("PlayService.play", () => {
const cacheNodeSubject: Subject<Node> = new Subject<Node>();
cacheNodeSpy.and.returnValue(cacheNodeSubject);
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode, nextNode];
state.lastNode = nextNode;
state.currentNode = currentNode;
state.nodesAhead = 0;
const currentStateSubject$: Subject<IFrame> = <Subject<IFrame>>stateService.currentState$;
const currentStateSubject$: Subject<AnimationFrame> = <Subject<AnimationFrame>>stateService.currentState$;
currentStateSubject$.next({ fps: 60, id: 0, state: state });
expect(cacheNodeSpy.calls.count()).toBe(0);
@ -1047,7 +1047,7 @@ describe("PlayService.play", () => {
graphService.setGraphMode(GraphMode.Spatial);
const playService: PlayService = new PlayService(graphService, stateService);
playService.setDirection(EdgeDirection.Next);
playService.setDirection(NavigationDirection.Next);
// Zero speed means max ten nodes ahead
playService.setSpeed(0);
@ -1058,24 +1058,24 @@ describe("PlayService.play", () => {
const sequenceKey: string = "sequenceKey";
const currentFullNode: IFullNode = new NodeHelper().createFullNode();
const currentFullNode: ImageEnt = new NodeHelper().createFullNode();
currentFullNode.sequence_key = sequenceKey;
currentFullNode.key = "currentNodeKey";
const currentNode: Node = new Node(currentFullNode);
currentNode.makeFull(currentFullNode);
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(currentNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
const sequence: Sequence = new Sequence({ key: sequenceKey, keys: [currentNode.key] });
const sequenceNodes: Node[] = [];
for (let i: number = 0; i < 20; i++) {
const sequenceNodeKey: string = `node${i}`;
const sequenceFullNode: IFullNode = new NodeHelper().createFullNode();
const sequenceFullNode: ImageEnt = new NodeHelper().createFullNode();
sequenceFullNode.sequence_key = sequenceKey;
sequenceFullNode.key = sequenceNodeKey;
const sequenceNode: Node = new Node(sequenceFullNode);
sequenceNode.makeFull(sequenceFullNode);
new MockCreator().mockProperty(sequenceNode, "sequenceEdges$", new Subject<IEdgeStatus>());
new MockCreator().mockProperty(sequenceNode, "sequenceEdges$", new Subject<NavigationEdgeStatus>());
sequence.keys.push(sequenceNode.key);
sequenceNodes.push(sequenceNode);
@ -1088,7 +1088,7 @@ describe("PlayService.play", () => {
const cacheNodeSpy: jasmine.Spy = spyOn(graphService, "cacheNode$").and.callFake(
(key: string): Observable<Node> => {
const fullNode: IFullNode = new NodeHelper().createFullNode();
const fullNode: ImageEnt = new NodeHelper().createFullNode();
fullNode.sequence_key = sequenceKey;
fullNode.key = key;
const node: Node = new Node(fullNode);
@ -1097,7 +1097,7 @@ describe("PlayService.play", () => {
return observableOf(node);
});
const state: ICurrentState = createState();
const state: IAnimationState = createState();
state.trajectory = [currentNode];
state.lastNode = currentNode;
state.currentNode = currentNode;
@ -1105,7 +1105,7 @@ describe("PlayService.play", () => {
state.nodesAhead = 0;
// Cache ten nodes immediately
const currentStateSubject$: Subject<IFrame> = <Subject<IFrame>>stateService.currentState$;
const currentStateSubject$: Subject<AnimationFrame> = <Subject<AnimationFrame>>stateService.currentState$;
currentStateSubject$.next({ fps: 60, id: 0, state: state });
let cachedCount: number = 10;

43
src/Mapillary.ts
View File

@ -4,16 +4,21 @@
* @name Mapillary
*/
// Bootstrap spatial index.
//
// Bootstrap
// This is a workaround to make the CommonJS unit testing
// work with Jest. Once Jest/Node supports ES6 modules
// fully this should be removed.
// fully this should be removed. GeoRBush and UnitBezier
// are registered here only to avoid loading them during
// unit tests.
// Bootstrap GeoRBush
import { Graph } from "./graph/Graph";
import { MarkerSet } from "./component/marker/MarkerSet";
import { GeoRBush } from "./geo/GeoRBush";
Graph.register(GeoRBush);
MarkerSet.register(GeoRBush);
// Bootstrap UnitBezier
import UnitBezier from "@mapbox/unitbezier";
import { TraversingState } from "./state/states/TraversingState";
TraversingState.register(UnitBezier);
@ -62,26 +67,30 @@ ComponentService.register(ZoomComponent);
export { isFallbackSupported, isSupported } from "./utils/Support";
// Viewer types
export { RenderMode } from "./render/RenderMode";
export { TransitionMode } from "./state/TransitionMode";
export { Alignment } from "./viewer/Alignment";
export { ImageSize } from "./viewer/ImageSize";
export { Viewer } from "./viewer/Viewer";
export { IComponentOptions } from "./viewer/interfaces/IComponentOptions";
export { ComponentSize } from "./component/utils/ComponentSize";
export { ICustomRenderer } from "./viewer/interfaces/ICustomRenderer";
export { IPointOfView } from "./viewer/interfaces/IPointOfView";
export { IUrlOptions } from "./viewer/interfaces/IUrlOptions";
export { IViewerEvent } from "./viewer/interfaces/IViewerEvent";
export { IViewerMouseEvent } from "./viewer/interfaces/IViewerMouseEvent";
export { IViewerOptions } from "./viewer/interfaces/IViewerOptions";
export { ImageSize } from "./viewer/ImageSize";
export { PointOfView } from "./viewer/interfaces/PointOfView";
export { RenderMode } from "./render/RenderMode";
export { TransitionMode } from "./state/TransitionMode";
export { Viewer } from "./viewer/Viewer";
// Viewer events
export { ViewerEvent } from "./viewer/interfaces/ViewerEvent";
export { ViewerMouseEvent } from "./viewer/interfaces/ViewerMouseEvent";
// Viewer configuration
export { ComponentOptions } from "./viewer/interfaces/ComponentOptions";
export { UrlOptions } from "./viewer/interfaces/UrlOptions";
export { ViewerOptions } from "./viewer/interfaces/ViewerOptions";
// Graph types
export { Node } from "./graph/Node";
export { EdgeDirection } from "./graph/edge/EdgeDirection";
export { IEdge } from "./graph/edge/interfaces/IEdge";
export { IEdgeData } from "./graph/edge/interfaces/IEdgeData";
export { IEdgeStatus } from "./graph/interfaces/IEdgeStatus";
export { NavigationDirection } from "./graph/edge/NavigationDirection";
export { NavigationEdge } from "./graph/edge/interfaces/NavigationEdge";
export { NavigationEdgeData } from "./graph/edge/interfaces/NavigationEdgeData";
export { NavigationEdgeStatus } from "./graph/interfaces/NavigationEdgeStatus";
export {
FilterExpression,
FilterOperation,

16
src/api/APIWrapper.ts
View File

@ -4,10 +4,10 @@ import {
} from "rxjs";
import { DataProviderBase } from "./DataProviderBase";
import { ICoreNode } from "./interfaces/ICoreNode";
import { IFillNode } from "./interfaces/IFillNode";
import { IFullNode } from "./interfaces/IFullNode";
import { ISequence } from "./interfaces/ISequence";
import { CoreImageEnt } from "./ents/CoreImageEnt";
import { SpatialImageEnt } from "./ents/SpatialImageEnt";
import { ImageEnt } from "./ents/ImageEnt";
import { SequenceEnt } from "./ents/SequenceEnt";
/**
* @class API
@ -21,19 +21,19 @@ export class APIWrapper {
return this._data;
}
public imageByKeyFill$(keys: string[]): Observable<{ [key: string]: IFillNode }> {
public imageByKeyFill$(keys: string[]): Observable<{ [key: string]: SpatialImageEnt }> {
return this._wrapPromise$(this._data.getFillImages(keys));
}
public imageByKeyFull$(keys: string[]): Observable<{ [key: string]: IFullNode }> {
public imageByKeyFull$(keys: string[]): Observable<{ [key: string]: ImageEnt }> {
return this._wrapPromise$(this._data.getFullImages(keys));
}
public imagesByH$(h: string): Observable<{ [h: string]: { [index: string]: ICoreNode } }> {
public imagesByH$(h: string): Observable<{ [h: string]: { [index: string]: CoreImageEnt } }> {
return this._wrapPromise$(this._data.getCoreImages(h));
}
public sequenceByKey$(sequenceKeys: string[]): Observable<{ [sequenceKey: string]: ISequence }> {
public sequenceByKey$(sequenceKeys: string[]): Observable<{ [sequenceKey: string]: SequenceEnt }> {
return this._wrapPromise$(this._data.getSequences(sequenceKeys));
}

28
src/api/DataProviderBase.ts
View File

@ -1,12 +1,12 @@
import { MapillaryError } from "../error/MapillaryError";
import { EventEmitter } from "../utils/EventEmitter";
import { IClusterReconstruction } from "./interfaces/IClusterReconstruction";
import { ICoreNode } from "./interfaces/ICoreNode";
import { IFillNode } from "./interfaces/IFillNode";
import { IFullNode } from "./interfaces/IFullNode";
import { IMesh } from "./interfaces/IMesh";
import { ISequence } from "./interfaces/ISequence";
import { ReconstructionEnt } from "./ents/ReconstructionEnt";
import { CoreImageEnt } from "./ents/CoreImageEnt";
import { SpatialImageEnt } from "./ents/SpatialImageEnt";
import { ImageEnt } from "./ents/ImageEnt";
import { MeshEnt } from "./ents/MeshEnt";
import { GeometryProviderBase } from "./GeometryProviderBase";
import { SequenceEnt } from "./ents/SequenceEnt";
/**
* @class DataProviderBase
@ -59,7 +59,7 @@ export abstract class DataProviderBase extends EventEmitter {
* @throws {Error} Rejects the promise on errors.
*/
public getCoreImages(cellId: string):
Promise<{ [cellId: string]: { [imageKey: string]: ICoreNode } }> {
Promise<{ [cellId: string]: { [imageKey: string]: CoreImageEnt } }> {
return Promise.reject(new MapillaryError("Not implemented"));
}
@ -70,12 +70,12 @@ export abstract class DataProviderBase extends EventEmitter {
* to retrieve.
* @param {Promise} [abort] - Optional promise for aborting
* the request through rejection.
* @returns {Promise<IClusterReconstruction>} Promise to the
* @returns {Promise<ReconstructionEnt>} Promise to the
* cluster reconstruction.
* @throws {Error} Rejects the promise on errors.
*/
public getClusterReconstruction(url: string, abort?: Promise<void>):
Promise<IClusterReconstruction> {
Promise<ReconstructionEnt> {
return Promise.reject(new MapillaryError("Not implemented"));
}
@ -89,7 +89,7 @@ export abstract class DataProviderBase extends EventEmitter {
* @throws {Error} Rejects the promise on errors.
*/
public getFillImages(imageKeys: string[]):
Promise<{ [imageKey: string]: IFillNode }> {
Promise<{ [imageKey: string]: SpatialImageEnt }> {
return Promise.reject(new MapillaryError("Not implemented"));
}
@ -103,7 +103,7 @@ export abstract class DataProviderBase extends EventEmitter {
* @throws {Error} Rejects the promise on errors.
*/
public getFullImages(imageKeys: string[]):
Promise<{ [imageKey: string]: IFullNode }> {
Promise<{ [imageKey: string]: ImageEnt }> {
return Promise.reject(new MapillaryError("Not implemented"));
}
@ -156,10 +156,10 @@ export abstract class DataProviderBase extends EventEmitter {
* @param {string} url - URL for mesh to retrieve.
* @param {Promise} [abort] - Optional promise for aborting
* the request through rejection.
* @returns {Promise<IMesh>} Promise to the mesh.
* @returns {Promise<MeshEnt>} Promise to the mesh.
* @throws {Error} Rejects the promise on errors.
*/
public getMesh(url: string, abort?: Promise<void>): Promise<IMesh> {
public getMesh(url: string, abort?: Promise<void>): Promise<MeshEnt> {
return Promise.reject(new MapillaryError("Not implemented"));
}
@ -173,7 +173,7 @@ export abstract class DataProviderBase extends EventEmitter {
* @throws {Error} Rejects the promise on errors.
*/
public getSequences(sequenceKeys: string[]):
Promise<{ [sequenceKey: string]: ISequence }> {
Promise<{ [sequenceKey: string]: SequenceEnt }> {
return Promise.reject(new MapillaryError("Not implemented"));
}

93
src/api/FalcorDataProvider.ts
View File

@ -9,28 +9,29 @@ import { GeohashGeometryProvider } from "./GeohashGeometryProvider";
import { JsonInflator } from "./JsonInflator";
import { ModelCreator } from "./ModelCreator";
import { PbfMeshReader } from "./PbfMeshReader";
import { IClusterReconstruction } from "./interfaces/IClusterReconstruction";
import { ICoreNode } from "./interfaces/ICoreNode";
import { IFalcorDataProviderOptions } from "./interfaces/IFalcorDataProviderOptions";
import { IFillNode } from "./interfaces/IFillNode";
import { IFullNode } from "./interfaces/IFullNode";
import { IMesh } from "./interfaces/IMesh";
import { ISequence } from "./interfaces/ISequence";
import { ReconstructionEnt } from "./ents/ReconstructionEnt";
import { CoreImageEnt } from "./ents/CoreImageEnt";
import { FalcorDataProviderOptions } from "./interfaces/FalcorDataProviderOptions";
import { SpatialImageEnt } from "./ents/SpatialImageEnt";
import { ImageEnt } from "./ents/ImageEnt";
import { MeshEnt } from "./ents/MeshEnt";
import { MapillaryError } from "../error/MapillaryError";
import { ImageSize } from "../viewer/ImageSize";
import { GeometryProviderBase } from "./GeometryProviderBase";
import { SequenceEnt } from "./ents/SequenceEnt";
import { LatLonAltEnt } from "./ents/LatLonAltEnt";
interface IImageByKey<T> {
interface ImageByKey<T> {
imageByKey: { [key: string]: T };
}
interface IImagesByH<T> {
interface ImagesByH<T> {
imagesByH: { [key: string]: { [index: string]: T } };
}
interface ISequenceByKey<T> {
interface SequenceByKey<T> {
sequenceByKey: { [sequenceKey: string]: T };
}
@ -39,6 +40,14 @@ type APIPath =
"imagesByH" |
"sequenceByKey";
interface Reconstruction extends ReconstructionEnt {
reference_lla: {
altitude: number,
latitude: number,
longitude: number,
}
}
/**
* @class PointsGeometry
*
@ -64,17 +73,17 @@ export class FalcorDataProviderUrls {
/**
* Create a new Falcor data provider URLs instance.
*
* @param {IFalcorDataProviderOptions} options - Options struct.
* @param {FalcorDataProviderOptions} options - Options struct.
*/
constructor(options: IFalcorDataProviderOptions) {
constructor(options: FalcorDataProviderOptions) {
this._clientToken = options.clientToken;
if (!!options.apiHost) {
this._apiHost = options.apiHost;
}
if (!!options.clusterReconstructionHost) {
this._clusterReconstructionHost = options.clusterReconstructionHost;
if (!!options.reconstructionHost) {
this._clusterReconstructionHost = options.reconstructionHost;
}
if (!!options.imageHost) {
@ -156,12 +165,12 @@ export class FalcorDataProvider extends DataProviderBase {
/**
* Create a new Falcor data provider instance.
*
* @param {IFalcorDataProviderOptions} options - Options struct.
* @param {FalcorDataProviderOptions} options - Options struct.
* @param {GeometryProviderBase} [geometry] - Optional geometry
* provider instance.
*/
constructor(
options: IFalcorDataProviderOptions,
options: FalcorDataProviderOptions,
geometry?: GeometryProviderBase) {
super(!!geometry ? geometry : new GeohashGeometryProvider());
@ -236,8 +245,8 @@ export class FalcorDataProvider extends DataProviderBase {
* @inheritdoc
*/
public getCoreImages(cellId: string):
Promise<{ [cellId: string]: { [imageKey: string]: ICoreNode } }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<IImagesByH<ICoreNode>>>>this._model
Promise<{ [cellId: string]: { [imageKey: string]: CoreImageEnt } }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<ImagesByH<CoreImageEnt>>>>this._model
.get([
this._pathImagesByH,
[cellId],
@ -245,7 +254,7 @@ export class FalcorDataProvider extends DataProviderBase {
this._propertiesKey
.concat(this._propertiesCore)]))
.then(
(value: JSONEnvelope<IImagesByH<ICoreNode>>): { [h: string]: { [index: string]: ICoreNode } } => {
(value: JSONEnvelope<ImagesByH<CoreImageEnt>>): { [h: string]: { [index: string]: CoreImageEnt } } => {
if (!value) {
value = { json: { imagesByH: {} } };
for (const h of [cellId]) {
@ -267,20 +276,32 @@ export class FalcorDataProvider extends DataProviderBase {
/**
* @inheritdoc
*/
public getClusterReconstruction(url: string, abort?: Promise<void>): Promise<IClusterReconstruction> {
public getClusterReconstruction(
url: string,
abort?: Promise<void>): Promise<ReconstructionEnt> {
return BufferFetcher.getArrayBuffer(url, abort)
.then(
(buffer: ArrayBuffer): IClusterReconstruction => {
const reconstructions: IClusterReconstruction[] =
(buffer: ArrayBuffer): Reconstruction => {
const reconstructions: Reconstruction[] =
JsonInflator.decompress(buffer);
if (reconstructions.length < 1) {
throw new MapillaryError("Cluster reconstruction is empty.");
}
const reconstruction = reconstructions[0];
const referenceLla = reconstruction.reference_lla;
const reference: LatLonAltEnt = {
alt: referenceLla.altitude,
lat: referenceLla.latitude,
lon: referenceLla.longitude,
};
reconstruction.reference = reference;
delete reconstruction.reference_lla;
return reconstructions[0];
},
(reason: Error): IClusterReconstruction => {
(reason: Error): Reconstruction => {
throw reason;
});
}
@ -288,8 +309,8 @@ export class FalcorDataProvider extends DataProviderBase {
/**
* @inheritdoc
*/
public getFillImages(keys: string[]): Promise<{ [key: string]: IFillNode }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<IImageByKey<IFillNode>>>>this._model
public getFillImages(keys: string[]): Promise<{ [key: string]: SpatialImageEnt }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<ImageByKey<SpatialImageEnt>>>>this._model
.get([
this._pathImageByKey,
keys,
@ -299,7 +320,7 @@ export class FalcorDataProvider extends DataProviderBase {
this._propertiesKey
.concat(this._propertiesUser)]))
.then(
(value: JSONEnvelope<IImageByKey<IFillNode>>): { [key: string]: IFillNode } => {
(value: JSONEnvelope<ImageByKey<SpatialImageEnt>>): { [key: string]: SpatialImageEnt } => {
if (!value) {
this._invalidateGet(this._pathImageByKey, keys);
throw new Error(`Images (${keys.join(", ")}) could not be found.`);
@ -316,8 +337,8 @@ export class FalcorDataProvider extends DataProviderBase {
/**
* @inheritdoc
*/
public getFullImages(keys: string[]): Promise<{ [key: string]: IFullNode }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<IImageByKey<IFullNode>>>>this._model
public getFullImages(keys: string[]): Promise<{ [key: string]: ImageEnt }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<ImageByKey<ImageEnt>>>>this._model
.get([
this._pathImageByKey,
keys,
@ -328,7 +349,7 @@ export class FalcorDataProvider extends DataProviderBase {
this._propertiesKey
.concat(this._propertiesUser)]))
.then(
(value: JSONEnvelope<IImageByKey<IFullNode>>): { [key: string]: IFullNode } => {
(value: JSONEnvelope<ImageByKey<ImageEnt>>): { [key: string]: ImageEnt } => {
if (!value) {
this._invalidateGet(this._pathImageByKey, keys);
throw new Error(`Images (${keys.join(", ")}) could not be found.`);
@ -371,13 +392,13 @@ export class FalcorDataProvider extends DataProviderBase {
/**
* @inheritdoc
*/
public getMesh(url: string, abort?: Promise<void>): Promise<IMesh> {
public getMesh(url: string, abort?: Promise<void>): Promise<MeshEnt> {
return BufferFetcher.getArrayBuffer(url, abort)
.then(
(buffer: ArrayBuffer): IMesh => {
(buffer: ArrayBuffer): MeshEnt => {
return PbfMeshReader.read(buffer);
},
(reason: Error): IMesh => {
(reason: Error): MeshEnt => {
throw reason;
});
}
@ -386,15 +407,15 @@ export class FalcorDataProvider extends DataProviderBase {
* @inheritdoc
*/
public getSequences(sequenceKeys: string[]):
Promise<{ [sequenceKey: string]: ISequence }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<ISequenceByKey<ISequence>>>>this._model
Promise<{ [sequenceKey: string]: SequenceEnt }> {
return Promise.resolve(<PromiseLike<JSONEnvelope<SequenceByKey<SequenceEnt>>>>this._model
.get([
this._pathSequenceByKey,
sequenceKeys,
this._propertiesKey
.concat(this._propertiesSequence)]))
.then(
(value: JSONEnvelope<ISequenceByKey<ISequence>>): { [sequenceKey: string]: ISequence } => {
(value: JSONEnvelope<SequenceByKey<SequenceEnt>>): { [sequenceKey: string]: SequenceEnt } => {
if (!value) {
value = { json: { sequenceByKey: {} } };
}
@ -429,7 +450,7 @@ export class FalcorDataProvider extends DataProviderBase {
this._model.invalidate([path, paths]);
}
private _populateUrls<T extends IFillNode>(ibk: { [key: string]: T }): { [key: string]: T } {
private _populateUrls<T extends SpatialImageEnt>(ibk: { [key: string]: T }): { [key: string]: T } {
for (let key in ibk) {
if (!ibk.hasOwnProperty(key)) {
continue;

40
src/api/GeohashGeometryProvider.ts
View File

@ -1,8 +1,8 @@
import * as geohash from "latlon-geohash";
import { GeometryProviderBase } from "./GeometryProviderBase";
import { ICellCorners, ICellNeighbors } from "./interfaces/ICellCorners";
import { ILatLon } from "./interfaces/ILatLon";
import { CellCorners, CellNeighbors } from "./interfaces/CellCorners";
import { LatLonEnt } from "./ents/LatLonEnt";
import { GeoCoords } from "../geo/GeoCoords";
@ -44,40 +44,40 @@ export class GeohashGeometryProvider extends GeometryProviderBase {
* The method currently uses the largest side as the threshold leading to
* more tiles being returned than needed in edge cases.
*
* @param {ILatLon} sw - South west corner of bounding box.
* @param {ILatLon} ne - North east corner of bounding box.
* @param {LatLonEnt} sw - South west corner of bounding box.
* @param {LatLonEnt} ne - North east corner of bounding box.
*
* @returns {string} The geohash tiles containing the bounding box.
*/
public bboxToCellIds(sw: ILatLon, ne: ILatLon): string[] {
public bboxToCellIds(sw: LatLonEnt, ne: LatLonEnt): string[] {
return this._bboxSquareToCellIds(sw, ne);
}
/** @inheritdoc */
public getCorners(cellId: string): ICellCorners {
public getCorners(cellId: string): CellCorners {
const bounds: geohash.Bounds = geohash.bounds(cellId);
const nw: ILatLon = { lat: bounds.ne.lat, lon: bounds.sw.lon };
const ne: ILatLon = { lat: bounds.ne.lat, lon: bounds.ne.lon };
const se: ILatLon = { lat: bounds.ne.lat, lon: bounds.sw.lon };
const sw: ILatLon = { lat: bounds.sw.lat, lon: bounds.sw.lon };
const nw: LatLonEnt = { lat: bounds.ne.lat, lon: bounds.sw.lon };
const ne: LatLonEnt = { lat: bounds.ne.lat, lon: bounds.ne.lon };
const se: LatLonEnt = { lat: bounds.ne.lat, lon: bounds.sw.lon };
const sw: LatLonEnt = { lat: bounds.sw.lat, lon: bounds.sw.lon };
return { nw, ne, se, sw };
}
/** @inheritdoc */
public getNeighbors(cellId: string): ICellNeighbors {
public getNeighbors(cellId: string): CellNeighbors {
return geohash.neighbours(cellId);
}
/**
* Encode the geohash tile for geodetic coordinates.
*
* @param {ILatLon} latlon - Latitude and longitude to encode.
* @param {LatLonEnt} latlon - Latitude and longitude to encode.
* @param {number} precision - Precision of the encoding.
*
* @returns {string} The geohash tile for the lat, lon and precision.
*/
public latLonToCellId(
latLon: ILatLon,
latLon: LatLonEnt,
relativeLevel: number = 0): string {
return geohash.encode(
@ -90,7 +90,7 @@ export class GeohashGeometryProvider extends GeometryProviderBase {
* Encode the geohash tiles within a threshold from a position
* using Manhattan distance.
*
* @param {ILatLon} latlon - Latitude and longitude to encode.
* @param {LatLonEnt} latlon - Latitude and longitude to encode.
* @param {number} precision - Precision of the encoding.
* @param {number} threshold - Threshold of the encoding in meters.
*
@ -98,7 +98,7 @@ export class GeohashGeometryProvider extends GeometryProviderBase {
* threshold.
*/
public latLonToCellIds(
latLon: ILatLon,
latLon: LatLonEnt,
threshold: number,
relativeLevel: number = 0): string[] {
@ -106,14 +106,14 @@ export class GeohashGeometryProvider extends GeometryProviderBase {
latLon.lat, latLon.lon, this._level + relativeLevel);
const bounds: geohash.Bounds = geohash.bounds(h);
const corners: ICellCorners = {
const corners: CellCorners = {
ne: { lat: bounds.ne.lat, lon: bounds.ne.lon },
nw: { lat: bounds.ne.lat, lon: bounds.sw.lon },
se: { lat: bounds.sw.lat, lon: bounds.ne.lon },
sw: { lat: bounds.sw.lat, lon: bounds.sw.lon },
};
const neighbours: ICellNeighbors = this.getNeighbors(h);
const neighbours: CellNeighbors = this.getNeighbors(h);
return this._filterNeighbors(
latLon,
@ -124,11 +124,11 @@ export class GeohashGeometryProvider extends GeometryProviderBase {
}
private _filterNeighbors(
latLon: ILatLon,
latLon: LatLonEnt,
threshold: number,
cellId: string,
corners: ICellCorners,
neighbors: ICellNeighbors): string[] {
corners: CellCorners,
neighbors: CellNeighbors): string[] {
const bl: number[] = [0, 0, 0];
const tr: number[] =

32
src/api/GeometryProviderBase.ts
View File

@ -1,5 +1,5 @@
import { ICellCorners, ICellNeighbors } from "./interfaces/ICellCorners";
import { ILatLon } from "./interfaces/ILatLon";
import { CellCorners, CellNeighbors } from "./interfaces/CellCorners";
import { LatLonEnt } from "./ents/LatLonEnt";
import { MapillaryError } from "../error/MapillaryError";
import { GeoCoords } from "../geo/GeoCoords";
@ -36,12 +36,12 @@ export abstract class GeometryProviderBase {
* to be sufficiently small to be contained in an area with the size
* of maximally four tiles. Up to nine adjacent tiles may be returned.
*
* @param {ILatLon} sw - South west corner of bounding box.
* @param {ILatLon} ne - North east corner of bounding box.
* @param {LatLonEnt} sw - South west corner of bounding box.
* @param {LatLonEnt} ne - North east corner of bounding box.
*
* @returns {Array<string>} Array of cell ids.
*/
public bboxToCellIds(sw: ILatLon, ne: ILatLon): string[] {
public bboxToCellIds(sw: LatLonEnt, ne: LatLonEnt): string[] {
throw new MapillaryError("Not implemented");
}
@ -49,30 +49,30 @@ export abstract class GeometryProviderBase {
* Get the corners of a cell.
*
* @param {string} cellId - Id of cell.
* @returns {ICellCorners} Cell corners struct.
* @returns {CellCorners} Cell corners struct.
*/
public getCorners(cellId: string): ICellCorners {
public getCorners(cellId: string): CellCorners {
throw new MapillaryError("Not implemented");
}
/**
* Get the neighbors of a cell.
*
* @param {ILatLon} sw - South west corner of the bounding box.
* @param {ILatLon} ne - North east corner of the bounding box.
* @returns {ICellCorners} Cell corners struct.
* @param {LatLonEnt} sw - South west corner of the bounding box.
* @param {LatLonEnt} ne - North east corner of the bounding box.
* @returns {CellCorners} Cell corners struct.
*/
public getNeighbors(cellId: string): ICellNeighbors {
public getNeighbors(cellId: string): CellNeighbors {
throw new MapillaryError("Not implemented");
}
/**
* Convert geodetic coordinates to a cell id.
*
* @param {ILatLon} latlon - Latitude and longitude to convert.
* @param {LatLonEnt} latlon - Latitude and longitude to convert.
* @returns {string} Cell id for the latitude, longitude.
*/
public latLonToCellId(latLon: ILatLon, relativeLevel?: number): string {
public latLonToCellId(latLon: LatLonEnt, relativeLevel?: number): string {
throw new MapillaryError("Not implemented");
}
@ -82,17 +82,17 @@ export abstract class GeometryProviderBase {
* The square is specified as a latitude, longitude
* and a threshold from the position using Manhattan distance.
*
* @param {ILatLon} latlon - Latitude and longitude.
* @param {LatLonEnt} latlon - Latitude and longitude.
* @param {number} threshold - Threshold of the conversion in meters.
*
* @returns {Array<string>} Array of cell ids reachable within
* the threshold.
*/
public latLonToCellIds(latLon: ILatLon, threshold: number, relativeLevel?: number): string[] {
public latLonToCellIds(latLon: LatLonEnt, threshold: number, relativeLevel?: number): string[] {
throw new MapillaryError("Not implemented");
}
protected _bboxSquareToCellIds(sw: ILatLon, ne: ILatLon): string[] {
protected _bboxSquareToCellIds(sw: LatLonEnt, ne: LatLonEnt): string[] {
if (ne.lat <= sw.lat || ne.lon <= sw.lon) {
throw new MapillaryError("North east needs to be top right of south west");
}

8
src/api/PbfMeshReader.ts
View File

@ -1,6 +1,6 @@
import Pbf from "pbf";
import { IMesh } from "./interfaces/IMesh";
import { MeshEnt } from "./ents/MeshEnt";
/**
* @class PbfMeshReader
@ -16,16 +16,16 @@ export class PbfMeshReader {
* @static
* @param {ArrayBuffer} buffer - Array buffer to read.
*
* @returns {IMesh} Mesh object.
* @returns {MeshEnt} Mesh object.
*/
public static read(buffer: ArrayBuffer): IMesh {
public static read(buffer: ArrayBuffer): MeshEnt {
const pbf = new Pbf(buffer);
return pbf.readFields(
PbfMeshReader._readMeshField,
{ faces: [], vertices: [] });
}
private static _readMeshField(tag: number, mesh: IMesh, pbf: Pbf): void {
private static _readMeshField(tag: number, mesh: MeshEnt, pbf: Pbf): void {
if (tag === 1) {
mesh.vertices.push(pbf.readFloat());
} else if (tag === 2) {

26
src/api/S2GeometryProvider.ts
View File

@ -1,8 +1,8 @@
import { S2 } from "s2-geometry";
import { GeometryProviderBase } from "./GeometryProviderBase";
import { ICellCorners, ICellNeighbors } from "./interfaces/ICellCorners";
import { ILatLon } from "./interfaces/ILatLon";
import { CellCorners, CellNeighbors } from "./interfaces/CellCorners";
import { LatLonEnt } from "./ents/LatLonEnt";
import { GeoCoords } from "../geo/GeoCoords";
@ -36,12 +36,12 @@ export class S2GeometryProvider extends GeometryProviderBase {
}
/** @inheritdoc */
public bboxToCellIds(sw: ILatLon, ne: ILatLon): string[] {
public bboxToCellIds(sw: LatLonEnt, ne: LatLonEnt): string[] {
return this._bboxSquareToCellIds(sw, ne);
}
/** @inheritdoc */
public getNeighbors(cellId: string): ICellNeighbors {
public getNeighbors(cellId: string): CellNeighbors {
const key: string = S2.idToKey(cellId);
const position: string = key.split('/')[1];
const level: number = position.length;
@ -63,7 +63,7 @@ export class S2GeometryProvider extends GeometryProviderBase {
}
/** @inheritdoc */
public getCorners(cellId: string): ICellCorners {
public getCorners(cellId: string): CellCorners {
const key: string = S2.idToKey(cellId);
const cell: S2.S2Cell = S2.S2Cell.FromHilbertQuadKey(key);
const corners: S2.ILatLng[] = cell.getCornerLatLngs();
@ -89,15 +89,15 @@ export class S2GeometryProvider extends GeometryProviderBase {
}
/** @inheritdoc */
public latLonToCellId(latLon: ILatLon): string {
public latLonToCellId(latLon: LatLonEnt): string {
return this._latLonToId(latLon, this._level);
}
/** @inheritdoc */
public latLonToCellIds(latLon: ILatLon, threshold: number): string[] {
public latLonToCellIds(latLon: LatLonEnt, threshold: number): string[] {
const cellId: string = this._latLonToId(latLon, this._level);
const neighbors: ICellNeighbors = this.getNeighbors(cellId);
const corners: ILatLon[] =
const neighbors: CellNeighbors = this.getNeighbors(cellId);
const corners: LatLonEnt[] =
this._getLatLonBoundingBoxCorners(latLon, threshold);
for (let corner of corners) {
@ -119,7 +119,7 @@ export class S2GeometryProvider extends GeometryProviderBase {
return [cellId];
}
private _enuToGeodetic(point: number[], reference: ILatLon): ILatLon {
private _enuToGeodetic(point: number[], reference: LatLonEnt): LatLonEnt {
const [lat, lon]: number[] = this._geoCoords.enuToGeodetic(
point[0],
point[1],
@ -132,14 +132,14 @@ export class S2GeometryProvider extends GeometryProviderBase {
}
private _getLatLonBoundingBoxCorners(
latLon: ILatLon, threshold: number): ILatLon[] {
latLon: LatLonEnt, threshold: number): LatLonEnt[] {
return [
[-threshold, threshold, 0],
[threshold, threshold, 0],
[threshold, -threshold, 0],
[-threshold, -threshold, 0],
].map(
(point: number[]): ILatLon => {
(point: number[]): LatLonEnt => {
return this._enuToGeodetic(point, latLon);
});
}
@ -154,7 +154,7 @@ export class S2GeometryProvider extends GeometryProviderBase {
return neighbors;
}
private _latLonToId(latLon: ILatLon, level: number): string {
private _latLonToId(latLon: LatLonEnt, level: number): string {
const key: string = S2.latLngToKey(
latLon.lat,
latLon.lon,

27
src/api/ents/CameraEnt.ts Normal file
View File

@ -0,0 +1,27 @@
/**
* Interface that represents a camera type in a
* reconstruction.
*
* @interface CameraEnt
*/
export interface CameraEnt {
/**
* SfM computed focal length.
*/
focal: number;
/**
* SfM computed radial distortion parameter.
*/
k1: number;
/**
* SfM computed radial distortion parameter.
*/
k2: number;
/**
* Projection type of the camera.
*/
projection_type: string;
}

23
src/api/ents/CameraShotEnt.ts Normal file
View File

@ -0,0 +1,23 @@
/**
* Interface that represents a shot (a camera frame) in a
* reconstruction.
*
* @interface CameraShotEnt
*/
export interface CameraShotEnt {
/**
* Key of the camera for the shot.
*/
camera: string;
/**
* Rotation vector in angle axis representation.
*/
rotation: number[];
/**
* The translation in meters in topocentric ENU
* reference frame.
*/
translation: number[];
}

12
src/api/interfaces/ICoreNode.ts → src/api/ents/CoreImageEnt.ts
View File

@ -1,21 +1,21 @@
import { IKey } from "./IKey";
import { ILatLon } from "./ILatLon";
import { KeyedEnt } from "./KeyedEnt";
import { LatLonEnt } from "./LatLonEnt";
/**
* Interface that describes the raw core node properties.
*
* @interface ICoreNode
* @interface CoreImageEnt
*/
export interface ICoreNode extends IKey {
export interface CoreImageEnt extends KeyedEnt {
/**
* SfM computed latitude longitude in WGS84 datum, measured in degrees.
*/
cl?: ILatLon;
cl?: LatLonEnt;
/**
* Original EXIF latitude longitude in WGS84 datum, measured in degrees.
*/
l: ILatLon;
l: LatLonEnt;
/**
* Key of sequence that the node is part of.

9
src/api/ents/ImageEnt.ts Normal file
View File

@ -0,0 +1,9 @@
import { SpatialImageEnt } from "./SpatialImageEnt";
import { CoreImageEnt } from "./CoreImageEnt";
/**
* Interface that describes the raw image properties.
*
* @interface ImageEnt
*/
export interface ImageEnt extends CoreImageEnt, SpatialImageEnt { }

11
src/api/ents/KeyedEnt.ts Normal file
View File

@ -0,0 +1,11 @@
/**
* Interface that describes an entity with a unique key.
*
* @interface KeyedEnt
*/
export interface KeyedEnt {
/**
* Unique key.
*/
key: string;
}

15
src/api/ents/LatLonAltEnt.ts Normal file
View File

@ -0,0 +1,15 @@
import { LatLonEnt } from "./LatLonEnt";
/**
* Interface that represents a latitude-longitude reference
* of a reconstruction, measured in degrees and an
* altitude in meters. Coordinates are defined in the WGS84 datum.
*
* @interface LatLonAltEnt
*/
export interface LatLonAltEnt extends LatLonEnt {
/**
* Altitude, measured in meters.
*/
alt: number;
}

4
src/api/interfaces/ILatLon.ts → src/api/ents/LatLonEnt.ts
View File

@ -2,9 +2,9 @@
* Interface that represents a latitude and longitude coordinate,
* measured in degrees. Coordinates are defined in the WGS84 datum.
*
* @interface ILatLon
* @interface LatLonEnt
*/
export interface ILatLon {
export interface LatLonEnt {
/**
* Latitude, measured in degrees.
*/

4
src/api/interfaces/IMesh.ts → src/api/ents/MeshEnt.ts
View File

@ -1,9 +1,9 @@
/**
* Interface that describes SfM triangulated meshes.
*
* @interface IMesh
* @interface MeshEnt
*/
export interface IMesh {
export interface MeshEnt {
/**
* Flattened array of faces for the mesh. Each face consist
* three vertex indices.

17
src/api/ents/PointEnt.ts Normal file
View File

@ -0,0 +1,17 @@
/**
* Interface that represents a reconstruction point.
*
* @interface PointEnt
*/
export interface PointEnt {
/**
* RGB color vector of the point.
*/
color: number[];
/**
* Coordinates in metric scale in topocentric ENU
* reference frame with respect to a geo reference.
*/
coordinates: number[];
}

8
src/api/ents/ProjectEnt.ts Normal file
View File

@ -0,0 +1,8 @@
import { KeyedEnt } from "./KeyedEnt";
/**
* Interface that describes the raw image project properties.
*
* @interface ProjectEnt
*/
export interface ProjectEnt extends KeyedEnt { }

34
src/api/ents/ReconstructionEnt.ts Normal file
View File

@ -0,0 +1,34 @@
import { CameraEnt } from "./CameraEnt";
import { CameraShotEnt } from "./CameraShotEnt";
import { LatLonAltEnt } from "./LatLonAltEnt";
import { PointEnt } from "./PointEnt";
export interface ReconstructionEnt {
/**
* The unique key of the reconstruction.
*/
key: string;
/**
* The cameras of the reconstruction.
*/
cameras: { [key: string]: CameraEnt };
/**
* The points of the reconstruction.
*/
points: { [id: string]: PointEnt };
/**
* The reference latitude, longitue, altitude of
* the reconstruction. Determines the
* position of the reconstruction in world reference
* frame.
*/
reference: LatLonAltEnt;
/**
* The shots of the reconstruction.
*/
shots: { [key: string]: CameraShotEnt };
}

6
src/api/interfaces/ISequence.ts → src/api/ents/SequenceEnt.ts
View File

@ -1,11 +1,11 @@
import { IKey } from "./IKey";
import { KeyedEnt } from "./KeyedEnt";
/**
* Interface that describes the raw image sequence properties.
*
* @interface ISequence
* @interface SequenceEnt
*/
export interface ISequence extends IKey {
export interface SequenceEnt extends KeyedEnt {
/**
* The ordered image keys of the sequence.
*/

27
src/api/interfaces/IFillNode.ts → src/api/ents/SpatialImageEnt.ts
View File

@ -1,14 +1,13 @@
import { CameraProjectionType } from "./CameraProjectionType";
import { INodeUrls } from "./INodeUrls";
import { IProject } from "./IProject";
import { IUser } from "./IUser";
import { URLImageEnt } from "./URLImageEnt";
import { ProjectEnt } from "./ProjectEnt";
import { UserEnt } from "./UserEnt";
/**
* Interface that describes the raw filling node properties.
* Interface that describes the raw spatial image properties.
*
* @interface ISpatialNode
* @interface SpatialImageEnt
*/
export interface IFillNode extends INodeUrls {
export interface SpatialImageEnt extends URLImageEnt {
/**
* Original EXIF altitude above sea level, in meters.
*/
@ -37,6 +36,11 @@ export interface IFillNode extends INodeUrls {
*/
calt?: number;
/**
* Projection type of captured image.
*/
camera_projection_type?: string;
/**
* Timestamp when the image was captured.
*/
@ -107,22 +111,17 @@ export interface IFillNode extends INodeUrls {
/**
* Project the image belongs to.
*/
project?: IProject;
project?: ProjectEnt;
/**
* Image quality score.
*/
quality_score?: number;
/**
* Projection type of captured image.
*/
camera_projection_type?: CameraProjectionType;
/**
* User who uploaded the image.
*/
user: IUser;
user: UserEnt;
/**
* Width of original image, not adjusted for orientation.

4
src/api/interfaces/INodeUrls.ts → src/api/ents/URLImageEnt.ts
View File

@ -1,9 +1,9 @@
/**
* Interface that describes an object with image thumb URLs.
*
* @interface INodeUrls
* @interface URLImageEnt
*/
export interface INodeUrls {
export interface URLImageEnt {
/**
* URL for cluster reconstruction resource.
*/

6
src/api/interfaces/IUser.ts → src/api/ents/UserEnt.ts
View File

@ -1,11 +1,11 @@
import { IKey } from "./IKey";
import { KeyedEnt } from "./KeyedEnt";
/**
* Interface that describes the raw image user properties.
*
* @interface IUser
* @interface UserEnt
*/
export interface IUser extends IKey {
export interface UserEnt extends KeyedEnt {
/**
* The username of the user.
*/

18
src/api/interfaces/ICellCorners.ts → src/api/interfaces/CellCorners.ts
View File

@ -1,11 +1,11 @@
import { ILatLon } from "./ILatLon";
import { LatLonEnt } from "../ents/LatLonEnt";
/**
* Interface that describes a cell neighbors object.
*
* @interface ICellNeighbors
* @interface CellNeighbors
*/
export interface ICellNeighbors {
export interface CellNeighbors {
/**
* East neighbor.
*/
@ -50,26 +50,26 @@ export interface ICellNeighbors {
/**
* Interface that describes a cell corners object.
*
* @interface ICellCorners
* @interface CellCorners
*/
export interface ICellCorners {
export interface CellCorners {
/**
* North east corner.
*/
ne: ILatLon;
ne: LatLonEnt;
/**
* North west corner.
*/
nw: ILatLon;
nw: LatLonEnt;
/**
* South east corner.
*/
se: ILatLon;
se: LatLonEnt;
/**
* South west corner.
*/
sw: ILatLon;
sw: LatLonEnt;
}

5
src/api/interfaces/IDataAddedEvent.ts → src/api/interfaces/DataAddedProviderEvent.ts
View File

@ -6,10 +6,9 @@ import { DataProviderBase } from "../DataProviderBase";
* @description Emitted when data has been added to a
* data provider after initial load.
*
* @event IDataAddedEvent
* @type {IDataAddedEvent}
* @event DataAddedProviderEvent
*/
export interface IDataAddedEvent {
export interface DataAddedProviderEvent {
/**
* Event type.
*/

9
src/api/interfaces/IFalcorDataProviderOptions.ts → src/api/interfaces/FalcorDataProviderOptions.ts
View File

@ -1,11 +1,12 @@
import { ModelCreator } from "../ModelCreator";
/**
* Interface for the options that can be provided to the {@link FalcorDataProvider}.
* Interface for the options that can be provided to
* the {@link FalcorDataProvider}.
*
* @interface IFalcorDataProviderOptions
* @interface FalcorDataProviderOptions
*/
export interface IFalcorDataProviderOptions {
export interface FalcorDataProviderOptions {
/**
* API v3 host.
*
@ -28,7 +29,7 @@ export interface IFalcorDataProviderOptions {
*
* @default {"cluster-reconstructions.mapillary.com"}
*/
clusterReconstructionHost?: string;
reconstructionHost?: string;
/**
* Optional model creator instance.

124
src/api/interfaces/IClusterReconstruction.ts
View File

@ -1,124 +0,0 @@
import { CameraProjectionType } from "./CameraProjectionType";
/**
* Interface that represents a camera type in a cluster
* reconstruction.
*
* @interface ICamera
*/
export interface ICamera {
/**
* SfM computed focal length.
*/
focal: number;
/**
* SfM computed radial distortion parameter.
*/
k1: number;
/**
* SfM computed radial distortion parameter.
*/
k2: number;
/**
* Projection type of the camera.
*/
projection_type: CameraProjectionType;
}
/**
* Interface that represents a latitude-longitude reference
* of a cluster reconstruction, measured in degrees and an
* altitude in meters. Coordinates are defined in the WGS84 datum.
*
* @interface IGeoReference
*/
export interface IGeoReference {
/**
* Altitude, measured in meters.
*/
altitude: number;
/**
* Latitude, measured in degrees.
*/
latitude: number;
/**
* Longitude, measured in degrees.
*/
longitude: number;
}
/**
* Interface that represents a cluster reconstruction point.
*
* @interface IReconstructionPoint
*/
export interface IReconstructionPoint {
/**
* RGB color vector of the point.
*/
color: number[];
/**
* Coordinates in metric scale in topocentric ENU
* reference frame with respect to a geo reference.
*/
coordinates: number[];
}
/**
* Interface that represents a shot (a camera frame) in a cluster
* reconstruction.
*
* @interface IShot
*/
export interface IShot {
/**
* Key of the camera for the shot.
*/
camera: string;
/**
* Rotation vector in angle axis representation.
*/
rotation: number[];
/**
* The translation in meters in topocentric ENU
* reference frame.
*/
translation: number[];
}
export interface IClusterReconstruction {
/**
* The unique key of the reconstruction.
*/
key: string;
/**
* The cameras of the reconstruction.
*/
cameras: { [key: string]: ICamera };
/**
* The points of the reconstruction.
*/
points: { [id: string]: IReconstructionPoint };
/**
* The reference of the reconstruction. Determines the
* position of the reconstruction in world reference
* frame.
*/
reference_lla: IGeoReference;
/**
* The shots of the reconstruction.
*/
shots: { [key: string]: IShot };
}

9
src/api/interfaces/IFullNode.ts
View File

@ -1,9 +0,0 @@
import { IFillNode } from "./IFillNode";
import { ICoreNode } from "./ICoreNode";
/**
* Interface that describes the raw full image properties.
*
* @interface IFullNode
*/
export interface IFullNode extends ICoreNode, IFillNode { }

11
src/api/interfaces/IKey.ts
View File

@ -1,11 +0,0 @@
/**
* Interface that describes an object with a unique key.
*
* @interface IKey
*/
export interface IKey {
/**
* Unique key.
*/
key: string;
}

8
src/api/interfaces/IProject.ts
View File

@ -1,8 +0,0 @@
import { IKey } from "./IKey";
/**
* Interface that describes the raw image project properties.
*
* @interface IProject
*/
export interface IProject extends IKey { }

12
src/component/AttributionComponent.ts
View File

@ -8,16 +8,16 @@ import {
import { map } from "rxjs/operators";
import { Component } from "./Component";
import { IComponentConfiguration } from "./interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "./interfaces/ComponentConfiguration";
import { Node } from "../graph/Node";
import { ISize } from "../render/interfaces/ISize";
import { IVNodeHash } from "../render/interfaces/IVNodeHash";
import { ViewportSize } from "../render/interfaces/ViewportSize";
import { VirtualNodeHash } from "../render/interfaces/VirtualNodeHash";
import { Urls } from "../utils/Urls";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
export class AttributionComponent extends Component<IComponentConfiguration> {
export class AttributionComponent extends Component<ComponentConfiguration> {
public static componentName: string = "attribution";
private _disposable: Subscription;
@ -30,7 +30,7 @@ export class AttributionComponent extends Component<IComponentConfiguration> {
this._navigator.stateService.currentNode$,
this._container.renderService.size$).pipe(
map(
([node, size]: [Node, ISize]): IVNodeHash => {
([node, size]: [Node, ViewportSize]): VirtualNodeHash => {
return {
name: this._name,
vnode: this._getAttributionNode(node.username, node.key, node.capturedAt, size.width),
@ -43,7 +43,7 @@ export class AttributionComponent extends Component<IComponentConfiguration> {
this._disposable.unsubscribe();
}
protected _getDefaultConfiguration(): IComponentConfiguration {
protected _getDefaultConfiguration(): ComponentConfiguration {
return {};
}

32
src/component/BearingComponent.ts
View File

@ -20,16 +20,16 @@ import {
import * as Geo from "../geo/Geo";
import { Component } from "./Component";
import { IBearingConfiguration } from "./interfaces/IBearingConfiguration";
import { BearingConfiguration } from "./interfaces/BearingConfiguration";
import { Spatial } from "../geo/Spatial";
import { Transform } from "../geo/Transform";
import { ViewportCoords } from "../geo/ViewportCoords";
import { Node } from "../graph/Node";
import { RenderCamera } from "../render/RenderCamera";
import { ISize } from "../render/interfaces/ISize";
import { IVNodeHash } from "../render/interfaces/IVNodeHash";
import { IFrame } from "../state/interfaces/IFrame";
import { ViewportSize } from "../render/interfaces/ViewportSize";
import { VirtualNodeHash } from "../render/interfaces/VirtualNodeHash";
import { AnimationFrame } from "../state/interfaces/AnimationFrame";
import { ComponentSize } from "./utils/ComponentSize";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
@ -45,7 +45,7 @@ type NodeFovState = {
prev: NodeFov,
};
interface INodeFovOperation {
interface NodeFovOperation {
(state: NodeFovState): NodeFovState;
}
@ -65,7 +65,7 @@ interface INodeFovOperation {
* bearingComponent.configure({ size: Mapillary.ComponentSize.Small });
* ```
*/
export class BearingComponent extends Component<IBearingConfiguration> {
export class BearingComponent extends Component<BearingConfiguration> {
public static componentName: string = "bearing";
private _spatial: Spatial;
@ -115,12 +115,12 @@ export class BearingComponent extends Component<IBearingConfiguration> {
this._navigator.stateService.currentState$.pipe(
distinctUntilChanged(
undefined,
(frame: IFrame): string => {
(frame: AnimationFrame): string => {
return frame.state.currentNode.key;
})),
this._navigator.panService.panNodes$).pipe(
map(
([frame, panNodes]: [IFrame, [Node, Transform, number][]]): NodeFov => {
([frame, panNodes]: [AnimationFrame, [Node, Transform, number][]]): NodeFov => {
const node: Node = frame.state.currentNode;
const transform: Transform = frame.state.currentTransform;
@ -158,22 +158,22 @@ export class BearingComponent extends Component<IBearingConfiguration> {
this._navigator.stateService.currentState$.pipe(
distinctUntilChanged(
undefined,
(frame: IFrame): string => {
(frame: AnimationFrame): string => {
return frame.state.currentNode.key;
})),
this._container.renderService.bearing$).pipe(
map(
([frame, bearing]: [IFrame, number]): number => {
([frame, bearing]: [AnimationFrame, number]): number => {
const offset: number = this._spatial.degToRad(frame.state.currentNode.ca - bearing);
return offset;
}));
const nodeFovOperation$: Subject<INodeFovOperation> = new Subject<INodeFovOperation>();
const nodeFovOperation$: Subject<NodeFovOperation> = new Subject<NodeFovOperation>();
const smoothNodeFov$: Observable<NodeFov> = nodeFovOperation$.pipe(
scan(
(state: NodeFovState, operation: INodeFovOperation): NodeFovState => {
(state: NodeFovState, operation: NodeFovOperation): NodeFovState => {
return operation(state);
},
{ alpha: 0, curr: [0, 0, 0], prev: [0, 0, 0] }),
@ -191,7 +191,7 @@ export class BearingComponent extends Component<IBearingConfiguration> {
this._fovSubscription = nodeFov$.pipe(
map(
(nbf: NodeFov): INodeFovOperation => {
(nbf: NodeFov): NodeFovOperation => {
return (state: NodeFovState): NodeFovState => {
const a: number = this._unitBezier.solve(state.alpha);
const c: NodeFov = state.curr;
@ -233,7 +233,7 @@ export class BearingComponent extends Component<IBearingConfiguration> {
}));
}),
map(
(alpha: number): INodeFovOperation => {
(alpha: number): NodeFovOperation => {
return (nbfState: NodeFovState): NodeFovState => {
return {
alpha: alpha,
@ -259,7 +259,7 @@ export class BearingComponent extends Component<IBearingConfiguration> {
this._container.renderService.size$).pipe(
map(
([[cb, cf], [no, nfl, nfr], configuration, size]:
[[number, number], [number, number, number], IBearingConfiguration, ISize]): IVNodeHash => {
[[number, number], [number, number, number], BearingConfiguration, ViewportSize]): VirtualNodeHash => {
const background: vd.VNode = this._createBackground(cb);
const fovIndicator: vd.VNode = this._createFovIndicator(nfl, nfr, no);
@ -293,7 +293,7 @@ export class BearingComponent extends Component<IBearingConfiguration> {
this._fovAnimationSubscription.unsubscribe();
}
protected _getDefaultConfiguration(): IBearingConfiguration {
protected _getDefaultConfiguration(): BearingConfiguration {
return { size: ComponentSize.Automatic };
}

76
src/component/CacheComponent.ts
View File

@ -22,19 +22,19 @@ import {
} from "rxjs/operators";
import { Component } from "./Component";
import { ICacheConfiguration, ICacheDepth } from "./interfaces/ICacheConfiguration";
import { CacheConfiguration, CacheDepthConfiguration } from "./interfaces/CacheConfiguration";
import { Node } from "../graph/Node";
import { IEdge } from "../graph/edge/interfaces/IEdge";
import { IEdgeStatus } from "../graph/interfaces/IEdgeStatus";
import { EdgeDirection } from "../graph/edge/EdgeDirection";
import { NavigationEdge } from "../graph/edge/interfaces/NavigationEdge";
import { NavigationEdgeStatus } from "../graph/interfaces/NavigationEdgeStatus";
import { NavigationDirection } from "../graph/edge/NavigationDirection";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
import { isSpherical } from "../geo/Geo";
type EdgesDepth = [IEdge[], number];
type EdgesDepth = [NavigationEdge[], number];
export class CacheComponent extends Component<ICacheConfiguration> {
export class CacheComponent extends Component<CacheConfiguration> {
public static componentName: string = "cache";
private _sequenceSubscription: Subscription;
@ -50,9 +50,9 @@ export class CacheComponent extends Component<ICacheConfiguration> {
* Configures the cache depth. The cache depth can be different for
* different edge direction types.
*
* @param {ICacheDepth} depth - Cache depth structure.
* @param {CacheDepthConfiguration} depth - Cache depth structure.
*/
public setDepth(depth: ICacheDepth): void {
public setDepth(depth: CacheDepthConfiguration): void {
this.configure({ depth: depth });
}
@ -60,23 +60,23 @@ export class CacheComponent extends Component<ICacheConfiguration> {
this._sequenceSubscription = observableCombineLatest(
this._navigator.stateService.currentNode$.pipe(
switchMap(
(node: Node): Observable<IEdgeStatus> => {
(node: Node): Observable<NavigationEdgeStatus> => {
return node.sequenceEdges$;
}),
filter(
(status: IEdgeStatus): boolean => {
(status: NavigationEdgeStatus): boolean => {
return status.cached;
})),
this._configuration$).pipe(
switchMap(
(nc: [IEdgeStatus, ICacheConfiguration]): Observable<EdgesDepth> => {
let status: IEdgeStatus = nc[0];
let configuration: ICacheConfiguration = nc[1];
(nc: [NavigationEdgeStatus, CacheConfiguration]): Observable<EdgesDepth> => {
let status: NavigationEdgeStatus = nc[0];
let configuration: CacheConfiguration = nc[1];
let sequenceDepth = Math.max(0, Math.min(4, configuration.depth.sequence));
let next$ = this._cache$(status.edges, EdgeDirection.Next, sequenceDepth);
let prev$ = this._cache$(status.edges, EdgeDirection.Prev, sequenceDepth);
let next$ = this._cache$(status.edges, NavigationDirection.Next, sequenceDepth);
let prev$ = this._cache$(status.edges, NavigationDirection.Prev, sequenceDepth);
return observableMerge<EdgesDepth>(
next$,
@ -93,20 +93,20 @@ export class CacheComponent extends Component<ICacheConfiguration> {
this._spatialSubscription = observableCombineLatest(
this._navigator.stateService.currentNode$.pipe(
switchMap(
(node: Node): Observable<[Node, IEdgeStatus]> => {
(node: Node): Observable<[Node, NavigationEdgeStatus]> => {
return observableCombineLatest(
observableOf<Node>(node),
node.spatialEdges$.pipe(
filter(
(status: IEdgeStatus): boolean => {
(status: NavigationEdgeStatus): boolean => {
return status.cached;
})));
})),
this._configuration$).pipe(
switchMap(
([[node, edgeStatus], configuration]: [[Node, IEdgeStatus], ICacheConfiguration]): Observable<EdgesDepth> => {
let edges: IEdge[] = edgeStatus.edges;
let depth: ICacheDepth = configuration.depth;
([[node, edgeStatus], configuration]: [[Node, NavigationEdgeStatus], CacheConfiguration]): Observable<EdgesDepth> => {
let edges: NavigationEdge[] = edgeStatus.edges;
let depth: CacheDepthConfiguration = configuration.depth;
let sphericalDepth =
Math.max(0, Math.min(2, depth.spherical));
@ -115,16 +115,16 @@ export class CacheComponent extends Component<ICacheConfiguration> {
let turnDepth = isSpherical(node.cameraType) ?
0 : Math.max(0, Math.min(1, depth.turn));
let spherical$ = this._cache$(edges, EdgeDirection.Spherical, sphericalDepth);
let spherical$ = this._cache$(edges, NavigationDirection.Spherical, sphericalDepth);
let forward$ = this._cache$(edges, EdgeDirection.StepForward, stepDepth);
let backward$ = this._cache$(edges, EdgeDirection.StepBackward, stepDepth);
let left$ = this._cache$(edges, EdgeDirection.StepLeft, stepDepth);
let right$ = this._cache$(edges, EdgeDirection.StepRight, stepDepth);
let forward$ = this._cache$(edges, NavigationDirection.StepForward, stepDepth);
let backward$ = this._cache$(edges, NavigationDirection.StepBackward, stepDepth);
let left$ = this._cache$(edges, NavigationDirection.StepLeft, stepDepth);
let right$ = this._cache$(edges, NavigationDirection.StepRight, stepDepth);
let turnLeft$ = this._cache$(edges, EdgeDirection.TurnLeft, turnDepth);
let turnRight$ = this._cache$(edges, EdgeDirection.TurnRight, turnDepth);
let turnU$ = this._cache$(edges, EdgeDirection.TurnU, turnDepth);
let turnLeft$ = this._cache$(edges, NavigationDirection.TurnLeft, turnDepth);
let turnRight$ = this._cache$(edges, NavigationDirection.TurnRight, turnDepth);
let turnU$ = this._cache$(edges, NavigationDirection.TurnU, turnDepth);
return observableMerge<EdgesDepth>(
forward$,
@ -150,17 +150,17 @@ export class CacheComponent extends Component<ICacheConfiguration> {
this._spatialSubscription.unsubscribe();
}
protected _getDefaultConfiguration(): ICacheConfiguration {
protected _getDefaultConfiguration(): CacheConfiguration {
return { depth: { spherical: 1, sequence: 2, step: 1, turn: 0 } };
}
private _cache$(edges: IEdge[], direction: EdgeDirection, depth: number): Observable<EdgesDepth> {
private _cache$(edges: NavigationEdge[], direction: NavigationDirection, depth: number): Observable<EdgesDepth> {
return observableZip(
observableOf<IEdge[]>(edges),
observableOf<NavigationEdge[]>(edges),
observableOf<number>(depth)).pipe(
expand(
(ed: EdgesDepth): Observable<EdgesDepth> => {
let es: IEdge[] = ed[0];
let es: NavigationEdge[] = ed[0];
let d = ed[1];
let edgesDepths$: Observable<EdgesDepth>[] = [];
@ -170,9 +170,9 @@ export class CacheComponent extends Component<ICacheConfiguration> {
if (edge.data.direction === direction) {
edgesDepths$.push(
observableZip(
this._navigator.graphService.cacheNode$(edge.to).pipe(
this._navigator.graphService.cacheNode$(edge.target).pipe(
mergeMap(
(n: Node): Observable<IEdge[]> => {
(n: Node): Observable<NavigationEdge[]> => {
return this._nodeToEdges$(n, direction);
})),
observableOf<number>(d - 1)));
@ -186,16 +186,16 @@ export class CacheComponent extends Component<ICacheConfiguration> {
skip(1));
}
private _nodeToEdges$(node: Node, direction: EdgeDirection): Observable<IEdge[]> {
return ([EdgeDirection.Next, EdgeDirection.Prev].indexOf(direction) > -1 ?
private _nodeToEdges$(node: Node, direction: NavigationDirection): Observable<NavigationEdge[]> {
return ([NavigationDirection.Next, NavigationDirection.Prev].indexOf(direction) > -1 ?
node.sequenceEdges$ :
node.spatialEdges$).pipe(
first(
(status: IEdgeStatus): boolean => {
(status: NavigationEdgeStatus): boolean => {
return status.cached;
}),
map(
(status: IEdgeStatus): IEdge[] => {
(status: NavigationEdgeStatus): NavigationEdge[] => {
return status.edges;
}));
}

4
src/component/Component.ts
View File

@ -11,13 +11,13 @@ import {
Subject,
} from "rxjs";
import { IComponentConfiguration } from "./interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "./interfaces/ComponentConfiguration";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
import { EventEmitter } from "../utils/EventEmitter";
export abstract class Component<TConfiguration extends IComponentConfiguration> extends EventEmitter {
export abstract class Component<TConfiguration extends ComponentConfiguration> extends EventEmitter {
public static componentName: string = "not_worthy";
protected _activated: boolean;

22
src/component/ComponentService.ts
View File

@ -1,23 +1,23 @@
import { Component } from "./Component";
import { CoverComponent } from "./CoverComponent";
import { IComponentConfiguration } from "./interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "./interfaces/ComponentConfiguration";
import { ArgumentMapillaryError } from "../error/ArgumentMapillaryError";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
interface IActiveComponent {
interface ActiveComponent {
active: boolean;
component: Component<IComponentConfiguration>;
component: Component<ComponentConfiguration>;
}
export class ComponentService {
public static registeredCoverComponent: typeof CoverComponent;
public static registeredComponents: { [key: string]: { new(...args: any[]): Component<IComponentConfiguration>; } } = {};
public static registeredComponents: { [key: string]: { new(...args: any[]): Component<ComponentConfiguration>; } } = {};
private _coverActivated: boolean;
private _coverComponent: CoverComponent;
private _components: { [key: string]: IActiveComponent } = {};
private _components: { [key: string]: ActiveComponent } = {};
constructor(container: Container, navigator: Navigator) {
for (const componentName in ComponentService.registeredComponents) {
@ -25,7 +25,7 @@ export class ComponentService {
continue;
}
const component: new (...args: any[]) => Component<IComponentConfiguration> =
const component: new (...args: any[]) => Component<ComponentConfiguration> =
ComponentService.registeredComponents[componentName];
this._components[componentName] = {
@ -39,7 +39,7 @@ export class ComponentService {
this._coverActivated = true;
}
public static register<T extends Component<IComponentConfiguration>>(
public static register<T extends Component<ComponentConfiguration>>(
component: { componentName: string, new(...args: any[]): T; }): void {
if (ComponentService.registeredComponents[component.componentName] === undefined) {
ComponentService.registeredComponents[component.componentName] = component;
@ -66,7 +66,7 @@ export class ComponentService {
continue;
}
const component: IActiveComponent = this._components[componentName];
const component: ActiveComponent = this._components[componentName];
if (component.active) {
component.component.deactivate();
@ -86,7 +86,7 @@ export class ComponentService {
continue;
}
const component: IActiveComponent = this._components[componentName];
const component: ActiveComponent = this._components[componentName];
if (component.active) {
component.component.activate();
@ -103,7 +103,7 @@ export class ComponentService {
}
}
public configure<TConfiguration extends IComponentConfiguration>(name: string, conf: TConfiguration): void {
public configure<TConfiguration extends ComponentConfiguration>(name: string, conf: TConfiguration): void {
this._checkName(name);
this.get(name).configure(conf);
}
@ -117,7 +117,7 @@ export class ComponentService {
}
}
public get<TComponent extends Component<IComponentConfiguration>>(name: string): TComponent {
public get<TComponent extends Component<ComponentConfiguration>>(name: string): TComponent {
return <TComponent>this._components[name].component;
}

40
src/component/CoverComponent.ts
View File

@ -21,18 +21,18 @@ import {
} from "rxjs/operators";
import { Component } from "./Component";
import { CoverState, ICoverConfiguration } from "./interfaces/ICoverConfiguration";
import { CoverState, CoverConfiguration } from "./interfaces/CoverConfiguration";
import { IFullNode } from "../api/interfaces/IFullNode";
import { ImageEnt } from "../api/ents/ImageEnt";
import { MapillaryError } from "../error/MapillaryError";
import { Node } from "../graph/Node";
import { ISize } from "../render/interfaces/ISize";
import { IVNodeHash } from "../render/interfaces/IVNodeHash";
import { ViewportSize } from "../render/interfaces/ViewportSize";
import { VirtualNodeHash } from "../render/interfaces/VirtualNodeHash";
import { Urls } from "../utils/Urls";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
export class CoverComponent extends Component<ICoverConfiguration> {
export class CoverComponent extends Component<CoverConfiguration> {
public static componentName: string = "cover";
private _renderSubscription: Subscription;
@ -47,15 +47,15 @@ export class CoverComponent extends Component<ICoverConfiguration> {
protected _activate(): void {
const originalSrc$: Observable<string> = this.configuration$.pipe(
first(
(c: ICoverConfiguration): boolean => {
(c: CoverConfiguration): boolean => {
return !!c.key;
}),
filter(
(c: ICoverConfiguration): boolean => {
(c: CoverConfiguration): boolean => {
return !c.src;
}),
switchMap(
(c: ICoverConfiguration): Observable<string> => {
(c: CoverConfiguration): Observable<string> => {
return this._getImageSrc$(c.key).pipe(
catchError(
(error: Error): Observable<string> => {
@ -69,11 +69,11 @@ export class CoverComponent extends Component<ICoverConfiguration> {
this._configureSrcSubscription = originalSrc$.pipe(
map(
(src: string): ICoverConfiguration => {
(src: string): CoverConfiguration => {
return { src: src };
}))
.subscribe(
(c: ICoverConfiguration): void => {
(c: CoverConfiguration): void => {
this._configurationSubject$.next(c);
});
@ -81,23 +81,23 @@ export class CoverComponent extends Component<ICoverConfiguration> {
this.configuration$,
originalSrc$).pipe(
filter(
([c, src]: [ICoverConfiguration, string]): boolean => {
([c, src]: [CoverConfiguration, string]): boolean => {
return !!c.src && c.src !== src;
}),
first())
.subscribe(
([, src]: [ICoverConfiguration, string]): void => {
([, src]: [CoverConfiguration, string]): void => {
window.URL.revokeObjectURL(src);
});
this._keySubscription = this._configuration$.pipe(
distinctUntilChanged(
undefined,
(configuration: ICoverConfiguration): CoverState => {
(configuration: CoverConfiguration): CoverState => {
return configuration.state;
}),
switchMap(
(configuration: ICoverConfiguration): Observable<[CoverState, Node]> => {
(configuration: CoverConfiguration): Observable<[CoverState, Node]> => {
return observableCombineLatest(
observableOf(configuration.state),
this._navigator.stateService.currentNode$);
@ -123,7 +123,7 @@ export class CoverComponent extends Component<ICoverConfiguration> {
return k1 === k2 && s1 === s2;
}),
map(
([key, src]: [string, string]): ICoverConfiguration => {
([key, src]: [string, string]): CoverConfiguration => {
return { key: key, src: src };
}))
.subscribe(this._configurationSubject$);
@ -132,7 +132,7 @@ export class CoverComponent extends Component<ICoverConfiguration> {
this._configuration$,
this._container.renderService.size$).pipe(
map(
([configuration, size]: [ICoverConfiguration, ISize]): IVNodeHash => {
([configuration, size]: [CoverConfiguration, ViewportSize]): VirtualNodeHash => {
if (!configuration.src) {
return { name: this._name, vnode: vd.h("div", []) };
}
@ -163,11 +163,11 @@ export class CoverComponent extends Component<ICoverConfiguration> {
this._revokeUrlSubscription.unsubscribe();
}
protected _getDefaultConfiguration(): ICoverConfiguration {
protected _getDefaultConfiguration(): CoverConfiguration {
return { state: CoverState.Visible };
}
private _getCoverButtonVNode(configuration: ICoverConfiguration): vd.VNode {
private _getCoverButtonVNode(configuration: CoverConfiguration): vd.VNode {
const cover: string = configuration.state === CoverState.Loading ? "div.mapillary-cover.mapillary-cover-loading" : "div.mapillary-cover";
const coverButton: vd.VNode = vd.h(
"div.mapillary-cover-button",
@ -189,7 +189,7 @@ export class CoverComponent extends Component<ICoverConfiguration> {
]);
}
private _getCoverBackgroundVNode(conf: ICoverConfiguration): vd.VNode {
private _getCoverBackgroundVNode(conf: CoverConfiguration): vd.VNode {
const properties: vd.createProperties = {
style: { backgroundImage: `url(${conf.src})` },
};
@ -207,7 +207,7 @@ export class CoverComponent extends Component<ICoverConfiguration> {
(subscriber: Subscriber<string>): void => {
this._navigator.api.imageByKeyFull$([key])
.subscribe(
(fullNodes: { [key: string]: IFullNode; }): void => {
(fullNodes: { [key: string]: ImageEnt; }): void => {
if (!fullNodes[key]) {
subscriber.error(new MapillaryError(`Non existent cover key: ${key}`));
return;

18
src/component/ImageComponent.ts
View File

@ -13,15 +13,15 @@ import {
} from "rxjs/operators";
import { Component } from "./Component";
import { IComponentConfiguration } from "./interfaces/IComponentConfiguration";
import { ComponentConfiguration } from "./interfaces/ComponentConfiguration";
import { Node } from "../graph/Node";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
import { ISize } from "../render/interfaces/ISize";
import { ViewportSize } from "../render/interfaces/ViewportSize";
import { DOM } from "../utils/DOM";
export class ImageComponent extends Component<IComponentConfiguration> {
export class ImageComponent extends Component<ComponentConfiguration> {
public static componentName: string = "image";
private _canvasId: string;
@ -36,7 +36,7 @@ export class ImageComponent extends Component<IComponentConfiguration> {
}
protected _activate(): void {
const canvasSize$: Observable<[HTMLCanvasElement, ISize]> = this._container.domRenderer.element$.pipe(
const canvasSize$: Observable<[HTMLCanvasElement, ViewportSize]> = this._container.domRenderer.element$.pipe(
map(
(): HTMLCanvasElement => {
return <HTMLCanvasElement>this._dom.document.getElementById(this._canvasId);
@ -46,7 +46,7 @@ export class ImageComponent extends Component<IComponentConfiguration> {
return !!canvas;
}),
map(
(canvas: HTMLCanvasElement): [HTMLCanvasElement, ISize] => {
(canvas: HTMLCanvasElement): [HTMLCanvasElement, ViewportSize] => {
const adaptableDomRenderer: HTMLElement = canvas.parentElement;
const width: number = adaptableDomRenderer.offsetWidth;
const height: number = adaptableDomRenderer.offsetHeight;
@ -54,10 +54,10 @@ export class ImageComponent extends Component<IComponentConfiguration> {
return [canvas, { height: height, width: width }];
}),
distinctUntilChanged(
(s1: ISize, s2: ISize): boolean => {
(s1: ViewportSize, s2: ViewportSize): boolean => {
return s1.height === s2.height && s1.width === s2.width;
},
([, size]: [HTMLCanvasElement, ISize]): ISize => {
([, size]: [HTMLCanvasElement, ViewportSize]): ViewportSize => {
return size;
}));
@ -65,7 +65,7 @@ export class ImageComponent extends Component<IComponentConfiguration> {
canvasSize$,
this._navigator.stateService.currentNode$)
.subscribe(
([[canvas, size], node]: [[HTMLCanvasElement, ISize], Node]): void => {
([[canvas, size], node]: [[HTMLCanvasElement, ViewportSize], Node]): void => {
canvas.width = size.width;
canvas.height = size.height;
canvas
@ -80,7 +80,7 @@ export class ImageComponent extends Component<IComponentConfiguration> {
this.drawSubscription.unsubscribe();
}
protected _getDefaultConfiguration(): IComponentConfiguration {
protected _getDefaultConfiguration(): ComponentConfiguration {
return {};
}
}

60
src/component/NavigationComponent.ts
View File

@ -13,14 +13,14 @@ import {
} from "rxjs/operators";
import { Component } from "./Component";
import { INavigationConfiguration } from "./interfaces/INavigationConfiguration";
import { NavigationConfiguration } from "./interfaces/NavigationConfiguration";
import { AbortMapillaryError } from "../error/AbortMapillaryError";
import { Node } from "../graph/Node";
import { EdgeDirection } from "../graph/edge/EdgeDirection";
import { IEdge } from "../graph/edge/interfaces/IEdge";
import { IEdgeStatus } from "../graph/interfaces/IEdgeStatus";
import { IVNodeHash } from "../render/interfaces/IVNodeHash";
import { NavigationDirection } from "../graph/edge/NavigationDirection";
import { NavigationEdge } from "../graph/edge/interfaces/NavigationEdge";
import { NavigationEdgeStatus } from "../graph/interfaces/NavigationEdgeStatus";
import { VirtualNodeHash } from "../render/interfaces/VirtualNodeHash";
import { Container } from "../viewer/Container";
import { Navigator } from "../viewer/Navigator";
import { isSpherical } from "../geo/Geo";
@ -32,7 +32,7 @@ import { isSpherical } from "../geo/Geo";
*
* Replaces the functionality in the Direction and Sequence components.
*/
export class NavigationComponent extends Component<INavigationConfiguration> {
export class NavigationComponent extends Component<NavigationConfiguration> {
public static componentName: string = "navigation";
private _renderSubscription: Subscription;
@ -46,18 +46,18 @@ export class NavigationComponent extends Component<INavigationConfiguration> {
super(name, container, navigator);
this._seqNames = {};
this._seqNames[EdgeDirection[EdgeDirection.Prev]] = "-prev";
this._seqNames[EdgeDirection[EdgeDirection.Next]] = "-next";
this._seqNames[NavigationDirection[NavigationDirection.Prev]] = "-prev";
this._seqNames[NavigationDirection[NavigationDirection.Next]] = "-next";
this._spaTopNames = {};
this._spaTopNames[EdgeDirection[EdgeDirection.TurnLeft]] = "-turn-left";
this._spaTopNames[EdgeDirection[EdgeDirection.StepLeft]] = "-left";
this._spaTopNames[EdgeDirection[EdgeDirection.StepForward]] = "-forward";
this._spaTopNames[EdgeDirection[EdgeDirection.StepRight]] = "-right";
this._spaTopNames[EdgeDirection[EdgeDirection.TurnRight]] = "-turn-right";
this._spaTopNames[NavigationDirection[NavigationDirection.TurnLeft]] = "-turn-left";
this._spaTopNames[NavigationDirection[NavigationDirection.StepLeft]] = "-left";
this._spaTopNames[NavigationDirection[NavigationDirection.StepForward]] = "-forward";
this._spaTopNames[NavigationDirection[NavigationDirection.StepRight]] = "-right";
this._spaTopNames[NavigationDirection[NavigationDirection.TurnRight]] = "-turn-right";
this._spaBottomNames = {};
this._spaBottomNames[EdgeDirection[EdgeDirection.TurnU]] = "-turn-around";
this._spaBottomNames[EdgeDirection[EdgeDirection.StepBackward]] = "-backward";
this._spaBottomNames[NavigationDirection[NavigationDirection.TurnU]] = "-turn-around";
this._spaBottomNames[NavigationDirection[NavigationDirection.StepBackward]] = "-backward";
}
protected _activate(): void {
@ -65,42 +65,42 @@ export class NavigationComponent extends Component<INavigationConfiguration> {
this._navigator.stateService.currentNode$,
this._configuration$).pipe(
switchMap(
([node, configuration]: [Node, INavigationConfiguration]): Observable<EdgeDirection[]> => {
const sequenceEdges$: Observable<EdgeDirection[]> = configuration.sequence ?
([node, configuration]: [Node, NavigationConfiguration]): Observable<NavigationDirection[]> => {
const sequenceEdges$: Observable<NavigationDirection[]> = configuration.sequence ?
node.sequenceEdges$.pipe(
map(
(status: IEdgeStatus): EdgeDirection[] => {
(status: NavigationEdgeStatus): NavigationDirection[] => {
return status.edges
.map(
(edge: IEdge): EdgeDirection => {
(edge: NavigationEdge): NavigationDirection => {
return edge.data.direction;
});
})) :
observableOf<EdgeDirection[]>([]);
observableOf<NavigationDirection[]>([]);
const spatialEdges$: Observable<EdgeDirection[]> = !isSpherical(node.cameraType) &&
const spatialEdges$: Observable<NavigationDirection[]> = !isSpherical(node.cameraType) &&
configuration.spatial ?
node.spatialEdges$.pipe(
map(
(status: IEdgeStatus): EdgeDirection[] => {
(status: NavigationEdgeStatus): NavigationDirection[] => {
return status.edges
.map(
(edge: IEdge): EdgeDirection => {
(edge: NavigationEdge): NavigationDirection => {
return edge.data.direction;
});
})) :
observableOf<EdgeDirection[]>([]);
observableOf<NavigationDirection[]>([]);
return observableCombineLatest(
sequenceEdges$,
spatialEdges$).pipe(
map(
([seq, spa]: [EdgeDirection[], EdgeDirection[]]): EdgeDirection[] => {
([seq, spa]: [NavigationDirection[], NavigationDirection[]]): NavigationDirection[] => {
return seq.concat(spa);
}));
}),
map(
(edgeDirections: EdgeDirection[]): IVNodeHash => {
(edgeDirections: NavigationDirection[]): VirtualNodeHash => {
const seqs: vd.VNode[] = this._createArrowRow(this._seqNames, edgeDirections);
const spaTops: vd.VNode[] = this._createArrowRow(this._spaTopNames, edgeDirections);
const spaBottoms: vd.VNode[] = this._createArrowRow(this._spaBottomNames, edgeDirections);
@ -119,11 +119,11 @@ export class NavigationComponent extends Component<INavigationConfiguration> {
this._renderSubscription.unsubscribe();
}
protected _getDefaultConfiguration(): INavigationConfiguration {
protected _getDefaultConfiguration(): NavigationConfiguration {
return { sequence: true, spatial: true };
}
private _createArrowRow(arrowNames: { [dir: string]: string }, edgeDirections: EdgeDirection[]): vd.VNode[] {
private _createArrowRow(arrowNames: { [dir: string]: string }, edgeDirections: NavigationDirection[]): vd.VNode[] {
const arrows: vd.VNode[] = [];
for (const arrowName in arrowNames) {
@ -131,7 +131,7 @@ export class NavigationComponent extends Component<INavigationConfiguration> {
continue;
}
const direction: EdgeDirection = EdgeDirection[<keyof typeof EdgeDirection>arrowName];
const direction: NavigationDirection = NavigationDirection[<keyof typeof NavigationDirection>arrowName];
if (edgeDirections.indexOf(direction) !== -1) {
arrows.push(this._createVNode(direction, arrowNames[arrowName], "visible"));
} else {
@ -142,7 +142,7 @@ export class NavigationComponent extends Component<INavigationConfiguration> {
return arrows;
}
private _createVNode(direction: EdgeDirection, name: string, visibility: string): vd.VNode {
private _createVNode(direction: NavigationDirection, name: string, visibility: string): vd.VNode {
return vd.h(
`span.mapillary-navigation-button.mapillary-navigation${name}`,
{

22
src/component/direction/DirectionComponent.ts
View File

@ -25,19 +25,19 @@ import { Component } from "../Component";
import { Node } from "../../graph/Node";
import { Container } from "../../viewer/Container";
import { Navigator } from "../../viewer/Navigator";
import { IEdgeStatus } from "../../graph/interfaces/IEdgeStatus";
import { NavigationEdgeStatus } from "../../graph/interfaces/NavigationEdgeStatus";
import { Sequence } from "../../graph/Sequence";
import { ISize } from "../../render/interfaces/ISize";
import { IVNodeHash } from "../../render/interfaces/IVNodeHash";
import { ViewportSize } from "../../render/interfaces/ViewportSize";
import { VirtualNodeHash } from "../../render/interfaces/VirtualNodeHash";
import { RenderCamera } from "../../render/RenderCamera";
import { IDirectionConfiguration } from "../interfaces/IDirectionConfiguration";
import { DirectionConfiguration } from "../interfaces/DirectionConfiguration";
import { DirectionDOMRenderer } from "./DirectionDOMRenderer";
/**
* @class DirectionComponent
* @classdesc Component showing navigation arrows for steps and turns.
*/
export class DirectionComponent extends Component<IDirectionConfiguration> {
export class DirectionComponent extends Component<DirectionConfiguration> {
/** @inheritdoc */
public static componentName: string = "direction";
@ -140,13 +140,13 @@ export class DirectionComponent extends Component<IDirectionConfiguration> {
protected _activate(): void {
this._configurationSubscription = this._configuration$
.subscribe(
(configuration: IDirectionConfiguration): void => {
(configuration: DirectionConfiguration): void => {
this._renderer.setConfiguration(configuration);
});
this._resizeSubscription = this._container.renderService.size$
.subscribe(
(size: ISize): void => {
(size: ViewportSize): void => {
this._renderer.resize(size);
});
@ -158,7 +158,7 @@ export class DirectionComponent extends Component<IDirectionConfiguration> {
}),
withLatestFrom(this._configuration$),
switchMap(
([node, configuration]: [Node, IDirectionConfiguration]): Observable<[IEdgeStatus, Sequence]> => {
([node, configuration]: [Node, DirectionConfiguration]): Observable<[NavigationEdgeStatus, Sequence]> => {
return observableCombineLatest(
node.spatialEdges$,
configuration.distinguishSequence ?
@ -173,7 +173,7 @@ export class DirectionComponent extends Component<IDirectionConfiguration> {
observableOf<Sequence>(null));
}))
.subscribe(
([edgeStatus, sequence]: [IEdgeStatus, Sequence]): void => {
([edgeStatus, sequence]: [NavigationEdgeStatus, Sequence]): void => {
this._renderer.setEdges(edgeStatus, sequence);
});
@ -191,7 +191,7 @@ export class DirectionComponent extends Component<IDirectionConfiguration> {
return renderer.needsRender;
}),
map(
(renderer: DirectionDOMRenderer): IVNodeHash => {
(renderer: DirectionDOMRenderer): VirtualNodeHash => {
return { name: this._name, vnode: renderer.render(this._navigator) };
}))
.subscribe(this._container.domRenderer.render$);
@ -235,7 +235,7 @@ export class DirectionComponent extends Component<IDirectionConfiguration> {
this._resizeSubscription.unsubscribe();
}
protected _getDefaultConfiguration(): IDirectionConfiguration {
protected _getDefaultConfiguration(): DirectionConfiguration {
return {
distinguishSequence: false,
maxWidth: 460,

18
src/component/direction/DirectionDOMCalculator.ts
View File

@ -1,6 +1,6 @@
import { Spatial } from "../../geo/Spatial";
import { ISize } from "../../render/interfaces/ISize";
import { IDirectionConfiguration } from "../interfaces/IDirectionConfiguration";
import { ViewportSize } from "../../render/interfaces/ViewportSize";
import { DirectionConfiguration } from "../interfaces/DirectionConfiguration";
/**
* @class DirectionDOMCalculator
@ -40,7 +40,7 @@ export class DirectionDOMCalculator {
private _shadowOffset: number;
constructor(configuration: IDirectionConfiguration, size: ISize) {
constructor(configuration: DirectionConfiguration, size: ViewportSize) {
this._spatial = new Spatial();
this._minThresholdWidth = 320;
@ -124,10 +124,10 @@ export class DirectionDOMCalculator {
/**
* Configures the min and max width values.
*
* @param {IDirectionConfiguration} configuration Configuration
* @param {DirectionConfiguration} configuration Configuration
* with min and max width values.
*/
public configure(configuration: IDirectionConfiguration): void {
public configure(configuration: DirectionConfiguration): void {
this._configure(configuration);
this._reset();
}
@ -136,9 +136,9 @@ export class DirectionDOMCalculator {
* Resizes all properties according to the width and height
* of the size object.
*
* @param {ISize} size The size of the container element.
* @param {ViewportSize} size The size of the container element.
*/
public resize(size: ISize): void {
public resize(size: ViewportSize): void {
this._resize(size);
this._reset();
}
@ -168,12 +168,12 @@ export class DirectionDOMCalculator {
return this.angleToCoordinates(relativeAngle);
}
private _configure(configuration: IDirectionConfiguration): void {
private _configure(configuration: DirectionConfiguration): void {
this._minWidth = configuration.minWidth;
this._maxWidth = this._getMaxWidth(configuration.minWidth, configuration.maxWidth);
}
private _resize(size: ISize): void {
private _resize(size: ViewportSize): void {
this._elementWidth = size.width;
this._elementHeight = size.height;
}

Some files were not shown because too many files have changed in this diff Show More