Expose sensing start/end times and starting/ending ranges in the STATIC runconfig

python/packages/isce3/geometry/bounding_radar_grid.py

@@ -303,6 +303,11 @@ def get_bounding_radar_grid(
         Azimuth time spacing of the output grid, in seconds. Must be > 0.
     rg_spacing : float
         Slant range spacing of the output grid, in meters. Must be > 0.
+    sensing_start : float
+        The sensing start time of the input `geo_grid`, in seconds since the epoch of
+        `orbit`.
+    starting_range : float
+        The starting slant range of the input `geo_grid`, in meters.
     orbit : isce3.core.Orbit
         The trajectory of the radar antenna phase center over a time interval that
         includes the observation times of each point in `geo_grid` at each height

python/packages/nisar/workflows/static.py

@@ -32,7 +32,7 @@
 
 import isce3
 from isce3.geometry import make_geo_grid_bounding_polygon, load_dem_from_proj
-from isce3.core import normalize_data_interp_method
+from isce3.core import normalize_look_side, normalize_data_interp_method
 
 
 def run_static_layers_workflow(config_file: os.PathLike | str) -> None:
@@ -117,6 +117,7 @@ def run_static_layers_workflow(config_file: os.PathLike | str) -> None:
     radar_grid_spacing_params = radar_grid_params["spacing"]
     az_spacing = radar_grid_spacing_params["az_spacing"]
     rg_spacing = radar_grid_spacing_params["rg_spacing"]
+
     pts_per_side = radar_grid_spacing_params["pts_per_side"]
 
     if az_spacing is not None and not (az_spacing > 0.0):
@@ -125,12 +126,61 @@ def run_static_layers_workflow(config_file: os.PathLike | str) -> None:
     if rg_spacing is not None and not (rg_spacing > 0.0):
         raise ValueError(f"Runconfig {rg_spacing=}, must be > 0")
 
-    logger.info("Estimate radar grid spacing")
+    bounding_box_params = radar_grid_params["bounding_box"]
+    start_datetime_str = bounding_box_params["start_time"]
+    end_datetime_str = bounding_box_params["end_time"]
+    start_range = bounding_box_params["start_range"]
+    end_range = bounding_box_params["end_range"]
+    min_height = bounding_box_params["min_height"]
+    max_height = bounding_box_params["max_height"]
+    pts_per_edge = bounding_box_params["pts_per_edge"]
+    az_margin = bounding_box_params["az_margin"]
+    rg_margin = bounding_box_params["rg_margin"]
+
+    start_time = None
+    end_time = None
+
+    # Print user radar grid bounding box parameters, if provided.
+    if (start_datetime_str is not None or start_range is not None or
+            end_datetime_str is not None or end_range is not None):
+
+        logger.info("Using user-specified radar grid bounding box parameters")
+        if start_datetime_str is not None:
+            logger.info(f'    start time: {start_datetime_str}')
+            start_time = isce3.core.DateTime(start_datetime_str)
+
+        if end_datetime_str is not None:
+            logger.info(f'    end time: {end_datetime_str}')
+            end_time = isce3.core.DateTime(end_datetime_str)
+
+        if start_range is not None:
+            logger.info(f'    start range: {start_range}')
+
+        if end_range is not None:
+            logger.info(f'    end range: {end_range}')
+
     if rg_spacing is not None:
         logger.info(f'    range spacing: {rg_spacing}')
     if az_spacing is not None:
         logger.info(f'    azimuth time interval: {az_spacing}')
 
+    if start_time is not None and az_margin != 0.0:
+        start_time -= isce3.core.TimeDelta(az_margin)
+        logger.info(f'    start time (adjusted for az. margin) {az_margin}:'
+                    f' {start_time}')
+    if end_time is not None and az_margin != 0.0:
+        end_time += isce3.core.TimeDelta(az_margin)
+        logger.info(f'    end time (adjusted for az. margin) {az_margin}:'
+                    f' {end_time}')
+    if start_range is not None and rg_margin != 0.0:
+        start_range -= rg_margin
+        logger.info(f'    start range (adjusted for rg margin) {rg_margin}:'
+                    f' {start_range}')
+    if end_range is not None and rg_margin != 0.0:
+        end_range += rg_margin
+        logger.info(f'    end range (adjusted for rg margin) {rg_margin}:'
+                    f' {end_range}')
+
     if rg_spacing is None or az_spacing is None:
         az_spacing_inferred, rg_spacing_inferred = \
             isce3.geometry.infer_radar_grid_spacing_from_geo_grid(
@@ -143,25 +193,64 @@ def run_static_layers_workflow(config_file: os.PathLike | str) -> None:
                 pts_per_side=pts_per_side
             )
         if rg_spacing is None:
-            logger.info(f'   inferred range spacing: {rg_spacing}')
             rg_spacing = rg_spacing_inferred
+            logger.info(f'   inferred range spacing: {rg_spacing}')
         if az_spacing is None:
-            logger.info(f'   inferred azimuth time interval: {az_spacing}')
             az_spacing = az_spacing_inferred
+            logger.info(f'   inferred azimuth time interval: {az_spacing}')
 
-    # Compute a radar grid whose footprint on the ground encloses the geocoded
-    # grid on which each output layer is defined.
-    logger.info("Compute a radar grid spanning the region of interest")
-    radar_grid = isce3.geometry.get_bounding_radar_grid(
-        geo_grid=geo_grid,
-        az_spacing=az_spacing,
-        rg_spacing=rg_spacing,
-        orbit=orbit,
-        look_side=look_side,
-        wavelength=wavelength,
-        doppler=img_grid_doppler,
-        **radar_grid_params["bounding_box"],
-    )
+    if (start_time is not None and start_range is not None and
+            end_time is not None and end_range is not None):
+
+        epoch = orbit.reference_epoch
+
+        t0 = (isce3.core.DateTime(start_time) - epoch).total_seconds()
+        tf = (isce3.core.DateTime(end_time) - epoch).total_seconds()
+
+        num_az = round((tf - t0) / az_spacing)
+        num_rg = round((end_range - start_range) / rg_spacing)
+
+        logger.info(f'    number of lines: {num_az}')
+        logger.info(f'    number of range samples: {num_rg}')
+
+        radar_grid = isce3.product.RadarGridParameters(
+            sensing_start=t0,
+            wavelength=wavelength,
+            prf=1.0 / az_spacing,
+            starting_range=start_range,
+            range_pixel_spacing=rg_spacing,
+            lookside=normalize_look_side(look_side),
+            length=num_az,
+            width=num_rg,
+            ref_epoch=epoch,
+        )
+
+    elif (start_time is not None or start_range is not None or
+            end_time is not None or end_range is not None):
+        raise ValueError(
+            "If specifying radar grid bounding box parameters, must provide"
+            " all of 'start_time', 'start_range', 'end_time', and"
+            " 'end_range'"
+        )
+    else:
+
+        # Compute a radar grid whose footprint on the ground encloses the geocoded
+        # grid on which each output layer is defined.
+        logger.info("Compute a radar grid spanning the region of interest")
+        radar_grid = isce3.geometry.get_bounding_radar_grid(
+            geo_grid=geo_grid,
+            az_spacing=az_spacing,
+            rg_spacing=rg_spacing,
+            orbit=orbit,
+            look_side=look_side,
+            wavelength=wavelength,
+            doppler=img_grid_doppler,
+            min_height=min_height,
+            max_height=max_height,
+            pts_per_edge=pts_per_edge,
+            az_margin=az_margin,
+            rg_margin=rg_margin
+        )
     logger.info(f"Using radar grid: {radar_grid}")
 
     # Get the native Doppler LUT.

share/nisar/defaults/static.yaml

@@ -242,6 +242,31 @@ runconfig:
           # Defaults to 5.
           pts_per_side: 5
         bounding_box:
+          # [OPTIONAL] Azimuth start UTC date and time of the start of the radar
+          # observation, as a string in ISO 8601 format with up to nanosecond precision.
+          # If not provided, it will be inferred from the specified geographic grid.
+          # If provided, must be a valid azimuth time within the observation time
+          # interval.
+          start_time:
+
+          # [OPTIONAL] Azimuth ending UTC date and time of the end of the radar
+          # observation, as a string in ISO 8601
+          # format with up to nanosecond precision. Must be >= `start_time`.
+          # If not provided, it will be inferred from the specified geographic grid.
+          # If provided, must be a valid azimuth time within the observation time
+          # interval.
+          end_time:
+
+          # [OPTIONAL] Starting range, in meters, of the first column of the radar grid.
+          # If not provided, it will be inferred from the specified geographic grid.
+          # If provided, must be a positive value.
+          start_range:
+
+          # [OPTIONAL] Ending range, in meters, of the last column of the radar grid.
+          # If not provided, it will be inferred from the specified geographic grid.
+          # If provided, must be a positive value.
+          end_range:
+
           # [OPTIONAL] Lower bound on the height of targets within the region of interest,
           # in meters above the reference ellipsoid of the output product.
           # Used to estimate the bounds of a radar grid that spans the region of interest.

share/nisar/schemas/static.yaml

@@ -99,6 +99,18 @@ radar_grid_spacing_options:
   pts_per_side: int(min=2, required=False)
 
 radar_grid_bounding_box_options:
+  start_time: any(
+      timestamp(),
+      regex(r'^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d{1,9})?$'),
+      required=False
+    )
+  end_time: any(
+      timestamp(),
+      regex(r'^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d{1,9})?$'),
+      required=False
+    )
+  start_range: num(required=False)
+  end_range: num(required=False)
   min_height: num(required=False)
   max_height: num(required=False)
   pts_per_edge: int(min=2, required=False)