ARToolKitWrapperExportedAPI.h

Go to the documentation of this file.

/*
 *  ARToolKitWrapperExportedAPI.h
 *  ARToolKit5
 *
 *  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 ARTOOLKITWRAPPEREXPORTEDAPI_H
#define ARTOOLKITWRAPPEREXPORTEDAPI_H

#include <ARWrapper/Platform.h>
#include <ARWrapper/Image.h>
#include <ARWrapper/Error.h>

extern "C" {

        EXPORT_API void arwRegisterLogCallback(PFN_LOGCALLBACK callback);

    // ----------------------------------------------------------------------------------------------------
#pragma mark  ARToolKit lifecycle functions
    // ----------------------------------------------------------------------------------------------------
        EXPORT_API bool arwInitialiseAR();

    EXPORT_API bool arwInitialiseARWithOptions(const int pattSize, const int pattCountMax);
    
        EXPORT_API bool arwGetARToolKitVersion(char *buffer, int length);

    EXPORT_API int arwGetError();
    
        EXPORT_API bool arwChangeToResourcesDir(const char *resourcesDirectoryPath);
    
        EXPORT_API bool arwStartRunning(const char *vconf, const char *cparaName, const float nearPlane, const float farPlane);
        
        EXPORT_API bool arwStartRunningB(const char *vconf, const char *cparaBuff, const int cparaBuffLen, const float nearPlane, const float farPlane);

    EXPORT_API bool arwStartRunningStereo(const char *vconfL, const char *cparaNameL, const char *vconfR, const char *cparaNameR, const char *transL2RName, const float nearPlane, const float farPlane);
    
    EXPORT_API bool arwStartRunningStereoB(const char *vconfL, const char *cparaBuffL, const int cparaBuffLenL, const char *vconfR, const char *cparaBuffR, int cparaBuffLenR, const char *transL2RBuff, const int transL2RBuffLen, const float nearPlane, const float farPlane);

        EXPORT_API bool arwIsRunning();

        EXPORT_API bool arwStopRunning();

        EXPORT_API bool arwShutdownAR();
    
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Video stream management
    // ----------------------------------------------------------------------------------------------------

        EXPORT_API bool arwGetProjectionMatrix(float p[16]);
    
        EXPORT_API bool arwGetProjectionMatrixStereo(float pL[16], float pR[16]);
        
        EXPORT_API bool arwGetVideoParams(int *width, int *height, int *pixelSize, char *pixelFormatStringBuffer, int pixelFormatStringBufferLen);
    
        EXPORT_API bool arwGetVideoParamsStereo(int *widthL, int *heightL, int *pixelSizeL, char *pixelFormatStringBufferL, int pixelFormatStringBufferLenL, int *widthR, int *heightR, int *pixelSizeR, char *pixelFormatStringBufferR, int pixelFormatStringBufferLenR);
    
        EXPORT_API bool arwCapture();
        
    EXPORT_API bool arwUpdateAR();
    
        EXPORT_API bool arwUpdateTexture(Color *buffer);
    
    EXPORT_API bool arwUpdateTexture32(unsigned int *buffer);
    
        EXPORT_API bool arwUpdateTextureStereo(Color *bufferL, Color *bufferR);
    
    EXPORT_API bool arwUpdateTexture32Stereo(unsigned int *bufferL, unsigned int *bufferR);
    
        EXPORT_API void arwSetVideoDebugMode(bool debug);
    
        EXPORT_API bool arwGetVideoDebugMode();
    
        EXPORT_API bool arwUpdateDebugTexture(Color *buffer, float alpha);

#if !TARGET_PLATFORM_WINRT

        EXPORT_API bool arwUpdateTextureGL(const int textureID);
    
        EXPORT_API bool arwUpdateTextureGLStereo(const int textureID_L, const int textureID_R);
#endif // !TARGET_PLATFORM_WINRT

    // ----------------------------------------------------------------------------------------------------
#pragma mark  Unity-specific API
    // ----------------------------------------------------------------------------------------------------
    
    enum {
        ARW_UNITY_RENDER_EVENTID_NOP = 0, // No operation (does nothing).
#if !TARGET_PLATFORM_WINRT
        ARW_UNITY_RENDER_EVENTID_UPDATE_TEXTURE_GL = 1,
        ARW_UNITY_RENDER_EVENTID_UPDATE_TEXTURE_GL_STEREO = 2,
#endif // !TARGET_PLATFORM_WINRT
    };
    
    EXPORT_API void UnityRenderEvent(int eventID);

#if !TARGET_PLATFORM_WINRT

    EXPORT_API void arwSetUnityRenderEventUpdateTextureGLTextureID(int textureID);
    
    EXPORT_API void arwSetUnityRenderEventUpdateTextureGLStereoTextureIDs(int textureID_L, int textureID_R);
#endif // !TARGET_PLATFORM_WINRT

        // ----------------------------------------------------------------------------------------------------
#pragma mark  Tracking configuration
    // ----------------------------------------------------------------------------------------------------
        EXPORT_API void arwSetVideoThreshold(int threshold);

        EXPORT_API int arwGetVideoThreshold();

        EXPORT_API void arwSetVideoThresholdMode(int mode);

        EXPORT_API int arwGetVideoThresholdMode();

    EXPORT_API void arwSetLabelingMode(int mode);
    
    EXPORT_API int arwGetLabelingMode();
    
    EXPORT_API void arwSetPatternDetectionMode(int mode);
    
    EXPORT_API int arwGetPatternDetectionMode();
    
    EXPORT_API void arwSetBorderSize(float size);
    
    EXPORT_API float arwGetBorderSize();
    
    EXPORT_API void arwSetMatrixCodeType(int type);
    
    EXPORT_API int arwGetMatrixCodeType();

    EXPORT_API void arwSetImageProcMode(int mode);
    
    EXPORT_API int arwGetImageProcMode();

    EXPORT_API void arwSetNFTMultiMode(bool on);
    
    EXPORT_API bool arwGetNFTMultiMode();

    // ----------------------------------------------------------------------------------------------------
#pragma mark  Marker management
    // ----------------------------------------------------------------------------------------------------
        EXPORT_API int arwAddMarker(const char *cfg);
    
        EXPORT_API bool arwRemoveMarker(int markerUID);
        
        EXPORT_API int arwRemoveAllMarkers();
    
        EXPORT_API bool arwQueryMarkerVisibility(int markerUID);
    
        EXPORT_API bool arwQueryMarkerTransformation(int markerUID, float matrix[16]);
        
        EXPORT_API bool arwQueryMarkerTransformationStereo(int markerUID, float matrixL[16], float matrixR[16]);
        
        EXPORT_API int arwGetMarkerPatternCount(int markerUID);
        
        EXPORT_API bool arwGetMarkerPatternConfig(int markerUID, int patternID, float matrix[16], float *width, float *height, int *imageSizeX, int *imageSizeY);
        
        EXPORT_API bool arwGetMarkerPatternImage(int markerUID, int patternID, Color *buffer);
    
    enum {
        ARW_MARKER_OPTION_FILTERED = 1,                         
        ARW_MARKER_OPTION_FILTER_SAMPLE_RATE = 2,               
        ARW_MARKER_OPTION_FILTER_CUTOFF_FREQ = 3,               
        ARW_MARKER_OPTION_SQUARE_USE_CONT_POSE_ESTIMATION = 4,  
        ARW_MARKER_OPTION_SQUARE_CONFIDENCE = 5,                
        ARW_MARKER_OPTION_SQUARE_CONFIDENCE_CUTOFF = 6,         
        ARW_MARKER_OPTION_NFT_SCALE = 7                         
    };
    
    EXPORT_API void arwSetMarkerOptionBool(int markerUID, int option, bool value);
    
    EXPORT_API void arwSetMarkerOptionInt(int markerUID, int option, int value);
    
    EXPORT_API void arwSetMarkerOptionFloat(int markerUID, int option, float value);

    EXPORT_API bool arwGetMarkerOptionBool(int markerUID, int option);
    
    EXPORT_API int arwGetMarkerOptionInt(int markerUID, int option);
    
    EXPORT_API float arwGetMarkerOptionFloat(int markerUID, int option);
    
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Utility
    // ----------------------------------------------------------------------------------------------------
    EXPORT_API bool arwLoadOpticalParams(const char *optical_param_name, const char *optical_param_buff, const int optical_param_buffLen, float *fovy_p, float *aspect_p, float m[16], float p[16]);
}

#endif // !ARTOOLKITWRAPPEREXPORTEDAPI_H