markerdetector.h

Go to the documentation of this file.

/*****************************
Copyright 2011 Rafael Muñoz Salinas. 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.

THIS SOFTWARE IS PROVIDED BY Rafael Muñoz Salinas ''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 Rafael Muñoz Salinas 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.

The views and conclusions contained in the software and documentation are those of the
authors and should not be interpreted as representing official policies, either expressed
or implied, of Rafael Muñoz Salinas.
********************************/
#ifndef _ARUCO_MarkerDetector_H
#define _ARUCO_MarkerDetector_H
#include <opencv2/core/core.hpp>
#include <cstdio>
#include <iostream>
#include "exports.h"
#include "cameraparameters.h"
#include "dictionary.h"
#include "marker.h"
#include "markerlabeler.h"
using namespace std;

namespace aruco {
class ARUCO_EXPORTS MarkerDetector {

public:

    enum CornerRefinementMethod { NONE,   SUBPIX, LINES };

    enum ThresholdMethods { FIXED_THRES, ADPT_THRES, CANNY };

    struct Params{
        //method emplpoyed for image threshold
        ThresholdMethods _thresMethod;
        // Threshold parameters
        double _thresParam1, _thresParam2, _thresParam1_range;

        // Current corner method
        CornerRefinementMethod _cornerMethod;
        //when using subpix, this indicates the search range for optimization (in pixels)
        int _subpix_wsize;
        //size of the image passed to the MarkerLabeler
        int _markerWarpSize;
        // border around image limits in which corners are not allowed to be detected. (0,1)
        float _borderDistThres;

        // minimum and maximum size of a contour lenght. We use the following formula
        // minLenght=  min ( _minSize_pix , _minSize* Is)*4
        // maxLenght=    _maxSize* Is*4
        // being Is=max(imageWidth,imageHeight)
        //the values  _minSize and _maxSize are normalized, thus, depends on camera image size
        //However, _minSize_pix is expressed in pixels and  prevents a marker large enough, but relatively small to the image dimensions
        //to be discarded. For instance, imagine a image of 6000x6000 and a marker of 100x100 in it.
        // The marker is visible, but relatively small, so, we set a minimum size expressed in pixels to avoid discarding it
        float _minSize, _maxSize;
        int _minSize_pix ;
        Params(){
            _thresMethod = ADPT_THRES;
            _thresParam1 = _thresParam2 = 7;
            _cornerMethod = LINES;

            _thresParam1_range = 0;
            _markerWarpSize = 56;

            _minSize = 0.04;_maxSize = 0.5;_minSize_pix=25;
            _borderDistThres = 0.005; // corners at a distance from image boundary nearer than 2.5% of image are ignored
            _subpix_wsize=5;//window size employed for subpixel search (in vase you use _cornerMethod=SUBPIX
        }

    };

    MarkerDetector();

    ~MarkerDetector();
    std::vector<aruco::Marker> detect(const cv::Mat &input) throw(cv::Exception);
    std::vector<aruco::Marker> detect(const cv::Mat &input,const CameraParameters &camParams, float markerSizeMeters , bool setYPerperdicular = false) throw(cv::Exception);

    void detect(const cv::Mat &input, std::vector< Marker > &detectedMarkers, CameraParameters camParams, float markerSizeMeters = -1,
                bool setYPerperdicular = false) throw(cv::Exception);


    void detect(const cv::Mat &input, std::vector< Marker > &detectedMarkers, cv::Mat camMatrix = cv::Mat(), cv::Mat distCoeff = cv::Mat(),
                float markerSizeMeters = -1, bool setYPerperdicular = false) throw(cv::Exception);

    void setParams(Params p){_params =p;}
    Params getParams()const {return _params;}
    void setDictionary(std::string dict_type,float error_correction_rate=0)throw(cv::Exception);

    void setDictionary(Dictionary::DICT_TYPES dict_type,float error_correction_rate=0)throw(cv::Exception);


    const cv::Mat &getThresholdedImage() { return thres; }


    //Below this point, you are most probably not interested
    //--- deprecated accesor modifiers ue the new setParams() and getParams() methods instead
    void setThresholdMethod(ThresholdMethods m) { _params._thresMethod = m; }
    ThresholdMethods getThresholdMethod() const { return _params._thresMethod; }
    void setThresholdParams(double param1, double param2) {
        _params._thresParam1 = param1;
        _params._thresParam2 = param2;
    }

    void setThresholdParamRange(size_t r1 = 0, size_t r2 = 0) {_params. _thresParam1_range = r1; (void)(r2); }

    void getThresholdParams(double &param1, double &param2) const {
        param1 = _params._thresParam1;
        param2 = _params._thresParam2;
    }



    void setCornerRefinementMethod(CornerRefinementMethod method,int val=-1) { _params._cornerMethod = method; if (val!=-1)_params._subpix_wsize=val;}
    CornerRefinementMethod getCornerRefinementMethod() const { return _params._cornerMethod; }
    void setMinMaxSize(float min = 0.03, float max = 0.5) throw(cv::Exception){
    if (min <= 0 || min > 1)        throw cv::Exception(1, " min parameter out of range", "MarkerDetector::setMinMaxSize", __FILE__, __LINE__);
    if (max <= 0 || max > 1)        throw cv::Exception(1, " max parameter out of range", "MarkerDetector::setMinMaxSize", __FILE__, __LINE__);
    if (min > max)        throw cv::Exception(1, " min>max", "MarkerDetector::setMinMaxSize", __FILE__, __LINE__);
    _params._minSize = min;
    _params._maxSize = max;
    }


