@ifc-lite/create 1.15.0 → 1.16.0

package/dist/in-store/extract-walls.js

@@ -28,7 +28,7 @@
  * callers (and the viewer's Auto Spaces UI) can surface why a wall
  * didn't contribute to the planar graph.
  */
-import { EntityExtractor, extractLengthUnitScale, } from '@ifc-lite/parser';
+import { EntityExtractor, extractLengthUnitScale, extractMaterialsOnDemand, } from '@ifc-lite/parser';
 /**
  * Element types treated as "wall-like" dividers by default. Extends
  * the obvious walls with curtain walls (often the only divider on a
@@ -51,6 +51,7 @@ const AXIS_EPS = 1e-6;
 export function extractWallSegmentsForStorey(store, storeyExpressId, overlay, options = {}) {
     const segments = [];
     const contributing = [];
+    const wallThicknesses = [];
     const skipped = [];
     const debug = !!options.debug;
     const log = debug ? (...args) => console.debug('[extract-walls]', ...args) : () => { };
@@ -72,7 +73,7 @@ export function extractWallSegmentsForStorey(store, storeyExpressId, overlay, op
     log(`length unit scale = ${lengthUnitScale} (raw → metres)`);
     if (!store.source) {
         log('no source bytes on data store — extraction cannot run');
-        return { segments, contributingWallIds: contributing, skipped, considered: 0, lengthUnitScale };
+        return { segments, contributingWallIds: contributing, wallThicknesses, skipped, considered: 0, lengthUnitScale };
     }
     const dividerTypes = new Set(DEFAULT_DIVIDER_TYPES);
     if (options.extraDividerTypes) {
@@ -80,13 +81,14 @@ export function extractWallSegmentsForStorey(store, storeyExpressId, overlay, op
             dividerTypes.add(t.toLowerCase());
     }
     const extractor = new EntityExtractor(store.source);
-    const dividerIds = collectDividerIdsOnStorey(store, storeyExpressId, dividerTypes, log);
+    const dividerIds = collectDividerIdsOnStorey(store, extractor, storeyExpressId, dividerTypes, log);
     log(`storey #${storeyExpressId}: ${dividerIds.length} contained divider element(s)`);
     for (const id of dividerIds) {
         const result = extractWallAxisFromSource(store, extractor, id, log);
         if (result.segment) {
             segments.push(scaleSegment(result.segment, lengthUnitScale));
             contributing.push(id);
+            wallThicknesses.push(wallThicknessFromMaterial(store, id));
         }
         else {
             skipped.push({ wallId: id, reason: result.reason ?? 'no-axis-or-rect-profile' });
@@ -104,6 +106,7 @@ export function extractWallSegmentsForStorey(store, storeyExpressId, overlay, op
                 // metre coords — don't double-scale.
                 segments.push(result.segment);
                 contributing.push(ent.expressId);
+                wallThicknesses.push(undefined); // overlay walls carry no material yet
             }
             else {
                 skipped.push({ wallId: ent.expressId, reason: result.reason ?? 'no-axis-or-rect-profile' });
@@ -126,11 +129,27 @@ export function extractWallSegmentsForStorey(store, storeyExpressId, overlay, op
     return {
         segments,
         contributingWallIds: contributing,
+        wallThicknesses,
         skipped,
         considered: dividerIds.length + overlayCount,
         lengthUnitScale,
     };
 }
+/**
+ * Total thickness (metres) of a wall's material layer set, or `undefined` when
+ * the wall has no resolvable layers. The material resolver already scales layer
+ * thicknesses to metres, so no further unit conversion is applied.
+ */
+function wallThicknessFromMaterial(store, wallId) {
+    const info = extractMaterialsOnDemand(store, wallId);
+    const layers = info?.layers;
+    if (!layers || layers.length === 0)
+        return undefined;
+    let total = 0;
+    for (const layer of layers)
+        total += layer.thickness ?? 0;
+    return total > 0 ? total : undefined;
+}
 function scaleSegment(seg, scale) {
     if (scale === 1)
         return seg;
@@ -142,12 +161,18 @@ function scaleSegment(seg, scale) {
 function isDividerType(type, dividerTypes) {
     return dividerTypes.has(type.toLowerCase());
 }
-function collectDividerIdsOnStorey(store, storeyId, dividerTypes, log) {
+function collectDividerIdsOnStorey(store, extractor, storeyId, dividerTypes, log) {
     const ids = [];
     const seen = new Set();
     if (!store.source)
         return ids;
-    const extractor = new EntityExtractor(store.source);
+    // Build relating → related-children indices ONCE, then walk in O(1) per
+    // parent. Previously each `descendAggregate` / `walkContainmentInto`
+    // call walked every IfcRelAggregates / IfcRelContainedInSpatialStructure
+    // entity in the file looking for one with the right relating id —
+    // O(R·N) total in the number of rels and parents visited.
+    const aggregateChildren = buildRelatingChildrenIndex(store, extractor, 'IFCRELAGGREGATES', 4, 5);
+    const containmentChildren = buildRelatingChildrenIndex(store, extractor, 'IFCRELCONTAINEDINSPATIALSTRUCTURE', 5, 4);
     const visitMember = (memberId) => {
         if (seen.has(memberId))
             return;
@@ -169,80 +194,112 @@ function collectDividerIdsOnStorey(store, storeyId, dividerTypes, log) {
         seen.add(parentId);
         // Anything `IfcRelContainedInSpatialStructure`-anchored to this
         // sub-structure should still be reachable.
-        walkContainmentInto(parentId);
+        const contained = containmentChildren.get(parentId);
+        if (contained)
+            for (const m of contained)
+                visitMember(m);
         // And recurse through aggregation.
-        const aggRels = store.entityIndex.byType.get('IFCRELAGGREGATES') ?? [];
-        for (const relId of aggRels) {
-            const ref = store.entityIndex.byId.get(relId);
-            if (!ref)
-                continue;
-            const rel = extractor.extractEntity(ref);
-            if (!rel)
-                continue;
-            const relating = rel.attributes[4];
-            if (typeof relating !== 'number' || relating !== parentId)
-                continue;
-            const related = rel.attributes[5];
-            if (!Array.isArray(related))
-                continue;
-            for (const child of related) {
-                if (typeof child !== 'number')
-                    continue;
-                visitMember(child);
-            }
-        }
-    };
-    const walkContainmentInto = (parentId) => {
-        const containedRels = store.entityIndex.byType.get('IFCRELCONTAINEDINSPATIALSTRUCTURE') ?? [];
-        for (const relId of containedRels) {
-            const ref = store.entityIndex.byId.get(relId);
-            if (!ref)
-                continue;
-            const rel = extractor.extractEntity(ref);
-            if (!rel)
-                continue;
-            const relating = rel.attributes[5];
-            if (typeof relating !== 'number' || relating !== parentId)
-                continue;
-            const related = rel.attributes[4];
-            if (!Array.isArray(related))
-                continue;
-            for (const member of related) {
-                if (typeof member !== 'number')
-                    continue;
-                visitMember(member);
-            }
-        }
+        const agg = aggregateChildren.get(parentId);
+        if (agg)
+            for (const c of agg)
+                visitMember(c);
     };
     // Mark the storey itself as seen but DON'T push it (we want its
     // children, not the storey id).
     seen.add(storeyId);
-    walkContainmentInto(storeyId);
+    const storeyContained = containmentChildren.get(storeyId);
+    if (storeyContained)
+        for (const m of storeyContained)
+            visitMember(m);
     // Some authoring tools attach elements via IfcRelAggregates to the
     // storey instead of containment (or in addition). Walk both
     // unconditionally to keep coverage broad.
-    const aggRels = store.entityIndex.byType.get('IFCRELAGGREGATES') ?? [];
-    for (const relId of aggRels) {
+    const storeyAgg = aggregateChildren.get(storeyId);
+    if (storeyAgg)
+        for (const c of storeyAgg)
+            visitMember(c);
+    log(`collected ${ids.length} divider candidate(s) — types: ${[...dividerTypes].join(', ')}`);
+    return ids;
+}
+/**
+ * Footprint polygons (model-local metres, same frame as the extracted wall
+ * segments) of existing `IfcSpace` per storey — so generation can skip *only*
+ * the new rooms that overlap an already-present space (per-space dedup), while
+ * still adding rooms an empty part of the floor lacks. Keyed by storey
+ * expressId; storeys with no resolvable space footprints are omitted.
+ */
+export function existingSpaceFootprintsByStorey(store) {
+    const out = new Map();
+    if (!store.source)
+        return out;
+    const extractor = new EntityExtractor(store.source);
+    const scale = extractLengthUnitScale(store.source, store.entityIndex) ?? 1;
+    const aggregated = buildRelatingChildrenIndex(store, extractor, 'IFCRELAGGREGATES', 4, 5);
+    const contained = buildRelatingChildrenIndex(store, extractor, 'IFCRELCONTAINEDINSPATIALSTRUCTURE', 5, 4);
+    for (const st of store.getEntitiesByType('IfcBuildingStorey')) {
+        const kids = [...(aggregated.get(st.expressId) ?? []), ...(contained.get(st.expressId) ?? [])];
+        const footprints = [];
+        for (const id of kids) {
+            if ((store.entities.getTypeName(id) ?? '').toUpperCase() !== 'IFCSPACE')
+                continue;
+            const ref = store.entityIndex.byId.get(id);
+            if (!ref)
+                continue;
+            const ent = extractor.extractEntity(ref);
+            if (!ent)
+                continue;
+            const placementId = numericAttr(ent.attributes[5]); // ObjectPlacement
+            const representationId = numericAttr(ent.attributes[6]); // Representation
+            if (placementId === null || representationId === null)
+                continue;
+            const frame = readPlacementFrame(store, extractor, undefined, placementId);
+            const localPts = gatherBodyFootprintPoints(store, extractor, undefined, representationId);
+            if (!frame || !localPts || localPts.length < 3)
+                continue;
+            footprints.push(localPts.map((p) => {
+                const w = applyFrame(frame, p);
+                return [w[0] * scale, w[1] * scale];
+            }));
+        }
+        if (footprints.length)
+            out.set(st.expressId, footprints);
+    }
+    return out;
+}
+/**
+ * Index every relationship of `relType` by its "relating" attribute, so a
+ * lookup of "what's anchored to id X" becomes O(1) instead of an O(R)
+ * scan of every relationship.
+ */
+function buildRelatingChildrenIndex(store, extractor, relType, relatingIdx, relatedIdx) {
+    const out = new Map();
+    const relIds = store.entityIndex.byType.get(relType);
+    if (!relIds)
+        return out;
+    for (const relId of relIds) {
         const ref = store.entityIndex.byId.get(relId);
         if (!ref)
             continue;
         const rel = extractor.extractEntity(ref);
         if (!rel)
             continue;
-        const relating = rel.attributes[4];
-        if (typeof relating !== 'number' || relating !== storeyId)
+        const relating = rel.attributes[relatingIdx];
+        if (typeof relating !== 'number')
             continue;
-        const related = rel.attributes[5];
+        const related = rel.attributes[relatedIdx];
         if (!Array.isArray(related))
             continue;
+        let bucket = out.get(relating);
+        if (!bucket) {
+            bucket = [];
+            out.set(relating, bucket);
+        }
         for (const child of related) {
-            if (typeof child !== 'number')
-                continue;
-            visitMember(child);
+            if (typeof child === 'number')
+                bucket.push(child);
         }
     }
-    log(`collected ${ids.length} divider candidate(s) — types: ${[...dividerTypes].join(', ')}`);
-    return ids;
+    return out;
 }
 function extractWallAxisFromSource(store, extractor, wallId, log) {
     const ref = store.entityIndex.byId.get(wallId);
@@ -299,9 +356,278 @@ function computeWallSegment(store, extractor, placementId, representationId, ove
         ];
         return finaliseSegment(start, end, wallId, log, 'rect-profile');
     }
-    log(`wall #${wallId}: no Axis representation and no IfcRectangleProfileDef body — skipping`);
+    // Strategy 3 — body-footprint centreline. For walls with only a meshed
+    // body (IfcTriangulatedFaceSet / IfcPolygonalFaceSet) and no Axis/rect
+    // profile, project the body vertices to the local ground plane (drop the
+    // local vertical Z) and take the principal axis of that footprint as the
+    // wall centreline. Covers tessellated exports that the two shape-specific
+    // strategies miss.
+    const footprint = gatherBodyFootprintPoints(store, extractor, overlay, representationId);
+    if (footprint && footprint.length >= 3) {
+        const centreline = principalAxisCentreline(footprint);
+        if (centreline) {
+            const start = applyFrame(frame, centreline[0]);
+            const end = applyFrame(frame, centreline[1]);
+            return finaliseSegment(start, end, wallId, log, 'body-footprint');
+        }
+    }
+    log(`wall #${wallId}: no Axis representation, no IfcRectangleProfileDef body, no meshed footprint — skipping`);
     return { segment: null, reason: 'no-axis-or-rect-profile' };
 }
+/**
+ * Gather the wall body's ground-plane footprint points (local frame, raw
+ * units) from a meshed representation. Reads the vertex list of every
+ * `IfcTriangulatedFaceSet` / `IfcPolygonalFaceSet` item in a non-`Axis`
+ * representation and drops the local vertical (Z), which is up in the
+ * wall-local frame before placement. Returns null when there's no mesh body.
+ */
+function gatherBodyFootprintPoints(store, extractor, overlay, representationId) {
+    const productShape = readEntity(store, extractor, overlay, representationId);
+    if (!productShape)
+        return null;
+    const reps = productShape.attributes[2];
+    if (!Array.isArray(reps))
+        return null;
+    const pts = [];
+    for (const repRef of reps) {
+        const repId = numericAttr(repRef);
+        if (repId === null)
+            continue;
+        const rep = readEntity(store, extractor, overlay, repId);
+        if (!rep)
+            continue;
+        const identifier = stringAttr(rep.attributes[1]);
+        if (identifier && identifier.toLowerCase() === 'axis')
+            continue; // handled by Strategy 1
+        const items = rep.attributes[3];
+        if (!Array.isArray(items))
+            continue;
+        for (const itemRef of items) {
+            const itemId = numericAttr(itemRef);
+            if (itemId === null)
+                continue;
+            const item = readEntity(store, extractor, overlay, itemId);
+            if (!item)
+                continue;
+            const itemType = resolveEntityTypeName(store, item, itemId);
+            if (itemType === 'ifctriangulatedfaceset' || itemType === 'ifcpolygonalfaceset') {
+                // Vertices live in an IfcCartesianPointList3D at attribute 0; its
+                // attribute 0 is the flat list of [x, y, z] triples (rep frame).
+                const coordId = numericAttr(item.attributes[0]);
+                if (coordId === null)
+                    continue;
+                const coordList = readEntity(store, extractor, overlay, coordId);
+                if (!coordList || !Array.isArray(coordList.attributes[0]))
+                    continue;
+                for (const p of coordList.attributes[0]) {
+                    const v = readVec3(p);
+                    if (v)
+                        pts.push([v[0], v[1]]);
+                }
+            }
+            else if (itemType === 'ifcextrudedareasolid') {
+                gatherExtrudedFootprint(store, extractor, overlay, item, pts);
+            }
+            else if (itemType === 'ifcfacetedbrep') {
+                gatherBrepFootprint(store, extractor, overlay, item, pts);
+            }
+        }
+    }
+    return pts.length >= 3 ? pts : null;
+}
+const IDENTITY2 = { o: [0, 0], x: [1, 0], y: [0, 1] };
+const apply2 = (f, p) => [
+    f.o[0] + f.x[0] * p[0] + f.y[0] * p[1],
+    f.o[1] + f.x[1] * p[0] + f.y[1] * p[1],
+];
+/** Read an IfcAxis2Placement2D/3D into its XY affine frame (Z ignored). */
+function readPlacement2(store, extractor, overlay, ref) {
+    const id = numericAttr(ref);
+    if (id === null)
+        return IDENTITY2;
+    const ent = readEntity(store, extractor, overlay, id);
+    if (!ent)
+        return IDENTITY2;
+    const o = readCartesianPoint2D(store, extractor, overlay, ent.attributes[0]) ?? [0, 0];
+    // RefDirection: attr 1 on the 2D placement, attr 2 on the 3D placement.
+    const is3d = resolveEntityTypeName(store, ent, id) === 'ifcaxis2placement3d';
+    const refDir = readCartesianPoint2D(store, extractor, overlay, ent.attributes[is3d ? 2 : 1]);
+    let xx = 1, xy = 0;
+    if (refDir) {
+        const l = Math.hypot(refDir[0], refDir[1]) || 1;
+        xx = refDir[0] / l;
+        xy = refDir[1] / l;
+    }
+    return { o, x: [xx, xy], y: [-xy, xx] };
+}
+/**
+ * Footprint of a vertically-extruded solid = its swept profile placed into the
+ * rep frame. Handles rectangle and arbitrary-(polyline-)closed profiles; skips
+ * non-vertical extrusions (the profile wouldn't be a plan footprint then).
+ */
+function gatherExtrudedFootprint(store, extractor, overlay, solid, out) {
+    // IfcExtrudedAreaSolid = SweptArea(0), Position(1), ExtrudedDirection(2), Depth(3).
+    // The swept profile is a *plan* footprint only when the extrusion ends up
+    // world-vertical: ExtrudedDirection must be the solid's local Z AND the
+    // solid's Position must keep that Z world-up. Multi-layer walls (e.g. #218)
+    // extrude along their thickness via a Position rotated to a horizontal axis —
+    // their profile is an elevation, not a footprint, so skip rather than emit a
+    // bogus centreline.
+    const dirId = numericAttr(solid.attributes[2]);
+    if (dirId !== null) {
+        const d = readVec3(readEntity(store, extractor, overlay, dirId)?.attributes[0]);
+        if (d && Math.abs(d[2]) < 0.9)
+            return;
+    }
+    const posId = numericAttr(solid.attributes[1]);
+    if (posId !== null) {
+        const posEnt = readEntity(store, extractor, overlay, posId);
+        const axisId = posEnt ? numericAttr(posEnt.attributes[1]) : null;
+        if (axisId !== null) {
+            const az = readVec3(readEntity(store, extractor, overlay, axisId)?.attributes[0]);
+            if (az && Math.abs(az[2]) < 0.9)
+                return; // solid's local Z isn't world-up
+        }
+    }
+    const solidPos = readPlacement2(store, extractor, overlay, solid.attributes[1]);
+    const profileId = numericAttr(solid.attributes[0]);
+    if (profileId === null)
+        return;
+    const profile = readEntity(store, extractor, overlay, profileId);
+    if (!profile)
+        return;
+    const ptype = resolveEntityTypeName(store, profile, profileId);
+    if (ptype === 'ifcrectangleprofiledef') {
+        const ppos = readPlacement2(store, extractor, overlay, profile.attributes[2]);
+        const xd = numericAttr(profile.attributes[3]) ?? 0;
+        const yd = numericAttr(profile.attributes[4]) ?? 0;
+        if (xd <= 0 || yd <= 0)
+            return;
+        const corners = [[-xd / 2, -yd / 2], [xd / 2, -yd / 2], [xd / 2, yd / 2], [-xd / 2, yd / 2]];
+        for (const c of corners)
+            out.push(apply2(solidPos, apply2(ppos, c)));
+    }
+    else if (ptype === 'ifcarbitraryclosedprofiledef' || ptype === 'ifcarbitraryprofiledefwithvoids') {
+        // OuterCurve at attr 2 for both; read its points as the footprint cloud
+        // (PCA only needs the cloud, not edge order). Polyline or IndexedPolyCurve.
+        const ocId = numericAttr(profile.attributes[2]);
+        if (ocId === null)
+            return;
+        const oc = readEntity(store, extractor, overlay, ocId);
+        if (!oc)
+            return;
+        const octype = resolveEntityTypeName(store, oc, ocId);
+        if (octype === 'ifcpolyline' && Array.isArray(oc.attributes[0])) {
+            for (const ptRef of oc.attributes[0]) {
+                const v = readCartesianPoint2D(store, extractor, overlay, ptRef);
+                if (v)
+                    out.push(apply2(solidPos, v));
+            }
+        }
+        else if (octype === 'ifcindexedpolycurve') {
+            // IfcIndexedPolyCurve.Points → IfcCartesianPointList2D (flat [x,y] list).
+            const listId = numericAttr(oc.attributes[0]);
+            if (listId === null)
+                return;
+            const list = readEntity(store, extractor, overlay, listId);
+            if (!list || !Array.isArray(list.attributes[0]))
+                return;
+            for (const p of list.attributes[0]) {
+                const v = readVec3(p);
+                if (v)
+                    out.push(apply2(solidPos, [v[0], v[1]]));
+            }
+        }
+    }
+}
+/**
+ * Footprint of an IfcFacetedBrep = all its shell vertices projected to XY.
+ * Walks Outer (IfcClosedShell) → faces → bounds → IfcPolyLoop → points. The
+ * vertices are already in the rep frame, so no extra placement is needed.
+ */
+function gatherBrepFootprint(store, extractor, overlay, brep, out) {
+    const shellId = numericAttr(brep.attributes[0]);
+    if (shellId === null)
+        return;
+    const shell = readEntity(store, extractor, overlay, shellId);
+    if (!shell || !Array.isArray(shell.attributes[0]))
+        return;
+    for (const faceRef of shell.attributes[0]) {
+        const faceId = numericAttr(faceRef);
+        if (faceId === null)
+            continue;
+        const face = readEntity(store, extractor, overlay, faceId);
+        if (!face || !Array.isArray(face.attributes[0]))
+            continue;
+        for (const boundRef of face.attributes[0]) {
+            const boundId = numericAttr(boundRef);
+            if (boundId === null)
+                continue;
+            const bound = readEntity(store, extractor, overlay, boundId);
+            if (!bound)
+                continue;
+            const loopId = numericAttr(bound.attributes[0]);
+            if (loopId === null)
+                continue;
+            const loop = readEntity(store, extractor, overlay, loopId);
+            if (!loop || !Array.isArray(loop.attributes[0]))
+                continue;
+            for (const ptRef of loop.attributes[0]) {
+                const v = readCartesianPoint2D(store, extractor, overlay, ptRef);
+                if (v)
+                    out.push(v);
+            }
+        }
+    }
+}
+/**
+ * Principal-axis centreline of a 2D point cloud (PCA). A wall footprint is a
+ * thin elongated rectangle, so the largest-eigenvalue direction is the wall's
+ * length and the centroid sits on the centreline — exactly the axis we want.
+ * Returns the centroid-anchored segment spanning the footprint's extent along
+ * that axis, or null if it collapses to a point.
+ */
+function principalAxisCentreline(points) {
+    const n = points.length;
+    let cx = 0, cy = 0;
+    for (const [x, y] of points) {
+        cx += x;
+        cy += y;
+    }
+    cx /= n;
+    cy /= n;
+    let sxx = 0, sxy = 0, syy = 0;
+    for (const [x, y] of points) {
+        const dx = x - cx, dy = y - cy;
+        sxx += dx * dx;
+        sxy += dx * dy;
+        syy += dy * dy;
+    }
+    const tr = sxx + syy;
+    const disc = Math.sqrt(Math.max(0, (tr * tr) / 4 - (sxx * syy - sxy * sxy)));
+    const lambda = tr / 2 + disc; // largest eigenvalue
+    let ex = sxy, ey = lambda - sxx;
+    if (Math.hypot(ex, ey) < 1e-12) {
+        ex = lambda - syy;
+        ey = sxy;
+    }
+    const elen = Math.hypot(ex, ey);
+    if (elen < 1e-12)
+        return null;
+    ex /= elen;
+    ey /= elen;
+    let tmin = Infinity, tmax = -Infinity;
+    for (const [x, y] of points) {
+        const t = (x - cx) * ex + (y - cy) * ey;
+        if (t < tmin)
+            tmin = t;
+        if (t > tmax)
+            tmax = t;
+    }
+    if (tmax - tmin < AXIS_EPS)
+        return null;
+    return [[cx + ex * tmin, cy + ey * tmin], [cx + ex * tmax, cy + ey * tmax]];
+}
 function finaliseSegment(start, end, wallId, log, source) {
     const dx = end[0] - start[0];
     const dy = end[1] - start[1];
@@ -402,7 +728,7 @@ function readAxisRepresentationEndpoints(store, extractor, overlay, representati
             const item = readEntity(store, extractor, overlay, itemId);
             if (!item)
                 continue;
-            const itemType = (store.entities.getTypeName(itemId) || item.type || '').toLowerCase();
+            const itemType = resolveEntityTypeName(store, item, itemId);
             if (itemType !== 'ifcpolyline')
                 continue;
             // IfcPolyline.Points = list of IfcCartesianPoint refs (attribute 0).
@@ -463,7 +789,7 @@ function readWallLength(store, extractor, overlay, representationId) {
             const profile = readEntity(store, extractor, overlay, profileId);
             if (!profile)
                 continue;
-            const profileType = profileTypeName(store, profile, profileId);
+            const profileType = resolveEntityTypeName(store, profile, profileId);
             if (profileType !== 'ifcrectangleprofiledef')
                 continue;
             // IfcRectangleProfileDef.XDim = attribute index 3.
@@ -474,9 +800,18 @@ function readWallLength(store, extractor, overlay, representationId) {
     }
     return null;
 }
-function profileTypeName(store, profile, profileId) {
-    const fromTable = store.entities.getTypeName(profileId);
-    const name = (fromTable && fromTable !== 'Unknown' ? fromTable : profile.type) ?? '';
+/**
+ * Robust IFC type-name for an entity read from source. The columnar entity
+ * table only indexes products/named entities, so `getTypeName` returns
+ * `'Unknown'` for geometry primitives (IfcPolyline, IfcCartesianPoint,
+ * profiles, solids). The extractor's `entity.type` is always reliable — so
+ * prefer the table only when it actually resolved, otherwise fall back to the
+ * extractor type. (Reading the table's `'Unknown'` literally was what made
+ * every `Curve2D` Axis polyline — e.g. all of AC20-FZK-Haus — get skipped.)
+ */
+export function resolveEntityTypeName(store, entity, entityId) {
+    const fromTable = store.entities.getTypeName(entityId);
+    const name = (fromTable && fromTable !== 'Unknown' ? fromTable : entity.type) ?? '';
     return name.toLowerCase();
 }
 function readEntity(store, extractor, overlay, expressId) {