@mapbox/mapbox-gl-style-spec
Version:
a specification for mapbox gl styles
584 lines (537 loc) • 25.5 kB
text/typescript
import {isValue} from '../values';
import {NumberType} from '../types';
import {classifyRings, updateBBox, boxWithinBox, pointWithinPolygon, segmentIntersectSegment} from '../../util/geometry_util';
import CheapRuler from "cheap-ruler";
import TinyQueue from "tinyqueue";
import EXTENT from '../../data/extent';
import type Point from "@mapbox/point-geometry";
import type ParsingContext from '../parsing_context';
import type {BBox} from '../../util/geometry_util';
import type {Type} from '../types';
import type {Expression} from '../expression';
import type {CanonicalTileID} from '../../types/tile_id';
import type EvaluationContext from '../evaluation_context';
type DistanceGeometry = GeoJSON.Point | GeoJSON.MultiPoint | GeoJSON.LineString | GeoJSON.MultiLineString | GeoJSON.Polygon | GeoJSON.MultiPolygon;
// Inclusive index range for multipoint or linestring container
type IndexRange = [number, number];
type DistPair = {
dist: number;
range1: IndexRange;
range2: IndexRange;
};
function compareMax(a: DistPair, b: DistPair) {
return b.dist - a.dist;
}
const MIN_POINT_SIZE = 100;
const MIN_LINE_POINT_SIZE = 50;
function isDefaultBBOX(bbox: BBox) {
const defualtBBox = [Infinity, Infinity, -Infinity, -Infinity];
if (defualtBBox.length !== bbox.length) {
return false;
}
for (let i = 0; i < defualtBBox.length; i++) {
if (defualtBBox[i] !== bbox[i]) {
return false;
}
}
return true;
}
function getRangeSize(range: IndexRange) {
return range[1] - range[0] + 1;
}
function isRangeSafe(range: IndexRange, threshold: number) {
const ret = range[1] >= range[0] && range[1] < threshold;
if (!ret) {
console.warn("Distance Expression: Index is out of range");
}
return ret;
}
// Split the point set(points or linestring) into two halves, using IndexRange to do in-place splitting.
// If geometry is a line, the last point(here is the second index) of range1 needs to be included as the first point(here is the first index) of range2.
// If geometry are points, just split the points equally(if possible) into two new point sets(here are two index ranges).
function splitRange(range: IndexRange, isLine: boolean) {
if (range[0] > range[1]) return [null, null];
const size = getRangeSize(range);
if (isLine) {
if (size === 2) {
return [range, null];
}
const size1 = Math.floor(size / 2);
const range1: IndexRange = [range[0], range[0] + size1];
const range2: IndexRange = [range[0] + size1, range[1]];
return [range1, range2];
} else {
if (size === 1) {
return [range, null];
}
const size1 = Math.floor(size / 2) - 1;
const range1: IndexRange = [range[0], range[0] + size1];
const range2: IndexRange = [range[0] + size1 + 1, range[1]];
return [range1, range2];
}
}
function getBBox(pointSets: Array<[number, number]>, range: IndexRange) {
const bbox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
if (!isRangeSafe(range, pointSets.length)) return bbox;
for (let i = range[0]; i <= range[1]; ++i) {
updateBBox(bbox, pointSets[i]);
}
return bbox;
}
function getPolygonBBox(polygon: Array<Array<[number, number]>>) {
const bbox: BBox = [Infinity, Infinity, -Infinity, -Infinity];
for (let i = 0; i < polygon.length; ++i) {
for (let j = 0; j < polygon[i].length; ++j) {
updateBBox(bbox, polygon[i][j]);
}
}
return bbox;
}
// Calculate the distance between two bounding boxes.
// Calculate the delta in x and y direction, and use two fake points {0.0, 0.0} and {dx, dy} to calculate the distance.
// Distance will be 0.0 if bounding box are overlapping.
function bboxToBBoxDistance(bbox1: BBox, bbox2: BBox, ruler: CheapRuler) {
if (isDefaultBBOX(bbox1) || isDefaultBBOX(bbox2)) {
return NaN;
}
let dx = 0.0;
let dy = 0.0;
// bbox1 in left side
if (bbox1[2] < bbox2[0]) {
dx = bbox2[0] - bbox1[2];
}
// bbox1 in right side
if (bbox1[0] > bbox2[2]) {
dx = bbox1[0] - bbox2[2];
}
// bbox1 in above side
if (bbox1[1] > bbox2[3]) {
dy = bbox1[1] - bbox2[3];
}
// bbox1 in down side
if (bbox1[3] < bbox2[1]) {
dy = bbox2[1] - bbox1[3];
}
return ruler.distance([0.0, 0.0], [dx, dy]);
}
function lngFromMercatorX(x: number): number {
return x * 360 - 180;
}
function latFromMercatorY(y: number): number {
const y2 = 180 - y * 360;
return 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
}
function getLngLatPoint(coord: Point, canonical: CanonicalTileID) {
const tilesAtZoom = Math.pow(2, canonical.z);
const x = (coord.x / EXTENT + canonical.x) / tilesAtZoom;
const y = (coord.y / EXTENT + canonical.y) / tilesAtZoom;
return [lngFromMercatorX(x), latFromMercatorY(y)];
}
function getLngLatPoints(coordinates: Array<Point>, canonical: CanonicalTileID) {
const coords = [];
for (let i = 0; i < coordinates.length; ++i) {
coords.push(getLngLatPoint(coordinates[i], canonical));
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-return
return coords;
}
function pointToLineDistance(point: [number, number], line: Array<[number, number]>, ruler: CheapRuler) {
const nearestPoint = ruler.pointOnLine(line, point).point;
return ruler.distance(point, nearestPoint);
}
function pointsToLineDistance(points: Array<[number, number]>, rangeA: IndexRange, line: Array<[number, number]>, rangeB: IndexRange, ruler: CheapRuler) {
const subLine = line.slice(rangeB[0], rangeB[1] + 1);
let dist = Infinity;
for (let i = rangeA[0]; i <= rangeA[1]; ++i) {
if ((dist = Math.min(dist, pointToLineDistance(points[i], subLine, ruler))) === 0.0) return 0.0;
}
return dist;
}
// precondition is two segments are not intersecting with each other
function segmentToSegmentDistance(p1: [number, number], p2: [number, number], q1: [number, number], q2: [number, number], ruler: CheapRuler) {
const dist1 = Math.min(
ruler.pointToSegmentDistance(p1, q1, q2),
ruler.pointToSegmentDistance(p2, q1, q2)
);
const dist2 = Math.min(
ruler.pointToSegmentDistance(q1, p1, p2),
ruler.pointToSegmentDistance(q2, p1, p2)
);
return Math.min(dist1, dist2);
}
function lineToLineDistance(line1: Array<[number, number]>, range1: IndexRange, line2: Array<[number, number]>, range2: IndexRange, ruler: CheapRuler) {
if (!isRangeSafe(range1, line1.length) || !isRangeSafe(range2, line2.length)) {
return NaN;
}
let dist = Infinity;
for (let i = range1[0]; i < range1[1]; ++i) {
for (let j = range2[0]; j < range2[1]; ++j) {
if (segmentIntersectSegment(line1[i], line1[i + 1], line2[j], line2[j + 1])) return 0.0;
dist = Math.min(dist, segmentToSegmentDistance(line1[i], line1[i + 1], line2[j], line2[j + 1], ruler));
}
}
return dist;
}
function pointsToPointsDistance(pointSet1: Array<[number, number]>, range1: IndexRange, pointSet2: Array<[number, number]>, range2: IndexRange, ruler: CheapRuler) {
if (!isRangeSafe(range1, pointSet1.length) || !isRangeSafe(range2, pointSet2.length)) {
return NaN;
}
let dist = Infinity;
for (let i = range1[0]; i <= range1[1]; ++i) {
for (let j = range2[0]; j <= range2[1]; ++j) {
if ((dist = Math.min(dist, ruler.distance(pointSet1[i], pointSet2[j]))) === 0.0) return dist;
}
}
return dist;
}
function pointToPolygonDistance(point: [number, number], polygon: Array<Array<[number, number]>>, ruler: CheapRuler) {
if (pointWithinPolygon(point, polygon, true /*trueOnBoundary*/)) return 0.0;
let dist = Infinity;
for (const ring of polygon) {
const ringLen = ring.length;
if (ringLen < 2) {
console.warn("Distance Expression: Invalid polygon!");
return NaN;
}
if (ring[0] !== ring[ringLen - 1]) {
if ((dist = Math.min(dist, ruler.pointToSegmentDistance(point, ring[ringLen - 1], ring[0]))) === 0.0) return dist;
}
if ((dist = Math.min(dist, pointToLineDistance(point, ring, ruler))) === 0.0) return dist;
}
return dist;
}
function lineToPolygonDistance(line: Array<[number, number]>, range: IndexRange, polygon: Array<Array<[number, number]>>, ruler: CheapRuler) {
if (!isRangeSafe(range, line.length)) {
return NaN;
}
for (let i = range[0]; i <= range[1]; ++i) {
if (pointWithinPolygon(line[i], polygon, true /*trueOnBoundary*/)) return 0.0;
}
let dist = Infinity;
for (let i = range[0]; i < range[1]; ++i) {
for (const ring of polygon) {
for (let j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
if (segmentIntersectSegment(line[i], line[i + 1], ring[k], ring[j])) return 0.0;
dist = Math.min(dist, segmentToSegmentDistance(line[i], line[i + 1], ring[k], ring[j], ruler));
}
}
}
return dist;
}
function polygonIntersect(polygon1: Array<Array<[number, number]>>, polygon2: Array<Array<[number, number]>>) {
for (const ring of polygon1) {
for (let i = 0; i <= ring.length - 1; ++i) {
if (pointWithinPolygon(ring[i], polygon2, true /*trueOnBoundary*/)) return true;
}
}
return false;
}
function polygonToPolygonDistance(polygon1: Array<Array<[number, number]>>, polygon2: Array<Array<[number, number]>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
const bbox1 = getPolygonBBox(polygon1);
const bbox2 = getPolygonBBox(polygon2);
if (currentMiniDist !== Infinity && bboxToBBoxDistance(bbox1, bbox2, ruler) >= currentMiniDist) {
return currentMiniDist;
}
if (boxWithinBox(bbox1, bbox2)) {
if (polygonIntersect(polygon1, polygon2)) return 0.0;
} else if (polygonIntersect(polygon2, polygon1)) {
return 0.0;
}
let dist = currentMiniDist;
for (const ring1 of polygon1) {
for (let i = 0, len1 = ring1.length, l = len1 - 1; i < len1; l = i++) {
for (const ring2 of polygon2) {
for (let j = 0, len2 = ring2.length, k = len2 - 1; j < len2; k = j++) {
if (segmentIntersectSegment(ring1[l], ring1[i], ring2[k], ring2[j])) return 0.0;
dist = Math.min(dist, segmentToSegmentDistance(ring1[l], ring1[i], ring2[k], ring2[j], ruler));
}
}
}
}
return dist;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function updateQueue(distQueue: any, miniDist: number, ruler: CheapRuler, pointSet1: Array<[number, number]>, pointSet2: Array<[number, number]>, r1: IndexRange | null, r2: IndexRange | null) {
if (r1 === null || r2 === null) return;
const tempDist = bboxToBBoxDistance(getBBox(pointSet1, r1), getBBox(pointSet2, r2), ruler);
// Insert new pair to the queue if the bbox distance is less than miniDist, the pair with biggest distance will be at the top
if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: r1, range2: r2});
}
// Divide and conquer, the time complexity is O(n*lgn), faster than Brute force O(n*n)
// Most of the time, use index for in-place processing.
function pointSetToPolygonDistance(pointSets: Array<[number, number]>, isLine: boolean, polygon: Array<Array<[number, number]>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
let miniDist = Math.min(ruler.distance(pointSets[0], polygon[0][0]), currentMiniDist);
if (miniDist === 0.0) return miniDist;
const initialDistPair: DistPair = {
dist: 0,
range1: [0, pointSets.length - 1],
range2: [0, 0]
};
const distQueue = new TinyQueue<DistPair>([initialDistPair], compareMax);
const setThreshold = isLine ? MIN_LINE_POINT_SIZE : MIN_POINT_SIZE;
const polyBBox = getPolygonBBox(polygon);
while (distQueue.length) {
const distPair = distQueue.pop();
if (distPair.dist >= miniDist) continue;
const range = distPair.range1;
// In case the set size are relatively small, we could use brute-force directly
if (getRangeSize(range) <= setThreshold) {
if (!isRangeSafe(range, pointSets.length)) return NaN;
if (isLine) {
const tempDist = lineToPolygonDistance(pointSets, range, polygon, ruler);
if ((miniDist = Math.min(miniDist, tempDist)) === 0.0) return miniDist;
} else {
for (let i = range[0]; i <= range[1]; ++i) {
const tempDist = pointToPolygonDistance(pointSets[i], polygon, ruler);
if ((miniDist = Math.min(miniDist, tempDist)) === 0.0) return miniDist;
}
}
} else {
const newRanges = splitRange(range, isLine);
if (newRanges[0] !== null) {
const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[0]), polyBBox, ruler);
if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: newRanges[0], range2: [0, 0]});
}
if (newRanges[1] !== null) {
const tempDist = bboxToBBoxDistance(getBBox(pointSets, newRanges[1]), polyBBox, ruler);
if (tempDist < miniDist) distQueue.push({dist: tempDist, range1: newRanges[1], range2: [0, 0]});
}
}
}
return miniDist;
}
function pointSetsDistance(pointSet1: Array<[number, number]>, isLine1: boolean, pointSet2: Array<[number, number]>, isLine2: boolean, ruler: CheapRuler, currentMiniDist: number = Infinity) {
let miniDist = Math.min(currentMiniDist, ruler.distance(pointSet1[0], pointSet2[0]));
if (miniDist === 0.0) return miniDist;
const initialDistPair: DistPair = {
dist: 0,
range1: [0, pointSet1.length - 1],
range2: [0, pointSet2.length - 1]
};
const distQueue = new TinyQueue<DistPair>([initialDistPair], compareMax);
const set1Threshold = isLine1 ? MIN_LINE_POINT_SIZE : MIN_POINT_SIZE;
const set2Threshold = isLine2 ? MIN_LINE_POINT_SIZE : MIN_POINT_SIZE;
while (distQueue.length) {
const distPair = distQueue.pop();
if (distPair.dist >= miniDist) continue;
const rangeA = distPair.range1;
const rangeB = distPair.range2;
// In case the set size are relatively small, we could use brute-force directly
if (getRangeSize(rangeA) <= set1Threshold && getRangeSize(rangeB) <= set2Threshold) {
if (!isRangeSafe(rangeA, pointSet1.length) || !isRangeSafe(rangeB, pointSet2.length)) {
return NaN;
}
if (isLine1 && isLine2) {
miniDist = Math.min(miniDist, lineToLineDistance(pointSet1, rangeA, pointSet2, rangeB, ruler));
} else if (!isLine1 && !isLine2) {
miniDist = Math.min(miniDist, pointsToPointsDistance(pointSet1, rangeA, pointSet2, rangeB, ruler));
} else if (isLine1 && !isLine2) {
miniDist = Math.min(miniDist, pointsToLineDistance(pointSet2, rangeB, pointSet1, rangeA, ruler));
} else if (!isLine1 && isLine2) {
miniDist = Math.min(miniDist, pointsToLineDistance(pointSet1, rangeA, pointSet2, rangeB, ruler));
}
if (miniDist === 0.0) return miniDist;
} else {
const newRangesA = splitRange(rangeA, isLine1);
const newRangesB = splitRange(rangeB, isLine2);
updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[0], newRangesB[0]);
updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[0], newRangesB[1]);
updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[1], newRangesB[0]);
updateQueue(distQueue, miniDist, ruler, pointSet1, pointSet2, newRangesA[1], newRangesB[1]);
}
}
return miniDist;
}
function pointSetToLinesDistance(pointSet: Array<[number, number]>, isLine: boolean, lines: Array<Array<[number, number]>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
let dist = currentMiniDist;
const bbox1 = getBBox(pointSet, [0, pointSet.length - 1]);
for (const line of lines) {
if (dist !== Infinity && bboxToBBoxDistance(bbox1, getBBox(line, [0, line.length - 1]), ruler) >= dist) continue;
dist = Math.min(dist, pointSetsDistance(pointSet, isLine, line, true /*isLine*/, ruler, dist));
if (dist === 0.0) return dist;
}
return dist;
}
function pointSetToPolygonsDistance(points: Array<[number, number]>, isLine: boolean, polygons: Array<Array<Array<[number, number]>>>, ruler: CheapRuler, currentMiniDist: number = Infinity) {
let dist = currentMiniDist;
const bbox1 = getBBox(points, [0, points.length - 1]);
for (const polygon of polygons) {
if (dist !== Infinity && bboxToBBoxDistance(bbox1, getPolygonBBox(polygon), ruler) >= dist) continue;
const tempDist = pointSetToPolygonDistance(points, isLine, polygon, ruler, dist);
if (isNaN(tempDist)) return tempDist;
if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
}
return dist;
}
function polygonsToPolygonsDistance(polygons1: Array<Array<Array<[number, number]>>>, polygons2: Array<Array<Array<[number, number]>>>, ruler: CheapRuler) {
let dist = Infinity;
for (const polygon1 of polygons1) {
for (const polygon2 of polygons2) {
const tempDist = polygonToPolygonDistance(polygon1, polygon2, ruler, dist);
if (isNaN(tempDist)) return tempDist;
if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
}
}
return dist;
}
function pointsToGeometryDistance(originGeometry: Array<Array<Point>>, canonical: CanonicalTileID, geometry: DistanceGeometry) {
const lngLatPoints = [];
for (const points of originGeometry) {
for (const point of points) {
lngLatPoints.push(getLngLatPoint(point, canonical));
}
}
const ruler = new CheapRuler(lngLatPoints[0][1], 'meters');
if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
return pointSetsDistance(lngLatPoints, false /*isLine*/,
(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates) as Array<[number, number]>,
geometry.type === 'LineString' /*isLine*/, ruler);
}
if (geometry.type === 'MultiLineString') {
return pointSetToLinesDistance(lngLatPoints, false /*isLine*/, geometry.coordinates as Array<Array<[number, number]>>, ruler);
}
if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
return pointSetToPolygonsDistance(lngLatPoints, false /*isLine*/,
(geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates) as Array<Array<Array<[number, number]>>>, ruler);
}
return null;
}
function linesToGeometryDistance(originGeometry: Array<Array<Point>>, canonical: CanonicalTileID, geometry: DistanceGeometry) {
const lngLatLines = [];
for (const line of originGeometry) {
const lngLatLine = [];
for (const point of line) {
lngLatLine.push(getLngLatPoint(point, canonical));
}
lngLatLines.push(lngLatLine);
}
const ruler = new CheapRuler(lngLatLines[0][0][1], 'meters');
if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
return pointSetToLinesDistance(
(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates) as Array<[number, number]>,
geometry.type === 'LineString' /*isLine*/, lngLatLines, ruler);
}
if (geometry.type === 'MultiLineString') {
let dist = Infinity;
for (let i = 0; i < geometry.coordinates.length; i++) {
const tempDist = pointSetToLinesDistance(geometry.coordinates[i] as Array<[number, number]>, true /*isLine*/, lngLatLines, ruler, dist);
if (isNaN(tempDist)) return tempDist;
if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
}
return dist;
}
if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
let dist = Infinity;
for (let i = 0; i < lngLatLines.length; i++) {
const tempDist = pointSetToPolygonsDistance(lngLatLines[i], true /*isLine*/,
(geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates) as Array<Array<Array<[number, number]>>>,
ruler, dist);
if (isNaN(tempDist)) return tempDist;
if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
}
return dist;
}
return null;
}
function polygonsToGeometryDistance(originGeometry: Array<Array<Point>>, canonical: CanonicalTileID, geometry: DistanceGeometry) {
const lngLatPolygons = [];
for (const polygon of classifyRings(originGeometry, 0)) {
const lngLatPolygon = [];
for (let i = 0; i < polygon.length; ++i) {
lngLatPolygon.push(getLngLatPoints(polygon[i], canonical));
}
lngLatPolygons.push(lngLatPolygon);
}
const ruler = new CheapRuler(lngLatPolygons[0][0][0][1], 'meters');
if (geometry.type === 'Point' || geometry.type === 'MultiPoint' || geometry.type === 'LineString') {
return pointSetToPolygonsDistance(
(geometry.type === 'Point' ? [geometry.coordinates] : geometry.coordinates) as Array<[number, number]>,
geometry.type === 'LineString' /*isLine*/, lngLatPolygons, ruler);
}
if (geometry.type === 'MultiLineString') {
let dist = Infinity;
for (let i = 0; i < geometry.coordinates.length; i++) {
const tempDist = pointSetToPolygonsDistance(geometry.coordinates[i] as Array<[number, number]>, true /*isLine*/, lngLatPolygons, ruler, dist);
if (isNaN(tempDist)) return tempDist;
if ((dist = Math.min(dist, tempDist)) === 0.0) return dist;
}
return dist;
}
if (geometry.type === 'Polygon' || geometry.type === 'MultiPolygon') {
return polygonsToPolygonsDistance(
(geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates) as Array<Array<Array<[number, number]>>>,
lngLatPolygons, ruler);
}
return null;
}
function isTypeValid(type: string) {
return (
type === "Point" ||
type === "MultiPoint" ||
type === "LineString" ||
type === "MultiLineString" ||
type === "Polygon" ||
type === "MultiPolygon"
);
}
class Distance implements Expression {
type: Type;
geojson: GeoJSON.GeoJSON;
geometries: DistanceGeometry;
constructor(geojson: GeoJSON.GeoJSON, geometries: DistanceGeometry) {
this.type = NumberType;
this.geojson = geojson;
this.geometries = geometries;
}
static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Distance | null | void {
if (args.length !== 2) {
return context.error(`'distance' expression requires either one argument, but found ' ${args.length - 1} instead.`);
}
if (isValue(args[1])) {
const geojson = args[1] as GeoJSON.GeoJSON;
if (geojson.type === 'FeatureCollection') {
for (let i = 0; i < geojson.features.length; ++i) {
if (isTypeValid(geojson.features[i].geometry.type)) {
return new Distance(geojson, geojson.features[i].geometry as DistanceGeometry);
}
}
} else if (geojson.type === 'Feature') {
if (isTypeValid(geojson.geometry.type)) {
return new Distance(geojson, geojson.geometry as DistanceGeometry);
}
} else if (isTypeValid(geojson.type)) {
return new Distance(geojson, geojson as DistanceGeometry);
}
}
return context.error(
"'distance' expression needs to be an array with format [\'Distance\', GeoJSONObj]."
);
}
evaluate(ctx: EvaluationContext): number | null {
const geometry = ctx.geometry();
const canonical = ctx.canonicalID();
if (geometry != null && canonical != null) {
if (ctx.geometryType() === 'Point') {
return pointsToGeometryDistance(geometry, canonical, this.geometries);
}
if (ctx.geometryType() === 'LineString') {
return linesToGeometryDistance(geometry, canonical, this.geometries);
}
if (ctx.geometryType() === 'Polygon') {
return polygonsToGeometryDistance(geometry, canonical, this.geometries);
}
console.warn("Distance Expression: currently only evaluates valid Point/LineString/Polygon geometries.");
} else {
console.warn("Distance Expression: requirs valid feature and canonical information.");
}
return null;
}
eachChild() {}
outputDefined(): boolean {
return true;
}
serialize(): Array<unknown> {
return ['distance', this.geojson];
}
}
export default Distance;