Tracker.h

Go to the documentation of this file.

#ifndef __ARTOOLKIT_TRACKERIMPL_HEADERFILE__
#define __ARTOOLKIT_TRACKERIMPL_HEADERFILE__

#include <ARToolKitPlus/ARToolKitPlus.h>
#include <ARToolKitPlus/ar.h>
#include <ARToolKitPlus/arMulti.h>
#include <ARToolKitPlus/vector.h>
#include <ARToolKitPlus/Camera.h>
#include <ARToolKitPlus/extra/BCH.h>
#include <ARToolKitPlus/extra/Hull.h>

#include <vector>


namespace ARToolKitPlus {

class AR_EXPORT Tracker {
public:
    Tracker(int imWidth, int imHeight, int maxImagePatterns = 8, int pattWidth = 6, int pattHeight = 6, int pattSamples = 6,
            int maxLoadPatterns = 0);
    virtual ~Tracker();

    virtual bool setPixelFormat(PIXEL_FORMAT nFormat);

    virtual bool loadCameraFile(const char* nCamParamFile, ARFloat nNearClip, ARFloat nFarClip);

    virtual void setLoadUndistLUT(bool nSet) {
        loadCachedUndist = nSet;
    }

    virtual int arDetectMarker(uint8_t *dataPtr, int thresh, ARMarkerInfo **marker_info, int *marker_num);

    virtual int arDetectMarkerLite(uint8_t *dataPtr, int thresh, ARMarkerInfo **marker_info, int *marker_num);

    virtual ARFloat arMultiGetTransMat(ARMarkerInfo *marker_info, int marker_num, ARMultiMarkerInfoT *config);

    virtual ARFloat arMultiGetTransMatHull(ARMarkerInfo *marker_info, int marker_num, ARMultiMarkerInfoT *config);

    virtual ARFloat arGetTransMat(ARMarkerInfo *marker_info, ARFloat center[2], ARFloat width, ARFloat conv[3][4]);

    virtual ARFloat arGetTransMatCont(ARMarkerInfo *marker_info, ARFloat prev_conv[3][4], ARFloat center[2],
            ARFloat width, ARFloat conv[3][4]);

    // RPP integration -- [t.pintaric]
    virtual ARFloat rppMultiGetTransMat(ARMarkerInfo *marker_info, int marker_num, ARMultiMarkerInfoT *config);
    virtual ARFloat rppGetTransMat(ARMarkerInfo *marker_info, ARFloat center[2], ARFloat width, ARFloat conv[3][4]);

    virtual int arLoadPatt(char *filename);

    virtual int arFreePatt(int patno);

    virtual int arMultiFreeConfig(ARMultiMarkerInfoT *config);

    virtual ARMultiMarkerInfoT *arMultiReadConfigFile(const char *filename);

    virtual void activateBinaryMarker(int nThreshold) {
        binaryMarkerThreshold = nThreshold;
    }

    virtual void setMarkerMode(MARKER_MODE nMarkerMode);

    virtual void activateVignettingCompensation(bool nEnable, int nCorners = 0, int nLeftRight = 0, int nTopBottom = 0);

    static bool calcCameraMatrix(const char* nCamParamFile, ARFloat nNear, ARFloat nFar, ARFloat *nMatrix);

    virtual void changeCameraSize(int nWidth, int nHeight);

    virtual void setUndistortionMode(UNDIST_MODE nMode);

    virtual bool setPoseEstimator(POSE_ESTIMATOR nMethod);

    virtual void setHullMode(HULL_TRACKING_MODE nMode) {
        hullTrackingMode = nMode;
    }

    virtual void setBorderWidth(ARFloat nFraction) {
        relBorderWidth = nFraction;
    }

    virtual void setThreshold(int nValue) {
        thresh = nValue;
    }

    virtual int getThreshold() const {
        return thresh;
    }

    virtual void activateAutoThreshold(bool nEnable) {
        autoThreshold.enable = nEnable;
    }

    virtual bool isAutoThresholdActivated() const {
        return autoThreshold.enable;
    }

    virtual void setNumAutoThresholdRetries(int nNumRetries) {
        autoThreshold.numRandomRetries = nNumRetries >= 1 ? nNumRetries : 1;
    }

    virtual void setImageProcessingMode(IMAGE_PROC_MODE nMode) {
        arImageProcMode = (nMode == IMAGE_HALF_RES ? AR_IMAGE_PROC_IN_HALF : AR_IMAGE_PROC_IN_FULL);
    }

    virtual const ARFloat* getModelViewMatrix() const {
        return gl_para;
    }

    virtual const ARFloat* getProjectionMatrix() const {
        return gl_cpara;
    }

    virtual PIXEL_FORMAT getPixelFormat() const {
        return static_cast<PIXEL_FORMAT> (pixelFormat);
    }

