mars3d-cesium 1.133.2 → 1.134.0

package/Build/Cesium/Cesium.d.ts

@@ -5457,15 +5457,6 @@ export class DefaultProxy extends Proxy {
     getURL(resource: string): string;
 }
 
-/**
- * Returns the first parameter if not undefined, otherwise the second parameter.
-Useful for setting a default value for a parameter.
- * @example
- * param = Cesium.defaultValue(param, 'default');
- * @returns Returns the first parameter if not undefined, otherwise the second parameter.
- */
-export function defaultValue(a: any, b: any): any;
-
 /**
  * @example
  * if (Cesium.defined(positions)) {
@@ -9095,7 +9086,7 @@ export class IonResource extends Resource {
      * @param [options] - An object with the following properties:
      * @param [options.accessToken = Ion.defaultAccessToken] - The access token to use.
      * @param [options.server = Ion.defaultServer] - The resource to the Cesium ion API server.
-     * @returns A Promise to am instance representing the Cesium ion Asset.
+     * @returns A Promise to an instance representing the Cesium ion Asset.
      */
     static fromAssetId(assetId: number, options?: {
         accessToken?: string;
@@ -30657,12 +30648,12 @@ export class ClippingPlaneCollection {
      * An event triggered when a new clipping plane is added to the collection.  Event handlers
     are passed the new plane and the index at which it was added.
      */
-    planeAdded: Event;
+    readonly planeAdded: Event;
     /**
      * An event triggered when a new clipping plane is removed from the collection.  Event handlers
     are passed the new plane and the index from which it was removed.
      */
-    planeRemoved: Event;
+    readonly planeRemoved: Event;
     /**
      * Returns the number of planes in this collection.  This is commonly used with
     {@link ClippingPlaneCollection#get} to iterate over all the planes
@@ -30802,6 +30793,33 @@ export class ClippingPolygon {
     computeRectangle(result?: Rectangle): Rectangle;
 }
 
+/**
+ * Returns a deep copy of the given array.
+
+If the input is undefined, then <code>undefined</code> is returned.
+
+Otherwise, the result will be a copy of the given array, where
+each element is copied with <code>Cartesian3.clone</code>.
+ * @param input - The input array
+ * @returns The copy
+ */
+export function copyArrayCartesian3(input: Cartesian3[] | undefined): Cartesian3[] | undefined;
+
+/**
+ * Returns whether the given arrays are component-wise equal.
+
+When both arrays are undefined, then <code>true</code> is returned.
+When only one array is defined, or they are both defined but have
+different lengths, then <code>false</code> is returned.
+
+Otherwise, returns whether the corresponding elements of the arrays
+are equal, as of <code>Cartesian3.equals</code>.
+ * @param a - The first array
+ * @param b - The second array
+ * @returns Whether the arrays are equal
+ */
+export function equalsArrayCartesian3(a: Cartesian3[] | undefined, b: Cartesian3[] | undefined): boolean;
+
 /**
  * Specifies a set of clipping polygons. Clipping polygons selectively disable rendering in a region
 inside or outside the specified list of {@link ClippingPolygon} objects for a single glTF model, 3D Tileset, or the globe.
@@ -31911,9 +31929,9 @@ export enum DepthFunction {
 
 /**
  * Returns the type that the given class property has in a GLSL shader.
-
-It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
-for a property texture property with the given class property
+ *
+ * It returns the same string as `PropertyTextureProperty.prototype.getGlslType`
+ * for a property texture property with the given class property
  * @param classProperty - The class property
  * @returns The GLSL shader type string for the property
  */
@@ -31921,8 +31939,8 @@ export function getGlslType(classProperty: MetadataClassProperty): string;
 
 /**
  * Returns a shader statement that applies the inverse of the
-value transform to the given value, based on the given offset
-and scale.
+ * value transform to the given value, based on the given offset
+ * and scale.
  * @param input - The input value
  * @param offset - The offset
  * @param scale - The scale
@@ -31932,7 +31950,7 @@ export function unapplyValueTransform(input: string, offset: string, scale: stri
 
 /**
  * Returns a shader statement that applies the inverse of the
-normalization, based on the given component type
+ * normalization, based on the given component type
  * @param input - The input value
  * @param componentType - The component type
  * @returns The statement
@@ -31941,20 +31959,20 @@ export function unnormalize(input: string, componentType: string): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
-property, normalized to the range [0, 1].
+ * property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
-a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @returns The string
  */
 export function getSourceValueStringScalar(classProperty: MetadataClassProperty, metadataProperty: any): string;
 
 /**
  * Creates a shader statement that returns the value of the specified
-component of the given property, normalized to the range [0, 1].
+ * component of the given property, normalized to the range [0, 1].
  * @param classProperty - The class property
  * @param metadataProperty - The metadata property, either
-a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
  * @param componentName - The name, in ["x", "y", "z", "w"]
  * @returns The string
  */
@@ -33058,6 +33076,258 @@ export function loadGltfJson(): void;
  */
 export function removeExtension(gltf: any, extension: string): any;
 
+export namespace Google2DImageryProvider {
+    /**
+     * Initialization options for the Google2DImageryProvider constructor
+     * @property key - The Google api key to send with tile requests.
+     * @property session - The Google session token that tracks the current state of your map and viewport.
+     * @property url - The Google 2D maps endpoint.
+     * @property tileWidth - The width of each tile in pixels.
+     * @property tileHeight - The height of each tile in pixels.
+     * @property [ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
+     * @property [minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+                    this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
+                    to result in rendering problems.
+     * @property [maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
+     * @property [rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
+     */
+    type ConstructorOptions = {
+        key: string;
+        session: string;
+        url: string | Resource | IonResource;
+        tileWidth: string;
+        tileHeight: string;
+        ellipsoid?: Ellipsoid;
+        minimumLevel?: number;
+        maximumLevel?: number;
+        rectangle?: Rectangle;
+    };
+}
+
+/**
+ * <div class="notice">
+This object is normally not instantiated directly, use {@link Google2DImageryProvider.fromIonAssetId} or {@link Google2DImageryProvider.fromUrl}.
+</div>
+
+
+Provides 2D image tiles from {@link https://developers.google.com/maps/documentation/tile/2d-tiles-overview|Google 2D Tiles}.
+
+Google 2D Tiles can only be used with the Google geocoder.
+ * @example
+ * // Google 2D imagery provider
+const googleTilesProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
+    assetId: 3830184
+});
+ * @example
+ * // Use your own Google api key
+Cesium.GoogleMaps.defaultApiKey = "your-api-key";
+
+const googleTilesProvider = Cesium.Google2DImageryProvider.fromUrl({
+    mapType: "SATELLITE"
+});
+ * @param options - Object describing initialization options
+ */
+export class Google2DImageryProvider {
+    constructor(options: Google2DImageryProvider.ConstructorOptions);
+    /**
+     * Gets the URL of the Google 2D Imagery server.
+     */
+    readonly url: string;
+    /**
+     * Gets the rectangle, in radians, of the imagery provided by the instance.
+     */
+    readonly rectangle: Rectangle;
+    /**
+     * Gets the width of each tile, in pixels.
+     */
+    readonly tileWidth: number;
+    /**
+     * Gets the height of each tile, in pixels.
+     */
+    readonly tileHeight: number;
+    /**
+     * Gets the maximum level-of-detail that can be requested.
+     */
+    readonly maximumLevel: number | undefined;
+    /**
+     * Gets the minimum level-of-detail that can be requested. Generally,
+    a minimum level should only be used when the rectangle of the imagery is small
+    enough that the number of tiles at the minimum level is small.  An imagery
+    provider with more than a few tiles at the minimum level will lead to
+    rendering problems.
+     */
+    readonly minimumLevel: number;
+    /**
+     * Gets the tiling scheme used by the provider.
+     */
+    readonly tilingScheme: TilingScheme;
+    /**
+     * Gets the tile discard policy.  If not undefined, the discard policy is responsible
+    for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+    returns undefined, no tiles are filtered.
+     */
+    readonly tileDiscardPolicy: TileDiscardPolicy;
+    /**
+     * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing
+    to the event, you will be notified of the error and can potentially recover from it.  Event listeners
+    are passed an instance of {@link TileProviderError}.
+     */
+    readonly errorEvent: Event;
+    /**
+     * Gets the credit to display when this imagery provider is active.  Typically this is used to credit
+    the source of the imagery.
+     */
+    readonly credit: Credit;
+    /**
+     * Gets the proxy used by this provider.
+     */
+    readonly proxy: Proxy;
+    /**
+     * Gets a value indicating whether or not the images provided by this imagery provider
+    include an alpha channel.  If this property is false, an alpha channel, if present, will
+    be ignored.  If this property is true, any images without an alpha channel will be treated
+    as if their alpha is 1.0 everywhere.  When this property is false, memory usage
+    and texture upload time are reduced.
+     */
+    readonly hasAlphaChannel: boolean;
+    /**
+     * Creates an {@link ImageryProvider} which provides 2D global tiled imagery from {@link https://developers.google.com/maps/documentation/tile/2d-tiles-overview|Google 2D Tiles}, streamed using the Cesium ion REST API.
+     * @example
+     * // Google 2D imagery provider
+    const googleTilesProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
+        assetId: 3830184
+    });
+     * @example
+     * // Google 2D roadmap overlay with custom styles
+    const googleTileProvider = Cesium.Google2DImageryProvider.fromIonAssetId({
+        assetId: 3830184,
+        overlayLayerType: "layerRoadmap",
+        styles: [
+            {
+                stylers: [{ hue: "#00ffe6" }, { saturation: -20 }],
+            },
+            {
+                featureType: "road",
+                elementType: "geometry",
+                stylers: [{ lightness: 100 }, { visibility: "simplified" }],
+            },
+        ],
+    });
+     * @param options - Object with the following properties:
+     * @param options.assetId - The Cesium ion asset id.
+     * @param [options.mapType = "satellite"] - The map type of the Google map imagery. Valid options are satellite, terrain, and roadmap. If overlayLayerType is set, mapType is ignored and a transparent overlay is returned. If overlayMapType is undefined, then a basemap of mapType is returned. layerRoadmap overlayLayerType is included in terrain and roadmap mapTypes.
+     * @param [options.language = "en_US"] - an IETF language tag that specifies the language used to display information on the tiles
+     * @param [options.region = "US"] - A Common Locale Data Repository region identifier (two uppercase letters) that represents the physical location of the user.
+     * @param [options.overlayLayerType] - Returns a transparent overlay map with the specified layerType. If no value is provided, a basemap of mapType is returned. Use multiple instances of Google2DImageryProvider to add multiple Google Maps overlays to a scene. layerRoadmap is included in terrain and roadmap mapTypes, so adding as overlay to terrain or roadmap has no effect.
+     * @param [options.styles] - An array of JSON style objects that specify the appearance and detail level of map features such as roads, parks, and built-up areas. Styling is used to customize the standard Google base map. The styles parameter is valid only if the mapType is roadmap. For the complete style syntax, see the ({@link https://developers.google.com/maps/documentation/tile/style-reference|Google Style Reference}).
+     * @param [options.ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
+     * @param [options.minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+                    this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
+                    to result in rendering problems.
+     * @param [options.maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
+     * @param [options.rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
+     * @param [options.credit] - A credit for the data source, which is displayed on the canvas.
+     * @returns A promise that resolves to the created Google2DImageryProvider.
+     */
+    static fromIonAssetId(options: {
+        assetId: string;
+        mapType?: "satellite" | "terrain" | "roadmap";
+        language?: string;
+        region?: string;
+        overlayLayerType?: "layerRoadmap" | "layerStreetview" | "layerTraffic";
+        styles?: any;
+        ellipsoid?: Ellipsoid;
+        minimumLevel?: number;
+        maximumLevel?: number;
+        rectangle?: Rectangle;
+        credit?: Credit | string;
+    }): Promise<Google2DImageryProvider>;
+    /**
+     * Creates an {@link ImageryProvider} which provides 2D global tiled imagery from {@link https://developers.google.com/maps/documentation/tile/2d-tiles-overview|Google 2D Tiles}.
+     * @example
+     * // Use your own Google api key
+    Cesium.GoogleMaps.defaultApiKey = "your-api-key";
+    
+    const googleTilesProvider = Cesium.Google2DImageryProvider.fromUrl({
+        mapType: "satellite"
+    });
+     * @example
+     * // Google 2D roadmap overlay with custom styles
+    Cesium.GoogleMaps.defaultApiKey = "your-api-key";
+    
+    const googleTileProvider = Cesium.Google2DImageryProvider.fromUrl({
+        overlayLayerType: "layerRoadmap",
+        styles: [
+            {
+                stylers: [{ hue: "#00ffe6" }, { saturation: -20 }],
+            },
+            {
+                featureType: "road",
+                elementType: "geometry",
+                stylers: [{ lightness: 100 }, { visibility: "simplified" }],
+            },
+        ],
+    });
+     * @param options - Object with the following properties:
+     * @param [options.key = GoogleMaps.defaultApiKey] - Your API key to access Google 2D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
+     * @param [options.mapType = "satellite"] - The map type of the Google map imagery. Valid options are satellite, terrain, and roadmap. If overlayLayerType is set, mapType is ignored and a transparent overlay is returned. If overlayMapType is undefined, then a basemap of mapType is returned. layerRoadmap overlayLayerType is included in terrain and roadmap mapTypes.
+     * @param [options.language = "en_US"] - an IETF language tag that specifies the language used to display information on the tiles
+     * @param [options.region = "US"] - A Common Locale Data Repository region identifier (two uppercase letters) that represents the physical location of the user.
+     * @param [options.overlayLayerType] - Returns a transparent overlay map with the specified layerType. If no value is provided, a basemap of mapType is returned. Use multiple instances of Google2DImageryProvider to add multiple Google Maps overlays to a scene. layerRoadmap is included in terrain and roadmap mapTypes, so adding as overlay to terrain or roadmap has no effect.
+     * @param [options.styles] - An array of JSON style objects that specify the appearance and detail level of map features such as roads, parks, and built-up areas. Styling is used to customize the standard Google base map. The styles parameter is valid only if the mapType is roadmap. For the complete style syntax, see the ({@link https://developers.google.com/maps/documentation/tile/style-reference|Google Style Reference}).
+     * @param [options.ellipsoid = Ellipsoid.default] - The ellipsoid.  If not specified, the default ellipsoid is used.
+     * @param [options.minimumLevel = 0] - The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+                    this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
+                    to result in rendering problems.
+     * @param [options.maximumLevel = 22] - The maximum level-of-detail supported by the imagery provider.
+     * @param [options.rectangle = Rectangle.MAX_VALUE] - The rectangle, in radians, covered by the image.
+     * @param [options.credit] - A credit for the data source, which is displayed on the canvas.
+     * @returns A promise that resolves to the created Google2DImageryProvider.
+     */
+    static fromUrl(options: {
+        key?: string;
+        mapType?: "satellite" | "terrain" | "roadmap";
+        language?: string;
+        region?: string;
+        overlayLayerType?: "layerRoadmap" | "layerStreetview" | "layerTraffic";
+        styles?: any;
+        ellipsoid?: Ellipsoid;
+        minimumLevel?: number;
+        maximumLevel?: number;
+        rectangle?: Rectangle;
+        credit?: Credit | string;
+    }): Promise<Google2DImageryProvider>;
+    /**
+     * Gets the credits to be displayed when a given tile is displayed.
+     * @param x - The tile X coordinate.
+     * @param y - The tile Y coordinate.
+     * @param level - The tile level;
+     * @returns The credits to be displayed when the tile is displayed.
+     */
+    getTileCredits(x: number, y: number, level: number): Credit[] | undefined;
+    /**
+     * Requests the image for a given tile.
+     * @param x - The tile X coordinate.
+     * @param y - The tile Y coordinate.
+     * @param level - The tile level.
+     * @param [request] - The request object. Intended for internal use only.
+     * @returns A promise for the image that will resolve when the image is available, or
+             undefined if there are too many active requests to the server, and the request should be retried later.
+     */
+    requestImage(x: number, y: number, level: number, request?: Request): Promise<ImageryTypes> | undefined;
+    /**
+     * Picking features is not currently supported by this imagery provider, so this function simply returns
+    undefined.
+     * @param x - The tile X coordinate.
+     * @param y - The tile Y coordinate.
+     * @param level - The tile level.
+     * @param longitude - The longitude at which to pick features.
+     * @param latitude - The latitude at which to pick features.
+     * @returns Undefined since picking is not supported.
+     */
+    pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): undefined;
+}
+
 export namespace GoogleEarthEnterpriseImageryProvider {
     /**
      * Initialization options for the GoogleEarthEnterpriseImageryProvider constructor
@@ -39671,6 +39941,29 @@ export type PickedMetadataInfo = {
     classProperty: MetadataClassProperty;
 };
 
+/**
+ * Remove all invalid binary body references from the batch table
+JSON of the given parsed content.
+
+This is a workaround for gracefully handling the invalid PNTS
+files that may have been created by the point cloud tiler.
+See https://github.com/CesiumGS/cesium/issues/12872
+
+When the batch table JSON is undefined, nothing will be done.
+When the batch table binary is defined, nothing will be done
+(assuming that any binary body references are valid - this is
+not checked here).
+
+Otherwise, this will remove all binary body references from the
+batch table JSON that are not resolved from draco via the
+`parsedContent.draco.batchTableProperties`.
+
+If any (invalid) binary body reference is found (and removed),
+a one-time warning will be printed.
+ * @param parsedContent - The parsed content
+ */
+export function removeInvalidBinaryBodyReferences(parsedContent: any): void;
+
 /**
  * Options for performing point attenuation based on geometric error when rendering
 point clouds using 3D Tiles.
@@ -41520,8 +41813,8 @@ const scene = new Cesium.Scene({
  * @param options - Object with the following properties:
  * @param options.canvas - The HTML canvas element to create the scene for.
  * @param [options.contextOptions] - Context and WebGL creation properties.
- * @param [options.creditContainer] - The HTML element in which the credits will be displayed.
- * @param [options.creditViewport] - The HTML element in which to display the credit popup.  If not specified, the viewport will be a added as a sibling of the canvas.
+ * @param [options.creditContainer] - The HTML element in which the credits will be displayed. If not specified, a credit container will be created and added as a sibling of the canvas.
+ * @param [options.creditViewport] - The HTML element in which to display the credit popup.  If not specified, the viewport will be added as a sibling of the canvas.
  * @param [options.ellipsoid = Ellipsoid.default] - The default ellipsoid. If not specified, the default ellipsoid is used.
  * @param [options.mapProjection = new GeographicProjection(options.ellipsoid)] - The map projection to use in 2D and Columbus View modes.
  * @param [options.orderIndependentTranslucency = true] - If true and the configuration supports it, use order independent translucency.