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

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):
@@ -156,6 +160,7 @@ class PointCloudOutlierRemoval(ApplicationTemplate, metaclass=ABCMeta):
 
         """
 
+    # pylint: disable=too-many-positional-arguments
     def __register_epipolar_dataset__(
         self,
         epipolar_point_cloud,
@@ -346,7 +351,7 @@ class PointCloudOutlierRemoval(ApplicationTemplate, metaclass=ABCMeta):
         )
 
     @abstractmethod
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         merged_point_cloud,
         orchestrator=None,

cars/applications/point_cloud_outlier_removal/outlier_removal_algo.py

@@ -31,7 +31,7 @@ import outlier_filter  # pylint:disable=E0401
 import pandas
 from scipy.spatial import cKDTree  # pylint: disable=no-name-in-module
 
-from cars.applications.point_cloud_fusion.pc_fusion_wrappers import filter_cloud
+from cars.applications.triangulation import pc_transform
 
 # CARS imports
 from cars.core import constants as cst
@@ -82,7 +82,9 @@ def small_component_filtering(
         clusters_distance_threshold=clusters_distance_threshold_float,
     )
 
-    return filter_cloud(cloud, index_elt_to_remove, filtered_elt_pos)
+    return pc_transform.filter_cloud(
+        cloud, index_elt_to_remove, filtered_elt_pos
+    )
 
 
 def detect_small_components(
@@ -188,6 +190,7 @@ def detect_small_components(
 # ##### statistical filtering ######
 
 
+# pylint: disable=too-many-positional-arguments
 def statistical_outlier_filtering(
     cloud: pandas.DataFrame,
     k: int,
@@ -228,7 +231,9 @@ def statistical_outlier_filtering(
         use_median=use_median,
     )
 
-    return filter_cloud(cloud, index_elt_to_remove, filtered_elt_pos)
+    return pc_transform.filter_cloud(
+        cloud, index_elt_to_remove, filtered_elt_pos
+    )
 
 
 def detect_statistical_outliers(
@@ -339,9 +344,9 @@ def epipolar_small_components(
     return cloud
 
 
+# pylint: disable=too-many-positional-arguments
 def epipolar_statistical_filtering(
     epipolar_ds,
-    epsg,
     k=15,
     filtering_constant=0.0,
     mean_factor=1.0,
@@ -354,8 +359,6 @@ def epipolar_statistical_filtering(
 
     :param epipolar_ds: epipolar dataset to filter
     :type epipolar_ds: xr.Dataset
-    :param epsg: epsg code of the CRS used to compute distances
-    :type epsg: int
     :param statistical_k: k
     :type statistical_k: int
     :param std_dev_factor: std factor
@@ -370,8 +373,6 @@ def epipolar_statistical_filtering(
 
     """
 
