or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

3d-tiles.mdcore-math-geometry.mddata-sources.mdentity-data-visualization.mdimagery-terrain.mdindex.mdscene-3d-graphics.mdtime-animation.mdviewer-widgets.md
tile.json

imagery-terrain.mddocs/

Imagery and Terrain

Data providers for satellite imagery, maps, and elevation data from various sources including web services and tiling schemes.

Capabilities

Imagery Providers

Data providers for loading and displaying satellite imagery and map tiles.

/**
 * Base interface for imagery providers
 */
interface ImageryProvider {
  readonly url: string;
  readonly token?: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}

/**
 * ArcGIS MapServer imagery provider
 */
class ArcGisMapServerImageryProvider {
  constructor(options: ArcGisMapServerImageryProviderOptions);
  readonly url: string;
  readonly token?: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  readonly layers: string;
  readonly enablePickFeatures: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}

interface ArcGisMapServerImageryProviderOptions {
  url: string;
  token?: string;
  layers?: string;
  enablePickFeatures?: boolean;
  rectangle?: Rectangle;
  tilingScheme?: TilingScheme;
  ellipsoid?: Ellipsoid;
  credit?: Credit | string;
  tileWidth?: number;
  tileHeight?: number;
  maximumLevel?: number;
  minimumLevel?: number;
  usePreCachedTilesIfAvailable?: boolean;
}

/**
 * Bing Maps imagery provider
 */
class BingMapsImageryProvider {
  constructor(options: BingMapsImageryProviderOptions);
  readonly url: string;
  readonly key: string;
  readonly mapStyle: BingMapsStyle;
  readonly culture: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  
  static getTileCredits(x: number, y: number, level: number): Credit[];
  static getQuadKeyFromTileXY(x: number, y: number, level: number): string;
  static getTileXYFromQuadKey(quadkey: string): { x: number; y: number; level: number };
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}

interface BingMapsImageryProviderOptions {
  url?: string;
  key?: string;
  mapStyle?: BingMapsStyle;
  culture?: string;
  ellipsoid?: Ellipsoid;
  tileDiscardPolicy?: TileDiscardPolicy;
}

enum BingMapsStyle {
  AERIAL = "Aerial",
  AERIAL_WITH_LABELS = "AerialWithLabels", 
  AERIAL_WITH_LABELS_ON_DEMAND = "AerialWithLabelsOnDemand",
  ROAD = "Road",
  COLLINS_BART = "CollinsBart",
  ORDNANCE_SURVEY = "OrdnanceSurvey"
}

/**
 * Mapbox imagery provider
 */
class MapboxImageryProvider {
  constructor(options: MapboxImageryProviderOptions);
  readonly url: string;
  readonly mapId: string;
  readonly accessToken: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}

interface MapboxImageryProviderOptions {
  mapId: string;
  accessToken?: string;
  url?: string;
  format?: string;
  ellipsoid?: Ellipsoid;
  minimumLevel?: number;
  maximumLevel?: number;
  rectangle?: Rectangle;
  credit?: Credit | string;
}

/**
 * Mapbox Style imagery provider
 */
class MapboxStyleImageryProvider {
  constructor(options: MapboxStyleImageryProviderOptions);
  readonly url: string;
  readonly styleId: string;
  readonly accessToken: string;
  readonly username: string;
  readonly tilesize: number;
  readonly scaleFactor: boolean;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
}

interface MapboxStyleImageryProviderOptions {
  styleId: string;
  accessToken?: string;
  username?: string;
  tilesize?: number;
  scaleFactor?: boolean;
  ellipsoid?: Ellipsoid;
  minimumLevel?: number;
  maximumLevel?: number;
  rectangle?: Rectangle;
  credit?: Credit | string;
}

/**
 * OpenStreetMap imagery provider
 */
class OpenStreetMapImageryProvider {
  constructor(options?: OpenStreetMapImageryProviderOptions);
  readonly url: string;
  readonly fileExtension: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
}

interface OpenStreetMapImageryProviderOptions {
  url?: string;
  fileExtension?: string;
  rectangle?: Rectangle;
  minimumLevel?: number;
  maximumLevel?: number;
  ellipsoid?: Ellipsoid;
  credit?: Credit | string;
}

/**
 * URL template imagery provider for custom tile services
 */
