WebSVN - AndroidProjects - Rev 204 - /ARToolKit/util/mk_patt/mk

/*
*
* 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);
}

Subversion Repositories AndroidProjects

(root)/ARToolKit/util/mk_patt/mk_patt.c @ 1490 - Rev 204