Calibration.h

Go to the documentation of this file.

// ****************************************************************************
// This file is part of the Integrating Vision Toolkit (IVT).
//
// The IVT is maintained by the Karlsruhe Institute of Technology (KIT)
// (www.kit.edu) in cooperation with the company Keyetech (www.keyetech.de).
//
// Copyright (C) 2014 Karlsruhe Institute of Technology (KIT).
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the KIT nor the names of its contributors may be
//    used to endorse or promote products derived from this software
//    without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE KIT AND CONTRIBUTORS “AS IS” AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE KIT OR CONTRIBUTORS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ****************************************************************************
// ****************************************************************************
// Filename:  Calibration.h
// Author:    Pedram Azad
// Date:      2004
// ****************************************************************************

#ifndef _CALIBRATION_H_
#define _CALIBRATION_H_


// ****************************************************************************
// Necessary includes
// ****************************************************************************

#include "Math/Math2d.h"
#include "Math/Math3d.h"



// ****************************************************************************
// CCalibration
// ****************************************************************************

class CCalibration
{
public:
        struct CCameraParameters
        {
                int width;
                int height;
                Vec2d principalPoint;
                Vec2d focalLength;
                float distortion[4];
                Mat3d rotation;
                Vec3d translation;
        };


        CCalibration();

        ~CCalibration();

        
        void Set(const CCalibration &calibration);
        
        void SetCameraParameters(float fx, float fy, float cx, float cy,
                          float d1, float d2, float d3, float d4,
                          const Mat3d &R, const Vec3d &t, int width, int height);
        
        void SetIntrinsicBase(float cx, float cy, float fx, float fy);
        
        void SetDistortion(float d1, float d2, float d3, float d4);

        void SetRotation(const Mat3d &R);
        
        void SetTranslation(const Vec3d &t);
        
        
        void GetCalibrationMatrix(Mat3d &K) const;
        
        void GetProjectionMatrix(Mat3d &P1, Vec3d &p2) const;
        
        const CCameraParameters& GetCameraParameters() const { return m_cameraParameters; }
        

        bool LoadCameraParameters(const char *pCameraParameterFileName, int nCamera = 0, bool bSetExtrinsicToIdentity = false);
        
        bool SaveCameraParameters(const char *pCameraParameterFileName) const;
        
        void PrintCameraParameters() const;
        
        
        void WorldToImageCoordinates(const Vec3d &worldPoint, Vec2d &imagePoint, bool bUseDistortionParameters = true) const;
        
        void ImageToWorldCoordinates(const Vec2d &imagePoint, Vec3d &worldPoint, float zc = 1.0f, bool bUseDistortionParameters = true) const;
        
        
        void WorldToCameraCoordinates(const Vec3d &worldPoint, Vec3d &cameraPoint) const;
        
        void CameraToWorldCoordinates(const Vec3d &cameraPoint, Vec3d &worldPoint) const;

        
        void CameraToImageCoordinates(const Vec3d &cameraPoint, Vec2d &imagePoint, bool bUseDistortionParameters = true) const;
        
        void ImageToCameraCoordinates(const Vec2d &imagePoint, Vec3d &cameraPoint, float zc = 1.0f, bool bUseDistortionParameters = true) const;
        
        
        void UndistortImageCoordinates(const Vec2d &distortedImagePoint, Vec2d &undistortedImagePoint) const;
        
        void DistortImageCoordinates(const Vec2d &undistortedImagePoint, Vec2d &distortedImagePoint) const;
        
        
        void UndistortCameraCoordinates(const Vec2d &distortedCameraPoint, Vec2d &undistortedCameraPoint) const;
        
        void DistortCameraCoordinates(const Vec2d &undistortedCameraPoint, Vec2d &distortedCameraPoint) const;
        
        void GetCameraCoordinates(const Vec3d &worldPoint, Vec2d &imagePoint, bool bUseDistortionParameters = true) const;
        
        void GetWorldCoordinates(const Vec2d &imagePoint, Vec3d &worldPoint, float zc = 1.0f, bool bUseDistortionParameters = true) const;
        
        
        Mat3d m_rotation_inverse;
        
        Vec3d m_translation_inverse;


private:
        // private methods
        void CalculateInverseTransformation();
        void CalculateRadialLensDistortion();
        
        // private attributes

        // intrinsic camera parameters
        CCameraParameters m_cameraParameters;
};



#endif /* _CALIBRATION_H_ */