stereo_calibration.h

Go to the documentation of this file.

 
#ifndef STEPSABC_STEREO_CALIBRATION_H
#define STEPSABC_STEREO_CALIBRATION_H
 
#include <array>
#include <string>
#include <vector>
 
namespace cppxdic {
namespace stepsABC {
 
struct CalibPoint3D {
    double x = 0.0;
    double y = 0.0;
    double z = 0.0;
};
 
struct CalibPoint2D {
    double u = 0.0;
    double v = 0.0;
};
 
struct CylinderCalibSpec {
    double radius = 30.0;    // cylinder radius (mm)
    int num_columns = 18;    // dots around the circumference
    int num_rows = 11;       // dot rows along the cylinder axis
    double dz = 5.0;         // vertical spacing between rows (mm)
    double theta0_deg = 0.0; // angular offset of first column (deg)
    bool full_circle = true; // columns span 360 deg (true) or [0, (N-1)*dtheta]
};
 
struct CameraDLT {
    int camera_id = 0;
    std::array<double, 11> L{};    // 11 DLT parameters
    double rms_reprojection = 0.0; // RMS image-plane reprojection error (px)
    bool valid = false;
};
 
struct ReconstructionError {
    double mean = 0.0;             // mean 3D error magnitude (mm)
    double rms = 0.0;              // RMS 3D error magnitude (mm)
    double max = 0.0;              // max 3D error magnitude (mm)
    double std = 0.0;              // std-dev of 3D error magnitude (mm)
    std::vector<double> per_point; // per-point 3D error magnitude (mm)
};
 
struct StereoCalibrationResult {
    CameraDLT cam_first;
    CameraDLT cam_second;
    ReconstructionError recon_error;
    std::vector<CalibPoint3D> reconstructed; // triangulated 3D points
    bool valid = false;
};
 
class StereoCalibration {
public:
    static std::vector<CalibPoint3D> generateCylindricalObject(const CylinderCalibSpec& spec);
 
    static bool writeObjectFile(const std::vector<CalibPoint3D>& pts, const std::string& path,
                                std::string& error_message);
 
    static std::vector<CalibPoint3D> readObjectFile(const std::string& path,
                                                    std::string& error_message);
 
    static std::vector<CalibPoint2D> readImagePointsFile(const std::string& path,
                                                         std::string& error_message);
 
    static CameraDLT calcDLTParameters(int camera_id, const std::vector<CalibPoint2D>& image_points,
                                       const std::vector<CalibPoint3D>& object_points,
                                       std::string& error_message);
 
    static CalibPoint3D reconstructPoint(const CameraDLT& cam1, const CalibPoint2D& p1,
                                         const CameraDLT& cam2, const CalibPoint2D& p2);
 
    static ReconstructionError reconstructionError(const CameraDLT& cam1,
                                                   const std::vector<CalibPoint2D>& img1,
                                                   const CameraDLT& cam2,
                                                   const std::vector<CalibPoint2D>& img2,
                                                   const std::vector<CalibPoint3D>& object_points,
                                                   std::vector<CalibPoint3D>& reconstructed_out);
 
    static StereoCalibrationResult calibrateStereoPair(
        int cam_first_id, const std::vector<CalibPoint2D>& img_first, int cam_second_id,
        const std::vector<CalibPoint2D>& img_second, const std::vector<CalibPoint3D>& object_points,
        std::string& error_message);
};
 
} // namespace stepsABC
} // namespace cppxdic
 
#endif // STEPSABC_STEREO_CALIBRATION_H