cars 1.0.0a3__cp39-cp39-win_amd64.whl → 1.0.0a4__cp39-cp39-win_amd64.whl

cars/__init__.py

@@ -24,7 +24,7 @@ Cars module init file
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_11_1():
+def _delvewheel_patch_1_11_2():
     import ctypes
     import os
     import platform
@@ -35,10 +35,10 @@ def _delvewheel_patch_1_11_1():
         if os.path.isdir(libs_dir):
             os.add_dll_directory(libs_dir)
     else:
-        load_order_filepath = os.path.join(libs_dir, '.load-order-cars-1.0.0a3')
+        load_order_filepath = os.path.join(libs_dir, '.load-order-cars-1.0.0a4')
         if os.path.isfile(load_order_filepath):
             import ctypes.wintypes
-            with open(os.path.join(libs_dir, '.load-order-cars-1.0.0a3')) as file:
+            with open(os.path.join(libs_dir, '.load-order-cars-1.0.0a4')) as file:
                 load_order = file.read().split()
             kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
             kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
@@ -49,8 +49,8 @@ def _delvewheel_patch_1_11_1():
                     raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
 
 
-_delvewheel_patch_1_11_1()
-del _delvewheel_patch_1_11_1
+_delvewheel_patch_1_11_2()
+del _delvewheel_patch_1_11_2
 # end delvewheel patch
 
 import os

cars/applications/__init__.py

@@ -30,9 +30,6 @@ from . import dense_matching  # noqa: F401
 from . import dsm_filling  # noqa: F401
 from . import grid_generation  # noqa: F401
 from . import ground_truth_reprojection  # noqa: F401
-from . import hole_detection  # noqa: F401
-from . import point_cloud_denoising  # noqa: F401
-from . import point_cloud_fusion  # noqa: F401
 from . import point_cloud_outlier_removal  # noqa: F401
 from . import rasterization  # noqa: F401
 from . import resampling  # noqa: F401

cars/applications/application_template.py

@@ -29,6 +29,7 @@ in sub application classes
 
 # Standard imports
 import logging
+import os
 import pprint
 from abc import ABCMeta, abstractmethod
 
@@ -103,6 +104,25 @@ class ApplicationTemplate(metaclass=ABCMeta):
 
         return self.used_config
 
+    def generate_unknown_dump_dir(self, orchestrator):
+        """
+        Generate dump dir from orchestrator
+
+        :param orchestrator: orchestrator
+
+        :return: dump dir
+        """
+
+        dump_dir = None
+        if orchestrator is not None:
+            orch_out_dir = orchestrator.out_dir
+            dump_dir = os.path.join(
+                orch_out_dir,
+                "unknown_dump",
+                self.__class__.__bases__[0].__name__,
+            )
+        return dump_dir
+
 
 class ScalingApplicationTemplate(ApplicationTemplate, metaclass=ABCMeta):
     """

cars/applications/auxiliary_filling/abstract_auxiliary_filling_app.py

@@ -86,8 +86,18 @@ class AuxiliaryFilling(ApplicationTemplate, metaclass=ABCMeta):
         cls.available_applications[short_name] = cls
 
     @abstractmethod
-    def run(
-        self, dsm_file, color_file, classif_file, dump_dir, orchestrator=None
+    def run(  # pylint: disable=too-many-positional-arguments
+        self,
+        dsm_file,
+        color_file,
+        classif_file,
+        dump_dir,
+        sensor_inputs,
+        pairing,
+        geom_plugin,
+        texture_bands,
+        output_geoid,
+        orchestrator=None,
     ):
         """
         Run Auxiliary filling

cars/applications/auxiliary_filling/auxiliary_filling_algo.py

@@ -28,7 +28,7 @@ import rasterio as rio
 from scipy import interpolate
 
 
