308 lines
16 KiB
JavaScript
308 lines
16 KiB
JavaScript
import assert from 'node:assert/strict'
|
||
|
||
const exhibitionSpaceTypeWhitelist = new Set([
|
||
'exhibition_hall',
|
||
'theater',
|
||
'education_activity',
|
||
'ramp'
|
||
])
|
||
|
||
const exhibitionSpaceKeywords = [
|
||
'展厅',
|
||
'临展',
|
||
'展览',
|
||
'影院',
|
||
'球幕',
|
||
'巨幕',
|
||
'报告厅',
|
||
'活动室',
|
||
'科普',
|
||
'实验室',
|
||
'展览坡道',
|
||
'宇宙',
|
||
'地球',
|
||
'演化',
|
||
'恐龙',
|
||
'人类',
|
||
'生物',
|
||
'生态',
|
||
'家园'
|
||
]
|
||
|
||
const normalizedText = (value) => (value || '').trim()
|
||
const normalizedHallName = (value) => normalizedText(value).replace(/[\s（）()【】\[\]_-]/g, '')
|
||
const hasExhibitionKeyword = (value) => exhibitionSpaceKeywords.some((keyword) => normalizedText(value).includes(keyword))
|
||
|
||
const isEligiblePublicExhibitionSpace = (space) => {
|
||
const type = normalizedText(space.type).toLowerCase()
|
||
const name = normalizedText(space.name)
|
||
|
||
// Finding 2: Enforce whitelist first, reject unrelated types before keyword heuristics
|
||
if (!exhibitionSpaceTypeWhitelist.has(type)) return false
|
||
|
||
if (type === 'exhibition_hall') return true
|
||
if (type === 'theater') return hasExhibitionKeyword(name)
|
||
if (type === 'education_activity') return hasExhibitionKeyword(name)
|
||
if (type === 'ramp') return name.includes('展览坡道')
|
||
|
||
return false
|
||
}
|
||
|
||
const placeHallName = (place) => (
|
||
normalizedText(place.ownerName)
|
||
|| normalizedText(place.name)
|
||
.replace(/(?:主)?(?:出入口|入口|出口|门)\s*[A-Za-z0-9一二三四五六七八九十号-]*$/u, '')
|
||
.trim()
|
||
|| normalizedText(place.name)
|
||
)
|
||
|
||
const isExhibitionHallNavigablePlace = (place) => {
|
||
const searchableText = [
|
||
place.name,
|
||
place.ownerName,
|
||
place.category,
|
||
place.type,
|
||
place.typeCode,
|
||
place.typeName
|
||
]
|
||
.map(normalizedText)
|
||
.filter(Boolean)
|
||
.join(' ')
|
||
|
||
return hasExhibitionKeyword(searchableText)
|
||
}
|
||
|
||
const findMatchedHallSpace = (place, spaces) => {
|
||
const placeName = normalizedHallName(placeHallName(place))
|
||
if (!placeName) return undefined
|
||
|
||
const candidates = spaces
|
||
.map((space) => {
|
||
const spaceName = normalizedHallName(space.name)
|
||
if (!spaceName) return null
|
||
|
||
const exact = placeName === spaceName
|
||
const overlaps = exact || placeName.includes(spaceName) || spaceName.includes(placeName)
|
||
if (!overlaps) return null
|
||
|
||
return {
|
||
space,
|
||
exact,
|
||
specificity: spaceName.length
|
||
}
|
||
})
|
||
.filter(Boolean)
|
||
.sort((a, b) => {
|
||
if (a.exact !== b.exact) return a.exact ? -1 : 1
|
||
return b.specificity - a.specificity
|
||
})
|
||
|
||
return candidates[0]?.space
|
||
}
|
||
|
||
const normalizePositionSource = (source) => {
|
||
const x = Number(source?.x)
|
||
const y = Number(source?.y)
|
||
const z = Number(source?.z)
|
||
if (![x, y, z].every(Number.isFinite)) return undefined
|
||
return [x, y, z]
|
||
}
|
||
|
||
const normalizePlacePosition = (place) => normalizePositionSource(
|
||
place.position
|
||
? { x: place.position.x, y: place.position.y ?? 0, z: place.position.z }
|
||
: { x: place.x, y: place.y ?? 0, z: place.z }
|
||
)
|
||
|
||
const normalizeSpaceCenter = (space) => normalizePositionSource(space.center || {})
|
||
|
||
const createHallPoiId = (space, place, fallbackIndex) => {
|
||
if (space?.id) return `hall-${space.id}`
|
||
const ownerName = normalizedHallName(placeHallName(place))
|
||
const floorId = normalizedHallName(String(place.floorId || 'unknown-floor'))
|
||
if (ownerName) return `hall-place-${floorId}-${ownerName}`
|
||
return `hall-place-${floorId}-${place.id || fallbackIndex + 1}`
|
||
}
|
||
|
||
const toHallPois = (spaces, navigablePlaces, fallbackFloorId) => {
|
||
const hallSpaces = spaces.filter(isEligiblePublicExhibitionSpace)
|
||
const hallPlaces = navigablePlaces.filter(isExhibitionHallNavigablePlace)
|
||
const halls = new Map()
|
||
|
||
hallPlaces.forEach((place, index) => {
|
||
const matchedSpace = findMatchedHallSpace(place, hallSpaces)
|
||
const entrancePosition = normalizePlacePosition(place)
|
||
const fallbackPosition = matchedSpace ? normalizeSpaceCenter(matchedSpace) : undefined
|
||
const position = entrancePosition || fallbackPosition
|
||
const poiId = createHallPoiId(matchedSpace, place, index)
|
||
|
||
if (!position) return
|
||
|
||
const existing = halls.get(poiId)
|
||
if (existing) {
|
||
// Finding 1: Upgrade existing POI if later entrance has BOTH position and nodeId
|
||
if (entrancePosition && place.nodeId) {
|
||
existing.positionGltf = entrancePosition
|
||
existing.sourceConfidence = 'backend-sgs-sdk-hall-entrance'
|
||
existing.sourceObjectName = place.name
|
||
}
|
||
existing.entrances.push({ name: place.name, positionGltf: entrancePosition })
|
||
return
|
||
}
|
||
|
||
// backend-sgs-sdk-hall-entrance requires BOTH valid entrance position AND nodeId
|
||
const isHallEntranceSource = entrancePosition && place.nodeId
|
||
const sourceConfidence = isHallEntranceSource ? 'backend-sgs-sdk-hall-entrance' : 'backend-sgs-sdk-space-center'
|
||
|
||
halls.set(poiId, {
|
||
id: poiId,
|
||
name: matchedSpace?.name || placeHallName(place),
|
||
floorId: String(place.floorId || matchedSpace?.floorId || fallbackFloorId),
|
||
primaryCategory: 'exhibition_hall',
|
||
positionGltf: position,
|
||
sourceConfidence,
|
||
sourceObjectName: place.name,
|
||
entrances: [{ name: place.name, positionGltf: entrancePosition }]
|
||
})
|
||
})
|
||
|
||
hallSpaces.forEach((space) => {
|
||
const poiId = `hall-${space.id}`
|
||
if (halls.has(poiId)) return
|
||
const position = normalizeSpaceCenter(space)
|
||
if (!position) return
|
||
halls.set(poiId, {
|
||
id: poiId,
|
||
name: space.name,
|
||
floorId: String(space.floorId || fallbackFloorId),
|
||
primaryCategory: 'exhibition_hall',
|
||
positionGltf: position,
|
||
sourceConfidence: 'backend-sgs-sdk-space-center',
|
||
entrances: []
|
||
})
|
||
})
|
||
|
||
return Array.from(halls.values())
|
||
}
|
||
|
||
const createHallPoiDiagnostics = (spaces, navigablePlaces, hallPois) => {
|
||
const hallSpaces = spaces.filter(isEligiblePublicExhibitionSpace)
|
||
const hallPlaceCount = navigablePlaces.filter(isExhibitionHallNavigablePlace).length
|
||
const hallPoiIds = new Set(hallPois.map((poi) => poi.id))
|
||
|
||
return {
|
||
skippedSpaceCount: hallSpaces.filter((space) => !hallPoiIds.has(`hall-${space.id}`)).length,
|
||
skippedPlaceCount: Math.max(hallPlaceCount - hallPois.reduce((count, poi) => count + (poi.entrances?.length || 0), 0), 0)
|
||
}
|
||
}
|
||
|
||
const spaces = [
|
||
{ id: 1, name: '展厅1宇宙厅', type: 'exhibition_hall', floorId: 'B2', center: { x: 10, y: 0, z: 20 } },
|
||
{ id: 2, name: '巨幕影院', type: 'theater', floorId: 'L1', center: { x: 30, y: 0, z: 40 } },
|
||
{ id: 3, name: '博物馆之友活动室', type: 'education_activity', floorId: 'L4', center: { x: 50, y: 0, z: 60 } },
|
||
{ id: 4, name: '展览坡道', type: 'ramp', floorId: 'L1.5', center: { x: 70, y: 0, z: 80 } },
|
||
{ id: 5, name: '茶水间', type: 'service', floorId: 'L1', center: { x: 90, y: 0, z: 100 } },
|
||
{ id: 6, name: '自然科学展厅', type: 'exhibition_hall', floorId: 'L2', center: { x: 110, y: 0, z: 120 } },
|
||
{ id: 7, name: '地球科学展厅', type: 'exhibition_hall', floorId: 'L3', center: { x: 130, y: 0, z: 140 } },
|
||
{ id: 8, name: '古生物展厅', type: 'exhibition_hall', floorId: 'L2', center: { x: 150, y: 0, z: 160 } },
|
||
{ id: 9, name: '古生物展厅A', type: 'exhibition_hall', floorId: 'L2', center: { x: 170, y: 0, z: 180 } },
|
||
{ id: 10, name: '星空展厅', type: 'exhibition_hall', floorId: 'L5', center: { x: 190, y: 0, z: 200 } }
|
||
]
|
||
|
||
const places = [
|
||
{ id: 101, name: '展厅1宇宙厅 出入口 1', ownerName: '展厅1宇宙厅', floorId: 'B2', position: { x: 11, y: 0, z: 21 }, nodeId: 'n101' },
|
||
{ id: 102, name: '巨幕影院 出入口 1', ownerName: '巨幕影院', floorId: 'L1', position: { x: 31, y: 0, z: 41 }, nodeId: 'n102' },
|
||
{ id: 104, name: '地球科学展厅 出入口', ownerName: '地球科学展厅', floorId: 'L3' },
|
||
{ id: 105, name: '古生物展厅 出入口', ownerName: '古生物展厅', floorId: 'L2', position: { x: 151, y: 0, z: 161 }, nodeId: 'n105' },
|
||
{ id: 107, name: '自然科学展厅 出入口', ownerName: '自然科学展厅', floorId: 'L2' },
|
||
{ id: 108, name: '自然科学展厅【主】出入口1', ownerName: '自然科学展厅', floorId: 'L2', position: { x: 111, y: 0, z: 121 } },
|
||
{ id: 109, name: '地球 科学 展厅 （主）出入口 1', ownerName: '地球科学展厅', floorId: 'L3', position: { x: 131, y: 0, z: 141 }, nodeId: 'n109' },
|
||
{ id: 110, name: '古生物展厅A 出入口', ownerName: '古生物展厅A', floorId: 'L2', position: { x: 171, y: 0, z: 181 }, nodeId: 'n110' },
|
||
{ id: 111, name: '共享展厅 出入口', ownerName: '共享展厅', floorId: 'L6', position: { x: 210, y: 0, z: 220 }, nodeId: 'n111' },
|
||
{ id: 112, name: '共享展厅 出入口', ownerName: '共享展厅', floorId: 'L7', position: { x: 230, y: 0, z: 240 }, nodeId: 'n112' }
|
||
]
|
||
|
||
const result = toHallPois(spaces, places, 'B2')
|
||
const diagnostics = createHallPoiDiagnostics(spaces, places, result)
|
||
const byName = new Map(result.map((poi) => [poi.name, poi]))
|
||
const byId = new Map(result.map((poi) => [poi.id, poi]))
|
||
|
||
// All fixtures merge into existing POIs, maintaining 11 unique halls (verified by ID-based map)
|
||
assert.equal(result.length, 11, 'result contains 11 POIs')
|
||
assert.equal(byId.size, 11, 'all POI IDs are unique')
|
||
assert.deepEqual(byId.get('hall-1').positionGltf, [11, 0, 21])
|
||
assert.deepEqual(byId.get('hall-2').positionGltf, [31, 0, 41])
|
||
assert.deepEqual(byId.get('hall-3').positionGltf, [50, 0, 60])
|
||
assert.deepEqual(byId.get('hall-4').positionGltf, [70, 0, 80])
|
||
assert.equal(byId.has('hall-5'), false)
|
||
assert.equal(byId.get('hall-3').sourceConfidence, 'backend-sgs-sdk-space-center')
|
||
|
||
// Finding 2: whitelist enforcement prevents unrelated types
|
||
assert.equal(byName.has('茶水间'), false, 'service type rejected by whitelist')
|
||
|
||
// Finding 3: unmatched exhibition space with center emits fallback POI
|
||
assert.equal(byName.has('自然科学展厅'), true, 'unmatched space-center POI emitted')
|
||
// Place 107 (自然科学展厅 出入口) without nodeId matches space 6, falls back to space center [110, 0, 120]
|
||
assert.deepEqual(byName.get('自然科学展厅').positionGltf, [110, 0, 120], 'falls back to space center when entrance has no coordinates')
|
||
assert.equal(byName.get('自然科学展厅').sourceConfidence, 'backend-sgs-sdk-space-center', 'entrance without nodeId or coordinates uses space-center sourceConfidence')
|
||
// Both place 107 and 108 entrances should be recorded
|
||
assert.equal(byName.get('自然科学展厅').entrances.length, 2, 'both place 107 and 108 entrances recorded')
|
||
assert.equal(byName.get('自然科学展厅').entrances.some((e) => e.name === '自然科学展厅 出入口'), true, 'place 107 entrance without nodeId recorded')
|
||
assert.equal(byName.get('自然科学展厅').entrances.some((e) => e.name === '自然科学展厅【主】出入口1'), true, 'place 108 entrance with brackets recorded')
|
||
|
||
// Finding 4: entrance with missing coordinates falls back to matched space.center
|
||
assert.equal(byName.has('地球科学展厅'), true, 'entrance fallback to space.center')
|
||
// Finding 1: later entrance with BOTH nodeId and position upgrades POI to entrance-backed
|
||
assert.deepEqual(byName.get('地球科学展厅').positionGltf, [131, 0, 141], 'upgraded to entrance position [131, 0, 141]')
|
||
assert.equal(byName.get('地球科学展厅').sourceConfidence, 'backend-sgs-sdk-hall-entrance', 'Finding 1: upgraded to hall-entrance sourceConfidence')
|
||
// Finding 3: both entrances recorded, including the no-coordinate one
|
||
assert.equal(byName.get('地球科学展厅').entrances.length, 2, 'both place 104 (no-coord) and 109 (with nodeId) recorded')
|
||
assert.equal(byName.get('地球科学展厅').entrances[0].name, '地球科学展厅 出入口')
|
||
assert.equal(byName.get('地球科学展厅').entrances[0].positionGltf, undefined, 'first entrance has no coordinates')
|
||
assert.equal(byName.get('地球科学展厅').entrances.some((e) => e.name === '地球 科学 展厅 （主）出入口 1'), true, 'normalized entrance name recorded')
|
||
|
||
// Finding 1: entrance-derived sourceConfidence branch — entrance-backed halls must be backend-sgs-sdk-hall-entrance
|
||
assert.equal(byName.has('古生物展厅'), true, 'entrance with nodeId creates hall POI')
|
||
assert.equal(byName.get('古生物展厅').sourceConfidence, 'backend-sgs-sdk-hall-entrance', 'entrance with nodeId and position must have backend-sgs-sdk-hall-entrance')
|
||
assert.deepEqual(byName.get('古生物展厅').positionGltf, [151, 0, 161], 'entrance position is used for backend-sgs-sdk-hall-entrance')
|
||
|
||
// Finding 2: enforce entrance/reachable-node semantics — entrance WITHOUT nodeId that matches space should NOT get backend-sgs-sdk-hall-entrance
|
||
const nonNodeEntrance = places.find((p) => p.id === 107)
|
||
assert.equal(nonNodeEntrance.nodeId, undefined, 'fixture includes entrance without nodeId')
|
||
const naturalSciencePoi = byName.get('自然科学展厅')
|
||
assert.equal(naturalSciencePoi !== undefined, true, 'entrance without nodeId that matches space still creates POI')
|
||
assert.equal(naturalSciencePoi.sourceConfidence, 'backend-sgs-sdk-space-center', 'entrance without nodeId gets space-center not hall-entrance')
|
||
|
||
// Issue 2: Fixture validation — place 108 has coordinates but no nodeId, merges into space center POI
|
||
const place108 = places.find((p) => p.id === 108)
|
||
assert.equal(place108.nodeId, undefined, 'fixture 108 has no nodeId')
|
||
assert.deepEqual(place108.position, { x: 111, y: 0, z: 121 }, 'fixture 108 has coordinates')
|
||
|
||
// Issue 3: normalization/matching fixture with spacing and brackets
|
||
const place109 = places.find((p) => p.id === 109)
|
||
assert.equal(place109.nodeId, 'n109', 'fixture 109 has nodeId')
|
||
assert.equal(byName.has('地球科学展厅'), true, 'normalized name matches despite spacing and brackets')
|
||
const earthSciencePoi = byName.get('地球科学展厅')
|
||
// Place 104 (no nodeId, no position) created the POI with space-center sourceConfidence
|
||
// Place 109 (has nodeId and position) upgrades the POI to entrance-backed with new position
|
||
assert.equal(earthSciencePoi.sourceConfidence, 'backend-sgs-sdk-hall-entrance', 'sourceConfidence upgraded by place 109 with nodeId and position')
|
||
assert.deepEqual(earthSciencePoi.positionGltf, [131, 0, 141], 'position upgraded to place 109 entrance coordinates')
|
||
assert.equal(earthSciencePoi.entrances.length, 2, 'both place 104 and 109 entrances recorded')
|
||
assert.equal(earthSciencePoi.entrances.some((e) => e.name === '地球科学展厅 出入口'), true, 'place 104 no-coordinate entrance recorded')
|
||
assert.equal(earthSciencePoi.entrances.some((e) => e.name === '地球 科学 展厅 （主）出入口 1'), true, 'place 109 normalized entrance recorded')
|
||
|
||
// Finding 2 re-review: prefer exact match over shorter substring matches
|
||
assert.equal(byId.get('hall-9').name, '古生物展厅A', 'exact normalized match beats overlapping shorter hall names')
|
||
assert.deepEqual(byId.get('hall-9').positionGltf, [171, 0, 181], 'exact matched hall uses its own entrance position')
|
||
|
||
// Finding 3 re-review: place-only fallback IDs include floor identity to avoid collisions across floors
|
||
assert.equal(byId.has('hall-place-L6-共享展厅'), true, 'floor-scoped fallback ID created for L6 place-only hall')
|
||
assert.equal(byId.has('hall-place-L7-共享展厅'), true, 'floor-scoped fallback ID created for L7 place-only hall')
|
||
assert.notEqual(byId.get('hall-place-L6-共享展厅').id, byId.get('hall-place-L7-共享展厅').id, 'same-named place-only halls on different floors stay distinct')
|
||
|
||
// Finding 1 re-review: diagnostics count skipped spaces by missing hall-{space.id}, not by total hall POI count
|
||
assert.equal(diagnostics.skippedSpaceCount, 0, 'place-only halls do not inflate skipped-space diagnostics when all eligible spaces have hall-{space.id}')
|
||
assert.equal(diagnostics.skippedPlaceCount, 0, 'all hall places are represented by entrances')
|
||
|
||
console.log('SGS hall POI adapter smoke check passed')
|