home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / grafik / coregraf / bench.c next >
Encoding:
C/C++ Source or Header  |  1986-01-06  |  10.4 KB  |  362 lines
  1. /*    bench - integer mode graphics demonstration and benchmark      
  2.  
  3.     bugs...
  4.  
  5. screen measurements: 191 mm wide by 158 mm high on Z-150
  6. index multiple draw/erase by colors rather than intensities.
  7. illustrate draw/erase on grid to show independent erasure.
  8.  
  9. */
  10.  
  11. #include <stdio.h>
  12. #include <g.h>
  13.  
  14. int no_characters=0;    /* nonzero if calls to character functions are
  15.                             to be avoided (presumably because they aren't
  16.                             yet implemented)              */
  17. long int t1,t2,t3,min_rate,max_rate,overhead;
  18. long tics();
  19.  
  20. main(argc,argv) int argc; char **argv;
  21. {    int i,j,k;
  22.     int q,x1,y1,x2,y2;
  23.     int w0,w1,w2,z2;
  24.     double intensity;
  25.     double d1,d2,d3,minimum_rate,maximum_rate;
  26.  
  27.     initialize_parameters(argc,argv);
  28.  
  29.     init_graphics();
  30. /*        draw barber-pole patterns in top right & bottom left corners */
  31.     set_intensity(.4);
  32.     box(0,0,pixels_wide-1,pixels_high-1);
  33.     if(no_characters)
  34.         {puts("\n character routine demo omitted ");
  35.         for(i=1; i<1000; i++) for(j=1; j<100; j++) ;
  36.         set_intensity(1.);
  37.         }
  38.     else
  39.         {gotoxy(0,1);
  40.         puts(" character size \n and placement?");
  41.         q=0;
  42.         for(i=0; i<144; i++)
  43.             {gotoxy(q%12+char_columns-12,q/12);
  44.             putchar('a'+q/12+q%12);
  45.             gotoxy(q%12,q/12+char_rows-12);
  46.             putchar('a'+q/12+q%12);
  47.             q=(q+17)%144;
  48.             }
  49.         x2=char_columns*char_width+x_offset-1; x1=x2-12*char_width+1; 
  50.         y1=y_offset-char_height+1; y2=y1+char_height*12-1;
  51.         set_intensity(1.);
  52.         box(x1,y1,x2,y2);
  53.         x1=x_offset; x2=x1+char_width*12-1;
  54.         y2=(char_rows-1)*char_height+y_offset; y1=y2-12*char_height+1; 
  55.         box(x1,y1,x2,y2);
  56.         wait();
  57.         }
  58.     clear_graphics();
  59. /*                        diamonds    */
  60.     if(!no_characters) gotoxy(0,char_rows-2);
  61.     puts("lines end ");
  62.     if(!no_characters) gotoxy(0,char_rows-1);
  63.     puts("accurately?");
  64.     w0=(pixels_wide-1)/4;
  65.     y2=0;
  66.     while(y2<pixels_high)    {(*draw_line)(0,pixels_high/2,w0-1,y2); y2+=5;}
  67.     while(y2>0)                {y2-=5; (*draw_line)(2*w0,pixels_high/2,w0+1,y2);}
  68.     x2=pixels_wide/2; x1=pixels_wide*3/4; y1=pixels_high/2; y2=pixels_high-1;
  69.     while(x2<pixels_wide)    {(*draw_line)(x1,0,x2,y1); x2+=5;}
  70.     while(x2>pixels_wide/2)    {x2-=5; (*draw_line)(x1,y2,x2,y1+2);}
  71.     wait(); clear_graphics();
  72. /*                        drawing & erasing rectangles            */
  73.     rectangles();
  74.     wait(); clear_graphics();
  75. /*                        creating & erasing rectangles of different intensities */
  76.     if(!no_characters) gotoxy(0,char_rows-1);
  77.     puts("drawing and erasing algorithms match?");
  78.         for (intensity=.938; intensity>0.; intensity-=.125)
  79.         {if(!no_characters) gotoxy(0,10);
  80.         set_intensity(1.);
  81.         printf("intensity %5.3f",intensity);
  82.         set_intensity(intensity);
  83.         rectangle(.3);
  84.         }
  85.     clear_graphics();
  86.     set_intensity(1.);
  87. /*                         timed squares */
  88.     if(!no_characters) gotoxy(char_columns-7,char_rows-1);
  89.     puts("timing");
  90.     timed_squares();
  91.     if(!no_characters) gotoxy(0,0);
  92.     d1=t1; d2=t2; d3=t3;
  93.     printf("large square: %3.0f tics, or %3.0f lines/sec\n",
  94.         d2-d1,32000./(d2-d1));
  95.     printf("small square: %3.0f tics, or %3.0f lines/sec\n\n",
  96.         d3-d2,32000./(d3-d2));
  97.     maximum_rate=(32000.*9)/(10*(d3-d2)-(d2-d1));
  98.     minimum_rate=(32000.*maximum_rate)/(2*maximum_rate*(d2-d1)-16000.);
  99.     overhead=(100*minimum_rate)/maximum_rate;
  100. /*    printf("maximum drawing speed = %4.0f lines/sec  \n",maximum_rate); */
  101.     printf("minimum drawing speed = %4.0f lines/sec  \n",minimum_rate);
  102.     printf("(for which %D%% is overhead independent of line length) \n",
  103.         overhead);
  104.  
  105.     wait(); clear_graphics();
  106. /*                        draw stripes of negative and positive width 
  107.                         and bow tie of horizontal lines                    */    
  108.     if(!no_characters) gotoxy(0,char_rows-1);
  109.         puts("accurate horizontal lines?");
  110.     for(x1=20,k=-13; k<19; x1+=abs(k)+9,k++)
  111.         {i=x1;
  112.         for(y1=0; y1<39 && i+k<pixels_wide; i++,y1++)
  113.             (*draw_line)(i,y1,i+k,y1);
  114.         }
  115.     x1=0; x2=pixels_high/3;
  116.     for(y1=40; y1<pixels_high && x1<pixels_wide ; y1++)
  117.         {(*draw_line)(x1,y1,x2,y1);
  118.         x2++;
  119.         x1+=2;
  120.         }
  121.     wait(); clear_graphics();
  122. /*                        draw bow tie of vertical lines                    */
  123.     if(!no_characters) gotoxy(0,char_rows-1);
  124.         puts("accurate vertical lines?");
  125.     x1=20;
  126.     for(y1=0,y2=pixels_high/5 ; y1<(pixels_high*7)/8 ; x1++,y2++,y1+=2)
  127.         (*draw_line)(x1,y1,x1,y2);
  128.     k=-10;
  129.     for(x1=35 ; x1+20<pixels_wide ; x1+=abs(k)+9)
  130.         {x2=x1;
  131.         for(y1=11 ; y1<25 ; y1++)
  132.             {(*draw_line)(x2,y1,x2,y1+k);
  133.             x2++;
  134.             }
  135.         k++;
  136.         }
  137.     wait(); clear_graphics();
  138.  
  139. /*                        right triangle (near-vertical lines) */
  140.     if(!no_characters) gotoxy(0,char_rows-1);
  141.         puts("centered step in near-vertical lines?");
  142.     j=0;
  143.     for (i=pixels_wide-100; i<pixels_wide; i=i+3)
  144.         {(*draw_line)(i,0,i-1,j); j=j+1;
  145.         }
  146.     wait();
  147.     clear_graphics();
  148. /*                        this should draw a vertical line    */
  149.     if(!no_characters) gotoxy(0,0);
  150.     puts("display of zero-length horizontal lines");
  151.     for (i=50;i<100; i++) (*draw_line)(pixels_wide/2,i,pixels_wide/2,i);
  152.     wait();
  153.     clear_graphics();
  154. /*                        draw lines with user selecting colors    */
  155. /*    if(!no_characters) gotoxy(0,0);
  156.     puts("enter color code for each new line (0-7), CR to stop\n");
  157.     for (i=20; i<199; i++)
  158.         {j=getchar()-'0';
  159.         if((j<0)|(j>7)) break;
  160.         set_color(j);
  161.         (*draw_line)(0,i,50,i);
  162.         }
  163.     clear_graphics();
  164. */
  165. /*                        color bars  */
  166.     if(!no_characters) gotoxy(0,0);
  167.     puts("color bars             intensity bars \n");
  168.     y2=10;
  169.     x1=pixels_wide/2;
  170.     for (i=0; i<=max_color; i++)
  171.         {set_color(i);
  172.         for (j=0; j<10; j++) {(*draw_line)(0,y2,x1,y2); y2++;}
  173.         }
  174.     y2=10;
  175.     for (i=0; i<=max_color; i++)
  176.         {set_color(i);
  177.         for (j=0; j<10; j++) {(*erase_line)(x1/2,y2,x1*4/3,y2); y2++;}
  178.         }
  179. /*                        intensity bars  */
  180.     y2=10;
  181.     for (intensity=0.; intensity<=1.; intensity+=.01)
  182.         {set_intensity(intensity);
  183.         (*draw_line)(x1+2,y2,pixels_wide-1,y2); y2++;
  184.         }
  185.     wait(); clear_graphics();
  186.  
  187.     finish_graphics();
  188. }
  189.  
  190. box(x1,y1,x2,y2) int x1,y1,x2,y2;
  191.     {(*draw_line)(x1,y1,x1,y2); (*draw_line)(x1,y2,x2,y2); 
  192.     (*draw_line)(x2,y2,x2,y1); (*draw_line)(x2,y1,x1,y1);
  193.     }
  194.  
  195. rectangle(size) double size;
  196. {    int x1,y1,x2,y2,i;
  197.  
  198.     x2=size*pixels_wide*best_height-1; x1=x2/2;
  199.     y2=size*pixels_high*best_width-1; y1=y2/2;
  200.     for (i=0; i<40; i++) {(*draw_line)(x1,y1,0,(i*y2)/40);}
  201.     for (i=0; i<40; i++) {(*draw_line)(x1,y1,(i*x2)/40,y2);}
  202.     for (i=40; i>0; i--) {(*draw_line)(x1,y1,x2,(i*y2)/40);}
  203.     for (i=40; i>0; i--) {(*draw_line)(x1,y1,(i*x2)/40,0);}
  204.     for (i=0; i<40; i++) {(*erase_line)(x1,y1,0,(i*y2)/40);}
  205.     for (i=0; i<40; i++) {(*erase_line)(x1,y1,(i*x2)/40,y2);}
  206.     for (i=40; i>0; i--) {(*erase_line)(x1,y1,x2,(i*y2)/40);}
  207.     for (i=40; i>0; i--) {(*erase_line)(x1,y1,(i*x2)/40,0);}
  208. }
  209.  
  210. rectangles()
  211. {    int x1,x2,y1,y2,w1,w2;
  212. /*                        drawing a rectangle    */
  213.     if(!no_characters) gotoxy(0,char_rows-1);
  214.     puts("lines in different \ndirections symmetric?");
  215.     x1=pixels_wide/4; y1=pixels_high/4;
  216.     w1=w2=0;
  217.     while(w2<pixels_high/2)    {(*draw_line)(x1,y1,w1,w2); w2+=5;} y2=w2;
  218.     while(w1<pixels_wide/2)    {(*draw_line)(x1,y1,w1,w2); w1+=5;}
  219.     while(w2>0)             {(*draw_line)(x1,y1,w1,w2); w2-=5;}
  220.     while(w1>0)             {(*draw_line)(x1,y1,w1,w2); w1-=5;}
  221. /*                        erasing a rectangle    */
  222.     set_intensity(1.);
  223.     x1=pixels_wide/2; x2=pixels_wide-1;
  224.     for(y1=0; y1<y2; y1++) draw_line(x1,y1,x2,y1);
  225.     x1=pixels_wide/4*3; y1=pixels_high/4;
  226.     x2=pixels_wide-1; y2=0;
  227.     while(y2<pixels_high/2)    {(*erase_line)(x1,y1,x2,y2); y2+=5;}
  228.     while(x2>pixels_wide/2)    {(*erase_line)(x1,y1,x2,y2); x2-=5;}
  229.     while(y2>0)                {(*erase_line)(x1,y1,x2,y2); y2-=5;}
  230.     while(x2<pixels_wide-1)    {(*erase_line)(x1,y1,x2,y2); x2+=5;}
  231. }
  232.  
  233. timed_squares()
  234. {    int i,x1,x2,y1,y2;
  235.  
  236.     t1=tics();
  237.     x2=pixels_wide*best_height-1; x1=x2/2;
  238.     y2=pixels_high*best_width-1; y1=y2/2;
  239.     for (i=0; i<40; i++) {(*draw_line)(x1,y1,0,(i*y2)/40);}
  240.     for (i=0; i<40; i++) {(*draw_line)(x1,y1,(i*x2)/40,y2);}
  241.     for (i=40; i>0; i--) {(*draw_line)(x1,y1,x2,(i*y2)/40);}
  242.     for (i=40; i>0; i--) {(*draw_line)(x1,y1,(i*x2)/40,0);}
  243.     for (i=0; i<40; i++) {(*erase_line)(x1,y1,0,(i*y2)/40);}
  244.     for (i=0; i<40; i++) {(*erase_line)(x1,y1,(i*x2)/40,y2);}
  245.     for (i=40; i>0; i--) {(*erase_line)(x1,y1,x2,(i*y2)/40);}
  246.     for (i=40; i>0; i--) {(*erase_line)(x1,y1,(i*x2)/40,0);}
  247.     t2=tics();
  248.     x2=x2/10; x1=x2/2;
  249.     y2=y2/10; y1=y2/2;
  250.     for (i=0; i<40; i++) {(*draw_line)(x1,y1,0,(i*y2)/40);}
  251.     for (i=0; i<40; i++) {(*draw_line)(x1,y1,(i*x2)/40,y2);}
  252.     for (i=40; i>0; i--) {(*draw_line)(x1,y1,x2,(i*y2)/40);}
  253.     for (i=40; i>0; i--) {(*draw_line)(x1,y1,(i*x2)/40,0);}
  254.     for (i=0; i<40; i++) {(*erase_line)(x1,y1,0,(i*y2)/40);}
  255.     for (i=0; i<40; i++) {(*erase_line)(x1,y1,(i*x2)/40,y2);}
  256.     for (i=40; i>0; i--) {(*erase_line)(x1,y1,x2,(i*y2)/40);}
  257.     for (i=40; i>0; i--) {(*erase_line)(x1,y1,(i*x2)/40,0);}
  258.     t3=tics();
  259. }
  260. wait()
  261. {    char c;
  262.     c=getchar();
  263.     if((c=='q')|(c=='x')) {finish_graphics(); exit();}
  264. }
  265.  
  266. getint(s) char *s;
  267. {    int x,i;
  268.     char buffer[128],c;
  269.  
  270.     puts(s); gets(buffer);
  271.     x=0; i=0;
  272.     while(c=buffer[i++]) x=x*10+c-'0';
  273.     return x;
  274. }
  275.  
  276. /*                            dummy routines        */
  277. /*
  278. mode(x) int x;
  279. {
  280. }
  281. pixel_insert(i,j) int i,j;
  282. {    printf("inserting pixel at address %d with mask %d \n",i,j);
  283.     wait();
  284. }
  285. byte_insert(i,j) int i,j;
  286. {    printf("inserting byte %d at address %d \n",j,i);
  287.     wait();
  288. }
  289. */
  290. /*
  291.     tics - report hundreths of a second since midnight
  292. */
  293.  
  294. long tics()  /*    seconds since last call    */
  295. {    int hr,min,sec,hun;
  296.  
  297.     _timer(&hr,&min,&sec,&hun);
  298.     return (( (long) hr*60+min)*60+sec)*100+hun;
  299. }
  300.  
  301. _timer()
  302. {
  303. #asm
  304.     mov    ah,2ch
  305.     int    21h
  306.     mov    bx,[bp+4]
  307.     mov    [bx],ch        ;hours
  308.     mov    byte [bx+1],0
  309.     mov    bx,[bp+6]
  310.     mov    [bx],cl        ;minutes
  311.     mov    byte [bx+1],0
  312.     mov    bx,[bp+8]
  313.     mov    [bx],dh        ;seconds
  314.     mov    byte [bx+1],0
  315.     mov    bx,[bp+10]
  316.     mov    [bx],dl        ;hundreths
  317.     mov    byte [bx+1],0
  318. #endasm
  319. }
  320.  
  321. #define FIRST_OPTION 1  /* first "dash option", where 0 is program name */
  322. initialize_parameters(argc,argv) int argc; char **argv;
  323. {    int i;
  324. /*    file; */
  325.  
  326.     if(argc>1 && strcmp(argv[1],"?")==0)
  327.         {printf("sample usage...\nbench  [options]\n");
  328.         printf("options are:\n");
  329.         printf("-c   omit calls to character functions \n");
  330.         exit();
  331.         }
  332. /*    file=fopen(argv[1],"r");
  333.     if(file==-1){puts("file %s not found\n",argv[1]); exit();}
  334. */
  335.     argc=argc-FIRST_OPTION; argv=argv+FIRST_OPTION;
  336.     while(argc>0)
  337.         {/* printf("read_data: parsing \"%s\" \n",*argv); */
  338.         i=get_parameter(argc,argv);
  339.         argv=argv+i; argc=argc-i;
  340.         }
  341. }
  342.  
  343. /* get_parameter - process one command line option
  344.         (return # parameters used) */
  345. get_parameter(argc,argv) int argc; char **argv;
  346. {    if(streq(*argv,"-c")) {no_characters=1; return 1;}
  347.     else gripe(argv);
  348. }
  349.  
  350. int streq(a,b) char *a,*b;
  351. {    while(*a)
  352.         {if(*a!=*b)return 0;
  353.         a++; b++;
  354.         }
  355.     return 1;
  356. }
  357.  
  358. gripe(argv) char **argv;
  359. {    puts(*argv); puts(" isn\'t a legal argument \n");
  360.     exit();
  361. }
  362.