56 lines
4.2 KiB
JavaScript
56 lines
4.2 KiB
JavaScript
'use strict';
|
|
|
|
// Research probe: --expect-bug reproduces the recorded pre-fix behavior.
|
|
// Without that flag, verifies the corrected final-pavement contract.
|
|
// Run from the repository root: node .trellis/tasks/09-17-junction-exclusion-routing/probe.cjs
|
|
const fs = require('fs');
|
|
const path = require('path');
|
|
const assert = require('assert/strict');
|
|
const root = process.cwd();
|
|
const { compileRoadModel, compileGeometry } = require(path.join(root, 'src/compile/native-road'));
|
|
const { solvePavedRegion } = require(path.join(root, 'src/compile/junction-region-solver'));
|
|
const { solveComplexPavementRegion } = require(path.join(root, 'src/compile/junction-pavement-region'));
|
|
const clipping = require(path.join(root, 'node_modules/polygon-clipping'));
|
|
const model = compileRoadModel(fs.readFileSync(path.join(root, 'inputs/osm/枫树二路.osm'), 'utf8'), { overrides: [] });
|
|
const cluster = { id: 'exclusion-probe', template: 'complex-junction-v1', coreRadiusMeters: 21, nodeIds: ['8005332807', '8024512135', '8024512145', '8024512147'] };
|
|
const options = { junctionTemplates: { enabled: true, clusters: [cluster] } };
|
|
const compile = (exclusionRegions = []) => compileGeometry({ ...model, exclusionRegions }, { overrides: [] }, options);
|
|
const base = compile();
|
|
const core = base.roadSurface.features.find((f) => f.properties.kind === 'complex-core');
|
|
assert.ok(core);
|
|
const origin = core.properties.center;
|
|
const scale = 111320 * Math.cos(origin[1] * Math.PI / 180);
|
|
const xy = (p) => [(p[0] - origin[0]) * scale, (p[1] - origin[1]) * 111320];
|
|
const ll = (p) => [origin[0] + p[0] / scale, origin[1] + p[1] / 111320];
|
|
const rectangle = (x1, y1, x2, y2) => [[x1, y1], [x2, y1], [x2, y2], [x1, y2], [x1, y1]];
|
|
const area = (regions) => regions.reduce((sum, polygon) => sum + polygon.reduce((sum, ring, index) => sum + (index ? -1 : 1) * Math.abs(ring.slice(1).reduce((sum, q, i) => sum + ring[i][0] * q[1] - q[0] * ring[i][1], 0)) / 2, 0), 0);
|
|
const regions = (feature) => (feature.geometry.type === 'Polygon' ? [feature.geometry.coordinates] : feature.geometry.coordinates).map((p) => p.map((r) => r.map(xy)));
|
|
const hole = rectangle(-0.5, -0.5, 0.5, 0.5).map(ll);
|
|
const approach = base.roadSurface.features.find((f) => f.properties.kind === 'complex-approach');
|
|
const cases = [
|
|
{ name: 'interior-hole', exclusion: { id: 'protected-hole', isHole: true, ring: hole } },
|
|
{ name: 'interior-obstacle', exclusion: { id: 'protected-obstacle', ring: hole } },
|
|
{ name: 'blocked-entry', exclusion: { id: 'blocked-entry', ring: approach.geometry.coordinates[0] } },
|
|
{ name: 'split-core', exclusion: { id: 'split-core', ring: rectangle(-0.5, -100, 0.5, 100).map(ll) } },
|
|
];
|
|
const results = cases.map(({ name, exclusion }) => {
|
|
const geometry = compile([exclusion]);
|
|
const surfaces = geometry.roadSurface.features.filter((f) => ['complex-core', 'complex-pavement-region'].includes(f.properties.kind)).map((f) => ({
|
|
kind: f.properties.kind,
|
|
rings: regions(f).map((p) => p.length),
|
|
overlapSquareMeters: area(clipping.intersection(regions(f), [[exclusion.ring.map(xy)]])),
|
|
}));
|
|
return { name, surfaces, approachCount: geometry.roadSurface.features.filter((f) => f.properties.kind === 'complex-approach').length, diagnostics: geometry.diagnostics.filter((d) => /exclusion|known-region|closure|pavement-region/.test(d.rule)).map(({ rule, subjectId, message }) => ({ rule, subjectId, message })) };
|
|
});
|
|
const holeResult = results[0];
|
|
assert.equal(holeResult.surfaces.find((f) => f.kind === 'complex-core').overlapSquareMeters, 0);
|
|
const finalOverlap = holeResult.surfaces.find((f) => f.kind === 'complex-pavement-region').overlapSquareMeters;
|
|
if (process.argv.includes('--expect-bug')) assert.ok(finalOverlap > 0.99, 'Expected original hole-filling defect');
|
|
else assert.ok(finalOverlap < 0.000001, 'Final pavement must preserve the explicit hole');
|
|
const shell = rectangle(-10, -10, 10, 10);
|
|
const divided = solvePavedRegion(shell, [rectangle(-1, -11, 1, 11)]);
|
|
assert.equal(divided.length, 2);
|
|
const assembled = solveComplexPavementRegion(divided.map((p) => p[0]));
|
|
assert.equal(assembled.status, 'disconnected');
|
|
console.log(JSON.stringify({ cases: results, splitSolver: { components: divided.length, assemblyStatus: assembled.status } }, null, 2));
|