-    projection.point_cloud_conversion_dataset(epipolar_ds, epsg)
-
     if not np.all(np.isnan(epipolar_ds[cst.Z])):
 
         outlier_filter.epipolar_statistical_outlier_filtering(

cars/applications/point_cloud_outlier_removal/small_components_app.py

@@ -27,9 +27,7 @@ import copy
 
 # Standard imports
 import logging
-import math
 import os
-import time
 
 # Third party imports
 import numpy as np
@@ -39,14 +37,13 @@ from pyproj import CRS
 # CARS imports
 import cars.orchestrator.orchestrator as ocht
 from cars.applications import application_constants
-from cars.applications.point_cloud_fusion import (
-    pc_fusion_algo,
-    pc_fusion_wrappers,
-)
 from cars.applications.point_cloud_outlier_removal import (
     abstract_outlier_removal_app as pc_removal,
 )
-from cars.applications.point_cloud_outlier_removal import outlier_removal_algo
+from cars.applications.point_cloud_outlier_removal import (
+    outlier_removal_algo,
+)
+from cars.applications.triangulation import pc_transform
 from cars.applications.triangulation.triangulation_wrappers import (
     generate_point_cloud_file_names,
 )
@@ -64,20 +61,21 @@ 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"]
 
         # small components
-        self.activated = self.used_config["activated"]
         self.on_ground_margin = self.used_config["on_ground_margin"]
         self.connection_distance = self.used_config["connection_distance"]
         self.nb_points_threshold = self.used_config["nb_points_threshold"]
@@ -119,10 +117,6 @@ class SmallComponents(
         overloaded_conf["save_by_pair"] = conf.get("save_by_pair", False)
 
         # small components
-        overloaded_conf["activated"] = conf.get(
-            "activated", True
-        )  # if false, the following
-        # parameters are unused
         # on_ground_margin:
         #           margin added to the on ground region to not filter
         #           points clusters
@@ -131,7 +125,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
@@ -159,7 +153,6 @@ class SmallComponents(
         point_cloud_fusion_schema = {
             "method": str,
             "save_by_pair": bool,
-            "activated": bool,
             "on_ground_margin": int,
             "connection_distance": And(float, lambda x: x > 0),
             "nb_points_threshold": And(int, lambda x: x > 0),
@@ -194,18 +187,12 @@ class SmallComponents(
         :rtype: float
 
         """
+        tot = 10000 * superposing_point_clouds / point_cloud_resolution
 
-        if not self.activated:
-            # if not activated, this tile size must not be taken into acount
-            # during the min(*tile_sizes) operations
-            tile_size = math.inf
-        else:
-            tot = 10000 * superposing_point_clouds / point_cloud_resolution
-
-            import_ = 200  # MiB
-            tile_size = int(
-                np.sqrt(float(((max_ram_per_worker - import_) * 2**23)) / tot)
-            )
+        import_ = 200  # MiB
+        tile_size = int(
+            np.sqrt(float(((max_ram_per_worker - import_) * 2**23)) / tot)
+        )
 
         logging.info(
             "Estimated optimal tile size for small"
@@ -232,11 +219,7 @@ class SmallComponents(
         :return: margin
         :rtype: int
         """
-
-        margin = 0
-
-        if self.activated:
-            margin = self.half_epipolar_size
+        margin = self.half_epipolar_size
 
         return margin
 
@@ -248,15 +231,11 @@ class SmallComponents(
         :rtype: float
 
         """
-
-        on_ground_margin = 0
-
-        if self.activated:
-            on_ground_margin = self.on_ground_margin * resolution
+        on_ground_margin = self.on_ground_margin * resolution
 
         return on_ground_margin
 
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         merged_point_cloud,
         orchestrator=None,
@@ -310,10 +289,6 @@ class SmallComponents(
 
         :rtype: CarsDataset filled with xr.Dataset
         """
-
-        if not self.activated:
-            return merged_point_cloud
-
         # Default orchestrator
         if orchestrator is None:
             # Create default sequential orchestrator for current application
@@ -325,244 +300,99 @@ class SmallComponents(
         else:
             self.orchestrator = orchestrator
 
-        if merged_point_cloud.dataset_type == "points":
-            (
-                filtered_point_cloud,
-                point_cloud_laz_file_name,
-                point_cloud_csv_file_name,
-                saving_info,
-            ) = self.__register_pc_dataset__(
-                merged_point_cloud,
-                point_cloud_dir,
-                dump_dir,
-                app_name="small_components",
-            )
-            # Generate rasters
-            for col in range(filtered_point_cloud.shape[1]):
-                for row in range(filtered_point_cloud.shape[0]):
-                    # update saving infos  for potential replacement
-                    full_saving_info = ocht.update_saving_infos(
-                        saving_info, row=row, col=col
-                    )
-                    if merged_point_cloud.tiles[row][col] is not None:
-                        # Delayed call to cloud filtering
-                        filtered_point_cloud[
-                            row, col
-                        ] = self.orchestrator.cluster.create_task(
-                            small_component_removal_wrapper
-                        )(
-                            merged_point_cloud[row, col],
-                            self.connection_distance,
-                            self.nb_points_threshold,
-                            self.clusters_distance_threshold,
-                            save_by_pair=(self.save_by_pair),
-                            point_cloud_csv_file_name=point_cloud_csv_file_name,
-                            point_cloud_laz_file_name=point_cloud_laz_file_name,
-                            saving_info=full_saving_info,
-                        )
+        if dump_dir is None:
+            dump_dir = self.generate_unknown_dump_dir(self.orchestrator)
 
-        elif merged_point_cloud.dataset_type == "arrays":
-            prefix = os.path.basename(dump_dir)
-            # Save as depth map
-            filtered_point_cloud, saving_info_epipolar = (
-                self.__register_epipolar_dataset__(
-                    merged_point_cloud,
-                    depth_map_dir,
-                    dump_dir,
-                    app_name="small_components",
-                    pair_key=prefix,
-                )
+        if merged_point_cloud.dataset_type != "arrays":
+            raise RuntimeError(
+                "Only arrays is supported in small components removal"
             )
-
-            # Save as point cloud
-            (
-                flatten_filtered_point_cloud,
-                laz_pc_dir_name,
-                csv_pc_dir_name,
-                saving_info_flatten,
-            ) = self.__register_pc_dataset__(
+        prefix = os.path.basename(dump_dir)
+        # Save as depth map
+        filtered_point_cloud, saving_info_epipolar = (
+            self.__register_epipolar_dataset__(
                 merged_point_cloud,
-                point_cloud_dir,
+                depth_map_dir,
                 dump_dir,
                 app_name="small_components",
+                pair_key=prefix,
             )
+        )
 
-            # initialize empty index file for point cloud product if official
-            # product is requested
-            pc_index = None
-            if point_cloud_dir:
-                pc_index = {}
+        # Save as point cloud
+        (
+            flatten_filtered_point_cloud,
+            laz_pc_dir_name,
+            csv_pc_dir_name,
+            saving_info_flatten,
+        ) = self.__register_pc_dataset__(
+            merged_point_cloud,
+            point_cloud_dir,
+            dump_dir,
+            app_name="small_components",
+        )
+
+        # initialize empty index file for point cloud product if official
+        # product is requested
+        pc_index = None
+        if point_cloud_dir:
+            pc_index = {}
 
-            # Generate rasters
-            for col in range(filtered_point_cloud.shape[1]):
-                for row in range(filtered_point_cloud.shape[0]):
+        # Generate rasters
+        for col in range(filtered_point_cloud.shape[1]):
+            for row in range(filtered_point_cloud.shape[0]):
 
-                    # update saving infos  for potential replacement
-                    full_saving_info_epipolar = ocht.update_saving_infos(
-                        saving_info_epipolar, row=row, col=col
+                # update saving infos  for potential replacement
+                full_saving_info_epipolar = ocht.update_saving_infos(
+                    saving_info_epipolar, row=row, col=col
+                )
+                full_saving_info_flatten = None
+                if saving_info_flatten is not None:
+                    full_saving_info_flatten = ocht.update_saving_infos(
+                        saving_info_flatten, row=row, col=col
                     )
-                    full_saving_info_flatten = None
-                    if saving_info_flatten is not None:
-                        full_saving_info_flatten = ocht.update_saving_infos(
-                            saving_info_flatten, row=row, col=col
+                if merged_point_cloud[row][col] is not None:
+                    csv_pc_file_name, laz_pc_file_name = (
+                        generate_point_cloud_file_names(
+                            csv_pc_dir_name,
+                            laz_pc_dir_name,
+                            row,
+                            col,
+                            pc_index,
+                            pair_key=prefix,
                         )
-                    if merged_point_cloud[row][col] is not None:
-                        csv_pc_file_name, laz_pc_file_name = (
-                            generate_point_cloud_file_names(
-                                csv_pc_dir_name,
-                                laz_pc_dir_name,
-                                row,
-                                col,
-                                pc_index,
-                                pair_key=prefix,
-                            )
-                        )
-                        window = merged_point_cloud.tiling_grid[row, col]
-                        overlap = filtered_point_cloud.overlaps[row, col]
-                        # Delayed call to cloud filtering
-                        (
-                            filtered_point_cloud[row, col],
-                            flatten_filtered_point_cloud[row, col],
-                        ) = self.orchestrator.cluster.create_task(
-                            epipolar_small_component_removal_wrapper, nout=2
-                        )(
-                            merged_point_cloud[row, col],
-                            self.connection_distance,
-                            self.nb_points_threshold,
-                            self.clusters_distance_threshold,
-                            self.half_epipolar_size,
-                            window,
-                            overlap,
-                            point_cloud_csv_file_name=csv_pc_file_name,
-                            point_cloud_laz_file_name=laz_pc_file_name,
-                            saving_info_epipolar=full_saving_info_epipolar,
-                            saving_info_flatten=full_saving_info_flatten,
-                        )
-
-            # update point cloud index
-            if point_cloud_dir:
-                self.orchestrator.update_index(pc_index)
+                    )
+                    window = merged_point_cloud.tiling_grid[row, col]
+                    overlap = filtered_point_cloud.overlaps[row, col]
+                    # Delayed call to cloud filtering
+                    (
+                        filtered_point_cloud[row, col],
+                        flatten_filtered_point_cloud[row, col],
+                    ) = self.orchestrator.cluster.create_task(
+                        epipolar_small_component_removal_wrapper, nout=2
+                    )(
+                        merged_point_cloud[row, col],
+                        self.connection_distance,
+                        self.nb_points_threshold,
+                        self.clusters_distance_threshold,
+                        self.half_epipolar_size,
+                        window,
+                        overlap,
+                        epsg=epsg,
+                        point_cloud_csv_file_name=csv_pc_file_name,
+                        point_cloud_laz_file_name=laz_pc_file_name,
+                        saving_info_epipolar=full_saving_info_epipolar,
+                        saving_info_flatten=full_saving_info_flatten,
+                    )
 
-        else:
-            logging.error(
-                "PointCloudOutlierRemoval application doesn't support "
-                "this input data "
-                "format"
-            )
+        # update point cloud index
+        if point_cloud_dir:
+            self.orchestrator.update_index(pc_index)
 
         return filtered_point_cloud
 
 
-def small_component_removal_wrapper(
-    cloud,
-    connection_distance,
-    nb_points_threshold,
-    clusters_distance_threshold,
-    save_by_pair: bool = False,
-    point_cloud_csv_file_name=None,
-    point_cloud_laz_file_name=None,
-    saving_info=None,
-):
-    """
-    Small components outlier removal
-
-    :param cloud: cloud to filter
-    :type cloud: pandas DataFrame
-    :param connection_distance: connection distance
-    :type connection_distance: float
-    :param nb_points_threshold:
-    :type nb_points_threshold: int
-    :param clusters_distance_threshold:
-    :type clusters_distance_threshold: float
-    :param save_by_pair: save point cloud as pair
-    :type save_by_pair: bool
-    :param point_cloud_csv_file_name: write point cloud as CSV in filename
-        (if None, the point cloud is not written as csv)
-    :type point_cloud_csv_file_name: str
-    :param point_cloud_laz_file_name: write point cloud as laz in filename
-        (if None, the point cloud is not written as laz)
-    :type point_cloud_laz_file_name: str
-    :param saving_info: saving infos
-    :type saving_info: dict
-
-    :return: filtered cloud
-    :rtype: pandas DataFrame
-
-    """
-
-    # Copy input cloud
-    new_cloud = cloud.copy()
-    new_cloud.attrs = copy.deepcopy(cloud.attrs)
-
-    # Get current epsg
-    cloud_attributes = cars_dataset.get_attributes(new_cloud)
-    cloud_epsg = cloud_attributes["epsg"]
-    current_epsg = cloud_epsg
-
-    # Check if can be used to filter
-    spatial_ref = CRS.from_epsg(cloud_epsg)
-    if spatial_ref.is_geographic:
-        logging.debug(
-            "The points cloud to filter is not in a cartographic system. "
-            "The filter's default parameters might not be adapted "
-            "to this referential. Please, convert the points "
-            "cloud to ECEF to ensure a proper point_cloud."
-        )
-        # Convert to epsg = 4978
-        cartographic_epsg = 4978
-
-        projection.point_cloud_conversion_dataframe(
-            new_cloud, current_epsg, cartographic_epsg
-        )
-        current_epsg = cartographic_epsg
-
-    # Filter point cloud
-    tic = time.process_time()
-    (
-        new_cloud,
-        _,
-    ) = outlier_removal_algo.small_component_filtering(
-        new_cloud,
-        connection_distance,
-        nb_points_threshold,
-        clusters_distance_threshold,
-    )
-    toc = time.process_time()
-    logging.debug(
-        "Small component cloud filtering done in {} seconds".format(toc - tic)
-    )
-
-    # Conversion to UTM
-    projection.point_cloud_conversion_dataframe(
-        new_cloud, cloud_epsg, current_epsg
-    )
-    # Update attributes
-    cloud_attributes["epsg"] = current_epsg
-    cars_dataset.fill_dataframe(
-        new_cloud, saving_info=saving_info, attributes=cloud_attributes
-    )
-
-    # save point cloud in worker
-    if point_cloud_csv_file_name:
-        cars_dataset.run_save_points(
-            new_cloud,
-            point_cloud_csv_file_name,
-            save_by_pair=save_by_pair,
-            overwrite=True,
-            point_cloud_format="csv",
-        )
-    if point_cloud_laz_file_name:
-        cars_dataset.run_save_points(
-            new_cloud,
-            point_cloud_laz_file_name,
-            save_by_pair=save_by_pair,
-            overwrite=True,
-            point_cloud_format="laz",
-        )
-
-    return new_cloud
-
-
+# pylint: disable=too-many-positional-arguments
 def epipolar_small_component_removal_wrapper(
     cloud,
     connection_distance,
@@ -571,6 +401,7 @@ def epipolar_small_component_removal_wrapper(
     half_epipolar_size,
     window,
     overlap,
+    epsg=None,
     point_cloud_csv_file_name=None,
     point_cloud_laz_file_name=None,
     saving_info_epipolar=None,
@@ -647,19 +478,19 @@ def epipolar_small_component_removal_wrapper(
     if point_cloud_csv_file_name or point_cloud_laz_file_name:
         # Convert epipolar array into point cloud
         flatten_filtered_cloud, cloud_epsg = (
-            pc_fusion_algo.create_combined_cloud(
-                [filtered_cloud], ["0"], current_epsg
+            pc_transform.depth_map_dataset_to_dataframe(
+                filtered_cloud, current_epsg
             )
         )
         # Convert to UTM
-        if current_epsg is not None and cloud_epsg != current_epsg:
+        if epsg is not None and cloud_epsg != epsg:
             projection.point_cloud_conversion_dataframe(
-                flatten_filtered_cloud, cloud_epsg, current_epsg
+                flatten_filtered_cloud, cloud_epsg, epsg
             )
-            cloud_epsg = current_epsg
+            cloud_epsg = epsg
 
         # Fill attributes for LAZ saving
-        color_type = pc_fusion_wrappers.get_color_type([filtered_cloud])
+        color_type = pc_transform.get_color_type([filtered_cloud])
 
         attributes = {
             "epsg": cloud_epsg,