@sakuzu/maplibre-gl-draw 1.0.0

package/dist/shared/math/intersection.js

@@ -0,0 +1,236 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Tests whether a point is inside a rectangle
+ */
+export function pointInRectangle(point, rect) {
+    return (point[0] >= rect.minX && point[0] <= rect.maxX && point[1] >= rect.minY && point[1] <= rect.maxY);
+}
+/**
+ * Intersection test between two segments
+ *
+ * Uses the CCW (Counter-Clockwise) algorithm.
+ */
+export function segmentIntersectsSegment(a1, a2, b1, b2) {
+    // CCW test function
+    const ccw = (p1, p2, p3) => {
+        return (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0]);
+    };
+    const d1 = ccw(a1, a2, b1);
+    const d2 = ccw(a1, a2, b2);
+    const d3 = ccw(b1, b2, a1);
+    const d4 = ccw(b1, b2, a2);
+    // Condition under which the segments intersect
+    if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0))) {
+        return true;
+    }
+    // When an endpoint lies on the other segment
+    const onSegment = (p, q, r) => {
+        return (q[0] <= Math.max(p[0], r[0]) &&
+            q[0] >= Math.min(p[0], r[0]) &&
+            q[1] <= Math.max(p[1], r[1]) &&
+            q[1] >= Math.min(p[1], r[1]));
+    };
+    if (d1 === 0 && onSegment(a1, b1, a2))
+        return true;
+    if (d2 === 0 && onSegment(a1, b2, a2))
+        return true;
+    if (d3 === 0 && onSegment(b1, a1, b2))
+        return true;
+    if (d4 === 0 && onSegment(b1, a2, b2))
+        return true;
+    return false;
+}
+/**
+ * Tests whether a segment intersects a rectangle
+ */
+export function segmentIntersectsRectangle(p1, p2, rect) {
+    // When either endpoint is inside the rectangle
+    if (pointInRectangle(p1, rect) || pointInRectangle(p2, rect)) {
+        return true;
+    }
+    // Intersection test against the 4 edges of the rectangle
+    const corners = [
+        [rect.minX, rect.minY],
+        [rect.maxX, rect.minY],
+        [rect.maxX, rect.maxY],
+        [rect.minX, rect.maxY],
+    ];
+    for (let i = 0; i < 4; i++) {
+        const j = (i + 1) % 4;
+        if (segmentIntersectsSegment(p1, p2, corners[i], corners[j])) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Intersection test between a rectangle and a LineString
+ *
+ * Returns true when any vertex of the LineString is inside the rectangle, or when any of its
+ * edges intersects the rectangle.
+ */
+export function rectangleIntersectsLineString(rect, lineString) {
+    if (lineString.length === 0)
+        return false;
+    // When any vertex is inside the rectangle
+    for (const coord of lineString) {
+        if (pointInRectangle(coord, rect)) {
+            return true;
+        }
+    }
+    // When any edge intersects the rectangle
+    for (let i = 0; i < lineString.length - 1; i++) {
+        if (segmentIntersectsRectangle(lineString[i], lineString[i + 1], rect)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Tests whether a point is inside a polygon (Ray Casting algorithm)
+ */
+function pointInPolygon(point, ring) {
+    let inside = false;
+    const x = point[0];
+    const y = point[1];
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const xi = ring[i][0];
+        const yi = ring[i][1];
+        const xj = ring[j][0];
+        const yj = ring[j][1];
+        if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+/**
+ * Intersection test between a rectangle and a Polygon
+ *
+ * Returns true when any of the following conditions holds:
+ * 1. Any vertex of the polygon is inside the rectangle
+ * 2. Any vertex of the rectangle is inside the polygon
+ * 3. Any edge of the polygon intersects the rectangle
+ */
+export function rectangleIntersectsPolygon(rect, polygon) {
+    if (polygon.length === 0 || polygon[0].length === 0)
+        return false;
+    const outerRing = polygon[0];
+    // 1. Any vertex of the polygon is inside the rectangle
+    for (const coord of outerRing) {
+        if (pointInRectangle(coord, rect)) {
+            return true;
+        }
+    }
+    // 2. Any vertex of the rectangle is inside the polygon
+    const rectCorners = [
+        [rect.minX, rect.minY],
+        [rect.maxX, rect.minY],
+        [rect.maxX, rect.maxY],
+        [rect.minX, rect.maxY],
+    ];
+    for (const corner of rectCorners) {
+        if (pointInPolygon(corner, outerRing)) {
+            return true;
+        }
+    }
+    // 3. Any edge of the polygon intersects the rectangle
+    for (let i = 0; i < outerRing.length - 1; i++) {
+        if (segmentIntersectsRectangle(outerRing[i], outerRing[i + 1], rect)) {
+            return true;
+        }
+    }
+    // The edge that joins the last vertex to the first vertex
+    if (outerRing.length > 1 &&
+        segmentIntersectsRectangle(outerRing[outerRing.length - 1], outerRing[0], rect)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Intersection test between a rectangle and a Circle
+ *
+ * Returns true when the center of the circle is inside the rectangle, or when an edge or a
+ * vertex of the rectangle intersects the circle.
+ *
+ * @param rect Selection rectangle (geographic coordinates)
+ * @param center Center of the circle (geographic coordinates)
+ * @param radiusInDegrees Radius of the circle (in degrees)
+ */
+export function rectangleIntersectsCircle(rect, center, radiusInDegrees) {
+    // When the center of the circle is inside the rectangle
+    if (pointInRectangle(center, rect)) {
+        return true;
+    }
+    // Compute the closest point of the rectangle
+    const closestX = Math.max(rect.minX, Math.min(center[0], rect.maxX));
+    const closestY = Math.max(rect.minY, Math.min(center[1], rect.maxY));
+    // Compute the distance between the closest point and the center of the circle
+    const dx = center[0] - closestX;
+    const dy = center[1] - closestY;
+    const distanceSquared = dx * dx + dy * dy;
+    // They intersect if the distance is at most the radius
+    return distanceSquared <= radiusInDegrees * radiusInDegrees;
+}
+/**
+ * Intersection test between an AABB and an OBB (Separating Axis Theorem: SAT)
+ *
+ * @param rect Axis-aligned bounding box (AABB)
+ * @param obb Bounding box that accounts for rotation (OBB)
+ */
+export function rectangleIntersectsOBB(rect, obb) {
+    if (obb.corners.length !== 4)
+        return false;
+    // Convert the AABB into an array of vertices
+    const rectCorners = [
+        [rect.minX, rect.minY],
+        [rect.maxX, rect.minY],
+        [rect.maxX, rect.maxY],
+        [rect.minX, rect.maxY],
+    ];
+    // Get the separating axes (the 2 axes of the AABB + the 2 axes of the OBB)
+    const axes = [
+        // Axes of the AABB (always the X axis and the Y axis)
+        [1, 0],
+        [0, 1],
+        // Axes of the OBB (derived from its edges)
+        normalize([obb.corners[1][0] - obb.corners[0][0], obb.corners[1][1] - obb.corners[0][1]]),
+        normalize([obb.corners[3][0] - obb.corners[0][0], obb.corners[3][1] - obb.corners[0][1]]),
+    ];
+    // Check for separation along each axis
+    for (const axis of axes) {
+        const [minA, maxA] = projectPolygon(rectCorners, axis);
+        const [minB, maxB] = projectPolygon(obb.corners, axis);
+        // When the projections do not overlap, a separating axis has been found
+        if (maxA < minB || maxB < minA) {
+            return false;
+        }
+    }
+    // When they overlap on every axis, they intersect
+    return true;
+}
+/**
+ * Normalizes a vector
+ */
+function normalize(v) {
+    const len = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+    if (len === 0)
+        return [1, 0];
+    return [v[0] / len, v[1] / len];
+}
+/**
+ * Projects a polygon onto an axis and returns the minimum and maximum values
+ */
+function projectPolygon(corners, axis) {
+    let min = corners[0][0] * axis[0] + corners[0][1] * axis[1];
+    let max = min;
+    for (let i = 1; i < corners.length; i++) {
+        const p = corners[i][0] * axis[0] + corners[i][1] * axis[1];
+        if (p < min)
+            min = p;
+        if (p > max)
+            max = p;
+    }
+    return [min, max];
+}

package/dist/shared/math/longitude.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Longitude wrapping
+ *
+ * The longitude arithmetic that the rendering, the hit testing and the snapping share, so
+ * that all of them pick the same copy of the world.
+ */
+/**
+ * Brings a longitude into [-180, 180] (a longitude already inside is returned unchanged)
+ */
+export declare function wrapLongitude(lng: number): number;
+/**
+ * The copy of a longitude nearest to a reference longitude
+ *
+ * A longitude within 180 degrees of the reference is returned unchanged (so nothing moves
+ * away from the antimeridian); otherwise it is moved by whole turns. This is the choice the
+ * rendering makes for a feature near the view: it is drawn on the copy of the world the view
+ * shows, which is the copy nearest to the camera. Hit testing and snapping use it around the
+ * pointer so that they meet the copy that is drawn.
+ */
+export declare function nearestLongitude(lng: number, reference: number): number;

package/dist/shared/math/longitude.js

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Longitude wrapping
+ *
+ * The longitude arithmetic that the rendering, the hit testing and the snapping share, so
+ * that all of them pick the same copy of the world.
+ */
+/**
+ * Brings a longitude into [-180, 180] (a longitude already inside is returned unchanged)
+ */
+export function wrapLongitude(lng) {
+    if (lng >= -180 && lng <= 180)
+        return lng;
+    return lng - 360 * Math.round(lng / 360);
+}
+/**
+ * The copy of a longitude nearest to a reference longitude
+ *
+ * A longitude within 180 degrees of the reference is returned unchanged (so nothing moves
+ * away from the antimeridian); otherwise it is moved by whole turns. This is the choice the
+ * rendering makes for a feature near the view: it is drawn on the copy of the world the view
+ * shows, which is the copy nearest to the camera. Hit testing and snapping use it around the
+ * pointer so that they meet the copy that is drawn.
+ */
+export function nearestLongitude(lng, reference) {
+    const delta = lng - reference;
+    if (delta >= -180 && delta <= 180)
+        return lng;
+    return lng - 360 * Math.round(delta / 360);
+}

package/dist/shared/math/mercator-plane.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The plane the transform operations work in
+ *
+ * Resize and rotate compute in Web Mercator, the plane the map is drawn in, so a transform
+ * does on the map what the pointer does on the screen (at any latitude and size, with no
+ * local cos φ approximation that changes the shape a little on every rotation). The plane is
+ * maplibre's world coordinate (0 to 1 across the world) with y pointing north, so an angle
+ * measured in it is counterclockwise like the old lng/lat angle. Longitude is linear and not
+ * wrapped. Latitude is clamped to the Web Mercator limit (±85.051129 degrees), beyond which
+ * the map draws nothing and the projection reaches infinity at the poles.
+ */
+import type { Coordinate } from '../types/model.js';
+/**
+ * Converts a longitude/latitude into the transform plane
+ *
+ * @param coord [lng, lat]
+ * @returns [x, y] in world units (1 = the width of the world), y pointing north
+ */
+export declare function toPlane(coord: Coordinate): [number, number];
+/**
+ * Converts a point of the transform plane back into a longitude/latitude
+ *
+ * @param x World units east
+ * @param y World units north
+ * @returns [lng, lat]
+ */
+export declare function fromPlane(x: number, y: number): Coordinate;

package/dist/shared/math/mercator-plane.js

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/** The latitude limit of Web Mercator (degrees) */
+const MAX_MERCATOR_LATITUDE = 85.0511287798066;
+/**
+ * Converts a longitude/latitude into the transform plane
+ *
+ * @param coord [lng, lat]
+ * @returns [x, y] in world units (1 = the width of the world), y pointing north
+ */
+export function toPlane(coord) {
+    const lat = Math.max(-MAX_MERCATOR_LATITUDE, Math.min(MAX_MERCATOR_LATITUDE, coord[1]));
+    const phi = (lat * Math.PI) / 180;
+    return [coord[0] / 360, Math.log(Math.tan(Math.PI / 4 + phi / 2)) / (2 * Math.PI)];
+}
+/**
+ * Converts a point of the transform plane back into a longitude/latitude
+ *
+ * @param x World units east
+ * @param y World units north
+ * @returns [lng, lat]
+ */
+export function fromPlane(x, y) {
+    const lat = (2 * Math.atan(Math.exp(y * 2 * Math.PI)) - Math.PI / 2) * (180 / Math.PI);
+    return [x * 360, lat];
+}

package/dist/shared/math/obb.d.ts

@@ -0,0 +1,65 @@
+/**
+ * OBB (Oriented Bounding Box)
+ *
+ * Computation and hit testing of a bounding box that includes rotation.
+ */
+import type { Coordinate } from '../types/model.js';
+/**
+ * Definition of an OBB
+ */
+export interface OBB {
+    /** The center [lng, lat] */
+    center: Coordinate;
+    /** Half the width, in degrees */
+    halfWidth: number;
+    /** Half the height, in degrees */
+    halfHeight: number;
+    /** The rotation angle, in radians */
+    rotation: number;
+}
+/**
+ * Creates an OBB
+ *
+ * @param centerLng Center longitude
+ * @param centerLat Center latitude
+ * @param width Width (degrees)
+ * @param height Height (degrees)
+ * @param rotationDeg Rotation angle (degrees, counter-clockwise)
+ * @returns OBB
+ */
+export declare function createOBB(centerLng: number, centerLat: number, width: number, height: number, rotationDeg: number): OBB;
+/**
+ * Tests whether a point is inside an OBB
+ *
+ * @param obb OBB
+ * @param point The point to test [lng, lat]
+ * @returns true when it is inside the OBB
+ */
+export declare function pointInOBB(obb: OBB, point: Coordinate): boolean;
+/**
+ * Computes the distance from a point to an OBB
+ *
+ * @param obb OBB
+ * @param point Point [lng, lat]
+ * @returns Distance (degrees). 0 when inside the OBB
+ */
+export declare function distanceToOBB(obb: OBB, point: Coordinate): number;
+/**
+ * Gets the 4 vertices of an OBB
+ *
+ * @param obb OBB
+ * @returns Array of the 4 vertices [topLeft, topRight, bottomRight, bottomLeft]
+ */
+export declare function getOBBCorners(obb: OBB): Coordinate[];
+/**
+ * Gets the AABB (Axis-Aligned Bounding Box) of an OBB
+ *
+ * @param obb OBB
+ * @returns AABB { minX, minY, maxX, maxY }
+ */
+export declare function getOBBAABB(obb: OBB): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};

package/dist/shared/math/obb.js

@@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Creates an OBB
+ *
+ * @param centerLng Center longitude
+ * @param centerLat Center latitude
+ * @param width Width (degrees)
+ * @param height Height (degrees)
+ * @param rotationDeg Rotation angle (degrees, counter-clockwise)
+ * @returns OBB
+ */
+export function createOBB(centerLng, centerLat, width, height, rotationDeg) {
+    return {
+        center: [centerLng, centerLat],
+        halfWidth: width / 2,
+        halfHeight: height / 2,
+        rotation: (rotationDeg * Math.PI) / 180,
+    };
+}
+/**
+ * Tests whether a point is inside an OBB
+ *
+ * @param obb OBB
+ * @param point The point to test [lng, lat]
+ * @returns true when it is inside the OBB
+ */
+export function pointInOBB(obb, point) {
+    // Convert the point into the local coordinate system of the OBB
+    const dx = point[0] - obb.center[0];
+    const dy = point[1] - obb.center[1];
+    // Apply the inverse rotation
+    const cos = Math.cos(-obb.rotation);
+    const sin = Math.sin(-obb.rotation);
+    const localX = dx * cos - dy * sin;
+    const localY = dx * sin + dy * cos;
+    // AABB test in the local coordinate system
+    return Math.abs(localX) <= obb.halfWidth && Math.abs(localY) <= obb.halfHeight;
+}
+/**
+ * Computes the distance from a point to an OBB
+ *
+ * @param obb OBB
+ * @param point Point [lng, lat]
+ * @returns Distance (degrees). 0 when inside the OBB
+ */
+export function distanceToOBB(obb, point) {
+    // Convert the point into the local coordinate system of the OBB
+    const dx = point[0] - obb.center[0];
+    const dy = point[1] - obb.center[1];
+    // Apply the inverse rotation
+    const cos = Math.cos(-obb.rotation);
+    const sin = Math.sin(-obb.rotation);
+    const localX = dx * cos - dy * sin;
+    const localY = dx * sin + dy * cos;
+    // 0 when inside the OBB
+    if (Math.abs(localX) <= obb.halfWidth && Math.abs(localY) <= obb.halfHeight) {
+        return 0;
+    }
+    // Compute the closest point
+    const clampedX = Math.max(-obb.halfWidth, Math.min(obb.halfWidth, localX));
+    const clampedY = Math.max(-obb.halfHeight, Math.min(obb.halfHeight, localY));
+    // Compute the distance
+    const distX = localX - clampedX;
+    const distY = localY - clampedY;
+    return Math.sqrt(distX * distX + distY * distY);
+}
+/**
+ * Gets the 4 vertices of an OBB
+ *
+ * @param obb OBB
+ * @returns Array of the 4 vertices [topLeft, topRight, bottomRight, bottomLeft]
+ */
+export function getOBBCorners(obb) {
+    const cos = Math.cos(obb.rotation);
+    const sin = Math.sin(obb.rotation);
+    // The 4 vertices in the local coordinate system
+    const corners = [
+        [-obb.halfWidth, -obb.halfHeight], // top-left
+        [obb.halfWidth, -obb.halfHeight], // top-right
+        [obb.halfWidth, obb.halfHeight], // bottom-right
+        [-obb.halfWidth, obb.halfHeight], // bottom-left
+    ];
+    // Apply the rotation and convert into global coordinates
+    return corners.map(([x, y]) => {
+        const rx = x * cos - y * sin;
+        const ry = x * sin + y * cos;
+        return [obb.center[0] + rx, obb.center[1] + ry];
+    });
+}
+/**
+ * Gets the AABB (Axis-Aligned Bounding Box) of an OBB
+ *
+ * @param obb OBB
+ * @returns AABB { minX, minY, maxX, maxY }
+ */
+export function getOBBAABB(obb) {
+    const corners = getOBBCorners(obb);
+    const lngs = corners.map((c) => c[0]);
+    const lats = corners.map((c) => c[1]);
+    return {
+        minX: Math.min(...lngs),
+        minY: Math.min(...lats),
+        maxX: Math.max(...lngs),
+        maxY: Math.max(...lats),
+    };
+}

package/dist/shared/math/rotation.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Spherical rotation utilities (ECEF coordinate system)
+ *
+ * Provides rotation computation in the ECEF coordinate system, accounting for the WGS84
+ * ellipsoid.
+ *
+ * Implemented with standard geodetic computation: Rodrigues' rotation formula and the ECEF
+ * conversion on the WGS84 ellipsoid (the inverse conversion uses Bowring's method).
+ */
+import type { Coordinate } from '../types/model.js';
+/**
+ * ECEF coordinate (3D Cartesian coordinate)
+ */
+interface ECEFCoordinate {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Converts a WGS84 coordinate into an ECEF coordinate (accounting for the ellipsoid)
+ *
+ * @param coord WGS84 coordinate [lng, lat]
+ * @returns ECEF coordinate {x, y, z} (in meters)
+ */
+export declare function wgs84ToECEF(coord: Coordinate): ECEFCoordinate;
+/**
+ * Converts an ECEF coordinate into a WGS84 coordinate (iterative computation by Bowring's
+ * method)
+ *
+ * @param x ECEF X coordinate (meters)
+ * @param y ECEF Y coordinate (meters)
+ * @param z ECEF Z coordinate (meters)
+ * @returns WGS84 coordinate [lng, lat]
+ */
+export declare function ecefToWGS84(x: number, y: number, z: number): Coordinate;
+/**
+ * Rotates a single coordinate about the center point as the axis (ECEF coordinate system,
+ * Rodrigues' formula)
+ *
+ * @param coord The coordinate to rotate [lng, lat]
+ * @param center Center point of the rotation [lng, lat]
+ * @param angleDegrees Rotation angle (degrees, counter-clockwise)
+ * @returns The coordinate after rotation [lng, lat]
+ */
+export declare function rotateCoordinateOnSphere(coord: Coordinate, center: Coordinate, angleDegrees: number): Coordinate;
+/**
+ * Rotates multiple coordinates about the center point as the axis (ECEF coordinate system,
+ * Rodrigues' formula)
+ *
+ * @param coords Array of coordinates to rotate
+ * @param center Center point of the rotation [lng, lat]
+ * @param angleDegrees Rotation angle (degrees, counter-clockwise)
+ * @returns Array of coordinates after rotation
+ */
+export declare function rotateCoordinatesOnSphere(coords: readonly Coordinate[], center: Coordinate, angleDegrees: number): Coordinate[];
+/**
+ * Converts kilometers into degrees (with a latitude correction)
+ *
+ * @param km Distance (kilometers)
+ * @param latitude Reference latitude
+ * @returns Degrees
+ */
+export declare function kmToDegrees(km: number, latitude: number): number;
+/**
+ * Converts pixels into degrees (with a latitude correction)
+ *
+ * @param pixels Number of pixels
+ * @param latitude Reference latitude
+ * @param zoom Zoom level
+ * @param tileSize Tile size (default 512)
+ * @returns Degrees
+ */
+export declare function pixelsToDegrees(pixels: number, latitude: number, zoom: number, tileSize?: number): {
+    lngDegrees: number;
+    latDegrees: number;
+};
+/**
+ * Computes the vertices of a quad with a rotation applied (uses spherical rotation)
+ *
+ * @param centerLng Center longitude
+ * @param centerLat Center latitude
+ * @param halfWidthDeg Half width (degrees) - in the longitude direction
+ * @param halfHeightDeg Half height (degrees) - in the latitude direction
+ * @param rotationDeg Rotation angle (degrees, counter-clockwise)
+ * @returns The 4 vertices of the quad [topLeft, topRight, bottomLeft, bottomRight]
+ */
+export declare function computeRotatedQuadCorners(centerLng: number, centerLat: number, halfWidthDeg: number, halfHeightDeg: number, rotationDeg: number): {
+    topLeft: Coordinate;
+    topRight: Coordinate;
+    bottomLeft: Coordinate;
+    bottomRight: Coordinate;
+};
+export {};