Comment extraire des résultats aberrants du résultat de ceres solveur?

Question

J'essaie de comparer des images en utilisant la méthode similaire à Features2D + Homography to find a known object mais remplacer findHomography() par auto-écrit findAffine() fonction. J'utilise Ceres Solver pour obtenir une matrice affine optimale en considérant les valeurs aberrantes.

double translation[] = {0, 0}; 
    double angle = 0; 
    double scaleFactor = 1; 

    ceres::Problem problem; 


    for (size_t i = 0; i < points1.size(); ++i) { 
     problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<AffineResidual, 1, 2, 1, 1>(
          new AffineResidual(Eigen::Vector2d(points1[i].x, points1[i].y), 
              Eigen::Vector2d(points2[i].x, points2[i].y))), 
          new ceres::HuberLoss(1.0), 
          translation, 
          &angle, 
          &scaleFactor); 
    } 

    ceres::Solver::Options options; 
    options.linear_solver_type = ceres::DENSE_QR; 
    options.minimizer_progress_to_stdout = true; 

    ceres::Solver::Summary summary; 
    Solve(options, &problem, &summary); 

Ceres fournir solveur LossFunction:

fonctions de perte réduisent l'influence des blocs résiduels avec des résiduels élevés, généralement ceux correspondant aux valeurs aberrantes.

Bien sûr, je peux transformer les coordonnées des points-clés de la première image par la matrice obtenue, comparer avec la seconde et obtenir une déviation. Mais ceres solveur déjà fait à l'intérieur pendant le travail.

Comment puis-je le récupérer? Je ne l'ai pas trouvé dans la documentation.

Answer 1

J'ai eu le même problème. Après avoir examiné les sources de la bibliothèque Ceres (en particulier dans la méthode ResidualBlock :: Evaluate()), j'ai conclu qu'il n'y avait pas de statut «aberrant» explicite pour le bloc résiduel. Il semble que la fonction de perte affecte simplement la valeur de coût qui en résulte pour un bloc (ce qui est exactement décrit par la phrase de la documentation que vous avez citée - "Les fonctions de perte réduisent l'influence des blocs résiduels avec des résidus élevés"). Donc, la réponse est que vous ne pouvez pas récupérer les valeurs aberrantes de Ceres, il n'y a pas de telle fonctionnalité.

Solution de contournement peut être calculer résiduels pour vos données avec le résultat résolu, et appliquer la fonction de perte à eux. Le commentaire de LossFunction :: Evaluate() peut aider:

// For a residual vector with squared 2-norm 'sq_norm', this method 
// is required to fill in the value and derivatives of the loss 
// function (rho in this example): 
// 
// out[0] = rho(sq_norm), 
// out[1] = rho'(sq_norm), 
// out[2] = rho''(sq_norm), 
// 
// Here the convention is that the contribution of a term to the 
// cost function is given by 1/2 rho(s), where 
// 
// s = ||residuals||^2. 
// 
// Calling the method with a negative value of 's' is an error and 
// the implementations are not required to handle that case. 
// 
// Most sane choices of rho() satisfy: 
// 
// rho(0) = 0, 
// rho'(0) = 1, 
// rho'(s) < 1 in outlier region, 
// rho''(s) < 0 in outlier region, 
// 
// so that they mimic the least squares cost for small residuals. 
virtual void Evaluate(double sq_norm, double out[3]) const = 0;