surface_viewer.cpp

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <cstdlib>
#include <cstdio>
#include <cassert>
#include <cstring>
#include <iostream>
#include <sstream>
#include <vector>

#include <inttypes.h>

#if defined SURFACE_HAVE_OPENGL
#include <GL/gl.h>
#include <GL/glu.h>
#endif

#if defined SURFACE_HAVE_GLUT_FRAMEWORK
#include <GLUT/glut.h>
#elif defined SURFACE_HAVE_GLUT
#include <GL/glut.h>
#endif

#ifdef SURFACE_HAVE_DMALLOC
#include <dmalloc.h>
#endif

#include <jwsc/math/constants.h>
#include <jwsc/vector/vector.h>
#include <jwsc/vector/vector_math.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/matrix/matrix_math.h>
#include <jwsc/image/image.h>
#include <jwsc/image/image_io.h>
#include <jwsc/imgblock/surface.h>

#include <jwsc++/base/option.h>
#include <jwsc++/base/exception.h>
#include <jwsc++/graphics/camera.h>


/* Anaglyph glasses filter types. */
#define REDBLUE  1
#define REDGREEN 2
#define REDCYAN  3
#define BLUERED  4
#define GREENRED 5
#define CYANRED  6

/* Program defaults. */
#define  VIEW_WIDTH      800
#define  VIEW_HEIGHT     800
#define  APERTURE        60.0f
#define  CLIP_NEAR       10.0f
#define  CLIP_FAR        3000.0f
#define  GLASSES_TYPE    REDCYAN
#define  CAPTURE_FNAME   "capture.tiff"
#define  PATCH_SIZE      2.0
#define  SURFACE_SCALE   1.0
#define  X_SCALE         1.0
#define  Y_SCALE         1.0
#define  Z_SCALE         1.4
#define  SAMPLE_RATE     1.0


using std::cout;
using std::cerr;
using std::ostringstream;
using std::sscanf;
using std::sprintf;
using std::vector;
using namespace jwsc;
using jwscxx::base::Options;
using jwscxx::base::Exception;
using jwscxx::base::Arg_error;
using jwscxx::graphics::Stereo_camera_f;


Options* opts = 0;

uint32_t view_width = VIEW_WIDTH;

uint32_t view_height = VIEW_HEIGHT;

float aperture = APERTURE;

float clip_near = CLIP_NEAR;

float clip_far = CLIP_FAR;

int glasses_type = GLASSES_TYPE;

const char* capture_fname = CAPTURE_FNAME;

float surface_scale = SURFACE_SCALE;

float surface_patch_size = PATCH_SIZE;

float x_scale = X_SCALE;

float y_scale = Y_SCALE;

float z_scale = Z_SCALE;

float sample_rate = SAMPLE_RATE;

Stereo_camera_f* camera = 0;

GLUquadric* quad_fill = 0;

list<Surface_patch_f*>* surface = 0;

Vector_f* patch_offset = 0;


struct Surface_viewer_modes
{
    bool translate_camera;

    bool rotate_camera;

    bool capture_view;

    bool anaglyph;

    bool render_focal_plane;

    bool render_world_axis;

    bool focal_prp;

    bool focal_vrp;
}
modes;

void init_modes()
{
    modes.translate_camera   = false;
    modes.rotate_camera      = true;
    modes.capture_view       = false;
    modes.anaglyph           = false;
    modes.render_focal_plane = false;
    modes.render_world_axis  = true;
    modes.focal_prp          = false;
    modes.focal_vrp          = true;
}

void init_camera() throw (Arg_error)
{
    delete camera;

    camera = new Stereo_camera_f(0, 50, 300, 0, 50, 0, 0, 1, 0,
            aperture, clip_near, clip_far);
}

void reset()
{
    surface_scale = SURFACE_SCALE;
    aperture      = APERTURE;
    init_camera();
    init_modes();
}

void capture_view()
{
    static uint32_t capture_num = 1;

    char  fname_buf       [ 256 ] = { 0 };
    char  fname_suffix_buf[ 256 ] = { 0 };
    char* fname_suffix;

    strncpy(fname_buf, capture_fname, 250);

    if ((fname_suffix = strstr(fname_buf, ".")) != NULL)
    {
        strncpy(fname_suffix_buf, fname_suffix, 250);
    }
    else
    {
        fname_suffix = fname_buf + strlen(fname_buf);
    }

    sprintf(fname_suffix, "-%04d%s", capture_num, fname_suffix_buf);

    camera->capture_gl_view(fname_buf, capture_num);

    capture_num++;
}

