import { test } from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; import { FLEET_MODEL_BASE, aircraftModelSpec, aisShipTypeCode, emitterCategory, fleetModelSet, fleetModelSpec, hullBeam, hullLength, loadFleetModelSet, namedFleetModels, placeScale, resetFleetModelSet, resolveAircraft, resolveTransit, resolveVessel, transitModelSpec, vesselModelSpec, } from './fleetModels.js'; import { FLEET_TRAIL_ANCHORS } from './fleetTrailAnchors.js'; import { centrelineSegments, distanceToSurface, fleetMesh, measuredTrailAnchor, readGlb, vertexBounds, } from '../testSupport/fleetGlb.mjs'; const ROOT = path.resolve( path.dirname(fileURLToPath(import.meta.url)), '../..', ); const DIR = path.join(ROOT, 'public', 'models', 'fleet'); const json = (name) => JSON.parse(fs.readFileSync(path.join(DIR, name), 'utf8')); const catalog = json('catalog.json'); const types = json('types.json'); const set = { catalog, types }; // A slice of the set's types.json and catalog.json, as the resolver's own // reference tests use, so these read independently of later model changes. const sliceTypes = { aircraft: { A320: ['a320', 37.57], A21N: ['a320', 44.51], A319: ['a320', 33.84], B38M: ['b738', 39.52], }, helicopters: { EC35: ['ec35', 10.2] }, categories: { A1: ['c172', 8.3] }, vessels: [ { types: [70, 79], rules: [ { min_len: 70, max_len: 140, max_bl: 0.12, model: 'inland_cargo' }, { name_re: '\\b(LEADER|HIGHWAY|ACE|GLOVIS|HOEGH|SPIRIT OF)\\b', min_len: 150, model: 'car_carrier', }, { min_len: 250, model: 'container_ship' }, { model: 'general_cargo' }, ], }, { types: [31, 32], rules: [{ model: 'tug' }] }, { types: [52, 52], rules: [{ model: 'tug' }] }, { types: [0, 99], rules: [{ model: 'generic_vessel' }] }, ], default_aircraft: ['generic_plane', 36], default_vessel: 'generic_vessel', }; const model = (category, file, length, beam, clearance) => ({ category, file, min: [0, 0, 0], max: [0, 0, 0], length, beam, clearance, tris: 1, icon: 'jet', }); const sliceCatalog = { a320: model('aircraft', 'aircraft/a320.glb', 37.57, 35.6, 3.063), container_ship: model('ships', 'ships/container_ship.glb', 309.9, 48, 13.9), }; test('aircraft resolve by type, then emitter category, then the generic plane', () => { assert.deepEqual(resolveAircraft(sliceTypes, 'A320'), { model: 'a320', length: 37.57, }); assert.deepEqual(resolveAircraft(sliceTypes, ' b38m '), { model: 'b738', length: 39.52, }); assert.equal(resolveAircraft(sliceTypes, 'EC35').model, 'ec35'); assert.deepEqual(resolveAircraft(sliceTypes, 'ZZZZ', 'A1'), { model: 'c172', length: 8.3, }); assert.deepEqual(resolveAircraft(sliceTypes, undefined, 'Q9'), { model: 'generic_plane', length: 36, }); }); test('vessels: the first matching rule of the first type range with one, else the generic vessel', () => { assert.equal(resolveVessel(sliceTypes, 70, 366, 51).model, 'container_ship'); assert.equal( resolveVessel(sliceTypes, 71, 199, 32, 'GLOVIS SPIRIT').model, 'car_carrier', ); assert.equal(resolveVessel(sliceTypes, 79, 110, 11.4).model, 'inland_cargo'); assert.equal(resolveVessel(sliceTypes, 70, 90, 15).model, 'general_cargo'); assert.deepEqual(resolveVessel(sliceTypes, 52, 30, 10), { model: 'tug', length: 30, }); assert.deepEqual(resolveVessel(sliceTypes, undefined, 50), { model: 'generic_vessel', length: 50, }); assert.deepEqual(resolveVessel(sliceTypes, 0), { model: 'generic_vessel', length: null, }); }); test("vessels: AIS's out-of-range sizes (511 m long, 126 m abeam) are unknown, drawn as built", () => { assert.deepEqual(resolveVessel(sliceTypes, 52, 511), { model: 'tug', length: null, }); assert.equal(hullLength(511), undefined); assert.equal(hullLength(0), undefined); assert.equal(hullBeam(126), undefined); assert.equal(hullBeam(32), 32); const ship = sliceCatalog.container_ship; assert.deepEqual(placeScale(ship, ship.length, 126), [1, 1, 1]); }); test('scale: aircraft by the type length, vessels by length and beam', () => { const a320 = sliceCatalog.a320; const [sx, sy, sz] = placeScale(a320, 44.51); assert.ok(Math.abs(sx - 44.51 / 37.57) < 1e-12); assert.equal(sy, sx); assert.equal(sz, sx); const ship = sliceCatalog.container_ship; assert.deepEqual(placeScale(ship, ship.length / 2, 24), [0.5, 0.5, 0.5]); assert.deepEqual(placeScale(ship, null), [1, 1, 1]); }); test('every model the type map names is in the catalog, and its file is a GLB on disk', () => { for (const name of namedFleetModels(types)) assert.ok( catalog[name], `${name}: named by types.json but not in the catalog`, ); assert.equal(catalog.generic_plane?.category, 'aircraft'); assert.equal(catalog.generic_vessel?.category, 'ships'); assert.equal(catalog.city_bus?.category, 'transit'); for (const [name, metres] of Object.entries(types.transit.elevation)) { assert.ok(catalog[name], name); assert.ok(metres > 0, name); } let total = 0; for (const [name, entry] of Object.entries(catalog)) { const file = path.join(DIR, entry.file); assert.ok(fs.existsSync(file), `${name}: ${entry.file} is missing`); const bytes = fs.readFileSync(file); assert.equal(bytes.subarray(0, 4).toString('latin1'), 'glTF', name); assert.ok(entry.length > 0, name); assert.ok(entry.tris <= 50_000, name); total += bytes.length; } // The set ships with the repository and loads up front: keep it small. assert.ok(total < 3 * 1024 * 1024, `fleet GLBs total ${total} bytes`); }); test('transit bodies mark the share of the route colour they take; other models mark none', () => { for (const [name, entry] of Object.entries(catalog)) { const { json: gltf } = readGlb(path.join(DIR, entry.file)); for (const mesh of gltf.meshes) for (const primitive of mesh.primitives) assert.equal( '_TINT' in primitive.attributes, entry.category === 'transit', name, ); assert.equal( fleetModelSpec(set, name, null).tinted, entry.category === 'transit', ); } }); test('aircraft specs: by type, then class for an unlisted type, then emitter category', () => { assert.equal(aircraftModelSpec(set, { typeCode: 'A320' }).model, 'a320'); assert.equal(aircraftModelSpec(set, { type: 'b744' }).model, 'b744'); // An unlisted fast jet is still a fast jet, not the generic airliner. assert.equal( aircraftModelSpec(set, { typeCode: 'FA18', category: 'A3' }).model, 't38', ); assert.equal(aircraftModelSpec(set, { typeCode: 'MQ9' }).model, 'mq9'); assert.equal( aircraftModelSpec(set, { typeCode: 'PUMA' }).model, 'generic_heli', ); // An unlisted type of no special class falls to its category. assert.equal( aircraftModelSpec(set, { typeCode: 'ZZZZ', category: 'A5' }).model, 'b77w', ); // OpenSky's integer category: 8 is rotorcraft (A7), 2 light (A1). assert.equal(emitterCategory(8), 'A7'); assert.equal(emitterCategory('a3'), 'A3'); assert.equal(emitterCategory(1), undefined); assert.equal(aircraftModelSpec(set, { category: 8 }).model, 'generic_heli'); assert.equal(aircraftModelSpec(set, { category: 2 }).model, 'c172'); assert.equal(aircraftModelSpec(set, {}).model, types.default_aircraft[0]); }); test('aircraft specs are life size, standing on their scaled clearance', () => { const spec = aircraftModelSpec(set, { typeCode: 'A21N' }); const [, length] = types.aircraft.A21N; assert.equal(spec.model, types.aircraft.A21N[0]); assert.ok(Math.abs(spec.length - length) < 1e-9); assert.ok(Math.abs(spec.scale - length / catalog[spec.model].length) < 1e-12); assert.ok( Math.abs(spec.clearanceM - catalog[spec.model].clearance * spec.scale) < 1e-12, ); assert.equal(spec.url, `${FLEET_MODEL_BASE}${catalog[spec.model].file}`); assert.equal(spec.tinted, false); assert.equal(spec.elevationM, 0); assert.ok( spec.nativeRadiusM * spec.scale > 25 && spec.nativeRadiusM * spec.scale < 60, ); assert.deepEqual(spec.trailAnchorNative, FLEET_TRAIL_ANCHORS[spec.model]); // A grounded service vehicle and an obstacle are drawn as built: the // tower's 60 m is its height, not a length to stretch it to. const tower = aircraftModelSpec(set, { category: 'C3' }); assert.equal(tower.model, 'tower'); assert.equal(tower.scale, 1); assert.equal(aircraftModelSpec(set, { category: 'C1' }).scale, 1); }); test('vessel specs read AIS codes and text families, stretched to the reported beam', () => { assert.equal(aisShipTypeCode('70'), 70); assert.equal(aisShipTypeCode(' Cargo '), 70); assert.equal(aisShipTypeCode('Tanker'), 80); assert.equal(aisShipTypeCode('Tug'), 52); assert.equal(aisShipTypeCode('0'), undefined); assert.equal(aisShipTypeCode(''), undefined); const box = vesselModelSpec(set, { type: '71', length: 366, beam: 51 }); assert.equal(box.model, 'container_ship'); assert.ok(Math.abs(box.length - 366) < 1e-9); const [sx, sy, sz] = box.scaleXYZ; assert.ok(Math.abs(sy - 51 / catalog.container_ship.beam) < 1e-12); assert.ok(Math.abs(sz - (sx + sy) / 2) < 1e-12); assert.equal(vesselModelSpec(set, { type: 'Tug', length: 30 }).model, 'tug'); assert.equal(vesselModelSpec(set, { type: '36' }).model, 'sailboat'); // No type, no size: the generic vessel as built. const unknown = vesselModelSpec(set, {}); assert.equal(unknown.model, types.default_vessel); assert.equal(unknown.scale, 1); }); test('transit specs: rail category and mode, then route type, then mode, then the default', () => { assert.deepEqual(resolveTransit(types, { railCategory: 'national' }), { model: 'intercity', length: types.transit.rail.national.rail[1], }); assert.equal( resolveTransit(types, { railCategory: 'transit', railMode: 'metro' }).model, 'metro', ); assert.equal( resolveTransit(types, { railCategory: 'regional', railMode: 'tram' }).model, 'light_rail', ); assert.equal(resolveTransit(types, { routeType: 3 }).model, 'city_bus'); assert.equal(resolveTransit(types, { routeType: '0' }).model, 'tram'); assert.equal(resolveTransit(types, { routeType: 109 }).model, 'commuter_emu'); assert.equal(resolveTransit(types, { mode: 'subway' }).model, 'metro'); assert.equal(resolveTransit(types, { mode: 'ferry' }).model, 'fast_ferry'); assert.equal( resolveTransit(types, { mode: 'unknown' }).model, types.transit.default[0], ); const tram = transitModelSpec(set, { mode: 'tram' }); assert.equal(tram.tinted, true); assert.equal(tram.clearanceM, 0); assert.ok(Math.abs(tram.length - types.transit.modes.tram[1]) < 1e-9); assert.equal( transitModelSpec(set, { routeType: 12 }).elevationM, types.transit.elevation.monorail, ); assert.equal( transitModelSpec(set, { mode: 'gondola' }).elevationM, types.transit.elevation.gondola, ); assert.equal(transitModelSpec(set, { mode: 'ferry' }).tinted, false); }); test('a model missing from the catalog falls back to the default of its kind', () => { const thin = { catalog: { ...catalog }, types: { ...types, aircraft: { ...types.aircraft, XXXX: ['no_such_model', 20] }, }, }; assert.equal( aircraftModelSpec(thin, { typeCode: 'XXXX' }).model, types.default_aircraft[0], ); }); const ANCHORED = Object.entries(catalog).filter(([, entry]) => ['aircraft', 'helicopters', 'other'].includes(entry.category), ); test('every aircraft-layer model has a trail anchor on its real aft-belly hull', async () => { assert.deepEqual( new Set(Object.keys(FLEET_TRAIL_ANCHORS)), new Set(ANCHORED.map(([name]) => name)), 're-run scripts/measure-fleet-trail-anchors.mjs', ); for (const [name, entry] of ANCHORED) { const mesh = await fleetMesh(path.join(DIR, entry.file)); const { min, max } = vertexBounds(mesh.verts); const anchor = FLEET_TRAIL_ANCHORS[name]; // On the hull, not in the air beside it. const offHull = distanceToSurface(anchor, mesh.verts, mesh.tris); assert.ok( offHull <= 1e-3, `${name}: trail anchor is ${offHull.toFixed(4)} m off the hull`, ); // Aft of the middle, so the head segment does not run into the body. assert.ok( anchor[0] > (min[0] + max[0]) / 2, `${name}: trail anchor is not aft`, ); // Nothing of the centreline hangs lower at or behind its station. const lowest = centrelineSegments(mesh.verts, mesh.tris) .flat() .filter((p) => p[0] >= anchor[0] - 1e-3) .reduce((low, p) => Math.min(low, p[1]), Infinity); assert.ok( anchor[1] <= lowest + 1e-3, `${name}: trail anchor is above the hull aft of it`, ); assert.equal(anchor[2], 0, `${name}: trail anchor is off the centreline`); // And it is the construction, re-derived. const measured = measuredTrailAnchor(mesh); for (const axis of [0, 1]) assert.ok( Math.abs(anchor[axis] - measured[axis]) <= 1e-3, `${name} axis ${axis}: table ${anchor[axis]} vs measured ${measured[axis].toFixed(4)}`, ); } }); test('catalog bounds match the GLBs they describe', async () => { for (const [name, entry] of Object.entries(catalog)) { const { min, max } = vertexBounds( (await fleetMesh(path.join(DIR, entry.file))).verts, ); // The catalog is Z up (glTF Y), glTF Z across. const tolerance = 0.01 * Math.max(1, entry.length); assert.ok(Math.abs(min[0] - entry.min[0]) <= tolerance, `${name} min x`); assert.ok(Math.abs(max[0] - entry.max[0]) <= tolerance, `${name} max x`); assert.ok(Math.abs(min[1] - entry.min[2]) <= tolerance, `${name} min up`); assert.ok( Math.abs(-min[1] - entry.clearance) <= tolerance, `${name} clearance`, ); assert.ok( Math.abs(max[2] - min[2] - (entry.max[1] - entry.min[1])) <= tolerance, `${name} beam`, ); } }); test('the model set loads once, every GLB up front, shared by every layer', async () => { resetFleetModelSet(); const requested = []; const fetchImpl = async (url) => { requested.push(url); const file = path.join(ROOT, 'public', url.replace(/^\/app/, '')); if (!fs.existsSync(file)) return { ok: false, status: 404 }; const bytes = fs.readFileSync(file); return { ok: true, json: async () => JSON.parse(bytes.toString('utf8')), arrayBuffer: async () => bytes.buffer.slice( bytes.byteOffset, bytes.byteOffset + bytes.byteLength, ), }; }; const resolveAsset = (url) => `/app${url}`; const [first, second] = await Promise.all([ loadFleetModelSet({ resolveAsset, fetchImpl }), loadFleetModelSet({ resolveAsset, fetchImpl }), ]); assert.equal(first, second); assert.equal(fleetModelSet(), first); assert.equal(first.bytes.size, Object.keys(catalog).length); assert.equal(requested.length, Object.keys(catalog).length + 2); assert.ok(requested.every((url) => url.startsWith('/app/models/fleet/'))); assert.ok(first.totalBytes > 0 && Number.isFinite(first.loadMs)); await loadFleetModelSet({ resolveAsset, fetchImpl }); assert.equal(requested.length, Object.keys(catalog).length + 2); resetFleetModelSet(); });