markerdetector.h

Go to the documentation of this file.

#ifndef CV_ARUCO_H
#define CV_ARUCO_H
#include <opencv/cv.h>
#include <opencv/highgui.h>
#include <cstdio>
#include <iostream>
#include "cameraparameters.h"
#include "marker.h"
using namespace std;

namespace aruco
{

class MarkerDetector
{
public:

    MarkerDetector();

    ~MarkerDetector();

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

    enum ThresholdMethods {FIXED_THRES,ADPT_THRES,CANNY};

    void setThresholdMethod(ThresholdMethods m) {
        _thresMethod=m;
    }
    ThresholdMethods getThresholdMethod()const {
        return _thresMethod;
    }
    void setThresholdParams(double param1,double param2) {
        _thresParam1=param1;
        _thresParam2=param2;
    }
    void getThresholdParams(double &param1,double &param2)const {
        param1=_thresParam1;
        param2=_thresParam2;
    }


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


    static void glGetProjectionMatrix( CameraParameters &  CamMatrix,cv::Size orgImgSize, cv::Size size,double proj_matrix[16],double gnear,double gfar,bool invert=false   )throw(cv::Exception);
private:

    cv::Mat grey,thres,thres2;
    std::vector<std::vector<cv::Point> > contours2;
    std::vector<cv::Vec4i> hierarchy2;
    //Threshold parameters
    double _thresParam1,_thresParam2;

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

    int hammDistMarker(cv::Mat  bits);
    int mat2id(cv::Mat &bits);
    bool correctHammMarker(cv::Mat &bits);

    cv::Mat rotate(cv::Mat  in);

    int getMarkerId(cv::Mat &in,int &nRotations);

    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 thresHold(int method,cv::Mat &grey,cv::Mat &out);

    void drawAllContours(cv::Mat input);

    void draw(cv::Mat out,const std::vector<Marker> &markers );
    bool isInto(cv::Mat &contour,std::vector<cv::Point2f> &b);
    //bool isInto(vector<Point2f> &a,vector<Point2f> &b);
    int perimeter(std::vector<cv::Point2f> &a);
    template<typename T>
    void printMat(cv::Mat M,std::string info="")
    {

        std::cout<<info<<std::endl;
        for (int y=0;y<M.rows;y++)
        {
            for (int x=0;x<M.cols;x++)
            {
                if (sizeof(T)==1)
                    std::cout<<(int) M.at<T>(y,x)<<" ";
                else std::cout<<  M.at<T>(y,x)<<" ";
            }
            std::cout<<std::endl;
        }
    }
    template<typename T>
    void printMat(CvMat   *M,std::string info="")
    {
        std::cout<<info<<std::endl;
        cv::Mat MM(M);
        for (int y=0;y<MM.rows;y++)
        {
            for (int x=0;x<MM.cols;x++)
            {
                if (sizeof(T)==1)
                    std::cout<<(int) MM.at<T>(y,x)<<" ";
                else std::cout<<  MM.at<T>(y,x)<<" ";
            }
            std::cout<<endl;
        }
    }

    //from ARToolKit

    static void argConvGLcpara2( double cparam[3][4], int width, int height, double gnear, double gfar, double m[16], bool invert )throw(cv::Exception);
    static int  arParamDecompMat( double source[3][4], double cpara[3][4], double trans[3][4] )throw(cv::Exception);
    static double norm( double a, double b, double c );
    static double dot(  double a1, double a2, double a3,
                        double b1, double b2, double b3 );

 

};




};
#endif