ARController.h

Go to the documentation of this file.

/*
 *  ARController.h
 *  artoolkitX
 *
 *  A C++ class encapsulating core controller functionality of artoolkitX.
 *
 *  This file is part of artoolkitX.
 *
 *  artoolkitX 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.
 *
 *  artoolkitX 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 artoolkitX.  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 2018 Realmax, Inc.
 *  Copyright 2015 Daqri, LLC.
 *  Copyright 2010-2015 ARToolworks, Inc.
 *
 *  Author(s): Philip Lamb, Julian Looser.
 *
 */
 
 
#ifndef ARCONTROLLER_H
#define ARCONTROLLER_H
 
#include <ARX/Platform.h>
#include <ARX/AR/ar.h>
#include <ARX/ARVideoSource.h>
#include <ARX/ARVideoView.h>
#include <ARX/ARTrackerSquare.h>
#if HAVE_NFT
#  include <ARX/ARTrackerNFT.h>
#endif
#if HAVE_2D
#  include <ARX/ARTracker2d.h>
#endif
#include <ARX/ARTrackable.h>
 
 
#include <vector>
#include <memory>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.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
 
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;                
 
    ARVideoSource *m_videoSource0;      
    ARVideoSource *m_videoSource1;      
    ARdouble m_transL2R[3][4];
    bool m_videoSourceIsStereo;
    AR2VideoTimestampT m_updateFrameStamp0;
    AR2VideoTimestampT m_updateFrameStamp1;
    ARVideoView *m_arVideoViews[2];
 
    std::shared_ptr<ARTrackerSquare> m_squareTracker;
#if HAVE_NFT
    std::shared_ptr<ARTrackerNFT> m_nftTracker;
#endif
#if HAVE_2D
    std::shared_ptr<ARTracker2d> m_twoDTracker;
#endif
 
    int m_error;
    void setError(int error);
 
public:
#pragma mark Public API
    // ------------------------------------------------------------------------------
    // Public API
    // ------------------------------------------------------------------------------
 
    ARController();
 
    ~ARController();
 
    const char* getARToolKitVersion();
 
    int getError();
 
    bool initialiseBase();
 
    std::shared_ptr<ARTrackerSquare> getSquareTracker() { return m_squareTracker; };
#if HAVE_NFT
    std::shared_ptr<ARTrackerNFT> getNFTTracker() { return m_nftTracker; };
#endif
#if HAVE_2D
    std::shared_ptr<ARTracker2d> get2dTracker() { return m_twoDTracker; };
#endif
 
    bool isInited();
 
    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);
 
    int videoPushInit(int videoSourceIndex, int width, int height, const char *pixelFormat, int cameraIndex, int cameraPosition);
    int videoPush(int videoSourceIndex,
                  ARUint8 *buf0p, int buf0Size, int buf0PixelStride, int buf0RowStride,
                  ARUint8 *buf1p, int buf1Size, int buf1PixelStride, int buf1RowStride,
                  ARUint8 *buf2p, int buf2Size, int buf2PixelStride, int buf2RowStride,
                  ARUint8 *buf3p, int buf3Size, int buf3PixelStride, int buf3RowStride);
    int videoPushFinal(int videoSourceIndex);
 
    bool videoParameters(const int videoSourceIndex, int *width, int *height, AR_PIXEL_FORMAT *pixelFormat);
 
    bool isRunning();
 
    bool stopRunning();
 
    bool shutdown();
 
    bool projectionMatrix(const int videoSourceIndex, const ARdouble projectionNearPlane, const ARdouble projectionFarPlane, ARdouble proj[16]);
 
    bool projectionForViewportSizeAndFittingMode(const int videoSourceIndex, const ARVideoSource::Size viewportSize, const ARVideoSource::ScalingMode scalingMode, const ARdouble projectionNearPlane, const ARdouble projectionFarPlane, ARdouble proj[16]);
 
    bool drawVideoInit(const int videoSourceIndex);
 
    bool drawVideoSettings(const int videoSourceIndex, const int width, const int height, const bool rotate90, const bool flipH, const bool flipV, const ARVideoView::HorizontalAlignment hAlign, const ARVideoView::VerticalAlignment vAlign, const ARVideoView::ScalingMode scalingMode, int32_t viewport[4]);
 
    bool drawVideo(const int videoSourceIndex);
 
    bool drawVideoFinal(const int videoSourceIndex);
 
    int addTrackable(const std::string& cfgs);
 
    bool removeTrackable(int UID);
 
    int removeAllTrackables();
 
    unsigned int countTrackables() const;
 
    unsigned int countTrackables(ARTrackable::TrackableType trackableType) const;
 
    std::vector<std::shared_ptr<ARTrackable>> getAllTrackables();
 
    std::shared_ptr<ARTrackable> findTrackable(int UID);
 
    bool capture();
 
    bool updateTextureRGBA32(const int videoSourceIndex, uint32_t *buffer);
 
    bool update();
 
    bool updateDebugTexture32(const int videoSourceIndex, uint32_t* buffer);
 
    bool getPatternImage(int patternID, uint32_t* buffer);
 
    bool loadOpticalParams(const char *optical_param_name, const char *optical_param_buff, const long optical_param_buffLen, const ARdouble projectionNearPlane, const ARdouble projectionFarPlane, ARdouble *fovy_p, ARdouble *aspect_p, ARdouble m[16], ARdouble p[16]);
 
 
#if HAVE_2D
    bool load2DTrackerImageDatabase(const char* databaseFileName);
 
    bool save2DTrackerImageDatabase(const char* databaseFileName);
#endif // HAVE_2D
 
};
 
 
#endif // !ARCONTROLLER_H