Compreendendo a validação por reprojeção

Ao finalizar o processo de calibração de uma câmera, é comum questionar a confiabilidade dos parâmetros obtidos — matriz intrínseca, coeficientes de distorção, rotações e translações. Em aplicações como visão robótica, reconstrução 3D ou realidade aumentada, a precisão desses parâmetros é fundamental. Um erro na calibração se propaga diretamente para medições, posicionamento e modelagem, comprometendo todo o sistema.

O método mais eficaz para validar esses parâmetros não está no algoritmo de calibração em si, mas sim em um teste inverso chamado reprojeção. A ideia central é: usando os parâmetros estimados, projetamos novamente os pontos 3D conhecidos (como cantos de um tabuleiro de xadrez) sobre o plano da imagem e comparamos as posições resultantes com as detecções reais feitas pelo algoritmo de detecção de cantos. A diferença entre essas localizações é o chamado erro de reprojeção, que serve como métrica primária de qualidade.

Nesse contexto, a função cv::projectPoints() do OpenCV desempenha um papel crucial. Ela realiza exatamente essa transformação perspectiva, considerando tanto os parâmetros intrínsecos quanto os coeficientes de distorção. Mais do que uma simples ferramenta de projeção, ela permite inspecionar visualmente e quantificar o ajuste do modelo de câmera ao comportamento físico real do sistema óptico.

Cálculo prático do erro de reprojeção

Suponha que você já tenha executado cv::calibrateCamera() e obtenha os seguintes dados:

• cameraMatrix: matriz intrínseca (focais e ponto principal)
• distCoeffs: vetor de distorção (radial e tangencial)
• rvecs, tvecs: vetores de rotação e translação por imagem
• objectPoints: coordenadas 3D dos cantos do tabuleiro (no sistema mundo)
• imagePoints: coordenadas 2D detectadas nas imagens

O trecho abaixo demonstra como usar cv::projectPoints() para calcular o erro médio por imagem e gerar uma comparação visual direta:

#include <opencv2/opencv.hpp>
#include <iostream>

int main() {
    // Dados hipotéticos vindos da calibração
    cv::Mat K, D;
    std::vector<cv::Mat> rvecs, tvecs;
    std::vector<std::vector<cv::Point3f>> objPts;
    std::vector<std::vector<cv::Point2f>> imgPts;
    std::vector<std::string> paths;

    // ... carregamento ou inicialização dos dados ...

    double totalError = 0.0;
    std::vector<double> errorsPerImage;

    for (size_t i = 0; i < paths.size(); ++i) {
        std::vector<cv::Point2f> reproj;
        
        // Projeta os pontos 3D usando os parâmetros calibrados
        cv::projectPoints(objPts[i], rvecs[i], tvecs[i], K, D, reproj);

        // Calcula erro médio nesta imagem
        double sumDist = 0.0;
        for (size_t j = 0; j < imgPts[i].size(); ++j) {
            double dx = imgPts[i][j].x - reproj[j].x;
            double dy = imgPts[i][j].y - reproj[j].y;
            sumDist += std::sqrt(dx*dx + dy*dy);
        }
        double avgError = sumDist / imgPts[i].size();
        errorsPerImage.push_back(avgError);
        totalError += avgError;

        // Visualização: imagem original com pontos sobrepostos
        cv::Mat frame = cv::imread(paths[i]);
        for (size_t j = 0; j < reproj.size(); ++j) {
            cv::circle(frame, imgPts[i][j], 3, cv::Scalar(0, 255, 0), -1);   // Detectado (verde)
            cv::circle(frame, reproj[j], 3, cv::Scalar(0, 0, 255), 1);         // Reprojetado (vermelho)
            cv::line(frame, imgPts[i][j], reproj[j], cv::Scalar(255, 255, 0), 1); // Linha de erro
        }

        std::string label = "Erro: " + std::to_string(avgError).substr(0, 4) + " px";
        cv::putText(frame, label, cv::Point(10, 30),
                    cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(0, 255, 255), 2);
        cv::imshow("Validação", frame);
        cv::waitKey(400);
    }
    cv::destroyAllWindows();

    double meanTotalError = totalError / paths.size();
    std::cout << "Erro médio global: " << meanTotalError << " pixels\n";

    return 0;
}

Este código produz três tipos de saída:

