@ifc-lite/viewer 1.21.0 → 1.22.1

package/src/lib/geo/reproject.ts

@@ -18,8 +18,9 @@
 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 { lookupEpsgByCode } from '@ifc-lite/data';
+import { getEffectiveHorizontalScale, resolveMapUnitToMetreScale } from './geo-scale';
+import { resolvePrecisionDef } from './precision-grids';
 
 export interface LatLon {
   lat: number;
@@ -28,6 +29,10 @@ export interface LatLon {
 
 // Cache resolved projection definitions (from any source).
 const projDefCache = new Map<string, string | null>();
+const approxDatumWarningCache = new Set<string>();
+// Track datums where the bundled proj4 lacked any datum-shift parameters and we
+// couldn't supply a fallback — surfaced via diagnostics, warned once per datum.
+const unknownDatumWarningCache = new Set<string>();
 
 /**
  * Extract EPSG numeric code from a CRS name like "EPSG:32632" or "EPSG 2056".
@@ -39,9 +44,14 @@ function extractEpsgCode(crs: ProjectedCRS): string | null {
 
 /**
  * Well-known CRS names that IFC authoring tools set without an EPSG: prefix.
- * Maps normalised name → EPSG code.
+ * Maps normalised name → EPSG code. Keys are lowercased before lookup.
+ *
+ * Authoring tools across regions emit different local conventions for the same
+ * national grid; covering the common ones lets ifc-lite resolve a projection
+ * for files that omit the "EPSG:" prefix entirely.
  */
 const WELL_KNOWN_CRS: Record<string, string> = {
+  // Global / generic
   'wgs 84': '4326',
   'wgs84': '4326',
   'wgs-84': '4326',
@@ -50,6 +60,53 @@ const WELL_KNOWN_CRS: Record<string, string> = {
   'etrs89': '4258',
   'gcs_wgs_1984': '4326',        // ArcGIS / Revit export alias
   'gcs_north_american_1983': '4269',
+
+  // Netherlands — Rijksdriehoeksmeting (RD New, EPSG:28992)
+  'rd': '28992',
+  'rd new': '28992',
+  'amersfoort / rd new': '28992',
+  'amersfoort rd new': '28992',
+  'stelsel van de rijksdriehoeksmeting': '28992',
+  'rijksdriehoeksmeting': '28992',
+  'nl_rd': '28992',
+  // RD/NAP compound (horizontal RD + vertical NAP)
+  'rd new + nap height': '7415',
+  'amersfoort / rd new + nap height': '7415',
+
+  // United Kingdom — Ordnance Survey GB (BNG, EPSG:27700)
+  'osgb 1936 / british national grid': '27700',
+  'osgb36 / british national grid': '27700',
+  'british national grid': '27700',
+  'bng': '27700',
+
+  // Germany — DHDN / Gauss-Kruger zones + ETRS89 / UTM (most common)
+  'dhdn / gauss-kruger zone 2': '31466',
+  'dhdn / gauss-kruger zone 3': '31467',
+  'dhdn / gauss-kruger zone 4': '31468',
+  'dhdn / gauss-kruger zone 5': '31469',
+  'etrs89 / utm zone 32n': '25832',
+  'etrs89 / utm zone 33n': '25833',
+
+  // Austria — MGI Lambert / Austrian Grid (EPSG:31287)
+  'mgi / austria lambert': '31287',
+  'austria lambert': '31287',
+
+  // Switzerland — CH1903+ / LV95 (EPSG:2056) and legacy LV03 (EPSG:21781)
+  'ch1903+ / lv95': '2056',
+  'lv95': '2056',
+  'ch1903 / lv03': '21781',
+  'lv03': '21781',
+
+  // Belgium — Lambert 2008 (EPSG:3812) and legacy Lambert 72 (EPSG:31370)
+  'belge 1972 / belgian lambert 72': '31370',
+  'belgian lambert 72': '31370',
+  'etrs89 / belgian lambert 2008': '3812',
+
+  // France — RGF93 / Lambert-93 (EPSG:2154)
+  'rgf93 / lambert-93': '2154',
+  'rgf93 v1 / lambert-93': '2154',
+  'lambert-93': '2154',
+  'lambert 93': '2154',
 };
 
 /**
@@ -73,32 +130,92 @@ function utmProj4String(zone: string): string | null {
 }
 
 /**
- * Well-known +towgs84 approximations for datums that normally use grid files.
- * These are accurate to ~1-5m, which is sufficient for map display.
- * Grid files (like OSTN15_NTv2_OSGBtoETRS.gsb) cannot run in the browser.
+ * Datum-keyed +towgs84 approximations for CRSs whose canonical definition
+ * relies on browser-unavailable grid files (NTv2, NADCON, etc.). Each entry
+ * is the published Bursa-Wolf 7-parameter set for that specific datum, in
+ * the Position Vector convention proj4 expects, with rotations in arc-seconds.
+ *
+ * Keys are lowercased datum names as they appear in EpsgIndexEntry.datum. A
+ * lookup miss is intentional — it forces sanitizeProj4 to emit a diagnostic
+ * rather than silently substitute parameters for the wrong region (an earlier
+ * version of this table was keyed by ellipsoid alone, which caused every
+ * Bessel-1841 CRS — RD/NL, Hermannskogel/AT, S-JTSK/CZ — to inherit Germany's
+ * DHDN shift). Accuracy is typically ~1-5 m, sufficient for map display.
  */
 const DATUM_TOWGS84: Record<string, string> = {
-  'airy': '+towgs84=446.448,-125.157,542.06,0.15,0.247,0.842,-20.489',      // OSGB36 (UK)
-  'clrk66': '+towgs84=-8,160,176,0,0,0,0',                                   // NAD27 (approx)
-  'GRS80': '+towgs84=0,0,0,0,0,0,0',                                          // GRS80-based (NAD83≈WGS84)
-  'bessel': '+towgs84=598.1,73.7,418.2,0.202,0.045,-2.455,6.7',              // DHDN (Germany)
-  'intl': '+towgs84=-87,-98,-121,0,0,0,0',                                    // NZGD49 (NZ)
-  'aust_SA': '+towgs84=-134,-48,149,0,0,0,0',                                 // AGD84 (Australia)
+  // United Kingdom — OSGB36 (Airy 1830)
+  'osgb 1936': '+towgs84=446.448,-125.157,542.06,0.15,0.247,0.842,-20.489',
+  // North America — NAD27 (Clarke 1866)
+  'north american datum 1927': '+towgs84=-8,160,176,0,0,0,0',
+  'nad27': '+towgs84=-8,160,176,0,0,0,0',
+  // NAD83 ≈ WGS84 to within ~1 m; identity is the standard browser approximation.
+  'north american datum 1983': '+towgs84=0,0,0,0,0,0,0',
+  'nad83': '+towgs84=0,0,0,0,0,0,0',
+  // Germany — DHDN (Bessel 1841)
+  'deutsches hauptdreiecksnetz': '+towgs84=598.1,73.7,418.2,0.202,0.045,-2.455,6.7',
+  'dhdn': '+towgs84=598.1,73.7,418.2,0.202,0.045,-2.455,6.7',
+  // Netherlands — Amersfoort (Bessel 1841). The bundled EPSG:28992 already
+  // ships with the higher-precision Kadaster +towgs84, so this fires only
+  // when a derived/compound CRS lacks it (e.g. some compound RD/NAP cases).
+  'amersfoort': '+towgs84=565.4171,50.3319,465.5524,1.9342,-1.6677,9.1019,4.0725',
+  // Austria — MGI (Bessel 1841)
+  'militar-geographische institut': '+towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232',
+  'mgi': '+towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232',
+  // Czech Republic — S-JTSK (Bessel 1841)
+  'system of the unified trigonometrical cadastral network': '+towgs84=570.8,85.7,462.8,4.998,1.587,5.261,3.56',
+  's-jtsk': '+towgs84=570.8,85.7,462.8,4.998,1.587,5.261,3.56',
+  // New Zealand — NZGD49 (International 1924)
+  'new zealand geodetic datum 1949': '+towgs84=59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993',
+  'nzgd49': '+towgs84=59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993',
+  // Australia — AGD84 (Australian National Spheroid)
+  'australian geodetic datum 1984': '+towgs84=-117.763,-51.51,139.061,0.292,0.443,0.277,-0.191',
+  'agd84': '+towgs84=-117.763,-51.51,139.061,0.292,0.443,0.277,-0.191',
 };
 
 /**
  * Strip +nadgrids=... from a proj4 string and add a +towgs84 approximation
- * based on the ellipsoid. Grid files cannot be loaded in the browser.
+ * keyed by the datum name from the bundled EPSG index. Grid files cannot be
+ * loaded in the browser; +towgs84 is the standard fallback.
+ *
+ * Skipped (returns input verbatim) when:
+ *   - No +nadgrids reference (or it's the no-op `@null`)
+ *   - A +towgs84 is already present (proj4 will honour it)
  */
-function sanitizeProj4(def: string): string {
+function sanitizeProj4(def: string, code?: string | null, datumName?: string | null): string {
   if (!def.includes('+nadgrids') || def.includes('+nadgrids=@null')) return def;
+  if (/\+towgs84=/.test(def)) {
+    // Strip the unusable grid reference but keep the existing datum shift.
+    return def.replace(/\+nadgrids=\S+/g, '').replace(/\s+/g, ' ').trim();
+  }
 
-  // Extract the ellipsoid to find the right towgs84 approximation
-  const ellpsMatch = def.match(/\+ellps=(\S+)/);
-  const ellps = ellpsMatch?.[1] ?? '';
-  const towgs84 = DATUM_TOWGS84[ellps] ?? '+towgs84=0,0,0,0,0,0,0';
+  const datumKey = datumName?.trim().toLowerCase() ?? '';
+  const towgs84 = datumKey ? DATUM_TOWGS84[datumKey] : undefined;
+
+  if (!towgs84) {
+    if (datumKey && !unknownDatumWarningCache.has(datumKey)) {
+      unknownDatumWarningCache.add(datumKey);
+      console.warn(
+        `[reproject] EPSG:${code ?? '?'} ("${datumName}") needs browser-unavailable `
+        + 'datum grids and has no known +towgs84 fallback for its datum. '
+        + 'Positions will be aligned to the source CRS but may be tens of metres '
+        + 'off relative to WGS84/basemaps. Consider adding the datum to '
+        + 'DATUM_TOWGS84 in apps/viewer/src/lib/geo/reproject.ts.',
+      );
+    }
+    // Strip the grid reference; let proj4 fall through with no datum shift
+    // rather than silently substitute a wrong-region transform.
+    return def.replace(/\+nadgrids=\S+/g, '').replace(/\s+/g, ' ').trim();
+  }
+
+  if (code && !approxDatumWarningCache.has(code)) {
+    approxDatumWarningCache.add(code);
+    console.warn(
+      `[reproject] EPSG:${code} requires browser-unavailable datum grids; `
+      + `using approximate +towgs84 for "${datumName}" 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;
 }
 
@@ -124,10 +241,13 @@ async function fetchProj4Def(epsgCode: string): Promise<string | null> {
  *
  * Resolution order:
  *   1. Cache hit
- *   2. Bundled EPSG index (7000+ codes with proj4 strings)
- *   3. Well-known CRS name lookup (e.g. "WGS 84" → EPSG:4326)
- *   4. UTM zone heuristic (from CRS metadata — mapZone, name, description, mapProjection)
- *   5. Fetch from epsg.io (network fallback)
+ *   2. Precision grid (NTv2/GeoTIFF) for codes where +towgs84 is too coarse
+ *      (RD/NL, OSGB/UK, BD72/BE) — fetched once from cdn.proj.org, gives
+ *      sub-decimeter accuracy. Falls through to (3) if the fetch fails.
+ *   3. Bundled EPSG index (7000+ codes with proj4 strings)
+ *   4. Well-known CRS name lookup (e.g. "WGS 84" → EPSG:4326)
+ *   5. UTM zone heuristic (from CRS metadata — mapZone, name, description, mapProjection)
+ *   6. Fetch from epsg.io (network fallback)
  */
 export async function resolveProjection(crs: ProjectedCRS): Promise<string | null> {
   let code = extractEpsgCode(crs);
@@ -137,12 +257,29 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
     return projDefCache.get(code) ?? null;
   }
 
-  // 2. Bundled EPSG index (primary source — all 7000+ codes)
+  // 2. Precision grid (NTv2/GeoTIFF). For Bessel-based national grids
+  // (RD/NL, BD72/BE, OSGB/UK), the +towgs84 approximation that the bundled
+  // entries carry is off by 80-200 m. proj4js can consume PROJ's GeoTIFF
+  // datum-shift grids — load and register, then use a +nadgrids-based
+  // proj4 string for sub-decimeter accuracy.
+  if (code) {
+    try {
+      const precisionDef = await resolvePrecisionDef(code);
+      if (precisionDef) {
+        projDefCache.set(code, precisionDef);
+        return precisionDef;
+      }
+    } catch (error) {
+      console.warn(`[reproject] precision grid resolution failed for EPSG:${code}, falling back`, error);
+    }
+  }
+
+  // 3. Bundled EPSG index (primary source — all 7000+ codes)
   if (code) {
     try {
-      const bundled = await lookupProj4(code);
-      if (bundled) {
-        const sanitized = sanitizeProj4(bundled);
+      const entry = await lookupEpsgByCode(code);
+      if (entry?.proj4) {
+        const sanitized = sanitizeProj4(entry.proj4, code, entry.datum);
         projDefCache.set(code, sanitized);
         return sanitized;
       }
@@ -151,7 +288,7 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
     }
   }
 
-  // 3. Well-known CRS name → EPSG code (handles "WGS 84", "NAD83", etc.)
+  // 3. Well-known CRS name → EPSG code (handles "WGS 84", "NAD83", "RD New", etc.)
   if (!code) {
     const normalised = crs.name?.trim().toLowerCase() ?? '';
     const wellKnownCode = WELL_KNOWN_CRS[normalised];
@@ -161,9 +298,9 @@ export async function resolveProjection(crs: ProjectedCRS): Promise<string | nul
         return projDefCache.get(code) ?? null;
       }
       try {
-        const bundled = await lookupProj4(code);
-        if (bundled) {
-          const sanitized = sanitizeProj4(bundled);
+        const entry = await lookupEpsgByCode(code);
+        if (entry?.proj4) {
+          const sanitized = sanitizeProj4(entry.proj4, code, entry.datum);
           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 +342,12 @@ 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;
+    // We don't have a bundled EpsgIndexEntry here (otherwise we'd have hit
+    // step 2), so fall back to parsing the datum name out of the proj4
+    // string itself when possible. `+datum=` is rare in modern proj4 output;
+    // the typical hint is `+ellps=` which we already accept as a weak signal
+    // inside DATUM_TOWGS84 keys above.
+    const fetched = raw ? sanitizeProj4(raw, code, null) : null;
     projDefCache.set(code, fetched);
     return fetched;
   }
@@ -235,7 +377,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
@@ -285,7 +427,7 @@ export async function reprojectToLatLon(
 
   // MapConversion values use the unit from IfcProjectedCRS.MapUnit. If MapUnit
   // is not specified, the IFC spec defaults to the project's length unit.
-  const mapScale = crs.mapUnitScale ?? lengthUnitScale;
+  const mapScale = resolveMapUnitToMetreScale(crs.mapUnitScale, lengthUnitScale);
   const { easting, northing } = computeProjectedCenter(conversion, coordinateInfo, mapScale, lengthUnitScale);
 
   try {
@@ -299,11 +441,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 +458,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,
+  };
 }
 
 /**
@@ -351,9 +501,9 @@ export async function reprojectFromLatLon(
 
     // Convert projected metres back to MapConversion's unit.
     // Geometry offsets (ifcX/Y) are already in metres.
-    const mapScale = crs.mapUnitScale ?? lengthUnitScale;
+    const mapScale = resolveMapUnitToMetreScale(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,8 +543,15 @@ 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 mapScale = resolveMapUnitToMetreScale(crs.mapUnitScale, lengthUnitScale);
   const scale = getEffectiveHorizontalScale(conversion.scale, mapScale, lengthUnitScale);
   const abscissa = conversion.xAxisAbscissa ?? 1.0;
   const ordinate = conversion.xAxisOrdinate ?? 0.0;