react-native-cesium 1.2.10 → 1.2.12

package/cpp/engine/CesiumEngine.cpp

@@ -4,6 +4,7 @@
 #endif
 
 #include "CesiumEngine.hpp"
+#include "GeoidConverter.hpp"
 
 
 #include <Cesium3DTilesContent/registerAllTileContentTypes.h>
@@ -608,10 +609,26 @@ void CesiumEngine::updateFrame(double w, double h, FrameResult& result) {
   const CameraParams camParams  = trackTerrainFloor ? camera_.getParams() : CameraParams{};
   const double camLatRad = glm::radians(camParams.latitude);
   const double camLonRad = glm::radians(camParams.longitude);
+  
+  // Expected ground ellipsoid height at camera location (from geoid).
+  // Used to filter out elevated structures (buildings) during floor sampling.
+  const double expectedGroundEllipsoid = trackTerrainFloor
+      ? mslToEllipsoidMeters(camParams.latitude, camParams.longitude, 0.0)
+      : 0.0;
+  
   float  bestTerrainFloor = terrainFloorEllipsoidM_; // carry previous value if no tile matches
   double bestHorizDistSq  = std::numeric_limits<double>::max();
   bool   floorScanFound   = false;
 
+  // Horizontal search radius for floor sampling.
+  constexpr double kFloorSearchRadiusM  = 50.0;
+  constexpr double kFloorSearchRadiusSq = kFloorSearchRadiusM * kFloorSearchRadiusM;
+  // Only accept vertices within this tolerance of expected ground (filters out buildings).
+  constexpr double kGroundToleranceM    = 10.0;
+  // 3D fallback: if no ground-level vertices found, use closest 3D vertex.
+  double bestDist3D       = std::numeric_limits<double>::max();
+  float  bestDist3DFloor  = 0.0f;
+
   // ── floor-scan cache lookup ─────────────────────────────────────────
   // Skip the per-vertex scan when the camera has moved less than ~10 cm in
   // both lat and lon AND the visible primitive set is unchanged (same
@@ -675,22 +692,53 @@ void CesiumEngine::updateFrame(double w, double h, FrameResult& result) {
             for (size_t vi = 0; vi < vc; ++vi) {
               const glm::dvec3 vECEF =
                   glm::dvec3(prim.localPositions[vi]) + prim.rtcCenter;
-              const glm::dvec3 delta = vECEF - cameraPos;
-              const double    de     = glm::dot(delta, floorEast);
-              const double    dn     = glm::dot(delta, floorNorth);
+              const glm::dvec3 delta  = vECEF - cameraPos;
+              const double    de      = glm::dot(delta, floorEast);
+              const double    dn      = glm::dot(delta, floorNorth);
               const double    horizSq = de * de + dn * dn;
-              if (horizSq < bestHorizDistSq) {
-                bestHorizDistSq  = horizSq;
-                bestTerrainFloor = prim.altitudes[vi];
-                floorScanFound   = true;
-              } else if (horizSq <= bestHorizDistSq * (1.0 + 1e-9) + 1e-4) {
-                bestTerrainFloor =
-                    std::min(bestTerrainFloor, prim.altitudes[vi]);
-                floorScanFound = true;
+              const float     vAlt    = prim.altitudes[vi];
+
+              // Primary: horizontal search within radius, only accept vertices near ground level.
+              // This filters out elevated structures (buildings) in urban areas.
+              if (horizSq <= kFloorSearchRadiusSq) {
+                const double heightAboveGround = static_cast<double>(vAlt) - expectedGroundEllipsoid;
+                if (heightAboveGround >= -kGroundToleranceM && 
+                    heightAboveGround <= kGroundToleranceM) {
+                  if (!floorScanFound || vAlt < bestTerrainFloor) {
+                    bestTerrainFloor = vAlt;
+                    bestHorizDistSq  = horizSq;
+                    floorScanFound   = true;
+                  }
+                }
+              }
+
+              // Fallback: track closest 3D vertex for sparse/ocean scenarios.
+              const double dist3D = glm::length(delta);
+              if (dist3D < bestDist3D) {
+                bestDist3D      = dist3D;
+                bestDist3DFloor = vAlt;
               }
             }
           }
         }
+        // Fallback: if no ground-level vertices found, use expected ground from geoid.
+        // This handles urban areas where terrain tiles only contain building structures.
+        if (!floorScanFound) {
+          if (bestDist3D < std::numeric_limits<double>::max()) {
+            // Use closest 3D vertex only if it's near ground level
+            const double heightAboveGround = static_cast<double>(bestDist3DFloor) - expectedGroundEllipsoid;
+            if (heightAboveGround >= -kGroundToleranceM && 
+                heightAboveGround <= kGroundToleranceM) {
+              bestTerrainFloor = bestDist3DFloor;
+              floorScanFound   = true;
+            }
+          }
+          // Ultimate fallback: use geoid-based ground estimate
+          if (!floorScanFound) {
+            bestTerrainFloor = static_cast<float>(expectedGroundEllipsoid);
+            floorScanFound   = true;
+          }
+        }
       }
 
       const glm::dvec3 rtcCamRel = c.rtcCenter - glm::dvec3(cameraPos);
