:py:mod:`cars.applications.resampling.bicubic_resampling` ========================================================= .. py:module:: cars.applications.resampling.bicubic_resampling .. autoapi-nested-parse:: this module contains the bicubic_resampling application class. Module Contents --------------- Classes ~~~~~~~ .. autoapisummary:: cars.applications.resampling.bicubic_resampling.BicubicResampling Functions ~~~~~~~~~ .. autoapisummary:: cars.applications.resampling.bicubic_resampling.generate_epipolar_images_wrapper cars.applications.resampling.bicubic_resampling.get_sensors_bounds cars.applications.resampling.bicubic_resampling.check_tiles_in_sensor cars.applications.resampling.bicubic_resampling.check_tile_inclusion .. py:class:: BicubicResampling(conf=None) Bases: :py:obj:`cars.applications.resampling.resampling.Resampling` BicubicResampling .. py:method:: check_conf(conf) Check configuration :param conf: configuration to check :type conf: dict :return: overloaded configuration :rtype: dict .. py:method:: pre_run(grid_left, tile_width, tile_height) Pre run some computations : tiling grid :param grid_left: left grid :type grid_left: CarsDataset :param optimum_tile_size: optimum tile size :type optimum_tile_size: int :return: epipolar_regions_grid, epipolar_regions, opt_epipolar_tile_size, largest_epipolar_region, .. py:method:: run(sensor_image_left, sensor_image_right, grid_left, grid_right, geom_plugin, orchestrator=None, pair_folder=None, pair_key='PAIR_0', margins_fun=None, tile_width=None, tile_height=None, add_color=True, add_classif=True, epipolar_roi=None) Run resampling application. Creates left and right CarsDataset filled with xarray.Dataset, corresponding to sensor images resampled in epipolar geometry. :param sensor_images_left: tiled sensor left image Dict Must contain keys : "image", "color", "geomodel", "no_data", "mask", "classification". Paths must be absolutes :type sensor_images_left: CarsDataset :param sensor_images_right: tiled sensor right image Dict Must contain keys : "image", "color", "geomodel", "no_data", "mask", "classification". Paths must be absolutes :type sensor_images_right: CarsDataset :param grid_left: left epipolar grid Grid CarsDataset contains : - A single tile stored in [0,0], containing a (N, M, 2) shape array in xarray Dataset - Attributes containing: "grid_spacing", "grid_origin", "epipolar_size_x", "epipolar_size_y", "epipolar_origin_x", "epipolar_origin_y", epipolar_spacing_x", "epipolar_spacing", "disp_to_alt_ratio", :type grid_left: CarsDataset :param grid_right: right epipolar grid. Grid CarsDataset contains : - A single tile stored in [0,0], containing a (N, M, 2) shape array in xarray Dataset - Attributes containing: "grid_spacing", "grid_origin", "epipolar_size_x", "epipolar_size_y", "epipolar_origin_x", "epipolar_origin_y", epipolar_spacing_x", "epipolar_spacing", "disp_to_alt_ratio", :type grid_right: CarsDataset :param orchestrator: orchestrator used :param pair_folder: folder used for current pair :type pair_folder: directory to save files to :param pair_key: pair id :type pair_key: str :param margins_fun: margins function to use :type margins_fun: fun :param optimum_tile_size: optimum tile size to use :type optimum_tile_size: int :param tile_width: width of tile :type tile_width: int :param tile_height: height of tile :type tile_height: int :param add_color: add color image to dataset :type add_color: bool :param add_classif: add classif to dataset :type add_classif: bool :param epipolar_roi: Epipolar roi to use if set. Set None tiles outsize roi :type epipolar_roi: list(int), [row_min, row_max, col_min, col_max] :return: left epipolar image, right epipolar image. Each CarsDataset contains: - N x M Delayed tiles. Each tile will be a future xarray Dataset containing: - data with keys : "im", "msk", "color", "classif" - 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", "disp_min_tiling", "disp_max_tiling" :rtype: Tuple(CarsDataset, CarsDataset) .. py:function:: generate_epipolar_images_wrapper(left_overlaps, right_overlaps, window, epipolar_size_x, epipolar_size_y, img1, img2, grid1, grid2, interpolator_image, interpolator_color, interpolator_classif, interpolator_mask, step=None, used_disp_min=None, used_disp_max=None, add_color=True, add_classif=True, color1=None, mask1=None, mask2=None, classif1=None, classif2=None, nodata1=0, nodata2=0, saving_info_left=None, saving_info_right=None) -> Dict[str, Tuple[xarray.Dataset, xarray.Dataset]] Compute disparity maps from image objects. This function will be run as a delayed task. If user want to correctly save dataset, the user must provide saving_info_left and right. See cars_dataset.fill_dataset. :param left_overlaps: Overlaps of left image, with row_min, row_max, col_min and col_max keys. :type left_overlaps: dict :param right_overlaps: Overlaps of right image, with row_min, row_max, col_min and col_max keys. :type right_overlaps: dict :param window: Window considered in generation, with row_min, row_max, col_min and col_max keys. :type window: dict :return: Left image object, Right image object (if exists) Returned objects are composed of dataset with : - cst.EPI_IMAGE - cst.EPI_MSK (if given) - cst.EPI_COLOR (for left, if given) .. py:function:: get_sensors_bounds(sensor_image_left, sensor_image_right) Get bounds of sensor images Bounds: BoundingBox(left, bottom, right, top) :param sensor_image_left: left sensor :type sensor_image_left: dict :param sensor_image_right: right sensor :type sensor_image_right: dict :return: left image bounds, right image bounds :rtype: tuple(list, list) .. py:function:: check_tiles_in_sensor(sensor_image_left, sensor_image_right, image_tiling, grid_left, grid_right, geom_plugin) Check if epipolar tiles will be used. A tile is not used if is outside sensor bounds :param sensor_image_left: left sensor :type sensor_image_left: dict :param sensor_image_right: right sensor :type sensor_image_right: dict :param image_tiling: epipolar tiling grid :type image_tiling: np.array :param grid_left: left epipolar grid :type grid_left: CarsDataset :param grid_right: right epipolar grid :type grid_right: CarsDataset :return: left in sensor, right in sensor :rtype: np.array(bool), np.array(bool) .. py:function:: check_tile_inclusion(left_sensor_bounds, right_sensor_bounds, sensor_pos_left, sensor_pos_right) Check if tile is in sensor image :param left_sensor_bounds: bounds of left sensor :type left_sensor_bounds: list :param right_sensor_bounds: bounds of right sensor :type right_sensor_bounds: list :param sensor_pos_left: left sensor position :type sensor_pos_left: np.array :param sensor_pos_right: right sensor position :type sensor_pos_right: np.array :return: left tile in sensor image left, right tile in sensor image right :rtype: tuple(bool, bool)