:py:mod:`cars.applications.dense_matching.census_mccnn_sgm` =========================================================== .. py:module:: cars.applications.dense_matching.census_mccnn_sgm .. autoapi-nested-parse:: this module contains the dense_matching application class. Module Contents --------------- Classes ~~~~~~~ .. autoapisummary:: cars.applications.dense_matching.census_mccnn_sgm.CensusMccnnSgm Functions ~~~~~~~~~ .. autoapisummary:: cars.applications.dense_matching.census_mccnn_sgm.compute_disparity_wrapper cars.applications.dense_matching.census_mccnn_sgm.loc_inverse_wrapper .. py:class:: CensusMccnnSgm(conf=None) Bases: :py:obj:`cars.applications.dense_matching.dense_matching.DenseMatching` Census SGM & MCCNN SGM matching class .. py:method:: get_performance_map_parameters() Get parameter linked to performance, that will be used in triangulation :return: parameters to use :type: dict .. py:method:: check_conf(conf) Check configuration :param conf: configuration to check :type conf: dict :return: overloaded configuration :rtype: dict .. py:method:: get_margins_fun(grid_left, disp_range_grid) Get Margins function that generates margins needed by matching method, to use during resampling :param grid_left: left epipolar grid :param disp_range_grid: minimum and maximum disparity grid :return: function that generates margin for given roi .. py:method:: get_optimal_tile_size(disp_range_grid, max_ram_per_worker) Get the optimal tile size to use during dense matching. :param disp_range_grid: minimum and maximum disparity grid :param max_ram_per_worker: maximum ram per worker :return: optimal tile size .. py:method:: generate_disparity_grids(sensor_image_right, grid_right, geom_plugin_with_dem_and_geoid, dmin=None, dmax=None, altitude_delta_min=None, altitude_delta_max=None, dem_median=None, dem_min=None, dem_max=None, pair_folder=None, loc_inverse_orchestrator=None) Generate disparity grids min and max, with given step global mode: uses dmin and dmax local mode: uses dems :param sensor_image_right: sensor image right :type sensor_image_right: dict :param grid_right: right epipolar grid :type grid_right: CarsDataset :param geom_plugin_with_dem_and_geoid: geometry plugin with dem mean used to generate epipolar grids :type geom_plugin_with_dem_and_geoid: GeometryPlugin :param dmin: minimum disparity :type dmin: float :param dmax: maximum disparity :type dmax: float :param altitude_delta_max: Delta max of altitude :type altitude_delta_max: int :param altitude_delta_min: Delta min of altitude :type altitude_delta_min: int :param dem_median: path to median dem :type dem_median: str :param dem_min: path to minimum dem :type dem_min: str :param dem_max: path to maximum dem :type dem_max: str :param pair_folder: folder used for current pair :type pair_folder: str :param loc_inverse_orchestrator: orchestrator to perform inverse locs :type loc_inverse_orchestrator: Orchestrator :return disparity grid range, containing grid min and max :rtype: CarsDataset .. py:method:: run(epipolar_images_left, epipolar_images_right, local_tile_optimal_size_fun, orchestrator=None, pair_folder=None, pair_key='PAIR_0', disp_range_grid=None, compute_disparity_masks=False, margins_to_keep=0) Run Matching application. Create CarsDataset filled with xarray.Dataset, corresponding to epipolar disparities, on the same geometry than epipolar_images_left. :param epipolar_images_left: tiled left epipolar CarsDataset contains: - N x M Delayed tiles. Each tile will be a future xarray Dataset containing: - data with keys : "im", "msk", "color" - attrs with keys: "margins" with "disp_min" and "disp_max" "transform", "crs", "valid_pixels", "no_data_mask", "no_data_img" - attributes containing: "largest_epipolar_region","opt_epipolar_tile_size" :type epipolar_images_left: CarsDataset :param epipolar_images_right: tiled right epipolar CarsDataset contains: - N x M Delayed tiles. Each tile will be a future xarray Dataset containing: - data with keys : "im", "msk", "color" - attrs with keys: "margins" with "disp_min" and "disp_max" "transform", "crs", "valid_pixels", "no_data_mask", "no_data_img" - attributes containing: "largest_epipolar_region","opt_epipolar_tile_size" :type epipolar_images_right: CarsDataset :param local_tile_optimal_size_fun: function to compute local optimal tile size :type local_tile_optimal_size_fun: func :param orchestrator: orchestrator used :param pair_folder: folder used for current pair :type pair_folder: str :param pair_key: pair id :type pair_key: str :param disp_range_grid: minimum and maximum disparity grid :type disp_range_grid: CarsDataset :param margins_to_keep: margin to keep after dense matching :type margins_to_keep: int :return: disparity map: The CarsDataset contains: - N x M Delayed tiles. Each tile will be a future xarray Dataset containing: - data with keys : "disp", "disp_msk" - attrs with keys: profile, window, overlaps - attributes containing: "largest_epipolar_region","opt_epipolar_tile_size", "disp_min_tiling", "disp_max_tiling" :rtype: CarsDataset .. py:function:: compute_disparity_wrapper(left_image_object: xarray.Dataset, right_image_object: xarray.Dataset, corr_cfg: dict, disp_range_grid, saving_info=None, compute_disparity_masks=False, crop_with_range=None, left_overlaps=None, margins_to_keep=0, classification_fusion_margin=-1) -> Dict[str, Tuple[xarray.Dataset, xarray.Dataset]] Compute disparity maps from image objects. This function will be run as a delayed task. User must provide saving infos to save properly created datasets :param left_image_object: tiled Left image - dataset with : - cst.EPI_IMAGE - cst.EPI_MSK (if given) - cst.EPI_COLOR (for left, if given) :type left_image_object: xr.Dataset - dataset with : - cst.EPI_IMAGE - cst.EPI_MSK (if given) - cst.EPI_COLOR (for left, if given) :param right_image_object: tiled Right image :type right_image_object: xr.Dataset :param corr_cfg: Correlator configuration :type corr_cfg: dict :param disp_range_grid: minimum and maximum disparity grid :type disp_range_grid: np.ndarray :param compute_disparity_masks: Compute all the disparity pandora masks(disable by default) :type compute_disparity_masks: bool :param generate_performance_map: True if generate performance map :type generate_performance_map: bool :param perf_ambiguity_threshold: ambiguity threshold used for performance map :type perf_ambiguity_threshold: float :param disp_to_alt_ratio: disp to alti ratio used for performance map :type disp_to_alt_ratio: float :param crop_with_range: range length to crop disparity range with :type crop_with_range: float :param left_overlaps: left overlap :type: left_overlaps: dict :param margins_to_keep: margin to keep after dense matching :type margins_to_keep: int :param classification_fusion_margin: the margin to add for the fusion :type classification_fusion_margin: int :return: Left to right disparity dataset Returned dataset is composed of : - cst_disp.MAP - cst_disp.VALID - cst.EPI_COLOR .. py:function:: loc_inverse_wrapper(geom_plugin, image, geomodel, latitudes, longitudes, altitudes, saving_info=None) -> pandas.DataFrame Perform inverse localizations on input coordinates This function will be run as a delayed task. :param geom_plugin: geometry plugin used to perform localizations :type geom_plugin: SharelocGeometry :param image: input image path :type image: str :param geomodel: input geometric model :type geomodel: str :param latitudes: input latitude coordinates :type latitudes: np.array :param longitudes: input longitudes coordinates :type longitudes: np.array :param altitudes: input latitude coordinates :type altitudes: np.array :param saving_info: saving info for cars orchestrator :type saving_info: dict