void render_world_axis()
{
    static GLfloat amb_dif[4] = {0, 0, 0, 1.0f};

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();

    float axis_length  = 100.0f;
    float arrow_radius = axis_length / 10.0f;
    float arrow_height = axis_length / 5.0f;

    /* X */
    amb_dif[0] = 0.9f;  amb_dif[1] = 1.0f;  amb_dif[2] = 0.3f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    glPushMatrix();
      glRotatef(90, 0, 1.0f, 0);
      gluCylinder(quad_fill, 1, 1, axis_length - 0.5f*arrow_height, 8, 1);
    glPopMatrix();
    glPushMatrix();
      glTranslatef(axis_length - arrow_height, 0, 0);
      glRotatef(90, 0, 1.0f, 0);
      gluCylinder(quad_fill, arrow_radius, 0, arrow_height, 16, 8);
    glPopMatrix();

    /* Y */
    amb_dif[0] = 0.9f;  amb_dif[1] = 1.0f;  amb_dif[2] = 0.3f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    glPushMatrix();
      glRotatef(-90, 1.0f, 0, 0);
      gluCylinder(quad_fill, 1, 1, axis_length - 0.5f*arrow_height, 8, 1);
    glPopMatrix();
    glPushMatrix();
      glTranslatef(0, axis_length - arrow_height, 0);
      glRotatef(-90, 1.0f, 0, 0);
      gluCylinder(quad_fill, arrow_radius, 0, arrow_height, 16, 8);
    glPopMatrix();

    /* Z */
    amb_dif[0] = 0.9f;  amb_dif[1] = 1.0f;  amb_dif[2] = 0.3f;
    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);
    gluCylinder(quad_fill, 1, 1, axis_length - 0.5f*arrow_height, 8, 1);
    glPushMatrix();
      glTranslatef(0, 0, axis_length - arrow_height);
      gluCylinder(quad_fill, arrow_radius, 0, arrow_height, 16, 8);
    glPopMatrix();

    glPopMatrix();
}

void render_focal_plane()
{
    static GLfloat amb_dif[4] = {0.7f, 0.6f, 0.5f, 0.2f};
    GLboolean prev_blend;
    GLint     prev_blend_src;
    GLint     prev_blend_dst;

    if ((prev_blend = glIsEnabled(GL_BLEND)))
    {
        glGetIntegerv(GL_BLEND_SRC, &prev_blend_src);
        glGetIntegerv(GL_BLEND_DST, &prev_blend_dst);
    }
    else
    {
        glEnable(GL_BLEND);
    }
    glBlendFunc(GL_SRC_ALPHA, GL_SRC_ALPHA);

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();
    glLoadIdentity();

    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);

    float x = 200.0f;
    float y = 200.0f;
    float z = -camera->get_focal_length();

    glBegin(GL_POLYGON);
    glNormal3f( 0,  0, 1);
    glVertex3f( x,  y, z);
    glVertex3f(-x,  y, z);
    glVertex3f(-x, -y, z);
    glVertex3f( x, -y, z);
    glEnd();

    glPopMatrix();

    if (prev_blend)
    {
        glBlendFunc(prev_blend_src, prev_blend_dst);
    }
    else
    {
        glDisable(GL_BLEND);
    }
}

void render_scene()
{
    static GLfloat amb_dif[4] = {0, 0, 0, 1.0f};

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();

    glScalef(surface_scale, surface_scale, surface_scale);

    glTranslatef(-patch_offset->elts[0],
                 -patch_offset->elts[1],
                 -patch_offset->elts[2]);

    // Render the surface patches.
    list<Surface_patch_f*>::iterator it;
    for (it = surface->begin(); it != surface->end(); it++)
    {
        const Surface_patch_f* patch = *it;

        amb_dif[0] = 3*patch->albedo*0.78f; 
        amb_dif[1] = 3*patch->albedo*0.6f; 
        amb_dif[2] = 3*patch->albedo*0.2f;
        /*
        amb_dif[0] = 4*patch->albedo*0.1f; 
        amb_dif[1] = 4*patch->albedo*1.0f; 
        amb_dif[2] = 4*patch->albedo*0.1f;
        */

        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, amb_dif);

        glNormal3f(patch->normal->elts[0], patch->normal->elts[1],
                patch->normal->elts[2]);

        glBegin(GL_POLYGON);
        for (int i = 0; i < 4; i++)
        {
            const Vector_f* point = patch->pts[ i ];
            glVertex3f(point->elts[0], point->elts[1], point->elts[2]);
        }
        glEnd();
    }

    glPopMatrix();
}

