Biomechanical Joint Model  Author: Anderson Maciel

---

sample_marching_cubes.cpp

Go to the documentation of this file.

/*####################################################################################################################
 *
 *    Test functionality of Marching_cubes library.
 *
 *####################################################################################################################*/


#include <OpenGLMyLib/glmodel3D.h>
#include <OpenGLMyLib/glModImplicit.h> 
#include <stdlib.h>
#include <GL/glut.h>


using namespace MyOGL;
using namespace VL;

// GLUT callback functions 
void OpenGLInit(int argc, char** argv);
void MyDisplay(void);
void MyMouse( int button, int state, int x, int y );
void MyReshape(GLsizei w, GLsizei h);
void MyMotion(int x, int y);
void MyKeyb(unsigned char key, int x, int y);
void MySpecKeyb(int key, int x, int y);

// Perspective default params
double Near = 5.0;        // near and far cliping planes
double Far  = 50.0;       // far clipping plane
double Distance = 25.0;   // distance of the camera to the object
double Fovy = M_PI/2;     // perspective angle
double Size_persp = 2*Distance*tan(Fovy/2); // size of the object to be visible by the above given perspective proj. params

double CalculateAngle(double size, double distance){
    double radtheta, degtheta;

    radtheta = 2.0 * atan2 (size/2.0, distance);
    degtheta = (180.0 * radtheta) / M_PI;
    return (degtheta);
}

void InitLight(){
// setting general light property(herein white light source)
  glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
  glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);  
  // light source position
  // 1) directional light source: it is in infinity and directed in (1,1,1) direction
  //    light is emited in all direction
#if DIRECTONAL_LIGHT
  GLfloat light_position_directional[] = { 0.0, 0.0, 5*Size_persp, 0.0 };
  for(int i=0; i<4; i++) light_position[i]=light_position_directional[i];
#else
  // 2) positional light source: light is at (1,1,1) position
  GLfloat light_position_positional[]  = { 0.0, 0.0, 5*Size_persp, 1.0 };
  for(int i=0; i<4; i++) light_position[i]=light_position_positional[i];
#endif
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
#if GLOBAL_AMBIENT_LIGHT
  //1) Global ambient light 
  GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
#endif
  //2) controls the position of the viewpoint(false means that the view point is in infinity, while
  //   when it is true view point is placet at (0,0,0). This influence specularity. Better use true.
  glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

  //3) use one or both sides of the facets for light computattion
  glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE); 

// setting general material property
  GLfloat no_mat[] = { 0.0, 0.0, 0.0, 1.0 };
  GLfloat mat_ambient[] = { 0.5, 0.5, 0.5, 1.0 };
  GLfloat mat_ambient_color[] = { 0.1, 0.1, 0.1, 1.0 };
  GLfloat mat_diffuse[] = { 0.5, 0.5, 0.5, 1.0 };
  GLfloat mat_specular[] = { 0.5, 0.5, 0.5, 0.5 };
  GLfloat no_shininess[] = { 0.0 };
  GLfloat low_shininess[] = { 20.0 };
  GLfloat high_shininess[] = { 100.0 };
  
  glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
  glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
  glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);
  glMaterialfv(GL_FRONT, GL_EMISSION, no_mat);


  // background color
  glClearColor (0.0, 0.0, 0.0, 0.0);

  // shading model
  glShadeModel(GL_SMOOTH);
  
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glEnable(GL_COLOR_MATERIAL); 
}

void OpenGLInit(int argc, char **argv)
{ 

  Vector4d<double> LL, UR;
  double *CG, size;

  if(argc < 2 ) 
     PrintHelp(argv[0]);

    //Loads model
  if(ReadOptionString("-sph",sphere_fname)){ 
    Model = new glModImplicit(resP,sphere_fname,SPHERE,stiffnesPF);
    fprintf(stderr,"read spheres\n");
  }else if(ReadOptionString("-el",ellipse_fname)){
    Model = new glModImplicit(resP,sphere_fname,ELLIPSOID,stiffnesPF);
    fprintf(stderr,"read ellipsoids\n");
  }else{
    Model = new glmodel3D(model_filename);
    fprintf(stderr,"read mesh\n");
  }
  
  Model->SetAllEdgesVisibles();
  Model->GetTriangulationGCdist();
  // Set correct perspective in terms of object initial size and position
  LL=Model->GetBboxLL();
  UR=Model->GetBboxUR();
  CG=Model->GetCG();
  Size_persp=sqrt((UR[0]-LL[0])*(UR[0]-LL[0]) + (UR[1]-LL[1])*(UR[1]-LL[1]) + (UR[2]-LL[2])*(UR[2]-LL[2]))/2;
  Distance = 3*Size_persp;
  Fovy=CalculateAngle(2*Size_persp,Distance);
  Near=Distance/2;
  Far=2*Distance;
#if 1
  fprintf(stderr,"CG = [%lf, %lf, %lf]\n",CG[0],CG[1],CG[2]);
  fprintf(stderr,"Bounding box: LL[%lf, %lf, %lf], UR[%lf, %lf, %lf]\n",LL[0],LL[1],LL[2],UR[0],UR[1],UR[2]);
  fprintf(stderr,"Size_persp = %lf, Distance = %lf, Fovy = %lf, Near = %lf, Far = %lf\n",Size_persp,Distance,Fovy,Near,Far);
#endif
   
  // set the initial translation so that the mesh is centered at the coordinate frame
  origX=-(*CG++), origY=-(*CG++), origZ=-(*CG);
  origScaleX=scalex, origScaleY=scaley, origScaleZ=scalez;

  glEnable(GL_DEPTH_TEST);
  glClearColor(0.0, 0.0, 0.0, 0.0);
  sc_global=Size_persp/0.5;
  sc_local=sc_global/4.0;
  CoordFrames(sc_global,sc_local);
}

