Code

prepare for the release of rrdtool-1.2.17
[rrdtool-all.git] / program / src / rrd_graph.c
1 /****************************************************************************
2  * RRDtool 1.2.17  Copyright by Tobi Oetiker, 1997-2006
3  ****************************************************************************
4  * rrd__graph.c  produce graphs from data in rrdfiles
5  ****************************************************************************/
8 #include <sys/stat.h>
10 #ifdef WIN32
11 #include "strftime.h"
12 #endif
13 #include "rrd_tool.h"
15 #if defined(WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
16 #include <io.h>
17 #include <fcntl.h>
18 #endif
20 #ifdef HAVE_TIME_H
21 #include <time.h>
22 #endif
24 #ifdef HAVE_LOCALE_H
25 #include <locale.h>
26 #endif
28 #include "rrd_graph.h"
30 /* some constant definitions */
34 #ifndef RRD_DEFAULT_FONT
35 /* there is special code later to pick Cour.ttf when running on windows */
36 #define RRD_DEFAULT_FONT "DejaVuSansMono-Roman.ttf"
37 #endif
39 text_prop_t text_prop[] = {   
40      { 8.0, RRD_DEFAULT_FONT }, /* default */
41      { 9.0, RRD_DEFAULT_FONT }, /* title */
42      { 7.0,  RRD_DEFAULT_FONT }, /* axis */
43      { 8.0, RRD_DEFAULT_FONT }, /* unit */
44      { 8.0, RRD_DEFAULT_FONT }  /* legend */
45 };
47 xlab_t xlab[] = {
48     {0,                 0,   TMT_SECOND,30, TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
49     {2,                 0,   TMT_MINUTE,1,  TMT_MINUTE,5,  TMT_MINUTE,5,         0,"%H:%M"},
50     {5,                 0,   TMT_MINUTE,2,  TMT_MINUTE,10, TMT_MINUTE,10,        0,"%H:%M"},
51     {10,                0,   TMT_MINUTE,5,  TMT_MINUTE,20, TMT_MINUTE,20,        0,"%H:%M"},
52     {30,                0,   TMT_MINUTE,10, TMT_HOUR,1,    TMT_HOUR,1,           0,"%H:%M"},
53     {60,                0,   TMT_MINUTE,30, TMT_HOUR,2,    TMT_HOUR,2,           0,"%H:%M"},
54     {60,          24*3600,   TMT_MINUTE,30, TMT_HOUR,2,    TMT_HOUR,4,           0,"%a %H:%M"},
55     {180,               0,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,6,           0,"%H:%M"},
56     {180,         24*3600,   TMT_HOUR,1,    TMT_HOUR,6,    TMT_HOUR,12,          0,"%a %H:%M"},
57     /*{300,             0,   TMT_HOUR,3,    TMT_HOUR,12,   TMT_HOUR,12,    12*3600,"%a %p"},  this looks silly*/
58     {600,               0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%a"},
59     {1200,              0,   TMT_HOUR,6,    TMT_DAY,1,     TMT_DAY,1,      24*3600,"%d"},
60     {1800,              0,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a %d"},
61     {2400,              0,   TMT_HOUR,12,   TMT_DAY,1,     TMT_DAY,2,      24*3600,"%a"},
62     {3600,              0,   TMT_DAY,1,     TMT_WEEK,1,    TMT_WEEK,1,   7*24*3600,"Week %V"},
63     {3*3600,            0,   TMT_WEEK,1,    TMT_MONTH,1,   TMT_WEEK,2,   7*24*3600,"Week %V"},
64     {6*3600,            0,   TMT_MONTH,1,   TMT_MONTH,1,   TMT_MONTH,1, 30*24*3600,"%b"},
65     {48*3600,           0,   TMT_MONTH,1,   TMT_MONTH,3,   TMT_MONTH,3, 30*24*3600,"%b"},
66     {315360,            0,   TMT_MONTH,3,   TMT_YEAR,1,    TMT_YEAR,1,  365*24*3600,"%Y"},
67     {10*24*3600,        0,   TMT_YEAR,1,  TMT_YEAR,1,    TMT_YEAR,1, 365*24*3600,"%y"},
68     {-1,0,TMT_MONTH,0,TMT_MONTH,0,TMT_MONTH,0,0,""}
69 };
71 /* sensible y label intervals ...*/
73 ylab_t ylab[]= {
74     {0.1, {1,2, 5,10}},
75     {0.2, {1,5,10,20}},
76     {0.5, {1,2, 4,10}},
77     {1.0,   {1,2, 5,10}},
78     {2.0,   {1,5,10,20}},
79     {5.0,   {1,2, 4,10}},
80     {10.0,  {1,2, 5,10}},
81     {20.0,  {1,5,10,20}},
82     {50.0,  {1,2, 4,10}},
83     {100.0, {1,2, 5,10}},
84     {200.0, {1,5,10,20}},
85     {500.0, {1,2, 4,10}},
86     {0.0,   {0,0,0,0}}};
89 gfx_color_t graph_col[] =   /* default colors */
90 {    0xFFFFFFFF,   /* canvas     */
91      0xF0F0F0FF,   /* background */
92      0xD0D0D0FF,   /* shade A    */
93      0xA0A0A0FF,   /* shade B    */
94      0x90909080,   /* grid       */
95      0xE0505080,   /* major grid */
96      0x000000FF,   /* font       */ 
97      0x802020FF,   /* arrow      */
98      0x202020FF,   /* axis       */
99      0x000000FF    /* frame      */ 
100 };     
103 /* #define DEBUG */
105 #ifdef DEBUG
106 # define DPRINT(x)    (void)(printf x, printf("\n"))
107 #else
108 # define DPRINT(x)
109 #endif
112 /* initialize with xtr(im,0); */
113 int
114 xtr(image_desc_t *im,time_t mytime){
115     static double pixie;
116     if (mytime==0){
117         pixie = (double) im->xsize / (double)(im->end - im->start);
118         return im->xorigin;
119     }
120     return (int)((double)im->xorigin 
121                  + pixie * ( mytime - im->start ) );
124 /* translate data values into y coordinates */
125 double
126 ytr(image_desc_t *im, double value){
127     static double pixie;
128     double yval;
129     if (isnan(value)){
130       if(!im->logarithmic)
131         pixie = (double) im->ysize / (im->maxval - im->minval);
132       else 
133         pixie = (double) im->ysize / (log10(im->maxval) - log10(im->minval));
134       yval = im->yorigin;
135     } else if(!im->logarithmic) {
136       yval = im->yorigin - pixie * (value - im->minval);
137     } else {
138       if (value < im->minval) {
139         yval = im->yorigin;
140       } else {
141         yval = im->yorigin - pixie * (log10(value) - log10(im->minval));
142       }
143     }
144     /* make sure we don't return anything too unreasonable. GD lib can
145        get terribly slow when drawing lines outside its scope. This is 
146        especially problematic in connection with the rigid option */
147     if (! im->rigid) {
148       /* keep yval as-is */
149     } else if (yval > im->yorigin) {
150       yval = im->yorigin +0.00001;
151     } else if (yval < im->yorigin - im->ysize){
152       yval = im->yorigin - im->ysize - 0.00001;
153     } 
154     return yval;
159 /* conversion function for symbolic entry names */
162 #define conv_if(VV,VVV) \
163    if (strcmp(#VV, string) == 0) return VVV ;
165 enum gf_en gf_conv(char *string){
166     
167     conv_if(PRINT,GF_PRINT)
168     conv_if(GPRINT,GF_GPRINT)
169     conv_if(COMMENT,GF_COMMENT)
170     conv_if(HRULE,GF_HRULE)
171     conv_if(VRULE,GF_VRULE)
172     conv_if(LINE,GF_LINE)
173     conv_if(AREA,GF_AREA)
174     conv_if(STACK,GF_STACK) 
175     conv_if(TICK,GF_TICK)
176     conv_if(DEF,GF_DEF)
177     conv_if(CDEF,GF_CDEF)
178     conv_if(VDEF,GF_VDEF)
179 #ifdef WITH_PIECHART
180     conv_if(PART,GF_PART)
181 #endif
182     conv_if(XPORT,GF_XPORT)
183     conv_if(SHIFT,GF_SHIFT)
184     
185     return (-1);
188 enum gfx_if_en if_conv(char *string){
189     
190     conv_if(PNG,IF_PNG)
191     conv_if(SVG,IF_SVG)
192     conv_if(EPS,IF_EPS)
193     conv_if(PDF,IF_PDF)
195     return (-1);
198 enum tmt_en tmt_conv(char *string){
200     conv_if(SECOND,TMT_SECOND)
201     conv_if(MINUTE,TMT_MINUTE)
202     conv_if(HOUR,TMT_HOUR)
203     conv_if(DAY,TMT_DAY)
204     conv_if(WEEK,TMT_WEEK)
205     conv_if(MONTH,TMT_MONTH)
206     conv_if(YEAR,TMT_YEAR)
207     return (-1);
210 enum grc_en grc_conv(char *string){
212     conv_if(BACK,GRC_BACK)
213     conv_if(CANVAS,GRC_CANVAS)
214     conv_if(SHADEA,GRC_SHADEA)
215     conv_if(SHADEB,GRC_SHADEB)
216     conv_if(GRID,GRC_GRID)
217     conv_if(MGRID,GRC_MGRID)
218     conv_if(FONT,GRC_FONT)
219     conv_if(ARROW,GRC_ARROW)
220     conv_if(AXIS,GRC_AXIS)
221     conv_if(FRAME,GRC_FRAME)
223     return -1;  
226 enum text_prop_en text_prop_conv(char *string){
227       
228     conv_if(DEFAULT,TEXT_PROP_DEFAULT)
229     conv_if(TITLE,TEXT_PROP_TITLE)
230     conv_if(AXIS,TEXT_PROP_AXIS)
231     conv_if(UNIT,TEXT_PROP_UNIT)
232     conv_if(LEGEND,TEXT_PROP_LEGEND)
233     return -1;
237 #undef conv_if
239 int
240 im_free(image_desc_t *im)
242     unsigned long       i,ii;
244     if (im == NULL) return 0;
245     for(i=0;i<(unsigned)im->gdes_c;i++){
246       if (im->gdes[i].data_first){
247         /* careful here, because a single pointer can occur several times */
248           free (im->gdes[i].data);
249           if (im->gdes[i].ds_namv){
250               for (ii=0;ii<im->gdes[i].ds_cnt;ii++)
251                   free(im->gdes[i].ds_namv[ii]);
252               free(im->gdes[i].ds_namv);
253           }
254       }
255       free (im->gdes[i].p_data);
256       free (im->gdes[i].rpnp);
257     }
258     free(im->gdes);
259     gfx_destroy(im->canvas);
260     return 0;
263 /* find SI magnitude symbol for the given number*/
264 void
265 auto_scale(
266            image_desc_t *im,   /* image description */
267            double *value,
268            char **symb_ptr,
269            double *magfact
270            )
272         
273     char *symbol[] = {"a", /* 10e-18 Atto */
274                       "f", /* 10e-15 Femto */
275                       "p", /* 10e-12 Pico */
276                       "n", /* 10e-9  Nano */
277                       "u", /* 10e-6  Micro */
278                       "m", /* 10e-3  Milli */
279                       " ", /* Base */
280                       "k", /* 10e3   Kilo */
281                       "M", /* 10e6   Mega */
282                       "G", /* 10e9   Giga */
283                       "T", /* 10e12  Tera */
284                       "P", /* 10e15  Peta */
285                       "E"};/* 10e18  Exa */
287     int symbcenter = 6;
288     int sindex;  
290     if (*value == 0.0 || isnan(*value) ) {
291         sindex = 0;
292         *magfact = 1.0;
293     } else {
294         sindex = floor(log(fabs(*value))/log((double)im->base)); 
295         *magfact = pow((double)im->base, (double)sindex);
296         (*value) /= (*magfact);
297     }
298     if ( sindex <= symbcenter && sindex >= -symbcenter) {
299         (*symb_ptr) = symbol[sindex+symbcenter];
300     }
301     else {
302         (*symb_ptr) = "?";
303     }
307 static char si_symbol[] = {
308                      'a', /* 10e-18 Atto */ 
309                      'f', /* 10e-15 Femto */
310                      'p', /* 10e-12 Pico */
311                      'n', /* 10e-9  Nano */
312                      'u', /* 10e-6  Micro */
313                      'm', /* 10e-3  Milli */
314                      ' ', /* Base */
315                      'k', /* 10e3   Kilo */
316                      'M', /* 10e6   Mega */
317                      'G', /* 10e9   Giga */
318                      'T', /* 10e12  Tera */
319                      'P', /* 10e15  Peta */
320                      'E', /* 10e18  Exa */
321 };
322 static const int si_symbcenter = 6;
324 /* find SI magnitude symbol for the numbers on the y-axis*/
325 void 
326 si_unit(
327     image_desc_t *im   /* image description */
331     double digits,viewdigits=0;  
332     
333     digits = floor( log( max( fabs(im->minval),fabs(im->maxval)))/log((double)im->base)); 
335     if (im->unitsexponent != 9999) {
336         /* unitsexponent = 9, 6, 3, 0, -3, -6, -9, etc */
337         viewdigits = floor(im->unitsexponent / 3);
338     } else {
339         viewdigits = digits;
340     }
342     im->magfact = pow((double)im->base , digits);
343     
344 #ifdef DEBUG
345     printf("digits %6.3f  im->magfact %6.3f\n",digits,im->magfact);
346 #endif
348     im->viewfactor = im->magfact / pow((double)im->base , viewdigits);
350     if ( ((viewdigits+si_symbcenter) < sizeof(si_symbol)) &&
351                     ((viewdigits+si_symbcenter) >= 0) )
352         im->symbol = si_symbol[(int)viewdigits+si_symbcenter];
353     else
354         im->symbol = '?';
355  }
357 /*  move min and max values around to become sensible */
359 void 
360 expand_range(image_desc_t *im)
362     double sensiblevalues[] ={1000.0,900.0,800.0,750.0,700.0,
363                               600.0,500.0,400.0,300.0,250.0,
364                               200.0,125.0,100.0,90.0,80.0,
365                               75.0,70.0,60.0,50.0,40.0,30.0,
366                               25.0,20.0,10.0,9.0,8.0,
367                               7.0,6.0,5.0,4.0,3.5,3.0,
368                               2.5,2.0,1.8,1.5,1.2,1.0,
369                               0.8,0.7,0.6,0.5,0.4,0.3,0.2,0.1,0.0,-1};
370     
371     double scaled_min,scaled_max;  
372     double adj;
373     int i;
374     
376     
377 #ifdef DEBUG
378     printf("Min: %6.2f Max: %6.2f MagFactor: %6.2f\n",
379            im->minval,im->maxval,im->magfact);
380 #endif
382     if (isnan(im->ygridstep)){
383         if(im->extra_flags & ALTAUTOSCALE) {
384             /* measure the amplitude of the function. Make sure that
385                graph boundaries are slightly higher then max/min vals
386                so we can see amplitude on the graph */
387               double delt, fact;
389               delt = im->maxval - im->minval;
390               adj = delt * 0.1;
391               fact = 2.0 * pow(10.0,
392                     floor(log10(max(fabs(im->minval), fabs(im->maxval))/im->magfact)) - 2);
393               if (delt < fact) {
394                 adj = (fact - delt) * 0.55;
395 #ifdef DEBUG
396               printf("Min: %6.2f Max: %6.2f delt: %6.2f fact: %6.2f adj: %6.2f\n", im->minval, im->maxval, delt, fact, adj);
397 #endif
398               }
399               im->minval -= adj;
400               im->maxval += adj;
401         }
402         else if(im->extra_flags & ALTAUTOSCALE_MAX) {
403             /* measure the amplitude of the function. Make sure that
404                graph boundaries are slightly higher than max vals
405                so we can see amplitude on the graph */
406               adj = (im->maxval - im->minval) * 0.1;
407               im->maxval += adj;
408         }
409         else {
410             scaled_min = im->minval / im->magfact;
411             scaled_max = im->maxval / im->magfact;
412             
413             for (i=1; sensiblevalues[i] > 0; i++){
414                 if (sensiblevalues[i-1]>=scaled_min &&
415                     sensiblevalues[i]<=scaled_min)      
416                     im->minval = sensiblevalues[i]*(im->magfact);
417                 
418                 if (-sensiblevalues[i-1]<=scaled_min &&
419                 -sensiblevalues[i]>=scaled_min)
420                     im->minval = -sensiblevalues[i-1]*(im->magfact);
421                 
422                 if (sensiblevalues[i-1] >= scaled_max &&
423                     sensiblevalues[i] <= scaled_max)
424                     im->maxval = sensiblevalues[i-1]*(im->magfact);
425                 
426                 if (-sensiblevalues[i-1]<=scaled_max &&
427                     -sensiblevalues[i] >=scaled_max)
428                     im->maxval = -sensiblevalues[i]*(im->magfact);
429             }
430         }
431     } else {
432         /* adjust min and max to the grid definition if there is one */
433         im->minval = (double)im->ylabfact * im->ygridstep * 
434             floor(im->minval / ((double)im->ylabfact * im->ygridstep));
435         im->maxval = (double)im->ylabfact * im->ygridstep * 
436             ceil(im->maxval /( (double)im->ylabfact * im->ygridstep));
437     }
438     
439 #ifdef DEBUG
440     fprintf(stderr,"SCALED Min: %6.2f Max: %6.2f Factor: %6.2f\n",
441            im->minval,im->maxval,im->magfact);
442 #endif
445 void
446 apply_gridfit(image_desc_t *im)
448   if (isnan(im->minval) || isnan(im->maxval))
449     return;
450   ytr(im,DNAN);
451   if (im->logarithmic) {
452     double ya, yb, ypix, ypixfrac;
453     double log10_range = log10(im->maxval) - log10(im->minval);
454     ya = pow((double)10, floor(log10(im->minval)));
455     while (ya < im->minval)
456       ya *= 10;
457     if (ya > im->maxval)
458       return; /* don't have y=10^x gridline */
459     yb = ya * 10;
460     if (yb <= im->maxval) {
461       /* we have at least 2 y=10^x gridlines.
462          Make sure distance between them in pixels
463          are an integer by expanding im->maxval */
464       double y_pixel_delta = ytr(im, ya) - ytr(im, yb);
465       double factor = y_pixel_delta / floor(y_pixel_delta);
466       double new_log10_range = factor * log10_range;
467       double new_ymax_log10 = log10(im->minval) + new_log10_range;
468       im->maxval = pow(10, new_ymax_log10);
469       ytr(im,DNAN); /* reset precalc */
470       log10_range = log10(im->maxval) - log10(im->minval);
471     }
472     /* make sure first y=10^x gridline is located on 
473        integer pixel position by moving scale slightly 
474        downwards (sub-pixel movement) */
475     ypix = ytr(im, ya) + im->ysize; /* add im->ysize so it always is positive */
476     ypixfrac = ypix - floor(ypix);
477     if (ypixfrac > 0 && ypixfrac < 1) {
478       double yfrac = ypixfrac / im->ysize;
479       im->minval = pow(10, log10(im->minval) - yfrac * log10_range);
480       im->maxval = pow(10, log10(im->maxval) - yfrac * log10_range);
481       ytr(im,DNAN); /* reset precalc */
482     }
483   } else {
484     /* Make sure we have an integer pixel distance between
485        each minor gridline */
486     double ypos1 = ytr(im, im->minval);
487     double ypos2 = ytr(im, im->minval + im->ygrid_scale.gridstep);
488     double y_pixel_delta = ypos1 - ypos2;
489     double factor = y_pixel_delta / floor(y_pixel_delta);
490     double new_range = factor * (im->maxval - im->minval);
491     double gridstep = im->ygrid_scale.gridstep;
492     double minor_y, minor_y_px, minor_y_px_frac;
493     im->maxval = im->minval + new_range;
494     ytr(im,DNAN); /* reset precalc */
495     /* make sure first minor gridline is on integer pixel y coord */
496     minor_y = gridstep * floor(im->minval / gridstep);
497     while (minor_y < im->minval)
498       minor_y += gridstep;
499     minor_y_px = ytr(im, minor_y) + im->ysize; /* ensure > 0 by adding ysize */
500     minor_y_px_frac = minor_y_px - floor(minor_y_px);
501     if (minor_y_px_frac > 0 && minor_y_px_frac < 1) {
502       double yfrac = minor_y_px_frac / im->ysize;
503       double range = im->maxval - im->minval;
504       im->minval = im->minval - yfrac * range;
505       im->maxval = im->maxval - yfrac * range;
506       ytr(im,DNAN); /* reset precalc */
507     }
508     calc_horizontal_grid(im); /* recalc with changed im->maxval */
509   }
512 /* reduce data reimplementation by Alex */
514 void
515 reduce_data(
516     enum cf_en     cf,         /* which consolidation function ?*/
517     unsigned long  cur_step,   /* step the data currently is in */
518     time_t         *start,     /* start, end and step as requested ... */
519     time_t         *end,       /* ... by the application will be   ... */
520     unsigned long  *step,      /* ... adjusted to represent reality    */
521     unsigned long  *ds_cnt,    /* number of data sources in file */
522     rrd_value_t    **data)     /* two dimensional array containing the data */
524     int i,reduce_factor = ceil((double)(*step) / (double)cur_step);
525     unsigned long col,dst_row,row_cnt,start_offset,end_offset,skiprows=0;
526     rrd_value_t    *srcptr,*dstptr;
528     (*step) = cur_step*reduce_factor; /* set new step size for reduced data */
529     dstptr = *data;
530     srcptr = *data;
531     row_cnt = ((*end)-(*start))/cur_step;
533 #ifdef DEBUG
534 #define DEBUG_REDUCE
535 #endif
536 #ifdef DEBUG_REDUCE
537 printf("Reducing %lu rows with factor %i time %lu to %lu, step %lu\n",
538                         row_cnt,reduce_factor,*start,*end,cur_step);
539 for (col=0;col<row_cnt;col++) {
540     printf("time %10lu: ",*start+(col+1)*cur_step);
541     for (i=0;i<*ds_cnt;i++)
542         printf(" %8.2e",srcptr[*ds_cnt*col+i]);
543     printf("\n");
545 #endif
547     /* We have to combine [reduce_factor] rows of the source
548     ** into one row for the destination.  Doing this we also
549     ** need to take care to combine the correct rows.  First
550     ** alter the start and end time so that they are multiples
551     ** of the new step time.  We cannot reduce the amount of
552     ** time so we have to move the end towards the future and
553     ** the start towards the past.
554     */
555     end_offset = (*end) % (*step);
556     start_offset = (*start) % (*step);
558     /* If there is a start offset (which cannot be more than
559     ** one destination row), skip the appropriate number of
560     ** source rows and one destination row.  The appropriate
561     ** number is what we do know (start_offset/cur_step) of
562     ** the new interval (*step/cur_step aka reduce_factor).
563     */
564 #ifdef DEBUG_REDUCE
565 printf("start_offset: %lu  end_offset: %lu\n",start_offset,end_offset);
566 printf("row_cnt before:  %lu\n",row_cnt);
567 #endif
568     if (start_offset) {
569         (*start) = (*start)-start_offset;
570         skiprows=reduce_factor-start_offset/cur_step;
571         srcptr+=skiprows* *ds_cnt;
572         for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
573         row_cnt-=skiprows;
574     }
575 #ifdef DEBUG_REDUCE
576 printf("row_cnt between: %lu\n",row_cnt);
577 #endif
579     /* At the end we have some rows that are not going to be
580     ** used, the amount is end_offset/cur_step
581     */
582     if (end_offset) {
583         (*end) = (*end)-end_offset+(*step);
584         skiprows = end_offset/cur_step;
585         row_cnt-=skiprows;
586     }
587 #ifdef DEBUG_REDUCE
588 printf("row_cnt after:   %lu\n",row_cnt);
589 #endif
591 /* Sanity check: row_cnt should be multiple of reduce_factor */
592 /* if this gets triggered, something is REALLY WRONG ... we die immediately */
594     if (row_cnt%reduce_factor) {
595         printf("SANITY CHECK: %lu rows cannot be reduced by %i \n",
596                                 row_cnt,reduce_factor);
597         printf("BUG in reduce_data()\n");
598         exit(1);
599     }
601     /* Now combine reduce_factor intervals at a time
602     ** into one interval for the destination.
603     */
605     for (dst_row=0;(long int)row_cnt>=reduce_factor;dst_row++) {
606         for (col=0;col<(*ds_cnt);col++) {
607             rrd_value_t newval=DNAN;
608             unsigned long validval=0;
610             for (i=0;i<reduce_factor;i++) {
611                 if (isnan(srcptr[i*(*ds_cnt)+col])) {
612                     continue;
613                 }
614                 validval++;
615                 if (isnan(newval)) newval = srcptr[i*(*ds_cnt)+col];
616                 else {
617                     switch (cf) {
618                         case CF_HWPREDICT:
619                         case CF_DEVSEASONAL:
620                         case CF_DEVPREDICT:
621                         case CF_SEASONAL:
622                         case CF_AVERAGE:
623                             newval += srcptr[i*(*ds_cnt)+col];
624                             break;
625                         case CF_MINIMUM:
626                             newval = min (newval,srcptr[i*(*ds_cnt)+col]);
627                             break;
628                         case CF_FAILURES: 
629                         /* an interval contains a failure if any subintervals contained a failure */
630                         case CF_MAXIMUM:
631                             newval = max (newval,srcptr[i*(*ds_cnt)+col]);
632                             break;
633                         case CF_LAST:
634                             newval = srcptr[i*(*ds_cnt)+col];
635                             break;
636                     }
637                 }
638             }
639             if (validval == 0){newval = DNAN;} else{
640                 switch (cf) {
641                     case CF_HWPREDICT:
642             case CF_DEVSEASONAL:
643                     case CF_DEVPREDICT:
644                     case CF_SEASONAL:
645                     case CF_AVERAGE:                
646                        newval /= validval;
647                         break;
648                     case CF_MINIMUM:
649                     case CF_FAILURES:
650                     case CF_MAXIMUM:
651                     case CF_LAST:
652                         break;
653                 }
654             }
655             *dstptr++=newval;
656         }
657         srcptr+=(*ds_cnt)*reduce_factor;
658         row_cnt-=reduce_factor;
659     }
660     /* If we had to alter the endtime, we didn't have enough
661     ** source rows to fill the last row. Fill it with NaN.
662     */
663     if (end_offset) for (col=0;col<(*ds_cnt);col++) *dstptr++ = DNAN;
664 #ifdef DEBUG_REDUCE
665     row_cnt = ((*end)-(*start))/ *step;
666     srcptr = *data;
667     printf("Done reducing. Currently %lu rows, time %lu to %lu, step %lu\n",
668                                 row_cnt,*start,*end,*step);
669 for (col=0;col<row_cnt;col++) {
670     printf("time %10lu: ",*start+(col+1)*(*step));
671     for (i=0;i<*ds_cnt;i++)
672         printf(" %8.2e",srcptr[*ds_cnt*col+i]);
673     printf("\n");
675 #endif
679 /* get the data required for the graphs from the 
680    relevant rrds ... */
682 int
683 data_fetch(image_desc_t *im )
685     int i,ii;
686     int         skip;
688     /* pull the data from the rrd files ... */
689     for (i=0;i< (int)im->gdes_c;i++){
690         /* only GF_DEF elements fetch data */
691         if (im->gdes[i].gf != GF_DEF) 
692             continue;
694         skip=0;
695         /* do we have it already ?*/
696         for (ii=0;ii<i;ii++) {
697             if (im->gdes[ii].gf != GF_DEF) 
698                 continue;
699             if ((strcmp(im->gdes[i].rrd, im->gdes[ii].rrd) == 0)
700                         && (im->gdes[i].cf    == im->gdes[ii].cf)
701                         && (im->gdes[i].cf_reduce == im->gdes[ii].cf_reduce)
702                         && (im->gdes[i].start_orig == im->gdes[ii].start_orig)
703                         && (im->gdes[i].end_orig   == im->gdes[ii].end_orig)
704                         && (im->gdes[i].step_orig  == im->gdes[ii].step_orig)) {
705                 /* OK, the data is already there.
706                 ** Just copy the header portion
707                 */
708                 im->gdes[i].start = im->gdes[ii].start;
709                 im->gdes[i].end = im->gdes[ii].end;
710                 im->gdes[i].step = im->gdes[ii].step;
711                 im->gdes[i].ds_cnt = im->gdes[ii].ds_cnt;
712                 im->gdes[i].ds_namv = im->gdes[ii].ds_namv;             
713                 im->gdes[i].data = im->gdes[ii].data;
714                 im->gdes[i].data_first = 0;
715                 skip=1;
716             }
717             if (skip) 
718                 break;
719         }
720         if (! skip) {
721             unsigned long  ft_step = im->gdes[i].step ; /* ft_step will record what we got from fetch */
722             
723             if((rrd_fetch_fn(im->gdes[i].rrd,
724                              im->gdes[i].cf,
725                              &im->gdes[i].start,
726                              &im->gdes[i].end,
727                              &ft_step,
728                              &im->gdes[i].ds_cnt,
729                              &im->gdes[i].ds_namv,
730                              &im->gdes[i].data)) == -1){                
731                 return -1;
732             }
733             im->gdes[i].data_first = 1;     
734         
735             if (ft_step < im->gdes[i].step) {
736                 reduce_data(im->gdes[i].cf_reduce,
737                             ft_step,
738                             &im->gdes[i].start,
739                             &im->gdes[i].end,
740                             &im->gdes[i].step,
741                             &im->gdes[i].ds_cnt,
742                             &im->gdes[i].data);
743             } else {
744                 im->gdes[i].step = ft_step;
745             }
746         }
747         
748         /* lets see if the required data source is really there */
749         for(ii=0;ii<(int)im->gdes[i].ds_cnt;ii++){
750             if(strcmp(im->gdes[i].ds_namv[ii],im->gdes[i].ds_nam) == 0){
751                 im->gdes[i].ds=ii; }
752         }
753         if (im->gdes[i].ds== -1){
754             rrd_set_error("No DS called '%s' in '%s'",
755                           im->gdes[i].ds_nam,im->gdes[i].rrd);
756             return -1; 
757         }
758         
759     }
760     return 0;
763 /* evaluate the expressions in the CDEF functions */
765 /*************************************************************
766  * CDEF stuff 
767  *************************************************************/
769 long
770 find_var_wrapper(void *arg1, char *key)
772    return find_var((image_desc_t *) arg1, key);
775 /* find gdes containing var*/
776 long
777 find_var(image_desc_t *im, char *key){
778     long ii;
779     for(ii=0;ii<im->gdes_c-1;ii++){
780         if((im->gdes[ii].gf == GF_DEF 
781             || im->gdes[ii].gf == GF_VDEF
782             || im->gdes[ii].gf == GF_CDEF) 
783            && (strcmp(im->gdes[ii].vname,key) == 0)){
784             return ii; 
785         }          
786     }               
787     return -1;
790 /* find the largest common denominator for all the numbers
791    in the 0 terminated num array */
792 long
793 lcd(long *num){
794     long rest;
795     int i;
796     for (i=0;num[i+1]!=0;i++){
797         do { 
798             rest=num[i] % num[i+1];
799             num[i]=num[i+1]; num[i+1]=rest;
800         } while (rest!=0);
801         num[i+1] = num[i];
802     }
803 /*    return i==0?num[i]:num[i-1]; */
804       return num[i];
807 /* run the rpn calculator on all the VDEF and CDEF arguments */
808 int
809 data_calc( image_desc_t *im){
811     int       gdi;
812     int       dataidx;
813     long      *steparray, rpi;
814     int       stepcnt;
815     time_t    now;
816     rpnstack_t rpnstack;
818     rpnstack_init(&rpnstack);
820     for (gdi=0;gdi<im->gdes_c;gdi++){
821         /* Look for GF_VDEF and GF_CDEF in the same loop,
822          * so CDEFs can use VDEFs and vice versa
823          */
824         switch (im->gdes[gdi].gf) {
825             case GF_XPORT:
826               break;
827             case GF_SHIFT: {
828                 graph_desc_t    *vdp = &im->gdes[im->gdes[gdi].vidx];
829                 
830                 /* remove current shift */
831                 vdp->start -= vdp->shift;
832                 vdp->end -= vdp->shift;
833                 
834                 /* vdef */
835                 if (im->gdes[gdi].shidx >= 0) 
836                         vdp->shift = im->gdes[im->gdes[gdi].shidx].vf.val;
837                 /* constant */
838                 else
839                         vdp->shift = im->gdes[gdi].shval;
841                 /* normalize shift to multiple of consolidated step */
842                 vdp->shift = (vdp->shift / (long)vdp->step) * (long)vdp->step;
844                 /* apply shift */
845                 vdp->start += vdp->shift;
846                 vdp->end += vdp->shift;
847                 break;
848             }
849             case GF_VDEF:
850                 /* A VDEF has no DS.  This also signals other parts
851                  * of rrdtool that this is a VDEF value, not a CDEF.
852                  */
853                 im->gdes[gdi].ds_cnt = 0;
854                 if (vdef_calc(im,gdi)) {
855                     rrd_set_error("Error processing VDEF '%s'"
856                         ,im->gdes[gdi].vname
857                         );
858                     rpnstack_free(&rpnstack);
859                     return -1;
860                 }
861                 break;
862             case GF_CDEF:
863                 im->gdes[gdi].ds_cnt = 1;
864                 im->gdes[gdi].ds = 0;
865                 im->gdes[gdi].data_first = 1;
866                 im->gdes[gdi].start = 0;
867                 im->gdes[gdi].end = 0;
868                 steparray=NULL;
869                 stepcnt = 0;
870                 dataidx=-1;
872                 /* Find the variables in the expression.
873                  * - VDEF variables are substituted by their values
874                  *   and the opcode is changed into OP_NUMBER.
875                  * - CDEF variables are analized for their step size,
876                  *   the lowest common denominator of all the step
877                  *   sizes of the data sources involved is calculated
878                  *   and the resulting number is the step size for the
879                  *   resulting data source.
880                  */
881                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
882                     if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE  ||
883                         im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
884                         long ptr = im->gdes[gdi].rpnp[rpi].ptr;
885                         if (im->gdes[ptr].ds_cnt == 0) { /* this is a VDEF data source */
886 #if 0
887                             printf("DEBUG: inside CDEF '%s' processing VDEF '%s'\n",
888                                im->gdes[gdi].vname,
889                                im->gdes[ptr].vname);
890                             printf("DEBUG: value from vdef is %f\n",im->gdes[ptr].vf.val);
891 #endif
892                             im->gdes[gdi].rpnp[rpi].val = im->gdes[ptr].vf.val;
893                             im->gdes[gdi].rpnp[rpi].op  = OP_NUMBER;
894                         } else { /* normal variables and PREF(variables) */
896                             /* add one entry to the array that keeps track of the step sizes of the
897                              * data sources going into the CDEF. */
898                             if ((steparray =
899                                  rrd_realloc(steparray,
900                                                          (++stepcnt+1)*sizeof(*steparray)))==NULL){
901                                  rrd_set_error("realloc steparray");
902                                  rpnstack_free(&rpnstack);
903                                  return -1;
904                             };
906                             steparray[stepcnt-1] = im->gdes[ptr].step;
908                             /* adjust start and end of cdef (gdi) so
909                              * that it runs from the latest start point
910                              * to the earliest endpoint of any of the
911                              * rras involved (ptr)
912                              */
914                             if(im->gdes[gdi].start < im->gdes[ptr].start)
915                                 im->gdes[gdi].start = im->gdes[ptr].start;
917                             if(im->gdes[gdi].end == 0 ||
918                                         im->gdes[gdi].end > im->gdes[ptr].end)
919                                 im->gdes[gdi].end = im->gdes[ptr].end;
920                 
921                             /* store pointer to the first element of
922                              * the rra providing data for variable,
923                              * further save step size and data source
924                              * count of this rra
925                              */ 
926                             im->gdes[gdi].rpnp[rpi].data   = im->gdes[ptr].data + im->gdes[ptr].ds;
927                             im->gdes[gdi].rpnp[rpi].step   = im->gdes[ptr].step;
928                             im->gdes[gdi].rpnp[rpi].ds_cnt = im->gdes[ptr].ds_cnt;
930                             /* backoff the *.data ptr; this is done so
931                              * rpncalc() function doesn't have to treat
932                              * the first case differently
933                              */
934                         } /* if ds_cnt != 0 */
935                     } /* if OP_VARIABLE */
936                 } /* loop through all rpi */
938                 /* move the data pointers to the correct period */
939                 for(rpi=0;im->gdes[gdi].rpnp[rpi].op != OP_END;rpi++){
940                     if(im->gdes[gdi].rpnp[rpi].op == OP_VARIABLE ||
941                         im->gdes[gdi].rpnp[rpi].op == OP_PREV_OTHER){
942                         long ptr  = im->gdes[gdi].rpnp[rpi].ptr;
943                         long diff = im->gdes[gdi].start - im->gdes[ptr].start;
945                         if(diff > 0)
946                             im->gdes[gdi].rpnp[rpi].data += (diff / im->gdes[ptr].step) * im->gdes[ptr].ds_cnt;
947                      }
948                 }
950                 if(steparray == NULL){
951                     rrd_set_error("rpn expressions without DEF"
952                                 " or CDEF variables are not supported");
953                     rpnstack_free(&rpnstack);
954                     return -1;    
955                 }
956                 steparray[stepcnt]=0;
957                 /* Now find the resulting step.  All steps in all
958                  * used RRAs have to be visited
959                  */
960                 im->gdes[gdi].step = lcd(steparray);
961                 free(steparray);
962                 if((im->gdes[gdi].data = malloc((
963                                 (im->gdes[gdi].end-im->gdes[gdi].start) 
964                                     / im->gdes[gdi].step)
965                                     * sizeof(double)))==NULL){
966                     rrd_set_error("malloc im->gdes[gdi].data");
967                     rpnstack_free(&rpnstack);
968                     return -1;
969                 }
970         
971                 /* Step through the new cdef results array and
972                  * calculate the values
973                  */
974                 for (now = im->gdes[gdi].start + im->gdes[gdi].step;
975                                 now<=im->gdes[gdi].end;
976                                 now += im->gdes[gdi].step)
977                 {
978                     rpnp_t  *rpnp = im -> gdes[gdi].rpnp;
980                     /* 3rd arg of rpn_calc is for OP_VARIABLE lookups;
981                      * in this case we are advancing by timesteps;
982                      * we use the fact that time_t is a synonym for long
983                      */
984                     if (rpn_calc(rpnp,&rpnstack,(long) now, 
985                                 im->gdes[gdi].data,++dataidx) == -1) {
986                         /* rpn_calc sets the error string */
987                         rpnstack_free(&rpnstack); 
988                         return -1;
989                     } 
990                 } /* enumerate over time steps within a CDEF */
991                 break;
992             default:
993                 continue;
994         }
995     } /* enumerate over CDEFs */
996     rpnstack_free(&rpnstack);
997     return 0;
1000 /* massage data so, that we get one value for each x coordinate in the graph */
1001 int
1002 data_proc( image_desc_t *im ){
1003     long i,ii;
1004     double pixstep = (double)(im->end-im->start)
1005         /(double)im->xsize; /* how much time 
1006                                passes in one pixel */
1007     double paintval;
1008     double minval=DNAN,maxval=DNAN;
1009     
1010     unsigned long gr_time;    
1012     /* memory for the processed data */
1013     for(i=0;i<im->gdes_c;i++) {
1014         if((im->gdes[i].gf==GF_LINE) ||
1015                 (im->gdes[i].gf==GF_AREA) ||
1016                 (im->gdes[i].gf==GF_TICK)) {
1017             if((im->gdes[i].p_data = malloc((im->xsize +1)
1018                                         * sizeof(rrd_value_t)))==NULL){
1019                 rrd_set_error("malloc data_proc");
1020                 return -1;
1021             }
1022         }
1023     }
1025     for (i=0;i<im->xsize;i++) { /* for each pixel */
1026         long vidx;
1027         gr_time = im->start+pixstep*i; /* time of the current step */
1028         paintval=0.0;
1029         
1030         for (ii=0;ii<im->gdes_c;ii++) {
1031             double value;
1032             switch (im->gdes[ii].gf) {
1033                 case GF_LINE:
1034                 case GF_AREA:
1035                 case GF_TICK:
1036                     if (!im->gdes[ii].stack)
1037                         paintval = 0.0;
1038                     value = im->gdes[ii].yrule;
1039                     if (isnan(value) || (im->gdes[ii].gf == GF_TICK)) {
1040                         /* The time of the data doesn't necessarily match
1041                         ** the time of the graph. Beware.
1042                         */
1043                         vidx = im->gdes[ii].vidx;
1044                         if (im->gdes[vidx].gf == GF_VDEF) {
1045                             value = im->gdes[vidx].vf.val;
1046                         } else if (((long int)gr_time >= (long int)im->gdes[vidx].start) &&
1047                                    ((long int)gr_time <= (long int)im->gdes[vidx].end) ) {
1048                             value = im->gdes[vidx].data[
1049                                 (unsigned long) floor(
1050                                     (double)(gr_time - im->gdes[vidx].start)
1051                                                 / im->gdes[vidx].step)
1052                                 * im->gdes[vidx].ds_cnt
1053                                 + im->gdes[vidx].ds
1054                             ];
1055                         } else {
1056                             value = DNAN;
1057                         }
1058                     };
1060                     if (! isnan(value)) {
1061                         paintval += value;
1062                         im->gdes[ii].p_data[i] = paintval;
1063                         /* GF_TICK: the data values are not
1064                         ** relevant for min and max
1065                         */
1066                         if (finite(paintval) && im->gdes[ii].gf != GF_TICK ) {
1067                             if ((isnan(minval) || paintval <  minval ) &&
1068                               ! (im->logarithmic && paintval <= 0.0)) 
1069                                         minval = paintval;
1070                             if (isnan(maxval) || paintval >  maxval)
1071                                 maxval = paintval;
1072                         }
1073                     } else {
1074                         im->gdes[ii].p_data[i] = DNAN;
1075                     }
1076                     break;
1077                 case GF_STACK:
1078                     rrd_set_error("STACK should already be turned into LINE or AREA here");
1079                     return -1;
1080                     break;
1081                 default:
1082                     break;
1083             }
1084         }
1085     }
1087     /* if min or max have not been asigned a value this is because
1088        there was no data in the graph ... this is not good ...
1089        lets set these to dummy values then ... */
1091     if (im->logarithmic) {
1092         if (isnan(minval)) minval = 0.2;
1093         if (isnan(maxval)) maxval = 5.1;
1094     }
1095     else {
1096         if (isnan(minval)) minval = 0.0;
1097         if (isnan(maxval)) maxval = 1.0;
1098     }
1099     
1100     /* adjust min and max values */
1101     if (isnan(im->minval) 
1102         /* don't adjust low-end with log scale */ /* why not? */
1103         || ((!im->rigid) && im->minval > minval)
1104         ) {
1105         if (im->logarithmic)
1106             im->minval = minval * 0.5;
1107         else
1108             im->minval = minval;
1109     }
1110     if (isnan(im->maxval) 
1111         || (!im->rigid && im->maxval < maxval)
1112         ) {
1113         if (im->logarithmic)
1114             im->maxval = maxval * 2.0;
1115         else
1116             im->maxval = maxval;
1117     }
1118     /* make sure min is smaller than max */
1119     if (im->minval > im->maxval) {
1120             im->minval = 0.99 * im->maxval;
1121     }
1122                       
1123     /* make sure min and max are not equal */
1124     if (im->minval == im->maxval) {
1125         im->maxval *= 1.01; 
1126         if (! im->logarithmic) {
1127             im->minval *= 0.99;
1128         }
1129         /* make sure min and max are not both zero */
1130         if (im->maxval == 0.0) {
1131             im->maxval = 1.0;
1132         }
1133     }
1134     return 0;
1139 /* identify the point where the first gridline, label ... gets placed */
1141 time_t
1142 find_first_time(
1143     time_t   start, /* what is the initial time */
1144     enum tmt_en baseint,  /* what is the basic interval */
1145     long     basestep /* how many if these do we jump a time */
1146     )
1148     struct tm tm;
1149     localtime_r(&start, &tm);
1150     switch(baseint){
1151     case TMT_SECOND:
1152         tm.tm_sec -= tm.tm_sec % basestep; break;
1153     case TMT_MINUTE: 
1154         tm.tm_sec=0;
1155         tm.tm_min -= tm.tm_min % basestep; 
1156         break;
1157     case TMT_HOUR:
1158         tm.tm_sec=0;
1159         tm.tm_min = 0;
1160         tm.tm_hour -= tm.tm_hour % basestep; break;
1161     case TMT_DAY:
1162         /* we do NOT look at the basestep for this ... */
1163         tm.tm_sec=0;
1164         tm.tm_min = 0;
1165         tm.tm_hour = 0; break;
1166     case TMT_WEEK:
1167         /* we do NOT look at the basestep for this ... */
1168         tm.tm_sec=0;
1169         tm.tm_min = 0;
1170         tm.tm_hour = 0;
1171         tm.tm_mday -= tm.tm_wday -1;    /* -1 because we want the monday */
1172         if (tm.tm_wday==0) tm.tm_mday -= 7; /* we want the *previous* monday */
1173         break;
1174     case TMT_MONTH:
1175         tm.tm_sec=0;
1176         tm.tm_min = 0;
1177         tm.tm_hour = 0;
1178         tm.tm_mday = 1;
1179         tm.tm_mon -= tm.tm_mon % basestep; break;
1181     case TMT_YEAR:
1182         tm.tm_sec=0;
1183         tm.tm_min = 0;
1184         tm.tm_hour = 0;
1185         tm.tm_mday = 1;
1186         tm.tm_mon = 0;
1187         tm.tm_year -= (tm.tm_year+1900) % basestep;
1188         
1189     }
1190     return mktime(&tm);
1192 /* identify the point where the next gridline, label ... gets placed */
1193 time_t 
1194 find_next_time(
1195     time_t   current, /* what is the initial time */
1196     enum tmt_en baseint,  /* what is the basic interval */
1197     long     basestep /* how many if these do we jump a time */
1198     )
1200     struct tm tm;
1201     time_t madetime;
1202     localtime_r(&current, &tm);
1203     do {
1204         switch(baseint){
1205         case TMT_SECOND:
1206             tm.tm_sec += basestep; break;
1207         case TMT_MINUTE: 
1208             tm.tm_min += basestep; break;
1209         case TMT_HOUR:
1210             tm.tm_hour += basestep; break;
1211         case TMT_DAY:
1212             tm.tm_mday += basestep; break;
1213         case TMT_WEEK:
1214             tm.tm_mday += 7*basestep; break;
1215         case TMT_MONTH:
1216             tm.tm_mon += basestep; break;
1217         case TMT_YEAR:
1218             tm.tm_year += basestep;     
1219         }
1220         madetime = mktime(&tm);
1221     } while (madetime == -1); /* this is necessary to skip impssible times
1222                                  like the daylight saving time skips */
1223     return madetime;
1224           
1228 /* calculate values required for PRINT and GPRINT functions */
1230 int
1231 print_calc(image_desc_t *im, char ***prdata) 
1233     long i,ii,validsteps;
1234     double printval;
1235     struct tm tmvdef;
1236     int graphelement = 0;
1237     long vidx;
1238     int max_ii; 
1239     double magfact = -1;
1240     char *si_symb = "";
1241     char *percent_s;
1242     int prlines = 1;
1243     /* wow initializing tmvdef is quite a task :-) */
1244     time_t now = time(NULL);
1245     localtime_r(&now,&tmvdef);
1246     if (im->imginfo) prlines++;
1247     for(i=0;i<im->gdes_c;i++){
1248         switch(im->gdes[i].gf){
1249         case GF_PRINT:
1250             prlines++;
1251             if(((*prdata) = rrd_realloc((*prdata),prlines*sizeof(char *)))==NULL){
1252                 rrd_set_error("realloc prdata");
1253                 return 0;
1254             }
1255         case GF_GPRINT:
1256             /* PRINT and GPRINT can now print VDEF generated values.
1257              * There's no need to do any calculations on them as these
1258              * calculations were already made.
1259              */
1260             vidx = im->gdes[i].vidx;
1261             if (im->gdes[vidx].gf==GF_VDEF) { /* simply use vals */
1262                 printval = im->gdes[vidx].vf.val;
1263                 localtime_r(&im->gdes[vidx].vf.when,&tmvdef);
1264             } else { /* need to calculate max,min,avg etcetera */
1265                 max_ii =((im->gdes[vidx].end 
1266                         - im->gdes[vidx].start)
1267                         / im->gdes[vidx].step
1268                         * im->gdes[vidx].ds_cnt);
1269                 printval = DNAN;
1270                 validsteps = 0;
1271                 for(    ii=im->gdes[vidx].ds;
1272                         ii < max_ii;
1273                         ii+=im->gdes[vidx].ds_cnt){
1274                     if (! finite(im->gdes[vidx].data[ii]))
1275                         continue;
1276                     if (isnan(printval)){
1277                         printval = im->gdes[vidx].data[ii];
1278                         validsteps++;
1279                         continue;
1280                     }
1282                     switch (im->gdes[i].cf){
1283                         case CF_HWPREDICT:
1284                         case CF_DEVPREDICT:
1285                         case CF_DEVSEASONAL:
1286                         case CF_SEASONAL:
1287                         case CF_AVERAGE:
1288                             validsteps++;
1289                             printval += im->gdes[vidx].data[ii];
1290                             break;
1291                         case CF_MINIMUM:
1292                             printval = min( printval, im->gdes[vidx].data[ii]);
1293                             break;
1294                         case CF_FAILURES:
1295                         case CF_MAXIMUM:
1296                             printval = max( printval, im->gdes[vidx].data[ii]);
1297                             break;
1298                         case CF_LAST:
1299                             printval = im->gdes[vidx].data[ii];
1300                     }
1301                 }
1302                 if (im->gdes[i].cf==CF_AVERAGE || im->gdes[i].cf > CF_LAST) {
1303                     if (validsteps > 1) {
1304                         printval = (printval / validsteps);
1305                     }
1306                 }
1307             } /* prepare printval */
1309             if ((percent_s = strstr(im->gdes[i].format,"%S")) != NULL) {
1310                 /* Magfact is set to -1 upon entry to print_calc.  If it
1311                  * is still less than 0, then we need to run auto_scale.
1312                  * Otherwise, put the value into the correct units.  If
1313                  * the value is 0, then do not set the symbol or magnification
1314                  * so next the calculation will be performed again. */
1315                 if (magfact < 0.0) {
1316                     auto_scale(im,&printval,&si_symb,&magfact);
1317                     if (printval == 0.0)
1318                         magfact = -1.0;
1319                 } else {
1320                     printval /= magfact;
1321                 }
1322                 *(++percent_s) = 's';
1323             } else if (strstr(im->gdes[i].format,"%s") != NULL) {
1324                 auto_scale(im,&printval,&si_symb,&magfact);
1325             }
1327             if (im->gdes[i].gf == GF_PRINT){
1328                 (*prdata)[prlines-2] = malloc((FMT_LEG_LEN+2)*sizeof(char));
1329                 (*prdata)[prlines-1] = NULL;
1330                 if (im->gdes[i].strftm){
1331                         strftime((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,&tmvdef);
1332                 } else {
1333                   if (bad_format(im->gdes[i].format)) {
1334                         rrd_set_error("bad format for PRINT in '%s'", im->gdes[i].format);
1335                         return -1;
1336                   }
1338 #ifdef HAVE_SNPRINTF
1339                   snprintf((*prdata)[prlines-2],FMT_LEG_LEN,im->gdes[i].format,printval,si_symb);
1340 #else
1341                   sprintf((*prdata)[prlines-2],im->gdes[i].format,printval,si_symb);
1342 #endif
1343                }
1344              } else {
1345                 /* GF_GPRINT */
1347                 if (im->gdes[i].strftm){
1348                         strftime(im->gdes[i].legend,FMT_LEG_LEN,im->gdes[i].format,&tmvdef);
1349                 } else {
1350                   if (bad_format(im->gdes[i].format)) {
1351                         rrd_set_error("bad format for GPRINT in '%s'", im->gdes[i].format);
1352                         return -1;
1353                   }
1354 #ifdef HAVE_SNPRINTF
1355                   snprintf(im->gdes[i].legend,FMT_LEG_LEN-2,im->gdes[i].format,printval,si_symb);
1356 #else
1357                   sprintf(im->gdes[i].legend,im->gdes[i].format,printval,si_symb);
1358 #endif
1359                 }
1360                 graphelement = 1;               
1361             }       
1362             break;
1363         case GF_LINE:
1364         case GF_AREA:
1365         case GF_TICK:
1366             graphelement = 1;
1367             break;
1368         case GF_HRULE:
1369             if(isnan(im->gdes[i].yrule)) { /* we must set this here or the legend printer can not decide to print the legend */
1370                im->gdes[i].yrule=im->gdes[im->gdes[i].vidx].vf.val;
1371             };
1372             graphelement = 1;
1373             break;
1374         case GF_VRULE:
1375             if(im->gdes[i].xrule == 0) { /* again ... the legend printer needs it*/
1376               im->gdes[i].xrule = im->gdes[im->gdes[i].vidx].vf.when;
1377             };
1378             graphelement = 1;
1379             break;
1380         case GF_COMMENT:
1381         case GF_DEF:
1382         case GF_CDEF:       
1383         case GF_VDEF:       
1384 #ifdef WITH_PIECHART
1385         case GF_PART:
1386 #endif
1387         case GF_SHIFT:
1388         case GF_XPORT:
1389             break;
1390         case GF_STACK:
1391             rrd_set_error("STACK should already be turned into LINE or AREA here");
1392             return -1;
1393             break;
1394         }
1395     }
1396     return graphelement;
1400 /* place legends with color spots */
1401 int
1402 leg_place(image_desc_t *im)
1404     /* graph labels */
1405     int   interleg = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
1406     int   border = im->text_prop[TEXT_PROP_LEGEND].size*2.0;
1407     int   fill=0, fill_last;
1408     int   leg_c = 0;
1409     int   leg_x = border, leg_y = im->yimg;
1410     int   leg_y_prev = im->yimg;
1411     int   leg_cc;
1412     int   glue = 0;
1413     int   i,ii, mark = 0;
1414     char  prt_fctn; /*special printfunctions */
1415     int  *legspace;
1417   if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
1418     if ((legspace = malloc(im->gdes_c*sizeof(int)))==NULL){
1419        rrd_set_error("malloc for legspace");
1420        return -1;
1421     }
1423     for(i=0;i<im->gdes_c;i++){
1424         fill_last = fill;
1425         
1426         /* hid legends for rules which are not displayed */
1427         
1428         if(!(im->extra_flags & FORCE_RULES_LEGEND)) {
1429                 if (im->gdes[i].gf == GF_HRULE &&
1430                     (im->gdes[i].yrule < im->minval || im->gdes[i].yrule > im->maxval))
1431                     im->gdes[i].legend[0] = '\0';
1433                 if (im->gdes[i].gf == GF_VRULE &&
1434                     (im->gdes[i].xrule < im->start || im->gdes[i].xrule > im->end))
1435                     im->gdes[i].legend[0] = '\0';
1436         }
1438         leg_cc = strlen(im->gdes[i].legend);
1439         
1440         /* is there a controle code ant the end of the legend string ? */ 
1441         /* and it is not a tab \\t */
1442         if (leg_cc >= 2 && im->gdes[i].legend[leg_cc-2] == '\\' && im->gdes[i].legend[leg_cc-1] != 't') {
1443             prt_fctn = im->gdes[i].legend[leg_cc-1];
1444             leg_cc -= 2;
1445             im->gdes[i].legend[leg_cc] = '\0';
1446         } else {
1447             prt_fctn = '\0';
1448         }
1449         /* only valid control codes */
1450         if (prt_fctn != 'l' && 
1451             prt_fctn != 'n' && /* a synonym for l */
1452             prt_fctn != 'r' &&
1453             prt_fctn != 'j' &&
1454             prt_fctn != 'c' &&
1455             prt_fctn != 't' &&
1456             prt_fctn != '\0' &&
1457             prt_fctn != 'g' ) {
1458                free(legspace);
1459                rrd_set_error("Unknown control code at the end of '%s\\%c'",im->gdes[i].legend,prt_fctn);
1460                return -1;
1462         }
1464         /* remove exess space */
1465         if ( prt_fcnt == 'n' ){
1466             prt_fcnt='l';
1467         }
1469         while (prt_fctn=='g' && 
1470                leg_cc > 0 && 
1471                im->gdes[i].legend[leg_cc-1]==' '){
1472            leg_cc--;
1473            im->gdes[i].legend[leg_cc]='\0';
1474         }
1475         if (leg_cc != 0 ){
1476            legspace[i]=(prt_fctn=='g' ? 0 : interleg);
1477            
1478            if (fill > 0){ 
1479                /* no interleg space if string ends in \g */
1480                fill += legspace[i];
1481             }
1482            fill += gfx_get_text_width(im->canvas, fill+border,
1483                                       im->text_prop[TEXT_PROP_LEGEND].font,
1484                                       im->text_prop[TEXT_PROP_LEGEND].size,
1485                                       im->tabwidth,
1486                                       im->gdes[i].legend, 0);
1487             leg_c++;
1488         } else {
1489            legspace[i]=0;
1490         }
1491         /* who said there was a special tag ... ?*/
1492         if (prt_fctn=='g') {    
1493            prt_fctn = '\0';
1494         }
1495         if (prt_fctn == '\0') {
1496             if (i == im->gdes_c -1 ) prt_fctn ='l';
1497             
1498             /* is it time to place the legends ? */
1499             if (fill > im->ximg - 2*border){
1500                 if (leg_c > 1) {
1501                     /* go back one */
1502                     i--; 
1503                     fill = fill_last;
1504                     leg_c--;
1505                     prt_fctn = 'j';
1506                 } else {
1507                     prt_fctn = 'l';
1508                 }
1509                 
1510             }
1511         }
1514         if (prt_fctn != '\0'){  
1515             leg_x = border;
1516             if (leg_c >= 2 && prt_fctn == 'j') {
1517                 glue = (im->ximg - fill - 2* border) / (leg_c-1);
1518             } else {
1519                 glue = 0;
1520             }
1521             if (prt_fctn =='c') leg_x =  (im->ximg - fill) / 2.0;
1522             if (prt_fctn =='r') leg_x =  im->ximg - fill - border;
1524             for(ii=mark;ii<=i;ii++){
1525                 if(im->gdes[ii].legend[0]=='\0')
1526                     continue; /* skip empty legends */
1527                 im->gdes[ii].leg_x = leg_x;
1528                 im->gdes[ii].leg_y = leg_y;
1529                 leg_x += 
1530                  gfx_get_text_width(im->canvas, leg_x,
1531                                       im->text_prop[TEXT_PROP_LEGEND].font,
1532                                       im->text_prop[TEXT_PROP_LEGEND].size,
1533                                       im->tabwidth,
1534                                       im->gdes[ii].legend, 0) 
1535                    + legspace[ii]
1536                    + glue;
1537             }                   
1538             leg_y_prev = leg_y;
1539             /* only add y space if there was text on the line */
1540             if (leg_x > border || prt_fctn == 's')            
1541                leg_y += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
1542             if (prt_fctn == 's')
1543                leg_y -=  im->text_prop[TEXT_PROP_LEGEND].size;     
1544             fill = 0;
1545             leg_c = 0;
1546             mark = ii;
1547         }          
1548     }
1549     im->yimg = leg_y_prev;
1550     /* if we did place some legends we have to add vertical space */
1551     if (leg_y != im->yimg){
1552         im->yimg += im->text_prop[TEXT_PROP_LEGEND].size*1.8;
1553     }
1554     free(legspace);
1555   }
1556   return 0;
1559 /* create a grid on the graph. it determines what to do
1560    from the values of xsize, start and end */
1562 /* the xaxis labels are determined from the number of seconds per pixel
1563    in the requested graph */
1567 int
1568 calc_horizontal_grid(image_desc_t   *im)
1570     double   range;
1571     double   scaledrange;
1572     int      pixel,i;
1573     int      gridind=0;
1574     int      decimals, fractionals;
1576     im->ygrid_scale.labfact=2;
1577     range =  im->maxval - im->minval;
1578     scaledrange = range / im->magfact;
1580         /* does the scale of this graph make it impossible to put lines
1581            on it? If so, give up. */
1582         if (isnan(scaledrange)) {
1583                 return 0;
1584         }
1586     /* find grid spaceing */
1587     pixel=1;
1588     if(isnan(im->ygridstep)){
1589         if(im->extra_flags & ALTYGRID) {
1590             /* find the value with max number of digits. Get number of digits */
1591             decimals = ceil(log10(max(fabs(im->maxval), fabs(im->minval))*im->viewfactor/im->magfact));
1592             if(decimals <= 0) /* everything is small. make place for zero */
1593                 decimals = 1;
1594             
1595             im->ygrid_scale.gridstep = pow((double)10, floor(log10(range*im->viewfactor/im->magfact)))/im->viewfactor*im->magfact;
1596             
1597             if(im->ygrid_scale.gridstep == 0) /* range is one -> 0.1 is reasonable scale */
1598                 im->ygrid_scale.gridstep = 0.1;
1599             /* should have at least 5 lines but no more then 15 */
1600             if(range/im->ygrid_scale.gridstep < 5)
1601                 im->ygrid_scale.gridstep /= 10;
1602             if(range/im->ygrid_scale.gridstep > 15)
1603                 im->ygrid_scale.gridstep *= 10;
1604             if(range/im->ygrid_scale.gridstep > 5) {
1605                 im->ygrid_scale.labfact = 1;
1606                 if(range/im->ygrid_scale.gridstep > 8)
1607                     im->ygrid_scale.labfact = 2;
1608             }
1609             else {
1610                 im->ygrid_scale.gridstep /= 5;
1611                 im->ygrid_scale.labfact = 5;
1612             }
1613             fractionals = floor(log10(im->ygrid_scale.gridstep*(double)im->ygrid_scale.labfact*im->viewfactor/im->magfact));
1614             if(fractionals < 0) { /* small amplitude. */
1615                 int len = decimals - fractionals + 1;
1616                 if (im->unitslength < len+2) im->unitslength = len+2;
1617                 sprintf(im->ygrid_scale.labfmt, "%%%d.%df%s", len, -fractionals,(im->symbol != ' ' ? " %c" : ""));
1618             } else {
1619                 int len = decimals + 1;
1620                 if (im->unitslength < len+2) im->unitslength = len+2;
1621                 sprintf(im->ygrid_scale.labfmt, "%%%d.0f%s", len, ( im->symbol != ' ' ? " %c" : "" ));
1622             }
1623         }
1624         else {
1625             for(i=0;ylab[i].grid > 0;i++){
1626                 pixel = im->ysize / (scaledrange / ylab[i].grid);
1627                 gridind = i;
1628                 if (pixel > 7)
1629                     break;
1630             }
1631             
1632             for(i=0; i<4;i++) {
1633                if (pixel * ylab[gridind].lfac[i] >=  2.5 * im->text_prop[TEXT_PROP_AXIS].size) {
1634                   im->ygrid_scale.labfact =  ylab[gridind].lfac[i];
1635                   break;
1636                }
1637             } 
1638             
1639             im->ygrid_scale.gridstep = ylab[gridind].grid * im->magfact;
1640         }
1641     } else {
1642         im->ygrid_scale.gridstep = im->ygridstep;
1643         im->ygrid_scale.labfact = im->ylabfact;
1644     }
1645     return 1;
1648 int draw_horizontal_grid(image_desc_t *im)
1650     int      i;
1651     double   scaledstep;
1652     char     graph_label[100];
1653     int      nlabels=0;
1654     double X0=im->xorigin;
1655     double X1=im->xorigin+im->xsize;
1656    
1657     int sgrid = (int)( im->minval / im->ygrid_scale.gridstep - 1);
1658     int egrid = (int)( im->maxval / im->ygrid_scale.gridstep + 1);
1659     double MaxY;
1660     scaledstep = im->ygrid_scale.gridstep/(double)im->magfact*(double)im->viewfactor;
1661     MaxY = scaledstep*(double)egrid;
1662     for (i = sgrid; i <= egrid; i++){
1663        double Y0=ytr(im,im->ygrid_scale.gridstep*i);
1664        double YN=ytr(im,im->ygrid_scale.gridstep*(i+1));
1665        if ( Y0 >= im->yorigin-im->ysize
1666                  && Y0 <= im->yorigin){       
1667             /* Make sure at least 2 grid labels are shown, even if it doesn't agree
1668                with the chosen settings. Add a label if required by settings, or if
1669                there is only one label so far and the next grid line is out of bounds. */
1670             if(i % im->ygrid_scale.labfact == 0 || ( nlabels==1 && (YN < im->yorigin-im->ysize || YN > im->yorigin) )){         
1671                 if (im->symbol == ' ') {
1672                     if(im->extra_flags & ALTYGRID) {
1673                         sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i);
1674                     } else {
1675                         if(MaxY < 10) {
1676                            sprintf(graph_label,"%4.1f",scaledstep*(double)i);
1677                         } else {
1678                            sprintf(graph_label,"%4.0f",scaledstep*(double)i);
1679                         }
1680                     }
1681                 }else {
1682                     char sisym = ( i == 0  ? ' ' : im->symbol);
1683                     if(im->extra_flags & ALTYGRID) {
1684                         sprintf(graph_label,im->ygrid_scale.labfmt,scaledstep*(double)i,sisym);
1685                     } else {
1686                         if(MaxY < 10){
1687                           sprintf(graph_label,"%4.1f %c",scaledstep*(double)i, sisym);
1688                         } else {
1689                           sprintf(graph_label,"%4.0f %c",scaledstep*(double)i, sisym);
1690                         }
1691                     }
1692                 }
1693                 nlabels++;
1695                gfx_new_text ( im->canvas,
1696                               X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
1697                               im->graph_col[GRC_FONT],
1698                               im->text_prop[TEXT_PROP_AXIS].font,
1699                               im->text_prop[TEXT_PROP_AXIS].size,
1700                               im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
1701                               graph_label );
1702                gfx_new_dashed_line ( im->canvas,
1703                               X0-2,Y0,
1704                               X1+2,Y0,
1705                               MGRIDWIDTH, im->graph_col[GRC_MGRID],
1706                               im->grid_dash_on, im->grid_dash_off);            
1707                
1708             } else if (!(im->extra_flags & NOMINOR)) {          
1709                gfx_new_dashed_line ( im->canvas,
1710                               X0-1,Y0,
1711                               X1+1,Y0,
1712                               GRIDWIDTH, im->graph_col[GRC_GRID],
1713                               im->grid_dash_on, im->grid_dash_off);            
1714                
1715             }       
1716         }       
1717     } 
1718     return 1;
1721 /* this is frexp for base 10 */
1722 double frexp10(double, double *);
1723 double frexp10(double x, double *e) {
1724     double mnt;
1725     int iexp;
1727     iexp = floor(log(fabs(x)) / log(10));
1728     mnt = x / pow(10.0, iexp);
1729     if(mnt >= 10.0) {
1730         iexp++;
1731         mnt = x / pow(10.0, iexp);
1732     }
1733     *e = iexp;
1734     return mnt;
1737 static int AlmostEqual2sComplement (float A, float B, int maxUlps)
1740     int aInt = *(int*)&A;
1741     int bInt = *(int*)&B;
1742     int intDiff;
1743     /* Make sure maxUlps is non-negative and small enough that the
1744        default NAN won't compare as equal to anything.  */
1746     /* assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024); */
1748     /* Make aInt lexicographically ordered as a twos-complement int */
1750     if (aInt < 0)
1751         aInt = 0x80000000l - aInt;
1753     /* Make bInt lexicographically ordered as a twos-complement int */
1755     if (bInt < 0)
1756         bInt = 0x80000000l - bInt;
1758     intDiff = abs(aInt - bInt);
1760     if (intDiff <= maxUlps)
1761         return 1;
1763     return 0;
1766 /* logaritmic horizontal grid */
1767 int
1768 horizontal_log_grid(image_desc_t   *im)   
1770     double yloglab[][10] = {
1771         {1.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
1772         {1.0, 5.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
1773         {1.0, 2.0, 5.0, 7.0, 10., 0.0, 0.0, 0.0, 0.0, 0.0},
1774         {1.0, 2.0, 4.0, 6.0, 8.0, 10., 0.0, 0.0, 0.0, 0.0},
1775         {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.},
1776         {0,0,0,0,0, 0,0,0,0,0} /* last line */ };
1778     int i, j, val_exp, min_exp;
1779     double nex;         /* number of decades in data */
1780     double logscale;    /* scale in logarithmic space */
1781     int exfrac = 1;     /* decade spacing */
1782     int mid = -1;       /* row in yloglab for major grid */
1783     double mspac;       /* smallest major grid spacing (pixels) */
1784     int flab;           /* first value in yloglab to use */
1785     double value, tmp, pre_value;
1786     double X0,X1,Y0;   
1787     char graph_label[100];
1789     nex = log10(im->maxval / im->minval);
1790     logscale = im->ysize / nex;
1792     /* major spacing for data with high dynamic range */
1793     while(logscale * exfrac < 3 * im->text_prop[TEXT_PROP_LEGEND].size) {
1794         if(exfrac == 1) exfrac = 3;
1795         else exfrac += 3;
1796     }
1798     /* major spacing for less dynamic data */
1799     do {
1800         /* search best row in yloglab */
1801         mid++;
1802         for(i = 0; yloglab[mid][i + 1] < 10.0; i++);
1803         mspac = logscale * log10(10.0 / yloglab[mid][i]);
1804     } while(mspac > 2 * im->text_prop[TEXT_PROP_LEGEND].size && yloglab[mid][0] > 0);
1805     if(mid) mid--;
1807     /* find first value in yloglab */
1808     for(flab = 0; yloglab[mid][flab] < 10 && frexp10(im->minval, &tmp) > yloglab[mid][flab] ; flab++);
1809     if(yloglab[mid][flab] == 10.0) {
1810         tmp += 1.0;
1811         flab = 0;
1812     }
1813     val_exp = tmp;
1814     if(val_exp % exfrac) val_exp += abs(-val_exp % exfrac);
1816     X0=im->xorigin;
1817     X1=im->xorigin+im->xsize;
1819     /* draw grid */
1820     pre_value = DNAN;
1821     while(1) {       
1823         value = yloglab[mid][flab] * pow(10.0, val_exp);
1824         if (  AlmostEqual2sComplement(value,pre_value,4) ) break; /* it seems we are not converging */
1826         pre_value = value;
1828         Y0 = ytr(im, value);
1829         if(Y0 <= im->yorigin - im->ysize) break;
1831         /* major grid line */
1832         gfx_new_dashed_line ( im->canvas,
1833             X0-2,Y0,
1834             X1+2,Y0,
1835             MGRIDWIDTH, im->graph_col[GRC_MGRID],
1836             im->grid_dash_on, im->grid_dash_off);
1838         /* label */
1839         if (im->extra_flags & FORCE_UNITS_SI) {
1840             int scale;
1841             double pvalue;
1842             char symbol;
1844             scale = floor(val_exp / 3.0);
1845             if( value >= 1.0 ) pvalue = pow(10.0, val_exp % 3);
1846             else pvalue = pow(10.0, ((val_exp + 1) % 3) + 2);
1847             pvalue *= yloglab[mid][flab];
1849             if ( ((scale+si_symbcenter) < (int)sizeof(si_symbol)) &&
1850                 ((scale+si_symbcenter) >= 0) )
1851                 symbol = si_symbol[scale+si_symbcenter];
1852             else
1853                 symbol = '?';
1855                 sprintf(graph_label,"%3.0f %c", pvalue, symbol);
1856         } else
1857             sprintf(graph_label,"%3.0e", value);
1858         gfx_new_text ( im->canvas,
1859             X0-im->text_prop[TEXT_PROP_AXIS].size, Y0,
1860             im->graph_col[GRC_FONT],
1861             im->text_prop[TEXT_PROP_AXIS].font,
1862             im->text_prop[TEXT_PROP_AXIS].size,
1863             im->tabwidth,0.0, GFX_H_RIGHT, GFX_V_CENTER,
1864             graph_label );
1866         /* minor grid */
1867         if(mid < 4 && exfrac == 1) {
1868             /* find first and last minor line behind current major line
1869              * i is the first line and j tha last */
1870             if(flab == 0) {
1871                 min_exp = val_exp - 1;
1872                 for(i = 1; yloglab[mid][i] < 10.0; i++);
1873                 i = yloglab[mid][i - 1] + 1;
1874                 j = 10;
1875             }
1876             else {
1877                 min_exp = val_exp;
1878                 i = yloglab[mid][flab - 1] + 1;
1879                 j = yloglab[mid][flab];
1880             }
1882             /* draw minor lines below current major line */
1883             for(; i < j; i++) {
1885                 value = i * pow(10.0, min_exp);
1886                 if(value < im->minval) continue;
1888                 Y0 = ytr(im, value);
1889                 if(Y0 <= im->yorigin - im->ysize) break;
1891                 /* draw lines */
1892                 gfx_new_dashed_line ( im->canvas,
1893                     X0-1,Y0,
1894                     X1+1,Y0,
1895                     GRIDWIDTH, im->graph_col[GRC_GRID],
1896                     im->grid_dash_on, im->grid_dash_off);
1897             }
1898         }
1899         else if(exfrac > 1) {
1900             for(i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) {
1901                 value = pow(10.0, i);
1902                 if(value < im->minval) continue;
1904                 Y0 = ytr(im, value);
1905                 if(Y0 <= im->yorigin - im->ysize) break;
1907                 /* draw lines */
1908                 gfx_new_dashed_line ( im->canvas,
1909                     X0-1,Y0,
1910                     X1+1,Y0,
1911                     GRIDWIDTH, im->graph_col[GRC_GRID],
1912                     im->grid_dash_on, im->grid_dash_off);
1913             }
1914         }
1916         /* next decade */
1917         if(yloglab[mid][++flab] == 10.0) {
1918             flab = 0;
1919             val_exp += exfrac;
1920         }
1921     }
1923     /* draw minor lines after highest major line */
1924     if(mid < 4 && exfrac == 1) {
1925         /* find first and last minor line below current major line
1926          * i is the first line and j tha last */
1927         if(flab == 0) {
1928             min_exp = val_exp - 1;
1929             for(i = 1; yloglab[mid][i] < 10.0; i++);
1930             i = yloglab[mid][i - 1] + 1;
1931             j = 10;
1932         }
1933         else {
1934             min_exp = val_exp;
1935             i = yloglab[mid][flab - 1] + 1;
1936             j = yloglab[mid][flab];
1937         }
1939         /* draw minor lines below current major line */
1940         for(; i < j; i++) {
1942             value = i * pow(10.0, min_exp);
1943             if(value < im->minval) continue;
1945             Y0 = ytr(im, value);
1946             if(Y0 <= im->yorigin - im->ysize) break;
1948             /* draw lines */
1949             gfx_new_dashed_line ( im->canvas,
1950                 X0-1,Y0,
1951                 X1+1,Y0,
1952                 GRIDWIDTH, im->graph_col[GRC_GRID],
1953                 im->grid_dash_on, im->grid_dash_off);
1954         }
1955     }
1956     /* fancy minor gridlines */
1957     else if(exfrac > 1) {
1958         for(i = val_exp - exfrac / 3 * 2; i < val_exp; i += exfrac / 3) {
1959             value = pow(10.0, i);
1960             if(value < im->minval) continue;
1962             Y0 = ytr(im, value);
1963             if(Y0 <= im->yorigin - im->ysize) break;
1965             /* draw lines */
1966             gfx_new_dashed_line ( im->canvas,
1967                 X0-1,Y0,
1968                 X1+1,Y0,
1969                 GRIDWIDTH, im->graph_col[GRC_GRID],
1970                 im->grid_dash_on, im->grid_dash_off);
1971         }
1972     }
1974     return 1;
1978 void
1979 vertical_grid(
1980     image_desc_t   *im )
1981 {   
1982     int xlab_sel;               /* which sort of label and grid ? */
1983     time_t ti, tilab, timajor;
1984     long factor;
1985     char graph_label[100];
1986     double X0,Y0,Y1; /* points for filled graph and more*/
1987     struct tm tm;
1989     /* the type of time grid is determined by finding
1990        the number of seconds per pixel in the graph */
1991     
1992     
1993     if(im->xlab_user.minsec == -1){
1994         factor=(im->end - im->start)/im->xsize;
1995         xlab_sel=0;
1996         while ( xlab[xlab_sel+1].minsec != -1 
1997                 && xlab[xlab_sel+1].minsec <= factor) { xlab_sel++; }   /* pick the last one */
1998         while ( xlab[xlab_sel-1].minsec == xlab[xlab_sel].minsec
1999                 && xlab[xlab_sel].length > (im->end - im->start)) { xlab_sel--; }       /* go back to the smallest size */
2000         im->xlab_user.gridtm = xlab[xlab_sel].gridtm;
2001         im->xlab_user.gridst = xlab[xlab_sel].gridst;
2002         im->xlab_user.mgridtm = xlab[xlab_sel].mgridtm;
2003         im->xlab_user.mgridst = xlab[xlab_sel].mgridst;
2004         im->xlab_user.labtm = xlab[xlab_sel].labtm;
2005         im->xlab_user.labst = xlab[xlab_sel].labst;
2006         im->xlab_user.precis = xlab[xlab_sel].precis;
2007         im->xlab_user.stst = xlab[xlab_sel].stst;
2008     }
2009     
2010     /* y coords are the same for every line ... */
2011     Y0 = im->yorigin;
2012     Y1 = im->yorigin-im->ysize;
2013    
2015     /* paint the minor grid */
2016     if (!(im->extra_flags & NOMINOR))
2017     {
2018         for(ti = find_first_time(im->start,
2019                                 im->xlab_user.gridtm,
2020                                 im->xlab_user.gridst),
2021             timajor = find_first_time(im->start,
2022                                 im->xlab_user.mgridtm,
2023                                 im->xlab_user.mgridst);
2024             ti < im->end; 
2025             ti = find_next_time(ti,im->xlab_user.gridtm,im->xlab_user.gridst)
2026             ){
2027             /* are we inside the graph ? */
2028             if (ti < im->start || ti > im->end) continue;
2029             while (timajor < ti) {
2030                 timajor = find_next_time(timajor,
2031                         im->xlab_user.mgridtm, im->xlab_user.mgridst);
2032             }
2033             if (ti == timajor) continue; /* skip as falls on major grid line */
2034            X0 = xtr(im,ti);       
2035            gfx_new_dashed_line(im->canvas,X0,Y0+1, X0,Y1-1,GRIDWIDTH,
2036                im->graph_col[GRC_GRID],
2037                im->grid_dash_on, im->grid_dash_off);
2038            
2039         }
2040     }
2042     /* paint the major grid */
2043     for(ti = find_first_time(im->start,
2044                             im->xlab_user.mgridtm,
2045                             im->xlab_user.mgridst);
2046         ti < im->end; 
2047         ti = find_next_time(ti,im->xlab_user.mgridtm,im->xlab_user.mgridst)
2048         ){
2049         /* are we inside the graph ? */
2050         if (ti < im->start || ti > im->end) continue;
2051        X0 = xtr(im,ti);
2052        gfx_new_dashed_line(im->canvas,X0,Y0+3, X0,Y1-2,MGRIDWIDTH,
2053            im->graph_col[GRC_MGRID],
2054            im->grid_dash_on, im->grid_dash_off);
2055        
2056     }
2057     /* paint the labels below the graph */
2058     for(ti = find_first_time(im->start - im->xlab_user.precis/2,
2059                             im->xlab_user.labtm,
2060                             im->xlab_user.labst);
2061         ti <= im->end - im->xlab_user.precis/2; 
2062         ti = find_next_time(ti,im->xlab_user.labtm,im->xlab_user.labst)
2063         ){
2064         tilab= ti + im->xlab_user.precis/2; /* correct time for the label */
2065         /* are we inside the graph ? */
2066         if (tilab < im->start || tilab > im->end) continue;
2068 #if HAVE_STRFTIME
2069         localtime_r(&tilab, &tm);
2070         strftime(graph_label,99,im->xlab_user.stst, &tm);
2071 #else
2072 # error "your libc has no strftime I guess we'll abort the exercise here."
2073 #endif
2074        gfx_new_text ( im->canvas,
2075                       xtr(im,tilab), Y0+im->text_prop[TEXT_PROP_AXIS].size*1.4+5,
2076                       im->graph_col[GRC_FONT],
2077                       im->text_prop[TEXT_PROP_AXIS].font,
2078                       im->text_prop[TEXT_PROP_AXIS].size,
2079                       im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_BOTTOM,
2080                       graph_label );
2081        
2082     }
2087 void 
2088 axis_paint(
2089    image_desc_t   *im
2090            )
2091 {   
2092     /* draw x and y axis */
2093     /* gfx_new_line ( im->canvas, im->xorigin+im->xsize,im->yorigin,
2094                       im->xorigin+im->xsize,im->yorigin-im->ysize,
2095                       GRIDWIDTH, im->graph_col[GRC_AXIS]);
2096        
2097        gfx_new_line ( im->canvas, im->xorigin,im->yorigin-im->ysize,
2098                          im->xorigin+im->xsize,im->yorigin-im->ysize,
2099                          GRIDWIDTH, im->graph_col[GRC_AXIS]); */
2100    
2101        gfx_new_line ( im->canvas, im->xorigin-4,im->yorigin,
2102                          im->xorigin+im->xsize+4,im->yorigin,
2103                          MGRIDWIDTH, im->graph_col[GRC_AXIS]);
2104    
2105        gfx_new_line ( im->canvas, im->xorigin,im->yorigin+4,
2106                          im->xorigin,im->yorigin-im->ysize-4,
2107                          MGRIDWIDTH, im->graph_col[GRC_AXIS]);
2108    
2109     
2110     /* arrow for X and Y axis direction */
2111     gfx_new_area ( im->canvas, 
2112                    im->xorigin+im->xsize+2,  im->yorigin-2,
2113                    im->xorigin+im->xsize+2,  im->yorigin+3,
2114                    im->xorigin+im->xsize+7,  im->yorigin+0.5, /* LINEOFFSET */
2115                    im->graph_col[GRC_ARROW]);
2117     gfx_new_area ( im->canvas, 
2118                    im->xorigin-2,  im->yorigin-im->ysize-2,
2119                    im->xorigin+3,  im->yorigin-im->ysize-2,
2120                    im->xorigin+0.5,    im->yorigin-im->ysize-7, /* LINEOFFSET */
2121                    im->graph_col[GRC_ARROW]);
2125 void
2126 grid_paint(image_desc_t   *im)
2127 {   
2128     long i;
2129     int res=0;
2130     double X0,Y0; /* points for filled graph and more*/
2131     gfx_node_t *node;
2133     /* draw 3d border */
2134     node = gfx_new_area (im->canvas, 0,im->yimg,
2135                                  2,im->yimg-2,
2136                                  2,2,im->graph_col[GRC_SHADEA]);
2137     gfx_add_point( node , im->ximg - 2, 2 );
2138     gfx_add_point( node , im->ximg, 0 );
2139     gfx_add_point( node , 0,0 );
2140 /*    gfx_add_point( node , 0,im->yimg ); */
2141    
2142     node =  gfx_new_area (im->canvas, 2,im->yimg-2,
2143                                   im->ximg-2,im->yimg-2,
2144                                   im->ximg - 2, 2,
2145                                  im->graph_col[GRC_SHADEB]);
2146     gfx_add_point( node ,   im->ximg,0);
2147     gfx_add_point( node ,   im->ximg,im->yimg);
2148     gfx_add_point( node ,   0,im->yimg);
2149 /*    gfx_add_point( node , 0,im->yimg ); */
2150    
2151    
2152     if (im->draw_x_grid == 1 )
2153       vertical_grid(im);
2154     
2155     if (im->draw_y_grid == 1){
2156         if(im->logarithmic){
2157                 res = horizontal_log_grid(im);
2158         } else {
2159                 res = draw_horizontal_grid(im);
2160         }
2161         
2162         /* dont draw horizontal grid if there is no min and max val */
2163         if (! res ) {
2164           char *nodata = "No Data found";
2165            gfx_new_text(im->canvas,im->ximg/2, (2*im->yorigin-im->ysize) / 2,
2166                         im->graph_col[GRC_FONT],
2167                         im->text_prop[TEXT_PROP_AXIS].font,
2168                         im->text_prop[TEXT_PROP_AXIS].size,
2169                         im->tabwidth, 0.0, GFX_H_CENTER, GFX_V_CENTER,
2170                         nodata );          
2171         }
2172     }
2174     /* yaxis unit description */
2175     gfx_new_text( im->canvas,
2176                   10, (im->yorigin - im->ysize/2),
2177                   im->graph_col[GRC_FONT],
2178                   im->text_prop[TEXT_PROP_UNIT].font,
2179                   im->text_prop[TEXT_PROP_UNIT].size, im->tabwidth, 
2180                   RRDGRAPH_YLEGEND_ANGLE,
2181                   GFX_H_LEFT, GFX_V_CENTER,
2182                   im->ylegend);
2184     /* graph title */
2185     gfx_new_text( im->canvas,
2186                   im->ximg/2, im->text_prop[TEXT_PROP_TITLE].size*1.3+4,
2187                   im->graph_col[GRC_FONT],
2188                   im->text_prop[TEXT_PROP_TITLE].font,
2189                   im->text_prop[TEXT_PROP_TITLE].size, im->tabwidth, 0.0,
2190                   GFX_H_CENTER, GFX_V_CENTER,
2191                   im->title);
2192     /* rrdtool 'logo' */
2193     gfx_new_text( im->canvas,
2194                   im->ximg-7, 7,
2195                   ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
2196                   im->text_prop[TEXT_PROP_AXIS].font,
2197                   5.5, im->tabwidth, 270,
2198                   GFX_H_RIGHT, GFX_V_TOP,
2199                   "RRDTOOL / TOBI OETIKER");
2201     /* graph watermark */
2202     if(im->watermark[0] != '\0') {
2203         gfx_new_text( im->canvas,
2204                   im->ximg/2, im->yimg-6,
2205                   ( im->graph_col[GRC_FONT] & 0xffffff00 ) | 0x00000044,
2206                   im->text_prop[TEXT_PROP_AXIS].font,
2207                   5.5, im->tabwidth, 0,
2208                   GFX_H_CENTER, GFX_V_BOTTOM,
2209                   im->watermark);
2210     }
2211     
2212     /* graph labels */
2213     if( !(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH) ) {
2214             for(i=0;i<im->gdes_c;i++){
2215                     if(im->gdes[i].legend[0] =='\0')
2216                             continue;
2217                     
2218                     /* im->gdes[i].leg_y is the bottom of the legend */
2219                     X0 = im->gdes[i].leg_x;
2220                     Y0 = im->gdes[i].leg_y;
2221                     gfx_new_text ( im->canvas, X0, Y0,
2222                                    im->graph_col[GRC_FONT],
2223                                    im->text_prop[TEXT_PROP_LEGEND].font,
2224                                    im->text_prop[TEXT_PROP_LEGEND].size,
2225                                    im->tabwidth,0.0, GFX_H_LEFT, GFX_V_BOTTOM,
2226                                    im->gdes[i].legend );
2227                     /* The legend for GRAPH items starts with "M " to have
2228                        enough space for the box */
2229                     if (           im->gdes[i].gf != GF_PRINT &&
2230                                    im->gdes[i].gf != GF_GPRINT &&
2231                                    im->gdes[i].gf != GF_COMMENT) {
2232                             int boxH, boxV;
2233                             
2234                             boxH = gfx_get_text_width(im->canvas, 0,
2235                                                       im->text_prop[TEXT_PROP_LEGEND].font,
2236                                                       im->text_prop[TEXT_PROP_LEGEND].size,
2237                                                       im->tabwidth,"o", 0) * 1.2;
2238                             boxV = boxH*1.1;
2239                             
2240                             /* make sure transparent colors show up the same way as in the graph */
2241                              node = gfx_new_area(im->canvas,
2242                                                 X0,Y0-boxV,
2243                                                 X0,Y0,
2244                                                 X0+boxH,Y0,
2245                                                 im->graph_col[GRC_BACK]);
2246                             gfx_add_point ( node, X0+boxH, Y0-boxV );
2248                             node = gfx_new_area(im->canvas,
2249                                                 X0,Y0-boxV,
2250                                                 X0,Y0,
2251                                                 X0+boxH,Y0,
2252                                                 im->gdes[i].col);
2253                             gfx_add_point ( node, X0+boxH, Y0-boxV );
2254                             node = gfx_new_line(im->canvas,
2255                                                 X0,Y0-boxV,
2256                                                 X0,Y0,
2257                                                 1.0,im->graph_col[GRC_FRAME]);
2258                             gfx_add_point(node,X0+boxH,Y0);
2259                             gfx_add_point(node,X0+boxH,Y0-boxV);
2260                             gfx_close_path(node);
2261                     }
2262             }
2263     }
2267 /*****************************************************
2268  * lazy check make sure we rely need to create this graph
2269  *****************************************************/
2271 int lazy_check(image_desc_t *im){
2272     FILE *fd = NULL;
2273         int size = 1;
2274     struct stat  imgstat;
2275     
2276     if (im->lazy == 0) return 0; /* no lazy option */
2277     if (stat(im->graphfile,&imgstat) != 0) 
2278       return 0; /* can't stat */
2279     /* one pixel in the existing graph is more then what we would
2280        change here ... */
2281     if (time(NULL) - imgstat.st_mtime > 
2282         (im->end - im->start) / im->xsize) 
2283       return 0;
2284     if ((fd = fopen(im->graphfile,"rb")) == NULL) 
2285       return 0; /* the file does not exist */
2286     switch (im->canvas->imgformat) {
2287     case IF_PNG:
2288            size = PngSize(fd,&(im->ximg),&(im->yimg));
2289            break;
2290     default:
2291            size = 1;
2292     }
2293     fclose(fd);
2294     return size;
2297 #ifdef WITH_PIECHART
2298 void
2299 pie_part(image_desc_t *im, gfx_color_t color,
2300             double PieCenterX, double PieCenterY, double Radius,
2301             double startangle, double endangle)
2303     gfx_node_t *node;
2304     double angle;
2305     double step=M_PI/50; /* Number of iterations for the circle;
2306                          ** 10 is definitely too low, more than
2307                          ** 50 seems to be overkill
2308                          */
2310     /* Strange but true: we have to work clockwise or else
2311     ** anti aliasing nor transparency don't work.
2312     **
2313     ** This test is here to make sure we do it right, also
2314     ** this makes the for...next loop more easy to implement.
2315     ** The return will occur if the user enters a negative number
2316     ** (which shouldn't be done according to the specs) or if the
2317     ** programmers do something wrong (which, as we all know, never
2318     ** happens anyway :)
2319     */
2320     if (endangle<startangle) return;
2322     /* Hidden feature: Radius decreases each full circle */
2323     angle=startangle;
2324     while (angle>=2*M_PI) {
2325         angle  -= 2*M_PI;
2326         Radius *= 0.8;
2327     }
2329     node=gfx_new_area(im->canvas,
2330                 PieCenterX+sin(startangle)*Radius,
2331                 PieCenterY-cos(startangle)*Radius,
2332                 PieCenterX,
2333                 PieCenterY,
2334                 PieCenterX+sin(endangle)*Radius,
2335                 PieCenterY-cos(endangle)*Radius,
2336                 color);
2337     for (angle=endangle;angle-startangle>=step;angle-=step) {
2338         gfx_add_point(node,
2339                 PieCenterX+sin(angle)*Radius,
2340                 PieCenterY-cos(angle)*Radius );
2341     }
2344 #endif
2346 int
2347 graph_size_location(image_desc_t *im, int elements
2349 #ifdef WITH_PIECHART
2350 , int piechart
2351 #endif
2353  )
2355     /* The actual size of the image to draw is determined from
2356     ** several sources.  The size given on the command line is
2357     ** the graph area but we need more as we have to draw labels
2358     ** and other things outside the graph area
2359     */
2361     /* +-+-------------------------------------------+
2362     ** |l|.................title.....................|
2363     ** |e+--+-------------------------------+--------+
2364     ** |b| b|                               |        |
2365     ** |a| a|                               |  pie   |
2366     ** |l| l|          main graph area      | chart  |
2367     ** |.| .|                               |  area  |
2368     ** |t| y|                               |        |
2369     ** |r+--+-------------------------------+--------+
2370     ** |e|  | x-axis labels                 |        |
2371     ** |v+--+-------------------------------+--------+
2372     ** | |..............legends......................|
2373     ** +-+-------------------------------------------+
2374     ** |                 watermark                   |
2375     ** +---------------------------------------------+
2376     */
2377     int Xvertical=0,    
2378                         Ytitle   =0,
2379         Xylabel  =0,    
2380         Xmain    =0,    Ymain    =0,
2381 #ifdef WITH_PIECHART
2382         Xpie     =0,    Ypie     =0,
2383 #endif
2384                         Yxlabel  =0,
2385 #if 0
2386         Xlegend  =0,    Ylegend  =0,
2387 #endif
2388         Xspacing =15,  Yspacing =15,
2389        
2390                       Ywatermark =4;
2392     if (im->extra_flags & ONLY_GRAPH) {
2393         im->xorigin =0;
2394         im->ximg = im->xsize;
2395         im->yimg = im->ysize;
2396         im->yorigin = im->ysize;
2397         ytr(im,DNAN); 
2398         return 0;
2399     }
2401     if (im->ylegend[0] != '\0' ) {
2402            Xvertical = im->text_prop[TEXT_PROP_UNIT].size *2;
2403     }
2406     if (im->title[0] != '\0') {
2407         /* The title is placed "inbetween" two text lines so it
2408         ** automatically has some vertical spacing.  The horizontal
2409         ** spacing is added here, on each side.
2410         */
2411         /* don't care for the with of the title
2412                 Xtitle = gfx_get_text_width(im->canvas, 0,
2413                 im->text_prop[TEXT_PROP_TITLE].font,
2414                 im->text_prop[TEXT_PROP_TITLE].size,
2415                 im->tabwidth,
2416                 im->title, 0) + 2*Xspacing; */
2417         Ytitle = im->text_prop[TEXT_PROP_TITLE].size*2.6+10;
2418     }
2420     if (elements) {
2421         Xmain=im->xsize;
2422         Ymain=im->ysize;
2423         if (im->draw_x_grid) {
2424             Yxlabel=im->text_prop[TEXT_PROP_AXIS].size *2.5;
2425         }
2426         if (im->draw_y_grid) {
2427             Xylabel=gfx_get_text_width(im->canvas, 0,
2428                         im->text_prop[TEXT_PROP_AXIS].font,
2429                         im->text_prop[TEXT_PROP_AXIS].size,
2430                         im->tabwidth,
2431                         "0", 0) * im->unitslength;
2432         }
2433     }
2435 #ifdef WITH_PIECHART
2436     if (piechart) {
2437         im->piesize=im->xsize<im->ysize?im->xsize:im->ysize;
2438         Xpie=im->piesize;
2439         Ypie=im->piesize;
2440     }
2441 #endif
2443     /* Now calculate the total size.  Insert some spacing where
2444        desired.  im->xorigin and im->yorigin need to correspond
2445        with the lower left corner of the main graph area or, if
2446        this one is not set, the imaginary box surrounding the
2447        pie chart area. */
2449     /* The legend width cannot yet be determined, as a result we
2450     ** have problems adjusting the image to it.  For now, we just
2451     ** forget about it at all; the legend will have to fit in the
2452     ** size already allocated.
2453     */
2454     im->ximg = Xylabel + Xmain + 2 * Xspacing;
2456 #ifdef WITH_PIECHART
2457     im->ximg  += Xpie;
2458 #endif
2460     if (Xmain) im->ximg += Xspacing;
2461 #ifdef WITH_PIECHART
2462     if (Xpie) im->ximg += Xspacing;
2463 #endif
2465     im->xorigin = Xspacing + Xylabel;
2467     /* the length of the title should not influence with width of the graph
2468        if (Xtitle > im->ximg) im->ximg = Xtitle; */
2470     if (Xvertical) { /* unit description */
2471         im->ximg += Xvertical;
2472         im->xorigin += Xvertical;
2473     }
2474     xtr(im,0);
2476     /* The vertical size is interesting... we need to compare
2477     ** the sum of {Ytitle, Ymain, Yxlabel, Ylegend, Ywatermark} with 
2478     ** Yvertical however we need to know {Ytitle+Ymain+Yxlabel}
2479     ** in order to start even thinking about Ylegend or Ywatermark.
2480     **
2481     ** Do it in three portions: First calculate the inner part,
2482     ** then do the legend, then adjust the total height of the img,
2483     ** adding space for a watermark if one exists;
2484     */
2486     /* reserve space for main and/or pie */
2488     im->yimg = Ymain + Yxlabel;
2489     
2490 #ifdef WITH_PIECHART
2491     if (im->yimg < Ypie) im->yimg = Ypie;
2492 #endif
2494     im->yorigin = im->yimg - Yxlabel;
2496     /* reserve space for the title *or* some padding above the graph */
2497     if (Ytitle) {
2498         im->yimg += Ytitle;
2499         im->yorigin += Ytitle;
2500     } else {
2501         im->yimg += 1.5*Yspacing;
2502         im->yorigin += 1.5*Yspacing;
2503     }
2504     /* reserve space for padding below the graph */
2505     im->yimg += Yspacing;
2506      
2507     /* Determine where to place the legends onto the image.
2508     ** Adjust im->yimg to match the space requirements.
2509     */
2510     if(leg_place(im)==-1)
2511         return -1;
2512         
2513     if (im->watermark[0] != '\0') {
2514         im->yimg += Ywatermark;
2515     }
2517 #if 0
2518     if (Xlegend > im->ximg) {
2519         im->ximg = Xlegend;
2520         /* reposition Pie */
2521     }
2522 #endif
2524 #ifdef WITH_PIECHART
2525     /* The pie is placed in the upper right hand corner,
2526     ** just below the title (if any) and with sufficient
2527     ** padding.
2528     */
2529     if (elements) {
2530         im->pie_x = im->ximg - Xspacing - Xpie/2;
2531         im->pie_y = im->yorigin-Ymain+Ypie/2;
2532     } else {
2533         im->pie_x = im->ximg/2;
2534         im->pie_y = im->yorigin-Ypie/2;
2535     }
2536 #endif
2538     ytr(im,DNAN);
2539     return 0;
2542 /* from http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm */
2543 /* yes we are loosing precision by doing tos with floats instead of doubles
2544    but it seems more stable this way. */
2545    
2547 /* draw that picture thing ... */
2548 int
2549 graph_paint(image_desc_t *im, char ***calcpr)
2551   int i,ii;
2552   int lazy =     lazy_check(im);
2553 #ifdef WITH_PIECHART
2554   int piechart = 0;
2555   double PieStart=0.0;
2556 #endif
2557   FILE  *fo;
2558   gfx_node_t *node;
2559   
2560   double areazero = 0.0;
2561   graph_desc_t *lastgdes = NULL;    
2563   /* if we are lazy and there is nothing to PRINT ... quit now */
2564   if (lazy && im->prt_c==0) return 0;
2566   /* pull the data from the rrd files ... */
2567   
2568   if(data_fetch(im)==-1)
2569     return -1;
2571   /* evaluate VDEF and CDEF operations ... */
2572   if(data_calc(im)==-1)
2573     return -1;
2575 #ifdef WITH_PIECHART  
2576   /* check if we need to draw a piechart */
2577   for(i=0;i<im->gdes_c;i++){
2578     if (im->gdes[i].gf == GF_PART) {
2579       piechart=1;
2580       break;
2581     }
2582   }
2583 #endif
2585   /* calculate and PRINT and GPRINT definitions. We have to do it at
2586    * this point because it will affect the length of the legends
2587    * if there are no graph elements we stop here ... 
2588    * if we are lazy, try to quit ... 
2589    */
2590   i=print_calc(im,calcpr);
2591   if(i<0) return -1;
2592   if(((i==0)
2593 #ifdef WITH_PIECHART
2594 &&(piechart==0)
2595 #endif
2596 ) || lazy) return 0;
2598 #ifdef WITH_PIECHART
2599   /* If there's only the pie chart to draw, signal this */
2600   if (i==0) piechart=2;
2601 #endif
2602   
2603   /* get actual drawing data and find min and max values*/
2604   if(data_proc(im)==-1)
2605     return -1;
2606   
2607   if(!im->logarithmic){si_unit(im);}        /* identify si magnitude Kilo, Mega Giga ? */
2608   
2609   if(!im->rigid && ! im->logarithmic)
2610     expand_range(im);   /* make sure the upper and lower limit are
2611                            sensible values */
2613   if (!calc_horizontal_grid(im))
2614     return -1;
2616   if (im->gridfit)
2617     apply_gridfit(im);
2620 /**************************************************************
2621  *** Calculating sizes and locations became a bit confusing ***
2622  *** so I moved this into a separate function.              ***
2623  **************************************************************/
2624   if(graph_size_location(im,i
2625 #ifdef WITH_PIECHART
2626 ,piechart
2627 #endif
2628 )==-1)
2629     return -1;
2631   /* the actual graph is created by going through the individual
2632      graph elements and then drawing them */
2633   
2634   node=gfx_new_area ( im->canvas,
2635                       0, 0,
2636                       0, im->yimg,
2637                       im->ximg, im->yimg,                      
2638                       im->graph_col[GRC_BACK]);
2640   gfx_add_point(node,im->ximg, 0);
2642 #ifdef WITH_PIECHART
2643   if (piechart != 2) {
2644 #endif
2645     node=gfx_new_area ( im->canvas,
2646                       im->xorigin,             im->yorigin, 
2647                       im->xorigin + im->xsize, im->yorigin,
2648                       im->xorigin + im->xsize, im->yorigin-im->ysize,
2649                       im->graph_col[GRC_CANVAS]);
2650   
2651     gfx_add_point(node,im->xorigin, im->yorigin - im->ysize);
2653     if (im->minval > 0.0)
2654       areazero = im->minval;
2655     if (im->maxval < 0.0)
2656       areazero = im->maxval;
2657 #ifdef WITH_PIECHART
2658    }
2659 #endif
2661 #ifdef WITH_PIECHART
2662   if (piechart) {
2663     pie_part(im,im->graph_col[GRC_CANVAS],im->pie_x,im->pie_y,im->piesize*0.5,0,2*M_PI);
2664   }
2665 #endif
2667   for(i=0;i<im->gdes_c;i++){
2668     switch(im->gdes[i].gf){
2669     case GF_CDEF:
2670     case GF_VDEF:
2671     case GF_DEF:
2672     case GF_PRINT:
2673     case GF_GPRINT:
2674     case GF_COMMENT:
2675     case GF_HRULE:
2676     case GF_VRULE:
2677     case GF_XPORT:
2678     case GF_SHIFT:
2679       break;
2680     case GF_TICK:
2681       for (ii = 0; ii < im->xsize; ii++)
2682         {
2683           if (!isnan(im->gdes[i].p_data[ii]) && 
2684               im->gdes[i].p_data[ii] != 0.0)
2685            { 
2686               if (im -> gdes[i].yrule > 0 ) {
2687                       gfx_new_line(im->canvas,
2688                                    im -> xorigin + ii, im->yorigin,
2689                                    im -> xorigin + ii, im->yorigin - im -> gdes[i].yrule * im -> ysize,
2690                                    1.0,
2691                                    im -> gdes[i].col );
2692               } else if ( im -> gdes[i].yrule < 0 ) {
2693                       gfx_new_line(im->canvas,
2694                                    im -> xorigin + ii, im->yorigin - im -> ysize,
2695                                    im -> xorigin + ii, im->yorigin - ( 1 - im -> gdes[i].yrule ) * im -> ysize,
2696                                    1.0,
2697                                    im -> gdes[i].col );
2698               
2699               }
2700            }
2701         }
2702       break;
2703     case GF_LINE:
2704     case GF_AREA:
2705       /* fix data points at oo and -oo */
2706       for(ii=0;ii<im->xsize;ii++){
2707         if (isinf(im->gdes[i].p_data[ii])){
2708           if (im->gdes[i].p_data[ii] > 0) {
2709             im->gdes[i].p_data[ii] = im->maxval ;
2710           } else {
2711             im->gdes[i].p_data[ii] = im->minval ;
2712           }                 
2713           
2714         }
2715       } /* for */
2717       /* *******************************************************
2718        a           ___. (a,t) 
2719                   |   |    ___
2720               ____|   |   |   |
2721               |       |___|
2722        -------|--t-1--t--------------------------------      
2723                       
2724       if we know the value at time t was a then 
2725       we draw a square from t-1 to t with the value a.
2727       ********************************************************* */
2728       if (im->gdes[i].col != 0x0){   
2729         /* GF_LINE and friend */
2730         if(im->gdes[i].gf == GF_LINE ){
2731           double last_y=0.0;
2732           node = NULL;
2733           for(ii=1;ii<im->xsize;ii++){
2734             if (isnan(im->gdes[i].p_data[ii]) || (im->slopemode==1 && isnan(im->gdes[i].p_data[ii-1]))){
2735                 node = NULL;
2736                 continue;
2737             }
2738             if ( node == NULL ) {
2739                 last_y = ytr(im,im->gdes[i].p_data[ii]);
2740                 if ( im->slopemode == 0 ){
2741                   node = gfx_new_line(im->canvas,
2742                                     ii-1+im->xorigin,last_y,
2743                                     ii+im->xorigin,last_y,
2744                                     im->gdes[i].linewidth,
2745                                     im->gdes[i].col);
2746                 } else {
2747                   node = gfx_new_line(im->canvas,
2748                                     ii-1+im->xorigin,ytr(im,im->gdes[i].p_data[ii-1]),
2749                                     ii+im->xorigin,last_y,
2750                                     im->gdes[i].linewidth,
2751                                     im->gdes[i].col);
2752                 }
2753              } else {
2754                double new_y = ytr(im,im->gdes[i].p_data[ii]);
2755                if ( im->slopemode==0 && ! AlmostEqual2sComplement(new_y,last_y,4)){
2756                    gfx_add_point(node,ii-1+im->xorigin,new_y);
2757                };
2758                last_y = new_y;
2759                gfx_add_point(node,ii+im->xorigin,new_y);
2760              };
2762           }
2763         } else {
2764           int idxI=-1;
2765           double *foreY=malloc(sizeof(double)*im->xsize*2);
2766           double *foreX=malloc(sizeof(double)*im->xsize*2);
2767           double *backY=malloc(sizeof(double)*im->xsize*2);
2768           double *backX=malloc(sizeof(double)*im->xsize*2);
2769           int drawem = 0;
2770           for(ii=0;ii<=im->xsize;ii++){
2771             double ybase,ytop;
2772             if ( idxI > 0 && ( drawem != 0 || ii==im->xsize)){
2773                int cntI=1;
2774                int lastI=0;
2775                while (cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;}
2776                node = gfx_new_area(im->canvas,
2777                                 backX[0],backY[0],
2778                                 foreX[0],foreY[0],
2779                                 foreX[cntI],foreY[cntI], im->gdes[i].col);
2780                while (cntI < idxI) {
2781                  lastI = cntI;
2782                  cntI++;
2783                  while ( cntI < idxI && AlmostEqual2sComplement(foreY[lastI],foreY[cntI],4) && AlmostEqual2sComplement(foreY[lastI],foreY[cntI+1],4)){cntI++;} 
2784                  gfx_add_point(node,foreX[cntI],foreY[cntI]);
2785                }
2786                gfx_add_point(node,backX[idxI],backY[idxI]);
2787                while (idxI > 1){
2788                  lastI = idxI;
2789                  idxI--;
2790                  while ( idxI > 1 && AlmostEqual2sComplement(backY[lastI], backY[idxI],4) && AlmostEqual2sComplement(backY[lastI],backY[idxI-1],4)){idxI--;} 
2791                  gfx_add_point(node,backX[idxI],backY[idxI]);
2792                }
2793                idxI=-1;
2794                drawem = 0;
2795             }
2796             if (drawem != 0){
2797               drawem = 0;
2798               idxI=-1;
2799             }
2800             if (ii == im->xsize) break;
2801             
2802             /* keep things simple for now, just draw these bars
2803                do not try to build a big and complex area */
2805                                                               
2806             if ( im->slopemode == 0 && ii==0){
2807                 continue;
2808             }
2809             if ( isnan(im->gdes[i].p_data[ii]) ) {
2810                 drawem = 1;
2811                 continue;
2812             }
2813             ytop = ytr(im,im->gdes[i].p_data[ii]);
2814             if ( lastgdes && im->gdes[i].stack ) {
2815                   ybase = ytr(im,lastgdes->p_data[ii]);
2816             } else {
2817                   ybase = ytr(im,areazero);
2818             }
2819             if ( ybase == ytop ){
2820                 drawem = 1;
2821                 continue;       
2822             }
2823             /* every area has to be wound clock-wise,
2824                so we have to make sur base remains base  */             
2825             if (ybase > ytop){
2826                 double extra = ytop;
2827                 ytop = ybase;
2828                 ybase = extra;
2829             }
2830             if ( im->slopemode == 0 ){
2831                     backY[++idxI] = ybase-0.2;
2832                     backX[idxI] = ii+im->xorigin-1;
2833                     foreY[idxI] = ytop+0.2;
2834                     foreX[idxI] = ii+im->xorigin-1;
2835             }
2836             backY[++idxI] = ybase-0.2;
2837             backX[idxI] = ii+im->xorigin;
2838             foreY[idxI] = ytop+0.2;
2839             foreX[idxI] = ii+im->xorigin;
2840           }
2841           /* close up any remaining area */             
2842           free(foreY);
2843           free(foreX);
2844           free(backY);
2845           free(backX);
2846         } /* else GF_LINE */
2847       } /* if color != 0x0 */
2848       /* make sure we do not run into trouble when stacking on NaN */
2849       for(ii=0;ii<im->xsize;ii++){
2850         if (isnan(im->gdes[i].p_data[ii])) {
2851           if (lastgdes && (im->gdes[i].stack)) {
2852             im->gdes[i].p_data[ii] = lastgdes->p_data[ii];
2853           } else {
2854             im->gdes[i].p_data[ii] = areazero;
2855           }
2856         }
2857       } 
2858       lastgdes = &(im->gdes[i]);                         
2859       break;
2860 #ifdef WITH_PIECHART
2861     case GF_PART:
2862       if(isnan(im->gdes[i].yrule)) /* fetch variable */
2863         im->gdes[i].yrule = im->gdes[im->gdes[i].vidx].vf.val;
2864      
2865       if (finite(im->gdes[i].yrule)) {  /* even the fetched var can be NaN */
2866         pie_part(im,im->gdes[i].col,
2867                 im->pie_x,im->pie_y,im->piesize*0.4,
2868                 M_PI*2.0*PieStart/100.0,
2869                 M_PI*2.0*(PieStart+im->gdes[i].yrule)/100.0);
2870         PieStart += im->gdes[i].yrule;
2871       }
2872       break;
2873 #endif
2874     case GF_STACK:
2875       rrd_set_error("STACK should already be turned into LINE or AREA here");
2876       return -1;
2877       break;
2878         
2879     } /* switch */
2880   }
2881 #ifdef WITH_PIECHART
2882   if (piechart==2) {
2883     im->draw_x_grid=0;
2884     im->draw_y_grid=0;
2885   }
2886 #endif
2889   /* grid_paint also does the text */
2890   if( !(im->extra_flags & ONLY_GRAPH) )  
2891     grid_paint(im);
2893   
2894   if( !(im->extra_flags & ONLY_GRAPH) )  
2895       axis_paint(im);
2896   
2897   /* the RULES are the last thing to paint ... */
2898   for(i=0;i<im->gdes_c;i++){    
2899     
2900     switch(im->gdes[i].gf){
2901     case GF_HRULE:
2902       if(im->gdes[i].yrule >= im->minval
2903          && im->gdes[i].yrule <= im->maxval)
2904         gfx_new_line(im->canvas,
2905                      im->xorigin,ytr(im,im->gdes[i].yrule),
2906                      im->xorigin+im->xsize,ytr(im,im->gdes[i].yrule),
2907                      1.0,im->gdes[i].col); 
2908       break;
2909     case GF_VRULE:
2910       if(im->gdes[i].xrule >= im->start
2911          && im->gdes[i].xrule <= im->end)
2912         gfx_new_line(im->canvas,
2913                      xtr(im,im->gdes[i].xrule),im->yorigin,
2914                      xtr(im,im->gdes[i].xrule),im->yorigin-im->ysize,
2915                      1.0,im->gdes[i].col); 
2916       break;
2917     default:
2918       break;
2919     }
2920   }
2922   
2923   if (strcmp(im->graphfile,"-")==0) {
2924     fo = im->graphhandle ? im->graphhandle : stdout;
2925 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
2926     /* Change translation mode for stdout to BINARY */
2927     _setmode( _fileno( fo ), O_BINARY );
2928 #endif
2929   } else {
2930     if ((fo = fopen(im->graphfile,"wb")) == NULL) {
2931       rrd_set_error("Opening '%s' for write: %s",im->graphfile,
2932                     rrd_strerror(errno));
2933       return (-1);
2934     }
2935   }
2936   gfx_render (im->canvas,im->ximg,im->yimg,0x00000000,fo);
2937   if (strcmp(im->graphfile,"-") != 0)
2938     fclose(fo);
2939   return 0;
2943 /*****************************************************
2944  * graph stuff 
2945  *****************************************************/
2947 int
2948 gdes_alloc(image_desc_t *im){
2950     im->gdes_c++;
2951     if ((im->gdes = (graph_desc_t *) rrd_realloc(im->gdes, (im->gdes_c)
2952                                            * sizeof(graph_desc_t)))==NULL){
2953         rrd_set_error("realloc graph_descs");
2954         return -1;
2955     }
2958     im->gdes[im->gdes_c-1].step=im->step;
2959     im->gdes[im->gdes_c-1].step_orig=im->step;
2960     im->gdes[im->gdes_c-1].stack=0;
2961     im->gdes[im->gdes_c-1].linewidth=0;
2962     im->gdes[im->gdes_c-1].debug=0;
2963     im->gdes[im->gdes_c-1].start=im->start; 
2964     im->gdes[im->gdes_c-1].start_orig=im->start; 
2965     im->gdes[im->gdes_c-1].end=im->end; 
2966     im->gdes[im->gdes_c-1].end_orig=im->end; 
2967     im->gdes[im->gdes_c-1].vname[0]='\0'; 
2968     im->gdes[im->gdes_c-1].data=NULL;
2969     im->gdes[im->gdes_c-1].ds_namv=NULL;
2970     im->gdes[im->gdes_c-1].data_first=0;
2971     im->gdes[im->gdes_c-1].p_data=NULL;
2972     im->gdes[im->gdes_c-1].rpnp=NULL;
2973     im->gdes[im->gdes_c-1].shift=0;
2974     im->gdes[im->gdes_c-1].col = 0x0;
2975     im->gdes[im->gdes_c-1].legend[0]='\0';
2976     im->gdes[im->gdes_c-1].format[0]='\0';
2977     im->gdes[im->gdes_c-1].strftm=0;   
2978     im->gdes[im->gdes_c-1].rrd[0]='\0';
2979     im->gdes[im->gdes_c-1].ds=-1;    
2980     im->gdes[im->gdes_c-1].cf_reduce=CF_AVERAGE;    
2981     im->gdes[im->gdes_c-1].cf=CF_AVERAGE;    
2982     im->gdes[im->gdes_c-1].p_data=NULL;    
2983     im->gdes[im->gdes_c-1].yrule=DNAN;
2984     im->gdes[im->gdes_c-1].xrule=0;
2985     return 0;
2988 /* copies input untill the first unescaped colon is found
2989    or until input ends. backslashes have to be escaped as well */
2990 int
2991 scan_for_col(const char *const input, int len, char *const output)
2993     int inp,outp=0;
2994     for (inp=0; 
2995          inp < len &&
2996            input[inp] != ':' &&
2997            input[inp] != '\0';
2998          inp++){
2999       if (input[inp] == '\\' &&
3000           input[inp+1] != '\0' && 
3001           (input[inp+1] == '\\' ||
3002            input[inp+1] == ':')){
3003         output[outp++] = input[++inp];
3004       }
3005       else {
3006         output[outp++] = input[inp];
3007       }
3008     }
3009     output[outp] = '\0';
3010     return inp;
3012 /* Some surgery done on this function, it became ridiculously big.
3013 ** Things moved:
3014 ** - initializing     now in rrd_graph_init()
3015 ** - options parsing  now in rrd_graph_options()
3016 ** - script parsing   now in rrd_graph_script()
3017 */
3018 int 
3019 rrd_graph(int argc, char **argv, char ***prdata, int *xsize, int *ysize, FILE *stream, double *ymin, double *ymax)
3021     image_desc_t   im;
3022     rrd_graph_init(&im);
3023     im.graphhandle = stream;
3024     
3025     rrd_graph_options(argc,argv,&im);
3026     if (rrd_test_error()) {
3027         im_free(&im);
3028         return -1;
3029     }
3030     
3031     if (strlen(argv[optind])>=MAXPATH) {
3032         rrd_set_error("filename (including path) too long");
3033         im_free(&im);
3034         return -1;
3035     }
3036     strncpy(im.graphfile,argv[optind],MAXPATH-1);
3037     im.graphfile[MAXPATH-1]='\0';
3039     rrd_graph_script(argc,argv,&im,1);
3040     if (rrd_test_error()) {
3041         im_free(&im);
3042         return -1;
3043     }
3045     /* Everything is now read and the actual work can start */
3047     (*prdata)=NULL;
3048     if (graph_paint(&im,prdata)==-1){
3049         im_free(&im);
3050         return -1;
3051     }
3053     /* The image is generated and needs to be output.
3054     ** Also, if needed, print a line with information about the image.
3055     */
3057     *xsize=im.ximg;
3058     *ysize=im.yimg;
3059     *ymin=im.minval;
3060     *ymax=im.maxval;
3061     if (im.imginfo) {
3062         char *filename;
3063         if (!(*prdata)) {
3064             /* maybe prdata is not allocated yet ... lets do it now */
3065             if ((*prdata = calloc(2,sizeof(char *)))==NULL) {
3066                 rrd_set_error("malloc imginfo");
3067                 return -1; 
3068             };
3069         }
3070         if(((*prdata)[0] = malloc((strlen(im.imginfo)+200+strlen(im.graphfile))*sizeof(char)))
3071          ==NULL){
3072             rrd_set_error("malloc imginfo");
3073             return -1;
3074         }
3075         filename=im.graphfile+strlen(im.graphfile);
3076         while(filename > im.graphfile) {
3077             if (*(filename-1)=='/' || *(filename-1)=='\\' ) break;
3078             filename--;
3079         }
3081         sprintf((*prdata)[0],im.imginfo,filename,(long)(im.canvas->zoom*im.ximg),(long)(im.canvas->zoom*im.yimg));
3082     }
3083     im_free(&im);
3084     return 0;
3087 void
3088 rrd_graph_init(image_desc_t *im)
3090     unsigned int i;
3092 #ifdef HAVE_TZSET
3093     tzset();
3094 #endif
3095 #ifdef HAVE_SETLOCALE
3096     setlocale(LC_TIME,"");
3097 #ifdef HAVE_MBSTOWCS
3098     setlocale(LC_CTYPE,"");
3099 #endif
3100 #endif
3101     im->yorigin=0;
3102     im->xorigin=0;
3103     im->minval=0;
3104     im->xlab_user.minsec = -1;
3105     im->ximg=0;
3106     im->yimg=0;
3107     im->xsize = 400;
3108     im->ysize = 100;
3109     im->step = 0;
3110     im->ylegend[0] = '\0';
3111     im->title[0] = '\0';
3112     im->watermark[0] = '\0';
3113     im->minval = DNAN;
3114     im->maxval = DNAN;    
3115     im->unitsexponent= 9999;
3116     im->unitslength= 6; 
3117     im->symbol = ' ';
3118     im->viewfactor = 1.0;
3119     im->extra_flags= 0;
3120     im->rigid = 0;
3121     im->gridfit = 1;
3122     im->imginfo = NULL;
3123     im->lazy = 0;
3124     im->slopemode = 0;
3125     im->logarithmic = 0;
3126     im->ygridstep = DNAN;
3127     im->draw_x_grid = 1;
3128     im->draw_y_grid = 1;
3129     im->base = 1000;
3130     im->prt_c = 0;
3131     im->gdes_c = 0;
3132     im->gdes = NULL;
3133     im->canvas = gfx_new_canvas();
3134     im->grid_dash_on = 1;
3135     im->grid_dash_off = 1;
3136     im->tabwidth = 40.0;
3137     
3138     for(i=0;i<DIM(graph_col);i++)
3139         im->graph_col[i]=graph_col[i];
3141 #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__CYGWIN32__)
3142     {
3143             char *windir; 
3144             char rrd_win_default_font[1000];
3145             windir = getenv("windir");
3146             /* %windir% is something like D:\windows or C:\winnt */
3147             if (windir != NULL) {
3148                     strncpy(rrd_win_default_font,windir,500);
3149                     rrd_win_default_font[500] = '\0';
3150                     strcat(rrd_win_default_font,"\\fonts\\");
3151                     strcat(rrd_win_default_font,RRD_DEFAULT_FONT);         
3152                     for(i=0;i<DIM(text_prop);i++){
3153                             strncpy(text_prop[i].font,rrd_win_default_font,sizeof(text_prop[i].font)-1);
3154                             text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
3155                      }
3156              }
3157     }
3158 #endif
3159     {
3160             char *deffont; 
3161             deffont = getenv("RRD_DEFAULT_FONT");
3162             if (deffont != NULL) {
3163                  for(i=0;i<DIM(text_prop);i++){
3164                         strncpy(text_prop[i].font,deffont,sizeof(text_prop[i].font)-1);
3165                         text_prop[i].font[sizeof(text_prop[i].font)-1] = '\0';
3166                  }
3167             }
3168     }
3169     for(i=0;i<DIM(text_prop);i++){        
3170       im->text_prop[i].size = text_prop[i].size;
3171       strcpy(im->text_prop[i].font,text_prop[i].font);
3172     }
3175 void
3176 rrd_graph_options(int argc, char *argv[],image_desc_t *im)
3178     int                 stroff;    
3179     char                *parsetime_error = NULL;
3180     char                scan_gtm[12],scan_mtm[12],scan_ltm[12],col_nam[12];
3181     time_t              start_tmp=0,end_tmp=0;
3182     long                long_tmp;
3183     struct rrd_time_value       start_tv, end_tv;
3184     gfx_color_t         color;
3185     optind = 0; opterr = 0;  /* initialize getopt */
3187     parsetime("end-24h", &start_tv);
3188     parsetime("now", &end_tv);
3190     /* defines for long options without a short equivalent. should be bytes,
3191        and may not collide with (the ASCII value of) short options */
3192     #define LONGOPT_UNITS_SI 255
3194     while (1){
3195         static struct option long_options[] =
3196         {
3197             {"start",      required_argument, 0,  's'},
3198             {"end",        required_argument, 0,  'e'},
3199             {"x-grid",     required_argument, 0,  'x'},
3200             {"y-grid",     required_argument, 0,  'y'},
3201             {"vertical-label",required_argument,0,'v'},
3202             {"width",      required_argument, 0,  'w'},
3203             {"height",     required_argument, 0,  'h'},
3204             {"interlaced", no_argument,       0,  'i'},
3205             {"upper-limit",required_argument, 0,  'u'},
3206             {"lower-limit",required_argument, 0,  'l'},
3207             {"rigid",      no_argument,       0,  'r'},
3208             {"base",       required_argument, 0,  'b'},
3209             {"logarithmic",no_argument,       0,  'o'},
3210             {"color",      required_argument, 0,  'c'},
3211             {"font",       required_argument, 0,  'n'},
3212             {"title",      required_argument, 0,  't'},
3213             {"imginfo",    required_argument, 0,  'f'},
3214             {"imgformat",  required_argument, 0,  'a'},
3215             {"lazy",       no_argument,       0,  'z'},
3216             {"zoom",       required_argument, 0,  'm'},
3217             {"no-legend",  no_argument,       0,  'g'},
3218             {"force-rules-legend",no_argument,0,  'F'},
3219             {"only-graph", no_argument,       0,  'j'},
3220             {"alt-y-grid", no_argument,       0,  'Y'},
3221             {"no-minor",   no_argument,       0,  'I'},
3222             {"slope-mode", no_argument,       0,  'E'},
3223             {"alt-autoscale", no_argument,    0,  'A'},
3224             {"alt-autoscale-max", no_argument, 0, 'M'},
3225             {"no-gridfit", no_argument,       0,   'N'},
3226             {"units-exponent",required_argument, 0, 'X'},
3227             {"units-length",required_argument, 0, 'L'},
3228             {"units",      required_argument, 0,  LONGOPT_UNITS_SI },
3229             {"step",       required_argument, 0,    'S'},
3230             {"tabwidth",   required_argument, 0,    'T'},            
3231             {"font-render-mode", required_argument, 0, 'R'},
3232             {"font-smoothing-threshold", required_argument, 0, 'B'},
3233             {"watermark",  required_argument, 0,  'W'},
3234             {"alt-y-mrtg", no_argument,       0,  1000}, /* this has no effect it is just here to save old apps from crashing when they use it */
3235             {0,0,0,0}};
3236         int option_index = 0;
3237         int opt;
3238         int col_start,col_end;
3240         opt = getopt_long(argc, argv, 
3241                          "s:e:x:y:v:w:h:iu:l:rb:oc:n:m:t:f:a:I:zgjFYAMEX:L:S:T:NR:B:W:",
3242                           long_options, &option_index);
3244         if (opt == EOF)
3245             break;
3246         
3247         switch(opt) {
3248         case 'I':
3249             im->extra_flags |= NOMINOR;
3250             break;
3251         case 'Y':
3252             im->extra_flags |= ALTYGRID;
3253             break;
3254         case 'A':
3255             im->extra_flags |= ALTAUTOSCALE;
3256             break;
3257         case 'M':
3258             im->extra_flags |= ALTAUTOSCALE_MAX;
3259             break;
3260         case 'j':
3261            im->extra_flags |= ONLY_GRAPH;
3262            break;
3263         case 'g':
3264             im->extra_flags |= NOLEGEND;
3265             break;
3266         case 'F':
3267             im->extra_flags |= FORCE_RULES_LEGEND;
3268             break;
3269         case LONGOPT_UNITS_SI:
3270             if(im->extra_flags & FORCE_UNITS) {
3271                 rrd_set_error("--units can only be used once!");
3272                 return;
3273             }
3274             if(strcmp(optarg,"si")==0)
3275                 im->extra_flags |= FORCE_UNITS_SI;
3276             else {
3277                 rrd_set_error("invalid argument for --units: %s", optarg );
3278                 return;
3279             }
3280             break;
3281         case 'X':
3282             im->unitsexponent = atoi(optarg);
3283             break;
3284         case 'L':
3285             im->unitslength = atoi(optarg);
3286             break;
3287         case 'T':
3288             im->tabwidth = atof(optarg);
3289             break;
3290         case 'S':
3291             im->step =  atoi(optarg);
3292             break;
3293         case 'N':
3294             im->gridfit = 0;
3295             break;
3296         case 's':
3297             if ((parsetime_error = parsetime(optarg, &start_tv))) {
3298                 rrd_set_error( "start time: %s", parsetime_error );
3299                 return;
3300             }
3301             break;
3302         case 'e':
3303             if ((parsetime_error = parsetime(optarg, &end_tv))) {
3304                 rrd_set_error( "end time: %s", parsetime_error );
3305                 return;
3306             }
3307             break;
3308         case 'x':
3309             if(strcmp(optarg,"none") == 0){
3310               im->draw_x_grid=0;
3311               break;
3312             };
3313                 
3314             if(sscanf(optarg,
3315                       "%10[A-Z]:%ld:%10[A-Z]:%ld:%10[A-Z]:%ld:%ld:%n",
3316                       scan_gtm,
3317                       &im->xlab_user.gridst,
3318                       scan_mtm,
3319                       &im->xlab_user.mgridst,
3320                       scan_ltm,
3321                       &im->xlab_user.labst,
3322                       &im->xlab_user.precis,
3323                       &stroff) == 7 && stroff != 0){
3324                 strncpy(im->xlab_form, optarg+stroff, sizeof(im->xlab_form) - 1);
3325                 im->xlab_form[sizeof(im->xlab_form)-1] = '\0'; 
3326                 if((int)(im->xlab_user.gridtm = tmt_conv(scan_gtm)) == -1){
3327                     rrd_set_error("unknown keyword %s",scan_gtm);
3328                     return;
3329                 } else if ((int)(im->xlab_user.mgridtm = tmt_conv(scan_mtm)) == -1){
3330                     rrd_set_error("unknown keyword %s",scan_mtm);
3331                     return;
3332                 } else if ((int)(im->xlab_user.labtm = tmt_conv(scan_ltm)) == -1){
3333                     rrd_set_error("unknown keyword %s",scan_ltm);
3334                     return;
3335                 } 
3336                 im->xlab_user.minsec = 1;
3337                 im->xlab_user.stst = im->xlab_form;
3338             } else {
3339                 rrd_set_error("invalid x-grid format");
3340                 return;
3341             }
3342             break;
3343         case 'y':
3345             if(strcmp(optarg,"none") == 0){
3346               im->draw_y_grid=0;
3347               break;
3348             };
3350             if(sscanf(optarg,
3351                       "%lf:%d",
3352                       &im->ygridstep,
3353                       &im->ylabfact) == 2) {
3354                 if(im->ygridstep<=0){
3355                     rrd_set_error("grid step must be > 0");
3356                     return;
3357                 } else if (im->ylabfact < 1){
3358                     rrd_set_error("label factor must be > 0");
3359                     return;
3360                 } 
3361             } else {
3362                 rrd_set_error("invalid y-grid format");
3363                 return;
3364             }
3365             break;
3366         case 'v':
3367             strncpy(im->ylegend,optarg,150);
3368             im->ylegend[150]='\0';
3369             break;
3370         case 'u':
3371             im->maxval = atof(optarg);
3372             break;
3373         case 'l':
3374             im->minval = atof(optarg);
3375             break;
3376         case 'b':
3377             im->base = atol(optarg);
3378             if(im->base != 1024 && im->base != 1000 ){
3379                 rrd_set_error("the only sensible value for base apart from 1000 is 1024");
3380                 return;
3381             }
3382             break;
3383         case 'w':
3384             long_tmp = atol(optarg);
3385             if (long_tmp < 10) {
3386                 rrd_set_error("width below 10 pixels");
3387                 return;
3388             }
3389             im->xsize = long_tmp;
3390             break;
3391         case 'h':
3392             long_tmp = atol(optarg);
3393             if (long_tmp < 10) {
3394                 rrd_set_error("height below 10 pixels");
3395                 return;
3396             }
3397             im->ysize = long_tmp;
3398             break;
3399         case 'i':
3400             im->canvas->interlaced = 1;
3401             break;
3402         case 'r':
3403             im->rigid = 1;
3404             break;
3405         case 'f':
3406             im->imginfo = optarg;
3407             break;
3408         case 'a':
3409             if((int)(im->canvas->imgformat = if_conv(optarg)) == -1) {
3410                 rrd_set_error("unsupported graphics format '%s'",optarg);
3411                 return;
3412             }
3413             break;
3414         case 'z':
3415             im->lazy = 1;
3416             break;
3417         case 'E':
3418             im->slopemode = 1;
3419             break;
3421         case 'o':
3422             im->logarithmic = 1;
3423             break;
3424         case 'c':
3425             if(sscanf(optarg,
3426                       "%10[A-Z]#%n%8lx%n",
3427                       col_nam,&col_start,&color,&col_end) == 2){
3428                 int ci;
3429                 int col_len = col_end - col_start;
3430                 switch (col_len){
3431                         case 3:
3432                                 color = (
3433                                         ((color & 0xF00) * 0x110000) |
3434                                         ((color & 0x0F0) * 0x011000) |
3435                                         ((color & 0x00F) * 0x001100) |
3436                                         0x000000FF
3437                                         );
3438                                 break;
3439                         case 4:
3440                                 color = (
3441                                         ((color & 0xF000) * 0x11000) |
3442                                         ((color & 0x0F00) * 0x01100) |
3443                                         ((color & 0x00F0) * 0x00110) |
3444                                         ((color & 0x000F) * 0x00011)
3445                                         );
3446                                 break;
3447                         case 6:
3448                                 color = (color << 8) + 0xff /* shift left by 8 */;
3449                                 break;
3450                         case 8:
3451                                 break;
3452                         default:
3453                                 rrd_set_error("the color format is #RRGGBB[AA]");
3454                                 return;
3455                 }
3456                 if((ci=grc_conv(col_nam)) != -1){
3457                     im->graph_col[ci]=color;
3458                 }  else {
3459                   rrd_set_error("invalid color name '%s'",col_nam);
3460                   return;
3461                 }
3462             } else {
3463                 rrd_set_error("invalid color def format");
3464                 return;
3465             }
3466             break;        
3467         case 'n':{
3468             char prop[15];
3469             double size = 1;
3470             char font[1024] = "";
3472             if(sscanf(optarg,
3473                                 "%10[A-Z]:%lf:%1000s",
3474                                 prop,&size,font) >= 2){
3475                 int sindex,propidx;
3476                 if((sindex=text_prop_conv(prop)) != -1){
3477                   for (propidx=sindex;propidx<TEXT_PROP_LAST;propidx++){                      
3478                       if (size > 0){
3479                           im->text_prop[propidx].size=size;              
3480                       }
3481                       if (strlen(font) > 0){
3482                           strcpy(im->text_prop[propidx].font,font);
3483                       }
3484                       if (propidx==sindex && sindex != 0) break;
3485                   }
3486                 } else {
3487                     rrd_set_error("invalid fonttag '%s'",prop);
3488                     return;
3489                 }
3490             } else {
3491                 rrd_set_error("invalid text property format");
3492                 return;
3493             }
3494             break;          
3495         }
3496         case 'm':
3497             im->canvas->zoom = atof(optarg);
3498             if (im->canvas->zoom <= 0.0) {
3499                 rrd_set_error("zoom factor must be > 0");
3500                 return;
3501             }
3502           break;
3503         case 't':
3504             strncpy(im->title,optarg,150);
3505             im->title[150]='\0';
3506             break;
3508         case 'R':
3509                 if ( strcmp( optarg, "normal" ) == 0 )
3510                         im->canvas->aa_type = AA_NORMAL;
3511                 else if ( strcmp( optarg, "light" ) == 0 )
3512                         im->canvas->aa_type = AA_LIGHT;
3513                 else if ( strcmp( optarg, "mono" ) == 0 )
3514                         im->canvas->aa_type = AA_NONE;
3515                 else
3516                 {
3517                         rrd_set_error("unknown font-render-mode '%s'", optarg );
3518                         return;
3519                 }
3520                 break;
3522         case 'B':
3523             im->canvas->font_aa_threshold = atof(optarg);
3524                 break;
3526         case 'W':
3527             strncpy(im->watermark,optarg,100);
3528             im->watermark[99]='\0';
3529             break;
3531         case '?':
3532             if (optopt != 0)
3533                 rrd_set_error("unknown option '%c'", optopt);
3534             else
3535                 rrd_set_error("unknown option '%s'",argv[optind-1]);
3536             return;
3537         }
3538     }
3539     
3540     if (optind >= argc) {
3541        rrd_set_error("missing filename");
3542        return;
3543     }
3545     if (im->logarithmic == 1 && im->minval <= 0){
3546         rrd_set_error("for a logarithmic yaxis you must specify a lower-limit > 0");    
3547         return;
3548     }
3550     if (proc_start_end(&start_tv,&end_tv,&start_tmp,&end_tmp) == -1){
3551         /* error string is set in parsetime.c */
3552         return;
3553     }  
3554     
3555     if (start_tmp < 3600*24*365*10){
3556         rrd_set_error("the first entry to fetch should be after 1980 (%ld)",start_tmp);
3557         return;
3558     }
3559     
3560     if (end_tmp < start_tmp) {
3561         rrd_set_error("start (%ld) should be less than end (%ld)", 
3562                start_tmp, end_tmp);
3563         return;
3564     }
3565     
3566     im->start = start_tmp;
3567     im->end = end_tmp;
3568     im->step = max((long)im->step, (im->end-im->start)/im->xsize);
3571 int
3572 rrd_graph_check_vname(image_desc_t *im, char *varname, char *err)
3574     if ((im->gdes[im->gdes_c-1].vidx=find_var(im,varname))==-1) {
3575         rrd_set_error("Unknown variable '%s' in %s",varname,err);
3576         return -1;
3577     }
3578     return 0;
3580 int
3581 rrd_graph_color(image_desc_t *im, char *var, char *err, int optional)
3583     char *color;
3584     graph_desc_t *gdp=&im->gdes[im->gdes_c-1];
3586     color=strstr(var,"#");
3587     if (color==NULL) {
3588         if (optional==0) {
3589             rrd_set_error("Found no color in %s",err);
3590             return 0;
3591         }
3592         return 0;
3593     } else {
3594         int n=0;
3595         char *rest;
3596         gfx_color_t    col;
3598         rest=strstr(color,":");
3599         if (rest!=NULL)
3600             n=rest-color;
3601         else
3602             n=strlen(color);
3604         switch (n) {
3605             case 7:
3606                 sscanf(color,"#%6lx%n",&col,&n);
3607                 col = (col << 8) + 0xff /* shift left by 8 */;
3608                 if (n!=7) rrd_set_error("Color problem in %s",err);
3609                 break;
3610             case 9:
3611                 sscanf(color,"#%8lx%n",&col,&n);
3612                 if (n==9) break;
3613             default:
3614                 rrd_set_error("Color problem in %s",err);
3615         }
3616         if (rrd_test_error()) return 0;
3617         gdp->col = col;
3618         return n;
3619     }
3623 int bad_format(char *fmt) {
3624     char *ptr;
3625     int n=0;
3626     ptr = fmt;
3627     while (*ptr != '\0')
3628         if (*ptr++ == '%') {
3629  
3630              /* line cannot end with percent char */
3631              if (*ptr == '\0') return 1;
3632  
3633              /* '%s', '%S' and '%%' are allowed */
3634              if (*ptr == 's' || *ptr == 'S' || *ptr == '%') ptr++;
3636              /* %c is allowed (but use only with vdef!) */
3637              else if (*ptr == 'c') {
3638                 ptr++;
3639                 n=1;
3640              }
3642              /* or else '% 6.2lf' and such are allowed */
3643              else {
3644                  /* optional padding character */
3645                  if (*ptr == ' ' || *ptr == '+' || *ptr == '-') ptr++;
3647                  /* This should take care of 'm.n' with all three optional */
3648                  while (*ptr >= '0' && *ptr <= '9') ptr++;
3649                  if (*ptr == '.') ptr++;
3650                  while (*ptr >= '0' && *ptr <= '9') ptr++;
3651   
3652                  /* Either 'le', 'lf' or 'lg' must follow here */
3653                  if (*ptr++ != 'l') return 1;
3654                  if (*ptr == 'e' || *ptr == 'f' || *ptr == 'g') ptr++;
3655                  else return 1;
3656                  n++;
3657             }
3658          }
3659       
3660       return (n!=1); 
3664 int
3665 vdef_parse(gdes,str)
3666 struct graph_desc_t *gdes;
3667 const char *const str;
3669     /* A VDEF currently is either "func" or "param,func"
3670      * so the parsing is rather simple.  Change if needed.
3671      */
3672     double      param;
3673     char        func[30];
3674     int         n;
3675     
3676     n=0;
3677     sscanf(str,"%le,%29[A-Z]%n",&param,func,&n);
3678     if (n== (int)strlen(str)) { /* matched */
3679         ;
3680     } else {
3681         n=0;
3682         sscanf(str,"%29[A-Z]%n",func,&n);
3683         if (n== (int)strlen(str)) { /* matched */
3684             param=DNAN;
3685         } else {
3686             rrd_set_error("Unknown function string '%s' in VDEF '%s'"
3687                 ,str
3688                 ,gdes->vname
3689                 );
3690             return -1;
3691         }
3692     }
3693     if          (!strcmp("PERCENT",func)) gdes->vf.op = VDEF_PERCENT;
3694     else if     (!strcmp("MAXIMUM",func)) gdes->vf.op = VDEF_MAXIMUM;
3695     else if     (!strcmp("AVERAGE",func)) gdes->vf.op = VDEF_AVERAGE;
3696     else if     (!strcmp("MINIMUM",func)) gdes->vf.op = VDEF_MINIMUM;
3697     else if     (!strcmp("TOTAL",  func)) gdes->vf.op = VDEF_TOTAL;
3698     else if     (!strcmp("FIRST",  func)) gdes->vf.op = VDEF_FIRST;
3699     else if     (!strcmp("LAST",   func)) gdes->vf.op = VDEF_LAST;
3700     else if     (!strcmp("LSLSLOPE", func)) gdes->vf.op = VDEF_LSLSLOPE;
3701     else if     (!strcmp("LSLINT",   func)) gdes->vf.op = VDEF_LSLINT;
3702     else if     (!strcmp("LSLCORREL",func)) gdes->vf.op = VDEF_LSLCORREL;
3703     else {
3704         rrd_set_error("Unknown function '%s' in VDEF '%s'\n"
3705             ,func
3706             ,gdes->vname
3707             );
3708         return -1;
3709     };
3711     switch (gdes->vf.op) {
3712         case VDEF_PERCENT:
3713             if (isnan(param)) { /* no parameter given */
3714                 rrd_set_error("Function '%s' needs parameter in VDEF '%s'\n"
3715                     ,func
3716                     ,gdes->vname
3717                     );
3718                 return -1;
3719             };
3720             if (param>=0.0 && param<=100.0) {
3721                 gdes->vf.param = param;
3722                 gdes->vf.val   = DNAN;  /* undefined */
3723                 gdes->vf.when  = 0;     /* undefined */
3724             } else {
3725                 rrd_set_error("Parameter '%f' out of range in VDEF '%s'\n"
3726                     ,param
3727                     ,gdes->vname
3728                     );
3729                 return -1;
3730             };
3731             break;
3732         case VDEF_MAXIMUM:
3733         case VDEF_AVERAGE:
3734         case VDEF_MINIMUM:
3735         case VDEF_TOTAL:
3736         case VDEF_FIRST:
3737         case VDEF_LAST:
3738         case VDEF_LSLSLOPE:
3739         case VDEF_LSLINT:
3740         case VDEF_LSLCORREL:
3741             if (isnan(param)) {
3742                 gdes->vf.param = DNAN;
3743                 gdes->vf.val   = DNAN;
3744                 gdes->vf.when  = 0;
3745             } else {
3746                 rrd_set_error("Function '%s' needs no parameter in VDEF '%s'\n"
3747                     ,func
3748                     ,gdes->vname
3749                     );
3750                 return -1;
3751             };
3752             break;
3753     };
3754     return 0;
3758 int
3759 vdef_calc(im,gdi)
3760 image_desc_t *im;
3761 int gdi;
3763     graph_desc_t        *src,*dst;
3764     rrd_value_t         *data;
3765     long                step,steps;
3767     dst = &im->gdes[gdi];
3768     src = &im->gdes[dst->vidx];
3769     data = src->data + src->ds;
3770     steps = (src->end - src->start) / src->step;
3772 #if 0
3773 printf("DEBUG: start == %lu, end == %lu, %lu steps\n"
3774     ,src->start
3775     ,src->end
3776     ,steps
3777     );
3778 #endif
3780     switch (dst->vf.op) {
3781         case VDEF_PERCENT: {
3782                 rrd_value_t *   array;
3783                 int             field;
3786                 if ((array = malloc(steps*sizeof(double)))==NULL) {
3787                     rrd_set_error("malloc VDEV_PERCENT");
3788                     return -1;
3789                 }
3790                 for (step=0;step < steps; step++) {
3791                     array[step]=data[step*src->ds_cnt];
3792                 }
3793                 qsort(array,step,sizeof(double),vdef_percent_compar);
3795                 field = (steps-1)*dst->vf.param/100;
3796                 dst->vf.val  = array[field];
3797                 dst->vf.when = 0;       /* no time component */
3798                 free(array);
3799 #if 0
3800 for(step=0;step<steps;step++)
3801 printf("DEBUG: %3li:%10.2f %c\n",step,array[step],step==field?'*':' ');
3802 #endif
3803             }
3804             break;
3805         case VDEF_MAXIMUM:
3806             step=0;
3807             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3808             if (step == steps) {
3809                 dst->vf.val  = DNAN;
3810                 dst->vf.when = 0;
3811             } else {
3812                 dst->vf.val  = data[step*src->ds_cnt];
3813                 dst->vf.when = src->start + (step+1)*src->step;
3814             }
3815             while (step != steps) {
3816                 if (finite(data[step*src->ds_cnt])) {
3817                     if (data[step*src->ds_cnt] > dst->vf.val) {
3818                         dst->vf.val  = data[step*src->ds_cnt];
3819                         dst->vf.when = src->start + (step+1)*src->step;
3820                     }
3821                 }
3822                 step++;
3823             }
3824             break;
3825         case VDEF_TOTAL:
3826         case VDEF_AVERAGE: {
3827             int cnt=0;
3828             double sum=0.0;
3829             for (step=0;step<steps;step++) {
3830                 if (finite(data[step*src->ds_cnt])) {
3831                     sum += data[step*src->ds_cnt];
3832                     cnt ++;
3833                 };
3834             }
3835             if (cnt) {
3836                 if (dst->vf.op == VDEF_TOTAL) {
3837                     dst->vf.val  = sum*src->step;
3838                     dst->vf.when = 0;   /* no time component */
3839                 } else {
3840                     dst->vf.val = sum/cnt;
3841                     dst->vf.when = 0;   /* no time component */
3842                 };
3843             } else {
3844                 dst->vf.val  = DNAN;
3845                 dst->vf.when = 0;
3846             }
3847             }
3848             break;
3849         case VDEF_MINIMUM:
3850             step=0;
3851             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3852             if (step == steps) {
3853                 dst->vf.val  = DNAN;
3854                 dst->vf.when = 0;
3855             } else {
3856                 dst->vf.val  = data[step*src->ds_cnt];
3857                 dst->vf.when = src->start + (step+1)*src->step;
3858             }
3859             while (step != steps) {
3860                 if (finite(data[step*src->ds_cnt])) {
3861                     if (data[step*src->ds_cnt] < dst->vf.val) {
3862                         dst->vf.val  = data[step*src->ds_cnt];
3863                         dst->vf.when = src->start + (step+1)*src->step;
3864                     }
3865                 }
3866                 step++;
3867             }
3868             break;
3869         case VDEF_FIRST:
3870             /* The time value returned here is one step before the
3871              * actual time value.  This is the start of the first
3872              * non-NaN interval.
3873              */
3874             step=0;
3875             while (step != steps && isnan(data[step*src->ds_cnt])) step++;
3876             if (step == steps) { /* all entries were NaN */
3877                 dst->vf.val  = DNAN;
3878                 dst->vf.when = 0;
3879             } else {
3880                 dst->vf.val  = data[step*src->ds_cnt];
3881                 dst->vf.when = src->start + step*src->step;
3882             }
3883             break;
3884         case VDEF_LAST:
3885             /* The time value returned here is the
3886              * actual time value.  This is the end of the last
3887              * non-NaN interval.
3888              */
3889             step=steps-1;
3890             while (step >= 0 && isnan(data[step*src->ds_cnt])) step--;
3891             if (step < 0) { /* all entries were NaN */
3892                 dst->vf.val  = DNAN;
3893                 dst->vf.when = 0;
3894             } else {
3895                 dst->vf.val  = data[step*src->ds_cnt];
3896                 dst->vf.when = src->start + (step+1)*src->step;
3897             }
3898             break;
3899         case VDEF_LSLSLOPE:
3900         case VDEF_LSLINT:
3901         case VDEF_LSLCORREL:{
3902             /* Bestfit line by linear least squares method */ 
3904             int cnt=0;
3905             double SUMx, SUMy, SUMxy, SUMxx, SUMyy, slope, y_intercept, correl ;
3906             SUMx = 0; SUMy = 0; SUMxy = 0; SUMxx = 0; SUMyy = 0;
3908             for (step=0;step<steps;step++) {
3909                 if (finite(data[step*src->ds_cnt])) {
3910                     cnt++;
3911                     SUMx  += step;
3912                     SUMxx += step * step;
3913                     SUMxy += step * data[step*src->ds_cnt];
3914                     SUMy  += data[step*src->ds_cnt];
3915                     SUMyy  += data[step*src->ds_cnt]*data[step*src->ds_cnt];
3916                 };
3917             }
3919             slope = ( SUMx*SUMy - cnt*SUMxy ) / ( SUMx*SUMx - cnt*SUMxx );
3920             y_intercept = ( SUMy - slope*SUMx ) / cnt;
3921             correl = (SUMxy - (SUMx*SUMy)/cnt) / sqrt((SUMxx - (SUMx*SUMx)/cnt)*(SUMyy - (SUMy*SUMy)/cnt));
3923             if (cnt) {
3924                     if (dst->vf.op == VDEF_LSLSLOPE) {
3925                         dst->vf.val  = slope;
3926                         dst->vf.when = 0;
3927                     } else if (dst->vf.op == VDEF_LSLINT)  {
3928                         dst->vf.val = y_intercept;
3929                         dst->vf.when = 0;
3930                     } else if (dst->vf.op == VDEF_LSLCORREL)  {
3931                         dst->vf.val = correl;
3932                         dst->vf.when = 0;
3933                     };
3934                 
3935             } else {
3936                 dst->vf.val  = DNAN;
3937                 dst->vf.when = 0;
3938             }
3939         }
3940         break;
3941     }
3942     return 0;
3945 /* NaN < -INF < finite_values < INF */
3946 int
3947 vdef_percent_compar(a,b)
3948 const void *a,*b;
3950     /* Equality is not returned; this doesn't hurt except
3951      * (maybe) for a little performance.
3952      */
3954     /* First catch NaN values. They are smallest */
3955     if (isnan( *(double *)a )) return -1;
3956     if (isnan( *(double *)b )) return  1;
3958     /* NaN doesn't reach this part so INF and -INF are extremes.
3959      * The sign from isinf() is compatible with the sign we return
3960      */
3961     if (isinf( *(double *)a )) return isinf( *(double *)a );
3962     if (isinf( *(double *)b )) return isinf( *(double *)b );
3964     /* If we reach this, both values must be finite */
3965     if ( *(double *)a < *(double *)b ) return -1; else return 1;