mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 08:12:24 +00:00
At the ~20 px the fleet renders at, the bus, tram, metro and unknown glyphs were near-symmetric boxes: rotated along the course, nothing showed which end was the front. Each now has a front built into its outline (an arrow-like nose for the bus, a pointed cab for the tram, a chamfered cab for the metro), so it survives the tint, the halo and the sensor profiles, which keep only the outline. A vehicle with no known course sits at rotation 0, where a pointed glyph would claim it is heading north. Those vehicles, fleet and selected alike, now get a symmetric outline (rail and ferry included) and switch to the pointed one once a course arrives. The raster cache doubles to a fixed 72 variants. Co-Authored-By: Claude Opus 5.5 <[email protected]>
305 lines
11 KiB
JavaScript
305 lines
11 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import {
|
|
FLEET_SCREEN_PX,
|
|
TRANSIT_ICON_KINDS,
|
|
haloFrame,
|
|
transitIcon,
|
|
transitIconCacheSize,
|
|
} from './transitIcons.js';
|
|
|
|
const decode = (uri) =>
|
|
Buffer.from(uri.replace('data:image/svg+xml;base64,', ''), 'base64').toString(
|
|
'utf8',
|
|
);
|
|
|
|
test('a halo is sized in screen pixels and pads the frame so it cannot clip', () => {
|
|
const none = haloFrame(0);
|
|
assert.deepEqual(none, { units: 0, pad: 0, ratio: 1 });
|
|
const two = haloFrame(2, FLEET_SCREEN_PX);
|
|
// Two pixels of ring on an eighteen-pixel glyph is a 4-px stroke: 21.3 of 96 units.
|
|
assert.ok(Math.abs(two.units - (4 * 96) / 20) < 1e-9);
|
|
assert.ok(
|
|
two.pad >= two.units / 2,
|
|
'padding covers the half-stroke outside the body',
|
|
);
|
|
assert.ok(two.ratio > 1, 'and the billboard grows by the same ratio');
|
|
});
|
|
|
|
test('a haloed glyph draws the dark ring under the shipped white body', () => {
|
|
const plain = decode(transitIcon('bus'));
|
|
const haloed = decode(transitIcon('bus', 48, { haloScreenPx: 2 }));
|
|
assert.notEqual(plain, haloed);
|
|
assert.match(
|
|
haloed,
|
|
/stroke="#05080C" stroke-opacity="1" stroke-width="14\.77"/,
|
|
);
|
|
assert.ok(
|
|
haloed.indexOf('#05080C') < haloed.indexOf('fill="white"'),
|
|
'ring first, body on top',
|
|
);
|
|
assert.match(haloed, /viewBox="-\d+ -\d+ \d+ \d+"/, 'padded frame');
|
|
assert.match(plain, /stroke-width="9\.60"/, 'normal has a one-pixel halo');
|
|
});
|
|
|
|
test('the raster cache is bounded by kind, size and halo — never by call count', () => {
|
|
const before = transitIconCacheSize();
|
|
for (let i = 0; i < 50; i += 1) {
|
|
transitIcon('tram', 48, { haloScreenPx: 2 });
|
|
transitIcon('tram', 48);
|
|
transitIcon('tram', 128, { haloScreenPx: 1.25 });
|
|
}
|
|
assert.ok(
|
|
transitIconCacheSize() - before <= 3,
|
|
`three variants, not ${transitIconCacheSize() - before}`,
|
|
);
|
|
assert.equal(
|
|
transitIcon('tram', 48, { haloScreenPx: 2 }),
|
|
transitIcon('tram', 48, { haloScreenPx: 2 }),
|
|
);
|
|
for (const kind of TRANSIT_ICON_KINDS)
|
|
transitIcon(kind, 48, { haloScreenPx: 2 });
|
|
assert.ok(transitIconCacheSize() <= before + 3 + TRANSIT_ICON_KINDS.length);
|
|
});
|
|
|
|
test('all 72 variants retain the specified final halo at both display sizes', async () => {
|
|
const { presetSpriteScale, presetSpriteOutlinePx } =
|
|
await import('./transitPresetStyle.js');
|
|
for (const kind of TRANSIT_ICON_KINDS) {
|
|
for (const selected of [false, true]) {
|
|
for (const style of ['normal', 'thermal', 'retro'])
|
|
for (const heading of [true, false]) {
|
|
const display =
|
|
(selected ? 30 : 20) * presetSpriteScale(style, selected);
|
|
const svg = decode(
|
|
transitIcon(kind, selected ? 96 : 48, { style, heading }),
|
|
);
|
|
const units = Number(
|
|
svg.match(/stroke-opacity="(?:0.95|1)" stroke-width="([\d.]+)"/)[1],
|
|
);
|
|
assert.ok(
|
|
Math.abs(
|
|
(units * display) / 192 - presetSpriteOutlinePx(style, selected),
|
|
) < 0.001,
|
|
);
|
|
const frame = haloFrame(
|
|
presetSpriteOutlinePx(style, selected),
|
|
display,
|
|
);
|
|
assert.match(
|
|
svg,
|
|
new RegExp(
|
|
`width="${Math.round((selected ? 96 : 48) * frame.ratio)}"`,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
for (let i = 0; i < 100; i++)
|
|
transitIcon('invalid', i, { haloScreenPx: i, screenPx: i });
|
|
assert.equal(transitIconCacheSize(), 72);
|
|
});
|
|
|
|
test('every mono raster preserves the normal silhouette mask and aspect at CRT display size', async () => {
|
|
const sharp = (await import('sharp')).default;
|
|
const { presetSpriteScale, presetSpriteOutlinePx } =
|
|
await import('./transitPresetStyle.js');
|
|
const rasterBody = async (svg) => {
|
|
// Compare fills in the same frame; the separately tested external halo is excluded.
|
|
const d =
|
|
[...svg.matchAll(/<path d="([^"]+)" fill="white"/g)][0]?.[1] ??
|
|
svg.match(/<path d="([^"]+)"\s+fill="white"/)[1];
|
|
const { data, info } = await sharp(
|
|
Buffer.from(
|
|
`<svg xmlns="http://www.w3.org/2000/svg" width="192" height="192" viewBox="-48 -48 96 96"><path d="${d}" fill="white"/></svg>`,
|
|
),
|
|
)
|
|
.ensureAlpha()
|
|
.raw()
|
|
.toBuffer({ resolveWithObject: true });
|
|
const mask = [];
|
|
let minX = info.width,
|
|
minY = info.height,
|
|
maxX = 0,
|
|
maxY = 0;
|
|
for (let y = 0; y < info.height; y++)
|
|
for (let x = 0; x < info.width; x++) {
|
|
const alpha = data[(y * info.width + x) * 4 + 3];
|
|
mask.push(alpha);
|
|
if (alpha > 127) {
|
|
minX = Math.min(minX, x);
|
|
maxX = Math.max(maxX, x);
|
|
minY = Math.min(minY, y);
|
|
maxY = Math.max(maxY, y);
|
|
}
|
|
}
|
|
return { mask, aspect: (maxX - minX + 1) / (maxY - minY + 1) };
|
|
};
|
|
for (const selected of [false, true])
|
|
for (const heading of [true, false])
|
|
for (const kind of TRANSIT_ICON_KINDS) {
|
|
const normal = await rasterBody(
|
|
decode(
|
|
transitIcon(kind, selected ? 96 : 48, { style: 'normal', heading }),
|
|
),
|
|
);
|
|
for (const style of ['surveillance', 'thermal', 'noir', 'nvg']) {
|
|
const svg = decode(
|
|
transitIcon(kind, selected ? 96 : 48, { style, heading }),
|
|
);
|
|
const mono = await rasterBody(svg);
|
|
assert.deepEqual(
|
|
mono.mask,
|
|
normal.mask,
|
|
`${kind}/${style}: no envelope`,
|
|
);
|
|
assert.ok(
|
|
Math.abs(mono.aspect / normal.aspect - 1) <= 0.05,
|
|
`${kind}/${style}: aspect`,
|
|
);
|
|
const display =
|
|
(selected ? 30 : 20) * presetSpriteScale(style, selected);
|
|
const crt =
|
|
(selected ? 30 : 20) * presetSpriteScale('retro', selected);
|
|
assert.equal(display, crt);
|
|
const frame = haloFrame(
|
|
presetSpriteOutlinePx(style, selected),
|
|
display,
|
|
);
|
|
const crtFrame = haloFrame(
|
|
presetSpriteOutlinePx('retro', selected),
|
|
crt,
|
|
);
|
|
assert.equal(
|
|
(display * frame.ratio) / frame.ratio,
|
|
(crt * crtFrame.ratio) / crtFrame.ratio,
|
|
'unpadded silhouette matches CRT; only external halo padding grows',
|
|
);
|
|
assert.equal(
|
|
(svg.match(/<path /g) || []).length,
|
|
2,
|
|
'only outer halo and opaque silhouette',
|
|
);
|
|
assert.match(svg, /fill="white" \/>/);
|
|
}
|
|
}
|
|
});
|
|
|
|
test('sensor raster halo stays dark across its screen-space band on a white roof', async () => {
|
|
const sharp = (await import('sharp')).default;
|
|
const { presetSpriteScale, presetSpriteOutlinePx } =
|
|
await import('./transitPresetStyle.js');
|
|
const { reduceSensorContrast } =
|
|
await import('../layers/transit/qaMetrics.js');
|
|
const sides = {
|
|
bus: 17,
|
|
tram: 10,
|
|
subway: 11.5,
|
|
rail: 10.5,
|
|
ferry: 12.5,
|
|
unknown: 10,
|
|
};
|
|
for (const selected of [false, true]) {
|
|
const pixels = [];
|
|
for (const kind of TRANSIT_ICON_KINDS) {
|
|
const display =
|
|
(selected ? 30 : 20) * presetSpriteScale('thermal', selected);
|
|
const frame = haloFrame(
|
|
presetSpriteOutlinePx('thermal', selected),
|
|
display,
|
|
);
|
|
const size = Math.round(display * frame.ratio * 8);
|
|
const svg = decode(
|
|
transitIcon(kind, selected ? 96 : 48, { style: 'thermal' }),
|
|
);
|
|
const { data, info } = await sharp(Buffer.from(svg))
|
|
.resize(size, size)
|
|
.flatten({ background: '#ffffff' })
|
|
.raw()
|
|
.toBuffer({ resolveWithObject: true });
|
|
const sample = (offsetPx) => {
|
|
const x = Math.floor(
|
|
size / 2 + (offsetPx * size) / (display * frame.ratio),
|
|
);
|
|
const i = (Math.floor(size / 2) * info.width + x) * info.channels;
|
|
return (
|
|
(0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2]) / 255
|
|
);
|
|
};
|
|
// The body stays at CRT size; the ring must cover this fixed external band.
|
|
const ringMin = sample((sides[kind] * display) / 96 + 1.25);
|
|
pixels.push({
|
|
key: kind,
|
|
verified: true,
|
|
centre: sample(0),
|
|
ringMin,
|
|
ringMax: 1 - ringMin,
|
|
background: 1,
|
|
});
|
|
}
|
|
const white = reduceSensorContrast(pixels, 'white', 'thermal');
|
|
assert.ok(white.pass, JSON.stringify({ selected, pixels, white }));
|
|
const black = reduceSensorContrast(
|
|
pixels.map((p) => ({ ...p, centre: 1 - p.centre })),
|
|
'black',
|
|
'thermal',
|
|
);
|
|
assert.ok(black.pass, JSON.stringify({ selected, black }));
|
|
}
|
|
});
|
|
|
|
test('a vehicle with a course shows its front; one without claims no direction', async () => {
|
|
const sharp = (await import('sharp')).default;
|
|
const outline = (svg) => svg.match(/<path d="([^"]+)"\s+fill="white"/)[1];
|
|
// Fleet-size raster of the outline alone: row widths from front to back.
|
|
const rows = async (d) => {
|
|
const { data, info } = await sharp(
|
|
Buffer.from(
|
|
`<svg xmlns="http://www.w3.org/2000/svg" width="96" height="96" viewBox="-48 -48 96 96"><path d="${d}" fill="white"/></svg>`,
|
|
),
|
|
)
|
|
.resize(20, 20)
|
|
.ensureAlpha()
|
|
.raw()
|
|
.toBuffer({ resolveWithObject: true });
|
|
const out = [];
|
|
for (let y = 0; y < info.height; y++) {
|
|
let sum = 0;
|
|
for (let x = 0; x < info.width; x++)
|
|
sum += data[(y * info.width + x) * 4 + 3] / 255;
|
|
out.push(sum);
|
|
}
|
|
return out;
|
|
};
|
|
// How much the outline differs from itself turned end for end, in pixels.
|
|
const asymmetry = (r) =>
|
|
r.reduce((a, v, i) => a + Math.abs(v - r[r.length - 1 - i]), 0);
|
|
for (const kind of TRANSIT_ICON_KINDS) {
|
|
const pointed = await rows(outline(decode(transitIcon(kind))));
|
|
const neutral = await rows(
|
|
outline(decode(transitIcon(kind, 48, { heading: false }))),
|
|
);
|
|
assert.ok(
|
|
asymmetry(pointed) >= 2.5,
|
|
`${kind}: front reads at 20 px (${asymmetry(pointed).toFixed(2)})`,
|
|
);
|
|
assert.ok(
|
|
asymmetry(neutral) < 0.5,
|
|
`${kind}: no implied heading (${asymmetry(neutral).toFixed(2)})`,
|
|
);
|
|
// The front is the narrow end: the two leading rows of ink carry less
|
|
// than the two trailing rows.
|
|
const inked = pointed.flatMap((v, i) => (v > 0.05 ? [i] : []));
|
|
const first = inked[0];
|
|
const last = inked[inked.length - 1];
|
|
const lead = pointed[first] + pointed[first + 1];
|
|
const trail = pointed[last] + pointed[last - 1];
|
|
assert.ok(lead < trail, `${kind}: nose toward -Y`);
|
|
}
|
|
assert.notEqual(
|
|
transitIcon('bus'),
|
|
transitIcon('bus', 48, { heading: false }),
|
|
);
|
|
assert.equal(transitIcon('bus', 48, { heading: true }), transitIcon('bus'));
|
|
});
|