home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / VOGLE.ZIP / VOGLE / DRIVERS / GIF.C < prev    next >
C/C++ Source or Header  |  2000-02-11  |  12KB  |  357 lines
  1. #include "gd.h"
  2. #include <stdio.h>
  3. #include <math.h>
  4. #include <stdlib.h>
  5. #include "vogle.h"
  6.  
  7. extern FILE     *_voutfile();
  8. static FILE     *fp;
  9.  
  10. static gdImagePtr    im;
  11.  
  12. static int x_size, y_size; /* size of graphics array */
  13.  
  14. byte *graphics_rgb; /* the graphics data */
  15.  
  16. static int color = 0;
  17.  
  18. static int drawn = 0;
  19.  
  20. static int GLOBAL_rasters = 1; /* line thickness */
  21.  
  22. static int lastx, lasty;     /* position of last draw */
  23.  
  24. int coltab[256];
  25.  
  26. static int 
  27. noop()
  28. { 
  29.     return(-1); /* do nothing but return-1 */
  30. }
  31.  
  32. static int
  33. GIF_color(col) /* change the current color */
  34.         int     col;
  35. {
  36.         color = coltab[col % 256];
  37.         return(0);
  38. }
  39. /******************************************************************************/
  40. static int 
  41. GIF_mapcolor(indx, r, g, b)
  42.         int     indx, r, g, b;
  43. {
  44.         if (indx < 256 && indx >= 0) {
  45.         coltab[indx] = gdImageColorAllocate(im, r, g, b);
  46.         }
  47.         return(0);
  48. }
  49. /******************************************************************************/
  50. static int 
  51. GIF_init()
  52. {
  53.         int prefx, prefy, prefxs, prefys;
  54.         int i;
  55.  
  56.         getprefposandsize(&prefx, &prefy, &prefxs, &prefys);
  57.         if (prefxs != -1 ) {
  58.                 if (prefys <= 0 ){
  59.                         fprintf(stderr,"*GIF_init* y size of %d set to 400\n",prefys);
  60.                         prefys = 400;
  61.                 }
  62.                 else{
  63.                         vdevice.sizeSy = prefys;
  64.                 }
  65.                 if (prefxs <= 0 ){
  66.                         fprintf(stderr,"*GIF_init* x size of %d set to 600\n",prefys);
  67.                         prefxs = 600;
  68.                 }
  69.                 else{
  70.                         vdevice.sizeSx = prefxs;
  71.                 }
  72.         } else {
  73.                 /* nice default value */
  74.                 prefx = 0;
  75.                 prefy = 0;
  76.                 vdevice.sizeSy = 400;
  77.                 vdevice.sizeSx = 600;
  78.         }
  79.         vdevice.sizeX = vdevice.sizeY = MIN(vdevice.sizeSy,vdevice.sizeSx);
  80.         x_size=vdevice.sizeSx;
  81.         y_size=vdevice.sizeSy;
  82.         vdevice.depth = 8;
  83.     im = gdImageCreate(x_size, y_size);
  84.  
  85.         fp = _voutfile();
  86.  
  87.         /* Cause scaling to be 0 to maxX maxY: prefx, vdevice.sizeSx+prefx, prefy, vdevice.sizeSy+prefy */
  88.  
  89.         lastx = -1111111;
  90.         lasty = -1111111;
  91.  
  92.         drawn = 0;
  93.  
  94.         GIF_mapcolor(0, 0, 0, 0);
  95.         GIF_mapcolor(1, 255, 0, 0);
  96.         GIF_mapcolor(2, 0, 255, 0);
  97.         GIF_mapcolor(3, 255, 255, 0);
  98.         GIF_mapcolor(4, 0, 0, 255);
  99.         GIF_mapcolor(5, 255, 0, 255);
  100.         GIF_mapcolor(6, 0, 255, 255);
  101.         GIF_mapcolor(7, 255, 255, 255);
  102.  
  103.         for(i=8; i<256; i++){
  104.            GIF_mapcolor(i, 255, 255, 255);
  105.         }
  106.  
  107.         return(1);
  108. }
  109.  
  110. /******************************************************************************/
  111. static 
  112. PPM_fill(n, x, y) /* "fill" a polygon */
  113. int     n, x[], y[];
  114. {
  115.         int     i;
  116.  
  117.         PROTOTYPE static void PPM_SOLID_FILL( int n, int x[], int y[]);
  118.  
  119.         /* update current position if needed */
  120.         GLOBAL_lastx=x[0];
  121.         GLOBAL_lasty=y[0];
  122.  
  123.         for (i = 1; i < n; i++){
  124.                 PPM_DRAW_LINE(x[i],y[i]); /* draw outline across graphics array */
  125.         }
  126.         if ( x[n-1] != x[0] || y[n-1] != y[0] ) /* close the polygon if it is not closed */
  127.                 PPM_DRAW_LINE(x[0],y[0]);
  128.  
  129.         PPM_SOLID_FILL(n, x, y);
  130.  
  131.         /* update current position */
  132.         GLOBAL_lastx = vdevice.cpVx = x[n - 1];
  133.         GLOBAL_lasty = vdevice.cpVy = y[n - 1];
  134.  
  135.         GLOBAL_drawn = DRAWN;
  136. }
  137. /******************************************************************************/
  138. static 
  139. GIF_draw(x, y)
  140.         int     x, y;
  141. {
  142.         int     holdx, holdy;
  143.         int    xwide[4], ywide[4];
  144.         float cosa, sina;
  145.         double angle;
  146.  
  147.         if (lastx != x || lasty != y) {
  148.         gdImageLine(im, lastx, lasty, x, y, color);
  149.         lastx = vdevice.cpVx
  150.         lasty = vdevice.cpVy
  151.         drawn = 1;
  152.     }
  153. }
  154. static 
  155. GIF_exit()
  156. {
  157.         gdImageGif(im, fp);
  158.         if (fp != stdout){
  159.                 fclose(fp);
  160.         }
  161. }
  162.  
  163. static 
  164. GIF_setlw(w) 
  165.         int     w;
  166. {
  167.         GLOBAL_rasters = MAX(1,w);
  168. }
  169. static 
  170. GIF_clear() 
  171. {
  172.         gdImageGif(im, fp);
  173.         memset(im->pixels, 0, x_size * y_size);
  174. }
  175. /******************************************************************************/
  176. static int GIF_font(font) /* load in large or small */
  177.         char    *font;
  178. {
  179.         if (strcmp(font, "small") == 0) {
  180.                 vdevice.hwidth = 97.01; /* Size in plotter resolution units */
  181.                 vdevice.hheight = vdevice.hwidth * 2.0;
  182.         } else if (strcmp(font, "large") == 0) {
  183.                 vdevice.hwidth = 145.5;
  184.                 vdevice.hheight = vdevice.hwidth * 2.0;
  185.         } else
  186.                 return(0);
  187.  
  188.         return(1);
  189. }
  190. /******************************************************************************/
  191. static PPM_string(s) /* output a string.  */
  192.         char    *s;
  193. {
  194.         int             dy, dx;
  195.  
  196.         if (GLOBAL_lastx != vdevice.cpVx || GLOBAL_lasty != vdevice.cpVy){
  197.                 GLOBAL_lastx=vdevice.cpVx;
  198.                 GLOBAL_lasty=vdevice.cpVy;
  199.         }
  200.  
  201.         fputs(s, fp);
  202.  
  203.         GLOBAL_lastx = GLOBAL_lasty = -1111111; /* undefine current position because used hardware text ?*/
  204.         GLOBAL_drawn = DRAWN;
  205. }
  206. /******************************************************************************/
  207. static PPM_char(c) /* output a character */
  208. char    c;
  209. {
  210.   char  s[2];
  211.   s[0] = c; s[1]='\0';
  212.   PPM_string(s);
  213. }
  214. /******************************************************************************/
  215. static DevEntry PPMdev = {
  216.                 "ppm",       /* name of device */
  217.                 "large",     /* name of large font */
  218.                 "small",     /* name of small font */
  219.                 noop,        /* Set drawing in back buffer */
  220.                 PPM_char,    /* Draw a hardware character */
  221.                 noop,        /* Check if a key was hit */
  222.                 PPM_clear,   /* Clear the screen to current color */
  223.                 PPM_color,   /* Set current color */
  224.                 PPM_draw,    /* Draw a line */
  225.                 PPM_exit,    /* Exit graphics */
  226.                 PPM_fill,    /* Fill a polygon */
  227.                 PPM_font,    /* Set hardware font */
  228.                 noop,        /* Set drawing in front buffer */
  229.                 noop,        /* Wait for and get the next key hit */
  230.                 PPM_init,    /* Initialize the device */
  231.                 noop,        /* Get mouse/cross hair position */
  232.                 PPM_mapcolor,/* Set color indices */
  233.                 PPM_setlw,   /* Set line width */
  234.                 PPM_string,  /* Draw a hardware string */
  235.                 noop,        /* Swap front and back buffers */
  236.                 noop         /* Syncronize the display */
  237. };
  238. /******************************************************************************/
  239. _P3_devcpy()
  240. {
  241.         vdevice.dev = PPMdev;
  242.         vdevice.dev.Vinit = PPM_init;
  243.         GLOBAL_driver = P3;
  244. }
  245. /******************************************************************************/
  246. _P6_devcpy()
  247. {
  248.         vdevice.dev = PPMdev;
  249.         vdevice.dev.Vinit = PPM_init;
  250.         GLOBAL_driver = P6;
  251. }
  252. /*******************************************************************************/
  253. static PPM_YINTERCEPT(yscan, x1, y1, x2, y2, xintercept,yprev)
  254. /*
  255. Determine if scan line intercepts the line segment. If it does, return the x intercept.
  256. */
  257. int     yscan, x1, y1, x2, y2, *xintercept, *yprev;
  258. {
  259.         int deltay, yprevious;
  260.         float   t;
  261.         yprevious = *yprev; /* the value we need to use in this pass */
  262.         *yprev = y1;        /* store the value for the next call to (probably) use */
  263.         deltay = y2 - y1;
  264.         if ( deltay == 0 ){
  265.                 /* horizontal lines do not contribute to scan line intercepts */
  266.                 *yprev=yprevious;
  267.                 return(0);
  268.         }
  269.         t = (float)(yscan - y1) / deltay;
  270.         if (t > 0.0 && t <= 1.0) {
  271.                 /* scan line and line segment intersect but not at leading vertex */
  272.                 *xintercept = x1 + t*(x2 - x1) + 0.5;
  273.                 return (1);
  274.         } else if ( t == 0.0 ){
  275.                 /* scan line and line segment intersect at leading vertex */
  276.                 *xintercept = x1 + t*(x2 - x1) + 0.5;
  277.                 if(yprevious <= y1 && y2 <= y1 ){
  278.                    /* local maximum */
  279.                    return (1);
  280.                 } else if(yprevious >= y1 && y2 >= y1 ){
  281.                    /* local minimum */
  282.                    return (1);
  283.                 } else{
  284.                    /* ignore duplicate at vertex that is not a local maximum or minimum */
  285.                    return (0);
  286.                 }
  287.         }
  288.         /* scan line and line segment did not intersect */
  289.         return (0);
  290. }
  291. /*******************************************************************************/
  292. static void PPM_SOLID_FILL(n, x, y) /* fill polygon of n points drawn by polyline <x,y>.  */
  293. int     n, x[], y[];
  294. {
  295.         int i, j, sorted, yhorizontal, xint, tmp, xmin, xmax, ymax, ymin, xi[MAXVERTS], yprev;
  296.  
  297.         if ( n > MAXVERTS) {
  298.            fprintf(stderr,"*PPM_SOLID_FILL* more than %d vertices in a polygon\n",MAXVERTS);
  299.            return;
  300.         }
  301.  
  302.         /* find clip range */
  303.         ymin = ymax = y[0];
  304.         xmin = xmax = y[0];
  305.         for (i = 0; i < n; i++) {
  306.                 ymax = MAX(ymax, y[i]);
  307.                 ymin = MIN(ymin, y[i]);
  308.                 xmax = MAX(xmax, x[i]);
  309.                 xmin = MIN(xmin, x[i]);
  310.         }
  311.         /* ensure scan lines are generated that do not cause out-of-bound problems in the y direction */
  312.         ymin=MAX(ymin,0);
  313.         ymax=MIN(ymax,Y_SIZE);
  314.  
  315.         /* For each y value, get a list of X intersections... */
  316.         yhorizontal = ymax ;
  317.         while (yhorizontal >= ymin) {
  318.                 j = 0;
  319.                 yprev = y[n-1];
  320.                 for (i = 0; i < n-1; i++)
  321.                         if (PPM_YINTERCEPT(yhorizontal, x[i], y[i], x[i+1], y[i+1], &xint, &yprev))
  322.                                         xi[j++] = xint;
  323.                 /* Last one. */
  324.                 if (PPM_YINTERCEPT(yhorizontal, x[n-1], y[n-1], x[0], y[0], &xint, &yprev))
  325.                                 xi[j++] = xint;
  326.  
  327.                 /* odd pairs means something went wrong in figuring out whether to count vertices or not */
  328.                 if( 2 * (j/2) != j){
  329.                    fprintf(stderr,"*PPM_SOLID_FILL* Internal error: odd number of intersection points (%d) \n",j);
  330.                 }
  331.  
  332.                 /* Sort the X intersections... */
  333.                 sorted = 0;
  334.                 while (!sorted) {
  335.                         sorted = 1;
  336.                         for (i = 0; i < j-1; i++)
  337.                                 if (xi[i] > xi[i+1]) {
  338.                                         tmp = xi[i];
  339.                                         xi[i] = xi[i+1];
  340.                                         xi[i+1] = tmp;
  341.                                         sorted = 0;
  342.                                 }
  343.                 }
  344.  
  345.                 /* Draw the horizontal lines */
  346.                 /* should make sure within X clipping range */
  347.                 for (i = 0; i < j-1; i += 2) {
  348.                         GLOBAL_lastx=MAX(0,MIN(xi[i],X_SIZE));
  349.                         GLOBAL_lasty=yhorizontal;
  350.                         PPM_DRAW_LINE(MAX(0,MIN(xi[i+1],X_SIZE)), yhorizontal);
  351.                 }
  352.                 yhorizontal -= 1;
  353.         }
  354. }
  355. /*******************************************************************************/
  356.  
  357.