cars 1.0.0a3__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,6 +208,7 @@ class SimpleGaussian(
         )
         return tile_size
 
+    # pylint: disable=too-many-positional-arguments
     def run(  # noqa: C901 function is too complex
         self,
         point_clouds,
@@ -363,21 +368,13 @@ class SimpleGaussian(
             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))
             )
@@ -389,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()
 
@@ -445,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(
                 {
@@ -466,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:
@@ -493,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:
@@ -518,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:
@@ -548,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:
@@ -573,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
 
@@ -614,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
@@ -629,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:
@@ -654,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:
@@ -681,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:
@@ -702,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:
@@ -873,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,
@@ -931,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,
@@ -1044,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")
@@ -1158,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]
@@ -344,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,
@@ -453,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))
 
@@ -468,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

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,

cars/applications/sparse_matching/sift_app.py

@@ -159,7 +159,7 @@ class Sift(SparseMatching, short_name=["sift"]):
 
         # minimum number of matches to continue with
         overloaded_conf["minimum_nb_matches"] = conf.get(
-            "minimum_nb_matches", 100
+            "minimum_nb_matches", 90
         )
 
         # sifts params
@@ -430,7 +430,7 @@ class Sift(SparseMatching, short_name=["sift"]):
         """
         self.decimation_factor = value
 
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         epipolar_image_left,
         epipolar_image_right,
@@ -627,7 +627,7 @@ class Sift(SparseMatching, short_name=["sift"]):
         return epipolar_disparity_map_left, None
 
 
-def compute_matches_wrapper(
+def compute_matches_wrapper(  # pylint: disable=too-many-positional-arguments
     left_image_object: xr.Dataset,
     right_image_object: xr.Dataset,
     used_band="b0",

cars/applications/sparse_matching/sparse_matching_algo.py

@@ -37,7 +37,7 @@ from cars.applications.sparse_matching.sparse_matching_wrappers import (
 )
 
 
-def compute_matches(
+def compute_matches(  # pylint: disable=too-many-positional-arguments
     left: np.ndarray,
     right: np.ndarray,
     left_mask: np.ndarray = None,
@@ -191,6 +191,7 @@ def compute_matches(
                 right_id_offset = left_id
             else:
                 right_descr_block = []
+                right_id_offset = 0
         else:
             right_descr_block = right_descr
             right_id_offset = 0
@@ -253,7 +254,7 @@ def compute_matches(
     return matches
 
 
-def dataset_matching(
+def dataset_matching(  # pylint: disable=too-many-positional-arguments
     ds1,
     ds2,
     used_band,

cars/applications/sparse_matching/sparse_matching_wrappers.py

@@ -170,7 +170,7 @@ def compute_disp_min_disp_max(
     return dmin, dmax
 
 
-@cars_profile(name="filter_point_cloud_matches")
+@cars_profile(name="Filter_point_cloud_matches")
 def filter_point_cloud_matches(
     pd_cloud,
     match_filter_knn=25,

cars/applications/triangulation/abstract_triangulation_app.py

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

cars/applications/triangulation/line_of_sight_intersection_app.py

@@ -39,11 +39,8 @@ from shareloc.geofunctions.rectification_grid import RectificationGrid
 import cars.orchestrator.orchestrator as ocht
 from cars.applications import application_constants
 from cars.applications.grid_generation import grid_generation_algo
-from cars.applications.point_cloud_fusion import (
-    pc_fusion_algo,
-    pc_fusion_wrappers,
-)
 from cars.applications.triangulation import (
+    pc_transform,
     triangulation_algo,
     triangulation_constants,
 )
@@ -58,6 +55,7 @@ from cars.core import constants as cst
 from cars.core import inputs, projection, tiling
 from cars.core.utils import safe_makedirs
 from cars.data_structures import cars_dataset
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 from cars.pipelines.parameters import sensor_inputs_constants as sens_cst
 
 
@@ -133,6 +131,8 @@ class LineOfSightIntersection(
 
         return overloaded_conf
 
+    # pylint: disable=too-many-positional-arguments
+    @cars_profile(name="Save triangulation output", interval=0.5)
     def save_triangulation_output(  # noqa: C901 function is too complex
         self,
         epipolar_point_cloud,
@@ -355,7 +355,8 @@ class LineOfSightIntersection(
                 optional_data=True,
             )
 
-    def fill_index(
+    @cars_profile(name="Fill index", interval=0.5)
+    def fill_index(  # pylint: disable=too-many-positional-arguments
         self,
         save_output_coordinates=True,
         save_output_color=True,
@@ -466,7 +467,7 @@ class LineOfSightIntersection(
 
         return csv_pc_dir_name, laz_pc_dir_name
 
-    def run(  # noqa: C901
+    def run(  # pylint: disable=too-many-positional-arguments  # noqa: C901
         self,
         sensor_image_left,
         sensor_image_right,
@@ -933,7 +934,7 @@ class LineOfSightIntersection(
         return epipolar_point_cloud
 
 
-def triangulation_wrapper(
+def triangulation_wrapper(  # pylint: disable=too-many-positional-arguments
     disparity_object: xr.Dataset,
     sensor1,
     sensor2,
@@ -1154,10 +1155,10 @@ def triangulation_wrapper(
     flatten_pc_dataset = None
     if point_cloud_csv_file_name or point_cloud_laz_file_name:
         # Convert epipolar array into point cloud
-        flatten_pc_dataset, cloud_epsg = pc_fusion_algo.create_combined_cloud(
-            [pc_dataset], [0], epsg
+        flatten_pc_dataset, cloud_epsg = (
+            pc_transform.depth_map_dataset_to_dataframe(pc_dataset, epsg)
         )
-        # Convert to UTM
+        # Convert to wanted epsg
         if epsg is not None and cloud_epsg != epsg:
             projection.point_cloud_conversion_dataframe(
                 flatten_pc_dataset, cloud_epsg, epsg
@@ -1165,7 +1166,7 @@ def triangulation_wrapper(
             cloud_epsg = epsg
 
         # Fill attributes for LAZ saving
-        color_type = pc_fusion_wrappers.get_color_type([pc_dataset])
+        color_type = pc_transform.get_color_type([pc_dataset])
         attributes = {
             "epsg": cloud_epsg,
             "color_type": color_type,
@@ -1196,6 +1197,7 @@ def triangulation_wrapper(
     return pc_dataset, flatten_pc_dataset
 
 
+# pylint: disable=too-many-positional-arguments
 def triangulation_wrapper_matches(
     matches,
     sensor1,