325 lines
14 KiB
JavaScript
325 lines
14 KiB
JavaScript
'use strict';
|
|
|
|
const { stationAtDistanceFrom } = require('./junction-build-plan');
|
|
|
|
function pointAtStation(line, station, helpers) {
|
|
let remaining = Math.max(0, station);
|
|
for (let index = 1; index < line.length; index += 1) {
|
|
const length = helpers.distanceMeters(line[index - 1], line[index]);
|
|
if (remaining <= length) {
|
|
const ratio = length ? remaining / length : 0;
|
|
return [
|
|
line[index - 1][0] + (line[index][0] - line[index - 1][0]) * ratio,
|
|
line[index - 1][1] + (line[index][1] - line[index - 1][1]) * ratio,
|
|
];
|
|
}
|
|
remaining -= length;
|
|
}
|
|
return line.at(-1) || null;
|
|
}
|
|
|
|
function tangentAtStation(line, station, helpers) {
|
|
let walked = 0;
|
|
for (let index = 1; index < line.length; index += 1) {
|
|
const length = helpers.distanceMeters(line[index - 1], line[index]);
|
|
if (station <= walked + length || index === line.length - 1)
|
|
return helpers.headingAtEndpoint([line[index - 1], line[index]]);
|
|
walked += length;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function offsetCoordinate(point, heading, meters) {
|
|
if (!point || !Number.isFinite(heading)) return null;
|
|
const radians = (heading * Math.PI) / 180;
|
|
const lonMeters = 111320 * Math.cos((point[1] * Math.PI) / 180);
|
|
return [
|
|
point[0] + (Math.sin(radians) * meters) / Math.max(lonMeters, 1e-9),
|
|
point[1] + (Math.cos(radians) * meters) / 111320,
|
|
];
|
|
}
|
|
|
|
function sectionAt(item, radius, center, widthMeters, helpers, explicitStation, edgeOffsets = null) {
|
|
const station = Math.max(
|
|
0,
|
|
Math.min(item.length, explicitStation ?? stationAtDistanceFrom(item.approach.line, center, radius, helpers)),
|
|
);
|
|
const point = pointAtStation(item.approach.line, station, helpers);
|
|
const tangent = tangentAtStation(item.approach.line, station, helpers) + (Number(edgeOffsets?.direction) || 0);
|
|
const halfWidth = Math.max(0, Number(widthMeters) || 0) / 2;
|
|
const leftOffset = Number(edgeOffsets?.left) || 0;
|
|
const rightOffset = Number(edgeOffsets?.right) || 0;
|
|
return {
|
|
stationMeters: station,
|
|
point,
|
|
tangent,
|
|
left: offsetCoordinate(point, tangent - 90, halfWidth + leftOffset),
|
|
right: offsetCoordinate(point, tangent + 90, halfWidth + rightOffset),
|
|
};
|
|
}
|
|
|
|
// The graph currently owns only source-derived entry edges. Core closure is
|
|
// deliberately unresolved until a later stage can distinguish paved links,
|
|
// medians, and exclusion regions from topology alone.
|
|
function buildJunctionBoundaryGraph(topology, center, radii, helpers, exclusionRegions = []) {
|
|
const sections = topology.carriageways.map((item) => {
|
|
const outerRadius = radii.outerRadiusFor(item);
|
|
const innerRadius = radii.innerRadiusFor(item);
|
|
const outerWidthMeters = Number(item.approach.sourceWidthMeters) || item.approach.widthMeters;
|
|
const innerWidthMeters = item.approach.widthMeters;
|
|
const positionOffset = Number(item.approach.positionOffsetMeters) || 0;
|
|
const outer = sectionAt(item, outerRadius, center, outerWidthMeters, helpers, undefined);
|
|
const requestedTransition = Number.isFinite(item.approach.transitionLengthMeters)
|
|
? Math.max(0, item.approach.transitionLengthMeters)
|
|
: null;
|
|
const edgeOffsets = {
|
|
left: item.approach.leftEdgeOffsetMeters,
|
|
right: item.approach.rightEdgeOffsetMeters,
|
|
direction: item.approach.directionOffsetDegrees,
|
|
};
|
|
const baseInnerStation =
|
|
requestedTransition === null
|
|
? stationAtDistanceFrom(item.approach.line, center, innerRadius, helpers)
|
|
: outer.stationMeters - requestedTransition;
|
|
const inner = sectionAt(
|
|
item,
|
|
innerRadius,
|
|
center,
|
|
innerWidthMeters,
|
|
helpers,
|
|
baseInnerStation + positionOffset,
|
|
edgeOffsets,
|
|
);
|
|
const key = `boundary:${item.key}`;
|
|
const sectionRing = [outer.right, inner.right, inner.left, outer.left, outer.right];
|
|
const exclusion = exclusionRegions.find((region) => ringsOverlap(region.ring, sectionRing));
|
|
const ringFinite = sectionRing.every((coordinate) => coordinate?.every(Number.isFinite));
|
|
const ringArea = ringFinite ? Math.abs(signedArea(sectionRing)) : 0;
|
|
const ringStatus = !ringFinite || ringArea < 1e-14 || ringSelfIntersects(sectionRing) ? 'invalid' : 'supported';
|
|
return {
|
|
key,
|
|
carriagewayKey: item.key,
|
|
exclusionStatus: exclusion ? 'overlaps-known-region' : 'clear',
|
|
...(exclusion ? { exclusionRegionId: String(exclusion.id ?? '') } : {}),
|
|
armKey: item.armKey,
|
|
outerWidthMeters,
|
|
innerWidthMeters,
|
|
transitionMeters: Math.max(0, outer.stationMeters - inner.stationMeters),
|
|
transitionStatus:
|
|
Math.abs(baseInnerStation + positionOffset - inner.stationMeters) > 1e-6
|
|
? 'insufficient-source-length'
|
|
: outer.stationMeters - inner.stationMeters > 1e-6
|
|
? 'supported'
|
|
: 'insufficient-source-length',
|
|
outer,
|
|
inner,
|
|
ring: sectionRing,
|
|
ringStatus,
|
|
edgeRefs: {
|
|
left: `${key}:left`,
|
|
right: `${key}:right`,
|
|
outer: `${key}:outer`,
|
|
inner: `${key}:inner`,
|
|
},
|
|
};
|
|
});
|
|
const edges = sections.flatMap((section) => [
|
|
{ key: section.edgeRefs.left, from: section.outer.left, to: section.inner.left, owner: section.carriagewayKey },
|
|
{ key: section.edgeRefs.right, from: section.inner.right, to: section.outer.right, owner: section.carriagewayKey },
|
|
{ key: section.edgeRefs.outer, from: section.outer.right, to: section.outer.left, owner: section.carriagewayKey },
|
|
{ key: section.edgeRefs.inner, from: section.inner.left, to: section.inner.right, owner: section.carriagewayKey },
|
|
]);
|
|
return {
|
|
schema: 'junction-boundary-graph/v1',
|
|
status: 'entry-sections-only',
|
|
sections,
|
|
edges,
|
|
exclusionRegions: exclusionRegions.filter((region) => Array.isArray(region.ring) && region.ring.length >= 4),
|
|
unresolvedClosures: topology.arms.map((arm) => arm.cornerKey),
|
|
};
|
|
}
|
|
|
|
function ringSelfIntersects(ring) {
|
|
const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
|
|
const straddles = (p1, p2, p3, p4) => {
|
|
const d1 = cross(p3, p4, p1);
|
|
const d2 = cross(p3, p4, p2);
|
|
const d3 = cross(p1, p2, p3);
|
|
const d4 = cross(p1, p2, p4);
|
|
return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0));
|
|
};
|
|
for (let first = 0; first < ring.length - 1; first += 1) {
|
|
for (let second = first + 2; second < ring.length - 1; second += 1) {
|
|
if (first === 0 && second === ring.length - 2) continue;
|
|
if (straddles(ring[first], ring[first + 1], ring[second], ring[second + 1])) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function signedArea(ring) {
|
|
return ring.slice(1).reduce((area, point, index) => area + ring[index][0] * point[1] - point[0] * ring[index][1], 0);
|
|
}
|
|
|
|
function pointInRing(point, ring) {
|
|
return ring.slice(1).reduce((inside, candidate, index) => {
|
|
const previous = ring[index];
|
|
const crosses = previous[1] > point[1] !== candidate[1] > point[1];
|
|
return crosses &&
|
|
point[0] < ((candidate[0] - previous[0]) * (point[1] - previous[1])) / (candidate[1] - previous[1]) + previous[0]
|
|
? !inside
|
|
: inside;
|
|
}, false);
|
|
}
|
|
|
|
function segmentsIntersect(first, second, third, fourth) {
|
|
// Orientation alone treats all collinear segments as intersecting, even
|
|
// when their finite extents are disjoint.
|
|
if (
|
|
Math.max(first[0], second[0]) < Math.min(third[0], fourth[0]) ||
|
|
Math.max(third[0], fourth[0]) < Math.min(first[0], second[0]) ||
|
|
Math.max(first[1], second[1]) < Math.min(third[1], fourth[1]) ||
|
|
Math.max(third[1], fourth[1]) < Math.min(first[1], second[1])
|
|
)
|
|
return false;
|
|
const cross = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
|
|
const firstSide = cross(first, second, third);
|
|
const secondSide = cross(first, second, fourth);
|
|
const thirdSide = cross(third, fourth, first);
|
|
const fourthSide = cross(third, fourth, second);
|
|
return (
|
|
((firstSide >= 0 && secondSide <= 0) || (firstSide <= 0 && secondSide >= 0)) &&
|
|
((thirdSide >= 0 && fourthSide <= 0) || (thirdSide <= 0 && fourthSide >= 0))
|
|
);
|
|
}
|
|
|
|
function ringsOverlap(first, second) {
|
|
return (
|
|
first.slice(0, -1).some((point) => pointInRing(point, second)) ||
|
|
second.slice(0, -1).some((point) => pointInRing(point, first)) ||
|
|
first
|
|
.slice(1)
|
|
.some((point, index) =>
|
|
second.slice(1).some((other, otherIndex) => segmentsIntersect(first[index], point, second[otherIndex], other)),
|
|
)
|
|
);
|
|
}
|
|
|
|
function coordinateDistanceMeters(first, second) {
|
|
if (!first?.every(Number.isFinite) || !second?.every(Number.isFinite)) return Infinity;
|
|
const radians = Math.PI / 180;
|
|
const latitude = ((first[1] + second[1]) / 2) * radians;
|
|
const east = (second[0] - first[0]) * 111320 * Math.cos(latitude);
|
|
const north = (second[1] - first[1]) * 111320;
|
|
return Math.hypot(east, north);
|
|
}
|
|
|
|
// A central paved region is safe to infer only when every arm has exactly one
|
|
// source carriageway. Its shared entry seams are the sections' `inner` edges;
|
|
// every remaining edge is an explicit closure between adjacent arms.
|
|
function buildCoreClosure(topology, graph, center) {
|
|
let coreSections = graph.sections;
|
|
if (topology.arms.some((arm) => arm.members.length !== 1)) {
|
|
if (topology.arms.length < 4 || topology.arms.length > 6)
|
|
return { status: 'unsupported', reason: 'parallel-carriageway-closure-unresolved' };
|
|
coreSections = topology.arms.map(
|
|
(arm) =>
|
|
graph.sections
|
|
.filter((section) => section.armKey === arm.key && section.ringStatus === 'supported')
|
|
.sort((a, b) => {
|
|
const distance = (section) => {
|
|
const x = (section.inner.left[0] + section.inner.right[0]) / 2 - center[0];
|
|
const y = (section.inner.left[1] + section.inner.right[1]) / 2 - center[1];
|
|
return x * x + y * y;
|
|
};
|
|
return distance(a) - distance(b) || a.carriagewayKey.localeCompare(b.carriagewayKey);
|
|
})[0],
|
|
);
|
|
if (coreSections.some((section) => !section))
|
|
return { status: 'unsupported', reason: 'parallel-carriageway-closure-unresolved' };
|
|
}
|
|
if (coreSections.length < 3 || coreSections.length > 6)
|
|
return { status: 'unsupported', reason: 'unsupported-arm-count' };
|
|
const points = coreSections
|
|
.flatMap((section) => [
|
|
{ point: section.inner.left, edgeRef: section.edgeRefs.inner },
|
|
{ point: section.inner.right, edgeRef: section.edgeRefs.inner },
|
|
])
|
|
.filter((item) => item.point?.every(Number.isFinite))
|
|
.sort(
|
|
(first, second) =>
|
|
Math.atan2(first.point[1] - center[1], first.point[0] - center[0]) -
|
|
Math.atan2(second.point[1] - center[1], second.point[0] - center[0]),
|
|
);
|
|
const ring = [...points.map((item) => item.point), points[0]?.point].filter(Boolean);
|
|
const hasZeroLengthEdge = ring.slice(1).some((point, index) => {
|
|
const previous = ring[index];
|
|
const dx = point[0] - previous[0];
|
|
const dy = point[1] - previous[1];
|
|
return dx * dx + dy * dy <= 1e-24;
|
|
});
|
|
const pairedEdges = new Map();
|
|
points.forEach((item, index) => {
|
|
if (!pairedEdges.has(item.edgeRef)) pairedEdges.set(item.edgeRef, []);
|
|
pairedEdges.get(item.edgeRef).push(index);
|
|
});
|
|
const paired = [...pairedEdges.values()].every((indexes) => {
|
|
if (indexes.length !== 2) return false;
|
|
return Math.abs(indexes[0] - indexes[1]) === 1 || (indexes[0] === 0 && indexes[1] === points.length - 1);
|
|
});
|
|
if (ring.length < 7 || hasZeroLengthEdge || !paired || Math.abs(signedArea(ring)) < 1e-14 || ringSelfIntersects(ring))
|
|
return { status: 'unsupported', reason: 'core-closure-invalid' };
|
|
const holes = graph.exclusionRegions
|
|
.filter((region) => {
|
|
const boundaryIntersects = ringSelfIntersects([...region.ring]);
|
|
const contained = region.ring.slice(0, -1).every((point) => pointInRing(point, ring));
|
|
const clearOfEntries = graph.sections.every((section) => !ringsOverlap(region.ring, section.ring));
|
|
return region.isHole === true && !boundaryIntersects && contained && clearOfEntries;
|
|
})
|
|
.map((region) => region.ring);
|
|
if (graph.exclusionRegions.some((region) => ringsOverlap(region.ring, ring) && !holes.includes(region.ring)))
|
|
return { status: 'unsupported', reason: 'known-exclusion-region' };
|
|
const seamErrors = graph.sections.map((section) => {
|
|
const leftIndex = ring.findIndex(
|
|
(point) => point[0] === section.inner.left[0] && point[1] === section.inner.left[1],
|
|
);
|
|
const rightIndex = ring.findIndex(
|
|
(point) => point[0] === section.inner.right[0] && point[1] === section.inner.right[1],
|
|
);
|
|
const contiguous =
|
|
leftIndex >= 0 &&
|
|
rightIndex >= 0 &&
|
|
(Math.abs(leftIndex - rightIndex) === 1 || Math.abs(leftIndex - rightIndex) === ring.length - 2);
|
|
const edge = graph.edges.find((candidate) => candidate.key === section.edgeRefs.inner);
|
|
if (!contiguous || !edge) return { carriagewayKey: section.carriagewayKey, errorMeters: Infinity };
|
|
const ringLeft = ring[leftIndex];
|
|
const ringRight = ring[rightIndex];
|
|
const forward = Math.max(
|
|
coordinateDistanceMeters(ringLeft, edge.from),
|
|
coordinateDistanceMeters(ringRight, edge.to),
|
|
);
|
|
const reverse = Math.max(
|
|
coordinateDistanceMeters(ringLeft, edge.to),
|
|
coordinateDistanceMeters(ringRight, edge.from),
|
|
);
|
|
return { carriagewayKey: section.carriagewayKey, errorMeters: Math.min(forward, reverse) };
|
|
});
|
|
const seamErrorMeters = seamErrors.reduce((maximum, item) => Math.max(maximum, item.errorMeters), 0);
|
|
const connectedEntryCount = seamErrors.filter((item) => Number.isFinite(item.errorMeters)).length;
|
|
return {
|
|
status: 'supported',
|
|
ring,
|
|
holes,
|
|
ringArea: Math.abs(signedArea(ring)) / 2,
|
|
ringSelfIntersects: false,
|
|
sharedEdgeRefs: [...pairedEdges.keys()].sort(),
|
|
closureCount: graph.sections.length,
|
|
connectedEntryCount,
|
|
requiredPavementConnected: connectedEntryCount === graph.sections.length,
|
|
maxSharedSeamErrorMeters: seamErrorMeters,
|
|
sharedSeamErrors: seamErrors,
|
|
};
|
|
}
|
|
|
|
module.exports = { buildJunctionBoundaryGraph, buildCoreClosure, ringsOverlap };
|