200 lines
7.2 KiB
TypeScript
200 lines
7.2 KiB
TypeScript
import { test, expect } from '@playwright/test';
|
|
import {
|
|
computeBoundingBox,
|
|
boundingBoxRing,
|
|
type BoundingBox,
|
|
} from '../../src/lib/domain/boundingBox';
|
|
import type { LatLngTuple } from '../../src/lib/domain/geo';
|
|
|
|
/**
|
|
* The restricted area filed with the regulator.
|
|
*
|
|
* It is a rectangle in kilometres, axis-aligned to east/north at its own centre,
|
|
* with four lat/lon corners joined by great circles. Not a rectangle in degrees:
|
|
* that form cannot work near a pole, because every meridian passes through the
|
|
* pole, so any lat/lon rectangle containing one spans all 360 deg of longitude.
|
|
* The measured cost of that was a 44 200 km^2 cap standing in for a 1 695 km^2
|
|
* corridor.
|
|
*
|
|
* These tests run in Node, not a browser — the module under test is pure
|
|
* geometry and imports only a type.
|
|
*/
|
|
|
|
const R_KM = 6371;
|
|
const rad = (d: number) => (d * Math.PI) / 180;
|
|
const deg = (r: number) => (r * 180) / Math.PI;
|
|
|
|
/**
|
|
* Standard spherical destination-point formula, written out here rather than
|
|
* imported so the tests do not check the implementation against itself.
|
|
* Undefined starting exactly at a pole, which is why the polar cases use 89.99.
|
|
*/
|
|
function destination(lat: number, lng: number, bearingDeg: number, distKm: number): LatLngTuple {
|
|
const d = distKm / R_KM;
|
|
const br = rad(bearingDeg);
|
|
const p1 = rad(lat);
|
|
const l1 = rad(lng);
|
|
const p2 = Math.asin(Math.sin(p1) * Math.cos(d) + Math.cos(p1) * Math.sin(d) * Math.cos(br));
|
|
const l2 =
|
|
l1 +
|
|
Math.atan2(Math.sin(br) * Math.sin(d) * Math.cos(p1), Math.cos(d) - Math.sin(p1) * Math.sin(p2));
|
|
return [deg(p2), deg(l2)];
|
|
}
|
|
|
|
/** A straight meridional track: identical in kilometres at any latitude. */
|
|
function meridionalTrack(lat: number, lng: number, lengthKm: number, n = 40): LatLngTuple[] {
|
|
return Array.from({ length: n }, (_, i) => destination(lat, lng, 180, (lengthKm * i) / (n - 1)));
|
|
}
|
|
|
|
function toVec([lat, lng]: LatLngTuple): [number, number, number] {
|
|
const p = rad(lat);
|
|
const l = rad(lng);
|
|
return [Math.cos(p) * Math.cos(l), Math.cos(p) * Math.sin(l), Math.sin(p)];
|
|
}
|
|
|
|
const dot = (a: number[], b: number[]) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
|
const cross = (a: number[], b: number[]): [number, number, number] => [
|
|
a[1] * b[2] - a[2] * b[1],
|
|
a[2] * b[0] - a[0] * b[2],
|
|
a[0] * b[1] - a[1] * b[0],
|
|
];
|
|
|
|
/**
|
|
* Signed clearance in km from a point to the great circle through two corners,
|
|
* positive on the side the box interior is on.
|
|
*
|
|
* This is measured against the edge the regulator would draw — the great circle
|
|
* between the filed corners — not against the projected rectangle. The two are
|
|
* not the same: a great-circle edge bows toward the centre of the box relative
|
|
* to its chord in the projection, by roughly (half-edge)^2 / 2R. On a 500 km
|
|
* edge that is 4.9 km, so it silently eats a 5 km margin whole.
|
|
*/
|
|
function clearanceKm(point: LatLngTuple, from: LatLngTuple, to: LatLngTuple, inside: LatLngTuple) {
|
|
const n = cross(toVec(from), toVec(to));
|
|
const len = Math.hypot(...n) || 1;
|
|
const unit = n.map((c) => c / len);
|
|
const sign = Math.sign(dot(unit, toVec(inside))) || 1;
|
|
return sign * Math.asin(Math.max(-1, Math.min(1, dot(unit, toVec(point))))) * R_KM;
|
|
}
|
|
|
|
/** Smallest clearance from any track point to any of the four filed edges. */
|
|
function worstClearanceKm(box: BoundingBox, path: LatLngTuple[]): number {
|
|
const c = box.corners;
|
|
const edges: [LatLngTuple, LatLngTuple][] = [
|
|
[c[0], c[1]],
|
|
[c[1], c[2]],
|
|
[c[2], c[3]],
|
|
[c[3], c[0]],
|
|
];
|
|
let worst = Infinity;
|
|
for (const p of path) {
|
|
for (const [a, b] of edges) {
|
|
const d = clearanceKm(p, a, b, box.centre);
|
|
if (d < worst) worst = d;
|
|
}
|
|
}
|
|
return worst;
|
|
}
|
|
|
|
/** Spherical excess area of the filed quad, km^2. */
|
|
function areaKm2(box: BoundingBox): number {
|
|
const v = box.corners.map(toVec);
|
|
let sum = 0;
|
|
for (let i = 0; i < 4; i++) {
|
|
// Interior angle at vertex i, between the planes of its two edges.
|
|
const prev = v[(i + 3) % 4];
|
|
const next = v[(i + 1) % 4];
|
|
const n1 = cross(v[i], prev);
|
|
const n2 = cross(v[i], next);
|
|
const l1 = Math.hypot(...n1) || 1;
|
|
const l2 = Math.hypot(...n2) || 1;
|
|
sum += Math.acos(Math.max(-1, Math.min(1, -dot(n1, n2) / (l1 * l2))));
|
|
}
|
|
return (sum - 2 * Math.PI) * R_KM * R_KM;
|
|
}
|
|
|
|
/**
|
|
* The real trajectory from a launch at 89.99 N, 0 E, decimated. Under the old
|
|
* lat/lon-rectangle form this produced south 88.93, north 90, west -180,
|
|
* east 180: the entire cap, 44 200 km^2. In 1 degree of latitude it sweeps
|
|
* 79 degrees of longitude, because near a pole a short displacement crosses
|
|
* many meridians.
|
|
*/
|
|
const POLAR_TRACK: LatLngTuple[] = [
|
|
[89.99, 0],
|
|
[89.9564, 60.5627],
|
|
[89.8954, 70.1192],
|
|
[89.8095, 73.9615],
|
|
[89.6924, 76.1248],
|
|
[89.563, 77.1293],
|
|
[89.494, 77.2284],
|
|
[89.4553, 77.0498],
|
|
[89.4281, 76.8977],
|
|
[89.4109, 76.7301],
|
|
[89.3981, 76.6866],
|
|
[89.388, 76.9395],
|
|
[89.3823, 77.663],
|
|
[89.3771, 78.6642],
|
|
[89.3748, 79.0682],
|
|
[89.3736, 79.2029],
|
|
[89.3589, 79.2173],
|
|
[89.3177, 78.9415],
|
|
[89.2028, 78.9972],
|
|
[89.0974, 79.125],
|
|
[89.0269, 79.0071],
|
|
[88.9812, 78.8571],
|
|
[88.9782, 78.8563],
|
|
];
|
|
|
|
const MARGIN = 5;
|
|
|
|
test('every trajectory point clears the filed edges by the full margin', () => {
|
|
// 500 km is where the great-circle bow matters: the east and west edges span
|
|
// +-255 km, and a chord-to-arc sag of 255^2/2R = 5.1 km would consume the
|
|
// entire 5 km margin and put the edge inside the trajectory.
|
|
const path = meridionalTrack(52.2, 0.1, 500);
|
|
const box = computeBoundingBox(path, MARGIN);
|
|
|
|
expect(box).not.toBeNull();
|
|
expect(worstClearanceKm(box!, path)).toBeGreaterThanOrEqual(MARGIN - 0.01);
|
|
});
|
|
|
|
test('every trajectory point clears the filed edges by the full margin near the pole', () => {
|
|
const box = computeBoundingBox(POLAR_TRACK, MARGIN);
|
|
|
|
expect(box).not.toBeNull();
|
|
expect(worstClearanceKm(box!, POLAR_TRACK)).toBeGreaterThanOrEqual(MARGIN - 0.01);
|
|
});
|
|
|
|
test('a box at the pole covers the corridor, not the whole polar cap', () => {
|
|
const box = computeBoundingBox(POLAR_TRACK, MARGIN);
|
|
|
|
// The lat/lon rectangle gave 44 200 km^2 for this track. The corridor it
|
|
// actually flies is 13.7 x 123.4 km.
|
|
expect(areaKm2(box!)).toBeLessThan(3000);
|
|
});
|
|
|
|
test('the same track in kilometres gives the same box at 52 N and at 89.99 N', () => {
|
|
// A meridional track is the one shape whose kilometre extent is independent
|
|
// of latitude, so any difference here is the code treating a pole specially.
|
|
const mid = computeBoundingBox(meridionalTrack(52.2, 0.1, 120), MARGIN)!;
|
|
const polar = computeBoundingBox(meridionalTrack(89.99, 0, 120), MARGIN)!;
|
|
|
|
expect(polar.heightKm).toBeCloseTo(mid.heightKm, 1);
|
|
expect(polar.widthKm).toBeCloseTo(mid.widthKm, 1);
|
|
});
|
|
|
|
test('the drawn ring closes and never spans the antimeridian in one segment', () => {
|
|
// Cesium cuts geometry at the IDL; a single segment straddling it with
|
|
// degenerate endpoints is what stopped the render loop before. Dense samples
|
|
// along each edge keep every segment short and the drawn shape equal to the
|
|
// filed one.
|
|
const ring = boundingBoxRing(computeBoundingBox(POLAR_TRACK, MARGIN)!);
|
|
|
|
expect(ring.length).toBeGreaterThan(16);
|
|
expect(ring[0]).toEqual(ring[ring.length - 1]);
|
|
for (let i = 1; i < ring.length; i++) {
|
|
const step = Math.abs(ring[i][1] - ring[i - 1][1]);
|
|
expect(Math.min(step, 360 - step)).toBeLessThan(90);
|
|
}
|
|
});
|