@ifc-lite/viewer 1.21.0 → 1.22.0

package/src/lib/geo/effective-georef.test.ts

@@ -5,7 +5,14 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
-import { detectScaleUnitMismatch, getEffectiveHorizontalScale, inferMapUnitScale, mergeMapConversion, mergeProjectedCRS } from './effective-georef.js';
+import {
+  detectScaleUnitMismatch,
+  getEffectiveHorizontalScale,
+  inferMapUnitScale,
+  mergeMapConversion,
+  mergeProjectedCRS,
+  supportsStandardGeoreferencing,
+} from './effective-georef.js';
 import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
 
 describe('effective georeferencing', () => {
@@ -37,6 +44,72 @@ describe('effective georeferencing', () => {
     assert.strictEqual(merged?.mapUnitScale, 2.5);
   });
 
+  it('treats IFC2X3 files with IfcMapConversion and IfcProjectedCRS as standard georeferencing', () => {
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        source: 'mapConversion',
+        projectedCRS: {
+          id: 1,
+          name: 'EPSG:2056',
+        },
+        mapConversion: {
+          id: 2,
+          sourceCRS: 10,
+          targetCRS: 11,
+          eastings: 2681750,
+          northings: 1225750,
+          orthogonalHeight: 0,
+        },
+      }),
+      true,
+    );
+  });
+
+  it('treats IFC2X3 files with only IfcMapConversion (no IfcProjectedCRS name yet) as editable', () => {
+    // Extension-bearing IFC2X3 files sometimes carry one half of the
+    // georef pair; once we've parsed it, the editor should surface the
+    // data instead of hiding behind a schema notice. See issue #683.
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        source: 'mapConversion',
+        mapConversion: {
+          id: 2,
+          sourceCRS: 10,
+          targetCRS: 11,
+          eastings: 2681750,
+          northings: 1225750,
+          orthogonalHeight: 0,
+        },
+      }),
+      true,
+    );
+  });
+
+  it('treats IFC2X3 files with only IfcProjectedCRS as editable so users can add IfcMapConversion', () => {
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        projectedCRS: {
+          id: 1,
+          name: 'EPSG:2056',
+        },
+      }),
+      true,
+    );
+  });
+
+  it('keeps pure IfcSite IFC2X3 geolocation in read-only mode', () => {
+    assert.strictEqual(
+      supportsStandardGeoreferencing('IFC2X3', {
+        source: 'siteLocation',
+        projectedCRS: {
+          id: 226,
+          name: 'EPSG:4326',
+        },
+      }),
+      false,
+    );
+  });
+
   it('overlays edited IfcMapConversion fields without dropping original rotation and scale', () => {
     const original: MapConversion = {
       id: 2,

package/src/lib/geo/effective-georef.ts

@@ -11,6 +11,19 @@ import {
   type ProjectedCRS,
 } from '@ifc-lite/parser';
 import type { CoordinateInfo } from '@ifc-lite/geometry';
+import {
+  detectScaleUnitMismatch,
+  getEffectiveHorizontalScale,
+  inferMapUnitScale,
+  type ScaleUnitMismatch,
+} from './geo-scale';
+
+export {
+  detectScaleUnitMismatch,
+  getEffectiveHorizontalScale,
+  inferMapUnitScale,
+  type ScaleUnitMismatch,
+} from './geo-scale';
 
 export interface GeorefMutationDataLike {
   projectedCRS?: Partial<ProjectedCRS>;
@@ -23,102 +36,35 @@ export interface EffectiveGeoreference extends GeoreferenceInfo {
   lengthUnitScale: number;
 }
 
-/**
- * Compute the effective horizontal scale to apply to viewer-space coordinates
- * (which are already in metres) when transforming through IfcMapConversion.
- *
- * Per the IFC schema, IfcMapConversion.Scale converts LOCAL ENGINEERING
- * coordinates (in the project's length unit) to MAP coordinates (in the map
- * CRS unit). For a typical file with mm project units and m map units, the
- * Scale attribute is 0.001.
- *
- * The IFC formula is:
- *   E_map_units = Eastings + (X_local * absc - Y_local * ordi) * Scale
- *
- * To produce metres for proj4, we multiply by mapUnitScale; and X_local can be
- * recovered from the metre-converted geometry as X_metres / lengthUnitScale.
- * Substituting:
- *   E_metres = mapUnitScale * Eastings
- *            + (mapUnitScale * Scale / lengthUnitScale)
- *              * (X_metres * absc - Y_metres * ordi)
- *
- * So when geometry has already been converted to metres (as ifc-lite does),
- * the effective horizontal scale is (Scale * mapUnitScale) / lengthUnitScale.
- * For files where Scale is set per IFC spec to bridge the unit difference
- * (Scale = lengthUnitScale / mapUnitScale), this evaluates to 1.0 and the
- * geometry passes through unchanged. Applying the raw Scale would otherwise
- * double-scale and shrink/expand the model — see issue #595.
- */
-export function getEffectiveHorizontalScale(
-  ifcMapConversionScale: number | undefined,
-  mapUnitScale: number,
-  lengthUnitScale: number,
-): number {
-  const scale = ifcMapConversionScale ?? 1.0;
-  const lus = lengthUnitScale > 0 ? lengthUnitScale : 1;
-  const mus = mapUnitScale > 0 ? mapUnitScale : 1;
-  return (scale * mus) / lus;
-}
-
-export interface ScaleUnitMismatch {
-  /** Effective horizontal scale applied to viewer-space (metre) geometry. */
-  effectiveScale: number;
-  /** Raw IfcMapConversion.Scale (or 1 if absent). */
-  rawScale: number;
-  /** Map unit → metres factor (e.g. 1 for METRE, 0.001 for MILLIMETRE). */
-  mapUnitScale: number;
-  /** Project length unit → metres factor. */
-  lengthUnitScale: number;
-  /**
-   * Scale value the file would need for the IFC formula to map local→map
-   * coordinates without any extra scaling (i.e. lengthUnitScale / mapUnitScale).
-   */
-  expectedScale: number;
-}
-
-/**
- * Detect when IfcMapConversion.Scale is inconsistent with the project and map
- * units. Per the IFC schema, Scale × mapUnitScale should equal lengthUnitScale
- * (i.e. effectiveScale = 1.0). A deviation usually means the authoring tool
- * forgot to set Scale to bridge a unit difference (e.g. mm project + m map
- * with Scale=1.0). Files like this render at the wrong size in any tool that
- * follows the schema strictly — see issue #595.
- *
- * Returns null when the values are consistent (within 0.5% of 1.0); otherwise
- * returns the diagnostic data so callers can surface a warning.
- */
-export function detectScaleUnitMismatch(
-  ifcMapConversionScale: number | undefined,
-  mapUnitScale: number | undefined,
-  lengthUnitScale: number | undefined,
-): ScaleUnitMismatch | null {
-  const lus = lengthUnitScale && lengthUnitScale > 0 ? lengthUnitScale : 1;
-  const mus = mapUnitScale && mapUnitScale > 0 ? mapUnitScale : 1;
-  const rawScale = ifcMapConversionScale ?? 1.0;
-  const effectiveScale = (rawScale * mus) / lus;
-  if (Math.abs(effectiveScale - 1) <= 0.005) return null;
-  return {
-    effectiveScale,
-    rawScale,
-    mapUnitScale: mus,
-    lengthUnitScale: lus,
-    expectedScale: lus / mus,
-  };
+export function hasStandardGeoreferencing(
+  georef: Pick<GeoreferenceInfo, 'source' | 'projectedCRS' | 'mapConversion'> | null | undefined,
+): boolean {
+  return Boolean(
+    georef
+    && georef.source !== 'siteLocation'
+    && georef.projectedCRS?.name
+    && georef.mapConversion,
+  );
 }
 
-export function inferMapUnitScale(mapUnit: string | undefined, fallback?: number): number | undefined {
-  if (!mapUnit) return fallback;
-  const normalized = mapUnit.toUpperCase();
-  if (normalized.includes('US') && (normalized.includes('SURVEY') || normalized.includes('FTUS'))) {
-    return 0.3048006096;
+export function supportsStandardGeoreferencing(
+  schemaVersion: string | undefined,
+  georef: Pick<GeoreferenceInfo, 'source' | 'projectedCRS' | 'mapConversion'> | null | undefined,
+): boolean {
+  if (hasStandardGeoreferencing(georef)) return true;
+  // Any extracted IfcProjectedCRS / IfcMapConversion makes editing useful,
+  // regardless of the declared schema. IFC2X3 files commonly carry these
+  // via extensions; once we've parsed them, surface the full editor instead
+  // of hiding behind a schema-version notice that contradicts what the
+  // properties panel already shows for the same entities.
+  if (
+    georef
+    && georef.source !== 'siteLocation'
+    && (georef.projectedCRS?.name || georef.mapConversion)
+  ) {
+    return true;
   }
-  if (normalized.includes('FOOT') || normalized.includes('FEET')) return 0.3048;
-  if (normalized.includes('MILLI')) return 0.001;
-  if (normalized.includes('CENTI')) return 0.01;
-  if (normalized.includes('DECI')) return 0.1;
-  if (normalized.includes('KILO')) return 1000;
-  if (normalized.includes('METRE') || normalized.includes('METER')) return 1;
-  return fallback;
+  return !schemaVersion?.toUpperCase().includes('2X3');
 }
 
 export function getIfcLengthUnitScale(dataStore: IfcDataStore | null | undefined): number {
@@ -189,6 +135,7 @@ export function getEffectiveGeoreference(
     mapConversion,
     coordinateInfo,
     lengthUnitScale,
+    source: original?.source,
     transformMatrix: original?.transformMatrix,
   };
 }

package/src/lib/geo/geo-scale.ts

@@ -0,0 +1,104 @@
+/* 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/. */
+
+/**
+ * Compute the effective horizontal scale to apply to viewer-space coordinates
+ * (which are already in metres) when transforming through IfcMapConversion.
+ *
+ * Per the IFC schema, IfcMapConversion.Scale converts LOCAL ENGINEERING
+ * coordinates (in the project's length unit) to MAP coordinates (in the map
+ * CRS unit). For a typical file with mm project units and m map units, the
+ * Scale attribute is 0.001.
+ *
+ * The IFC formula is:
+ *   E_map_units = Eastings + (X_local * absc - Y_local * ordi) * Scale
+ *
+ * To produce metres for proj4, we multiply by mapUnitScale; and X_local can be
+ * recovered from the metre-converted geometry as X_metres / lengthUnitScale.
+ * Substituting:
+ *   E_metres = mapUnitScale * Eastings
+ *            + (mapUnitScale * Scale / lengthUnitScale)
+ *              * (X_metres * absc - Y_metres * ordi)
+ *
+ * So when geometry has already been converted to metres (as ifc-lite does),
+ * the effective horizontal scale is (Scale * mapUnitScale) / lengthUnitScale.
+ * For files where Scale is set per IFC spec to bridge the unit difference
+ * (Scale = lengthUnitScale / mapUnitScale), this evaluates to 1.0 and the
+ * geometry passes through unchanged. Applying the raw Scale would otherwise
+ * double-scale and shrink/expand the model — see issue #595.
+ */
+export function getEffectiveHorizontalScale(
+  ifcMapConversionScale: number | undefined,
+  mapUnitScale: number,
+  lengthUnitScale: number,
+): number {
+  const scale = ifcMapConversionScale ?? 1.0;
+  const lus = lengthUnitScale > 0 ? lengthUnitScale : 1;
+  const mus = mapUnitScale > 0 ? mapUnitScale : 1;
+  return (scale * mus) / lus;
+}
+
+export interface ScaleUnitMismatch {
+  /** Effective horizontal scale applied to viewer-space (metre) geometry. */
+  effectiveScale: number;
+  /** Raw IfcMapConversion.Scale (or 1 if absent). */
+  rawScale: number;
+  /** Map unit → metres factor (e.g. 1 for METRE, 0.001 for MILLIMETRE). */
+  mapUnitScale: number;
+  /** Project length unit → metres factor. */
+  lengthUnitScale: number;
+  /**
+   * Scale value the file would need for the IFC formula to map local→map
+   * coordinates without any extra scaling (i.e. lengthUnitScale / mapUnitScale).
+   */
+  expectedScale: number;
+}
+
+/**
+ * Detect when IfcMapConversion.Scale is inconsistent with the project and map
+ * units. Per the IFC schema, Scale × mapUnitScale should equal lengthUnitScale
+ * (i.e. effectiveScale = 1.0). A deviation usually means the authoring tool
+ * forgot to set Scale to bridge a unit difference (e.g. mm project + m map
+ * with Scale=1.0). Files like this render at the wrong size in any tool that
+ * follows the schema strictly — see issue #595.
+ *
+ * Returns null when the values are consistent (within 0.5% of 1.0); otherwise
+ * returns the diagnostic data so callers can surface a warning.
+ */
+export function detectScaleUnitMismatch(
+  ifcMapConversionScale: number | undefined,
+  mapUnitScale: number | undefined,
+  lengthUnitScale: number | undefined,
+): ScaleUnitMismatch | null {
+  const lus = lengthUnitScale && lengthUnitScale > 0 ? lengthUnitScale : 1;
+  const mus = mapUnitScale && mapUnitScale > 0 ? mapUnitScale : 1;
+  const rawScale = ifcMapConversionScale ?? 1.0;
+  const effectiveScale = (rawScale * mus) / lus;
+  if (Math.abs(effectiveScale - 1) <= 0.005) return null;
+  return {
+    effectiveScale,
+    rawScale,
+    mapUnitScale: mus,
+    lengthUnitScale: lus,
+    expectedScale: lus / mus,
+  };
+}
+
+export function inferMapUnitScale(
+  mapUnit: string | undefined,
+  fallback?: number,
+): number | undefined {
+  if (!mapUnit) return fallback;
+  const normalized = mapUnit.toUpperCase();
+  if (normalized.includes('US') && (normalized.includes('SURVEY') || normalized.includes('FTUS'))) {
+    return 0.3048006096;
+  }
+  if (normalized.includes('FOOT') || normalized.includes('FEET')) return 0.3048;
+  if (normalized.includes('MILLI')) return 0.001;
+  if (normalized.includes('CENTI')) return 0.01;
+  if (normalized.includes('DECI')) return 0.1;
+  if (normalized.includes('KILO')) return 1000;
+  if (normalized.includes('METRE') || normalized.includes('METER')) return 1;
+  return fallback;
+}

package/src/lib/geo/reproject.test.ts

@@ -0,0 +1,130 @@
+/* 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/. */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+import { computeCesiumModelOrigin } from './cesium-bridge.js';
+import {
+  computeFootprintGeoJSON,
+  computeModelCenterInIfcMeters,
+  reprojectFromLatLon,
+  reprojectToLatLon,
+  resolveProjection,
+} from './reproject.js';
+import type { CoordinateInfo } from '@ifc-lite/geometry';
+import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+
+function makeCoordinateInfo(): CoordinateInfo {
+  return {
+    originShift: { x: 1000, y: 5, z: 2000 },
+    originalBounds: {
+      min: { x: -10, y: -1, z: -20 },
+      max: { x: 10, y: 11, z: 20 },
+    },
+    shiftedBounds: {
+      min: { x: -10, y: -1, z: -20 },
+      max: { x: 10, y: 11, z: 20 },
+    },
+    hasLargeCoordinates: true,
+    wasmRtcOffset: { x: 3, y: 7, z: 11 },
+  };
+}
+
+describe('reproject helpers', () => {
+  it('computes the IFC-space model center from originShift and RTC', () => {
+    const center = computeModelCenterInIfcMeters(makeCoordinateInfo());
+    assert.deepStrictEqual(center, {
+      ifcX: 1003,
+      ifcY: -1993,
+      ifcZ: 21,
+    });
+  });
+
+  it('round-trips the #652 EPSG:5514 issue fixture coordinates', async () => {
+    const crs: ProjectedCRS = {
+      id: 114,
+      name: 'EPSG:5514',
+      verticalDatum: 'EPSG:8357',
+      mapUnit: 'METRE',
+      mapUnitScale: 1,
+    };
+    const conversion: MapConversion = {
+      id: 115,
+      sourceCRS: 14,
+      targetCRS: 114,
+      eastings: -740344,
+      northings: -1048817,
+      orthogonalHeight: 244,
+      scale: 0.001,
+    };
+
+    const latLon = await reprojectToLatLon(conversion, crs, undefined, 0.001);
+    assert.ok(latLon);
+    const roundTrip = await reprojectFromLatLon(latLon!, crs, conversion, undefined, 0.001);
+    assert.ok(roundTrip);
+    assert.ok(Math.abs(roundTrip!.easting - conversion.eastings) < 0.001);
+    assert.ok(Math.abs(roundTrip!.northing - conversion.northings) < 0.001);
+
+    const origin = await computeCesiumModelOrigin(conversion, crs, undefined, 0.001);
+    assert.ok(origin);
+    assert.ok(Math.abs(origin!.longitude - latLon!.lon) < 1e-9);
+    assert.ok(Math.abs(origin!.latitude - latLon!.lat) < 1e-9);
+    assert.strictEqual(origin!.ifcOriginHeight, 244);
+    assert.strictEqual(origin!.horizontalScale, 1);
+  });
+
+  it('resolves EPSG:28992 and round-trips projected coordinates', async () => {
+    const crs: ProjectedCRS = {
+      id: 1,
+      name: 'EPSG:28992',
+      mapUnit: 'METRE',
+      mapUnitScale: 1,
+    };
+    const conversion: MapConversion = {
+      id: 2,
+      sourceCRS: 10,
+      targetCRS: 1,
+      eastings: 121687.331,
+      northings: 487326.994,
+      orthogonalHeight: 0,
+      xAxisAbscissa: 1,
+      xAxisOrdinate: 0,
+      scale: 1,
+    };
+
+    const projDef = await resolveProjection(crs);
+    assert.ok(projDef);
+
+    const latLon = await reprojectToLatLon(conversion, crs);
+    assert.ok(latLon);
+    const roundTrip = await reprojectFromLatLon(latLon!, crs, conversion);
+    assert.ok(roundTrip);
+    assert.ok(Math.abs(roundTrip!.easting - conversion.eastings) < 0.01);
+    assert.ok(Math.abs(roundTrip!.northing - conversion.northings) < 0.01);
+  });
+
+  it('builds a closed footprint polygon and preserves corner count', async () => {
+    const crs: ProjectedCRS = {
+      id: 114,
+      name: 'EPSG:5514',
+      mapUnit: 'METRE',
+      mapUnitScale: 1,
+    };
+    const conversion: MapConversion = {
+      id: 115,
+      sourceCRS: 14,
+      targetCRS: 114,
+      eastings: -740344,
+      northings: -1048817,
+      orthogonalHeight: 244,
+      scale: 0.001,
+    };
+
+    const footprint = await computeFootprintGeoJSON(conversion, crs, makeCoordinateInfo(), 0.001);
+    assert.ok(footprint);
+    assert.strictEqual(footprint!.length, 5);
+    assert.deepStrictEqual(footprint![0], footprint![4]);
+  });
+});

package/src/lib/geo/reproject.ts

@@ -19,7 +19,7 @@ import proj4 from 'proj4';
 import type { MapConversion, ProjectedCRS } from '@ifc-lite/parser';
 import type { CoordinateInfo } from '@ifc-lite/geometry';
 import { lookupProj4 } from '@ifc-lite/data';
-import { getEffectiveHorizontalScale } from './effective-georef';
+import { getEffectiveHorizontalScale } from './geo-scale';
 
 export interface LatLon {
   lat: number;
@@ -28,6 +28,7 @@ export interface LatLon {
 
 // Cache resolved projection definitions (from any source).
 const projDefCache = new Map<string, string | null>();
+const approxDatumWarningCache = new Set<string>();
 
 /**
  * Extract EPSG numeric code from a CRS name like "EPSG:32632" or "EPSG 2056".
@@ -90,7 +91,7 @@ const DATUM_TOWGS84: Record<string, string> = {
  * Strip +nadgrids=... from a proj4 string and add a +towgs84 approximation
  * based on the ellipsoid. Grid files cannot be loaded in the browser.
  */
-function sanitizeProj4(def: string): string {
+function sanitizeProj4(def: string, code?: string | null): string {
   if (!def.includes('+nadgrids') || def.includes('+nadgrids=@null')) return def;
 
   // Extract the ellipsoid to find the right towgs84 approximation
@@ -98,6 +99,15 @@ function sanitizeProj4(def: string): string {
   const ellps = ellpsMatch?.[1] ?? '';
   const towgs84 = DATUM_TOWGS84[ellps] ?? '+towgs84=0,0,0,0,0,0,0';
 
+  if (code && !approxDatumWarningCache.has(code)) {
+    approxDatumWarningCache.add(code);
+    console.warn(
+      `[reproject] EPSG:${code} requires browser-unavailable datum grids; `
+      + 'using an approximate +towgs84 transform instead. '
+      + 'Expect metre-level XY differences for some locations.',
+    );
+  }
+
   // Remove +nadgrids=... and add +towgs84
   return def.replace(/\+nadgrids=\S+/g, '').replace(/\s+/g, ' ').trim() + ' ' + towgs84;
 }
@@ -142,7 +152,7 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
     try {
       const bundled = await lookupProj4(code);
       if (bundled) {
-        const sanitized = sanitizeProj4(bundled);
+        const sanitized = sanitizeProj4(bundled, code);
         projDefCache.set(code, sanitized);
         return sanitized;
       }
@@ -163,7 +173,7 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
       try {
         const bundled = await lookupProj4(code);
         if (bundled) {
-          const sanitized = sanitizeProj4(bundled);
+          const sanitized = sanitizeProj4(bundled, code);
           projDefCache.set(code, sanitized);
           // For geographic CRS (longlat), check if we can infer a projected CRS
           // from the UTM zone metadata — a projected CRS is much more useful.
@@ -205,7 +215,7 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
   // 5. Network fallback — fetch from epsg.io
   if (code) {
     const raw = await fetchProj4Def(code);
-    const fetched = raw ? sanitizeProj4(raw) : null;
+    const fetched = raw ? sanitizeProj4(raw, code) : null;
     projDefCache.set(code, fetched);
     return fetched;
   }
@@ -235,7 +245,7 @@ function computeProjectedCenter(
   mapUnitScale: number,
   lengthUnitScale: number,
 ): { easting: number; northing: number } {
-  const { ifcX, ifcY } = computeLocalIfcCenter(coordinateInfo);
+  const { ifcX, ifcY } = computeModelCenterInIfcMeters(coordinateInfo);
 
   // Geometry coordinates (ifcX, ifcY) are already in metres — the geometry engine
   // converts from the IFC file's native unit during extraction. Only MapConversion
@@ -299,11 +309,13 @@ export async function reprojectToLatLon(
 }
 
 /**
- * Compute the model's local IFC center offset (ifcX, ifcY) from coordinate info.
- * This is the geometry center in IFC Z-up coordinates, before MapConversion is applied.
+ * Compute the model's center in IFC Z-up metres from coordinate info.
+ * This is the geometry center before MapConversion is applied.
  */
-function computeLocalIfcCenter(coordinateInfo?: CoordinateInfo): { ifcX: number; ifcY: number } {
-  if (!coordinateInfo) return { ifcX: 0, ifcY: 0 };
+export function computeModelCenterInIfcMeters(
+  coordinateInfo?: CoordinateInfo,
+): { ifcX: number; ifcY: number; ifcZ: number } {
+  if (!coordinateInfo) return { ifcX: 0, ifcY: 0, ifcZ: 0 };
 
   const bounds = coordinateInfo.originalBounds;
   const shift = coordinateInfo.originShift;
@@ -314,12 +326,18 @@ function computeLocalIfcCenter(coordinateInfo?: CoordinateInfo): { ifcX: number;
     : { x: 0, y: 0, z: 0 };
 
   const cx = (bounds.min.x + bounds.max.x) / 2;
+  const cy = (bounds.min.y + bounds.max.y) / 2;
   const cz = (bounds.min.z + bounds.max.z) / 2;
 
   const worldYupX = cx + shift.x + rtcYup.x;
+  const worldYupY = cy + shift.y + rtcYup.y;
   const worldYupZ = cz + shift.z + rtcYup.z;
 
-  return { ifcX: worldYupX, ifcY: -worldYupZ };
+  return {
+    ifcX: worldYupX,
+    ifcY: -worldYupZ,
+    ifcZ: worldYupY,
+  };
 }
 
 /**
@@ -353,7 +371,7 @@ export async function reprojectFromLatLon(
     // Geometry offsets (ifcX/Y) are already in metres.
     const mapScale = crs.mapUnitScale ?? lengthUnitScale;
     const invScale = mapScale !== 0 ? 1 / mapScale : 1;
-    const { ifcX, ifcY } = computeLocalIfcCenter(coordinateInfo);
+    const { ifcX, ifcY } = computeModelCenterInIfcMeters(coordinateInfo);
     // Effective horizontal scale for metre-converted geometry — see issue #595.
     const scale = getEffectiveHorizontalScale(conversion?.scale, mapScale, lengthUnitScale);
     const abscissa = conversion?.xAxisAbscissa ?? 1.0;
@@ -393,6 +411,13 @@ export async function computeFootprintGeoJSON(
     return null;
   }
 
+  // Geographic CRS values are degrees, while the model bounds are metres.
+  // Without a projected CRS / map conversion, we can show the model pin but
+  // not a trustworthy footprint polygon.
+  if (isGeographicProj4(projDef)) {
+    return null;
+  }
+
   // Effective horizontal scale for metre-converted geometry — see issue #595.
   const mapScale = crs.mapUnitScale ?? lengthUnitScale;
   const scale = getEffectiveHorizontalScale(conversion.scale, mapScale, lengthUnitScale);