home *** CD-ROM | disk | FTP | other *** search
/ ftp.hitl.washington.edu / ftp.hitl.washington.edu.tar / ftp.hitl.washington.edu / pub / people / habib / VirtCity / glut_viewer.cc~ < prev    next >
Text File  |  2000-04-24  |  66KB  |  2,390 lines
  1. // By Habib Abi-Rached
  2. // Summer 1997.
  3. // Intern in Ford Motor.
  4. // Parts of code taken from Mark J. Kilgard, 1994.
  5. // Using Glut / OpenGl
  6. // Implementation of Data Desk using Stereo-Vision.
  7.  
  8. #include <stdio.h>
  9. #include <iostream.h>  
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include <math.h>       /* for cos(), sin(), and sqrt() */
  13. #include <GL/glut.h>
  14. #include "trackball.h"
  15.  
  16. #define FLAG int
  17.  
  18. float zero1 = 0.0;
  19. float zero2 = 0.0;
  20. float NaN = 999999999; 
  21.  
  22. extern void add_quats (float, float, float);
  23. extern void add_quats (float *, float *, float *);
  24.  
  25.  
  26. typedef enum  {
  27.   RESERVED, BODY_SIDE, BODY_EDGE, BODY_WHOLE, ARM_SIDE, ARM_EDGE, ARM_WHOLE,
  28.   LEG_SIDE, LEG_EDGE, LEG_WHOLE, EYE_SIDE, EYE_EDGE, EYE_WHOLE, DINOSAUR
  29. } displayLists;
  30.  
  31. GLfloat angle = -150;   /* in degrees */
  32. GLboolean doubleBuffer = GL_TRUE, iconic = GL_FALSE, keepAspect = GL_FALSE;
  33. int beginx, beginy;
  34. float curquat[4];
  35. float lastquat[4];
  36. GLdouble bodyWidth = 2.0;
  37. int dinosor =0;
  38. int newModel = 1;
  39. float scalefactor = 1.0;
  40.  
  41. GLdouble TOP = 1;      /* it is the limits of the bounding box */
  42. GLdouble BOTTOM = -1;  /* it is the limits of the bounding box */
  43.  
  44. GLdouble LEFT = -13.8/10.5;    /* it is the limits of the bounding box */
  45. GLdouble RIGHT = 13.8/10.5;    /* it is the limits of the bounding box */
  46.  
  47. GLdouble NEAR2 =  0;
  48. GLdouble FAR2 =   3;
  49.  
  50. /* *INDENT-OFF* */
  51. GLfloat body[][2] = { {0, 3}, {1, 1}, {5, 1}, {8, 4}, {10, 4}, {11, 5},
  52.   {11, 11.5}, {13, 12}, {13, 13}, {10, 13.5}, {13, 14}, {13, 15}, {11, 16},
  53.   {8, 16}, {7, 15}, {7, 13}, {8, 12}, {7, 11}, {6, 6}, {4, 3}, {3, 2},
  54.   {1, 2} };
  55. GLfloat arm[][2] = { {8, 10}, {9, 9}, {10, 9}, {13, 8}, {14, 9}, {16, 9},
  56.   {15, 9.5}, {16, 10}, {15, 10}, {15.5, 11}, {14.5, 10}, {14, 11}, {14, 10},
  57.   {13, 9}, {11, 11}, {9, 11} };
  58. GLfloat leg[][2] = { {8, 6}, {8, 4}, {9, 3}, {9, 2}, {8, 1}, {8, 0.5}, {9, 0},
  59.   {12, 0}, {10, 1}, {10, 2}, {12, 4}, {11, 6}, {10, 7}, {9, 7} };
  60. GLfloat eye[][2] = { {8.75, 15}, {9, 14.7}, {9.6, 14.7}, {10.1, 15},
  61.   {9.6, 15.25}, {9, 15.25} };
  62.  
  63. GLfloat skinColor[] = {0.1, 1.0, 0.1, 1.0}, eyeColor[] = {1.0, 0.2, 0.2, 1.0};
  64.  
  65. // Structures --------------------------------------------------------------------------- Structures
  66. // Structures -------------------------------------------------------------------------- Structures
  67. // Structures -------------------------------------------------------------------------- Structures
  68.  
  69. struct bmm  {
  70.          double bar;     /*pr calc xmin xbar xmax ymin... */
  71.          double min;     /*sans parcourir a chaque fois   */
  72.          double max;     /*trois fois l'array xc, yc, zc. */
  73. } ;
  74.  
  75. struct color {
  76.         char r;
  77.         char g;
  78.         char b;
  79. };
  80.  
  81. struct scr_bar
  82. { 
  83.      // corner of the green square
  84.          int x_g_min, x_g_max, y_g_min, y_g_max;
  85.  
  86.      // corner of the red square
  87.          int x_r_min, x_r_max, y_r_min, y_r_max;
  88.  
  89.          // corners of the middle square.
  90.          int x_m_min, x_m_max, y_m_min, y_m_max;
  91.  
  92.          // corners of the higher triangle
  93.          int x_ht_min, x_ht_max, y_ht_min, y_ht_max;
  94.  
  95.          // corners of the lower triangle
  96.          int x_lt_min, x_lt_max, y_lt_min, y_lt_max;
  97. };
  98.  
  99. struct rect
  100. {
  101.          int xmin, xmax, ymin, ymax;
  102. };
  103.  
  104.  
  105.  
  106. // Variables of my data (The Cloud of points) ------------------------- Variables of my data (The Cloud of points)
  107. // Variables of my data (The Cloud of points) ------------------------- Variables of my data (The Cloud of points)
  108. // Variables of my data (The Cloud of points) ------------------------- Variables of my data (The Cloud of points)
  109.  
  110. float *var[100]; // Contains all the variables at hand.
  111.  
  112. float *var_animation;
  113. float var_animation_min;
  114. float var_animation_max;
  115. char var_name[100][40];
  116. int nbr_of_col = 0;
  117. float *zc; // Contain the z value 4th column (cloud of pts)
  118. float *yc; // Contain the y value 3rd column (cloud of pts)
  119. float *xc; // Contain the x value 2nd column (cloud of pts)
  120.  
  121. int *col1; // I have 5 column in my data this is the first one
  122. int *col4; // I have 5 column in my data this is the 5th   one
  123.  
  124. float *czz;  /* arrays containg the color information of the 3D pts */
  125. float *cyy;  /* arrays containg the color information of the 3D pts */
  126. float *cxx;  /* arrays containg the color information of the 3D pts */
  127.  
  128. double xmin,xmin_e ; 
  129. double xmax,xmax_e ; 
  130. double ymin,ymin_e ; 
  131. double ymax,ymax_e ; 
  132. double zmin,zmin_e ; 
  133. double zmax,zmax_e ; 
  134.  
  135. double delta_min;
  136. double sig_min;
  137. double deltax ; // abs (xmax-xmin)
  138. double deltay ; // abs (ymax-ymin)
  139. double deltaz ; // abs (zmax-zmin)
  140.  
  141. double deltax_n ; // abs (xmax-xmin) after normalization to have normalized scaling
  142. double deltay_n ; // abs (ymax-ymin) after normalization to have normalized scaling
  143. double deltaz_n ; // abs (zmax-zmin) after normalization to have normalized scaling
  144.  
  145. double xbar = 1;  /* Ce sont les coordonnes du */
  146. double ybar = 2;  /* centre du gravite de la   */
  147. double zbar = 3;  /* carte de profondeur       */
  148.  
  149. double sigx; // sigmax
  150. double sigy; // sigmay
  151. double sigz; // sigmaz
  152.  
  153. double sig_x_n; // sigmax after normalization to have normalized scaling
  154. double sig_y_n; // sigmay after normalization to have normalized scaling
  155. double sig_z_n; // sigmaz after normalization to have normalized scaling
  156.  
  157. int dim[1]; // Number of 3D points => dim[0]-1 is the last indice. [of the point with the Nans].
  158.  
  159. // Variables for my camera  -------------------------------------------- Variables for my camera
  160. // Variables for my camera  -------------------------------------------- Variables for my camera
  161. // Variables for my camera  -------------------------------------------- Variables for my camera
  162. double transX, transY, transZ;
  163. double baseline = -1.14; // 0.2;
  164. double eyex,eyey,eyez,upx,upy,upz,sidex,sidey,sidez,teta=0,phi=0,teta2;
  165.  
  166. // Flags ------------------------------------------------------------------------------------------------ Flags
  167. // Flags ------------------------------------------------------------------------------------------------ Flags
  168. // Flags ------------------------------------------------------------------------------------------------ Flags
  169. FLAG DRAW_CARRE1 = 0;
  170. FLAG DRAW_CARRE2 = 0;
  171. FLAG DRAW_CARRE3 = 0;
  172. FLAG FLAG_X_SMALLER_THAN_100 = 0;
  173. FLAG TOGGLE_BOX = 0;
  174. FLAG TRANSLATE_TO_GRAVITY=0;
  175. FLAG TRANSLATE_TO_MIDDLE =1;
  176. FLAG  displayListInited = 0;
  177. FLAG Draw_relative_axe = 1;
  178. FLAG spinning = 0;
  179. FLAG expand_carre1 = 0;
  180. FLAG expand_carre2 = 0;
  181. FLAG expand_carre3 = 0;
  182. FLAG APPLY_MOUSE_MOTION = 0;
  183. enum  {baseline_zoom, rotating, translating, scaling, motion_carre1, motion_carre2, motion_carre3, vertical_adj} 
  184. flag_motion, flag_motion_command;
  185. FLAG VIRGULE = 0;
  186. FLAG VIRGULE_AT_END_OF_LINE = 0;
  187. enum {up, down, bandflag}
  188. flag_elevator;
  189.  
  190. // int SCALE_DEFAULT = 1 ; not necessary since by default it's 1!!!
  191. int SCALE_SIGMA   = 0 ;
  192. int SCALE_MIDDLE  = 1 ;
  193.  
  194. // OpenGl Variables. --------------------------------------------------------------------- OpenGl Variables.
  195. // OpenGl Variables. --------------------------------------------------------------------- OpenGl Variables.
  196. // OpenGl Variables. --------------------------------------------------------------------- OpenGl Variables.
  197. double pt_size = 1.0;
  198. int fraction =1 ; // the fraction of the points displayed.
  199. float fogDensity = 0.02;
  200.  
  201. // strings strings -----------------------------------------------------------------strings
  202. // strings strings -----------------------------------------------------------------strings
  203. // strings strings -----------------------------------------------------------------strings
  204. char string1[40]; // Z Blue.
  205. char string2[40]; // Y Green.
  206. char string3[40]; // X RED.
  207. char string4[]="Stereo_zoom";
  208. char string5[]="Zoom";
  209. char string6[]="Animation";
  210. char string7[]="Vert_adj.";
  211. char string8[]="Color.";
  212. char string9[]="Pt_Size";
  213.  
  214. // Variables for the viewport -------------------------------------- Variables for the viewport
  215. // Variables for the viewport--------------------------------------- Variables for the viewport 
  216. // Variables for the viewport -------------------------------------- Variables for the viewport
  217. FLAG viewport = 1; // initially no command bar.
  218. struct scr_bar
  219. sb_c1[1], sb_c2[1], sb_c3[1];
  220.  
  221. struct rect
  222. stereo_zoom_rect[1],scaling_rect[1],animation_rect[1],vertical_adj_rect[1], color_rect[1], pt_size_rect[1];
  223.  
  224. // Variables for the elevator------------------------------------- Variables for the elevator
  225. // Variables for the elevator------------------------------------- Variables for the elevator
  226. // Variables for the elevator------------------------------------- Variables for the elevator
  227. struct rect
  228. up_rect[1], down_rect[1],band_rect[1];
  229. float band; //determins the band width of highlight points.
  230.  
  231. float thresh; // threshhold for window2 (the elevator) (The line).
  232.  
  233. // GLUT Variables -------------------------------------------------------------------- GLUT Variables
  234. // GLUT Variables -------------------------------------------------------------------- GLUT Variables
  235. // GLUT Variables -------------------------------------------------------------------- GLUT Variables
  236. int Menu1_id,Menu2_id;
  237. int X,Y;
  238. int W = 930, H = 350;
  239. int W2 = 400, H2 = 100;
  240. int vav = 33; // vav  = vertical adjustment value.
  241. int win; // identifier of the big big windoooooow...
  242.  
  243. // Variables -------------------------------------------------------------------- Variables
  244. // Variables -------------------------------------------------------------------- Variables
  245. // Variables -------------------------------------------------------------------- Variables
  246. double carre1 = 0;
  247. double carre2 = 0;
  248. double carre3 = 0;
  249. double carre1_trans=0.5;
  250. double carre2_trans=0.5;
  251. double carre3_trans=0.5;
  252. float         lUPt[16][3] = {  1 , 0 , 0 ,
  253.                               0 , 1 , 0 ,
  254.                               0 , 0 , 1 ,
  255.  
  256.                               1  , 0.8, 0.3,
  257.                               0.8,  1 , 0.3,
  258.                               0.8, 0.3, 1,
  259.  
  260.                               1 , 1 , 0 ,
  261.                               1 , 0 , 1 ,
  262.                               0 , 1 , 1 , 
  263.  
  264.                               1  , 0.3, 0.8,
  265.                               0.3,  1 , 0.8,
  266.                               0.3, 0.8, 1,
  267.  
  268.                               0.5 , 0.5 , 1,
  269.                               0.5 ,  1  , 0.5,
  270.                                 1 ,  0.5, 0.5,
  271.  
  272.                                 1 , 1 , 1} ;
  273.  
  274.                               
  275.  
  276.  
  277.  
  278. int i;
  279.  
  280. void 
  281. inputdollar (char phrase[70]) 
  282. {  
  283.    char mot[20] ;
  284.    char blanc [2];
  285.    blanc[0] = ' ';
  286.    strcpy (phrase,""); /* pour vider input car on va lui faire un strcat. */
  287.    printf ("---> ");
  288.    while (blanc[0] == ' ')
  289.    {
  290.     scanf ("%s",mot);
  291.     scanf ("%1c",blanc);
  292.     strcat (phrase,mot);
  293.     strncat (phrase,blanc,1);
  294.     
  295.    }
  296.    
  297. }
  298.  
  299. void
  300. showMessage(GLfloat x, GLfloat y, GLfloat z, char *message)
  301. {
  302.          glPushMatrix();
  303.          glDisable(GL_LIGHTING);
  304.          glRasterPos3f(x,y,z);
  305.          //glScalef(.02, .02, .02); 
  306.          
  307.          while (*message) {
  308.                     //glutStrokeCharacter(GLUT_STROKE_ROMAN, *message);
  309.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, *message);
  310.                     message++;
  311.          }
  312.          glPopMatrix();
  313.          if (dinosor) glEnable(GL_LIGHTING);
  314. }
  315. /*________________________trouver____________________________________*/
  316. /* c'est une fct qui calcul la moyenne */
  317. /* d'un tableau TABC et le min et le   */
  318. /* et le max du meme TABC et renvoie   */
  319. /* ces 3 valeurs en renvoyant une struc*/
  320. struct bmm trouver (float *tabc,int dim[1])
  321. { int i;
  322.   int local_dim = dim[0];
  323.   struct bmm bmm2;
  324.   bmm2.bar=0;
  325.   bmm2.min=tabc[0];
  326.   bmm2.max=tabc[0];
  327.   for (i=0; i<dim[0]; i++)
  328.   {
  329.       if (tabc[i] != NaN) {
  330.             bmm2.bar = bmm2.bar + tabc [i];
  331.             if (tabc[i]<bmm2.min) bmm2.min = tabc[i];
  332.             if (tabc[i]>bmm2.max) bmm2.max = tabc[i];
  333.       }
  334.       else local_dim = local_dim -1;
  335.   }
  336.   bmm2.bar = bmm2.bar/local_dim;
  337.   return bmm2;
  338. }
  339. /*_____________________trouver_bar_min_max_________________________*/
  340. /* c'est une fct qui calcul le bar, max et min */
  341. /* de 3 tableaux: xc, yc, zc.                  */
  342. trouver_bar_min_max_sig(float *xc,float *yc, float* zc,int dim[1])
  343. { struct bmm bmm1;
  344.   
  345.   bmm1=trouver (xc,dim);
  346.   xmax = bmm1.max;
  347.   xbar = bmm1.bar;
  348.   xmin = bmm1.min;
  349.   bmm1=trouver (yc,dim);
  350.   ymax = bmm1.max;
  351.   ybar = bmm1.bar;
  352.   ymin = bmm1.min;
  353.   bmm1=trouver (zc,dim);
  354.   zmax = bmm1.max;
  355.   zbar = bmm1.bar;
  356.   zmin = bmm1.min;
  357.  
  358.     // Calculating sigma and taking care of NaN.
  359.     sigx = sigy = sigz = 0;
  360.     int dimx, dimy, dimz; // to take care of NaN.
  361.     dimx = dimy = dimz = dim[0];
  362.     for (int i=0; i< dim[0]; i++){
  363.             if (xc[i] != NaN)
  364.                 sigx = sigx + (xbar - xc[i]) * (xbar - xc[i]);
  365.             else dimx = dimx -1;
  366.  
  367.             if (yc[i] != NaN)
  368.                 sigy = sigy + (ybar - yc[i]) * (ybar - yc[i]);
  369.             else (dimy = dimy -1);
  370.  
  371.             if (zc[i] != NaN)
  372.                 sigz = sigz + (zbar - zc[i]) * (zbar - zc[i]);
  373.             else (dimz = dimz -1);
  374.     }
  375.     sigx = sigx/dimx;
  376.     sigy = sigy/dimy;
  377.     sigz = sigz/dimz;
  378.  
  379.     sigx = sqrt (sigx);    
  380.     sigy = sqrt (sigy);    
  381.     sigz = sqrt (sigz);    
  382.  
  383.     // Normalizing sigma so that when we scale it keeps the smallest axes fix.
  384.     if ((sigx<sigy) && (sigx<sigz)) sig_min = sigx;
  385.     else     
  386.              if ((sigy<sigx) && (sigy<sigz)) sig_min = sigy;
  387.              else sig_min = sigz;
  388.     
  389.     sig_x_n = sigx/sig_min;
  390.     sig_y_n = sigy/sig_min;
  391.     sig_z_n = sigz/sig_min;
  392.  
  393.     // Calculating delta.
  394.     deltax = fabs(xmax - xmin);
  395.     deltay = fabs(ymax - ymin);
  396.     deltaz = fabs(zmax - zmin);
  397.  
  398. // Normalizing sigma so that when we scale it keeps the smallest axes fix.
  399.     if ((deltax<deltay) && (deltax<deltaz)) delta_min = deltax;
  400.     else     
  401.              if ((deltay<deltax) && (deltay<deltaz)) delta_min = deltay;
  402.              else delta_min = deltaz;
  403.  
  404.     deltax_n = deltax/delta_min;
  405.     deltay_n = deltay/delta_min;
  406.     deltaz_n = deltaz/delta_min;
  407.  
  408.     // Calculating xmin_e ... for some extraneous uses...
  409.     xmin_e = xmin - 0.3*deltax;
  410.     ymin_e = ymin - 0.3*deltay;
  411.     zmin_e = zmin - 0.3*deltaz;
  412.     xmax_e = xmax + 0.3*deltax;
  413.     ymax_e = ymax + 0.3*deltay;
  414.     zmax_e = zmax + 0.3*deltaz;
  415.  
  416.     cout << "xmax=" << xmax << "  ymax=" << ymax << "  zmax=" << zmax << endl;
  417.     cout << "xmin=" << xmin << "  ymin=" << ymin << "  zmin=" << zmin << endl;
  418.     cout << "xbar=" << xbar << "  ybar=" << ybar << "  zbar=" << zbar << endl;
  419.     cout << "sigx="<< sigx << "  sigy=" << sigy << "  sigz=" << sigz << endl;
  420.     cout << "sig_x_n="<< sig_x_n << "  sig_y_n=" << sig_y_n << "  sig_z_n=" << sig_z_n << endl;
  421.     cout << "xmax-xmin=" << xmax - xmin << "  ymax-ymin=" << ymax - ymin << " zmax-zmin=" << zmax - zmin << endl;
  422.     cout << "deltax=" << deltax << "  deltay="<<  deltay << "  deltaz=" << deltaz << endl;
  423.     cout << "deltax_n=" << deltax_n << "  deltay_n="<<  deltay_n << "  deltaz_n=" << deltaz_n << endl;
  424.   
  425. }
  426. void
  427. load_data_NZP ()
  428. {
  429.     // initializing the look up table.
  430.  
  431.      int fin,i,choice;
  432.          int pts = 1000;
  433.          char joumlat[10000];
  434.      FILE *file;
  435.          char filename[70];
  436.          char fileroot[70];
  437.      i=0;
  438.          strcpy (fileroot,"./");
  439.          cout << "Please give the name of the file : " ;
  440.          cin >> filename;
  441.          strcat (fileroot,filename);
  442.      printf ("loading ...\n");
  443.      if ((file = fopen (fileroot,"r")) == NULL)
  444.                     //     if ((file = fopen ("/ford/sl1426/u/habirach/c/data/data.hab","r")) == NULL)
  445.       printf ("mako1 it's not opening the NZP file \n");
  446.  
  447.          // Reading the first line of the file + prompting the user
  448.          // to get rid of the junk. Junk will point AT the last char read.
  449.          int junk = 0;  // contains the junk
  450.          int junkl = 0; // contains the junk + the last line read
  451.          choice = 3;
  452.          while (choice == 3){
  453.                     junk = junkl;
  454.                     joumlat[junkl] = '-';  // initializing joumlat[junk]
  455.                     cout << endl << endl;
  456.                     cout << "*********************************************************"<< endl; 
  457.                     while (joumlat[junkl] !='\n'){
  458.                              junkl++;
  459.                              fscanf (file, "%1c",&joumlat[junkl]);
  460.                              cout << joumlat[junkl] ;
  461.                     }
  462.                     cout << "*********************************************************"<< endl; 
  463.                     cout << endl << endl;
  464.                     cout << "*     1) Use as a header         *"<< endl; 
  465.                     cout << "*     2) Start loading           *"<< endl; 
  466.                     cout << "*     3) Skip  row               *"<< endl; 
  467.                     cout << "       Press 1,2 or 3 --->  ";
  468.                     cin >> choice;
  469.          }
  470.          cout <<  "How Many points do you want to load ? " ;
  471.          cin >> pts;
  472.          // Setting the VIRGULE FLAG.
  473.          char harf [2];
  474.          harf[0] = 't';
  475.          while (harf[0]!='\n'){
  476.                     fscanf (file, "%1c",&harf[0]);
  477.                     if (harf[0] == ',') VIRGULE = VIRGULE + 1;
  478.          }
  479.  
  480.          // counting the number of columns and placing the file pointer on the first number.
  481.          nbr_of_col = 0;
  482.          float f;
  483.          harf[0] = 't';
  484.          while (harf[0] != '\n'){
  485.                     while ( (harf[0]!=32) && (harf[0]!=9) && (harf[0]!=',') && (harf[0]!='\n')) // scan the first number
  486.                              fscanf (file, "%1c",&harf[0]);
  487.                   nbr_of_col++;
  488.                     while ( (harf[0]==32) || (harf[0]==9) || (harf[0]==',') ) // scan the following del.
  489.                              fscanf (file, "%1c",&harf[0]);
  490.          }
  491.          fflush(file);
  492.          fclose(file);
  493.          if ((file = fopen (fileroot,"r")) == NULL)  // Reopening the file
  494.                     printf ("mako2 it's not opening the NZP file \n");
  495.          for (i = 0; i<junk-1; i++){  // Passing all the junk again.
  496.                     fscanf (file, "%1c",&joumlat[i]);
  497.          }
  498.          fscanf (file, "%1c",&joumlat[i]);
  499.  
  500.          // set VIRGULE_AT_END_OF_LINE
  501.          if (VIRGULE == nbr_of_col) VIRGULE_AT_END_OF_LINE = 1;
  502.          
  503.          // Load the damn data!!
  504.          int dim_list_points = 0;
  505.          if (choice == 1){
  506.                     if (!VIRGULE){
  507.                              for (i=0; i<nbr_of_col; i++){
  508.                                         fscanf (file, "%s",var_name[i]);
  509.                                         cout << var_name[i] << endl;
  510.                              }
  511.                     }
  512.                     if (VIRGULE){
  513.                              for (i=0; i<nbr_of_col; i++){
  514.                                         int j = 0;
  515.                                         fscanf (file, "%1c",&harf[0]);
  516.                                         while ((harf[0]!=',')&&(harf[0]!='\n')) {
  517.                                                  var_name[i][j] = harf[0];
  518.                                                  fscanf (file, "%1c",&harf[0]);
  519.                                                  j++;
  520.                                         }
  521.                              }
  522.                     }
  523.                     for (i=0; i<nbr_of_col; i++)
  524.                              cout << var_name[i] << endl;
  525.          }
  526.          
  527.          // setting var_name
  528.          char cca[1],ccb[1];
  529.          i=0;
  530.          if (choice ==2)
  531.                     for (cca[0]=48;cca[0]<58;cca[0]++)
  532.                              for (ccb[0]=48;ccb[0]<58;ccb[0]++){
  533.                                         strcat (var_name[i],"var_");
  534.                                         strcat (var_name[i],ccb);
  535.                                         strcat (var_name[i],cca);
  536.                                         i++;
  537.                              }
  538.          i = 0;
  539.          fin = 1;
  540.          char string[40];
  541.          // Reading the numerical value of the data points
  542.          while ((fin!=-1)&&(dim_list_points < pts)){
  543.                     if ((dim_list_points%1000) == 0) printf (".");
  544.                     glFlush();
  545.                     dim_list_points = dim_list_points +1;
  546.                     for (i=0; i<nbr_of_col; i++){
  547.                              var[i] = (float *) realloc (var[i],(dim_list_points) * sizeof(float)); 
  548.                              fin = fscanf (file, "%s", &string);
  549.                              if ((string[0] == 'N') && (string[1]=='a')) var[i][dim_list_points-1] = NaN;
  550.                              else var[i][dim_list_points-1] = atof(string);
  551.                              if (dim_list_points <= 2) printf(" - %f - ",var[i][dim_list_points-1]);
  552.                              if (VIRGULE){
  553.                                         fscanf (file, "%1c",&harf[0]);
  554.                                         while ( (harf[0]==32) || (harf[0]==9) ) // scan until ',' read
  555.                                                  fscanf (file, "%1c",&harf[0]);
  556.                              }
  557.                     }    
  558.                     if (VIRGULE_AT_END_OF_LINE){
  559.                              fscanf (file, "%1c",&harf[0]);
  560.                              while ( (harf[0]==32) || (harf[0]==9) ) // scan the following del.
  561.                                         fscanf (file, "%1c",&harf[0]);
  562.                     }
  563.          }
  564.  
  565.          fclose (file);
  566.  
  567.          if (fin ==-1)
  568.                     dim_list_points = dim_list_points -1;
  569.          // dim_list_points is now = to the number of points. dim_list_points-1 --> to the last point.
  570.          
  571.          cxx = (float *) realloc (cxx,(dim_list_points) * sizeof(float));
  572.          cyy = (float *) realloc (cyy,(dim_list_points) * sizeof(float));
  573.          czz = (float *) realloc (czz,(dim_list_points) * sizeof(float));
  574.          for (i=0;i<dim_list_points;i++){
  575.                     cxx[i] = 1.0;
  576.                     cyy[i] = 1.0;
  577.                     czz[i] = 1.0;
  578.          }                    
  579.          
  580.          cout << endl << "There is " << dim_list_points << " loaded" << endl;
  581.          dim[0] = dim_list_points;
  582.          printf ("finishing the Load data from disk process...\n" );
  583.  
  584.          // set string1,2,3
  585.          strcat (string1,"Z: ");
  586.          strcat (string1,var_name[0]);
  587.          strcat (string2,"Y: ");
  588.          strcat (string2,var_name[1]);
  589.          strcat (string3,"X: ");
  590.          strcat (string3,var_name[2]);
  591.  
  592.         xc = var[0];
  593.         yc = var[1];
  594.         zc = var[2];
  595.  
  596.          trouver_bar_min_max_sig (xc,yc,zc,dim);
  597.  
  598.          /* if (Flag_eternal) {
  599.             // Set TOP RIGHT
  600.             if (fabs(xmax) > fabs (xmin)) RIGHT = 2*fabs(xmax);
  601.             else RIGHT = 2*fabs (xmin);
  602.          
  603.             if (fabs(ymax) > fabs (ymin)) TOP = 2*fabs(ymax);
  604.             else TOP = 2*fabs (ymin);
  605.          
  606.             // Scaling so that it is in the same ratio as the pixel ratio : 5/4 
  607.             if (TOP > RIGHT) RIGHT = 5*TOP/4;
  608.             else  TOP = 4*RIGHT/5;
  609.  
  610.             BOTTOM = - TOP;
  611.             LEFT   = - RIGHT;
  612.          }
  613.          Flag_eternal = 0; */
  614.  
  615. }
  616.  
  617. void 
  618. rectangle(int x1,int y1,int x2,int y2, float r, float g, float b, rect *re) //frectangle
  619. // x1 , y1 are the upper left  corner
  620. // x2 , y2 are the low   right corner
  621. {
  622.          glBegin(GL_POLYGON);
  623.          glColor3f (r,g,b);
  624.          glVertex2f(x1 , y1 );
  625.          glVertex2f(x1 , y2 );
  626.          glVertex2f(x2 , y2 );
  627.          glVertex2f(x2 , y1 );
  628.          glEnd();
  629.          re->xmin = x1;
  630.          re->xmax = x2;
  631.          re->ymin = y1;
  632.          re->ymax = y2;
  633. }
  634. void
  635. scrollbar(int x,int y,int w,scr_bar *s) //fscrollbar
  636. // (x,y) is the upper left corner
  637. // w is the width of the scroll bar.
  638. // The scrollbar is 88 pixel long
  639.  
  640. {
  641.          // Create a srall bar.
  642.  
  643.          // Drawing the green squar up
  644.          glBegin(GL_POLYGON);
  645.          glColor3f (0,1,0);
  646.          glVertex2f(x  ,y   );
  647.          glVertex2f(x  ,y+10);
  648.          glVertex2f(x+w,y+10);
  649.          glVertex2f(x+w,y   );
  650.          glEnd();
  651.          s->x_g_min = x;
  652.          s->x_g_max = x+w;
  653.          s->y_g_min = y;
  654.          s->y_g_max = y+10;
  655.  
  656.          // Drawing the red squar down
  657.          glBegin(GL_POLYGON);
  658.          glColor3f (1,0,0);
  659.          glVertex2f(x  ,y+78);
  660.          glVertex2f(x  ,y+88);
  661.          glVertex2f(x+w,y+88);
  662.          glVertex2f(x+w,y+78);
  663.          glEnd();
  664.          s->x_r_min = x;
  665.          s->x_r_max = x+w;
  666.          s->y_r_min = y+78;
  667.          s->y_r_max = y+88;
  668.  
  669.          // Drawing upper triangle
  670.          glBegin (GL_TRIANGLES);
  671.           glColor3f (0.7,0.6,0.5);
  672.          glVertex2f(x+w/2, y+12);
  673.          glVertex2f(x    , y+22);
  674.          glVertex2f(x+w  , y+22);
  675.          glEnd();
  676.          s->x_ht_min = x;
  677.          s->x_ht_max = x+w;
  678.          s->y_ht_min = y+12;
  679.          s->y_ht_max = y+22;
  680.  
  681.          // Drawing lower triangle
  682.          glBegin (GL_TRIANGLES);
  683.           glColor3f (0.7,0.6,0.5);
  684.          glVertex2f(x    ,y+66);
  685.          glVertex2f(x+w/2,y+76);
  686.          glVertex2f(x+w  ,y+66);
  687.          glEnd();
  688.          s->x_lt_min = x;
  689.          s->x_lt_max = x+w;
  690.          s->y_lt_min = y+66;
  691.          s->y_lt_max = y+76;
  692.  
  693.          // Drawing the middle rectangle.
  694.          glBegin (GL_POLYGON);
  695.          glColor3f (0.7,0.9,0.6);
  696.          glVertex2f(x   ,y+24   );
  697.          glVertex2f(x   ,y+24+40);
  698.          glVertex2f(x+w ,y+24+40);
  699.          glVertex2f(x+w ,y+24   );
  700.          glEnd();
  701.          s->x_m_min = x;
  702.          s->x_m_max = x+w;
  703.          s->y_m_min = y+24;
  704.          s->y_m_max = y+64;
  705.  
  706. }
  707.  
  708.  
  709. void
  710. draw_carre1() //fdraw_carre1
  711. {
  712.          glEnable (GL_BLEND);
  713.          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  714.          // glDepthMask(GL_FALSE);
  715.          // glMateriali (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,1);
  716.          double z = zmin+carre1;
  717.          if (expand_carre1){
  718.                     glBegin (GL_POLYGON);
  719.                     glColor4f (0, 0, 0.9,carre1_trans);
  720.                     // glShadeModel (GL_FLAT);
  721.                     glVertex3f (xmin_e,ymin_e,z);
  722.                     glVertex3f (xmax_e,ymin_e,z);
  723.                     glVertex3f (xmax_e,ymax_e,z);
  724.                     glVertex3f (xmin_e,ymax_e,z);
  725.                     glEnd();
  726.  
  727.                     glBegin (GL_POLYGON);
  728.                     glColor4f (0, 0, 0.9,carre1_trans);
  729.                     glVertex3f (xmin_e,ymax_e,z);
  730.                     glVertex3f (xmax_e,ymax_e,z);
  731.                     glVertex3f (xmax_e,ymin_e,z);
  732.                     glVertex3f (xmin_e,ymin_e,z);
  733.                     glEnd();
  734.          }
  735.          else{
  736.                     glBegin (GL_POLYGON);
  737.                     glColor4f (0, 0, 0.9,carre1_trans);
  738.                     glVertex3f (xmin,ymin,z);
  739.                     glVertex3f (xmax,ymin,z);
  740.                     glVertex3f (xmax,ymax,z);
  741.                     glVertex3f (xmin,ymax,z);
  742.                     glEnd();
  743.  
  744.                     glBegin (GL_POLYGON);
  745.                     glColor4f (0, 0, 0.9,carre1_trans);
  746.                     glVertex3f (xmin,ymax,z);
  747.                     glVertex3f (xmax,ymax,z);
  748.                     glVertex3f (xmax,ymin,z);
  749.                     glVertex3f (xmin,ymin,z);
  750.                     glEnd();
  751.          }
  752.          glDisable(GL_BLEND);
  753.          // glDepthMask(GL_TRUE);
  754. }
  755.  
  756. void
  757. draw_carre2() //fdraw_carre2
  758. {
  759.          glEnable (GL_BLEND);
  760.          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  761.          // glDepthMask(GL_FALSE);
  762.          double y = ymin+carre2;
  763.          if (expand_carre2){
  764.                     glBegin (GL_POLYGON);
  765.                     glColor4f (0, 0.9, 0.0,carre2_trans);
  766.                     glVertex3f (xmin_e,y,zmin_e);
  767.                     glVertex3f (xmax_e,y,zmin_e);
  768.                     glVertex3f (xmax_e,y,zmax_e);
  769.                     glVertex3f (xmin_e,y,zmax_e);
  770.                     glEnd();
  771.  
  772.                     glBegin (GL_POLYGON);
  773.                     glColor4f (0, 0.9, 0.0,carre1_trans);
  774.                     glVertex3f (xmin_e,y,zmax_e);
  775.                     glVertex3f (xmax_e,y,zmax_e);
  776.                     glVertex3f (xmax_e,y,zmin_e);
  777.                     glVertex3f (xmin_e,y,zmin_e);
  778.                     glEnd();
  779.          }
  780.          else{
  781.                     glBegin (GL_POLYGON);
  782.                     glColor4f (0, 0.9, 0.0,carre1_trans);
  783.                     glVertex3f (xmin ,y,zmin );
  784.                     glVertex3f (xmax ,y,zmin );
  785.                     glVertex3f (xmax ,y,zmax );
  786.                     glVertex3f (xmin ,y,zmax );
  787.                     glEnd();
  788.  
  789.                     glBegin (GL_POLYGON);
  790.                     glColor4f (0, 0.9, 0.0,carre1_trans);
  791.                     glVertex3f (xmin ,y,zmax );
  792.                     glVertex3f (xmax ,y,zmax );
  793.                     glVertex3f (xmax ,y,zmin );
  794.                     glVertex3f (xmin ,y,zmin );
  795.                     glEnd();
  796.          }
  797.          glDisable(GL_BLEND);
  798.          // glDepthMask(GL_TRUE);
  799. }
  800.  
  801. void
  802. draw_carre3() //fdraw_carre3
  803. {
  804.          glEnable (GL_BLEND);
  805.          glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  806.          // glDepthMask(GL_FALSE);
  807.          double x = xmin+carre3;
  808.          if (expand_carre3){
  809.                     glBegin (GL_POLYGON);
  810.                     glColor4f (0.9, 0.0, 0.0,carre3_trans);
  811.                     glVertex3f (x,ymin_e,zmax_e);
  812.                     glVertex3f (x,ymin_e,zmin_e);
  813.                     glVertex3f (x,ymax_e,zmin_e);
  814.                     glVertex3f (x,ymax_e,zmax_e);
  815.                     glEnd();
  816.  
  817.                     glBegin (GL_POLYGON);
  818.                     glColor4f (0.9, 0, 0.0,carre3_trans);
  819.                     glVertex3f (x,ymax_e,zmax_e);
  820.                     glVertex3f (x,ymax_e,zmin_e);
  821.                     glVertex3f (x,ymin_e,zmin_e);
  822.                     glVertex3f (x,ymin_e,zmax_e);
  823.                     glEnd();
  824.          }
  825.          else{
  826.                     glBegin (GL_POLYGON);
  827.                     glColor4f (0.9, 0.0, 0.0,carre3_trans);
  828.                     glVertex3f (x,ymin,zmax);
  829.                     glVertex3f (x,ymin,zmin);
  830.                     glVertex3f (x,ymax,zmin);
  831.                     glVertex3f (x,ymax,zmax);
  832.                     glEnd();
  833.  
  834.                     glBegin (GL_POLYGON);
  835.                     glColor4f (0.9, 0, 0.0,carre3_trans);
  836.                     glVertex3f (x,ymax,zmax);
  837.                     glVertex3f (x,ymax,zmin);
  838.                     glVertex3f (x,ymin,zmin);
  839.                     glVertex3f (x,ymin,zmax);
  840.                     glEnd();
  841.          }
  842.          glDisable(GL_BLEND);
  843.          // glDepthMask(GL_TRUE);
  844. }
  845.  
  846. void
  847. draw_axes()
  848. {
  849.          void dvertical_adjx();
  850.          glBegin(GL_LINES);
  851.          glColor3f (0.2,0.2,1.0);
  852.          glVertex3f (0.0, 0.0, 0.0);
  853.          glVertex3f (deltax, 0.0, 0.0);
  854.          glEnd();
  855.          showMessage(deltax,0,0, string3);
  856.          glBegin(GL_LINES);
  857.          glColor3f (0.15,0.7,0.15);
  858.          glVertex3f (0.0, 0.0, 0.0);
  859.          glVertex3f (0.0, deltay, 0.0);    
  860.          glEnd();
  861.          showMessage(0,deltay,0, string2);
  862.          glBegin(GL_LINES);
  863.          glColor3f (1,0.2,0.2);
  864.          glVertex3f (0, 0, 0);
  865.          glVertex3f (0.0, 0.0, deltaz);
  866.          glEnd();      
  867.          showMessage(0,0,deltaz, string1);
  868. }
  869.  
  870. void
  871. draw_box()
  872. {
  873.          glBegin(GL_LINES);
  874.          glColor3f (0.45,0.45,0.45);
  875.          glVertex3f (xmin,ymax,zmax);
  876.          glVertex3f (xmax,ymax,zmax);
  877.          glEnd();
  878.  
  879.          glBegin(GL_LINES);
  880.          glColor3f (0.45,0.45,0.45);
  881.          glVertex3f (xmax,ymax,zmax);
  882.          glVertex3f (xmax,ymin,zmax);
  883.          glEnd();
  884.  
  885.          glBegin(GL_LINES);
  886.          glColor3f (0.45,0.45,0.45);
  887.          // glColor3f (0.5,0,0);
  888.          glVertex3f (xmax,ymin,zmax);
  889.          glVertex3f (xmin,ymin,zmax);
  890.          glEnd();
  891.  
  892.          glBegin(GL_LINES);
  893.          glColor3f (0.45,0.45,0.45);
  894.          // glColor3f (0.0,0.5,0.0);
  895.          glVertex3f (xmin,ymin,zmax);
  896.          glVertex3f (xmin,ymax,zmax);
  897.          glEnd();
  898.  
  899.          glBegin(GL_LINES);
  900.          glColor3f (0.45,0.45,0.45);
  901.          // glColor3f (0,0,0.8);
  902.          glVertex3f (xmin,ymax,zmax);
  903.          glVertex3f (xmin,ymax,zmin);
  904.          glEnd();
  905.  
  906.          glBegin(GL_LINES);
  907.          glColor3f (0.45,0.45,0.45);
  908.          //glColor3f (0,0,0.8);
  909.          glVertex3f (xmax,ymax,zmax);
  910.          glVertex3f (xmax,ymax,zmin);
  911.          glEnd();
  912.  
  913.          glBegin(GL_LINES);
  914.          glColor3f (0.45,0.45,0.45);
  915.          //glColor3f (0,0,0.8);
  916.          glVertex3f (xmax,ymin,zmax);
  917.          glVertex3f (xmax,ymin,zmin);
  918.          glEnd();
  919.  
  920.          glBegin(GL_LINES);
  921.          glColor3f (0.45,0.45,0.45);
  922.          //glColor3f (0,0,0.8);
  923.          glVertex3f (xmin,ymin,zmax);
  924.          glVertex3f (xmin,ymin,zmin);
  925.          glEnd();
  926.  
  927.          glBegin(GL_LINES);
  928.          glColor3f (0.45,0.45,0.45);
  929.          //glColor3f (0.0,0.5,0.0);
  930.          glVertex3f (xmin,ymax,zmin);
  931.          glVertex3f (xmin,ymin,zmin);
  932.          glEnd();
  933.  
  934.          glBegin(GL_LINES);
  935.          glColor3f (0.45,0.45,0.45);
  936.          //glColor3f (0.5,0,0);
  937.          glVertex3f (xmin,ymin,zmin);
  938.          glVertex3f (xmax,ymin,zmin);
  939.          glEnd();
  940.  
  941.          glBegin(GL_LINES);
  942.          glColor3f (0.45,0.45,0.45);
  943.          //glColor3f (0.0,0.5,0.0);
  944.          glVertex3f (xmax,ymin,zmin);
  945.          glVertex3f (xmax,ymax,zmin);
  946.          glEnd();
  947.  
  948.          glBegin(GL_LINES);
  949.          glColor3f (0.45,0.45,0.45);
  950.          //glColor3f (0.5,0,0);
  951.          glVertex3f (xmax,ymax,zmin);
  952.          glVertex3f (xmin,ymax,zmin);
  953.          glEnd();
  954.  
  955.  
  956. }
  957.  
  958. void
  959. recalcModelView(void) //frecalcmodelview
  960. {
  961.   GLfloat m[4][4];
  962.     glMatrixMode(GL_MODELVIEW);
  963.   glPopMatrix();
  964.   glPushMatrix();
  965.  
  966.     double scalex, scaley, scalez;
  967.  
  968.   build_rotmatrix(m, curquat);
  969.     gluLookAt(eyex,eyey,eyez,   /* eye is at (... */
  970.                         0,0,0,      /* looking to */
  971.                         upx,upy,upz);      /* up is in positive Y direction */
  972.     
  973.     // rotate
  974.   glMultMatrixf(&m[0][0]);
  975.  
  976.     // We should normalize scaling in order to maintain the same lenth for the smaller axes.
  977.     if (SCALE_SIGMA)  {
  978.              scalex = 1/sigx;
  979.              scaley = 1/sigy;
  980.              scalez = 1/sigz;
  981.     }
  982.  
  983.     // We should normalize scaling in order to maintain the same lenth for the smaller axes.
  984.     if (SCALE_MIDDLE)  {
  985.              scalex = 1/deltax;
  986.              scaley = 1/deltay;
  987.              scalez = 1/deltaz;
  988.     }
  989.     else {
  990.              scalex = 1;  
  991.              scaley = 1;
  992.              scalez = 1;
  993.     }
  994.  
  995.     // Translate the origin ONLY IF INDICATED OTHERWHISE PUT IT IN 0,0,0
  996.              // 
  997.     if (TRANSLATE_TO_GRAVITY) glTranslatef (-xbar*scalex,-ybar*scaley,-zbar*scalez); 
  998.     if (TRANSLATE_TO_MIDDLE ) glTranslatef (-(xmin+xmax)*scalex/2,-(ymin+ymax)*scaley/2,-(zmin+zmax)*scalez/2); 
  999.  
  1000.  
  1001.     // SCALE ONLY IF REQUESTED OTHERWISE DO NOT SCALE (1,1,1).
  1002.   glScalef (scalex, scaley, scalez);
  1003.   newModel = 0;
  1004. }
  1005.  
  1006. void
  1007. ViewPort() //fViewPort()
  1008. {
  1009.          // Draw The Vertical Control Menu.
  1010.  
  1011.          // Set View Port.
  1012.          glViewport (0,0,100,H);
  1013.  
  1014.          // Set Projection Matrix
  1015.          glMatrixMode(GL_PROJECTION);/* set up projection transform */
  1016.          glLoadIdentity();
  1017.          glOrtho (0,100, H,0, -1,1);
  1018.          
  1019.          // Set ModelView Matrix.
  1020.          glMatrixMode (GL_MODELVIEW);
  1021.          glLoadIdentity();
  1022.          
  1023.          // Draw Menu.
  1024.          glBegin (GL_POLYGON);
  1025.          glColor3f (0.25,0.2,0.1);
  1026.          glVertex3f (0  ,H,-0.5);
  1027.          glColor3f (0.25,0.2,0.1);
  1028.          glVertex3f (100,H,-0.5);
  1029.          glColor3f (0.3,0.1,0.15);
  1030.          glVertex3f (100,  0,-0.5);
  1031.          glColor3f (0.3, 0.1,0.15);
  1032.          glVertex3f (0  ,  0,-0.5);
  1033.          glEnd(); 
  1034.  
  1035.          // writing on the window characters Blue -->X...
  1036.          int i;
  1037.          glColor3f (0.75,0.75,1.0);
  1038.          glRasterPos3f(0,10,0.5);
  1039.          int len;
  1040.          len = (int) strlen(string3);
  1041.          for (i = 0; i < len; i++) 
  1042.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string3[i]);
  1043.          
  1044.          glColor3f (0.75,1.0,0.75);
  1045.          glRasterPos3f(0,20,0.5);
  1046.          len = (int) strlen(string2);
  1047.          for (i = 0; i < len; i++) 
  1048.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string2[i]);
  1049.          
  1050.          glColor3f (1.0,0.75,0.75);
  1051.          glRasterPos3f(0,30,0.5);
  1052.          len = (int) strlen(string1);
  1053.          for (i = 0; i < len; i++) 
  1054.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string1[i]);
  1055.          
  1056.  
  1057.          // Drawing the scrollbar for carre1.
  1058.          scrollbar (10,40,20,sb_c1);
  1059.          scrollbar (40,40,20,sb_c2);
  1060.          scrollbar (70,40,20,sb_c3);
  1061.  
  1062.          // Drawing rectanle Stereo_Zoom
  1063.          rectangle (10,130,90,143,0.9,0.3,0.7,stereo_zoom_rect);
  1064.          glColor3f (0,0,0);
  1065.          glRasterPos3f(10,142,0.5);
  1066.          len = (int) strlen(string4);
  1067.          for (i = 0; i < len; i++) 
  1068.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string4[i]);
  1069.  
  1070.          // Drawing rectanle Scaling
  1071.          rectangle (10,145,90,158,0.7,0.9,0.4,scaling_rect);
  1072.          glColor3f (0,0,0);
  1073.          glRasterPos3f(10,157,0.5);
  1074.          len = (int) strlen(string5);
  1075.          for (i = 0; i < len; i++) 
  1076.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string5[i]);
  1077.          
  1078.          // Drawing rectanle Animation.
  1079.          rectangle (10,160,90,173,0.7,0.9,0.4,animation_rect);
  1080.          glColor3f (0,0,0);
  1081.          glRasterPos3f(10,172,0.5);
  1082.          len = (int) strlen(string6);
  1083.          for (i = 0; i < len; i++) 
  1084.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string6[i]);
  1085.  
  1086.          // Drawing rectanle Vertical Adjustment..
  1087.          rectangle (10,175,90,188,0.9,0.9,0.4,vertical_adj_rect);
  1088.          glColor3f (0,0,0);
  1089.          glRasterPos3f(10,187,0.5);
  1090.          len = (int) strlen(string7);
  1091.          for (i = 0; i < len; i++) 
  1092.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string7[i]);
  1093.  
  1094.     
  1095.          // Drawing rectanle Color mapping...
  1096.          rectangle (10,191,90,204,0.9,0.3,0.4,color_rect);
  1097.          glColor3f (0,0,0);
  1098.          glRasterPos3f(10,203,0.5);
  1099.          len = (int) strlen(string8);
  1100.          for (i = 0; i < len; i++) 
  1101.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string8[i]);
  1102.  
  1103.          // Drawing rectanle change pt_size...
  1104.          rectangle (10,207,90,220,0.5,0.3,0.8,pt_size_rect);
  1105.          glColor3f (0,0,0);
  1106.          glRasterPos3f(10,219,0.5);
  1107.          len = (int) strlen(string8);
  1108.          for (i = 0; i < len; i++) 
  1109.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string9[i]);
  1110. }
  1111.  
  1112. void
  1113. recalcModelView_axes(void)
  1114. {
  1115.   GLfloat m[4][4];
  1116.     glMatrixMode(GL_MODELVIEW);
  1117.   glPopMatrix();
  1118.   glPushMatrix();
  1119.   build_rotmatrix(m, curquat);
  1120.     gluLookAt(eyex,eyey,eyez,   /* eye is at (... */
  1121.                         0,0,0,      /* looking to */
  1122.                         upx,upy,upz);      /* up is in positive Y direction */
  1123.     
  1124.     // rotate
  1125.   glMultMatrixf(&m[0][0]);
  1126.  
  1127.     // SCALE ONLY IF REQUESTED OTHERWISE DO NOT SCALE (1,1,1).
  1128.     if (SCALE_SIGMA)   glScalef (1/sigx,1/sigy,1/sigz); // normalized scaling.
  1129.     else  
  1130.         if (SCALE_MIDDLE)  glScalef (1/deltax,1/deltay,1/deltaz);
  1131.         else
  1132.             glScalef (1,1,1);
  1133.  
  1134.   newModel = 0;
  1135. }
  1136.  
  1137.  
  1138. recalcboundingbox() //frecalcboundingbox
  1139. {
  1140.      glMatrixMode(GL_PROJECTION);/* set up projection transform */
  1141.      glPopMatrix();
  1142.      glLoadIdentity();
  1143.      glOrtho (LEFT,RIGHT, BOTTOM,TOP, NEAR2,FAR2);
  1144.      glPushMatrix();
  1145. }
  1146.  
  1147. void
  1148. redraw() //fredraw
  1149. {
  1150.      int i;
  1151.         glDrawBuffer(GL_BACK_LEFT);
  1152.          if (viewport){
  1153.                     // draw command margin then set the viewport for the 3D
  1154.                   
  1155.                     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  1156.                     ViewPort(); // Sets the control band viewport and draws in it.
  1157.                     glViewport (100,0,W-100,H); // set the viewport for the 3D left eye
  1158.          }                                          // vav = vertical adj value.
  1159.          else {
  1160.                     // Set all the screen viewport for the 3D rendering the left eye..
  1161.                     
  1162.                     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  1163.                     glViewport (0,0,W    ,H);
  1164.                              }
  1165.  
  1166.      if (displayListInited) {
  1167.  
  1168.                     // Draw left eye
  1169.                   
  1170.                     eyex = -baseline;
  1171.  
  1172.                     // Draw axes left eye
  1173.                     if (Draw_relative_axe) {
  1174.                              recalcboundingbox(); 
  1175.                              recalcModelView_axes();
  1176.                              draw_axes();
  1177.                     }
  1178.  
  1179.                     // Recalc Model View.
  1180.                     recalcboundingbox(); 
  1181.                     recalcModelView();
  1182.  
  1183.                     // Draw either Dinosaur or pts in left eye
  1184.                     if (dinosor)
  1185.                              glCallList(DINOSAUR);
  1186.                     else
  1187.                              glCallList(28);
  1188.                     
  1189.                     // Draw box left eye
  1190.                     if (TOGGLE_BOX) draw_box();
  1191.  
  1192.                     // Draw carre1
  1193.                     if (DRAW_CARRE1) draw_carre1();
  1194.  
  1195.                     // Draw carre2
  1196.                     if (DRAW_CARRE2) draw_carre2();
  1197.  
  1198.                     // Draw carre3
  1199.                     if (DRAW_CARRE3) draw_carre3();
  1200.                              
  1201.                     // Draw right eye
  1202.                     glDrawBuffer(GL_BACK_RIGHT);
  1203.                     eyex = baseline;
  1204.  
  1205.                     // Draw axes right eye
  1206.                     if (viewport){
  1207.                         glViewport (100,0,W-100,H); // set the viewport for the 3D
  1208.                     }
  1209.                     else {
  1210.                         // Set all the screen viewport for the 3D rendering.
  1211.                         glViewport (0,0,W,H);
  1212.                     }
  1213.  
  1214.                     if (Draw_relative_axe) {
  1215.                             recalcboundingbox(); 
  1216.                             recalcModelView_axes();
  1217.                             draw_axes();
  1218.                     }
  1219.  
  1220.                     // Recalc Model View.
  1221.                     recalcboundingbox();
  1222.                     recalcModelView();
  1223.                     
  1224.                     // Draw Object right eye
  1225.                     if (dinosor)
  1226.                              glCallList(DINOSAUR);
  1227.                     else
  1228.                              glCallList(28);
  1229.                     
  1230.                     // Draw box right eye
  1231.                     if (TOGGLE_BOX) draw_box();
  1232.                     
  1233.                     // Draw carre1
  1234.                     if (DRAW_CARRE1) draw_carre1();
  1235.                     
  1236.                     // Draw carre2
  1237.                     if (DRAW_CARRE2) draw_carre2();
  1238.                     
  1239.                     // Draw carre3
  1240.                     if (DRAW_CARRE3) draw_carre3(); 
  1241.                     glutSwapBuffers();
  1242.          }
  1243.          else {
  1244.                     /* otherwise compile and execute to create the display list */
  1245.                     glNewList(28, GL_COMPILE_AND_EXECUTE);
  1246.                     /* front face */
  1247.                     glPointSize (pt_size);
  1248.                     glBegin(GL_POINTS);
  1249.                     /*    glColor3f(0.0, 0.7, 0.1);    green */
  1250.                     printf ("Drawing for the first time \n");
  1251.                     for (i=0; i<dim[0]; i=i+fraction){
  1252.                         if ((xc[i] != NaN) && (yc[i] != NaN) && (zc[i] != NaN)){
  1253.                              glColor3f (cxx[i], cyy[i], czz[i]);
  1254.                              glVertex3f(xc[i],yc[i],zc[i]);
  1255.                         }
  1256.                     }
  1257.                     
  1258.                     glEnd();
  1259.                     glEndList();
  1260.                     displayListInited = 1;
  1261.                     redraw();
  1262.                     glFlush();
  1263.      }
  1264. }
  1265.  
  1266. void
  1267. fog()
  1268. {
  1269.          glEnable(GL_DEPTH_TEST);
  1270.          GLfloat fogColor[4] = {0, 0,0 , 1.0};
  1271.          glEnable (GL_FOG);
  1272.          glFogi (GL_FOG_MODE, GL_EXP);
  1273.          glFogf (GL_FOG_DENSITY, fogDensity);
  1274.          glFogfv(GL_FOG_COLOR, fogColor);
  1275.          // glHint (GL_FOG_HINT, GL_NICEST);
  1276.           //glFogf (GL_FOG_START, 0);
  1277.          //glFogf (GL_FOG_END, abs(zmin) + abs(zmax));
  1278. }
  1279.  
  1280. void
  1281. extrudeSolidFromPolygon(GLfloat data[][2], unsigned int dataSize,
  1282.                                                 GLdouble thickness, GLuint side, GLuint edge, GLuint whole)
  1283. {
  1284.   static GLUtriangulatorObj *tobj = NULL;
  1285.   GLdouble vertex[3], dx, dy, len;
  1286.   int i;
  1287.   int count = dataSize / (2 * sizeof(GLfloat));
  1288.  
  1289.   if (tobj == NULL) {
  1290.     tobj = gluNewTess();  /* create and initialize a GLU
  1291.                              polygon * * tesselation object */
  1292.     // gluTessCallback(tobj, GLU_BEGIN, glBegin);
  1293.     // gluTessCallback(tobj, GLU_VERTEX, glVertex2fv);  // semi-tricky 
  1294.                                                       
  1295.     gluTessCallback(tobj, GLU_END, glEnd);
  1296.   }
  1297.   glNewList(side, GL_COMPILE);
  1298.   glShadeModel(GL_SMOOTH);  /* smooth minimizes seeing
  1299.                                tessellation */
  1300.   gluBeginPolygon(tobj);
  1301.   for (i = 0; i < count; i++) {
  1302.     vertex[0] = data[i][0];
  1303.     vertex[1] = data[i][1];
  1304.     vertex[2] = 0;
  1305.     gluTessVertex(tobj, vertex, data[i]);
  1306.   }
  1307.   gluEndPolygon(tobj);
  1308.   glEndList();
  1309.   glNewList(edge, GL_COMPILE);
  1310.   glShadeModel(GL_FLAT);  /* flat shade keeps angular hands
  1311.                              from being * * "smoothed" */
  1312.   glBegin(GL_QUAD_STRIP);
  1313.   for (i = 0; i <= count; i++) {
  1314.     /* mod function handles closing the edge */
  1315.     glVertex3f(data[i % count][0], data[i % count][1], 0.0);
  1316.     glVertex3f(data[i % count][0], data[i % count][1], thickness);
  1317.     /* Calculate a unit normal by dividing by Euclidean
  1318.        distance. We * could be lazy and use
  1319.        glEnable(GL_NORMALIZE) so we could pass in * arbitrary
  1320.        normals for a very slight performance hit. */
  1321.     dx = data[(i + 1) % count][1] - data[i % count][1];
  1322.     dy = data[i % count][0] - data[(i + 1) % count][0];
  1323.     len = sqrt(dx * dx + dy * dy);
  1324.     glNormal3f(dx / len, dy / len, 0.0);
  1325.   }
  1326.   glEnd();
  1327.   glEndList();
  1328.   glNewList(whole, GL_COMPILE);
  1329.   glFrontFace(GL_CW);
  1330.   glCallList(edge);
  1331.   glNormal3f(0.0, 0.0, -1.0);  /* constant normal for side */
  1332.   glCallList(side);
  1333.   glPushMatrix();
  1334.   glTranslatef(0.0, 0.0, thickness);
  1335.   glFrontFace(GL_CCW);
  1336.   glNormal3f(0.0, 0.0, 1.0);  /* opposite normal for other side 
  1337.                                */
  1338.   glCallList(side);
  1339.   glPopMatrix();
  1340.   glEndList();
  1341. }
  1342.  
  1343. void
  1344. makeDinosaur(void)
  1345. {
  1346.   GLfloat bodyWidth = 3.0;
  1347.  
  1348.   extrudeSolidFromPolygon(body, sizeof(body), bodyWidth,
  1349.     BODY_SIDE, BODY_EDGE, BODY_WHOLE);
  1350.   extrudeSolidFromPolygon(arm, sizeof(arm), bodyWidth / 4,
  1351.     ARM_SIDE, ARM_EDGE, ARM_WHOLE);
  1352.   extrudeSolidFromPolygon(leg, sizeof(leg), bodyWidth / 2,
  1353.     LEG_SIDE, LEG_EDGE, LEG_WHOLE);
  1354.   extrudeSolidFromPolygon(eye, sizeof(eye), bodyWidth + 0.2,
  1355.                                                     EYE_SIDE, EYE_EDGE, EYE_WHOLE);
  1356.   glNewList(DINOSAUR, GL_COMPILE);
  1357.   glMaterialfv(GL_FRONT, GL_DIFFUSE, skinColor);
  1358.   glCallList(BODY_WHOLE);
  1359.   glPushMatrix();
  1360.   glTranslatef(0.0, 0.0, bodyWidth);
  1361.   glCallList(ARM_WHOLE);
  1362.   glCallList(LEG_WHOLE);
  1363.   glTranslatef(0.0, 0.0, -bodyWidth - bodyWidth / 4);
  1364.   glCallList(ARM_WHOLE);
  1365.   glTranslatef(0.0, 0.0, -bodyWidth / 4);
  1366.   glCallList(LEG_WHOLE);
  1367.   glTranslatef(0.0, 0.0, bodyWidth / 2 - 0.1);
  1368.   glMaterialfv(GL_FRONT, GL_DIFFUSE, eyeColor);
  1369.   glCallList(EYE_WHOLE);
  1370.   glPopMatrix();
  1371.     glMatrixMode(GL_MODELVIEW);
  1372.     glTranslatef(8, 8, bodyWidth/2 );
  1373.   glEndList();
  1374. }
  1375.  
  1376. void
  1377. redraw1(void)
  1378. {
  1379.          if (newModel)
  1380.                     recalcModelView();
  1381.          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  1382.          glCallList(DINOSAUR);
  1383.          // showMessage(2, 7.1, 4.1, "Habib.");
  1384.          glutSwapBuffers();
  1385. }
  1386.  
  1387. void
  1388. myReshape(int w, int h)
  1389. {
  1390.   glViewport(0, 0, w, h);
  1391.   W = w;
  1392.   H = h;
  1393. }
  1394.  
  1395. void
  1396. myReshape2(int w, int h)
  1397. {
  1398.   glViewport(0, 0, w, h);
  1399.   W2 = w;
  1400.   H2 = h;
  1401. }
  1402.  
  1403. void 
  1404. commande_de_bord(int x, int y) //fcommand_de_bord
  1405. {
  1406.          void animation_window2();
  1407.  
  1408.          // if... draw the transparent carre1.
  1409.          if (x>sb_c1->x_g_min  && x<sb_c1->x_g_max 
  1410.                  && y>sb_c1->y_g_min && y<sb_c1->y_g_max){
  1411.                     DRAW_CARRE1 = 1;
  1412.                     if (expand_carre1)
  1413.                              expand_carre1 = 0;
  1414.                     else
  1415.                              expand_carre1 = 1;
  1416.                     flag_motion_command = motion_carre1;
  1417.          }
  1418.  
  1419.          // if... DO NOT draw the transparent carre1.
  1420.          if (x>sb_c1->x_r_min && x<sb_c1->x_r_max 
  1421.                  && y>sb_c1->y_r_min && y<sb_c1->y_r_max) 
  1422.                     DRAW_CARRE1 = 0;
  1423.  
  1424.          // if... draw the transparent carre2.
  1425.          if (x>sb_c2->x_g_min  && x<sb_c2->x_g_max 
  1426.                  && y>sb_c2->y_g_min && y<sb_c2->y_g_max){
  1427.                     DRAW_CARRE2 = 1;
  1428.                     if (expand_carre2)
  1429.                              expand_carre2 = 0;
  1430.                     else
  1431.                              expand_carre2 = 1;
  1432.                     flag_motion_command = motion_carre2;
  1433.          }
  1434.          
  1435.          // if... DO NOT draw the transparent carre2.  
  1436.          if (x>sb_c2->x_r_min && x<sb_c2->x_r_max && 
  1437.                  y>sb_c2->y_r_min && y<sb_c2->y_r_max) 
  1438.                     DRAW_CARRE2     = 0;
  1439.  
  1440.          // if... draw the transparent carre3.
  1441.          if (x>sb_c3->x_g_min  && x<sb_c3->x_g_max 
  1442.                  && y>sb_c3->y_g_min && y<sb_c3->y_g_max){
  1443.                     DRAW_CARRE3 = 1;
  1444.                     if (expand_carre3)
  1445.                              expand_carre3 = 0;
  1446.                     else
  1447.                              expand_carre3 = 1;
  1448.                     flag_motion_command = motion_carre3;
  1449.          }
  1450.  
  1451.          // if... DO NOT draw the transparent carre3.
  1452.          if (x>sb_c3->x_r_min && x<sb_c3->x_r_max 
  1453.                  && y>sb_c3->y_r_min && y<sb_c3->y_r_max) 
  1454.                     DRAW_CARRE3 = 0;
  1455.  
  1456.          // if... Baseline_zoom = stereo_zoom
  1457.          if (x > stereo_zoom_rect->xmin && x < stereo_zoom_rect->xmax && 
  1458.                  y > stereo_zoom_rect->ymin && y < stereo_zoom_rect->ymax )
  1459.                     flag_motion_command = baseline_zoom;
  1460.  
  1461.  
  1462.          // if... scaling = 3D Zoom
  1463.          if (x > scaling_rect->xmin && x < scaling_rect->xmax && 
  1464.                  y > scaling_rect->ymin && y < scaling_rect->ymax )
  1465.                     flag_motion_command = scaling;
  1466.  
  1467.          // if... Animation
  1468.          if (x > animation_rect->xmin && x < animation_rect->xmax && 
  1469.                  y > animation_rect->ymin && y < animation_rect->ymax )
  1470.                     animation_window2();
  1471.          
  1472.          // if... vertical_adj
  1473.          if (x > vertical_adj_rect->xmin && x < vertical_adj_rect->xmax && 
  1474.                  y > vertical_adj_rect->ymin && y < vertical_adj_rect->ymax )
  1475.                     flag_motion_command = vertical_adj;
  1476.  
  1477.          redraw();
  1478. }
  1479.  
  1480. void  
  1481.  
  1482. mouse(int button, int state, int x, int y) //fmouse
  1483. {
  1484.          // if button down
  1485.          if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN ) {
  1486.                     // if commande board exist and mouse in it
  1487.                     if (viewport && x<100) {
  1488.                              commande_de_bord(x,y);
  1489.                     }
  1490.                     // if y>100 or viewport do not exist
  1491.                     else{
  1492.                              beginx = x;
  1493.                              beginy = y;
  1494.                              APPLY_MOUSE_MOTION = 1;
  1495.                              flag_motion = flag_motion_command;
  1496.                     }
  1497.          }
  1498.          else {
  1499.             // Translation / Rotation
  1500.             if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  1501.                 APPLY_MOUSE_MOTION = 1;
  1502.                 flag_motion = rotating;
  1503.                 beginx = x;
  1504.                 beginy = y;        
  1505.                 if(glutGetModifiers() & GLUT_ACTIVE_SHIFT) {
  1506.                          flag_motion = translating;
  1507.                 }
  1508.             }     
  1509.          }
  1510.          // if button up
  1511.          if (state == GLUT_UP) {
  1512.                     APPLY_MOUSE_MOTION =0;
  1513.          }
  1514.          
  1515.          /*                     translating = rotating =scaling = baseline_zoom = 0;
  1516.                                     DRAW_CARRE1 = DRAW_CARRE2 = DRAW_CARRE3 = 0; */         
  1517.          
  1518. }
  1519.  
  1520. void
  1521. mouse2(int button, int state, int x, int y) //fmouse
  1522. {
  1523.          float thresh2;
  1524.          void draw_elevator();
  1525.  
  1526.          // if left button down highlight some points
  1527.          if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
  1528.                     thresh= (var_animation_min - var_animation_max) * (H2-y) / H2 + var_animation_max;
  1529.                     Y = y;
  1530.                     draw_elevator();
  1531.  
  1532.                     glutSetWindow(win);
  1533.                     // highlightint points in the band
  1534.                     if (flag_elevator == bandflag){
  1535.                              // Recompiling the list.
  1536.                              glNewList(28, GL_COMPILE_AND_EXECUTE);
  1537.                              thresh2 = thresh + band;
  1538.                              glPointSize(pt_size);
  1539.                              glBegin(GL_POINTS);
  1540.                              for (i=0; i<dim[0]; i=i+fraction){
  1541.                                         if (var_animation[i] < thresh && var_animation[i] > thresh2 ) {
  1542.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1543.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1544.                                         }
  1545.                              }
  1546.                              glEnd();
  1547.                              glPointSize(pt_size+2);
  1548.                              glBegin(GL_POINTS);
  1549.                              for (i=0; i<dim[0]; i=i+fraction){
  1550.                                         if (var_animation[i] >= thresh && var_animation[i] <= thresh2 ) {
  1551.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1552.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1553.                                         }
  1554.                              }
  1555.                              glEnd();
  1556.                     }
  1557.                     else {
  1558.                              // Highlighting point in the upper or lower part of the elevator.
  1559.                              glNewList(28, GL_COMPILE_AND_EXECUTE);
  1560.                              if (flag_elevator == up)
  1561.                                         glPointSize (pt_size);
  1562.                              else if (flag_elevator == down)
  1563.                                         glPointSize (pt_size+2);
  1564.                              glBegin(GL_POINTS);
  1565.                              for (i=0; i<dim[0]; i=i+fraction){
  1566.                                         if (var_animation[i] <= thresh ) {
  1567.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1568.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1569.                                         }
  1570.                              }
  1571.                              glEnd();
  1572.                     
  1573.                              if (flag_elevator == up)
  1574.                                         glPointSize (pt_size+2);
  1575.                              else if (flag_elevator == down)
  1576.                                         glPointSize (pt_size);
  1577.                              glBegin(GL_POINTS);
  1578.                              for (i=0; i<dim[0]; i=i+fraction){
  1579.                                         if (var_animation[i] > thresh ) {
  1580.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1581.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1582.                                         }
  1583.                              }
  1584.                              glEnd();
  1585.                              
  1586.                              glEndList();
  1587.                              displayListInited = 1;
  1588.                     }
  1589.                     redraw();
  1590.          }
  1591.          
  1592.          // if middle button down
  1593.          if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) {
  1594.                     if (x > up_rect->xmin && x < up_rect->xmax && 
  1595.                             y > up_rect->ymin && y < up_rect->ymax )
  1596.                              flag_elevator = up;
  1597.  
  1598.                     if (x > down_rect->xmin && x < down_rect->xmax && 
  1599.                             y > down_rect->ymin && y < down_rect->ymax )
  1600.                              flag_elevator = down;
  1601.  
  1602.                     if (x > band_rect->xmin && x < band_rect->xmax && 
  1603.                             y > band_rect->ymin && y < band_rect->ymax )
  1604.                              flag_elevator = bandflag;
  1605.          }
  1606.  
  1607.  
  1608. }
  1609.  
  1610. void
  1611. animate(void)
  1612. {
  1613.          glutPostRedisplay();
  1614. }
  1615.  
  1616. void
  1617. passive_motion(int x, int y) //fpassive_motion
  1618. {
  1619.          X = x;
  1620.          Y = y;
  1621.          if ((x>200) && FLAG_X_SMALLER_THAN_100) {
  1622.                     FLAG_X_SMALLER_THAN_100 = 0;
  1623.                     glutSetMenu(Menu1_id);
  1624.                     glutAttachMenu(GLUT_RIGHT_BUTTON);
  1625.          }
  1626.          else {
  1627.                     if ((x<100) && !FLAG_X_SMALLER_THAN_100) {
  1628.                              FLAG_X_SMALLER_THAN_100 =1;
  1629.                              glutSetMenu(Menu2_id);
  1630.                              glutAttachMenu(GLUT_RIGHT_BUTTON);
  1631.                     }
  1632.          }
  1633. }
  1634.  
  1635. void
  1636. motion2(int x, int y) //f02
  1637. {
  1638.          float thresh; // threshhold
  1639.          float thresh2;
  1640.          void draw_elevator();
  1641.  
  1642.          Y = y;
  1643.          draw_elevator();
  1644.          // highlight some pts.
  1645.          if (1){
  1646.                     thresh= (var_animation_min - var_animation_max) * (H2-y) / H2 + var_animation_max;
  1647.                     glutSetWindow(win);
  1648.                     
  1649.                     // highlightint points in the band
  1650.                     if (flag_elevator == bandflag){
  1651.                              // Recompiling the list.
  1652.                              glNewList(28, GL_COMPILE_AND_EXECUTE);
  1653.                              thresh2 = thresh + band;
  1654.                              glPointSize(pt_size);
  1655.                              glBegin(GL_POINTS);
  1656.                              for (i=0; i<dim[0]; i=i+fraction){
  1657.                                         if (var_animation[i] < thresh && var_animation[i] > thresh2 ) {
  1658.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1659.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1660.                                         }
  1661.                              }
  1662.                              glEnd();
  1663.                              glPointSize(pt_size+2);
  1664.                              glBegin(GL_POINTS);
  1665.                              for (i=0; i<dim[0]; i=i+fraction){
  1666.                                         if (var_animation[i] >= thresh && var_animation[i] <= thresh2 ) {
  1667.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1668.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1669.                                         }
  1670.                              }
  1671.                              glEnd();
  1672.                     }
  1673.                     else {
  1674.                              // Highlighting point in the upper or lower part of the elevator.
  1675.                              glNewList(28, GL_COMPILE_AND_EXECUTE);
  1676.                              if (flag_elevator == up)
  1677.                                         glPointSize (pt_size);
  1678.                              else if (flag_elevator == down)
  1679.                                         glPointSize  (pt_size+2);
  1680.                              glBegin(GL_POINTS);
  1681.                              for (i=0; i<dim[0]; i=i+fraction){
  1682.                                         if (var_animation[i] <= thresh ) {
  1683.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1684.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1685.                                         }
  1686.                              }
  1687.                              glEnd();
  1688.                     
  1689.                              if (flag_elevator == up)
  1690.                                         glPointSize (pt_size+2);
  1691.                              else if (flag_elevator == down)
  1692.                                         glPointSize  (pt_size);
  1693.                              glBegin(GL_POINTS);
  1694.                              for (i=0; i<dim[0]; i=i+fraction){
  1695.                                         if (var_animation[i] > thresh ) {
  1696.                                                  glColor3f (cxx[i], cyy[i], czz[i]);
  1697.                                                  glVertex3f(xc[i],yc[i],zc[i]);
  1698.                                         }
  1699.                              }
  1700.                              glEnd();
  1701.                              
  1702.                              glEndList();
  1703.                              displayListInited = 1;
  1704.                     }
  1705.                     redraw();
  1706.          }
  1707.          
  1708. }
  1709.  
  1710. void
  1711. motion(int x, int y) //fmotion
  1712. // Handles the motion of the mouse in the big black window.
  1713. {
  1714.          if (APPLY_MOUSE_MOTION) {
  1715.                     double step1, step2;
  1716.                     int stepo,steppss,stepppi;
  1717.                     switch (flag_motion) {
  1718.                              
  1719.                     case motion_carre1:
  1720.                              stepo = (y-beginy);
  1721.                              carre1 = carre1 + stepo*(deltaz/1000); 
  1722.                              beginy = y;
  1723.                              break;
  1724.  
  1725.                     case motion_carre2:
  1726.                              steppss = (y-beginy);
  1727.                              carre2 = carre2 + steppss*(deltay/1000); 
  1728.                              beginy = y;
  1729.                              break;
  1730.  
  1731.                     case motion_carre3:
  1732.                              stepppi = (y-beginy);
  1733.                              carre3 = carre3 + stepppi*(deltax/1000); 
  1734.                              beginy = y;
  1735.                              break;
  1736.  
  1737.                     case scaling:
  1738.                              if (beginy!=y) {
  1739.                                         // scalefactor = scalefactor * (1.0 + (((float) (beginy - y)) / H));
  1740.                                         int sgnn = (y-beginy); 
  1741.                                         step1 = (LEFT-RIGHT)/200.0;
  1742.                                         step2 = (BOTTOM-TOP)/200.0;
  1743.                                         LEFT   = LEFT  + sgnn*step1;
  1744.                                         RIGHT  = RIGHT - sgnn*step1;
  1745.                                         BOTTOM = BOTTOM+ sgnn*step2;
  1746.                                         TOP    = TOP   - sgnn*step2;
  1747.                                         beginy = y;
  1748.                                         newModel = 1;
  1749.                                         //glutPostRedisplay();
  1750.                              }
  1751.                              break;
  1752.                              
  1753.                     case baseline_zoom:
  1754.                              if (beginy!=y) {
  1755.                                         int sgnn = (beginy-y); //abs((beginx-x));
  1756.                                         baseline = baseline + sgnn*0.001;
  1757.                                         beginy = y;
  1758.                                         //glutPostRedisplay();
  1759.                              }
  1760.                              break;
  1761.                     case vertical_adj:
  1762.                             vav = vav + (beginy - y); // vav = vertical adjustment value.
  1763.                             beginy=y;
  1764.                             break;
  1765.                              
  1766.                     case translating:
  1767.                              int sgnx,sgny;
  1768.                              sgnx = sgny =0;
  1769.                              if (beginx != x) sgnx = (beginx-x); //abs(beginx-x);
  1770.                              if (beginy != y) sgny = (beginy-y); //abs(beginy-y);
  1771.                              step1 = (LEFT-RIGHT)/800.0;
  1772.                              step2 = (BOTTOM-TOP)/700.0;
  1773.                              LEFT   = LEFT  - sgnx*step1;
  1774.                              RIGHT  = RIGHT - sgnx*step1;
  1775.                              BOTTOM = BOTTOM+ sgny*step2;
  1776.                              TOP    = TOP   + sgny*step2;
  1777.                              beginx = x;
  1778.                              beginy = y;
  1779.                              newModel = 1;
  1780.                              //glutPostRedisplay();
  1781.                              break;
  1782.                              
  1783.                     case rotating:
  1784.                              double deux = 2.0;
  1785.                              trackball(lastquat,
  1786.                                                  (deux*beginx - W) / W,
  1787.                                                  (H - deux*beginy) / H,
  1788.                                                  (deux*x - W) / W,
  1789.                                                  (H - deux*y) / H
  1790.                                                  );
  1791.                              beginx = x;
  1792.                              beginy = y;
  1793.                              spinning = 0;
  1794.                              add_quats(lastquat, curquat, curquat);
  1795.                              newModel = 1;
  1796.                              //glutPostRedisplay();
  1797.                              break;
  1798.                     }
  1799.                     redraw();
  1800.          }
  1801.  
  1802. }
  1803. GLboolean lightZeroSwitch = GL_TRUE, lightOneSwitch = GL_TRUE;
  1804. void
  1805. DropMenu2(int value)
  1806. {
  1807.          int i;
  1808.          FLAG FLAG_DRAW = 0;
  1809.          // Choosing the appropriate axe to load our data too.
  1810.          if (Y>0 && Y<=10) {
  1811.                     xc = var[value-2];
  1812.                     strcpy (string3,"");
  1813.                     strcat (string3,"X: ");
  1814.                     strcat (string3,var_name[value-2]);
  1815.                     FLAG_DRAW =1;
  1816.          }
  1817.          
  1818.          if (Y>10 && Y<20) {
  1819.                     yc = var[value-2];
  1820.                     strcpy (string2,"");
  1821.                     strcat (string2,"Y: ");
  1822.                     strcat (string2,var_name[value-2]);
  1823.                     FLAG_DRAW =1;
  1824.          }
  1825.          
  1826.          if (Y>20 && Y<30) {
  1827.                     zc = var[value-2];
  1828.                     strcpy (string1,"");
  1829.                     strcat (string1,"Z: ");
  1830.                     strcat (string1,var_name[value-2]);
  1831.                     FLAG_DRAW =1;
  1832.          }
  1833.  
  1834.          // Animation Variable.... Maximizing a part of the points...
  1835.          if (Y>160 && Y<173){
  1836.              if (value >= 2) {
  1837.                     // setting the var_animation value
  1838.                     var_animation = var[value-2];
  1839.                     // Setting the max & min
  1840.                     var_animation_min= var_animation[0];
  1841.                     var_animation_max= var_animation[0];
  1842.                     for (i=0; i<dim[0]; i++)
  1843.                     {
  1844.                              if (var_animation[i]<var_animation_min )  var_animation_min = var_animation[i];
  1845.                              if (var_animation[i]>var_animation_max )  var_animation_max = var_animation[i];
  1846.                     }
  1847.              }
  1848.              else {
  1849.                  pt_size = 1;
  1850.                  displayListInited = 0;
  1851.                  redraw();
  1852.              }
  1853.  
  1854.          }
  1855.  
  1856.          // if you are in the color zone... you want to choose a color linked to a variable.
  1857.          if (Y>190 && Y<205) {
  1858.              if (value >=2) {
  1859.                 float *tmp,delta;
  1860.                 float min;
  1861.                 float max;
  1862.                 tmp = var [value - 2];
  1863.                 // setting max & min.
  1864.                 min = max = tmp[0]; // initializing.
  1865.                 for (i=0; i<dim[0]; i++){
  1866.                      if (tmp[i]<min )  min = tmp[i];
  1867.                      if (tmp[i]>max )  max = tmp[i];
  1868.                 }
  1869.                 delta = (max - min)/14.0;
  1870.                 // coloring the points
  1871.                 int index;
  1872.                 for (i=0; i<dim[0]; i++) {
  1873.                      index = (tmp[i] - min) / delta ; // possible value for index 0...14
  1874.                      cxx[i] = lUPt[index][0];
  1875.                      cyy[i] = lUPt[index][1];
  1876.                      czz[i] = lUPt[index][2];
  1877.                  }
  1878.               displayListInited = 0;
  1879.               redraw();
  1880.              }
  1881.              else {
  1882.                  for (i = 0; i<dim[0]; i++) {
  1883.                      cxx[i] = 1;
  1884.                      cyy[i] = 1;
  1885.                      czz[i] = 1;
  1886.                  }
  1887.                  displayListInited = 0;
  1888.                  redraw();
  1889.              }
  1890.          }
  1891.  
  1892.  
  1893.          // Determin the pt_size...
  1894.          if (Y> 206 && Y<221) {
  1895.              pt_size = value;
  1896.              displayListInited = 0;
  1897.              redraw();
  1898.          }
  1899.  
  1900.  
  1901.          if (FLAG_DRAW){
  1902.                     trouver_bar_min_max_sig (xc,yc,zc,dim);
  1903.                     // Set TOP RIGHT
  1904.                     /* if (fabs(xmax) > fabs (xmin)) RIGHT = 2*fabs(xmax);
  1905.                     else RIGHT = 2*fabs (xmin);
  1906.                     
  1907.                     if (fabs(ymax) > fabs (ymin)) TOP = 2*fabs(ymax);
  1908.                     else TOP = 2*fabs (ymin);
  1909.                     
  1910.                     // Scaling so that it is in the same ratio as the pixel ratio : 5/4
  1911.                     if (TOP > RIGHT) RIGHT = 5*TOP/4;
  1912.                     else  TOP = 4*RIGHT/5;
  1913.  
  1914.                     BOTTOM = - TOP;
  1915.                     LEFT   = - RIGHT; */
  1916.                     
  1917.                     displayListInited = 0;
  1918.                     redraw();
  1919.          }
  1920. }
  1921. void
  1922. DropMenu1(int value)
  1923. {
  1924.          switch (value) {
  1925.          case 1:
  1926.                     glEnable(GL_LIGHTING); 
  1927.                     dinosor = 1;
  1928.                     break;
  1929.          case 2:
  1930.                     glDisable(GL_LIGHTING); 
  1931.                     dinosor = 0;
  1932.                     break;
  1933.          case 3:
  1934. /* workaround hack */
  1935. #if 0
  1936.                     if(glIsEnabled(GL_MULTISAMPLE_SGIS)) {
  1937.                              glDisable(GL_MULTISAMPLE_SGIS);
  1938.                     } else {
  1939.                              glEnable(GL_MULTISAMPLE_SGIS);
  1940.                     }
  1941. #endif
  1942.                     break;
  1943.          case 4:
  1944.                     glutFullScreen();
  1945.                     break;
  1946.          case 5:
  1947.                     cout << "Baseline = " << baseline << endl  ;
  1948.                     cout << "Give new Baseline : " ;
  1949.                     cin >> baseline;
  1950.                     break;
  1951.          case 6:
  1952.                     displayListInited=0;
  1953.                     for (i=0; i<dim[0]; i++){
  1954.                              cxx[i]=1.0;
  1955.                              cyy[i]=1.0;
  1956.                              czz[i]=1.0;
  1957.                     }
  1958.                     break;
  1959.          case 7:
  1960.                     displayListInited=0;
  1961.                     for (i=0; i<dim[0]; i++){
  1962.                              switch (col1[i]){
  1963.                              case 1:
  1964.                                         cxx[i]=0.0; cyy[i]=1.0; czz[i]=1.0;
  1965.                                         break;
  1966.                              case 2:
  1967.                                         cxx[i]=1.0; cyy[i]=0.0; czz[i]=1.0;
  1968.                                         break;
  1969.                              case 3:
  1970.                                         cxx[i]=1.0; cyy[i]=1.0; czz[i]=0.0;
  1971.                                         break;
  1972.                              case 4:
  1973.                                         cxx[i]=1.0; cyy[i]=0.0; czz[i]=0.0;
  1974.                                         break;
  1975.                              case 5:
  1976.                                         cxx[i]=0.0; cyy[i]=1.0; czz[i]=0.0;
  1977.                                         break;
  1978.                              case 6:
  1979.                                         cxx[i]=0.0; cyy[i]=0.0; czz[i]=1.0;
  1980.                                         break;
  1981.                              case 7:
  1982.                                         cxx[i]=1.0; cyy[i]=0.5; czz[i]=0.25;
  1983.                                         break;
  1984.                              case 8:
  1985.                                         cxx[i]=1.0; cyy[i]=1.0; czz[i]=1.0;
  1986.                                         break;
  1987.                              }
  1988.                     }
  1989.                     break;
  1990.          case 8:
  1991.                     displayListInited=0;
  1992.                     for (i=0; i<dim[0]; i++){
  1993.                              switch (col4[i]){ 
  1994.                              case 1:
  1995.                                         cxx[i]=1.0; cyy[i]=0.5; czz[i]=0.25;
  1996.                                         break;
  1997.                              case -1:
  1998.                                         cxx[i]=0.25; cyy[i]=0.9; czz[i]=0.75;
  1999.                                         break;
  2000.                              }
  2001.                     }
  2002.                     break;
  2003.          case 9:
  2004.                     TRANSLATE_TO_GRAVITY = 0; 
  2005.                     TRANSLATE_TO_MIDDLE  = 0;
  2006.                     break;
  2007.          case 10:
  2008.                     TRANSLATE_TO_GRAVITY = 1; 
  2009.                     TRANSLATE_TO_MIDDLE  = 0;
  2010.                     break;
  2011.          case 11:
  2012.                     TRANSLATE_TO_GRAVITY = 0; 
  2013.                     TRANSLATE_TO_MIDDLE  = 1;
  2014.                     break;
  2015.          case 12: // normal scaling (1,1,1)
  2016.                     SCALE_SIGMA   = 0 ;
  2017.                     SCALE_MIDDLE  = 0 ;
  2018.                     break;
  2019.          case 13: // sigma scaling
  2020.                     SCALE_SIGMA   = 1 ;
  2021.                     SCALE_MIDDLE  = 0 ;
  2022.                     break;
  2023.          case 14: // middle scaling 
  2024.                     SCALE_SIGMA   = 0 ;
  2025.                     SCALE_MIDDLE  = 1 ;
  2026.                     break;
  2027.          case 15:
  2028.                     cout << "Give the pixel size : " << endl;
  2029.                     cin >> pt_size;
  2030.                     displayListInited = 0;
  2031.                     break;
  2032.          case 16:
  2033.                     cout << "What fraction of the points would you like to display ?" ;
  2034.                     cin >> fraction;
  2035.                     displayListInited = 0;
  2036.                     break;
  2037.          case 17:
  2038.                     if (TOGGLE_BOX == 1 ) TOGGLE_BOX = 0;
  2039.                     else TOGGLE_BOX = 1;
  2040.                     redraw();
  2041.                     break;
  2042.          case 18:
  2043.                     baseline = -baseline;
  2044.                     redraw();
  2045.                     break;
  2046.          case 19:
  2047.                     fog();
  2048.                     redraw();
  2049.                     break;
  2050.          case 20:
  2051.                     glDisable(GL_FOG);
  2052.                     redraw();
  2053.                     break;
  2054.          case 21:
  2055.                     if (viewport == 0)
  2056.                              viewport = 1; 
  2057.                     else{
  2058.                              viewport = 0;
  2059.                     }
  2060.                     redraw();
  2061.                     break;
  2062.          case 22:
  2063.                     if (Draw_relative_axe == 0)
  2064.                              Draw_relative_axe = 1; 
  2065.                     else{
  2066.                              Draw_relative_axe = 0;
  2067.                     }
  2068.                     redraw();
  2069.                     break;
  2070.          case 99:
  2071.                     exit(0);
  2072.                     break;
  2073.          }
  2074.          glutPostRedisplay();
  2075. }
  2076.  
  2077. void
  2078. vis(int visible)
  2079. {
  2080.          
  2081.          if (visible == GLUT_VISIBLE) {
  2082.                     
  2083.                     if (spinning) 
  2084.                              glutIdleFunc(animate);
  2085.          } 
  2086.          else {
  2087.                     if (spinning)
  2088.                              glutIdleFunc(NULL);
  2089.          }
  2090. }
  2091. static void 
  2092. Key(unsigned char key, int x, int y)
  2093. {
  2094.          switch (key) {
  2095.          case 'd':
  2096.                     fogDensity *= 1.10;
  2097.                     glFogf(GL_FOG_DENSITY, fogDensity);
  2098.                     glutPostRedisplay();
  2099.                     break;
  2100.          case 'D':
  2101.                     fogDensity /= 1.10;
  2102.                     glFogf(GL_FOG_DENSITY, fogDensity);
  2103.                     glutPostRedisplay();
  2104.                     break;
  2105.          case 'b':
  2106.                     if (flag_motion == motion_carre1); 
  2107.                              carre1_trans = carre1_trans +0.05;
  2108.                     if (flag_motion == motion_carre2); 
  2109.                              carre2_trans = carre2_trans +0.05;
  2110.                     if (flag_motion == motion_carre3); 
  2111.                              carre3_trans = carre3_trans +0.05;
  2112.                     glutPostRedisplay();
  2113.                     break;
  2114.          case 'c':
  2115.                     if (flag_motion == motion_carre1); 
  2116.                              carre1_trans = carre1_trans -0.05;
  2117.                     if (flag_motion == motion_carre2); 
  2118.                              carre2_trans = carre2_trans -0.05;
  2119.                     if (flag_motion == motion_carre3); 
  2120.                              carre3_trans = carre3_trans -0.05;
  2121.                     glutPostRedisplay();
  2122.                     break;
  2123.  
  2124.                     
  2125.          case 27:
  2126.                     exit(0);
  2127.          }
  2128. }
  2129.  
  2130. static void 
  2131. SpecialKey(int key, int x, int y)
  2132. {
  2133.          switch (key) {
  2134.          case GLUT_KEY_UP:
  2135.                     DRAW_CARRE1 = 1;
  2136.                     carre1 = carre1 + (deltaz/100);
  2137.                     glutPostRedisplay();
  2138.                     break;
  2139.          case GLUT_KEY_DOWN:
  2140.                     DRAW_CARRE1 = 1;
  2141.                     carre1 = carre1 - (deltaz/100);
  2142.                     glutPostRedisplay();
  2143.                     break;
  2144.          case GLUT_KEY_LEFT:
  2145.                     carre1_trans = carre1_trans-0.03;
  2146.                     glutPostRedisplay();
  2147.                     break;
  2148.          case GLUT_KEY_RIGHT:
  2149.                     carre1_trans = carre1_trans+0.03;
  2150.                     glutPostRedisplay();
  2151.                     break;
  2152.          case GLUT_KEY_INSERT: // Expand carre.
  2153.                     if (expand_carre1) 
  2154.                              expand_carre1 = 0;
  2155.                     else
  2156.                              expand_carre1 = 1;
  2157.                     glutPostRedisplay();
  2158.                     break;
  2159.          }
  2160. }
  2161. void
  2162. create_menus()
  2163. {
  2164.  
  2165.          glutCreateMenu(DropMenu1);
  2166.          Menu1_id = glutGetMenu();
  2167.          glutAddMenuEntry("Show Dinosor"                       , 1);
  2168.          glutAddMenuEntry("Show Pts",                            2);
  2169.          glutAddMenuEntry("Full screen"                        , 4);
  2170.          glutAddMenuEntry("Set baseline"                       , 5);
  2171.          glutAddMenuEntry("Remove color "                      , 6);
  2172.          glutAddMenuEntry("Put color col1"                     , 7);
  2173.          glutAddMenuEntry("Put color col4"                     , 8);
  2174.          glutAddMenuEntry("Origine at 0"                       , 9);
  2175.          glutAddMenuEntry("Origine at mean"                    , 10);
  2176.          glutAddMenuEntry("Origine at mid-range"               , 11);
  2177.          glutAddMenuEntry("Scaling unity"                     , 12);
  2178.          glutAddMenuEntry("Scaling sigma"                     , 13);
  2179.          glutAddMenuEntry("Scaling range"                     , 14);
  2180.          glutAddMenuEntry("Size_pt = "                        , 15);
  2181.          glutAddMenuEntry("Number_points = "                  , 16);
  2182.          glutAddMenuEntry("Toggle box"                        , 17);
  2183.          glutAddMenuEntry("Toggle cameras left-right"         , 18);
  2184.          glutAddMenuEntry("Add some Fog..."                   , 19);
  2185.          glutAddMenuEntry("Remove the Fog..."                 , 20);
  2186.          glutAddMenuEntry("Toggle viewport"                   , 21);
  2187.          glutAddMenuEntry("Toggle axes "                      , 22);
  2188.          if(glutGet(GLUT_WINDOW_NUM_SAMPLES) > 0) {
  2189.                     glutAddMenuEntry("Toggle multisampling", 3);
  2190.                     glutSetWindowTitle("dinospin (multisample capable)");
  2191.          }
  2192.          glutAddMenuEntry("Quit", 99);
  2193.  
  2194.          glutCreateMenu(DropMenu2);
  2195.          Menu2_id = glutGetMenu();
  2196.          int i;
  2197.          glutAddMenuEntry ("None",1);
  2198.          for (i=0;i<nbr_of_col; i++){
  2199.                     glutAddMenuEntry(var_name[i],i+2);
  2200.          }
  2201. }
  2202.  
  2203. void
  2204. draw_elevator() //fdraw_elevator
  2205. /* draws the background of the window2 the elevator window. */
  2206. {
  2207.          int len;
  2208.          char string1[] = "Up";
  2209.          char string2[] = "Do";
  2210.          char string3[] = "Ba";
  2211.          char string4[] = "9.11";
  2212.  
  2213.  
  2214.          glDrawBuffer(GL_BACK);
  2215.          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  2216.  
  2217.          // Set Projection Matrix
  2218.          glMatrixMode(GL_PROJECTION);/* set up projection transform */
  2219.      glLoadIdentity();
  2220.      glOrtho (0,W2, H2,0 ,-1 ,1);
  2221.  
  2222.          // Set ModelView Matrix.
  2223.          glMatrixMode (GL_MODELVIEW);
  2224.          glLoadIdentity();
  2225.  
  2226.          // Drawing the up box.
  2227.          up_rect->xmin = 0 ;
  2228.          up_rect->xmax = 20;
  2229.          up_rect->ymin = 0 ;
  2230.          up_rect->ymax = 10 ;
  2231.          glBegin (GL_POLYGON);
  2232.          glColor3f (0.9,0.8,0.7);
  2233.          glVertex2i (up_rect->xmin,up_rect->ymin);
  2234.          glVertex2i (up_rect->xmin,up_rect->ymax);
  2235.          glVertex2i (up_rect->xmax,up_rect->ymax);
  2236.          glVertex2i (up_rect->xmax,up_rect->ymin);
  2237.          glEnd();
  2238.          glColor3f (0.15,0.15,1.0);
  2239.          glRasterPos2i(up_rect->xmin, up_rect->ymax);
  2240.          len = (int) strlen(string1);
  2241.          for (i = 0; i < len; i++) 
  2242.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string1[i]);
  2243.  
  2244.          // Drawing the down box.
  2245.          down_rect->xmin = 30 ;
  2246.          down_rect->xmax = 50;
  2247.          down_rect->ymin = 0 ;
  2248.          down_rect->ymax = 10 ;
  2249.          glBegin (GL_POLYGON);
  2250.          glColor3f (0.7,0.9,0.8);
  2251.          glVertex2i (down_rect->xmin,down_rect->ymin);
  2252.          glVertex2i (down_rect->xmin,down_rect->ymax);
  2253.          glVertex2i (down_rect->xmax,down_rect->ymax);
  2254.          glVertex2i (down_rect->xmax,down_rect->ymin);
  2255.          glEnd();
  2256.          glColor3f (0.2,0.15,0.1);
  2257.          glRasterPos2i(down_rect->xmin, down_rect->ymax);
  2258.          len = (int) strlen(string2);
  2259.          for (i = 0; i < len; i++) 
  2260.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string2[i]);
  2261.  
  2262.          // Drawing the Band box.
  2263.          band_rect->xmin = 60 ;
  2264.          band_rect->xmax = 80;
  2265.          band_rect->ymin = 0 ;
  2266.          band_rect->ymax = 10 ;
  2267.          glBegin (GL_POLYGON);
  2268.          glColor3f (0.76,0.9,0.6);
  2269.          glVertex2i (band_rect->xmin,band_rect->ymin);
  2270.          glVertex2i (band_rect->xmin,band_rect->ymax);
  2271.          glVertex2i (band_rect->xmax,band_rect->ymax);
  2272.          glVertex2i (band_rect->xmax,band_rect->ymin);
  2273.          glEnd();
  2274.          glColor3f (0.15,0.15,0.3);
  2275.          glRasterPos2i(band_rect->xmin, band_rect->ymax);
  2276.          len = (int) strlen(string3);
  2277.          for (i = 0; i < len; i++) 
  2278.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string3[i]);
  2279.  
  2280.          // Draw the line indicating where you are in the window.
  2281.          glBegin (GL_LINES);
  2282.          glColor3f (0.15,1.0,0.3);
  2283.          glVertex2i (0,Y);
  2284.          glVertex2i (90,Y);
  2285.          glEnd();
  2286.          glColor3f (1,1,1);
  2287.          glRasterPos2i(3,Y);
  2288.          len = (int) strlen(string4);
  2289.          for (i = 0; i < len; i++) 
  2290.                     glutBitmapCharacter(GLUT_BITMAP_8_BY_13, string4[i]);        
  2291.          
  2292.  
  2293.          glutSwapBuffers();
  2294.  
  2295. }
  2296.  
  2297. void
  2298. animation_window2() //fanimation_window
  2299. {
  2300.          cout << "Animation window activated" << endl;
  2301.          // glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE | GLUT_STEREO); 
  2302.          // glutCreateSubWindow (win, 0,0,100,H);
  2303.          glutCreateWindow("a second window");
  2304.          glutPositionWindow(0,175);
  2305.          glutReshapeWindow (90,350);
  2306.          glutDisplayFunc(draw_elevator);
  2307.          //gfxinit();
  2308.          glutReshapeFunc(myReshape2);
  2309.          glutMouseFunc(mouse2);
  2310.          glutMotionFunc(motion2);
  2311.          // glutPassiveMotionFunc(passive_motion);
  2312.          // create_menus();
  2313.  
  2314. }
  2315.  
  2316.  
  2317.  
  2318. int
  2319. main(int argc, char **argv)
  2320. {
  2321.          GLenum type;
  2322.          load_data_NZP ();
  2323.          flag_motion = rotating;
  2324.          glutInit(&argc, argv);
  2325.          // glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE | GLUT_STEREO); 
  2326.          glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE ); 
  2327.          trackball(curquat, 0.0, 0.0, 0.0, 0.0);
  2328.          win = glutCreateWindow("Ford's Demo");
  2329.          glutDisplayFunc(redraw);
  2330.          glutReshapeFunc(myReshape);
  2331.          glutVisibilityFunc(vis);
  2332.          glutMouseFunc(mouse);
  2333.          glutMotionFunc(motion);
  2334.          glutPassiveMotionFunc(passive_motion);           
  2335.          cout << "hihi... " << NaN << endl;
  2336.  
  2337.          create_menus();
  2338.          makeDinosaur();
  2339.          glEnable(GL_CULL_FACE);
  2340.          glEnable(GL_DEPTH_TEST);
  2341.          // glEnable(GL_LIGHTING);
  2342.          glMatrixMode(GL_PROJECTION);
  2343.          //gluPerspective( /* field of view in degree */ 40.0,  /* aspect blen
  2344.          //                                ratio 
  2345.          //                                */ 1.0,
  2346.          //    /* Z near */ 1.0, /* Z far */ 40.0);
  2347.  
  2348.          NEAR2 =   -10000;
  2349.          FAR2 =     10000;
  2350.          glMatrixMode(GL_MODELVIEW);
  2351.          transX = 0;
  2352.          transY = 0;
  2353.          transZ = 0;
  2354.          eyex = -baseline;
  2355.          eyey = 0;
  2356.          eyez =  30;
  2357.          upy = 1;
  2358.          upz = 0;
  2359.  
  2360.          glPushMatrix();       /* dummy push so we can pop on model
  2361.                                                             recalc */
  2362.          GLfloat lightZeroPosition[] = {10.0, 4.0, 10.0, 1.0};
  2363.          GLfloat lightZeroColor[] = {0.8, 1.0, 0.8, 1.0}; /* green-tinted */
  2364.          GLfloat lightOnePosition[] = {-1.0, -2.0, 1.0, 0.0};
  2365.          GLfloat lightOneColor[] = {0.6, 0.3, 0.2, 1.0}; /* red-tinted */
  2366.          glMatrixMode(GL_PROJECTION);/* set up projection transform */
  2367.          glOrtho (LEFT,RIGHT, BOTTOM,TOP, NEAR2,FAR2);
  2368.          
  2369.          glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
  2370.          glLightfv(GL_LIGHT0, GL_POSITION, lightZeroPosition);
  2371.          glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor);
  2372.          glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1);
  2373.          glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05);
  2374.          glLightfv(GL_LIGHT1, GL_POSITION, lightOnePosition);
  2375.          glLightfv(GL_LIGHT1, GL_DIFFUSE, lightOneColor);
  2376.          glEnable(GL_LIGHT0);
  2377.          glEnable(GL_LIGHT1); 
  2378.          GLfloat ambi[] = {1.0, 1.0, 1.0, 1.0};
  2379.          glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambi);
  2380.  
  2381.          if (dinosor)
  2382.                     glEnable(GL_LIGHTING); 
  2383.          glLineWidth(2.0);
  2384.  
  2385.          glutKeyboardFunc(Key);
  2386.          glutSpecialFunc(SpecialKey);
  2387.          glutMainLoop();
  2388.          return 0;             /* ANSI C requires main to return int. */
  2389. }
  2390.