    virtual int getBitsPerPixel() const {
        return pixelSize * 8;
    }

    virtual int getNumLoadablePatterns() const {
        return MAX_LOAD_PATTERNS;
    }

    virtual Camera* getCamera() {
        return arCamera;
    }

    virtual void setCamera(Camera* nCamera);

    virtual void setCamera(Camera* nCamera, ARFloat nNearClip, ARFloat nFarClip);

    virtual ARFloat calcOpenGLMatrixFromMarker(ARMarkerInfo* nMarkerInfo, ARFloat nPatternCenter[2],
            ARFloat nPatternSize, ARFloat *nOpenGLMatrix);

    virtual ARFloat executeSingleMarkerPoseEstimator(ARMarkerInfo *marker_info, ARFloat center[2], ARFloat width,
            ARFloat conv[3][4]);

    virtual ARFloat executeMultiMarkerPoseEstimator(ARMarkerInfo *marker_info, int marker_num,
            ARMultiMarkerInfoT *config);

    /*
     * Returns a vector with screen coordinates of all corners
     * that were used for marker tracking for the last image
     */
    virtual const CornerPoints& getTrackedCorners() const {
        return trackedCorners;
    }

protected:
#ifdef SMALL_LUM8_TABLE
    static const int LUM_TABLE_SIZE = (0xffff >> 6) + 1;
#else
    static const int LUM_TABLE_SIZE = 0xffff + 1;
#endif
    const int PATTERN_WIDTH;
    const int PATTERN_HEIGHT;
    const int PATTERN_SAMPLE_NUM;
    const int MAX_LOAD_PATTERNS;
    const int MAX_IMAGE_PATTERNS;
    const int WORK_SIZE;

    bool checkPixelFormat();

    void checkImageBuffer();

    // converts an ARToolKit transformation matrix for usage with OpenGL
    void convertTransformationMatrixToOpenGLStyle(ARFloat para[3][4], ARFloat gl_para[16]);

    // converts an ARToolKit projection matrix for usage with OpenGL
    static bool convertProjectionMatrixToOpenGLStyle(Camera *param, ARFloat gnear, ARFloat gfar, ARFloat m[16]);
    static bool convertProjectionMatrixToOpenGLStyle2(ARFloat cparam[3][4], int width, int height, ARFloat gnear,
            ARFloat gfar, ARFloat m[16]);

    ARMarkerInfo2* arDetectMarker2(int16_t *limage, int label_num, int *label_ref, int *warea, ARFloat *wpos,
            int *wclip, int area_max, int area_min, ARFloat factor, int *marker_num);

    int arGetContour(int16_t *limage, int *label_ref, int label, int clip[4], ARMarkerInfo2 *marker_infoTWO);

    int check_square(int area, ARMarkerInfo2 *marker_infoTWO, ARFloat factor);

    int
    arGetCode(uint8_t *image, int *x_coord, int *y_coord, int *vertex, int *code, int *dir, ARFloat *cf, int thresh);

    int arGetPatt(uint8_t *image, int *x_coord, int *y_coord, int *vertex, uint8_t *ext_pat);

    int pattern_match(uint8_t *data, int *code, int *dir, ARFloat *cf);

    int downsamplePattern(uint8_t* data, unsigned char* imgPtr);

    int bitfield_check_simple(uint8_t *data, int *code, int *dir, ARFloat *cf, int thresh);

    int bitfield_check_BCH(uint8_t *data, int *code, int *dir, ARFloat *cf, int thresh);

    void gen_evec(void);

    ARMarkerInfo* arGetMarkerInfo(uint8_t *image, ARMarkerInfo2 *marker_info2, int *marker_num, int thresh);

    ARFloat arGetTransMat5(ARFloat rot[3][3], ARFloat ppos2d[][2], ARFloat ppos3d[][3], int num, ARFloat conv[3][4],
            Camera *pCam);

    ARFloat arGetTransMatSub(ARFloat rot[3][3], ARFloat ppos2d[][2], ARFloat pos3d[][3], int num, ARFloat conv[3][4],
            Camera *pCam);

    ARFloat arModifyMatrix(ARFloat rot[3][3], ARFloat trans[3], ARFloat cpara[3][4], ARFloat vertex[][3],
            ARFloat pos2d[][2], int num);

    ARFloat arModifyMatrix2(ARFloat rot[3][3], ARFloat trans[3], ARFloat cpara[3][4], ARFloat vertex[][3],
            ARFloat pos2d[][2], int num);

    int arGetAngle(ARFloat rot[3][3], ARFloat *wa, ARFloat *wb, ARFloat *wc);

    int arGetRot(ARFloat a, ARFloat b, ARFloat c, ARFloat rot[3][3]);

