import { defaultValue } from "../../Source/Cesium.js";
|
import { Ellipsoid } from "../../Source/Cesium.js";
|
import { GeographicTilingScheme } from "../../Source/Cesium.js";
|
import { GoogleEarthEnterpriseMetadata } from "../../Source/Cesium.js";
|
import { GoogleEarthEnterpriseTerrainData } from "../../Source/Cesium.js";
|
import { GoogleEarthEnterpriseTerrainProvider } from "../../Source/Cesium.js";
|
import { GoogleEarthEnterpriseTileInformation } from "../../Source/Cesium.js";
|
import { Math as CesiumMath } from "../../Source/Cesium.js";
|
import { Request } from "../../Source/Cesium.js";
|
import { RequestScheduler } from "../../Source/Cesium.js";
|
import { Resource } from "../../Source/Cesium.js";
|
import { TerrainProvider } from "../../Source/Cesium.js";
|
import pollToPromise from "../pollToPromise.js";
|
import { when } from "../../Source/Cesium.js";
|
|
describe("Core/GoogleEarthEnterpriseTerrainProvider", function () {
|
function installMockGetQuadTreePacket() {
|
spyOn(
|
GoogleEarthEnterpriseMetadata.prototype,
|
"getQuadTreePacket"
|
).and.callFake(function (quadKey, version) {
|
quadKey = defaultValue(quadKey, "");
|
var t = new GoogleEarthEnterpriseTileInformation(0xff, 1, 1, 1);
|
t.ancestorHasTerrain = true;
|
this._tileInfo[quadKey + "0"] = t;
|
|
t = new GoogleEarthEnterpriseTileInformation(0xff, 1, 1, 1);
|
t.ancestorHasTerrain = true;
|
this._tileInfo[quadKey + "1"] = t;
|
|
t = new GoogleEarthEnterpriseTileInformation(0xff, 1, 1, 1);
|
t.ancestorHasTerrain = true;
|
this._tileInfo[quadKey + "2"] = t;
|
|
t = new GoogleEarthEnterpriseTileInformation(0xff, 1, 1, 1);
|
t.ancestorHasTerrain = true;
|
this._tileInfo[quadKey + "3"] = t;
|
|
return when();
|
});
|
}
|
|
var terrainProvider;
|
|
function waitForTile(level, x, y, f) {
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
return pollToPromise(function () {
|
return (
|
terrainProvider.ready &&
|
terrainProvider.getTileDataAvailable(x, y, level)
|
);
|
}).then(function () {
|
var promise = terrainProvider.requestTileGeometry(level, x, y);
|
|
return when(promise, f, function (error) {
|
expect("requestTileGeometry").toBe("returning a tile."); // test failure
|
});
|
});
|
}
|
|
function createRequest() {
|
return new Request({
|
throttleByServer: true,
|
});
|
}
|
|
beforeEach(function () {
|
RequestScheduler.clearForSpecs();
|
});
|
|
afterEach(function () {
|
Resource._Implementations.loadWithXhr =
|
Resource._DefaultImplementations.loadWithXhr;
|
});
|
|
it("conforms to TerrainProvider interface", function () {
|
expect(GoogleEarthEnterpriseTerrainProvider).toConformToInterface(
|
TerrainProvider
|
);
|
});
|
|
it("constructor throws if url is not provided", function () {
|
expect(function () {
|
return new GoogleEarthEnterpriseTerrainProvider();
|
}).toThrowDeveloperError();
|
|
expect(function () {
|
return new GoogleEarthEnterpriseTerrainProvider({});
|
}).toThrowDeveloperError();
|
});
|
|
it("resolves readyPromise", function () {
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
return terrainProvider.readyPromise.then(function (result) {
|
expect(result).toBe(true);
|
expect(terrainProvider.ready).toBe(true);
|
});
|
});
|
|
it("resolves readyPromise with Resource", function () {
|
var resource = new Resource({
|
url: "made/up/url",
|
});
|
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: resource,
|
});
|
|
return terrainProvider.readyPromise.then(function (result) {
|
expect(result).toBe(true);
|
expect(terrainProvider.ready).toBe(true);
|
});
|
});
|
|
it("uses geographic tiling scheme by default", function () {
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
expect(terrainProvider.tilingScheme).toBeInstanceOf(
|
GeographicTilingScheme
|
);
|
});
|
});
|
|
it("can use a custom ellipsoid", function () {
|
installMockGetQuadTreePacket();
|
|
var ellipsoid = new Ellipsoid(1, 2, 3);
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
ellipsoid: ellipsoid,
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
expect(terrainProvider.tilingScheme.ellipsoid).toEqual(ellipsoid);
|
});
|
});
|
|
it("has error event", function () {
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
expect(terrainProvider.errorEvent).toBeDefined();
|
expect(terrainProvider.errorEvent).toBe(terrainProvider.errorEvent);
|
});
|
|
it("returns reasonable geometric error for various levels", function () {
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
expect(terrainProvider.getLevelMaximumGeometricError(0)).toBeGreaterThan(
|
0.0
|
);
|
expect(terrainProvider.getLevelMaximumGeometricError(0)).toEqualEpsilon(
|
terrainProvider.getLevelMaximumGeometricError(1) * 2.0,
|
CesiumMath.EPSILON10
|
);
|
expect(terrainProvider.getLevelMaximumGeometricError(1)).toEqualEpsilon(
|
terrainProvider.getLevelMaximumGeometricError(2) * 2.0,
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("readyPromise rejects if there isn't terrain", function () {
|
installMockGetQuadTreePacket();
|
|
var metadata = new GoogleEarthEnterpriseMetadata({
|
url: "made/up/url",
|
});
|
|
metadata.terrainPresent = false;
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
metadata: metadata,
|
});
|
|
return terrainProvider.readyPromise
|
.then(function () {
|
fail("Server does not have terrain, so we shouldn't resolve.");
|
})
|
.otherwise(function () {
|
expect(terrainProvider.ready).toBe(false);
|
});
|
});
|
|
it("logo is undefined if credit is not provided", function () {
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
expect(terrainProvider.credit).toBeUndefined();
|
});
|
});
|
|
it("logo is defined if credit is provided", function () {
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
credit: "thanks to our awesome made up contributors!",
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
expect(terrainProvider.credit).toBeDefined();
|
});
|
});
|
|
it("has a water mask is false", function () {
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
expect(terrainProvider.hasWaterMask).toBe(false);
|
});
|
});
|
|
it("has vertex normals is false", function () {
|
installMockGetQuadTreePacket();
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: "made/up/url",
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
expect(terrainProvider.hasVertexNormals).toBe(false);
|
});
|
});
|
|
describe("requestTileGeometry", function () {
|
it("provides GoogleEarthEnterpriseTerrainData", function () {
|
installMockGetQuadTreePacket();
|
Resource._Implementations.loadWithXhr = function (
|
url,
|
responseType,
|
method,
|
data,
|
headers,
|
deferred,
|
overrideMimeType
|
) {
|
Resource._DefaultImplementations.loadWithXhr(
|
"Data/GoogleEarthEnterprise/gee.terrain",
|
responseType,
|
method,
|
data,
|
headers,
|
deferred
|
);
|
};
|
|
return waitForTile(0, 0, 0, function (loadedData) {
|
expect(loadedData).toBeInstanceOf(GoogleEarthEnterpriseTerrainData);
|
});
|
});
|
|
it("returns undefined if too many requests are already in progress", function () {
|
installMockGetQuadTreePacket();
|
var baseUrl = "made/up/url";
|
|
var deferreds = [];
|
var loadRealTile = true;
|
Resource._Implementations.loadWithXhr = function (
|
url,
|
responseType,
|
method,
|
data,
|
headers,
|
deferred,
|
overrideMimeType
|
) {
|
if (url.indexOf("dbRoot.v5") !== -1) {
|
return deferred.reject(); // Just reject dbRoot file and use defaults.
|
}
|
|
if (loadRealTile) {
|
loadRealTile = false;
|
return Resource._DefaultImplementations.loadWithXhr(
|
"Data/GoogleEarthEnterprise/gee.terrain",
|
responseType,
|
method,
|
data,
|
headers,
|
deferred
|
);
|
}
|
// Do nothing, so requests never complete
|
deferreds.push(deferred);
|
};
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: baseUrl,
|
});
|
|
var promises = [];
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
})
|
.then(function () {
|
return pollToPromise(function () {
|
var b = true;
|
for (var i = 0; i < 10; ++i) {
|
b = b && terrainProvider.getTileDataAvailable(i, i, i);
|
}
|
return b && terrainProvider.getTileDataAvailable(1, 2, 3);
|
});
|
})
|
.then(function () {
|
var promise;
|
for (var i = 0; i < RequestScheduler.maximumRequestsPerServer; ++i) {
|
promise = terrainProvider.requestTileGeometry(
|
i,
|
i,
|
i,
|
createRequest()
|
);
|
promises.push(promise);
|
}
|
RequestScheduler.update();
|
expect(promise).toBeDefined();
|
|
return terrainProvider.requestTileGeometry(1, 2, 3, createRequest());
|
})
|
.then(function (terrainData) {
|
expect(terrainData).toBeUndefined();
|
for (var i = 0; i < deferreds.length; ++i) {
|
deferreds[i].resolve();
|
}
|
|
// Parsing terrain will fail, so just eat the errors and request the tile again
|
return when.all(promises).otherwise(function () {
|
loadRealTile = true;
|
return terrainProvider.requestTileGeometry(1, 2, 3);
|
});
|
})
|
.then(function (terrainData) {
|
expect(terrainData).toBeDefined();
|
});
|
});
|
|
it("supports getTileDataAvailable()", function () {
|
installMockGetQuadTreePacket();
|
var baseUrl = "made/up/url";
|
|
Resource._Implementations.loadWithXhr = function (
|
url,
|
responseType,
|
method,
|
data,
|
headers,
|
deferred,
|
overrideMimeType
|
) {
|
Resource._DefaultImplementations.loadWithXhr(
|
"Data/CesiumTerrainTileJson/tile.terrain",
|
responseType,
|
method,
|
data,
|
headers,
|
deferred
|
);
|
};
|
|
terrainProvider = new GoogleEarthEnterpriseTerrainProvider({
|
url: baseUrl,
|
});
|
|
return pollToPromise(function () {
|
return terrainProvider.ready;
|
}).then(function () {
|
var tileInfo = terrainProvider._metadata._tileInfo;
|
var info =
|
tileInfo[GoogleEarthEnterpriseMetadata.tileXYToQuadKey(0, 1, 0)];
|
info._bits = 0x7f; // Remove terrain bit from 0,1,0 tile
|
info.terrainState = 1; // NONE
|
info.ancestorHasTerrain = true;
|
|
expect(terrainProvider.getTileDataAvailable(0, 0, 0)).toBe(true);
|
expect(terrainProvider.getTileDataAvailable(0, 1, 0)).toBe(false);
|
expect(terrainProvider.getTileDataAvailable(1, 0, 0)).toBe(true);
|
expect(terrainProvider.getTileDataAvailable(1, 1, 0)).toBe(true);
|
expect(terrainProvider.getTileDataAvailable(0, 0, 2)).toBe(false);
|
});
|
});
|
});
|
});
|