void display_glut_anaglyph()
{
    /* Set the buffer for reading and writing. Using double buffering. */
    glDrawBuffer(GL_BACK);
    glReadBuffer(GL_BACK);

    /* Clear things */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);

    /* Left camera filter. */
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
    switch (glasses_type)
    {
        case REDBLUE:
        case REDGREEN:
        case REDCYAN:
            glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
            break;
        case BLUERED:
            glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);
            break;
        case GREENRED:
            glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
            break;
        case CYANRED:
            glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
            break;
    }

    /* Set the left camera projection. */
    camera->set_left_gl_projection();

    /* Set the camera model view. */
    camera->set_left_gl_modelview();

    /* Render the world axis. */
    if (modes.render_world_axis)
    {
        render_world_axis();
    }

    render_scene();

    /* Render the focal plane if in that mode. */
    if (modes.render_focal_plane)
    {
        render_focal_plane();
    }

    glFlush();

    glAccum(GL_LOAD, 0.5f);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

    /* Right camera filter. */
    switch (glasses_type)
    {
        case REDBLUE:
            glColorMask(GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE);
            break;
        case REDGREEN:
            glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE);
            break;
        case REDCYAN:
            glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
            break;
        case BLUERED:
        case GREENRED:
        case CYANRED:
            glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE);
            break;
    }

    /* Set the right camera projection. */
    camera->set_right_gl_projection();

    /* Set the camera model view. */
    camera->set_right_gl_modelview();

    /* Render the world axis. */
    if (modes.render_world_axis)
    {
        render_world_axis();
    }

    render_scene();

    /* Render the focal plane if in that mode. */
    if (modes.render_focal_plane)
    {
        render_focal_plane();
    }

    glFlush();

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    glAccum(GL_ACCUM, 0.5f);
    glAccum(GL_RETURN, 2.0f);
}

void display_glut_regular()
{
    /* Set the buffer for writing. Using double buffering. */
    glDrawBuffer(GL_BACK);
    glReadBuffer(GL_BACK);

    /* Clear things */
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    /* Set the camera projection. */
    camera->set_gl_projection();

    /* Set the camera model view. */
    camera->set_gl_modelview();

    /* Render the world axis. */
    if (modes.render_world_axis)
    {
        render_world_axis();
    }

    render_scene();

    /* Render the focal plane if in that mode. */
    if (modes.render_focal_plane)
    {
        render_focal_plane();
    }

    glFlush();
}

void display_glut()
{
    if (modes.anaglyph)
    {
        display_glut_anaglyph();
    }
    else
    {
        display_glut_regular();
    }

    glutSwapBuffers();

    if (modes.capture_view)
    {
        capture_view();
        modes.capture_view = 0;
    }
}

void reshape_glut(int w, int h)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
    view_width = w;
    view_height = h;
}

