Update GCOV projection (#742)

* push GCOV projection changes from #604

* add default pixel spacing in geogrid.py if outputEPSG differs from the DEM epsg code

* revert changes to .ci/jenkins/PR-isce-develop/build.sh

* revert changes to .ci/jenkins/PR-isce-develop/build.sh (2)

* remove unnecessary comments, whitespaces, simplify code

* substitute (int) 0 by 0

* fix block reading of the input raster

* substitute C-style cast by static_cast

* substitute C-style cast by static_cast (2)

* substitute C-style cast by static_cast (3)

* Update python/packages/pybind_nisar/workflows/geogrid.py

Co-Authored-By: Liang Yu <[email protected]>

* use OSGEO OSR to test if EPSG reffers to geographic coordinates (lat/lon)

* add comment to the margin of 100 pixels used to load the DEM for geocoding the geogrid block

* substitute C-style cast with static cast

* merge develop into update_gcov_projection (2)

* fix load of DEM from the RTC module

* fix print of geogrid parameters using pyre

* rename GetDemCoordsSameEpsg() to getDemCoordsSameEpsg()

* include <functional> in order to get access to std::function

* substitute C-style cast with static_cast

* make non-public local function static

* add more comments explaining use of getDemCoords()

* add comments about cropping indexes between min X, Y and max X, Y

* pass std::function by const reference

* run "git-clang-format develop"

Co-authored-by: Liang Yu <[email protected]>

Author: 2 people

cxx/isce3/core/DenseMatrix.h

@@ -5,6 +5,7 @@
 #include <cmath>
 #define EIGEN_MPL2_ONLY
 #include <Eigen/Dense>
+
 #include "Common.h"
 #include "Vector.h"
 
@@ -16,16 +17,19 @@ class DenseMatrix : public Eigen::Matrix<T, N, N> {
     using super_t::super_t;
 
     static_assert(N > 0);
+
 public:
     DenseMatrix() = default;
     CUDA_HOSTDEV auto operator[](int i)       { return this->row(i); }
     CUDA_HOSTDEV auto operator[](int i) const { return this->row(i); }
 
-    CUDA_HOSTDEV auto dot(const DenseMatrix& other) const {
+    CUDA_HOSTDEV auto dot(const DenseMatrix& other) const
+    {
         return *this * other;
     }
 
-    CUDA_HOSTDEV auto dot(const Vector<N, T>& other) const {
+    CUDA_HOSTDEV auto dot(const Vector<N, T>& other) const
+    {
         return *this * other;
     }
 
@@ -87,8 +91,8 @@ CUDA_HOSTDEV Mat3 DenseMatrix<N, T>::enuToXyz(double lat, double lon)
 // multiplication produced incorrect results (or raised "illegal memory access"
 // errors in debug mode).
 template<int N, typename T>
-CUDA_HOSTDEV auto
-operator*(const DenseMatrix<N, T>& a, const DenseMatrix<N, T>& b)
+CUDA_HOSTDEV auto operator*(
+        const DenseMatrix<N, T>& a, const DenseMatrix<N, T>& b)
 {
     DenseMatrix<N, T> out;
     for (int i = 0; i < N; ++i) {
@@ -100,8 +104,7 @@ operator*(const DenseMatrix<N, T>& a, const DenseMatrix<N, T>& b)
 }
 
 template<int N, typename T>
-CUDA_HOSTDEV auto
-operator*(const DenseMatrix<N, T>& m, const Vector<N, T>& v)
+CUDA_HOSTDEV auto operator*(const DenseMatrix<N, T>& m, const Vector<N, T>& v)
 {
     Vector<N, T> out;
     for (int i = 0; i < N; ++i) {

cxx/isce3/cuda/core/InterpolatorHandle.cu

@@ -1,42 +1,39 @@
-#include "InterpolatorHandle.h"
+#include <cuda_runtime.h>
+#include <thrust/complex.h>
+#include <thrust/device_vector.h>
+
+#include <pyre/journal.h>
 
 #include <isce3/cuda/except/Error.h>
 #include <isce3/except/Error.h>
 
-#include <pyre/journal.h>
-
-#include <cuda_runtime.h>
-#include <thrust/complex.h>
-#include <thrust/device_vector.h>
+#include "InterpolatorHandle.h"
 
 template<class T>
 using DeviceInterp = isce3::cuda::core::gpuInterpolator<T>;
 
 namespace isce3::cuda::core {
 
 template<class T>
-__global__ void init_interp(
-        DeviceInterp<T>** interp, isce3::core::dataInterpMethod interp_method,
-        bool * unsupported_interp)
+__global__ void init_interp(DeviceInterp<T>** interp,
+        isce3::core::dataInterpMethod interp_method, bool* unsupported_interp)
 {
     if (threadIdx.x == 0 && blockIdx.x == 0) {
         // Choose interpolator
-        switch(interp_method) {
-            case isce3::core::BILINEAR_METHOD:
-                (*interp) = new isce3::cuda::core::gpuBilinearInterpolator<T>();
-                break;
-            case isce3::core::BICUBIC_METHOD:
-                (*interp) = new isce3::cuda::core::gpuBicubicInterpolator<T>();
-                break;
-            case isce3::core::BIQUINTIC_METHOD:
-                {
-                size_t order = 6;
-                (*interp) = new isce3::cuda::core::gpuSpline2dInterpolator<T>(order);
-                break;
-                }
-            default:
-                *unsupported_interp = true;
-                break;
+        switch (interp_method) {
+        case isce3::core::BILINEAR_METHOD:
+            (*interp) = new isce3::cuda::core::gpuBilinearInterpolator<T>();
+            break;
+        case isce3::core::BICUBIC_METHOD:
+            (*interp) = new isce3::cuda::core::gpuBicubicInterpolator<T>();
+            break;
+        case isce3::core::BIQUINTIC_METHOD: {
+            size_t order = 6;
+            (*interp) =
+                    new isce3::cuda::core::gpuSpline2dInterpolator<T>(order);
+            break;
+        }
+        default: *unsupported_interp = true; break;
         }
     }
 }
@@ -56,19 +53,19 @@ InterpolatorHandle<T>::InterpolatorHandle(
     checkCudaErrors(cudaMalloc(&_interp, sizeof(DeviceInterp<T>**)));
 
     thrust::device_vector<bool> d_unsupported_interp(1, false);
-    init_interp<<<1, 1>>>(_interp, interp_method, d_unsupported_interp.data().get());
+    init_interp<<<1, 1>>>(
+            _interp, interp_method, d_unsupported_interp.data().get());
     checkCudaErrors(cudaPeekAtLastError());
     checkCudaErrors(cudaDeviceSynchronize());
 
     bool unsupported_interp = d_unsupported_interp[0];
-    if (unsupported_interp)
-    {
+    if (unsupported_interp) {
         pyre::journal::error_t error(
                 "isce.cuda.core.InterpolatorHandle.InterpolatorHandle");
         error << "Unsupported interpolator method provided."
               << pyre::journal::endl;
-        throw isce3::except::InvalidArgument(ISCE_SRCINFO(),
-                                         "Unsupported interpolator method provided.");
+        throw isce3::except::InvalidArgument(
+                ISCE_SRCINFO(), "Unsupported interpolator method provided.");
     }
 }
 

cxx/isce3/cuda/core/ProjectionBaseHandle.cu

@@ -1,19 +1,19 @@
-#include "ProjectionBaseHandle.h"
+#include <cuda_runtime.h>
+#include <thrust/device_vector.h>
+
+#include <pyre/journal.h>
 
 #include <isce3/cuda/except/Error.h>
 #include <isce3/except/Error.h>
 
-#include <pyre/journal.h>
-
-#include <cuda_runtime.h>
-#include <thrust/device_vector.h>
+#include "ProjectionBaseHandle.h"
 
 namespace isce3::cuda::core {
 
 using isce3::cuda::core::ProjectionBase;
 
-__global__ void init_proj(ProjectionBase** proj, int epsg_code,
-                          bool * proj_invalid)
+__global__ void init_proj(
+        ProjectionBase** proj, int epsg_code, bool* proj_invalid)
 {
 
     if (threadIdx.x == 0 && blockIdx.x == 0) {
@@ -41,14 +41,12 @@ ProjectionBaseHandle::ProjectionBaseHandle(int epsg)
     checkCudaErrors(cudaDeviceSynchronize());
 
     bool proj_invalid = d_proj_invalid[0];
-    if (proj_invalid)
-    {
+    if (proj_invalid) {
         pyre::journal::error_t error(
                 "isce.cuda.core.ProjectionBaseHandle.ProjectionBaseHandle");
-        error << "Unsupported EPSG provided."
-              << pyre::journal::endl;
-        throw isce3::except::InvalidArgument(ISCE_SRCINFO(),
-                                         "Unsupported ESPG provided.");
+        error << "Unsupported EPSG provided." << pyre::journal::endl;
+        throw isce3::except::InvalidArgument(
+                ISCE_SRCINFO(), "Unsupported ESPG provided.");
     }
 }
 

cxx/isce3/cuda/focus/Backproject.h

@@ -3,21 +3,21 @@
 #include <isce3/container/forward.h>
 #include <isce3/cuda/container/forward.h>
 #include <isce3/cuda/geometry/forward.h>
-#include <isce3/geometry/detail/Geo2Rdr.h>
-#include <isce3/geometry/detail/Rdr2Geo.h>
 #include <isce3/geometry/forward.h>
 
 #include <complex>
 
 #include <isce3/core/Kernels.h>
 #include <isce3/focus/Backproject.h>
 #include <isce3/focus/DryTroposphereModel.h>
+#include <isce3/geometry/detail/Geo2Rdr.h>
+#include <isce3/geometry/detail/Rdr2Geo.h>
 
 namespace isce3 { namespace cuda { namespace focus {
 
+using isce3::focus::DryTroposphereModel;
 using isce3::geometry::detail::Geo2RdrParams;
 using isce3::geometry::detail::Rdr2GeoParams;
-using isce3::focus::DryTroposphereModel;
 
 /**
  * Focus in azimuth via time-domain backprojection