    int arGetNewMatrix(ARFloat a, ARFloat b, ARFloat c, ARFloat trans[3], ARFloat trans2[3][4], ARFloat cpara[3][4],
            ARFloat ret[3][4]);

    int arGetInitRot(ARMarkerInfo *marker_info, ARFloat cpara[3][4], ARFloat rot[3][3]);

    int arGetInitRot2(ARMarkerInfo *marker_info, ARFloat rot[3][3], ARFloat center[2], ARFloat width);

    ARFloat arGetTransMatContSub(ARMarkerInfo *marker_info, ARFloat prev_conv[3][4], ARFloat center[2], ARFloat width,
            ARFloat conv[3][4]);

    int16_t* arLabeling(uint8_t *image, int thresh, int *label_num, int **area, ARFloat **pos, int **clip,
            int **label_ref);

    int16_t* arLabeling_ABGR(uint8_t *image, int thresh, int *label_num, int **area, ARFloat **pos, int **clip,
            int **label_ref);
    int16_t* arLabeling_BGR(uint8_t *image, int thresh, int *label_num, int **area, ARFloat **pos, int **clip,
            int **label_ref);
    int16_t* arLabeling_RGB(uint8_t *image, int thresh, int *label_num, int **area, ARFloat **pos, int **clip,
            int **label_ref);
    int16_t* arLabeling_RGB565(uint8_t *image, int thresh, int *label_num, int **area, ARFloat **pos, int **clip,
            int **label_ref);
    int16_t* arLabeling_LUM(uint8_t *image, int thresh, int *label_num, int **area, ARFloat **pos, int **clip,
            int **label_ref);

    int arActivatePatt(int patno);

    int arDeactivatePatt(int patno);

    int arMultiActivate(ARMultiMarkerInfoT *config);

    int arMultiDeactivate(ARMultiMarkerInfoT *config);

    int verify_markers(ARMarkerInfo *marker_info, int marker_num, ARMultiMarkerInfoT *config);

    int arInitCparam(Camera *pCam);

    int arGetLine(int x_coord[], int y_coord[], int vertex[], ARFloat line[4][3], ARFloat v[4][2]);

    static int arUtilMatMul(ARFloat s1[3][4], ARFloat s2[3][4], ARFloat d[3][4]);

    static int arUtilMatInv(ARFloat s[3][4], ARFloat d[3][4]);

    static int arMatrixPCA(ARMat *input, ARMat *evec, ARVec *ev, ARVec *mean);

    static int arMatrixPCA2(ARMat *input, ARMat *evec, ARVec *ev);

    static int arCameraDecomp(Camera *source, Camera *icpara, ARFloat trans[3][4]);

    static int arCameraDecompMat(ARFloat source[3][4], ARFloat cpara[3][4], ARFloat trans[3][4]);

    int arCameraObserv2Ideal_none(Camera* pCam, ARFloat ox, ARFloat oy, ARFloat *ix, ARFloat *iy);

    int arCameraObserv2Ideal_LUT(Camera* pCam, ARFloat ox, ARFloat oy, ARFloat *ix, ARFloat *iy);

    int arCameraObserv2Ideal_std(Camera* pCam, ARFloat ox, ARFloat oy, ARFloat *ix, ARFloat *iy);
    int arCameraIdeal2Observ_std(Camera* pCam, ARFloat ix, ARFloat iy, ARFloat *ox, ARFloat *oy);

    typedef int (Tracker::* ARPARAM_UNDIST_FUNC)(Camera* pCam, ARFloat ox, ARFloat oy, ARFloat *ix, ARFloat *iy);

    typedef ARFloat (Tracker::* POSE_ESTIMATOR_FUNC)(ARMarkerInfo *marker_info, ARFloat center[2], ARFloat width,
            ARFloat conv[3][4]);
    typedef ARFloat (Tracker::* MULTI_POSE_ESTIMATOR_FUNC)(ARMarkerInfo *marker_info, int marker_num,
            ARMultiMarkerInfoT *config);

    void buildUndistO2ITable(Camera* pCam);

    void checkRGB565LUT();

    // required for calib camera, should otherwise not be used directly
    void setFittingMode(int nWhich) {
        arFittingMode = nWhich;
    }

    ARFloat arGetTransMat3(ARFloat rot[3][3], ARFloat ppos2d[][2], ARFloat ppos3d[][2], int num, ARFloat conv[3][4],
            Camera *pCam);

    static int arCameraObserv2Ideal(Camera *pCam, ARFloat ox, ARFloat oy, ARFloat *ix, ARFloat *iy);
    static int arCameraIdeal2Observ(Camera *pCam, ARFloat ix, ARFloat iy, ARFloat *ox, ARFloat *oy);

protected:
    struct AutoThreshold {
        enum {
            MINLUM0 = 255, MAXLUM0 = 0
        };

