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

cars/pipelines/unit/unit_pipeline.py

@@ -36,6 +36,7 @@ import math
 import os
 
 import numpy as np
+from pyproj import CRS
 
 import cars.applications.sparse_matching.sparse_matching_constants as sm_cst
 from cars import __version__
@@ -56,6 +57,7 @@ from cars.core import preprocessing, projection, roi_tools
 from cars.core.geometry.abstract_geometry import AbstractGeometry
 from cars.core.inputs import (
     get_descriptions_bands,
+    rasterio_get_crs,
     rasterio_get_epsg,
     rasterio_get_size,
     read_vector,
@@ -145,6 +147,9 @@ class UnitPipeline(PipelineTemplate):
             self.geom_plugin_without_dem_and_geoid,
             self.geom_plugin_with_dem_and_geoid,
             self.dem_generation_roi,
+            self.scaling_coeff,
+            self.land_cover_map,
+            self.classification_to_config_mapping,
         ) = advanced_parameters.check_advanced_parameters(
             inputs, conf.get(ADVANCED, {}), check_epipolar_a_priori=True
         )
@@ -161,7 +166,11 @@ class UnitPipeline(PipelineTemplate):
         self.debug_with_roi = self.used_conf[ADVANCED][adv_cst.DEBUG_WITH_ROI]
 
         # Check conf output
-        output = self.check_output(conf[OUTPUT])
+        (
+            output,
+            self.scaling_coeff,
+        ) = self.check_output(conf[OUTPUT], self.scaling_coeff)
+
         self.used_conf[OUTPUT] = output
 
         prod_level = output[out_cst.PRODUCT_LEVEL]
@@ -459,17 +468,18 @@ class UnitPipeline(PipelineTemplate):
         return output_config
 
     @staticmethod
-    def check_output(conf):
+    def check_output(conf, scaling_coeff):
         """
         Check the output given
 
         :param conf: configuration of output
         :type conf: dict
-
-        :return overloader output
-        :rtype : dict
+        :param scaling_coeff: scaling factor for resolution
+        :type scaling_coeff: float
+        :return: overloader output
+        :rtype: dict
         """
