mitkCameraCalibrationFacade.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef mitkCameraCalibrationFacade_h
#define mitkCameraCalibrationFacade_h

#include "niftkOpenCVExports.h"
#include <mitkOpenCVPointTypes.h>
#include <mitkPoint.h>

#include <cv.h>
#include <cstdlib>
#include <iostream>
#include <mitkVector.h>

namespace mitk {

extern "C++" NIFTKOPENCV_EXPORT void LoadImages(const std::vector<std::string>& files,
  std::vector<IplImage*>& images,
  std::vector<std::string>& fileNames
  );


extern "C++" NIFTKOPENCV_EXPORT void LoadImagesFromDirectory(
  const std::string& fullDirectoryName,
  std::vector<IplImage*>& images,
  std::vector<std::string>& fileNames
  );


extern "C++" NIFTKOPENCV_EXPORT bool CheckAndAppendPairOfFileNames(const std::string& leftFileName, const std::string& rightFileName,
                                   const int& numberCornersX,
                                   const int& numberCornersY,
                                   const double& sizeSquareMillimeters,
                                   const mitk::Point2D& pixelScaleFactor,
                                   std::vector<std::string>& successfulLeftFiles, std::vector<std::string>& successfulRightFiles
                                   );


extern "C++" NIFTKOPENCV_EXPORT void CheckConstImageSize(
  const std::vector<IplImage*>& images, int& width, int& height
  );


extern "C++" NIFTKOPENCV_EXPORT void ExtractChessBoardPoints(
  const std::vector<IplImage*>& images,
  const std::vector<std::string>& fileNames,
  const int& numberCornersWidth,
  const int& numberCornersHeight,
  const bool& drawCorners,
  const double& squareSizeInMillimetres,
  const mitk::Point2D& pixelScaleFactor,
  std::vector<IplImage*>& outputImages,
  std::vector<std::string>& outputFileNames,
  CvMat*& outputImagePoints,
  CvMat*& outputObjectPoints,
  CvMat*& outputPointCounts
  );


extern "C++" NIFTKOPENCV_EXPORT bool ExtractChessBoardPoints(
  const cv::Mat& image,
  const int& numberCornersWidth,
  const int& numberCornersHeight,
  const bool& drawCorners,
  const double& squareSizeInMillimetres,
  const mitk::Point2D& pixelScaleFactor,
  std::vector<cv::Point2d>& outputImagePoints,
  std::vector<cv::Point3d>& outputObjectPoints
  );


extern "C++" NIFTKOPENCV_EXPORT double CalibrateSingleCameraParameters(
  const CvMat& objectPoints,
  const CvMat& imagePoints,
  const CvMat& pointCounts,
  const CvSize& imageSize,
  CvMat& outputIntrinsicMatrix,
  CvMat& outputDistortionCoefficients,
  CvMat* outputRotationVectors,
  CvMat* outputTranslationVectors,
  const int& flags=0
  );


extern "C++" NIFTKOPENCV_EXPORT double CalibrateSingleCameraUsingMultiplePasses(
  const CvMat& objectPoints,
  const CvMat& imagePoints,
  const CvMat& pointCounts,
  const CvSize& imageSize,
  CvMat& outputIntrinsicMatrix,
  CvMat& outputDistortionCoefficients,
  CvMat& outputRotationVectors,
  CvMat& outputTranslationVectors
  );


extern "C++" NIFTKOPENCV_EXPORT void CalibrateSingleCameraExtrinsics(
  const CvMat& objectPoints,
  const CvMat& imagePoints,
  const CvMat& pointCounts,
  const CvMat& intrinsicMatrix,
  const CvMat& distortionCoefficients,
  const bool& useExtrinsicGuess,
  CvMat& outputRotationVectors,
  CvMat& outputTranslationVectors
  );


extern "C++" NIFTKOPENCV_EXPORT void ExtractExtrinsicMatrixFromRotationAndTranslationVectors(
  const CvMat& rotationVectors,
  const CvMat& translationVectors,
  const int& viewNumber,
  CvMat& outputExtrinsicMatrix
  );


extern "C++" NIFTKOPENCV_EXPORT void ComputeRightToLeftTransformations(
  const CvMat& rotationVectorsLeft,
  const CvMat& translationVectorsLeft,
  const CvMat& rotationVectorsRight,
  const CvMat& translationVectorsRight,
  CvMat& rotationVectorsRightToLeft,
  CvMat& translationVectorsRightToLeft
  );


extern "C++" NIFTKOPENCV_EXPORT void ProjectAllPoints(
  const int& numberSuccessfulViews,
  const int& pointCount,
  const CvMat& objectPoints,
  const CvMat& intrinsicMatrix,
  const CvMat& distortionCoeffictions,
  const CvMat& rotationVectors,
  const CvMat& translationVectors,
  CvMat& outputImagePoints
  );

extern "C++" NIFTKOPENCV_EXPORT double CalculateRPE(
    const CvMat& projectedPoints,
    const CvMat& goldStandardPoints
    );

extern "C++" NIFTKOPENCV_EXPORT double CalibrateStereoCameraParameters(
  const CvMat& objectPointsLeft,
  const CvMat& imagePointsLeft,
  const CvMat& pointCountsLeft,
  const CvSize& imageSize,
  const CvMat& objectPointsRight,
  const CvMat& imagePointsRight,
  const CvMat& pointCountsRight,
  CvMat& outputIntrinsicMatrixLeft,
  CvMat& outputDistortionCoefficientsLeft,
  CvMat& outputRotationVectorsLeft,
  CvMat& outputTranslationVectorsLeft,
  CvMat& outputIntrinsicMatrixRight,
  CvMat& outputDistortionCoefficientsRight,
  CvMat& outputRotationVectorsRight,
  CvMat& outputTranslationVectorsRight,
  CvMat& outputRightToLeftRotation,
  CvMat& outputRightToLeftTranslation,
  CvMat& outputEssentialMatrix,
  CvMat& outputFundamentalMatrix,
  const bool& fixedIntrinsics = false,
  const bool& fixedRightToLeft = false
  );


extern "C++" NIFTKOPENCV_EXPORT std::vector<double> OutputCalibrationData(
  std::ostream& outputStream,
  const std::string& outputDirectoryName,
  const std::string& intrinsicFlatFileName,
  const CvMat& objectPoints,
  const CvMat& imagePoints,
  const CvMat& pointCounts,
  const CvMat& intrinsicMatrix,
  const CvMat& distortionCoefficients,
  const CvMat& rotationVectors,
  const CvMat& translationVectors,
  const double& projectionError,
  const int& sizeX,
  const int& sizeY,
  const int& cornersX,
  const int& cornersY,
  std::vector<std::string>& fileNames
  );


extern "C++" NIFTKOPENCV_EXPORT void CorrectDistortionInImageFile(
  const std::string& inputImageFileName,
  const std::string& inputIntrinsicsFileName,
  const std::string& inputDistortionCoefficientsFileName,
  const std::string& outputImageFileName
  );


extern "C++" NIFTKOPENCV_EXPORT void CorrectDistortionInImageFile(
  const std::string& inputFileName,
  const CvMat& intrinsicParams,
  const CvMat& distortionCoefficients,
  const std::string& outputFileName
  );


extern "C++" NIFTKOPENCV_EXPORT void CorrectDistortionInSingleImage(
  const CvMat& intrinsicParams,
  const CvMat& distortionCoefficients,
  IplImage &image
  );


extern "C++" NIFTKOPENCV_EXPORT void UndistortImageUsingDistortionMap(
  const IplImage &mapX,
  const IplImage &mapY,
  IplImage &image
  );


extern "C++" NIFTKOPENCV_EXPORT void ApplyDistortionCorrectionMap(
  const IplImage &mapX,
  const IplImage &mapY,
  const IplImage &inputImage,
  IplImage &outputImage
  );


extern "C++" NIFTKOPENCV_EXPORT void Project3DModelPositionsToStereo2D(
  const CvMat& modelPointsIn3D,
  const CvMat& leftCameraIntrinsic,
  const CvMat& leftCameraDistortion,
  const CvMat& leftCameraRotationVector,
  const CvMat& leftCameraTranslationVector,
  const CvMat& rightCameraIntrinsic,
  const CvMat& rightCameraDistortion,
  const CvMat& rightToLeftRotationMatrix,
  const CvMat& rightToLeftTranslationVector,
  CvMat& output2DPointsLeft,
  CvMat& output2DPointsRight,
  const bool& cropPointsToScreen = false,
  const double& xLow = 0.0 , const double& xHigh = 0.0 , 
  const double& yLow = 0.0 , const double& yHigh = 0.0 , const double& cropValue = 0.0
  );


extern "C++" NIFTKOPENCV_EXPORT std::vector<int> ProjectVisible3DWorldPointsToStereo2D(
  const CvMat& leftCameraWorldPointsIn3D,
  const CvMat& leftCameraWorldNormalsIn3D,
  const CvMat& leftCameraPositionToFocalPointUnitVector,
  const CvMat& leftCameraIntrinsic,
  const CvMat& leftCameraDistortion,
  const CvMat& rightCameraIntrinsic,
  const CvMat& rightCameraDistortion,
  const CvMat& rightToLeftRotationMatrix,
  const CvMat& rightToLeftTranslationVector,
  CvMat*& outputLeftCameraWorldPointsIn3D,
  CvMat*& outputLeftCameraWorldNormalsIn3D,
  CvMat*& output2DPointsLeft,
  CvMat*& output2DPointsRight,
  const bool& cropPointsToScreen = false,
  const double& xLow = 0.0 , const double& xHigh = 0.0 , 
  const double& yLow = 0.0 , const double& yHigh = 0.0 , const double& cropValue = 0.0
  );


extern "C++" NIFTKOPENCV_EXPORT void UndistortPoints(const cv::Mat& inputObservedPointsNx2,
  const cv::Mat& cameraIntrinsics3x3,
  const cv::Mat& cameraDistortionParams5x1,
  cv::Mat& outputIdealPointsNx2,
  const bool& cropPointsToScreen = false,
  const double& xLow = 0.0 , const double& xHigh = 0.0 , 
  const double& yLow = 0.0 , const double& yHigh = 0.0 , const double& cropValue = 0.0
  );


extern "C++" NIFTKOPENCV_EXPORT void UndistortPoints(const std::vector<cv::Point2d>& inputObservedPoints,
  const cv::Mat& cameraIntrinsics3x3,
  const cv::Mat& cameraDistortionParams5x1,
  std::vector<cv::Point2d>& outputIdealPoints,
  const bool& cropPointsToScreen = false,
  const double& xLow = 0.0 , const double& xHigh = 0.0 , 
  const double& yLow = 0.0 , const double& yHigh = 0.0 , const double& cropValue = 0.0
  );


extern "C++" NIFTKOPENCV_EXPORT void UndistortPoint(const cv::Point2d& inputObservedPoint,
  const cv::Mat& cameraIntrinsics3x3,
  const cv::Mat& cameraDistortionParams,
  cv::Point2d& outputIdealPoint,
  const bool& cropPointsToScreen = false,
  const double& xLow = 0.0 , const double& xHigh = 0.0 , 
  const double& yLow = 0.0 , const double& yHigh = 0.0 , const double& cropValue = 0.0
  );


extern "C++" NIFTKOPENCV_EXPORT std::vector< std::pair < cv::Point3d , double> > TriangulatePointPairsUsingGeometry(
  const std::vector< std::pair<cv::Point2d, cv::Point2d> >& inputUndistortedPoints,
  const cv::Mat& leftCameraIntrinsicParams,
  const cv::Mat& rightCameraIntrinsicParams,
  const cv::Mat& rightToLeftRotationMatrix,
  const cv::Mat& rightToLeftTranslationVector,
  const double& tolerance,
  const bool& preserveVectorSize = false
  );

extern "C++" NIFTKOPENCV_EXPORT std::pair< cv::Point3d, cv::Point3d > GetRay(
  const cv::Point2d& inputUndistortedPoint,
  const cv::Mat& cameraIntrinsicParams,
  const double& rayLength = 1000
  );

extern "C++" NIFTKOPENCV_EXPORT cv::Point3d TriangulatePointPairUsingGeometry(
  const std::pair<cv::Point2d, cv::Point2d> & inputUndistortedPoints,
  const cv::Mat& leftCameraIntrinsicParams,
  const cv::Mat& rightCameraIntrinsicParams,
  const cv::Mat& rightToLeftRotationMatrix,
  const cv::Mat& rightToLeftTranslationVector
  );

extern "C++" NIFTKOPENCV_EXPORT void CStyleTriangulatePointPairsUsingSVD(
  const CvMat& leftCameraUndistortedImagePoints,
  const CvMat& rightCameraUndistortedImagePoints,
  const CvMat& leftCameraIntrinsicParams,
  const CvMat& leftCameraRotationVector,
  const CvMat& leftCameraTranslationVector,
  const CvMat& rightCameraIntrinsicParams,
  const CvMat& rightCameraRotationVector,
  const CvMat& rightCameraTranslationVector,
  CvMat& output3DPoints
  );

extern "C++" NIFTKOPENCV_EXPORT std::vector < mitk::WorldPoint > Triangulate (
    const std::vector < mitk::ProjectedPointPair >& onScreenPoints,
    const cv::Mat& leftIntrinsicMatrix,
    const cv::Mat& leftDistortionVector,
    const cv::Mat& rightIntrinsicMatrix,
    const cv::Mat& rightDistorionVector,
    const cv::Mat& rightToLeftRotationMatrix,
    const cv::Mat& rightToLeftTranslationVector,
    const bool& cropPointsToScreen = false,
    const double& xLow = 0.0 , const double& xHigh = 0.0 , 
    const double& yLow = 0.0 , const double& yHigh = 0.0 , const double& cropValue = 0.0
    );

extern "C++" NIFTKOPENCV_EXPORT cv::Point3d ReProjectPoint (
    const cv::Point2d& inputUndistortedPoint, const cv::Mat& CameraIntrinsicParams);

extern "C++" NIFTKOPENCV_EXPORT std::vector< cv::Point3d > TriangulatePointPairsUsingSVD(
  const std::vector< std::pair<cv::Point2d, cv::Point2d> >& inputUndistortedPoints,
  const cv::Mat& leftCameraIntrinsicParams,
  const cv::Mat& leftCameraRotationVector,
  const cv::Mat& leftCameraTranslationVector,
  const cv::Mat& rightCameraIntrinsicParams,
  const cv::Mat& rightCameraRotationVector,
  const cv::Mat& rightCameraTranslationVector
  );


cv::Mat_<double> InternalTriangulatePointUsingSVD(
  const cv::Matx34d& P1,
  const cv::Matx34d& P2,
  const cv::Point3d& u1,
  const cv::Point3d& u2,
  const double& w1,
  const double& w2
  );


cv::Point3d InternalIterativeTriangulatePointUsingSVD(
  const cv::Matx34d& P1,
  const cv::Matx34d& P2,
  const cv::Point3d& u1,
  const cv::Point3d& u2
  );

extern "C++" NIFTKOPENCV_EXPORT void GenerateFullHandeyeMatrices (const std::string& directory);


extern "C++" NIFTKOPENCV_EXPORT void LoadResult(const std::string& Filename, cv::Mat& result,
  std::vector<double>& residuals);


extern "C++" NIFTKOPENCV_EXPORT cv::Point3f LeftLensToWorld ( cv::Point3f pointInLensCS,
  cv::Mat& handeye, cv::Mat& tracker );


extern "C++" NIFTKOPENCV_EXPORT cv::Point3f WorldToLeftLens ( cv::Point3f pointInWorldCS,
  cv::Mat& handeye, cv::Mat& tracker );

extern "C++" NIFTKOPENCV_EXPORT void CropToScreen ( const std::vector <cv::Point2d>& srcPoints,
    std::vector <cv::Point2d>& dstPoints , 
    const double& xLow, const double& xHigh, const double& yLow, const double& yHigh,
    const double& cropValue );

} // end namespace

#endif