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

cars/core/geometry/shareloc_geometry.py

@@ -30,7 +30,7 @@ import numpy as np
 import rasterio as rio
 import shareloc.geofunctions.rectification as rectif
 import xarray as xr
-from json_checker import Checker
+from json_checker import And, Checker
 from shareloc.dtm_reader import dtm_reader
 from shareloc.geofunctions import localization
 from shareloc.geofunctions.rectification_grid import RectificationGrid
@@ -41,7 +41,7 @@ from shareloc.geomodels.rpc import RPC
 from shareloc.image import Image
 
 from cars.core import constants as cst
-from cars.core import inputs, projection
+from cars.core import projection
 from cars.core.geometry.abstract_geometry import AbstractGeometry
 
 GRID_TYPE = "GRID"
@@ -56,13 +56,15 @@ class SharelocGeometry(AbstractGeometry):
     Shareloc geometry class
     """
 
-    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,
     ):
 
         super().__init__(
@@ -71,50 +73,28 @@ class SharelocGeometry(AbstractGeometry):
             geoid=geoid,
             default_alt=default_alt,
             pairs_for_roi=pairs_for_roi,
+            scaling_coeff=scaling_coeff,
+            output_dem_dir=output_dem_dir,
         )
 
-        self.dem_roi = None
-        self.roi_shareloc = None
-        self.elevation = None
-
-        # a margin is needed for cubic interpolation
-        self.rectification_grid_margin = 0
-        if self.interpolator == "cubic":
-            self.rectification_grid_margin = 5
-
-        # compute roi only when generating geometry object with dem
-        # even if dem is None
-        if geoid is not None and pairs_for_roi is not None:
-            self.dem_roi_epsg = 4326
-            if dem is not None:
-                # Get dem epsg
-                self.dem_roi_epsg = inputs.rasterio_get_epsg(dem)
-
-            self.roi_shareloc = self.get_roi(
-                pairs_for_roi,
-                self.dem_roi_epsg,
-                z_min=0,
-                z_max=0,
-                margin=self.dem_roi_margin,
-            )
-            # change convention
-            self.dem_roi = [
-                self.roi_shareloc[1],
-                self.roi_shareloc[0],
-                self.roi_shareloc[3],
-                self.roi_shareloc[2],
-            ]
-
         if dem is not None:
-
             # fill_nodata option should be set when dealing with void in DTM
-            # see shareloc DTM limitations in sphinx doc for further details
-
+            # see shareloc DTM limitations in sphinx doc for further detailsd
             try:
+                if self.dem_roi is None:
+                    roi_shareloc = None
+                else:
+                    # From (x, y) to (y, x)
+                    roi_shareloc = [
+                        self.dem_roi[1],
+                        self.dem_roi[0],
+                        self.dem_roi[3],
+                        self.dem_roi[2],
+                    ]
                 dtm_image = dtm_reader(
-                    dem,
-                    geoid,
-                    roi=self.roi_shareloc,
+                    self.dem,
+                    self.geoid,
+                    roi=roi_shareloc,
                     roi_is_in_physical_space=True,
                     fill_nodata="mean",
                     fill_value=0.0,
@@ -141,7 +121,56 @@ class SharelocGeometry(AbstractGeometry):
         else:
             self.elevation = default_alt
 
-    def get_roi(self, pairs_for_roi, epsg, z_min=0, z_max=0, margin=0.012):
+    def check_conf(self, conf):
+        """
+        Check configuration
+
+        :param conf: configuration to check
+        :type conf: str or dict
+
+        :return: full dict
+        :rtype: dict
+
+        """
+
+        if conf is None:
+            raise RuntimeError("Geometry plugin configuration is None")
+
+        overloaded_conf = {}
+
+        if isinstance(conf, str):
+            conf = {"plugin_name": conf}
+
+        # overload conf
+        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.25, 0.02]
+        )
+
+        geometry_schema = {
+            "plugin_name": str,
+            "interpolator": And(str, lambda x: x in ["cubic", "linear"]),
+            "dem_roi_margin": [float],
+        }
+
+        # Check conf
+        checker = Checker(geometry_schema)
+        checker.validate(overloaded_conf)
+
+        return overloaded_conf
+
+    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
 
@@ -149,35 +178,17 @@ class SharelocGeometry(AbstractGeometry):
         :type pairs_for_roi: List[(str, dict, str, dict)]
         :param dem_epsg: output EPSG code for ROI
         :type dem_epsg: int
-        :param margin: margin for ROI in degrees
-        :type margin: float
+        :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
         """
