cars 1.0.0a2__cp312-cp312-win_amd64.whl → 1.0.0a3__cp312-cp312-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
@@ -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,6 +62,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:
@@ -100,9 +105,12 @@ 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"]
@@ -160,7 +168,9 @@ 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", float(self.scaling_coeff * 0.012)
+        )
 
         geometry_schema = {
             "plugin_name": str,
@@ -617,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,
@@ -640,6 +699,58 @@ 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,

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

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

cars/pipelines/default/default_pipeline.py

@@ -120,9 +120,6 @@ class DefaultPipeline(PipelineTemplate):
         # Check conf inputs
         inputs = self.check_inputs(conf[INPUTS], config_dir=config_dir)
 
-        # Check conf output
-        output = self.check_output(conf[OUTPUT])
-
         # Check advanced parameters
         # TODO static method in the base class
         (
@@ -132,10 +129,19 @@ class DefaultPipeline(PipelineTemplate):
             self.geom_plugin_without_dem_and_geoid,
             self.geom_plugin_with_dem_and_geoid,
             _,
+            self.scaling_coeff,
+            _,
+            _,
         ) = advanced_parameters.check_advanced_parameters(
             inputs, conf.get(ADVANCED, {}), check_epipolar_a_priori=True
         )
 
+        # Check conf output
+        (
+            output,
+            self.scaling_coeff,
+        ) = self.check_output(conf[OUTPUT], self.scaling_coeff)
+
         resolutions = advanced["epipolar_resolutions"]
         if isinstance(resolutions, int):
             resolutions = [resolutions]
@@ -254,20 +260,6 @@ class DefaultPipeline(PipelineTemplate):
                     # (except the last one)
                     self.used_conf[key][OUTPUT][out_cst.PRODUCT_LEVEL] = "dsm"
 
-                    # The idea is to calculate the less possible things
-                    # So we override those parameters
-                    self.used_conf[key][ADVANCED][adv_cst.MERGING] = False
-                    self.used_conf[key][ADVANCED][adv_cst.PHASING] = None
-                    self.used_conf[key][OUTPUT][out_cst.SAVE_BY_PAIR] = False
-
-                    aux_items = self.used_conf[key][OUTPUT][
-                        out_cst.AUXILIARY
-                    ].items()
-                    for aux_key, _ in aux_items:
-                        if aux_key not in ("dem_min", "dem_max", "dem_median"):
-                            self.used_conf[key][OUTPUT][out_cst.AUXILIARY][
-                                aux_key
-                            ] = False
                 else:
                     # If save_intermediate_data is true,
                     # we save the depth_maps also to debug
@@ -563,17 +555,19 @@ class DefaultPipeline(PipelineTemplate):
         return output_config
 
     @staticmethod
-    def check_output(conf):
+    def check_output(conf, scaling_coeff):
         """
         Check the output given
 
         :param conf: configuration of output
         :type conf: dict
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
 
         :return overloader output
         :rtype : dict
         """
-        return output_parameters.check_output_parameters(conf)
+        return output_parameters.check_output_parameters(conf, scaling_coeff)
 
     def merge_resolution_conf(self, config1, config2):
         """
@@ -629,6 +623,7 @@ class DefaultPipeline(PipelineTemplate):
         :param conf: configuration of applications
         :type conf: dict
         """
+        scaling_coeff = self.scaling_coeff
 
         # Check if all specified applications are used
         # Application in terrain_application are note used in
@@ -727,7 +722,9 @@ class DefaultPipeline(PipelineTemplate):
         if self.sensors_in_inputs:
             # Epipolar grid generation
             self.epipolar_grid_generation_application = Application(
-                "grid_generation", cfg=used_conf.get("grid_generation", {})
+                "grid_generation",
+                cfg=used_conf.get("grid_generation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["grid_generation"] = (
                 self.epipolar_grid_generation_application.get_conf()
@@ -736,7 +733,9 @@ class DefaultPipeline(PipelineTemplate):
             # image resampling
 
             self.resampling_application = Application(
-                "resampling", cfg=used_conf.get("resampling", {})
+                "resampling",
+                cfg=used_conf.get("resampling", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["resampling"] = self.resampling_application.get_conf()
 
@@ -758,10 +757,13 @@ class DefaultPipeline(PipelineTemplate):
                 self.ground_truth_reprojection = Application(
                     "ground_truth_reprojection",
                     cfg=used_conf.get("ground_truth_reprojection", {}),
+                    scaling_coeff=scaling_coeff,
                 )
             # holes detection
             self.hole_detection_app = Application(
-                "hole_detection", cfg=used_conf.get("hole_detection", {})
+                "hole_detection",
+                cfg=used_conf.get("hole_detection", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["hole_detection"] = self.hole_detection_app.get_conf()
 
@@ -772,6 +774,7 @@ class DefaultPipeline(PipelineTemplate):
                     "dense_match_filling.1",
                     {"method": "plane"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.1"] = (
                 self.dense_match_filling_1.get_conf()
@@ -784,6 +787,7 @@ class DefaultPipeline(PipelineTemplate):
                     "dense_match_filling.2",
                     {"method": "zero_padding"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.2"] = (
                 self.dense_match_filling_2.get_conf()
@@ -793,6 +797,7 @@ class DefaultPipeline(PipelineTemplate):
             self.sparse_mtch_sift_app = Application(
                 "sparse_matching",
                 cfg=used_conf.get("sparse_matching.sift", {"method": "sift"}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["sparse_matching.sift"] = (
                 self.sparse_mtch_sift_app.get_conf()
@@ -820,7 +825,9 @@ class DefaultPipeline(PipelineTemplate):
             ):
                 dense_matching_config["performance_map_method"] = "risk"
             self.dense_matching_app = Application(
-                "dense_matching", cfg=dense_matching_config
+                "dense_matching",
+                cfg=dense_matching_config,
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_matching"] = self.dense_matching_app.get_conf()
 
@@ -832,7 +839,9 @@ class DefaultPipeline(PipelineTemplate):
 
             # Triangulation
             self.triangulation_application = Application(
-                "triangulation", cfg=used_conf.get("triangulation", {})
+                "triangulation",
+                cfg=used_conf.get("triangulation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["triangulation"] = (
                 self.triangulation_application.get_conf()
@@ -840,7 +849,9 @@ class DefaultPipeline(PipelineTemplate):
 
             # MNT generation
             self.dem_generation_application = Application(
-                "dem_generation", cfg=used_conf.get("dem_generation", {})
+                "dem_generation",
+                cfg=used_conf.get("dem_generation", {}),
+                scaling_coeff=scaling_coeff,
             )
 
             height_margin = None
@@ -867,6 +878,7 @@ class DefaultPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.1",
                     {"method": "small_components"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
 
             connection_val = None
@@ -894,6 +906,7 @@ class DefaultPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.2",
                     {"method": "statistical"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["point_cloud_outlier_removal.2"] = (
                 self.pc_outlier_removal_2_app.get_conf()
@@ -905,6 +918,7 @@ class DefaultPipeline(PipelineTemplate):
             self.pc_denoising_application = Application(
                 "pc_denoising",
                 cfg=used_conf.get("pc_denoising", {"method": "none"}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["pc_denoising"] = self.pc_denoising_application.get_conf()
 
@@ -914,6 +928,7 @@ class DefaultPipeline(PipelineTemplate):
                 self.rasterization_application = Application(
                     "point_cloud_rasterization",
                     cfg=used_conf.get("point_cloud_rasterization", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["point_cloud_rasterization"] = (
                     self.rasterization_application.get_conf()
@@ -925,6 +940,7 @@ class DefaultPipeline(PipelineTemplate):
                         "dsm_filling.1",
                         {"method": "exogenous_filling"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.1"] = (
                     self.dsm_filling_1_application.get_conf()
@@ -947,13 +963,16 @@ class DefaultPipeline(PipelineTemplate):
                         "dsm_filling.3",
                         {"method": "border_interpolation"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.3"] = (
                     self.dsm_filling_3_application.get_conf()
                 )
                 # Auxiliary filling
                 self.auxiliary_filling_application = Application(
-                    "auxiliary_filling", cfg=conf.get("auxiliary_filling", {})
+                    "auxiliary_filling",
+                    cfg=conf.get("auxiliary_filling", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["auxiliary_filling"] = (
                     self.auxiliary_filling_application.get_conf()
@@ -965,6 +984,7 @@ class DefaultPipeline(PipelineTemplate):
                 self.pc_fusion_application = Application(
                     "point_cloud_fusion",
                     cfg=used_conf.get("point_cloud_fusion", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["point_cloud_fusion"] = (
                     self.pc_fusion_application.get_conf()