cars 1.0.0a2__cp310-cp310-win_amd64.whl → 1.0.0a4__cp310-cp310-win_amd64.whl

cars/core/geometry/abstract_geometry.py

@@ -18,6 +18,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
+# pylint: disable=C0302
+
 """
 this module contains the abstract geometry class to use in the
 geometry plugins
@@ -30,7 +33,10 @@ 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, Or
+from affine import Affine
+from json_checker import And, Checker
+from rasterio.enums import Resampling
+from rasterio.warp import reproject
 from scipy import interpolate
 from scipy.interpolate import LinearNDInterpolator
 from shapely.geometry import Polygon
@@ -38,19 +44,26 @@ from shareloc import proj_utils
 from shareloc.geofunctions.rectification_grid import RectificationGrid
 
 from cars.core import constants as cst
-from cars.core import inputs, outputs
+from cars.core import inputs, outputs, projection
 from cars.core.utils import safe_makedirs
 from cars.data_structures import cars_dataset
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 
 
-class AbstractGeometry(metaclass=ABCMeta):
+class AbstractGeometry(metaclass=ABCMeta):  # pylint: disable=R0902
     """
     AbstractGeometry
     """
 
     available_plugins: Dict = {}
 
-    def __new__(cls, geometry_plugin_conf=None, **kwargs):
+    def __new__(
+        cls,
+        geometry_plugin_conf=None,
+        pairs_for_roi=None,
+        scaling_coeff=1,
+        **kwargs,
+    ):
         """
         Return the required plugin
         :raises:
