'use strict'; const fs = require('fs'); const { COMPLEX_CROSSWALK_DEPTH_METERS } = require('./junction-metrics'); const { structureFromTopology } = require('./junction-topology'); const { resolveJunctionBuildPlan, stationAtDistanceFrom } = require('./junction-build-plan'); const { buildJunctionBoundaryGraph, buildCoreClosure, ringsOverlap } = require('./junction-boundary-graph'); const { solveComplexPavementRegion, rectangle } = require('./junction-pavement-region'); const { buildIslandFromCrossingEdges, orthogonalCrossingHeadings, stripeLayout, crossingArcSupport, solveIslandContacts, } = require('./junction-facility-composition'); const { complexJunctionMetrics: calculateComplexJunctionMetrics } = require('./junction-metrics'); const { radialShift } = require('./junction-island-offset'); const { convertGeoJson, boundsOf } = require('../reference/gaode'); const metricsCache = new WeakMap(); const CORNER_FILLET_SEGMENTS = 12; // Must match DEFAULT_SIDEWALK_WIDTH_METERS in native-road.js so the corner band // lines up with the straight strips it joins. const SIDEWALK_WIDTH_METERS = 2; // Compatibility export for current compiler consumers. The build-plan module is // pure and is the shared authority for geometry and direct-edit identity. const resolveComplexJunctionTopology = resolveJunctionBuildPlan; function buildComplexJunctionGeometry(model, cluster, helpers) { const nodeIds = new Set(cluster.nodeIds.map(String)); const nodes = cluster.nodeIds.map((id) => helpers.junctionPlans.get(String(id))?.node).filter(Boolean); if (nodes.length < 2) return { features: [], diagnostics: [ helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-insufficient-nodes', '复合路口至少需要两个有效节点。', null, ), ], }; const center = nodes.reduce( (sum, point) => [sum[0] + point[0] / nodes.length, sum[1] + point[1] / nodes.length], [0, 0], ); const topology = resolveComplexJunctionTopology(model, cluster, helpers); const { carriageways, arms } = topology; const approaches = arms.map((arm) => arm.representative); if (approaches.length < 3) return { features: [], diagnostics: [ helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-insufficient-approaches', '复合路口无法识别足够的外部进口。', center, ), ], }; const { calibration, coreRadius } = complexJunctionMetrics(cluster); const sorted = approaches; const shape = classifyJunctionShape(arms, center, helpers); if (shape.kind === 'unsupported') return { features: [], diagnostics: [ helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-shape-fallback', `${shape.label},已回退为普通路口渲染。`, center, ), ], shape, center, }; const outerRadius = complexJunctionMetrics(cluster).approachOuterRadius; const boundaryParts = []; const transitionDiagnostics = []; const crosswalks = []; const crossingRegions = []; const stopLines = []; const islands = []; // Each arm crossing is shared by two corner islands. Corner generation // records its two endpoint displacements here; the stripes are rebuilt once // after every corner has contributed, rather than being mutated per corner. const armEndpointOffsets = new Map(); const islandOffsetMeters = Number(helpers.clusterIslandOffsetMeters) || 0; const crossingControls = helpers.clusterCrossingControls || new Map(); const crossingPlans = new Map( arms.map((arm) => { const inferredRadius = Math.max(1, coreRadius * 0.68); const inferredEnvelope = armEnvelopeAtRadius(arm, inferredRadius, center, helpers); const evidence = inferredEnvelope ? crossingEvidenceForArm(model, arm, inferredEnvelope.center, helpers) : { kind: 'unknown-no-crossing-source', crossingNodeIds: [], crossing: null }; return [ arm.key, { evidence, baseRadius: evidence.crossing ? helpers.distanceMeters(center, evidence.crossing.coordinate) : inferredRadius, }, ]; }), ); const armCrosswalkRadiusFor = (arm) => Math.max( 1, (crossingPlans.get(arm.key)?.baseRadius || coreRadius * 0.68) + (crossingControls.get(`crossing:${arm.key}`)?.crosswalkInsetMeters || 0), ); const boundaryGraph = helpers.boundaryGraph || buildComplexApproachBoundaryGraph(topology, center, cluster, helpers, model.exclusionRegions || []); for (const section of boundaryGraph.sections) { const item = carriageways.find((candidate) => candidate.key === section.carriagewayKey); if (!item) continue; // The approach plan owns the editable handoff distance. It shifts only this // carriageway's outer transition, leaving neighboring arms untouched. A // collapsed handoff is reported and omitted rather than publishing a // zero-area trapezoid that downstream layers could mistake for pavement. if (section.ringStatus !== 'supported') { transitionDiagnostics.push( helpers.diagnostic( 'warning', `carriageway:${item.key}`, item.approach.roadIds.map(String), 'complex-junction-entry-ring-invalid', '该进口边界无法形成有效道路面,已省略退化或自交几何。', section.inner.point, ), ); continue; } if (section.exclusionStatus !== 'clear') { transitionDiagnostics.push( helpers.diagnostic( 'warning', `carriageway:${item.key}`, item.approach.roadIds.map(String), 'complex-junction-entry-overlaps-known-region', '该进口过渡区域侵入已知排除区域,已省略该进口面以保留来源区域。', section.inner.point, ), ); continue; } if (section.transitionStatus !== 'supported') { transitionDiagnostics.push( helpers.diagnostic( 'warning', `carriageway:${item.key}`, item.approach.roadIds.map(String), 'complex-junction-entry-transition-unsupported', '该进口在当前来源长度内无法形成外部断面到核心断面的连续过渡,已省略退化进口面。', section.inner.point, ), ); continue; } boundaryParts.push({ item, section }); const outerHalf = item.approach.widthMeters / 2; const incomingRoad = item.approach.roadIds .map((roadId) => model.roads.find((road) => road.id === roadId)) .find((road) => String(road?.sourceNodeIds.at(-1)) === String(item.nodeId)); if (incomingRoad) { // Offset is clear space beyond the relocated crossing outer edge; include // half the stop bar thickness so the minimum offset cannot cut into it. const arm = arms.find((candidate) => candidate.members.includes(item)); const crossingKey = `crossing:${arm.key}`; const crossingRadius = armCrosswalkRadiusFor(arm); const stopOffset = crossingControls.get(crossingKey)?.stopLineOffsetMeters || 3; const stopHeading = orthogonalCrossingHeadings(arms.map((candidate) => candidate.heading))[arms.indexOf(arm)]; const envelope = armEnvelopeAtRadius(arm, crossingRadius, center, helpers); const basePoint = pointOnCarriagewayRadius(item, center, crossingRadius, helpers); const lateral = signedLateralMeters(envelope.center, basePoint, stopHeading); const stopCenter = helpers.offsetCoordinate( helpers.offsetCoordinate(envelope.center, stopHeading + 90, lateral), stopHeading, COMPLEX_CROSSWALK_DEPTH_METERS * 1.5 + 0.24 + stopOffset, ); const crossingEvidence = crossingPlans.get(arm.key)?.evidence || { kind: 'unknown-no-crossing-source', crossingNodeIds: [], }; const ring = [ helpers.offsetCoordinate( helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, -0.24, ), helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, outerHalf), stopHeading, -0.24), helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, outerHalf), stopHeading, 0.24), helpers.offsetCoordinate(helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, 0.24), helpers.offsetCoordinate( helpers.offsetCoordinate(stopCenter, stopHeading + 90, -outerHalf), stopHeading, -0.24, ), ]; stopLines.push({ type: 'Feature', properties: { native_id: `complex-stop-line:${cluster.id}:${item.approach.segmentId}`, object_key: `stop-line:${item.key}`, crossing_key: crossingKey, arm_key: item.armKey, carriageway_key: item.key, cluster_id: cluster.id, kind: 'complex-stop-line', road_id: incomingRoad.id, node_id: item.nodeId, direction: item.heading, facility_evidence: crossingEvidence.kind, ...(crossingEvidence.crossingNodeIds.length ? { source_crossing_node_ids: crossingEvidence.crossingNodeIds } : {}), provenance: 'native-road-complex-junction-stop-line/v1', }, geometry: { type: 'Polygon', coordinates: [ring] }, }); } } // The four support lines provide a common corner frame, but each long // crossing remains clipped to its OSM-derived road envelope. Corner islands // fill the remaining frame gaps; crossings must never do that job. const publishedCarriageways = new Set(boundaryParts.map(({ item }) => item.key)); for (const arm of arms) { if (!arm.members.every((item) => publishedCarriageways.has(item.key))) { transitionDiagnostics.push( helpers.diagnostic( 'warning', `crossing:${arm.key}`, arm.members.flatMap((item) => item.approach.roadIds.map(String)), 'complex-junction-crosswalk-pavement-unavailable', '该过街缺少完整可发布的车行道过渡面,已省略标线,避免跨越无效进口。', center, ), ); continue; } const armCrosswalkRadius = armCrosswalkRadiusFor(arm); arm.crosswalkRadius = armCrosswalkRadius; const envelope = armEnvelopeAtRadius(arm, armCrosswalkRadius, center, helpers); if (!envelope) continue; const evidence = crossingPlans.get(arm.key)?.evidence || { kind: 'unknown-no-crossing-source', crossingNodeIds: [], }; if (evidence.kind !== 'source-crossing-node') { transitionDiagnostics.push( helpers.diagnostic( 'info', `crossing:${arm.key}`, arm.members.flatMap((item) => item.approach.roadIds.map(String)), 'complex-junction-crossing-source-missing', '该进口未找到匹配的 OSM 过街节点,过街来源未知,按复杂路口默认生成斑马线。', envelope.center, ), ); } arm.crosswalkFrame = { center: envelope.center, groupDepth: COMPLEX_CROSSWALK_DEPTH_METERS, supportHeading: normalizeHeading(arm.heading + 90), envelopeWidthMeters: envelope.widthMeters, }; arm.crosswalkEvidence = evidence; } const crossingHeadings = orthogonalCrossingHeadings(arms.map((arm) => arm.heading)); arms.forEach((arm, index) => { if (arm.crosswalkFrame) { arm.crosswalkFrame.heading = crossingHeadings[index]; arm.crosswalkFrame.supportHeading = normalizeHeading(crossingHeadings[index] + 90); } }); // Coordinate all four landing pairs before publishing stripes. Trim whole // stripe pitches symmetrically so stripe size and spacing stay unchanged. let crossingSpanTrim = 0; if (arms.length === 4 && arms.every((arm) => arm.crosswalkFrame)) { for (let attempt = 0; attempt < 12; attempt++) { const trialTrim = attempt * 1.64; const candidates = arms.map((arm) => { const f = arm.crosswalkFrame; const span = f.envelopeWidthMeters - 0.7 - trialTrim; if (span < f.groupDepth) return null; const shifted = helpers.offsetCoordinate(f.center, f.heading, f.groupDepth); const layout = stripeLayout(span); const half = span / 2 - (layout.centers[0] - layout.width / 2); return [-1, 1].map((sign) => helpers.offsetCoordinate(shifted, f.heading + 90, sign * half)); }); if (candidates.some((candidate) => !candidate)) break; const valid = arms.every((arm, i) => { const j = (i + 1) % arms.length; const pair = candidates[i] .flatMap((a) => candidates[j].map((b) => ({ a, b, distance: helpers.distanceMeters(a, b) }))) .sort((a, b) => a.distance - b.distance)[0]; const origin = rayIntersection( { point: pair.a, heading: arm.crosswalkFrame.heading }, { point: pair.b, heading: arms[j].crosswalkFrame.heading }, center, ); return ( origin && [ [arm, pair.a], [arms[j], pair.b], ].every( ([side, point]) => directionalProjectionMeters(origin, point, side.crosswalkFrame.heading) > side.crosswalkFrame.groupDepth / 2 + 0.2, ) ); }); if (valid) { crossingSpanTrim = trialTrim; break; } } } for (let index = 0; index < arms.length; index += 1) { const arm = arms[index]; if (!arm.crosswalkFrame) continue; const item = arm.representative; const crossingHeading = arm.crosswalkFrame.heading; const roadEdgeInset = 0.35; const usableSpan = Math.max(0.42, arm.crosswalkFrame.envelopeWidthMeters - roadEdgeInset * 2 - crossingSpanTrim); const groupDepth = arm.crosswalkFrame.groupDepth; arm.crosswalkFrame.center = helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading, groupDepth); arm.crosswalkRadius += groupDepth; const endpoints = [ helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading + 90, -usableSpan / 2), helpers.offsetCoordinate(arm.crosswalkFrame.center, crossingHeading + 90, usableSpan / 2), ]; const stripeWidth = 0.42; const layout = stripeLayout(usableSpan); const stripeCount = layout.centers.length; const stripeSpacing = layout.pitch; arm.crosswalkFrame.center = midpoint(...endpoints); arm.crosswalkFrame.endpoints = endpoints; arm.crosswalkFrame.spanMeters = usableSpan; arm.crosswalkFrame.contactEndpointRatio = (layout.centers[0] - layout.width / 2) / usableSpan; arm.crosswalkFrame.roadEdgeInsetMeters = roadEdgeInset; crossingRegions.push(rectangle(arm.crosswalkFrame.center, crossingHeading, groupDepth, usableSpan)); for (let stripe = 0; stripe < stripeCount; stripe += 1) { const along = layout.centers[stripe]; const centerPoint = helpers.offsetCoordinate(endpoints[0], bearing(...endpoints), along); const ring = [ helpers.offsetCoordinate( helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), crossingHeading + 90, -stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), crossingHeading + 90, -stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(centerPoint, crossingHeading, groupDepth / 2), crossingHeading + 90, stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), crossingHeading + 90, stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(centerPoint, crossingHeading, -groupDepth / 2), crossingHeading + 90, -stripeWidth / 2, ), ]; crosswalks.push({ type: 'Feature', properties: { native_id: `complex-crosswalk:${cluster.id}:${item.nodeId}:${item.approach.segmentId}:${stripe + 1}`, object_key: `crossing:${arm.key}`, crossing_key: `crossing:${arm.key}`, arm_key: arm.key, cluster_id: cluster.id, kind: 'complex-crosswalk', crossing_node_id: item.nodeId, road_id: item.approach.roadIds[0], direction: crossingHeading, radial_distance_m: arm.crosswalkRadius, span_m: usableSpan, road_envelope_span_m: arm.crosswalkFrame.envelopeWidthMeters, road_edge_inset_m: roadEdgeInset, group_depth_m: groupDepth, stripe_width_m: stripeWidth, stripe_spacing_m: stripeSpacing, frame_center: arm.crosswalkFrame.center, frame_support_heading: arm.crosswalkFrame.supportHeading, facility_evidence: arm.crosswalkEvidence.kind, ...(arm.crosswalkEvidence.crossingNodeIds.length ? { source_crossing_node_ids: arm.crosswalkEvidence.crossingNodeIds } : {}), provenance: 'native-road-complex-junction-crosswalk/v6-road-clipped', }, geometry: { type: 'Polygon', coordinates: [ring] }, }); } } // Corner islands and diagonal crossings need explicit island or pedestrian // connection sources. Angle and road width alone do not establish either, // so this compiler deliberately leaves them absent until that data exists. // Each carriageway ends in its own rectangle, so adjacent arms meet at a // sharp notch instead of a curb. A real corner is one tangent-continuous // sweep between the two outermost road edges, so fit a fixed-radius fillet // into the wedge those edges form and fill the sector behind it. const coreClosure = buildCoreClosure(topology, boundaryGraph, center); const coreRing = coreClosure.status === 'supported' ? coreClosure.ring : null; const cornerFills = []; const sidewalkCorners = []; const cornerDiagnostics = []; const cornerOverlapsExclusion = (ring, cornerKey, part) => { const region = boundaryGraph.exclusionRegions.find((region) => ringsOverlap(region.ring, ring)); if (!region) return false; cornerDiagnostics.push( helpers.diagnostic( 'warning', `corner:${cornerKey}`, [String(region.id)], 'complex-junction-corner-exclusion-overlap', `该角部${part}侵入已知排除区域 ${region.id},已省略,避免覆盖已知不可通行空间。`, center, ), ); return true; }; const omittedCornerFacilityCount = arms.filter((arm, index) => { const next = arms[(index + 1) % arms.length]; const delta = positiveHeadingDelta(arm.heading, next.heading); return delta >= 45 && delta <= 135; }).length; if (omittedCornerFacilityCount) cornerDiagnostics.push( helpers.diagnostic( 'info', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-corner-facilities-omitted', `已省略 ${omittedCornerFacilityCount} 组缺少岛体或步行连接来源的角部导流岛和斑马线。`, center, ), ); const defaultCornerRadius = Math.max(4, Math.min(25, Number(cluster.cornerRadiusMeters) || 12)); for (let index = 0; index < arms.length; index += 1) { const first = arms[index]; const second = arms[(index + 1) % arms.length]; if (!publishedCarriageways.size) continue; const cornerRadius = helpers.clusterCornerRadii?.get(first.cornerKey) ?? defaultCornerRadius; const delta = positiveHeadingDelta(first.heading, second.heading); if (delta < 45 || delta > 135) continue; const bisector = normalizeHeading(first.heading + delta / 2); const edges = [first, second].map((arm) => cornerEdgeAt(arm, coreRadius + 6, bisector, center, helpers)); if (!edges.every(Boolean)) continue; const apex = rayIntersection(edges[0], edges[1], center); const apexReach = apex ? directionalProjectionMeters(center, apex, bisector) : null; // The wedge apex has to sit ahead of the core and inside the arm handoff; // outside that band the two edges are near parallel and any fillet fitted // to them would sweep across the carriageways instead of the corner. if (apexReach === null || apexReach < 1 || apexReach > outerRadius) { cornerDiagnostics.push( helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-corner-fillet-fallback', '该夹角的道路边缘切线无法安全构造圆角,已保留直角过渡。', center, ), ); continue; } // Tangent distance for a circle of `cornerRadius` inscribed in a wedge of // opening `delta`. // Keep the radius control continuous. The previous handoff cap made a // sizeable part of the advertised 1..25 m range geometry-inert: once the // tangent distance hit the cap, pressing Enter only changed metadata. // The solver's radius bounds and the generated arm envelope provide the // validity boundary; this value must remain the direct geometric response. const tangentDistance = cornerRadius / Math.tan((delta * Math.PI) / 360); const tangents = edges.map((edge) => helpers.offsetCoordinate(apex, edge.heading, tangentDistance)); const curve = quadraticCurve(tangents[0], apex, tangents[1], CORNER_FILLET_SEGMENTS); const ring = [...curve, center, curve[0]]; if (!ring.every((point) => point.every(Number.isFinite))) continue; if (cornerOverlapsExclusion(ring, first.cornerKey, '道路补面')) continue; cornerFills.push({ type: 'Feature', properties: { native_id: `complex-corner-fillet:${cluster.id}:${index + 1}`, cluster_id: cluster.id, kind: 'complex-corner-fillet', object_key: first.cornerKey, corner_key: first.cornerKey, complex_part: 'corner-fillet', corner_index: index + 1, from_heading: first.heading, to_heading: second.heading, bisector_heading: bisector, corner_radius_m: cornerRadius, tangent_distance_m: Math.round(tangentDistance * 100) / 100, apex_reach_m: Math.round(apexReach * 100) / 100, provenance: 'native-road-complex-junction-corner-fillet/v1', }, geometry: { type: 'Polygon', coordinates: [ring] }, }); if (!first.crosswalkFrame?.endpoints || !second.crosswalkFrame?.endpoints) continue; const endpointPairs = first.crosswalkFrame.endpoints.flatMap((a, firstEndpointIndex) => second.crosswalkFrame.endpoints.map((b, secondEndpointIndex) => ({ a, b, firstEndpointIndex, secondEndpointIndex, distance: helpers.distanceMeters(a, b), })), ); const pair = endpointPairs.sort((a, b) => a.distance - b.distance)[0]; const crossingCorner = rayIntersection( { point: pair.a, heading: first.crosswalkFrame.heading }, { point: pair.b, heading: second.crosswalkFrame.heading }, center, ); if (!crossingCorner) continue; const stripeWidth = 0.42; const outerFirst = helpers.offsetCoordinate( crossingCorner, first.crosswalkFrame.heading, first.crosswalkFrame.groupDepth, ); const outerSecond = helpers.offsetCoordinate( crossingCorner, second.crosswalkFrame.heading, second.crosswalkFrame.groupDepth, ); const lonScale = 111320 * Math.cos((crossingCorner[1] * Math.PI) / 180); const toLocal = (point) => [(point[0] - crossingCorner[0]) * lonScale, (point[1] - crossingCorner[1]) * 111320]; const fromLocal = (point) => [crossingCorner[0] + point[0] / lonScale, crossingCorner[1] + point[1] / 111320]; const landing = (arm, endpoint) => { const frame = arm.crosswalkFrame; const layout = stripeLayout(frame.spanMeters); const margin = layout.centers[0] - layout.width / 2; const edgeCenter = helpers.offsetCoordinate(endpoint, bearing(endpoint, frame.center), margin); return [-1, 1].map((sign) => toLocal(helpers.offsetCoordinate(edgeCenter, frame.heading, (sign * frame.groupDepth) / 2)), ); }; let contactSolution = solveIslandContacts( landing(first, pair.a), landing(second, pair.b), COMPLEX_CROSSWALK_DEPTH_METERS, { maxLegLength: outerRadius }, ); if (contactSolution.status !== 'solved') { cornerDiagnostics.push( helpers.diagnostic( 'warning', `corner:${first.cornerKey}`, [...nodeIds], 'complex-junction-island-infeasible', contactSolution.reason, crossingCorner, ), ); continue; } // Dragging moves the whole pedestrian composition away from the cluster // centre. Re-solve from the translated landing segments so the island, // its green contact hexagon and all three complete contacts retain the same // source coordinates instead of merely translating a detached island. let islandShift = [0, 0]; if (islandOffsetMeters > 0) { const provisionalRing = contactSolution.ring.map(fromLocal); const provisionalCenter = polygonCenter(provisionalRing); islandShift = radialShift(center, provisionalCenter, islandOffsetMeters); const localShift = toLocal([crossingCorner[0] + islandShift[0], crossingCorner[1] + islandShift[1]]); const translateSegment = (segment) => segment.map((point) => [point[0] + localShift[0], point[1] + localShift[1]]); const shifted = solveIslandContacts( translateSegment(landing(first, pair.a)), translateSegment(landing(second, pair.b)), COMPLEX_CROSSWALK_DEPTH_METERS, { maxLegLength: outerRadius }, ); if (shifted.status !== 'solved') { cornerDiagnostics.push( helpers.diagnostic( 'warning', `corner:${first.cornerKey}`, [...nodeIds], 'complex-junction-island-offset-infeasible', shifted.reason, crossingCorner, ), ); continue; } contactSolution = shifted; const rememberOffset = (arm, endpointIndex) => { const offsets = armEndpointOffsets.get(arm.key) || [ [0, 0], [0, 0], ]; offsets[endpointIndex] = islandShift; armEndpointOffsets.set(arm.key, offsets); }; rememberOffset(first, pair.firstEndpointIndex); rememberOffset(second, pair.secondEndpointIndex); } const publishedIslandRing = contactSolution.ring.map(fromLocal); const greenRing = contactSolution.greenRing.map(fromLocal); if (!cornerOverlapsExclusion(publishedIslandRing, first.cornerKey, '安全岛')) islands.push({ type: 'Feature', properties: { native_id: `complex-corner-island:${cluster.id}:${index + 1}`, object_key: `island:inferred/${first.cornerKey}`, cluster_id: cluster.id, kind: 'island', corner_key: first.cornerKey, facility_evidence: 'inferred-complex-junction-corner', provenance: 'native-road-complex-junction-inferred-island/v1', island_leg_lengths_m: contactSolution.legLengths, contact_points: greenRing.slice(0, -1), }, geometry: { type: 'Polygon', coordinates: [publishedIslandRing] }, }); if (!cornerOverlapsExclusion(greenRing, first.cornerKey, '安全岛绿色接触区')) islands.push({ type: 'Feature', properties: { native_id: `complex-corner-island-green:${cluster.id}:${index + 1}`, object_key: `island:inferred/${first.cornerKey}`, cluster_id: cluster.id, corner_key: first.cornerKey, kind: 'island-green', island_key: `island:inferred/${first.cornerKey}`, provenance: 'native-road-complex-junction-island-contact-hexagon/v1', }, geometry: { type: 'Polygon', coordinates: [greenRing] }, }); if ( !first.members.every((item) => publishedCarriageways.has(item.key)) || !second.members.every((item) => publishedCarriageways.has(item.key)) ) continue; // Complex junctions carry a default diagonal crossing across each safe // corner. Source crossing nodes refine provenance/inset values, but are // not required for the default visual treatment. const outerMidpoint = fromLocal(contactSolution.thirdCenter); const diagonalDepth = COMPLEX_CROSSWALK_DEPTH_METERS; const outwardHeading = (Math.atan2(contactSolution.outward[0], contactSolution.outward[1]) * 180) / Math.PI; const diagonalHeading = outwardHeading; const diagonalCenter = helpers.offsetCoordinate(outerMidpoint, outwardHeading, diagonalDepth / 2); const diagonalSpan = COMPLEX_CROSSWALK_DEPTH_METERS; const layout = stripeLayout(diagonalDepth); const stripeCount = layout.centers.length; const stripeSpacing = layout.pitch; for (let stripe = 0; stripe < stripeCount; stripe += 1) { const along = -diagonalDepth / 2 + layout.centers[stripe] - (layout.centers[0] - stripeWidth / 2); const stripeCenter = helpers.offsetCoordinate(diagonalCenter, diagonalHeading, along); const ring = [ helpers.offsetCoordinate( helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), diagonalHeading, -stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), diagonalHeading, -stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, diagonalSpan / 2), diagonalHeading, stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), diagonalHeading, stripeWidth / 2, ), helpers.offsetCoordinate( helpers.offsetCoordinate(stripeCenter, diagonalHeading + 90, -diagonalSpan / 2), diagonalHeading, -stripeWidth / 2, ), ]; crosswalks.push({ type: 'Feature', properties: { native_id: `complex-corner-crosswalk:${cluster.id}:${index + 1}:${stripe + 1}`, object_key: `crossing:corner:${first.cornerKey}`, crossing_key: `crossing:corner:${first.cornerKey}`, island_key: `island:inferred/${first.cornerKey}`, from_boundary: `sidewalk:${first.cornerKey}:from`, to_boundary: `island:inferred/${first.cornerKey}`, cluster_id: cluster.id, kind: 'complex-corner-crosswalk', stripe_width_m: stripeWidth, stripe_spacing_m: stripeSpacing, group_depth_m: COMPLEX_CROSSWALK_DEPTH_METERS, corner_key: first.cornerKey, facility_evidence: 'default-complex-junction', provenance: 'native-road-complex-junction-corner-crosswalk/v1', }, geometry: { type: 'Polygon', coordinates: [ring] }, }); } // The straight pedestrian strips are trimmed at the cluster boundary, so // two arms that both carry a footway still meet as two loose ends across // an empty wedge. Bridge them along the curb the fillet already defines. // The corner faces clockwise from `first` and counter-clockwise from // `second`, so each arm must carry the footway on that facing side. if (!armCarriesSidewalk(first, model, true) || !armCarriesSidewalk(second, model, false)) continue; const seams = edges.map((edge) => exteriorSidewalkSeam(edge, boundaryGraph, helpers)); if (!seams.every(Boolean)) { cornerDiagnostics.push( helpers.diagnostic( 'warning', `corner:${first.cornerKey}`, edges.flatMap((edge) => edge.roadIds), 'complex-junction-sidewalk-seam-unavailable', '该角部缺少两侧可验证的人行道接缝,已省略连接,避免生成悬空步行带。', center, ), ); continue; } const curb = [seams[0].curb, ...curve, seams[1].curb]; const outerEdge = offsetPolylineAwayFromCenter(curb, center, SIDEWALK_WIDTH_METERS, helpers); outerEdge[0] = seams[0].outer; outerEdge[outerEdge.length - 1] = seams[1].outer; const sidewalkRing = [...curb, ...outerEdge.slice().reverse(), curb[0]]; if (!sidewalkRing.every((point) => point.every(Number.isFinite)) || ringSelfIntersects(sidewalkRing)) { cornerDiagnostics.push( helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-sidewalk-corner-fallback', '该夹角的人行道转角几何自交或无效,已跳过,两侧步行带保持断开。', center, ), ); continue; } if (cornerOverlapsExclusion(sidewalkRing, first.cornerKey, '人行道')) continue; sidewalkCorners.push({ type: 'Feature', properties: { native_id: `complex-sidewalk-corner:${cluster.id}:${index + 1}`, cluster_id: cluster.id, kind: 'complex-sidewalk-corner', object_key: `sidewalk-turn:${first.cornerKey}`, corner_key: first.cornerKey, corner_index: index + 1, from_heading: first.heading, to_heading: second.heading, bisector_heading: bisector, width_m: SIDEWALK_WIDTH_METERS, seam_source: 'published-exterior-sidewalk', provenance: 'native-road-complex-junction-sidewalk-corner/v1', }, geometry: { type: 'Polygon', coordinates: [sidewalkRing] }, }); } // Rebuild each shared arm crossing from its two endpoint displacement values. // Interpolation occurs along its declared support axis, preserving every // stripe's width and spacing while allowing the two neighbouring islands to // move in different radial directions. if (armEndpointOffsets.size) { for (const arm of arms) { const offsets = armEndpointOffsets.get(arm.key); if (!offsets || !arm.crosswalkFrame?.endpoints) continue; const [start, end] = arm.crosswalkFrame.endpoints; const movedRing = (ring) => ring.map((point) => { const rawRatio = projectionRatio(point, start, end); const contactRatio = arm.crosswalkFrame.contactEndpointRatio || 0; const ratio = Math.max(0, Math.min(1, (rawRatio - contactRatio) / (1 - contactRatio * 2))); const shift = [ offsets[0][0] * (1 - ratio) + offsets[1][0] * ratio, offsets[0][1] * (1 - ratio) + offsets[1][1] * ratio, ]; return [point[0] + shift[0], point[1] + shift[1]]; }); for (const crossing of crosswalks) { if (crossing.properties.arm_key === arm.key) crossing.geometry.coordinates[0] = movedRing(crossing.geometry.coordinates[0]); } // Preserve the original full crossing footprint and pave the swept // connection to its new position, including the gaps between white bars. const frame = arm.crosswalkFrame; const corners = rectangle(frame.center, frame.heading, frame.groupDepth, frame.spanMeters); const originalRegion = []; // Split at the same endpoint clamps used by movedRing. A four-vertex // rectangle would interpolate across those clamps and cut off the bars. const contactRatio = frame.contactEndpointRatio || 0; for (let edge = 0; edge < 4; edge++) { const ratios = edge % 2 === 0 ? [0, contactRatio, 1 - contactRatio] : [0]; for (const ratio of ratios) { originalRegion.push(corners[edge].map((value, axis) => value + (corners[edge + 1][axis] - value) * ratio)); } } originalRegion.push(originalRegion[0]); const movedRegion = movedRing(originalRegion); crossingRegions.push(movedRegion); for (let edge = 0; edge < originalRegion.length - 1; edge++) { crossingRegions.push([ originalRegion[edge], originalRegion[edge + 1], movedRegion[edge + 1], movedRegion[edge], originalRegion[edge], ]); } const averageShift = [(offsets[0][0] + offsets[1][0]) / 2, (offsets[0][1] + offsets[1][1]) / 2]; for (const stopLine of stopLines) { if (stopLine.properties.arm_key !== arm.key) continue; stopLine.geometry.coordinates[0] = stopLine.geometry.coordinates[0].map((point) => [ point[0] + averageShift[0], point[1] + averageShift[1], ]); } } } const features = []; let coreFeature = null; if (coreRing) coreFeature = { type: 'Feature', properties: { native_id: `complex-junction:${cluster.id}:core`, cluster_id: cluster.id, kind: 'complex-core', complex_part: 'core', center, radius_m: coreRadius, configured_radius_m: cluster.coreRadiusMeters, approach_count: approaches.length, carriageway_count: carriageways.length, shape_kind: shape.kind, shape_label: shape.label, arm_count: arms.length, through_pair_count: shape.throughPairCount, approach_headings: sorted.map((item) => Math.round(item.heading * 10) / 10), boundary_refs: coreClosure.sharedEdgeRefs, closure_count: coreClosure.closureCount, shared_seam_error_m: coreClosure.maxSharedSeamErrorMeters, shared_seam_errors: coreClosure.sharedSeamErrors, connected_entry_count: coreClosure.connectedEntryCount, required_pavement_connected: coreClosure.requiredPavementConnected, core_ring_area: coreClosure.ringArea, core_ring_self_intersects: coreClosure.ringSelfIntersects, exclusion_hole_count: (coreClosure.holes || []).length, region_status: coreClosure.holes?.length ? 'supported-with-holes' : 'supported', provenance: 'native-road-complex-junction/v7-shared-entry-core', }, geometry: { type: 'Polygon', coordinates: [coreRing, ...(coreClosure.holes || [])] }, }; if (coreRing && coreClosure.maxSharedSeamErrorMeters > 0.01) { cornerDiagnostics.push( helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-shared-seam-exceeds-tolerance', `核心区域与入口断面的最大接缝误差为 ${coreClosure.maxSharedSeamErrorMeters.toFixed(3)} 米,超过 1 厘米验收阈值。`, center, ), ); } else if (!coreRing) { cornerDiagnostics.push( helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-core-closure-unsupported', `路口中心区域缺少可验证的闭合边(${coreClosure.reason}),已保留各进口道路面。`, center, ), ); } for (const { item, section } of boundaryParts) { const ring = section.ring; features.push({ type: 'Feature', properties: { native_id: `complex-junction:${cluster.id}:carriageway:${item.approach.segmentId}`, cluster_id: cluster.id, kind: 'complex-approach', object_key: item.key, carriageway_key: item.key, arm_key: item.armKey, complex_part: 'carriageway', heading_deg: item.heading, lane_count: item.approach.roadIds.reduce( (sum, roadId) => sum + (model.roads.find((road) => road.id === roadId)?.laneCount || 0), 0, ), width_m: item.approach.widthMeters, outer_width_m: section.outerWidthMeters, inner_width_m: section.innerWidthMeters, transition_length_m: Math.round(section.transitionMeters * 10) / 10, transition_status: section.transitionStatus, ring_status: section.ringStatus, exclusion_status: section.exclusionStatus, ...(section.exclusionRegionId ? { exclusion_region_id: section.exclusionRegionId } : {}), boundary_refs: section.edgeRefs, provenance: 'native-road-complex-junction/v6-shared-transition-sections', }, geometry: { type: 'Polygon', coordinates: [ring] }, }); } // Corner fills come last so they overlay the rectangular carriageway ends // they are smoothing; they never replace an OSM-derived road surface. features.push(...cornerFills); if (coreFeature) features.push(coreFeature); // Publish a single canonical pavement region last. The individual approach, // core and corner polygons above remain structural inputs for editing and // diagnostics; they are no longer the visible authority at the junction. const basePavement = features.map((feature) => feature.geometry.coordinates[0]); const pavementRegion = solveComplexPavementRegion(basePavement, crossingRegions); if (pavementRegion.status === 'supported') { for (const feature of features) feature.properties.pavement_input = true; features.push({ type: 'Feature', properties: { native_id: `complex-junction:${cluster.id}:pavement-region`, cluster_id: cluster.id, kind: 'complex-pavement-region', complex_part: 'pavement-region', center, region_status: 'supported', region_input_count: pavementRegion.inputCount, crossing_connector_count: 0, provenance: 'native-road-complex-junction-pavement-region/v1', }, geometry: { type: 'MultiPolygon', coordinates: pavementRegion.regions }, }); } else cornerDiagnostics.push( helpers.diagnostic( 'warning', `junction-cluster:${cluster.id}`, [...nodeIds], pavementRegion.status === 'unsupported' ? 'complex-junction-pavement-region-assembly-failed' : 'complex-junction-pavement-region-disconnected', pavementRegion.status === 'unsupported' ? '统一铺装区域无法可靠装配,保留结构输入面并拒绝发布统一铺装面。' : '过街与入口无法组成连续铺装区域,保留结构输入面并拒绝发布统一铺装面。', center, ), ); // `coreRadiusMeters` is only consulted when there is no reference geometry. // Under calibration the radius comes from the reference span, so a configured // value that silently does nothing has to be reported, not swallowed. const configuredRadiusIgnored = calibration && Number.isFinite(cluster.coreRadiusMeters) && Math.abs(coreRadius - cluster.coreRadiusMeters) > 0.5; const configurationDiagnostics = configuredRadiusIgnored ? [ helpers.diagnostic( 'info', `junction-cluster:${cluster.id}`, [...nodeIds], 'complex-junction-configured-radius-ignored', `已按参考几何校准核心半径为 ${Math.round(coreRadius * 10) / 10} 米,配置的 coreRadiusMeters=${cluster.coreRadiusMeters} 在有参考文件时不生效。`, center, ), ] : []; const knownIslandFeatures = (model.exclusionRegions || []) .filter( (region) => Array.isArray(region.ring) && region.ring.length >= 4 && region.ring.some((point) => helpers.distanceMeters(point, center) <= outerRadius + 12), ) .map((region) => ({ type: 'Feature', properties: { native_id: `osm-traffic-island:${region.id}`, object_key: `island:osm/${region.id}`, kind: 'island', osm_way_ids: String(region.id), source: region.source, facility_evidence: 'source-osm-region', }, geometry: { type: 'Polygon', coordinates: [region.ring] }, })); const allFeatures = [ ...features, ...islands, ...sidewalkCorners, ...crosswalks, ...stopLines, ...knownIslandFeatures, ]; const structure = structureFromTopology(topology, shape, center, allFeatures); for (const feature of allFeatures) { feature.properties.junction_key = structure.junctionKey; feature.properties.topology_fingerprint = structure.topologyFingerprint; } // Persist the compiler authority with a generated road surface, including the // supported-shape case where only the central polygon had to be skipped. const carrier = features.find((feature) => feature.properties.kind === 'complex-core') || features[0]; if (carrier) carrier.properties.junction_structure = structure; return { structure, features, islands: [...islands, ...sidewalkCorners], crosswalks, stopLines, center, shape, approaches, diagnostics: [ ...transitionDiagnostics, ...cornerDiagnostics, ...configurationDiagnostics, helpers.diagnostic( 'info', `junction-cluster:${cluster.id}`, [...nodeIds], calibration ? 'complex-junction-reference-calibrated' : 'complex-junction-generated', calibration ? `已识别为${shape.label},使用参考几何校准参数后重新生成 ${approaches.length} 个进口、道路面、${crosswalks.length} 组斑马线和停止线。` : `已识别为${shape.label},独立生成 ${approaches.length} 个进口、道路面、${crosswalks.length} 组斑马线和停止线。`, center, ), ], }; } function buildComplexApproachBoundaryGraph(topology, center, cluster, helpers, exclusionRegions = []) { const metrics = complexJunctionMetrics(cluster); return buildJunctionBoundaryGraph( topology, center, { outerRadiusFor: (item) => Math.max(metrics.coreRadius + 4, metrics.approachOuterRadius - Math.max(0, Number(item.approach.cutback) || 0)), innerRadiusFor: () => metrics.approachInnerRadius, }, helpers, exclusionRegions, ); } function classifyJunctionShape(arms, center, helpers) { const headings = arms.map((arm) => arm.heading); const throughPairs = []; for (let first = 0; first < headings.length; first += 1) { for (let second = first + 1; second < headings.length; second += 1) { const delta = Math.abs(normalizeHeading(headings[first] - headings[second])); if (delta >= 155) throughPairs.push([first, second]); } } const sorted = [...headings].sort((a, b) => a - b); const gaps = sorted.map((heading, index) => positiveHeadingDelta(heading, sorted[(index + 1) % sorted.length])); const hasRightAngleCross = arms.length === 4 && gaps.filter((gap) => gap >= 55 && gap <= 125).length >= 3 && throughPairs.length >= 2; const hasOppositePair = throughPairs.length >= 1; if (arms.length === 3 && hasOppositePair) return { kind: 't-junction', label: '3 臂 T 字路口', throughPairCount: throughPairs.length }; if (hasRightAngleCross) { const centers = arms.map((arm) => arm.members[0]?.approach?.line?.at?.(-1)).filter(Boolean); const spread = centers.length === arms.length ? Math.max(...centers.map((point) => helpers.distanceMeters(point, center))) - Math.min(...centers.map((point) => helpers.distanceMeters(point, center))) : 0; return { kind: spread > 12 ? 'offset-cross' : 'cross', label: spread > 12 ? '4 臂偏置十字路口' : '4 臂十字路口', throughPairCount: throughPairs.length, }; } if (arms.length >= 3 && arms.length <= 8) { return { kind: 'multi-arm', label: `${arms.length} 臂非规则路口`, throughPairCount: throughPairs.length }; } return { kind: 'unsupported', label: '暂不支持的路口形态', throughPairCount: throughPairs.length }; } function readReferenceCalibration(cluster) { if (!cluster.referenceFile || !fs.existsSync(cluster.referenceFile)) return null; try { const converted = convertGeoJson(JSON.parse(fs.readFileSync(cluster.referenceFile, 'utf8'))); const bounds = boundsOf({ features: converted.features.filter((feature) => [1, 2, 3, 4].includes(Number(feature.properties?.type))), }); const lonScale = 111320 * Math.cos((((bounds.minLat + bounds.maxLat) / 2) * Math.PI) / 180); return { longSpanMeters: (bounds.maxLon - bounds.minLon) * lonScale, shortSpanMeters: (bounds.maxLat - bounds.minLat) * 111320, }; } catch (_) { return null; } } function complexJunctionMetrics(cluster) { if (metricsCache.has(cluster)) return metricsCache.get(cluster); const calibration = readReferenceCalibration(cluster); const metrics = calculateComplexJunctionMetrics(cluster, calibration); metricsCache.set(cluster, metrics); return metrics; } function normalizeHeading(value) { return ((((value + 180) % 360) + 360) % 360) - 180; } // `arm.heading` points outward from the junction, so the corner clockwise from // it sits at heading+90 and the one counter-clockwise at heading-90. A road's // own sidewalk flags are relative to its digitisation direction, so flip them // whenever the arm runs against that direction. function armCarriesSidewalk(arm, model, cornerIsClockwise) { return arm.members.some((member) => member.approach.roadIds .map((roadId) => model.roads.find((road) => road.id === roadId)) .filter(Boolean) .some((road) => { const outwardIsForward = String(road.sourceNodeIds[0]) === String(member.nodeId); const onClockwiseSide = outwardIsForward ? road.sidewalkRight : road.sidewalkLeft; const onCounterClockwiseSide = outwardIsForward ? road.sidewalkLeft : road.sidewalkRight; return Boolean(cornerIsClockwise ? onClockwiseSide : onCounterClockwiseSide); }), ); } // Use the emitted strip's complete end edge, including its actual width and // orientation. A radius extension cannot guarantee this seam on curved roads. function exteriorSidewalkSeam(edge, graph, helpers) { const section = graph.sections.find((item) => item.carriagewayKey === edge.carriagewayKey); if ( !section || section.ringStatus !== 'supported' || section.transitionStatus !== 'supported' || section.exclusionStatus !== 'clear' ) return null; const target = edge.side === 90 ? section.outer.right : section.outer.left; for (const feature of helpers.exteriorSidewalks || []) { const ids = String(feature.properties.directional_road_ids || '').split(','); if (!edge.roadIds.some((id) => ids.includes(String(id)))) continue; const ring = feature.geometry.coordinates[0]; const half = (ring.length - 1) / 2; for (const [curb, outer] of [ [ring[0], ring[ring.length - 2]], [ring[half - 1], ring[half]], ]) { if (helpers.distanceMeters(curb, target) <= 0.01) return { curb, outer }; } } return null; } // Offset each vertex along the polyline normal that increases distance from the // junction centre. The curb is star-shaped around that centre, so "farther from // the centre" is a reliable stand-in for "on the pedestrian side". function offsetPolylineAwayFromCenter(points, center, meters, helpers) { return points.map((point, index) => { const previous = points[Math.max(0, index - 1)]; const next = points[Math.min(points.length - 1, index + 1)]; const tangent = previous === next ? 0 : bearing(previous, next); return [tangent + 90, tangent - 90] .map((heading) => helpers.offsetCoordinate(point, heading, meters)) .sort((first, second) => helpers.distanceMeters(second, center) - helpers.distanceMeters(first, center))[0]; }); } 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 angleAround(center, point) { return Math.atan2(point[1] - center[1], point[0] - center[0]); } function signedLateralMeters(origin, point, heading) { const east = (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180); const north = (point[1] - origin[1]) * 111320; const radians = ((heading + 90) * Math.PI) / 180; return east * Math.sin(radians) + north * Math.cos(radians); } function bearing(first, second) { const east = (second[0] - first[0]) * Math.cos((first[1] * Math.PI) / 180); const north = second[1] - first[1]; return (Math.atan2(east, north) * 180) / Math.PI; } function midpoint(first, second) { return [(first[0] + second[0]) / 2, (first[1] + second[1]) / 2]; } function averageHeading(headings) { const vector = headings.reduce( (sum, heading) => { const radians = (heading * Math.PI) / 180; return [sum[0] + Math.sin(radians), sum[1] + Math.cos(radians)]; }, [0, 0], ); return (Math.atan2(vector[0], vector[1]) * 180) / Math.PI; } function positiveHeadingDelta(first, second) { return (((second - first) % 360) + 360) % 360; } function pointOnCarriagewayRadius(item, center, radius, helpers) { const station = stationAtDistanceFrom(item.approach.line, center, radius, helpers); return helpers.pointAlongLine(item.approach.line, Math.max(0, Math.min(item.length, station))); } function armEnvelopeAtRadius(arm, radius, center, helpers) { if (!arm.members.length) return null; const centers = arm.members.map((member) => pointOnCarriagewayRadius(member, center, radius, helpers)); const reference = centers[0]; let minimum = Infinity; let maximum = -Infinity; centers.forEach((point, index) => { const lateral = signedLateralMeters(reference, point, arm.heading); const halfWidth = arm.members[index].approach.widthMeters / 2; minimum = Math.min(minimum, lateral - halfWidth); maximum = Math.max(maximum, lateral + halfWidth); }); if (!Number.isFinite(minimum) || maximum - minimum < 1) return null; return { center: helpers.offsetCoordinate(reference, arm.heading + 90, (minimum + maximum) / 2), widthMeters: maximum - minimum, }; } function crossingEvidenceForArm(model, arm, center, helpers) { const osmWayIds = new Set( arm.members.flatMap((member) => member.roads.flatMap((road) => (road.osmWayIds || []).map(String))), ); const maximumDistance = Math.max( 8, arm.members.reduce((width, member) => width + member.approach.widthMeters, 0) / 2 + 3, ); const crossings = (model.crossings || []) .filter( (crossing) => (crossing.osmWayIds || []).some((wayId) => osmWayIds.has(String(wayId))) && helpers.distanceMeters(crossing.coordinate, center) <= maximumDistance, ) .sort( (first, second) => helpers.distanceMeters(first.coordinate, center) - helpers.distanceMeters(second.coordinate, center) || String(first.id).localeCompare(String(second.id)), ); const crossingNodeIds = crossings.map((crossing) => String(crossing.id)); return { kind: crossingNodeIds.length ? 'source-crossing-node' : 'unknown-no-crossing-source', crossingNodeIds, crossing: crossings[0] || null, }; } function cornerEdgeAt(arm, radius, bisector, center, helpers) { const candidates = arm.members.flatMap((member) => { const point = pointOnCarriagewayRadius(member, center, radius, helpers); const halfWidth = member.approach.widthMeters / 2; return [90, -90].map((side) => ({ point: helpers.offsetCoordinate(point, member.heading + side, halfWidth), heading: member.heading, carriagewayKey: member.key, roadIds: member.approach.roadIds, side, })); }); return ( candidates.sort( (first, second) => directionalProjectionMeters(center, second.point, bisector) - directionalProjectionMeters(center, first.point, bisector), )[0] || null ); } function rayIntersection(first, second, origin) { const lonScale = 111320 * Math.cos((origin[1] * Math.PI) / 180); const toLocal = (point) => [(point[0] - origin[0]) * lonScale, (point[1] - origin[1]) * 111320]; const direction = (heading) => { const radians = (heading * Math.PI) / 180; return [Math.sin(radians), Math.cos(radians)]; }; const firstPoint = toLocal(first.point); const secondPoint = toLocal(second.point); const firstDirection = direction(first.heading); const secondDirection = direction(second.heading); const denominator = firstDirection[0] * secondDirection[1] - firstDirection[1] * secondDirection[0]; if (Math.abs(denominator) < 1e-4) return null; const delta = [secondPoint[0] - firstPoint[0], secondPoint[1] - firstPoint[1]]; const distanceAlongFirst = (delta[0] * secondDirection[1] - delta[1] * secondDirection[0]) / denominator; const local = [ firstPoint[0] + firstDirection[0] * distanceAlongFirst, firstPoint[1] + firstDirection[1] * distanceAlongFirst, ]; if (!local.every(Number.isFinite)) return null; return [origin[0] + local[0] / lonScale, origin[1] + local[1] / 111320]; } function quadraticCurve(start, control, end, segments) { const result = []; for (let index = 0; index <= segments; index += 1) { const t = index / segments; const u = 1 - t; result.push([ u * u * start[0] + 2 * u * t * control[0] + t * t * end[0], u * u * start[1] + 2 * u * t * control[1] + t * t * end[1], ]); } return result; } function directionalProjectionMeters(origin, point, heading) { const east = (point[0] - origin[0]) * 111320 * Math.cos((origin[1] * Math.PI) / 180); const north = (point[1] - origin[1]) * 111320; const radians = (heading * Math.PI) / 180; return east * Math.sin(radians) + north * Math.cos(radians); } function polygonCenter(ring) { const points = ring.slice(0, -1); return points.reduce((sum, point) => [sum[0] + point[0] / points.length, sum[1] + point[1] / points.length], [0, 0]); } function projectionRatio(point, start, end) { const lonScale = 111320 * Math.cos((start[1] * Math.PI) / 180); const vector = [(end[0] - start[0]) * lonScale, (end[1] - start[1]) * 111320]; const relative = [(point[0] - start[0]) * lonScale, (point[1] - start[1]) * 111320]; const lengthSquared = vector[0] * vector[0] + vector[1] * vector[1]; if (lengthSquared < 1e-12) return 0; return Math.max(0, Math.min(1, (relative[0] * vector[0] + relative[1] * vector[1]) / lengthSquared)); } module.exports = { resolveComplexJunctionTopology, buildComplexJunctionGeometry, buildComplexApproachBoundaryGraph, classifyJunctionShape, complexJunctionMetrics, };