@@ -791,16 +839,47 @@ void CesiumEngine::updateFrame(double w, double h, FrameResult& result) {
             const double    de      = glm::dot(delta, floorEast);
             const double    dn      = glm::dot(delta, floorNorth);
             const double    horizSq = de * de + dn * dn;
-            if (horizSq < bestHorizDistSq) {
-              bestHorizDistSq  = horizSq;
-              bestTerrainFloor = prim.altitudes[vi];
+            const float     vAlt    = prim.altitudes[vi];
+
+            // Primary: horizontal search within radius, only accept vertices near ground level.
+            // This filters out elevated structures (buildings) in urban areas.
+            if (horizSq <= kFloorSearchRadiusSq) {
+              const double heightAboveGround = static_cast<double>(vAlt) - expectedGroundEllipsoid;
+              if (heightAboveGround >= -kGroundToleranceM && 
+                  heightAboveGround <= kGroundToleranceM) {
+                if (!floorScanFound || vAlt < bestTerrainFloor) {
+                  bestTerrainFloor = vAlt;
+                  bestHorizDistSq  = horizSq;
+                  floorScanFound   = true;
+                }
+              }
+            }
+
+            // Fallback: track closest 3D vertex for sparse/ocean scenarios.
+            const double dist3D = glm::length(delta);
+            if (dist3D < bestDist3D) {
+              bestDist3D      = dist3D;
+              bestDist3DFloor = vAlt;
+            }
+          }
+        }
+        // Fallback: if no ground-level vertices found, use expected ground from geoid.
+        // This handles urban areas where terrain tiles only contain building structures.
+        if (!floorScanFound) {
+          if (bestDist3D < std::numeric_limits<double>::max()) {
+            // Use closest 3D vertex only if it's near ground level
+            const double heightAboveGround = static_cast<double>(bestDist3DFloor) - expectedGroundEllipsoid;
+            if (heightAboveGround >= -kGroundToleranceM && 
+                heightAboveGround <= kGroundToleranceM) {
+              bestTerrainFloor = bestDist3DFloor;
               floorScanFound   = true;
-            } else if (horizSq <= bestHorizDistSq * (1.0 + 1e-9) + 1e-4) {
-              bestTerrainFloor =
-                  std::min(bestTerrainFloor, prim.altitudes[vi]);
-              floorScanFound = true;
             }
           }
+          // Ultimate fallback: use geoid-based ground estimate
+          if (!floorScanFound) {
+            bestTerrainFloor = static_cast<float>(expectedGroundEllipsoid);
+            floorScanFound   = true;
+          }
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cesium",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "Experimental Cesium rendering for React Native via Nitro",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",