cars 1.0.0a1__cp313-cp313-win_amd64.whl → 1.0.0a2__cp313-cp313-win_amd64.whl

cars/applications/point_cloud_fusion/pc_fusion_algo.py

@@ -468,9 +468,12 @@ def create_combined_dense_cloud(  # noqa: C901
             if cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT in array_name:
                 arrays_to_add_to_point_cloud.append((array_name, array_name))
 
-        # add confidence layers
+        # add ambiguity layer, drop confidence_* layers
         for array_name in point_cloud:
-            if cst.EPI_CONFIDENCE_KEY_ROOT in array_name:
+            if (
+                cst.EPI_AMBIGUITY in array_name
+                and cst.EPI_CONFIDENCE_KEY_ROOT not in array_name
+            ):
                 arrays_to_add_to_point_cloud.append((array_name, array_name))
 
         # add denoising info layers
@@ -852,12 +855,15 @@ def generate_pc_wrapper(  # noqa: C901
             if cst.EPI_TEXTURE not in coords:
                 coords[cst.BAND_IM] = descriptions
 
-        elif key == cst.EPI_CONFIDENCE_KEY_ROOT:
-            for sub_key in cloud[key].keys():
-                data = pc_wrap.read_image_full(
-                    cloud[key][sub_key], window=window, squeeze=True
-                )
-                values[sub_key] = ([cst.ROW, cst.COL], data)
+        elif key == cst.EPI_AMBIGUITY:
+            data = pc_wrap.read_image_full(
+                cloud[key], window=window, squeeze=True
+            )
+            descriptions = list(inputs.get_descriptions_bands(cloud[key]))
+            values[cst.EPI_AMBIGUITY] = (
+                [cst.ROW, cst.COL],
+                data,
+            )
 
         elif key == cst.EPI_FILLING:
             data = pc_wrap.read_image_full(
@@ -1098,9 +1104,9 @@ def compute_x_y_min_max_wrapper(items, epsg, window, saving_info=None):
         data_dict[cst.POINT_CLOUD_FILLING_KEY_ROOT] = items[
             cst.POINT_CLOUD_FILLING_KEY_ROOT
         ]
-    if cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT in items:
-        data_dict[cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT] = items[
-            cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
+    if cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT in items:
+        data_dict[cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT] = items[
+            cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
         ]
     if cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT in items:
         data_dict[cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT] = items[

cars/applications/point_cloud_fusion/pc_fusion_wrappers.py

@@ -180,10 +180,9 @@ def create_point_cloud_index(cloud_sample):
             band_index = "{}_{}".format(cst.POINT_CLOUD_FILLING_KEY_ROOT, band)
             cloud_indexes_with_types[band_index] = "uint8"
 
-    # Add confidence indexes
-    for key in cloud_sample:
-        if cst.EPI_CONFIDENCE_KEY_ROOT in key:
-            cloud_indexes_with_types[key] = "float32"
+    # Add ambiguity information index
+    if cst.EPI_AMBIGUITY in cloud_sample:
+        cloud_indexes_with_types[cst.EPI_AMBIGUITY] = "float32"
 
     return cloud_indexes_with_types
 

cars/applications/rasterization/rasterization_algo.py

@@ -174,7 +174,7 @@ def compute_vector_raster_and_stats(
     points = cloud.loc[:, [cst.X, cst.Y]].values.T
     nb_points = points.shape[1]
     valid = np.ones((1, nb_points))
-    # create values: 1. altitudes and colors, 2. confidences, 3. masks
+    # create values: 1. altitudes and colors, 2. ambiguity, 3. masks
     # split_indexes allows to keep indexes separating values
     split_indexes = []
 
@@ -187,21 +187,16 @@ def compute_vector_raster_and_stats(
     values_bands.extend(clr_indexes)
     split_indexes.append(len(values_bands))
 
-    # 2. confidences
-    if list_computed_layers is not None:
-        if cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT not in list_computed_layers:
-            confidences_indexes = rast_wrap.find_indexes_in_point_cloud(
-                cloud, cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT, list_computed_layers
-            )
-        else:
-            confidences_indexes = rast_wrap.find_indexes_in_point_cloud(
-                cloud, cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT, list_computed_layers
-            )
-    else:
-        confidences_indexes = []
+    # 2. ambiguity
+    ambiguity_indexes = rast_wrap.find_indexes_in_point_cloud(
+        cloud, cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT, list_computed_layers
+    )
+
+    values_bands.extend(ambiguity_indexes)
+    split_indexes.append(len(ambiguity_indexes))
 
-    values_bands.extend(confidences_indexes)
-    split_indexes.append(len(confidences_indexes))
+    # sanity check
+    assert len(ambiguity_indexes) <= 1
 
     # 3. sup and inf layers interval
     layer_inf_sup_indexes = rast_wrap.find_indexes_in_point_cloud(
@@ -288,7 +283,7 @@ def compute_vector_raster_and_stats(
     # pylint: disable=unbalanced-tuple-unpacking
     (
         out,
-        confidences,
+        ambiguity,
         interval,
         msk,
         classif,
@@ -297,11 +292,9 @@ def compute_vector_raster_and_stats(
         performance_map,
     ) = np.split(out, np.cumsum(split_indexes), axis=-1)
 
-    confidences_out = None
-    if len(confidences_indexes) > 0:
-        confidences_out = {}
-        for k, key in enumerate(confidences_indexes):
-            confidences_out[key] = confidences[..., k]
+    ambiguity_out = None
+    if len(ambiguity_indexes) > 0:
+        ambiguity_out = ambiguity
 
     layers_inf_sup_out = None
     layers_inf_sup_stat_index = None
@@ -341,7 +334,7 @@ def compute_vector_raster_and_stats(
         clr_indexes,
         classif_out,
         classif_indexes,
-        confidences_out,
+        ambiguity_out,
         layers_inf_sup_out,
         layers_inf_sup_stat_index,
         layer_inf_sup_indexes,
@@ -420,7 +413,7 @@ def rasterize(
         clr_indexes,
         classif,
         classif_indexes,
-        confidences,
+        ambiguity,
         layer_inf_sup,
         layer_inf_sup_stats_indexes,
         layer_inf_sup_indexes,
@@ -463,9 +456,9 @@ def rasterize(
     else:
         msk = np.isnan(out[0, :, :])
 
-    if confidences is not None:
-        for key, value in confidences.items():
-            confidences[key] = value.reshape(shape_out)
+    if ambiguity is not None:
+        ambiguity = ambiguity.reshape(shape_out + (-1,))
+        ambiguity = np.moveaxis(ambiguity, 2, 0)
 
     if layer_inf_sup is not None:
         layer_inf_sup = layer_inf_sup.reshape(shape_out + (-1,))
@@ -512,7 +505,7 @@ def rasterize(
         clr_indexes,
         classif,
         classif_indexes,
-        confidences,
+        ambiguity,
         layer_inf_sup,
         layer_inf_sup_stats_indexes,
         layer_inf_sup_indexes,

cars/applications/rasterization/rasterization_wrappers.py

@@ -174,7 +174,7 @@ def create_raster_dataset(  # noqa: C901
     band_im: List[str] = None,
     classif: np.ndarray = None,
     band_classif: List[str] = None,
-    confidences: np.ndarray = None,
+    ambiguity: np.ndarray = None,
     layers_inf_sup: np.ndarray = None,
     layers_inf_sup_stat_index: List[int] = None,
     layer_inf_sup_indexes: List[str] = None,
@@ -207,7 +207,7 @@ def create_raster_dataset(  # noqa: C901
     :param n_in_cell: number of points which contribute to a cell
     :param msk: raster msk
     :param classif: raster classif
-    :param confidences: raster containing the confidences
+    :param ambiguity: raster containing the ambiguity
     :param layers_inf_sup: raster containing intervals inf and sup
     :param layers_inf_sup_stat_index: list containing index of
         intervals in mean and stdev rasters
@@ -310,9 +310,10 @@ def create_raster_dataset(  # noqa: C901
         # update raster output with classification data
         raster_out = xr.merge((raster_out, classif_out))
 
-    if confidences is not None:  # rasterizer produced color output
-        for key in confidences:
-            raster_out[key] = xr.DataArray(confidences[key], dims=raster_dims)
+    if ambiguity is not None:  # rasterizer produced color output
+        raster_out[cst.RASTER_AMBIGUITY] = xr.DataArray(
+            ambiguity[0], dims=raster_dims
+        )
 
     if layers_inf_sup is not None:
         # Get inf data

cars/applications/rasterization/simple_gaussian_app.py

@@ -644,7 +644,7 @@ class SimpleGaussian(
             )
         elif save_intermediate_data:
             # File is not part of the official product, write it in dump_dir
-            out_source_pc = os.path.join(out_dump_dir, "source_pc.tif")
+            out_source_pc = os.path.join(out_dump_dir, "contributing_pair.tif")
         if out_source_pc:
             list_computed_layers += ["source_pc"]
             self.orchestrator.add_to_save_lists(
@@ -653,7 +653,7 @@ class SimpleGaussian(
                 terrain_raster,
                 dtype=np.uint8,
                 nodata=self.msk_no_data,
-                cars_ds_name="source_pc",
+                cars_ds_name="contributing_pair",
                 optional_data=True,
             )
 
@@ -680,18 +680,6 @@ class SimpleGaussian(
 
         # TODO Check that intervals indeed exist!
         if save_intermediate_data:
-            out_confidence = os.path.join(out_dump_dir, "confidence.tif")
-            list_computed_layers += ["confidence"]
-            self.orchestrator.add_to_save_lists(
-                out_confidence,
-                cst.RASTER_CONFIDENCE,
-                terrain_raster,
-                dtype=np.float32,
-                nodata=self.msk_no_data,
-                cars_ds_name="confidence",
-                optional_data=True,
-            )
-
             list_computed_layers += [cst.POINT_CLOUD_LAYER_SUP_OR_INF_ROOT]
             out_dsm_inf_file_name = os.path.join(out_dump_dir, "dsm_inf.tif")
             self.orchestrator.add_to_save_lists(

cars/applications/sparse_matching/sparse_matching_wrappers.py

@@ -170,55 +170,6 @@ def compute_disp_min_disp_max(
     return dmin, dmax
 
 
-@cars_profile(name="Clustering matches")
-def clustering_matches(
-    triangulated_matches,
-    connection_val=3.0,
-    nb_pts_threshold=80,
-    clusters_distance_threshold: float = None,
-    filtered_elt_pos: bool = False,
-):
-    """
-    Filter triangulated  matches
-
-    :param pd_cloud: triangulated_matches
-    :type pd_cloud: pandas Dataframe
-    :param connection_val: distance to use
-        to consider that two points are connected
-    :param nb_pts_threshold: number of points to use
-        to identify small clusters to filter
-    :param clusters_distance_threshold: distance to use
-        to consider if two points clusters are far from each other or not
-        (set to None to deactivate this level of filtering)
-    :param filtered_elt_pos: if filtered_elt_pos is set to True,
-        the removed points positions in their original
-        epipolar images are returned, otherwise it is set to None
-
-    :return: filtered_matches
-    :rtype: pandas Dataframe
-
-    """
-
-    filtered_pandora_matches, _ = (
-        outlier_removal_algo.small_component_filtering(
-            triangulated_matches,
-            connection_val=connection_val,
-            nb_pts_threshold=nb_pts_threshold,
-            clusters_distance_threshold=clusters_distance_threshold,
-            filtered_elt_pos=filtered_elt_pos,
-        )
-    )
-
-    filtered_pandora_matches_dataframe = pandas.DataFrame(
-        filtered_pandora_matches
-    )
-    filtered_pandora_matches_dataframe.attrs["epsg"] = (
-        triangulated_matches.attrs["epsg"]
-    )
-
-    return filtered_pandora_matches_dataframe
-
-
 @cars_profile(name="filter_point_cloud_matches")
 def filter_point_cloud_matches(
     pd_cloud,

cars/applications/triangulation/line_of_sight_intersection_app.py

@@ -1044,7 +1044,7 @@ def triangulation_wrapper(
                 ambiguity_map = None
                 perf_ambiguity_threshold = None
                 if use_ambiguity:
-                    ambiguity_map = disp_ref["confidence_from_ambiguity.cars_1"]
+                    ambiguity_map = disp_ref["ambiguity"]
                     perf_ambiguity_threshold = performance_maps_parameters[
                         "perf_ambiguity_threshold"
                     ]

cars/applications/triangulation/triangulation_wrappers.py

@@ -246,7 +246,8 @@ def compute_performance_map(
     )
 
     if ambiguity_map is not None:
-        ambiguity_map = 1 - ambiguity_map.values
+        # ambiguity is already ambiguity, not confidence from ambiguity
+        ambiguity_map = ambiguity_map.values
         mask_ambi = ambiguity_map > perf_ambiguity_threshold
         w_ambi = ambiguity_map / perf_ambiguity_threshold
         w_ambi[mask_ambi] = 1

cars/bundleadjustment.py

@@ -15,6 +15,7 @@ import geopandas as gpd
 import numpy as np
 import pandas as pd
 import rasterio as rio
+import yaml
 
 try:
     from rpcfit import rpc_fit
@@ -34,6 +35,7 @@ from shareloc.geomodels.geomodel import GeoModel
 from shareloc.geomodels.los import LOS
 from shareloc.proj_utils import coordinates_conversion
 
+from cars.pipelines.parameters import sensor_inputs
 from cars.pipelines.pipeline import Pipeline
 
 
@@ -550,14 +552,26 @@ def new_rpcs_from_matches(
     return None
 
 
-def cars_bundle_adjustment(conf, no_run_sparse):
+def cars_bundle_adjustment(conf, no_run_sparse, output_format="yaml"):
     """
     cars-bundleadjustement main:
     - Launch CARS to compute homologous points (run sparse matching)
     - Compute new RPCs
     """
-    with open(conf, encoding="utf-8") as reader:
-        conf_as_dict = json.load(reader)
+    _, ext = os.path.splitext(conf)
+    ext = ext.lower()
+
+    if ext == ".json":
+        with open(conf, encoding="utf-8") as reader:
+            conf_as_dict = json.load(reader)
+    elif ext in [".yaml", ".yml"]:
+        with open(conf, encoding="utf-8") as reader:
+            conf_as_dict = yaml.safe_load(reader)
+    else:
+        raise ValueError(
+            f"Unsupported configuration file format: {ext}. "
+            "Please use .json, .yaml, or .yml"
+        )
 
     conf_dirname = os.path.dirname(conf)
     out_dir = os.path.abspath(
@@ -576,6 +590,7 @@ def cars_bundle_adjustment(conf, no_run_sparse):
     ]
     sparse_matching_config["output"]["directory"] = sparse_matching
     sparse_matching_config["output"]["product_level"] = []
+    sparse_matching_config["advanced"] = {}
     sparse_matching_config["advanced"]["epipolar_resolutions"] = [1]
     if "sparse_matching.sift" not in sparse_matching_config["applications"]:
         sparse_matching_config["applications"]["sparse_matching.sift"] = {}
@@ -595,6 +610,9 @@ def cars_bundle_adjustment(conf, no_run_sparse):
         sparse_matching_pipeline.run()
 
     # create new refined rpcs
+    conf_as_dict["inputs"] = sensor_inputs.sensors_check_inputs(
+        conf_as_dict["inputs"], config_dir=conf_dirname
+    )
     separate = bundle_adjustment_config.pop("separate")
     refined_rpcs = new_rpcs_from_matches(
         conf_as_dict["inputs"]["sensors"],
@@ -623,9 +641,15 @@ def cars_bundle_adjustment(conf, no_run_sparse):
             raw_config["inputs"]["pairing"] = pairing
             raw_config["output"]["directory"] = raw
 
-        raw_cfg_file = raw_config["output"]["directory"] + ".json"
-        with open(raw_cfg_file, "w", encoding="utf8") as json_writer:
-            json.dump(raw_config, json_writer, indent=2)
+        # output config file
+        raw_cfg_file = raw_config["output"]["directory"] + (
+            ".yaml" if output_format == "yaml" else ".json"
+        )
+        with open(raw_cfg_file, "w", encoding="utf8") as writer:
+            if output_format == "yaml":
+                yaml.safe_dump(raw_config, writer, sort_keys=False)
+            else:
+                json.dump(raw_config, writer, indent=2)
 
         if refined_rpcs is not None:
             # create configuration file + launch cars dense matching
@@ -645,9 +669,14 @@ def cars_bundle_adjustment(conf, no_run_sparse):
                 refined_config["inputs"]["pairing"] = pairing
                 refined_config["output"]["directory"] = refined
 
-            refined_cfg_file = refined_config["output"]["directory"] + ".json"
-            with open(refined_cfg_file, "w", encoding="utf8") as json_writer:
-                json.dump(refined_config, json_writer, indent=2)
+            refined_cfg_file = refined_config["output"]["directory"] + (
+                ".yaml" if output_format == "yaml" else ".json"
+            )
+            with open(refined_cfg_file, "w", encoding="utf8") as writer:
+                if output_format == "yaml":
+                    yaml.safe_dump(refined_config, writer, sort_keys=False)
+                else:
+                    json.dump(refined_config, writer, indent=2)
 
 
 def cli():
@@ -679,8 +708,8 @@ key and its associated value:
 ```
 
 - Parameters "pairing" and "separate" are mandatory.
-- Parameters "nb_decimals" (default value: 0) and "min_matches" \
-(default value: 100) are optional.
+- Parameters "nb_decimals" (default value: 0), "min_matches" \
+(default value: 100) and "output_format" (default value: yaml) are optional.
 
 ### Generation of homologous points calculated by pair
 
@@ -704,7 +733,18 @@ number of matches per zone required to calculate these statistics."""
     )
     parser.add_argument("conf", type=str, help="Configuration File")
     parser.add_argument("--no-run-sparse", action="store_true")
+    parser.add_argument(
+        "--output-format",
+        type=str,
+        default="json",
+        choices=["json", "yaml", "JSON", "YAML"],
+        help="Output format for generated configuration files "
+        "(json or yaml, case-insensitive). Default: json",
+    )
+
     args = parser.parse_args()
+    # normalize format to lowercase
+    args.output_format = args.output_format.lower()
     cars_bundle_adjustment(**vars(args))
 
 

cars/cars.py

@@ -33,6 +33,8 @@ import os
 import sys
 import warnings
 
+import yaml
+
 # CARS imports
 from cars import __version__
 from cars.core import cars_logging
@@ -87,9 +89,17 @@ def main_cli(args, dry_run=False):  # noqa: C901
     from cars.pipelines.pipeline import Pipeline
 
     try:
-        # Transform conf file to dict
-        with open(args.conf, "r", encoding="utf8") as fstream:
-            config = json.load(fstream)
+        # Check file extension and load configuration
+        config_path = args.conf
+        ext = os.path.splitext(config_path)[1].lower()
+        if ext == ".json":
+            with open(config_path, "r", encoding="utf8") as fstream:
+                config = json.load(fstream)
+        elif ext in [".yaml", ".yml"]:
+            with open(config_path, "r", encoding="utf8") as fstream:
+                config = yaml.safe_load(fstream)
+        else:
+            raise ValueError("Configuration file must be .json or .yaml/.yml")
 
         # Cars 0.9.0 API change, check if the configfile seems to use the old
         # API by looking for the deprecated out_dir key
@@ -109,7 +119,7 @@ def main_cli(args, dry_run=False):  # noqa: C901
             config["output"]["directory"] = config["output"]["out_dir"]
             del config["output"]["out_dir"]
 
-        config_json_dir = os.path.abspath(os.path.dirname(args.conf))
+        config_dir = os.path.abspath(os.path.dirname(config_path))
         pipeline_name = config.get("advanced", {}).get("pipeline", "default")
 
         # Logging configuration with args Loglevel
@@ -126,7 +136,7 @@ def main_cli(args, dry_run=False):  # noqa: C901
 
         # Generate pipeline and check conf
         cars_logging.add_progress_message("Check configuration...")
-        used_pipeline = Pipeline(pipeline_name, config, config_json_dir)
+        used_pipeline = Pipeline(pipeline_name, config, config_dir)
         cars_logging.add_progress_message("CARS pipeline is started.")
         if not dry_run:
             # run pipeline

cars/core/constants.py

@@ -184,7 +184,7 @@ DSM_INF_MEAN = "dsm_inf_mean"
 DSM_INF_STD = "dsm_inf_std"
 DSM_SUP_MEAN = "dsm_sup_mean"
 DSM_SUP_STD = "dsm_sup_std"
-DSM_CONFIDENCE_AMBIGUITY = "ambiguity"
+DSM_AMBIGUITY = "ambiguity"
 DSM_CONFIDENCE = "confidence"
 DSM_PERFORMANCE_MAP = "performance_map"
 DSM_SOURCE_PC = "source_pc"

cars/core/geometry/abstract_geometry.py

@@ -30,7 +30,7 @@ from typing import Dict, List, Tuple, Union
 import numpy as np
 import rasterio as rio
 import xarray as xr
-from json_checker import And, Checker
+from json_checker import And, Checker, Or
 from scipy import interpolate
 from scipy.interpolate import LinearNDInterpolator
 from shapely.geometry import Polygon
@@ -65,7 +65,9 @@ class AbstractGeometry(metaclass=ABCMeta):
             if isinstance(geometry_plugin_conf, str):
                 geometry_plugin = geometry_plugin_conf
             elif isinstance(geometry_plugin_conf, dict):
-                geometry_plugin = geometry_plugin_conf.get("plugin_name", None)
+                geometry_plugin = geometry_plugin_conf.get(
+                    "plugin_name", "SharelocGeometry"
+                )
             else:
                 raise RuntimeError("Not a supported type")
 
@@ -105,6 +107,7 @@ class AbstractGeometry(metaclass=ABCMeta):
 
         self.plugin_name = config["plugin_name"]
         self.interpolator = config["interpolator"]
+        self.dem_roi_margin = config["dem_roi_margin"]
 
         self.dem = dem
         self.dem_roi = None
@@ -153,12 +156,16 @@ class AbstractGeometry(metaclass=ABCMeta):
             conf = {"plugin_name": conf}
 
         # overload conf
-        overloaded_conf["plugin_name"] = conf.get("plugin_name", None)
+        overloaded_conf["plugin_name"] = conf.get(
+            "plugin_name", "SharelocGeometry"
+        )
         overloaded_conf["interpolator"] = conf.get("interpolator", "cubic")
+        overloaded_conf["dem_roi_margin"] = conf.get("dem_roi_margin", 0.012)
 
         geometry_schema = {
             "plugin_name": str,
             "interpolator": And(str, lambda x: x in ["cubic", "linear"]),
+            "dem_roi_margin": Or(float, int),
         }
 
         # Check conf
@@ -372,7 +379,6 @@ class AbstractGeometry(metaclass=ABCMeta):
                array of size [number of points, 2]. The last index indicates
                the 'x' coordinate (last index set to 0) or the 'y' coordinate
                (last index set to 1).
-        :param interpolator: interpolator to use
         :return: sensors positions as a numpy array of size
                  [number of points, 2]. The last index indicates the 'x'
                  coordinate (last index set to 0) or
@@ -387,6 +393,9 @@ class AbstractGeometry(metaclass=ABCMeta):
                 f"Grid type {type(grid)} not a dict or RectificationGrid"
             )
 
+        # Ensure positions is a numpy array
+        positions = np.asarray(positions)
+
         # Get data
         with rio.open(grid["path"]) as grid_data:
             row_dep = grid_data.read(2)
@@ -403,17 +412,42 @@ class AbstractGeometry(metaclass=ABCMeta):
         cols = np.arange(ori_col, last_col, step_col)
         rows = np.arange(ori_row, last_row, step_row)
 
-        # create regular grid points positions
-        sensor_row_positions = row_dep
-        sensor_col_positions = col_dep
+        # Determine margin based on interpolator type
+        margin = 6 if self.interpolator == "cubic" else 3
+
+        # Find the bounds of positions to determine crop region
+        min_col = np.nanmin(positions[:, 0])
+        max_col = np.nanmax(positions[:, 0])
+        min_row = np.nanmin(positions[:, 1])
+        max_row = np.nanmax(positions[:, 1])
+
+        # Convert position bounds to grid indices with margin
+        min_col_idx = max(0, int((min_col - ori_col) / step_col) - margin)
+        max_col_idx = min(
+            len(cols) - 1, int((max_col - ori_col) / step_col) + margin
+        )
+        min_row_idx = max(0, int((min_row - ori_row) / step_row) - margin)
+        max_row_idx = min(
+            len(rows) - 1, int((max_row - ori_row) / step_row) + margin
+        )
+
+        # Crop the grids and coordinate arrays
+        cols_cropped = cols[min_col_idx : max_col_idx + 1]
+        rows_cropped = rows[min_row_idx : max_row_idx + 1]
+        sensor_row_positions_cropped = row_dep[
+            min_row_idx : max_row_idx + 1, min_col_idx : max_col_idx + 1
+        ]
+        sensor_col_positions_cropped = col_dep[
+            min_row_idx : max_row_idx + 1, min_col_idx : max_col_idx + 1
+        ]
 
         # interpolate sensor positions
         interpolator = interpolate.RegularGridInterpolator(
-            (cols, rows),
+            (cols_cropped, rows_cropped),
             np.stack(
                 (
-                    sensor_row_positions.transpose(),
-                    sensor_col_positions.transpose(),
+                    sensor_row_positions_cropped.transpose(),
+                    sensor_col_positions_cropped.transpose(),
                 ),
                 axis=2,
             ),
@@ -607,7 +641,12 @@ class AbstractGeometry(metaclass=ABCMeta):
         """
 
     def image_envelope(
-        self, sensor, geomodel, out_path=None, out_driver="ESRI Shapefile"
+        self,
+        sensor,
+        geomodel,
+        out_path=None,
+        out_driver="ESRI Shapefile",
+        elevation=None,
     ):
         """
         Export the image footprint to a vector file
@@ -629,24 +668,28 @@ class AbstractGeometry(metaclass=ABCMeta):
             geomodel,
             np.array(shift_x),
             np.array(shift_y),
+            elevation,
         )
         lat_upper_right, lon_upper_right, _ = self.direct_loc(
             sensor,
             geomodel,
             np.array(img_size_x + shift_x),
             np.array(shift_y),
+            elevation,
         )
         lat_bottom_left, lon_bottom_left, _ = self.direct_loc(
             sensor,
             geomodel,
             np.array(shift_x),
             np.array(img_size_y + shift_y),
+            elevation,
         )
         lat_bottom_right, lon_bottom_right, _ = self.direct_loc(
             sensor,
             geomodel,
             np.array(img_size_x + shift_x),
             np.array(img_size_y + shift_y),
+            elevation,
         )
 
         u_l = (lon_upper_left, lat_upper_left)