-        return output_parameters.check_output_parameters(conf)
+        return output_parameters.check_output_parameters(conf, scaling_coeff)
 
     def check_applications(  # noqa: C901 : too complex
         self,
@@ -483,6 +493,7 @@ class UnitPipeline(PipelineTemplate):
         :param conf: configuration of applications
         :type conf: dict
         """
+        scaling_coeff = self.scaling_coeff
 
         # Check if all specified applications are used
         # Application in terrain_application are note used in
@@ -580,7 +591,9 @@ class UnitPipeline(PipelineTemplate):
         if self.sensors_in_inputs:
             # Epipolar grid generation
             self.epipolar_grid_generation_application = Application(
-                "grid_generation", cfg=used_conf.get("grid_generation", {})
+                "grid_generation",
+                cfg=used_conf.get("grid_generation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["grid_generation"] = (
                 self.epipolar_grid_generation_application.get_conf()
@@ -588,7 +601,9 @@ class UnitPipeline(PipelineTemplate):
 
             # image resampling
             self.resampling_application = Application(
-                "resampling", cfg=used_conf.get("resampling", {})
+                "resampling",
+                cfg=used_conf.get("resampling", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["resampling"] = self.resampling_application.get_conf()
 
@@ -610,10 +625,13 @@ class UnitPipeline(PipelineTemplate):
                 self.ground_truth_reprojection = Application(
                     "ground_truth_reprojection",
                     cfg=used_conf.get("ground_truth_reprojection", {}),
+                    scaling_coeff=scaling_coeff,
                 )
             # holes detection
             self.hole_detection_app = Application(
-                "hole_detection", cfg=used_conf.get("hole_detection", {})
+                "hole_detection",
+                cfg=used_conf.get("hole_detection", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["hole_detection"] = self.hole_detection_app.get_conf()
 
@@ -624,6 +642,7 @@ class UnitPipeline(PipelineTemplate):
                     "dense_match_filling.1",
                     {"method": "plane"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.1"] = (
                 self.dense_match_filling_1.get_conf()
@@ -636,6 +655,7 @@ class UnitPipeline(PipelineTemplate):
                     "dense_match_filling.2",
                     {"method": "zero_padding"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_match_filling.2"] = (
                 self.dense_match_filling_2.get_conf()
@@ -645,6 +665,7 @@ class UnitPipeline(PipelineTemplate):
             self.sparse_mtch_sift_app = Application(
                 "sparse_matching",
                 cfg=used_conf.get("sparse_matching.sift", {"method": "sift"}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["sparse_matching.sift"] = (
                 self.sparse_mtch_sift_app.get_conf()
@@ -672,13 +693,17 @@ class UnitPipeline(PipelineTemplate):
             ):
                 dense_matching_config["performance_map_method"] = "risk"
             self.dense_matching_app = Application(
-                "dense_matching", cfg=dense_matching_config
+                "dense_matching",
+                cfg=dense_matching_config,
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dense_matching"] = self.dense_matching_app.get_conf()
 
             # Triangulation
             self.triangulation_application = Application(
-                "triangulation", cfg=used_conf.get("triangulation", {})
+                "triangulation",
+                cfg=used_conf.get("triangulation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["triangulation"] = (
                 self.triangulation_application.get_conf()
@@ -686,7 +711,9 @@ class UnitPipeline(PipelineTemplate):
 
             # MNT generation
             self.dem_generation_application = Application(
-                "dem_generation", cfg=used_conf.get("dem_generation", {})
+                "dem_generation",
+                cfg=used_conf.get("dem_generation", {}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["dem_generation"] = (
                 self.dem_generation_application.get_conf()
@@ -704,6 +731,7 @@ class UnitPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.1",
                     {"method": "small_components"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["point_cloud_outlier_removal.1"] = (
                 self.pc_outlier_removal_1_app.get_conf()
@@ -716,6 +744,7 @@ class UnitPipeline(PipelineTemplate):
                     "point_cloud_outlier_removal.2",
                     {"method": "statistical"},
                 ),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["point_cloud_outlier_removal.2"] = (
                 self.pc_outlier_removal_2_app.get_conf()
@@ -727,6 +756,7 @@ class UnitPipeline(PipelineTemplate):
             self.pc_denoising_application = Application(
                 "pc_denoising",
                 cfg=used_conf.get("pc_denoising", {"method": "none"}),
+                scaling_coeff=scaling_coeff,
             )
             used_conf["pc_denoising"] = self.pc_denoising_application.get_conf()
 
@@ -736,6 +766,7 @@ class UnitPipeline(PipelineTemplate):
                 self.rasterization_application = Application(
                     "point_cloud_rasterization",
                     cfg=used_conf.get("point_cloud_rasterization", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["point_cloud_rasterization"] = (
                     self.rasterization_application.get_conf()
@@ -747,6 +778,7 @@ class UnitPipeline(PipelineTemplate):
                         "dsm_filling.1",
                         {"method": "exogenous_filling"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.1"] = (
                     self.dsm_filling_1_application.get_conf()
@@ -769,22 +801,25 @@ class UnitPipeline(PipelineTemplate):
                         "dsm_filling.3",
                         {"method": "border_interpolation"},
                     ),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["dsm_filling.3"] = (
                     self.dsm_filling_3_application.get_conf()
                 )
                 # Auxiliary filling
                 self.auxiliary_filling_application = Application(
-                    "auxiliary_filling", cfg=conf.get("auxiliary_filling", {})
+                    "auxiliary_filling",
+                    cfg=conf.get("auxiliary_filling", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["auxiliary_filling"] = (
                     self.auxiliary_filling_application.get_conf()
                 )
 
             if (
-                self.dsm_filling_1_application.classification
-                or self.dsm_filling_2_application.classification
-                or self.dsm_filling_3_application.classification
+                self.dsm_filling_1_application.classification != ["nodata"]
+                or self.dsm_filling_2_application.classification != ["nodata"]
+                or self.dsm_filling_3_application.classification != ["nodata"]
             ):
                 self.save_output_classif_for_filling = True
 
@@ -794,6 +829,7 @@ class UnitPipeline(PipelineTemplate):
                 self.pc_fusion_application = Application(
                     "point_cloud_fusion",
                     cfg=used_conf.get("point_cloud_fusion", {}),
+                    scaling_coeff=scaling_coeff,
                 )
                 used_conf["point_cloud_fusion"] = (
                     self.pc_fusion_application.get_conf()
@@ -914,7 +950,7 @@ class UnitPipeline(PipelineTemplate):
                 ]
             if (
                 "classification" in inputs_conf["sensors"][key2]
-                and inputs_conf["sensors"][key1]["classification"] is not None
+                and inputs_conf["sensors"][key2]["classification"] is not None
             ):
                 classif_right = inputs_conf["sensors"][key2]["classification"][
                     "main_file"
@@ -1156,6 +1192,10 @@ class UnitPipeline(PipelineTemplate):
             # Run cluster breakpoint to compute sifts: force computation
             self.cars_orchestrator.breakpoint()
 
+            minimum_nb_matches = (
+                self.sparse_mtch_sift_app.get_minimum_nb_matches()
+            )
+
             # Run grid correction application
             if self.used_conf[ADVANCED][adv_cst.USE_EPIPOLAR_A_PRIORI] is False:
                 # Estimate grid correction if no epipolar a priori
@@ -1177,10 +1217,6 @@ class UnitPipeline(PipelineTemplate):
                     )
                 )
 
-                minimum_nb_matches = (
-                    self.sparse_mtch_sift_app.get_minimum_nb_matches()
-                )
-
                 # Compute grid correction
                 (
                     self.pairs[pair_key]["grid_correction_coef"],
@@ -1475,6 +1511,7 @@ class UnitPipeline(PipelineTemplate):
                     new_grid_matches_array,
                     self.pairs[pair_key]["grid_right"],
                     save_matches=save_matches,
+                    minimum_nb_matches=minimum_nb_matches,
                     pair_folder=os.path.join(
                         self.dump_dir, "grid_correction", "new", pair_key
                     ),
@@ -1781,6 +1818,7 @@ class UnitPipeline(PipelineTemplate):
                     geoid=self.used_conf[ADVANCED][adv_cst.GROUND_TRUTH_DSM][
                         adv_cst.INPUT_GEOID
                     ],
+                    scaling_coeff=self.scaling_coeff,
                 )
                 self.ground_truth_reprojection.run(
                     self.pairs[pair_key]["sensor_image_left"],
@@ -1804,6 +1842,131 @@ class UnitPipeline(PipelineTemplate):
                     ),
                 )
 
+            if self.epsg is None:
+                # compute epsg
+                # Epsg uses global disparity min and max
+                self.epsg = preprocessing.compute_epsg(
+                    self.pairs[pair_key]["sensor_image_left"],
+                    self.pairs[pair_key]["sensor_image_right"],
+                    self.pairs[pair_key]["corrected_grid_left"],
+                    self.pairs[pair_key]["corrected_grid_right"],
+                    self.geom_plugin_with_dem_and_geoid,
+                    disp_min=self.pairs[pair_key]["disp_range_grid"][
+                        "global_min"
+                    ],
+                    disp_max=self.pairs[pair_key]["disp_range_grid"][
+                        "global_max"
+                    ],
+                )
+                # Compute roi polygon, in input EPSG
+                self.roi_poly = preprocessing.compute_roi_poly(
+                    self.input_roi_poly, self.input_roi_epsg, self.epsg
+                )
+
+            self.vertical_crs = projection.get_output_crs(self.epsg, output)
+
+            if (
+                self.save_output_dsm
+                or self.save_output_point_cloud
+                or self.dense_matching_app.get_method() == "auto"
+            ):
+                # Compute terrain bounding box /roi related to
+                # current images
+                (current_terrain_roi_bbox, intersection_poly) = (
+                    preprocessing.compute_terrain_bbox(
+                        self.pairs[pair_key]["sensor_image_left"],
+                        self.pairs[pair_key]["sensor_image_right"],
+                        new_epipolar_image_left,
+                        self.pairs[pair_key]["corrected_grid_left"],
+                        self.pairs[pair_key]["corrected_grid_right"],
+                        self.epsg,
+                        self.geom_plugin_with_dem_and_geoid,
+                        resolution=self.resolution,
+                        disp_min=self.pairs[pair_key]["disp_range_grid"][
+                            "global_min"
+                        ],
+                        disp_max=self.pairs[pair_key]["disp_range_grid"][
+                            "global_max"
+                        ],
+                        roi_poly=(
+                            None if self.debug_with_roi else self.roi_poly
+                        ),
+                        orchestrator=self.cars_orchestrator,
+                        pair_key=pair_key,
+                        pair_folder=os.path.join(
+                            self.dump_dir, "terrain_bbox", pair_key
+                        ),
+                        check_inputs=False,
+                    )
+                )
+                self.list_terrain_roi.append(current_terrain_roi_bbox)
+                self.list_intersection_poly.append(intersection_poly)
+
+                # compute terrain bounds for later use
+                (
+                    self.terrain_bounds,
+                    self.optimal_terrain_tile_width,
+                ) = preprocessing.compute_terrain_bounds(
+                    self.list_terrain_roi,
+                    roi_poly=(None if self.debug_with_roi else self.roi_poly),
+                    resolution=self.resolution,
+                )
+
+                if self.which_resolution not in ("final", "single"):
+                    # To get the correct size for the dem generation
+                    if self.dem_generation_roi is not None:
+                        # ROI has been computed by Shareloc
+                        self.terrain_bounds = (
+                            dem_wrappers.modify_terrain_bounds(
+                                self.dem_generation_roi.bounds,
+                                4326,
+                                self.epsg,
+                                self.dem_generation_application.margin,
+                            )
+                        )
+                    else:
+                        # ROI has not been computed
+                        self.terrain_bounds = (
+                            dem_wrappers.modify_terrain_bounds(
+                                self.terrain_bounds,
+                                self.epsg,
+                                self.epsg,
+                                self.dem_generation_application.margin,
+                                0.7,
+                            )
+                        )
+
+            if self.dense_matching_app.get_method() == "auto":
+                # Copy the initial corr_config in order to keep
+                # the inputs that have already been checked
+                corr_cfg = self.dense_matching_app.corr_config.copy()
+
+                # Find the conf that correspond to the land cover map
+                conf = self.dense_matching_app.loader.find_auto_conf(
+                    intersection_poly,
+                    self.land_cover_map,
+                    self.classification_to_config_mapping,
+                    self.epsg,
+                )
+
+                # Update the used_conf if order to reinitialize
+                # the dense matching app
+                # Because we kept the information regarding the ambiguity,
+                # performance_map calculus..
+                self.used_conf["applications"]["dense_matching"]["loader_conf"][
+                    "pipeline"
+                ] = conf["pipeline"]
+
+                # Re initialization of the dense matching application
+                self.dense_matching_app = Application(
+                    "dense_matching",
+                    cfg=self.used_conf["applications"]["dense_matching"],
+                )
+
+                # Update the corr_config with the inputs that have
+                # already been checked
+                self.dense_matching_app.corr_config["input"] = corr_cfg["input"]
+
             # Run epipolar matching application
             epipolar_disparity_map = self.dense_matching_app.run(
                 new_epipolar_image_left,
@@ -1903,27 +2066,6 @@ class UnitPipeline(PipelineTemplate):
             if self.quit_on_app("dense_match_filling.2"):
                 continue  # keep iterating over pairs, but don't go further
 
-            if self.epsg is None:
-                # compute epsg
-                # Epsg uses global disparity min and max
-                self.epsg = preprocessing.compute_epsg(
-                    self.pairs[pair_key]["sensor_image_left"],
-                    self.pairs[pair_key]["sensor_image_right"],
-                    self.pairs[pair_key]["corrected_grid_left"],
-                    self.pairs[pair_key]["corrected_grid_right"],
-                    self.geom_plugin_with_dem_and_geoid,
-                    disp_min=self.pairs[pair_key]["disp_range_grid"][
-                        "global_min"
-                    ],
-                    disp_max=self.pairs[pair_key]["disp_range_grid"][
-                        "global_max"
-                    ],
-                )
-                # Compute roi polygon, in input EPSG
-                self.roi_poly = preprocessing.compute_roi_poly(
-                    self.input_roi_poly, self.input_roi_epsg, self.epsg
-                )
-
             if isinstance(output[sens_cst.GEOID], str):
                 output_geoid_path = output[sens_cst.GEOID]
             elif (
@@ -2119,60 +2261,6 @@ class UnitPipeline(PipelineTemplate):
                         # keep iterating over pairs, but don't go further
                         continue
 
-            if self.save_output_dsm or self.save_output_point_cloud:
-                # Compute terrain bounding box /roi related to
-                # current images
-                (current_terrain_roi_bbox, intersection_poly) = (
-                    preprocessing.compute_terrain_bbox(
-                        self.pairs[pair_key]["sensor_image_left"],
-                        self.pairs[pair_key]["sensor_image_right"],
-                        new_epipolar_image_left,
-                        self.pairs[pair_key]["corrected_grid_left"],
-                        self.pairs[pair_key]["corrected_grid_right"],
-                        self.epsg,
-                        self.geom_plugin_with_dem_and_geoid,
-                        resolution=self.resolution,
-                        disp_min=self.pairs[pair_key]["disp_range_grid"][
-                            "global_min"
-                        ],
-                        disp_max=self.pairs[pair_key]["disp_range_grid"][
-                            "global_max"
-                        ],
-                        roi_poly=(
-                            None if self.debug_with_roi else self.roi_poly
-                        ),
-                        orchestrator=self.cars_orchestrator,
-                        pair_key=pair_key,
-                        pair_folder=os.path.join(
-                            self.dump_dir, "terrain_bbox", pair_key
-                        ),
-                        check_inputs=False,
-                    )
-                )
-                self.list_terrain_roi.append(current_terrain_roi_bbox)
-                self.list_intersection_poly.append(intersection_poly)
-
-                # compute terrain bounds for later use
-                (
-                    self.terrain_bounds,
-                    self.optimal_terrain_tile_width,
-                ) = preprocessing.compute_terrain_bounds(
-                    self.list_terrain_roi,
-                    roi_poly=(None if self.debug_with_roi else self.roi_poly),
-                    resolution=self.resolution,
-                )
-
-                if self.which_resolution not in ("final", "single"):
-                    if self.dem_generation_roi is not None:
-                        # To get the correct size for the dem generation
-                        self.terrain_bounds = (
-                            dem_wrappers.modify_terrain_bounds(
-                                self.dem_generation_roi,
-                                self.epsg,
-                                self.dem_generation_application.margin,
-                            )
-                        )
-
         # quit if any app in the loop over the pairs was the last one
         # pylint:disable=too-many-boolean-expressions
         if (
@@ -2312,6 +2400,7 @@ class UnitPipeline(PipelineTemplate):
         _ = self.rasterization_application.run(
             self.point_cloud_to_rasterize,
             self.epsg,
+            self.vertical_crs,
             resolution=self.resolution,
             orchestrator=self.cars_orchestrator,
             dsm_file_name=dsm_file_name,
@@ -2419,6 +2508,7 @@ class UnitPipeline(PipelineTemplate):
                         sens_cst.DEM_PATH
                     ]
                 ),
+                default_alt=self.geom_plugin_with_dem_and_geoid.default_alt,
                 cars_orchestrator=self.cars_orchestrator,
             )
 
@@ -2549,6 +2639,7 @@ class UnitPipeline(PipelineTemplate):
             )
 
             self.epsg = rasterio_get_epsg(dict_path["dsm"][0])
+            self.vertical_crs = rasterio_get_crs(dict_path["dsm"][0])
 
             # Compute roi polygon, in input EPSG
             self.roi_poly = preprocessing.compute_roi_poly(
@@ -2678,9 +2769,9 @@ class UnitPipeline(PipelineTemplate):
                     )
 
                     # Project polygon if epsg is different
-                    if self.epsg != inter_epsg:
-                        inter_poly = projection.polygon_projection(
-                            inter_poly, inter_epsg, self.epsg
+                    if self.vertical_crs != CRS(inter_epsg):
+                        inter_poly = projection.polygon_projection_crs(
+                            inter_poly, CRS(inter_epsg), self.vertical_crs
                         )
 
                 self.list_intersection_poly.append(inter_poly)
@@ -2851,6 +2942,10 @@ class UnitPipeline(PipelineTemplate):
         if self.epsg is None:
             self.epsg = epsg_cloud
 
+        self.vertical_crs = projection.get_output_crs(
+            self.epsg, self.used_conf[OUTPUT]
+        )
+
         self.resolution = (
             self.used_conf[OUTPUT][out_cst.RESOLUTION] * self.res_resamp
         )

cars-1.0.0a3.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.11.1
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-0av8ij8b\\cp39-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-0av8ij8b\\cp39-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-0av8ij8b\\cp39-win_amd64\\built_wheel\\cars-1.0.0a3-cp39-cp39-win_amd64.whl']

{cars-1.0.0a2.dist-info → cars-1.0.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cars
-Version: 1.0.0a2
+Version: 1.0.0a3
 Summary: A satellite multi view stereo pipeline
 Keywords: cars,3D,DEM,pandora,photogrammetry
 Author-Email: CNES <cars@cnes.fr>