ARX_c.h

Go to the documentation of this file.

/*
 *  ARX_c.h
 *  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 ARX_C_H
#define ARX_C_H
 
#include <ARX/Platform.h>
#include <ARX/Error.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

    ARX_EXTERN void arwRegisterLogCallback(PFN_LOGCALLBACK callback);
 
    ARX_EXTERN void arwSetLogLevel(const int logLevel);
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  artoolkitX lifecycle functions
    // ----------------------------------------------------------------------------------------------------
    ARX_EXTERN bool arwInitialiseAR();

    ARX_EXTERN bool arwGetARToolKitVersion(char *buffer, int length);

    ARX_EXTERN int arwGetError();

    ARX_EXTERN bool arwChangeToResourcesDir(const char *resourcesDirectoryPath);

    ARX_EXTERN bool arwStartRunning(const char *vconf, const char *cparaName);

    ARX_EXTERN bool arwStartRunningB(const char *vconf, const char *cparaBuff, const int cparaBuffLen);
 
    ARX_EXTERN bool arwStartRunningStereo(const char *vconfL, const char *cparaNameL, const char *vconfR, const char *cparaNameR, const char *transL2RName);
 
    ARX_EXTERN 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);

    ARX_EXTERN bool arwIsRunning();

    ARX_EXTERN bool arwIsInited();

    ARX_EXTERN bool arwStopRunning();

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

    enum {
        ARW_H_ALIGN_LEFT,       
        ARW_H_ALIGN_CENTRE,     
        ARW_H_ALIGN_RIGHT       
    };

    enum {
        ARW_V_ALIGN_TOP,        
        ARW_V_ALIGN_CENTRE,     
        ARW_V_ALIGN_BOTTOM      
    };

    enum {
        ARW_SCALE_MODE_STRETCH, 
        ARW_SCALE_MODE_FIT,     
        ARW_SCALE_MODE_FILL,    
        ARW_SCALE_MODE_1_TO_1   
    };

    ARX_EXTERN bool arwGetProjectionMatrix(const float nearPlane, const float farPlane, float p[16]);

    ARX_EXTERN bool arwGetProjectionMatrixStereo(const float nearPlane, const float farPlane, float pL[16], float pR[16]);
 
    ARX_EXTERN bool arwGetProjectionMatrixForViewportSizeAndFittingMode(const int width, const int height, const int scaleMode, const int hAlign, const int vAlign, const float nearPlane, const float farPlane, float p[16]);
 
    ARX_EXTERN bool arwGetProjectionMatrixForViewportSizeAndFittingModeStereo(const int width, const int height, const int scaleMode, const int hAlign, const int vAlign, const float nearPlane, const float farPlane, float pL[16], float pR[16]);

    ARX_EXTERN bool arwGetVideoParams(int *width, int *height, int *pixelSize, char *pixelFormatStringBuffer, int pixelFormatStringBufferLen);

    ARX_EXTERN bool arwGetVideoParamsStereo(int *widthL, int *heightL, int *pixelSizeL, char *pixelFormatStringBufferL, int pixelFormatStringBufferLenL, int *widthR, int *heightR, int *pixelSizeR, char *pixelFormatStringBufferR, int pixelFormatStringBufferLenR);

    ARX_EXTERN bool arwCapture();

    ARX_EXTERN bool arwUpdateAR();
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Video push interface.
    // ----------------------------------------------------------------------------------------------------
    ARX_EXTERN int arwVideoPushInit(int videoSourceIndex, int width, int height, const char *pixelFormat, int cameraIndex, int cameraPosition);
    ARX_EXTERN int arwVideoPush(int videoSourceIndex,
                                uint8_t *buf0p, int buf0Size, int buf0PixelStride, int buf0RowStride,
                                uint8_t *buf1p, int buf1Size, int buf1PixelStride, int buf1RowStride,
                                uint8_t *buf2p, int buf2Size, int buf2PixelStride, int buf2RowStride,
                                uint8_t *buf3p, int buf3Size, int buf3PixelStride, int buf3RowStride,
                                PFN_VIDEOPUSHRELEASECALLBACK releaseCallback, void *releaseCallbackUserdata);
    ARX_EXTERN int arwVideoPushFinal(int videoSourceIndex);
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Video stream retrieval and/or drawing.
    // ----------------------------------------------------------------------------------------------------

    ARX_EXTERN bool arwUpdateTexture32(uint32_t *buffer);

    ARX_EXTERN bool arwUpdateTexture32Stereo(uint32_t *bufferL, uint32_t *bufferR);

    ARX_EXTERN bool arwDrawVideoInit(const int videoSourceIndex);

    ARX_EXTERN bool arwDrawVideoSettings(int videoSourceIndex, int width, int height, bool rotate90, bool flipH, bool flipV, int hAlign, int vAlign, int scalingMode, int32_t viewport[4]);

    ARX_EXTERN bool arwDrawVideo(const int videoSourceIndex);

    ARX_EXTERN bool arwDrawVideoFinal(const int videoSourceIndex);
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Tracking configuration
    // ----------------------------------------------------------------------------------------------------
    enum {
        ARW_TRACKER_OPTION_NFT_MULTIMODE = 0,                          
        ARW_TRACKER_OPTION_SQUARE_THRESHOLD = 1,                       
        ARW_TRACKER_OPTION_SQUARE_THRESHOLD_MODE = 2,                  
        ARW_TRACKER_OPTION_SQUARE_LABELING_MODE = 3,                   
        ARW_TRACKER_OPTION_SQUARE_PATTERN_DETECTION_MODE = 4,          
        ARW_TRACKER_OPTION_SQUARE_BORDER_SIZE = 5,                     
        ARW_TRACKER_OPTION_SQUARE_MATRIX_CODE_TYPE = 6,                
        ARW_TRACKER_OPTION_SQUARE_IMAGE_PROC_MODE = 7,                 
        ARW_TRACKER_OPTION_SQUARE_DEBUG_MODE = 8,                      
        ARW_TRACKER_OPTION_SQUARE_PATTERN_SIZE = 9,                    
        ARW_TRACKER_OPTION_SQUARE_PATTERN_COUNT_MAX = 10,              
        ARW_TRACKER_OPTION_2D_TRACKER_FEATURE_TYPE = 11,               
        ARW_TRACKER_OPTION_2D_MAXIMUM_MARKERS_TO_TRACK = 12,           
        ARW_TRACKER_OPTION_SQUARE_MATRIX_MODE_AUTOCREATE_NEW_TRACKABLES = 13, 
        ARW_TRACKER_OPTION_SQUARE_MATRIX_MODE_AUTOCREATE_NEW_TRACKABLES_DEFAULT_WIDTH = 14, 
        ARW_TRACKER_OPTION_2D_THREADED = 15,                           
    };

    ARX_EXTERN void arwSetTrackerOptionBool(int option, bool value);

    ARX_EXTERN void arwSetTrackerOptionInt(int option, int value);

    ARX_EXTERN void arwSetTrackerOptionFloat(int option, float value);

    ARX_EXTERN bool arwGetTrackerOptionBool(int option);

    ARX_EXTERN int arwGetTrackerOptionInt(int option);

    ARX_EXTERN float arwGetTrackerOptionFloat(int option);
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Trackable management
    // ----------------------------------------------------------------------------------------------------

    ARX_EXTERN int arwAddTrackable(const char *cfg);
 
#pragma pack(push, 4)
    typedef struct {
        int uid;
        bool visible;
        float matrix[16];
        float matrixR[16]; // For stereo.
    } ARWTrackableStatus;
#pragma pack(pop)

    ARX_EXTERN int arwGetTrackableCount(void);

    ARX_EXTERN bool arwGetTrackableStatuses(ARWTrackableStatus *statuses, int statusesCount);

    ARX_EXTERN bool arwRemoveTrackable(int trackableUID);

    ARX_EXTERN int arwRemoveAllTrackables();

    ARX_EXTERN bool arwQueryTrackableVisibilityAndTransformation(int trackableUID, float matrix[16]);

    ARX_EXTERN bool arwQueryTrackableVisibilityAndTransformationStereo(int trackableUID, float matrixL[16], float matrixR[16]);

    ARX_EXTERN int arwGetTrackablePatternCount(int trackableUID);

    ARX_EXTERN bool arwGetTrackablePatternConfig(int trackableUID, int patternIndex, float matrix[16], float *width, float *height, int *imageSizeX, int *imageSizeY);

    ARX_EXTERN bool arwGetTrackablePatternImage(int trackableUID, int patternIndex, uint32_t *buffer);

    enum {
        ARW_TRACKABLE_OPTION_TYPE = 0,                             
        ARW_TRACKABLE_OPTION_FILTERED = 1,                         
        ARW_TRACKABLE_OPTION_FILTER_SAMPLE_RATE = 2,               
        ARW_TRACKABLE_OPTION_FILTER_CUTOFF_FREQ = 3,               
        ARW_TRACKABLE_OPTION_SQUARE_USE_CONT_POSE_ESTIMATION = 4,  
        ARW_TRACKABLE_OPTION_SQUARE_CONFIDENCE = 5,                
        ARW_TRACKABLE_OPTION_SQUARE_CONFIDENCE_CUTOFF = 6,         
        ARW_TRACKABLE_OPTION_NFT_SCALE = 7,                        
        ARW_TRACKABLE_OPTION_MULTI_MIN_SUBMARKERS = 8,             
        ARW_TRACKABLE_OPTION_MULTI_MIN_CONF_MATRIX = 9,            
        ARW_TRACKABLE_OPTION_MULTI_MIN_CONF_PATTERN = 10,          
        ARW_TRACKABLE_OPTION_MULTI_MIN_INLIER_PROB = 11,           
        ARW_TRACKABLE_OPTION_SQUARE_WIDTH = 12,                    
        ARW_TRACKABLE_OPTION_2D_SCALE = 13,                        
        ARW_TRACKABLE_OPTION_SQUARE_BARCODE_ID = 14,               
    };
 
    enum
    {
        ARW_TRACKABLE_TYPE_Unknown = -1,       
        ARW_TRACKABLE_TYPE_Square = 0,         
        ARW_TRACKABLE_TYPE_SquareBarcode = 1,  
        ARW_TRACKABLE_TYPE_Multimarker = 2,    
        ARW_TRACKABLE_TYPE_NFT = 3,            
        ARW_TRACKABLE_TYPE_TwoD = 4,           
    };

    ARX_EXTERN void arwSetTrackableOptionBool(int trackableUID, int option, bool value);

    ARX_EXTERN void arwSetTrackableOptionInt(int trackableUID, int option, int value);

    ARX_EXTERN void arwSetTrackableOptionFloat(int trackableUID, int option, float value);

    ARX_EXTERN void arwSetTrackableOptionString(int trackableUID, int option, char *value);

    ARX_EXTERN bool arwGetTrackableOptionBool(int trackableUID, int option);

    ARX_EXTERN int arwGetTrackableOptionInt(int trackableUID, int option);

    ARX_EXTERN float arwGetTrackableOptionFloat(int trackableUID, int option);

    ARX_EXTERN bool arwGetTrackableOptionString(int trackableUID, int option, char *buf, int bufLen);
 
    enum {
        ARW_TRACKABLE_EVENT_TYPE_NONE = 0,
        ARW_TRACKABLE_EVENT_TYPE_AUTOCREATED = 1,
        ARW_TRACKABLE_EVENT_TYPE_AUTOREMOVED = 2,
    };
 
    ARX_EXTERN void arwRegisterTrackableEventCallback(PFN_TRACKABLEEVENTCALLBACK callback);

    ARX_EXTERN bool arwLoad2dTrackableDatabase(const char *databaseFileName);

    ARX_EXTERN bool arwSave2dTrackableDatabase(const char *databaseFileName);
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Utility
    // ----------------------------------------------------------------------------------------------------
    ARX_EXTERN bool arwLoadOpticalParams(const char *optical_param_name, const char *optical_param_buff, const int optical_param_buffLen, const float projectionNearPlane, const float projectionFarPlane, float *fovy_p, float *aspect_p, float m[16], float p[16]);
 
    // ----------------------------------------------------------------------------------------------------
#pragma mark  Video source info list management
    // ----------------------------------------------------------------------------------------------------

    ARX_EXTERN int arwCreateVideoSourceInfoList(const char *config);

    ARX_EXTERN bool arwGetVideoSourceInfoListEntry(int index, char *nameBuf, int nameBufLen, char *modelBuf, int modelBufLen, char *UIDBuf, int UIDBufLen, uint32_t *flags_p, char *openTokenBuf, int openTokenBufLen);

    ARX_EXTERN void arwDeleteVideoSourceInfoList(void);
 
#ifdef __cplusplus
}
#endif
#endif // !ARX_C_H