@splnlss/3d-story-viewer 0.5.7 → 0.6.0

package/build/{index-C7Ow38PB.js → index-CsZhc21b.js}

@@ -30844,6 +30844,148 @@ class WebGLRenderer {
     gl.unpackColorSpace = ColorManagement._getUnpackColorSpace();
   }
 }
+const WGS84_SEMI_MAJOR_AXIS_METERS = 6378137;
+const WGS84_INVERSE_FLATTENING = 298.257223563;
+const WGS84_FLATTENING = 1 / WGS84_INVERSE_FLATTENING;
+const WGS84_SEMI_MINOR_AXIS_METERS = WGS84_SEMI_MAJOR_AXIS_METERS * (1 - WGS84_FLATTENING);
+const WGS84_FIRST_ECCENTRICITY_SQUARED = WGS84_FLATTENING * (2 - WGS84_FLATTENING);
+const MIN_ELLIPSOIDAL_HEIGHT_METERS = -12e3;
+const MAX_ELLIPSOIDAL_HEIGHT_METERS = 1e5;
+const DEGREES_TO_RADIANS = Math.PI / 180;
+const RADIANS_TO_DEGREES = 180 / Math.PI;
+function requireFiniteNumber(value, field) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${field} must be a finite number.`);
+  }
+  return value;
+}
+function validateLongitudeLatitude(longitude, latitude, field = "Geodetic position") {
+  requireFiniteNumber(longitude, `${field} longitude`);
+  requireFiniteNumber(latitude, `${field} latitude`);
+  if (longitude < -180 || longitude > 180) {
+    throw new RangeError(`${field} longitude must be within [-180, 180] degrees.`);
+  }
+  if (latitude < -90 || latitude > 90) {
+    throw new RangeError(`${field} latitude must be within [-90, 90] degrees.`);
+  }
+}
+function validateGeodeticPosition(longitude, latitude, altitude, field = "Geodetic position") {
+  validateLongitudeLatitude(longitude, latitude, field);
+  requireFiniteNumber(altitude, `${field} altitude`);
+  if (altitude < MIN_ELLIPSOIDAL_HEIGHT_METERS || altitude > MAX_ELLIPSOIDAL_HEIGHT_METERS) {
+    throw new RangeError(`${field} altitude must be within [${MIN_ELLIPSOIDAL_HEIGHT_METERS}, ${MAX_ELLIPSOIDAL_HEIGHT_METERS}] WGS84 ellipsoidal meters.`);
+  }
+  return { longitude, latitude, altitude };
+}
+function validateRotation(pitch, yaw, roll, field = "Rotation") {
+  return {
+    pitch: requireFiniteNumber(pitch, `${field} pitch`),
+    yaw: requireFiniteNumber(yaw, `${field} yaw`),
+    roll: requireFiniteNumber(roll, `${field} roll`)
+  };
+}
+function validateTuple(value, field) {
+  if (!Array.isArray(value) || value.length !== 3 || !value.every(Number.isFinite)) {
+    throw new TypeError(`${field} must be a finite three-number tuple.`);
+  }
+  return value;
+}
+function validateScale(value, field = "Scale") {
+  requireFiniteNumber(value, field);
+  if (value <= 0) throw new RangeError(`${field} must be positive.`);
+  return value;
+}
+function normalizeLayerOffset(offset, field = "Layer offset") {
+  const normalized = {
+    lon: (offset == null ? void 0 : offset.lon) ?? 0,
+    lat: (offset == null ? void 0 : offset.lat) ?? 0,
+    alt: (offset == null ? void 0 : offset.alt) ?? 0
+  };
+  requireFiniteNumber(normalized.lon, `${field} longitude`);
+  requireFiniteNumber(normalized.lat, `${field} latitude`);
+  requireFiniteNumber(normalized.alt, `${field} altitude`);
+  return normalized;
+}
+function validateEcefPosition(x, y, z) {
+  requireFiniteNumber(x, "ECEF x");
+  requireFiniteNumber(y, "ECEF y");
+  requireFiniteNumber(z, "ECEF z");
+  if (x === 0 && y === 0 && z === 0) {
+    throw new RangeError("The ECEF origin has no geodetic solution.");
+  }
+  return [x, y, z];
+}
+function geodeticToEcefPosition(longitude, latitude, altitude) {
+  requireFiniteNumber(longitude, "Longitude");
+  requireFiniteNumber(latitude, "Latitude");
+  requireFiniteNumber(altitude, "Altitude");
+  const latitudeRadians = latitude * DEGREES_TO_RADIANS;
+  const longitudeRadians = longitude * DEGREES_TO_RADIANS;
+  const sinLatitude = Math.sin(latitudeRadians);
+  const cosLatitude = Math.abs(latitude) === 90 ? 0 : Math.cos(latitudeRadians);
+  const primeVerticalRadius = WGS84_SEMI_MAJOR_AXIS_METERS / Math.sqrt(1 - WGS84_FIRST_ECCENTRICITY_SQUARED * sinLatitude ** 2);
+  return [
+    (primeVerticalRadius + altitude) * cosLatitude * Math.cos(longitudeRadians),
+    (primeVerticalRadius + altitude) * cosLatitude * Math.sin(longitudeRadians),
+    ((1 - WGS84_FIRST_ECCENTRICITY_SQUARED) * primeVerticalRadius + altitude) * sinLatitude
+  ];
+}
+function ecefToGeodeticPosition(x, y, z) {
+  validateEcefPosition(x, y, z);
+  const distanceFromPolarAxis = Math.hypot(x, y);
+  if (distanceFromPolarAxis === 0) {
+    return {
+      lon: 0,
+      lat: z < 0 ? -90 : 90,
+      alt: Math.abs(z) - WGS84_SEMI_MINOR_AXIS_METERS
+    };
+  }
+  const semiMajorAxisSquared = WGS84_SEMI_MAJOR_AXIS_METERS ** 2;
+  const semiMinorAxisSquared = WGS84_SEMI_MINOR_AXIS_METERS ** 2;
+  const secondEccentricity = Math.sqrt((semiMajorAxisSquared - semiMinorAxisSquared) / semiMinorAxisSquared);
+  const theta = Math.atan2(WGS84_SEMI_MAJOR_AXIS_METERS * z, WGS84_SEMI_MINOR_AXIS_METERS * distanceFromPolarAxis);
+  const longitude = Math.atan2(y, x);
+  const latitude = Math.atan2(
+    z + secondEccentricity ** 2 * WGS84_SEMI_MINOR_AXIS_METERS * Math.sin(theta) ** 3,
+    distanceFromPolarAxis - WGS84_FIRST_ECCENTRICITY_SQUARED * WGS84_SEMI_MAJOR_AXIS_METERS * Math.cos(theta) ** 3
+  );
+  const sinLatitude = Math.sin(latitude);
+  const primeVerticalRadius = WGS84_SEMI_MAJOR_AXIS_METERS / Math.sqrt(1 - WGS84_FIRST_ECCENTRICITY_SQUARED * sinLatitude ** 2);
+  const altitude = Math.abs(Math.cos(latitude)) >= Math.abs(sinLatitude) ? distanceFromPolarAxis / Math.cos(latitude) - primeVerticalRadius : z / sinLatitude - primeVerticalRadius * (1 - WGS84_FIRST_ECCENTRICITY_SQUARED);
+  return {
+    lon: longitude * RADIANS_TO_DEGREES,
+    lat: latitude * RADIANS_TO_DEGREES,
+    alt: altitude
+  };
+}
+function getEnuBasis(longitude, latitude) {
+  validateLongitudeLatitude(longitude, latitude, "ENU origin");
+  const longitudeRadians = longitude * DEGREES_TO_RADIANS;
+  const latitudeRadians = latitude * DEGREES_TO_RADIANS;
+  const sinLongitude = Math.sin(longitudeRadians);
+  const cosLongitude = Math.cos(longitudeRadians);
+  const sinLatitude = Math.sin(latitudeRadians);
+  const cosLatitude = Math.cos(latitudeRadians);
+  return {
+    east: [-sinLongitude, cosLongitude, 0],
+    north: [-sinLatitude * cosLongitude, -sinLatitude * sinLongitude, cosLatitude],
+    up: [cosLatitude * cosLongitude, cosLatitude * sinLongitude, sinLatitude]
+  };
+}
+function geodeticOffsetToEcefDelta(position, offset) {
+  validateLongitudeLatitude(position.lon, position.lat, "Layer root");
+  requireFiniteNumber(position.alt, "Layer root altitude");
+  const normalizedOffset = normalizeLayerOffset(offset);
+  const longitude = position.lon + normalizedOffset.lon;
+  const latitude = position.lat + normalizedOffset.lat;
+  validateLongitudeLatitude(longitude, latitude, "Offset layer root");
+  const originalEcef = geodeticToEcefPosition(position.lon, position.lat, position.alt);
+  const adjustedEcef = geodeticToEcefPosition(longitude, latitude, position.alt + normalizedOffset.alt);
+  return (
+    /** @type {[number, number, number]} */
+    adjustedEcef.map((value, index) => value - originalEcef[index])
+  );
+}
 globalThis.process = globalThis.process || {};
 globalThis.process.env = globalThis.process.env || {};
 async function parseFromContext(data, loaders, options, context) {
@@ -38506,38 +38648,6 @@ const logColors = {
   fgRed: "\x1B[31m"
 };
 let sessionKeyCache = null;
-function ecefToGeodeticPosition(x, y, z) {
-  const a = 6378137;
-  const e = 0.081819190842622;
-  const asq = a * a;
-  const esq = e * e;
-  const b = Math.sqrt(asq * (1 - esq));
-  const bsq = b * b;
-  const ep = Math.sqrt((asq - bsq) / bsq);
-  const p = Math.sqrt(x * x + y * y);
-  const th = Math.atan2(a * z, b * p);
-  const lon = Math.atan2(y, x);
-  const lat = Math.atan2(z + ep * ep * b * Math.sin(th) ** 3, p - esq * a * Math.cos(th) ** 3);
-  const N = a / Math.sqrt(1 - esq * Math.sin(lat) * Math.sin(lat));
-  const alt = p / Math.cos(lat) - N;
-  return {
-    lon: lon * (180 / Math.PI),
-    lat: lat * (180 / Math.PI),
-    alt
-  };
-}
-function geodeticToEcefPosition(lon, lat, alt) {
-  const a = 6378137;
-  const e = 0.081819190842622;
-  const esq = e * e;
-  const latRad = lat * (Math.PI / 180);
-  const lonRad = lon * (Math.PI / 180);
-  const N = a / Math.sqrt(1 - esq * Math.sin(latRad) ** 2);
-  const x = (N + alt) * Math.cos(latRad) * Math.cos(lonRad);
-  const y = (N + alt) * Math.cos(latRad) * Math.sin(lonRad);
-  const z = ((1 - esq) * N + alt) * Math.sin(latRad);
-  return [x, y, z];
-}
 function buildTileUrl(path, apiKey) {
   const url = new URL("https://tile.googleapis.com" + path);
   const sessionKeyValue = url.searchParams.get("session");
@@ -38650,12 +38760,13 @@ function getDeepestTile(tileQueue) {
   return deepest;
 }
 async function computeElevation(lon, lat, options) {
+  validateGeodeticPosition(lon, lat, 0, "Elevation query");
   const apiKey = options == null ? void 0 : options.apiKey;
   if (!apiKey) {
     console.log(`${logColors.fgRed}No API key provided for fetching tiles.${logColors.reset}`);
     return null;
   }
-  const maxDepth = (options == null ? void 0 : options.maxDepth) || 18;
+  const maxDepth = (options == null ? void 0 : options.maxDepth) ?? 18;
   const alt = 1e4;
   const point = geodeticToEcefPosition(lon, lat, alt);
   const tileQueue = await getOGC3DTile(point, maxDepth, apiKey);
@@ -38665,162 +38776,173 @@ async function computeElevation(lon, lat, options) {
     const gltf = await loadGltf(tileUrl);
     const intersectionPoint = intersectGltf(gltf.json.nodes, gltf.json.meshes, point);
     const coords = ecefToGeodeticPosition(...intersectionPoint);
+    validateGeodeticPosition(coords.lon, coords.lat, coords.alt, "Computed elevation");
     return coords;
   }
 }
 export {
-  Material as $,
-  InterleavedBufferAttribute as A,
+  Raycaster as $,
+  Camera as A,
   BufferGeometry as B,
   Color as C,
-  DoubleSide as D,
-  MeshPhysicalMaterial as E,
+  DataArrayTexture as D,
+  PMREMGenerator as E,
   Float32BufferAttribute as F,
-  Vector2 as G,
-  SpotLight as H,
-  ImageUtils as I,
-  PointLight as J,
-  DirectionalLight as K,
-  LinearFilter as L,
-  Mesh as M,
-  NoColorSpace as N,
-  OrthographicCamera as O,
-  PropertyBinding as P,
+  GLSL3 as G,
+  MeshStandardMaterial as H,
+  InstancedBufferGeometry as I,
+  REVISION as J,
+  Matrix2 as K,
+  Loader as L,
+  Matrix4 as M,
+  NearestFilter as N,
+  Object3D as O,
+  PerspectiveCamera as P,
   Quaternion as Q,
-  REVISION as R,
+  RGBAIntegerFormat as R,
   ShaderChunk as S,
-  TrianglesDrawMode as T,
-  InstancedMesh as U,
+  Texture as T,
+  UnsignedIntType as U,
   Vector3$1 as V,
-  InstancedBufferAttribute as W,
-  Object3D as X,
-  TextureLoader as Y,
-  ImageBitmapLoader as Z,
-  PointsMaterial as _,
-  Matrix4 as a,
-  Vector4 as a$,
-  LineBasicMaterial as a0,
-  MeshStandardMaterial as a1,
-  MeshBasicMaterial as a2,
-  SkinnedMesh as a3,
-  LineSegments as a4,
-  Line as a5,
-  LineLoop as a6,
-  Points as a7,
-  Group as a8,
-  PerspectiveCamera as a9,
-  RGBA_S3TC_DXT1_Format as aA,
-  RGBA_ASTC_6x6_Format as aB,
-  RGBA_ASTC_4x4_Format as aC,
-  SIGNED_RG11_EAC_Format as aD,
-  RG11_EAC_Format as aE,
-  SIGNED_R11_EAC_Format as aF,
-  R11_EAC_Format as aG,
-  RGB_ETC2_Format as aH,
-  RGBA_ETC2_EAC_Format as aI,
-  RGBFormat as aJ,
-  RedFormat as aK,
-  RGFormat as aL,
-  UnsignedByteType as aM,
-  UnsignedInt101111Type as aN,
-  UnsignedInt5999Type as aO,
-  UnsignedShortType as aP,
-  DataTexture as aQ,
-  Data3DTexture as aR,
-  RGB_PVRTC_4BPPV1_Format as aS,
-  RGB_ETC1_Format as aT,
-  RGB_BPTC_UNSIGNED_Format as aU,
-  DataArrayTexture as aV,
-  RGBAIntegerFormat as aW,
-  UnsignedIntType as aX,
-  RawShaderMaterial as aY,
-  RGIntegerFormat as aZ,
-  ShaderMaterial as a_,
-  Skeleton as aa,
-  AnimationClip as ab,
-  Bone as ac,
-  Texture as ad,
-  VectorKeyframeTrack as ae,
-  NumberKeyframeTrack as af,
-  QuaternionKeyframeTrack as ag,
-  FrontSide as ah,
-  Interpolant as ai,
-  Box3 as aj,
-  Sphere as ak,
-  DataTextureLoader as al,
-  HalfFloatType as am,
-  FloatType as an,
-  DataUtils as ao,
-  CompressedCubeTexture as ap,
-  CompressedArrayTexture as aq,
-  RGBA_PVRTC_2BPPV1_Format as ar,
-  RGBA_PVRTC_4BPPV1_Format as as,
-  RGBA_BPTC_Format as at,
-  RED_GREEN_RGTC2_Format as au,
-  SIGNED_RED_GREEN_RGTC2_Format as av,
-  RED_RGTC1_Format as aw,
-  SIGNED_RED_RGTC1_Format as ax,
-  RGBA_S3TC_DXT5_Format as ay,
-  RGB_S3TC_DXT1_Format as az,
-  BufferAttribute as b,
-  Matrix3$1 as b0,
-  InstancedBufferGeometry as b1,
-  DynamicDrawUsage as b2,
-  WebGLArrayRenderTarget as b3,
-  GLSL3 as b4,
-  Clock as b5,
-  WebGLRenderTarget as b6,
-  WebGLCubeRenderTarget as b7,
-  LinearMipMapLinearFilter as b8,
-  CubeCamera as b9,
-  Camera as ba,
-  PMREMGenerator as bb,
-  Matrix2 as bc,
-  PlaneGeometry as bd,
-  Ray as be,
-  EventDispatcher as bf,
-  Plane as bg,
-  Raycaster as bh,
-  Euler as bi,
-  Spherical as bj,
-  LoadingManager as bk,
-  Frustum as bl,
-  DefaultLoadingManager as bm,
-  TextureUtils as bn,
-  Triangle as bo,
-  CanvasTexture as bp,
-  WebGLRenderer as bq,
-  OneFactor as br,
-  ZeroFactor as bs,
-  CustomBlending as bt,
-  Box2 as bu,
-  BackSide as bv,
-  BoxGeometry as bw,
-  AgXToneMapping as bx,
-  EquirectangularReflectionMapping as by,
-  computeElevation as bz,
-  CompressedTexture as c,
-  Source as d,
-  MathUtils as e,
-  RGBAFormat as f,
-  InterpolateDiscrete as g,
-  Scene as h,
-  SRGBColorSpace as i,
-  NearestFilter as j,
-  NearestMipmapNearestFilter as k,
-  NearestMipmapLinearFilter as l,
-  LinearMipmapNearestFilter as m,
-  LinearMipmapLinearFilter as n,
-  ClampToEdgeWrapping as o,
-  RepeatWrapping as p,
-  MirroredRepeatWrapping as q,
-  InterpolateLinear as r,
-  TriangleFanDrawMode as s,
-  TriangleStripDrawMode as t,
-  Loader as u,
-  LoaderUtils as v,
-  FileLoader as w,
-  LinearSRGBColorSpace as x,
-  InterleavedBuffer as y,
-  ColorManagement as z
+  WebGLArrayRenderTarget as W,
+  PlaneGeometry as X,
+  Ray as Y,
+  EventDispatcher as Z,
+  Plane as _,
+  Vector2 as a,
+  Source as a$,
+  MathUtils as a0,
+  Sphere as a1,
+  Euler as a2,
+  Spherical as a3,
+  Group as a4,
+  LoaderUtils as a5,
+  InterleavedBuffer as a6,
+  ColorManagement as a7,
+  InterleavedBufferAttribute as a8,
+  TrianglesDrawMode as a9,
+  Skeleton as aA,
+  AnimationClip as aB,
+  Bone as aC,
+  InterpolateDiscrete as aD,
+  InterpolateLinear as aE,
+  VectorKeyframeTrack as aF,
+  NumberKeyframeTrack as aG,
+  QuaternionKeyframeTrack as aH,
+  FrontSide as aI,
+  Interpolant as aJ,
+  LoadingManager as aK,
+  Frustum as aL,
+  DefaultLoadingManager as aM,
+  TextureUtils as aN,
+  RGFormat as aO,
+  Triangle as aP,
+  CanvasTexture as aQ,
+  WebGLRenderer as aR,
+  OneFactor as aS,
+  ZeroFactor as aT,
+  CustomBlending as aU,
+  Box2 as aV,
+  DataTextureLoader as aW,
+  HalfFloatType as aX,
+  FloatType as aY,
+  DataUtils as aZ,
+  CompressedTexture as a_,
+  TriangleFanDrawMode as aa,
+  TriangleStripDrawMode as ab,
+  MeshPhysicalMaterial as ac,
+  SpotLight as ad,
+  PointLight as ae,
+  DirectionalLight as af,
+  InstancedMesh as ag,
+  TextureLoader as ah,
+  ImageBitmapLoader as ai,
+  LinearMipmapLinearFilter as aj,
+  NearestMipmapLinearFilter as ak,
+  LinearMipmapNearestFilter as al,
+  NearestMipmapNearestFilter as am,
+  RepeatWrapping as an,
+  MirroredRepeatWrapping as ao,
+  ClampToEdgeWrapping as ap,
+  PointsMaterial as aq,
+  Material as ar,
+  LineBasicMaterial as as,
+  MeshBasicMaterial as at,
+  PropertyBinding as au,
+  SkinnedMesh as av,
+  LineSegments as aw,
+  Line as ax,
+  LineLoop as ay,
+  Points as az,
+  Mesh as b,
+  NoColorSpace as b0,
+  ImageUtils as b1,
+  Scene as b2,
+  ecefToGeodeticPosition as b3,
+  getEnuBasis as b4,
+  BackSide as b5,
+  BoxGeometry as b6,
+  CompressedCubeTexture as b7,
+  CompressedArrayTexture as b8,
+  RGBA_PVRTC_2BPPV1_Format as b9,
+  geodeticOffsetToEcefDelta as bA,
+  validateGeodeticPosition as bB,
+  validateTuple as bC,
+  validateScale as bD,
+  geodeticToEcefPosition as bE,
+  AgXToneMapping as bF,
+  EquirectangularReflectionMapping as bG,
+  validateRotation as bH,
+  requireFiniteNumber as bI,
+  computeElevation as bJ,
+  RGBA_PVRTC_4BPPV1_Format as ba,
+  RGBA_BPTC_Format as bb,
+  RED_GREEN_RGTC2_Format as bc,
+  SIGNED_RED_GREEN_RGTC2_Format as bd,
+  RED_RGTC1_Format as be,
+  SIGNED_RED_RGTC1_Format as bf,
+  RGBA_S3TC_DXT5_Format as bg,
+  RGB_S3TC_DXT1_Format as bh,
+  RGBA_S3TC_DXT1_Format as bi,
+  RGBA_ASTC_6x6_Format as bj,
+  RGBA_ASTC_4x4_Format as bk,
+  SIGNED_RG11_EAC_Format as bl,
+  RG11_EAC_Format as bm,
+  SIGNED_R11_EAC_Format as bn,
+  R11_EAC_Format as bo,
+  RGB_ETC2_Format as bp,
+  RGBA_ETC2_EAC_Format as bq,
+  RGBFormat as br,
+  RedFormat as bs,
+  UnsignedInt101111Type as bt,
+  UnsignedInt5999Type as bu,
+  UnsignedShortType as bv,
+  RGB_PVRTC_4BPPV1_Format as bw,
+  RGB_ETC1_Format as bx,
+  RGB_BPTC_UNSIGNED_Format as by,
+  normalizeLayerOffset as bz,
+  OrthographicCamera as c,
+  RawShaderMaterial as d,
+  DataTexture as e,
+  RGIntegerFormat as f,
+  ShaderMaterial as g,
+  Data3DTexture as h,
+  Vector4 as i,
+  Box3 as j,
+  Matrix3$1 as k,
+  BufferAttribute as l,
+  InstancedBufferAttribute as m,
+  DynamicDrawUsage as n,
+  FileLoader as o,
+  DoubleSide as p,
+  Clock as q,
+  WebGLRenderTarget as r,
+  SRGBColorSpace as s,
+  UnsignedByteType as t,
+  RGBAFormat as u,
+  WebGLCubeRenderTarget as v,
+  LinearSRGBColorSpace as w,
+  LinearFilter as x,
+  LinearMipMapLinearFilter as y,
+  CubeCamera as z
 };