    void getMinMaxSize(float &min, float &max) {
        min = _params._minSize;
        max = _params._maxSize;
    }


    void setDesiredSpeed(int val){(void)(val);}
    int getDesiredSpeed() const { return 0; }

    void setWarpSize(int val) throw(cv::Exception){
        if (val < 10)
            throw cv::Exception(1, " invalid canonical image size", "MarkerDetector::setWarpSize", __FILE__, __LINE__);
        _params._markerWarpSize = val;
    };
    int getWarpSize() const { return _params._markerWarpSize; }








    void setMarkerLabeler(cv::Ptr<MarkerLabeler> detector)throw(cv::Exception);
    cv::Ptr<MarkerLabeler>     getMarkerLabeler()throw(cv::Exception){ return markerIdDetector;}
    // Represent a candidate to be a maker
    class MarkerCandidate : public Marker {
      public:
        MarkerCandidate() {}
        MarkerCandidate(const Marker &M) : Marker(M) {}
        MarkerCandidate(const MarkerCandidate &M) : Marker(M) {
            contour = M.contour;
            idx = M.idx;
        }
        MarkerCandidate &operator=(const MarkerCandidate &M) {
            (*(Marker *)this) = (*(Marker *)&M);
            contour = M.contour;
            idx = M.idx;
            return *this;
        }

        vector< cv::Point > contour; // all the points of its contour
        int idx; // index position in the global contour list
    };

    void thresHold(int method, const cv::Mat &grey, cv::Mat &thresImg, double param1 = -1, double param2 = -1) throw(cv::Exception);
    void  adpt_threshold_multi(const cv::Mat &grey, std::vector<cv::Mat> &out, double param1  , double param1_range , double param2,double param2_range=0 );
    void detectRectangles(const cv::Mat &thresImg, vector< std::vector< cv::Point2f > > &candidates);

    const vector< std::vector< cv::Point2f > > &getCandidates() { return _candidates; }

    bool warp(cv::Mat &in, cv::Mat &out, cv::Size size, std::vector< cv::Point2f > points) throw(cv::Exception);



    void refineCandidateLines(MarkerCandidate &candidate, const cv::Mat &camMatrix, const cv::Mat &distCoeff);




  private:
    bool warp_cylinder(cv::Mat &in, cv::Mat &out, cv::Size size, MarkerCandidate &mc) throw(cv::Exception);
    void detectRectangles(vector< cv::Mat > &vimages, vector< MarkerCandidate > &candidates);
    //operating params
    Params _params;
    // vectr of candidates to be markers. This is a vector with a set of rectangles that have no valid id
    vector< std::vector< cv::Point2f > > _candidates;
    // Images
    cv::Mat grey, thres;
    // pointer to the function that analizes a rectangular region so as to detect its internal marker
    cv::Ptr<MarkerLabeler> markerIdDetector;

    bool isInto(cv::Mat &contour, std::vector< cv::Point2f > &b);
    int perimeter(std::vector< cv::Point2f > &a);

     // auxiliar functions to perform LINES refinement
    void interpolate2Dline(const vector< cv::Point2f > &inPoints, cv::Point3f &outLine);
    cv::Point2f getCrossPoint(const cv::Point3f &line1, const cv::Point3f &line2);
    void distortPoints(vector< cv::Point2f > in, vector< cv::Point2f > &out, const cv::Mat &camMatrix, const cv::Mat &distCoeff);


    template < typename T > void removeElements(vector< T > &vinout, const vector< bool > &toRemove) {
        // remove the invalid ones by setting the valid in the positions left by the invalids
        size_t indexValid = 0;
        for (size_t i = 0; i < toRemove.size(); i++) {
            if (!toRemove[i]) {
                if (indexValid != i)
                    vinout[indexValid] = vinout[i];
                indexValid++;
            }
        }
        vinout.resize(indexValid);
    }

    // graphical debug
    void drawApproxCurve(cv::Mat &in, std::vector< cv::Point > &approxCurve, cv::Scalar color);
    void drawContour(cv::Mat &in, std::vector< cv::Point > &contour, cv::Scalar);
    void drawAllContours(cv::Mat input, std::vector< std::vector< cv::Point > > &contours);
    void draw(cv::Mat out, const std::vector< Marker > &markers);
    // method to refine corner detection in case the internal border after threshold is found
    // This was tested in the context of chessboard methods
    void findCornerMaxima(vector< cv::Point2f > &Corners, const cv::Mat &grey, int wsize);



    template < typename T > void joinVectors(vector< vector< T > > &vv, vector< T > &v, bool clearv = false) {
        if (clearv)
            v.clear();
        for (size_t i = 0; i < vv.size(); i++)
            for (size_t j = 0; j < vv[i].size(); j++)
                v.push_back(vv[i][j]);
    }

    vector<cv::Mat > imagePyramid;
};
};
#endif