ARController.h

Go to the documentation of this file.

/*
 *  ARController.h
 *  ARToolKit5
 *
 *  A C++ class encapsulating core controller functionality of ARToolKit.
 *
 *  This file is part of ARToolKit.
 *
 *  ARToolKit is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  ARToolKit is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with ARToolKit.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  As a special exception, the copyright holders of this library give you
 *  permission to link this library with independent modules to produce an
 *  executable, regardless of the license terms of these independent modules, and to
 *  copy and distribute the resulting executable under terms of your choice,
 *  provided that you also meet, for each linked independent module, the terms and
 *  conditions of the license of that module. An independent module is a module
 *  which is neither derived from nor based on this library. If you modify this
 *  library, you may extend this exception to your version of the library, but you
 *  are not obligated to do so. If you do not wish to do so, delete this exception
 *  statement from your version.
 *
 *  Copyright 2015 Daqri, LLC.
 *  Copyright 2010-2015 ARToolworks, Inc.
 *
 *  Author(s): Philip Lamb, Julian Looser.
 *
 */


#ifndef ARCONTROLLER_H
#define ARCONTROLLER_H

#include <ARWrapper/Platform.h>

#include <AR/ar.h>
#include <AR/arMulti.h>
#include <AR/video.h>

#include <ARWrapper/Image.h>
#include <ARWrapper/VideoSource.h>
#include <ARWrapper/ARMarker.h>
#include <ARWrapper/ARMarkerSquare.h>
#include <ARWrapper/ARMarkerMulti.h>
#if HAVE_NFT
#  include <AR2/tracking.h>
#  include <KPM/kpm.h>
#  include <ARWrapper/ARMarkerNFT.h>
#endif


#include <vector>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#if !defined(_WINRT)
#  include <pthread.h>
#else
#  define pthread_mutex_t               CRITICAL_SECTION
#  define pthread_mutex_init(pm, a)     InitializeCriticalSectionEx(pm, 4000, CRITICAL_SECTION_NO_DEBUG_INFO)
#  define pthread_mutex_lock(pm)        EnterCriticalSection(pm)
#  define pthread_mutex_unlock(pm)      LeaveCriticalSection(pm)
#  define pthread_mutex_destroy(pm)     DeleteCriticalSection(pm)
#endif
#define PAGES_MAX 64

class ARController {

private:
#pragma mark Private types and instance variables
    // ------------------------------------------------------------------------------
    // Private types and instance variables.
    // ------------------------------------------------------------------------------

        typedef enum {
                NOTHING_INITIALISED,                    
                BASE_INITIALISED,                               
                WAITING_FOR_VIDEO,                              
                DETECTION_RUNNING                               
        } ARToolKitState;
    
        ARToolKitState state;                           
    bool stateWaitingMessageLogged;

        char* versionString;                            

        VideoSource *m_videoSource0;          
        VideoSource *m_videoSource1;          
    pthread_mutex_t m_videoSourceLock;
    bool m_videoSourceIsStereo;
    int m_videoSourceFrameStamp0;
    int m_videoSourceFrameStamp1;
    
    // Virtual environment parameters.
        ARdouble m_projectionNearPlane;         
        ARdouble m_projectionFarPlane;          
        ARdouble m_projectionMatrix0[16];       
        ARdouble m_projectionMatrix1[16];       
        bool m_projectionMatrixSet;                     
    
    // ARToolKit configuration. These allow for configuration prior to starting ARToolKit.
    int threshold;
    AR_LABELING_THRESH_MODE thresholdMode;
    int imageProcMode;
    int labelingMode;
    ARdouble pattRatio;
    int patternDetectionMode;
    AR_MATRIX_CODE_TYPE matrixCodeType;
    bool debugMode;

    std::vector<ARMarker *> markers;    

    bool doMarkerDetection;
    // ARToolKit data.
        ARHandle *m_arHandle0;                          
        ARHandle *m_arHandle1;                          
        ARPattHandle *m_arPattHandle;                   
        AR3DHandle *m_ar3DHandle;                   
    ARdouble m_transL2R[3][4];
    AR3DStereoHandle *m_ar3DStereoHandle;
    
#if HAVE_NFT
    bool doNFTMarkerDetection;
    bool m_nftMultiMode;
    bool m_kpmRequired;
    bool m_kpmBusy;
    // NFT data.
    THREAD_HANDLE_T     *trackingThreadHandle;
    AR2HandleT          *m_ar2Handle;
    KpmHandle           *m_kpmHandle;
    AR2SurfaceSetT      *surfaceSet[PAGES_MAX]; // Weak-reference. Strong reference is now in ARMarkerNFT class.
#endif
    
