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

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/grid_generation/grid_correction_app.py

@@ -31,7 +31,6 @@ import os
 
 # Third party imports
 import numpy as np
-import pandas
 import rasterio as rio
 from scipy.interpolate import LinearNDInterpolator
 from scipy.spatial import Delaunay  # pylint: disable=E0611
@@ -45,7 +44,6 @@ from cars.applications.grid_generation import (
 from cars.core.utils import safe_makedirs
 
 # CARS imports
-from cars.data_structures import cars_dataset
 from cars.orchestrator.cluster.log_wrapper import cars_profile
 
 
@@ -171,7 +169,6 @@ def correct_grid(grid, grid_correction, pair_folder, save_grid=None):
 def estimate_right_grid_correction(
     matches,
     grid_right,
-    initial_cars_ds=None,
     save_matches=False,
     minimum_nb_matches=100,
     pair_folder="",
@@ -480,13 +477,6 @@ def estimate_right_grid_correction(
         )
         np.save(matches_array_path, corrected_matches)
 
-    # Create CarsDataset containing corrected matches, with same tiling as input
-    corrected_matches_cars_ds = None
-    if initial_cars_ds is not None:
-        corrected_matches_cars_ds = create_matches_cars_ds(
-            corrected_matches, initial_cars_ds
-        )
-
     # Update orchestrator out_json
     corrected_matches_infos = {
         application_constants.APPLICATION_TAG: {
@@ -498,49 +488,6 @@ def estimate_right_grid_correction(
     return (
         grid_correction,
         corrected_matches,
-        corrected_matches_cars_ds,
         in_stats,
         out_stats,
     )
-
-
-def create_matches_cars_ds(corrected_matches, initial_cars_ds):
-    """
-    Create CarsDataset representing matches, from numpy matches.
-    Matches are split into tiles, stored in pandas DataFrames
-
-    Right CarsDataset is filled with Nones
-
-    :param corrected_matches: matches
-    :type corrected_matches: numpy array
-    :param initial_cars_ds: cars dataset to use tiling from
-    :type initial_cars_ds: CarsDataset
-
-    :return new_matches_cars_ds
-    :rtype: CarsDataset
-    """
-
-    # initialize CarsDataset
-    new_matches_cars_ds = cars_dataset.CarsDataset("points")
-    new_matches_cars_ds.create_empty_copy(initial_cars_ds)
-    new_matches_cars_ds.attributes = initial_cars_ds.attributes
-
-    for row in range(new_matches_cars_ds.shape[0]):
-        for col in range(new_matches_cars_ds.shape[1]):
-            [
-                row_min,
-                row_max,
-                col_min,
-                col_max,
-            ] = new_matches_cars_ds.tiling_grid[row, col, :]
-
-            # Get corresponding matches
-            tile_matches = corrected_matches[corrected_matches[:, 1] > row_min]
-            tile_matches = tile_matches[tile_matches[:, 1] < row_max]
-            tile_matches = tile_matches[tile_matches[:, 0] > col_min]
-            tile_matches = tile_matches[tile_matches[:, 0] < col_max]
-
-            # Create pandas DataFrame
-            new_matches_cars_ds[row, col] = pandas.DataFrame(tile_matches)
-
-    return new_matches_cars_ds

cars/applications/grid_generation/transform_grid.py

@@ -41,9 +41,9 @@ def transform_grid_func(grid, resolution, right=False):
     for key, value in grid.items():
         if right:
             if key not in ("grid_origin", "grid_spacing"):
-                divide(key, value, grid, resolution)
+                scale(key, value, grid, resolution)
         else:
-            divide(key, value, grid, resolution)
+            scale(key, value, grid, resolution)
 
     # we need to charge the data to override it
     with rasterio.open(grid["path"]) as src:
@@ -59,9 +59,9 @@ def transform_grid_func(grid, resolution, right=False):
     return grid
 
 
-def divide(key, value, grid, resolution):
+def scale(key, value, grid, resolution):
     """
-    Divide attributs by the resolution
+    Scale attributes by the resolution
     """
 
     if key == "grid_origin":
@@ -71,7 +71,7 @@ def divide(key, value, grid, resolution):
         for i, _ in enumerate(value):
             grid[key][i] = np.floor(value[i] / resolution)
     elif key == "disp_to_alt_ratio":
-        grid[key] = value / resolution
+        grid[key] = value * resolution
     elif key == "epipolar_size_x":
         grid[key] = np.floor(value / resolution)
     elif key == "epipolar_size_y":

cars/applications/point_cloud_fusion/pc_fusion_algo.py

@@ -468,9 +468,12 @@ def create_combined_dense_cloud(  # noqa: C901
             if cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT in array_name:
                 arrays_to_add_to_point_cloud.append((array_name, array_name))
 
-        # add confidence layers
+        # add ambiguity layer, drop confidence_* layers
         for array_name in point_cloud:
-            if cst.EPI_CONFIDENCE_KEY_ROOT in array_name:
+            if (
+                cst.EPI_AMBIGUITY in array_name
+                and cst.EPI_CONFIDENCE_KEY_ROOT not in array_name
+            ):
                 arrays_to_add_to_point_cloud.append((array_name, array_name))
 
         # add denoising info layers
@@ -852,12 +855,15 @@ def generate_pc_wrapper(  # noqa: C901
             if cst.EPI_TEXTURE not in coords:
                 coords[cst.BAND_IM] = descriptions
 
-        elif key == cst.EPI_CONFIDENCE_KEY_ROOT:
-            for sub_key in cloud[key].keys():
-                data = pc_wrap.read_image_full(
-                    cloud[key][sub_key], window=window, squeeze=True
-                )
-                values[sub_key] = ([cst.ROW, cst.COL], data)
+        elif key == cst.EPI_AMBIGUITY:
+            data = pc_wrap.read_image_full(
+                cloud[key], window=window, squeeze=True
+            )
+            descriptions = list(inputs.get_descriptions_bands(cloud[key]))
+            values[cst.EPI_AMBIGUITY] = (
+                [cst.ROW, cst.COL],
+                data,
+            )
 
         elif key == cst.EPI_FILLING:
             data = pc_wrap.read_image_full(
@@ -1098,9 +1104,9 @@ def compute_x_y_min_max_wrapper(items, epsg, window, saving_info=None):
         data_dict[cst.POINT_CLOUD_FILLING_KEY_ROOT] = items[
             cst.POINT_CLOUD_FILLING_KEY_ROOT
         ]
-    if cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT in items:
-        data_dict[cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT] = items[
-            cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT
+    if cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT in items:
+        data_dict[cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT] = items[
+            cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT
         ]
     if cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT in items:
         data_dict[cst.POINT_CLOUD_PERFORMANCE_MAP_ROOT] = items[

cars/applications/point_cloud_fusion/pc_fusion_wrappers.py

@@ -180,10 +180,9 @@ def create_point_cloud_index(cloud_sample):
             band_index = "{}_{}".format(cst.POINT_CLOUD_FILLING_KEY_ROOT, band)
             cloud_indexes_with_types[band_index] = "uint8"
 
-    # Add confidence indexes
-    for key in cloud_sample:
-        if cst.EPI_CONFIDENCE_KEY_ROOT in key:
-            cloud_indexes_with_types[key] = "float32"
+    # Add ambiguity information index
+    if cst.EPI_AMBIGUITY in cloud_sample:
+        cloud_indexes_with_types[cst.EPI_AMBIGUITY] = "float32"
 
     return cloud_indexes_with_types
 

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/rasterization_algo.py

@@ -174,7 +174,7 @@ def compute_vector_raster_and_stats(
     points = cloud.loc[:, [cst.X, cst.Y]].values.T
     nb_points = points.shape[1]
     valid = np.ones((1, nb_points))
-    # create values: 1. altitudes and colors, 2. confidences, 3. masks
+    # create values: 1. altitudes and colors, 2. ambiguity, 3. masks
     # split_indexes allows to keep indexes separating values
     split_indexes = []
 
@@ -187,21 +187,16 @@ def compute_vector_raster_and_stats(
     values_bands.extend(clr_indexes)
     split_indexes.append(len(values_bands))
 
-    # 2. confidences
-    if list_computed_layers is not None:
-        if cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT not in list_computed_layers:
-            confidences_indexes = rast_wrap.find_indexes_in_point_cloud(
-                cloud, cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT, list_computed_layers
-            )
-        else:
-            confidences_indexes = rast_wrap.find_indexes_in_point_cloud(
-                cloud, cst.POINT_CLOUD_CONFIDENCE_KEY_ROOT, list_computed_layers
-            )
-    else:
-        confidences_indexes = []
+    # 2. ambiguity
+    ambiguity_indexes = rast_wrap.find_indexes_in_point_cloud(
+        cloud, cst.POINT_CLOUD_AMBIGUITY_KEY_ROOT, list_computed_layers
+    )
+
+    values_bands.extend(ambiguity_indexes)
+    split_indexes.append(len(ambiguity_indexes))
 
-    values_bands.extend(confidences_indexes)
-    split_indexes.append(len(confidences_indexes))
+    # sanity check
+    assert len(ambiguity_indexes) <= 1
 
     # 3. sup and inf layers interval
     layer_inf_sup_indexes = rast_wrap.find_indexes_in_point_cloud(
@@ -288,7 +283,7 @@ def compute_vector_raster_and_stats(
     # pylint: disable=unbalanced-tuple-unpacking
     (
         out,
-        confidences,
+        ambiguity,
         interval,
         msk,
         classif,
@@ -297,11 +292,9 @@ def compute_vector_raster_and_stats(
         performance_map,
     ) = np.split(out, np.cumsum(split_indexes), axis=-1)
 
-    confidences_out = None
-    if len(confidences_indexes) > 0:
-        confidences_out = {}
-        for k, key in enumerate(confidences_indexes):
-            confidences_out[key] = confidences[..., k]
+    ambiguity_out = None
+    if len(ambiguity_indexes) > 0:
+        ambiguity_out = ambiguity
 
     layers_inf_sup_out = None
     layers_inf_sup_stat_index = None
@@ -341,7 +334,7 @@ def compute_vector_raster_and_stats(
         clr_indexes,
         classif_out,
         classif_indexes,
-        confidences_out,
+        ambiguity_out,
         layers_inf_sup_out,
         layers_inf_sup_stat_index,
         layer_inf_sup_indexes,
@@ -420,7 +413,7 @@ def rasterize(
         clr_indexes,
         classif,
         classif_indexes,
-        confidences,
+        ambiguity,
         layer_inf_sup,
         layer_inf_sup_stats_indexes,
         layer_inf_sup_indexes,
@@ -463,9 +456,9 @@ def rasterize(
     else:
         msk = np.isnan(out[0, :, :])
 
-    if confidences is not None:
-        for key, value in confidences.items():
-            confidences[key] = value.reshape(shape_out)
+    if ambiguity is not None:
+        ambiguity = ambiguity.reshape(shape_out + (-1,))
+        ambiguity = np.moveaxis(ambiguity, 2, 0)
 
     if layer_inf_sup is not None:
         layer_inf_sup = layer_inf_sup.reshape(shape_out + (-1,))
@@ -512,7 +505,7 @@ def rasterize(
         clr_indexes,
         classif,
         classif_indexes,
-        confidences,
+        ambiguity,
         layer_inf_sup,
         layer_inf_sup_stats_indexes,
         layer_inf_sup_indexes,

cars/applications/rasterization/rasterization_wrappers.py

@@ -174,7 +174,7 @@ def create_raster_dataset(  # noqa: C901
     band_im: List[str] = None,
     classif: np.ndarray = None,
     band_classif: List[str] = None,
-    confidences: np.ndarray = None,
+    ambiguity: np.ndarray = None,
     layers_inf_sup: np.ndarray = None,
     layers_inf_sup_stat_index: List[int] = None,
     layer_inf_sup_indexes: List[str] = None,
@@ -207,7 +207,7 @@ def create_raster_dataset(  # noqa: C901
     :param n_in_cell: number of points which contribute to a cell
     :param msk: raster msk
     :param classif: raster classif
-    :param confidences: raster containing the confidences
+    :param ambiguity: raster containing the ambiguity
     :param layers_inf_sup: raster containing intervals inf and sup
     :param layers_inf_sup_stat_index: list containing index of
         intervals in mean and stdev rasters
@@ -310,9 +310,10 @@ def create_raster_dataset(  # noqa: C901
         # update raster output with classification data
         raster_out = xr.merge((raster_out, classif_out))
 
-    if confidences is not None:  # rasterizer produced color output
-        for key in confidences:
-            raster_out[key] = xr.DataArray(confidences[key], dims=raster_dims)
+    if ambiguity is not None:  # rasterizer produced color output
+        raster_out[cst.RASTER_AMBIGUITY] = xr.DataArray(
+            ambiguity[0], dims=raster_dims
+        )
 
     if layers_inf_sup is not None:
         # Get inf data