home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / pctech / hlsrc / hlgraph.c < prev    next >
Text File  |  1988-09-09  |  13KB  |  509 lines
  1. /*+
  2.     Name:    hlgraph.c
  3.     Date:    30-May-1988
  4.     Author:    Kent J. Quirk
  5.         (c) Copyright 1988 Ziff Communications Co.
  6.     Abstract:    This program performs a graphics video benchmark.
  7.     History:    09-Sep-88   kjq     Version 1.00
  8. -*/
  9.  
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <graph.h>
  14. #include <conio.h>
  15. #include <math.h>
  16. #include "hl.h"
  17. #include "hltimes.h"
  18.  
  19. #define MAXROWS 10
  20. #define MAXCOLS 10
  21.  
  22. int nrows = 3;
  23. int ncols = 3;
  24. int vmax = 400;
  25.  
  26. int graphdata[MAXROWS][MAXCOLS] = {
  27.     {  277, 251, 226, 246     } ,
  28.     {  295, 295, 240, 170     } ,
  29.     {  309, 298, 247, 145     } ,
  30.     {  337, 290, 241, 139     } 
  31. };
  32.  
  33. extern int *colorlist;
  34. int base_color = 0;
  35. struct videoconfig config;
  36.  
  37. TIME_REC tests[] = {
  38.     {  0L, ""      } ,
  39.     {  0L, " 400 small areas   "     } ,
  40.     {  0L, " 100 large areas   "     } ,
  41.     {  0L, " 400 small ellipses"     } ,
  42.     {  0L, " 200 large ellipses"     } ,
  43.     {  0L, "4000 small lines   "     } ,
  44.     {  0L, "2000 large lines   "     } ,
  45.     {  0L, "General graphs     "     } ,
  46.     { -1L, "HLGRAPH4"      } 
  47. };
  48.  
  49. #define NRECT    100
  50. #define NELLIPSE 200
  51. #define NLINE    2000
  52. #define PIXFMT     " %5ldK pels\000"
  53.  
  54. /**** f a t _ r e c t a n g l e ****
  55.     Abstract:    Draws a rectangle with a drop shadow
  56.     Parameters: short x1, y1, x2, y2 -- the corners of the rectangle
  57.         short depth - the depth of the shadow (in pixels)
  58.         int shadow, front -- the color of the shadow and front
  59.             (which is modified by base_color for visual interest)
  60.     Returns:    nothing
  61. ****************************/
  62. void fat_rectangle(x1, y1, x2, y2, depth, shadow, front)
  63. short x1, y1, x2, y2, depth;
  64. int shadow, front;
  65. {
  66.     int i;
  67.  
  68.     _setcolor(colorlist[(base_color+shadow) % 16]);
  69.     for (i=depth; i>0; i--)
  70.     _rectangle(_GBORDER, x1+i, y1-i, x2+i, y2-i);
  71.     _setcolor(colorlist[(base_color+front) % 16]);
  72.     _rectangle(_GFILLINTERIOR, x1, y1, x2, y2);
  73.     _setcolor(0);
  74.     _moveto(x2+1, y2);
  75.     _lineto(x2+depth+1, y2-depth);
  76. }
  77.  
  78. /**** b a r _ g r a p h ****
  79.     Abstract:    Given the global graphdata[], this draws a bar graph
  80.         with that data.
  81.     Parameters: int x, y -- the position of the lower left corner
  82.         int max_x, max_y -- the position of the upper right corner
  83.     Returns:    Nothing
  84. ****************************/
  85. void bar_graph(x, y, max_x, max_y)
  86. int x, y, max_x, max_y;
  87. {
  88.     int barwidth;
  89.     int yscale;
  90.     int i, j;
  91.     long t;
  92.     int xl, hgt;
  93.     int depth;
  94.  
  95.     _setlogorg(x, y);
  96.  
  97.     barwidth = max_x / (ncols * (nrows+1) - 1);
  98.     depth = barwidth / 4;
  99.  
  100.     for (i=0; i<ncols; i++)
  101.     {
  102.     for (j=0; j<nrows; j++)
  103.     {
  104.         xl = (i * (nrows+1) + j) * barwidth;
  105.         t = (long)graphdata[j][i] * (long)max_y;
  106.         hgt = (int)(t / (long)vmax);
  107.         fat_rectangle(xl+1, 0, xl + barwidth, hgt,
  108.         depth, j, j+8);
  109.     }
  110.     }
  111.  
  112.     _setcolor(0xFF);
  113.     _moveto(0, max_y);
  114.     _lineto(0, 0);
  115.     _lineto(max_x, 0);
  116.     if (++base_color >= 16)
  117.     base_color = 0;
  118. }
  119.  
  120. /**** p i e _ g r a p h ****
  121.     Abstract:    In a manner similar to bar graph, this draws a pie chart.
  122. ****************************/
  123. void pie_graph(x, y, wid, hgt)
  124. int x, y, wid, hgt;
  125. {
  126.     _setlogorg(x,y);
  127.     _setcolor(colorlist[base_color]);
  128.     _pie(_GFILLINTERIOR, 0, 0, wid, hgt, wid, hgt/2, wid, hgt);
  129.     _setcolor(colorlist[(base_color+1) % 16]);
  130.     _pie(_GFILLINTERIOR, 0, 0, wid, hgt, wid, hgt, 0, hgt);
  131.     _setcolor(colorlist[(base_color+2) % 16]);
  132.     _pie(_GFILLINTERIOR, 0, 0, wid, hgt, 0, hgt, wid, hgt/2);
  133.     _setcolor(0xFF);
  134.     _pie(_GBORDER, 0, 0, wid, hgt, wid, hgt/2, wid, hgt);
  135.     _pie(_GBORDER, 0, 0, wid, hgt, wid, hgt, 0, hgt);
  136.     _pie(_GBORDER, 0, 0, wid, hgt, 0, hgt, wid, hgt/2);
  137.     if (++base_color >= 16)
  138.     base_color = 0;
  139. }
  140.  
  141. /**** l i n e _ g r a p h ****
  142.     Abstract:    In a manner similar to bar graph, this draws a line graph.
  143. ****************************/
  144. void line_graph(x, y, wid, hgt)
  145. int x, y, wid, hgt;
  146. {
  147.     int xstep = 4;
  148.     int ystep = 4;
  149.     int i;
  150.     int x1, y1, x2, y2;
  151.  
  152.     y1 = y2 = hgt;                      /* realize that hgt is negative */
  153.     x1 = xstep;
  154.     x2 = wid;
  155.  
  156.     _setlogorg(x,y);
  157.     _setcolor(colorlist[base_color]);
  158.     _moveto(0, y1);
  159.     while (x2 >= 0 && y2 <= 0)
  160.     {
  161.     _lineto(x1, 0);
  162.     _lineto(x2, y2);
  163.     _lineto(0, y1);
  164.     x1 += xstep;
  165.     x2 -= xstep;
  166.     y1 += ystep/2;
  167.     y2 += ystep;
  168.     }
  169.     if (++base_color >= 16)
  170.     base_color = 0;
  171. }
  172.  
  173. /**** l i n e s ****
  174.     Abstract:    This tests line drawing speed of a video adapter
  175.         by drawing a number of lines at random positions and 
  176.         colors.
  177.     Parameters: int npts -- the number of lines to draw
  178.         int max_x, max_y -- the maximum x and y values to use
  179.     Returns:    nothing
  180. ****************************/
  181. void lines(npts, max_x, max_y)
  182. int npts;
  183. int max_x, max_y;
  184. {
  185.     int x, y, i;
  186.  
  187.     _moveto(0,0);
  188.     srand(1);
  189.     for (i=0; i<npts; i++)
  190.     {
  191.     x = rand() % max_x;
  192.     y = rand() % max_y;
  193.     _setcolor(colorlist[base_color]);
  194.     _lineto(x, y);
  195.     if (++base_color >= 16)
  196.         base_color = 0;
  197.     }
  198. }
  199.  
  200. /**** r e c t s ****
  201.     Abstract:    Draws a number of rectangles at various positions and colors.
  202.     Parameters: int npts -- the number of lines to draw
  203.         int max_x, max_y -- the maximum x and y values to use
  204.     Returns:    nothing
  205. ****************************/
  206. void rects(n, max_x, max_y)
  207. int n;
  208. int max_x, max_y;
  209. {
  210.     int i, x, y, wid, hgt;
  211.  
  212.     srand(1);
  213.     for (i=0; i<n; i++)
  214.     {
  215.     wid = rand() % max_x;
  216.     hgt = rand() % max_y;
  217.     x = rand() % (max_x - wid);
  218.     y = rand() % (max_y - hgt);
  219.     _setcolor(colorlist[base_color]);
  220.     _rectangle(_GFILLINTERIOR, x, y, x+wid, y+hgt);
  221.     if (++base_color >= 16)
  222.         base_color = 0;
  223.     }
  224. }
  225.  
  226. /**** e l l i p s e s ****
  227.     Abstract:    Draws a number of ellipses at various positions and colors.
  228.     Parameters: int npts -- the number of lines to draw
  229.         int max_x, max_y -- the maximum x and y values to use
  230.     Returns:    nothing
  231. ****************************/
  232. void ellipses(n, max_x, max_y)
  233. int n;
  234. int max_x, max_y;
  235. {
  236.     int i, x, y, wid, hgt;
  237.  
  238.     srand(1);
  239.     for (i=0; i<n; i++)
  240.     {
  241.     wid = rand() % max_x;
  242.     hgt = rand() % max_y;
  243.     x = rand() % (max_x - wid);
  244.     y = rand() % (max_y - hgt);
  245.     _setcolor(colorlist[base_color]);
  246.     _ellipse(_GBORDER, x, y, x+wid, y+hgt);
  247.     if (++base_color >= 16)
  248.         base_color = 0;
  249.     }
  250. }
  251.  
  252. /**** c a l c _ l i n e s ****
  253.     Abstract:    Given the same parameters as lines(), this calculates the 
  254.         number of pixels drawn.
  255. ****************************/
  256. long calc_lines(npts, max_x, max_y)
  257. int npts;
  258. int max_x, max_y;
  259. {
  260.     int x, y, i;
  261.     int ox=0, oy=0;
  262.     double dx, dy;
  263.     long npixels = 0L;
  264.  
  265.     srand(1);
  266.     for (i=0; i<npts; i++)
  267.     {
  268.     x = rand() % max_x;
  269.     y = rand() % max_y;
  270.     dx = (double)(x-ox);
  271.     dy = (double)(y-oy);
  272.     npixels += (long)sqrt(dx*dx + dy*dy);
  273.     oy = y;
  274.     ox = x;
  275.     }
  276.     return(npixels/1000L);
  277. }
  278.  
  279. /**** c a l c _ r e c t s ****
  280.     Abstract:    Given the same parameters as rects(), this calculates the 
  281.         number of pixels drawn.
  282. ****************************/
  283. long calc_rects(n, max_x, max_y)
  284. int n;
  285. int max_x, max_y;
  286. {
  287.     int i, x, y, wid, hgt;
  288.     long npixels = 0L;
  289.  
  290.     srand(1);
  291.     for (i=0; i<n; i++)
  292.     {
  293.     wid = rand() % max_x;
  294.     hgt = rand() % max_y;
  295.     x = rand() % (max_x - wid);
  296.     y = rand() % (max_y - hgt);
  297.     npixels += (long)wid * hgt;
  298.     }
  299.     return(npixels/1000L);
  300. }
  301.  
  302. /**** c a l c _ e l l i p s e s ****
  303.     Abstract:    Given the same parameters as ellipses(), this calculates the 
  304.         number of pixels drawn.
  305. ****************************/
  306. long calc_ellipses(n, max_x, max_y)
  307. int n;
  308. int max_x, max_y;
  309. {
  310.     int i, x, y, wid, hgt;
  311.     long npixels = 0L;
  312.     long np1, np2;
  313.  
  314.     srand(1);
  315.     for (i=0; i<n; i++)
  316.     {
  317.     wid = rand() % max_x;
  318.     hgt = rand() % max_y;
  319.     x = rand() % (max_x - wid);
  320.     y = rand() % (max_y - hgt);
  321.     np1 = (long)(wid + hgt) * 2L;
  322.     np2 = 4L * (long)sqrt((double)wid*wid/4 + (double)hgt*hgt/4);
  323.     npixels += (np1+np1+np2)/3L;
  324.     }
  325.     return(npixels/1000L);
  326. }
  327.  
  328. /**** u s a g e ****
  329.     Abstract:    Displays brief usage message and terminates.
  330.     Returns:    Never returns.
  331. ****************************/
  332. void usage()
  333. {
  334.     printf("Usage: HLGRAPH [-?] [-xXCOUNT] [-yYCOUNT]\n");
  335.     printf("  XCOUNT and YCOUNT are the number of graph repetitions.\n");
  336.     exit(1);
  337. }
  338.  
  339.  
  340. int main(argc, argv)
  341. int argc;
  342. char *argv[];
  343. {
  344.     int i, x, y, xp, yp, dx, dy;
  345.     int xcount = 5;
  346.     int ycount = 3;
  347.     int batch = 0;
  348.     int bench = 0;
  349.     int wid, hgt;
  350.     int test = 1;
  351.     int program = -1;
  352.     char *filename = NULL;
  353.  
  354.     for (i=1; i<argc; i++)
  355.     {
  356.     if (argv[i][0] != '-')
  357.         usage();
  358.  
  359.     switch (tolower(argv[i][1])) {
  360.     case 'x':
  361.         xcount = atoi(argv[i]+2);
  362.         break;
  363.     case 'y':
  364.         ycount = atoi(argv[i]+2);
  365.         break;
  366.     case 'a':
  367.         batch = 1;
  368.         break;
  369.     case 'b':
  370.         bench = 1;
  371.         break;
  372.     case 'f':
  373.         filename = argv[i]+2;
  374.         break;
  375.     case 'p':
  376.         program = atoi(argv[i]+2);
  377.         break;
  378.     default:
  379.     case '?':
  380.         usage();
  381.     }
  382.     }
  383.  
  384.     if (!init_video((struct videoconfig far *)&config))
  385.     {
  386.     printf("Couldn't set any graphics mode!\n");
  387.     exit(1);
  388.     }
  389.     start_timer(0);
  390.  
  391.     start_timer(1);
  392.     rects(NRECT*4, config.numxpixels/2, config.numypixels/2);
  393.     stop_timer();
  394.     sprintf(tests[test].desc+strlen(tests[test].desc), PIXFMT,
  395.     calc_rects(NRECT*4, config.numxpixels/2, config.numypixels/2));
  396.     tests[test++].ticks = get_timer(1);
  397.  
  398.     start_timer(1);
  399.     rects(NRECT, config.numxpixels, config.numypixels);
  400.     stop_timer();
  401.     sprintf(tests[test].desc+strlen(tests[test].desc), PIXFMT,
  402.     calc_rects(NRECT, config.numxpixels, config.numypixels));
  403.     tests[test++].ticks = get_timer(1);
  404.  
  405.     _setcolor(0);
  406.     _rectangle(_GFILLINTERIOR, 0, 0, config.numxpixels, config.numypixels);
  407.  
  408.     start_timer(1);
  409.     ellipses(NELLIPSE*2, config.numxpixels/2, config.numypixels/2);
  410.     stop_timer();
  411.     sprintf(tests[test].desc+strlen(tests[test].desc), PIXFMT,
  412.     calc_ellipses(NELLIPSE*2, config.numxpixels/2, config.numypixels/2));
  413.     tests[test++].ticks = get_timer(1);
  414.  
  415.     start_timer(1);
  416.     ellipses(NELLIPSE, config.numxpixels, config.numypixels);
  417.     stop_timer();
  418.     sprintf(tests[test].desc+strlen(tests[test].desc), PIXFMT,
  419.     calc_ellipses(NELLIPSE, config.numxpixels, config.numypixels));
  420.     tests[test++].ticks = get_timer(1);
  421.  
  422.     _setcolor(0);
  423.     _rectangle(_GFILLINTERIOR, 0, 0, config.numxpixels, config.numypixels);
  424.  
  425.     start_timer(1);
  426.     lines(NLINE * 2, config.numxpixels/2, config.numypixels/2);
  427.     stop_timer();
  428.     sprintf(tests[test].desc+strlen(tests[test].desc), PIXFMT,
  429.     calc_lines(NLINE*2, config.numxpixels/2, config.numypixels/2));
  430.     tests[test++].ticks = get_timer(1);
  431.  
  432.     start_timer(1);
  433.     lines(NLINE, config.numxpixels, config.numypixels);
  434.     stop_timer();
  435.     sprintf(tests[test].desc+strlen(tests[test].desc), PIXFMT,
  436.     calc_lines(NLINE, config.numxpixels, config.numypixels));
  437.     tests[test++].ticks = get_timer(1);
  438.  
  439.     _setcolor(colorlist[0]);
  440.     _rectangle(_GFILLINTERIOR, 0, 0, config.numxpixels, config.numypixels);
  441.  
  442.     start_timer(1);
  443.     wid = div(config.numxpixels * 2, xcount * 3).quot;
  444.     hgt = div(config.numypixels * -1, ycount * 2).quot;
  445.     dx = config.numxpixels / (xcount + 1);
  446.     dy = config.numypixels / (ycount + 1);
  447.  
  448.     _clearscreen(_GCLEARSCREEN);
  449.     i=0;
  450.     for (y=ycount; y>0; y--)
  451.     {
  452.     yp = y * dy + dy/2;
  453.     for (x=0; x<xcount; x++)
  454.     {
  455.         xp = x * dx + dx/2;
  456.         switch (++i % 3) {
  457.         case 1:
  458.         line_graph(xp, yp, wid, hgt);
  459.         break;
  460.         case 2:
  461.         pie_graph(xp, yp, wid, hgt);
  462.         break;
  463.         case 0:
  464.         bar_graph(xp, yp, wid, hgt);
  465.         break;
  466.         default:
  467.         printf("Whoops!\n");
  468.         break;
  469.         }
  470.     }
  471.     }
  472.     stop_timer();
  473.     tests[test++].ticks = get_timer(1);
  474.     tests[0].ticks=0;        /* add times to get total time */
  475.     for (i=1; i<test; i++)
  476.     tests[0].ticks += tests[i].ticks;
  477.  
  478.     if (!batch)
  479.     {
  480.     _settextposition(1,1);
  481.     _outtext("Press any key...");
  482.     getch();
  483.     }
  484.     else
  485.     {
  486.     start_timer(2);
  487.     do stop_timer(); while (get_timer(2) < 36);    /* 36 is 2 seconds */
  488.     }
  489.     _setvideomode(_DEFAULTMODE);
  490.  
  491.     sprintf(tests[0].desc, "Total: Graphics (%dx%d,%d col)",
  492.     config.numxpixels, config.numypixels, config.numcolors);
  493.  
  494.     if ((!bench) && (!batch))
  495.     for (i=0; i<test; i++)
  496.         printf("%s:  %s\n", time_secs(tests[i].ticks), tests[i].desc);
  497.  
  498.     if ((program != -1) && (filename != NULL))
  499.     {
  500.     opentime(filename);
  501.     for (i=0; i<test+1; i++)
  502.         savetime(program, i, &tests[i]);
  503.     closetime();
  504.     }
  505.  
  506.     return(0);
  507. }
  508. 
  509.