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

cars/applications/dense_matching/loaders/pandora_loader.py

@@ -31,6 +31,7 @@ from typing import Dict
 
 import numpy as np
 import pandora
+import rasterio
 from json_checker import Checker, Or
 from pandora.check_configuration import (
     check_pipeline_section,
@@ -40,6 +41,10 @@ from pandora.check_configuration import (
 )
 from pandora.img_tools import get_metadata
 from pandora.state_machine import PandoraMachine
+from rasterio.mask import mask
+from shapely.geometry import mapping
+
+from cars.core.projection import polygon_projection
 
 
 class PandoraLoader:
@@ -135,7 +140,7 @@ class PandoraLoader:
                 # read conf
                 with open(conf_file_path, "r", encoding="utf8") as fstream:
                     conf = json.load(fstream)
-            elif method_name == "census_sgm_default":
+            elif method_name in ("census_sgm_default", "auto"):
                 # Use census sgm conf
                 conf_file_path = os.path.join(
                     package_path, "config_census_sgm_default.json"
@@ -300,6 +305,78 @@ class PandoraLoader:
 
         return self.pandora_config
 
+    def find_auto_conf(
+        self, intersection_poly, land_cover_map, classif_to_config_mapping, epsg
+    ):
+        """
+        Find the configuration that suits the most on the
+        land cover map based on the roi
+        """
+        package_path = os.path.dirname(__file__)
+
+        # construct the path to the land_cover_map
+        if os.path.dirname(land_cover_map) == "":
+            land_cover_map_path = os.path.join(package_path, land_cover_map)
+        else:
+            land_cover_map_path = land_cover_map
+
+        with rasterio.open(land_cover_map_path) as src:
+            # Project the polygon to the right epsg
+            if src.crs != epsg:
+                poly = polygon_projection(
+                    intersection_poly, epsg, src.crs.to_epsg()
+                )
+            else:
+                poly = intersection_poly
+
+            # Use a buffer because the land_cover_map resolution is coarse
+            data_land_cover, _ = mask(
+                src, [mapping(poly)], crop=True, all_touched=True
+            )
+
+            # Find the most common class in the roi
+            data_squeeze = data_land_cover.squeeze()
+            valid_data = data_squeeze[data_squeeze != src.nodata]
+
+            most_common_class = None
+            if valid_data.size > 0:
+                classes, counts = np.unique(valid_data, return_counts=True)
+                max_index = np.argmax(counts)
+                most_common_class = classes[max_index]
+
+        # Construct the path to the classification to configuration mapping
+        if os.path.dirname(classif_to_config_mapping) == "":
+            conf_file_path = os.path.join(
+                package_path, classif_to_config_mapping
+            )
+        else:
+            conf_file_path = classif_to_config_mapping
+
+        # read conf
+        with open(conf_file_path, "r", encoding="utf8") as fstream:
+            conf_mapping = json.load(fstream)
+
+        # Find the configuration that corresponds to the most common class
+        corresponding_conf_name = conf_mapping.get(str(most_common_class), None)
+
+        # If no equivalence has been found, we use the default configuration
+        if corresponding_conf_name is None:
+            corresponding_conf_name = "census_sgm_default"
+
+        logging.info(
+            "The conf that has been chosen regarding the "
+            "world classification map is {}".format(corresponding_conf_name)
+        )
+
+        # We return the corresponding configuration
+        json_conf_name = os.path.join(
+            package_path, "config_" + corresponding_conf_name + ".json"
+        )
+        with open(json_conf_name, "r", encoding="utf8") as fstream:
+            conf = json.load(fstream)
+
+        return conf
+
     def check_conf(
         self,
         user_cfg,

cars/applications/dsm_filling/border_interpolation_app.py

@@ -31,6 +31,7 @@ import rasterio as rio
 import scipy
 import skimage
 from json_checker import Checker, Or
+from pyproj import CRS
 from shapely import Polygon
 
 from cars.core import inputs, projection
@@ -74,7 +75,11 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer")
         overloaded_conf["activated"] = conf.get("activated", False)
-        overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["classification"] = conf.get("classification", "nodata")
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
         overloaded_conf["component_min_size"] = conf.get(
             "component_min_size", 5
         )
@@ -151,8 +156,8 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
             roi_polys_outepsg = []
             for poly in roi_polys:
                 if isinstance(poly, Polygon):
-                    roi_poly_outepsg = projection.polygon_projection(
-                        poly, roi_epsg, dsm_crs.to_epsg()
+                    roi_poly_outepsg = projection.polygon_projection_crs(
+                        poly, CRS(roi_epsg), dsm_crs
                     )
                     roi_polys_outepsg.append(roi_poly_outepsg)
 
@@ -160,8 +165,8 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
                 roi_polys_outepsg, out_shape=roi_raster.shape, transform=dsm_tr
             )
         elif isinstance(roi_polys, Polygon):
-            roi_poly_outepsg = projection.polygon_projection(
-                roi_polys, roi_epsg, dsm_crs.to_epsg()
+            roi_poly_outepsg = projection.polygon_projection_crs(
+                roi_polys, CRS(roi_epsg), dsm_crs
             )
             roi_raster = rio.features.rasterize(
                 [roi_poly_outepsg], out_shape=roi_raster.shape, transform=dsm_tr

cars/applications/dsm_filling/bulldozer_filling_app.py

@@ -32,6 +32,7 @@ import rasterio as rio
 import yaml
 from bulldozer.pipeline.bulldozer_pipeline import dsm_to_dtm
 from json_checker import Checker, Or
+from pyproj import CRS
 from shapely import Polygon
 
 from cars.core import inputs, projection
@@ -72,7 +73,13 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer")
         overloaded_conf["activated"] = conf.get("activated", False)
-        overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["classification"] = conf.get("classification", "nodata")
+
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
+
         overloaded_conf["save_intermediate_data"] = conf.get(
             "save_intermediate_data", False
         )
@@ -162,8 +169,8 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
             roi_polys_outepsg = []
             for poly in roi_polys:
                 if isinstance(poly, Polygon):
-                    roi_poly_outepsg = projection.polygon_projection(
-                        poly, roi_epsg, dsm_crs.to_epsg()
+                    roi_poly_outepsg = projection.polygon_projection_crs(
+                        poly, CRS(roi_epsg), dsm_crs
                     )
                     roi_polys_outepsg.append(roi_poly_outepsg)
 
@@ -171,8 +178,8 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
                 roi_polys_outepsg, out_shape=roi_raster.shape, transform=dsm_tr
             )
         elif isinstance(roi_polys, Polygon):
-            roi_poly_outepsg = projection.polygon_projection(
-                roi_polys, roi_epsg, dsm_crs.to_epsg()
+            roi_poly_outepsg = projection.polygon_projection_crs(
+                roi_polys, CRS(roi_epsg), dsm_crs
             )
             roi_raster = rio.features.rasterize(
                 [roi_poly_outepsg], out_shape=roi_raster.shape, transform=dsm_tr
@@ -211,7 +218,7 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
             with rio.open(old_dsm_path, "w", **dsm_meta) as out_dsm:
                 out_dsm.write(dsm, 1)
 
-        if classif_file is not None:
+        if classif_file is not None and os.path.exists(classif_file):
             classif_descriptions = inputs.get_descriptions_bands(classif_file)
         else:
             classif_descriptions = []
@@ -225,7 +232,7 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
                 classif[classif_msk == 0] = 0
                 filling_mask = np.logical_and(classif, roi_raster > 0)
             elif label == "nodata":
-                if classif_file is not None:
+                if classif_file is not None and os.path.exists(classif_file):
                     with rio.open(classif_file) as in_classif:
                         classif_msk = in_classif.read_masks(1)
                     classif = ~classif_msk

cars/applications/dsm_filling/exogenous_filling_app.py

@@ -29,6 +29,7 @@ import shutil
 import numpy as np
 import rasterio as rio
 from json_checker import Checker, Or
+from pyproj import CRS
 from rasterio.enums import Resampling
 from rasterio.warp import reproject
 from shapely import Polygon
@@ -73,7 +74,11 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer")
         overloaded_conf["activated"] = conf.get("activated", False)
-        overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["classification"] = conf.get("classification", "nodata")
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
         overloaded_conf["fill_with_geoid"] = conf.get("fill_with_geoid", None)
         overloaded_conf["interpolation_method"] = conf.get(
             "interpolation_method", "bilinear"
@@ -170,8 +175,8 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
             roi_polys_outepsg = []
             for poly in roi_polys:
                 if isinstance(poly, Polygon):
-                    roi_poly_outepsg = projection.polygon_projection(
-                        poly, roi_epsg, dsm_crs.to_epsg()
+                    roi_poly_outepsg = projection.polygon_projection_crs(
+                        poly, CRS(roi_epsg), dsm_crs
                     )
                     roi_polys_outepsg.append(roi_poly_outepsg)
 
@@ -179,8 +184,8 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
                 roi_polys_outepsg, out_shape=roi_raster.shape, transform=dsm_tr
             )
         elif isinstance(roi_polys, Polygon):
-            roi_poly_outepsg = projection.polygon_projection(
-                roi_polys, roi_epsg, dsm_crs.to_epsg()
+            roi_poly_outepsg = projection.polygon_projection_crs(
+                roi_polys, CRS(roi_epsg), dsm_crs
             )
             roi_raster = rio.features.rasterize(
                 [roi_poly_outepsg], out_shape=roi_raster.shape, transform=dsm_tr

cars/applications/point_cloud_outlier_removal/abstract_outlier_removal_app.py

@@ -31,7 +31,7 @@ import numpy as np
 
 from cars.applications import application_constants
 from cars.applications.application import Application
-from cars.applications.application_template import ApplicationTemplate
+from cars.applications.application_template import ScalingApplicationTemplate
 from cars.applications.point_cloud_outlier_removal import (
     outlier_removal_constants as pr_cst,
 )
@@ -41,7 +41,7 @@ from cars.data_structures import cars_dataset
 
 
 @Application.register("point_cloud_outlier_removal")
-class PointCloudOutlierRemoval(ApplicationTemplate, metaclass=ABCMeta):
+class PointCloudOutlierRemoval(ScalingApplicationTemplate, metaclass=ABCMeta):
     """
     PointCloudOutlierRemoval
     """
@@ -49,12 +49,14 @@ class PointCloudOutlierRemoval(ApplicationTemplate, metaclass=ABCMeta):
     available_applications: Dict = {}
     default_application = "statistical"
 
-    def __new__(cls, conf=None):  # pylint: disable=W0613
+    def __new__(cls, scaling_coeff, conf=None):  # pylint: disable=W0613
         """
         Return the required application
         :raises:
          - KeyError when the required application is not registered
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration for points removal
         :return: a application_to_use object
         """
@@ -95,15 +97,17 @@ class PointCloudOutlierRemoval(ApplicationTemplate, metaclass=ABCMeta):
         cls.orchestrator = None
         cls.available_applications[short_name] = cls
 
-    def __init__(self, conf=None):
+    def __init__(self, scaling_coeff, conf=None):
         """
         Init function of PointCloudOutlierRemoval
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration
         :return: an application_to_use object
         """
 
-        super().__init__(conf=conf)
+        super().__init__(scaling_coeff, conf=conf)
 
     @abstractmethod
     def get_on_ground_margin(self, resolution=0.5):

cars/applications/point_cloud_outlier_removal/small_components_app.py

@@ -64,15 +64,17 @@ class SmallComponents(
 
     # pylint: disable=too-many-instance-attributes
 
-    def __init__(self, conf=None):
+    def __init__(self, scaling_coeff, conf=None):
         """
         Init function of SmallComponents
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration for points outlier removal
         :return: an application_to_use object
         """
 
-        super().__init__(conf=conf)
+        super().__init__(scaling_coeff, conf=conf)
 
         self.used_method = self.used_config["method"]
 
@@ -131,7 +133,7 @@ class SmallComponents(
         # pts_connection_dist:
         #           distance to use to consider that two points are connected
         overloaded_conf["connection_distance"] = conf.get(
-            "connection_distance", 3.0
+            "connection_distance", self.scaling_coeff * 3.0
         )
         # nb_pts_threshold:
         #           points clusters that have less than this number of points

cars/applications/point_cloud_outlier_removal/statistical_app.py

@@ -68,15 +68,17 @@ class Statistical(
 
     # pylint: disable=too-many-instance-attributes
 
-    def __init__(self, conf=None):
+    def __init__(self, scaling_coeff, conf=None):
         """
         Init function of Statistical
 
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
         :param conf: configuration for points outlier removal
         :return: a application_to_use object
         """
 
-        super().__init__(conf=conf)
+        super().__init__(scaling_coeff, conf=conf)
 
         self.used_method = self.used_config["method"]
 

cars/applications/rasterization/abstract_pc_rasterization_app.py

@@ -131,6 +131,7 @@ class PointCloudRasterization(ApplicationTemplate, metaclass=ABCMeta):
         self,
         point_clouds,
         epsg,
+        output_crs,
         resolution,
         orchestrator=None,
         dsm_file_name=None,

cars/applications/rasterization/simple_gaussian_app.py

@@ -208,6 +208,7 @@ class SimpleGaussian(
         self,
         point_clouds,
         epsg,
+        output_crs,
         resolution,
         orchestrator=None,
         dsm_file_name=None,
@@ -256,6 +257,8 @@ class SimpleGaussian(
         :type point_clouds: CarsDataset filled with pandas.DataFrame
         :param epsg: epsg of raster data
         :type epsg: str
+        :param output_crs: output_crs of raster data
+        :type output_crs: str
         :param resolution: resolution of raster data (in target CRS unit)
         :type resolution: float
         :param orchestrator: orchestrator used
@@ -267,7 +270,7 @@ class SimpleGaussian(
         :type color_file_name: str
         :param mask_file_name: path of color
         :type mask_file_name: str
-        :param classif_file_name: path of color
+        :param classif_file_name: path of classification
         :type classif_file_name: str
         :param performance_map_file_name: path of performance map file
         :type performance_map_file_name: str
@@ -317,6 +320,27 @@ class SimpleGaussian(
         # Get if color, mask and stats are saved
         save_intermediate_data = self.used_config["save_intermediate_data"]
 
+        keep_dir = (
+            len(
+                list(
+                    filter(
+                        lambda x: x is not None,
+                        [
+                            weights_file_name,
+                            color_file_name,
+                            mask_file_name,
+                            classif_file_name,
+                            performance_map_file_name,
+                            ambiguity_file_name,
+                            contributing_pair_file_name,
+                            filling_file_name,
+                        ],
+                    )
+                )
+            )
+            > 0
+        )
+
         if not self.color_dtype:
             self.color_dtype = color_dtype
 
@@ -333,7 +357,7 @@ class SimpleGaussian(
         if dump_dir is not None:
             out_dump_dir = dump_dir
             safe_makedirs(dump_dir)
-            if not save_intermediate_data:
+            if not save_intermediate_data and not keep_dir:
                 self.orchestrator.add_to_clean(dump_dir)
         else:
             out_dump_dir = self.orchestrator.out_dir
@@ -512,6 +536,7 @@ class SimpleGaussian(
             out_classif_file_name = os.path.join(
                 out_dump_dir, "classification.tif"
             )
+
         if out_classif_file_name is not None:
             list_computed_layers += ["classif"]
             self.orchestrator.add_to_save_lists(
@@ -817,7 +842,7 @@ class SimpleGaussian(
                 "driver": "GTiff",
                 "dtype": "float32",
                 "transform": transform,
-                "crs": "EPSG:{}".format(epsg),
+                "crs": output_crs.to_wkt(),
                 "tiled": True,
             }
         )

cars/applications/resampling/resampling_algo.py

@@ -284,14 +284,10 @@ def resample_image(  # noqa: C901
             (nb_bands, region[3] - region[1], region[2] - region[0]),
             dtype=np.float32,
         )
-        nodata = 0
-        if nodata is not None or mask is not None:
-            msk = np.empty(
-                (nb_bands, region[3] - region[1], region[2] - region[0]),
-                dtype=np.float32,
-            )
-        else:
-            msk = None
+        msk = np.empty(
+            (nb_bands, region[3] - region[1], region[2] - region[0]),
+            dtype=np.float32,
+        )
 
         ystart = 0
         with rio.open(grid["path"]) as grid_reader, rio.open(img) as img_reader:
@@ -513,51 +509,50 @@ def oversampling_func(
     resamp[:, ystart : ystart + ysize, xstart : xstart + xsize] = block_resamp
 
     # create msk
-    if nodata is not None or mask is not None:
-        if in_sensor:
-            # get mask in source geometry
-            nodata_index = img_as_array == nodata
-
-            if mask is not None:
-                with rio.open(mask) as msk_reader:
-                    msk_as_array = msk_reader.read(1, window=img_window)
-                msk_as_array = np.array([msk_as_array] * img_as_array.shape[0])
-            else:
-                msk_as_array = np.zeros(img_as_array.shape)
+    if in_sensor:
+        # get mask in source geometry
+        if mask is not None:
+            with rio.open(mask) as msk_reader:
+                msk_as_array = msk_reader.read(1, window=img_window)
+            msk_as_array = np.array([msk_as_array] * img_as_array.shape[0])
+        else:
+            msk_as_array = np.zeros(img_as_array.shape)
 
+        if nodata is not None:
+            nodata_index = img_as_array == nodata
             msk_as_array[nodata_index] = nodata_msk
 
-            # resample mask
-            block_msk = cresample.grid(
-                msk_as_array,
-                grid_as_array,
-                oversampling,
-                interpolator=interpolator_mask,
-                nodata=nodata_msk,
-            )
+        # resample mask
+        block_msk = cresample.grid(
+            msk_as_array,
+            grid_as_array,
+            oversampling,
+            interpolator=interpolator_mask,
+            nodata=nodata_msk,
+        )
 
-            if interpolator_mask == "bicubic":
-                block_msk = np.where(
-                    block_msk >= 0.5,
-                    1,
-                    np.where(block_msk < 0.5, 0, block_msk),
-                ).astype(int)
-
-            block_msk = block_msk[
-                ...,
-                ext_region[1] : ext_region[3] - 1,
-                ext_region[0] : ext_region[2] - 1,
-            ]
-        else:
-            block_msk = np.full(
-                (
-                    nb_bands,
-                    block_region[3] - block_region[1],
-                    block_region[2] - block_region[0],
-                ),
-                fill_value=nodata_msk,
-            )
+        if interpolator_mask == "bicubic":
+            block_msk = np.where(
+                block_msk >= 0.5,
+                1,
+                np.where(block_msk < 0.5, 0, block_msk),
+            ).astype(int)
+
+        block_msk = block_msk[
+            ...,
+            ext_region[1] : ext_region[3] - 1,
+            ext_region[0] : ext_region[2] - 1,
+        ]
+    else:
+        block_msk = np.full(
+            (
+                nb_bands,
+                block_region[3] - block_region[1],
+                block_region[2] - block_region[0],
+            ),
+            fill_value=nodata_msk,
+        )
 
-        msk[:, ystart : ystart + ysize, xstart : xstart + xsize] = block_msk
+    msk[:, ystart : ystart + ysize, xstart : xstart + xsize] = block_msk
 
     return resamp, msk

cars/applications/sparse_matching/sift_app.py

@@ -224,7 +224,7 @@ class Sift(SparseMatching, short_name=["sift"]):
             "sift_matching_threshold": And(float, lambda x: x > 0),
             "sift_n_octave": And(int, lambda x: x > 0),
             "sift_n_scale_per_octave": And(int, lambda x: x > 0),
-            "sift_peak_threshold": Or(float, None),
+            "sift_peak_threshold": Or(float, int),
             "sift_edge_threshold": float,
             "sift_magnification": And(float, lambda x: x > 0),
             "sift_window_size": And(int, lambda x: x > 0),
@@ -514,26 +514,6 @@ class Sift(SparseMatching, short_name=["sift"]):
             epipolar_disparity_map_left.attributes.update(
                 epipolar_image_left.attributes
             )
-            # check sift_peak_threshold with image type
-            # only if sift_peak_threshold is None
-            tmp_sift_peak_threshold = self.sift_peak_threshold
-            if not self.sift_peak_threshold:
-                logging.info("The sift_peak_threshold is set to auto-mode.")
-                # sift_peak_threshold is None or not specified
-                # check input type
-                if np.issubdtype(
-                    epipolar_disparity_map_left.attributes["image_type"],
-                    np.uint8,
-                ):
-                    tmp_sift_peak_threshold = 1
-                else:
-                    tmp_sift_peak_threshold = 20
-                logging.info(
-                    "The sift_peak_threshold will be set to {}.".format(
-                        tmp_sift_peak_threshold
-                    )
-                )
-                self.sift_peak_threshold = tmp_sift_peak_threshold
 
             # Save disparity maps
             if self.save_intermediate_data:
@@ -628,7 +608,7 @@ class Sift(SparseMatching, short_name=["sift"]):
                         matching_threshold=self.sift_matching_threshold,
                         n_octave=self.sift_n_octave,
                         n_scale_per_octave=self.sift_n_scale_per_octave,
-                        peak_threshold=tmp_sift_peak_threshold,
+                        peak_threshold=self.sift_peak_threshold,
                         edge_threshold=self.sift_edge_threshold,
                         magnification=self.sift_magnification,
                         window_size=self.sift_window_size,