@twinfinity/printing 5.0.3-ci.28538-beta

package/src/layout/itemBuilders.ts

@@ -0,0 +1,159 @@
+import type { SectionRenderState } from '@twinfinity/geometry';
+import { normalizePropertySets } from './metadata';
+import { getPathValue } from './renderUtils';
+import { buildModelViewFromRaw } from './model';
+import { ProductFieldPaths, NormalizedProductItem, SvgModelView, LabelStyle } from './types';
+
+import { getProp } from './typeGuards';
+
+export interface ProductLike {
+    product?: any;
+    polylines?: Array<{ points?: Array<{ x: number; z: number }> }>;
+}
+
+export interface BuildViewportItemsOptions {
+    productFields?: ProductFieldPaths;
+}
+
+/**
+ * Normalize a single product entry using explicit field paths.
+ */
+export const normalizeProductEntry = (entry: ProductLike, productFields: ProductFieldPaths): NormalizedProductItem => {
+    if (!productFields?.idPath || !productFields?.namePath || !productFields?.areaPath) {
+        throw new Error(
+            'productFields must include idPath, namePath, and areaPath using propertySets.<Set>.<Prop>.value.'
+        );
+    }
+    const product = getProp(entry, 'product') ?? entry;
+    const propertySets = normalizePropertySets(product);
+    const getVal = (path: string): unknown => getPathValue({ propertySets }, path);
+    const idVal = getVal(productFields.idPath) ?? getProp(product, 'gid');
+    const nameVal = getVal(productFields.namePath);
+    const areaVal = getVal(productFields.areaPath);
+    // class.type = IfcClassType ("space", "walls", etc.) — used by template filters
+    // class.id = PredefinedIfcClassId ("IfcSpace", "IfcWall", etc.) — used as fallback
+    // classPath from propertySets may contain a PredefinedIfcClassId
+    const classPathVal = productFields.classPath ? getVal(productFields.classPath) : null;
+    const productClass = getProp(product, 'class');
+    const classType = getProp(productClass, 'type') as string | null; // IfcClassType
+    const classId = getProp(productClass, 'id') as string | null; // PredefinedIfcClassId
+    // ifcClass = IfcClassType category; ifcClassId = PredefinedIfcClassId
+    const ifcClass = (classType ?? null) as string | null;
+    const ifcClassId = (classPathVal ?? classId ?? null) as string | null;
+    // Try multiple sources for coordinates:
+    // 1. BBox center from product
+    // 2. Polylines center from entry
+    // 3. Direct x/z on entry or product
+    let { x, z } = getBBoxCenter(product);
+    if (x === null || z === null) {
+        const polyCenter = computePolylinesCenter(entry);
+        x = polyCenter.x ?? x;
+        z = polyCenter.z ?? z;
+    }
+    if (x === null || z === null) {
+        const directX = getProp(entry, 'x') ?? getProp(product, 'x');
+        const directZ = getProp(entry, 'z') ?? getProp(product, 'z');
+        if (Number.isFinite(directX)) x = directX as number;
+        if (Number.isFinite(directZ)) z = directZ as number;
+    }
+    const rawPolylines = getProp(entry, 'polylines');
+    return {
+        gid: getProp(product, 'gid') as string | undefined,
+        ifcClass,
+        ifcClassId,
+        propertySets,
+        productId: idVal ? String(idVal) : '-',
+        productName: typeof nameVal === 'string' && nameVal.trim().length ? nameVal.trim() : '-',
+        area: typeof areaVal === 'number' && Number.isFinite(areaVal) ? areaVal : null,
+        x,
+        z,
+        text: typeof nameVal === 'string' && nameVal.trim().length ? nameVal.trim() : '-',
+        polylines: Array.isArray(rawPolylines) ? rawPolylines : undefined
+    };
+};
+
+const getBBoxCenter = (product: unknown): { x: number | null; z: number | null } => {
+    try {
+        const boundingInfo = getProp(product, 'boundingInfo');
+        const boundingInfoResult = typeof boundingInfo === 'function' ? boundingInfo() : null;
+        const bbox = getProp(boundingInfoResult, 'boundingBox');
+        const min = getProp(bbox, 'minimumWorld') ?? getProp(bbox, 'minimum');
+        const max = getProp(bbox, 'maximumWorld') ?? getProp(bbox, 'maximum');
+        const minX = getProp(min, 'x');
+        const maxX = getProp(max, 'x');
+        const minZ = getProp(min, 'z');
+        const maxZ = getProp(max, 'z');
+        if (Number.isFinite(minX) && Number.isFinite(maxX) && Number.isFinite(minZ) && Number.isFinite(maxZ)) {
+            return { x: ((minX as number) + (maxX as number)) * 0.5, z: ((minZ as number) + (maxZ as number)) * 0.5 };
+        }
+    } catch {
+        // Bounding info access may fail for products without geometry or with malformed data structures.
+        // This is expected behavior - we return null coordinates as fallback.
+    }
+    return { x: null, z: null };
+};
+
+export const computePolylinesCenter = (entry: unknown): { x: number | null; z: number | null } => {
+    try {
+        const polylines = getProp(entry, 'polylines');
+        if (!Array.isArray(polylines) || !polylines.length) {
+            return { x: null, z: null };
+        }
+        let sumX = 0;
+        let sumZ = 0;
+        let count = 0;
+        for (const polyline of polylines) {
+            const points = getProp(polyline, 'points');
+            if (!Array.isArray(points)) continue;
+            for (const pt of points) {
+                const px = getProp(pt, 'x');
+                const pz = getProp(pt, 'z');
+                if (Number.isFinite(px) && Number.isFinite(pz)) {
+                    sumX += px as number;
+                    sumZ += pz as number;
+                    count++;
+                }
+            }
+        }
+        if (count > 0) {
+            return { x: sumX / count, z: sumZ / count };
+        }
+    } catch {
+        // Polyline access may fail - return null
+    }
+    return { x: null, z: null };
+};
+
+/**
+ * Normalize raw product entries into viewport items using explicit field paths.
+ * Requires productFields (id/name/area/class) pointing to propertySets.<Set>.<Prop>.value.
+ */
+export const buildViewportItems = (
+    entries: ProductLike[],
+    options?: BuildViewportItemsOptions
+): NormalizedProductItem[] => {
+    if (!options?.productFields) {
+        throw new Error('buildViewportItems requires productFields (idPath/namePath/areaPath/classPath).');
+    }
+    const { idPath, namePath, areaPath } = options.productFields;
+    if (!idPath || !namePath || !areaPath) {
+        throw new Error(
+            'productFields must include idPath, namePath, and areaPath using propertySets.<Set>.<Prop>.value.'
+        );
+    }
+    return (entries ?? []).map((entry: any) => normalizeProductEntry(entry, options.productFields!));
+};
+
+export function sectionStateToModelView(state: SectionRenderState, labelStyle?: LabelStyle): SvgModelView {
+    const model = buildModelViewFromRaw(
+        state.paths,
+        state.labels,
+        state.transform,
+        state.geometryTransform,
+        labelStyle
+    );
+    if (!model) {
+        throw new Error('sectionStateToModelView requires paths, transform, and geometryTransform.');
+    }
+    return model;
+}

