cars 0.12.0rc2__cp311-cp311-win_amd64.whl → 1.0.0a2__cp311-cp311-win_amd64.whl

cars/__init__.py

@@ -24,14 +24,14 @@ Cars module init file
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_10_1():
+def _delvewheel_patch_1_11_1():
     import os
     if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'cars.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_10_1()
-del _delvewheel_patch_1_10_1
+_delvewheel_patch_1_11_1()
+del _delvewheel_patch_1_11_1
 # end delvewheel patch
 
 import os
@@ -83,4 +83,4 @@ def import_plugins() -> None:
         entry_point.load()
 
 
-import_plugins()
+import_plugins()

cars/applications/auxiliary_filling/__init__.py

@@ -23,7 +23,7 @@ CARS auxiliary filling module init file
 """
 # flake8: noqa: F401
 
-import cars.applications.auxiliary_filling.auxiliary_filling
-from cars.applications.auxiliary_filling.auxiliary_filling_from_sensors import (
+import cars.applications.auxiliary_filling.abstract_auxiliary_filling_app
+from cars.applications.auxiliary_filling.auxiliary_filling_from_sensors_app import (  # pylint: disable=C0301
     AuxiliaryFilling,
 )

cars/applications/auxiliary_filling/{auxiliary_filling_tools.py → auxiliary_filling_algo.py}

@@ -26,9 +26,6 @@ this module contains the AuxiliaryFillingFromSensors application class.
 import numpy as np
 import rasterio as rio
 from scipy import interpolate
-from shapely.geometry import Polygon
-
-from cars.core.projection import polygon_projection
 
 
 def fill_auxiliary(
@@ -40,7 +37,8 @@ def fill_auxiliary(
     geom_plugin,
     number_of_color_bands,
     number_of_classification_bands,
-    color_interpolator,
+    texture_bands,
+    texture_interpolator,
     use_mask=False,
 ):
     """
