bool ofxArtool5::setupCamera(string pthCamParam, ofVec2f _camSize, ofVec2f _viewportSize, ofPixelFormat pf){
ARParam cParam;
AR_PIXEL_FORMAT pixFormat = toAR(pf);
const char * cPathCamParam = ofToDataPath(pthCamParam).c_str();
camSize=_camSize;
viewportSize=_viewportSize;
if(arParamLoad(cPathCamParam, 1, &cParam)){
ofLogError("ofxArtool5::setupCamera()", "error loading param file");
return false;
}
if(cParam.xsize!=camSize.x||cParam.ysize!=camSize.y){
ofLogWarning("ofxArtool5::setupCamera()","camera param needs resizing");
arParamChangeSize(&cParam, camSize.x, camSize.y, &cParam);
}
if((gCparamLT = arParamLTCreate(&cParam, AR_PARAM_LT_DEFAULT_OFFSET))==NULL){
ofLogError("ofxArtool5::setupCamera()","Error: arParamLTCreate");
return false;
}
if(artMode==ART_PATTERN){
if((gARHandle = arCreateHandle(gCparamLT))==NULL){
ofLogError("ofxArtool5::setupCamera()","Error: arCreateHandle");
return false;
}
if(arSetPixelFormat(gARHandle, pixFormat)<0){
ofLogError("ofxArtool5::setupCamera()","Error arSetPixelFormat");
return false;
}
if(arSetDebugMode(gARHandle, AR_DEBUG_DISABLE)<0){
ofLogError("ofxArtool5::setupCamera()","Error arSetDebugMode");
return false;
}
if((gAR3DHandle = ar3DCreateHandle(&cParam))==NULL){
ofLogError("ofxArtool5::setupCamera()","Error ar3DCreateHandle");
return false;
}
}else if(artMode==ART_NFT){
arglCameraFrustumRH(&(gCparamLT->param), getMinDistance(), getMaxDistance(), cameraLens);
}
cvColorFrame.allocate(camSize.x, camSize.y);
cvGrayFrame.allocate(camSize.x, camSize.y);
return true;
}
int main(int argc, char** argv)
{
char glutGamemode[32] = "";
char *vconf = NULL;
char cparaDefault[] = "../share/artoolkit-examples/Data/camera_para.dat";
char *cpara = NULL;
int i;
int gotTwoPartOption;
const char markerConfigDataFilename[] = "../share/artoolkit-examples/Data/markers.dat";
const char objectDataFilename[] = "../share/artoolkit-examples/Data/objects.dat";
//
// Process command-line options.
//
glutInit(&argc, argv);
i = 1; // argv[0] is name of app, so start at 1.
while (i < argc) {
gotTwoPartOption = FALSE;
// Look for two-part options first.
if ((i + 1) < argc) {
if (strcmp(argv[i], "--vconf") == 0) {
i++;
vconf = argv[i];
gotTwoPartOption = TRUE;
} else if (strcmp(argv[i], "--cpara") == 0) {
i++;
cpara = argv[i];
gotTwoPartOption = TRUE;
} else if (strcmp(argv[i],"--width") == 0) {
i++;
// Get width from second field.
if (sscanf(argv[i], "%d", &prefWidth) != 1) {
ARLOGe("Error: --width option must be followed by desired width.\n");
}
gotTwoPartOption = TRUE;
} else if (strcmp(argv[i],"--height") == 0) {
i++;
// Get height from second field.
if (sscanf(argv[i], "%d", &prefHeight) != 1) {
ARLOGe("Error: --height option must be followed by desired height.\n");
}
gotTwoPartOption = TRUE;
} else if (strcmp(argv[i],"--refresh") == 0) {
i++;
// Get refresh rate from second field.
if (sscanf(argv[i], "%d", &prefRefresh) != 1) {
ARLOGe("Error: --refresh option must be followed by desired refresh rate.\n");
}
gotTwoPartOption = TRUE;
}
}
if (!gotTwoPartOption) {
// Look for single-part options.
if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-help") == 0 || strcmp(argv[i], "-h") == 0) {
usage(argv[0]);
} else if (strncmp(argv[i], "-cpara=", 7) == 0) {
cpara = &(argv[i][7]);
} else if (strcmp(argv[i], "--version") == 0 || strcmp(argv[i], "-version") == 0 || strcmp(argv[i], "-v") == 0) {
ARLOG("%s version %s\n", argv[0], AR_HEADER_VERSION_STRING);
exit(0);
} else if (strcmp(argv[i],"--windowed") == 0) {
prefWindowed = TRUE;
} else if (strcmp(argv[i],"--fullscreen") == 0) {
prefWindowed = FALSE;
} else {
ARLOGe("Error: invalid command line argument '%s'.\n", argv[i]);
usage(argv[0]);
}
}
i++;
}
//
// Video setup.
//
if (!setupCamera((cpara ? cpara : cparaDefault), vconf, &gCparamLT)) {
ARLOGe("main(): Unable to set up AR camera.\n");
exit(-1);
}
//
// AR init.
//
// Init AR.
gARPattHandle = arPattCreateHandle();
if (!gARPattHandle) {
ARLOGe("Error creating pattern handle.\n");
exit(-1);
}
gARHandle = arCreateHandle(gCparamLT);
if (!gARHandle) {
ARLOGe("Error creating AR handle.\n");
exit(-1);
}
arPattAttach(gARHandle, gARPattHandle);
if (arSetPixelFormat(gARHandle, arVideoGetPixelFormat()) < 0) {
ARLOGe("Error setting pixel format.\n");
exit(-1);
}
gAR3DHandle = ar3DCreateHandle(&gCparamLT->param);
if (!gAR3DHandle) {
ARLOGe("Error creating 3D handle.\n");
exit(-1);
}
//
// Markers setup.
//
// Load marker(s).
newMarkers(markerConfigDataFilename, gARPattHandle, &markersSquare, &markersSquareCount, &gARPattDetectionMode);
ARLOGi("Marker count = %d\n", markersSquareCount);
//
// Other ARToolKit setup.
//
arSetMarkerExtractionMode(gARHandle, AR_USE_TRACKING_HISTORY_V2);
//arSetMarkerExtractionMode(gARHandle, AR_NOUSE_TRACKING_HISTORY);
//arSetLabelingThreshMode(gARHandle, AR_LABELING_THRESH_MODE_MANUAL); // Uncomment to force manual thresholding.
// Set the pattern detection mode (template (pictorial) vs. matrix (barcode) based on
// the marker types as defined in the marker config. file.
arSetPatternDetectionMode(gARHandle, gARPattDetectionMode); // Default = AR_TEMPLATE_MATCHING_COLOR
// Other application-wide marker options. Once set, these apply to all markers in use in the application.
// If you are using standard ARToolKit picture (template) markers, leave commented to use the defaults.
// If you are usign a different marker design (see http://www.artoolworks.com/support/app/marker.php )
// then uncomment and edit as instructed by the marker design application.
//arSetLabelingMode(gARHandle, AR_LABELING_BLACK_REGION); // Default = AR_LABELING_BLACK_REGION
//arSetBorderSize(gARHandle, 0.25f); // Default = 0.25f
//arSetMatrixCodeType(gARHandle, AR_MATRIX_CODE_3x3); // Default = AR_MATRIX_CODE_3x3
//
// Graphics setup.
//
// Set up GL context(s) for OpenGL to draw into.
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
if (prefWindowed) {
if (prefWidth > 0 && prefHeight > 0) glutInitWindowSize(prefWidth, prefHeight);
else glutInitWindowSize(gCparamLT->param.xsize, gCparamLT->param.ysize);
glutCreateWindow(argv[0]);
} else {
if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE)) {
if (prefWidth && prefHeight) {
if (prefDepth) {
if (prefRefresh) snprintf(glutGamemode, sizeof(glutGamemode), "%ix%i:%i@%i", prefWidth, prefHeight, prefDepth, prefRefresh);
else snprintf(glutGamemode, sizeof(glutGamemode), "%ix%i:%i", prefWidth, prefHeight, prefDepth);
} else {
if (prefRefresh) snprintf(glutGamemode, sizeof(glutGamemode), "%ix%i@%i", prefWidth, prefHeight, prefRefresh);
else snprintf(glutGamemode, sizeof(glutGamemode), "%ix%i", prefWidth, prefHeight);
}
} else {
prefWidth = glutGameModeGet(GLUT_GAME_MODE_WIDTH);
prefHeight = glutGameModeGet(GLUT_GAME_MODE_HEIGHT);
snprintf(glutGamemode, sizeof(glutGamemode), "%ix%i", prefWidth, prefHeight);
}
glutGameModeString(glutGamemode);
glutEnterGameMode();
} else {
if (prefWidth > 0 && prefHeight > 0) glutInitWindowSize(prefWidth, prefHeight);
glutCreateWindow(argv[0]);
glutFullScreen();
}
}
// Create the OpenGL projection from the calibrated camera parameters.
arglCameraFrustumRH(&(gCparamLT->param), VIEW_DISTANCE_MIN, VIEW_DISTANCE_MAX, cameraLens);
cameraPoseValid = FALSE;
// Setup ARgsub_lite library for current OpenGL context.
if ((gArglSettings = arglSetupForCurrentContext(&(gCparamLT->param), arVideoGetPixelFormat())) == NULL) {
ARLOGe("main(): arglSetupForCurrentContext() returned error.\n");
cleanup();
exit(-1);
}
arglSetupDebugMode(gArglSettings, gARHandle);
// Load objects (i.e. OSG models).
VirtualEnvironmentInit(objectDataFilename);
VirtualEnvironmentHandleARViewUpdatedCameraLens(cameraLens);
//
// Setup complete. Start tracking.
//
// Start the video.
if (arVideoCapStart() != 0) {
ARLOGe("setupCamera(): Unable to begin camera data capture.\n");
return (FALSE);
}
arUtilTimerReset();
// Register GLUT event-handling callbacks.
// NB: mainLoop() is registered by Visibility.
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutVisibilityFunc(Visibility);
glutKeyboardFunc(Keyboard);
glutMainLoop();
return (0);
}
static void nativeVideoGetCparamCallback(const ARParam *cparam_p, void *userdata)
{
// Load the camera parameters, resize for the window and init.
ARParam cparam;
if (cparam_p) cparam = *cparam_p;
else {
LOGE("Unable to automatically determine camera parameters. Using default.\n");
if (arParamLoad(cparaName, 1, &cparam) < 0) {
LOGE("Error: Unable to load parameter file %s for camera.\n", cparaName);
return;
}
}
if (cparam.xsize != videoWidth || cparam.ysize != videoHeight) {
#ifdef DEBUG
LOGI("*** Camera Parameter resized from %d, %d. ***\n", cparam.xsize, cparam.ysize);
#endif
arParamChangeSize(&cparam, videoWidth, videoHeight, &cparam);
}
#ifdef DEBUG
LOGI("*** Camera Parameter ***\n");
arParamDisp(&cparam);
#endif
if ((gCparamLT = arParamLTCreate(&cparam, AR_PARAM_LT_DEFAULT_OFFSET)) == NULL) {
LOGE("Error: arParamLTCreate.\n");
return;
}
videoInited = true;
//
// AR init.
//
// Create the OpenGL projection from the calibrated camera parameters.
arglCameraFrustumRHf(&gCparamLT->param, NEAR_PLANE, FAR_PLANE, cameraLens);
cameraPoseValid = FALSE;
// Init AR.
arHandle = arCreateHandle(gCparamLT);
if (arHandle == NULL) {
LOGE("Error creating AR handle");
return;
}
arPattAttach(arHandle, arPattHandle);
if (arSetPixelFormat(arHandle, gPixFormat) < 0) {
LOGE("Error setting pixel format");
return;
}
ar3DHandle = ar3DCreateHandle(&gCparamLT->param);
if (ar3DHandle == NULL) {
LOGE("Error creating 3D handle");
return;
}
// Other ARToolKit setup.
arSetMarkerExtractionMode(arHandle, AR_USE_TRACKING_HISTORY_V2);
//arSetMarkerExtractionMode(arHandle, AR_NOUSE_TRACKING_HISTORY);
//arSetLabelingThreshMode(arHandle, AR_LABELING_THRESH_MODE_MANUAL); // Uncomment to use manual thresholding.
// Set the pattern detection mode (template (pictorial) vs. matrix (barcode) based on
// the marker types as defined in the marker config. file.
arSetPatternDetectionMode(arHandle, arPattDetectionMode); // Default = AR_TEMPLATE_MATCHING_COLOR
// Other application-wide marker options. Once set, these apply to all markers in use in the application.
// If you are using standard ARToolKit picture (template) markers, leave commented to use the defaults.
// If you are usign a different marker design (see http://www.artoolworks.com/support/app/marker.php )
// then uncomment and edit as instructed by the marker design application.
//arSetLabelingMode(arHandle, AR_LABELING_BLACK_REGION); // Default = AR_LABELING_BLACK_REGION
//arSetBorderSize(arHandle, 0.25f); // Default = 0.25f
//arSetMatrixCodeType(arHandle, AR_MATRIX_CODE_3x3); // Default = AR_MATRIX_CODE_3x3
}
static int setupCamera(const char *cparam_name, char *vconf, ARParamLT **cparamLT_p, ARHandle **arhandle, AR3DHandle **ar3dhandle)
{
ARParam cparam;
int xsize, ysize;
AR_PIXEL_FORMAT pixFormat;
// Open the video path.
if (arVideoOpen(vconf) < 0) {
ARLOGe("setupCamera(): Unable to open connection to camera.\n");
return (FALSE);
}
// Find the size of the window.
if (arVideoGetSize(&xsize, &ysize) < 0) {
ARLOGe("setupCamera(): Unable to determine camera frame size.\n");
arVideoClose();
return (FALSE);
}
ARLOGi("Camera image size (x,y) = (%d,%d)\n", xsize, ysize);
// Get the format in which the camera is returning pixels.
pixFormat = arVideoGetPixelFormat();
if (pixFormat == AR_PIXEL_FORMAT_INVALID) {
ARLOGe("setupCamera(): Camera is using unsupported pixel format.\n");
arVideoClose();
return (FALSE);
}
// Load the camera parameters, resize for the window and init.
if (arParamLoad(cparam_name, 1, &cparam) < 0) {
ARLOGe("setupCamera(): Error loading parameter file %s for camera.\n", cparam_name);
arVideoClose();
return (FALSE);
}
if (cparam.xsize != xsize || cparam.ysize != ysize) {
ARLOGw("*** Camera Parameter resized from %d, %d. ***\n", cparam.xsize, cparam.ysize);
arParamChangeSize(&cparam, xsize, ysize, &cparam);
}
#ifdef DEBUG
ARLOG("*** Camera Parameter ***\n");
arParamDisp(&cparam);
#endif
if ((*cparamLT_p = arParamLTCreate(&cparam, AR_PARAM_LT_DEFAULT_OFFSET)) == NULL) {
ARLOGe("setupCamera(): Error: arParamLTCreate.\n");
arVideoClose();
return (FALSE);
}
if ((*arhandle = arCreateHandle(*cparamLT_p)) == NULL) {
ARLOGe("setupCamera(): Error: arCreateHandle.\n");
return (FALSE);
}
if (arSetPixelFormat(*arhandle, pixFormat) < 0) {
ARLOGe("setupCamera(): Error: arSetPixelFormat.\n");
return (FALSE);
}
if (arSetDebugMode(*arhandle, AR_DEBUG_DISABLE) < 0) {
ARLOGe("setupCamera(): Error: arSetDebugMode.\n");
return (FALSE);
}
if ((*ar3dhandle = ar3DCreateHandle(&cparam)) == NULL) {
ARLOGe("setupCamera(): Error: ar3DCreateHandle.\n");
return (FALSE);
}
if (arVideoCapStart() != 0) {
ARLOGe("setupCamera(): Unable to begin camera data capture.\n");
return (FALSE);
}
return (TRUE);
}
static void init(int argc, char *argv[])
{
ARParam cparam;
ARGViewport viewport;
ARPattHandle *arPattHandle;
char vconf[512];
AR_PIXEL_FORMAT pixFormat;
ARUint32 id0, id1;
int i;
if (argc == 1)
vconf[0] = '\0';
else
{
strcpy(vconf, argv[1]);
for (i = 2; i < argc; i++)
{
strcat(vconf, " "); strcat(vconf, argv[i]);
}
}
/* open the video path */
if (arVideoOpen(vconf) < 0)
exit(0);
if (arVideoGetSize(&xsize, &ysize) < 0)
exit(0);
ARLOG("Image size (x,y) = (%d,%d)\n", xsize, ysize);
if ((pixFormat = arVideoGetPixelFormat()) < 0)
exit(0);
if (arVideoGetId(&id0, &id1) == 0)
{
ARLOG("Camera ID = (%08x, %08x)\n", id1, id0);
sprintf(vconf, VPARA_NAME, id1, id0);
if (arVideoLoadParam(vconf) < 0)
{
ARLOGe("No camera setting data!!\n");
}
}
/* set the initial camera parameters */
if (arParamLoad(CPARA_NAME, 1, &cparam) < 0)
{
ARLOGe("Camera parameter load error !!\n");
exit(0);
}
arParamChangeSize(&cparam, xsize, ysize, &cparam);
ARLOG("*** Camera Parameter ***\n");
arParamDisp(&cparam);
if ((gCparamLT = arParamLTCreate(&cparam, AR_PARAM_LT_DEFAULT_OFFSET)) == NULL)
{
ARLOGe("Error: arParamLTCreate.\n");
exit(-1);
}
if ((arHandle = arCreateHandle(gCparamLT)) == NULL)
{
ARLOGe("Error: arCreateHandle.\n");
exit(0);
}
if (arSetPixelFormat(arHandle, pixFormat) < 0)
{
ARLOGe("Error: arSetPixelFormat.\n");
exit(0);
}
if ((ar3DHandle = ar3DCreateHandle(&cparam)) == NULL)
{
ARLOGe("Error: ar3DCreateHandle.\n");
exit(0);
}
if ((arPattHandle = arPattCreateHandle()) == NULL)
{
ARLOGe("Error: arPattCreateHandle.\n");
exit(0);
}
if ((patt_id = arPattLoad(arPattHandle, PATT_NAME)) < 0)
{
ARLOGe("pattern load error !!\n");
exit(0);
}
arPattAttach(arHandle, arPattHandle);
/* open the graphics window */
w1 = argCreateWindow(xsize, ysize);
viewport.sx = 0;
viewport.sy = 0;
viewport.xsize = xsize;
viewport.ysize = ysize;
if ((vp1 = argCreateViewport(&viewport)) == NULL)
exit(0);
argViewportSetCparam(vp1, &cparam);
argViewportSetPixFormat(vp1, pixFormat);
argViewportSetDispMethod(vp1, AR_GL_DISP_METHOD_TEXTURE_MAPPING_FRAME);
argViewportSetDispMode(vp1, AR_GL_DISP_MODE_FIT_TO_VIEWPORT);
argViewportSetDistortionMode(vp1, AR_GL_DISTORTION_COMPENSATE_ENABLE);
w2 = argCreateWindow(xsize, ysize);
viewport.sx = 0;
viewport.sy = 0;
viewport.xsize = xsize;
viewport.ysize = ysize;
if ((vp2 = argCreateViewport(&viewport)) == NULL)
exit(0);
argViewportSetCparam(vp2, &cparam);
argViewportSetPixFormat(vp2, pixFormat);
argViewportSetDispMethod(vp2, AR_GL_DISP_METHOD_TEXTURE_MAPPING_FRAME);
argViewportSetDispMode(vp2, AR_GL_DISP_MODE_FIT_TO_VIEWPORT);
argViewportSetDistortionMode(vp2, AR_GL_DISTORTION_COMPENSATE_DISABLE);
return;
}
static void init( void )
{
ARParam cparam;
ARParamLT *cparamLT;
ARGViewport viewport;
xsize = 640;
ysize = 480;
ARLOGi("Image size (x,y) = (%d,%d)\n", xsize, ysize);
/* set the initial camera parameters */
arParamClear(&cparam, xsize, ysize, AR_DIST_FUNCTION_VERSION_DEFAULT);
ARLOG("*** Camera Parameter ***\n");
arParamDisp( &cparam );
//COVHI10445 ignored as false positive, i.e. cparam->m[3][4] uninitialized.
cparamLT = arParamLTCreate(&cparam, AR_PARAM_LT_DEFAULT_OFFSET);
arHandle = arCreateHandle(cparamLT);
if( arHandle == NULL ) {
ARLOGe("Error: arCreateHandle.\n");
exit(0);
}
arSetPixelFormat( arHandle, PIXEL_FORMAT );
arSetLabelingMode( arHandle, AR_LABELING_BLACK_REGION );
arSetImageProcMode( arHandle, AR_IMAGE_PROC_FRAME_IMAGE );
ar3DHandle = ar3DCreateHandle( &cparam );
if( ar3DHandle == NULL ) {
ARLOGe("Error: ar3DCreateHandle.\n");
exit(0);
}
/* open the graphics window */
viewport.sx = 0;
viewport.sy = 0;
viewport.xsize = xsize;
viewport.ysize = ysize;
vp = argCreateViewport( &viewport );
if( vp == NULL ) exit(0);
argViewportSetCparam( vp, &cparam );
argViewportSetPixFormat( vp, PIXEL_FORMAT );
argViewportSetDispMode( vp, AR_GL_DISP_MODE_FIT_TO_VIEWPORT );
argViewportSetDispMethod( vp, AR_GL_DISP_METHOD_GL_DRAW_PIXELS );
//argViewportSetDispMethod( vp, AR_GL_DISP_METHOD_TEXTURE_MAPPING_FRAME );
//argViewportSetDispMethod( vp, AR_GL_DISP_METHOD_TEXTURE_MAPPING_FIELD );
argViewportSetDistortionMode( vp, AR_GL_DISTORTION_COMPENSATE_DISABLE );
//argViewportSetDistortionMode( vp, AR_GL_DISTORTION_COMPENSATE_ENABLE );
#if 0
if( argSetFullScreenConfig("1024x768") == 0 ) {
ARLOGe("Full screen is not possible.\n");
exit(0);
}
//argGetWindowSizeFullScreen( &viewport.xsize, &viewport.ysize );
viewport.sx = 0;
viewport.sy = 0;
viewport.xsize = 1024;
viewport.ysize = 768;
argViewportSetViewportFullScreen( vpL, &viewport );
viewport.sx = 1024;
argViewportSetViewportFullScreen( vpR, &viewport );
#endif
}
bool
ARToolKit4NFTTracker::init(int xsize,int ysize,
const std::string& pattlist_name,const std::string& camera_name)
{
ARParam wparam;
// Set the initial camera parameters.
if(arParamLoad((char*)camera_name.c_str(), 1, &wparam) < 0) {
std::cerr << "ERROR: Camera parameter load error." << std::endl;
return false;
}
arParamChangeSize(&wparam, xsize, ysize, &cparam);
std::cout << "*** Camera Parameter ***" << std::endl;
arParamDisp( &cparam );
if( (arHandle = arCreateHandle(&cparam)) == NULL )
{
std::cerr << "ERROR: arCreateHandle." << std::endl;
return false;
}
int pixFormat = AR_PIXEL_FORMAT_BGRA;
if( arSetPixelFormat(arHandle, pixFormat) < 0 )
{
std::cerr << "Error: arSetPixelFormat." << std::endl;
return false;
}
if( arSetDebugMode(arHandle, AR_DEBUG_DISABLE) < 0 )
{
std::cerr << "Error: arSetDebugMode." << std::endl;
return false;
}
if( arSetLabelingThresh(arHandle,threshold) < 0 )
{
std::cerr << "Error: arSetLabelingThresh." << std::endl;
return false;
}
arSetMarkerExtractionMode( arHandle, AR_NOUSE_TRACKING_HISTORY );
if( (ar3DHandle=ar3DCreateHandle(&cparam)) == NULL )
{
std::cerr << "Error: ar3DCreateHandle." << std::endl;
return false;
}
if( (arPattHandle=arPattCreateHandle()) == NULL )
{
std::cerr << "Error: arPattCreateHandle." << std::endl;
return false;
}
setProjection(10.0f, 10000.0f);
//INIT NFT
int matchingImageMode = AR2_MATCHING_FRAME_IMAGE;
int matchingMethod = AR2_MATCHING_FINE;
int debugMode = 0;
ar2Handle = ar2CreateHandle( &cparam, pixFormat );
ar2ChangeMacthingImageMode( ar2Handle, matchingImageMode );
ar2ChangeMacthingMethod( ar2Handle, matchingMethod );
ar2ChangeDebugMode( ar2Handle, debugMode );
//arFittingMode = AR_FITTING_TO_IDEAL;
//arImageProcMode = AR_IMAGE_PROC_IN_FULL;
if (!setupMarkers(pattlist_name)) {
std::cerr << "ERROR: Marker setup failed." << std::endl;
return false;
}
return true;
}