@@ -59,6 +72,8 @@ class AbstractGeometry(metaclass=ABCMeta):
         :param geometry_plugin_conf: plugin name or plugin configuration
             to instantiate
         :type geometry_plugin_conf: str or dict
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :return: a geometry_plugin object
         """
         if geometry_plugin_conf is not None:
@@ -94,28 +109,218 @@ class AbstractGeometry(metaclass=ABCMeta):
             )
         return super().__new__(cls)
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-positional-arguments
         self,
         geometry_plugin_conf,
         dem=None,
         geoid=None,
         default_alt=None,
+        pairs_for_roi=None,
+        scaling_coeff=1,
+        output_dem_dir=None,
         **kwargs,
     ):
+        self.scaling_coeff = scaling_coeff
 
-        config = self.check_conf(geometry_plugin_conf)
+        self.used_config = self.check_conf(geometry_plugin_conf)
 
-        self.plugin_name = config["plugin_name"]
-        self.interpolator = config["interpolator"]
-        self.dem_roi_margin = config["dem_roi_margin"]
-
-        self.dem = dem
+        self.plugin_name = self.used_config["plugin_name"]
+        self.interpolator = self.used_config["interpolator"]
+        self.dem_roi_margin = self.used_config["dem_roi_margin"]
+        self.dem = None
         self.dem_roi = None
         self.dem_roi_epsg = None
         self.geoid = geoid
         self.default_alt = default_alt
+        self.elevation = default_alt
+        # a margin is needed for cubic interpolation
+        self.rectification_grid_margin = 0
+        if self.interpolator == "cubic":
+            self.rectification_grid_margin = 5
         self.kwargs = kwargs
 
+        # compute roi only when generating geometry object with dem
+        if dem is not None:
+            self.dem = dem
+            self.default_alt = self.get_dem_median_value()
+            self.elevation = self.default_alt
+            logging.info(
+                "Median value of DEM ({}) will be used as default_alt".format(
+                    self.default_alt
+                )
+            )
+            if pairs_for_roi is not None:
+                self.dem_roi_epsg = inputs.rasterio_get_epsg(dem)
+                self.dem_roi = self.get_roi(
+                    pairs_for_roi,
+                    self.dem_roi_epsg,
+                    z_min=-1000,
+                    z_max=9000,
+                    linear_margin=self.dem_roi_margin[0],
+                    constant_margin=self.dem_roi_margin[1],
+                )
+                if output_dem_dir is not None:
+                    self.dem = self.extend_dem_to_roi(dem, output_dem_dir)
+
+    def get_dem_median_value(self):
+        """
+        Compute dem median value
+        :param dem: path of DEM
+        """
+        with rio.open(self.dem) as dem_file:
+            dem_data = dem_file.read(1)
+            median_value = np.nanmedian(dem_data)
+        median_value = float(median_value)
+        return median_value
+
+    def get_roi(  # pylint: disable=too-many-positional-arguments
+        self,
+        pairs_for_roi,
+        epsg,
+        z_min=0,
+        z_max=0,
+        linear_margin=0,
+        constant_margin=0.012,
+    ):
+        """
+        Compute region of interest for intersection of DEM
+
+        :param pairs_for_roi: list of pairs of images and geomodels
+        :type pairs_for_roi: List[(str, dict, str, dict)]
+        :param dem_epsg: output EPSG code for ROI
+        :type dem_epsg: int
+        :param linear_margin: margin for ROI (factor of initial ROI size)
+        :type linear_margin: float
+        :param constant_margin: margin for ROI in degrees
+        :type constant_margin: float
+        """
+        coords_list = []
+        z_min = np.array(z_min)
+        z_max = np.array(z_max)
+        for image1, geomodel1, image2, geomodel2 in pairs_for_roi:
+            # Footprint of left image with altitude z_min
+            coords_list.extend(
+                self.image_envelope(
+                    image1["main_file"], geomodel1, elevation=z_min
+                )
+            )
+            # Footprint of left image with altitude z_max
+            coords_list.extend(
+                self.image_envelope(
+                    image1["main_file"], geomodel1, elevation=z_max
+                )
+            )
+            # Footprint of right image with altitude z_min
+            coords_list.extend(
+                self.image_envelope(
+                    image2["main_file"], geomodel2, elevation=z_min
+                )
+            )
+            # Footprint of right image with altitude z_max
+            coords_list.extend(
+                self.image_envelope(
+                    image2["main_file"], geomodel2, elevation=z_max
+                )
+            )
+        lon_list, lat_list = list(zip(*coords_list))  # noqa: B905
+        roi = [
+            min(lon_list) - constant_margin,
+            min(lat_list) - constant_margin,
+            max(lon_list) + constant_margin,
+            max(lat_list) + constant_margin,
+        ]
+        points = np.array(
+            [
+                (roi[0], roi[1], 0),
+                (roi[2], roi[3], 0),
+                (roi[0], roi[1], 0),
+                (roi[2], roi[3], 0),
+            ]
+        )
+        new_points = projection.point_cloud_conversion(points, 4326, epsg)
+        roi = [
+            min(new_points[:, 0]),
+            min(new_points[:, 1]),
+            max(new_points[:, 0]),
+            max(new_points[:, 1]),
+        ]
+
+        lon_size = roi[2] - roi[0]
+        lat_size = roi[3] - roi[1]
+
+        roi[0] -= linear_margin * lon_size
+        roi[1] -= linear_margin * lat_size
+        roi[2] += linear_margin * lon_size
+        roi[3] += linear_margin * lat_size
+
+        return roi
+
+    def extend_dem_to_roi(self, dem, output_dem_dir):
+        """
+        Extend the size of the dem to the required ROI and fill
+        :param dem: path to the input DEM
+        :param output_dem_dir: path to write the output extended DEM
+        """
+        with rio.open(dem) as in_dem:
+            src_dem = in_dem.read(1)
+            metadata = in_dem.meta
+            src_transform = in_dem.transform
+            crs = in_dem.crs
+            bounds = in_dem.bounds
+
+        logging.info(
+            "DEM bounds : {}, {}, {}, {}".format(
+                bounds.left, bounds.top, bounds.right, bounds.bottom
+            )
+        )
+        logging.info(
+            "ROI bounds : {}, {}, {}, {}".format(
+                self.dem_roi[0],
+                self.dem_roi[1],
+                self.dem_roi[2],
+                self.dem_roi[3],
+            )
+        )
+
+        # Longitude
+        lon_res = src_transform[0]
+        lon_shift = (self.dem_roi[0] - bounds.left) / lon_res
+        dst_width = int((self.dem_roi[2] - self.dem_roi[0]) / abs(lon_res)) + 1
+        # Latitude
+        lat_res = src_transform[4]
+        lat_shift = (self.dem_roi[3] - bounds.top) / lat_res
+        dst_height = int((self.dem_roi[3] - self.dem_roi[1]) / abs(lat_res)) + 1
+
+        shift = Affine.translation(lon_shift, lat_shift)
+        dst_transform = src_transform * shift
+        dst_dem = np.zeros((dst_height, dst_width))
+
+        reproject(
+            source=src_dem,
+            destination=dst_dem,
+            src_transform=src_transform,
+            src_crs=crs,
+            dst_transform=dst_transform,
+            dst_crs=crs,
+            resampling=Resampling.bilinear,
+        )
+        # Fill nodata
+        dst_dem = rio.fill.fillnodata(
+            dst_dem,
+            mask=~(dst_dem == 0),
+        )
+        metadata["transform"] = dst_transform
+        metadata["height"] = dst_height
+        metadata["width"] = dst_width
+        metadata["driver"] = "GTiff"
+
+        out_dem_path = os.path.join(output_dem_dir, "initial_elevation.tif")
+
+        with rio.open(out_dem_path, "w", **metadata) as dst:
+            dst.write(dst_dem, 1)
+
+        return out_dem_path
+
     @classmethod
     def register_subclass(cls, short_name: str):
         """
