OK or ZERO_RESULTS
+ */
+GoogleGeocoderService.prototype.geocode = async function (query) {
+ // See API documentation at https://developers.google.com/maps/documentation/geocoding/requests-geocoding
+
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.string("query", query);
+ //>>includeEnd('debug');
+
+ const resource = this._resource.getDerivedResource({
+ queryParameters: {
+ address: query,
+ },
+ });
+
+ const response = await resource.fetchJson();
+
+ if (response.status === "ZERO_RESULTS") {
+ return [];
+ }
+
+ if (response.status !== "OK") {
+ throw new RuntimeError(
+ `GoogleGeocoderService got a bad response ${response.status}: ${response.error_message}`,
+ );
+ }
+
+ const results = response.results.map((result) => {
+ const southWest = result.geometry.viewport.southwest;
+ const northEast = result.geometry.viewport.northeast;
+ return {
+ displayName: result.formatted_address,
+ destination: Rectangle.fromDegrees(
+ southWest.lng,
+ southWest.lat,
+ northEast.lng,
+ northEast.lat,
+ ),
+ attribution: {
+ html: CREDIT_HTML,
+ collapsible: false,
+ },
+ };
+ });
+
+ return results;
+};
+
+export default GoogleGeocoderService;
diff --git a/packages/engine/Source/Core/IonGeocodeProviderType.js b/packages/engine/Source/Core/IonGeocodeProviderType.js
new file mode 100644
index 000000000000..2dc9bf35d775
--- /dev/null
+++ b/packages/engine/Source/Core/IonGeocodeProviderType.js
@@ -0,0 +1,33 @@
+/**
+ * Underlying geocoding services that can be used via Cesium ion.
+ *
+ * @enum {string}
+ */
+const IonGeocodeProviderType = {
+ /**
+ * Google geocoder, for use with Google data.
+ *
+ * @type {string}
+ * @constant
+ */
+ GOOGLE: "GOOGLE",
+
+ /**
+ * Bing geocoder, for use with Bing data.
+ *
+ * @type {string}
+ * @constant
+ */
+ BING: "BING",
+
+ /**
+ * Use the default geocoder as set on the server. Used when neither Bing or
+ * Google data is used.
+ *
+ * @type {string}
+ * @constant
+ */
+ DEFAULT: "DEFAULT",
+};
+
+export default Object.freeze(IonGeocodeProviderType);
diff --git a/packages/engine/Source/Core/IonGeocoderService.js b/packages/engine/Source/Core/IonGeocoderService.js
index 81da96b7dbba..f473d80005b3 100644
--- a/packages/engine/Source/Core/IonGeocoderService.js
+++ b/packages/engine/Source/Core/IonGeocoderService.js
@@ -2,10 +2,45 @@ import Check from "./Check.js";
import Credit from "./Credit.js";
import defaultValue from "./defaultValue.js";
import defined from "./defined.js";
+import DeveloperError from "./DeveloperError.js";
import Ion from "./Ion.js";
+import IonGeocodeProviderType from "./IonGeocodeProviderType.js";
import PeliasGeocoderService from "./PeliasGeocoderService.js";
import Resource from "./Resource.js";
+/**
+ * @param {*} geocodeProviderType
+ * @throws {DeveloperError}
+ * @private
+ */
+function validateIonGeocodeProviderType(geocodeProviderType) {
+ if (
+ !Object.values(IonGeocodeProviderType).some(
+ (value) => value === geocodeProviderType,
+ )
+ ) {
+ throw new DeveloperError(
+ `Invalid geocodeProviderType: "${geocodeProviderType}"`,
+ );
+ }
+}
+
+const providerToParameterMap = Object.freeze({
+ [IonGeocodeProviderType.GOOGLE]: "google",
+ [IonGeocodeProviderType.BING]: "bing",
+ [IonGeocodeProviderType.DEFAULT]: undefined,
+});
+
+function providerToQueryParameter(provider) {
+ return providerToParameterMap[provider];
+}
+
+function queryParameterToProvider(parameter) {
+ return Object.entries(providerToParameterMap).find(
+ (entry) => entry[1] === parameter,
+ )[0];
+}
+
/**
* Provides geocoding through Cesium ion.
* @alias IonGeocoderService
@@ -15,6 +50,7 @@ import Resource from "./Resource.js";
* @param {Scene} options.scene The scene
* @param {string} [options.accessToken=Ion.defaultAccessToken] The access token to use.
* @param {string|Resource} [options.server=Ion.defaultServer] The resource to the Cesium ion API server.
+ * @param {IonGeocodeProviderType} [options.geocodeProviderType=IonGeocodeProviderType.DEFAULT] The geocoder the Cesium ion API server should use to fulfill this request.
*
* @see Ion
*/
@@ -25,6 +61,14 @@ function IonGeocoderService(options) {
Check.typeOf.object("options.scene", options.scene);
//>>includeEnd('debug');
+ const geocodeProviderType = defaultValue(
+ options.geocodeProviderType,
+ IonGeocodeProviderType.DEFAULT,
+ );
+ //>>includeStart('debug', pragmas.debug);
+ validateIonGeocodeProviderType(geocodeProviderType);
+ //>>includeEnd('debug');
+
const accessToken = defaultValue(options.accessToken, Ion.defaultAccessToken);
const server = Resource.createIfNeeded(
defaultValue(options.server, Ion.defaultServer),
@@ -49,6 +93,9 @@ function IonGeocoderService(options) {
this._accessToken = accessToken;
this._server = server;
this._pelias = new PeliasGeocoderService(searchEndpoint);
+ // geocoderProviderType isn't stored here directly but instead relies on the
+ // query parameters of this._pelias.url. Use the setter logic to update value.
+ this.geocodeProviderType = geocodeProviderType;
}
Object.defineProperties(IonGeocoderService.prototype, {
@@ -64,6 +111,31 @@ Object.defineProperties(IonGeocoderService.prototype, {
return undefined;
},
},
+ /**
+ * The geocoding service that Cesium ion API server should use to fulfill geocding requests.
+ * @memberof IonGeocoderService.prototype
+ * @type {IonGeocodeProviderType}
+ * @default IonGeocodeProviderType.DEFAULT
+ */
+ geocodeProviderType: {
+ get: function () {
+ return queryParameterToProvider(
+ this._pelias.url.queryParameters["geocoder"],
+ );
+ },
+ set: function (geocodeProviderType) {
+ validateIonGeocodeProviderType(geocodeProviderType);
+ const query = {
+ ...this._pelias.url.queryParameters,
+ geocoder: providerToQueryParameter(geocodeProviderType),
+ };
+ // Delete the geocoder parameter to prevent sending &geocoder=undefined in the query
+ if (!defined(query.geocoder)) {
+ delete query.geocoder;
+ }
+ this._pelias.url.setQueryParameters(query);
+ },
+ },
});
/**
diff --git a/packages/engine/Source/Core/TrackingReferenceFrame.js b/packages/engine/Source/Core/TrackingReferenceFrame.js
index 4ad418e96b7a..d16be08b853b 100644
--- a/packages/engine/Source/Core/TrackingReferenceFrame.js
+++ b/packages/engine/Source/Core/TrackingReferenceFrame.js
@@ -16,25 +16,30 @@ const TrackingReferenceFrame = {
*/
AUTODETECT: 0,
+ /**
+ * The entity's local East-North-Up reference frame.
+ *
+ * @type {number}
+ * @constant
+ */
+ ENU: 1,
+
/**
* The entity's inertial reference frame. If entity has no defined orientation
- * property, a {@link VelocityOrientationProperty} is used instead, thus
- * falling back to TrackingReferenceFrame.VELOCITY.
- * When selected, the auto-detect algorithm is overridden.
+ * property, it falls back to auto-detect algorithm.
*
* @type {number}
* @constant
*/
- INERTIAL: 1,
+ INERTIAL: 2,
/**
* The entity's inertial reference frame with orientation fixed to its
* {@link VelocityOrientationProperty}, ignoring its own orientation.
- * When selected, the auto-detect algorithm is overridden.
*
* @type {number}
* @constant
*/
- VELOCITY: 2,
+ VELOCITY: 3,
};
export default Object.freeze(TrackingReferenceFrame);
diff --git a/packages/engine/Source/DataSources/EntityView.js b/packages/engine/Source/DataSources/EntityView.js
index bc759b53dbd6..9e7ae33234b5 100644
--- a/packages/engine/Source/DataSources/EntityView.js
+++ b/packages/engine/Source/DataSources/EntityView.js
@@ -269,7 +269,12 @@ function updateTransform(
rotationScratch,
);
Matrix4.fromRotationTranslation(rotation, cartesian, transform);
- } else if (hasBasis) {
+ } else if (
+ trackingReferenceFrame === TrackingReferenceFrame.ENU ||
+ !hasBasis
+ ) {
+ Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, transform);
+ } else {
transform[0] = xBasis.x;
transform[1] = xBasis.y;
transform[2] = xBasis.z;
@@ -286,9 +291,6 @@ function updateTransform(
transform[13] = cartesian.y;
transform[14] = cartesian.z;
transform[15] = 0.0;
- } else {
- // Stationary or slow-moving, low-altitude objects use East-North-Up.
- Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, transform);
}
camera._setTransform(transform);
diff --git a/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js b/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
index f762d748dc36..9c7bad99e30d 100644
--- a/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
+++ b/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
@@ -4,23 +4,37 @@ import defined from "../Core/defined.js";
import IonResource from "../Core/IonResource.js";
import GoogleMaps from "../Core/GoogleMaps.js";
import Resource from "../Core/Resource.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
/**
- * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D Tiles tileset.
+ * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D
+ * Tiles tileset.
+ *
+ * Google Photorealistic 3D Tiles can only be used with the Google geocoder. To
+ * confirm that you are aware of this restriction pass
+ * `usingOnlyWithGoogleGeocoder: true` to the apiOptions. Otherwise a one time
+ * warning will be displayed when this function is called.
*
* @function
*
- * @param {string} [key=GoogleMaps.defaultApiKey] Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
- * @param {Cesium3DTileset.ConstructorOptions} [options] An object describing initialization options.
+ * @param {object} [apiOptions]
+ * @param {string} [apiOptions.key=GoogleMaps.defaultApiKey] Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
+ * @param {true} [apiOptions.onlyUsingWithGoogleGeocoder] Confirmation that this tileset will only be used with the Google geocoder.
+ * @param {Cesium3DTileset.ConstructorOptions} [tilesetOptions] An object describing initialization options.
* @returns {Promise
`,
+ collapsible: false,
+ },
+ },
+ ]);
+ });
+
+ it("returns empty array for status=ZERO_RESULTS", async function () {
+ const service = new GoogleGeocoderService({ key: "key" });
+
+ spyOn(Resource.prototype, "fetchJson").and.resolveTo({
+ status: "ZERO_RESULTS",
+ });
+
+ const results = await service.geocode("test");
+ expect(results).toEqual([]);
+ });
+});
diff --git a/packages/engine/Specs/Core/IonGeocoderServiceSpec.js b/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
index 17951c615c02..719a762daffc 100644
--- a/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
+++ b/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
@@ -1,7 +1,9 @@
import {
+ DeveloperError,
GeocoderService,
GeocodeType,
Ion,
+ IonGeocodeProviderType,
IonGeocoderService,
} from "../../index.js";
@@ -26,20 +28,24 @@ describe("Core/IonGeocoderService", function () {
expect(service._accessToken).toEqual(Ion.defaultAccessToken);
expect(service._server.url).toEqual(Ion.defaultServer.url);
+ expect(service.geocodeProviderType).toEqual(IonGeocodeProviderType.DEFAULT);
});
it("creates with specified parameters", function () {
const accessToken = "123456";
const server = "http://not.ion.invalid/";
+ const geocodeProviderType = IonGeocodeProviderType.GOOGLE;
const service = new IonGeocoderService({
accessToken: accessToken,
server: server,
scene: scene,
+ geocodeProviderType,
});
expect(service._accessToken).toEqual(accessToken);
expect(service._server.url).toEqual(server);
+ expect(service.geocodeProviderType).toEqual(geocodeProviderType);
});
it("calls inner geocoder and returns result", async function () {
@@ -64,4 +70,47 @@ describe("Core/IonGeocoderService", function () {
expect(service.credit).toBeUndefined();
});
+
+ it("setting geocodeProviderType updates _pelias.url for GOOGLE", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.DEFAULT,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.GOOGLE;
+ expect(service._pelias.url.queryParameters["geocoder"]).toEqual("google");
+ });
+
+ it("setting geocodeProviderType updates _pelias.url for BING", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.DEFAULT,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.BING;
+ expect(service._pelias.url.queryParameters["geocoder"]).toEqual("bing");
+ });
+
+ it("setting geocodeProviderType updates _pelias.url for DEFAULT", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.GOOGLE,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.DEFAULT;
+ const queryParameters = service._pelias.url.queryParameters;
+ expect(queryParameters.geocoder).toBeUndefined();
+ // Make sure that it isn't 'geocoder: undefined'
+ expect(queryParameters.hasOwnProperty("geocoder")).toBeFalse();
+ });
+
+ it("throws if setting invalid geocodeProviderType", function () {
+ expect(
+ () => new IonGeocoderService({ scene, geocodeProviderType: "junk" }),
+ ).toThrowError(DeveloperError, /Invalid geocodeProviderType/);
+ expect(() => {
+ const service = new IonGeocoderService({ scene });
+ service.geocodeProviderType = "junk";
+ }).toThrowError(DeveloperError, /Invalid geocodeProviderType/);
+ });
});
diff --git a/packages/engine/Specs/DataSources/EntityViewSpec.js b/packages/engine/Specs/DataSources/EntityViewSpec.js
index 2aa12913f9e5..61223cc1dd0b 100644
--- a/packages/engine/Specs/DataSources/EntityViewSpec.js
+++ b/packages/engine/Specs/DataSources/EntityViewSpec.js
@@ -83,6 +83,10 @@ describe(
entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
view.update(JulianDate.now());
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("uses entity bounding sphere", function () {
@@ -115,6 +119,13 @@ describe(
new BoundingSphere(new Cartesian3(3, 4, 5), 6),
);
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("uses entity viewFrom if available and boundingsphere is supplied", function () {
@@ -140,6 +151,10 @@ describe(
entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
view.update(JulianDate.now());
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("update throws without time parameter", function () {
diff --git a/packages/widgets/Source/Viewer/Viewer.js b/packages/widgets/Source/Viewer/Viewer.js
index 41f76c1bb495..b00646389215 100644
--- a/packages/widgets/Source/Viewer/Viewer.js
+++ b/packages/widgets/Source/Viewer/Viewer.js
@@ -18,6 +18,7 @@ import {
Math as CesiumMath,
Property,
ScreenSpaceEventType,
+ IonGeocoderService,
} from "@cesium/engine";
import Animation from "../Animation/Animation.js";
import AnimationViewModel from "../Animation/AnimationViewModel.js";
@@ -280,7 +281,7 @@ function enableVRUI(viewer, enabled) {
* @property {boolean} [baseLayerPicker=true] If set to false, the BaseLayerPicker widget will not be created.
* @property {boolean} [fullscreenButton=true] If set to false, the FullscreenButton widget will not be created.
* @property {boolean} [vrButton=false] If set to true, the VRButton widget will be created.
- * @property {boolean|GeocoderService[]} [geocoder=true] If set to false, the Geocoder widget will not be created.
+ * @property {boolean|IonGeocodeProviderType|GeocoderService[]} [geocoder=IonGeocodeProviderType.DEFAULT] The geocoding service or services to use when searching with the Geocoder widget. If set to false, the Geocoder widget will not be created.
* @property {boolean} [homeButton=true] If set to false, the HomeButton widget will not be created.
* @property {boolean} [infoBox=true] If set to false, the InfoBox widget will not be created.
* @property {boolean} [sceneModePicker=true] If set to false, the SceneModePicker widget will not be created.
@@ -567,7 +568,17 @@ Either specify options.terrainProvider instead or set options.baseLayerPicker to
geocoderContainer.className = "cesium-viewer-geocoderContainer";
toolbar.appendChild(geocoderContainer);
let geocoderService;
- if (defined(options.geocoder) && typeof options.geocoder !== "boolean") {
+ if (typeof options.geocoder === "string") {
+ geocoderService = [
+ new IonGeocoderService({
+ scene,
+ geocodeProviderType: options.geocoder,
+ }),
+ ];
+ } else if (
+ defined(options.geocoder) &&
+ typeof options.geocoder !== "boolean"
+ ) {
geocoderService = Array.isArray(options.geocoder)
? options.geocoder
: [options.geocoder];
diff --git a/packages/widgets/Specs/Viewer/ViewerSpec.js b/packages/widgets/Specs/Viewer/ViewerSpec.js
index a967a34289e1..822df41c034b 100644
--- a/packages/widgets/Specs/Viewer/ViewerSpec.js
+++ b/packages/widgets/Specs/Viewer/ViewerSpec.js
@@ -18,6 +18,8 @@ import {
ImageryLayerCollection,
SceneMode,
ShadowMode,
+ IonGeocodeProviderType,
+ IonGeocoderService,
} from "@cesium/engine";
import {
@@ -354,6 +356,19 @@ describe(
expect(viewer.geocoder.viewModel._geocoderServices.length).toBe(1);
});
+ it("constructs geocoder with IonGeocodeProviderType", function () {
+ viewer = createViewer(container, {
+ geocoder: IonGeocodeProviderType.GOOGLE,
+ });
+ expect(viewer.geocoder).toBeDefined();
+ expect(viewer.geocoder.viewModel._geocoderServices.length).toBe(1);
+ const geocoderService = viewer.geocoder.viewModel._geocoderServices[0];
+ expect(geocoderService).toBeInstanceOf(IonGeocoderService);
+ expect(geocoderService.geocodeProviderType).toEqual(
+ IonGeocodeProviderType.GOOGLE,
+ );
+ });
+
it("constructs geocoder with geocoder service option", function () {
const service = new CartographicGeocoderService();
viewer = createViewer(container, {