Signification de la valeur de retour retval dans cv2.CalibrateCamera

Question

comme le dit le titre, ma question concerne une valeur de retour donnée par la fonction calibrateCamera d'OpenCv.

http://docs.opencv.org/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.html

J'ai une implémentation en python pour fonctionnel trouver les paramètres intrinsèques et les coefficients de distorsion d'une caméra à l'aide d'une & noire grille blanche.

La question est plus sur le retour renvoyé par la fonction. Si je comprends bien, c'est "l'erreur de re-projection moyenne, ce nombre donne une bonne estimation de la précision des paramètres trouvés, qui devrait être aussi proche de zéro que possible". comme mentionné dans

http://docs.opencv.org/doc/tutorials/calib3d/camera_calibration/camera_calibration.html

Que signifie exactement une valeur proche aussi proche de zéro que possible signifie?

Par exemple quand je le fais pour ma webcam Logitech:

RMS: 0.702660793513

matrice de la caméra

:

[[ 616.30868126 0.   339.02126978] 
[ 0.   605.08224927 241.64607568] 
[ 0.   0.   1.  ]] 

coefficients de distorsion:

[ 0.19805527 -0.62915986 0.00924648 0.02618232 1.02491764] 

Dans ce cas, Comment l'erreur quantifie-t-elle la qualité du p intrinsèque? estimation des aramètres?

EDIT:

Je suis donc allé chercher des réponses et creuser un peu plus profond et de vérifier la mise en œuvre de cpp de cette fonction.

Ceci est la fonction de calcul de cette valeur d'erreur:

static double computeReprojectionErrors(
     const vector<vector<Point3f> >& objectPoints, 
     const vector<vector<Point2f> >& imagePoints, 
     const vector<Mat>& rvecs, const vector<Mat>& tvecs, 
     const Mat& cameraMatrix, const Mat& distCoeffs, 
     vector<float>& perViewErrors) 
{ 
    vector<Point2f> imagePoints2; 
    int i, totalPoints = 0; 
    double totalErr = 0, err; 
    perViewErrors.resize(objectPoints.size()); 

    for(i = 0; i < (int)objectPoints.size(); i++) 
    { 
     projectPoints(Mat(objectPoints[i]), rvecs[i], tvecs[i], 
         cameraMatrix, distCoeffs, imagePoints2); 
     err = norm(Mat(imagePoints[i]), Mat(imagePoints2), NORM_L2); 
     int n = (int)objectPoints[i].size(); 
     perViewErrors[i] = (float)std::sqrt(err*err/n); 
     totalErr += err*err; 
     totalPoints += n; 
    } 

    return std::sqrt(totalErr/totalPoints); 
} 

Cette erreur est calculée en tenant compte des tvecs et rvecs trouvés avec cv2.CalibrateCamera, il reprojette les points utilisés pour trouver les vecteurs de translation et de rotation et calcule la distance euclidienne entre le point reprojeté et les coordonnées réelles de ces points.

Je ne pense pas que cette erreur soit bornée dans [0,1] mais dépend plutôt de la plage des coordonnées utilisées pour l'étalonnage. Cela dépend donc de la résolution des images utilisées pour l'étalonnage.

Quelqu'un peut-il confirmer/infirmer cela?

Answer 1

calibrateCamera renvoie l'erreur de re-projection du carré moyen (RMS), généralement comprise entre 0,1 et 1,0 pixels dans un bon étalonnage.
Le calcul se fait en projetant les points d'échiquier 3D (objectPoints) dans le plan d'image en utilisant l'ensemble final de paramètres de calibration (cameraMatrix, distCoeffs, rvecs et tvecs) et en comparant la position connue des coins (imagePoints). Une erreur RMS de 1,0 signifie qu'en moyenne, chacun de ces points projetés est éloigné de 1,0 px de sa position réelle.L'erreur n'est pas bornée dans [0, 1], elle peut être considérée comme une distance.