自学教程：C++ ARLOGe函数代码示例

// References globals: markersNFTCount// Modifies globals: threadHandle, surfaceSet[], surfaceSetCount, markersNFT[]static int loadNFTData(void){    int i;	KpmRefDataSet *refDataSet;        // If data was already loaded, stop KPM tracking thread and unload previously loaded data.    if (threadHandle) {        ARLOGi("Reloading NFT data./n");        unloadNFTData();    } else {        ARLOGi("Loading NFT data./n");    }        refDataSet = NULL;        for (i = 0; i < markersNFTCount; i++) {        // Load KPM data.        KpmRefDataSet  *refDataSet2;        ARLOGi("Reading %s.fset3/n", markersNFT[i].datasetPathname);        if (kpmLoadRefDataSet(markersNFT[i].datasetPathname, "fset3", &refDataSet2) < 0 ) {            ARLOGe("Error reading KPM data from %s.fset3/n", markersNFT[i].datasetPathname);            markersNFT[i].pageNo = -1;            continue;        }        markersNFT[i].pageNo = surfaceSetCount;        ARLOGi("  Assigned page no. %d./n", surfaceSetCount);        if (kpmChangePageNoOfRefDataSet(refDataSet2, KpmChangePageNoAllPages, surfaceSetCount) < 0) {            ARLOGe("Error: kpmChangePageNoOfRefDataSet/n");            exit(-1);        }        if (kpmMergeRefDataSet(&refDataSet, &refDataSet2) < 0) {            ARLOGe("Error: kpmMergeRefDataSet/n");            exit(-1);        }        ARLOGi("  Done./n");                // Load AR2 data.        ARLOGi("Reading %s.fset/n", markersNFT[i].datasetPathname);                if ((surfaceSet[surfaceSetCount] = ar2ReadSurfaceSet(markersNFT[i].datasetPathname, "fset", NULL)) == NULL ) {            ARLOGe("Error reading data from %s.fset/n", markersNFT[i].datasetPathname);        }        ARLOGi("  Done./n");                surfaceSetCount++;        if (surfaceSetCount == PAGES_MAX) break;    }    if (kpmSetRefDataSet(kpmHandle, refDataSet) < 0) {        ARLOGe("Error: kpmSetRefDataSet/n");        exit(-1);    }    kpmDeleteRefDataSet(&refDataSet);        // Start the KPM tracking thread.    threadHandle = trackingInitInit(kpmHandle);    if (!threadHandle) exit(-1);	ARLOGi("Loading of NFT data complete./n");    return (TRUE);}

