Subversion Repositories AndroidProjects

/*

 *

 * This file is part of ARToolKit.

 *

 * ARToolKit is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with ARToolKit; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

// ============================================================================

//      Includes

// ============================================================================

#ifdef _WIN32

#  include <windows.h>

#endif

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifndef __APPLE__

#  include <GL/glut.h>

#  ifdef GL_VERSION_1_2

#    include <GL/glext.h>

#  endif

#else

#  include <GLUT/glut.h>

#  include <OpenGL/glext.h>

#endif

#include <AR/config.h>

#include <AR/video.h>

#include <AR/param.h>

#include <AR/ar.h>

#include <AR/gsub_lite.h>

// ============================================================================

//      Constants

// ============================================================================

// ============================================================================

//      Global variables

// ============================================================================

/* set up the video format globals */

#if defined(__sgi)

char            *vconf = "-size=FULL";

#elif defined(__linux)

#  if defined(AR_INPUT_GSTREAMER)

char                    *vconf = "videotestsrc";

#  elif defined(AR_INPUT_V4L)

char            *vconf = "-width=640 -height=480";

#  elif defined(AR_INPUT_1394CAM)

char            *vconf = "-mode=640x480_YUV411";

#  elif defined(AR_INPUT_DV)

char            *vconf = "";

#  endif

#elif defined(_WIN32)

char                    *vconf = "Data\\WDM_camera_flipV.xml";

#elif defined(__APPLE__)

char                    *vconf = "-width=640 -height=480";

#else

char                    *vconf = "";

#endif

// Image acquisition.

static ARUint8          *gARTImage = NULL;

static ARUint8          *gARTsaveImage = NULL;

// Marker detection.

static int                      gARTThreshhold = 100;

static ARMarkerInfo* gTarget  = NULL;

// Drawing.

static ARParam          gARTCparam;

static ARGL_CONTEXT_SETTINGS_REF gArglSettings = NULL;

// ============================================================================

//      Functions

// ============================================================================

void lineSeg(double x1, double y1, double x2, double y2, ARGL_CONTEXT_SETTINGS_REF contextSettings, ARParam cparam, double zoom)

{

        int enable;

    float   ox, oy;

    double  xx1, yy1, xx2, yy2;

        if (!contextSettings) return;

        arglDistortionCompensationGet(contextSettings, &enable);

    if (arglDrawModeGet(contextSettings) == AR_DRAW_BY_TEXTURE_MAPPING && enable) {

        xx1 = x1;  yy1 = y1;

        xx2 = x2;  yy2 = y2;

    } else {

        arParamIdeal2Observ(cparam.dist_factor, x1, y1, &xx1, &yy1);

        arParamIdeal2Observ(cparam.dist_factor, x2, y2, &xx2, &yy2);

    }

    xx1 *= zoom; yy1 *= zoom;

    xx2 *= zoom; yy2 *= zoom;

        ox = 0;

        oy = cparam.ysize - 1;

        glBegin(GL_LINES);

        glVertex2f(ox + xx1, oy - yy1);

        glVertex2f(ox + xx2, oy - yy2);

        glEnd();

    glFlush();

}

static int setupCamera(ARParam *cparam)

{

    ARParam  wparam;

    char     name1[256], name2[256];

        int                             xsize, ysize;

    printf("Enter camera parameter filename");

    printf("(Data/camera_para.dat): ");

    if (fgets(name1, 256, stdin) == NULL) exit(0);

    if (sscanf(name1, "%s", name2) != 1) {

        strcpy(name2, "Data/camera_para.dat");

    }

        // Load the camera parameters.

        if (arParamLoad(name2, 1, &wparam) < 0 ) {

        printf("Parameter load error !!\n");

        return (FALSE);

    }

    // Open the video path.

    if (arVideoOpen(vconf) < 0) {

        fprintf(stderr, "setupCamera(): Unable to open connection to camera.\n");

        return (FALSE);

        }

    // Find the size of the window.

    if (arVideoInqSize(&xsize, &ysize) < 0) return (FALSE);

    fprintf(stdout, "Camera image size (x,y) = (%d,%d)\n", xsize, ysize);

        // Resize for the window and init.

    arParamChangeSize(&wparam, xsize, ysize, cparam);

    fprintf(stdout, "*** Camera Parameter ***\n");

    arParamDisp(cparam);

    arInitCparam(cparam);

        if (arVideoCapStart() != 0) {

        fprintf(stderr, "setupCamera(): Unable to begin camera data capture.\n");

                return (FALSE);        

        }

        return (TRUE);

}

