@twinfinity/printing 6.0.1-ci.28952-beta → 6.0.2-beta

package/src/layout/viewportPrep.ts

@@ -1,351 +1,351 @@
-import { filterModelForViewport } from './model';
-import { ModelMetadata } from './metadata';
-import { ViewportElement, SvgModelView, ComputedViewportScale } from './types';
-import { pushWarning } from './warnings';
-import { pickScale } from './viewportUtils';
-import type { ResolvedPresets } from './presets';
-import { getPathValue } from './renderUtils';
-import { pointInPolygon, offsetPolygons, Polygon } from './clipUtils';
-import { matchesV2Filter, normalizeClass } from './filters';
-import { EPSILON_MIN_DIMENSION } from './geometryConstants';
-
-export interface ViewportPrepResult {
-    viewportScales: Record<string, ComputedViewportScale>;
-    viewportClipPolygonsLocal: Record<string, Array<Array<{ x: number; y: number }>>>;
-    viewportClipPolygonsWorld: Record<string, Array<Array<{ x: number; z: number }>>>;
-    viewportClipBounds: Record<
-        string,
-        { minX: number; maxX: number; minY: number; maxY: number; width: number; height: number }
-    >;
-    viewportClipLabels: Record<string, boolean>;
-    viewportClipStyles: Record<
-        string,
-        { stroke?: string; strokeWidthMm?: number; strokeOpacity?: number; fill?: string; fillOpacity?: number }
-    >;
-    viewportClipWhere: Record<string, WhereCondition | undefined>;
-    viewportHighlight: Record<
-        string,
-        {
-            gids: Set<string> | null;
-            styles: {
-                stroke?: string;
-                strokeWidthMm?: number;
-                strokeOpacity?: number;
-                fill?: string;
-                fillOpacity?: number;
-            };
-        }
-    >;
-    filteredModelsByViewport: Record<string, SvgModelView>;
-}
-
-import { isRecord, getProp } from './typeGuards';
-import type { WhereCondition } from './types';
-
-export const prepareViewports = (
-    viewports: ViewportElement[],
-    models: Record<string, SvgModelView | undefined>,
-    data: unknown,
-    preferredScales: number[],
-    presets: ResolvedPresets,
-    options: { metadataById?: unknown; warnings: string[] }
-): ViewportPrepResult => {
-    const viewportScales: Record<string, ComputedViewportScale> = {};
-    const viewportClipPolygonsLocal: Record<string, Array<Array<{ x: number; y: number }>>> = {};
-    const viewportClipPolygonsWorld: Record<string, Array<Array<{ x: number; z: number }>>> = {};
-    const viewportClipBounds: Record<
-        string,
-        { minX: number; maxX: number; minY: number; maxY: number; width: number; height: number }
-    > = {};
-    const viewportClipLabels: Record<string, boolean> = {};
-    const viewportClipStyles: Record<
-        string,
-        { stroke?: string; strokeWidthMm?: number; strokeOpacity?: number; fill?: string; fillOpacity?: number }
-    > = {};
-    const viewportClipWhere: Record<string, WhereCondition | undefined> = {};
-    const viewportHighlight: ViewportPrepResult['viewportHighlight'] = {};
-    const filteredModelsByViewport: Record<string, SvgModelView> = {};
-    const scales = presets.scales;
-
-    viewports.forEach((vp) => {
-        const baseModel = models[vp.id];
-        let clipAllowedGids: Set<string> | null = null;
-
-        // Highlight: optional class+where filter on normalized items
-        let highlightGids: Set<string> | null = null;
-        const hlCfg = vp.highlight;
-        if (hlCfg && hlCfg.where) {
-            const sourceItems = getPathValue(data, `viewports.${vp.id}.items`);
-            if (Array.isArray(sourceItems) && sourceItems.length) {
-                const matching = sourceItems.filter((it) => matchesV2Filter(it, hlCfg.class, hlCfg.where));
-                if (matching.length) {
-                    highlightGids = new Set(
-                        matching
-                            .map((it: unknown) => getProp(it, 'gid') ?? getProp(it, 'id') ?? null)
-                            .filter((v: unknown) => v !== null && v !== undefined)
-                            .map((v: unknown) => String(v))
-                    );
-
-                    // Intersect with referenced viewport if specified
-                    if (hlCfg.intersectsViewport) {
-                        const refItems = getPathValue(data, `viewports.${hlCfg.intersectsViewport}.items`);
-                        if (Array.isArray(refItems) && refItems.length) {
-                            const refGids = new Set(
-                                refItems
-                                    .map((it: unknown) => getProp(it, 'gid') ?? getProp(it, 'id') ?? null)
-                                    .filter((v: unknown) => v !== null && v !== undefined)
-                                    .map((v: unknown) => String(v))
-                            );
-                            // Keep only items that appear in both viewports
-                            const intersection = new Set<string>();
-                            highlightGids.forEach((gid) => {
-                                if (refGids.has(gid)) intersection.add(gid);
-                            });
-                            highlightGids = intersection;
-                        } else {
-                            pushWarning(
-                                options.warnings,
-                                `Viewport '${vp.id}' highlight intersectsViewport="${hlCfg.intersectsViewport}": referenced viewport has no items.`
-                            );
-                            highlightGids = new Set(); // No items in referenced viewport = no highlights
-                        }
-                    }
-                } else {
-                    highlightGids = new Set(); // explicit no matches
-                    pushWarning(
-                        options.warnings,
-                        `Viewport '${vp.id}' highlight filter matched 0 of ${sourceItems.length} items.`
-                    );
-                }
-            } else if (Array.isArray(sourceItems) && !sourceItems.length) {
-                pushWarning(options.warnings, `Viewport '${vp.id}' highlight: no items available to filter.`);
-            }
-        }
-
-        // Clip: class+where filter — find matching items, extract their polylines as clip polygons
-        let clipEffectiveWidthModel: number | undefined;
-        let clipEffectiveHeightModel: number | undefined;
-        const clipCfg = vp.clip;
-        if (clipCfg && clipCfg.where && baseModel?.transform) {
-            viewportClipWhere[vp.id] = clipCfg.where;
-            const sourceItems = getPathValue(data, `viewports.${vp.id}.items`);
-            if (Array.isArray(sourceItems) && sourceItems.length) {
-                const matchingItems = sourceItems.filter((it) => matchesV2Filter(it, clipCfg.class, clipCfg.where));
-                if (!matchingItems.length) {
-                    pushWarning(
-                        options.warnings,
-                        `Viewport '${vp.id}' clip filter matched 0 of ${sourceItems.length} items.`
-                    );
-                }
-
-                // Extract polylines from matched items
-                const allPolylines: Array<{ points?: Array<{ x: number; z: number }> }> = [];
-                for (const item of matchingItems) {
-                    const polylines = getProp(item, 'polylines');
-                    if (Array.isArray(polylines)) {
-                        for (const pl of polylines) {
-                            if (isRecord(pl)) allPolylines.push(pl as { points?: Array<{ x: number; z: number }> });
-                        }
-                    }
-                }
-
-                if (allPolylines.length) {
-                    // Project polyline points from world (x/z) to model view space
-                    const projectedLocal: Polygon[] = [];
-                    for (const poly of allPolylines) {
-                        const pts = poly.points;
-                        if (!Array.isArray(pts) || pts.length < 3) continue;
-                        const mapped: Polygon = [];
-                        for (const pt of pts) {
-                            const px = pt?.x;
-                            const pz = pt?.z;
-                            if (!Number.isFinite(px) || !Number.isFinite(pz)) continue;
-                            mapped.push({
-                                x: px - baseModel.transform!.viewMinX,
-                                y: baseModel.transform!.viewMaxZ - pz
-                            });
-                        }
-                        if (mapped.length >= 3) projectedLocal.push(mapped);
-                    }
-                    const expandByM =
-                        typeof clipCfg.expandByM === 'number' &&
-                        Number.isFinite(clipCfg.expandByM) &&
-                        clipCfg.expandByM > 0
-                            ? clipCfg.expandByM
-                            : 0;
-                    const buffered = expandByM > 0 ? offsetPolygons(projectedLocal, expandByM) : projectedLocal;
-
-                    if (buffered.length) {
-                        // Calculate bounds from EXPANDED polygon for viewport sizing (so everything fits)
-                        // Fill filtering (clipAllowedGids) uses ORIGINAL polygon from worldPolygons (line 239)
-                        const boundsSource = buffered; // Use EXPANDED for viewport sizing
-                        const flat = boundsSource.flat();
-                        let minX = Infinity,
-                            maxX = -Infinity,
-                            minY = Infinity,
-                            maxY = -Infinity;
-                        for (let i = 0; i < flat.length; i++) {
-                            const p = flat[i];
-                            if (p.x < minX) minX = p.x;
-                            if (p.x > maxX) maxX = p.x;
-                            if (p.y < minY) minY = p.y;
-                            if (p.y > maxY) maxY = p.y;
-                        }
-                        clipEffectiveWidthModel = Math.max(EPSILON_MIN_DIMENSION, maxX - minX);
-                        clipEffectiveHeightModel = Math.max(EPSILON_MIN_DIMENSION, maxY - minY);
-                        viewportClipPolygonsLocal[vp.id] = buffered;
-                        viewportClipLabels[vp.id] = !!clipCfg.clipLabels;
-                        viewportClipStyles[vp.id] = {
-                            stroke: clipCfg.stroke ?? '#000000',
-                            strokeWidthMm: clipCfg.strokeWidthMm ?? 0.5,
-                            strokeOpacity: clipCfg.strokeOpacity ?? 1,
-                            fill: clipCfg.fill ?? 'none',
-                            fillOpacity: clipCfg.fillOpacity ?? 0
-                        };
-                        viewportClipBounds[vp.id] = {
-                            minX,
-                            maxX,
-                            minY,
-                            maxY,
-                            width: clipEffectiveWidthModel,
-                            height: clipEffectiveHeightModel
-                        };
-
-                        // Build clipAllowedGids: include items whose center falls inside the clip polygons
-                        // Polygon is in XZ coordinates (horizontal plane), Y is vertical (plane height)
-                        const worldPolygons = allPolylines
-                            .filter((pl) => Array.isArray(pl.points) && pl.points.length >= 3)
-                            .map((pl) => pl.points!.map((p) => ({ x: p.x, z: p.z })));
-                        if (worldPolygons.length) {
-                            viewportClipPolygonsWorld[vp.id] = worldPolygons;
-                            clipAllowedGids = new Set<string>();
-                            for (const item of sourceItems) {
-                                // Use item's direct x/z properties (same approach as labels)
-                                const ix = getProp(item, 'x');
-                                const iz = getProp(item, 'z');
-
-                                if (!Number.isFinite(ix) || !Number.isFinite(iz)) {
-                                    continue;
-                                }
-                                // Convert polygon {x,z} to {x,y} for pointInPolygon (same as labels do)
-                                const inside = worldPolygons.some((poly) => {
-                                    const polyWith2D = poly.map((p) => ({ x: p.x, y: p.z }));
-                                    return pointInPolygon(polyWith2D, ix as number, iz as number);
-                                });
-                                if (inside) {
-                                    const gid = getProp(item, 'gid') ?? getProp(item, 'id');
-                                    if (gid !== null && gid !== undefined) {
-                                        clipAllowedGids.add(String(gid));
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Effective allowed set: if highlight defined, use highlight set; else clipAllowed; if both exist, intersect.
-        // IMPORTANT: Store empty Set (not null) when clip filtering is active but finds no matches
-        let effectiveAllowed: Set<string> | null = null;
-        if (highlightGids && highlightGids.size > 0 && clipAllowedGids) {
-            // Both highlight and clip active - intersect them (even if clipAllowedGids is empty)
-            const intersection = new Set<string>();
-            highlightGids.forEach((gid) => {
-                if (clipAllowedGids!.has(gid)) intersection.add(gid);
-            });
-            effectiveAllowed = intersection;
-        } else if (highlightGids && highlightGids.size > 0) {
-            effectiveAllowed = highlightGids;
-        } else if (clipAllowedGids !== null) {
-            // Clip filtering is active - use clipAllowedGids even if empty (means zero items allowed)
-            effectiveAllowed = clipAllowedGids;
-        }
-
-        const hlStyles = hlCfg
-            ? {
-                  stroke: typeof hlCfg.stroke === 'string' ? hlCfg.stroke : '#ff0000',
-                  strokeWidthMm: typeof hlCfg.strokeWidthMm === 'number' ? hlCfg.strokeWidthMm : 0.5,
-                  strokeOpacity: typeof hlCfg.strokeOpacity === 'number' ? hlCfg.strokeOpacity : 1,
-                  fill: typeof hlCfg.fill === 'string' ? hlCfg.fill : '#ffff00',
-                  fillOpacity: typeof hlCfg.fillOpacity === 'number' ? hlCfg.fillOpacity : 0.5
-              }
-            : {
-                  stroke: undefined,
-                  strokeWidthMm: undefined,
-                  strokeOpacity: undefined,
-                  fill: undefined,
-                  fillOpacity: undefined
-              };
-
-        // Build the set of classes subject to GID-based filtering from highlight/clip configs
-        const filterClasses = new Set<string>();
-        const addFilterClasses = (cls: string | string[] | undefined): void => {
-            if (!cls) return;
-            const classes = Array.isArray(cls) ? cls : [cls];
-            for (const c of classes) {
-                const normalized = normalizeClass(c);
-                if (normalized) filterClasses.add(normalized);
-            }
-        };
-        addFilterClasses(hlCfg?.class);
-        addFilterClasses(clipCfg?.class);
-
-        const model = baseModel
-            ? filterModelForViewport(
-                  baseModel,
-                  vp,
-                  options?.metadataById as ModelMetadata | undefined,
-                  presets.includeClasses,
-                  effectiveAllowed,
-                  {
-                      gids: highlightGids,
-                      styles: hlStyles
-                  },
-                  filterClasses.size > 0 ? filterClasses : null
-              )
-            : null;
-        viewportHighlight[vp.id] = {
-            gids: effectiveAllowed, // Use effectiveAllowed (includes both clip and highlight GIDs)
-            styles: hlStyles
-        };
-        if (!model) {
-            pushWarning(options.warnings, `Missing model for viewport '${vp.id}'.`);
-            return;
-        }
-        filteredModelsByViewport[vp.id] = model;
-        const effectiveWidthModel = clipEffectiveWidthModel ?? model.widthModel;
-        const effectiveHeightModel = clipEffectiveHeightModel ?? model.heightModel;
-
-        const scale = pickScale(
-            vp,
-            { ...model, widthModel: effectiveWidthModel, heightModel: effectiveHeightModel },
-            preferredScales,
-            scales
-        );
-        viewportScales[vp.id] = scale;
-        viewportClipBounds[vp.id] = viewportClipBounds[vp.id] ?? {
-            minX: model.transform?.viewMinX ?? 0,
-            maxX: model.transform ? model.transform.viewMinX + effectiveWidthModel : effectiveWidthModel,
-            minY: model.transform?.viewMinZ ?? 0,
-            maxY: model.transform ? model.transform.viewMinZ + effectiveHeightModel : effectiveHeightModel,
-            width: effectiveWidthModel,
-            height: effectiveHeightModel
-        };
-        if (!viewportClipPolygonsLocal[vp.id]) {
-            viewportClipPolygonsLocal[vp.id] = [];
-        }
-    });
-
-    return {
-        viewportScales,
-        viewportClipPolygonsLocal,
-        viewportClipPolygonsWorld,
-        viewportClipBounds,
-        viewportClipLabels,
-        viewportClipStyles,
-        viewportClipWhere,
-        viewportHighlight,
-        filteredModelsByViewport
-    };
-};
+import { filterModelForViewport } from './model';
+import { ModelMetadata } from './metadata';
+import { ViewportElement, SvgModelView, ComputedViewportScale } from './types';
+import { pushWarning } from './warnings';
+import { pickScale } from './viewportUtils';
+import type { ResolvedPresets } from './presets';
+import { getPathValue } from './renderUtils';
+import { pointInPolygon, offsetPolygons, Polygon } from './clipUtils';
+import { matchesV2Filter, normalizeClass } from './filters';
+import { EPSILON_MIN_DIMENSION } from './geometryConstants';
+
+export interface ViewportPrepResult {
+    viewportScales: Record<string, ComputedViewportScale>;
+    viewportClipPolygonsLocal: Record<string, Array<Array<{ x: number; y: number }>>>;
+    viewportClipPolygonsWorld: Record<string, Array<Array<{ x: number; z: number }>>>;
+    viewportClipBounds: Record<
+        string,
+        { minX: number; maxX: number; minY: number; maxY: number; width: number; height: number }
+    >;
+    viewportClipLabels: Record<string, boolean>;
+    viewportClipStyles: Record<
+        string,
+        { stroke?: string; strokeWidthMm?: number; strokeOpacity?: number; fill?: string; fillOpacity?: number }
+    >;
+    viewportClipWhere: Record<string, WhereCondition | undefined>;
+    viewportHighlight: Record<
+        string,
+        {
+            gids: Set<string> | null;
+            styles: {
+                stroke?: string;
+                strokeWidthMm?: number;
+                strokeOpacity?: number;
+                fill?: string;
+                fillOpacity?: number;
+            };
+        }
+    >;
+    filteredModelsByViewport: Record<string, SvgModelView>;
+}
+
+import { isRecord, getProp } from './typeGuards';
+import type { WhereCondition } from './types';
+
+export const prepareViewports = (
+    viewports: ViewportElement[],
+    models: Record<string, SvgModelView | undefined>,
+    data: unknown,
+    preferredScales: number[],
+    presets: ResolvedPresets,
+    options: { metadataById?: unknown; warnings: string[] }
+): ViewportPrepResult => {
+    const viewportScales: Record<string, ComputedViewportScale> = {};
+    const viewportClipPolygonsLocal: Record<string, Array<Array<{ x: number; y: number }>>> = {};
+    const viewportClipPolygonsWorld: Record<string, Array<Array<{ x: number; z: number }>>> = {};
+    const viewportClipBounds: Record<
+        string,
+        { minX: number; maxX: number; minY: number; maxY: number; width: number; height: number }
+    > = {};
+    const viewportClipLabels: Record<string, boolean> = {};
+    const viewportClipStyles: Record<
+        string,
+        { stroke?: string; strokeWidthMm?: number; strokeOpacity?: number; fill?: string; fillOpacity?: number }
+    > = {};
+    const viewportClipWhere: Record<string, WhereCondition | undefined> = {};
+    const viewportHighlight: ViewportPrepResult['viewportHighlight'] = {};
+    const filteredModelsByViewport: Record<string, SvgModelView> = {};
+    const scales = presets.scales;
+
+    viewports.forEach((vp) => {
+        const baseModel = models[vp.id];
+        let clipAllowedGids: Set<string> | null = null;
+
+        // Highlight: optional class+where filter on normalized items
+        let highlightGids: Set<string> | null = null;
+        const hlCfg = vp.highlight;
+        if (hlCfg && hlCfg.where) {
+            const sourceItems = getPathValue(data, `viewports.${vp.id}.items`);
+            if (Array.isArray(sourceItems) && sourceItems.length) {
+                const matching = sourceItems.filter((it) => matchesV2Filter(it, hlCfg.class, hlCfg.where));
+                if (matching.length) {
+                    highlightGids = new Set(
+                        matching
+                            .map((it: unknown) => getProp(it, 'gid') ?? getProp(it, 'id') ?? null)
+                            .filter((v: unknown) => v !== null && v !== undefined)
+                            .map((v: unknown) => String(v))
+                    );
+
+                    // Intersect with referenced viewport if specified
+                    if (hlCfg.intersectsViewport) {
+                        const refItems = getPathValue(data, `viewports.${hlCfg.intersectsViewport}.items`);
+                        if (Array.isArray(refItems) && refItems.length) {
+                            const refGids = new Set(
+                                refItems
+                                    .map((it: unknown) => getProp(it, 'gid') ?? getProp(it, 'id') ?? null)
+                                    .filter((v: unknown) => v !== null && v !== undefined)
+                                    .map((v: unknown) => String(v))
+                            );
+                            // Keep only items that appear in both viewports
+                            const intersection = new Set<string>();
+                            highlightGids.forEach((gid) => {
+                                if (refGids.has(gid)) intersection.add(gid);
+                            });
+                            highlightGids = intersection;
+                        } else {
+                            pushWarning(
+                                options.warnings,
+                                `Viewport '${vp.id}' highlight intersectsViewport="${hlCfg.intersectsViewport}": referenced viewport has no items.`
+                            );
+                            highlightGids = new Set(); // No items in referenced viewport = no highlights
+                        }
+                    }
+                } else {
+                    highlightGids = new Set(); // explicit no matches
+                    pushWarning(
+                        options.warnings,
+                        `Viewport '${vp.id}' highlight filter matched 0 of ${sourceItems.length} items.`
+                    );
+                }
+            } else if (Array.isArray(sourceItems) && !sourceItems.length) {
+                pushWarning(options.warnings, `Viewport '${vp.id}' highlight: no items available to filter.`);
+            }
+        }
+
+        // Clip: class+where filter — find matching items, extract their polylines as clip polygons
+        let clipEffectiveWidthModel: number | undefined;
+        let clipEffectiveHeightModel: number | undefined;
+        const clipCfg = vp.clip;
+        if (clipCfg && clipCfg.where && baseModel?.transform) {
+            viewportClipWhere[vp.id] = clipCfg.where;
+            const sourceItems = getPathValue(data, `viewports.${vp.id}.items`);
+            if (Array.isArray(sourceItems) && sourceItems.length) {
+                const matchingItems = sourceItems.filter((it) => matchesV2Filter(it, clipCfg.class, clipCfg.where));
+                if (!matchingItems.length) {
+                    pushWarning(
+                        options.warnings,
+                        `Viewport '${vp.id}' clip filter matched 0 of ${sourceItems.length} items.`
+                    );
+                }
+
+                // Extract polylines from matched items
+                const allPolylines: Array<{ points?: Array<{ x: number; z: number }> }> = [];
+                for (const item of matchingItems) {
+                    const polylines = getProp(item, 'polylines');
+                    if (Array.isArray(polylines)) {
+                        for (const pl of polylines) {
+                            if (isRecord(pl)) allPolylines.push(pl as { points?: Array<{ x: number; z: number }> });
+                        }
+                    }
+                }
+
+                if (allPolylines.length) {
+                    // Project polyline points from world (x/z) to model view space
+                    const projectedLocal: Polygon[] = [];
+                    for (const poly of allPolylines) {
+                        const pts = poly.points;
+                        if (!Array.isArray(pts) || pts.length < 3) continue;
+                        const mapped: Polygon = [];
+                        for (const pt of pts) {
+                            const px = pt?.x;
+                            const pz = pt?.z;
+                            if (!Number.isFinite(px) || !Number.isFinite(pz)) continue;
+                            mapped.push({
+                                x: px - baseModel.transform!.viewMinX,
+                                y: baseModel.transform!.viewMaxZ - pz
+                            });
+                        }
+                        if (mapped.length >= 3) projectedLocal.push(mapped);
+                    }
+                    const expandByM =
+                        typeof clipCfg.expandByM === 'number' &&
+                        Number.isFinite(clipCfg.expandByM) &&
+                        clipCfg.expandByM > 0
+                            ? clipCfg.expandByM
+                            : 0;
+                    const buffered = expandByM > 0 ? offsetPolygons(projectedLocal, expandByM) : projectedLocal;
+
+                    if (buffered.length) {
+                        // Calculate bounds from EXPANDED polygon for viewport sizing (so everything fits)
+                        // Fill filtering (clipAllowedGids) uses ORIGINAL polygon from worldPolygons (line 239)
+                        const boundsSource = buffered; // Use EXPANDED for viewport sizing
+                        const flat = boundsSource.flat();
+                        let minX = Infinity,
+                            maxX = -Infinity,
+                            minY = Infinity,
+                            maxY = -Infinity;
+                        for (let i = 0; i < flat.length; i++) {
+                            const p = flat[i];
+                            if (p.x < minX) minX = p.x;
+                            if (p.x > maxX) maxX = p.x;
+                            if (p.y < minY) minY = p.y;
+                            if (p.y > maxY) maxY = p.y;
+                        }
+                        clipEffectiveWidthModel = Math.max(EPSILON_MIN_DIMENSION, maxX - minX);
+                        clipEffectiveHeightModel = Math.max(EPSILON_MIN_DIMENSION, maxY - minY);
+                        viewportClipPolygonsLocal[vp.id] = buffered;
+                        viewportClipLabels[vp.id] = !!clipCfg.clipLabels;
+                        viewportClipStyles[vp.id] = {
+                            stroke: clipCfg.stroke ?? '#000000',
+                            strokeWidthMm: clipCfg.strokeWidthMm ?? 0.5,
+                            strokeOpacity: clipCfg.strokeOpacity ?? 1,
+                            fill: clipCfg.fill ?? 'none',
+                            fillOpacity: clipCfg.fillOpacity ?? 0
+                        };
+                        viewportClipBounds[vp.id] = {
+                            minX,
+                            maxX,
+                            minY,
+                            maxY,
+                            width: clipEffectiveWidthModel,
+                            height: clipEffectiveHeightModel
+                        };
+
+                        // Build clipAllowedGids: include items whose center falls inside the clip polygons
+                        // Polygon is in XZ coordinates (horizontal plane), Y is vertical (plane height)
+                        const worldPolygons = allPolylines
+                            .filter((pl) => Array.isArray(pl.points) && pl.points.length >= 3)
+                            .map((pl) => pl.points!.map((p) => ({ x: p.x, z: p.z })));
+                        if (worldPolygons.length) {
+                            viewportClipPolygonsWorld[vp.id] = worldPolygons;
+                            clipAllowedGids = new Set<string>();
+                            for (const item of sourceItems) {
+                                // Use item's direct x/z properties (same approach as labels)
+                                const ix = getProp(item, 'x');
+                                const iz = getProp(item, 'z');
+
+                                if (!Number.isFinite(ix) || !Number.isFinite(iz)) {
+                                    continue;
+                                }
+                                // Convert polygon {x,z} to {x,y} for pointInPolygon (same as labels do)
+                                const inside = worldPolygons.some((poly) => {
+                                    const polyWith2D = poly.map((p) => ({ x: p.x, y: p.z }));
+                                    return pointInPolygon(polyWith2D, ix as number, iz as number);
+                                });
+                                if (inside) {
+                                    const gid = getProp(item, 'gid') ?? getProp(item, 'id');
+                                    if (gid !== null && gid !== undefined) {
+                                        clipAllowedGids.add(String(gid));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Effective allowed set: if highlight defined, use highlight set; else clipAllowed; if both exist, intersect.
+        // IMPORTANT: Store empty Set (not null) when clip filtering is active but finds no matches
+        let effectiveAllowed: Set<string> | null = null;
+        if (highlightGids && highlightGids.size > 0 && clipAllowedGids) {
+            // Both highlight and clip active - intersect them (even if clipAllowedGids is empty)
+            const intersection = new Set<string>();
+            highlightGids.forEach((gid) => {
+                if (clipAllowedGids!.has(gid)) intersection.add(gid);
+            });
+            effectiveAllowed = intersection;
+        } else if (highlightGids && highlightGids.size > 0) {
+            effectiveAllowed = highlightGids;
+        } else if (clipAllowedGids !== null) {
+            // Clip filtering is active - use clipAllowedGids even if empty (means zero items allowed)
+            effectiveAllowed = clipAllowedGids;
+        }
+
+        const hlStyles = hlCfg
+            ? {
+                  stroke: typeof hlCfg.stroke === 'string' ? hlCfg.stroke : '#ff0000',
+                  strokeWidthMm: typeof hlCfg.strokeWidthMm === 'number' ? hlCfg.strokeWidthMm : 0.5,
+                  strokeOpacity: typeof hlCfg.strokeOpacity === 'number' ? hlCfg.strokeOpacity : 1,
+                  fill: typeof hlCfg.fill === 'string' ? hlCfg.fill : '#ffff00',
+                  fillOpacity: typeof hlCfg.fillOpacity === 'number' ? hlCfg.fillOpacity : 0.5
+              }
+            : {
+                  stroke: undefined,
+                  strokeWidthMm: undefined,
+                  strokeOpacity: undefined,
+                  fill: undefined,
+                  fillOpacity: undefined
+              };
+
+        // Build the set of classes subject to GID-based filtering from highlight/clip configs
+        const filterClasses = new Set<string>();
+        const addFilterClasses = (cls: string | string[] | undefined): void => {
+            if (!cls) return;
+            const classes = Array.isArray(cls) ? cls : [cls];
+            for (const c of classes) {
+                const normalized = normalizeClass(c);
+                if (normalized) filterClasses.add(normalized);
+            }
+        };
+        addFilterClasses(hlCfg?.class);
+        addFilterClasses(clipCfg?.class);
+
+        const model = baseModel
+            ? filterModelForViewport(
+                  baseModel,
+                  vp,
+                  options?.metadataById as ModelMetadata | undefined,
+                  presets.includeClasses,
+                  effectiveAllowed,
+                  {
+                      gids: highlightGids,
+                      styles: hlStyles
+                  },
+                  filterClasses.size > 0 ? filterClasses : null
+              )
+            : null;
+        viewportHighlight[vp.id] = {
+            gids: effectiveAllowed, // Use effectiveAllowed (includes both clip and highlight GIDs)
+            styles: hlStyles
+        };
+        if (!model) {
+            pushWarning(options.warnings, `Missing model for viewport '${vp.id}'.`);
+            return;
+        }
+        filteredModelsByViewport[vp.id] = model;
+        const effectiveWidthModel = clipEffectiveWidthModel ?? model.widthModel;
+        const effectiveHeightModel = clipEffectiveHeightModel ?? model.heightModel;
+
+        const scale = pickScale(
+            vp,
+            { ...model, widthModel: effectiveWidthModel, heightModel: effectiveHeightModel },
+            preferredScales,
+            scales
+        );
+        viewportScales[vp.id] = scale;
+        viewportClipBounds[vp.id] = viewportClipBounds[vp.id] ?? {
+            minX: model.transform?.viewMinX ?? 0,
+            maxX: model.transform ? model.transform.viewMinX + effectiveWidthModel : effectiveWidthModel,
+            minY: model.transform?.viewMinZ ?? 0,
+            maxY: model.transform ? model.transform.viewMinZ + effectiveHeightModel : effectiveHeightModel,
+            width: effectiveWidthModel,
+            height: effectiveHeightModel
+        };
+        if (!viewportClipPolygonsLocal[vp.id]) {
+            viewportClipPolygonsLocal[vp.id] = [];
+        }
+    });
+
+    return {
+        viewportScales,
+        viewportClipPolygonsLocal,
+        viewportClipPolygonsWorld,
+        viewportClipBounds,
+        viewportClipLabels,
+        viewportClipStyles,
+        viewportClipWhere,
+        viewportHighlight,
+        filteredModelsByViewport
+    };
+};