Move contrib charuco to main objdetect

apps/interactive-calibration/CMakeLists.txt

@@ -1,6 +1,3 @@
-set(DEPS opencv_core opencv_imgproc opencv_features2d opencv_highgui opencv_calib3d opencv_videoio)
-if(${BUILD_opencv_aruco})
-    list(APPEND DEPS opencv_aruco)
-endif()
+set(DEPS opencv_core opencv_imgproc opencv_features2d opencv_highgui opencv_calib3d opencv_videoio opencv_objdetect)
 file(GLOB SRCS *.cpp)
 ocv_add_application(opencv_interactive-calibration MODULES ${DEPS} SRCS ${SRCS})

apps/interactive-calibration/calibController.cpp

@@ -219,10 +219,10 @@ void calib::calibDataController::filterFrames()
         if(mCalibData->imagePoints.size()) {
             mCalibData->imagePoints.erase(mCalibData->imagePoints.begin() + worstElemIndex);
             mCalibData->objectPoints.erase(mCalibData->objectPoints.begin() + worstElemIndex);
-        }
-        else {
-            mCalibData->allCharucoCorners.erase(mCalibData->allCharucoCorners.begin() + worstElemIndex);
-            mCalibData->allCharucoIds.erase(mCalibData->allCharucoIds.begin() + worstElemIndex);
+            if (mCalibData->allCharucoCorners.size()) {
+                mCalibData->allCharucoCorners.erase(mCalibData->allCharucoCorners.begin() + worstElemIndex);
+                mCalibData->allCharucoIds.erase(mCalibData->allCharucoIds.begin() + worstElemIndex);
+            }
         }
 
         cv::Mat newErrorsVec = cv::Mat((int)numberOfFrames - 1, 1, CV_64F);

apps/interactive-calibration/frameProcessor.cpp

@@ -11,7 +11,6 @@
 
 #include <vector>
 #include <string>
-#include <algorithm>
 #include <limits>
 
 using namespace calib;
@@ -74,17 +73,12 @@ bool CalibProcessor::detectAndParseChessboard(const cv::Mat &frame)
 
 bool CalibProcessor::detectAndParseChAruco(const cv::Mat &frame)
 {
-#ifdef HAVE_OPENCV_ARUCO
     cv::Ptr<cv::aruco::Board> board = mCharucoBoard.staticCast<cv::aruco::Board>();
 
     std::vector<std::vector<cv::Point2f> > corners, rejected;
     std::vector<int> ids;
-    cv::aruco::detectMarkers(frame, cv::makePtr<cv::aruco::Dictionary>(mArucoDictionary), corners, ids, cv::makePtr<cv::aruco::DetectorParameters>(), rejected);
-    cv::aruco::refineDetectedMarkers(frame, board, corners, ids, rejected);
     cv::Mat currentCharucoCorners, currentCharucoIds;
-    if(ids.size() > 0)
-        cv::aruco::interpolateCornersCharuco(corners, ids, frame, mCharucoBoard, currentCharucoCorners,
-                                         currentCharucoIds);
+    detector->detectBoard(frame, currentCharucoCorners, currentCharucoIds, corners, ids);
     if(ids.size() > 0) cv::aruco::drawDetectedMarkers(frame, corners);
 
     if(currentCharucoCorners.total() > 3) {
@@ -102,9 +96,6 @@ bool CalibProcessor::detectAndParseChAruco(const cv::Mat &frame)
         mCurrentCharucoIds = currentCharucoIds;
         return true;
     }
-#else
-    CV_UNUSED(frame);
-#endif
     return false;
 }
 