virtual bool onFrameBuffer(void *buffer, int bufferSize){    int  frameIndex;    bool ret;    if (!isConnected() || !buffer || bufferSize <= 0)    {        ARLOGe("Error: onFrameBuffer() called while not connected, or called without frame./n");        return false;    }    ret = true;    m_framesReceived++;    pthread_mutex_lock(&m_nc->frameLock);    if (m_nc->frameBuffers[0] && m_nc->frameBuffers[1])       // Only do copy if capture has been started.    {        if (bufferSize != m_nc->frameBufferLength)        {            ARLOGe("Error: onFrameBuffer frame size is %d but receiver expected %d./n", bufferSize, m_nc->frameBufferLength);            ret = false;        }        else        {            // Find a buffer to write to. Any buffer not locked by client is a candidate.            if (m_nc->frameBuffersStatus[0] != LOCKED)                frameIndex = 0;            else if (m_nc->frameBuffersStatus[1] != LOCKED)                frameIndex = 1;            else                frameIndex = -1;            if (frameIndex == -1)            {                ARLOGe("Error: onFrameBuffer receiver was all full up./n");                ret = false;            }            else            {                ARLOGd("FRAME => buffer %d %p/n", frameIndex, m_nc->frameBuffers[frameIndex]);                memcpy(m_nc->frameBuffers[frameIndex], buffer, bufferSize);                m_nc->frameBuffersStatus[frameIndex] = READY;                if (m_nc->frameReadyCallback)                    pthread_cond_signal(&m_nc->frameReadyNotifierThreadCondGo);            }        }    }    else    {        ARLOGd("FRAME =X/n");    }    pthread_mutex_unlock(&m_nc->frameLock);    return ret;}

static void errorWMC(void *userdata){	if (!userdata) {		ARLOGe("Windows.Media.Capture error but no userdata suppplied./n");		return;	}	AR2VideoParamWinMCT *vid = (AR2VideoParamWinMCT *)userdata;	ARLOGe("Windows.Media.Capture error./n");	stopWMC(vid);}

// Report state of ARToolKit tracker.static void debugReportMode(ARGViewportHandle *vp){	if (vp->dispMethod == AR_GL_DISP_METHOD_GL_DRAW_PIXELS) {		ARLOGe("dispMode (d)   : GL_DRAW_PIXELS/n");	} else if (vp->dispMethod == AR_GL_DISP_METHOD_TEXTURE_MAPPING_FRAME) {		ARLOGe("dispMode (d)   : TEXTURE MAPPING (FULL RESOLUTION)/n");	} else {		ARLOGe("dispMode (d)   : TEXTURE MAPPING (HALF RESOLUTION)/n");	}}

static void *trackingInitMain( THREAD_HANDLE_T *threadHandle ){    TrackingInitHandle     *trackingInitHandle;    KpmHandle              *kpmHandle;    KpmResult              *kpmResult = NULL;    int                     kpmResultNum;    ARUint8                *imagePtr;    float                  err;    int                    i, j, k;    if (!threadHandle) {        ARLOGe("Error starting tracking thread: empty THREAD_HANDLE_T./n");        return (NULL);    }    trackingInitHandle = (TrackingInitHandle *)threadGetArg(threadHandle);    if (!threadHandle) {        ARLOGe("Error starting tracking thread: empty trackingInitHandle./n");        return (NULL);    }    kpmHandle          = trackingInitHandle->kpmHandle;    imagePtr           = trackingInitHandle->imagePtr;    if (!kpmHandle || !imagePtr) {        ARLOGe("Error starting tracking thread: empty kpmHandle/imagePtr./n");        return (NULL);    }    ARLOGi("Start tracking thread./n");        kpmGetResult( kpmHandle, &kpmResult, &kpmResultNum );    for(;;) {        if( threadStartWait(threadHandle) < 0 ) break;        kpmMatching(kpmHandle, imagePtr);        trackingInitHandle->flag = 0;        for( i = 0; i < kpmResultNum; i++ ) {            if( kpmResult[i].camPoseF != 0 ) continue;            ARLOGd("kpmGetPose OK./n");            if( trackingInitHandle->flag == 0 || err > kpmResult[i].error ) { // Take the first or best result.                trackingInitHandle->flag = 1;                trackingInitHandle->page = kpmResult[i].pageNo;                for (j = 0; j < 3; j++) for (k = 0; k < 4; k++) trackingInitHandle->trans[j][k] = kpmResult[i].camPose[j][k];                err = kpmResult[i].error;            }        }        threadEndSignal(threadHandle);    }    ARLOGi("End tracking thread./n");    return (NULL);}

int ar2WriteImageSet(char *filename, AR2ImageSetT *imageSet){    FILE          *fp;    AR2JpegImageT jpegImage;    int           i;    size_t        len;    const char    ext[] = ".iset";    char          *buf;    len = strlen(filename) + strlen(ext) + 1; // +1 for nul terminator.    arMalloc(buf, char, len);    sprintf(buf, "%s%s", filename, ext);    if ((fp = fopen(buf, "wb")) == NULL)    {        ARLOGe("Error: unable to open file '%s' for writing./n", buf);        free(buf);        return (-1);    }    free(buf);    if (fwrite(&(imageSet->num), sizeof(imageSet->num), 1, fp) != 1)        goto bailBadWrite;    jpegImage.xsize = imageSet->scale[0]->xsize;    jpegImage.ysize = imageSet->scale[0]->ysize;    jpegImage.dpi   = imageSet->scale[0]->dpi;    jpegImage.nc    = 1;#if AR2_CAPABLE_ADAPTIVE_TEMPLATE    jpegImage.image = imageSet->scale[0]->imgBWBlur[0];#else    jpegImage.image = imageSet->scale[0]->imgBW;#endif    if (ar2WriteJpegImage2(fp, &jpegImage, AR2_DEFAULT_JPEG_IMAGE_QUALITY) < 0)        goto bailBadWrite;    for (i = 1; i < imageSet->num; i++)    {        if (fwrite(&(imageSet->scale[i]->dpi), sizeof(imageSet->scale[i]->dpi), 1, fp) != 1)            goto bailBadWrite;    }    fclose(fp);    return 0;bailBadWrite:    ARLOGe("Error saving image set: error writing data./n");    fclose(fp);    return (-1);}

static int setupCamera(const char *cparam_name, char *vconf, ARParamLT **cparamLT_p){	    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);    }		return (TRUE);}

bool videoAndroidNativeCaptureStart(VIDEO_ANDROID_NATIVE_CAPTURE *nc, AR_VIDEO_FRAME_READY_CALLBACK callback, void *userdata){    int  err;    bool ret = true;    ARLOGd("videoAndroidNativeCaptureStart()./n");    if (!nc)        return false;    // Don't start if already started.    if (nc->frameBuffers[0] || nc->frameBuffers[1])    {        ARLOGe("videoAndroidNativeCaptureStart called again./n");        return false;    }    // Create the frame buffers.    pthread_mutex_lock(&nc->frameLock);    nc->frameBufferLength     = (nc->frameWidth * nc->frameHeight * 3) / 2; // Assume NV21/NV12 format.    nc->frameBuffersStatus[0] = nc->frameBuffersStatus[1] = EMPTY;    nc->frameBuffers[0]       = (unsigned char*)malloc(nc->frameBufferLength);    nc->frameBuffers[1]       = (unsigned char*)malloc(nc->frameBufferLength);    if (!nc->frameBuffers[0] || !nc->frameBuffers[1])    {        ARLOGe("Out of memory!/n");        ret = false;    }    else    {        nc->frameReadyCallback = callback;        if (callback)        {            // Start the frameReadyNotifierThread.            nc->frameReadyCallbackUserdata         = userdata;            nc->frameReadyNotifierThreadShouldQuit = false;            if ((err = pthread_create(&(nc->frameReadyNotifierThread), NULL, frameReadyNotifier, (void*)nc)) != 0)            {                ARLOGe("videoAndroidNativeCaptureOpen(): Error %d detaching thread./n", err);                ret = false;            }        }    }    pthread_mutex_unlock(&nc->frameLock);    ARLOGd("/videoAndroidNativeCaptureStart nc->frameBufferLength=%d./n", nc->frameBufferLength);    return ret;}

bool ARTApp::init(const char *cparamName, const char *pattName, const char *objModelFile, float pattWidth, float modelScale){	if (arHandle) //has initialized		return false;	if (!setupCamera(cparamName, "", &cParam, &arHandle, &ar3DHandle)) {		return false;	}	if (!setupMarker(pattName, &pattID, arHandle, &pattHandle)) {		return false;	}	{		objModel = glmReadOBJ((char*)objModelFile);		if (!objModel)		{			ARLOGe("Unable to load obj model file./n");			return false;		}		glmUnitize(objModel);		glmScale(objModel, pattWidth*modelScale);	}	this->pattWidth = pattWidth;	return true;}

// N.B. This function is duplicated in libARvideo, so that libARvideo doesn't need to// link to libAR. Therefore, if changes are made here they should be duplicated there.const char *arUtilGetPixelFormatName(const AR_PIXEL_FORMAT arPixelFormat){    const char *names[] = {        "AR_PIXEL_FORMAT_RGB",        "AR_PIXEL_FORMAT_BGR",        "AR_PIXEL_FORMAT_RGBA",        "AR_PIXEL_FORMAT_BGRA",        "AR_PIXEL_FORMAT_ABGR",        "AR_PIXEL_FORMAT_MONO",        "AR_PIXEL_FORMAT_ARGB",        "AR_PIXEL_FORMAT_2vuy",        "AR_PIXEL_FORMAT_yuvs",        "AR_PIXEL_FORMAT_RGB_565",        "AR_PIXEL_FORMAT_RGBA_5551",        "AR_PIXEL_FORMAT_RGBA_4444",        "AR_PIXEL_FORMAT_420v",        "AR_PIXEL_FORMAT_420f",        "AR_PIXEL_FORMAT_NV21"    };    if ((int)arPixelFormat < 0 || (int)arPixelFormat > AR_PIXEL_FORMAT_MAX) {        ARLOGe("arUtilGetPixelFormatName: Error, unrecognised pixel format (%d)./n", (int)arPixelFormat);        return (NULL);    }    return (names[(int)arPixelFormat]);}

int ar2VideoGetAbsMaxValue1394(AR2VideoParam1394T *vid, int paramName, ARdouble *value){    dc1394feature_t feature;    float           min, max;    switch (paramName)    {    case AR_VIDEO_1394_GAMMA:        feature = DC1394_FEATURE_GAMMA;        break;    default:        return -1;    }    if (dc1394_feature_get_absolute_boundaries(vid->camera, feature, &min, &max) != DC1394_SUCCESS)    {        ARLOGe("unable to get max value./n");        return -1;    }    *value = (float)max;    return 0;}

static bool startWMC(AR2VideoParamWinMCT *vid, const int width, const int height){	if (!vid || !vid->wmc) return false;	if (vid->wmc->Capturing()) {		ARLOGe("Windows.Media.Capture already started./n");		return false;	}	if (!vid->wmc->StartCapture(width, height, getWMCVideoMediaSubTypeForARPixelFormat(vid->format), vid->devNum - 1, vid->preferredDeviceLocation, errorWMC, (void *)vid)) {		ARLOGe("Error starting capture./n");		return false;	}	return true;}

int main(int argc, char *argv[]){    ARParam cparam;    // ARParamLT          *cparamLT;    float trans[3][4];    float pos[2];    float dpi[2];    // char                name[1024], ext[1024];    int   i, j;    float z;    init(argc, argv);    if (!cpara)        cpara = cparaDefault;    // ar2UtilDivideExt( cpara, name, ext );    // Load the camera parameters, resize for the window and init.    // if( arParamLoad(name, ext, 1, &cparam) < 0 )    if (arParamLoad(cpara, 1, &cparam) < 0)    {        ARLOGe("setupCamera(): Error loading parameter file %s for camera./n", cpara);        exit(-1);    }    if (xsize != -1 && ysize != -1 && (cparam.xsize != xsize || cparam.ysize != ysize))    {        ARLOG("*** Camera Parameter resized from %d, %d. ***/n", cparam.xsize, cparam.ysize);        arParamChangeSize(&cparam, xsize, ysize, &cparam);    }    ARLOG("*** Camera Parameter ***/n");    arParamDisp(&cparam);    // if ((cparamLT = arParamLTCreate(&cparam, AR_PARAM_LT_DEFAULT_OFFSET)) == NULL) {    //    ARLOGe("setupCamera(): Error: arParamLTCreate./n");    //    exit(-1);    // }    pos[0] = 0.0;    pos[1] = 0.0;    for (j = 0; j < 3; j++)        for (i = 0; i < 4; i++)            trans[j][i] = ((i == j) ? 1.0 : 0.0);    for (i = 10; i <= 1000; i *= 10)    {        for (j = 1; j < 10; j++)        {            z           = j * i;            trans[2][3] = z;            ar2GetResolution2(&cparam, trans, pos, dpi);            ARLOG("Distance: %f [mm] --> Resolution = %10.5f, %10.5f [DPI]/n", z, dpi[0], dpi[1]);        }    }    return (0);}

VIDEO_ANDROID_NATIVE_CAPTURE* videoAndroidNativeCaptureOpen(int cameraIndex){    CameraActivity::ErrorCode ca_err;    ARLOGd("videoAndroidNativeCaptureOpen(%d)./n", cameraIndex);    VIDEO_ANDROID_NATIVE_CAPTURE *nc = (VIDEO_ANDROID_NATIVE_CAPTURE*)calloc(1, sizeof(VIDEO_ANDROID_NATIVE_CAPTURE));    if (!nc)    {        ARLOGe("Out of memory!/n");        return (NULL);    }    nc->ca = new ARToolKitVideoAndroidCameraActivity(nc);    if (!nc->ca)    {        ARLOGe("Unable to create native connection to camera./n");        goto bail;    }    // Lock manages contention between user thread, CameraActivity::onFrameBuffer thread (might be same as user thread), and frameReadyNotifierThread.    pthread_mutex_init(&nc->frameLock, NULL);    pthread_cond_init(&nc->frameReadyNotifierThreadCondGo, NULL);    ca_err = nc->ca->connect(cameraIndex);    if (ca_err != CameraActivity::NO_ERROR)    {        ARLOGe("Error %d opening native connection to camera./n", ca_err);        goto bail1;    }    nc->frameWidth  = (int)nc->ca->getProperty(ANDROID_CAMERA_PROPERTY_FRAMEWIDTH);    nc->frameHeight = (int)nc->ca->getProperty(ANDROID_CAMERA_PROPERTY_FRAMEHEIGHT);    ARLOGd("/videoAndroidNativeCaptureOpen %dx%d./n", nc->frameWidth, nc->frameHeight);    return (nc);bail1:    delete(nc->ca);    pthread_cond_destroy(&nc->frameReadyNotifierThreadCondGo);    pthread_mutex_destroy(&nc->frameLock);bail:    free(nc);    return (NULL);}

int arUtilChangeToResourcesDirectory(AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR behavior, const char *path)#endif{    char *wpath;    AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR behaviorW;        if (behavior == AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR_BEST) {#if defined(__APPLE__)        behaviorW = AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR_USE_BUNDLE_RESOURCES_DIR;#elif defined(ANDROID)        behaviorW = AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR_USE_APP_CACHE_DIR;#elif defined(_WIN32) || defined(__linux)        behaviorW = AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR_USE_EXECUTABLE_DIR;#else        behaviorW = AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR_USE_CWD;#endif    } else {        behaviorW = behavior;    }        if (behaviorW != AR_UTIL_RESOURCES_DIRECTORY_BEHAVIOR_USE_SUPPLIED_PATH) {#ifdef ANDROID        wpath = arUtilGetResourcesDirectoryPath(behavior, instanceOfAndroidContext);#else        wpath = arUtilGetResourcesDirectoryPath(behavior);#endif        if (wpath) {            if (chdir(wpath) != 0) {                ARLOGe("Error: Unable to change working directory to '%s'./n", wpath);                ARLOGperror(NULL);                free (wpath);                return (-1);            }            free(wpath);        }    }    if (path) {        if (chdir(path) != 0) {            ARLOGe("Error: Unable to change working directory to '%s'./n", path);            ARLOGperror(NULL);            return (-1);        }    }        return (0);}

void arglCameraFrustumRH(const ARParam *cparam, const ARdouble focalmin, const ARdouble focalmax, ARdouble m_projection[16]){	ARdouble    icpara[3][4];    ARdouble    trans[3][4];    ARdouble    p[3][3], q[4][4];	int         width, height;    int         i, j;	    width  = cparam->xsize;    height = cparam->ysize;	    if (arParamDecompMat(cparam->mat, icpara, trans) < 0) {        ARLOGe("arglCameraFrustum(): arParamDecompMat() indicated parameter error./n");        return;    }	for (i = 0; i < 4; i++) {        icpara[1][i] = (height - 1)*(icpara[2][i]) - icpara[1][i];    }	    for(i = 0; i < 3; i++) {        for(j = 0; j < 3; j++) {            p[i][j] = icpara[i][j] / icpara[2][2];        }    }    q[0][0] = (2.0 * p[0][0] / (width - 1));    q[0][1] = (2.0 * p[0][1] / (width - 1));    q[0][2] = -((2.0 * p[0][2] / (width - 1))  - 1.0);    q[0][3] = 0.0;	    q[1][0] = 0.0;    q[1][1] = -(2.0 * p[1][1] / (height - 1));    q[1][2] = -((2.0 * p[1][2] / (height - 1)) - 1.0);    q[1][3] = 0.0;	    q[2][0] = 0.0;    q[2][1] = 0.0;    q[2][2] = (focalmax + focalmin)/(focalmin - focalmax);    q[2][3] = 2.0 * focalmax * focalmin / (focalmin - focalmax);	    q[3][0] = 0.0;    q[3][1] = 0.0;    q[3][2] = -1.0;    q[3][3] = 0.0;	    for (i = 0; i < 4; i++) { // Row.		// First 3 columns of the current row.        for (j = 0; j < 3; j++) { // Column.            m_projection[i + j*4] = q[i][0] * trans[0][j] +									q[i][1] * trans[1][j] +									q[i][2] * trans[2][j];        }		// Fourth column of the current row.        m_projection[i + 3*4] = q[i][0] * trans[0][3] +								q[i][1] * trans[1][3] +								q[i][2] * trans[2][3] +								q[i][3];    }	}

static int setupMovie(const char *path){    char            *movieVconf;    int             len;    int             xsize, ysize;    AR_PIXEL_FORMAT pixFormat;    // Construct the vconf string.    arMalloc(movieVconf, char, 2048); // 2Kb for URL.    sprintf(movieVconf, "-device=QUICKTIME -movie=/""); // Make sure we're using the QuickTime video input.    len = (int)strlen(movieVconf);    strncat(movieVconf + len, path, 2048 - len - 1);    len = (int)strlen(movieVconf);    strncat(movieVconf + len, "/" -loop -pause", 2048 - len - 1); // Start the movie paused. It will be unpaused in mainLoop().    // Open the movie.    gMovieVideo = ar2VideoOpen(movieVconf);    free(movieVconf);    if (!gMovieVideo)    {        ARLOGe("setupMovie(): Unable to open movie./n");        return (FALSE);    }    // Find the size of the movie.    if (ar2VideoGetSize(gMovieVideo, &xsize, &ysize) < 0)        return (FALSE);    // Get the pixel format of the movie.    pixFormat = ar2VideoGetPixelFormat(gMovieVideo);    if (pixFormat == AR_PIXEL_FORMAT_INVALID)    {        ARLOGe("setupMovie(): Movie is using unsupported pixel format./n");        return (FALSE);    }    // Set up an ARParam object for the movie input.    arParamClear(&gMovieCparam, xsize, ysize, AR_DIST_FUNCTION_VERSION_DEFAULT);    // For convenience, we will use gsub_lite to draw the actual pixels. Set it up now.    gMovieArglSettings = arglSetupForCurrentContext(&gMovieCparam, pixFormat);    arglDistortionCompensationSet(gMovieArglSettings, 0);    return (TRUE);}

static int setupMarker(const char *patt_name, int *patt_id, ARHandle *arhandle, ARPattHandle **pattHandle_p){	    if ((*pattHandle_p = arPattCreateHandle()) == NULL) {        ARLOGe("setupMarker(): Error: arPattCreateHandle./n");        return (FALSE);    }    	// Loading only 1 pattern in this example.	if ((*patt_id = arPattLoad(*pattHandle_p, patt_name)) < 0) {		ARLOGe("setupMarker(): Error loading pattern file %s./n", patt_name);		arPattDeleteHandle(*pattHandle_p);		return (FALSE);	}        arPattAttach(arhandle, *pattHandle_p);		return (TRUE);}

static void mainLoop(void){    int        i;    static int imageNumber = 0;    static int ms_prev;    int        ms;    float      s_elapsed;    ARUint8    *image;    // Find out how long since mainLoop() last ran.    ms        = glutGet(GLUT_ELAPSED_TIME);    s_elapsed = (float)(ms - ms_prev) * 0.001f;    if (s_elapsed < 0.01f)        return;                        // Don't update more often than 100 Hz.    ms_prev = ms;    // Grab a video frame.    if ((image = arVideoGetImage()) != NULL)    {        gARTImage = image;              // Save the fetched image.        if (gARTImageSavePlease)        {            char imageNumberText[15];            sprintf(imageNumberText, "image-%04d.jpg", imageNumber++);            if (arVideoSaveImageJPEG(gARHandle->xsize, gARHandle->ysize, gARHandle->arPixelFormat, gARTImage, imageNumberText, 75, 0) < 0)            {                ARLOGe("Error saving video image./n");            }            gARTImageSavePlease = FALSE;        }        gCallCountMarkerDetect++;         // Increment ARToolKit FPS counter.        // Detect the markers in the video frame.        if (arDetectMarker(gARHandle, gARTImage) < 0)        {            exit(-1);        }        // If  marker config files were specified, evaluate detected patterns against them now.        for (i = 0; i < gMultiConfigCount; i++)        {            if (gRobustFlag)                gMultiErrs[i] = arGetTransMatMultiSquareRobust(gAR3DHandle, arGetMarker(gARHandle), arGetMarkerNum(gARHandle), gMultiConfigs[i]);            else                gMultiErrs[i] = arGetTransMatMultiSquare(gAR3DHandle, arGetMarker(gARHandle), arGetMarkerNum(gARHandle), gMultiConfigs[i]);            // if (gMultiConfigs[i]->prevF != 0) ARLOGe("Found multimarker set %d, err=%0.3f/n", i, gMultiErrs[i]);        }        // Tell GLUT the display has changed.        glutPostRedisplay();    }}

static int init( int argc, char *argv[] ){    ARGViewport		viewport;    char		*filename = NULL;    int			xmax, ymax;    float		xzoom, yzoom;    float		zoom;    int			i;    for( i = 1; i < argc; i++ ) {        if( filename == NULL ) filename = argv[i];        else usage(argv[0] );    }    if (!filename || !filename[0]) usage(argv[0]);    ARLOG("Read ImageSet./n");    ar2UtilRemoveExt( filename );    imageSet = ar2ReadImageSet( filename );    if( imageSet == NULL ) {        ARLOGe("file open error: %s.iset/n", filename );        exit(0);    }    ARLOG("  end./n");    arMalloc(vp, ARGViewportHandle *, imageSet->num);    xmax = ymax = 0;    for( i = 0; i < imageSet->num; i++ ) {        if( imageSet->scale[i]->xsize > xmax ) xmax = imageSet->scale[i]->xsize;        if( imageSet->scale[i]->ysize > ymax ) ymax = imageSet->scale[i]->ysize;    }    xzoom = yzoom = 1.0;    while( xmax > winXsize*xzoom ) xzoom += 1.0;    while( ymax > winYsize*yzoom ) yzoom += 1.0;    if( xzoom > yzoom ) zoom = 1.0/xzoom;    else                zoom = 1.0/yzoom;    winXsize = xmax * zoom;    winYsize = ymax * zoom;    ARLOG("Size = (%d,%d) Zoom = %f/n", xmax, ymax, zoom);    argCreateWindow( winXsize, winYsize );    for( i = 0; i < imageSet->num; i++ ) {        viewport.sx = viewport.sy = 0;        viewport.xsize = imageSet->scale[i]->xsize * zoom;        viewport.ysize = imageSet->scale[i]->ysize * zoom;        vp[i] = argCreateViewport( &viewport );        argViewportSetImageSize( vp[i], imageSet->scale[i]->xsize, imageSet->scale[i]->ysize );        argViewportSetDispMethod( vp[i], AR_GL_DISP_METHOD_TEXTURE_MAPPING_FRAME );        //argViewportSetDispMethod( vp[i], AR_GL_DISP_METHOD_GL_DRAW_PIXELS );        argViewportSetDispMode( vp[i], AR_GL_DISP_MODE_FIT_TO_VIEWPORT );        argViewportSetDistortionMode( vp[i], AR_GL_DISTORTION_COMPENSATE_DISABLE );    }    reportCurrentDPI();        return 0;}

int trackingInitStart( THREAD_HANDLE_T *threadHandle, ARUint8 *imagePtr ){    TrackingInitHandle     *trackingInitHandle;    if (!threadHandle || !imagePtr) {        ARLOGe("trackingInitStart(): Error: NULL threadHandle or imagePtr./n");        return (-1);    }        trackingInitHandle = (TrackingInitHandle *)threadGetArg(threadHandle);    if (!trackingInitHandle) {        ARLOGe("trackingInitStart(): Error: NULL trackingInitHandle./n");        return (-1);    }    memcpy( trackingInitHandle->imagePtr, imagePtr, trackingInitHandle->imageSize );    threadStartSignal( threadHandle );    return 0;}

int arSetLabelingThreshMode(ARHandle *handle, const AR_LABELING_THRESH_MODE mode){    AR_LABELING_THRESH_MODE mode1;	if (!handle) return (-1);    if (handle->arLabelingThreshMode != mode) {        if (handle->arImageProcInfo) {            arImageProcFinal(handle->arImageProcInfo);            handle->arImageProcInfo = NULL;        }        mode1 = mode;        switch (mode) {            case AR_LABELING_THRESH_MODE_AUTO_MEDIAN:            case AR_LABELING_THRESH_MODE_AUTO_OTSU:#if !AR_DISABLE_THRESH_MODE_AUTO_ADAPTIVE            case AR_LABELING_THRESH_MODE_AUTO_ADAPTIVE:#endif                handle->arImageProcInfo = arImageProcInit(handle->xsize, handle->ysize);                break;            case AR_LABELING_THRESH_MODE_AUTO_BRACKETING:                handle->arLabelingThreshAutoBracketOver = handle->arLabelingThreshAutoBracketUnder = 1;                break;            case AR_LABELING_THRESH_MODE_MANUAL:                break; // Do nothing.            default:                ARLOGe("Unknown or unsupported labeling threshold mode requested. Set to manual./n");                mode1 = AR_LABELING_THRESH_MODE_MANUAL;        }        handle->arLabelingThreshMode = mode1;        if (handle->arDebug == AR_DEBUG_ENABLE) {            const char *modeDescs[] = {                "MANUAL",                "AUTO_MEDIAN",                "AUTO_OTSU",                "AUTO_ADAPTIVE",                "AUTO_BRACKETING"            };            ARLOGe("Labeling threshold mode set to %s./n", modeDescs[mode1]);        }    }    return (0);}

// Report state of ARToolKit tracker.static void debugReportMode(ARHandle *arhandle){	int mode;		arGetImageProcMode(arhandle, &mode);	if (mode == AR_IMAGE_PROC_FRAME_IMAGE) {		ARLOGe("ProcMode (X)   : FRAME IMAGE/n");	} else if (mode == AR_IMAGE_PROC_FIELD_IMAGE) {		ARLOGe("ProcMode (X)   : FIELD IMAGE/n");	}		arGetPatternDetectionMode(arhandle, &mode);	if (mode == AR_TEMPLATE_MATCHING_COLOR) {		ARLOGe("TemplateMatchingMode (M)   : Color Template/n");	} else if (mode == AR_TEMPLATE_MATCHING_MONO) {		ARLOGe("TemplateMatchingMode (M)   : Mono Template/n");	} else if (mode == AR_MATRIX_CODE_DETECTION) {		ARLOGe("TemplateMatchingMode (M)   : Matrix code detection/n");	}}

static void saveParam(ARParam *param){    char   *name = NULL, *cwd = NULL;    size_t len;    int    nameOK;    arMalloc(name, char, MAXPATHLEN);    arMalloc(cwd, char, MAXPATHLEN);    if (!getcwd(cwd, MAXPATHLEN))        ARLOGe("Unable to read current working directory./n");    nameOK = 0;    ARLOG("Filename[%s]: ", SAVE_FILENAME);    if (fgets(name, MAXPATHLEN, stdin) != NULL)    {        // Trim whitespace from end of name.        len = strlen(name);        while (len > 0 && (name[len - 1] == '/r' || name[len - 1] == '/n' || name[len - 1] == '/t' || name[len - 1] == ' '))        {            len--;            name[len] = '/0';        }        if (len > 0)        {            nameOK = 1;            if (arParamSave(name, 1, param) < 0)            {                ARLOG("Parameter write error!!/n");            }            else            {                ARLOG("Saved parameter file '%s/%s'./n", cwd, name);            }        }    }    // Try and save with a default name.    if (!nameOK)    {        if (arParamSave(SAVE_FILENAME, 1, param) < 0)        {            ARLOG("Parameter write error!!/n");        }        else        {            ARLOG("Saved parameter file '%s/%s'./n", cwd, SAVE_FILENAME);        }    }    free(name);    free(cwd);}

// Modifies globals: kpmHandle, ar2Handle.static int initNFT(ARParamLT *cparamLT, AR_PIXEL_FORMAT pixFormat){    ARLOGd("Initialising NFT./n");    //    // NFT init.    //        // KPM init.    kpmHandle = kpmCreateHandle(cparamLT, pixFormat);    if (!kpmHandle) {        ARLOGe("Error: kpmCreateHandle./n");        return (FALSE);    }    //kpmSetProcMode( kpmHandle, KpmProcHalfSize );        // AR2 init.    if( (ar2Handle = ar2CreateHandle(cparamLT, pixFormat, AR2_TRACKING_DEFAULT_THREAD_NUM)) == NULL ) {        ARLOGe("Error: ar2CreateHandle./n");        kpmDeleteHandle(&kpmHandle);        return (FALSE);    }    if (threadGetCPU() <= 1) {        ARLOGi("Using NFT tracking settings for a single CPU./n");        ar2SetTrackingThresh(ar2Handle, 5.0);        ar2SetSimThresh(ar2Handle, 0.50);        ar2SetSearchFeatureNum(ar2Handle, 16);        ar2SetSearchSize(ar2Handle, 6);        ar2SetTemplateSize1(ar2Handle, 6);        ar2SetTemplateSize2(ar2Handle, 6);    } else {        ARLOGi("Using NFT tracking settings for more than one CPU./n");        ar2SetTrackingThresh(ar2Handle, 5.0);        ar2SetSimThresh(ar2Handle, 0.50);        ar2SetSearchFeatureNum(ar2Handle, 16);        ar2SetSearchSize(ar2Handle, 12);        ar2SetTemplateSize1(ar2Handle, 6);        ar2SetTemplateSize2(ar2Handle, 6);    }    // NFT dataset loading will happen later.    return (TRUE);}

int ar2VideoCloseAndroid( AR2VideoParamAndroidT *vid ){    if (!vid) return (-1); // Sanity check.        if (cparamSearchFinal() < 0) {        ARLOGe("Unable to finalise cparamSearch./n");    }        free( vid );        return 0;} 

int ar2VideoSetAutoOn1394(AR2VideoParam1394T *vid, int paramName, int value){    dc1394feature_t      feature;    dc1394feature_mode_t mode;    int                  v;    switch (paramName)    {    case AR_VIDEO_1394_BRIGHTNESS:        feature = DC1394_FEATURE_BRIGHTNESS;        break;    case AR_VIDEO_1394_EXPOSURE:        feature = DC1394_FEATURE_EXPOSURE;        break;    case AR_VIDEO_1394_WHITE_BALANCE:        feature = DC1394_FEATURE_WHITE_BALANCE;        break;    case AR_VIDEO_1394_SHUTTER_SPEED:        feature = DC1394_FEATURE_SHUTTER;        break;    case AR_VIDEO_1394_GAIN:        feature = DC1394_FEATURE_GAIN;        break;    case AR_VIDEO_1394_FOCUS:        feature = DC1394_FEATURE_FOCUS;        break;    case AR_VIDEO_1394_GAMMA:        feature = DC1394_FEATURE_GAMMA;        break;    default:        return -1;    }    if (value)        mode = DC1394_FEATURE_MODE_AUTO;    else        mode = DC1394_FEATURE_MODE_MANUAL;    if (dc1394_feature_set_mode(vid->camera, feature, mode) != DC1394_SUCCESS)    {        ARLOGe("unable to set mode./n");        return -1;    }    return 0;}

static void stopWMC(AR2VideoParamWinMCT *vid){    ARLOGd("ARWrap::ARvideo::stopWMC(): called");	if (!vid || !vid->wmc) return;    ARLOGd("ARWrap::ARvideo::stopWMC(): calling vid->wmc->Capturing()");	if (!vid->wmc->Capturing()) {		ARLOGe("ARWrap::ARvideo::stopWMC(): Windows.Media.Capture already stopped, exiting");		return;	}	vid->wmc->StopCapture();    ARLOGd("ARWrap::ARvideo::stopWMC(): exiting");}

int icpGetJ_U_S( ARdouble J_U_S[2][6], ARdouble matXc2U[3][4], ARdouble matXw2Xc[3][4], ICP3DCoordT *worldCoord ){    ARdouble        J_Xc_S[3][6];    ARdouble        J_U_Xc[2][3];    ICP3DCoordT   Xc;    int           i, j, k;    if( icpGetJ_Xc_S( J_Xc_S, &Xc, matXw2Xc, worldCoord ) < 0 ) {        ARLOGe("Error: icpGetJ_Xc_S/n");        return -1;    }#if ICP_DEBUG    icpDispMat( "J_Xc_S", (ARdouble *)J_Xc_S, 3, 6 );#endif    if( icpGetJ_U_Xc( J_U_Xc, matXc2U, &Xc ) < 0 ) {        ARLOGe("Error: icpGetJ_U_Xc");        return -1;    }#if ICP_DEBUG    icpDispMat( "J_U_Xc", (ARdouble *)J_U_Xc, 2, 3 );#endif    for( j = 0; j < 2; j++ ) {        for( i = 0; i < 6; i++ ) {            J_U_S[j][i] = 0.0;            for( k = 0; k < 3; k++ ) {                J_U_S[j][i] += J_U_Xc[j][k] * J_Xc_S[k][i];            }        }    }#if ICP_DEBUG    icpDispMat( "J_U_S", (ARdouble *)J_U_S, 2, 6 );#endif    return 0;}

int ar2VideoGetMinValue1394(AR2VideoParam1394T *vid, int paramName, int *value){    dc1394feature_t feature;    uint32_t        min, max;    switch (paramName)    {    case AR_VIDEO_1394_BRIGHTNESS:        feature = DC1394_FEATURE_BRIGHTNESS;        break;    case AR_VIDEO_1394_EXPOSURE:        feature = DC1394_FEATURE_EXPOSURE;        break;    case AR_VIDEO_1394_WHITE_BALANCE:        feature = DC1394_FEATURE_WHITE_BALANCE;        break;    case AR_VIDEO_1394_SHUTTER_SPEED:        feature = DC1394_FEATURE_SHUTTER;        break;    case AR_VIDEO_1394_GAIN:        feature = DC1394_FEATURE_GAIN;        break;    case AR_VIDEO_1394_FOCUS:        feature = DC1394_FEATURE_FOCUS;        break;    case AR_VIDEO_1394_GAMMA:        feature = DC1394_FEATURE_GAMMA;        break;    default:        return -1;    }    if (dc1394_feature_get_boundaries(vid->camera, feature, &min, &max) != DC1394_SUCCESS)    {        ARLOGe("unable to get max value./n");        return -1;    }    *value = min;    return 0;}