class UrlTemplateImageryProvider {
  constructor(options: UrlTemplateImageryProviderOptions);
  readonly url: string;
  readonly pickFeaturesUrl?: string;
  readonly urlSchemeZeroPadding?: any;
  readonly subdomains: string | string[];
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  readonly enablePickFeatures: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}

interface UrlTemplateImageryProviderOptions {
  url: string;
  pickFeaturesUrl?: string;
  urlSchemeZeroPadding?: any;
  subdomains?: string | string[];
  credit?: Credit | string;
  minimumLevel?: number;
  maximumLevel?: number;
  rectangle?: Rectangle;
  tilingScheme?: TilingScheme;
  ellipsoid?: Ellipsoid;
  tileWidth?: number;
  tileHeight?: number;
  hasAlphaChannel?: boolean;
  getFeatureInfoFormats?: GetFeatureInfoFormat[];
  enablePickFeatures?: boolean;
  customTags?: any;
}

/**
 * Web Map Service (WMS) imagery provider
 */
class WebMapServiceImageryProvider {
  constructor(options: WebMapServiceImageryProviderOptions);
  readonly url: string;
  readonly layers: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  readonly enablePickFeatures: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
  pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}

interface WebMapServiceImageryProviderOptions {
  url: string;
  layers: string;
  parameters?: any;
  getFeatureInfoParameters?: any;
  enablePickFeatures?: boolean;
  getFeatureInfoFormats?: GetFeatureInfoFormat[];
  rectangle?: Rectangle;
  tilingScheme?: TilingScheme;
  ellipsoid?: Ellipsoid;
  tileWidth?: number;
  tileHeight?: number;
  minimumLevel?: number;
  maximumLevel?: number;
  credit?: Credit | string;
  subdomains?: string | string[];
}

/**
 * Web Map Tile Service (WMTS) imagery provider
 */
class WebMapTileServiceImageryProvider {
  constructor(options: WebMapTileServiceImageryProviderOptions);
  readonly url: string;
  readonly layer: string;
  readonly style: string;
  readonly tileMatrixSetID: string;
  readonly format: string;
  readonly proxy?: Proxy;
  readonly tileWidth: number;
  readonly tileHeight: number;
  readonly maximumLevel?: number;
  readonly minimumLevel?: number;
  readonly tilingScheme: TilingScheme;
  readonly rectangle: Rectangle;
  readonly tileDiscardPolicy?: TileDiscardPolicy;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasAlphaChannel: boolean;
  
  getTileCredits(x: number, y: number, level: number): Credit[];
  requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement>;
}

interface WebMapTileServiceImageryProviderOptions {
  url: string;
  format?: string;
  layer: string;
  style: string;
  tileMatrixSetID: string;
  tileMatrixLabels?: any[];
  clock?: Clock;
  times?: TimeIntervalCollection;
  dimensions?: any;
  tileWidth?: number;
  tileHeight?: number;
  tilingScheme?: TilingScheme;
  rectangle?: Rectangle;
  minimumLevel?: number;
  maximumLevel?: number;
  ellipsoid?: Ellipsoid;
  credit?: Credit | string;
  subdomains?: string | string[];
}

Terrain Providers

Elevation data providers for rendering terrain and height-based calculations.

/**
 * Base interface for terrain providers
 */
interface TerrainProvider {
  readonly errorEvent: Event;
  readonly credit?: Credit;
  readonly tilingScheme: TilingScheme;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly hasWaterMask: boolean;
  readonly hasVertexNormals: boolean;
  readonly availability?: TileAvailability;
  
  requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
  getLevelMaximumGeometricError(level: number): number;
  getTileDataAvailable(x: number, y: number, level: number): boolean;
  loadTileDataAvailability(x: number, y: number, level: number): Promise<void>;
}

/**
 * Cesium terrain provider for quantized mesh terrain
 */
class CesiumTerrainProvider {
  constructor(options: CesiumTerrainProviderOptions);
  readonly url: string;
  readonly proxy?: Proxy;
  readonly tilingScheme: TilingScheme;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasWaterMask: boolean;
  readonly hasVertexNormals: boolean;
  readonly hasMetadata: boolean;
  readonly requestVertexNormals: boolean;
  readonly requestWaterMask: boolean;
  readonly requestMetadata: boolean;
  readonly availability?: TileAvailability;
  