@@ -155,6 +146,7 @@ bool CalibProcessor::detectAndParseDualACircles(const cv::Mat &frame)
 void CalibProcessor::saveFrameData()
 {
     std::vector<cv::Point3f> objectPoints;
+    std::vector<cv::Point2f> imagePoints;
 
     switch(mBoardType)
     {
@@ -169,6 +161,11 @@ void CalibProcessor::saveFrameData()
     case chAruco:
         mCalibData->allCharucoCorners.push_back(mCurrentCharucoCorners);
         mCalibData->allCharucoIds.push_back(mCurrentCharucoIds);
+
+        mCharucoBoard->matchImagePoints(mCurrentCharucoCorners, mCurrentCharucoIds, objectPoints, imagePoints);
+        CV_Assert(mCurrentCharucoIds.total() == imagePoints.size());
+        mCalibData->imagePoints.push_back(imagePoints);
+        mCalibData->objectPoints.push_back(objectPoints);
         break;
     case CirclesGrid:
         objectPoints.reserve(mBoardSize.height*mBoardSize.width);
@@ -248,37 +245,17 @@ bool CalibProcessor::checkLastFrame()
     else
         mCalibData->cameraMatrix.copyTo(tmpCamMatrix);
 
-    if(mBoardType != chAruco) {
-        cv::Mat r, t, angles;
-        cv::solvePnP(mCalibData->objectPoints.back(), mCurrentImagePoints, tmpCamMatrix, mCalibData->distCoeffs, r, t);
-        RodriguesToEuler(r, angles, CALIB_DEGREES);
-
-        if(fabs(angles.at<double>(0)) > badAngleThresh || fabs(angles.at<double>(1)) > badAngleThresh) {
-            mCalibData->objectPoints.pop_back();
-            mCalibData->imagePoints.pop_back();
-            isFrameBad = true;
-        }
-    }
-    else {
-#ifdef HAVE_OPENCV_ARUCO
-        cv::Mat r, t, angles;
-        std::vector<cv::Point3f> allObjPoints;
-        allObjPoints.reserve(mCurrentCharucoIds.total());
-        for(size_t i = 0; i < mCurrentCharucoIds.total(); i++) {
-            int pointID = mCurrentCharucoIds.at<int>((int)i);
-            CV_Assert(pointID >= 0 && pointID < (int)mCharucoBoard->getChessboardCorners().size());
-            allObjPoints.push_back(mCharucoBoard->getChessboardCorners()[pointID]);
-        }
-
-        cv::solvePnP(allObjPoints, mCurrentCharucoCorners, tmpCamMatrix, mCalibData->distCoeffs, r, t);
-        RodriguesToEuler(r, angles, CALIB_DEGREES);
-
-        if(180.0 - fabs(angles.at<double>(0)) > badAngleThresh || fabs(angles.at<double>(1)) > badAngleThresh) {
-            isFrameBad = true;
+    cv::Mat r, t, angles;
+    cv::solvePnP(mCalibData->objectPoints.back(), mCalibData->imagePoints.back(), tmpCamMatrix, mCalibData->distCoeffs, r, t);
+    RodriguesToEuler(r, angles, CALIB_DEGREES);
+    if(fabs(angles.at<double>(0)) > badAngleThresh || fabs(angles.at<double>(1)) > badAngleThresh) {
+        mCalibData->objectPoints.pop_back();
+        mCalibData->imagePoints.pop_back();
+        if (mCalibData->allCharucoCorners.size()) {
             mCalibData->allCharucoCorners.pop_back();
             mCalibData->allCharucoIds.pop_back();
         }
-#endif
+        isFrameBad = true;
     }
     return isFrameBad;
 }
@@ -295,15 +272,16 @@ CalibProcessor::CalibProcessor(cv::Ptr<calibrationData> data, captureParameters
     mTemplDist = capParams.templDst;
     mSaveFrames = capParams.saveFrames;
     mZoom = capParams.zoom;
+    cv::aruco::CharucoParameters charucoParameters;
+    charucoParameters.tryRefineMarkers = true;
 
     switch(mBoardType)
     {
     case chAruco:
-#ifdef HAVE_OPENCV_ARUCO
         mArucoDictionary = cv::aruco::getPredefinedDictionary(cv::aruco::PredefinedDictionaryType(capParams.charucoDictName));
-        mCharucoBoard = cv::aruco::CharucoBoard::create(mBoardSize.width, mBoardSize.height, capParams.charucoSquareLength,
-                                                        capParams.charucoMarkerSize, mArucoDictionary);
-#endif
+        mCharucoBoard = cv::makePtr<cv::aruco::CharucoBoard>(cv::Size(mBoardSize.width + 1, mBoardSize.height + 1), capParams.charucoSquareLength,
+                                                    capParams.charucoMarkerSize, mArucoDictionary);
+        detector = cv::makePtr<cv::aruco::CharucoDetector>(cv::aruco::CharucoDetector(*mCharucoBoard, charucoParameters));
         break;
     case CirclesGrid:
     case AcirclesGrid:

apps/interactive-calibration/frameProcessor.hpp

@@ -7,9 +7,7 @@
 
 #include <opencv2/core.hpp>
 #include <opencv2/calib3d.hpp>
-#ifdef HAVE_OPENCV_ARUCO
-#include <opencv2/aruco/charuco.hpp>
-#endif
+#include <opencv2/objdetect.hpp>
 
 #include "calibCommon.hpp"
 #include "calibController.hpp"
@@ -39,10 +37,9 @@ class CalibProcessor : public FrameProcessor
     cv::Mat mCurrentCharucoIds;
 
     cv::Ptr<cv::SimpleBlobDetector> mBlobDetectorPtr;
-#ifdef HAVE_OPENCV_ARUCO
     cv::aruco::Dictionary mArucoDictionary;
     cv::Ptr<cv::aruco::CharucoBoard> mCharucoBoard;
-#endif
+    cv::Ptr<cv::aruco::CharucoDetector> detector;
 
     int mNeededFramesNum;
     unsigned mDelayBetweenCaptures;

apps/interactive-calibration/main.cpp

@@ -7,9 +7,6 @@
 #include <opencv2/cvconfig.h>
 #include <opencv2/highgui.hpp>
 
-#ifdef HAVE_OPENCV_ARUCO
-#include <opencv2/aruco/charuco.hpp>
-#endif
 
 #include <string>
 #include <vector>
@@ -105,11 +102,6 @@ int main(int argc, char** argv)
 
     captureParameters capParams = paramsController.getCaptureParameters();
     internalParameters intParams = paramsController.getInternalParameters();
-#ifndef HAVE_OPENCV_ARUCO
-    if(capParams.board == chAruco)
-        CV_Error(cv::Error::StsNotImplemented, "Aruco module is disabled in current build configuration."
-                                               " Consider usage of another calibration pattern\n");
-#endif
 
     cv::TermCriteria solverTermCrit = cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS,
                                                        intParams.solverMaxIters, intParams.solverEps);
@@ -170,29 +162,12 @@ int main(int argc, char** argv)
                 globalData->imageSize = pipeline->getImageSize();
                 calibrationFlags = controller->getNewFlags();
 
-                if(capParams.board != chAruco) {
-                    globalData->totalAvgErr =
-                            cv::calibrateCamera(globalData->objectPoints, globalData->imagePoints,
-                                                    globalData->imageSize, globalData->cameraMatrix,
-                                                    globalData->distCoeffs, cv::noArray(), cv::noArray(),
-                                                    globalData->stdDeviations, cv::noArray(), globalData->perViewErrors,
-                                                    calibrationFlags, solverTermCrit);
-                }
-                else {
-#ifdef HAVE_OPENCV_ARUCO
-                    cv::aruco::Dictionary dictionary =
-                            cv::aruco::getPredefinedDictionary(cv::aruco::PredefinedDictionaryType(capParams.charucoDictName));
-                    cv::Ptr<cv::aruco::CharucoBoard> charucoboard =
-                                cv::aruco::CharucoBoard::create(capParams.boardSize.width, capParams.boardSize.height,
-                                                                capParams.charucoSquareLength, capParams.charucoMarkerSize, dictionary);
-                    globalData->totalAvgErr =
-                            cv::aruco::calibrateCameraCharuco(globalData->allCharucoCorners, globalData->allCharucoIds,
-                                                           charucoboard, globalData->imageSize,
-                                                           globalData->cameraMatrix, globalData->distCoeffs,
-                                                           cv::noArray(), cv::noArray(), globalData->stdDeviations, cv::noArray(),
-                                                           globalData->perViewErrors, calibrationFlags, solverTermCrit);
-#endif
-                }
+                globalData->totalAvgErr =
+                        cv::calibrateCamera(globalData->objectPoints, globalData->imagePoints,
+                                            globalData->imageSize, globalData->cameraMatrix,
+                                            globalData->distCoeffs, cv::noArray(), cv::noArray(),
+                                            globalData->stdDeviations, cv::noArray(), globalData->perViewErrors,
+                                            calibrationFlags, solverTermCrit);
                 dataController->updateUndistortMap();
                 dataController->printParametersToConsole(std::cout);
                 controller->updateState();

apps/interactive-calibration/parametersController.cpp

@@ -109,6 +109,7 @@ bool calib::parametersController::loadFromParser(cv::CommandLineParser &parser)
 
     std::string templateType = parser.get<std::string>("t");
 
+
     if(templateType.find("symcircles", 0) == 0) {
         mCapParams.board = CirclesGrid;
         mCapParams.boardSize = cv::Size(4, 11);
@@ -127,7 +128,7 @@ bool calib::parametersController::loadFromParser(cv::CommandLineParser &parser)
     }
     else if(templateType.find("charuco", 0) == 0) {
         mCapParams.board = chAruco;
-        mCapParams.boardSize = cv::Size(6, 8);
+        mCapParams.boardSize = cv::Size(5, 7);
         mCapParams.charucoDictName = 0;
         mCapParams.charucoSquareLength = 200;
         mCapParams.charucoMarkerSize = 100;

modules/objdetect/include/opencv2/objdetect.hpp

@@ -105,6 +105,26 @@ using a Boosted Cascade of Simple Features. IEEE CVPR, 2001. The paper is availa
     @defgroup objdetect_dnn_face DNN-based face detection and recognition
 Check @ref tutorial_dnn_face "the corresponding tutorial" for more details.
     @defgroup objdetect_common Common functions and classes
+    @defgroup objdetect_aruco ArUco markers and boards detection for robust camera pose estimation
+    @{
+        ArUco Marker Detection
+        Square fiducial markers (also known as Augmented Reality Markers) are useful for easy,
+        fast and robust camera pose estimation.
+
+        The main functionality of ArucoDetector class is detection of markers in an image. If the markers are grouped
+        as a board, then you can try to recover the missing markers with ArucoDetector::refineDetectedMarkers().
+        ArUco markers can also be used for advanced chessboard corner finding. To do this, group the markers in the
+        CharucoBoard and find the corners of the chessboard with the CharucoDetector::detectBoard().
+
+        The implementation is based on the ArUco Library by R. Muñoz-Salinas and S. Garrido-Jurado @cite Aruco2014.
+
+        Markers can also be detected based on the AprilTag 2 @cite wang2016iros fiducial detection method.
+
+        @sa @cite Aruco2014
+        This code has been originally developed by Sergio Garrido-Jurado as a project
+        for Google Summer of Code 2015 (GSoC 15).
+    @}
+
 @}
  */
 
@@ -852,5 +872,6 @@ class CV_EXPORTS_W QRCodeDetector
 #include "opencv2/objdetect/detection_based_tracker.hpp"
 #include "opencv2/objdetect/face.hpp"
 #include "opencv2/objdetect/aruco_detector.hpp"
+#include "opencv2/objdetect/charuco_detector.hpp"
 
 #endif