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>
 
extern "C" {
 
    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
    // ----------------------------------------------------------------------------------------------------
 
    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 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 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);
    
    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_FIT,     
        ARW_SCALE_MODE_FILL,    
        ARW_SCALE_MODE_STRETCH, 
        ARW_SCALE_MODE_1_TO_1   
    };
    
    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,              
    };
    
    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);
    
    typedef struct {
        int uid;
        bool visible;
        float matrix[16];
        float matrixR[16]; // For stereo.
    } ARWTrackableStatus;
    
    ARX_EXTERN bool arwGetTrackables(int *count_p, ARWTrackableStatus **statuses_p);
    
    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 patternID, float matrix[16], float *width, float *height, int *imageSizeX, int *imageSizeY);
    
    ARX_EXTERN bool arwGetTrackablePatternImage(int trackableUID, int patternID, uint32_t *buffer);
    
    enum {
        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,           
    };
    
    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 bool arwGetTrackableOptionBool(int trackableUID, int option);
    
    ARX_EXTERN int arwGetTrackableOptionInt(int trackableUID, int option);
    
    ARX_EXTERN float arwGetTrackableOptionFloat(int trackableUID, int option);
    
    // ----------------------------------------------------------------------------------------------------
#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]);
}
 
#endif // !ARX_C_H