void keyboard_glut(unsigned char key, int a, int b)
{
    float translate_delta = 10;
    float rotate_delta    = 10*JWSC_DEG_TO_RAD;
    float focal_length;
    float theta;

    Vector_f* v_tmp = 0;

    switch (key) {
        case 't':
            modes.translate_camera = 1;
            modes.rotate_camera = 0;
            break;
        case 'r':
            modes.rotate_camera = 1;
            modes.translate_camera = 0;
            break;
        case 'l':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        translate_delta * right->elts[0],
                        translate_delta * right->elts[1],
                        translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(-rotate_delta, 0, 1, 0);
            }
            glutPostRedisplay();
            break;
        case 'h':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        -translate_delta * right->elts[0],
                        -translate_delta * right->elts[1],
                        -translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(rotate_delta, 0, 1, 0);
            }
            glutPostRedisplay();
            break;
        case 'L':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        translate_delta * right->elts[0],
                        translate_delta * right->elts[1],
                        translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(rotate_delta, camera->get_v());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'H':
            if (modes.translate_camera)
            {
                const Vector_f* right = camera->get_u();
                camera->translate(
                        -translate_delta * right->elts[0],
                        -translate_delta * right->elts[1],
                        -translate_delta * right->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(-rotate_delta, camera->get_v());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'k':
            if (modes.translate_camera)
            {
                const Vector_f* up = camera->get_v();
                camera->translate(
                        translate_delta * up->elts[0],
                        translate_delta * up->elts[1],
                        translate_delta * up->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(rotate_delta, camera->get_u());
            }
            glutPostRedisplay();
            break;
        case 'j':
            if (modes.translate_camera)
            {
                const Vector_f* up = camera->get_v();
                camera->translate(
                        -translate_delta * up->elts[0],
                        -translate_delta * up->elts[1],
                        -translate_delta * up->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                camera->rotate(-rotate_delta, camera->get_u());
            }
            glutPostRedisplay();
            break;
        case 'K':
            if (modes.translate_camera)
            {
                const Vector_f* view = camera->get_n();
                camera->translate(
                        -translate_delta * view->elts[0],
                        -translate_delta * view->elts[1],
                        -translate_delta * view->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(-rotate_delta, camera->get_u());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'J':
            if (modes.translate_camera)
            {
                const Vector_f* view = camera->get_n();
                camera->translate(
                        translate_delta * view->elts[0],
                        translate_delta * view->elts[1],
                        translate_delta * view->elts[2]);
            }
            else if (modes.rotate_camera)
            {
                copy_vector_f(&v_tmp, camera->get_prp());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
                camera->rotate(rotate_delta, camera->get_u());
                multiply_vector_by_scalar_f(&v_tmp, v_tmp, -1);
                camera->translate(v_tmp);
            }
            glutPostRedisplay();
            break;
        case 'F':
            if (modes.focal_prp)
            {
                focal_length = camera->get_focal_length() + 20;
                camera->set_f_with_same_aperture_using_prp(focal_length);
            }
            else if (modes.focal_vrp)
            {
                focal_length = camera->get_focal_length() + 20;
                camera->set_f_with_same_aperture_using_vrp(focal_length);
            }
            glutPostRedisplay();
            break;
        case 'f':
            if (modes.focal_prp)
            {
                focal_length = camera->get_focal_length();
                if (focal_length >= 22)
                {
                    focal_length -= 20;
                    camera->set_f_with_same_aperture_using_prp(focal_length);
                }
            }
            else if (modes.focal_vrp)
            {
                focal_length = camera->get_focal_length();
                if (focal_length >= 22)
                {
                    focal_length -= 20;
                    camera->set_f_with_same_aperture_using_vrp(focal_length);
                }
            }
            glutPostRedisplay();
            break;
        case 'S':
            if (surface_scale >= 2.99f)
            {
                surface_scale = 3.0f;
            }
            else
            {
                surface_scale += 0.01f;
            }
            glutPostRedisplay();
            break;
        case 's':
            if (surface_scale > 0.01f)
            {
                surface_scale -= 0.01f;
            }
            glutPostRedisplay();
            break;
        case 'A':
            aperture += JWSC_PI_8;
            camera->set_aperture(aperture);
            glutPostRedisplay();
            break;
        case 'a':
            theta = aperture - JWSC_PI_8;
            if (theta >= 0)
            {
                aperture = theta;
                camera->set_aperture(theta);
            }
            glutPostRedisplay();
            break;
        case 'c':
            modes.capture_view = 1;
            glutPostRedisplay();
            break;
        case 'o':
            reset();
            glutPostRedisplay();
            break;
        case 'q':
            exit(EXIT_SUCCESS);
    }

    free_vector_f(v_tmp);
}

void main_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.capture_view = 1;
            glutPostRedisplay();
            break;
        case 1:
            reset();
            glutPostRedisplay();
            break;
        case 2:
            exit(EXIT_SUCCESS);
    }
}

void option_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.anaglyph = !modes.anaglyph;
            glutPostRedisplay();
            break;
        case 1:
            modes.render_focal_plane = !modes.render_focal_plane;
            glutPostRedisplay();
            break;
        case 2:
            modes.render_world_axis = !modes.render_world_axis;
            glutPostRedisplay();
            break;
    }
}

void navigation_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.rotate_camera    = true;
            modes.translate_camera = false;
            break;
        case 1:
            modes.rotate_camera    = false;
            modes.translate_camera = true;
            break;
        case 2:
            modes.rotate_camera    = false;
            modes.translate_camera = false;
            break;
    }
}

void focal_length_menu_glut(int id)
{
    switch (id)
    {
        case 0:
            modes.focal_prp = true;
            modes.focal_vrp = false;
            break;
        case 1:
            modes.focal_prp = false;
            modes.focal_vrp = true;
            break;
    }
}