    int m_error;
    void setError(int error);
    
#pragma mark Private methods.
    // ------------------------------------------------------------------------------
    // Private methods.
    // ------------------------------------------------------------------------------
    
    void lockVideoSource();
    void unlockVideoSource();
    
    //
    // Internal marker management.
    //
    
        bool addMarker(ARMarker* marker);

        bool removeMarker(ARMarker* marker);
        
    //
    // Convenience initialisers.
    //
    
    bool initAR(void);
#if HAVE_NFT
    bool unloadNFTData(void);
    bool loadNFTData(void);
    bool initNFT(void);
#endif

public:
#pragma mark Public API
    // ------------------------------------------------------------------------------
    // Public API
    // ------------------------------------------------------------------------------
    
        ARController();
    
        ~ARController();
        
        static PFN_LOGCALLBACK logCallback;             

private:
    static void logvBuf(va_list args, const char* format, char **bufPtr, int* lenPtr);
    static void logvWriteBuf(char* buf, int len, const int logLevel);

public:
    static void logv(const int logLevel, const char* format, ...);

        static void logv(const char* msg, ...);

        const char* getARToolKitVersion();
    
    int getError();
    
        bool initialiseBase(const int patternSize = AR_PATT_SIZE1, const int patternCountMax = AR_PATT_NUM_MAX);

        bool canAddMarker();
    
    void setProjectionNearPlane(const ARdouble projectionNearPlane);
    void setProjectionFarPlane(const ARdouble projectionFarPlane);
    ARdouble projectionNearPlane(void);
    ARdouble projectionFarPlane(void);

        bool startRunning(const char* vconf, const char* cparaName, const char* cparaBuff, const long cparaBuffLen);
        
        bool startRunningStereo(const char* vconfL, const char* cparaNameL, const char* cparaBuffL, const long cparaBuffLenL,
                            const char* vconfR, const char* cparaNameR, const char* cparaBuffR, const long cparaBuffLenR,
                            const char* transL2RName, const char* transL2RBuff, const long transL2RBuffLen);
        
#if TARGET_PLATFORM_ANDROID
    bool videoAcceptImage(JNIEnv* env, jobject obj, const int videoSourceIndex, jbyteArray pinArray, jint width, jint height, jint cameraIndex, jboolean cameraIsFrontFacing);
#endif
    
    bool videoParameters(const int videoSourceIndex, int *width, int *height, AR_PIXEL_FORMAT *pixelFormat);
    
        bool isRunning();
    
        bool stopRunning();

        bool shutdown();

        bool getProjectionMatrix(const int videoSourceIndex, ARdouble proj[16]);
    
        int addMarker(const char* cfg);

        bool removeMarker(int UID);
        
        int removeAllMarkers();

        unsigned int countMarkers();

        ARMarker* findMarker(int UID);
        
    bool capture();
    
    bool updateTexture(const int videoSourceIndex, Color* buffer);
    
    bool updateTexture32(const int videoSourceIndex, uint32_t *buffer);
    
#ifndef _WINRT

    bool updateTextureGL(const int videoSourceIndex, const int textureID);
#endif // !_WINRT

        bool update();

        void setDebugMode(bool debug);
    
        bool getDebugMode() const;
    
    void setImageProcMode(int mode);
    
    int getImageProcMode() const;
    
        void setThreshold(int thresh);

        int getThreshold() const;
    
        void setThresholdMode(int mode);

        int getThresholdMode() const;
        
        void setLabelingMode(int mode);
    
        int getLabelingMode() const;
        
    void setPatternDetectionMode(int mode);
    
    int getPatternDetectionMode() const;

    void setPattRatio(float ratio);
    
    float getPattRatio() const;
    
    void setMatrixCodeType(int type);
    
    int getMatrixCodeType() const;
    
    void setNFTMultiMode(bool on);
    
    bool getNFTMultiMode() const;

        bool updateDebugTexture(const int videoSourceIndex, Color* buffer);

    bool updateDebugTexture32(const int videoSourceIndex, uint32_t* buffer);

        bool getPatternImage(int patternID, Color* buffer);
    
    bool loadOpticalParams(const char *optical_param_name, const char *optical_param_buff, const long optical_param_buffLen, ARdouble *fovy_p, ARdouble *aspect_p, ARdouble m[16], ARdouble p[16]);
    
};


#endif // !ARCONTROLLER_H