Options
All
  • Public
  • Public/Protected
  • All
Menu

Class RemoteTileProvider

A remote tile provider fetches data from remote data-sources.

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Properties

Optional id

id: string

The id of the Provider

Optional margin

margin: number = 0

default tile margin.

Optional name

name: string

The name of the Provider.

Methods

addEventListener

  • addEventListener(type: string, listener: (e: CustomEvent) => void, _c?: any): boolean

  • Add an EventListener to the provider. Valid events: "featureAdd", "featureRemove", "featureCoordinatesChange", "clear" and "error"

    The detail property of the Event gives additional information about the event. detail.provider is a reference to the provider onto which the event was dispatched and is set for all events.

    Parameters

    • type: string

      A string representing the event type to listen for

    • listener: (e: CustomEvent) => void

      the listener function that will be called when an event of the specific type occurs

        • (e: CustomEvent): void

        • Parameters

          • e: CustomEvent

          Returns void

    • Optional _c: any

    Returns boolean

addFeature

  • Add a feature to the provider.

    example
    // add a feature to the provider.
provider.addFeature({
   type: "Feature"
   geometry: {
       coordinates: [[-122.49373, 37.78202], [-122.49263, 37.78602]],
       type: "LineString"
   }
});

    Parameters

    Returns Feature

  • Add multiple features to the provider.

    example
    // add multiple features to the provider.
provider.addFeature([{
   type: "Feature"
   geometry: {
       coordinates: [[-122.49373, 37.78202], [-122.49263, 37.78602]],
       type: "LineString"
   }
},{
   type: "Feature"
   geometry: {
       coordinates: [[-122.49375, 37.78203], [-122.49265, 37.78604]],
       type: "LineString"
   }
}]);

    Parameters

    Returns Feature[]

all

cancel

  • cancel(quadkey: string): void
  • cancel(tile: Tile): void

  • Cancel ongoing request(s) of a tile. The tile will be dropped.

    Parameters

    • quadkey: string

      the quadkey of the tile that should be canceled and removed.

    Returns void

  • Cancel ongoing request(s) of a tile. The tile will be dropped.

    Parameters

    • tile: Tile

      the tile that should be canceled and removed.

    Returns void

clear

  • clear(bbox?: number[]): string[] | null

  • Clear all tiles and features of a given bounding box or do a full wipe if no parameter is given.

    Parameters

    • Optional bbox: number[]

      array of geographical coordinates [minLon, minLat, maxLon, maxLat] defining the area to clear.

    Returns string[] | null

config

createTile

  • createTile(quadkey: string): Tile

  • Create a new Tile.

    Parameters

    • quadkey: string

      the quadkey of the tile to create

    Returns Tile

exists

  • exists(feature: { id: number | string }): { feature?: Feature }

  • Validate if a feature is stored in the local provider cache.

    Parameters

    • feature: { id: number | string }

      Object literal containing "id" property.

      • id: number | string

    Returns { feature?: Feature }

    the Feature if it is found, otherwise undefined

