home *** CD-ROM | disk | FTP | other *** search
/ ftp.disi.unige.it / 2015-02-11.ftp.disi.unige.it.tar / ftp.disi.unige.it / pub / .person / MagilloP / GEOMOD99 / visptloc.c < prev   
C/C++ Source or Header  |  1999-05-04  |  5KB  |  208 lines
  1. /***********************************************************************/
  2. /* FILE: visptloc.c                                                    */
  3. /***********************************************************************/
  4.  
  5. /*
  6. Visualizza una triangolazione con evidenziato un triangolo, e un punto
  7. */
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <GL/glut.h>
  12.  
  13. #include "point.h"
  14.  
  15. /***********************************************************************/
  16.  
  17. /*
  18. Variabili globali al programma:
  19. PER LA TRIANGOLAZIONE:
  20. ptNum = numero di punti
  21. ptArr = array di punti
  22. trNum = numero di triangoli
  23. trArr = array di terne di indici (triangoli)
  24. miX, maX, miY, maY = coordinate estreme dei punti
  25. PER IL PUNTO E IL TRIANGOLO:
  26. pt = il punto
  27. tr = l'indice intero del triangolo all'interno della triangolazione
  28. miX, maX, miY, maY = coordinate estreme dei punti
  29. */
  30.  
  31. #define MAX_POINT  100
  32. int ptNum = 0;
  33. Point ptArr[MAX_POINT];
  34. float miX, maX, miY, maY;
  35. int trNum = 0;
  36. int trArr[MAX_POINT][3];
  37. Point pt;
  38. int tr;
  39. float miX, maX, miY, maY;
  40.  
  41. /***********************************************************************/
  42.  
  43. /*
  44. Legge punti da input e li mette in array ptArr,
  45. mette il numero di punti letti in ptNum, legge i triangoli
  46. e li mette in trArr, mette il numero di triangoli in trNum.
  47. Alla fine legge punto e indice di triangolo.
  48.  
  49. */
  50. void ReadTriangles()
  51. {
  52.   int i;
  53.   char aux[40];
  54.   int dummy;
  55.   
  56.   /* legge i vertici */
  57.   scanf("%d",&ptNum);
  58.   for (i=0; i<ptNum; i++)
  59.   {
  60.      scanf("%f %f", &ptArr[i][X], &ptArr[i][Y]);
  61.   }
  62.   /* legge le terne che definiscono i triangoli */
  63.   scanf("%d",&trNum);
  64.   for (i=0; i<trNum; i++)
  65.   {
  66.     scanf("%d %d %d", &trArr[i][0], &trArr[i][1], &trArr[i][2]);
  67.   }
  68.   
  69.   /* legge la relazione VT parziale e la scarta */
  70.   for (i=0; i<ptNum; i++)
  71.   {
  72.      scanf("%d", &dummy);
  73.   }
  74.   /* legge la relazione TT e la scarta */
  75.   for (i=0; i<trNum; i++)
  76.   {
  77.     scanf("%d %d %d", &dummy, &dummy, &dummy);
  78.   }
  79.   
  80.   /* legge punto e triangolo */
  81.   scanf("%s",aux); /* legge la parola chiave del punto */
  82.   if (strcmp(aux,"INPUT_POINT")!=0)
  83.     fprintf(stderr,"Manca il punto\n");
  84.   else scanf("%f %f", &pt[X], &pt[Y]);
  85.   scanf("%s",aux); /* legge la parola chiave del triangolo */
  86.   if (strcmp(aux,"OUTPUT_TRIANGLE")!=0)
  87.     fprintf(stderr,"Manca il triangolo\n");
  88.   else scanf("%d", &tr);
  89. }
  90.  
  91. /***********************************************************************/
  92.  
  93. /*
  94. Calcola le ccordinate estreme dei punti in ptArr.
  95. */
  96. void BoundingBox(float *minX, float *maxX, float *minY, float *maxY)
  97. {
  98.   int i;
  99.  
  100.   (*minX) = (*maxX) = ptArr[0][X];
  101.   (*minY) = (*maxY) = ptArr[0][Y];
  102.   for (i=1; i<ptNum; i++)
  103.   {
  104.     if (ptArr[i][X]<(*minX)) (*minX) = ptArr[i][X];
  105.     else if (ptArr[i][X]>(*maxX)) (*maxX) = ptArr[i][X];
  106.     if (ptArr[i][Y]<(*minY)) (*minY) = ptArr[i][Y];
  107.     else if (ptArr[i][Y]>(*maxY)) (*maxY) = ptArr[i][Y];
  108.   }    
  109. }
  110.  
  111. /***********************************************************************/
  112.  
  113. void DrawingFunction(void)
  114. {
  115.   int i;
  116.  
  117.   /* pulisce il video riempiendolo con colore di sfondo bianco */
  118.   glClearColor(1.0,1.0,1.0,0.0);
  119.   glClear(GL_COLOR_BUFFER_BIT);
  120.   
  121.   /* stabilisce la parte di scena che deve essere inquadrata */
  122.   glMatrixMode(GL_PROJECTION);
  123.   glLoadIdentity();
  124.   gluOrtho2D(miX-EPSILON,maX+EPSILON,miY-EPSILON,maY+EPSILON);
  125.  
  126.   /* traccia il contorno dei triangoli in magenta riempiendo in
  127.      giallo il triangolo dato */
  128.  
  129.   if ( (tr>=0) && (tr<trNum) )
  130.   {
  131.     glColor3f(1.0,1.0,0.0);
  132.     glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
  133.     glBegin(GL_TRIANGLES);
  134.       glVertex2f(ptArr[trArr[tr][0]][X],ptArr[trArr[tr][0]][Y]);
  135.       glVertex2f(ptArr[trArr[tr][1]][X],ptArr[trArr[tr][1]][Y]);
  136.       glVertex2f(ptArr[trArr[tr][2]][X],ptArr[trArr[tr][2]][Y]);
  137.     glEnd();
  138.   }
  139.               
  140.   glColor3f(1.0,0.0,1.0);
  141.   glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
  142.   glBegin(GL_TRIANGLES);
  143.   for (i=0; i<trNum; i++)
  144.   {         
  145.     glVertex2f(ptArr[trArr[i][0]][X],ptArr[trArr[i][0]][Y]);
  146.     glVertex2f(ptArr[trArr[i][1]][X],ptArr[trArr[i][1]][Y]);
  147.     glVertex2f(ptArr[trArr[i][2]][X],ptArr[trArr[i][2]][Y]);
  148.   }
  149.   glEnd();
  150.  
  151.   /* traccia il punto in rosso */
  152.   glColor3f(1.0,0.0,0.0);
  153.   glPointSize(5.0);
  154.   glBegin(GL_POINTS);
  155.     glVertex2f(pt[X],pt[Y]);
  156.   glEnd();
  157.   
  158.   /* invia tutto allo schermo per visualizzazione effettiva */
  159.   glFlush();
  160.   glutSwapBuffers();
  161. }
  162.  
  163. void ReshapeFunction(int w, int h)
  164. {
  165.     glViewport(0, 0, w, h);
  166. }
  167.  
  168. void KeyboardFunction(unsigned char c, int x, int y)
  169. {
  170.   switch (c)
  171.   {
  172.     case 'Q':
  173.     case 'q': exit(0);
  174.   }
  175. }
  176.  
  177. /***********************************************************************/
  178.  
  179. /* apre una finestra larga  w pixel ed alta h pixel */
  180. void OpenWindow(int w, int h, char *titolo)
  181. {
  182.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  183.   glutInitWindowSize(w,h);
  184.   glutCreateWindow(titolo);
  185.   glutDisplayFunc(DrawingFunction);
  186.   glutReshapeFunc(ReshapeFunction);
  187.   glutKeyboardFunc(KeyboardFunction);
  188.   glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  189. }
  190.  
  191. /***********************************************************************/
  192.  
  193. void main(int argc, char **argv)
  194. {
  195.   /* inizializza il sistema grafico */
  196.   glutInit(&argc, argv);
  197.  
  198.   /* legge la triangolazione, il punto e l'indice del triangolo */
  199.   ReadTriangles();
  200.   BoundingBox(&miX, &maX, &miY, &maY);
  201.   
  202.   /* apre la finestra grafica e fa partire il tutto */
  203.   OpenWindow(300,300,"VisPointLocation");
  204.   glutMainLoop();
  205. }
  206.  
  207. /***********************************************************************/
  208.