display.cpp

模糊聚類分析源碼。包含教學文件

    {
    z = 0.0;
    }
*/
  if (d==0)
    {
    #ifdef OPENGL
    glBegin(GL_POINTS);
      glVertex3f(x,y,z);
    glEnd();
    #endif
    }
  else
    {  
    #ifdef OPENGL
    glPushMatrix();
      glTranslatef(x,y,z);
      glScalef(d,d,d);
      glCallList(unitDiscList);
    glPopMatrix();
    #endif
    }
  }  

void display_ball
  (
  float x,
  float y,
  float z,
  float d
  )  
  {
/*
  if (projectmode==PROJECT_MODE_2D) 
    {
    z = 0.0;
    }
*/
  if (d==0)
    {
    #ifdef OPENGL
    glBegin(GL_POINTS);
      glVertex3f(x,y,z);
    glEnd();
    #endif
    }
  else
    {  
    #ifdef OPENGL
    glPushMatrix();
      glTranslatef(x,y,z);
      glScalef(d,d,d);
      glCallList(unitBallList);
    glPopMatrix();
    #endif
    }
  }  
  
void 
display_text
  (
  float x,
  float y,
  float z,
  const char* text,
  int n
  )
  {
  #ifdef OPENGL
  glRasterPos3f(x,y,z);
  glPushAttrib (GL_LIST_BIT);
  glListBase(fontOffset);
  if (strlen(text)<n) n = strlen(text);
  glCallLists(n, GL_UNSIGNED_BYTE, (GLubyte *) text);
  glPopAttrib ();
  #endif
  }

void 
display_cylinder
  ( 
  float sx, 
  float sy, 
  float sz, 
  float fx, 
  float fy, 
  float fz,
  float d
  )
  {
  if (d==0)
    {
    #ifdef OPENGL
    glBegin(GL_LINES);
      glVertex3f(sx,sy,sz);
      glVertex3f(fx,fy,fz);
    glEnd();
    #endif
    }
  else
    {
    #ifdef OPENGL
             double len,angle;
             double dx,dy,dz;
             dx = (fx-sx); len  = dx*dx;
             dy = (fy-sy); len += dy*dy;
             dz = (fz-sz); len += dz*dz;
        len = sqrt(len);    
        dx /= len;
        dy /= len;
        dz /= len;
             glPushMatrix();
          glTranslatef(sx,sy,sz);
          
          if (dz==0.0)
            {
            // im 2d fall ein 2d problem daraus machen, d.h. cyulinder in xy ebene
            // kippen, so dass er auf ( 1 0 ) liegt
            angle = -M_PI / 2.0;
            glRotatef(angle*180.0/M_PI,0.0,1.0,0.0);
            // dann um z-Achse (das ist die x-Achse im gekippten System) drehen
            angle = atan2(-dy,-dx); 
            glRotatef(angle*180.0/M_PI,1.0,0.0,0.0);
            } 
          else 
            {
            // rotation: standard cylinder achse (richtungsvektor) ist ( 0 0 1 )
            // ziel ( dx dy dz )
            // cos(Winkel) zwischen Vektoren : Skalarprod / Laenge
            // xy Ebene egal (Nullvektor) 
            // yz Ebene ( 0 1 ) * ( fy-sy fz-sz ) / Norm   ^= x-Drehung
            // in beiden faellen drehen wir den vector ( 0 1 ) um phi, d.h.
            // der grdrehte vektor hat die coord. ( -sin phi   cos phi )
            angle = atan2(dz,dy); angle -= M_PI / 2.0;
            glRotatef(angle*180.0/M_PI,1.0,0.0,0.0);

            angle = atan2(dz,-dx); angle -= M_PI / 2.0;
            glRotatef(angle*180.0/M_PI,0.0,1.0,0.0);
            }
          glScalef(d,d,len);
          glCallList(unitCylinderList);
        glPopMatrix();              
    #endif
         }
  }
  
void 
display_line
  ( 
  float sx, 
  float sy, 
  float sz, 
  float fx, 
  float fy, 
  float fz,
  float 
  )
  {
  #ifdef OPENGL
  glBegin(GL_LINES);
    glVertex3f(sx,sy,sz);
    glVertex3f(fx,fy,fz);
  glEnd();
  #endif
  }

void display_mode_menu()
  {
  #ifdef OPENGL
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0,WindowWidth,WindowHeight,0,1,100);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0,0.0,-5.0);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  #endif
  }
 
void display_scale
  (
  float a_scale_x,
  float a_scale_y,
  float a_scale_z
  )
  {
  #ifdef OPENGL
  glScalef(a_scale_x,a_scale_y,a_scale_z);
  #endif
  }
  
