Replace direct imports from 'pybind_isce3' with 'isce3' (#887)

A number of scripts in the 'nisar' package were directly importing from
the 'pybind_isce3' package instead of the wrapper 'isce3' package. This
update redirects these imports to use the python wrapper (since
'pybind_isce3' is intended to just be used internally by isce3 as an
interface with the C++ library).

This update also exposes the 'isce3.cuda.matchtemplate' submodule,
which had previously only been exposed in 'pybind_isce3'.

Author: gmgunter

python/packages/isce3/cuda/__init__.py

@@ -4,3 +4,4 @@
 from . import geometry
 from . import image
 from . import signal
+from . import matchtemplate

python/packages/isce3/cuda/matchtemplate/__init__.py

@@ -0,0 +1 @@
+from pybind_isce3.cuda.matchtemplate import *

python/packages/nisar/products/readers/Base/Base.py

@@ -4,7 +4,7 @@
 import os
 import journal
 import pyre
-import pybind_isce3 as isce3
+import isce3
 from ..protocols import ProductReader
 
 

python/packages/nisar/products/readers/Base/Identification.py

@@ -52,7 +52,7 @@ def unpack(self, h5grp):
         Populate self with hdf5 group.
         '''
         from nisar.h5 import extractScalar, bytestring, extractWithIterator
-        import pybind_isce3 as isce3
+        import isce3
 
         self.missionId = extractScalar(h5grp, 'missionId', 
                                       bytestring, self.context['info'],

python/packages/nisar/products/readers/Raw/Raw.py

@@ -6,7 +6,7 @@
 import numpy as np
 import pyre
 import journal
-import pybind_isce3 as isce
+import isce3
 import re
 
 # TODO some CSV logger
@@ -126,7 +126,7 @@ def getChirpParameters(self, frequency: str = 'A', tx: str = 'H'):
             T = group["chirpDuration"][()]
             K = group["chirpSlope"][()]
             dr = group["slantRangeSpacing"][()]
-        fs = isce.core.speed_of_light / (2 * dr)
+        fs = isce3.core.speed_of_light / (2 * dr)
         fc = self.getCenterFrequency(frequency, tx)
         return fc, fs, K, T
 
@@ -139,13 +139,13 @@ def TelemetryPath(self):
     def getOrbit(self):
         path = f"{self.TelemetryPath}/orbit"
         with h5py.File(self.filename, 'r', libver='latest', swmr=True) as f:
-            orbit = isce.core.Orbit.load_from_h5(f[path])
+            orbit = isce3.core.Orbit.load_from_h5(f[path])
         return orbit
 
     def getAttitude(self):
         path = f"{self.TelemetryPath}/attitude"
         with h5py.File(self.filename, 'r', libver='latest', swmr=True) as f:
-            q = isce.core.Attitude.load_from_h5(f[path])
+            q = isce3.core.Attitude.load_from_h5(f[path])
         return q
 
     def getRanges(self, frequency='A', tx='H'):
@@ -155,7 +155,7 @@ def getRanges(self, frequency='A', tx='H'):
             r = np.asarray(group["slantRange"])
             dr = group["slantRangeSpacing"][()]
         nr = len(r)
-        out = isce.core.Linspace(r[0], dr, nr)
+        out = isce3.core.Linspace(r[0], dr, nr)
         assert np.isclose(out[-1], r[-1])
         return out
 
@@ -186,7 +186,7 @@ def getPulseTimes(self, frequency='A', tx='H'):
             # FIXME product spec changed UTCTime -> UTCtime
             name = find_case_insensitive(f[txpath], "UTCtime")
             t = np.asarray(f[txpath][name])
-            epoch = isce.io.get_ref_epoch(f[txpath], name)
+            epoch = isce3.io.get_ref_epoch(f[txpath], name)
         return epoch, t
 
 
@@ -202,7 +202,7 @@ def getCenterFrequency(self, frequency: str = 'A', tx: str = None):
     # since PRF isn't necessarily constant.  Return pulse times with grid?
     def getRadarGrid(self, frequency='A', tx='H', prf=None):
         fc = self.getCenterFrequency(frequency, tx)
-        wvl = isce.core.speed_of_light / fc
+        wvl = isce3.core.speed_of_light / fc
         r = self.getRanges(frequency, tx)
         epoch, t = self.getPulseTimes(frequency, tx)
         nt = len(t)
@@ -212,7 +212,7 @@ def getRadarGrid(self, frequency='A', tx='H', prf=None):
         else:
             prf = (nt - 1) / (t[-1] - t[0])
         side = self.identification.lookDirection
-        grid = isce.product.RadarGridParameters(
+        grid = isce3.product.RadarGridParameters(
             t[0], wvl, prf, r[0], r.spacing, side, nt, len(r), epoch)
         return t, grid
 

python/packages/nisar/products/readers/antenna/antenna_parser.py

@@ -5,7 +5,7 @@
 import collections as cl
 import numpy as np
 
-from pybind_isce3 import antenna as ant
+from isce3 import antenna as ant
 
 
 class AntennaParser:

python/packages/nisar/products/writers/SLC.py

@@ -4,9 +4,9 @@
 from numpy.testing import assert_allclose
 import os
 import isce3
-from pybind_isce3.core import LUT2d, DateTime, Orbit, Attitude, EulerAngles
-from pybind_isce3.product import RadarGridParameters
-from pybind_isce3.geometry import DEMInterpolator
+from isce3.core import LUT2d, DateTime, Orbit, Attitude, EulerAngles
+from isce3.product import RadarGridParameters
+from isce3.geometry import DEMInterpolator
 from nisar.h5 import set_string
 from nisar.types import complex32
 from nisar.products.readers.Raw import Raw

python/packages/nisar/workflows/crossmul.py

@@ -8,7 +8,7 @@
 
 import h5py
 import journal
-import pybind_isce3 as isce3
+import isce3
 from nisar.products.readers import SLC
 from nisar.workflows import gpu_check, h5_prep
 from nisar.workflows.crossmul_runconfig import CrossmulRunConfig

python/packages/nisar/workflows/dense_offsets.py

@@ -7,7 +7,7 @@
 
 import journal
 import numpy as np
-import pybind_isce3 as isce3
+import isce3
 from osgeo import gdal
 from nisar.products.readers import SLC
 from nisar.workflows import gpu_check, h5_prep

python/packages/nisar/workflows/focus.py

@@ -8,9 +8,9 @@
 from nisar.types import to_complex32
 from nisar.workflows import gpu_check
 import numpy as np
-import pybind_isce3 as isce
-from pybind_isce3.core import DateTime, LUT2d
-from pybind_isce3.io.gdal import Raster, GDT_CFloat32
+import isce3
+from isce3.core import DateTime, LUT2d
+from isce3.io.gdal import Raster, GDT_CFloat32
 from nisar.workflows.yaml_argparse import YamlArgparse
 import nisar.workflows.helpers as helpers
 from ruamel.yaml import YAML
@@ -100,9 +100,9 @@ def get_chirp(cfg: Struct, raw: Raw, frequency: str, tx: str):
 
 
 def parse_rangecomp_mode(mode: str):
-    lut = {"full": isce.focus.RangeComp.Mode.Full,
-           "same": isce.focus.RangeComp.Mode.Same,
-           "valid": isce.focus.RangeComp.Mode.Valid}
+    lut = {"full": isce3.focus.RangeComp.Mode.Full,
+           "same": isce3.focus.RangeComp.Mode.Same,
+           "valid": isce3.focus.RangeComp.Mode.Valid}
     mode = mode.lower()
     if mode not in lut:
         raise ValueError(f"Invalid RangeComp mode {mode}")
@@ -140,8 +140,8 @@ def get_total_grid_bounds(rawfiles: List[str], frequency='A'):
         times.append(raw.getPulseTimes(frequency, tx=pol[0]))
     rmin = min(r[0] for r in ranges)
     rmax = max(r[-1] for r in ranges)
-    dtmin = min(epoch + isce.core.TimeDelta(t[0]) for (epoch, t) in times)
-    dtmax = max(epoch + isce.core.TimeDelta(t[-1]) for (epoch, t) in times)
+    dtmin = min(epoch + isce3.core.TimeDelta(t[0]) for (epoch, t) in times)
+    dtmax = max(epoch + isce3.core.TimeDelta(t[-1]) for (epoch, t) in times)
     epoch = min(epoch for (epoch, t) in times)
     tmin = (dtmin - epoch).total_seconds()
     tmax = (dtmax - epoch).total_seconds()
@@ -152,8 +152,8 @@ def get_total_grid(rawfiles: List[str], dt, dr, frequency='A'):
     epoch, tmin, tmax, rmin, rmax = get_total_grid_bounds(rawfiles, frequency)
     nt = int(np.ceil((tmax - tmin) / dt))
     nr = int(np.ceil((rmax - rmin) / dr))
-    t = isce.core.Linspace(tmin, dt, nt)
-    r = isce.core.Linspace(rmin, dr, nr)
+    t = isce3.core.Linspace(tmin, dt, nt)
+    r = isce3.core.Linspace(rmin, dr, nr)
     return epoch, t, r
 
 
@@ -172,11 +172,11 @@ def squint(t, r, orbit, attitude, side, angle=0.0, dem=None, **kw):
                          f"inferred side={inferred_side} based on orientation "
                          f"(Y_RCS.dot(V) = {axis.dot(v)})")
     if dem is None:
-        dem = isce.geometry.DEMInterpolator()
+        dem = isce3.geometry.DEMInterpolator()
     # NOTE Here "left" means an acute, positive look angle by right-handed
     # rotation about `axis`.  Since axis will flip sign, always use "left" to
     # get the requested side in the sense of velocity vector.
-    xyz = isce.geometry.rdr2geo_cone(p, axis, angle, r, dem, "left", **kw)
+    xyz = isce3.geometry.rdr2geo_cone(p, axis, angle, r, dem, "left", **kw)
     look = (xyz - p) / np.linalg.norm(xyz - p)
     vhat = v / np.linalg.norm(v)
     return np.arcsin(look.dot(vhat))
@@ -187,12 +187,12 @@ def squint_to_doppler(squint, wvl, vmag):
 
 
 def convert_epoch(t: List[float], epoch_in, epoch_out):
-    TD = isce.core.TimeDelta
+    TD = isce3.core.TimeDelta
     return [(epoch_in - epoch_out + TD(ti)).total_seconds() for ti in t]
 
 
 def get_dem(cfg: Struct):
-    dem = isce.geometry.DEMInterpolator(
+    dem = isce3.geometry.DEMInterpolator(
         height=cfg.processing.dem.reference_height,
         method=cfg.processing.dem.interp_method)
     fn = cfg.DynamicAncillaryFileGroup.DEMFile
@@ -206,9 +206,9 @@ def get_dem(cfg: Struct):
 
 def make_doppler_lut(rawfiles: List[str],
         az: float = 0.0,
-        orbit: isce.core.Orbit = None,
-        attitude: isce.core.Attitude = None,
-        dem: isce.geometry.DEMInterpolator = None,
+        orbit: isce3.core.Orbit = None,
+        attitude: isce3.core.Attitude = None,
+        dem: isce3.geometry.DEMInterpolator = None,
         azimuth_spacing: float = 1.0,
         range_spacing: float = 1e3,
         frequency: str = "A",
@@ -259,13 +259,13 @@ def make_doppler_lut(rawfiles: List[str],
     if attitude is None:
         attitude = raw.getAttitude()
     if dem is None:
-        dem = isce.geometry.DEMInterpolator()
+        dem = isce3.geometry.DEMInterpolator()
     # Assume look side and center frequency constant across files.
     side = raw.identification.lookDirection
     fc = raw.getCenterFrequency(frequency)
 
     # Now do the actual calculations.
-    wvl = isce.core.speed_of_light / fc
+    wvl = isce3.core.speed_of_light / fc
     epoch, t, r = get_total_grid(rawfiles, azimuth_spacing, range_spacing)
     t = convert_epoch(t, epoch, orbit.reference_epoch)
     dop = np.zeros((len(t), len(r)))
@@ -349,9 +349,9 @@ def make_output_grid(cfg: Struct, igrid):
     nr = int(np.round((r1 - r0) / dr))
     nt = int(np.round((t1 - t0) * prf))
     assert (nr > 0) and (nt > 0)
-    ogrid = isce.product.RadarGridParameters(t0, igrid.wavelength, prf, r0,
-                                             dr, igrid.lookside, nt, nr,
-                                             igrid.ref_epoch)
+    ogrid = isce3.product.RadarGridParameters(t0, igrid.wavelength, prf, r0,
+                                              dr, igrid.lookside, nt, nr,
+                                              igrid.ref_epoch)
     return ogrid
 
 
@@ -362,9 +362,9 @@ def get_kernel(cfg: Struct):
     if opt.type.lower() != 'knab':
         raise NotImplementedError("Only Knab kernel implemented.")
     n = 1 + 2 * opt.halfwidth
-    kernel = isce.core.KnabKernel(n, 1 / 1.2)
+    kernel = isce3.core.KnabKernel(n, 1 / 1.2)
     assert opt.fit.lower() == "table"
-    table = isce.core.TabulatedKernelF32(kernel, opt.fit_order)
+    table = isce3.core.TabulatedKernelF32(kernel, opt.fit_order)
     return table
 
 
@@ -380,8 +380,8 @@ def verify_uniform_pri(t: np.ndarray, atol=0.0, rtol=0.001):
 
 
 def resample(raw: np.ndarray, t: np.ndarray,
-             grid: isce.product.RadarGridParameters, swaths: np.ndarray,
-             orbit: isce.core.Orbit, doppler: isce.core.LUT2d, L=12.0,
+             grid: isce3.product.RadarGridParameters, swaths: np.ndarray,
+             orbit: isce3.core.Orbit, doppler: isce3.core.LUT2d, L=12.0,
              fn="regridded.c8"):
     """
     Fill gaps and resample raw data to uniform grid using BLU method.
@@ -425,10 +425,10 @@ def resample(raw: np.ndarray, t: np.ndarray,
         # Get velocity for scaling autocorrelation function.  Won't change much
         # but update every pulse to avoid artifacts across images.
         v = np.linalg.norm(orbit.interpolate(tout)[1])
-        acor = isce.core.AzimuthKernel(L / v)
+        acor = isce3.core.AzimuthKernel(L / v)
         # Figure out what pulses are in play by computing weights without mask.
         # TODO All we really need is offset and len(weights)... maybe refactor.
-        offset, weights = isce.focus.get_presum_weights(acor, t, tout)
+        offset, weights = isce3.focus.get_presum_weights(acor, t, tout)
         nw = len(weights)
         # Compute valid data mask (transposed).
         # NOTE Could store the whole mask instead of recomputing blocks.
@@ -451,14 +451,14 @@ def resample(raw: np.ndarray, t: np.ndarray,
             valid = (uid & twiddle).astype(bool)
             # Pull out valid times for this mask config and compute weights.
             tj = t[offset:offset+nw][valid]
-            joff, jwgt = isce.focus.get_presum_weights(acor, tj, tout)
+            joff, jwgt = isce3.focus.get_presum_weights(acor, tj, tout)
             assert joff == 0
             # Now insert zeros where data is invalid to get full-length weights.
             jwgt_full = np.zeros_like(weights)
             jwgt_full[valid] = jwgt
             lut[uid] = jwgt_full
         # Fill weights for entire block using look up table.
-        w = isce.focus.fill_weights(ids, lut)
+        w = isce3.focus.fill_weights(ids, lut)
         # Read raw data.
         block = np.s_[offset:offset+nw, :]
         x = raw[block]
@@ -479,7 +479,7 @@ def delete_safely(filename):
         pass
 
 
-def get_range_deramp(grid: isce.product.RadarGridParameters) -> np.ndarray:
+def get_range_deramp(grid: isce3.product.RadarGridParameters) -> np.ndarray:
     """Compute the phase ramp required to shift a backprojected grid to
     baseband in range.
     """
@@ -502,7 +502,7 @@ def focus(runconfig):
     orbit = get_orbit(cfg)
     attitude = get_attitude(cfg)
     fc_ref, dop_ref = make_doppler(cfg)
-    zerodop = isce.core.LUT2d()
+    zerodop = isce3.core.LUT2d()
     azres = cfg.processing.azcomp.azimuth_resolution
     atmos = cfg.processing.dry_troposphere_model or "nodelay"
     kernel = get_kernel(cfg)
@@ -519,14 +519,14 @@ def focus(runconfig):
     use_gpu = gpu_check.use_gpu(cfg.worker.gpu_enabled, cfg.worker.gpu_id)
     if use_gpu:
         # Set the current CUDA device.
-        device = isce.cuda.core.Device(cfg.worker.gpu_id)
-        isce.cuda.core.set_device(device)
+        device = isce3.cuda.core.Device(cfg.worker.gpu_id)
+        isce3.cuda.core.set_device(device)
 
         log.info(f"Processing using CUDA device {device.id} ({device.name})")
 
-        backproject = isce.cuda.focus.backproject
+        backproject = isce3.cuda.focus.backproject
     else:
-        backproject = isce.focus.backproject
+        backproject = isce3.focus.backproject
 
     # Generate reference output grid based on highest bandwidth, always A.
     log.info(f"Available polarizations: {raw.polarizations}")
@@ -548,8 +548,8 @@ def focus(runconfig):
         ogrid["B"] = ogrid["A"][:, ::rskip]
         log.info("Output grid B is %s", ogrid["B"])
 
-    polygon = isce.geometry.get_geo_perimeter_wkt(ogrid["A"], orbit,
-                                                  zerodop, dem)
+    polygon = isce3.geometry.get_geo_perimeter_wkt(ogrid["A"], orbit,
+                                                   zerodop, dem)
 
     output_slc_path = os.path.abspath(cfg.ProductPathGroup.SASOutputFile)
 
@@ -639,15 +639,15 @@ def temp(suffix):
 
         rcmode = parse_rangecomp_mode(cfg.processing.rangecomp.mode)
         log.info(f"Preparing range compressor with {rcmode}")
-        rc = isce.focus.RangeComp(chirp, nr, maxbatch=na, mode=rcmode)
+        rc = isce3.focus.RangeComp(chirp, nr, maxbatch=na, mode=rcmode)
 
         # Rangecomp modifies range grid.  Also update wavelength.
         rc_grid = raw_grid.copy()
         rc_grid.starting_range -= (
             rc_grid.range_pixel_spacing * rc.first_valid_sample)
         rc_grid.width = rc.output_size
-        rc_grid.wavelength = isce.core.speed_of_light / fc
-        igeom = isce.container.RadarGeometry(rc_grid, orbit, dop[frequency])
+        rc_grid.wavelength = isce3.core.speed_of_light / fc
+        igeom = isce3.container.RadarGeometry(rc_grid, orbit, dop[frequency])
 
         fd = temp("_rc.c8")
         log.info(f"Writing range compressed data to {fd.name}")
@@ -683,7 +683,7 @@ def temp(suffix):
                 block = np.s_[i:imax, j:jmax]
                 log.info(f"Azcomp block at (i, j) = ({i}, {j})")
                 bgrid = ogrid[frequency][block]
-                ogeom = isce.container.RadarGeometry(bgrid, orbit, zerodop)
+                ogeom = isce3.container.RadarGeometry(bgrid, orbit, zerodop)
                 z = np.zeros(bgrid.shape, 'c8')
                 backproject(z, ogeom, rcfile.data, igeom, dem, fc, azres,
                             kernel, atmos, vars(cfg.processing.azcomp.rdr2geo),