534 lines
14 KiB
JavaScript
534 lines
14 KiB
JavaScript
// node_modules/ol/extent/Relationship.js
|
|
var Relationship_default = {
|
|
UNKNOWN: 0,
|
|
INTERSECTING: 1,
|
|
ABOVE: 2,
|
|
RIGHT: 4,
|
|
BELOW: 8,
|
|
LEFT: 16
|
|
};
|
|
|
|
// node_modules/ol/extent.js
|
|
function boundingExtent(coordinates) {
|
|
const extent = createEmpty();
|
|
for (let i = 0, ii = coordinates.length; i < ii; ++i) {
|
|
extendCoordinate(extent, coordinates[i]);
|
|
}
|
|
return extent;
|
|
}
|
|
function _boundingExtentXYs(xs, ys, dest) {
|
|
const minX = Math.min.apply(null, xs);
|
|
const minY = Math.min.apply(null, ys);
|
|
const maxX = Math.max.apply(null, xs);
|
|
const maxY = Math.max.apply(null, ys);
|
|
return createOrUpdate(minX, minY, maxX, maxY, dest);
|
|
}
|
|
function buffer(extent, value, dest) {
|
|
if (dest) {
|
|
dest[0] = extent[0] - value;
|
|
dest[1] = extent[1] - value;
|
|
dest[2] = extent[2] + value;
|
|
dest[3] = extent[3] + value;
|
|
return dest;
|
|
}
|
|
return [
|
|
extent[0] - value,
|
|
extent[1] - value,
|
|
extent[2] + value,
|
|
extent[3] + value
|
|
];
|
|
}
|
|
function clone(extent, dest) {
|
|
if (dest) {
|
|
dest[0] = extent[0];
|
|
dest[1] = extent[1];
|
|
dest[2] = extent[2];
|
|
dest[3] = extent[3];
|
|
return dest;
|
|
}
|
|
return extent.slice();
|
|
}
|
|
function closestSquaredDistanceXY(extent, x, y) {
|
|
let dx, dy;
|
|
if (x < extent[0]) {
|
|
dx = extent[0] - x;
|
|
} else if (extent[2] < x) {
|
|
dx = x - extent[2];
|
|
} else {
|
|
dx = 0;
|
|
}
|
|
if (y < extent[1]) {
|
|
dy = extent[1] - y;
|
|
} else if (extent[3] < y) {
|
|
dy = y - extent[3];
|
|
} else {
|
|
dy = 0;
|
|
}
|
|
return dx * dx + dy * dy;
|
|
}
|
|
function containsCoordinate(extent, coordinate) {
|
|
return containsXY(extent, coordinate[0], coordinate[1]);
|
|
}
|
|
function containsExtent(extent1, extent2) {
|
|
return extent1[0] <= extent2[0] && extent2[2] <= extent1[2] && extent1[1] <= extent2[1] && extent2[3] <= extent1[3];
|
|
}
|
|
function containsXY(extent, x, y) {
|
|
return extent[0] <= x && x <= extent[2] && extent[1] <= y && y <= extent[3];
|
|
}
|
|
function coordinateRelationship(extent, coordinate) {
|
|
const minX = extent[0];
|
|
const minY = extent[1];
|
|
const maxX = extent[2];
|
|
const maxY = extent[3];
|
|
const x = coordinate[0];
|
|
const y = coordinate[1];
|
|
let relationship = Relationship_default.UNKNOWN;
|
|
if (x < minX) {
|
|
relationship = relationship | Relationship_default.LEFT;
|
|
} else if (x > maxX) {
|
|
relationship = relationship | Relationship_default.RIGHT;
|
|
}
|
|
if (y < minY) {
|
|
relationship = relationship | Relationship_default.BELOW;
|
|
} else if (y > maxY) {
|
|
relationship = relationship | Relationship_default.ABOVE;
|
|
}
|
|
if (relationship === Relationship_default.UNKNOWN) {
|
|
relationship = Relationship_default.INTERSECTING;
|
|
}
|
|
return relationship;
|
|
}
|
|
function createEmpty() {
|
|
return [Infinity, Infinity, -Infinity, -Infinity];
|
|
}
|
|
function createOrUpdate(minX, minY, maxX, maxY, dest) {
|
|
if (dest) {
|
|
dest[0] = minX;
|
|
dest[1] = minY;
|
|
dest[2] = maxX;
|
|
dest[3] = maxY;
|
|
return dest;
|
|
}
|
|
return [minX, minY, maxX, maxY];
|
|
}
|
|
function createOrUpdateEmpty(dest) {
|
|
return createOrUpdate(Infinity, Infinity, -Infinity, -Infinity, dest);
|
|
}
|
|
function createOrUpdateFromCoordinate(coordinate, dest) {
|
|
const x = coordinate[0];
|
|
const y = coordinate[1];
|
|
return createOrUpdate(x, y, x, y, dest);
|
|
}
|
|
function createOrUpdateFromCoordinates(coordinates, dest) {
|
|
const extent = createOrUpdateEmpty(dest);
|
|
return extendCoordinates(extent, coordinates);
|
|
}
|
|
function createOrUpdateFromFlatCoordinates(flatCoordinates, offset, end, stride, dest) {
|
|
const extent = createOrUpdateEmpty(dest);
|
|
return extendFlatCoordinates(extent, flatCoordinates, offset, end, stride);
|
|
}
|
|
function createOrUpdateFromRings(rings, dest) {
|
|
const extent = createOrUpdateEmpty(dest);
|
|
return extendRings(extent, rings);
|
|
}
|
|
function equals(extent1, extent2) {
|
|
return extent1[0] == extent2[0] && extent1[2] == extent2[2] && extent1[1] == extent2[1] && extent1[3] == extent2[3];
|
|
}
|
|
function approximatelyEquals(extent1, extent2, tolerance) {
|
|
return Math.abs(extent1[0] - extent2[0]) < tolerance && Math.abs(extent1[2] - extent2[2]) < tolerance && Math.abs(extent1[1] - extent2[1]) < tolerance && Math.abs(extent1[3] - extent2[3]) < tolerance;
|
|
}
|
|
function extend(extent1, extent2) {
|
|
if (extent2[0] < extent1[0]) {
|
|
extent1[0] = extent2[0];
|
|
}
|
|
if (extent2[2] > extent1[2]) {
|
|
extent1[2] = extent2[2];
|
|
}
|
|
if (extent2[1] < extent1[1]) {
|
|
extent1[1] = extent2[1];
|
|
}
|
|
if (extent2[3] > extent1[3]) {
|
|
extent1[3] = extent2[3];
|
|
}
|
|
return extent1;
|
|
}
|
|
function extendCoordinate(extent, coordinate) {
|
|
if (coordinate[0] < extent[0]) {
|
|
extent[0] = coordinate[0];
|
|
}
|
|
if (coordinate[0] > extent[2]) {
|
|
extent[2] = coordinate[0];
|
|
}
|
|
if (coordinate[1] < extent[1]) {
|
|
extent[1] = coordinate[1];
|
|
}
|
|
if (coordinate[1] > extent[3]) {
|
|
extent[3] = coordinate[1];
|
|
}
|
|
}
|
|
function extendCoordinates(extent, coordinates) {
|
|
for (let i = 0, ii = coordinates.length; i < ii; ++i) {
|
|
extendCoordinate(extent, coordinates[i]);
|
|
}
|
|
return extent;
|
|
}
|
|
function extendFlatCoordinates(extent, flatCoordinates, offset, end, stride) {
|
|
for (; offset < end; offset += stride) {
|
|
extendXY(extent, flatCoordinates[offset], flatCoordinates[offset + 1]);
|
|
}
|
|
return extent;
|
|
}
|
|
function extendRings(extent, rings) {
|
|
for (let i = 0, ii = rings.length; i < ii; ++i) {
|
|
extendCoordinates(extent, rings[i]);
|
|
}
|
|
return extent;
|
|
}
|
|
function extendXY(extent, x, y) {
|
|
extent[0] = Math.min(extent[0], x);
|
|
extent[1] = Math.min(extent[1], y);
|
|
extent[2] = Math.max(extent[2], x);
|
|
extent[3] = Math.max(extent[3], y);
|
|
}
|
|
function forEachCorner(extent, callback) {
|
|
let val;
|
|
val = callback(getBottomLeft(extent));
|
|
if (val) {
|
|
return val;
|
|
}
|
|
val = callback(getBottomRight(extent));
|
|
if (val) {
|
|
return val;
|
|
}
|
|
val = callback(getTopRight(extent));
|
|
if (val) {
|
|
return val;
|
|
}
|
|
val = callback(getTopLeft(extent));
|
|
if (val) {
|
|
return val;
|
|
}
|
|
return false;
|
|
}
|
|
function getArea(extent) {
|
|
let area = 0;
|
|
if (!isEmpty(extent)) {
|
|
area = getWidth(extent) * getHeight(extent);
|
|
}
|
|
return area;
|
|
}
|
|
function getBottomLeft(extent) {
|
|
return [extent[0], extent[1]];
|
|
}
|
|
function getBottomRight(extent) {
|
|
return [extent[2], extent[1]];
|
|
}
|
|
function getCenter(extent) {
|
|
return [(extent[0] + extent[2]) / 2, (extent[1] + extent[3]) / 2];
|
|
}
|
|
function getCorner(extent, corner) {
|
|
let coordinate;
|
|
if (corner === "bottom-left") {
|
|
coordinate = getBottomLeft(extent);
|
|
} else if (corner === "bottom-right") {
|
|
coordinate = getBottomRight(extent);
|
|
} else if (corner === "top-left") {
|
|
coordinate = getTopLeft(extent);
|
|
} else if (corner === "top-right") {
|
|
coordinate = getTopRight(extent);
|
|
} else {
|
|
throw new Error("Invalid corner");
|
|
}
|
|
return coordinate;
|
|
}
|
|
function getEnlargedArea(extent1, extent2) {
|
|
const minX = Math.min(extent1[0], extent2[0]);
|
|
const minY = Math.min(extent1[1], extent2[1]);
|
|
const maxX = Math.max(extent1[2], extent2[2]);
|
|
const maxY = Math.max(extent1[3], extent2[3]);
|
|
return (maxX - minX) * (maxY - minY);
|
|
}
|
|
function getForViewAndSize(center, resolution, rotation, size, dest) {
|
|
const [x0, y0, x1, y1, x2, y2, x3, y3] = getRotatedViewport(
|
|
center,
|
|
resolution,
|
|
rotation,
|
|
size
|
|
);
|
|
return createOrUpdate(
|
|
Math.min(x0, x1, x2, x3),
|
|
Math.min(y0, y1, y2, y3),
|
|
Math.max(x0, x1, x2, x3),
|
|
Math.max(y0, y1, y2, y3),
|
|
dest
|
|
);
|
|
}
|
|
function getRotatedViewport(center, resolution, rotation, size) {
|
|
const dx = resolution * size[0] / 2;
|
|
const dy = resolution * size[1] / 2;
|
|
const cosRotation = Math.cos(rotation);
|
|
const sinRotation = Math.sin(rotation);
|
|
const xCos = dx * cosRotation;
|
|
const xSin = dx * sinRotation;
|
|
const yCos = dy * cosRotation;
|
|
const ySin = dy * sinRotation;
|
|
const x = center[0];
|
|
const y = center[1];
|
|
return [
|
|
x - xCos + ySin,
|
|
y - xSin - yCos,
|
|
x - xCos - ySin,
|
|
y - xSin + yCos,
|
|
x + xCos - ySin,
|
|
y + xSin + yCos,
|
|
x + xCos + ySin,
|
|
y + xSin - yCos,
|
|
x - xCos + ySin,
|
|
y - xSin - yCos
|
|
];
|
|
}
|
|
function getHeight(extent) {
|
|
return extent[3] - extent[1];
|
|
}
|
|
function getIntersectionArea(extent1, extent2) {
|
|
const intersection = getIntersection(extent1, extent2);
|
|
return getArea(intersection);
|
|
}
|
|
function getIntersection(extent1, extent2, dest) {
|
|
const intersection = dest ? dest : createEmpty();
|
|
if (intersects(extent1, extent2)) {
|
|
if (extent1[0] > extent2[0]) {
|
|
intersection[0] = extent1[0];
|
|
} else {
|
|
intersection[0] = extent2[0];
|
|
}
|
|
if (extent1[1] > extent2[1]) {
|
|
intersection[1] = extent1[1];
|
|
} else {
|
|
intersection[1] = extent2[1];
|
|
}
|
|
if (extent1[2] < extent2[2]) {
|
|
intersection[2] = extent1[2];
|
|
} else {
|
|
intersection[2] = extent2[2];
|
|
}
|
|
if (extent1[3] < extent2[3]) {
|
|
intersection[3] = extent1[3];
|
|
} else {
|
|
intersection[3] = extent2[3];
|
|
}
|
|
} else {
|
|
createOrUpdateEmpty(intersection);
|
|
}
|
|
return intersection;
|
|
}
|
|
function getMargin(extent) {
|
|
return getWidth(extent) + getHeight(extent);
|
|
}
|
|
function getSize(extent) {
|
|
return [extent[2] - extent[0], extent[3] - extent[1]];
|
|
}
|
|
function getTopLeft(extent) {
|
|
return [extent[0], extent[3]];
|
|
}
|
|
function getTopRight(extent) {
|
|
return [extent[2], extent[3]];
|
|
}
|
|
function getWidth(extent) {
|
|
return extent[2] - extent[0];
|
|
}
|
|
function intersects(extent1, extent2) {
|
|
return extent1[0] <= extent2[2] && extent1[2] >= extent2[0] && extent1[1] <= extent2[3] && extent1[3] >= extent2[1];
|
|
}
|
|
function isEmpty(extent) {
|
|
return extent[2] < extent[0] || extent[3] < extent[1];
|
|
}
|
|
function returnOrUpdate(extent, dest) {
|
|
if (dest) {
|
|
dest[0] = extent[0];
|
|
dest[1] = extent[1];
|
|
dest[2] = extent[2];
|
|
dest[3] = extent[3];
|
|
return dest;
|
|
}
|
|
return extent;
|
|
}
|
|
function scaleFromCenter(extent, value) {
|
|
const deltaX = (extent[2] - extent[0]) / 2 * (value - 1);
|
|
const deltaY = (extent[3] - extent[1]) / 2 * (value - 1);
|
|
extent[0] -= deltaX;
|
|
extent[2] += deltaX;
|
|
extent[1] -= deltaY;
|
|
extent[3] += deltaY;
|
|
}
|
|
function intersectsSegment(extent, start, end) {
|
|
let intersects2 = false;
|
|
const startRel = coordinateRelationship(extent, start);
|
|
const endRel = coordinateRelationship(extent, end);
|
|
if (startRel === Relationship_default.INTERSECTING || endRel === Relationship_default.INTERSECTING) {
|
|
intersects2 = true;
|
|
} else {
|
|
const minX = extent[0];
|
|
const minY = extent[1];
|
|
const maxX = extent[2];
|
|
const maxY = extent[3];
|
|
const startX = start[0];
|
|
const startY = start[1];
|
|
const endX = end[0];
|
|
const endY = end[1];
|
|
const slope = (endY - startY) / (endX - startX);
|
|
let x, y;
|
|
if (!!(endRel & Relationship_default.ABOVE) && !(startRel & Relationship_default.ABOVE)) {
|
|
x = endX - (endY - maxY) / slope;
|
|
intersects2 = x >= minX && x <= maxX;
|
|
}
|
|
if (!intersects2 && !!(endRel & Relationship_default.RIGHT) && !(startRel & Relationship_default.RIGHT)) {
|
|
y = endY - (endX - maxX) * slope;
|
|
intersects2 = y >= minY && y <= maxY;
|
|
}
|
|
if (!intersects2 && !!(endRel & Relationship_default.BELOW) && !(startRel & Relationship_default.BELOW)) {
|
|
x = endX - (endY - minY) / slope;
|
|
intersects2 = x >= minX && x <= maxX;
|
|
}
|
|
if (!intersects2 && !!(endRel & Relationship_default.LEFT) && !(startRel & Relationship_default.LEFT)) {
|
|
y = endY - (endX - minX) * slope;
|
|
intersects2 = y >= minY && y <= maxY;
|
|
}
|
|
}
|
|
return intersects2;
|
|
}
|
|
function applyTransform(extent, transformFn, dest, stops) {
|
|
if (isEmpty(extent)) {
|
|
return createOrUpdateEmpty(dest);
|
|
}
|
|
let coordinates = [];
|
|
if (stops > 1) {
|
|
const width = extent[2] - extent[0];
|
|
const height = extent[3] - extent[1];
|
|
for (let i = 0; i < stops; ++i) {
|
|
coordinates.push(
|
|
extent[0] + width * i / stops,
|
|
extent[1],
|
|
extent[2],
|
|
extent[1] + height * i / stops,
|
|
extent[2] - width * i / stops,
|
|
extent[3],
|
|
extent[0],
|
|
extent[3] - height * i / stops
|
|
);
|
|
}
|
|
} else {
|
|
coordinates = [
|
|
extent[0],
|
|
extent[1],
|
|
extent[2],
|
|
extent[1],
|
|
extent[2],
|
|
extent[3],
|
|
extent[0],
|
|
extent[3]
|
|
];
|
|
}
|
|
transformFn(coordinates, coordinates, 2);
|
|
const xs = [];
|
|
const ys = [];
|
|
for (let i = 0, l = coordinates.length; i < l; i += 2) {
|
|
xs.push(coordinates[i]);
|
|
ys.push(coordinates[i + 1]);
|
|
}
|
|
return _boundingExtentXYs(xs, ys, dest);
|
|
}
|
|
function wrapX(extent, projection) {
|
|
const projectionExtent = projection.getExtent();
|
|
const center = getCenter(extent);
|
|
if (projection.canWrapX() && (center[0] < projectionExtent[0] || center[0] >= projectionExtent[2])) {
|
|
const worldWidth = getWidth(projectionExtent);
|
|
const worldsAway = Math.floor(
|
|
(center[0] - projectionExtent[0]) / worldWidth
|
|
);
|
|
const offset = worldsAway * worldWidth;
|
|
extent[0] -= offset;
|
|
extent[2] -= offset;
|
|
}
|
|
return extent;
|
|
}
|
|
function wrapAndSliceX(extent, projection, multiWorld) {
|
|
if (projection.canWrapX()) {
|
|
const projectionExtent = projection.getExtent();
|
|
if (!isFinite(extent[0]) || !isFinite(extent[2])) {
|
|
return [[projectionExtent[0], extent[1], projectionExtent[2], extent[3]]];
|
|
}
|
|
wrapX(extent, projection);
|
|
const worldWidth = getWidth(projectionExtent);
|
|
if (getWidth(extent) > worldWidth && !multiWorld) {
|
|
return [[projectionExtent[0], extent[1], projectionExtent[2], extent[3]]];
|
|
}
|
|
if (extent[0] < projectionExtent[0]) {
|
|
return [
|
|
[extent[0] + worldWidth, extent[1], projectionExtent[2], extent[3]],
|
|
[projectionExtent[0], extent[1], extent[2], extent[3]]
|
|
];
|
|
}
|
|
if (extent[2] > projectionExtent[2]) {
|
|
return [
|
|
[extent[0], extent[1], projectionExtent[2], extent[3]],
|
|
[projectionExtent[0], extent[1], extent[2] - worldWidth, extent[3]]
|
|
];
|
|
}
|
|
}
|
|
return [extent];
|
|
}
|
|
|
|
export {
|
|
Relationship_default,
|
|
boundingExtent,
|
|
buffer,
|
|
clone,
|
|
closestSquaredDistanceXY,
|
|
containsCoordinate,
|
|
containsExtent,
|
|
containsXY,
|
|
coordinateRelationship,
|
|
createEmpty,
|
|
createOrUpdate,
|
|
createOrUpdateEmpty,
|
|
createOrUpdateFromCoordinate,
|
|
createOrUpdateFromCoordinates,
|
|
createOrUpdateFromFlatCoordinates,
|
|
createOrUpdateFromRings,
|
|
equals,
|
|
approximatelyEquals,
|
|
extend,
|
|
extendCoordinate,
|
|
extendCoordinates,
|
|
extendFlatCoordinates,
|
|
extendRings,
|
|
extendXY,
|
|
forEachCorner,
|
|
getArea,
|
|
getBottomLeft,
|
|
getBottomRight,
|
|
getCenter,
|
|
getCorner,
|
|
getEnlargedArea,
|
|
getForViewAndSize,
|
|
getRotatedViewport,
|
|
getHeight,
|
|
getIntersectionArea,
|
|
getIntersection,
|
|
getMargin,
|
|
getSize,
|
|
getTopLeft,
|
|
getTopRight,
|
|
getWidth,
|
|
intersects,
|
|
isEmpty,
|
|
returnOrUpdate,
|
|
scaleFromCenter,
|
|
intersectsSegment,
|
|
applyTransform,
|
|
wrapX,
|
|
wrapAndSliceX
|
|
};
|
|
//# sourceMappingURL=chunk-CKDBVGKM.js.map
|