  static getEstimatedLevelZeroGeometricErrorForAHeightmap(ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number): number;
  
  requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
  getLevelMaximumGeometricError(level: number): number;
  getTileDataAvailable(x: number, y: number, level: number): boolean;
  loadTileDataAvailability(x: number, y: number, level: number): Promise<void>;
}

interface CesiumTerrainProviderOptions {
  url: string;
  requestVertexNormals?: boolean;
  requestWaterMask?: boolean;
  requestMetadata?: boolean;
  ellipsoid?: Ellipsoid;
  credit?: Credit | string;
}

/**
 * ArcGIS tiled elevation terrain provider
 */
class ArcGISTiledElevationTerrainProvider {
  constructor(options: ArcGISTiledElevationTerrainProviderOptions);
  readonly url: string;
  readonly token?: string;
  readonly proxy?: Proxy;
  readonly tilingScheme: TilingScheme;
  readonly ellipsoid: Ellipsoid;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasWaterMask: boolean;
  readonly hasVertexNormals: boolean;
  readonly availability?: TileAvailability;
  
  requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
  getLevelMaximumGeometricError(level: number): number;
  getTileDataAvailable(x: number, y: number, level: number): boolean;
  loadTileDataAvailability(x: number, y: number, level: number): Promise<void>;
}

interface ArcGISTiledElevationTerrainProviderOptions {
  url: string;
  token?: string;
  ellipsoid?: Ellipsoid;
}

/**
 * Google Earth Enterprise terrain provider
 */
class GoogleEarthEnterpriseTerrainProvider {
  constructor(options: GoogleEarthEnterpriseTerrainProviderOptions);
  readonly url: string;
  readonly proxy?: Proxy;
  readonly tilingScheme: TilingScheme;
  readonly ellipsoid: Ellipsoid;
  readonly errorEvent: Event;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly credit?: Credit;
  readonly hasWaterMask: boolean;
  readonly hasVertexNormals: boolean;
  readonly availability?: TileAvailability;
  
  requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
  getLevelMaximumGeometricError(level: number): number;
  getTileDataAvailable(x: number, y: number, level: number): boolean;
  loadTileDataAvailability(x: number, y: number, level: number): Promise<void>;
}

interface GoogleEarthEnterpriseTerrainProviderOptions {
  url: string;
  metadata: GoogleEarthEnterpriseMetadata;
  ellipsoid?: Ellipsoid;
  credit?: Credit | string;
}

/**
 * Ellipsoid terrain provider (flat surface)
 */
class EllipsoidTerrainProvider {
  constructor(options?: EllipsoidTerrainProviderOptions);
  readonly errorEvent: Event;
  readonly credit?: Credit;
  readonly tilingScheme: TilingScheme;
  readonly ready: boolean;
  readonly readyPromise: Promise<boolean>;
  readonly hasWaterMask: boolean;
  readonly hasVertexNormals: boolean;
  
  requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
  getLevelMaximumGeometricError(level: number): number;
  getTileDataAvailable(x: number, y: number, level: number): boolean;
  loadTileDataAvailability(x: number, y: number, level: number): Promise<void>;
}

interface EllipsoidTerrainProviderOptions {
  tilingScheme?: TilingScheme;
  ellipsoid?: Ellipsoid;
}

Imagery Layers

Layer management for combining multiple imagery sources.

/**
 * An imagery layer for displaying imagery data on the globe
 */
class ImageryLayer {
  constructor(imageryProvider: ImageryProvider, options?: ImageryLayerOptions);
  readonly imageryProvider: ImageryProvider;
  readonly rectangle: Rectangle;
  alpha: number;
  nightAlpha: number;
  dayAlpha: number;
  brightness: number;
  contrast: number;
  hue: number;
  saturation: number;
  gamma: number;
  splitDirection: SplitDirection;
  minificationFilter: TextureMinificationFilter;
  magnificationFilter: TextureMagnificationFilter;
  show: boolean;
  readonly cutoutRectangle?: Rectangle;
  readonly colorToAlpha?: Color;
  readonly colorToAlphaThreshold: number;
  
  isBaseLayer(): boolean;
  isDestroyed(): boolean;
  destroy(): void;
  getViewableRectangle(): Promise<Rectangle>;
}