void CoordFrames(double sc_global, double sc_local){
  // global coordinate frame
 glNewList(GLOBAL_COORD_FRAME, GL_COMPILE);
   // x 
  glBegin(GL_LINES); 
     glColor3f(1.0, 0.0, 0.0);
     glVertex3f(0.0, 0.0, 0.0);
     glVertex3f(0.5, 0.0, 0.0);
     glVertex3f(0.5, 0.0, 0.0);
     glVertex3f(0.45, 0.01, 0.0);
     glVertex3f(0.5, 0.0, 0.0);
     glVertex3f(0.45, -0.01, 0.0);
     glVertex3f(0.45, 0.1, 0.0);
     glVertex3f(0.50, 0.05, 0.0);
     glVertex3f(0.50, 0.1, 0.0);
     glVertex3f(0.45, 0.05, 0.0);
  glEnd();
  glBegin(GL_LINES);
   // y 
    glColor3f(0.0, 1.0, 0.0);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 0.5, 0.0);
    glVertex3f(0.0, 0.5, 0.0);
    glVertex3f(0.01, 0.45, 0.0);
    glVertex3f(0.0, 0.5, 0.0);
    glVertex3f(-0.01, 0.45, 0.0);
  glEnd();
  glBegin(GL_LINES);
   // z 
    glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 0.0, 0.5);
    glVertex3f(0.0, 0.0, 0.5);
    glVertex3f(0.0, 0.01, 0.45);
    glVertex3f(0.0, 0.0, 0.5);
    glVertex3f(0.0, -0.01, 0.45);
  glEnd();
  glColor3f(0.0, 0.0, 0.0);
  glEndList();

  // local coordinate frame
  glNewList(LOCAL_COORD_FRAME, GL_COMPILE);
  glBegin(GL_LINES);
  // x 
    glColor3f(1.0, 0.0, 0.0);
    glVertex3f(0.0,0.0,0.0);
    glVertex3f(0.5*sc_local, 0.0, 0.0);
    glVertex3f(0.5*sc_local, 0.0, 0.0);
    glVertex3f(0.45*sc_local, 0.01*sc_local, 0.0);
    glVertex3f(0.5*sc_local, 0.0, 0.0);
    glVertex3f(0.45*sc_local, -0.01*sc_local, 0.0);
    glVertex3f(0.45*sc_local, 0.1*sc_local, 0.0);
    glVertex3f(0.50*sc_local, 0.05*sc_local, 0.0);
    glVertex3f(0.50*sc_local, 0.1*sc_local, 0.0);
    glVertex3f(0.45*sc_local, 0.05*sc_local, 0.0);
  glEnd();
  glBegin(GL_LINES);
   // y 
    glColor3f(0.0, 1.0, 0.0);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 0.5*sc_local, 0.0);
    glVertex3f(0.0, 0.5*sc_local, 0.0);
    glVertex3f(0.01*sc_local, 0.45*sc_local, 0.0);
    glVertex3f(0.0, 0.5*sc_local, 0.0);
    glVertex3f(-0.01*sc_local, 0.45*sc_local, 0.0);
  glEnd();
  glBegin(GL_LINES);
   // z 
    glColor3f(0.0, 0.0, 1.0);
    glVertex3f(0.0, 0.0, 0.0);
    glVertex3f(0.0, 0.0, 0.5*sc_local);
    glVertex3f(0.0, 0.0, 0.5*sc_local);
    glVertex3f(0.0, 0.01*sc_local, 0.45*sc_local);
    glVertex3f(0.0, 0.0, 0.5*sc_local);
    glVertex3f(0.0, -0.01*sc_local, 0.45*sc_local);
  glEnd();
  glColor3f(0.0, 0.0, 0.0);
  glEndList();


}