findPath

  • Finds the optimal path between two coordinates on a GeoJSON road network, considering various options. By default, the weight function returns the distance of the road segment, a lower distance implies a shorter route and is considered more favorable. If you have specific criteria such as road quality, traffic conditions, or other factors influencing the desirability of a road segment, you can customize the weight function accordingly. Pathfinding will consider only the locally cached data available on the client.

    experimental
    example
    const pathOptions = {
  from: [startLongitude, startLatitude],
  to: [endLongitude, endLatitude],
  // optional
  allowTurn: (turn) => {
     // Custom logic to determine whether a turn is allowed
    return true;
  },
  // optional
  weight: (data) => {
    // Custom weight function to determine the cost of traversing a road segment
    return data.distance; // Default implementation uses distance as the weight
  },
};
const result = await provider.findPath(pathOptions);
console.log(result);

    Parameters

    • options: { allowTurn?: (turn: { from: { index: number; link: Feature<"LineString"> }; to: { index: number; link: Feature<"LineString"> } }) => boolean; from: GeoJSONCoordinate | GeoPoint; to: GeoJSONCoordinate | GeoPoint; weight?: (data: { direction: "START_TO_END" | "END_TO_START"; distance: number; feature: Feature<"LineString">; from: GeoJSONCoordinate; to: GeoJSONCoordinate }) => number }

      The options object containing parameters for finding the path.

      • Optional allowTurn?: (turn: { from: { index: number; link: Feature<"LineString"> }; to: { index: number; link: Feature<"LineString"> } }) => boolean

        Optional callback function to determine if a turn is allowed between road segments. If not provided, all turns are considered allowed.

        param

        Object containing information about the turn, including source and destination road segments.

        returns

        true if the turn is allowed, false otherwise.

          • (turn: { from: { index: number; link: Feature<"LineString"> }; to: { index: number; link: Feature<"LineString"> } }): boolean

          • Parameters

            • turn: { from: { index: number; link: Feature<"LineString"> }; to: { index: number; link: Feature<"LineString"> } }
              • Readonly from: { index: number; link: Feature<"LineString"> }

                Object representing the source road segment of the turn.

                • Readonly index: number

                  Index of the Coordinates array of the source road segment.

                • Readonly link: Feature<"LineString">

                  GeoJSON Feature representing the source road segment.

              • Readonly to: { index: number; link: Feature<"LineString"> }

                Object representing the destination road segment of the turn.

                • Readonly index: number

                  Index of the Coordinates array of the destination road segment.

                • Readonly link: Feature<"LineString">

                  GeoJSON Feature representing the destination road segment.

            Returns boolean

      • from: GeoJSONCoordinate | GeoPoint

        The starting coordinates defining the path.

      • to: GeoJSONCoordinate | GeoPoint

        The ending coordinates of the path.

      • Optional weight?: (data: { direction: "START_TO_END" | "END_TO_START"; distance: number; feature: Feature<"LineString">; from: GeoJSONCoordinate; to: GeoJSONCoordinate }) => number

        Optional callback function to determine the weight (cost) of traversing a road segment.

        param

        Object containing information about the road segment.

        returns

        A numerical value representing the weight or cost of traversing the road segment. Default is the distance in meter.

          • Parameters

            • data: { direction: "START_TO_END" | "END_TO_START"; distance: number; feature: Feature<"LineString">; from: GeoJSONCoordinate; to: GeoJSONCoordinate }
              • direction: "START_TO_END" | "END_TO_START"

                Direction of traversal on the road segment.

              • distance: number

                The Distance of the road in meters.

              • feature: Feature<"LineString">

                Feature representing the road segment.

              • from: GeoJSONCoordinate

                Starting coordinates of the road segment.

              • to: GeoJSONCoordinate

                Ending coordinates of the road segment.

            Returns number

    Returns Promise<{ distance: number; features: Feature<"LineString">[]; from: GeoJSONCoordinate; path: GeoJSONFeature<"MultiLineString">; to: GeoJSONCoordinate }>

    {Promise<{ features: Feature[]; readonly path: GeoJSONFeature; readonly distance: number; from: GeoJSONCoordinate; to: GeoJSONCoordinate; }>} A Promise that resolves to an object containing the path, additional information, and the distance of the path.

getCachedTile

  • getCachedTile(quadkey: string): Tile

  • Get a locally cached tile by quadkey.

    Parameters

    • quadkey: string

      the quadkey of the tile

    Returns Tile

getCachedTilesOfBBox

  • getCachedTilesOfBBox(bbox: number[], zoomlevel?: number): Tile[]

  • get cached tile by bounding box.

    Parameters

    • bbox: number[]

      array of coordinates in order: [minLon, minLat, maxLon, maxLat]

    • Optional zoomlevel: number

      get tiles at specified tileMargin

    Returns Tile[]

    array of {@link Tiles}

