cars 1.0.0a2__cp312-cp312-win_amd64.whl → 1.0.0a4__cp312-cp312-win_amd64.whl

cars/applications/rasterization/simple_gaussian_app.py

@@ -42,21 +42,25 @@ from json_checker import Checker, Or
 
 import cars.orchestrator.orchestrator as ocht
 from cars.applications import application_constants
-from cars.applications.point_cloud_fusion import pc_fusion_algo
 
 # CARS imports
-from cars.applications.rasterization import rasterization_algo
+from cars.applications.rasterization import (
+    rasterization_algo,
+)
 from cars.applications.rasterization import (
     rasterization_constants as raster_cst,
 )
-from cars.applications.rasterization import rasterization_wrappers
+from cars.applications.rasterization import (
+    rasterization_wrappers,
+)
 from cars.applications.rasterization.abstract_pc_rasterization_app import (
     PointCloudRasterization,
 )
+from cars.applications.triangulation import pc_transform
 from cars.core import constants as cst
 from cars.core import projection, tiling
 from cars.core.utils import safe_makedirs
-from cars.data_structures import cars_dataset, format_transformation
+from cars.data_structures import cars_dataset
 
 # R0903  temporary disabled for error "Too few public methods"
 # œgoing to be corrected by adding new methods as check_conf
@@ -204,10 +208,12 @@ class SimpleGaussian(
         )
         return tile_size
 
