@ifc-lite/viewer 1.1.6 → 1.5.0

package/src/utils/spatialHierarchy.ts

@@ -0,0 +1,283 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Spatial hierarchy utilities for IFC models
+ * Pure functions for building spatial structure from entities and relationships
+ * Extracted from useIfc.ts for reusability and testability
+ */
+
+import {
+  IfcTypeEnum,
+  RelationshipType,
+  type SpatialHierarchy,
+  type SpatialNode,
+  type EntityTable,
+  type RelationshipGraph,
+} from '@ifc-lite/data';
+
+// Spatial structure types that form the IFC containment hierarchy
+const SPATIAL_TYPES = new Set([
+  IfcTypeEnum.IfcProject,
+  IfcTypeEnum.IfcSite,
+  IfcTypeEnum.IfcBuilding,
+  IfcTypeEnum.IfcBuildingStorey,
+  IfcTypeEnum.IfcSpace,
+]);
+
+/**
+ * Rebuild spatial hierarchy from cache data (entities + relationships)
+ * OPTIMIZED: Uses index maps for O(1) lookups instead of O(n) linear searches
+ *
+ * @param entities - Entity table from parsed IFC
+ * @param relationships - Relationship graph from parsed IFC
+ * @returns Spatial hierarchy or undefined if no project found
+ */
+export function rebuildSpatialHierarchy(
+  entities: EntityTable,
+  relationships: RelationshipGraph
+): SpatialHierarchy | undefined {
+  // PRE-BUILD INDEX MAP: O(n) once, then O(1) lookups
+  // This eliminates the O(n²) nested loops from before
+  const entityTypeMap = new Map<number, IfcTypeEnum>();
+  for (let i = 0; i < entities.count; i++) {
+    entityTypeMap.set(entities.expressId[i], entities.typeEnum[i]);
+  }
+
+  const byStorey = new Map<number, number[]>();
+  const byBuilding = new Map<number, number[]>();
+  const bySite = new Map<number, number[]>();
+  const bySpace = new Map<number, number[]>();
+  const storeyElevations = new Map<number, number>();
+  const storeyHeights = new Map<number, number>();
+  const elementToStorey = new Map<number, number>();
+
+  // Find IfcProject
+  const projectIds = entities.getByType(IfcTypeEnum.IfcProject);
+  if (projectIds.length === 0) {
+    console.warn('[rebuildSpatialHierarchy] No IfcProject found');
+    return undefined;
+  }
+  const projectId = projectIds[0];
+
+  // Build node tree recursively - NOW O(1) lookups!
+  function buildNode(expressId: number): SpatialNode {
+    // O(1) lookup instead of O(n) linear search
+    const typeEnum = entityTypeMap.get(expressId) ?? IfcTypeEnum.Unknown;
+    const name = entities.getName(expressId) || `Entity #${expressId}`;
+
+    // Get contained elements via IfcRelContainedInSpatialStructure
+    const rawContainedElements = relationships.getRelated(
+      expressId,
+      RelationshipType.ContainsElements,
+      'forward'
+    );
+
+    // Filter out spatial structure elements - O(1) per element now!
+    const containedElements = rawContainedElements.filter((id) => {
+      const elemType = entityTypeMap.get(id);
+      return elemType !== undefined && !SPATIAL_TYPES.has(elemType);
+    });
+
+    // Get aggregated children via IfcRelAggregates
+    const aggregatedChildren = relationships.getRelated(
+      expressId,
+      RelationshipType.Aggregates,
+      'forward'
+    );
+
+    // Filter to spatial structure types and recurse - O(1) per child now!
+    const childNodes: SpatialNode[] = [];
+    for (const childId of aggregatedChildren) {
+      const childType = entityTypeMap.get(childId);
+      if (childType && SPATIAL_TYPES.has(childType) && childType !== IfcTypeEnum.IfcProject) {
+        childNodes.push(buildNode(childId));
+      }
+    }
+
+    // Add elements to appropriate maps
+    if (typeEnum === IfcTypeEnum.IfcBuildingStorey) {
+      byStorey.set(expressId, containedElements);
+    } else if (typeEnum === IfcTypeEnum.IfcBuilding) {
+      byBuilding.set(expressId, containedElements);
+    } else if (typeEnum === IfcTypeEnum.IfcSite) {
+      bySite.set(expressId, containedElements);
+    } else if (typeEnum === IfcTypeEnum.IfcSpace) {
+      bySpace.set(expressId, containedElements);
+    }
+
+    return {
+      expressId,
+      type: typeEnum,
+      name,
+      children: childNodes,
+      elements: containedElements,
+    };
+  }
+
+  const projectNode = buildNode(projectId);
+
+  // Build reverse lookup map: elementId -> storeyId
+  for (const [storeyId, elementIds] of byStorey) {
+    for (const elementId of elementIds) {
+      elementToStorey.set(elementId, storeyId);
+    }
+  }
+
+  // Pre-build space lookup for O(1) getContainingSpace
+  const elementToSpace = new Map<number, number>();
+  for (const [spaceId, elementIds] of bySpace) {
+    for (const elementId of elementIds) {
+      elementToSpace.set(elementId, spaceId);
+    }
+  }
+
+  // Note: storeyHeights remains empty for cache path - client uses on-demand property extraction
+
+  return {
+    project: projectNode,
+    byStorey,
+    byBuilding,
+    bySite,
+    bySpace,
+    storeyElevations,
+    storeyHeights,
+    elementToStorey,
+
+    getStoreyElements(storeyId: number): number[] {
+      return byStorey.get(storeyId) ?? [];
+    },
+
+    getStoreyByElevation(): number | null {
+      return null;
+    },
+
+    getContainingSpace(elementId: number): number | null {
+      return elementToSpace.get(elementId) ?? null;
+    },
+
+    getPath(elementId: number): SpatialNode[] {
+      const path: SpatialNode[] = [];
+
+      // DFS to find element in spatial tree
+      // Elements can be in SpatialNode.elements (e.g., IfcSpace) even if not in elementToStorey
+      const findPath = (node: SpatialNode, targetId: number): boolean => {
+        path.push(node);
+        if (node.elements.includes(targetId)) {
+          return true;
+        }
+        for (const child of node.children) {
+          if (findPath(child, targetId)) {
+            return true;
+          }
+        }
+        path.pop();
+        return false;
+      };
+
+      findPath(projectNode, elementId);
+      return path;
+    },
+  };
+}
+
+/**
+ * Entity index type for property/quantity set lookup
+ */
+export interface EntityIndex {
+  byId: Map<number, unknown>;
+  byType: Map<string, number[]>;
+}
+
+/**
+ * Result of rebuilding on-demand maps
+ */
+export interface OnDemandMaps {
+  onDemandPropertyMap: Map<number, number[]>;
+  onDemandQuantityMap: Map<number, number[]>;
+}
+
+/**
+ * Rebuild on-demand property/quantity maps from relationships and entity types
+ * Uses FORWARD direction: pset -> elements (more efficient than inverse lookup)
+ * OPTIMIZED: Uses entityIndex.byType for property/quantity set lookup since
+ * the entity table may not include these types (filtered during fresh parse)
+ *
+ * @param entities - Entity table from parsed IFC
+ * @param relationships - Relationship graph from parsed IFC
+ * @param entityIndex - Optional entity index with byType map for cache loads
+ * @returns Maps from entity ID to property/quantity set IDs
+ */
+export function rebuildOnDemandMaps(
+  entities: EntityTable,
+  relationships: RelationshipGraph,
+  entityIndex?: EntityIndex
+): OnDemandMaps {
+  const onDemandPropertyMap = new Map<number, number[]>();
+  const onDemandQuantityMap = new Map<number, number[]>();
+
+  // Use entityIndex.byType if available (needed for cache loads where entity table
+  // doesn't include IfcPropertySet/IfcElementQuantity entities)
+  // Fall back to entities.getByType() for fresh parses where entity table has these types
+  let propertySets: number[];
+  let quantitySets: number[];
+
+  if (entityIndex?.byType) {
+    // entityIndex.byType keys are the original type strings from the IFC file
+    // Check both common casings (STEP files may use either)
+    propertySets =
+      entityIndex.byType.get('IFCPROPERTYSET') || entityIndex.byType.get('IfcPropertySet') || [];
+    quantitySets =
+      entityIndex.byType.get('IFCELEMENTQUANTITY') ||
+      entityIndex.byType.get('IfcElementQuantity') ||
+      [];
+  } else {
+    // Fallback for when entityIndex is not provided
+    propertySets = entities.getByType(IfcTypeEnum.IfcPropertySet);
+    quantitySets = entities.getByType(IfcTypeEnum.IfcElementQuantity);
+  }
+
+  // Process property sets
+  for (const psetId of propertySets) {
+    // Get elements defined by this pset (FORWARD: pset -> elements)
+    const definedElements = relationships.getRelated(
+      psetId,
+      RelationshipType.DefinesByProperties,
+      'forward'
+    );
+
+    for (const entityId of definedElements) {
+      let list = onDemandPropertyMap.get(entityId);
+      if (!list) {
+        list = [];
+        onDemandPropertyMap.set(entityId, list);
+      }
+      list.push(psetId);
+    }
+  }
+
+  // Process quantity sets
+  for (const qsetId of quantitySets) {
+    // Get elements defined by this qset (FORWARD: qset -> elements)
+    const definedElements = relationships.getRelated(
+      qsetId,
+      RelationshipType.DefinesByProperties,
+      'forward'
+    );
+
+    for (const entityId of definedElements) {
+      let list = onDemandQuantityMap.get(entityId);
+      if (!list) {
+        list = [];
+        onDemandQuantityMap.set(entityId, list);
+      }
+      list.push(qsetId);
+    }
+  }
+
+  console.log(
+    `[spatialHierarchy] Rebuilt on-demand maps: ${propertySets.length} psets, ${quantitySets.length} qsets -> ${onDemandPropertyMap.size} entities with properties, ${onDemandQuantityMap.size} with quantities`
+  );
+  return { onDemandPropertyMap, onDemandQuantityMap };
+}