@@ -63,9 +61,11 @@ def fill_auxiliary(
     :type number_of_color_bands: int
     :param number_of_classification_bands: number of bands in the color image
     :type number_of_classification_bands: int
-    :param color_interpolator: scipy interpolator use to interpolate color
+    :param texture_bands: list of band names used for output texture
+    :type texture_bands: list
+    :param texture_interpolator: scipy interpolator use to interpolate color
         values
-    :type color_interpolator: str
+    :type texture_interpolator: str
     :param use_mask: use mask information from sensors in color computation
     :type use_mask: bool
 
@@ -107,7 +107,8 @@ def fill_auxiliary(
                 geom_plugin,
                 number_of_color_bands,
                 number_of_classification_bands,
-                color_interpolator,
+                texture_bands,
+                texture_interpolator,
                 not_interpolated_mask=None,
                 use_mask=use_mask,
                 return_all_points=True,
@@ -132,7 +133,8 @@ def fill_auxiliary(
                     geom_plugin,
                     number_of_color_bands,
                     number_of_classification_bands,
-                    color_interpolator,
+                    texture_bands,
+                    texture_interpolator,
                     not_interpolated_mask,
                     use_mask=use_mask,
                     return_all_points=False,
@@ -165,7 +167,8 @@ def fill_from_one_sensor(  # noqa C901
     geom_plugin,
     number_of_color_bands,
     number_of_classification_bands,
-    color_interpolator,
+    texture_bands,
+    texture_interpolator,
     not_interpolated_mask=None,
     use_mask=False,
     return_all_points=False,
@@ -194,9 +197,11 @@ def fill_from_one_sensor(  # noqa C901
     :type number_of_color_bands: int
     :param number_of_classification_bands: number of bands in the color image
     :type number_of_classification_bands: int
-    :param color_interpolator: scipy interpolator use to interpolate color
+    :param texture_bands: list of band names used for output texture
+    :type texture_bands: list
+    :param texture_interpolator: scipy interpolator use to interpolate color
         values
-    :type color_interpolator: str
+    :type texture_interpolator: str
     :param not_interpolated_mask: use mask information in color computation
     :type not_interpolated_mask: numpy.array
     :param use_mask: use mask information in color computation
@@ -207,9 +212,7 @@ def fill_from_one_sensor(  # noqa C901
     """
 
     # Check if the sensor has color or classification
-    reference_sensor_image = sensor.get(
-        "color", sensor.get("classification", None)
-    )
+    reference_sensor_image = sensor["image"]["main_file"]
 
     output_not_interpolated_mask = np.ones(len(altitudes), dtype=bool)
     all_values = np.zeros((number_of_color_bands, len(altitudes)))
@@ -251,12 +254,12 @@ def fill_from_one_sensor(  # noqa C901
     ):
         return output_not_interpolated_mask, all_values
 
-    if color_interpolator in ("linear", "nearest"):
-        color_interpolator_margin = 1
-    elif color_interpolator == "cubic":
-        color_interpolator_margin = 3
+    if texture_interpolator in ("linear", "nearest"):
+        texture_interpolator_margin = 1
+    elif texture_interpolator == "cubic":
+        texture_interpolator_margin = 3
     else:
-        raise RuntimeError(f"Invalid interpolator {color_interpolator}")
+        raise RuntimeError(f"Invalid interpolator {texture_interpolator}")
 
     # Classification interpolator is always nearest
     classif_interpolator = "nearest"
@@ -308,100 +311,112 @@ def fill_from_one_sensor(  # noqa C901
                     validity_mask, not_interpolated_mask
                 )
 
-    if sensor.get("color"):
-        with rio.open(sensor["color"]) as sensor_color_image:
-            # Only fill color if the number of bands matches. For exemple do
-            # not try to fill an output RGB image from a greyscale "color"
-            # image.
-            if sensor_color_image.count == number_of_color_bands:
+    if sensor.get("image"):
+        # Only fill color if all texture bands are present
+        if all(
+            band_name in sensor["image"]["bands"] for band_name in texture_bands
+        ):
+            with rio.open(sensor["image"]["main_file"]) as sensor_color_image:
                 first_row = np.floor(
-                    max(np.min(ind_rows_sensor) - color_interpolator_margin, 0)
+                    max(
+                        np.min(ind_rows_sensor) - texture_interpolator_margin, 0
+                    )
                 )
                 last_row = np.ceil(
                     min(
-                        np.max(ind_rows_sensor) + color_interpolator_margin,
+                        np.max(ind_rows_sensor) + texture_interpolator_margin,
                         sensor_color_image.height,
                     )
                 )
                 first_col = np.floor(
-                    max(np.min(ind_cols_sensor) - color_interpolator_margin, 0)
+                    max(
+                        np.min(ind_cols_sensor) - texture_interpolator_margin, 0
+                    )
                 )
                 last_col = np.ceil(
                     min(
-                        np.max(ind_cols_sensor) + color_interpolator_margin,
+                        np.max(ind_cols_sensor) + texture_interpolator_margin,
                         sensor_color_image.width,
                     )
                 )
 
-                rio_window = rio.windows.Window.from_slices(
-                    (first_row, last_row),
-                    (first_col, last_col),
-                )
+            rio_window = rio.windows.Window.from_slices(
+                (first_row, last_row),
+                (first_col, last_col),
+            )
 
-                sensor_points = (
-                    np.arange(first_row, last_row),
-                    np.arange(first_col, last_col),
-                )
+            sensor_points = (
+                np.arange(first_row, last_row),
+                np.arange(first_col, last_col),
+            )
 
-                if validity_mask is not None:
-                    interpolated_mask = validity_mask
-                else:
-                    interpolated_mask = np.ones(len(altitudes), dtype=bool)
+            if validity_mask is not None:
+                interpolated_mask = validity_mask
+            else:
+                interpolated_mask = np.ones(len(altitudes), dtype=bool)
 
-                for band in range(sensor_color_image.count):
-                    # rio band convention
-                    sensor_data = sensor_color_image.read(
-                        band + 1, window=rio_window
-                    )
+            for output_band, band_name in enumerate(texture_bands):
+                # rio band convention
+                sensor_file = rio.open(
+                    sensor["image"]["bands"][band_name]["path"]
+                )
+                input_band = sensor["image"]["bands"][band_name]["band"]
+                sensor_data = sensor_file.read(
+                    input_band + 1, window=rio_window
+                )
 
-                    if validity_mask is not None:
-                        if return_all_points is True:
-                            all_values[band, :] = interpolate.interpn(
-                                sensor_points,
-                                sensor_data,
-                                (ind_rows_sensor, ind_cols_sensor),
-                                bounds_error=False,
-                                method=color_interpolator,
-                            )
-                            band_values = all_values[band, validity_mask]
-                        # No need to interpolate on every points
-                        else:
-                            band_values = interpolate.interpn(
-                                sensor_points,
-                                sensor_data,
-                                (
-                                    ind_rows_sensor[validity_mask],
-                                    ind_cols_sensor[validity_mask],
-                                ),
-                                bounds_error=False,
-                                method=color_interpolator,
-                            )
-                        nan_values = np.isnan(band_values)
-                        interpolated_mask[validity_mask] = np.logical_or(
-                            interpolated_mask[validity_mask], ~nan_values
+                if validity_mask is not None:
+                    if return_all_points is True:
+                        all_values[output_band, :] = interpolate.interpn(
+                            sensor_points,
+                            sensor_data,
+                            (ind_rows_sensor, ind_cols_sensor),
+                            bounds_error=False,
+                            method=texture_interpolator,
                         )
-                        filled_color[band, interpolated_mask] += band_values
-
+                        band_values = all_values[output_band, validity_mask]
+                    # No need to interpolate on every points
                     else:
                         band_values = interpolate.interpn(
                             sensor_points,
                             sensor_data,
-                            (ind_rows_sensor, ind_cols_sensor),
+                            (
+                                ind_rows_sensor[validity_mask],
+                                ind_cols_sensor[validity_mask],
+                            ),
                             bounds_error=False,
-                            method=color_interpolator,
+                            method=texture_interpolator,
                         )
-                        interpolated_mask = np.logical_or(
-                            interpolated_mask, ~np.isnan(band_values)
-                        )
-                        filled_color[band, interpolated_mask] += band_values
-                output_not_interpolated_mask = ~interpolated_mask
+                    nan_values = np.isnan(band_values)
+                    interpolated_mask[validity_mask] = np.logical_or(
+                        interpolated_mask[validity_mask], ~nan_values
+                    )
+                    filled_color[output_band, interpolated_mask] += band_values
 
-                weights[interpolated_mask] += 1
+                else:
+                    band_values = interpolate.interpn(
+                        sensor_points,
+                        sensor_data,
+                        (ind_rows_sensor, ind_cols_sensor),
+                        bounds_error=False,
+                        method=texture_interpolator,
+                    )
+                    interpolated_mask = np.logical_or(
+                        interpolated_mask, ~np.isnan(band_values)
+                    )
+                    filled_color[output_band, interpolated_mask] += band_values
+            output_not_interpolated_mask = ~interpolated_mask
+
+            weights[interpolated_mask] += 1
 
     if filled_classif is not None and sensor.get("classification"):
-        with rio.open(sensor["classification"]) as sensor_classif_image:
+        if number_of_classification_bands == len(
+            sensor["classification"]["bands"]
+        ):
+            with rio.open(
+                sensor["classification"]["main_file"]
+            ) as sensor_classif_image:
 
-            if sensor_classif_image.count == number_of_classification_bands:
                 first_row = np.floor(
                     max(
                         np.min(ind_rows_sensor) - classif_interpolator_margin, 0
@@ -425,95 +440,39 @@ def fill_from_one_sensor(  # noqa C901
                     )
                 )
 
-                rio_window = rio.windows.Window.from_slices(
-                    (first_row, last_row),
-                    (first_col, last_col),
-                )
+            rio_window = rio.windows.Window.from_slices(
+                (first_row, last_row),
+                (first_col, last_col),
+            )
 
-                sensor_points = (
-                    np.arange(first_row, last_row),
-                    np.arange(first_col, last_col),
-                )
+            sensor_points = (
+                np.arange(first_row, last_row),
+                np.arange(first_col, last_col),
+            )
 
-                for band in range(sensor_classif_image.count):
-                    # rio band convention
-                    sensor_data = sensor_classif_image.read(
-                        band + 1, window=rio_window, out_dtype=np.uint8
-                    )
+            for output_band, band_name in enumerate(
+                sensor["classification"]["bands"]
+            ):
+                # rio band convention
+                sensor_file = rio.open(
+                    sensor["classification"]["bands"][band_name]["path"]
+                )
+                input_band = sensor["classification"]["bands"][band_name][
+                    "band"
+                ]
+                sensor_data = sensor_file.read(
+                    input_band + 1, window=rio_window
+                )
 
-                    filled_classif[band, :] = np.logical_or(
-                        filled_classif[band, :],
-                        interpolate.interpn(
-                            sensor_points,
-                            sensor_data,
-                            (ind_rows_sensor, ind_cols_sensor),
-                            bounds_error=False,
-                            method=classif_interpolator,
-                        ),
-                    )
+                filled_classif[output_band, :] = np.logical_or(
+                    filled_classif[output_band, :],
+                    interpolate.interpn(
+                        sensor_points,
+                        sensor_data,
+                        (ind_rows_sensor, ind_cols_sensor),
+                        bounds_error=False,
+                        method=classif_interpolator,
+                    ),
+                )
 
     return output_not_interpolated_mask, all_values
-
-
-def compute_sensor_bounds(sensor_inputs, geom_plugin, output_epsg):
-    """
-    Compute bounds of each input sensor that have an associated color or
-    classification image
-
-    :param sensor_inputs: dictionary containing paths to input images and models
-    :type sensor_inputs: dict
-    :param geom_plugin: geometry plugin used for inverse locations
-    :type geom_plugin: AbstractGeometry
-    :param geom_plugin: geometry plugin used for inverse locations
-    :type geom_plugin: AbstractGeometry
-    :param output_epsg: epsg of the output polygons
-    :type output_epsg: int
-
-    :return: a dictionary containing a Polygon in output geometry for each
-        valid input sensor
-    """
-
-    sensor_bounds = {}
-
-    for sensor_name, sensor in sensor_inputs.items():
-        reference_sensor_image = sensor.get(
-            "color", sensor.get("classification", None)
-        )
-        # no data for this sensor, no need to compute its bounds
-        if reference_sensor_image is None:
-            continue
-
-        u_l, u_r, l_r, l_l = geom_plugin.image_envelope(
-            reference_sensor_image, sensor["geomodel"]
-        )
-
-        poly_geo = Polygon([u_l, u_r, l_r, l_l, u_l])
-
-        sensor_bounds[sensor_name] = polygon_projection(
-            poly_geo, 4326, output_epsg
-        )
-
-    return sensor_bounds
-
-
-def filter_sensor_inputs(sensor_inputs, sensor_bounds, ground_polygon):
-    """
-    Filter input sensors by comparing their bounds to a reference Polygon
-
-    :param sensor_inputs: dictionary containing paths to input images and models
-    :type sensor_inputs: dict
-    :param sensor_bounds: dictionary containing bounds of input sensors
-    :type sensor_bounds: dict
-    :param ground_polygon: reference polygon, in ground geometry
-    :type ground_polygon: Polygon
-
-    :return: a fitlered version of sensor_inputs
-    """
-
-    filtered_sensor_inputs = sensor_inputs.copy()
-
-    for sensor_name, bound in sensor_bounds.items():
-        if not bound.intersects(ground_polygon):
-            del filtered_sensor_inputs[sensor_name]
-
-    return filtered_sensor_inputs

cars/applications/auxiliary_filling/{auxiliary_filling_from_sensors.py → auxiliary_filling_from_sensors_app.py}

@@ -33,10 +33,13 @@ from json_checker import Checker
 from shapely.geometry import Polygon
 
 import cars.orchestrator.orchestrator as ocht
-from cars.applications.auxiliary_filling import auxiliary_filling_tools
+from cars.applications.auxiliary_filling import (
+    auxiliary_filling_algo,
+    auxiliary_filling_wrappers,
+)
 
 # CARS imports
-from cars.applications.auxiliary_filling.auxiliary_filling import (
+from cars.applications.auxiliary_filling.abstract_auxiliary_filling_app import (
     AuxiliaryFilling,
 )
 from cars.core import constants as cst
@@ -96,8 +99,8 @@ class AuxiliaryFillingFromSensors(
                 "and full"
             )
 
-        overloaded_conf["color_interpolator"] = conf.get(
-            "color_interpolator", "linear"
+        overloaded_conf["texture_interpolator"] = conf.get(
+            "texture_interpolator", "linear"
         )
         overloaded_conf["activated"] = conf.get("activated", False)
         overloaded_conf["use_mask"] = conf.get("use_mask", True)
@@ -112,7 +115,7 @@ class AuxiliaryFillingFromSensors(
             "activated": bool,
             "mode": str,
             "use_mask": bool,
-            "color_interpolator": str,
+            "texture_interpolator": str,
             "save_intermediate_data": bool,
         }
 
@@ -131,6 +134,7 @@ class AuxiliaryFillingFromSensors(
         sensor_inputs,
         pairing,
         geom_plugin,
+        texture_bands,
         orchestrator=None,
     ):
         """
@@ -151,6 +155,8 @@ class AuxiliaryFillingFromSensors(
         :type pairing: list
         :param geom_plugin: geometry plugin used for inverse locations
         :type geom_plugin: AbstractGeometry
+        :param texture_bands: list of band names used for output texture
+        :type texture_bands: list
         :param orchestrator: orchestrator used
         :type orchestrator: Orchestrator
         """
@@ -180,7 +186,7 @@ class AuxiliaryFillingFromSensors(
         if not os.path.exists(dump_dir):
             os.makedirs(dump_dir)
 
-        color_not_filled_file = os.path.join(dump_dir, "color_not_filled.tif")
+        color_not_filled_file = os.path.join(dump_dir, "texture_not_filled.tif")
         if os.path.exists(color_file):
             shutil.move(color_file, color_not_filled_file)
 
@@ -219,22 +225,22 @@ class AuxiliaryFillingFromSensors(
 
         # Initialize no data value
         classification_no_data_value = 0
-        color_no_data_value = 0
+        texture_no_data_value = 0
         color_dtype = np.float32
         classif_dtype = np.uint8
 
         if os.path.exists(color_not_filled_file):
             with rio.open(color_not_filled_file, "r") as descriptor:
-                color_no_data_value = descriptor.nodata
+                texture_no_data_value = descriptor.nodata
                 color_dtype = descriptor.profile.get("dtype", np.float32)
 
         self.orchestrator.add_to_save_lists(
             os.path.join(dump_dir, color_file),
             cst.RASTER_COLOR_IMG,
             aux_filled_image,
-            nodata=color_no_data_value,
+            nodata=texture_no_data_value,
             dtype=color_dtype,
-            cars_ds_name="filled_color",
+            cars_ds_name="filled_texture",
         )
 
         if classif_file is not None:
@@ -262,7 +268,7 @@ class AuxiliaryFillingFromSensors(
 
         # Pre-compute sensor bounds of all sensors to filter sensors that do
         # not intersect with tile in tasks
-        sensor_bounds = auxiliary_filling_tools.compute_sensor_bounds(
+        sensor_bounds = auxiliary_filling_wrappers.compute_sensor_bounds(
             sensor_inputs, geom_plugin, reference_epsg
         )
 
@@ -293,8 +299,11 @@ class AuxiliaryFillingFromSensors(
                     reference_epsg,
                     full_saving_info,
                     geom_plugin,
+                    texture_bands,
                     mode=self.used_config["mode"],
-                    color_interpolator=self.used_config["color_interpolator"],
+                    texture_interpolator=self.used_config[
+                        "texture_interpolator"
+                    ],
                     use_mask=self.used_config["use_mask"],
                 )
 
@@ -318,12 +327,13 @@ def filling_from_sensor_wrapper(
     epsg,
     saving_info,
     geom_plugin,
+    texture_bands,
     mode,
-    color_interpolator,
+    texture_interpolator,
     use_mask,
 ):
     """
-    fill color and classifcation from sensor information for a terrain tile
+    Fill color and classification from sensor information for a terrain tile
 
     :param dsm_file: path to the filled dsm file
     :type dsm_file: str
@@ -347,11 +357,13 @@ def filling_from_sensor_wrapper(
     :type saving_info: dict
     :param geom_plugin: geometry plugin used for inverse locations
     :type geom_plugin: AbstractGeometry
+    :param texture_bands: list of band names used for output texture
+    :type texture_bands: list
     :param mode: geometry plugin used for inverse locations
     :type mode: str
-    :param color_interpolator: scipy interpolator use to interpolate color
+    :param texture_interpolator: scipy interpolator use to interpolate color
         values
-    :type color_interpolator: str
+    :type texture_interpolator: str
     :param use_mask: use mask information from sensors in color computation
     :type use_mask: bool
 
@@ -432,13 +444,13 @@ def filling_from_sensor_wrapper(
     else:
         profile = dsm_profile
         number_of_color_bands = inputs.rasterio_get_nb_bands(
-            sensor_inputs[list(sensor_inputs.keys())[0]].get("color", None)
+            sensor_inputs[list(sensor_inputs.keys())[0]].get("texture", None)
         )
         color_values = np.full(
             (number_of_color_bands, *target_mask.shape), np.nan
         )
         color_band_names = inputs.get_descriptions_bands(
-            sensor_inputs[list(sensor_inputs.keys())[0]].get("color", None)
+            sensor_inputs[list(sensor_inputs.keys())[0]].get("texture", None)
         )
         # update profile
         profile.update(count=number_of_color_bands)
@@ -481,14 +493,14 @@ def filling_from_sensor_wrapper(
     index_1d = target_mask.flatten().nonzero()[0]
 
     # Remove sensor that don't intesects with current tile
-    filtered_sensor_inputs = auxiliary_filling_tools.filter_sensor_inputs(
+    filtered_sensor_inputs = auxiliary_filling_wrappers.filter_sensor_inputs(
         sensor_inputs, sensor_bounds, ground_polygon
     )
 
     if len(index_1d) > 0:
         # Fill required pixels
         color_values_filled, classification_values_filled = (
-            auxiliary_filling_tools.fill_auxiliary(
+            auxiliary_filling_algo.fill_auxiliary(
                 filtered_sensor_inputs,
                 pairing,
                 lon_lat[index_1d, 0],
@@ -497,7 +509,8 @@ def filling_from_sensor_wrapper(
                 geom_plugin,
                 number_of_color_bands,
                 number_of_classification_bands,
-                color_interpolator=color_interpolator,
+                texture_bands,
+                texture_interpolator=texture_interpolator,
                 use_mask=use_mask,
             )
         )