/****************************************************************************
- * RRDtool 1.2.23 Copyright by Tobi Oetiker, 1997-2007
+ * RRDtool 1.2.99907080300 Copyright by Tobi Oetiker, 1997-2007
****************************************************************************
* rrd__graph.c produce graphs from data in rrdfiles
****************************************************************************/
conv_if(AREA, GF_AREA);
conv_if(STACK, GF_STACK);
conv_if(TICK, GF_TICK);
+ conv_if(TEXTALIGN, GF_TEXTALIGN);
conv_if(DEF, GF_DEF);
conv_if(CDEF, GF_CDEF);
conv_if(VDEF, GF_VDEF);
image_desc_t *im)
{
unsigned long i, ii;
+ cairo_status_t status = 0;
if (im == NULL)
return 0;
free(im->gdes[i].rpnp);
}
free(im->gdes);
+ if (im->font_options)
+ cairo_font_options_destroy(im->font_options);
+
+ if (im->cr) {
+ status = cairo_status(im->cr);
+ cairo_destroy(im->cr);
+ }
if (im->surface)
cairo_surface_destroy(im->surface);
+ if (status)
+ fprintf(stderr, "OOPS: Cairo has issuesm it can't even die: %s\n",
+ cairo_status_to_string(status));
+
return 0;
}
else {
switch (cf) {
case CF_HWPREDICT:
+ case CF_MHWPREDICT:
case CF_DEVSEASONAL:
case CF_DEVPREDICT:
case CF_SEASONAL:
} else {
switch (cf) {
case CF_HWPREDICT:
+ case CF_MHWPREDICT:
case CF_DEVSEASONAL:
case CF_DEVPREDICT:
case CF_SEASONAL:
return 0;
}
+static int AlmostEqual2sComplement(
+ float A,
+ float B,
+ int maxUlps)
+{
+
+ int aInt = *(int *) &A;
+ int bInt = *(int *) &B;
+ int intDiff;
+
+ /* Make sure maxUlps is non-negative and small enough that the
+ default NAN won't compare as equal to anything. */
+
+ /* assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024); */
+
+ /* Make aInt lexicographically ordered as a twos-complement int */
+
+ if (aInt < 0)
+ aInt = 0x80000000l - aInt;
+
+ /* Make bInt lexicographically ordered as a twos-complement int */
+
+ if (bInt < 0)
+ bInt = 0x80000000l - bInt;
+
+ intDiff = abs(aInt - bInt);
+
+ if (intDiff <= maxUlps)
+ return 1;
+
+ return 0;
+}
+
/* massage data so, that we get one value for each x coordinate in the graph */
int data_proc(
image_desc_t *im)
}
/* adjust min and max values */
+ /* for logscale we add something on top */
if (isnan(im->minval)
- /* don't adjust low-end with log scale *//* why not? */
|| ((!im->rigid) && im->minval > minval)
) {
if (im->logarithmic)
else
im->maxval = maxval;
}
+
/* make sure min is smaller than max */
if (im->minval > im->maxval) {
- im->minval = 0.99 * im->maxval;
+ if (im->minval > 0)
+ im->minval = 0.99 * im->maxval;
+ else
+ im->minval = 1.01 * im->maxval;
}
/* make sure min and max are not equal */
- if (im->minval == im->maxval) {
- im->maxval *= 1.01;
- if (!im->logarithmic) {
- im->minval *= 0.99;
- }
+ if (AlmostEqual2sComplement(im->minval,im->maxval,4)) {
+ if (im->maxval > 0)
+ im->maxval *= 1.01;
+ else
+ im->maxval *= 0.99;
+
/* make sure min and max are not both zero */
- if (im->maxval == 0.0) {
+ if (AlmostEqual2sComplement(im->maxval,0,4)) {
im->maxval = 1.0;
}
}
switch (im->gdes[i].cf) {
case CF_HWPREDICT:
+ case CF_MHWPREDICT:
case CF_DEVPREDICT:
case CF_DEVSEASONAL:
case CF_SEASONAL:
graphelement = 1;
break;
case GF_COMMENT:
+ case GF_TEXTALIGN:
case GF_DEF:
case GF_CDEF:
case GF_VDEF:
int glue = 0;
int i, ii, mark = 0;
char prt_fctn; /*special printfunctions */
+ char default_txtalign = TXA_JUSTIFIED; /*default line orientation */
int *legspace;
if (!(im->extra_flags & NOLEGEND) & !(im->extra_flags & ONLY_GRAPH)) {
/* hide legends for rules which are not displayed */
+ if (im->gdes[i].gf == GF_TEXTALIGN) {
+ default_txtalign = im->gdes[i].txtalign;
+ }
+
if (!(im->extra_flags & FORCE_RULES_LEGEND)) {
if (im->gdes[i].gf == GF_HRULE &&
(im->gdes[i].yrule < im->minval
return -1;
}
-
- /* remove exess space */
+ /* \n -> \l */
if (prt_fctn == 'n') {
prt_fctn = 'l';
}
+ /* remove exess space from the end of the legend for \g */
while (prt_fctn == 'g' &&
leg_cc > 0 && im->gdes[i].legend[leg_cc - 1] == ' ') {
leg_cc--;
im->gdes[i].legend[leg_cc] = '\0';
}
+
if (leg_cc != 0) {
+
+ /* no interleg space if string ends in \g */
legspace[i] = (prt_fctn == 'g' ? 0 : interleg);
if (fill > 0) {
- /* no interleg space if string ends in \g */
fill += legspace[i];
}
- fill += gfx_get_text_width(im->cr, fill + border,
+ fill += gfx_get_text_width(im, fill + border,
im->text_prop[TEXT_PROP_LEGEND].
font,
im->text_prop[TEXT_PROP_LEGEND].
if (prt_fctn == 'g') {
prt_fctn = '\0';
}
- if (prt_fctn == '\0') {
- if (i == im->gdes_c - 1)
- prt_fctn = 'l';
+ if (prt_fctn == '\0') {
+ if (i == im->gdes_c - 1 || fill > im->ximg - 2 * border) {
+ /* just one legend item is left right or center */
+ switch (default_txtalign) {
+ case TXA_RIGHT:
+ prt_fctn = 'r';
+ break;
+ case TXA_CENTER:
+ prt_fctn = 'c';
+ break;
+ case TXA_JUSTIFIED:
+ prt_fctn = 'j';
+ break;
+ default:
+ prt_fctn = 'l';
+ break;
+ }
+ }
/* is it time to place the legends ? */
if (fill > im->ximg - 2 * border) {
if (leg_c > 1) {
i--;
fill = fill_last;
leg_c--;
- prt_fctn = 'j';
- } else {
- prt_fctn = 'l';
}
-
+ }
+ if (leg_c == 1 && prt_fctn == 'j') {
+ prt_fctn = 'l';
}
}
im->gdes[ii].leg_x = leg_x;
im->gdes[ii].leg_y = leg_y;
leg_x +=
- gfx_get_text_width(im->cr, leg_x,
+ gfx_get_text_width(im, leg_x,
im->text_prop[TEXT_PROP_LEGEND].
font,
im->text_prop[TEXT_PROP_LEGEND].
}
nlabels++;
- gfx_text(im->cr,
+ gfx_text(im,
X0 - im->text_prop[TEXT_PROP_AXIS].size, Y0,
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_AXIS].font,
im->text_prop[TEXT_PROP_AXIS].size,
im->tabwidth, 0.0, GFX_H_RIGHT, GFX_V_CENTER,
graph_label);
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0,
X0, Y0, MGRIDWIDTH, im->graph_col[GRC_MGRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0,
X1 + 2, Y0, MGRIDWIDTH, im->graph_col[GRC_MGRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 2, Y0,
X1 + 2, Y0,
MGRIDWIDTH, im->graph_col[GRC_MGRID],
im->grid_dash_on, im->grid_dash_off);
} else if (!(im->extra_flags & NOMINOR)) {
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0,
X0, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0,
X1 + 2, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 1, Y0,
X1 + 1, Y0,
GRIDWIDTH, im->graph_col[GRC_GRID],
return mnt;
}
-static int AlmostEqual2sComplement(
- float A,
- float B,
- int maxUlps)
-{
-
- int aInt = *(int *) &A;
- int bInt = *(int *) &B;
- int intDiff;
-
- /* Make sure maxUlps is non-negative and small enough that the
- default NAN won't compare as equal to anything. */
-
- /* assert(maxUlps > 0 && maxUlps < 4 * 1024 * 1024); */
-
- /* Make aInt lexicographically ordered as a twos-complement int */
-
- if (aInt < 0)
- aInt = 0x80000000l - aInt;
-
- /* Make bInt lexicographically ordered as a twos-complement int */
-
- if (bInt < 0)
- bInt = 0x80000000l - bInt;
-
- intDiff = abs(aInt - bInt);
-
- if (intDiff <= maxUlps)
- return 1;
+/* from http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm */
+/* yes we are loosing precision by doing tos with floats instead of doubles
+ but it seems more stable this way. */
- return 0;
-}
/* logaritmic horizontal grid */
int horizontal_log_grid(
/* major grid line */
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0, X0, Y0, MGRIDWIDTH, im->graph_col[GRC_MGRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0, X1 + 2, Y0, MGRIDWIDTH, im->graph_col[GRC_MGRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 2, Y0,
X1 + 2, Y0,
MGRIDWIDTH, im->graph_col[GRC_MGRID],
sprintf(graph_label, "%3.0f %c", pvalue, symbol);
} else
sprintf(graph_label, "%3.0e", value);
- gfx_text(im->cr,
+ gfx_text(im,
X0 - im->text_prop[TEXT_PROP_AXIS].size, Y0,
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_AXIS].font,
break;
/* draw lines */
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0,
X0, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0,
X1 + 2, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 1, Y0,
X1 + 1, Y0,
GRIDWIDTH, im->graph_col[GRC_GRID],
break;
/* draw lines */
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0,
X0, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0,
X1 + 2, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 1, Y0,
X1 + 1, Y0,
GRIDWIDTH, im->graph_col[GRC_GRID],
break;
/* draw lines */
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0, X0, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0, X1 + 2, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 1, Y0,
X1 + 1, Y0,
GRIDWIDTH, im->graph_col[GRC_GRID],
break;
/* draw lines */
- gfx_line(im->cr,
+ gfx_line(im,
X0 - 2, Y0, X0, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_line(im->cr,
+ gfx_line(im,
X1, Y0, X1 + 2, Y0, GRIDWIDTH, im->graph_col[GRC_GRID]);
- gfx_dashed_line(im->cr,
+ gfx_dashed_line(im,
X0 - 1, Y0,
X1 + 1, Y0,
GRIDWIDTH, im->graph_col[GRC_GRID],
if (ti == timajor)
continue; /* skip as falls on major grid line */
X0 = xtr(im, ti);
- gfx_line(im->cr, X0, Y1 - 2, X0, Y1, GRIDWIDTH,
+ gfx_line(im, X0, Y1 - 2, X0, Y1, GRIDWIDTH,
im->graph_col[GRC_GRID]);
- gfx_line(im->cr, X0, Y0, X0, Y0 + 2, GRIDWIDTH,
+ gfx_line(im, X0, Y0, X0, Y0 + 2, GRIDWIDTH,
im->graph_col[GRC_GRID]);
- gfx_dashed_line(im->cr, X0, Y1 - 1, X0, Y0 + 1, GRIDWIDTH,
+ gfx_dashed_line(im, X0, Y0 + 1, X0, Y1 - 1, GRIDWIDTH,
im->graph_col[GRC_GRID],
im->grid_dash_on, im->grid_dash_off);
if (ti < im->start || ti > im->end)
continue;
X0 = xtr(im, ti);
- gfx_line(im->cr, X0, Y1 - 2, X0, Y1, MGRIDWIDTH,
+ gfx_line(im, X0, Y1 - 2, X0, Y1, MGRIDWIDTH,
im->graph_col[GRC_MGRID]);
- gfx_line(im->cr, X0, Y0, X0, Y0 + 3, MGRIDWIDTH,
+ gfx_line(im, X0, Y0, X0, Y0 + 3, MGRIDWIDTH,
im->graph_col[GRC_MGRID]);
- gfx_dashed_line(im->cr, X0, Y1 - 2, X0, Y0 + 3, MGRIDWIDTH,
+ gfx_dashed_line(im, X0, Y0 + 3, X0, Y1 - 2, MGRIDWIDTH,
im->graph_col[GRC_MGRID],
im->grid_dash_on, im->grid_dash_off);
#else
# error "your libc has no strftime I guess we'll abort the exercise here."
#endif
- gfx_text(im->cr,
+ gfx_text(im,
xtr(im, tilab),
- Y0 + 1,
+ Y0 + 3,
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_AXIS].font,
im->text_prop[TEXT_PROP_AXIS].size, im->tabwidth, 0.0,
im->xorigin+im->xsize,im->yorigin-im->ysize,
GRIDWIDTH, im->graph_col[GRC_AXIS]); */
- gfx_line(im->cr, im->xorigin - 4, im->yorigin,
+ gfx_line(im, im->xorigin - 4, im->yorigin,
im->xorigin + im->xsize + 4, im->yorigin,
MGRIDWIDTH, im->graph_col[GRC_AXIS]);
- gfx_line(im->cr, im->xorigin, im->yorigin + 4,
+ gfx_line(im, im->xorigin, im->yorigin + 4,
im->xorigin, im->yorigin - im->ysize - 4,
MGRIDWIDTH, im->graph_col[GRC_AXIS]);
/* arrow for X and Y axis direction */
- gfx_new_area(im->cr, im->xorigin + im->xsize + 2, im->yorigin - 2, im->xorigin + im->xsize + 2, im->yorigin + 3, im->xorigin + im->xsize + 7, im->yorigin + 0.5, /* LINEOFFSET */
+
+ gfx_new_area(im, im->xorigin + im->xsize + 2, im->yorigin - 3, im->xorigin + im->xsize + 2, im->yorigin + 3, im->xorigin + im->xsize + 7, im->yorigin, /* horyzontal */
im->graph_col[GRC_ARROW]);
- gfx_close_path(im->cr);
+ gfx_close_path(im);
- gfx_new_area(im->cr, im->xorigin - 2, im->yorigin - im->ysize - 2, im->xorigin + 3, im->yorigin - im->ysize - 2, im->xorigin + 0.5, im->yorigin - im->ysize - 7, /* LINEOFFSET */
+ gfx_new_area(im, im->xorigin - 3, im->yorigin - im->ysize - 2, im->xorigin + 3, im->yorigin - im->ysize - 2, im->xorigin, im->yorigin - im->ysize - 7, /* vertical */
im->graph_col[GRC_ARROW]);
- gfx_close_path(im->cr);
+ gfx_close_path(im);
}
struct gfx_color_t water_color;
/* draw 3d border */
- gfx_new_area(im->cr, 0, im->yimg,
+ gfx_new_area(im, 0, im->yimg,
2, im->yimg - 2, 2, 2, im->graph_col[GRC_SHADEA]);
- gfx_add_point(im->cr, im->ximg - 2, 2);
- gfx_add_point(im->cr, im->ximg, 0);
- gfx_add_point(im->cr, 0, 0);
- gfx_close_path(im->cr);
+ gfx_add_point(im, im->ximg - 2, 2);
+ gfx_add_point(im, im->ximg, 0);
+ gfx_add_point(im, 0, 0);
+ gfx_close_path(im);
- gfx_new_area(im->cr, 2, im->yimg - 2,
+ gfx_new_area(im, 2, im->yimg - 2,
im->ximg - 2, im->yimg - 2,
im->ximg - 2, 2, im->graph_col[GRC_SHADEB]);
- gfx_add_point(im->cr, im->ximg, 0);
- gfx_add_point(im->cr, im->ximg, im->yimg);
- gfx_add_point(im->cr, 0, im->yimg);
- gfx_close_path(im->cr);
+ gfx_add_point(im, im->ximg, 0);
+ gfx_add_point(im, im->ximg, im->yimg);
+ gfx_add_point(im, 0, im->yimg);
+ gfx_close_path(im);
if (im->draw_x_grid == 1)
if (!res) {
char *nodata = "No Data found";
- gfx_text(im->cr, im->ximg / 2,
+ gfx_text(im, im->ximg / 2,
(2 * im->yorigin - im->ysize) / 2,
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_AXIS].font,
}
/* yaxis unit description */
- gfx_text(im->cr,
+ gfx_text(im,
10, (im->yorigin - im->ysize / 2),
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_UNIT].font,
RRDGRAPH_YLEGEND_ANGLE, GFX_H_CENTER, GFX_V_CENTER, im->ylegend);
/* graph title */
- gfx_text(im->cr,
- im->ximg / 2, 4,
+ gfx_text(im,
+ im->ximg / 2, 6,
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_TITLE].font,
im->text_prop[TEXT_PROP_TITLE].size, im->tabwidth, 0.0,
/* rrdtool 'logo' */
water_color = im->graph_col[GRC_FONT];
water_color.alpha = 0.3;
- gfx_text(im->cr,
- im->ximg - 4, 7,
+ gfx_text(im,
+ im->ximg - 4, 5,
water_color,
im->text_prop[TEXT_PROP_AXIS].font,
5.5, im->tabwidth, -90,
/* graph watermark */
if (im->watermark[0] != '\0') {
- gfx_text(im->cr,
+ gfx_text(im,
im->ximg / 2, im->yimg - 6,
water_color,
im->text_prop[TEXT_PROP_AXIS].font,
/* im->gdes[i].leg_y is the bottom of the legend */
X0 = im->gdes[i].leg_x;
Y0 = im->gdes[i].leg_y;
- gfx_text(im->cr, X0, Y0,
+ gfx_text(im, X0, Y0,
im->graph_col[GRC_FONT],
im->text_prop[TEXT_PROP_LEGEND].font,
im->text_prop[TEXT_PROP_LEGEND].size,
enough space for the box */
if (im->gdes[i].gf != GF_PRINT &&
im->gdes[i].gf != GF_GPRINT && im->gdes[i].gf != GF_COMMENT) {
- int boxH, boxV;
+ double boxH, boxV;
+ double X1, Y1;
+
- boxH = gfx_get_text_width(im->cr, 0,
+ boxH = gfx_get_text_width(im, 0,
im->text_prop[TEXT_PROP_LEGEND].
font,
im->text_prop[TEXT_PROP_LEGEND].
size, im->tabwidth, "o") * 1.2;
- boxV = boxH * 1.1;
+ boxV = boxH;
/* shift the box up a bit */
- Y0 -= boxV * 0.3;
+ Y0 -= boxV * 0.4;
/* make sure transparent colors show up the same way as in the graph */
- gfx_new_area(im->cr,
+ gfx_new_area(im,
X0, Y0 - boxV,
X0, Y0, X0 + boxH, Y0, im->graph_col[GRC_BACK]);
- gfx_add_point(im->cr, X0 + boxH, Y0 - boxV);
- gfx_close_path(im->cr);
+ gfx_add_point(im, X0 + boxH, Y0 - boxV);
+ gfx_close_path(im);
- gfx_new_area(im->cr,
+ gfx_new_area(im,
X0, Y0 - boxV,
X0, Y0, X0 + boxH, Y0, im->gdes[i].col);
- gfx_add_point(im->cr, X0 + boxH, Y0 - boxV);
- gfx_close_path(im->cr);
-
- gfx_line(im->cr,
- X0, Y0 - boxV,
- X0, Y0, 1.0, im->graph_col[GRC_FRAME]);
- gfx_line(im->cr,
- X0, Y0,
- X0 + boxH, Y0, 1.0, im->graph_col[GRC_FRAME]);
- gfx_line(im->cr,
- X0 + boxH, Y0,
- X0 + boxH, Y0 - boxV, 1.0, im->graph_col[GRC_FRAME]);
- gfx_line(im->cr,
- X0 + boxH, Y0 - boxV,
- X0, Y0 - boxV, 1.0, im->graph_col[GRC_FRAME]);
+ gfx_add_point(im, X0 + boxH, Y0 - boxV);
+ gfx_close_path(im);
+
+ cairo_save(im->cr);
+ cairo_new_path(im->cr);
+ cairo_set_line_width(im->cr, 1.0);
+ X1 = X0 + boxH;
+ Y1 = Y0 - boxV;
+ gfx_line_fit(im, &X0, &Y0);
+ gfx_line_fit(im, &X1, &Y1);
+ cairo_move_to(im->cr, X0, Y0);
+ cairo_line_to(im->cr, X1, Y0);
+ cairo_line_to(im->cr, X1, Y1);
+ cairo_line_to(im->cr, X0, Y1);
+ cairo_close_path(im->cr);
+ cairo_set_source_rgba(im->cr, im->graph_col[GRC_FRAME].red,
+ im->graph_col[GRC_FRAME].green,
+ im->graph_col[GRC_FRAME].blue,
+ im->graph_col[GRC_FRAME].alpha);
+ cairo_stroke(im->cr);
+ cairo_restore(im->cr);
}
}
}
Yxlabel = im->text_prop[TEXT_PROP_AXIS].size * 2.5;
}
if (im->draw_y_grid || im->forceleftspace) {
- Xylabel = gfx_get_text_width(im->cr, 0,
+ Xylabel = gfx_get_text_width(im, 0,
im->text_prop[TEXT_PROP_AXIS].font,
im->text_prop[TEXT_PROP_AXIS].size,
im->tabwidth, "0") * im->unitslength;
return 0;
}
-/* from http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm */
-/* yes we are loosing precision by doing tos with floats instead of doubles
- but it seems more stable this way. */
+static cairo_status_t cairo_write_func_filehandle(
+ void *closure,
+ const unsigned char *data,
+ unsigned int length)
+{
+ if (fwrite(data, length, 1, closure) != 1)
+ return CAIRO_STATUS_WRITE_ERROR;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t cairo_copy_to_buffer(
+ void *closure,
+ const unsigned char *data,
+ unsigned int length)
+{
+ image_desc_t *im = closure;
+
+ im->rendered_image =
+ realloc(im->rendered_image, im->rendered_image_size + length);
+ if (im->rendered_image == NULL) {
+ return CAIRO_STATUS_WRITE_ERROR;
+ }
+
+ memcpy(im->rendered_image + im->rendered_image_size, data, length);
+
+ im->rendered_image_size += length;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
/* draw that picture thing ... */
int graph_paint(
image_desc_t *im,
int lazy = lazy_check(im);
double areazero = 0.0;
+ graph_desc_t *lastgdes = NULL;
+
PangoFontMap *font_map = pango_cairo_font_map_get_default();
- graph_desc_t *lastgdes = NULL;
/* if we are lazy and there is nothing to PRINT ... quit now */
if (lazy && im->prt_c == 0)
if (!calc_horizontal_grid(im))
return -1;
- if (im->gridfit)
- apply_gridfit(im);
+ /* reset precalc */
+ ytr(im, DNAN);
+
+/* if (im->gridfit)
+ apply_gridfit(im); */
+
/* the actual graph is created by going through the individual
graph elements and then drawing them */
im->yimg * im->zoom);
break;
case IF_PDF:
- im->surface =
- cairo_pdf_surface_create(im->graphfile, im->ximg * im->zoom,
- im->yimg * im->zoom);
+ im->gridfit = 0;
+ im->surface = strlen(im->graphfile)
+ ? cairo_pdf_surface_create(im->graphfile, im->ximg * im->zoom,
+ im->yimg * im->zoom)
+ : cairo_pdf_surface_create_for_stream(&cairo_copy_to_buffer, im,
+ im->ximg * im->zoom,
+ im->yimg * im->zoom);
break;
case IF_EPS:
- im->surface =
- cairo_ps_surface_create(im->graphfile, im->ximg * im->zoom,
- im->yimg * im->zoom);
+ im->gridfit = 0;
+ im->surface = strlen(im->graphfile)
+ ? cairo_ps_surface_create(im->graphfile, im->ximg * im->zoom,
+ im->yimg * im->zoom)
+ : cairo_ps_surface_create_for_stream(&cairo_copy_to_buffer, im,
+ im->ximg * im->zoom,
+ im->yimg * im->zoom);
break;
case IF_SVG:
- im->surface =
- cairo_svg_surface_create(im->graphfile, im->ximg * im->zoom,
- im->yimg * im->zoom);
+ im->gridfit = 0;
+ im->surface = strlen(im->graphfile)
+ ? cairo_svg_surface_create(im->graphfile, im->ximg * im->zoom,
+ im->yimg * im->zoom)
+ : cairo_svg_surface_create_for_stream(&cairo_copy_to_buffer, im,
+ im->ximg * im->zoom,
+ im->yimg * im->zoom);
cairo_svg_surface_restrict_to_version(im->surface,
CAIRO_SVG_VERSION_1_1);
break;
};
im->cr = cairo_create(im->surface);
- pango_cairo_font_map_set_resolution(font_map, 100);
+ pango_cairo_font_map_set_resolution(PANGO_CAIRO_FONT_MAP(font_map), 100);
+ cairo_set_antialias(im->cr, im->graph_antialias);
cairo_scale(im->cr, im->zoom, im->zoom);
- gfx_new_area(im->cr,
+ gfx_new_area(im,
0, 0,
0, im->yimg, im->ximg, im->yimg, im->graph_col[GRC_BACK]);
- gfx_add_point(im->cr, im->ximg, 0);
- gfx_close_path(im->cr);
+ gfx_add_point(im, im->ximg, 0);
+ gfx_close_path(im);
- gfx_new_area(im->cr,
+ gfx_new_area(im,
im->xorigin, im->yorigin,
im->xorigin + im->xsize, im->yorigin,
im->xorigin + im->xsize, im->yorigin - im->ysize,
im->graph_col[GRC_CANVAS]);
- gfx_add_point(im->cr, im->xorigin, im->yorigin - im->ysize);
- gfx_close_path(im->cr);
+ gfx_add_point(im, im->xorigin, im->yorigin - im->ysize);
+ gfx_close_path(im);
if (im->minval > 0.0)
areazero = im->minval;
case GF_PRINT:
case GF_GPRINT:
case GF_COMMENT:
+ case GF_TEXTALIGN:
case GF_HRULE:
case GF_VRULE:
case GF_XPORT:
if (!isnan(im->gdes[i].p_data[ii]) &&
im->gdes[i].p_data[ii] != 0.0) {
if (im->gdes[i].yrule > 0) {
- gfx_line(im->cr,
+ gfx_line(im,
im->xorigin + ii, im->yorigin,
im->xorigin + ii,
im->yorigin -
im->gdes[i].yrule * im->ysize, 1.0,
im->gdes[i].col);
} else if (im->gdes[i].yrule < 0) {
- gfx_line(im->cr,
+ gfx_line(im,
im->xorigin + ii,
im->yorigin - im->ysize,
im->xorigin + ii,
double x = ii - 1 + im->xorigin;
double y = last_y;
- gfx_line_fit(im->cr, &x, &y);
+ gfx_line_fit(im, &x, &y);
cairo_move_to(im->cr, x, y);
x = ii + im->xorigin;
y = last_y;
- gfx_line_fit(im->cr, &x, &y);
+ gfx_line_fit(im, &x, &y);
cairo_line_to(im->cr, x, y);
} else {
double x = ii - 1 + im->xorigin;
double y = ytr(im,
im->gdes[i].p_data[ii - 1]);
- gfx_line_fit(im->cr, &x, &y);
+ gfx_line_fit(im, &x, &y);
cairo_move_to(im->cr, x, y);
x = ii + im->xorigin;
y = last_y;
- gfx_line_fit(im->cr, &x, &y);
+ gfx_line_fit(im, &x, &y);
cairo_line_to(im->cr, x, y);
}
draw_on = 1;
double x = ii - 1 + im->xorigin;
double y = y1;
- gfx_line_fit(im->cr, &x, &y);
+ gfx_line_fit(im, &x, &y);
cairo_line_to(im->cr, x, y);
};
last_y = y1;
- gfx_line_fit(im->cr, &x1, &y1);
+ gfx_line_fit(im, &x1, &y1);
cairo_line_to(im->cr, x1, y1);
};
4)) {
cntI++;
}
- gfx_new_area(im->cr,
+ gfx_new_area(im,
backX[0], backY[0],
foreX[0], foreY[0],
foreX[cntI], foreY[cntI],
1], 4)) {
cntI++;
}
- gfx_add_point(im->cr, foreX[cntI],
- foreY[cntI]);
+ gfx_add_point(im, foreX[cntI], foreY[cntI]);
}
- gfx_add_point(im->cr, backX[idxI], backY[idxI]);
+ gfx_add_point(im, backX[idxI], backY[idxI]);
while (idxI > 1) {
lastI = idxI;
idxI--;
1], 4)) {
idxI--;
}
- gfx_add_point(im->cr, backX[idxI],
- backY[idxI]);
+ gfx_add_point(im, backX[idxI], backY[idxI]);
}
idxI = -1;
drawem = 0;
- gfx_close_path(im->cr);
+ gfx_close_path(im);
}
if (drawem != 0) {
drawem = 0;
case GF_HRULE:
if (im->gdes[i].yrule >= im->minval
&& im->gdes[i].yrule <= im->maxval)
- gfx_line(im->cr,
+ gfx_line(im,
im->xorigin, ytr(im, im->gdes[i].yrule),
im->xorigin + im->xsize, ytr(im,
im->gdes[i].yrule),
case GF_VRULE:
if (im->gdes[i].xrule >= im->start
&& im->gdes[i].xrule <= im->end)
- gfx_line(im->cr,
+ gfx_line(im,
xtr(im, im->gdes[i].xrule), im->yorigin,
xtr(im, im->gdes[i].xrule),
im->yorigin - im->ysize, 1.0, im->gdes[i].col);
switch (im->imgformat) {
case IF_PNG:
- if (cairo_surface_write_to_png(im->surface, im->graphfile) !=
- CAIRO_STATUS_SUCCESS) {
+ {
+ cairo_status_t status;
+
+ if (strlen(im->graphfile) == 0) {
+ status =
+ cairo_surface_write_to_png_stream(im->surface,
+ &cairo_copy_to_buffer, im);
+ } else if (strcmp(im->graphfile, "-") == 0) {
+ status =
+ cairo_surface_write_to_png_stream(im->surface,
+ &cairo_write_func_filehandle,
+ (void *) stdout);
+ } else {
+ status = cairo_surface_write_to_png(im->surface, im->graphfile);
+ }
+
+ if (status != CAIRO_STATUS_SUCCESS) {
rrd_set_error("Could not save png to '%s'", im->graphfile);
return 1;
}
+ }
break;
default:
- cairo_show_page(im->cr);
+ if (strlen(im->graphfile)) {
+ cairo_show_page(im->cr);
+ } else {
+ cairo_surface_finish(im->surface);
+ }
break;
}
return 0;
/* a dummy surface so that we can measure text sizes for placements */
im.surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 10, 10);
im.cr = cairo_create(im.surface);
-
-
- /* not currently using this ... */
im.graphhandle = stream;
rrd_graph_options(argc, argv, &im);
return -1;
}
+ if (optind >= argc) {
+ rrd_set_error("missing filename");
+ return -1;
+ }
+
if (strlen(argv[optind]) >= MAXPATH) {
rrd_set_error("filename (including path) too long");
im_free(&im);
return -1;
}
+
strncpy(im.graphfile, argv[optind], MAXPATH - 1);
im.graphfile[MAXPATH - 1] = '\0';
return 0;
}
+/* a simplified version of the above that just creates the graph in memory
+ and returns a pointer to it. */
+
+unsigned char *rrd_graph_in_memory(
+ int argc,
+ char **argv,
+ char ***prdata,
+ int *xsize,
+ int *ysize,
+ double *ymin,
+ double *ymax,
+ size_t * img_size)
+{
+ image_desc_t im;
+
+ rrd_graph_init(&im);
+
+ /* a dummy surface so that we can measure text sizes for placements */
+ im.surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 10, 10);
+ im.cr = cairo_create(im.surface);
+
+ rrd_graph_options(argc, argv, &im);
+ if (rrd_test_error()) {
+ im_free(&im);
+ return NULL;
+ }
+
+ rrd_graph_script(argc, argv, &im, 1);
+ if (rrd_test_error()) {
+ im_free(&im);
+ return NULL;
+ }
+
+ /* Everything is now read and the actual work can start */
+
+ /* by not assigning a name to im.graphfile data will be written to
+ newly allocated memory on im.rendered_image ... */
+
+ (*prdata) = NULL;
+ if (graph_paint(&im, prdata) == -1) {
+ im_free(&im);
+ return NULL;
+ }
+
+ *xsize = im.ximg;
+ *ysize = im.yimg;
+ *ymin = im.minval;
+ *ymax = im.maxval;
+ *img_size = im.rendered_image_size;
+ im_free(&im);
+
+ return im.rendered_image;
+}
+
void rrd_graph_init(
image_desc_t *im)
{
im->yimg = 0;
im->xsize = 400;
im->ysize = 100;
+ im->rendered_image_size = 0;
+ im->rendered_image = NULL;
im->step = 0;
im->ylegend[0] = '\0';
im->title[0] = '\0';
im->symbol = ' ';
im->viewfactor = 1.0;
im->imgformat = IF_PNG;
+ im->graphfile[0] = '\0';
im->cr = NULL;
im->surface = NULL;
im->extra_flags = 0;
im->grid_dash_off = 1;
im->tabwidth = 40.0;
im->zoom = 1;
+ im->font_options = cairo_font_options_create();
+ im->graph_antialias = CAIRO_ANTIALIAS_GRAY;
+
+ cairo_font_options_set_hint_style(im->font_options,
+ CAIRO_HINT_STYLE_FULL);
+ cairo_font_options_set_hint_metrics(im->font_options,
+ CAIRO_HINT_METRICS_ON);
+ cairo_font_options_set_antialias(im->font_options, CAIRO_ANTIALIAS_GRAY);
+
for (i = 0; i < DIM(graph_col); i++)
im->graph_col[i] = graph_col[i];
long long_tmp;
struct rrd_time_value start_tv, end_tv;
long unsigned int color;
+ char *old_locale = "";
+
+ /* defines for long options without a short equivalent. should be bytes,
+ and may not collide with (the ASCII value of) short options */
+#define LONGOPT_UNITS_SI 255
+ struct option long_options[] = {
+ {"start", required_argument, 0, 's'},
+ {"end", required_argument, 0, 'e'},
+ {"x-grid", required_argument, 0, 'x'},
+ {"y-grid", required_argument, 0, 'y'},
+ {"vertical-label", required_argument, 0, 'v'},
+ {"width", required_argument, 0, 'w'},
+ {"height", required_argument, 0, 'h'},
+ {"full-size-mode", no_argument, 0, 'D'},
+ {"interlaced", no_argument, 0, 'i'},
+ {"upper-limit", required_argument, 0, 'u'},
+ {"lower-limit", required_argument, 0, 'l'},
+ {"rigid", no_argument, 0, 'r'},
+ {"base", required_argument, 0, 'b'},
+ {"logarithmic", no_argument, 0, 'o'},
+ {"color", required_argument, 0, 'c'},
+ {"font", required_argument, 0, 'n'},
+ {"title", required_argument, 0, 't'},
+ {"imginfo", required_argument, 0, 'f'},
+ {"imgformat", required_argument, 0, 'a'},
+ {"lazy", no_argument, 0, 'z'},
+ {"zoom", required_argument, 0, 'm'},
+ {"no-legend", no_argument, 0, 'g'},
+ {"force-rules-legend", no_argument, 0, 'F'},
+ {"only-graph", no_argument, 0, 'j'},
+ {"alt-y-grid", no_argument, 0, 'Y'},
+ {"no-minor", no_argument, 0, 'I'},
+ {"slope-mode", no_argument, 0, 'E'},
+ {"alt-autoscale", no_argument, 0, 'A'},
+ {"alt-autoscale-min", no_argument, 0, 'J'},
+ {"alt-autoscale-max", no_argument, 0, 'M'},
+ {"no-gridfit", no_argument, 0, 'N'},
+ {"units-exponent", required_argument, 0, 'X'},
+ {"units-length", required_argument, 0, 'L'},
+ {"units", required_argument, 0, LONGOPT_UNITS_SI},
+ {"step", required_argument, 0, 'S'},
+ {"tabwidth", required_argument, 0, 'T'},
+ {"font-render-mode", required_argument, 0, 'R'},
+ {"graph-render-mode", required_argument, 0, 'G'},
+ {"font-smoothing-threshold", required_argument, 0, 'B'},
+ {"watermark", required_argument, 0, 'W'},
+ {"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 */
+ {0, 0, 0, 0}
+ };
optind = 0;
opterr = 0; /* initialize getopt */
parsetime("end-24h", &start_tv);
parsetime("now", &end_tv);
- /* defines for long options without a short equivalent. should be bytes,
- and may not collide with (the ASCII value of) short options */
-#define LONGOPT_UNITS_SI 255
-
while (1) {
- static struct option long_options[] = {
- {"start", required_argument, 0, 's'},
- {"end", required_argument, 0, 'e'},
- {"x-grid", required_argument, 0, 'x'},
- {"y-grid", required_argument, 0, 'y'},
- {"vertical-label", required_argument, 0, 'v'},
- {"width", required_argument, 0, 'w'},
- {"height", required_argument, 0, 'h'},
- {"full-size-mode", no_argument, 0, 'D'},
- {"interlaced", no_argument, 0, 'i'},
- {"upper-limit", required_argument, 0, 'u'},
- {"lower-limit", required_argument, 0, 'l'},
- {"rigid", no_argument, 0, 'r'},
- {"base", required_argument, 0, 'b'},
- {"logarithmic", no_argument, 0, 'o'},
- {"color", required_argument, 0, 'c'},
- {"font", required_argument, 0, 'n'},
- {"title", required_argument, 0, 't'},
- {"imginfo", required_argument, 0, 'f'},
- {"imgformat", required_argument, 0, 'a'},
- {"lazy", no_argument, 0, 'z'},
- {"zoom", required_argument, 0, 'm'},
- {"no-legend", no_argument, 0, 'g'},
- {"force-rules-legend", no_argument, 0, 'F'},
- {"only-graph", no_argument, 0, 'j'},
- {"alt-y-grid", no_argument, 0, 'Y'},
- {"no-minor", no_argument, 0, 'I'},
- {"slope-mode", no_argument, 0, 'E'},
- {"alt-autoscale", no_argument, 0, 'A'},
- {"alt-autoscale-min", no_argument, 0, 'J'},
- {"alt-autoscale-max", no_argument, 0, 'M'},
- {"no-gridfit", no_argument, 0, 'N'},
- {"units-exponent", required_argument, 0, 'X'},
- {"units-length", required_argument, 0, 'L'},
- {"units", required_argument, 0, LONGOPT_UNITS_SI},
- {"step", required_argument, 0, 'S'},
- {"tabwidth", required_argument, 0, 'T'},
- {"font-render-mode", required_argument, 0, 'R'},
- {"font-smoothing-threshold", required_argument, 0, 'B'},
- {"watermark", required_argument, 0, 'W'},
- {"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 */
- {0, 0, 0, 0}
- };
int option_index = 0;
int opt;
int col_start, col_end;
case LONGOPT_UNITS_SI:
if (im->extra_flags & FORCE_UNITS) {
rrd_set_error("--units can only be used once!");
+ setlocale(LC_NUMERIC, old_locale);
return;
}
if (strcmp(optarg, "si") == 0)
im->forceleftspace = 1;
break;
case 'T':
+ old_locale = setlocale(LC_NUMERIC, "C");
im->tabwidth = atof(optarg);
+ setlocale(LC_NUMERIC, old_locale);
break;
case 'S':
+ old_locale = setlocale(LC_NUMERIC, "C");
im->step = atoi(optarg);
+ setlocale(LC_NUMERIC, old_locale);
break;
case 'N':
im->gridfit = 0;
im->draw_y_grid = 0;
break;
};
-
+ old_locale = setlocale(LC_NUMERIC, "C");
if (sscanf(optarg, "%lf:%d", &im->ygridstep, &im->ylabfact) == 2) {
+ setlocale(LC_NUMERIC, old_locale);
if (im->ygridstep <= 0) {
rrd_set_error("grid step must be > 0");
return;
return;
}
} else {
+ setlocale(LC_NUMERIC, old_locale);
rrd_set_error("invalid y-grid format");
return;
}
im->ylegend[150] = '\0';
break;
case 'u':
+ old_locale = setlocale(LC_NUMERIC, "C");
im->maxval = atof(optarg);
+ setlocale(LC_NUMERIC, old_locale);
break;
case 'l':
+ old_locale = setlocale(LC_NUMERIC, "C");
im->minval = atof(optarg);
+ setlocale(LC_NUMERIC, old_locale);
break;
case 'b':
im->base = atol(optarg);
double size = 1;
char font[1024] = "";
+ old_locale = setlocale(LC_NUMERIC, "C");
if (sscanf(optarg, "%10[A-Z]:%lf:%1000s", prop, &size, font) >= 2) {
int sindex, propidx;
+ setlocale(LC_NUMERIC, old_locale);
if ((sindex = text_prop_conv(prop)) != -1) {
for (propidx = sindex; propidx < TEXT_PROP_LAST;
propidx++) {
return;
}
} else {
+ setlocale(LC_NUMERIC, old_locale);
rrd_set_error("invalid text property format");
return;
}
break;
}
case 'm':
+ old_locale = setlocale(LC_NUMERIC, "C");
im->zoom = atof(optarg);
+ setlocale(LC_NUMERIC, old_locale);
if (im->zoom <= 0.0) {
rrd_set_error("zoom factor must be > 0");
return;
break;
case 'R':
- /* not supported curently */
+ if (strcmp(optarg, "normal") == 0) {
+ cairo_font_options_set_antialias(im->font_options,
+ CAIRO_ANTIALIAS_GRAY);
+ cairo_font_options_set_hint_style(im->font_options,
+ CAIRO_HINT_STYLE_FULL);
+ } else if (strcmp(optarg, "light") == 0) {
+ cairo_font_options_set_antialias(im->font_options,
+ CAIRO_ANTIALIAS_GRAY);
+ cairo_font_options_set_hint_style(im->font_options,
+ CAIRO_HINT_STYLE_SLIGHT);
+ } else if (strcmp(optarg, "mono") == 0) {
+ cairo_font_options_set_antialias(im->font_options,
+ CAIRO_ANTIALIAS_NONE);
+ cairo_font_options_set_hint_style(im->font_options,
+ CAIRO_HINT_STYLE_FULL);
+ } else {
+ rrd_set_error("unknown font-render-mode '%s'", optarg);
+ return;
+ }
+ break;
+ case 'G':
+ if (strcmp(optarg, "normal") == 0)
+ im->graph_antialias = CAIRO_ANTIALIAS_GRAY;
+ else if (strcmp(optarg, "mono") == 0)
+ im->graph_antialias = CAIRO_ANTIALIAS_NONE;
+ else {
+ rrd_set_error("unknown graph-render-mode '%s'", optarg);
+ return;
+ }
break;
-
case 'B':
/* not supported curently */
break;
}
}
- if (optind >= argc) {
- rrd_set_error("missing filename");
- return;
- }
-
if (im->logarithmic == 1 && im->minval <= 0) {
rrd_set_error
("for a logarithmic yaxis you must specify a lower-limit > 0");
int vdef_parse(
- gdes,
- str)
- struct graph_desc_t *gdes;
- const char *const str;
+ struct graph_desc_t *gdes,
+ const char *const str)
{
/* A VDEF currently is either "func" or "param,func"
* so the parsing is rather simple. Change if needed.
double param;
char func[30];
int n;
+ char *old_locale;
n = 0;
+ old_locale = setlocale(LC_NUMERIC, "C");
sscanf(str, "%le,%29[A-Z]%n", ¶m, func, &n);
+ setlocale(LC_NUMERIC, old_locale);
if (n == (int) strlen(str)) { /* matched */
;
} else {
gdes->vf.op = VDEF_MAXIMUM;
else if (!strcmp("AVERAGE", func))
gdes->vf.op = VDEF_AVERAGE;
+ else if (!strcmp("STDEV", func))
+ gdes->vf.op = VDEF_STDEV;
else if (!strcmp("MINIMUM", func))
gdes->vf.op = VDEF_MINIMUM;
else if (!strcmp("TOTAL", func))
break;
case VDEF_MAXIMUM:
case VDEF_AVERAGE:
+ case VDEF_STDEV:
case VDEF_MINIMUM:
case VDEF_TOTAL:
case VDEF_FIRST:
int vdef_calc(
- im,
- gdi)
- image_desc_t *im;
- int gdi;
+ image_desc_t *im,
+ int gdi)
{
graph_desc_t *src, *dst;
rrd_value_t *data;
}
break;
case VDEF_TOTAL:
+ case VDEF_STDEV:
case VDEF_AVERAGE:{
int cnt = 0;
double sum = 0.0;
+ double average = 0.0;
for (step = 0; step < steps; step++) {
if (finite(data[step * src->ds_cnt])) {
if (dst->vf.op == VDEF_TOTAL) {
dst->vf.val = sum * src->step;
dst->vf.when = 0; /* no time component */
- } else {
+ } else if (dst->vf.op == VDEF_AVERAGE) {
dst->vf.val = sum / cnt;
dst->vf.when = 0; /* no time component */
+ } else {
+ average = sum / cnt;
+ sum = 0.0;
+ for (step = 0; step < steps; step++) {
+ if (finite(data[step * src->ds_cnt])) {
+ sum += pow((data[step * src->ds_cnt] - average), 2.0);
+ };
+ }
+ dst->vf.val = pow(sum / cnt, 0.5);
+ dst->vf.when = 0; /* no time component */
};
} else {
dst->vf.val = DNAN;
/* NaN < -INF < finite_values < INF */
int vdef_percent_compar(
- a,
- b)
- const void *a, *b;
+ const void *a,
+ const void *b)
{
/* Equality is not returned; this doesn't hurt except
* (maybe) for a little performance.
projects / rrdtool.git / blobdiff