interface ImageryLayerOptions {
  rectangle?: Rectangle;
  alpha?: number | Function;
  nightAlpha?: number | Function;
  dayAlpha?: number | Function;
  brightness?: number | Function;
  contrast?: number | Function;
  hue?: number | Function;
  saturation?: number | Function;
  gamma?: number | Function;
  splitDirection?: SplitDirection | Function;
  minificationFilter?: TextureMinificationFilter;
  magnificationFilter?: TextureMagnificationFilter;
  show?: boolean;
  maximumAnisotropy?: number;
  minimumTerrainLevel?: number;
  maximumTerrainLevel?: number;
  cutoutRectangle?: Rectangle;
  colorToAlpha?: Color;
  colorToAlphaThreshold?: number;
}

/**
 * Collection of imagery layers
 */
class ImageryLayerCollection {
  readonly length: number;
  readonly layerAdded: Event;
  readonly layerRemoved: Event;
  readonly layerMoved: Event;
  readonly layerShownOrHidden: Event;
  
  add(layer: ImageryLayer, index?: number): void;
  addImageryProvider(imageryProvider: ImageryProvider, index?: number): ImageryLayer;
  remove(layer: ImageryLayer, destroy?: boolean): boolean;
  removeAll(destroy?: boolean): void;
  contains(layer: ImageryLayer): boolean;
  indexOf(layer: ImageryLayer): number;
  get(index: number): ImageryLayer;
  raise(layer: ImageryLayer): void;
  lower(layer: ImageryLayer): void;
  raiseToTop(layer: ImageryLayer): void;
  lowerToBottom(layer: ImageryLayer): void;
  pickImageryLayers(ray: Ray, scene: Scene): Promise<ImageryLayerFeatureInfo[]>;
  isDestroyed(): boolean;
  destroy(): void;
}

/**
 * Feature information from imagery layer picking
 */
class ImageryLayerFeatureInfo {
  name: string;
  description?: string;
  position?: Cartographic;
  data?: any;
  properties?: any;
  configureNameFromProperties(properties: any): void;
  configureDescriptionFromProperties(properties: any): void;
}

Tiling Schemes

Coordinate systems and tiling patterns for imagery and terrain.

/**
 * Base interface for tiling schemes
 */
interface TilingScheme {
  readonly ellipsoid: Ellipsoid;
  readonly rectangle: Rectangle;
  readonly projection: MapProjection;
  
  getNumberOfXTilesAtLevel(level: number): number;
  getNumberOfYTilesAtLevel(level: number): number;
  rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
  tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): any;
  tileXYToRectangle(x: number, y: number, level: number, result?: Rectangle): Rectangle;
  positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}

/**
 * Geographic tiling scheme using latitude/longitude coordinates
 */
class GeographicTilingScheme {
  constructor(options?: GeographicTilingSchemeOptions);
  readonly ellipsoid: Ellipsoid;
  readonly rectangle: Rectangle;
  readonly projection: GeographicProjection;
  
  getNumberOfXTilesAtLevel(level: number): number;
  getNumberOfYTilesAtLevel(level: number): number;
  rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
  tileXYToNativeRectangle(x: number, y: number, level: number, result?: Rectangle): Rectangle;
  tileXYToRectangle(x: number, y: number, level: number, result?: Rectangle): Rectangle;
  positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}

interface GeographicTilingSchemeOptions {
  ellipsoid?: Ellipsoid;
  rectangle?: Rectangle;
  numberOfLevelZeroTilesX?: number;
  numberOfLevelZeroTilesY?: number;
}

/**
 * Web Mercator tiling scheme
 */
class WebMercatorTilingScheme {
  constructor(options?: WebMercatorTilingSchemeOptions);
  readonly ellipsoid: Ellipsoid;
  readonly rectangle: Rectangle;
  readonly projection: WebMercatorProjection;
  
  getNumberOfXTilesAtLevel(level: number): number;
  getNumberOfYTilesAtLevel(level: number): number;
  rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
  tileXYToNativeRectangle(x: number, y: number, level: number, result?: Rectangle): Rectangle;
  tileXYToRectangle(x: number, y: number, level: number, result?: Rectangle): Rectangle;
  positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}

