cars 1.0.0a1__cp313-cp313-win_amd64.whl → 1.0.0a3__cp313-cp313-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,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
@@ -50,7 +53,7 @@ class AbstractGeometry(metaclass=ABCMeta):
 
     available_plugins: Dict = {}
 
-    def __new__(cls, geometry_plugin_conf=None, **kwargs):
+    def __new__(cls, geometry_plugin_conf=None, scaling_coeff=1, **kwargs):
         """
         Return the required plugin
         :raises:
@@ -59,13 +62,17 @@ 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:
             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")
 
@@ -98,13 +105,17 @@ class AbstractGeometry(metaclass=ABCMeta):
         dem=None,
         geoid=None,
         default_alt=None,
+        scaling_coeff=1,
         **kwargs,
     ):
 
+        self.scaling_coeff = scaling_coeff
+
         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.dem_roi = None
@@ -153,12 +164,18 @@ 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", float(self.scaling_coeff * 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 +389,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 +403,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 +422,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,
             ),
@@ -583,6 +627,55 @@ class AbstractGeometry(metaclass=ABCMeta):
         :return: Latitude, Longitude, Altitude coordinates list as a numpy array
         """
 
+    def safe_direct_loc(
+        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
+        """
+        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(
         self,
@@ -606,8 +699,65 @@ class AbstractGeometry(metaclass=ABCMeta):
         :return: X  / Y / Z Coordinates list in input image as a numpy array
         """
 
+    def safe_inverse_loc(
+        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
+        """
+        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(
-        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 +779,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)

cars/core/geometry/shareloc_geometry.py

@@ -63,6 +63,7 @@ class SharelocGeometry(AbstractGeometry):
         geoid=None,
         default_alt=None,
         pairs_for_roi=None,
+        scaling_coeff=1,
     ):
 
         super().__init__(
@@ -71,6 +72,7 @@ class SharelocGeometry(AbstractGeometry):
             geoid=geoid,
             default_alt=default_alt,
             pairs_for_roi=pairs_for_roi,
+            scaling_coeff=scaling_coeff,
         )
 
         self.dem_roi = None
@@ -91,7 +93,11 @@ class SharelocGeometry(AbstractGeometry):
                 self.dem_roi_epsg = inputs.rasterio_get_epsg(dem)
 
             self.roi_shareloc = self.get_roi(
-                pairs_for_roi, self.dem_roi_epsg, margin=0.012
+                pairs_for_roi,
+                self.dem_roi_epsg,
+                z_min=0,
+                z_max=0,
+                margin=self.dem_roi_margin,
             )
             # change convention
             self.dem_roi = [
@@ -105,14 +111,26 @@ class SharelocGeometry(AbstractGeometry):
 
             # fill_nodata option should be set when dealing with void in DTM
             # see shareloc DTM limitations in sphinx doc for further details
-            dtm_image = dtm_reader(
-                dem,
-                geoid,
-                roi=self.roi_shareloc,
-                roi_is_in_physical_space=True,
-                fill_nodata="mean",
-                fill_value=0.0,
-            )
+
+            try:
+                dtm_image = dtm_reader(
+                    dem,
+                    geoid,
+                    roi=self.roi_shareloc,
+                    roi_is_in_physical_space=True,
+                    fill_nodata="mean",
+                    fill_value=0.0,
+                )
+            except RuntimeError as err:
+                mss = "the roi bounds are"
+                if mss in str(err):
+                    new_except_mss = (
+                        f"The extent of the roi lies outside "
+                        f"the extent of the initial elevation : {err}"
+                    )
+                    raise RuntimeError(new_except_mss) from err
+                raise
+
             self.elevation = (
                 bindings_cpp.DTMIntersection(  # pylint: disable=I1101
                     dtm_image.epsg,
@@ -125,7 +143,7 @@ class SharelocGeometry(AbstractGeometry):
         else:
             self.elevation = default_alt
 
-    def get_roi(self, pairs_for_roi, epsg, margin=0.006):
+    def get_roi(self, pairs_for_roi, epsg, z_min=0, z_max=0, margin=0.012):
         """
         Compute region of interest for intersection of DEM
 
@@ -138,27 +156,56 @@ class SharelocGeometry(AbstractGeometry):
         """
         coords_list = []
         for image1, geomodel1, image2, geomodel2 in pairs_for_roi:
-            # Footprint of left image
+            # Footprint of left image with altitude z_min
             coords_list.extend(
-                self.image_envelope(image1["main_file"], geomodel1)
+                self.image_envelope(
+                    image1["main_file"], geomodel1, elevation=z_min
+                )
             )
-            # Footprint of right image
+            # Footprint of left image with altitude z_max
             coords_list.extend(
-                self.image_envelope(image2["main_file"], geomodel2)
+                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
+                )
             )
             # Footprint of rectification grid (with margins)
             image1 = SharelocGeometry.load_image(image1["main_file"])
             geomodel1 = self.load_geom_model(geomodel1)
             geomodel2 = self.load_geom_model(geomodel2)
+
+            # With altitude z_min
             epipolar_extent = rectif.get_epipolar_extent(
                 image1,
                 geomodel1,
                 geomodel2,
+                elevation=z_min,
                 grid_margin=self.rectification_grid_margin,
             )
             lat_min, lon_min, lat_max, lon_max = list(epipolar_extent)
             coords_list.extend([(lon_min, lat_min), (lon_max, lat_max)])
 
+            # With altitude z_max
+            epipolar_extent = rectif.get_epipolar_extent(
+                image1,
+                geomodel1,
+                geomodel2,
+                elevation=z_max,
+                grid_margin=self.rectification_grid_margin,
+            )
+            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,

cars/core/inputs.py

@@ -36,6 +36,7 @@ import numpy as np
 import rasterio as rio
 import xarray as xr
 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
@@ -378,6 +379,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

cars/core/projection.py

@@ -182,6 +182,22 @@ def polygon_projection(poly: Polygon, epsg_in: int, epsg_out: int) -> Polygon:
     return poly
 
 
+def polygon_projection_crs(poly: Polygon, crs_in: CRS, crs_out: CRS) -> Polygon:
+    """
+    Projects a polygon from an initial crs to another
+
+    :param poly: poly to project
+    :param crs_in: initial crs
+    :param crs_out: final crs
+    :return: The polygon in the final projection
+    """
+    # Project polygon between CRS (keep always_xy for compatibility)
+    project = pyproj.Transformer.from_crs(crs_in, crs_out, always_xy=True)
+    poly = transform(project.transform, poly)
+
+    return poly
+
+
 def geo_to_ecef(
     lat: np.ndarray, lon: np.ndarray, alt: np.ndarray
 ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -351,6 +367,27 @@ def point_cloud_conversion(
     return cloud_in
 
 
+def point_cloud_conversion_crs(
+    cloud_in: np.ndarray, crs_in: int, crs_out: int
+) -> np.ndarray:
+    """
+    Convert a point cloud from a SRS to another one.
+
+    :param cloud_in: cloud to project
+    :param crs_in: crs of the input SRS
+    :param crs_out: crs of the output SRS
+    :return: Projected point cloud
+    """
+    # Project point cloud between CRS (keep always_xy for compatibility)
+    cloud_in = np.array(cloud_in).T
+    transformer = pyproj.Transformer.from_crs(crs_in, crs_out, always_xy=True)
+
+    cloud_in = transformer.transform(*cloud_in)
+    cloud_in = np.array(cloud_in).T
+
+    return cloud_in
+
+
 def get_xyz_np_array_from_dataset(
     cloud_in: xr.Dataset,
 ) -> Tuple[np.array, List[int]]:
@@ -721,3 +758,83 @@ def get_ground_angles(
     convergence_angle = np.degrees(utils.angle_vectors(enu1, enu2))
 
     return az1, elev_angle1, az2, elev_angle2, convergence_angle
+
+
+def get_output_crs(epsg, out_conf):
+    """
+    Détermine le CRS de sortie en fonction de la config.
+    """
+    geoid = out_conf.get("geoid")
+    crs_epsg = CRS(f"EPSG:{epsg}")
+
+    if len(crs_epsg.axis_info) != 2:
+        return crs_epsg  # the user himself set a 3D CRS
+
+    geoid_is_path = isinstance(geoid, str)
+
+    if geoid_is_path:  # user given geoid
+        vepsg = guess_vcrs_from_file_name(geoid)
+        if vepsg is None:
+            custom_wkt = (
+                'VERTCRS["Custom geoid height",'
+                + f'    VDATUM["Custom geoid model (file: {geoid})"],'
+                + "    CS[vertical,1],"
+                + '    AXIS["gravity-related height (h)", up],'
+                + '    LENGTHUNIT["metre", 1, ID["EPSG", 9001]]'
+                "]"
+            )
+            logging.warning(
+                "Could not create a known VCRS from the geoid file."
+            )
+            return CRS.from_wkt(
+                f'COMPOUNDCRS["EPSG:{epsg} + Custom geoid height",'
+                f"    {crs_epsg.to_wkt()},"
+                f"    {custom_wkt}]"
+            )
+        # a vepsg was found using the geoid file
+        return CRS(f"EPSG:{epsg}+{vepsg}")
+
+    if geoid:  # geoid == True
+        return CRS(f"EPSG:{epsg}+5773")
+
+    # geoid == False
+    wgs84_wkt = (
+        'VERTCRS["WGS 84 ellipsoidal height",'
+        + '    VDATUM["WGS 84"],'
+        + "    CS[vertical,1],"
+        + '    AXIS["ellipsoidal height (h)", up],'
+        + '    LENGTHUNIT["metre", 1, ID["EPSG", 9001]]'
+        "]"
+    )
+    logging.warning("The output VCRS is WGS84.")
+
+    return CRS.from_wkt(
+        f'COMPOUNDCRS["EPSG:{epsg} + WGS84 ellipsoidal height",'
+        f"    {crs_epsg.to_wkt()},"
+        f"    {wgs84_wkt}]"
+    )
+
+
+def guess_vcrs_from_file_name(filepath):
+    """
+    Tries to detect the geoid's EPSG from the file name
+    """
+    filename = os.path.basename(filepath).lower()
+
+    known_models = {
+        "egm96": 5773,  # EGM96 height
+        "egm_96": 5773,  # alias
+        "egm 96": 5773,  # alias
+        "egm1996": 5773,  # alias
+        "egm08": 3855,  # EGM2008 height
+        "egm_08": 3855,  # alias
+        "egm 08": 3855,  # alias
+        "egm2008": 3855,  # alias
+    }
+
+    for key, vepsg in known_models.items():
+        if key in filename:
+            return vepsg
+
+    # aucun match connu
+    return None

cars/data_structures/cars_dataset.py

@@ -38,6 +38,7 @@ from typing import Dict
 # Third party imports
 import numpy as np
 import pandas
+import pyproj
 import rasterio as rio
 import xarray as xr
 from rasterio.profiles import DefaultGTiffProfile
@@ -1327,12 +1328,13 @@ def dict_profile_to_rio_profile(dict_profile: Dict) -> Dict:
     crs = None
     if "crs" in dict_profile:
         if dict_profile["crs"] is not None:
-            if isinstance(dict_profile["crs"], str):
-                crs = rio.crs.CRS.from_epsg(
-                    dict_profile["crs"].replace("EPSG:", "")
-                )
+            if (
+                isinstance(dict_profile["crs"], str)
+                and "EPSG:" in dict_profile["crs"]
+            ):
+                crs = pyproj.CRS(dict_profile["crs"].replace("EPSG:", ""))
             else:
-                crs = rio.crs.CRS.from_epsg(dict_profile["crs"])
+                crs = pyproj.CRS(dict_profile["crs"])
 
     rio_profile["crs"] = crs
     rio_profile["transform"] = transform

cars/orchestrator/cluster/log_wrapper.py

@@ -21,7 +21,7 @@
 """
 Contains functions for wrapper logs
 """
-# pylint: disable=too-many-lines
+# pylint: disable=C0302
 
 import copy
 import cProfile

cars/orchestrator/cluster/mp_cluster/multiprocessing_cluster.py

@@ -21,7 +21,7 @@
 """
 Contains abstract function for multiprocessing Cluster
 """
-# pylint: disable=too-many-lines
+# pylint: disable=C0302
 
 import copy
 import itertools

cars/orchestrator/orchestrator.py

@@ -22,7 +22,7 @@
 this module contains the orchestrator class
 """
 
-# pylint: disable=too-many-lines
+# pylint: disable=C0302
 
 import collections
 import logging