开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
distrib.c
资源名称：mrtg-2.13.2.zip　[点击查看]
上传用户：shbosideng
上传日期：2013-05-04
资源大小：1555k
文件大小：20k
源码类别：

SNMP编程

开发平台：

C/C++

distrib.c：源码内容
  1. /****************************************************************/
  2. /*                                                              */
  3. /* distrib.c (see readme.html for program explanation)          */
  4. /*                                                              */
  5. /* author : Philippe Simonet, Philippe.Simonet@swiisstelecom.com*/
  6. /*                                                              */
  7. /* change log :                                                 */
  8. /*                                                              */
  9. /* v. 1.00 : initial update (SIP) (23.06.97)                    */
  10. /*                                                              */
  11. /*                                                              */
  12. /*                                                              */
  15. /************************************************************************/
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <stdlib.h>
  19. #include <malloc.h>
  20. #include <time.h>
  21. #include "gd.h"
  22. #include "gdfonts.h"
  24. #define FALSE 0
  25. #define TRUE 1
  27. #define TEXT 1
  28. #define RECT 2
  29. #define POLY 3
  30. #define COLOR 4
  31. #define COLORDEF 5
  32. #define LINK 6
  33. #define COMPOUND 7
  34. #define ENDCOMPOUND 8
  35. #define GIFAREA 9
  36. #define URL 10
  37. #define IN 11
  38. #define OUT 12
  39. #define INOUT 13
  40. #define UNKNOWN 99
  43. #ifndef max
  44.  #define max(a,b) ((a)>(b))?(a):(b)
  45. #endif
  47. #ifndef min
  48.  #define min(a,b) ((a)<(b))?(a):(b)
  49. #endif
  51. int distcount;
  52. int xsize, ysize, rounds, rate;
  53. int dist[1000][2];
  55. /************************************************************************/
  56. /* analyze command-line options */
  57. static int optind = 0;  /* Global argv index.  */
  58. static char *scan = NULL;   /* Private scan pointer. */
  59. static int scale = 15;
  61. int getopt1( int argc, char *argv[], char *optstring, char ** optarg )
  62. {
  63.     int  c; /* return value */
  64.     char  *place;
  65.     char     *index();
  67.     *optarg = NULL;
  69. /* check argument validity */
  70.     if (scan == NULL || *scan == '') {
  71.         if (optind == 0) optind++;
  72.         if (optind >= argc) return EOF;
  73.         place = argv[optind];
  74.         if (place[0] != '-' || place[1] == '') return EOF;
  75.         optind++;
  76.         if (place[1] == '-' && place[2] == '') return EOF;
  77.         scan = place+1;
  78.     }
  80.     c = *scan++; /* get option character */
  81.     place = strchr(optstring, c);
  82.     if (place == NULL || c == ':') return '?';
  85. /* set optarg if needed */
  86.     if (*++place == ':') {
  87.         if (*scan != '') {
  88.          *optarg = scan; scan = NULL;
  89.         } else {
  90.          *optarg = argv[optind], optind++;
  91.         }
  92.     }
  93.     return c;
  94. }
  96. /************************************************************************/
  97. void computes_distrib ( FILE * fi, int length, int nb, unsigned int maxbytes ) {
  98. int i,j;
  99. unsigned long time, in, out, maxin, maxout;
  101. for ( i = 0; i < length; i ++ ) {
  102. in = 0; out = 0; 
  104. /* compute mean on 'nb' items */
  105. for (j = 0; j < nb; j ++ ) {
  106. unsigned long wi, wo;
  108. if (fscanf(fi,"%lu %lu %lu %lu %lun",&time,&wi,&wo,&maxin, &maxout) != 5) {
  109. printf ( "config file error !!!n" );
  110. } else {
  111. in += wi; out += wo;
  112. }
  113. }
  115. in /= nb; out /= nb;
  117. if ( in  >= maxbytes ) in  = maxbytes-1;
  118. if ( out >= maxbytes ) out = maxbytes-1;
  120. dist[(( in*distcount)/maxbytes)][0] ++;
  121. dist[((out*distcount)/maxbytes)][1] ++;
  122. }
  124. };
  126. /************************************************************************/
  127. /* in case of trouble ...                                               */
  128. void print_error ( void )
  129. { 
  130. fprintf ( stderr, "Read mrtg log files and build distribution graphs.n" );
  131. fprintf ( stderr, "Version 1.1, 27.06.97.n" );
  132. fprintf ( stderr, "Use : case 1 : (1 distr. log file)n" );
  133. fprintf ( stderr, "  distrib -i logfile -o gfile -w width -h height -t type -r rate -d countn" );
  134. fprintf ( stderr, "   ifile : input log file name,n" );
  135. fprintf ( stderr, "   gfile : output gif file (will be overwritten),n" );
  136. fprintf ( stderr, "   count : histogram count,n" );
  137. fprintf ( stderr, "   rate : line rate,n" );
  138. fprintf ( stderr, "   type : length of measurement (d/w/m/y).n" );
  139. fprintf ( stderr, "Use : case 2 : (distr. from distrib. file)n" );
  140. fprintf ( stderr, "  distrib -i distrib -o gfile -w width -h height -t x -r top -d countn" );
  141. fprintf ( stderr, "   ifile : input distribution summary file name,n" );
  142. fprintf ( stderr, "   gfile : output gif file (will be overwritten),n" );
  143. fprintf ( stderr, "   top : how may top n,n" );
  144. fprintf ( stderr, "   count : histogram count,n" );
  145. fprintf ( stderr, "   type : 'x'.n" );
  146. }
  148. /************************************************************************/
  149. #define r(color) ((color&0x0000ff)>>0)
  150. #define g(color) ((color&0x00ff00)>>8)
  151. #define b(color) ((color&0xff0000)>>16)
  152. #define rgb(color) ((color&0x0000ff)>>0),((color&0x00ff00)>>8),((color&0xff0000)>>16)
  154. /************************************************************************/
  155. /* build a color or find the nearest color in the color table           */ 
  156. int find_color ( gdImagePtr graph, int color ) {
  157. int i_col;
  159. if ( (i_col = gdImageColorExact(graph,r(color), g(color), b(color))) == -1 ) {
  160. if ( (i_col = gdImageColorAllocate(graph,r(color), g(color), b(color))) == -1 ) {
  161. i_col = gdImageColorClosest(graph,r(color), g(color), b(color));
  162. }
  163. }
  164. return (i_col);
  165. }
  168. /************************************************************************/
  169. /* draw the gif file */
  170. void draw_distrib_gif ( FILE * score, FILE * gif )
  171. {
  172. #define c_blank 245,245,245 /* base colors */
  173. #define c_light 194,194,194
  174. #define c_dark 100,100,100
  175. #define c_black 0,0,0
  176. #define c_white 255,255,0
  177. #define c_blue 0,0,255
  178. #define c_red 255,0,0
  179. #define c_green 0,255,0
  181.     gdImagePtr graph;
  182. int i_light,i_dark,i_blank, i_black, i_white, i_blue, i_red, i_green;
  183. int color[4000][2];
  185.     graph = gdImageCreate(xsize, ysize);
  187.     /* the first color allocated will be the background color. */
  189.     i_blank = gdImageColorAllocate(graph,c_blank);
  190.     i_light = gdImageColorAllocate(graph,c_light);
  191.     i_dark = gdImageColorAllocate(graph,c_dark);
  193.     gdImageInterlace(graph, 1); 
  195.     i_black = gdImageColorAllocate(graph,c_black);
  196.     i_white = gdImageColorAllocate(graph,c_white);
  197.     i_red = gdImageColorAllocate(graph,c_red);
  198.     i_green = gdImageColorAllocate(graph,c_green);
  199.     i_blue = gdImageColorAllocate(graph,c_blue);
  202. { 
  203. int i;
  204. for (i = 0; i <= distcount; i++ ) {
  205. color[distcount - i - 1][0] = gdImageColorAllocate(graph, (255*i)/distcount, 255, (255*i)/distcount);
  206. }
  207. for (i = 0; i <= distcount; i++ ) {
  208. color[distcount - i - 1][1] = gdImageColorAllocate(graph, (255*i)/distcount, (255*i)/distcount, 255);
  209. }
  210. }
  213.     /* draw the image border */
  214.     gdImageLine(graph,0,0,xsize-1,0,i_light);
  215.     gdImageLine(graph,1,1,xsize-2,1,i_light);
  216.     gdImageLine(graph,0,0,0,ysize-1,i_light);
  217.     gdImageLine(graph,1,1,1,ysize-2,i_light);
  218.     gdImageLine(graph,xsize-1,0,xsize-1,ysize-1,i_dark);
  219.     gdImageLine(graph,0,ysize-1,xsize-1,ysize-1,i_dark);
  220.     gdImageLine(graph,xsize-2,1,xsize-2,ysize-2,i_dark);
  221.     gdImageLine(graph,1,ysize-2,xsize-2,ysize-2,i_dark);
  223. { /* date the graph */
  224. struct tm *newtime;
  225. time_t aclock;
  226. time( &aclock ); /* Get time in seconds */
  227. newtime = localtime( &aclock ); /* Convert time to struct */
  228. /* tm form */
  230. gdImageString(graph, gdFontSmall,gdFontSmall->w,3,asctime( newtime ),i_dark);
  231. };
  234. /*i_col = find_color(graph, colortable[pcurrententry->color]);
  235.       gdImageFilledRectangle(graph,
  236. pcurrententry->coords[0],
  237. pcurrententry->coords[1],
  238. pcurrententry->coords[2],
  239. pcurrententry->coords[3],i_col2);
  240.  }
  241. gdImageString(graph, gdFontSmall,
  242. pcurrententry->coords[0],
  243. pcurrententry->coords[1],
  244. pcurrententry->str,
  245. i_col );
  246. gdImageStringUp(graph, gdFontSmall,
  247. pcurrententry->coords[0],
  248. pcurrententry->coords[1],
  249. pcurrententry->str,
  250. i_col );
  253.    gdImagePtr brush_2pix;
  254.     brush_2pix = gdImageCreate(2,2);
  255. gdImageColorAllocate(
  256. brush_2pix,
  257. r(colortable[colorratetable[pcurrententry->rate]]),
  258. g(colortable[colorratetable[pcurrententry->rate]]),
  259. b(colortable[colorratetable[pcurrententry->rate]]) );
  260. gdImageSetBrush(graph, brush_2pix);
  261. i_col = gdBrushed;
  262. gdImageLine(graph, x, y, x2, y2,i_col);
  263.     gdImageDestroy(brush_2pix);*/
  265. /* draw axes and graphs */
  266. {
  267. int w = gdFontSmall->w, h = gdFontSmall->h, i, j, k, incrx, incry;
  268. char str[4000];
  269. int nbaxesx = (rate + 1);
  270. int nbaxesy = 6;
  271. int textx = 7;
  272. int texty = 15;
  274. incry = (ysize-(h*2)-(w*texty))/(nbaxesy-1); 
  275. incrx = (xsize-(w*(textx+2)))/(nbaxesx-1);
  276. j = 100;
  277. for ( i = h*2; i <= ((h*2) + (incry * (nbaxesy-1))) ; i+= incry ) {
  278. gdImageLine(graph,w*textx,i,w*textx + (incrx*(nbaxesx-1)),i,i_black); /* horizontal */
  279. sprintf ( str, "%3u%%", j ); j-= 100/(nbaxesy-1);
  280. gdImageString(graph, gdFontSmall,w,i-h/2,str,i_black );
  281. }
  282. j = 0;
  283. for ( i = w*7; i <= ((w*7) + (incrx * (nbaxesx-1))) ; i+= incrx ) {
  284. /*gdImageLine(graph,i,h*2,i,h*2 + (incry*(AXESY-1)),i_black);*/ /* vertical */
  285. /*sprintf ( str, "%3u%%", j ); j+= (100/(AXESX-1));
  286. gdImageStringUp(graph, gdFontSmall, i - w/2, ysize - h, str, i_black );*/
  287. }
  290. for ( i = 0; i < rate; i ++ ) {
  291. char *name,*ptr;
  292. int tin=0, tout=0;
  293. int x1, x2, y1, y2, mrgx;
  295. if ( fscanf ( score, "%s", str ) == EOF ) break;
  296. /*printf ( "%sn", str );*/
  297. name = str;
  299. if ((ptr = strtok( str, ":")) == NULL) continue;
  300. /*printf ( "%s:", name );*/
  302. for ( j = 0; j < distcount; j++ ) {
  304. dist[j][0] = dist[j][0] = 0;
  306. if ((ptr = strtok( NULL, "/,")) == NULL) continue;
  307. dist[j][0] = atoi(ptr); tin += dist[j][0];
  309. if ((ptr = strtok( NULL, "/,")) == NULL) continue;
  310. dist[j][1] = atoi(ptr); tout += dist[j][1];
  312. /*printf ( "%u/%u,",dist[j][0],dist[j][1]  );*/
  313. }
  315. /*printf ( "n" );*/
  317. /* draw label and graphs */
  318. mrgx = incrx/5;
  319. x1 = (w*textx) + (i*incrx) + (incrx/2) - (h/2);
  320. y1 = ysize-h;
  321. gdImageStringUp( graph, gdFontSmall, x1, y1, str, i_black );
  322. for (k = 0; k < 2; k ++ ) {
  323. y1 = ysize-((texty-4) * w);
  324. if ( k == 0 ) {
  325. x1 = (w*textx) + (i*incrx) + mrgx;
  326. x2 = x1 + (incrx/3);
  327. gdImageStringUp( graph, gdFontSmall, x1, y1, "in", i_black );
  328. } else {
  329. x2 = (w*textx) + ((i+1)*incrx) - mrgx;
  330. x1 = x2 - (incrx/3);
  331. gdImageStringUp( graph, gdFontSmall, x1, y1, "out", i_black );
  332. }
  334. y2 = h*2 + (incry*(nbaxesy-1));
  335. for ( j = distcount-1; j >=0 ; j-- ) {
  336. y1 = y2 - (((ysize-(h*2)-(w*texty) - 2) * dist[j][k]) / tin);
  337. if (j == 0) { /* 'correct' cumulative error */
  338. y1 = h*2;
  339. }
  340. gdImageFilledRectangle(graph, x1, y1, x2, y2,color[j][k]);
  341. gdImageRectangle(graph, x1, y1, x2, y2,i_black);
  342. y2 = y1;
  343. }
  344. }
  346. /*
  348. int x1, x2, y1, y2, mrgx;
  349. mrgx = incrx/5;
  351. x1 = (w*7) + (i*incrx) + mrgx;
  352. x2 = x1 + (incrx/3);
  353. y2 = h*2 + (incry*(AXESY-1)) - 2;
  354. y1 = y2 - (((ysize-(h*2)-(w*7) - 2) * dist[i][0]) / rounds);
  355. gdImageFilledRectangle(graph, x1, y1, x2, y2,i_green);
  356. gdImageRectangle(graph, x1, y1, x2, y2,i_dark);
  358. x2 = (w*7) + ((i+1)*incrx) - mrgx;
  359. x1 = x2 - (incrx/3);
  360. y2 = h*2 + (incry*(AXESY-1)) - 2;
  361. y1 = y2 - (((ysize-(h*2)-(w*7) - 2) * dist[i][1]) / rounds);
  362. gdImageFilledRectangle(graph, x1, y1, x2, y2,i_blue);
  363. gdImageRectangle(graph, x1, y1, x2, y2,i_dark);
  364. */
  365. }
  366. }
  369.     gdImageGif(graph, gif);    
  371.     gdImageDestroy(graph);
  372. }
  375. /************************************************************************/
  376. /* draw the gif file, based on the tentry desciption                    */
  377. void draw_gif ( FILE * gif )
  378. {
  379. #define c_blank 245,245,245 /* base colors */
  380. #define c_light 194,194,194
  381. #define c_dark 100,100,100
  382. #define c_black 0,0,0
  383. #define c_white 255,255,0
  384. #define c_blue 0,0,255
  385. #define c_red 255,0,0
  386. #define c_green 0,255,0
  388.     gdImagePtr graph;
  389. int i_light,i_dark,i_blank, i_black, i_white, i_blue, i_red, i_green;
  391.     graph = gdImageCreate(xsize, ysize);
  393.     /* the first color allocated will be the background color. */
  394.     i_blank = gdImageColorAllocate(graph,c_blank);
  395.     i_light = gdImageColorAllocate(graph,c_light);
  396.     i_dark = gdImageColorAllocate(graph,c_dark);
  398.     gdImageInterlace(graph, 1); 
  400.     i_black = gdImageColorAllocate(graph,c_black);
  401.     i_white = gdImageColorAllocate(graph,c_white);
  402.     i_red = gdImageColorAllocate(graph,c_red);
  403.     i_green = gdImageColorAllocate(graph,c_green);
  404.     i_blue = gdImageColorAllocate(graph,c_blue);
  406.     /* draw the image border */
  407.     gdImageLine(graph,0,0,xsize-1,0,i_light);
  408.     gdImageLine(graph,1,1,xsize-2,1,i_light);
  409.     gdImageLine(graph,0,0,0,ysize-1,i_light);
  410.     gdImageLine(graph,1,1,1,ysize-2,i_light);
  411.     gdImageLine(graph,xsize-1,0,xsize-1,ysize-1,i_dark);
  412.     gdImageLine(graph,0,ysize-1,xsize-1,ysize-1,i_dark);
  413.     gdImageLine(graph,xsize-2,1,xsize-2,ysize-2,i_dark);
  414.     gdImageLine(graph,1,ysize-2,xsize-2,ysize-2,i_dark);
  416. { /* date the graph */
  417. struct tm *newtime;
  418. time_t aclock;
  419. time( &aclock ); /* Get time in seconds */
  420. newtime = localtime( &aclock ); /* Convert time to struct */
  421. /* tm form */
  423. gdImageString(graph, gdFontSmall,gdFontSmall->w,3,asctime( newtime ),i_dark);
  424. };
  427. /*i_col = find_color(graph, colortable[pcurrententry->color]);
  428.       gdImageFilledRectangle(graph,
  429. pcurrententry->coords[0],
  430. pcurrententry->coords[1],
  431. pcurrententry->coords[2],
  432. pcurrententry->coords[3],i_col2);
  433.  }
  434. gdImageString(graph, gdFontSmall,
  435. pcurrententry->coords[0],
  436. pcurrententry->coords[1],
  437. pcurrententry->str,
  438. i_col );
  439. gdImageStringUp(graph, gdFontSmall,
  440. pcurrententry->coords[0],
  441. pcurrententry->coords[1],
  442. pcurrententry->str,
  443. i_col );
  446.    gdImagePtr brush_2pix;
  447.     brush_2pix = gdImageCreate(2,2);
  448. gdImageColorAllocate(
  449. brush_2pix,
  450. r(colortable[colorratetable[pcurrententry->rate]]),
  451. g(colortable[colorratetable[pcurrententry->rate]]),
  452. b(colortable[colorratetable[pcurrententry->rate]]) );
  453. gdImageSetBrush(graph, brush_2pix);
  454. i_col = gdBrushed;
  455. gdImageLine(graph, x, y, x2, y2,i_col);
  456.     gdImageDestroy(brush_2pix);*/
  458. /* draw axes and graphs */
  459. {
  460. int w = gdFontSmall->w, h = gdFontSmall->h, i, j, incrx, incry, maxio;
  461. char str[20];
  462. #define AXESX (distcount + 1)
  463. #define AXESY 6
  465. maxio = 0;
  466. for ( i = 0; i < distcount; i ++ ) {
  467. if (maxio < dist[i][0]) maxio = dist[i][0];
  468. if (maxio < dist[i][1]) maxio = dist[i][1];
  469. }
  471. incry = (ysize-(h*2)-(w*7))/(AXESY-1); incrx = (xsize-(w*9))/(AXESX-1);
  472. j = 100;
  473. for ( i = h*2; i <= ((h*2) + (incry * (AXESY-1))) ; i+= incry ) {
  474. gdImageLine(graph,w*7,i,w*7 + (incrx*(AXESX-1)),i,i_black); /* horizontal */
  475. sprintf ( str, "%3u%%", j ); j-= 100/(AXESY-1);
  476. gdImageString(graph, gdFontSmall,w,i-h/2,str,i_black );
  477. }
  478. j = 0;
  479. for ( i = w*7; i <= ((w*7) + (incrx * (AXESX-1))) ; i+= incrx ) {
  480. gdImageLine(graph,i,h*2,i,h*2 + (incry*(AXESY-1)),i_black); /* vertical */
  481. sprintf ( str, "%3u%%", j ); j+= (100/(AXESX-1));
  482. gdImageStringUp(graph, gdFontSmall, i - w/2, ysize - h, str, i_black );
  483. }
  486. for ( i = 0; i < distcount; i ++ ) {
  487. int x1, x2, y1, y2, mrgx;
  488. mrgx = incrx/5;
  490. x1 = (w*7) + (i*incrx) + mrgx;
  491. x2 = x1 + (incrx/3);
  492. y2 = h*2 + (incry*(AXESY-1)) - 2;
  493. y1 = y2 - (((ysize-(h*2)-(w*7) - 2) * dist[i][0]) / rounds);
  494. /* printf ( "x1 %u, y1 %u, x2 %u, y2 %u.n", x1, y1, x2, y2 );*/
  495. gdImageFilledRectangle(graph, x1, y1, x2, y2,i_green);
  496. gdImageRectangle(graph, x1, y1, x2, y2,i_dark);
  498. x2 = (w*7) + ((i+1)*incrx) - mrgx;
  499. x1 = x2 - (incrx/3);
  500. y2 = h*2 + (incry*(AXESY-1)) - 2;
  501. y1 = y2 - (((ysize-(h*2)-(w*7) - 2) * dist[i][1]) / rounds);
  502. /* printf ( "x1 %u, y1 %u, x2 %u, y2 %u.n", x1, y1, x2, y2 );*/
  503. gdImageFilledRectangle(graph, x1, y1, x2, y2,i_blue);
  504. gdImageRectangle(graph, x1, y1, x2, y2,i_dark);
  505. }
  506. }
  508.     gdImageGif(graph, gif);    
  510.     gdImageDestroy(graph);
  511. }
  517. /************************************************************************/
  518. void main ( int argc, char * argv[] )
  519. {
  520. FILE *config = NULL, *gif = NULL;
  521. char  *sconfig = NULL, *sgif = NULL;
  522. char  *optarg;
  523. char type;
  524. int i; 
  526. /* globals */
  527. xsize = 400, ysize = 150; type = 'd'; rate = 1250000; distcount = 10;
  529. do {
  530. /***************************************************************/
  531. /* 0 : read program arguments */
  532. while ( ( i = getopt1( argc, argv, "o:i:t:w:h:r:d:", &optarg ) ) != EOF ) {
  533. switch ( i ) {
  534. case 'i':
  535. sconfig = optarg;
  536. break;
  537. case 'o':
  538. sgif = optarg;
  539. break;
  540. case 'w':
  541. if ( optarg != NULL ) { 
  542. xsize = atoi (optarg);
  543. }
  544. break;
  545. case 'r':
  546. if ( optarg != NULL ) { 
  547. rate = atoi (optarg);
  548. }
  549. break;
  550. case 'd':
  551. if ( optarg != NULL ) { 
  552. distcount = atoi (optarg);
  553. }
  554. break;
  555. case 'h':
  556. if ( optarg != NULL ) { 
  557. ysize = atoi (optarg);
  558. }
  559. break;
  560. case 't':
  561. if ( optarg != NULL ) type = optarg[0];
  563. if (type != 'd' && type != 'm' && type != 'w' && type != 'y' && type != 'x' ) {
  564. print_error();
  565. exit (0);
  566. }
  567. break;
  568. case '?':
  569. print_error();
  570. exit (0);
  571. break;
  572. default:
  573. break;
  574. }
  575. }
  578. if ( sgif == NULL || sconfig == NULL ) {
  579. print_error();
  580. break;
  581. }
  584. /***************************************************************/
  585. /* 1 : OPEN FILES */
  586. gif = fopen ( sgif, "wb" );
  587. if ( gif == NULL ) {
  588. fprintf ( stderr, "Error opening %s.n", sgif );
  589. fclose ( config );
  590. break;
  591. }
  593. config = fopen ( sconfig, "r" );
  594. if ( config == NULL ) {
  595. fprintf ( stderr, "Error opening %s.n", sconfig );
  596. break;
  597. }
  599. if ( type != 'x' ) {
  601. /***************************************************************/
  602. for ( i = 0; i < distcount; i ++ ) {
  603. dist[i][0] = 0; dist[i][1] = 0;
  604. }
  605. { /* read first line ... */
  606. unsigned long time, in, out;
  607. fscanf ( config, "%lu %lu %lun", &time, &in, &out ); /* read first line */
  608. }
  609. switch ( type ) {
  610. case 'd':
  611. computes_distrib ( config, 288,  1, rate );
  612. rounds = 288; /* 288 * 5' = 24 hours */
  613. break;
  614. case 'w':
  615. computes_distrib ( config, 100,  6, rate ); /* 600 * 5', with mean on 6  (30')*/
  616. computes_distrib ( config, 236,  1, rate );
  617. rounds = 336; /* 336 * 30' = 7 days */
  618. break;
  619. case 'm':
  620. computes_distrib ( config,  25, 24, rate ); /* 600 * 5', with mean on 24 (2hours) */
  621. computes_distrib ( config, 150,  4, rate ); /* 600 *30', with mean on 4 */
  622. computes_distrib ( config, 185,  1, rate );
  623. rounds = 360; /* 260 * 2 hours = 30 days */
  624. break;
  625. case 'y':
  626. computes_distrib ( config,   2,300, rate ); /* 600 * 5', with mean on 300  ~= 1 day */
  627. computes_distrib ( config,  12, 50, rate ); /* 600 *30', with mean on 50 ~= 1 day */
  628. computes_distrib ( config,  50, 12, rate ); /* 600 * 2h, with mean on 12 */
  629. computes_distrib ( config, 300,  1, rate );
  630. rounds = 364;
  631. break;
  632. }
  634. for ( i = 0; i < distcount; i ++ ) {
  635. printf ( "%u:%u,%u.n", i, dist[i][0],dist[i][1] );
  636. }
  638. /***************************************************************/
  639. draw_gif ( gif );
  640. /***************************************************************/
  641. fclose ( gif );
  642. fclose ( config );
  644. break;
  645. } else {
  646. draw_distrib_gif ( config, gif );
  647. fclose ( config );
  648. fclose ( gif );
  649. break;
  650. }
  652. } while ( TRUE );
  654. }