CameraCalibrator.h

Go to the documentation of this file.

#ifndef __PBIO_API__PBIO__CAMERACALIBRATOR_H_
#define __PBIO_API__PBIO__CAMERACALIBRATOR_H_

#include <sstream>
#include <vector>


#include "ComplexObject.h"
#include "Error.h"
#include "ExceptionCheck.h"
#include "Image.h"
#include "Point.h"
#include "RawImage.h"
#include "SmartPtr.h"
#include "stl_wraps_impls/WrapIStreamImpl.h"
#include "stl_wraps_impls/WrapOStreamImpl.h"




namespace pbio
{

class FacerecService;

class CameraCalibrator : public ComplexObject
{
public:

    typedef LightSmartPtr<CameraCalibrator>::tPtr Ptr;


    struct CalibrationSettings
    {
        enum PatternType
        {
            PATTERN_CHESSBOARD = 0,               
            PATTERN_CIRCLES_GRID = 1,             
            PATTERN_ASYMMETRIC_CIRCLES_GRID = 2,  
        };

        int image_width;

        int image_height;

        PatternType pattern_type;

        int pattern_width;

        int pattern_height;

        bool fix_aspect_ratio;  
        
        bool calib_zero_tangent_dist;
        
        bool calib_fix_principal_point;  
        
        bool rational_distortion_model; 

        CalibrationSettings()
        {
            fix_aspect_ratio          = false;
            calib_zero_tangent_dist   = false;
            calib_fix_principal_point = false;
            rational_distortion_model = true;
        }
    };


    void initCalibration(
        const CalibrationSettings settings);


    void addImage(
        const RawImage image,
        bool *pattern_found,
        bool *pattern_accepted,
        std::vector<Point> *pattern_points);


    float getPatternSpaceCoverProgress() const;


    std::vector<Point> getTip();


    bool calibrate(
        const int max_used_patterns_count,
        float *reprojection_error);


    IRawImage::Ptr undistort(
        const RawImage image,
        const float alpha) const;



    void saveCameraParameters(
        std::ostream &binary_stream) const;

    void saveCameraParameters(
        pbio::stl_wraps::WrapOStream &binary_stream) const;


    void loadCameraParameters(
        std::istream &binary_stream);

    void loadCameraParameters(
        pbio::stl_wraps::WrapIStream &binary_stream);


private:

    CameraCalibrator(
        const DHPtr &dll_handle,
        void* impl);

    int _pattern_width;
    int _pattern_height;

    friend class FacerecService;
    friend class object_with_ref_counter<CameraCalibrator>;
};

}  // pbio namespace