getFeature

  • getFeature(id: string | number): Feature | undefined

  • Gets a feature from the provider by id.

    Parameters

    • id: string | number

      the id of the feature

    Returns Feature | undefined

    the found feature or undefined if feature is not present.

getFeatures

  • getFeatures(ids: string[] | number[]): Feature[] | Feature | undefined

  • Gets features from provider by id.

    Parameters

    • ids: string[] | number[]

      array of feature ids to search for.

    Returns Feature[] | Feature | undefined

    if just a single feature is found its getting returned otherwise an array of features or undefined if none is found.

getTile

  • getTile(quadkey: string, cb: (tile: Tile) => void): any

  • Get a tile by quadkey. If the tile is not cached already, it will be created and stored automatically. Data will be fetched from remote data-sources and attached to tile automatically

    Parameters

    • quadkey: string

      quadkey of the tile

    • cb: (tile: Tile) => void
        • (tile: Tile): void

        • Parameters

          Returns void

    Returns any

    the Tile

removeEventListener

  • removeEventListener(type: string, listener: (event: CustomEvent) => void, _c?: any): boolean

  • Remove an EventListener from the provider. Valid events: "featureAdd", "featureRemove", "featureCoordinatesChange", "clear" and "error"

    Parameters

    • type: string

      A string which specifies the type of event for which to remove an event listener.

    • listener: (event: CustomEvent) => void

      The listener function of the event handler to remove from the provider.

        • (event: CustomEvent): void

        • Parameters

          • event: CustomEvent

          Returns void

    • Optional _c: any

    Returns boolean

removeFeature

search

  • Search for feature(s) in the provider.

    example
    // searching by id:
layer.search({id: 1058507462})
// or:
layer.search({ids: [1058507462, 1058507464]})

// searching by point and radius:
layer.search({
 point: { longitude: 72.84205, latitude: 18.97172 },
 radius: 100
})

// searching by Rect:
layer.search({
 rect:  { minLon: 72.83584, maxLat: 18.97299, maxLon: 72.84443, minLat: 18.96876 }
})

    Parameters

    • options: { id?: number | string; ids?: number[] | string[]; point?: GeoPoint; radius?: number; rect?: GeoRect | GeoJSONBBox }

      configure the search

      • Optional id?: number | string

        search feature by id.

      • Optional ids?: number[] | string[]

        Array of feature ids to search.

      • Optional point?: GeoPoint

        Geographical center point of the point to search in. options.radius must be defined.

      • Optional radius?: number

        Radius of the point in meters, it is used in "point" search.

      • Optional rect?: GeoRect | GeoJSONBBox

        Geographical Rectangle to search in. [minLon, minLat, maxLon, maxLat] | GeoRect.

    Returns Feature | Feature[]

    array of features

  • Point Search for feature(s) in provider.

    example
    layer.search({longitude: 72.84205, latitude: 18.97172},{
 radius: 100
})
// or:
layer.search([72.84205, 18.97172], {
 radius: 100
})

    Parameters

    • point: GeoPoint

      Geographical center point of the point to search in. options.radius must be defined.

    • Optional options: { radius: number }

      configure the search

      • radius: number

        The radius of the circular area in meters to search in.

    Returns Feature[]

  • Rectangle Search for feature(s) in provider.

    example
    layer.search({minLon: 72.83584, maxLat: 18.97299, maxLon: 72.84443, minLat: 18.96876})
// or:
layer.search([72.83584, 18.96876, 72.84443,18.97299])

    Parameters

    • rect: GeoRect | GeoJSONBBox

      Geographical Rectangle to search in. [minLon, minLat, maxLon, maxLat] | GeoRect.

    Returns Feature[]

  • Search for feature by id in the provider.

    example
    layer.search(1058507462)

    Parameters

    • id: string | number

      id of the feature to search for

    Returns Feature

setFeatureCoordinates

setMargin

  • setMargin(tileMargin?: number): void

  • Set the tile margin in pixel.

    Parameters

    • Default value tileMargin: number = 0

      the tileMargin

    Returns void

Generated using TypeDoc