void init_glut(int argc, char** argv)
{
    glutInit(&argc, (char**)argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH | GLUT_ACCUM
                                    | GLUT_ALPHA);
    glutInitWindowSize(view_width, view_height);
    glutCreateWindow("Surface Viewer");
    glutDisplayFunc(display_glut); 
    glutReshapeFunc(reshape_glut);
    glutKeyboardFunc(keyboard_glut);

    int navigation = glutCreateMenu(navigation_menu_glut);
    glutAddMenuEntry("Rotate Camera", 0);
    glutAddMenuEntry("Translate Camera", 1);
    glutAddMenuEntry("Modify Structure", 2);

    int focal_length = glutCreateMenu(focal_length_menu_glut);
    glutAddMenuEntry("PRP", 0);
    glutAddMenuEntry("VRP", 1);

    int options = glutCreateMenu(option_menu_glut);
    glutAddMenuEntry("Anaglyph", 0);
    glutAddMenuEntry("Focal Plane", 1);
    glutAddMenuEntry("Axis", 2);

    glutCreateMenu(main_menu_glut);
    glutAddSubMenu("Navigation", navigation);
    glutAddSubMenu("Focal Length", focal_length);
    glutAddSubMenu("Options", options);
    glutAddMenuEntry("Capture", 1);
    glutAddMenuEntry("Reset", 2);
    glutAddMenuEntry("Quit", 3);

    glutAttachMenu(GLUT_RIGHT_BUTTON);
}

void init_gl() 
{
    static GLfloat base_amb [] = {0.0f, 0.0f, 0.0f, 0.0f};
    static GLfloat ambient0 [] = {0.2f, 0.2f, 0.2f, 1.0f};
    static GLfloat diffuse0 [] = {0.9f, 0.9f, 0.9f, 1.0f};
    static GLfloat direction[] = {0.0f, 0.0f, 2000.0f, 1.0f};

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);

    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, base_amb);

    glEnable(GL_LIGHT0);
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient0);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse0);
    glLightfv(GL_LIGHT0, GL_POSITION, direction);


    if (!quad_fill)
    {
        quad_fill = gluNewQuadric();
        gluQuadricDrawStyle(quad_fill, GLU_FILL);
    }

    glLineWidth(1.0);
    glPointSize(1.0);
    glClearColor(1.0, 1.0, 1.0, 0.0);
    //glClearColor(0.0, 0.0, 0.0, 0.0);
    glClearAccum(0.0, 0.0, 0.0, 0.0);

    glViewport(0, 0, view_width, view_height);
}

void print_usage(void)
{
    fprintf(stderr, "usage: surface-viewer OPTIONS surface_points\n");
    fprintf(stderr, "where OPTIONS is one or more of the following:\n");
    opts->print(cerr, 30);
}

void process_help_opt(void)
{   
    print_usage();
    exit(EXIT_SUCCESS);
}

void process_version_opt(void)
{
    cout << SURFACE_PACKAGE_STRING << "\n";
    exit(EXIT_SUCCESS);
}

void process_size_opt(const char* arg) throw (Arg_error)
{
    int32_t w, h;

    if (!arg)
    {
        throw Arg_error("Option 'size' requires an argument");
    }
    if (sscanf(arg, "%d,%d", &w, &h) != 2)
    {
        throw Arg_error("Option 'size' has format width,height");
    }
    if (w <= 0 || h <= 0)
    {
        throw Arg_error("Option 'size' must have width,height > 0");
    }
    view_width = (uint32_t)w;
    view_height = (uint32_t)h;
}

void process_glasses_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'glasses' requires an argument");
    }
    if (strcmp("red-blue", arg) == 0)
        glasses_type = REDBLUE;
    else if (strcmp("red-green", arg) == 0)
        glasses_type = REDGREEN;
    else if (strcmp("red-cyan", arg) == 0)
        glasses_type = REDCYAN;
    else if (strcmp("blue-red", arg) == 0)
        glasses_type = BLUERED;
    else if (strcmp("green-red", arg) == 0)
        glasses_type = GREENRED;
    else if (strcmp("cyan-red", arg) == 0)
        glasses_type = CYANRED;
    else
    {
        throw Arg_error("Invalid 'glasses' type");
    }
}

void process_capture_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'capture' requires an argument");
    }
    capture_fname = arg;
}

