aruco_detector.hpp

// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#ifndef OPENCV_OBJDETECT_ARUCO_DETECTOR_HPP
#define OPENCV_OBJDETECT_ARUCO_DETECTOR_HPP
 
#include <opencv2/objdetect/aruco_dictionary.hpp>
#include <opencv2/objdetect/aruco_board.hpp>
 
namespace cv {
namespace aruco {
 
 
enum CornerRefineMethod{
    CORNER_REFINE_NONE,     
    CORNER_REFINE_SUBPIX,   
    CORNER_REFINE_CONTOUR,  
    CORNER_REFINE_APRILTAG, 
};
 
struct CV_EXPORTS_W_SIMPLE DetectorParameters {
    CV_WRAP DetectorParameters() {
        adaptiveThreshWinSizeMin = 3;
        adaptiveThreshWinSizeMax = 23;
        adaptiveThreshWinSizeStep = 10;
        adaptiveThreshConstant = 7;
        minMarkerPerimeterRate = 0.03;
        maxMarkerPerimeterRate = 4.;
        polygonalApproxAccuracyRate = 0.03;
        minCornerDistanceRate = 0.05;
        minDistanceToBorder = 3;
        minMarkerDistanceRate = 0.125;
        cornerRefinementMethod = (int)CORNER_REFINE_NONE;
        cornerRefinementWinSize = 5;
        relativeCornerRefinmentWinSize = 0.3f;
        cornerRefinementMaxIterations = 30;
        cornerRefinementMinAccuracy = 0.1;
        markerBorderBits = 1;
        perspectiveRemovePixelPerCell = 4;
        perspectiveRemoveIgnoredMarginPerCell = 0.13;
        maxErroneousBitsInBorderRate = 0.35;
        minOtsuStdDev = 5.0;
        errorCorrectionRate = 0.6;
        aprilTagQuadDecimate = 0.0;
        aprilTagQuadSigma = 0.0;
        aprilTagMinClusterPixels = 5;
        aprilTagMaxNmaxima = 10;
        aprilTagCriticalRad = (float)(10* CV_PI /180);
        aprilTagMaxLineFitMse = 10.0;
        aprilTagMinWhiteBlackDiff = 5;
        aprilTagDeglitch = 0;
        detectInvertedMarker = false;
        useAruco3Detection = false;
        minSideLengthCanonicalImg = 32;
        minMarkerLengthRatioOriginalImg = 0.0;
    }
 
    CV_WRAP bool readDetectorParameters(const FileNode& fn);
 
    CV_WRAP bool writeDetectorParameters(FileStorage& fs, const String& name = String());
 
    CV_PROP_RW int adaptiveThreshWinSizeMin;
 
    CV_PROP_RW int adaptiveThreshWinSizeMax;
 
    CV_PROP_RW int adaptiveThreshWinSizeStep;
 
    CV_PROP_RW double adaptiveThreshConstant;
 
    CV_PROP_RW double minMarkerPerimeterRate;
 
    CV_PROP_RW double maxMarkerPerimeterRate;
 
    CV_PROP_RW double polygonalApproxAccuracyRate;
 
    CV_PROP_RW double minCornerDistanceRate;
 
    CV_PROP_RW int minDistanceToBorder;
 
    CV_PROP_RW double minMarkerDistanceRate;
 
    CV_PROP_RW float minGroupDistance = 0.21f;
 
    CV_PROP_RW int cornerRefinementMethod;
 
    CV_PROP_RW int cornerRefinementWinSize;
 
    CV_PROP_RW float relativeCornerRefinmentWinSize;
 
    CV_PROP_RW int cornerRefinementMaxIterations;
 
    CV_PROP_RW double cornerRefinementMinAccuracy;
 
    CV_PROP_RW int markerBorderBits;
 
    CV_PROP_RW int perspectiveRemovePixelPerCell;
 