static void Quit(void)

{

        free(gARTsaveImage); gARTsaveImage = NULL;

        arglCleanup(gArglSettings);

        arVideoCapStop();

        arVideoClose();

        exit(0);

}

static void Keyboard(unsigned char key, int x, int y)

{

        switch (key) {

                case 0x1B:                                              // Quit.

                case 'Q':

                case 'q':

                        Quit();

                        break;

                case 'T':

                case 't':

                printf("Enter new threshold value (default = 100): ");

                        scanf("%d", &gARTThreshhold); while (getchar()!='\n');

                                printf("\n");

                        break;

                case '?':

                case '/':

                        printf("Keys:\n");

                        printf(" q or [esc]    Quit demo.\n");

                        printf(" t             Enter new binarization threshold value.\n");

                        printf(" ? or /        Show this help.\n");

                        printf("\nAdditionally, the ARVideo library supplied the following help text:\n");

                        arVideoDispOption();

                        break;

                default:

                        break;

    }

}

static void Mouse(int button, int state, int x, int y)

{

    char   name1[256], name2[256];

        if (state == GLUT_DOWN) {

                if (button == GLUT_RIGHT_BUTTON) {

                        Quit();

                } else if (button == GLUT_MIDDLE_BUTTON) {

                        printf("Enter new threshold value (default = 100): ");

                        scanf("%d", &gARTThreshhold); while (getchar() != '\n');

                        printf("\n");

                } else if (button == GLUT_LEFT_BUTTON && gARTsaveImage && gTarget) {

                        printf("Enter filename: ");

                        if (fgets(name1, 256, stdin) == NULL) return;

                        if (sscanf(name1, "%s", name2) != 1 ) return;

                        if (arSavePatt(gARTsaveImage, gTarget, name2) < 0) {

                                printf("ERROR!!\n");

                        } else {

                                printf("  Saved\n");

                        }

                }

        }

}

static void Idle(void)

{

        static int ms_prev;

        int ms;

        float s_elapsed;

        ARUint8 *image;

    int             areamax;

        ARMarkerInfo    *marker_info;                                   // Pointer to array holding the details of detected markers.

    int             marker_num;                                         // Count of number of markers detected.

    int             i;

        // Find out how long since Idle() last ran.

        ms = glutGet(GLUT_ELAPSED_TIME);

        s_elapsed = (float)(ms - ms_prev) * 0.001;

        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;

                if (arDetectMarker(gARTImage, gARTThreshhold, &marker_info, &marker_num) < 0) {

                        Quit();

                }

                areamax = 0;

                gTarget = NULL;

                for (i = 0; i < marker_num; i++) {

                        if (marker_info[i].area > areamax) {

                                areamax = marker_info[i].area;

                                gTarget = &(marker_info[i]);

                        }

                }

                memcpy(gARTsaveImage, gARTImage,  gARTCparam.xsize * gARTCparam.ysize * AR_PIX_SIZE_DEFAULT);

                // Tell GLUT the display has changed.

                glutPostRedisplay();

        }

}

//

//      This function is called on events when the visibility of the

//      GLUT window changes (including when it first becomes visible).

//

static void Visibility(int visible)

{

        if (visible == GLUT_VISIBLE) {

                glutIdleFunc(Idle);

        } else {

                glutIdleFunc(NULL);

        }

}

//

