Class ShapeProvider

A ShapeProvider allows you to map Feature from a single model into different geometric representations. It is used by a FeatureLayer.

A common use case is to visualize a model on both a geographic map and a cartesian chart.

For example, a `ShapeProvider` helps you display trajectories on a geodetic map in one layer, and display same trajectories on a vertical chart in another layer.

``````class TrajectoryShapeProvider extends ShapeProvider {  constructor() {    super();    this.reference = createCartesianReference({      xUnitOfMeasure: meterUnit,      yUnitOfMeasure: meterUnit    });  }  provideShape(trajectoryFeature: Feature) {    const shape = trajectoryFeature.shape as any as Polyline;    if (!shape || !shape.reference) {      return null;    }    // Creates a cartesian shape for the passed trajectory feature,    // where the x-coordinates represent the distance along the trajectory, and the y-coordinate represents the altitude of the aircraft at that point.    const geodesy = createEllipsoidalGeodesy(shape.reference);    const points: Point[] = [];    // for each of the points in the original trajectory calculate the distance from the first point using    // the geodesy instance. This gives us the x-coordinate of the resulting shape    // The height is directly available in the z-coordinate of the points of the original trajectory    let distance = 0;    let point0 = shape.getPoint(0);    points[0] = createPoint(this.reference, [0, point0.z]);    for (let i = 0; i < shape.pointCount; i++) {      const nextPoint = shape.getPoint(i);      distance += geodesy.distance(point0, nextPoint, LineType.SHORTEST_DISTANCE);      points.push(createPoint(this.reference, [distance, nextPoint.z]))      point0 = nextPoint;    }    return createPolyline(this.reference, points);  }}
``````

Example for a `ShapeProvider` that provides shapes asynchronously.

``````class AsyncShapeProvider extends ShapeProvider {  private readonly shapeCache: Map<string|number, Shape>  private readonly shapePromise: Map<string|number, Promise<Shape>>;  constructor() {    super();    this.shapeCache = new Map();    this.shapePromise = new Map();  }  provideShape(feature: Feature) {    const shape = this.shapeCache.get(feature.id);    if (shape) {      // Shape was already resolved      return shape;    }    if (!this.shapePromise.get(feature.id)) {      // Invoke a function that provides shapes asynchronously      const promiseForShape = getAsyncShape(feature);      this.shapePromise.set(feature.id, promiseForShape);      // When the promise is resolved cache the shape and invalidate itself      promiseForShape.then((shape) => {        this.shapeCache.set(feature.id, shape);        this.shapePromise.delete(feature.id);        // Invalidate self to provide the resolved shape        this.invalidateById(feature.id);      });    }    // The feature will not be drawn till its shape is resolved    return null;  };}
``````

Constructors

• An object that provides a Feature object.

Accessors

• get reference(): null | CoordinateReference
• The reference of the shapes produced by the provideShape method.

When the `ShapeProvider` instance is added to a `FeatureLayer`, and then the layer is attached to a map, LuciadRIA determines if it is possible to visualize shapes on the map by matching the shape provider reference to the map reference.

This property is optional. When it is not set, the `FeatureLayer` expects all shape references to be the same as the reference of the `FeatureModel`.

Returns null | CoordinateReference

• set reference(reference): void

Methods

• Invalidates the shape for a specific object.

Call this method when any state that determines the mapping for a feature to a shape has changed. Calling this method guarantees that the object will be repainted with a new shape during the next map render.

Returns void

• Invalidates shapes for all objects.

Calling this method guarantees that all the objects will be repainted with new shapes during the next map render.

Returns void

• Invalidates this shape for a specific object by id.

Call this method when any state that determines the mapping for a feature to a shape has changed. Calling this method guarantees that the object will be repainted with a new shape during the next map render.

Parameters

• featureId: FeatureId

The id of the feature. It corresponds to `luciad/model/feature/Feature#id`.

Returns void

• Registers a callback function for a given event type.

Parameters

• event: string

the event type to register on

• callback: ((...args) => void)

the callback function to register

• (...args): void
• Parameters

• `Rest` ...args: any[]

Returns void

• `Optional` scope: any

the context in which the callback function should be invoked implementation dependent.

Returns Handle

a handle to the registered callback with a single function 'remove'. This function can be used to unregister the callback function.

• Returns a shape for the given feature.

Returns null | Shape

the shape associated with the input feature.