    CV_PROP_RW double perspectiveRemoveIgnoredMarginPerCell;
 
    CV_PROP_RW double maxErroneousBitsInBorderRate;
 
    CV_PROP_RW double minOtsuStdDev;
 
    CV_PROP_RW double errorCorrectionRate;
 
    CV_PROP_RW float aprilTagQuadDecimate;
 
    CV_PROP_RW float aprilTagQuadSigma;
 
    // April :: Internal variables
    CV_PROP_RW int aprilTagMinClusterPixels;
 
    CV_PROP_RW int aprilTagMaxNmaxima;
 
    CV_PROP_RW float aprilTagCriticalRad;
 
    CV_PROP_RW float aprilTagMaxLineFitMse;
 
    CV_PROP_RW int aprilTagMinWhiteBlackDiff;
 
    CV_PROP_RW int aprilTagDeglitch;
 
    CV_PROP_RW bool detectInvertedMarker;
 
    CV_PROP_RW bool useAruco3Detection;
 
    CV_PROP_RW int minSideLengthCanonicalImg;
 
    CV_PROP_RW float minMarkerLengthRatioOriginalImg;
};
 
struct CV_EXPORTS_W_SIMPLE RefineParameters {
    CV_WRAP RefineParameters(float minRepDistance = 10.f, float errorCorrectionRate = 3.f, bool checkAllOrders = true);
 
 
    CV_WRAP bool readRefineParameters(const FileNode& fn);
 
    CV_WRAP bool writeRefineParameters(FileStorage& fs, const String& name = String());
 
    CV_PROP_RW float minRepDistance;
 
    CV_PROP_RW float errorCorrectionRate;
 
    CV_PROP_RW bool checkAllOrders;
};
 
class CV_EXPORTS_W ArucoDetector : public Algorithm
{
public:
    CV_WRAP ArucoDetector(const Dictionary &dictionary = getPredefinedDictionary(cv::aruco::DICT_4X4_50),
                          const DetectorParameters &detectorParams = DetectorParameters(),
                          const RefineParameters& refineParams = RefineParameters());
 
    CV_WRAP void detectMarkers(InputArray image, OutputArrayOfArrays corners, OutputArray ids,
                               OutputArrayOfArrays rejectedImgPoints = noArray()) const;
 
    CV_WRAP void refineDetectedMarkers(InputArray image, const Board &board,
                                       InputOutputArrayOfArrays detectedCorners,
                                       InputOutputArray detectedIds, InputOutputArrayOfArrays rejectedCorners,
                                       InputArray cameraMatrix = noArray(), InputArray distCoeffs = noArray(),
                                       OutputArray recoveredIdxs = noArray()) const;
 
    CV_WRAP const Dictionary& getDictionary() const;
    CV_WRAP void setDictionary(const Dictionary& dictionary);
 
    CV_WRAP const DetectorParameters& getDetectorParameters() const;
    CV_WRAP void setDetectorParameters(const DetectorParameters& detectorParameters);
 
    CV_WRAP const RefineParameters& getRefineParameters() const;
    CV_WRAP void setRefineParameters(const RefineParameters& refineParameters);
 
    virtual void write(FileStorage& fs) const override;
 
    CV_WRAP inline void write(FileStorage& fs, const String& name) { Algorithm::write(fs, name); }
 
    CV_WRAP virtual void read(const FileNode& fn) override;
protected:
    struct ArucoDetectorImpl;
    Ptr<ArucoDetectorImpl> arucoDetectorImpl;
};
 
CV_EXPORTS_W void drawDetectedMarkers(InputOutputArray image, InputArrayOfArrays corners,
                                      InputArray ids = noArray(), Scalar borderColor = Scalar(0, 255, 0));
 
CV_EXPORTS_W void generateImageMarker(const Dictionary &dictionary, int id, int sidePixels, OutputArray img,
                                      int borderBits = 1);
 
 
}
}
 
#endif