pandora2d.multiscale.model_estimation ===================================== .. py:module:: pandora2d.multiscale.model_estimation .. autoapi-nested-parse:: This module contains methods associated to the estimation model for the MVP Attributes ---------- .. autoapisummary:: pandora2d.multiscale.model_estimation.COMPRESSION_FACTOR Functions --------- .. autoapisummary:: pandora2d.multiscale.model_estimation.get_invalid_disp_mask pandora2d.multiscale.model_estimation.add_mesh_validity_band pandora2d.multiscale.model_estimation.make_position_vectors pandora2d.multiscale.model_estimation.make_polynomial_design_matrix pandora2d.multiscale.model_estimation.check_nb_observations pandora2d.multiscale.model_estimation.estimate_model pandora2d.multiscale.model_estimation.estimate_model_cholesky pandora2d.multiscale.model_estimation.estimate_init_disparity_grids pandora2d.multiscale.model_estimation.get_next_shape_mesh_list pandora2d.multiscale.model_estimation.concatenate_estimated_grids pandora2d.multiscale.model_estimation.get_init_disparity_grids pandora2d.multiscale.model_estimation.get_init_disparity_grids_with_mesh Module Contents --------------- .. py:data:: COMPRESSION_FACTOR :value: 0.5 .. py:function:: get_invalid_disp_mask(row_map: numpy.typing.NDArray, col_map: numpy.typing.NDArray, invalid_disp: Union[int, float]) -> numpy.typing.NDArray Compute mask for points equal to invalid_disp in row_map or col_map. This mask is then used to remove invalid points from position vectors. :param row_map: row disparity map :param col_map: col disparity map :param invalid_disp: invalid disparity value :return: invalid mask for position matrix .. py:function:: add_mesh_validity_band(dataset_disp_maps: xarray.Dataset) -> xarray.Dataset Add a 'MESH_validity' band to an existing validity dataset. :param dataset_disp_maps: xarray Dataset containing the validity data and the disparity maps .. py:function:: make_position_vectors(dataset_disp_maps: xarray.Dataset) -> Tuple[numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray] Construct initial et final positions vectors using dataset_disp_maps coordinates and disparity maps. To reduce numerical instability, a compression factor is used to create the final and initial position grids. For the least squares problem y=Xb: - X is constructed using init_row_coords and init_col_coords - y is either final_row_coords or final_col_coords. :param dataset_disp_maps: disparity maps dataset :return: initial position vectors and final position vectors .. py:function:: make_polynomial_design_matrix(row_init_coords: numpy.typing.NDArray, col_init_coords: numpy.typing.NDArray, degree: int) -> numpy.typing.NDArray Construct a 2D polynomial design matrix up to a given degree. It generates all polynomial combination of the input variables col_init_coords and row_init_coords. For the least squares problem y=Xb, X is the design matrix. :param col_init_coords: initial column positions :param row_init_coords: initial row positions :param degree: polynomial degree :return: polynomial design matrix .. py:function:: check_nb_observations(design_matrix: numpy.typing.NDArray) Check if we have more parameters than observations, in which case a ValueError is raised. :param design_matrix: Design matrix .. py:function:: estimate_model(dataset_disp_maps: xarray.Dataset, degree: int) -> Tuple[numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray] Estimate deformation model from initial positions to final positions by resolving y=Xb. :param degree: polynomial degree :param dataset_disp_maps: disparity maps dataset :return: least square solution and sum of residuals for rows and columns .. py:function:: estimate_model_cholesky(dataset_disp_maps: xarray.Dataset, degree: int, lambda_ridge: Union[int, float, None] = None) -> Tuple[numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray] Estimate deformation model from initial positions to final positions by resolving y=Xb using Cholesky decomposition. We have X.T*X*b = X.T*y and X.T*X = L*L.T with L a lower triangular matrix. Then, using Cholesky decomposition we can resolve L*z=X.T*y and L.T*b = z. If a value is specified for lamba_ridge, Ridge regularization is used. :param dataset_disp_maps: disparity maps dataset :param degree: polynomial degree :param lambda_ridge: Ridge regularization factor :return: least square solution and sum of residuals for rows and columns .. py:function:: estimate_init_disparity_grids(dataset_disp_maps: xarray.Dataset, coefficients_row: numpy.typing.NDArray, coefficients_col: numpy.typing.NDArray, degree: int, next_resolution_shape: Tuple) -> Tuple[numpy.typing.NDArray, numpy.typing.NDArray] Estimate initial disparity grids (rows and columns) according to scale factor and coefficients of least squares resolution. :param dataset_disp_maps: disparity maps dataset :param coefficients_row: row coefficients computed by least squares resolution :param coefficients_col: col coefficients computed by least squares resolution :param degree: polynomial degree :param next_resolution_shape: shape of image for next resolution :return: initial disparity grids for rows and columns .. py:function:: get_next_shape_mesh_list(next_resolution_shape: int, nb_mesh: int) -> List[int] Return list of shape for mesh for next resolution. This list is then used to estimate initial disparity grid at next resolution with the right shape for each mesh. :param next_resolution_shape: next resolution shape (row or column) :param nb_mesh: number of mesh (row or column) :return: List of shape by mesh (row or column) .. py:function:: concatenate_estimated_grids(estimated_init_grid_list: List[numpy.typing.NDArray], nb_row_mesh: int, nb_col_mesh: int) -> numpy.typing.NDArray Concatenate the estimated disparity grids computed by mesh and return the full initial disparity grid for next resolution. :param estimated_init_grid_list: :param nb_row_mesh: number of mesh for rows :param nb_col_mesh: number of mesh for columns :return: full estimated initial disparity grid for next resolution .. py:function:: get_init_disparity_grids(dataset_disp_maps: xarray.Dataset, multiscale_cfg: Dict, next_resolution_shape: Tuple) -> Tuple[numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray] Return initial disparity grid after computing least square coefficients :param dataset_disp_maps: disparity maps dataset :param multiscale_cfg: multiscale pipeline configuration :param next_resolution_shape: shape of image for next resolution :return: initial disparity grids for rows and columns and sum of squared residuals .. py:function:: get_init_disparity_grids_with_mesh(dataset_disp_maps: xarray.Dataset, multiscale_cfg: Dict, next_resolution_shape: Tuple) -> Tuple[numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray, numpy.typing.NDArray, xarray.Dataset] Return initial disparity grid after computing least square coefficients for each mesh :param dataset_disp_maps: disparity maps dataset :param multiscale_cfg: multiscale pipeline configuration :param next_resolution_shape: shape of image for next resolution :return: initial disparity grids for rows and columns and RMSE for row and columns