void display_mode_3d
  (
  float xfocus,
  float yfocus,
  float zfocus,
  float distance,
  float twist,
  float elevation,
  float azimuth
  )
  {
  #ifdef OPENGL  
    glDisable(GL_BLEND);  

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    gluPerspective (60.0, (GLfloat)WindowWidth/(GLfloat)WindowHeight, 0.1, 100.0);
    //glOrtho(-20,20,-20,20,1,100);
    //glFrustum(-1.0,1.0,-1.0,1.0,1.5,20.0);

    glMatrixMode (GL_MODELVIEW);
    //glClearColor(1.0,1.0,1.0,0.0);
    glClear( (GLbitfield)(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) );
    glLoadIdentity();
    glTranslated(0.0,0.0,-distance);
    glRotated(-twist,0.0,0.0,1.0);
    glRotated(-elevation,1.0,0.0,0.0);
    glRotated(azimuth,0.0,0.0,1.0);
    glTranslated(-xfocus,-yfocus,-zfocus);
  #endif
  } 

void display_mode_2d
  (
  float xfocus,
  float yfocus,
  float ,
  float 
  )
  {
  #ifdef OPENGL
    glDisable(GL_BLEND);  

    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
    //gluPerspective (40.0, (GLfloat)WindowWidth/(GLfloat)WindowHeight, 1.0, 100.0);
    glOrtho(-20,20,-20,20,1,100);
    //glFrustum(-1.0,1.0,-1.0,1.0,1.5,20.0);

    glMatrixMode (GL_MODELVIEW);
    glClear( (GLbitfield)(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) );
    glLoadIdentity();
    glTranslated(-xfocus,-yfocus,0);
  #endif
  } 

void display_again
  (
  ) 
  { 
  #ifdef OPENGL
  glutPostRedisplay(); 
  #endif
  }
void display_delete_list
  (
  int listno
  )
  {
  invariant(listno>0,"display list index is positive");
  
  #ifdef OPENGL  
    // wenn Liste bereits bekannt, loeschen
    if (oglList.find(listno)!=oglList.end())
      {
      GLuint no;
           no = oglList[listno];
           glDeleteLists(no,1);
           }
    oglList.erase(oglList.begin(),oglList.end());
  #endif
  }
  
void display_list_begin
  (
  int listno
  )
  {
  invariant(actualList==-1,"no list active when display_list_begin called");
  invariant(listno>0,"display list index is positive");
  
  actualList = listno;
  #ifdef OPENGL
    GLuint no;

    // wenn Liste bereits bekannt, erst alte loeschen
    if (oglList.find(listno)!=oglList.end())
      {
           no = oglList[listno];
           glDeleteLists(no,1);
           }
    // und dann neue starten
    no = glGenLists(1);
    oglList[listno] = no;
    glNewList(no,GL_COMPILE);
  #endif
  }
  
void display_list_end
  (
  )
  {
  invariant(actualList!=-1,"one list active when display_list_end called");
  
  #ifdef OPENGL
  glEndList();
  #endif
  actualList = -1;
  }  

void display_list
  (
  int listno
  )
  {
  invariant(listno>0,"display list index is positive");
  
  #ifdef OPENGL
    if (oglList.find(listno)!=oglList.end())
      {
      glCallList(oglList[listno]);
      }
  #endif
  }

void display_all_lists
  (
  )
  {
  #ifdef OPENGL
    map<int,GLuint,less<int> >::iterator i;
    for (i=oglList.begin();i!=oglList.end();++i)
      {
           glCallList((*i).second);
           }
  #endif
  }


void 
display_cube
  (float x1,float y1,float z1,float x2,float y2,float z2)
    {
    #ifdef OPENGL
        glBegin(GL_LINE_LOOP);
          glVertex3f(x1,y1,z1);
          glVertex3f(x2,y1,z1);
          glVertex3f(x2,y2,z1);
          glVertex3f(x1,y2,z1);
          glVertex3f(x1,y2,z2);
          glVertex3f(x2,y2,z2);
          glVertex3f(x2,y1,z2);
          glVertex3f(x1,y1,z2);
          glVertex3f(x1,y1,z1);
          glVertex3f(x1,y2,z1);
        glEnd();
        glBegin(GL_LINES);
          glVertex3f(x2,y1,z1);
          glVertex3f(x2,y1,z2);
          glVertex3f(x2,y2,z1);
          glVertex3f(x2,y2,z2);
          glVertex3f(x1,y1,z2);
          glVertex3f(x1,y2,z2);
        glEnd();
    #endif
    }
#ifdef OPENGL
void
display_refresh
  (
  )
  {
  cycle_func();
  glFlush();
  glutSwapBuffers();
  }

void
display_reshape(int w,int h)
  {
  WindowWidth = w;
  WindowHeight = h;
  glViewport(0,0,w,h); // legt Zeichenbereich fest
    // define projection
  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
//  gluPerspective (40.0, (GLfloat)w/(GLfloat)h, 1.0, 100.0);
  glOrtho(-20,20,-20,20,1,100);
//  glFrustum(-1.0,1.0,-1.0,1.0,1.5,20.0);

  glMatrixMode (GL_MODELVIEW);

//gluLookAt(2,2,10,0,0,0,0,1,0);
//glTranslatef(0,0,-5);

  display_refresh();
  }
#endif

/* template instantiation */
#pragma instantiate map<int,GLuint,less<int> >


#endif /* display_SOURCE */