---

Tetraviewer.C

Go to the documentation of this file.

/*
 * Copyright (C) 2003 Eric Bohm
 *
 *This program 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 version 2 of the License.
 * 
 *This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 *675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/*
 *  Tetraviewer loads tetrahedron data files and allows the user to 
 *  view them.

 * LIMITATION: Tetraviewer currently assumes an origin centered
 *    tetrahedron less than 3 units wide.

 * TODO:
 *
 *   Use GL display list to optimize
 *
 *   Allow for timestepping.
 *   - Move vectors ?width ?min ?max ?center to timestep object.
 *   - Move display routines to timestep object
 *   - Move loadfile to timestep object 
 *   - Create draw_timestep
 *   - Use glNewList(timestep,GL_COMPILE) to store compiled timesteps.
 */
#include <unistd.h>
#include <GL/glut.h>
#include <mui/mui.h>
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#include "Controller.h"
#include "View.h"
using namespace std;
View view;
Controller controller;
int subwindow;
void init(void)
{
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_LINE_SMOOTH);
  glLineWidth(2.0);
  glShadeModel(GL_SMOOTH);
}

void display(void)
{
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  view.display();
  glutSwapBuffers();
}

void motion(int x, int y)
{
  glutPostRedisplay();
}



void reshape(int w, int h)
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  // Calculate correct aspect ratio (and prevent div by zero error)
  if (h == 0)
    view.aspect_ratio = (float) w;
  else
    view.aspect_ratio = (float) w / (float) h;

  gluPerspective(50.0, view.aspect_ratio, 1.0, 200.0);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  view.ScreenWidth = w;
  view.ScreenHeight = h;
}


void keyboard(unsigned char key, int x, int y)
{
  glutSetWindow(subwindow);
  switch (key) {
  case '0':
    view.set_solo_chunk(0);
    break;
  case '1':
    view.set_solo_chunk(1);
    break;
  case '2':
    view.set_solo_chunk(2);
    break;
  case '3':
    view.set_solo_chunk(3);
    break;
  case '4':
    view.set_solo_chunk(4);
    break;
  case '5':
    view.set_solo_chunk(5);
    break;
  case '6':
    view.set_solo_chunk(6);
    break;
  case '7':
    view.set_solo_chunk(7);
    break;
  case '8':
    view.set_solo_chunk(8);
    break;
  case '9':
    view.set_solo_chunk(9);
    break;
  case '-':
    view.set_solo_chunk(-1);
    break;
  case 'Q':
  case 'q':
  case 27:
    exit(0);
    break;
  case 'A':
    view.animate(-1);
    break;
  case 'a':
    view.animate(1);
    break;
  case 'F':
  case 'f':
    view.toggle_fillpoly();
    break;
  case 'L':
  case 'l':
    view.toggle_showlabel();
    break;
  case 'E':
  case 'e':
    view.toggle_showlength();
    break;
  case 'O':
  case 'o':
    view.toggle_opaque();
    break;
  case 'c':
  case 'C':
    view.rotatecolormap();
    break;
  case 'V':
  case 'v':
    view.toggle_pointmode();
    break;
  case 'Z':
    view.zoomout();
    break;
  case 'z':
    view.zoomin();
    break;
  case 'i':
    view.move_y(1.0);
    break;
  case 'm':
    view.move_y(-1.0);
    break;
  case 'j':
    view.move_x(-1.0);
    break;
  case 'k':
    view.move_x(1.0);
    break;
  case 'y':
    view.move_z(-1.0);
    break;
  case 'b':
    view.move_z(1.0);
    break;
  case 'N':
  case 'n':
    view.next_step();
    break;
  case 'p':
  case 'P':
    view.prev_step();
    break;
  }
  snprintf(controller.timestring,80,"%d",view.get_currstep());
  muiChangeLabel(controller.timestep_number,controller.timestring);
  view.display();
  glutPostWindowRedisplay(subwindow);
  glutPostWindowRedisplay(1);
}

void movers(int key, int x, int y)
{
  glutSetWindow(subwindow);
  switch (key) {
  case GLUT_KEY_LEFT:
    view.rotate_y(1);
    break;
  case GLUT_KEY_RIGHT:
    view.rotate_y(-1);
    break;
  case GLUT_KEY_UP:
    view.rotate_x(1);
    break;
  case GLUT_KEY_DOWN:
    view.rotate_x(-1);
    break;
  case GLUT_KEY_PAGE_UP:
    view.rotate_z(1);
    break;
  case GLUT_KEY_PAGE_DOWN:
    view.rotate_z(-1);
    break;
  }
  glutPostWindowRedisplay(subwindow);
}


void interpclick(int click)
{

  keyboard((unsigned int) click,0,0);
}

void bcallback(muiObject *obj, enum muiReturnValue r)
{
  r = r; /* for lint's sake */
  keyboard(muiGetID(obj),0,0);
}

void chunkcallback(muiObject *obj, enum muiReturnValue r)
{
  glutSetWindow(subwindow);
  view.set_solo_chunk(atoi(muiGetTBString(controller.chunkbox)));
  view.display();
  glutPostWindowRedisplay(subwindow);
  glutPostWindowRedisplay(1);

}

void nochunkcallback(muiObject *obj, enum muiReturnValue r)
{
  glutSetWindow(subwindow);
  view.set_solo_chunk(-1);
  view.display();
  glutPostWindowRedisplay(subwindow);
  glutPostWindowRedisplay(1);

}

void timecallback(muiObject *obj, enum muiReturnValue r)
{
  glutSetWindow(subwindow);
  view.display_step(atoi(muiGetTBString(controller.seltimebox)));
  snprintf(controller.timestring,80,"%d",view.get_currstep());
  muiChangeLabel(controller.timestep_number,controller.timestring);
  glutPostWindowRedisplay(subwindow);
  glutPostWindowRedisplay(1);

}


void idle(void)
{
  glutPostRedisplay();
}

int main(int argc, char **argv)
{
// initialize GL
// load files and make View

  glutInit(&argc, argv);
  glutInitWindowSize(400, 550);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
  glutCreateWindow("TetController");
  muiInit();
  controller=Controller(glutGetWindow());
  //  glutKeyboardFunc(keyboard);
  glutSpecialFunc(movers);
  glutInitWindowSize(500, 500);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  subwindow=glutCreateWindow("Tetraviewer");
  init();
  srand48(65);
  cout << " 
  a : animate timestep forwards to end
  A : animate timestep backwards to start
  f : toggle fill mode (opaque or transparent faces)
  o : toggle line mode (emphasis lines)
  e : toggle edge length labels
  l : toggle vertex labels
  v : vertex view mode (vertex points only)
  c : cycle color map (random, chunk, point)
  z : zoom in
  Z : zoom out
  n : next timestep
  p : prev timestep
  q : quit 
0-9 : choose only chunk 0..9
  - : all chunks
  arrow and page up/down keys to rotate x y z
\n";
  for (int i = 1; i < argc; i++) {
    if (!view.loadfile(argv[i])) {
      fprintf(stderr, "loadfile %s failed\n", argv[i]);
      return (1);
    }
  }
  glutIdleFunc(idle);
  glutReshapeFunc(reshape);
  glutDisplayFunc(display);
  glutMotionFunc(motion);
  glutKeyboardFunc(keyboard);
  glutSpecialFunc(movers);
  view.make_random_color_set();
  view.recenter();
  view.display_first();
  glutMainLoop();
  return 0;
}

---