cars 1.0.0a1__cp313-cp313-win_amd64.whl → 1.0.0a3__cp313-cp313-win_amd64.whl

cars/applications/rasterization/simple_gaussian_app.py

@@ -208,6 +208,7 @@ class SimpleGaussian(
         self,
         point_clouds,
         epsg,
+        output_crs,
         resolution,
         orchestrator=None,
         dsm_file_name=None,
@@ -256,6 +257,8 @@ class SimpleGaussian(
         :type point_clouds: CarsDataset filled with pandas.DataFrame
         :param epsg: epsg of raster data
         :type epsg: str
+        :param output_crs: output_crs of raster data
+        :type output_crs: str
         :param resolution: resolution of raster data (in target CRS unit)
         :type resolution: float
         :param orchestrator: orchestrator used
@@ -267,7 +270,7 @@ class SimpleGaussian(
         :type color_file_name: str
         :param mask_file_name: path of color
         :type mask_file_name: str
-        :param classif_file_name: path of color
+        :param classif_file_name: path of classification
         :type classif_file_name: str
         :param performance_map_file_name: path of performance map file
         :type performance_map_file_name: str
@@ -317,6 +320,27 @@ class SimpleGaussian(
         # Get if color, mask and stats are saved
         save_intermediate_data = self.used_config["save_intermediate_data"]
 
+        keep_dir = (
+            len(
+                list(
+                    filter(
+                        lambda x: x is not None,
+                        [
+                            weights_file_name,
+                            color_file_name,
+                            mask_file_name,
+                            classif_file_name,
+                            performance_map_file_name,
+                            ambiguity_file_name,
+                            contributing_pair_file_name,
+                            filling_file_name,
+                        ],
+                    )
+                )
+            )
+            > 0
+        )
+
         if not self.color_dtype:
             self.color_dtype = color_dtype
 
@@ -333,7 +357,7 @@ class SimpleGaussian(
         if dump_dir is not None:
             out_dump_dir = dump_dir
             safe_makedirs(dump_dir)
-            if not save_intermediate_data:
+            if not save_intermediate_data and not keep_dir:
                 self.orchestrator.add_to_clean(dump_dir)
         else:
             out_dump_dir = self.orchestrator.out_dir
@@ -512,6 +536,7 @@ class SimpleGaussian(
             out_classif_file_name = os.path.join(
                 out_dump_dir, "classification.tif"
             )
+
         if out_classif_file_name is not None:
             list_computed_layers += ["classif"]
             self.orchestrator.add_to_save_lists(
@@ -644,7 +669,7 @@ class SimpleGaussian(
             )
         elif save_intermediate_data:
             # File is not part of the official product, write it in dump_dir
-            out_source_pc = os.path.join(out_dump_dir, "source_pc.tif")
+            out_source_pc = os.path.join(out_dump_dir, "contributing_pair.tif")
         if out_source_pc:
             list_computed_layers += ["source_pc"]
             self.orchestrator.add_to_save_lists(
@@ -653,7 +678,7 @@ class SimpleGaussian(
                 terrain_raster,
                 dtype=np.uint8,
                 nodata=self.msk_no_data,
-                cars_ds_name="source_pc",
+                cars_ds_name="contributing_pair",
                 optional_data=True,
             )
 
@@ -680,18 +705,6 @@ class SimpleGaussian(
 
         # TODO Check that intervals indeed exist!
         if save_intermediate_data:
-            out_confidence = os.path.join(out_dump_dir, "confidence.tif")
-            list_computed_layers += ["confidence"]
-            self.orchestrator.add_to_save_lists(
-                out_confidence,
-                cst.RASTER_CONFIDENCE,
-                terrain_raster,
-                dtype=np.float32,
-                nodata=self.msk_no_data,
-                cars_ds_name="confidence",
-                optional_data=True,
-            )
-
             list_computed_layers += [cst.POINT_CLOUD_LAYER_SUP_OR_INF_ROOT]
             out_dsm_inf_file_name = os.path.join(out_dump_dir, "dsm_inf.tif")
             self.orchestrator.add_to_save_lists(
@@ -829,7 +842,7 @@ class SimpleGaussian(
                 "driver": "GTiff",
                 "dtype": "float32",
                 "transform": transform,
-                "crs": "EPSG:{}".format(epsg),
+                "crs": output_crs.to_wkt(),
                 "tiled": True,
             }
         )

cars/applications/resampling/resampling_algo.py

@@ -284,14 +284,10 @@ def resample_image(  # noqa: C901
             (nb_bands, region[3] - region[1], region[2] - region[0]),
             dtype=np.float32,
         )
-        nodata = 0
-        if nodata is not None or mask is not None:
-            msk = np.empty(
-                (nb_bands, region[3] - region[1], region[2] - region[0]),
-                dtype=np.float32,
-            )
-        else:
-            msk = None
+        msk = np.empty(
+            (nb_bands, region[3] - region[1], region[2] - region[0]),
+            dtype=np.float32,
+        )
 
         ystart = 0
         with rio.open(grid["path"]) as grid_reader, rio.open(img) as img_reader:
@@ -513,51 +509,50 @@ def oversampling_func(
     resamp[:, ystart : ystart + ysize, xstart : xstart + xsize] = block_resamp
 
     # create msk
-    if nodata is not None or mask is not None:
-        if in_sensor:
-            # get mask in source geometry
-            nodata_index = img_as_array == nodata
-
-            if mask is not None:
-                with rio.open(mask) as msk_reader:
-                    msk_as_array = msk_reader.read(1, window=img_window)
-                msk_as_array = np.array([msk_as_array] * img_as_array.shape[0])
-            else:
-                msk_as_array = np.zeros(img_as_array.shape)
+    if in_sensor:
+        # get mask in source geometry
+        if mask is not None:
+            with rio.open(mask) as msk_reader:
+                msk_as_array = msk_reader.read(1, window=img_window)
+            msk_as_array = np.array([msk_as_array] * img_as_array.shape[0])
+        else:
+            msk_as_array = np.zeros(img_as_array.shape)
 
+        if nodata is not None:
+            nodata_index = img_as_array == nodata
             msk_as_array[nodata_index] = nodata_msk
 
-            # resample mask
-            block_msk = cresample.grid(
-                msk_as_array,
-                grid_as_array,
-                oversampling,
-                interpolator=interpolator_mask,
-                nodata=nodata_msk,
-            )
+        # resample mask
+        block_msk = cresample.grid(
+            msk_as_array,
+            grid_as_array,
+            oversampling,
+            interpolator=interpolator_mask,
+            nodata=nodata_msk,
+        )
 
-            if interpolator_mask == "bicubic":
-                block_msk = np.where(
-                    block_msk >= 0.5,
-                    1,
-                    np.where(block_msk < 0.5, 0, block_msk),
-                ).astype(int)
-
-            block_msk = block_msk[
-                ...,
-                ext_region[1] : ext_region[3] - 1,
-                ext_region[0] : ext_region[2] - 1,
-            ]
-        else:
-            block_msk = np.full(
-                (
-                    nb_bands,
-                    block_region[3] - block_region[1],
-                    block_region[2] - block_region[0],
-                ),
-                fill_value=nodata_msk,
-            )
+        if interpolator_mask == "bicubic":
+            block_msk = np.where(
+                block_msk >= 0.5,
+                1,
+                np.where(block_msk < 0.5, 0, block_msk),
+            ).astype(int)
+
+        block_msk = block_msk[
+            ...,
+            ext_region[1] : ext_region[3] - 1,
+            ext_region[0] : ext_region[2] - 1,
+        ]
+    else:
+        block_msk = np.full(
+            (
+                nb_bands,
+                block_region[3] - block_region[1],
+                block_region[2] - block_region[0],
+            ),
+            fill_value=nodata_msk,
+        )
 
-        msk[:, ystart : ystart + ysize, xstart : xstart + xsize] = block_msk
+    msk[:, ystart : ystart + ysize, xstart : xstart + xsize] = block_msk
 
     return resamp, msk

cars/applications/sparse_matching/sift_app.py

@@ -224,7 +224,7 @@ class Sift(SparseMatching, short_name=["sift"]):
             "sift_matching_threshold": And(float, lambda x: x > 0),
             "sift_n_octave": And(int, lambda x: x > 0),
             "sift_n_scale_per_octave": And(int, lambda x: x > 0),
-            "sift_peak_threshold": Or(float, None),
+            "sift_peak_threshold": Or(float, int),
             "sift_edge_threshold": float,
             "sift_magnification": And(float, lambda x: x > 0),
             "sift_window_size": And(int, lambda x: x > 0),
@@ -514,26 +514,6 @@ class Sift(SparseMatching, short_name=["sift"]):
             epipolar_disparity_map_left.attributes.update(
                 epipolar_image_left.attributes
             )
-            # check sift_peak_threshold with image type
-            # only if sift_peak_threshold is None
-            tmp_sift_peak_threshold = self.sift_peak_threshold
-            if not self.sift_peak_threshold:
-                logging.info("The sift_peak_threshold is set to auto-mode.")
-                # sift_peak_threshold is None or not specified
-                # check input type
-                if np.issubdtype(
-                    epipolar_disparity_map_left.attributes["image_type"],
-                    np.uint8,
-                ):
-                    tmp_sift_peak_threshold = 1
-                else:
-                    tmp_sift_peak_threshold = 20
-                logging.info(
-                    "The sift_peak_threshold will be set to {}.".format(
-                        tmp_sift_peak_threshold
-                    )
-                )
-                self.sift_peak_threshold = tmp_sift_peak_threshold
 
             # Save disparity maps
             if self.save_intermediate_data:
@@ -628,7 +608,7 @@ class Sift(SparseMatching, short_name=["sift"]):
                         matching_threshold=self.sift_matching_threshold,
                         n_octave=self.sift_n_octave,
                         n_scale_per_octave=self.sift_n_scale_per_octave,
-                        peak_threshold=tmp_sift_peak_threshold,
+                        peak_threshold=self.sift_peak_threshold,
                         edge_threshold=self.sift_edge_threshold,
                         magnification=self.sift_magnification,
                         window_size=self.sift_window_size,

cars/applications/sparse_matching/sparse_matching_wrappers.py

@@ -170,55 +170,6 @@ def compute_disp_min_disp_max(
     return dmin, dmax
 
 
-@cars_profile(name="Clustering matches")
-def clustering_matches(
-    triangulated_matches,
-    connection_val=3.0,
-    nb_pts_threshold=80,
-    clusters_distance_threshold: float = None,
-    filtered_elt_pos: bool = False,
-):
-    """
-    Filter triangulated  matches
-
-    :param pd_cloud: triangulated_matches
-    :type pd_cloud: pandas Dataframe
-    :param connection_val: distance to use
-        to consider that two points are connected
-    :param nb_pts_threshold: number of points to use
-        to identify small clusters to filter
-    :param clusters_distance_threshold: distance to use
-        to consider if two points clusters are far from each other or not
-        (set to None to deactivate this level of filtering)
-    :param filtered_elt_pos: if filtered_elt_pos is set to True,
-        the removed points positions in their original
-        epipolar images are returned, otherwise it is set to None
-
-    :return: filtered_matches
-    :rtype: pandas Dataframe
-
-    """
-
-    filtered_pandora_matches, _ = (
-        outlier_removal_algo.small_component_filtering(
-            triangulated_matches,
-            connection_val=connection_val,
-            nb_pts_threshold=nb_pts_threshold,
-            clusters_distance_threshold=clusters_distance_threshold,
-            filtered_elt_pos=filtered_elt_pos,
-        )
-    )
-
-    filtered_pandora_matches_dataframe = pandas.DataFrame(
-        filtered_pandora_matches
-    )
-    filtered_pandora_matches_dataframe.attrs["epsg"] = (
-        triangulated_matches.attrs["epsg"]
-    )
-
-    return filtered_pandora_matches_dataframe
-
-
 @cars_profile(name="filter_point_cloud_matches")
 def filter_point_cloud_matches(
     pd_cloud,

cars/applications/triangulation/line_of_sight_intersection_app.py

@@ -1044,7 +1044,7 @@ def triangulation_wrapper(
                 ambiguity_map = None
                 perf_ambiguity_threshold = None
                 if use_ambiguity:
-                    ambiguity_map = disp_ref["confidence_from_ambiguity.cars_1"]
+                    ambiguity_map = disp_ref["ambiguity"]
                     perf_ambiguity_threshold = performance_maps_parameters[
                         "perf_ambiguity_threshold"
                     ]

cars/applications/triangulation/triangulation_wrappers.py

@@ -246,7 +246,8 @@ def compute_performance_map(
     )
 
     if ambiguity_map is not None:
-        ambiguity_map = 1 - ambiguity_map.values
+        # ambiguity is already ambiguity, not confidence from ambiguity
+        ambiguity_map = ambiguity_map.values
         mask_ambi = ambiguity_map > perf_ambiguity_threshold
         w_ambi = ambiguity_map / perf_ambiguity_threshold
         w_ambi[mask_ambi] = 1

cars/bundleadjustment.py

@@ -15,6 +15,7 @@ import geopandas as gpd
 import numpy as np
 import pandas as pd
 import rasterio as rio
+import yaml
 
 try:
     from rpcfit import rpc_fit
@@ -34,6 +35,7 @@ from shareloc.geomodels.geomodel import GeoModel
 from shareloc.geomodels.los import LOS
 from shareloc.proj_utils import coordinates_conversion
 
+from cars.pipelines.parameters import sensor_inputs
 from cars.pipelines.pipeline import Pipeline
 
 
@@ -550,14 +552,26 @@ def new_rpcs_from_matches(
     return None
 
 
-def cars_bundle_adjustment(conf, no_run_sparse):
+def cars_bundle_adjustment(conf, no_run_sparse, output_format="yaml"):
     """
     cars-bundleadjustement main:
     - Launch CARS to compute homologous points (run sparse matching)
     - Compute new RPCs
     """
-    with open(conf, encoding="utf-8") as reader:
-        conf_as_dict = json.load(reader)
+    _, ext = os.path.splitext(conf)
+    ext = ext.lower()
+
+    if ext == ".json":
+        with open(conf, encoding="utf-8") as reader:
+            conf_as_dict = json.load(reader)
+    elif ext in [".yaml", ".yml"]:
+        with open(conf, encoding="utf-8") as reader:
+            conf_as_dict = yaml.safe_load(reader)
+    else:
+        raise ValueError(
+            f"Unsupported configuration file format: {ext}. "
+            "Please use .json, .yaml, or .yml"
+        )
 
     conf_dirname = os.path.dirname(conf)
     out_dir = os.path.abspath(
@@ -576,6 +590,7 @@ def cars_bundle_adjustment(conf, no_run_sparse):
     ]
     sparse_matching_config["output"]["directory"] = sparse_matching
     sparse_matching_config["output"]["product_level"] = []
+    sparse_matching_config["advanced"] = {}
     sparse_matching_config["advanced"]["epipolar_resolutions"] = [1]
     if "sparse_matching.sift" not in sparse_matching_config["applications"]:
         sparse_matching_config["applications"]["sparse_matching.sift"] = {}
@@ -595,6 +610,9 @@ def cars_bundle_adjustment(conf, no_run_sparse):
         sparse_matching_pipeline.run()
 
     # create new refined rpcs
+    conf_as_dict["inputs"] = sensor_inputs.sensors_check_inputs(
+        conf_as_dict["inputs"], config_dir=conf_dirname
+    )
     separate = bundle_adjustment_config.pop("separate")
     refined_rpcs = new_rpcs_from_matches(
         conf_as_dict["inputs"]["sensors"],
@@ -623,9 +641,15 @@ def cars_bundle_adjustment(conf, no_run_sparse):
             raw_config["inputs"]["pairing"] = pairing
             raw_config["output"]["directory"] = raw
 
-        raw_cfg_file = raw_config["output"]["directory"] + ".json"
-        with open(raw_cfg_file, "w", encoding="utf8") as json_writer:
-            json.dump(raw_config, json_writer, indent=2)
+        # output config file
+        raw_cfg_file = raw_config["output"]["directory"] + (
+            ".yaml" if output_format == "yaml" else ".json"
+        )
+        with open(raw_cfg_file, "w", encoding="utf8") as writer:
+            if output_format == "yaml":
+                yaml.safe_dump(raw_config, writer, sort_keys=False)
+            else:
+                json.dump(raw_config, writer, indent=2)
 
         if refined_rpcs is not None:
             # create configuration file + launch cars dense matching
@@ -645,9 +669,14 @@ def cars_bundle_adjustment(conf, no_run_sparse):
                 refined_config["inputs"]["pairing"] = pairing
                 refined_config["output"]["directory"] = refined
 
-            refined_cfg_file = refined_config["output"]["directory"] + ".json"
-            with open(refined_cfg_file, "w", encoding="utf8") as json_writer:
-                json.dump(refined_config, json_writer, indent=2)
+            refined_cfg_file = refined_config["output"]["directory"] + (
+                ".yaml" if output_format == "yaml" else ".json"
+            )
+            with open(refined_cfg_file, "w", encoding="utf8") as writer:
+                if output_format == "yaml":
+                    yaml.safe_dump(refined_config, writer, sort_keys=False)
+                else:
+                    json.dump(refined_config, writer, indent=2)
 
 
 def cli():
@@ -679,8 +708,8 @@ key and its associated value:
 ```
 
 - Parameters "pairing" and "separate" are mandatory.
-- Parameters "nb_decimals" (default value: 0) and "min_matches" \
-(default value: 100) are optional.
+- Parameters "nb_decimals" (default value: 0), "min_matches" \
+(default value: 100) and "output_format" (default value: yaml) are optional.
 
 ### Generation of homologous points calculated by pair
 
@@ -704,7 +733,18 @@ number of matches per zone required to calculate these statistics."""
     )
     parser.add_argument("conf", type=str, help="Configuration File")
     parser.add_argument("--no-run-sparse", action="store_true")
+    parser.add_argument(
+        "--output-format",
+        type=str,
+        default="json",
+        choices=["json", "yaml", "JSON", "YAML"],
+        help="Output format for generated configuration files "
+        "(json or yaml, case-insensitive). Default: json",
+    )
+
     args = parser.parse_args()
+    # normalize format to lowercase
+    args.output_format = args.output_format.lower()
     cars_bundle_adjustment(**vars(args))
 
 

cars/cars.py

@@ -33,6 +33,8 @@ import os
 import sys
 import warnings
 
+import yaml
+
 # CARS imports
 from cars import __version__
 from cars.core import cars_logging
@@ -87,9 +89,17 @@ def main_cli(args, dry_run=False):  # noqa: C901
     from cars.pipelines.pipeline import Pipeline
 
     try:
-        # Transform conf file to dict
-        with open(args.conf, "r", encoding="utf8") as fstream:
-            config = json.load(fstream)
+        # Check file extension and load configuration
+        config_path = args.conf
+        ext = os.path.splitext(config_path)[1].lower()
+        if ext == ".json":
+            with open(config_path, "r", encoding="utf8") as fstream:
+                config = json.load(fstream)
+        elif ext in [".yaml", ".yml"]:
+            with open(config_path, "r", encoding="utf8") as fstream:
+                config = yaml.safe_load(fstream)
+        else:
+            raise ValueError("Configuration file must be .json or .yaml/.yml")
 
         # Cars 0.9.0 API change, check if the configfile seems to use the old
         # API by looking for the deprecated out_dir key
@@ -109,7 +119,7 @@ def main_cli(args, dry_run=False):  # noqa: C901
             config["output"]["directory"] = config["output"]["out_dir"]
             del config["output"]["out_dir"]
 
-        config_json_dir = os.path.abspath(os.path.dirname(args.conf))
+        config_dir = os.path.abspath(os.path.dirname(config_path))
         pipeline_name = config.get("advanced", {}).get("pipeline", "default")
 
         # Logging configuration with args Loglevel
@@ -126,7 +136,7 @@ def main_cli(args, dry_run=False):  # noqa: C901
 
         # Generate pipeline and check conf
         cars_logging.add_progress_message("Check configuration...")
-        used_pipeline = Pipeline(pipeline_name, config, config_json_dir)
+        used_pipeline = Pipeline(pipeline_name, config, config_dir)
         cars_logging.add_progress_message("CARS pipeline is started.")
         if not dry_run:
             # run pipeline

cars/core/constants.py

@@ -184,7 +184,7 @@ DSM_INF_MEAN = "dsm_inf_mean"
 DSM_INF_STD = "dsm_inf_std"
 DSM_SUP_MEAN = "dsm_sup_mean"
 DSM_SUP_STD = "dsm_sup_std"
-DSM_CONFIDENCE_AMBIGUITY = "ambiguity"
+DSM_AMBIGUITY = "ambiguity"
 DSM_CONFIDENCE = "confidence"
 DSM_PERFORMANCE_MAP = "performance_map"
 DSM_SOURCE_PC = "source_pc"