cars 1.0.0a2__cp313-cp313-win_amd64.whl → 1.0.0a4__cp313-cp313-win_amd64.whl

cars/applications/dense_matching/loaders/pandora_loader.py

@@ -31,6 +31,8 @@ from typing import Dict
 
 import numpy as np
 import pandora
+import rasterio
+import xarray as xr
 from json_checker import Checker, Or
 from pandora.check_configuration import (
     check_pipeline_section,
@@ -38,8 +40,12 @@ from pandora.check_configuration import (
     get_config_pipeline,
     update_conf,
 )
-from pandora.img_tools import get_metadata
 from pandora.state_machine import PandoraMachine
+from rasterio.mask import mask
+from shapely.geometry import mapping
+
+from cars.core.projection import polygon_projection
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 
 
 class PandoraLoader:
@@ -48,7 +54,7 @@ class PandoraLoader:
 
     """
 
-    def __init__(  # noqa: C901
+    def __init__(  # pylint: disable=too-many-positional-arguments  # noqa: C901
         self,
         conf=None,
         method_name=None,
@@ -135,7 +141,7 @@ class PandoraLoader:
                 # read conf
                 with open(conf_file_path, "r", encoding="utf8") as fstream:
                     conf = json.load(fstream)
-            elif method_name == "census_sgm_default":
+            elif method_name in ("census_sgm_default", "auto"):
                 # Use census sgm conf
                 conf_file_path = os.path.join(
                     package_path, "config_census_sgm_default.json"
@@ -266,26 +272,6 @@ class PandoraLoader:
                 if "band" not in filter_conf:
                     conf["pipeline"]["filter"]["band"] = used_band
 
-        for key in list(conf.get("pipeline")):
-            if key.startswith("filter"):
-                if (
-                    conf["pipeline"][key]["filter_method"]
-                    == "median_for_intervals"
-                    and "validation" in conf["pipeline"]
-                ):
-                    if (
-                        conf["pipeline"]["validation"]["validation_method"]
-                        == "cross_checking_fast"
-                    ):
-                        conf["pipeline"]["validation"][
-                            "validation_method"
-                        ] = "cross_checking_accurate"
-                        logging.warning(
-                            "You can not use median_for_intervals with "
-                            "the fast cross checking validation for now. "
-                            "It therefore has been overrided to accurate"
-                        )
-
         # Check conf
         self.pandora_config = conf
 
@@ -300,15 +286,116 @@ class PandoraLoader:
 
         return self.pandora_config
 
-    def check_conf(
+    def get_classif_bands(self):
+        """
+        Get the classification bands used in the pandora configuration
+
+        :return: list of classification bands
+        """
+
+        classif_bands = []
+
+        def search_classes_recursive(obj):
+            """
+            Recursive search of keys containing 'classes' in the configuration
+            """
+            if isinstance(obj, dict):
+                for key, value in obj.items():
+                    if "classes" in key.lower():
+                        if isinstance(value, list):
+                            classif_bands.extend(value)
+                        elif value is not None:
+                            classif_bands.append(value)
+                    # Continue recursive search
+                    search_classes_recursive(value)
+
+        search_classes_recursive(self.pandora_config)
+
+        # Remove duplicates and return the list
+        return list(set(classif_bands))
+
+    @cars_profile(name="Find auto conf")
+    def find_auto_conf(
+        self, intersection_poly, land_cover_map, classif_to_config_mapping, epsg
+    ):
+        """
+        Find the configuration that suits the most on the
+        land cover map based on the roi
+        """
+        package_path = os.path.dirname(__file__)
+
+        # construct the path to the land_cover_map
+        if os.path.dirname(land_cover_map) == "":
+            land_cover_map_path = os.path.join(package_path, land_cover_map)
+        else:
+            land_cover_map_path = land_cover_map
+
+        with rasterio.open(land_cover_map_path) as src:
+            # Project the polygon to the right epsg
+            if src.crs != epsg:
+                poly = polygon_projection(
+                    intersection_poly, epsg, src.crs.to_epsg()
+                )
+            else:
+                poly = intersection_poly
+
+            # Use a buffer because the land_cover_map resolution is coarse
+            data_land_cover, _ = mask(
+                src, [mapping(poly)], crop=True, all_touched=True
+            )
+
+            # Find the most common class in the roi
+            data_squeeze = data_land_cover.squeeze()
+            valid_data = data_squeeze[data_squeeze != src.nodata]
+
+            most_common_class = None
+            if valid_data.size > 0:
+                classes, counts = np.unique(valid_data, return_counts=True)
+                max_index = np.argmax(counts)
+                most_common_class = classes[max_index]
+
+        # Construct the path to the classification to configuration mapping
+        if os.path.dirname(classif_to_config_mapping) == "":
+            conf_file_path = os.path.join(
+                package_path, classif_to_config_mapping
+            )
+        else:
+            conf_file_path = classif_to_config_mapping
+
+        # read conf
+        with open(conf_file_path, "r", encoding="utf8") as fstream:
+            conf_mapping = json.load(fstream)
+
+        # Find the configuration that corresponds to the most common class
+        corresponding_conf_name = conf_mapping.get(str(most_common_class), None)
+
+        # If no equivalence has been found, we use the default configuration
+        if corresponding_conf_name is None:
+            corresponding_conf_name = "census_sgm_default"
+
+        logging.info(
+            "The conf that has been chosen regarding the "
+            "world classification map is {}".format(corresponding_conf_name)
+        )
+
+        # We return the corresponding configuration
+        json_conf_name = os.path.join(
+            package_path, "config_" + corresponding_conf_name + ".json"
+        )
+        with open(json_conf_name, "r", encoding="utf8") as fstream:
+            conf = json.load(fstream)
+
+        return conf
+
+    def check_conf(  # pylint: disable=too-many-positional-arguments
         self,
         user_cfg,
-        img_left,
-        img_right,
+        nodata_left,
+        nodata_right,
         bands_left,
         bands_right,
-        classif_left=None,
-        classif_right=None,
+        bands_classif_left=None,
+        bands_classif_right=None,
     ):
         """
         Check configuration
@@ -320,15 +407,18 @@ class PandoraLoader:
         :rtype: dict
 
         """
-
         # Import plugins before checking configuration
         pandora.import_plugin()
         # Check configuration and update the configuration with default values
         # Instantiate pandora state machine
         pandora_machine = PandoraMachine()
         # check pipeline
-        metadata_left = get_metadata(img_left, classif=classif_left)
-        metadata_right = get_metadata(img_right, classif=classif_right)
+        metadata_left = overide_pandora_get_metadata(
+            bands_left, classif_bands=bands_classif_left
+        )
+        metadata_right = overide_pandora_get_metadata(
+            bands_right, classif_bands=bands_classif_right
+        )
 
         metadata_left = metadata_left.assign_coords(band_im=bands_left)
         metadata_right = metadata_right.assign_coords(band_im=bands_right)
@@ -345,7 +435,9 @@ class PandoraLoader:
             saved_schema
         )
         # check a part of input section
-        user_cfg_input = get_config_input_custom_cars(user_cfg)
+        user_cfg_input = get_config_input_custom_cars(
+            user_cfg, nodata_left, nodata_right
+        )
         cfg_input = check_input_section_custom_cars(user_cfg_input)
         # concatenate updated config
         cfg = concat_conf([cfg_input, cfg_pipeline])
@@ -370,7 +462,46 @@ default_short_configuration_input_custom_cars = {
 }
 
 
-def get_config_input_custom_cars(user_cfg: Dict[str, dict]) -> Dict[str, dict]:
+def overide_pandora_get_metadata(
+    im_bands: list, classif_bands: list = None
+) -> xr.Dataset:
+    """
+    Read metadata from image, and return the corresponding xarray.DataSet
+
+    :param im_bands: list of band names
+    :param classif_bands: list of classification band names
+    :return: partial xarray.DataSet (attributes and coordinates)
+    :rtype: xarray.DataSet
+    """
+
+    coords = {
+        "band_im": list(im_bands),
+        "row": np.arange(10),
+        "col": np.arange(10),
+    }
+
+    data_vars = {
+        "image": (["row", "col"], np.zeros((10, 10))),
+    }
+
+    if classif_bands is not None:
+        coords["band_classif"] = list(classif_bands)
+        data_vars["classif"] = (
+            ["row", "col", "band_classif"],
+            np.zeros((10, 10, len(classif_bands)), dtype=np.int32),
+        )
+
+    # create the dataset
+    dataset = xr.Dataset(data_vars=data_vars, coords=coords)
+
+    dataset.attrs["disparity_source"] = None
+
+    return dataset
+
+
+def get_config_input_custom_cars(
+    user_cfg: Dict[str, dict], nodata_left, nodata_right
+) -> Dict[str, dict]:
     """
     Get the input configuration
 
@@ -387,9 +518,13 @@ def get_config_input_custom_cars(user_cfg: Dict[str, dict]) -> Dict[str, dict]:
 
         if "nodata_left" in user_cfg["input"]:
             cfg["input"]["nodata_left"] = user_cfg["input"]["nodata_left"]
+        else:
+            cfg["input"]["nodata_left"] = nodata_left
 
         if "nodata_right" in user_cfg["input"]:
             cfg["input"]["nodata_right"] = user_cfg["input"]["nodata_right"]
+        else:
+            cfg["input"]["nodata_right"] = nodata_right
 
     return cfg
 
@@ -439,7 +574,7 @@ def overload_pandora_conf_with_confidence(conf, confidence_conf):
 
     for key in confidence_conf_keys:
         if key in conf_keys:
-            logging.error("{} pandora key already in configuration".format(key))
+            logging.info("{} pandora key already in configuration".format(key))
 
     # update confidence
     out_dict.update(confidence_conf)

cars/applications/dsm_filling/border_interpolation_app.py

@@ -31,6 +31,7 @@ import rasterio as rio
 import scipy
 import skimage
 from json_checker import Checker, Or
+from pyproj import CRS
 from shapely import Polygon
 
 from cars.core import inputs, projection
@@ -55,7 +56,6 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
 
         # check conf
         self.used_method = self.used_config["method"]
-        self.activated = self.used_config["activated"]
         self.classification = self.used_config["classification"]
         self.component_min_size = self.used_config["component_min_size"]
         self.border_size = self.used_config["border_size"]
@@ -73,8 +73,11 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
 
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer")
-        overloaded_conf["activated"] = conf.get("activated", False)
-        overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["classification"] = conf.get("classification", "nodata")
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
         overloaded_conf["component_min_size"] = conf.get(
             "component_min_size", 5
         )
@@ -86,7 +89,6 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
 
         rectification_schema = {
             "method": str,
-            "activated": bool,
             "classification": Or(None, [str]),
             "component_min_size": int,
             "border_size": int,
@@ -101,7 +103,7 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
         return overloaded_conf
 
     @cars_profile(name="Border interpolation filling")
-    def run(  # noqa C901
+    def run(  # pylint: disable=too-many-positional-arguments  # noqa C901
         self,
         dsm_file,
         classif_file,
@@ -122,9 +124,6 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
             - a Shapely Polygon
         """
 
-        if not self.activated:
-            return
-
         if self.classification is None:
             self.classification = ["nodata"]
             logging.error(
@@ -151,8 +150,8 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
             roi_polys_outepsg = []
             for poly in roi_polys:
                 if isinstance(poly, Polygon):
-                    roi_poly_outepsg = projection.polygon_projection(
-                        poly, roi_epsg, dsm_crs.to_epsg()
+                    roi_poly_outepsg = projection.polygon_projection_crs(
+                        poly, CRS(roi_epsg), dsm_crs
                     )
                     roi_polys_outepsg.append(roi_poly_outepsg)
 
@@ -160,8 +159,8 @@ class BorderInterpolation(DsmFilling, short_name="border_interpolation"):
                 roi_polys_outepsg, out_shape=roi_raster.shape, transform=dsm_tr
             )
         elif isinstance(roi_polys, Polygon):
-            roi_poly_outepsg = projection.polygon_projection(
-                roi_polys, roi_epsg, dsm_crs.to_epsg()
+            roi_poly_outepsg = projection.polygon_projection_crs(
+                roi_polys, CRS(roi_epsg), dsm_crs
             )
             roi_raster = rio.features.rasterize(
                 [roi_poly_outepsg], out_shape=roi_raster.shape, transform=dsm_tr

cars/applications/dsm_filling/bulldozer_filling_app.py

@@ -32,6 +32,7 @@ import rasterio as rio
 import yaml
 from bulldozer.pipeline.bulldozer_pipeline import dsm_to_dtm
 from json_checker import Checker, Or
+from pyproj import CRS
 from shapely import Polygon
 
 from cars.core import inputs, projection
@@ -56,7 +57,6 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
 
         # check conf
         self.used_method = self.used_config["method"]
-        self.activated = self.used_config["activated"]
         self.classification = self.used_config["classification"]
         self.save_intermediate_data = self.used_config["save_intermediate_data"]
 
@@ -71,15 +71,19 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
 
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer")
-        overloaded_conf["activated"] = conf.get("activated", False)
-        overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["classification"] = conf.get("classification", "nodata")
+
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
+
         overloaded_conf["save_intermediate_data"] = conf.get(
             "save_intermediate_data", False
         )
 
         rectification_schema = {
             "method": str,
-            "activated": bool,
             "classification": Or(None, [str]),
             "save_intermediate_data": bool,
         }
@@ -91,7 +95,7 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
         return overloaded_conf
 
     @cars_profile(name="Bulldozer filling")
-    def run(  # noqa C901
+    def run(  # pylint: disable=too-many-positional-arguments # noqa C901
         self,
         dsm_file,
         classif_file,
@@ -112,9 +116,6 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
             - a Shapely Polygon
         """
 
-        if not self.activated:
-            return None
-
         if self.classification is None:
             self.classification = ["nodata"]
 
@@ -162,8 +163,8 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
             roi_polys_outepsg = []
             for poly in roi_polys:
                 if isinstance(poly, Polygon):
-                    roi_poly_outepsg = projection.polygon_projection(
-                        poly, roi_epsg, dsm_crs.to_epsg()
+                    roi_poly_outepsg = projection.polygon_projection_crs(
+                        poly, CRS(roi_epsg), dsm_crs
                     )
                     roi_polys_outepsg.append(roi_poly_outepsg)
 
@@ -171,8 +172,8 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
                 roi_polys_outepsg, out_shape=roi_raster.shape, transform=dsm_tr
             )
         elif isinstance(roi_polys, Polygon):
-            roi_poly_outepsg = projection.polygon_projection(
-                roi_polys, roi_epsg, dsm_crs.to_epsg()
+            roi_poly_outepsg = projection.polygon_projection_crs(
+                roi_polys, CRS(roi_epsg), dsm_crs
             )
             roi_raster = rio.features.rasterize(
                 [roi_poly_outepsg], out_shape=roi_raster.shape, transform=dsm_tr
@@ -199,7 +200,7 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
                     ):
                         dsm_to_dtm(bull_conf_path)
         except Exception:
-            logging.error(
+            logging.warning(
                 "Bulldozer failed on its second execution."
                 + " The DSM could not be filled."
             )
@@ -211,7 +212,7 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
             with rio.open(old_dsm_path, "w", **dsm_meta) as out_dsm:
                 out_dsm.write(dsm, 1)
 
-        if classif_file is not None:
+        if classif_file is not None and os.path.exists(classif_file):
             classif_descriptions = inputs.get_descriptions_bands(classif_file)
         else:
             classif_descriptions = []
@@ -225,7 +226,7 @@ class BulldozerFilling(DsmFilling, short_name="bulldozer"):
                 classif[classif_msk == 0] = 0
                 filling_mask = np.logical_and(classif, roi_raster > 0)
             elif label == "nodata":
-                if classif_file is not None:
+                if classif_file is not None and os.path.exists(classif_file):
                     with rio.open(classif_file) as in_classif:
                         classif_msk = in_classif.read_masks(1)
                     classif = ~classif_msk

cars/applications/dsm_filling/exogenous_filling_app.py

@@ -29,6 +29,7 @@ import shutil
 import numpy as np
 import rasterio as rio
 from json_checker import Checker, Or
+from pyproj import CRS
 from rasterio.enums import Resampling
 from rasterio.warp import reproject
 from shapely import Polygon
@@ -55,7 +56,6 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
 
         # check conf
         self.used_method = self.used_config["method"]
-        self.activated = self.used_config["activated"]
         self.classification = self.used_config["classification"]
         self.fill_with_geoid = self.used_config["fill_with_geoid"]
         self.interpolation_method = self.used_config["interpolation_method"]
@@ -72,18 +72,22 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
 
         # Overload conf
         overloaded_conf["method"] = conf.get("method", "bulldozer")
-        overloaded_conf["activated"] = conf.get("activated", False)
-        overloaded_conf["classification"] = conf.get("classification", None)
+        overloaded_conf["classification"] = conf.get("classification", "nodata")
+        if isinstance(overloaded_conf["classification"], str):
+            overloaded_conf["classification"] = [
+                overloaded_conf["classification"]
+            ]
         overloaded_conf["fill_with_geoid"] = conf.get("fill_with_geoid", None)
         overloaded_conf["interpolation_method"] = conf.get(
             "interpolation_method", "bilinear"
         )
 
         if overloaded_conf["interpolation_method"] not in ["bilinear", "cubic"]:
+            # pylint: disable=inconsistent-quotes
             raise RuntimeError(
-                "Invalid interpolation method"
+                f"Invalid interpolation method"
                 f"{overloaded_conf['interpolation_method']}, "
-                "supported modes are bilinear and cubic."
+                f"supported modes are bilinear and cubic."
             )
 
         overloaded_conf["save_intermediate_data"] = conf.get(
@@ -92,7 +96,6 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
 
         rectification_schema = {
             "method": str,
-            "activated": bool,
             "classification": Or(None, [str]),
             "fill_with_geoid": Or(None, [str]),
             "interpolation_method": str,
@@ -106,7 +109,7 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
         return overloaded_conf
 
     @cars_profile(name="Exogeneous filling")
-    def run(  # noqa C901
+    def run(  # pylint: disable=too-many-positional-arguments  # noqa C901
         self,
         dsm_file,
         classif_file,
@@ -128,9 +131,6 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
             - a Shapely Polygon
         """
 
-        if not self.activated:
-            return
-
         if self.classification is None:
             self.classification = ["nodata"]
 
@@ -170,8 +170,8 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
             roi_polys_outepsg = []
             for poly in roi_polys:
                 if isinstance(poly, Polygon):
-                    roi_poly_outepsg = projection.polygon_projection(
-                        poly, roi_epsg, dsm_crs.to_epsg()
+                    roi_poly_outepsg = projection.polygon_projection_crs(
+                        poly, CRS(roi_epsg), dsm_crs
                     )
                     roi_polys_outepsg.append(roi_poly_outepsg)
 
@@ -179,8 +179,8 @@ class ExogenousFilling(DsmFilling, short_name="exogenous_filling"):
                 roi_polys_outepsg, out_shape=roi_raster.shape, transform=dsm_tr
             )
         elif isinstance(roi_polys, Polygon):
-            roi_poly_outepsg = projection.polygon_projection(
-                roi_polys, roi_epsg, dsm_crs.to_epsg()
+            roi_poly_outepsg = projection.polygon_projection_crs(
+                roi_polys, CRS(roi_epsg), dsm_crs
             )
             roi_raster = rio.features.rasterize(
                 [roi_poly_outepsg], out_shape=roi_raster.shape, transform=dsm_tr

cars/applications/grid_generation/abstract_grid_generation_app.py

@@ -104,7 +104,7 @@ class GridGeneration(ApplicationTemplate, metaclass=ABCMeta):
         """
 
     @abstractmethod
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         image_left,
         image_right,

cars/applications/grid_generation/epipolar_grid_generation_app.py

@@ -31,7 +31,9 @@ from json_checker import And, Checker
 
 import cars.orchestrator.orchestrator as ocht
 from cars.applications import application_constants
-from cars.applications.grid_generation import grid_generation_algo
+from cars.applications.grid_generation import (
+    grid_generation_algo,
+)
 from cars.applications.grid_generation import (
     grid_generation_constants as grid_constants,
 )
@@ -119,7 +121,7 @@ class EpipolarGridGeneration(GridGeneration, short_name="epipolar"):
         return self.save_intermediate_data
 
     @cars_profile(name="Epi Grid Generation")
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         image_left,
         image_right,

cars/applications/grid_generation/grid_correction_app.py

@@ -37,7 +37,9 @@ from scipy.spatial import Delaunay  # pylint: disable=E0611
 
 import cars.orchestrator.orchestrator as ocht
 from cars.applications import application_constants
-from cars.applications.grid_generation import grid_generation_algo
+from cars.applications.grid_generation import (
+    grid_generation_algo,
+)
 from cars.applications.grid_generation import (
     grid_generation_constants as grid_constants,
 )
@@ -165,6 +167,7 @@ def correct_grid(grid, grid_correction, pair_folder, save_grid=None):
     return corrected_grid_right
 
 
+# pylint: disable=too-many-positional-arguments
 @cars_profile(name="Grid correction estimation")
 def estimate_right_grid_correction(
     matches,

cars/applications/grid_generation/grid_generation_algo.py

@@ -43,6 +43,7 @@ from cars.applications.triangulation.triangulation_algo import (
 )
 from cars.core import constants as cst
 from cars.core import inputs, projection, tiling
+from cars.orchestrator.cluster.log_wrapper import cars_profile
 
 
 def get_new_path(path):
@@ -106,7 +107,7 @@ def write_grid(grid, fname, origin, spacing):
         dst.write_band(2, grid[:, :, 1])
 
 
-def generate_epipolar_grids(
+def generate_epipolar_grids(  # pylint: disable=too-many-positional-arguments
     sensor1, sensor2, geomodel1, geomodel2, geometry_plugin, epipolar_step
 ):
     """
@@ -140,6 +141,8 @@ def generate_epipolar_grids(
     )
 
 
+# pylint: disable=too-many-positional-arguments
+@cars_profile(name="Compute epipolar grid min max", interval=0.5)
 def compute_epipolar_grid_min_max(
     geometry_plugin,
     grid,
@@ -239,6 +242,7 @@ def compute_epipolar_grid_min_max(
         grid1,
         grid2,
         matches_min,
+        interpolation_method="linear",
     )
     pc_max = triangulate_matches(
         geometry_plugin,
@@ -249,6 +253,7 @@ def compute_epipolar_grid_min_max(
         grid1,
         grid2,
         matches_max,
+        interpolation_method="linear",
     )
 
     # Convert to correct EPSG
@@ -278,7 +283,7 @@ def compute_epipolar_grid_min_max(
     return grid_min, grid_max
 
 
-def terrain_region_to_epipolar(
+def terrain_region_to_epipolar(  # pylint: disable=too-many-positional-arguments
     region,
     sensor1,
     sensor2,

cars/applications/ground_truth_reprojection/abstract_ground_truth_reprojection_app.py

@@ -97,7 +97,7 @@ class GroundTruthReprojection(ApplicationTemplate, metaclass=ABCMeta):
         super().__init__(conf=conf)
 
     @abstractmethod
-    def run(
+    def run(  # pylint: disable=too-many-positional-arguments
         self,
         sensor_left,
         sensor_right,