+    # pylint: disable=too-many-positional-arguments
     def run(  # noqa: C901 function is too complex
         self,
         point_clouds,
         epsg,
+        output_crs,
         resolution,
         orchestrator=None,
         dsm_file_name=None,
@@ -256,6 +262,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 +275,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 +325,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,27 +362,19 @@ 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
 
         # Check if input data is supported
-        data_valid = True
-        if isinstance(point_clouds, tuple):
-            if isinstance(point_clouds[0][0], cars_dataset.CarsDataset):
-                if point_clouds[0][0].dataset_type not in ("arrays", "points"):
-                    data_valid = False
-            else:
-                data_valid = False
-        elif isinstance(point_clouds, cars_dataset.CarsDataset):
-            if point_clouds.dataset_type != "points":
-                data_valid = False
-        else:
-            data_valid = False
-        if not data_valid:
+        if not (
+            isinstance(point_clouds, tuple)
+            and isinstance(point_clouds[0][0], cars_dataset.CarsDataset)
+            and point_clouds[0][0].dataset_type == "arrays"
+        ):
             message = (
-                "PointCloudRasterisation application doesn't support "
+                "PointCloudRasterization application doesn't support "
                 "this input data "
                 "format : type : {}".format(type(point_clouds))
             )
@@ -365,24 +386,17 @@ class SimpleGaussian(
             "arrays", name="rasterization"
         )
 
-        if isinstance(point_clouds, cars_dataset.CarsDataset):
-            # Get tiling grid
-            terrain_raster.tiling_grid = (
-                format_transformation.terrain_coords_to_pix(
-                    point_clouds, resolution
-                )
-            )
-            bounds = point_clouds.attributes["bounds"]
-        else:
-            bounds = point_clouds[1]
-            # tiling grid: all tiles from sources -> not replaceable.
-            # CarsDataset is only used for processing
-            nb_tiles = 0
-            for point_cld in point_clouds[0]:
-                nb_tiles += point_cld.shape[0] * point_cld.shape[1]
-            terrain_raster.tiling_grid = tiling.generate_tiling_grid(
-                0, 0, 1, nb_tiles, 1, 1
-            )
+        paths_data = {}
+
+        bounds = point_clouds[1]
+        # tiling grid: all tiles from sources -> not replaceable.
+        # CarsDataset is only used for processing
+        nb_tiles = 0
+        for point_cld in point_clouds[0]:
+            nb_tiles += point_cld.shape[0] * point_cld.shape[1]
+        terrain_raster.tiling_grid = tiling.generate_tiling_grid(
+            0, 0, 1, nb_tiles, 1, 1
+        )
 
         terrain_raster.generate_none_tiles()
 
@@ -421,6 +435,7 @@ class SimpleGaussian(
             safe_makedirs(os.path.dirname(dsm_file_name))
 
         out_dsm_file_name = dsm_file_name
+
         if out_dsm_file_name is not None:
             self.orchestrator.update_index(
                 {
@@ -442,6 +457,7 @@ class SimpleGaussian(
                 nodata=self.dsm_no_data,
                 cars_ds_name="dsm",
             )
+            paths_data[cst.RASTER_HGT] = out_dsm_file_name
 
         out_weights_file_name = weights_file_name
         if out_weights_file_name is not None:
@@ -469,6 +485,7 @@ class SimpleGaussian(
                 nodata=0,
                 cars_ds_name="dsm_weights",
             )
+            paths_data[cst.RASTER_WEIGHTS_SUM] = out_weights_file_name
 
         out_clr_file_name = color_file_name
         if out_clr_file_name is not None:
@@ -494,6 +511,7 @@ class SimpleGaussian(
                 nodata=self.texture_no_data,
                 cars_ds_name="texture",
             )
+            paths_data[cst.RASTER_COLOR_IMG] = out_clr_file_name
 
         out_classif_file_name = classif_file_name
         if out_classif_file_name is not None:
@@ -512,6 +530,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(
@@ -523,6 +542,7 @@ class SimpleGaussian(
                 cars_ds_name="dsm_classif",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_CLASSIF] = out_classif_file_name
 
         out_msk_file_name = mask_file_name
         if out_msk_file_name is not None:
@@ -548,6 +568,7 @@ class SimpleGaussian(
                 cars_ds_name="dsm_mask",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_MSK] = out_msk_file_name
 
         out_performance_map = performance_map_file_name
 
@@ -589,6 +610,7 @@ class SimpleGaussian(
                 cars_ds_name="performance_map_raw",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_PERFORMANCE_MAP_RAW] = out_performance_map_raw
         if (
             out_performance_map is not None
             and performance_map_classes is not None
@@ -604,6 +626,7 @@ class SimpleGaussian(
                 cars_ds_name="performance_map",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_PERFORMANCE_MAP] = out_performance_map
 
         out_ambiguity = ambiguity_file_name
         if out_ambiguity is not None:
@@ -629,6 +652,7 @@ class SimpleGaussian(
                 cars_ds_name="ambiguity",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_AMBIGUITY] = out_ambiguity
 
         out_source_pc = contributing_pair_file_name
         if out_source_pc is not None:
@@ -656,6 +680,7 @@ class SimpleGaussian(
                 cars_ds_name="contributing_pair",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_SOURCE_PC] = out_source_pc
 
         out_filling = filling_file_name
         if out_filling is not None:
@@ -677,6 +702,7 @@ class SimpleGaussian(
                 cars_ds_name="filling",
                 optional_data=True,
             )
+            paths_data[cst.RASTER_FILLING] = out_filling
 
         # TODO Check that intervals indeed exist!
         if save_intermediate_data:
@@ -817,7 +843,7 @@ class SimpleGaussian(
                 "driver": "GTiff",
                 "dtype": "float32",
                 "transform": transform,
-                "crs": "EPSG:{}".format(epsg),
+                "crs": output_crs.to_wkt(),
                 "tiled": True,
             }
         )
@@ -848,53 +874,34 @@ class SimpleGaussian(
 
         self.orchestrator.update_out_info(updating_dict)
 
-        # Generate rasters
-        if not isinstance(point_clouds, tuple):
-            for col in range(terrain_raster.shape[1]):
-                for row in range(terrain_raster.shape[0]):
-                    # get corresponding point cloud
-                    # one tile in point cloud correspond
-                    # to one tile in raster
-                    # uses rasterio conventions
-                    (
-                        pc_row,
-                        pc_col,
-                    ) = format_transformation.get_corresponding_indexes(
-                        row, col
+        # Add attributrs
+        terrain_raster.attributes["paths"] = paths_data
+
+        # Add final function to apply
+        terrain_raster.final_function = raster_final_function
+        ind_tile = 0
+        for point_cloud in point_clouds[0]:
+            for row_pc in range(point_cloud.shape[0]):
+                for col_pc in range(point_cloud.shape[1]):
+                    # update saving infos  for potential replacement
+                    full_saving_info = ocht.update_saving_infos(
+                        saving_info, row=0, col=ind_tile
                     )
-
-                    if point_clouds.tiles[pc_row][pc_col] is not None:
-                        # Get window
-                        window = cars_dataset.window_array_to_dict(
-                            terrain_raster.tiling_grid[row, col]
-                        )
-                        # update saving infos  for potential replacement
-                        full_saving_info = ocht.update_saving_infos(
-                            saving_info, row=row, col=col
-                        )
-
-                        # Get terrain region
-                        # corresponding to point cloud tile
-                        terrain_region = [
-                            point_clouds.tiling_grid[pc_row, pc_col, 0],
-                            point_clouds.tiling_grid[pc_row, pc_col, 2],
-                            point_clouds.tiling_grid[pc_row, pc_col, 1],
-                            point_clouds.tiling_grid[pc_row, pc_col, 3],
-                        ]
-
+                    if point_cloud[row_pc, col_pc] is not None:
                         # Delayed call to rasterization operations using all
                         #  required point clouds
                         terrain_raster[
-                            row, col
+                            0, ind_tile
                         ] = self.orchestrator.cluster.create_task(
                             rasterization_wrapper
                         )(
-                            point_clouds[pc_row, pc_col],
+                            point_cloud[row_pc, col_pc],
                             resolution,
                             epsg,
                             raster_profile,
-                            window=window,
-                            terrain_region=terrain_region,
+                            window=None,
+                            terrain_region=None,
+                            terrain_full_roi=bounds,
                             list_computed_layers=list_computed_layers,
                             saving_info=full_saving_info,
                             radius=self.dsm_radius,
@@ -906,50 +913,14 @@ class SimpleGaussian(
                             source_pc_names=source_pc_names,
                             performance_map_classes=performance_map_classes,
                         )
-        else:
-            # Add final function to apply
-            terrain_raster.final_function = raster_final_function
-            ind_tile = 0
-            for point_cloud in point_clouds[0]:
-                for row_pc in range(point_cloud.shape[0]):
-                    for col_pc in range(point_cloud.shape[1]):
-                        # update saving infos  for potential replacement
-                        full_saving_info = ocht.update_saving_infos(
-                            saving_info, row=0, col=ind_tile
-                        )
-                        if point_cloud[row_pc, col_pc] is not None:
-                            # Delayed call to rasterization operations using all
-                            #  required point clouds
-                            terrain_raster[
-                                0, ind_tile
-                            ] = self.orchestrator.cluster.create_task(
-                                rasterization_wrapper
-                            )(
-                                point_cloud[row_pc, col_pc],
-                                resolution,
-                                epsg,
-                                raster_profile,
-                                window=None,
-                                terrain_region=None,
-                                terrain_full_roi=bounds,
-                                list_computed_layers=list_computed_layers,
-                                saving_info=full_saving_info,
-                                radius=self.dsm_radius,
-                                sigma=self.sigma,
-                                dsm_no_data=self.dsm_no_data,
-                                texture_no_data=self.texture_no_data,
-                                color_dtype=color_dtype,
-                                msk_no_data=self.msk_no_data,
-                                source_pc_names=source_pc_names,
-                                performance_map_classes=performance_map_classes,
-                            )
-                        ind_tile += 1
+                    ind_tile += 1
 
         # Sort tiles according to rank TODO remove or implement it ?
 
         return terrain_raster
 
 
+# pylint: disable=too-many-positional-arguments
 def rasterization_wrapper(  # noqa: C901
     cloud,
     resolution,
@@ -1019,8 +990,8 @@ def rasterization_wrapper(  # noqa: C901
     # If the point cloud is not in the right epsg referential, it is converted
     if isinstance(cloud, xarray.Dataset):
         # Transform Dataset to Dataframe
-        cloud, cloud_epsg = pc_fusion_algo.create_combined_cloud(
-            [cloud], [attributes["cloud_id"]], epsg
+        cloud, cloud_epsg = pc_transform.depth_map_dataset_to_dataframe(
+            cloud, epsg
         )
     elif cloud is None:
         logging.warning("Input cloud is None")
@@ -1133,6 +1104,7 @@ def rasterization_wrapper(  # noqa: C901
         list_computed_layers=list_computed_layers,
         source_pc_names=source_pc_names,
         performance_map_classes=performance_map_classes,
+        cloud_global_id=attributes["cloud_id"],
     )
 
     # Fill raster

cars/applications/resampling/abstract_resampling_app.py

@@ -95,7 +95,7 @@ class Resampling(ApplicationTemplate, metaclass=ABCMeta):
         super().__init__(conf=conf)
 
     @abstractmethod
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         sensor_image_left,
         sensor_image_right,

cars/applications/resampling/bicubic_resampling_app.py

@@ -208,7 +208,7 @@ class BicubicResampling(Resampling, short_name="bicubic"):
             largest_epipolar_region,
         )
 
-    def run(  # noqa: C901
+    def run(  # pylint: disable=too-many-positional-arguments  # noqa: C901
         self,
         sensor_image_left,
         sensor_image_right,
@@ -621,9 +621,11 @@ class BicubicResampling(Resampling, short_name="bicubic"):
                         epipolar_images_left[row, col] = None
                     if not in_sensor_right_array[row, col]:
                         epipolar_images_right[row, col] = None
+
         return epipolar_images_left, epipolar_images_right
 
 
+# pylint: disable=too-many-positional-arguments
 def generate_epipolar_images_wrapper(
     left_overlaps,
     right_overlaps,

cars/applications/resampling/resampling_algo.py

@@ -41,7 +41,7 @@ from cars.core import datasets, inputs, tiling
 from cars.core.geometry import abstract_geometry
 
 
-def epipolar_rectify_images(
+def epipolar_rectify_images(  # pylint: disable=too-many-positional-arguments
     left_imgs,
     right_imgs,
     grid1,
@@ -108,7 +108,9 @@ def epipolar_rectify_images(
     right_margins[3] = right_region[3] - right_roi[3]
 
     # Resample left images
-    left_img_transform = inputs.rasterio_get_transform(next(iter(left_imgs)))
+    left_img_transform = inputs.rasterio_get_transform(
+        next(iter(left_imgs)), convention="north"
+    )
 
     left_dataset = resample_image(
         left_imgs,
@@ -201,6 +203,7 @@ def epipolar_rectify_images(
     )
 
 
+# pylint: disable=too-many-positional-arguments
 def resample_image(  # noqa: C901
     imgs,
     grid,
@@ -252,7 +255,9 @@ def resample_image(  # noqa: C901
         ]
 
     if img_transform is None:
-        img_transform = inputs.rasterio_get_transform(img_sample)
+        img_transform = inputs.rasterio_get_transform(
+            img_sample, convention="north"
+        )
 
     # Convert largest_size to int if needed
     largest_size = [int(x) for x in largest_size]
@@ -284,14 +289,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:
@@ -348,7 +349,7 @@ def resample_image(  # noqa: C901
     return dataset
 
 
-def oversampling_func(
+def oversampling_func(  # pylint: disable=too-many-positional-arguments
     grid_reader,
     img_reader,
     img_transform,
@@ -457,7 +458,10 @@ def oversampling_func(
     if in_sensor:
         # Get sensor data
         img_as_array = img_reader.read(bands["band_id"], window=img_window)
+        # get the nodata mask before blurring
+        img_nan_mask = img_as_array == nodata
 
+        # blur the image to avoid moiré artefacts if downsampling
         if resolution != 1:
             fourier = fftshift(fft2(img_as_array))
 
@@ -472,6 +476,10 @@ def oversampling_func(
 
             img_as_array = np.real(ifft2(ifftshift(f_filtered)))
 
+        # set the nodata values back
+        if nodata is not None:
+            img_as_array[img_nan_mask] = nodata
+
         # shift grid regarding the img extraction
         grid_as_array[0, ...] -= x_offset
         grid_as_array[1, ...] -= y_offset
@@ -513,51 +521,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/resampling/resampling_wrappers.py

@@ -34,9 +34,11 @@ import numpy as np
 # CARS imports
 from cars.core import constants as cst
 from cars.core import inputs
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
 
 
+@cars_profile(name="Get paths and bands", interval=0.5)
 def get_paths_and_bands(sensor_image, required_bands=None):
     """
     Reformat file paths and bands required from each file to ease reading
@@ -92,7 +94,7 @@ def get_sensors_bounds(sensor_image_left, sensor_image_right):
     return left_sensor_bounds, right_sensor_bounds
 
 
-def check_tiles_in_sensor(
+def check_tiles_in_sensor(  # pylint: disable=too-many-positional-arguments
     sensor_image_left,
     sensor_image_right,
     image_tiling,

cars/applications/sparse_matching/abstract_sparse_matching_app.py

@@ -269,7 +269,7 @@ class SparseMatching(ApplicationTemplate, metaclass=ABCMeta):
 
         return margins_wrapper
 
-    def filter_matches(
+    def filter_matches(  # pylint: disable=too-many-positional-arguments
         self,
         epipolar_matches_left,
         grid_left,