-def fill_auxiliary(
+def fill_auxiliary(  # pylint: disable=too-many-positional-arguments
     sensor_inputs,
     pairing,
     longitudes,
@@ -156,7 +156,7 @@ def fill_auxiliary(
     return filled_color, filled_classif
 
 
-def fill_from_one_sensor(  # noqa C901
+def fill_from_one_sensor(  # pylint: disable=too-many-positional-arguments  # noqa C901
     sensor,
     filled_color,
     filled_classif,

cars/applications/auxiliary_filling/auxiliary_filling_from_sensors_app.py

@@ -31,6 +31,8 @@ import rasterio as rio
 import xarray as xr
 from json_checker import Checker
 from pyproj import CRS
+from rasterio.enums import Resampling
+from rasterio.warp import reproject
 from shapely.geometry import Polygon
 
 import cars.orchestrator.orchestrator as ocht
@@ -94,10 +96,11 @@ class AuxiliaryFillingFromSensors(
         overloaded_conf["mode"] = conf.get("mode", "fill_nan")
 
         if overloaded_conf["mode"] not in ["fill_nan", "full"]:
+            # pylint: disable=inconsistent-quotes
             raise RuntimeError(
                 f"Invalid mode {overloaded_conf['mode']} for "
-                "AuxiliaryFilling, supported modes are fill_nan "
-                "and full"
+                f"AuxiliaryFilling, supported modes are fill_nan "
+                f"and full"
             )
 
         overloaded_conf["texture_interpolator"] = conf.get(
@@ -126,7 +129,8 @@ class AuxiliaryFillingFromSensors(
 
         return overloaded_conf
 
-    def run(
+    # pylint: disable=too-many-positional-arguments
+    def run(  # noqa: C901
         self,
         dsm_file,
         color_file,
@@ -136,6 +140,7 @@ class AuxiliaryFillingFromSensors(
         pairing,
         geom_plugin,
         texture_bands,
+        output_geoid,
         orchestrator=None,
     ):
         """
@@ -158,6 +163,10 @@ class AuxiliaryFillingFromSensors(
         :type geom_plugin: AbstractGeometry
         :param texture_bands: list of band names used for output texture
         :type texture_bands: list
+        :param output_geoid: output geoid filename as vertical reference for the
+            input DSM. If a boolean is provided instead of a filename True means
+            defined relative to cars internal geoid, and false on ellipsoid
+        :type output_geoid: OR(bool, str)
         :param orchestrator: orchestrator used
         :type orchestrator: Orchestrator
         """
@@ -188,7 +197,7 @@ class AuxiliaryFillingFromSensors(
             os.makedirs(dump_dir)
 
         color_not_filled_file = os.path.join(dump_dir, "texture_not_filled.tif")
-        if os.path.exists(color_file):
+        if color_file is not None and os.path.exists(color_file):
             shutil.move(color_file, color_not_filled_file)
 
         classification_not_filled_file = None
@@ -233,19 +242,20 @@ class AuxiliaryFillingFromSensors(
         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:
-                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=texture_no_data_value,
-            dtype=color_dtype,
-            cars_ds_name="filled_texture",
-        )
+        if color_file is not None:
+            if os.path.exists(color_not_filled_file):
+                with rio.open(color_not_filled_file, "r") as descriptor:
+                    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=texture_no_data_value,
+                dtype=color_dtype,
+                cars_ds_name="filled_texture",
+            )
 
         if classif_file is not None:
             if os.path.exists(classification_not_filled_file):
@@ -304,6 +314,7 @@ class AuxiliaryFillingFromSensors(
                     full_saving_info,
                     geom_plugin,
                     texture_bands,
+                    output_geoid,
                     mode=self.used_config["mode"],
                     texture_interpolator=self.used_config[
                         "texture_interpolator"
@@ -319,6 +330,7 @@ class AuxiliaryFillingFromSensors(
         return aux_filled_image
 
 
+# pylint: disable=too-many-positional-arguments
 def filling_from_sensor_wrapper(
     dsm_file,
     color_file,
@@ -332,6 +344,7 @@ def filling_from_sensor_wrapper(
     saving_info,
     geom_plugin,
     texture_bands,
+    output_geoid,
     mode,
     texture_interpolator,
     use_mask,
@@ -363,6 +376,10 @@ def filling_from_sensor_wrapper(
     :type geom_plugin: AbstractGeometry
     :param texture_bands: list of band names used for output texture
     :type texture_bands: list
+    :param output_geoid: output geoid filename as vertical reference for the
+        input DSM. If a boolean is provided instead of a filename True means
+        defined relative to cars internal geoid, and false on ellipsoid
+    :type output_geoid: OR(bool, str)
     :param mode: geometry plugin used for inverse locations
     :type mode: str
     :param texture_interpolator: scipy interpolator use to interpolate color
@@ -370,13 +387,17 @@ def filling_from_sensor_wrapper(
     :type texture_interpolator: str
     :param use_mask: use mask information from sensors in color computation
     :type use_mask: bool
-
     """
 
-    col_min_ground = window["col_min"] * transform[0] + transform[2]
-    col_max_ground = window["col_max"] * transform[0] + transform[2]
-    row_min_ground = window["row_min"] * transform[4] + transform[5]
-    row_max_ground = window["row_max"] * transform[4] + transform[5]
+    col_min = window["col_min"]
+    col_max = window["col_max"]
+    row_min = window["row_min"]
+    row_max = window["row_max"]
+
+    col_min_ground = col_min * transform[0] + transform[2]
+    col_max_ground = col_max * transform[0] + transform[2]
+    row_min_ground = row_min * transform[4] + transform[5]
+    row_max_ground = row_max * transform[4] + transform[5]
 
     ground_polygon = Polygon(
         [
@@ -388,15 +409,13 @@ def filling_from_sensor_wrapper(
         ]
     )
 
-    cols = np.arange(
-        col_min_ground,
-        col_max_ground,
-        transform[0],
+    cols = (
+        np.linspace(col_min, col_max, col_max - col_min) * transform[0]
+        + transform[2]
     )
-    rows = np.arange(
-        row_min_ground,
-        row_max_ground,
-        transform[4],
+    rows = (
+        np.linspace(row_min, row_max, row_max - row_min) * transform[4]
+        + transform[5]
     )
 
     cols_values_2d, rows_values_2d = np.meshgrid(cols, rows)
@@ -409,12 +428,12 @@ def filling_from_sensor_wrapper(
 
     rio_window = rio.windows.Window.from_slices(
         (
-            window["row_min"],
-            window["row_max"],
+            row_min,
+            row_max,
         ),
         (
-            window["col_min"],
-            window["col_max"],
+            col_min,
+            col_max,
         ),
     )
 
@@ -428,6 +447,28 @@ def filling_from_sensor_wrapper(
         target_mask = dsm_image.read_masks(1, window=rio_window)
         dsm_profile = dsm_image.profile
 
+    if output_geoid:
+        if output_geoid is True:
+            geoid_file = geom_plugin.geoid
+        else:
+            geoid_file = output_geoid
+        with rio.open(geoid_file) as in_geoid:
+            # Reproject the geoid data to match the DSM
+            output_geoid_data = np.empty(
+                alt_values.shape, dtype=in_geoid.dtypes[0]
+            )
+
+            reproject(
+                source=rio.band(in_geoid, 1),
+                destination=output_geoid_data,
+                src_transform=in_geoid.transform,
+                src_crs=in_geoid.crs,
+                dst_transform=transform,
+                dst_crs=crs,
+                resampling=Resampling.bilinear,
+            )
+            alt_values += output_geoid_data
+
     nodata_color = None
     nodata_classif = None
 
@@ -543,8 +584,8 @@ def filling_from_sensor_wrapper(
                 classification_values_filled[band_index, :],
             )
 
-    row_arr = np.array(range(window["row_min"], window["row_max"]))
-    col_arr = np.array(range(window["col_min"], window["col_max"]))
+    row_arr = np.array(range(row_min, row_max))
+    col_arr = np.array(range(col_min, col_max))
 
     values = {}
     coords = {cst.ROW: row_arr, cst.COL: col_arr}
@@ -573,6 +614,9 @@ def filling_from_sensor_wrapper(
         values,
         coords=coords,
     )
+
+    profile.update(crs=crs.to_wkt())
+
     cars_dataset.fill_dataset(
         dataset,
         saving_info=saving_info,

cars/applications/dem_generation/dem_generation_algo.py

@@ -108,7 +108,7 @@ def launch_bulldozer(
     return output_dem
 
 
-def multi_res_rec(
+def multi_res_rec(  # pylint: disable=too-many-positional-arguments
     pd_pc,
     list_fun,
     x_grid,

cars/applications/dem_generation/dem_generation_wrappers.py

@@ -26,7 +26,6 @@ import logging
 import os
 
 import numpy as np
-import pyproj
 import rasterio as rio
 import xdem
 
@@ -37,8 +36,6 @@ from rasterio.enums import Resampling
 from rasterio.warp import calculate_default_transform, reproject
 from scipy.ndimage import median_filter
 
-from cars.core import preprocessing
-
 
 def fit_initial_elevation_on_dem_median(
     dem_to_fit_path: str, dem_ref_path: str, dem_out_path: str
@@ -136,7 +133,7 @@ def add_margin(bbox, ratio=1):
     return new_bbox
 
 
-def generate_grid(
+def generate_grid(  # pylint: disable=too-many-positional-arguments
     pd_pc, resolution, xmin=None, xmax=None, ymin=None, ymax=None
 ):
     """
@@ -247,7 +244,8 @@ def reverse_dem(input_dem):
 def downsample_dem(
     input_dem,
     scale,
-    median_filter_size=7,
+    interpolator,
+    median_filter_size=None,
     default_alt=0,
 ):
     """
@@ -272,6 +270,13 @@ def downsample_dem(
     metadata["height"] = dst_height
     metadata["width"] = dst_width
     dem_data = np.zeros((dst_height, dst_width))
+    interpolator_dict = {
+        "min": Resampling.min,
+        "median": Resampling.med,
+        "max": Resampling.max,
+        "nearest": Resampling.nearest,
+    }
+    interpolator = interpolator_dict[interpolator]
     reproject(
         data,
         dem_data,
@@ -280,13 +285,14 @@ def downsample_dem(
         dst_transform=dst_transform,
         dst_crs=crs,
         dst_nodata=nodata,
-        resampling=Resampling.med,
+        resampling=interpolator,
     )
 
     # Post-processing
 
     # Median filter
-    dem_data = median_filter(dem_data, size=median_filter_size)
+    if median_filter_size is not None:
+        dem_data = median_filter(dem_data, size=median_filter_size)
 
     # Fill nodata
     dem_data = rio.fill.fillnodata(
@@ -300,65 +306,25 @@ def downsample_dem(
         dst.write(dem_data, 1)
 
 
-def modify_terrain_bounds(
-    bounds_poly, in_epsg, out_epsg, constant_margin, linear_margin=0
-):
+def modify_terrain_bounds(terrain_bounds, linear_margin, constant_margin):
     """
     Modify the terrain bounds
 
-    :param bounds_poly: Input region of interest for DEM
-    :type bounds_poly: list
-    :param in_epsg: EPSG code of dem_roi_to_use
-    :type in_epsg: int
-    :param out_epsg: EPSG code of dem_roi_to_use
-    :type out_epsg: int
+    :param terrain_bounds: Input region of interest for DEM
+    :type terrain_bounds: list
     :param margin: Margin of the output ROI in meters
     :type margin: int
     """
-    # Get bounds
-    xmin = min(bounds_poly[0], bounds_poly[2])
-    xmax = max(bounds_poly[0], bounds_poly[2])
-    ymin = min(bounds_poly[1], bounds_poly[3])
-    ymax = max(bounds_poly[1], bounds_poly[3])
-
-    bounds_cloud = [xmin, ymin, xmax, ymax]
-
-    if in_epsg == 4326:
-        # Convert resolution and margin to degrees
-        utm_epsg = preprocessing.get_utm_zone_as_epsg_code(xmin, ymin)
-        conversion_factor = preprocessing.get_conversion_factor(
-            bounds_cloud, 4326, utm_epsg
-        )
-        constant_margin *= conversion_factor
-
-    # Get borders, adding margin
-    xmin = xmin - constant_margin - linear_margin * (xmax - xmin)
-    ymin = ymin - constant_margin - linear_margin * (ymax - ymin)
-    xmax = xmax + constant_margin + linear_margin * (xmax - xmin)
-    ymax = ymax + constant_margin + linear_margin * (ymax - ymin)
+    xsize = terrain_bounds[2] - terrain_bounds[0]
+    ysize = terrain_bounds[3] - terrain_bounds[1]
+    xmin = terrain_bounds[0] - linear_margin * xsize - constant_margin
+    ymin = terrain_bounds[1] - linear_margin * ysize - constant_margin
+    xmax = terrain_bounds[2] + linear_margin * xsize + constant_margin
+    ymax = terrain_bounds[3] + linear_margin * ysize + constant_margin
 
     terrain_bounds = [xmin, ymin, xmax, ymax]
 
-    if out_epsg != in_epsg:
-        crs_in = pyproj.CRS.from_epsg(in_epsg)
-        crs_out = pyproj.CRS.from_epsg(out_epsg)
-
-        transformer = pyproj.Transformer.from_crs(
-            crs_in, crs_out, always_xy=True
-        )
-
-        xymin = transformer.transform(terrain_bounds[0], terrain_bounds[1])
-        xymax = transformer.transform(terrain_bounds[2], terrain_bounds[3])
-
-        xmin, ymin = xymin if isinstance(xymin, tuple) else (None, None)
-        xmax, ymax = xymax if isinstance(xymax, tuple) else (None, None)
-
-        if None in (xmin, ymin, xmax, ymax):
-            raise RuntimeError("An error occured during the projection")
-
-    new_terrain_bounds = [xmin, ymin, xmax, ymax]
-
-    return new_terrain_bounds
+    return terrain_bounds
 
 
 def reproject_dem(dsm_file_name, epsg_out, out_file_name):

cars/applications/dem_generation/dichotomic_generation_app.py

@@ -129,7 +129,7 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         overloaded_conf["resolution"] = conf.get("resolution", 90)
         # default margin: (z max - zmin) * tan(teta)
         # with z max = 9000, z min = 0, teta = 30 degrees
-        overloaded_conf["margin"] = conf.get("margin", 6000)
+        overloaded_conf["margin"] = conf.get("margin", [0, 6000])
         overloaded_conf["height_margin"] = conf.get("height_margin", 20)
         overloaded_conf["percentile"] = conf.get("percentile", 1)
         overloaded_conf["min_number_matches"] = conf.get(
@@ -154,7 +154,7 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         rectification_schema = {
             "method": str,
             "resolution": And(Or(float, int), lambda x: x > 0),
-            "margin": And(Or(float, int), lambda x: x > 0),
+            "margin": [Or(float, int)],
             "height_margin": Or(list, int),
             "percentile": And(Or(int, float), lambda x: x >= 0),
             "min_number_matches": And(int, lambda x: x > 0),
@@ -173,7 +173,7 @@ class DichotomicGeneration(DemGeneration, short_name="dichotomic"):
         return overloaded_conf
 
     @cars_profile(name="DEM Generation")
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         triangulated_matches_list,
         output_dir,