intrinsics.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Geometry>
#include <optional>
#include <vector>
 
#include "calib/estimation/common/intrinsics_utils.h"
#include "calib/estimation/common/ransac.h"      // RansacOptions
#include "calib/estimation/linear/homography.h"  // HomographyResult
#include "calib/estimation/linear/planarpose.h"  // PlanarObservation/View
#include "calib/models/cameramodel.h"
#include "calib/models/distortion.h"
#include "calib/models/pinhole.h"
 
namespace calib {
 
struct IntrinsicsEstimOptions final {
    std::optional<CalibrationBounds> bounds = std::nullopt;         
    std::optional<RansacOptions> homography_ransac = std::nullopt;  
    bool use_skew = false;                                          
};
 
struct ViewEstimateData final {
    size_t view_index = 0;
    Eigen::Isometry3d c_se3_t = Eigen::Isometry3d::Identity();
    // Diagnostics
    HomographyResult homography;
    double forward_rms_px = 0.0;
};
 
struct IntrinsicsEstimateResult final {
    bool success{false};
 
    CameraMatrix kmtx;                        
    std::vector<double> dist = {0, 0, 0, 0};  
    std::vector<ViewEstimateData> views;      
    std::string log;
};
 
auto estimate_intrinsics(const std::vector<PlanarView>& views,
                         const IntrinsicsEstimOptions& opts = {}) -> IntrinsicsEstimateResult;
 
auto estimate_intrinsics_linear(const std::vector<Observation<double>>& observations,
                                std::optional<CalibrationBounds> bounds = std::nullopt,
                                bool use_skew = false) -> std::optional<CameraMatrix>;
 
constexpr int k_default_max_iterations = 5;
auto estimate_intrinsics_linear_iterative(const std::vector<Observation<double>>& observations,
                                          int num_radial,
                                          int max_iterations = k_default_max_iterations,
                                          bool use_skew = false)
    -> std::optional<PinholeCamera<BrownConradyd>>;
 
static_assert(serializable_aggregate<IntrinsicsEstimateResult>);
static_assert(serializable_aggregate<IntrinsicsEstimOptions>);
static_assert(serializable_aggregate<ViewEstimateData>);
 
}  // namespace calib