@@ -160,12 +365,14 @@ class AbstractGeometry(metaclass=ABCMeta):
             "plugin_name", "SharelocGeometry"
         )
         overloaded_conf["interpolator"] = conf.get("interpolator", "cubic")
-        overloaded_conf["dem_roi_margin"] = conf.get("dem_roi_margin", 0.012)
+        overloaded_conf["dem_roi_margin"] = conf.get(
+            "dem_roi_margin", [0.75, 0.02]
+        )
 
         geometry_schema = {
             "plugin_name": str,
             "interpolator": And(str, lambda x: x in ["cubic", "linear"]),
-            "dem_roi_margin": Or(float, int),
+            "dem_roi_margin": [float],
         }
 
         # Check conf
@@ -175,7 +382,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         return overloaded_conf
 
     @abstractmethod
-    def triangulate(
+    def triangulate(  # pylint: disable=too-many-positional-arguments
         self,
         sensor1,
         sensor2,
@@ -186,6 +393,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         grid1: str,
         grid2: str,
         roi_key: Union[None, str] = None,
+        interpolation_method=None,
     ) -> np.ndarray:
         """
         Performs triangulation from cars disparity or matches dataset
@@ -215,6 +423,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         :return: True if the products are readable, False otherwise
         """
 
+    # pylint: disable=too-many-positional-arguments
     @abstractmethod
     def generate_epipolar_grids(
         self, sensor1, sensor2, geomodel1, geomodel2, epipolar_step: int = 30
@@ -249,6 +458,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         """
         return geomodel
 
+    # pylint: disable=too-many-positional-arguments
     def matches_to_sensor_coords(
         self,
         grid1: Union[str, cars_dataset.CarsDataset, RectificationGrid],
@@ -257,6 +467,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         matches_type: str,
         matches_msk: np.ndarray = None,
         ul_matches_shift: Tuple[int, int] = None,
+        interpolation_method=None,
     ) -> Tuple[np.ndarray, np.ndarray]:
         """
         Convert matches (sparse or dense matches) given in epipolar
@@ -330,10 +541,10 @@ class AbstractGeometry(metaclass=ABCMeta):
 
         # convert epipolar matches to sensor coordinates
         sensor_pos_left = self.sensor_position_from_grid(
-            grid1, vec_epi_pos_left
+            grid1, vec_epi_pos_left, interpolation_method=interpolation_method
         )
         sensor_pos_right = self.sensor_position_from_grid(
-            grid2, vec_epi_pos_right
+            grid2, vec_epi_pos_right, interpolation_method=interpolation_method
         )
 
         if matches_type == cst.DISP_MODE:
@@ -369,6 +580,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         self,
         grid: Union[dict, RectificationGrid],
         positions: np.ndarray,
+        interpolation_method=None,
     ) -> np.ndarray:
         """
         Interpolate the positions given as inputs using the grid
@@ -441,6 +653,11 @@ class AbstractGeometry(metaclass=ABCMeta):
             min_row_idx : max_row_idx + 1, min_col_idx : max_col_idx + 1
         ]
 
+        if interpolation_method is not None:
+            method = interpolation_method
+        else:
+            method = self.interpolator
+
         # interpolate sensor positions
         interpolator = interpolate.RegularGridInterpolator(
             (cols_cropped, rows_cropped),
@@ -451,13 +668,35 @@ class AbstractGeometry(metaclass=ABCMeta):
                 ),
                 axis=2,
             ),
-            method=self.interpolator,
+            method=method,
             bounds_error=False,
             fill_value=None,
         )
 
         sensor_positions = interpolator(positions)
 
+        min_row = np.min(sensor_row_positions_cropped)
+        max_row = np.max(sensor_row_positions_cropped)
+        min_col = np.min(sensor_col_positions_cropped)
+        max_col = np.max(sensor_col_positions_cropped)
+
+        valid_rows = np.logical_and(
+            sensor_positions[:, 0] > min_row,
+            sensor_positions[:, 0] < max_row,
+        )
+        valid_cols = np.logical_and(
+            sensor_positions[:, 1] > min_col,
+            sensor_positions[:, 1] < max_col,
+        )
+        valid = np.logical_and(valid_rows, valid_cols)
+
+        if np.sum(~valid) > 0:
+            logging.warning(
+                "{}/{} points are outside of epipolar grid".format(
+                    np.sum(~valid), valid.size
+                )
+            )
+
         # swap
         sensor_positions[:, [0, 1]] = sensor_positions[:, [1, 0]]
 
@@ -517,6 +756,7 @@ class AbstractGeometry(metaclass=ABCMeta):
 
         return epipolar_positions
 
+    @cars_profile(name="Transform matches", interval=0.5)
     def transform_matches_from_grids(
         self,
         sensor_matches_left,
@@ -553,7 +793,8 @@ class AbstractGeometry(metaclass=ABCMeta):
 
         return new_matches_array
 
-    def get_sensor_matches(
+    @cars_profile(name="Get sensor matches")
+    def get_sensor_matches(  # pylint: disable=too-many-positional-arguments
         self,
         matches_array,
         grid_left,
@@ -562,7 +803,7 @@ class AbstractGeometry(metaclass=ABCMeta):
         save_matches,
     ):
         """
-        get sensor matches
+        Get sensor matches
 
         :param grid_left: path to epipolar grid of image 1
         :param grid_left: path to epipolar grid of image 2
@@ -595,7 +836,29 @@ class AbstractGeometry(metaclass=ABCMeta):
         return sensor_matches_left, sensor_matches_right
 
     @abstractmethod
-    def direct_loc(
+    def direct_loc(  # pylint: disable=too-many-positional-arguments
+        self,
+        sensor,
+        geomodel,
+        x_coord: np.array,
+        y_coord: np.array,
+        z_coord: np.array = None,
+    ) -> np.ndarray:
+        """
+        For a given image points list, compute the latitudes,
+        longitudes, altitudes
+
+        Advice: to be sure, use x,y,z list inputs only
+
+        :param sensor: path to sensor image
+        :param geomodel: path and attributes for geomodel
+        :param x_coord: X Coordinates list in input image sensor
+        :param y_coord: Y Coordinate list in input image sensor
+        :param z_coord: Z Altitude list coordinate to take the image
+        :return: Latitude, Longitude, Altitude coordinates list as a numpy array
+        """
+
+    def safe_direct_loc(  # pylint: disable=too-many-positional-arguments
         self,
         sensor,
         geomodel,
@@ -616,9 +879,58 @@ class AbstractGeometry(metaclass=ABCMeta):
         :param z_coord: Z Altitude list coordinate to take the image
         :return: Latitude, Longitude, Altitude coordinates list as a numpy array
         """
+        if len(x_coord) > 0:
+            ground_points = self.direct_loc(
+                sensor,
+                geomodel,
+                x_coord,
+                y_coord,
+                z_coord,
+            )
+        else:
+            logging.warning("Direct loc function launched on empty list")
+            return []
+        if z_coord is None:
+            status = np.any(np.isnan(ground_points), axis=0)
+            if sum(status) > 0:
+                logging.warning(
+                    "{} errors have been detected on direct "
+                    "loc and will be re-launched".format(sum(status))
+                )
+                ground_points_retry = self.direct_loc(
+                    sensor,
+                    geomodel,
+                    x_coord[status],
+                    y_coord[status],
+                    np.array([0]),
+                )
+                ground_points[:, status] = ground_points_retry
+        return ground_points
 
     @abstractmethod
-    def inverse_loc(
+    def inverse_loc(  # pylint: disable=too-many-positional-arguments
+        self,
+        sensor,
+        geomodel,
+        lat_coord: np.array,
+        lon_coord: np.array,
+        z_coord: np.array = None,
+    ) -> np.ndarray:
+        """
+        For a given image points list, compute the latitudes,
+        longitudes, altitudes
+
+        Advice: to be sure, use x,y,z list inputs only
+
+        :param sensor: path to sensor image
+        :param geomodel: path and attributes for geomodel
+        :param lat_coord: latitute Coordinate list
+        :param lon_coord: longitude Coordinates list
+        :param z_coord: Z Altitude list
+        :return: X  / Y / Z Coordinates list in input image as a numpy array
+        """
+
+    def safe_inverse_loc(  # pylint: disable=too-many-positional-arguments
         self,
         sensor,
         geomodel,
@@ -639,8 +951,38 @@ class AbstractGeometry(metaclass=ABCMeta):
         :param z_coord: Z Altitude list
         :return: X  / Y / Z Coordinates list in input image as a numpy array
         """
+        if len(lat_coord) > 0:
+            image_points = self.inverse_loc(
+                sensor,
+                geomodel,
+                lat_coord,
+                lon_coord,
+                z_coord,
+            )
+            image_points = np.array(image_points)
+        else:
+            logging.warning("Inverse loc function launched on empty list")
+            return [], [], []
+        if z_coord is None:
+            image_points = np.array(image_points)
+            status = np.any(np.isnan(image_points), axis=0)
+            if sum(status) > 0:
+                logging.warning(
+                    "{} errors have been detected on inverse "
+                    "loc and will be re-launched".format(sum(status))
+                )
+            image_points_retry = self.inverse_loc(
+                sensor,
+                geomodel,
+                lat_coord[status],
+                lon_coord[status],
+                np.array([self.default_alt]),
+            )
+
+            image_points[:, status] = image_points_retry
+        return image_points[0], image_points[1], image_points[2]
 
-    def image_envelope(
+    def image_envelope(  # pylint: disable=too-many-positional-arguments
         self,
         sensor,
         geomodel,