namespace pbio
{

inline
CameraCalibrator::CameraCalibrator(
    const DHPtr &dll_handle,
    void* impl):
ComplexObject(dll_handle, impl)
{
    _pattern_width = 0;
    _pattern_height = 0;
}


inline
void CameraCalibrator::initCalibration(
    const CalibrationSettings settings)
{
    _pattern_height = 0;
    _pattern_width = 0;

    void* exception = NULL;

    _dll_handle->CameraCalibrator_initCalibration(
        _impl,

        settings.image_width,
        settings.image_height,
        settings.pattern_type,
        settings.pattern_width,
        settings.pattern_height,

        settings.fix_aspect_ratio,
        settings.calib_zero_tangent_dist,
        settings.calib_fix_principal_point,
        settings.rational_distortion_model,

        &exception);

    checkException(exception, *_dll_handle);

    _pattern_height = settings.pattern_height;
    _pattern_width = settings.pattern_width;
}


inline
void CameraCalibrator::addImage(
    const RawImage image,
    bool *pattern_found,
    bool *pattern_accepted,
    std::vector<Point> *pattern_points)
{

    int32_t pattern_found_i = 0;
    int32_t pattern_accepted_i = 0;

    std::vector<float> pattern_points_f;

    if(_pattern_height > 0 && _pattern_width > 0)
        pattern_points_f.resize(_pattern_height * _pattern_width * 2);

    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    _dll_handle->CameraCalibrator_addImage_with_crop(
        _impl,

        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,

        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,

        &pattern_found_i,
        &pattern_accepted_i,
        pattern_points_f.empty() ?
            NULL :
            &pattern_points_f[0],
        &exception);

    checkException(exception, *_dll_handle);


    if(pattern_found)
        *pattern_found = pattern_found_i;

    if(pattern_accepted)
        *pattern_accepted = pattern_accepted_i;

    if(pattern_points)
    {
        pattern_points->resize(_pattern_width * _pattern_height);
        for(size_t i = 0; i < pattern_points->size(); ++i)
        {
            pattern_points->at(i).x = pattern_points_f[i * 2 + 0];
            pattern_points->at(i).y = pattern_points_f[i * 2 + 1];
        }
    }
}


inline
float CameraCalibrator::getPatternSpaceCoverProgress() const
{
    void* exception = NULL;

    const float progress = _dll_handle->CameraCalibrator_getPatternSpaceCoverProgress(
        _impl,
        &exception);

    checkException(exception, *_dll_handle);

    return progress;
}


inline
std::vector<Point> CameraCalibrator::getTip()
{
    std::vector<float> pattern_points_f;

    if(_pattern_height > 0 && _pattern_width > 0)
        pattern_points_f.resize(_pattern_height * _pattern_width * 2);

    void* exception = NULL;

    const int32_t tip_ready = _dll_handle->CameraCalibrator_getTip(
        _impl,
        pattern_points_f.empty() ?
            NULL :
            &pattern_points_f[0],
        &exception);

    checkException(exception, *_dll_handle);

    std::vector<Point> pattern_points;

    if(tip_ready)
    {
        pattern_points.resize(_pattern_width * _pattern_height);

        for(size_t i = 0; i < pattern_points.size(); ++i)
        {
            pattern_points[i].x = pattern_points_f[i * 2 + 0];
            pattern_points[i].y = pattern_points_f[i * 2 + 1];
        }
    }

    return pattern_points;
}



inline
bool CameraCalibrator::calibrate(
    const int max_used_patterns_count,
    float *reprojection_error_ptr)
{
    void* exception = NULL;

    const float reprojection_error = _dll_handle->CameraCalibrator_calibrate(
        _impl,
        max_used_patterns_count,
        &exception);

    checkException(exception, *_dll_handle);

    if(reprojection_error < 0 - 0.1f)
        return false;

    if(reprojection_error_ptr)
        *reprojection_error_ptr = reprojection_error;

    return true;
}


inline
IRawImage::Ptr CameraCalibrator::undistort(
    const RawImage image,
    const float alpha) const
{
    pbio::image::Image::Ptr result(
        new pbio::image::Image(
            image.height,
            image.width,
            image.format));

    void* exception = NULL;

    const RawImage::CapiData cdata = image.makeCapiData();

    _dll_handle->CameraCalibrator_undistort_with_crop(
        _impl,

        cdata.data,
        cdata.width,
        cdata.height,
        cdata.format,

        cdata.with_crop,
        cdata.crop_info_offset_x,
        cdata.crop_info_offset_y,
        cdata.crop_info_data_image_width,
        cdata.crop_info_data_image_height,

        alpha,
        result->data(),
        &exception);

    checkException(exception, *_dll_handle);

    return result;
}



inline
void CameraCalibrator::saveCameraParameters(
    std::ostream &binary_stream) const
{
    pbio::stl_wraps::WrapOStreamImpl binary_stream_wrap(binary_stream);

    saveCameraParameters(binary_stream_wrap);
}

inline
void CameraCalibrator::saveCameraParameters(
    pbio::stl_wraps::WrapOStream &binary_stream) const
{
    void* exception = NULL;

    _dll_handle->CameraCalibrator_saveCameraParameters(
        _impl,
        &binary_stream,
        pbio::stl_wraps::WrapOStream::write_func,
        &exception);

    checkException(exception, *_dll_handle);
}


inline
void CameraCalibrator::loadCameraParameters(
    std::istream &binary_stream)
{
    pbio::stl_wraps::WrapIStreamImpl binary_stream_wrap(binary_stream);

    loadCameraParameters(binary_stream_wrap);
}

inline
void CameraCalibrator::loadCameraParameters(
    pbio::stl_wraps::WrapIStream &binary_stream)
{
    void* exception = NULL;

    _dll_handle->CameraCalibrator_loadCameraParameters(
        _impl,
        &binary_stream,
        pbio::stl_wraps::WrapIStream::read_func,
        &exception);

    checkException(exception, *_dll_handle);
}


}  // pbio namespace

#endif  // __PBIO_API__PBIO__CAMERACALIBRATOR_H_