package/src/layout/labelsRender.ts

@@ -0,0 +1,170 @@
+import { LabelsElement, LayoutData } from './types';
+import { matchesV2Filter } from './filters';
+import { pointInPolygon } from './clipUtils';
+import { getPathValue, resolvePath, escapeAttr, escapeText } from './renderUtils';
+
+import { isRecord, getProp } from './typeGuards';
+
+export interface ViewportRenderInfo {
+    mmPerModel: number;
+    contentWidthMm: number;
+    contentHeightMm: number;
+    offsetX: number;
+    offsetY: number;
+    rotationDeg: number;
+    transform: {
+        viewMinX: number;
+        viewMaxX: number;
+        viewMinZ: number;
+        viewMaxZ: number;
+        viewWidth: number;
+        viewHeight: number;
+    };
+    centerX: number;
+    centerY: number;
+    centerModelX: number;
+    centerModelY: number;
+}
+
+export const renderLabels = (
+    labelElements: LabelsElement[],
+    data: LayoutData,
+    viewportRenderInfo: Record<string, ViewportRenderInfo>,
+    viewportClipLabels: Record<string, boolean>,
+    viewportClipPolygonsLocal: Record<string, Array<Array<{ x: number; y: number }>>>,
+    viewportClipPolygonsWorld: Record<string, Array<Array<{ x: number; z: number }>>>,
+    styles: Record<string, unknown>,
+    dataWithViewport: unknown,
+    warnings: string[]
+): string[] => {
+    const parts: string[] = [];
+
+    for (const dl of labelElements) {
+        const vpInfo = viewportRenderInfo[dl.viewport];
+        if (!vpInfo) {
+            warnings.push(`Labels '${dl.id}' missing viewport '${dl.viewport}'.`);
+            continue;
+        }
+        if (vpInfo.rotationDeg !== 0) {
+            warnings.push(`Labels '${dl.id}' skipped because rotation is not supported.`);
+            continue;
+        }
+        if (!vpInfo.transform) {
+            warnings.push(`Labels '${dl.id}' skipped because model transform is missing.`);
+            continue;
+        }
+        // Items come from the bound viewport's data
+        const items = getPathValue(data, `viewports.${dl.viewport}.items`);
+        if (!Array.isArray(items) || !items.length) {
+            continue;
+        }
+        // Filter by class + where
+        let filteredItems =
+            dl.class || dl.where ? items.filter((item) => matchesV2Filter(item, dl.class, dl.where)) : items;
+
+        console.log(`[Labels ${dl.id}] Total items:`, items.length, 'After class+where filter:', filteredItems.length);
+
+        // If matchClipFilter is true, filter by spatial position inside clip polygon
+        if (dl.matchClipFilter && viewportClipPolygonsWorld[dl.viewport]?.length) {
+            const clipPolygons = viewportClipPolygonsWorld[dl.viewport];
+            console.log(`[Labels ${dl.id}] Applying matchClipFilter (spatial) with ${clipPolygons.length} polygons`);
+            const beforeClipFilter = filteredItems.length;
+            filteredItems = filteredItems.filter((item) => {
+                const ix = getProp(item, 'x');
+                const iz = getProp(item, 'z');
+                if (!Number.isFinite(ix) || !Number.isFinite(iz)) return false;
+                return clipPolygons.some((poly) => {
+                    // pointInPolygon expects y coordinate, but we use z for world space
+                    const polyWith2D = poly.map((p) => ({ x: p.x, y: p.z }));
+                    return pointInPolygon(polyWith2D, ix as number, iz as number);
+                });
+            });
+            console.log(
+                `[Labels ${dl.id}] After matchClipFilter (spatial):`,
+                filteredItems.length,
+                '(was:',
+                beforeClipFilter,
+                ')'
+            );
+
+            // Debug: log first few items to see their properties
+            if (filteredItems.length === 0 && beforeClipFilter > 0) {
+                console.log('[Labels] Sample item that was filtered out:', items[0]);
+            }
+        }
+
+        if (!filteredItems.length) {
+            console.log(`[Labels ${dl.id}] No items left after filtering, skipping.`);
+            continue;
+        }
+        const styleName = dl.textStyle;
+        const style = styleName && isRecord(styles) ? getProp(styles, styleName) : undefined;
+        if (!isRecord(style)) {
+            warnings.push(`Labels '${dl.id}' missing textStyle '${styleName ?? '(none)'}'.`);
+            continue;
+        }
+        const anchor = dl.align === 'center' ? 'middle' : dl.align === 'right' ? 'end' : 'start';
+        const t = vpInfo.transform;
+
+        let renderedCount = 0;
+        let spatiallyFilteredCount = 0;
+
+        filteredItems.forEach((item) => {
+            // Hardcoded x/z for BIM floor plane convention
+            const xVal = getProp(item, 'x');
+            const yVal = getProp(item, 'z');
+            if (!Number.isFinite(xVal as number) || !Number.isFinite(yVal as number)) {
+                return;
+            }
+            const viewX = (xVal as number) - t.viewMinX;
+            const viewY = t.viewMaxZ - (yVal as number);
+            const centerModelX = vpInfo.centerModelX;
+            const centerModelY = vpInfo.centerModelY;
+            const xMm = vpInfo.centerX + (viewX - centerModelX) * vpInfo.mmPerModel;
+            const yMm = vpInfo.centerY + (viewY - centerModelY) * vpInfo.mmPerModel;
+
+            if (viewportClipLabels[dl.viewport] && viewportClipPolygonsLocal[dl.viewport]?.length) {
+                const inside = viewportClipPolygonsLocal[dl.viewport].some((poly) =>
+                    pointInPolygon(poly, viewX, viewY)
+                );
+                if (!inside) {
+                    spatiallyFilteredCount++;
+                    return;
+                }
+            }
+
+            renderedCount++;
+
+            const text = escapeText(
+                dl.text && typeof dl.text === 'string'
+                    ? dl.text.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_m, path) => {
+                          const val = resolvePath(item, path) ?? getPathValue(dataWithViewport, path);
+                          return val === undefined || val === null || typeof val === 'object' ? '' : String(val);
+                      })
+                    : ''
+            );
+
+            const fontFamily = getProp(style, 'fontFamily');
+            const fontSizeMm = getProp(style, 'fontSizeMm');
+            const fontWeight = getProp(style, 'fontWeight');
+            const color = getProp(style, 'color');
+            const letterSpacingMm = getProp(style, 'letterSpacingMm');
+            const lineHeightMm = getProp(style, 'lineHeightMm');
+
+            parts.push(
+                `<text x="${xMm}" y="${yMm}" font-family="${escapeAttr(String(fontFamily))}" font-size="${fontSizeMm}"` +
+                    (fontWeight ? ` font-weight="${escapeAttr(String(fontWeight))}"` : '') +
+                    (color ? ` fill="${escapeAttr(String(color))}"` : '') +
+                    (letterSpacingMm !== undefined ? ` letter-spacing="${letterSpacingMm}"` : '') +
+                    (lineHeightMm !== undefined ? ` line-height="${lineHeightMm}"` : '') +
+                    ` text-anchor="${anchor}">${text}</text>`
+            );
+        });
+
+        console.log(
+            `[Labels ${dl.id}] Rendered ${renderedCount} labels. Spatially filtered out: ${spatiallyFilteredCount}`
+        );
+    }
+
+    return parts;
+};

package/src/layout/legendConstants.ts

@@ -0,0 +1,11 @@
+export const PX_PER_MM = 96 / 25.4;
+export const DEFAULT_LEGEND_SWATCH_WIDTH_MM = 8;
+export const DEFAULT_LEGEND_CELL_PADDING_MM = 2;
+export const DEFAULT_LEGEND_BORDER_WIDTH_MM = 0.25;
+export const DEFAULT_LEGEND_GRID_WIDTH_MM = 0.25;
+export const DEFAULT_LEGEND_HEADER_WIDTH_MM = 0.65;
+export const DEFAULT_LEGEND_OFFSET_MM = 5;
+export const LEGEND_TEXT_WIDTH_FACTOR = 0.7;
+export const LEGEND_MIN_CONTENT_WIDTH_EM = 4;
+export const LEGEND_TEXT_Y_OFFSET_FACTOR = 0.3;
+export const MAX_LEGEND_ROWS = 200;