void MyDisplay(void)
{    
  // clear the screen
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 
  // draw world referential
  glPushMatrix();
    glScaled(sc_global,sc_global,sc_global);
    glCallList(GLOBAL_COORD_FRAME);
  glPopMatrix();

  glPushMatrix();
    glTranslatef(xgl, ygl, zgl);
    glRotated(spinx, 1.0, 0.0, 0.0);
    glRotated(spiny, 0.0, 1.0, 0.0);
    glRotated(spinz, 0.0, 0.0, 1.0);
    glScaled(scalex, scaley, scalez);
    // translation and rotation of the objects
    glTranslatef(origX, origY, origZ);
  
  // draw wireframe model and data cloud(observations)
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
    if(drawShaded){
      glColor3f(0.9, 0.9, 0.9);
      Model->glDrawSolid(shading);
      glColor3f(0.5, 0.5, 0.5);
      Model->glDrawWireEdges();
    }
    else{
      glColor3f(0.5, 0.5, 0.5);
      Model->glDrawWire();
    }
  glPopMatrix();
  
  glPushMatrix();
  // translation and rotation of the local coord frame
    glTranslatef(xgl, ygl, zgl);
    glRotated(spinx, 1.0, 0.0, 0.0);
    glRotated(spiny, 0.0, 1.0, 0.0);
    glRotated(spinz, 0.0, 0.0, 1.0);
    glScaled(scalex, scaley, scalez);
#if 0
    printf("xgl=%lf, ygl=%lf, zgl=%lf\n",xgl,ygl,zgl);
    printf("origX=%lf, origY=%lf, origZ=%lf\n",origX,origY,origZ);
#endif
    glCallList(LOCAL_COORD_FRAME);
  glPopMatrix();

  glutSwapBuffers();
}

void MyReshape(GLsizei w, GLsizei h){
  glViewport(0, 0, w, h);
  Cam.setShape(Fovy, w/h, Near, Far);
  glLoadIdentity();
  gluLookAt(0, 0, Distance, 0, 0, 0, 0, 1, 0);
}

void MyMouse(int button, int state, int x, int y ){

  Facet  *SelectedFacet;
  Vertex *SelectedVertex;
  double Trans[3], Rot[3], Scale[3];
  Point  *Pt;
  int selId;
  
 
//  x & y rotation
  if(button == GLUT_LEFT_BUTTON && glutGetModifiers() != GLUT_ACTIVE_SHIFT && \
     glutGetModifiers() != GLUT_ACTIVE_ALT && state == GLUT_DOWN){
    rotxy = GL_TRUE;
    startx = x;
    starty = y;
  }

//  z rotation 
  if(button == GLUT_LEFT_BUTTON && glutGetModifiers() == GLUT_ACTIVE_SHIFT && state == GLUT_DOWN){
    rotz = GL_TRUE;
    starty = y;
  }

//  x & y translation
  if(button == GLUT_RIGHT_BUTTON && glutGetModifiers() != GLUT_ACTIVE_SHIFT && \
     glutGetModifiers() != GLUT_ACTIVE_CTRL && state == GLUT_DOWN){       
    movexy = GL_TRUE;
    startx = x;
    starty = y;
  }

//  z translation
  if(button == GLUT_RIGHT_BUTTON && glutGetModifiers() == GLUT_ACTIVE_SHIFT \
     && glutGetModifiers() != GLUT_ACTIVE_CTRL && state == GLUT_DOWN){
    movez = GL_TRUE;
    starty = y;
  }

  glutPostRedisplay();
  
}

void MyMotion(int x, int y){
        
  if(rotxy){
    spinx = spinx + (y - starty)/DIV_FACTOR_ROT;  
    spiny = spiny + (x - startx)/DIV_FACTOR_ROT;
    startx = x;
    starty = y;
  }

  if(rotz){
    spinz = spinz + (y - starty)/DIV_FACTOR_ROT;
    starty = y;
  }

  if(movexy){
    xgl = xgl + (x - startx)/DIV_FACTOR_TRANS;
    ygl = ygl - (y - starty)/DIV_FACTOR_TRANS;
    startx = x;
    starty = y;
  }

  if(movez){
    zgl = zgl + (y - starty)/DIV_FACTOR_TRANS;
    starty = y;
  }

  glutPostRedisplay();
 
}


void MyKeyb(unsigned char key, int x, int y){   

  switch(key){    
    case 'q' : 
    case 'Q' :
      exit(0);
    case 'z' : 
         scalex+=0.01;
         scaley+=0.01;
         scalez+=0.01;
         break;
    case 'Z' :
      if(scalex > 0.0){
         scalex-=0.01;
         scaley-=0.01;
         scalez-=0.01;
      }
      break;
    case 's':
    case 'S':  
      shading=SMOOTH_SHADING;
      drawShaded=GL_TRUE;
      break;
    case 'f':
    case 'F':  
      shading=FLAT_SHADING;
      drawShaded=GL_TRUE;
      break;
    case 'w':
    case 'W':
      drawShaded=GL_FALSE;
      break;

    case 'o':
    case 'O': // positioning mesh in the origin
      xgl=0.0, ygl=0.0, zgl=0.0;
      spinx=spiny=spinz=0.0;
      scalex=origScaleX, scaley=origScaleY, scalez=origScaleZ;
      glFlush();
      break;
  }
  glutPostRedisplay();
}

---