Update metadata cubes: elevation angle and LOS unit vector (#711)

* change direction of the LOS vector and update unitest

* update calculation of elevation angle from geocentric to geodedic

* compute LOS unit vector around target

* update evaluation of LOS unit vector around target and update sat_position_error_threshold

Author: gshiroma

cxx/isce3/geometry/metadataCubes.cpp

@@ -105,12 +105,21 @@ static inline void writeVectorDerivedCubes(const int array_pos_i,
 
     // Compute elevation angle calculated in ECEF (geocentric)
     if (elevation_angle_raster != nullptr) {
-        const double cos_elevation =
-                sat_xyz.dot(look_vector_xyz) / sat_xyz.norm();
+
+        // Get platform position in llh (sat_llh)
+        const isce3::core::Vec3 sat_llh = ellipsoid.xyzToLonLat(sat_xyz);
+
+        // Get target-to-sat vector in ENU around the platform
+        const isce3::core::Mat3 xyz2enu_sat =
+                isce3::core::Mat3::xyzToEnu(sat_llh[1], sat_llh[0]);
+        const isce3::core::Vec3 look_vector_enu_sat =
+                xyz2enu_sat.dot(look_vector_xyz).normalized();
+        const double cos_elevation = look_vector_enu_sat[2];
         elevation_angle_array(i, j) = std::acos(cos_elevation) * 180.0 / M_PI;
+
     }
 
-    // Get target-to-sat vector in ENU (local)
+    // Get target-to-sat vector in ENU around the target
     const isce3::core::Mat3 xyz2enu =
             isce3::core::Mat3::xyzToEnu(target_llh[1], target_llh[0]);
     const isce3::core::Vec3 look_vector_enu =
@@ -158,16 +167,15 @@ static inline void writeVectorDerivedCubes(const int array_pos_i,
 
     } else {
 
-        /*
-        Get platform position in llh (sat_llh) and in output proj
-        coordinates (sat_proj)
-        */
-        const isce3::core::Vec3 sat_llh = ellipsoid.xyzToLonLat(sat_xyz);
-        isce3::core::Vec3 sat_proj = proj->forward(sat_llh);
-
-        // Compute target-to-sat vector (proj)
+        // Compute target-to-sat vector (proj) around the target
+        const isce3::core::Vec3 target_to_sat_next_xyz = 
+            target_xyz + look_vector_xyz;
+        const isce3::core::Vec3 target_to_sat_next_llh = 
+            ellipsoid.xyzToLonLat(target_to_sat_next_xyz);
+        isce3::core::Vec3 target_to_sat_next_proj = 
+            proj->forward(target_to_sat_next_llh);
         const isce3::core::Vec3 look_vector_proj =
-                (sat_proj - target_proj).normalized();
+                (target_to_sat_next_proj - target_proj).normalized();
 
         // LOS unit vector X (proj)
         if (los_unit_vector_x_raster != nullptr) {

tests/cxx/isce3/geometry/metadata_cubes/metadata_cubes.cpp

@@ -71,12 +71,12 @@ void _check_vectors(const isce3::product::GeoGridParameters& geogrid,
     if (geogrid.epsg() == 4326) {
         slant_range_error_threshold = 1e-16;
         incidence_angle_error_threshold = 1e-5;
-        sat_position_error_threshold = 1e-7;
+        sat_position_error_threshold = 1e-3;
         vel_unit_error_threshold = 1e-3;
     } else {
         slant_range_error_threshold = 1e-16;
         incidence_angle_error_threshold = 1e-5;
-        sat_position_error_threshold = 1e-5;
+        sat_position_error_threshold = 1e-3;
         vel_unit_error_threshold = 1e-3;
     }
 
@@ -144,33 +144,34 @@ void _check_vectors(const isce3::product::GeoGridParameters& geogrid,
                                           std::pow(los_unit_test[1], 2)));
 
             // 3. Estimate platform position
-            isce3::core::Vec3 sat_xyz_test, sat_llh_test;
+            isce3::core::Vec3 sat_xyz_test, sat_llh_test, los_xyz_test;
             if (proj->code() == 4326) {
                 // For epsg == 4326, vectors are given in ENU
-                const isce3::core::Vec3 los_xyz_test =
+                los_xyz_test =
                         enu2xyz.dot(los_unit_test).normalized();
                 sat_xyz_test = target_xyz + slant_range_test * los_xyz_test;
 
             } else {
-                const isce3::core::Vec3 look_vector_test =
-                        slant_range_test * los_unit_test;
-                const isce3::core::Vec3 sat_proj_test =
-                        target_proj + look_vector_test;
-                sat_llh_test = proj->inverse(sat_proj_test);
-                sat_xyz_test = ellipsoid.lonLatToXyz(sat_llh_test);
+                const isce3::core::Vec3 target_to_sat_next_proj =
+                        target_proj + los_unit_test;
+                const isce3::core::Vec3 target_to_sat_next_llh = 
+                        proj->inverse(target_to_sat_next_proj);
+                const isce3::core::Vec3 target_to_sat_next_xyz = 
+                        ellipsoid.lonLatToXyz(target_to_sat_next_llh);
+                los_xyz_test = 
+                        (target_to_sat_next_xyz - target_xyz).normalized();
+                sat_xyz_test = target_xyz + slant_range_test * los_xyz_test;
             }
 
-            /* 3. Evaluate platform position from LOS vector and slant-range
+            /* 
+            3. Evaluate platform position from LOS vector and slant-range
             distance extracted from metadata cubes (errors are multiplied).
-            Absolute values are large, therefore they are normalized
-            for comparison */
-            double error_norm = std::sqrt(std::pow(sat_xyz_test.norm(), 2) +
-                                          std::pow(sat_xyz.norm(), 2));
-            ASSERT_NEAR(sat_xyz_test[0] / error_norm, sat_xyz[0] / error_norm,
+            */
+            ASSERT_NEAR(sat_xyz_test[0], sat_xyz[0],
                         sat_position_error_threshold);
-            ASSERT_NEAR(sat_xyz_test[1] / error_norm, sat_xyz[1] / error_norm,
+            ASSERT_NEAR(sat_xyz_test[1], sat_xyz[1],
                         sat_position_error_threshold);
-            ASSERT_NEAR(sat_xyz_test[2] / error_norm, sat_xyz[2] / error_norm,
+            ASSERT_NEAR(sat_xyz_test[2], sat_xyz[2],
                         sat_position_error_threshold);
 
             // 4. Estimate velocity from cube along-track vector