diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md index 3557c4137b..13c3dbac80 100644 --- a/DATA_SOURCES.md +++ b/DATA_SOURCES.md @@ -234,6 +234,13 @@ commercial use with attribution and applicable database share-alike/access obligations; it does not license the application code. Trimmed test-only tile fixtures retain their provenance in `src/data/fixtures/README.md`. +A mapped `model` tag that names datasheet hardware adds a spec line to the +selected card. The specs are 16 verbatim CC0-1.0 records from the CCTV Camera +Database model-enrichment extract (v2.29.0), compiled into +`src/layers/alpr/modelSpecs.js`; nothing is fetched at runtime, and an +unrecognised tag is never displayed. The hourly extract does not carry `model` +yet, so only an Overpass-backed source shows these lines today. + ### CCTV Camera Database (`src/layers/cctv/modelSpecs.js`) The CCTV layer's hardware-model specs are a small verbatim extract (v2.26.0) of the diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index ede889fdc7..fddce328ae 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -788,6 +788,13 @@ The row count explicitly says **nearby**: loaded records can be outside the screen. Cyan camera badges use Manjunath's camera artwork; selection switches to a larger coral badge with corner brackets and an animated tactical card. Numeric mapped bearings draw illustrative 90 m direction wedges (not measured coverage). +A camera whose OSM `model` tag names known hardware (Motorola Solutions Vigilant, +Genetec AutoVu SharpV, Axis, Verkada, Bosch MIC; 459 of the 1,567 tagged cameras +in October 2026) gets a `SPEC` line on its card from vendored datasheet records +(`src/layers/alpr/modelSpecs.js`, matched with the CCTV layer's +`createModelSpecLookup`). A `manufacturer` naming another maker rejects the +match, and the raw tag text is never shown. The hourly extract has no `model` +field yet, so only an Overpass-backed source fills it. The shared overlay paints gradients for at most 64 nearby cameras, promoting the selected camera; farther cameras keep native Cesium badges without wedges. Native ground-clamped wedges (a ground polyline plus a classification polygon per diff --git a/scripts/package-boundaries.json b/scripts/package-boundaries.json index 3970a1ee2d..3787b57b1e 100644 --- a/scripts/package-boundaries.json +++ b/scripts/package-boundaries.json @@ -1497,6 +1497,8 @@ "src/layers/alpr/policy.js", "src/layers/alpr/presentation.js", "src/layers/alpr/visuals.js", + "src/layers/alpr/modelSpecs.js", + "src/layers/cctv/modelSpecs.js", "src/layers/alpr/overlay.js", "src/layers/alpr/source.js", "src/data/inputOwnership.js", @@ -1927,6 +1929,7 @@ "src/layers/alpr/policy.js", "src/layers/alpr/presentation.js", "src/layers/alpr/visuals.js", + "src/layers/alpr/modelSpecs.js", "src/layers/alpr/overlay.js", "src/layers/alpr/source.js", "src/layers/awareness/controls.js", @@ -2717,6 +2720,7 @@ "src/layers/alpr/policy.js", "src/layers/alpr/presentation.js", "src/layers/alpr/visuals.js", + "src/layers/alpr/modelSpecs.js", "src/layers/alpr/overlay.js", "src/layers/alpr/source.js", "src/layers/awareness/controls.js", diff --git a/src/data/alprCameras.test.mjs b/src/data/alprCameras.test.mjs index 5a50220d54..8867739a10 100644 --- a/src/data/alprCameras.test.mjs +++ b/src/data/alprCameras.test.mjs @@ -54,6 +54,7 @@ test('normalizeAlprNode: maps a full OSM node to a plain record', () => { longitude: -97.7431, operator: 'Flock Safety', manufacturer: null, + model: null, cameraType: 'fixed', zone: 'traffic', directionDeg: 270, diff --git a/src/layers/alpr/modelSpecs.js b/src/layers/alpr/modelSpecs.js new file mode 100644 index 0000000000..789b6fc4a5 --- /dev/null +++ b/src/layers/alpr/modelSpecs.js @@ -0,0 +1,257 @@ +/** + * @module alprModelSpecs + * + * Datasheet specs for the ALPR hardware that OpenStreetMap mappers name. + * + * 1,567 mapped ALPR cameras carry a `model` tag (October 2026). This module + * vendors the records for the models among them that the CCTV Camera Database + * (https://github.com/ch-bas/cctv-camera-database, CC0-1.0) covers — + * Motorola Solutions Vigilant, Genetec AutoVu, Axis, Verkada and Bosch MIC, + * which resolve 459 of those cameras — and resolves a camera's `model` (with + * its `manufacturer`) through the CCTV layer's matcher. The hourly extract the + * layer reads by default does not publish `model` yet, so today only an + * Overpass-backed source shows these specs. Flock Safety publishes no + * datasheet resolution, so Flock models stay unresolved; an unknown model + * never implies anything. + * + * Scope guardrail: records describe camera PRODUCTS (optics, resolution, + * night vision) — never endpoints, operators or what a camera records. + */ + +import { createModelSpecLookup } from '../cctv/modelSpecs.js'; + +/** + * Verbatim records from the dataset's model-enrichment extract (v2.29.0). + * Mappers tag the bare product code ("L6Q", "MIC-7522-Z30B") where the + * datasheet names the product line too ("Vigilant L6Q"), so each record also + * lists its bare code as an alias. + */ +const RECORDS = [ + { + id: 'motorola-solutions-l5f', + brand: 'Motorola Solutions', + model: 'Vigilant L5F', + type: 'box', + url: 'https://www.cctv-database.com/camera/motorola-solutions-l5f/', + aliases: ['L5F', 'L5F Fixed LPR Camera System'], + resolution: { mp: 1.6, w: 1440, h: 1080 }, + lens_count: 2, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'motorola-solutions-l5m', + brand: 'Motorola Solutions', + model: 'Vigilant L5M', + type: 'box', + url: 'https://www.cctv-database.com/camera/motorola-solutions-l5m/', + aliases: [ + 'L5M', + 'L5M Mobile LPR Camera System', + 'L5M Mobile ANPR Camera System', + ], + resolution: { mp: 1.6, w: 1440, h: 1080 }, + lens_count: 2, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'motorola-solutions-l5q', + brand: 'Motorola Solutions', + model: 'Vigilant L5Q', + type: 'box', + url: 'https://www.cctv-database.com/camera/motorola-solutions-l5q/', + aliases: ['L5Q', 'L5Q Quick Deploy LPR Camera System'], + resolution: { mp: 3 }, + environment: ['outdoor'], + }, + { + id: 'motorola-solutions-l6d', + brand: 'Motorola Solutions', + model: 'Vigilant L6D', + type: 'bullet', + url: 'https://www.cctv-database.com/camera/motorola-solutions-l6d/', + aliases: [ + 'L6D', + 'L6D Dual-Purpose LPR Camera', + 'VSM-L6D-8IR', + 'VSM-L6D-7IR', + ], + fov_deg: '52-3 horizontal', + resolution: { mp: 1.6, w: 1440, h: 1080 }, + lens_count: 2, + varifocal: true, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'motorola-solutions-l6q', + brand: 'Motorola Solutions', + model: 'Vigilant L6Q', + type: 'box', + url: 'https://www.cctv-database.com/camera/motorola-solutions-l6q/', + aliases: ['L6Q', 'L6Q Quick-Deploy LPR Camera System'], + resolution: { mp: 2.1, w: 1920, h: 1080, label: '1080p' }, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'genetec-autovu-sharpv', + brand: 'Genetec', + model: 'AutoVu SharpV', + type: 'box', + url: 'https://www.cctv-database.com/camera/genetec-autovu-sharpv/', + aliases: [ + 'AutoVu SharpV G3', + 'AU-V-WS850-LC-G3-000', + 'AU-V-BS850-LC-G3-0M0', + 'AU-V-BS850-LC-G3-0M1', + ], + resolution: { mp: 2.3, w: 1920, h: 1200, label: '1920x1200' }, + lens_count: 2, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'genetec-autovu-sharpv-g2', + brand: 'Genetec', + model: 'AutoVu SharpV G2', + type: 'box', + url: 'https://www.cctv-database.com/camera/genetec-autovu-sharpv-g2/', + aliases: ['AutoVu SharpV G1', 'AU-V-WS850-LC-G2', 'AU-V-WS850-LC'], + resolution: { mp: 1.2, w: 1280, h: 960, label: '1280x960' }, + lens_count: 2, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'genetec-autovu-sharpx', + brand: 'Genetec', + model: 'AutoVu SharpX', + type: 'box', + url: 'https://www.cctv-database.com/camera/genetec-autovu-sharpx/', + // i18n-ignore: datasheet label + resolution: { mp: 1, w: 1024, h: 946, label: 'XGA (1024x946)' }, + lens_count: 2, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'genetec-autovu-sharpz3', + brand: 'Genetec', + model: 'AutoVu SharpZ3', + type: 'box', + url: 'https://www.cctv-database.com/camera/genetec-autovu-sharpz3/', + resolution: { mp: 1.6, w: 1456, h: 1088, label: '1456x1088' }, + lens_count: 3, + night_vision: { type: 'ir' }, + environment: ['outdoor'], + }, + { + id: 'axis-q1700-le', + brand: 'Axis', + model: 'Q1700-LE', + type: 'box', + url: 'https://www.cctv-database.com/camera/axis-q1700-le/', + fov_deg: '16-2.3 horizontal / 9.6-1.3 vertical', + resolution: { mp: 2, w: 1920, h: 1080, label: '1080p' }, + varifocal: true, + night_vision: { type: 'ir', range_m: 50 }, + environment: ['outdoor'], + ndaa_compliant: true, + }, + { + id: 'axis-q1800-le', + brand: 'Axis', + model: 'Q1800-LE', + type: 'bullet', + url: 'https://www.cctv-database.com/camera/axis-q1800-le/', + aliases: ['03107-001', 'Q1800-LE-3 (License Plate Verifier kit)'], + fov_deg: '38-2.3 horizontal', + resolution: { mp: 2, w: 1920, h: 1080, label: '1080p' }, + varifocal: true, + night_vision: { type: 'ir', range_m: 40 }, + environment: ['indoor', 'outdoor'], + ndaa_compliant: true, + }, + { + id: 'verkada-cb62-te-f', + brand: 'Verkada', + model: 'CB62-TE-F', + type: 'bullet', + url: 'https://www.cctv-database.com/camera/verkada-cb62-te-f/', + fov_deg: '42 to 17 H', + resolution: { mp: 8.3, w: 3840, h: 2160, label: '4K' }, + varifocal: true, + night_vision: { type: 'ir', range_m: 50 }, + environment: ['outdoor'], + ndaa_compliant: true, + }, + { + id: 'verkada-ch52-e-f', + brand: 'Verkada', + model: 'CH52-E-F', + type: 'panoramic', + url: 'https://www.cctv-database.com/camera/verkada-ch52-e-f/', + fov_deg: '89 to 37 H (per sensor); up to 328 combined', + // i18n-ignore: datasheet label + resolution: { mp: 5, w: 2688, h: 1944, label: '4 x 5MP (20MP)' }, + lens_count: 4, + varifocal: true, + night_vision: { type: 'ir', range_m: 30 }, + environment: ['outdoor'], + ndaa_compliant: true, + }, + { + id: 'verkada-cp63-e', + brand: 'Verkada', + model: 'CP63-E', + type: 'ptz', + url: 'https://www.cctv-database.com/camera/verkada-cp63-e/', + fov_deg: '64 to 2 H', + resolution: { mp: 8.3, w: 3840, h: 2160, label: '4K' }, + ptz: true, + varifocal: true, + night_vision: { type: 'ir', range_m: 100 }, + environment: ['outdoor'], + ndaa_compliant: true, + }, + { + id: 'verkada-cr63-e', + brand: 'Verkada', + model: 'CR63-E', + type: 'bullet', + url: 'https://www.cctv-database.com/camera/verkada-cr63-e/', + fov_deg: '109 to 49 H', + resolution: { mp: 8.3, w: 3840, h: 2160, label: '4K' }, + varifocal: true, + night_vision: { type: 'ir', range_m: 20 }, + environment: ['indoor', 'outdoor'], + }, + { + id: 'bosch-mic-7522-z30b', + brand: 'Bosch', + model: 'MIC IP starlight 7100i (MIC-7522-Z30B)', + type: 'ptz', + url: 'https://www.cctv-database.com/camera/bosch-mic-7522-z30b/', + aliases: ['MIC-7522-Z30B'], + fov_deg: '2.1-58.3', + // i18n-ignore: datasheet label + resolution: { mp: 2, w: 1920, h: 1080, label: '1080p HD' }, + ptz: true, + varifocal: true, + night_vision: { type: 'color' }, + environment: ['outdoor'], + ndaa_compliant: true, + }, +]; + +/** + * Datasheet record for a mapped ALPR camera's `model` tag. A `manufacturer` + * naming another maker rejects the match, so a "Flock Safety" camera tagged + * "L6Q" stays unresolved rather than borrowing Motorola's specs. + * @param {string|null} model - The OSM `model` tag. + * @param {string|null} [manufacturer] - The OSM `manufacturer` tag. + * @returns {Object|null} The verbatim spec record, or null when unknown. + */ +export const lookupAlprModelSpec = createModelSpecLookup(RECORDS); diff --git a/src/layers/alpr/modelSpecs.test.mjs b/src/layers/alpr/modelSpecs.test.mjs new file mode 100644 index 0000000000..b33c1d879b --- /dev/null +++ b/src/layers/alpr/modelSpecs.test.mjs @@ -0,0 +1,100 @@ +// src/layers/alpr/modelSpecs.test.mjs +// Mapped ALPR model tags resolve to vendored datasheets, and never guess. +import { test } from 'node:test'; +import assert from 'node:assert/strict'; + +import { lookupAlprModelSpec } from './modelSpecs.js'; +import { normalizeAlprNode } from './records.js'; +import { alprLabelDetails } from './visuals.js'; + +const OSM = { attribution: { name: 'OpenStreetMap' } }; + +test('the model tags mappers write resolve to their datasheet record', () => { + // [model tag, manufacturer tag, record id] as they appear on OSM nodes. + for (const [model, manufacturer, id] of [ + ['L6Q', 'Motorola Solutions', 'motorola-solutions-l6q'], + ['L5F', 'Motorola Solutions', 'motorola-solutions-l5f'], + ['L6D', 'Motorola Solutions', 'motorola-solutions-l6d'], + ['L6Q', null, 'motorola-solutions-l6q'], + ['AutoVu SharpV', 'Genetec', 'genetec-autovu-sharpv'], + ['Q1700-LE', 'Axis Communications', 'axis-q1700-le'], + ['Q1800-LE', 'Axis Communications', 'axis-q1800-le'], + ['CP63-E', 'Verkada Inc.', 'verkada-cp63-e'], + ['CB62-TE-F', 'Verkada Inc.', 'verkada-cb62-te-f'], + ['CH52-E-F', 'Verkada Inc.', 'verkada-ch52-e-f'], + ['CR63-E', 'Verkada', 'verkada-cr63-e'], + ['MIC-7522-Z30B', 'The Bosch Group', 'bosch-mic-7522-z30b'], + ]) + assert.equal( + lookupAlprModelSpec(model, manufacturer)?.id, + id, + `${manufacturer} ${model}`, + ); +}); + +test('unknown, mis-attributed or partial models stay unresolved', () => { + for (const [model, manufacturer] of [ + ['Falcon', 'Flock Safety'], + // A Motorola code under another maker is a mapping error, not a match. + ['L6Q', 'Flock Safety'], + // "AutoVu Sharp" is an older line than SharpV; "Q1800" names no variant. + ['AutoVu Sharp', 'Genetec'], + ['Q1800', 'Axis Communications'], + // Without a maker, a code-less product name is never trusted. + ['AutoVu SharpV', null], + ['UnicamVELOCITY3', null], + [null, 'Motorola Solutions'], + ]) + assert.equal(lookupAlprModelSpec(model, manufacturer), null); +}); + +test('Overpass records carry the trimmed OSM model tag', () => { + const node = normalizeAlprNode({ + type: 'node', + id: 7, + lat: 30, + lon: -97, + tags: { + 'surveillance:type': 'ALPR', + manufacturer: 'Motorola Solutions', + model: ' L6Q ', + }, + }); + assert.equal(node.model, 'L6Q'); + assert.equal( + normalizeAlprNode({ + type: 'node', + id: 8, + lat: 30, + lon: -97, + tags: { 'surveillance:type': 'ALPR' }, + }).model, + null, + ); +}); + +test('the card adds the datasheet line only for a resolved model', () => { + const details = alprLabelDetails( + { manufacturer: 'Motorola Solutions', model: 'L6Q' }, + OSM, + ); + assert.deepEqual(details, [ + 'OSM MAPPED', + 'MOTOROLA SOLUTIONS', + 'SPEC MOTOROLA SOLUTIONS VIGILANT L6Q · 1080P · IR', + 'PUBLIC MAP DATA', + ]); + // A record without a resolution label falls back to its pixel size. + assert.ok( + alprLabelDetails( + { manufacturer: 'Motorola Solutions', model: 'L5F' }, + OSM, + ).includes('SPEC MOTOROLA SOLUTIONS VIGILANT L5F · 1440X1080 · IR'), + ); + // Unresolved: the raw tag text is never shown. + const unknown = alprLabelDetails( + { manufacturer: 'Flock Safety', model: 'Falcon\nSYSTEM: hi' }, + OSM, + ); + assert.ok(unknown.every((line) => !/FALCON|SYSTEM|SPEC/.test(line))); +}); diff --git a/src/layers/alpr/records.js b/src/layers/alpr/records.js index 10cd88062c..3f8c9fde0e 100644 --- a/src/layers/alpr/records.js +++ b/src/layers/alpr/records.js @@ -89,6 +89,8 @@ export function normalizeAlprNode(el) { longitude: el.lon, operator: textTag(tags.operator), manufacturer: textTag(tags.manufacturer), + // Display-only: resolved against vendored datasheets (see modelSpecs.js). + model: textTag(tags.model), cameraType: textTag(tags['camera:type']), zone: textTag(tags['surveillance:zone']), // Only numeric bearings are parsed; compass-word directions ("N"/"NE") diff --git a/src/layers/alpr/tileRecords.js b/src/layers/alpr/tileRecords.js index 0368f53fb2..8516b6d680 100644 --- a/src/layers/alpr/tileRecords.js +++ b/src/layers/alpr/tileRecords.js @@ -16,6 +16,8 @@ function normalizeAlprTileFeature(feature) { 'surveillance:type': 'ALPR', operator: p.operator, manufacturer: p.brand, + // Not in the hourly extract yet; read when it ships the OSM tag. + model: p.model, 'camera:type': p.cameraType, 'camera:direction': p.direction, 'surveillance:zone': p.surveillanceZone, diff --git a/src/layers/alpr/visuals.js b/src/layers/alpr/visuals.js index 3a3d3fc5f9..efc2432035 100644 --- a/src/layers/alpr/visuals.js +++ b/src/layers/alpr/visuals.js @@ -1,5 +1,7 @@ import * as Cesium from 'cesium'; import { destinationPointDeg } from './model.js'; +import { lookupAlprModelSpec } from './modelSpecs.js'; +import { specSummary } from '../cctv/modelSpecs.js'; import { DIRECTION_CONE_M, DIRECTION_CONE_HALF_ANGLE_DEG, @@ -42,7 +44,10 @@ export function alprDisplayId(record) { return `ALPR-${String(record.osmId).slice(-4).padStart(4, '0')}`; } -/** Show only supplied metadata, with the actual source named for custom adapters. */ +/** + * Show only supplied metadata, with the actual source named for custom + * adapters, plus the datasheet summary when the mapped model is known. + */ export function alprLabelDetails(record, source) { const sourceName = source.attribution?.name || source.label || 'Camera source'; @@ -63,6 +68,9 @@ export function alprLabelDetails(record, source) { ), ]; if (equipment.length) details.push(equipment.join(' · ')); + // Only a datasheet match is shown: the raw OSM `model` text never is. + const spec = lookupAlprModelSpec(record.model, record.manufacturer); + if (spec) details.push(`SPEC ${specSummary(spec).toUpperCase()}`); if (sourceName === 'OpenStreetMap') details.push('PUBLIC MAP DATA'); return details; } diff --git a/src/layers/cctv/modelSpecs.js b/src/layers/cctv/modelSpecs.js index 2d93166a72..128f30d6fd 100644 --- a/src/layers/cctv/modelSpecs.js +++ b/src/layers/cctv/modelSpecs.js @@ -387,33 +387,67 @@ const BRAND_ALIASES = { Hikvision: ['hiwatch'], }; -function brandWords(record) { - return new Set([ - ...words(record.brand), - ...(BRAND_ALIASES[record.brand] || []), - ]); -} - /** - * One entry per record name (model + aliases). `required` is every - * non-generic word of the name — all must appear in a query, so a generation - * or suffix ("Mk II", "7000i" vs "7000") is never dropped. `hasCode` marks - * names carrying a letter+digit model code; names without one ("3950", - * "01959-004", "AUTODOME 800 Series") match only when the brand does. + * Builds a model lookup over a record table, so another layer can resolve its + * own vendored records with the same matching rules (see lookupModelSpec). + * @param {Object[]} records - Spec records in this module's shape. + * @param {Object} [brandAliases] - Extra manufacturer words + * accepted per record brand. + * @returns {(model: string, manufacturer?: string) => (Object|null)} Lookup. */ -const NAME_INDEX = RECORDS.flatMap((record) => { - const brand = brandWords(record); - return [record.model, ...(record.aliases || [])].map((name) => { - const nameWords = words(name); - return { - record, - brand, - allowed: new Set(nameWords), - required: nameWords.filter((word) => !isGeneric(word)), - hasCode: nameWords.some(isModelCode), - }; +export function createModelSpecLookup(records, brandAliases = BRAND_ALIASES) { + /** + * One entry per record name (model + aliases). `required` is every + * non-generic word of the name — all must appear in a query, so a + * generation or suffix ("Mk II", "7000i" vs "7000") is never dropped. + * `hasCode` marks names carrying a letter+digit model code; names without + * one ("3950", "01959-004", "AUTODOME 800 Series") match only when the + * brand does. + */ + const nameIndex = records.flatMap((record) => { + const brand = new Set([ + ...words(record.brand), + ...(brandAliases[record.brand] || []), + ]); + return [record.model, ...(record.aliases || [])].map((name) => { + const nameWords = words(name); + return { + record, + brand, + allowed: new Set(nameWords), + required: nameWords.filter((word) => !isGeneric(word)), + hasCode: nameWords.some(isModelCode), + }; + }); }); -}); + return (model, manufacturer) => { + const query = words(model).map(stripVariantSuffix); + if (!query.length) return null; + const maker = words(manufacturer); + const found = new Set(); + for (const entry of nameIndex) { + const makerMatches = maker.some((word) => entry.brand.has(word)); + if (maker.length && !makerMatches) continue; + if ( + !entry.hasCode && + !makerMatches && + !query.some((word) => entry.brand.has(word)) + ) + continue; + if (!entry.required.length) continue; + if (!entry.required.every((word) => query.includes(word))) continue; + if ( + !query.every( + (word) => + entry.allowed.has(word) || entry.brand.has(word) || isGeneric(word), + ) + ) + continue; + found.add(entry.record); + } + return found.size === 1 ? [...found][0] : null; + }; +} /** * Looks up a spec record for a hardware-model string. @@ -433,33 +467,7 @@ const NAME_INDEX = RECORDS.flatMap((record) => { * @param {string} [manufacturer] - The source's manufacturer, when published. * @returns {Object|null} The verbatim spec record, or null when unknown. */ -export function lookupModelSpec(model, manufacturer) { - const query = words(model).map(stripVariantSuffix); - if (!query.length) return null; - const maker = words(manufacturer); - const found = new Set(); - for (const entry of NAME_INDEX) { - const makerMatches = maker.some((word) => entry.brand.has(word)); - if (maker.length && !makerMatches) continue; - if ( - !entry.hasCode && - !makerMatches && - !query.some((word) => entry.brand.has(word)) - ) - continue; - if (!entry.required.length) continue; - if (!entry.required.every((word) => query.includes(word))) continue; - if ( - !query.every( - (word) => - entry.allowed.has(word) || entry.brand.has(word) || isGeneric(word), - ) - ) - continue; - found.add(entry.record); - } - return found.size === 1 ? [...found][0] : null; -} +export const lookupModelSpec = createModelSpecLookup(RECORDS); /** * Datasheet horizontal FOV as the range the hardware can cover. Only @@ -539,7 +547,10 @@ export function specFovCapabilityToken( export function specSummary(spec) { if (!spec) return ''; const parts = [`${spec.brand} ${spec.model}`]; - if (spec.resolution?.label) parts.push(spec.resolution.label); + const { label, w, h, mp } = spec.resolution || {}; + if (label) parts.push(label); + else if (w && h) parts.push(`${w}x${h}`); + else if (mp) parts.push(`${mp}MP`); if (spec.night_vision) { parts.push( `${spec.night_vision.type.toUpperCase()}${spec.night_vision.range_m ? ` ${spec.night_vision.range_m}m` : ''}`,