void process_surf_scale_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'surf-scale' requires an argument");
    }
    if (sscanf(arg, "%f,%f,%f", &x_scale, &y_scale, &z_scale) != 3)
    {
        throw Arg_error("Option 'surf-scale' has format x,y,z");
    }
    if (x_scale <= 0 || y_scale <= 0 || z_scale <= 0)
    {
        throw Arg_error("Option 'surf-scale': scale must be > 0");
    }
}

void process_sample_rate_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'sample-rate' requires an argument");
    }
    if (sscanf(arg, "%f", &sample_rate) != 1 || sample_rate <= 0 ||
            sample_rate > 1.0)
    {
        throw Arg_error("Option 'sample-rate' must be in (0,1]");
    }
}

void process_patch_size_opt(const char* arg) throw (Arg_error)
{
    if (!arg)
    {
        throw Arg_error("Option 'patch-size' requires an argument");
    }
    if (sscanf(arg, "%f", &surface_patch_size) != 1 || sample_rate <= 0)
    {
        throw Arg_error("Option 'patch-size' must be > 0");
    }
}

void init_options()
{
    using jwscxx::base::Option_no_arg;
    using jwscxx::base::Option_with_arg;

    const char* l_name;
    const char* desc;

    opts = new Options();

    l_name = "help";
    desc   = "Program usage";
    opts->add(new Option_no_arg('h', l_name, desc, process_help_opt));

    l_name = "version";
    desc   = "Program version.";
    opts->add(new Option_no_arg('v', l_name, desc, process_version_opt));

    l_name = "size";
    desc   = "Window size with format width,height. Default is 600,600.";
    opts->add(new Option_with_arg(0, l_name, desc, process_size_opt));

    l_name = "glasses";
    desc   = "Type of colored glasses for anaglyph mode in the interactive window. Possible left-right filter types include include red-blue, red-green, red-cyan, blue-red, green-red, cyan-red. Default is cyan-red.";
    opts->add(new Option_with_arg(0, l_name, desc, process_glasses_opt));

    l_name = "capture";
    desc   = "View capture name in the interactive mode.";
    opts->add(new Option_with_arg(0, l_name, desc, process_capture_opt));

    l_name = "surf-scale";
    desc   = "Number of world units per image pixel. Has format x,y,z.";
    opts->add(new Option_with_arg(0, l_name, desc, process_surf_scale_opt));

    l_name = "sample-rate";
    desc   = "Surface point sampling rate.";
    opts->add(new Option_with_arg(0, l_name, desc, process_sample_rate_opt));

    l_name = "patch-size";
    desc   = "Surface patch size. Must be > 0.";
    opts->add(new Option_with_arg(0, l_name, desc, process_patch_size_opt));
}

void read_surface_data(const char* surface_fname) throw (Exception)
{
    Surface_point_f* points = 0;
    uint32_t num_pts;
    Error* err;
    if ((err = read_surface_points_f(&points, &num_pts, surface_fname)))
    {
        ostringstream ost;
        ost << surface_fname << ": " << err->msg;
        free_error(err);
        throw Arg_error(ost.str());
    }

    if (num_pts == 0)
    {
        ostringstream ost;
        ost << surface_fname << ": doesn't contain any surface points";
        throw Arg_error(ost.str());
    }

    surface = new list<Surface_patch_f*>();
    create_zero_vector_f(&patch_offset, 3);

    for (uint32_t i = 0; i < num_pts; i++)
    {
        Surface_patch_f* patch = 0;
        create_surface_patch_f(&patch, &(points[ i ]), surface_patch_size, 
                x_scale, y_scale, z_scale);
        patch_offset->elts[0] += patch->center->elts[0];
        patch_offset->elts[1] += patch->center->elts[1];
        patch_offset->elts[2] += patch->center->elts[2];
        surface->push_back(patch);
    }

    patch_offset->elts[0] *= 1.0f/num_pts;
    patch_offset->elts[1] *= 1.0f/(2.0f*num_pts);
    patch_offset->elts[2] *= 1.0f/num_pts;

    free(points);
}



int main(int argc, char** argv)
{
    init_options();

    try
    {
        int nargs = opts->process(argc, argv); 

        if (nargs < 2)
        {
            throw Arg_error("No surface to view");
        }

        read_surface_data(argv[ argc - nargs + 1]);

        init_glut(argc, argv);
        init_gl();
        init_camera();
        init_modes();

        glutMainLoop();
    }
    catch (Exception e)
    {
        cerr << "surface-viewer: ";
        e.print();
        return EXIT_FAILURE;
    }

    return EXIT_FAILURE;
}