138 lines
4.2 KiB
JavaScript
138 lines
4.2 KiB
JavaScript
const distancePerDegreeLongitude = 111.320; // 2π×6378.1km/360
|
||
const distancePerDegreeLatitude = 110.574; // 2π×6356.75km/360
|
||
|
||
import * as turf from "@turf/turf";
|
||
import { toMercator, toWgs84 } from '@turf/projection';
|
||
|
||
/**
|
||
* @param {Object} center - The center point of the circle.
|
||
* @param {number} center.x
|
||
* @param {number} center.y
|
||
* @param {number} radius - The radius of the circle.
|
||
* @param {number} density - The number of points used to approximate the circle.
|
||
*
|
||
* @returns {Object} GeoJSON Feature representing the circle polygon.
|
||
*/
|
||
export function getCirclePolygon(center, radius, density = 64) {
|
||
const points = [];
|
||
|
||
const coords = {
|
||
latitude: center[1], // Latitude
|
||
longitude: center[0] // Longitude
|
||
};
|
||
|
||
const distanceX = radius / (distancePerDegreeLongitude * Math.cos(coords.latitude * Math.PI / 180));
|
||
const distanceY = radius / distancePerDegreeLatitude;
|
||
|
||
for (let i = 0; i < density; i++) {
|
||
const angle = (i / density) * Math.PI * 2;
|
||
const x = distanceX * Math.cos(angle);
|
||
const y = distanceY * Math.sin(angle);
|
||
points.push([coords.longitude + x, coords.latitude + y]);
|
||
}
|
||
|
||
// Close the circle by adding the first point again
|
||
points.push(points[0]);
|
||
|
||
return {
|
||
type: "Feature",
|
||
geometry: {
|
||
type: "Polygon",
|
||
coordinates: [points]
|
||
},
|
||
properties: {}
|
||
};
|
||
}
|
||
|
||
function getDistancePerDegreeLongitude(latitude) {
|
||
return 111.320 * Math.cos(latitude * Math.PI / 180);
|
||
}
|
||
|
||
/**
|
||
* @param {Object} center - The center point of the rectangle.
|
||
* @param {number} center.x
|
||
* @param {number} center.y
|
||
* @param {number} sideA - The length of the first side of the rectangle.
|
||
* @param {number} sideB - The length of the second side of the rectangle.
|
||
* @param {number} rotation - The angle (in radians) by which to rotate the rectangle.
|
||
*
|
||
* @returns {Object} GeoJSON Feature representing the rectangle polygon.
|
||
*/
|
||
export function getRectanglePolygon(center, width, height, rotation = 0) {
|
||
const widthMeters = width * 1000 ;
|
||
const heightMeters = height * 1000;
|
||
|
||
// 1. Střed převedeme do metrického systému (Web Mercator)
|
||
const centerMerc = toMercator(turf.point(center)).geometry.coordinates;
|
||
|
||
// 2. Vypočítáme rohy čtverce v metrech
|
||
const halfWidth = widthMeters / 2;
|
||
const halfHeight = heightMeters / 2;
|
||
|
||
let corners = [
|
||
[centerMerc[0] - halfWidth, centerMerc[1] + halfHeight], // topLeft
|
||
[centerMerc[0] + halfWidth, centerMerc[1] + halfHeight], // topRight
|
||
[centerMerc[0] + halfWidth, centerMerc[1] - halfHeight], // bottomRight
|
||
[centerMerc[0] - halfWidth, centerMerc[1] - halfHeight], // bottomLeft
|
||
];
|
||
|
||
// 3. Otočení (volitelně)
|
||
if (rotation !== 0) {
|
||
const rad = (rotation * Math.PI) / 180;
|
||
corners = corners.map(([x, y]) => rotateXY(x, y, centerMerc[0], centerMerc[1], rad));
|
||
}
|
||
|
||
// 4. Uzavřeme polygon a převedeme zpět do WGS84
|
||
corners.push(corners[0]);
|
||
const wgsCoords = corners.map(([x, y]) => toWgs84([x, y]));
|
||
|
||
return turf.polygon([wgsCoords]);
|
||
}
|
||
|
||
function rotateXY(x, y, cx, cy, angleRad) {
|
||
const dx = x - cx;
|
||
const dy = y - cy;
|
||
const cos = Math.cos(angleRad);
|
||
const sin = Math.sin(angleRad);
|
||
const rx = cx + dx * cos - dy * sin;
|
||
const ry = cy + dx * sin + dy * cos;
|
||
return [rx, ry];
|
||
}
|
||
/*
|
||
const [lon, lat] = center;
|
||
|
||
// Přepočet metrů na stupně:
|
||
const degLat = height / distancePerDegreeLatitude / 2;
|
||
const degLon = width / (distancePerDegreeLongitude * Math.cos(lat * Math.PI / 180)) / 2;
|
||
|
||
// Rohy bez rotace (v relative souřadnicích)
|
||
const corners = [
|
||
[-degLon, -degLat],
|
||
[ degLon, -degLat],
|
||
[ degLon, degLat],
|
||
[-degLon, degLat]
|
||
];
|
||
|
||
// Rotace a posun
|
||
const rotated = corners.map(([dx, dy]) => {
|
||
const x = dx;
|
||
const y = dy;
|
||
|
||
const rotatedX = x * Math.cos(rotation) - y * Math.sin(rotation);
|
||
const rotatedY = x * Math.sin(rotation) + y * Math.cos(rotation);
|
||
|
||
return [lon + rotatedX, lat + rotatedY];
|
||
});
|
||
|
||
// Uzavření polygonu
|
||
rotated.push(rotated[0]);
|
||
|
||
return {
|
||
type: "Feature",
|
||
geometry: {
|
||
type: "Polygon",
|
||
coordinates: [rotated]
|
||
},
|
||
properties: {}
|
||
};*/
|