        void reset() {
            minLum = MINLUM0;
            maxLum = MAXLUM0;
        }

        void addValue(int nRed, int nGreen, int nBlue, int nPixelFormat) {
            int lum;

            // in RGB565 and LUM8 all three values are simply the grey value...
            if (nPixelFormat == PIXEL_FORMAT_RGB565 || nPixelFormat == PIXEL_FORMAT_LUM)
                lum = nRed;
            else
                lum = (nRed + (nGreen << 1) + nBlue) >> 2;

            if (lum < minLum)
                minLum = lum;
            if (lum > maxLum)
                maxLum = lum;
        }

        int calc() {
            return (minLum + maxLum) / 2;
        }

        bool enable;
        int minLum, maxLum;
        int numRandomRetries;
    } autoThreshold;

    PIXEL_FORMAT pixelFormat;
    int pixelSize;

    int binaryMarkerThreshold;

    // arDetectMarker.cpp
    ARMarkerInfo2 *marker_info2;
    ARMarkerInfo *wmarker_info;
    int wmarker_num;

    arPrevInfo *prev_info;
    int prev_num;

    std::vector<std::vector<arPrevInfo> > sprev_info;
    int sprev_num[2];

    // arDetectMarker2.cpp
    ARMarkerInfo2 *marker_infoTWO; // CAUTION: this member has to be manually allocated!
    //          see TrackerSingleMarker for more info on this.

    int arGetContour_wx[AR_CHAIN_MAX];
    int arGetContour_wy[AR_CHAIN_MAX];

    // arGetCode.cpp
    int pattern_num;
    int *patf;
    std::vector<std::vector<std::vector<int> > > pat;
    ARFloat (*patpow)[4];
    std::vector<std::vector<std::vector<int> > > patBW;
    ARFloat (*patpowBW)[4];

    std::vector<std::vector<ARFloat> > evec;
    ARFloat (*epat)[4][EVEC_MAX];
    int evec_dim;
    int evecf;
    std::vector<std::vector<ARFloat> > evecBW;
    ARFloat (*epatBW)[4][EVEC_MAX];
    int evec_dimBW;
    int evecBWf;

    // arGetMarkerInfo.cpp
    //
    ARMarkerInfo *marker_infoL;

    // arGetTransMat.cpp
    //
    ARFloat pos2d[P_MAX][2];
    ARFloat pos3d[P_MAX][3];

    // arLabeling.cpp
    //
    int16_t *l_imageL; //[HARDCODED_BUFFER_WIDTH*HARDCODED_BUFFER_HEIGHT];              // dyna
    int16_t *l_imageR;
    int l_imageL_size;

    int *workL; //[WORK_SIZE];                                                                                  // dyna
    int *work2L; //[WORK_SIZE*7];                                                                                       // dyna

    int *workR;
    int *work2R;
    int *wareaR;
    int *wclipR;
    ARFloat *wposR;

    int wlabel_numL;
    int wlabel_numR;
    int *wareaL; //[WORK_SIZE]; dyna
    int *wclipL; //[WORK_SIZE*4]; dyna
    ARFloat *wposL; //[WORK_SIZE*2];dyna

    int arFittingMode;
    int arImageProcMode;
    Camera *arCamera;
    bool loadCachedUndist;
    int arImXsize, arImYsize;
    int arTemplateMatchingMode;
    int arMatchingPCAMode;

    uint8_t* arImageL;

    MARKER_MODE markerMode;

    unsigned char *RGB565_to_LUM8_LUT; // lookup table for RGB565 to LUM8 conversion


    // camera distortion addon by Daniel
    UNDIST_MODE undistMode;
    unsigned int *undistO2ITable;

    // used for Hull Tracking
    MarkerPoint hullInPoints[MAX_HULL_POINTS];
    MarkerPoint hullOutPoints[MAX_HULL_POINTS];

    CornerPoints trackedCorners;

    ARFloat relBorderWidth;

    ARPARAM_UNDIST_FUNC arCameraObserv2Ideal_func;

    // RPP integration -- [t.pintaric]
    POSE_ESTIMATOR poseEstimator;

    HULL_TRACKING_MODE hullTrackingMode;

    static int screenWidth;
        static int screenHeight;
    int thresh;

    ARFloat gl_para[16];
    ARFloat gl_cpara[16];

    char *descriptionString;

    struct {
        bool enabled;
        int corners, leftright, bottomtop;
    } vignetting;

    unsigned short *DIV_TABLE;

    BCH *bchProcessor;
};

} // namespace ARToolKitPlus

#endif //__ARTOOLKIT_TRACKERIMPL_HEADERFILE__

---

artoolkitplus
Author(s): Christian Bersch
autogenerated on Fri Jan 11 11:15:05 2013