+        base_roi = super().get_roi(
+            pairs_for_roi, epsg, z_min, z_max, linear_margin, constant_margin
+        )
+
         coords_list = []
-        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
-                )
-            )
+        for image1, geomodel1, _, geomodel2 in pairs_for_roi:
             # Footprint of rectification grid (with margins)
             image1 = SharelocGeometry.load_image(image1["main_file"])
             geomodel1 = self.load_geom_model(geomodel1)
@@ -204,28 +215,45 @@ class SharelocGeometry(AbstractGeometry):
             )
             lat_min, lon_min, lat_max, lon_max = list(epipolar_extent)
             coords_list.extend([(lon_min, lat_min), (lon_max, lat_max)])
+
         lon_list, lat_list = list(zip(*coords_list))  # noqa: B905
         roi = [
-            min(lat_list) - margin,
-            min(lon_list) - margin,
-            max(lat_list) + margin,
-            max(lon_list) + margin,
+            min(lon_list) - constant_margin,
+            min(lat_list) - constant_margin,
+            max(lon_list) + constant_margin,
+            max(lat_list) + constant_margin,
         ]
         points = np.array(
             [
-                (roi[1], roi[0], 0),
-                (roi[3], roi[2], 0),
-                (roi[1], roi[0], 0),
-                (roi[3], roi[2], 0),
+                (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[:, 1]),
             min(new_points[:, 0]),
-            max(new_points[:, 1]),
+            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
+
+        roi = [
+            min(roi[0], base_roi[0]),
+            min(roi[1], base_roi[1]),
+            max(roi[2], base_roi[2]),
+            max(roi[3], base_roi[3]),
         ]
+
         return roi
 
     @staticmethod
@@ -304,7 +332,7 @@ class SharelocGeometry(AbstractGeometry):
 
         return sensor, overloaded_geomodel
 
-    def triangulate(
+    def triangulate(  # pylint: disable=too-many-positional-arguments
         self,
         sensor1,
         sensor2,
@@ -315,6 +343,7 @@ class SharelocGeometry(AbstractGeometry):
         grid1: Union[dict, RectificationGrid],
         grid2: Union[dict, RectificationGrid],
         roi_key: Union[None, str] = None,
+        interpolation_method=None,
     ) -> np.ndarray:
         """
         Performs triangulation from cars disparity or matches dataset
@@ -396,6 +425,7 @@ class SharelocGeometry(AbstractGeometry):
 
         return llh
 
+    # pylint: disable=too-many-positional-arguments
     def generate_epipolar_grids(
         self,
         sensor1,
@@ -479,7 +509,7 @@ class SharelocGeometry(AbstractGeometry):
             disp_to_alt_ratio,
         )
 
-    def direct_loc(
+    def direct_loc(  # pylint: disable=too-many-positional-arguments
         self,
         sensor,
         geomodel,
@@ -524,7 +554,7 @@ class SharelocGeometry(AbstractGeometry):
             )
         return latlonalt
 
-    def inverse_loc(
+    def inverse_loc(  # pylint: disable=too-many-positional-arguments
         self,
         sensor,
         geomodel,

cars/core/inputs.py

@@ -35,7 +35,9 @@ import fiona
 import numpy as np
 import rasterio as rio
 import xarray as xr
+from affine import Affine
 from json_checker import Checker
+from pyproj import CRS
 from rasterio.warp import Resampling, calculate_default_transform, reproject
 from rasterio.windows import Window
 from shapely.geometry import shape
@@ -106,7 +108,7 @@ def rasterio_get_values(raster_file: str, x_list, y_list, proj_function):
         cloud_out = proj_function(cloud_in, 4326, file_espg)
 
         # get the transform and inverse
-        aff_tr = descriptor.transform
+        aff_tr = rasterio_get_transform(raster_file)
         np_tr = np.array(
             [
                 [aff_tr[0], aff_tr[1], aff_tr[2]],
@@ -119,17 +121,28 @@ def rasterio_get_values(raster_file: str, x_list, y_list, proj_function):
         # convert sensor to pixel coordinates
         pix_pos = np.hstack([cloud_out, np.ones((len(cloud_out), 1))])
         pix_pos = inv_tr @ pix_pos.T
-        pix_pos = pix_pos.T[:, [1, 0]].astype(int)
+        pix_pos = pix_pos.T[:, [1, 0]].astype(
+            int
+        )  # convention (row, col) i.e. (y, x)
+
+        # crop to dem bounds
+        ul_corner = np.array([0, 0])
+        lr_corner = np.array([descriptor.height, descriptor.width])
+        pix_pos_clipped = np.clip(pix_pos, ul_corner, lr_corner)
+        out_of_bounds_pix = np.any(pix_pos != pix_pos_clipped, axis=1)
+        pix_pos = pix_pos_clipped
 
         # get the data needed
         min_pt = pix_pos.min(axis=0)
         max_pt = pix_pos.max(axis=0)
 
-        width = max_pt[0] - min_pt[0] + 1
-        height = max_pt[1] - min_pt[1] + 1
-        window = Window(min_pt[1], min_pt[0], height, width)
+        height = max_pt[0] - min_pt[0] + 1
+        width = max_pt[1] - min_pt[1] + 1
+        window = Window(min_pt[1], min_pt[0], width, height)
 
         data = descriptor.read(1, window=window)
+        if data.size == 0:
+            return None
 
         # read the data for all points
         max_sampled_pos = np.array(data.shape)[:2] - 1
@@ -141,6 +154,7 @@ def rasterio_get_values(raster_file: str, x_list, y_list, proj_function):
 
         if nodata_value is not None:
             z_list[z_list == nodata_value] = np.nan
+        z_list[out_of_bounds_pix] = np.nan
 
         return z_list
 
@@ -252,19 +266,32 @@ def rasterio_get_pixel_points(raster_file: str, terrain_points) -> list:
 
     pixel_points = []
 
-    with rio.open(raster_file, "r") as descriptor:
-        for row in range(terrain_points.shape[0]):
-            pixel_points.append(
-                rio.transform.rowcol(
-                    descriptor.transform,
-                    terrain_points[row, 0],
-                    terrain_points[row, 1],
-                )
+    for row in range(terrain_points.shape[0]):
+        pixel_points.append(
+            rio.transform.rowcol(
+                rasterio_get_transform(raster_file),
+                terrain_points[row, 0],
+                terrain_points[row, 1],
             )
+        )
 
     return np.array(pixel_points)
 
 
+def rasterio_get_resolution(raster_file: str) -> Tuple[float, float]:
+    """
+    Get the resolution of raster_file
+
+    :param raster_file: Image file
+    :return: The resolution (res_x, res_y)
+    :rtype: tuple
+    """
+    transform = list(rasterio_get_transform(raster_file))
+    res_x = transform[0]
+    res_y = transform[4]
+    return (abs(res_x), abs(res_y))
+
+
 def rasterio_get_bounds(
     raster_file: str, apply_resolution_sign=False
 ) -> Tuple[int, int]:
@@ -277,8 +304,7 @@ def rasterio_get_bounds(
 
     # get sign of resolution
     if apply_resolution_sign:
-        profile = rasterio_get_profile(raster_file)
-        transform = list(profile["transform"])
+        transform = list(rasterio_get_transform(raster_file))
         res_x = transform[0]
         res_y = transform[4]
         res_x /= abs(res_x)
@@ -353,15 +379,28 @@ def rasterio_get_profile(raster_file: str) -> Dict:
         return descriptor.profile
 
 
-def rasterio_get_transform(raster_file: str) -> Dict:
+def rasterio_get_transform(raster_file: str, convention: str = None) -> Dict:
     """
     Get the transform of an image file
 
     :param raster_file: Image file
+    :param convention: The convention to follow: None, "north" or "south"
     :return: The transform of the given image
     """
-    with rio.open(raster_file, "r") as descriptor:
-        return descriptor.transform
+    with rio.open(raster_file, "r") as dsc:
+        src_tr = dsc.transform
+
+        if convention == "north" and src_tr.e < 0:
+            src_tr = Affine(
+                src_tr.a, src_tr.b, src_tr.c, -src_tr.d, -src_tr.e, -src_tr.f
+            )
+
+        elif convention == "south" and src_tr.e > 0:
+            src_tr = Affine(
+                src_tr.a, src_tr.b, src_tr.c, -src_tr.d, -src_tr.e, -src_tr.f
+            )
+
+        return src_tr
 
 
 def rasterio_get_epsg(raster_file: str) -> int:
@@ -378,6 +417,20 @@ def rasterio_get_epsg(raster_file: str) -> int:
     return epsg
 
 
+def rasterio_get_crs(raster_file: str) -> CRS:
+    """
+    Get the crs of an image file
+
+    :param raster_file: Image file
+    :return: The crs of the given image
+    """
+    crs = None
+    with rio.open(raster_file, "r") as descriptor:
+        crs = descriptor.crs
+
+    return crs
+
+
 def rasterio_transform_epsg(file_name, new_epsg):
     """
     Modify epsg of raster file
@@ -408,7 +461,7 @@ def rasterio_transform_epsg(file_name, new_epsg):
                 reproject(
                     source=rio.band(src, i),
                     destination=rio.band(dst, i),
-                    src_transform=src.transform,
+                    src_transform=rasterio_get_transform(file_name),
                     src_crs=src.crs,
                     dst_transform=transform,
                     dst_crs=new_epsg,

cars/core/outputs.py

@@ -110,7 +110,7 @@ def write_vector(polys, path_to_file, epsg, driver="GPKG"):
             vector_file.write(poly_dict)
 
 
-def rasterio_write_georaster(
+def rasterio_write_georaster(  # pylint: disable=too-many-positional-arguments
     raster_file: str,
     data: np.ndarray,
     profile: dict = None,

cars/core/preprocessing.py

@@ -72,13 +72,26 @@ def get_utm_zone_as_epsg_code(lon, lat):
         )
         return 32632
 
+    if lat > 84:
+        logging.warning(
+            "Since the latitude is above 84°, the EPSG 32661 will be used."
+        )
+        return 32661
+
+    if lat < -80:
+        logging.warning(
+            "Since the latitude is under -80°, the EPSG 32761 will be used."
+        )
+        return 32761
+
     zone = utm.from_latlon(lat, lon)[2]
 
     north_south = 600 if lat >= 0 else 700
     return 32000 + north_south + zone
 
 
-def compute_terrain_bbox(  # noqa: 751
+@cars_profile(name="Compute terrain bbox")
+def compute_terrain_bbox(  # pylint: disable=too-many-positional-arguments  # noqa: 751
     sensor_image_left,
     sensor_image_right,
     epipolar_image_left,
@@ -375,7 +388,7 @@ def compute_roi_poly(input_roi_poly, input_roi_epsg, epsg):
 
 
 @cars_profile(name="Compute epsg")
-def compute_epsg(
+def compute_epsg(  # pylint: disable=too-many-positional-arguments
     sensor_image_left,
     sensor_image_right,
     grid_left,
@@ -518,6 +531,7 @@ def crop_terrain_bounds_with_roi(roi_poly, xmin, ymin, xmax, ymax):
     return new_xmin, new_ymin, new_xmax, new_ymax
 
 
+@cars_profile(name="Compute terrain bounds")
 def compute_terrain_bounds(list_of_terrain_roi, roi_poly=None, resolution=0.5):
     """
     Compute Terrain bounds of merged pairs
@@ -650,7 +664,7 @@ def convert_optimal_tile_size_with_epsg(
 
 
 @cars_profile(name="Compute epipolar roi")
-def compute_epipolar_roi(
+def compute_epipolar_roi(  # pylint: disable=too-many-positional-arguments
     terrain_roi_poly,
     terrain_roi_epsg,
     geometry_plugin,