interface WebMercatorTilingSchemeOptions {
  ellipsoid?: Ellipsoid;
  numberOfLevelZeroTilesX?: number;
  numberOfLevelZeroTilesY?: number;
  rectangleSouthwestInMeters?: Cartesian2;
  rectangleNortheastInMeters?: Cartesian2;
}

Terrain Sampling

Utilities for sampling elevation data from terrain providers.

/**
 * Sample terrain heights at given positions
 */
function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[], rejectOnTileFail?: boolean): Promise<Cartographic[]>;

/**
 * Sample terrain at the most detailed level available
 */
function sampleTerrainMostDetailed(terrainProvider: TerrainProvider, positions: Cartographic[], rejectOnTileFail?: boolean): Promise<Cartographic[]>;

/**
 * Terrain data containing height information for a tile
 */
class TerrainData {
  readonly waterMask?: Uint8Array | HTMLImageElement | HTMLCanvasElement;
  
  interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
  upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData>;
  isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
  wasCreatedByUpsampling(): boolean;
}

/**
 * Quantized mesh terrain data
 */
class QuantizedMeshTerrainData {
  constructor(options: QuantizedMeshTerrainDataOptions);
  readonly waterMask?: Uint8Array | HTMLImageElement | HTMLCanvasElement;
  readonly credits?: Credit[];
  
  interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
  upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData>;
  isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
  wasCreatedByUpsampling(): boolean;
}

interface QuantizedMeshTerrainDataOptions {
  quantizedVertices: Uint16Array;
  indices: Uint16Array | Uint32Array;
  minimumHeight: number;
  maximumHeight: number;
  boundingSphere: BoundingSphere;
  orientedBoundingBox?: OrientedBoundingBox;
  horizonOcclusionPoint: Cartesian3;
  westIndices: number[];
  southIndices: number[];
  eastIndices: number[];
  northIndices: number[];
  westSkirtHeight: number;
  southSkirtHeight: number;
  eastSkirtHeight: number;
  northSkirtHeight: number;
  childTileMask?: number;
  createdByUpsampling?: boolean;
  encodedNormals?: Uint8Array;
  waterMask?: Uint8Array;
  credits?: Credit[];
}

/**
 * Height map terrain data
 */
class HeightmapTerrainData {
  constructor(options: HeightmapTerrainDataOptions);
  readonly waterMask?: Uint8Array | HTMLImageElement | HTMLCanvasElement;
  
  interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
  upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData>;
  isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
  wasCreatedByUpsampling(): boolean;
}

interface HeightmapTerrainDataOptions {
  buffer: ArrayBuffer;
  width: number;
  height: number;
  childTileMask?: number;
  waterMask?: Uint8Array;
  structure?: any;
  structureSize?: number;
  createdByUpsampling?: boolean;
}

Types

enum SplitDirection {
  NONE = 0,
  LEFT = 1,
  RIGHT = 2
}

enum TextureMinificationFilter {
  NEAREST = 9728,
  LINEAR = 9729,
  NEAREST_MIPMAP_NEAREST = 9984,
  LINEAR_MIPMAP_NEAREST = 9985,
  NEAREST_MIPMAP_LINEAR = 9986,
  LINEAR_MIPMAP_LINEAR = 9987
}

enum TextureMagnificationFilter {
  NEAREST = 9728,
  LINEAR = 9729
}

interface GetFeatureInfoFormat {
  type: string;
  format: string;
}

interface GoogleEarthEnterpriseMetadata {
  url: string;
  proxy?: Proxy;
}

interface TileAvailability {
  computeMaximumLevelAtPosition(position: Cartographic): number;
  isTileAvailable(level: number, x: number, y: number): boolean;
}

interface TileDiscardPolicy {
  isReady(): boolean;
  shouldDiscardImage(image: HTMLImageElement): boolean;
}

interface MapProjection {
  readonly ellipsoid: Ellipsoid;
  project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
  unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
}

class GeographicProjection {
  constructor(ellipsoid?: Ellipsoid);
  readonly ellipsoid: Ellipsoid;
  
  project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
  unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
}

class WebMercatorProjection {
  constructor(ellipsoid?: Ellipsoid);
  readonly ellipsoid: Ellipsoid;
  readonly maximumLatitude: number;
  
  project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
  unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
  static mercatorAngleToGeodeticLatitude(mercatorAngle: number): number;
  static geodeticLatitudeToMercatorAngle(latitude: number): number;
}