1. Valor numérico: Erro médio geral e por imagem.
2. Visualização dinâmica: Pontos verdes (detectados) e vermelhos (reprojetados), com linhas indicando o desvio.
3. Diagnóstico pontual: Permite identificar rapidamente quais imagens apresentam mau ajuste.

Como regra geral:

• < 0.5 px → Excelente
• 0.5 – 1.0 px → Bom
• 1.0 – 2.0 px → Aceitável com ressalvas
• > 2.0 px → Provavelmente inadequado para aplicações precisas

Interpretação de padrões de erro

Além do valor escalar do erro, a distribuição espacial dos desvios oferece pistas valiosas sobre falhas no modelo:

Erro elevado em todas as imagens

Indica problemas sistêmicos:

• Deteção imprecisa de cantos: Imagens borradas, reflexos ou baixo contraste. Solução: usar cv::cornerSubPix e revisar condições de captura.
• Falta de diversidade de poses: O tabuleiro deve cobrir diferentes regiões da imagem e ângulos (inclinações, rotações).
• Modelo de distorção inapropriado: Lentes grande-angulares ou olho de peixe exigem modelos específicos (cv::fisheye::calibrate).
• Dimensões incorretas do tabuleiro: Verifique unidades (mm vs m) e espaçamento exato entre cantos.

Erro alto apenas em algumas imagens

Analisar individualmente essas imagens pode revelar:

• Occlusão parcial do tabuleiro
• Borrão de movimento
• Tabuleiro flexível ou não plano
• Falha na detecção automática de padrão

Solução: descartar imagens problemáticas e recalcular a calibração com um conjunto mais limpo.

Padrões espaciais nos erros

Observar a direção dos vetores de erro ajuda a isolar causas:

• Erros radiais crescentes nas bordas: Modelo de distorção subajustado. Experimente habilitar mais coeficientes (k3, k4).
• Deslocamento uniforme de todos os pontos: Ponto principal mal estimado. Confirme se o tabuleiro foi posicionado próximo aos cantos da imagem durante a captura.
• Erros concentrados em uma região: Pode indicar distorção anômala local ou falha na fabricação do tabuleiro.

Técnicas avançadas de refinamento

Após a análise inicial, é possível aprimorar o resultado com estratégias iterativas.

Análise de sensibilidade via matriz jacobiana

A função cv::projectPoints() pode retornar opcionalmente uma matriz jacobiana, que expressa como pequenas variações nos parâmetros influenciam a posição dos pontos projetados. Isso é útil em otimizações tipo bundle adjustment ou para estimar incertezas de projeção.

cv::Mat jac;
cv::projectPoints(objPts[i], rvecs[i], tvecs[i], K, D, reproj, jac);
// 'jac' tem dimensão (2*N pontos) × (número de parâmetros livres)

Validação por zonas da imagem

Divida a imagem em regiões (centro, bordas) e calcule erros separadamente. Para lentes com campo amplo, é esperado que a borda tenha erro maior. Se esse desequilíbrio for excessivo, considere modelos de distorção mais completos.

Teste com objetos reais (fora do tabuleiro)

O verdadeiro teste de robustez é aplicar os parâmetros em cenas não usadas na calibração. Por exemplo:

1. Posicione um objeto com geometria conhecida (cubo metálico, placa com furos).
2. Detecte manualmente alguns pontos-chave na imagem.
3. Use cv::projectPoints() para prever suas posições com base na geometria 3D e nos parâmetros calibrados.
4. Compare com as posições reais.

Esse "erro de generalização" revela limitações do modelo que podem não aparecer no conjunto de calibração.

Refinamento iterativo dos dados

Um ciclo eficaz inclui:

• Limpeza de dados: Remova imagens com erro muito acima da média.
• Restrições paramétricas: Fixe certos parâmetros (ex: centro da imagem) se houver justificativa física.
• Calibração em múltiplas etapas: Primeiro estime distorção central, depois refine com dados periféricos.

Em muitos casos, menos imagens de alta qualidade produzem melhores resultados do que um grande conjunto com ruído.

Conclusão

A função cv::projectPoints() vai muito além de uma simples transformação geométrica. Quando usada estrategicamente no pós-calibração, ela se torna uma ferramenta diagnóstica poderosa. A combinação de erros numéricos, visualização espacial e análise contextual permite transformar um processo mecânico em uma engenharia precisa de parâmetros visuais. Incorporar essa prática como parte padrão do fluxo de trabalho aumenta significativamente a confiança em qualquer sistema baseado em visão computacional.