package/src/utils/viewportUtils.ts

@@ -0,0 +1,334 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Viewport utility functions
+ * Pure functions extracted from Viewport.tsx for reusability and testability
+ */
+
+import type { MeshData } from '@ifc-lite/geometry';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/**
+ * 3D point/vector
+ */
+export interface Point3D {
+  x: number;
+  y: number;
+  z: number;
+}
+
+/**
+ * Bounding box in 3D space
+ */
+export interface BoundingBox3D {
+  min: Point3D;
+  max: Point3D;
+}
+
+/**
+ * Section plane configuration
+ */
+export interface SectionPlaneConfig {
+  enabled: boolean;
+  height: number;
+  min?: number;
+  max?: number;
+}
+
+/**
+ * Render options for the WebGPU renderer
+ */
+export interface RenderOptions {
+  hiddenIds?: Set<number>;
+  isolatedIds?: Set<number> | null;
+  selectedId?: number | null;
+  selectedIds?: Set<number>;
+  clearColor?: [number, number, number, number];
+  sectionPlane?: SectionPlaneConfig;
+}
+
+/**
+ * Refs containing current visibility/selection state
+ */
+export interface ViewportStateRefs {
+  hiddenEntities: Set<number>;
+  isolatedEntities: Set<number> | null;
+  selectedEntityId: number | null;
+  clearColor: [number, number, number, number];
+  activeTool: string;
+  sectionPlane: { enabled: boolean; height: number };
+  sectionRange: { min: number; max: number } | null;
+}
+
+// ============================================================================
+// Entity Utilities
+// ============================================================================
+
+/**
+ * Maximum coordinate threshold for valid geometry
+ * Matches CoordinateHandler's NORMAL_COORD_THRESHOLD (10km)
+ * Coordinates beyond this are likely corrupted or unshifted original coordinates
+ */
+const MAX_VALID_COORD = 10000;
+
+/**
+ * Check if a vertex coordinate is valid (finite and within reasonable bounds)
+ */
+function isValidCoord(x: number, y: number, z: number): boolean {
+  return Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z) &&
+    Math.abs(x) < MAX_VALID_COORD &&
+    Math.abs(y) < MAX_VALID_COORD &&
+    Math.abs(z) < MAX_VALID_COORD;
+}
+
+/**
+ * Get bounding box for a specific entity from geometry
+ * @param geometry - Array of mesh data
+ * @param entityId - Express ID of the entity
+ * @returns Bounding box or null if entity not found
+ */
+export function getEntityBounds(
+  geometry: MeshData[] | null,
+  entityId: number
+): BoundingBox3D | null {
+  if (!geometry) {
+    return null;
+  }
+
+  // Find ALL meshes for this entity (entities can have multiple submeshes)
+  const matchingMeshes = geometry.filter(
+    (m) => m.expressId === entityId && m.positions.length >= 3
+  );
+
+  if (matchingMeshes.length === 0) {
+    return null;
+  }
+
+  let minX = Infinity,
+    minY = Infinity,
+    minZ = Infinity;
+  let maxX = -Infinity,
+    maxY = -Infinity,
+    maxZ = -Infinity;
+
+  // Aggregate bounds across all submeshes
+  // Filter out corrupted/unshifted vertices (> 10km from origin)
+  for (const mesh of matchingMeshes) {
+    for (let i = 0; i < mesh.positions.length; i += 3) {
+      const x = mesh.positions[i];
+      const y = mesh.positions[i + 1];
+      const z = mesh.positions[i + 2];
+      // Skip corrupted vertices (NaN, Inf, or huge coordinates from unshifted data)
+      if (!isValidCoord(x, y, z)) {
+        continue;
+      }
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      minZ = Math.min(minZ, z);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      maxZ = Math.max(maxZ, z);
+    }
+  }
+
+  // If no valid vertices found, return null
+  if (!Number.isFinite(minX) || !Number.isFinite(maxX)) {
+    return null;
+  }
+
+  return {
+    min: { x: minX, y: minY, z: minZ },
+    max: { x: maxX, y: maxY, z: maxZ },
+  };
+}
+
+/**
+ * Get center point of an entity's bounding box
+ * @param geometry - Array of mesh data
+ * @param entityId - Express ID of the entity
+ * @returns Center point or null if entity not found
+ */
+export function getEntityCenter(
+  geometry: MeshData[] | null,
+  entityId: number
+): Point3D | null {
+  const bounds = getEntityBounds(geometry, entityId);
+  if (!bounds) {
+    return null;
+  }
+
+  return {
+    x: (bounds.min.x + bounds.max.x) / 2,
+    y: (bounds.min.y + bounds.max.y) / 2,
+    z: (bounds.min.z + bounds.max.z) / 2,
+  };
+}
+
+/**
+ * Calculate combined bounding box from multiple meshes
+ * @param meshes - Array of mesh data
+ * @returns Combined bounding box
+ */
+export function calculateGeometryBounds(meshes: MeshData[]): BoundingBox3D {
+  if (meshes.length === 0) {
+    return {
+      min: { x: -100, y: -100, z: -100 },
+      max: { x: 100, y: 100, z: 100 },
+    };
+  }
+
+  let minX = Infinity,
+    minY = Infinity,
+    minZ = Infinity;
+  let maxX = -Infinity,
+    maxY = -Infinity,
+    maxZ = -Infinity;
+
+  // Filter out corrupted/unshifted vertices (> 10km from origin)
+  for (const mesh of meshes) {
+    for (let i = 0; i < mesh.positions.length; i += 3) {
+      const x = mesh.positions[i];
+      const y = mesh.positions[i + 1];
+      const z = mesh.positions[i + 2];
+      // Skip corrupted vertices (NaN, Inf, or huge coordinates from unshifted data)
+      if (!isValidCoord(x, y, z)) {
+        continue;
+      }
+      minX = Math.min(minX, x);
+      minY = Math.min(minY, y);
+      minZ = Math.min(minZ, z);
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+      maxZ = Math.max(maxZ, z);
+    }
+  }
+
+  // Handle degenerate cases:
+  // - Non-finite values (no valid positions found)
+  // - All three axes degenerate (single point)
+  // Note: Planar/linear geometry (only 1-2 axes equal) is valid and should NOT fall back
+  const isNonFinite = !Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(minZ) ||
+                      !Number.isFinite(maxX) || !Number.isFinite(maxY) || !Number.isFinite(maxZ);
+  const isFullyDegenerate = minX === maxX && minY === maxY && minZ === maxZ;
+
+  if (isNonFinite || isFullyDegenerate) {
+    return {
+      min: { x: -100, y: -100, z: -100 },
+      max: { x: 100, y: 100, z: 100 },
+    };
+  }
+
+  return {
+    min: { x: minX, y: minY, z: minZ },
+    max: { x: maxX, y: maxY, z: maxZ },
+  };
+}
+
+// ============================================================================
+// Render Options Builder
+// ============================================================================
+
+/**
+ * Build render options from viewport state refs
+ * Reduces code duplication - this object is constructed ~15+ times in Viewport.tsx
+ *
+ * @param refs - Object containing current state values from refs
+ * @returns Render options for the WebGPU renderer
+ */
+export function buildRenderOptions(refs: ViewportStateRefs): RenderOptions {
+  const options: RenderOptions = {
+    hiddenIds: refs.hiddenEntities,
+    isolatedIds: refs.isolatedEntities,
+    selectedId: refs.selectedEntityId,
+    clearColor: refs.clearColor,
+  };
+
+  // Add section plane if enabled
+  if (refs.activeTool === 'section') {
+    options.sectionPlane = {
+      ...refs.sectionPlane,
+      min: refs.sectionRange?.min,
+      max: refs.sectionRange?.max,
+    };
+  }
+
+  return options;
+}
+
+/**
+ * Build render options with additional selectedIds for multi-selection
+ */
+export function buildRenderOptionsWithSelection(
+  refs: ViewportStateRefs,
+  selectedIds?: Set<number>
+): RenderOptions {
+  const options = buildRenderOptions(refs);
+  if (selectedIds) {
+    options.selectedIds = selectedIds;
+  }
+  return options;
+}
+
+// ============================================================================
+// Throttling Utilities
+// ============================================================================
+
+/**
+ * Get render throttle interval based on mesh count
+ * Adaptive throttling: faster for small models, slower for large models
+ *
+ * @param meshCount - Number of meshes in the scene
+ * @returns Throttle interval in milliseconds
+ */
+export function getRenderThrottleMs(meshCount: number): number {
+  if (meshCount < 10000) {
+    return 16; // ~60fps for small models
+  } else if (meshCount < 50000) {
+    return 25; // ~40fps for medium models
+  } else {
+    return 33; // ~30fps for large models
+  }
+}
+
+// ============================================================================
+// Theme Utilities
+// ============================================================================
+
+/**
+ * Get clear color based on theme
+ * @param theme - 'light' or 'dark'
+ * @returns RGBA clear color tuple
+ */
+export function getThemeClearColor(theme: 'light' | 'dark'): [number, number, number, number] {
+  if (theme === 'light') {
+    return [0.96, 0.96, 0.97, 1]; // Light gray
+  }
+  return [0.102, 0.106, 0.149, 1]; // Tokyo Night storm (#1a1b26)
+}
+
+// ============================================================================
+// Scale Calculation
+// ============================================================================
+
+/**
+ * Calculate world-space size for a scale bar
+ *
+ * @param viewportHeight - Canvas height in pixels
+ * @param cameraDistance - Camera distance from target
+ * @param fov - Field of view in radians
+ * @param scaleBarPixels - Scale bar width in pixels (default 96px = 6rem)
+ * @returns World-space size represented by the scale bar
+ */
+export function calculateScaleBarSize(
+  viewportHeight: number,
+  cameraDistance: number,
+  fov: number,
+  scaleBarPixels: number = 96
+): number {
+  return (scaleBarPixels / viewportHeight) * (cameraDistance * Math.tan(fov / 2) * 2);
+}

package/src/vite-env.d.ts

@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_IFC_SERVER_URL?: string;
+  readonly VITE_SERVER_URL?: string;
+  readonly VITE_USE_SERVER?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}
+
+// Build-time constants injected by Vite define
+declare const __APP_VERSION__: string;
+declare const __BUILD_DATE__: string;
+declare const __RELEASE_HISTORY__: Array<{
+  version: string;
+  highlights: Array<{ type: 'feature' | 'fix' | 'perf'; text: string }>;
+}>;