//      This function is called when the

//      GLUT window is resized.

//

static void Reshape(int w, int h)

{

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glViewport(0, 0, (GLsizei) w, (GLsizei) h);

        glMatrixMode(GL_PROJECTION);

        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);

        glLoadIdentity();

        // Call through to anyone else who needs to know about window sizing here.

}

static void beginOrtho2D(int xsize, int ysize) {

        glMatrixMode(GL_PROJECTION);

        glPushMatrix();

        glLoadIdentity();

        gluOrtho2D(0.0, xsize, 0.0, ysize);

        glMatrixMode(GL_MODELVIEW);

        glPushMatrix();

        glLoadIdentity();      

}

static void endOrtho2D(void) {

        glMatrixMode(GL_PROJECTION);

        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);

        glPopMatrix();

}

//

// This function is called when the window needs redrawing.

//

static void Display(void)

{

        // Select correct buffer for this context.

        glDrawBuffer(GL_BACK);

        glClear(GL_COLOR_BUFFER_BIT); // Clear the buffers for new frame.

        arglDispImage(gARTImage, &gARTCparam, 1.0, gArglSettings);      // zoom = 1.0.

        arVideoCapNext();

        gARTImage = NULL; // Image data is no longer valid after calling arVideoCapNext().

        if (gTarget != NULL) {

                glDisable(GL_DEPTH_TEST);

                glDisable(GL_LIGHTING);

                glDisable(GL_TEXTURE_2D);

                beginOrtho2D(gARTCparam.xsize, gARTCparam.ysize);

        glLineWidth(2.0f);

        glColor3d(0.0, 1.0, 0.0);

        lineSeg(gTarget->vertex[0][0], gTarget->vertex[0][1],

                                gTarget->vertex[1][0], gTarget->vertex[1][1], gArglSettings, gARTCparam, 1.0);

        lineSeg(gTarget->vertex[3][0], gTarget->vertex[3][1],

                                gTarget->vertex[0][0], gTarget->vertex[0][1], gArglSettings, gARTCparam, 1.0);

        glColor3d(1.0, 0.0, 0.0);

        lineSeg(gTarget->vertex[1][0], gTarget->vertex[1][1],

                                gTarget->vertex[2][0], gTarget->vertex[2][1], gArglSettings, gARTCparam, 1.0);

        lineSeg(gTarget->vertex[2][0], gTarget->vertex[2][1],

                                gTarget->vertex[3][0], gTarget->vertex[3][1], gArglSettings, gARTCparam, 1.0);

                endOrtho2D();

    }

        glutSwapBuffers();

}

int main(int argc, char *argv[])

{

        // ----------------------------------------------------------------------------

        // Library inits.

        //

        glutInit(&argc, argv);

        // ----------------------------------------------------------------------------

        // Hardware setup.

        //

        if (!setupCamera(&gARTCparam)) {

                fprintf(stderr, "main(): Unable to set up AR camera.\n");

                exit(-1);

        }

        // ----------------------------------------------------------------------------

        // Library setup.

        //

        // Set up GL context(s) for OpenGL to draw into.

    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

        glutInitWindowSize(gARTCparam.xsize, gARTCparam.ysize);

        glutCreateWindow(argv[0]);

        // Setup argl library for current context.

        if ((gArglSettings = arglSetupForCurrentContext()) == NULL) {

                fprintf(stderr, "main(): arglSetupForCurrentContext() returned error.\n");

                exit(-1);

        }

        arMalloc(gARTsaveImage, ARUint8, gARTCparam.xsize * gARTCparam.ysize * AR_PIX_SIZE_DEFAULT);

        // Register GLUT event-handling callbacks.

        // NB: Idle() is registered by Visibility.

        glutDisplayFunc(Display);

        glutReshapeFunc(Reshape);

        glutVisibilityFunc(Visibility);

        glutKeyboardFunc(Keyboard);

    glutMouseFunc(Mouse);

        glutMainLoop();

        return (0);

}