int GetStringHeight(char *szString, char* font, int size)
{
int brect[8];
char* err;
gdFontPtr pFont;
if(font && strlen(font) != 0 && size > 0)
{
err = gdImageStringFT(NULL, brect, 0, font,size,0.,0,0,szString);
if (err)
{
/* if error occur, use native font */
return GetStringHeight(szString, "", size);
}
return brect[3]-brect[5];
}
else
{
/* negative size */
switch(size) {
case UF_TINY:
pFont = gdFontGetTiny();
break;
case UF_SMALL:
pFont = gdFontGetSmall();
break;
case UF_MEDIUM:
pFont = gdFontGetMediumBold();
break;
case UF_LARGE:
pFont = gdFontGetLarge();
break;
case UF_GIANT:
pFont = gdFontGetGiant();
break;
default:
pFont = gdFontGetMediumBold();
break;
}
/* positive size */
if(size > 0)
{
if(size > 9)
{
pFont = gdFontGetGiant();
}
else
{
pFont = gdFontGetSmall();
}
}
return pFont->h;
}
}
void GdImageRenderer::drawTimeAxisLabels() const
{
const int marker_height = 10;
// Time interval between axis markers (seconds)
const int axis_label_interval_secs = getAxisLabelScale();
// Time of first axis marker (seconds)
const int first_axis_label_secs = MathUtil::roundUpToNearest(start_time_, axis_label_interval_secs);
// Distance between waveform start time and first axis marker (seconds)
const double axis_label_offset_secs = first_axis_label_secs - start_time_;
// Distance between waveform start time and first axis marker (samples)
const int axis_label_offset_samples = secondsToSamples(axis_label_offset_secs);
// Distance between waveform start time and first axis marker (pixels)
const int axis_label_offset_pixels = axis_label_offset_samples / samples_per_pixel_;
assert(axis_label_offset_pixels >= 0);
gdFontPtr font = gdFontGetSmall();
int secs = first_axis_label_secs;
for (;;) {
const int x = axis_label_offset_pixels +
(secs - first_axis_label_secs) * sample_rate_ / samples_per_pixel_;
assert(x >= 0);
if (x >= image_width_) {
break;
}
gdImageLine(image_, x, 0, x, marker_height, border_color_);
gdImageLine(image_, x, image_height_ - 1, x, image_height_ - 1 - marker_height, border_color_);
char label[50];
const int label_length = TimeUtil::secondsToString(label, ARRAY_LENGTH(label), secs);
const int label_width = font->w * label_length;
const int label_x = x - (label_width / 2) + 1;
const int label_y = image_height_ - 1 - marker_height - 1 - font->h;
if (label_x >= 0) {
gdImageString(
image_,
font,
label_x,
label_y,
reinterpret_cast<unsigned char*>(label),
axis_label_color_
);
}
secs += axis_label_interval_secs;
}
}
void Gd::drawString(int x, int y, const char* str, int color, FontStyle style)
{
gdFontPtr font = style == FontTiny ? gdFontGetTiny()
: style == FontSmall ? gdFontGetSmall()
: style == FontMedium ? gdFontGetMediumBold()
: style == FontLarge ? gdFontGetLarge()
: style == FontGiant ? gdFontGetGiant()
: gdFontGetMediumBold();
gdImageString(_imagePtr, font, x, y, const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(str)), color);
}
void Gd::drawChar(int x, int y, char ch, int color, FontStyle style)
{
gdFontPtr font = style == FontTiny ? gdFontGetTiny()
: style == FontSmall ? gdFontGetSmall()
: style == FontMedium ? gdFontGetMediumBold()
: style == FontLarge ? gdFontGetLarge()
: style == FontGiant ? gdFontGetGiant()
: gdFontGetMediumBold();
gdImageChar(_imagePtr, font, x, y, ch, color);
}
Boolean GdoInit(unsigned int w,
unsigned int h,
const char *file,
struct ADrawTag *outContext)
{
GdoContext *context;
/* Create context */
context = outContext->internal = malloc(sizeof(GdoContext));
if(context == NULL)
{
return FALSE;
}
/* Open the output file */
context->outFile = fopen(file, "wb");
if(!context->outFile)
{
fprintf(stderr, "GdoInit: Failed to open output file '%s':\n", file);
perror(NULL);
return FALSE;
}
/* Allocate the image */
context->img = gdImageCreate(w, h);
/* Get the colours */
context->colour[ADRAW_COL_WHITE] = gdImageColorAllocate(context->img, 255, 255, 255); /* Background */
context->colour[ADRAW_COL_BLACK] = gdImageColorAllocate(context->img, 0, 0, 0);
context->colour[ADRAW_COL_BLUE] = gdImageColorAllocate(context->img, 0, 0, 255);
/* Set pen colour to black */
context->pen = context->colour[ADRAW_COL_BLACK];
/* Get the default font */
context->font = gdFontGetSmall();
/* Now fill in the function pointers */
outContext->line = gdoLine;
outContext->dottedLine = gdoDottedLine;
outContext->textL = gdoTextL;
outContext->textC = gdoTextC;
outContext->textR = gdoTextR;
outContext->textWidth = gdoTextWidth;
outContext->textHeight = gdoTextHeight;
outContext->filledTriangle = gdoFilledTriangle;
outContext->arc = gdoArc;
outContext->dottedArc = gdoDottedArc;
outContext->setPen = gdoSetPen;
outContext->setFontSize = gdoSetFontSize;
outContext->close = gdoClose;
return TRUE;
}
void string(const std::string& text, const Point& point, const Color& color, Size size, int align)
{
// copy text into gd-friendly (unsigned char) buffer
vector<unsigned char> buffer;
copy(text.begin(), text.end(), back_inserter(buffer));
buffer.push_back('\0');
// choose font
gdFontPtr font;
switch (size)
{
case Tiny:
font = gdFontGetTiny();
break;
case Small:
font = gdFontGetSmall();
break;
case MediumBold:
font = gdFontGetMediumBold();
break;
case Large:
font = gdFontGetLarge();
break;
case Giant:
font = gdFontGetGiant();
break;
default:
throw runtime_error("[ImageImpl::string()] This isn't happening.");
}
// calculate position
Point position = point;
int length = (int)text.size() * font->w;
int height = font->h;
if (align & CenterX) position.x -= length/2;
else if (align & Right) position.x -= length;
if (align & CenterY) position.y -= height/2;
else if (align & Bottom) position.y -= height;
// draw the string
gdImageString(im_, font, position.x, position.y, &buffer[0], color2gd(color));
}
void gdoSetFontSize(struct ADrawTag *ctx,
ADrawFontSize size)
{
switch(size)
{
case ADRAW_FONT_TINY:
getGdoCtx(ctx)->font = gdFontGetTiny();
break;
case ADRAW_FONT_SMALL:
getGdoCtx(ctx)->font = gdFontGetSmall();
break;
default:
assert(0);
}
}
gdFontPtr msGetBitmapFont(int size)
{
switch(size) { /* set the font to use */
case MS_TINY:
#ifdef GD_HAS_GETBITMAPFONT
return gdFontGetTiny();
#else
return(gdFontTiny);
#endif
break;
case MS_SMALL:
#ifdef GD_HAS_GETBITMAPFONT
return gdFontGetSmall();
#else
return(gdFontSmall);
#endif
break;
case MS_MEDIUM:
#ifdef GD_HAS_GETBITMAPFONT
return gdFontGetMediumBold();
#else
return(gdFontMediumBold);
#endif
break;
case MS_LARGE:
#ifdef GD_HAS_GETBITMAPFONT
return gdFontGetLarge();
#else
return(gdFontLarge);
#endif
break;
case MS_GIANT:
#ifdef GD_HAS_GETBITMAPFONT
return gdFontGetGiant();
#else
return(gdFontGiant);
#endif
break;
default:
msSetError(MS_GDERR,"Invalid bitmap font. Must be one of tiny, small, medium, large or giant." , "msGetBitmapFont()");
return(NULL);
}
}
gdFontPtr msGetBitmapFont(int size)
{
switch(size) { /* set the font to use */
case MS_TINY:
return gdFontGetTiny();
break;
case MS_SMALL:
return gdFontGetSmall();
break;
case MS_MEDIUM:
return gdFontGetMediumBold();
break;
case MS_LARGE:
return gdFontGetLarge();
break;
case MS_GIANT:
return gdFontGetGiant();
break;
default:
msSetError(MS_GDERR,"Invalid bitmap font. Must be one of tiny, small, medium, large or giant." , "msGetBitmapFont()");
return(NULL);
}
}
int
main (void)
{
#ifdef HAVE_LIBPNG
/* Input and output files */
FILE *in;
FILE *out;
/* Input and output images */
gdImagePtr im_in = 0, im_out = 0;
/* Brush image */
gdImagePtr brush;
/* Color indexes */
int white;
int blue;
int red;
int green;
/* Points for polygon */
gdPoint points[3];
int i;
/* gd fonts for font test */
gdFontPtr fonts[5];
int y;
/* Create output image, in true color. */
im_out = gdImageCreateTrueColor (256 + 384, 384);
/* 2.0.2: first color allocated would automatically be background in a
palette based image. Since this is a truecolor image, with an
automatic background of black, we must fill it explicitly. */
white = gdImageColorAllocate (im_out, 255, 255, 255);
gdImageFilledRectangle (im_out, 0, 0, gdImageSX (im_out),
gdImageSY (im_out), white);
/* Set transparent color. */
gdImageColorTransparent (im_out, white);
/* Try to load demoin.png and paste part of it into the
output image. */
in = fopen ("demoin.png", "rb");
if (!in)
{
fprintf (stderr, "Can't load source image; this demo\n");
fprintf (stderr, "is much more impressive if demoin.png\n");
fprintf (stderr, "is available.\n");
im_in = 0;
}
else
{
int a;
im_in = gdImageCreateFromPng (in);
fclose (in);
/* Now copy, and magnify as we do so */
gdImageCopyResampled (im_out, im_in, 32, 32, 0, 0, 192, 192, 255, 255);
/* Now display variously rotated space shuttles in a circle of our own */
for (a = 0; (a < 360); a += 45)
{
int cx = cos (a * .0174532925) * 128;
int cy = -sin (a * .0174532925) * 128;
gdImageCopyRotated (im_out, im_in,
256 + 192 + cx, 192 + cy,
0, 0, gdImageSX (im_in), gdImageSY (im_in), a);
}
}
red = gdImageColorAllocate (im_out, 255, 0, 0);
green = gdImageColorAllocate (im_out, 0, 255, 0);
blue = gdImageColorAllocate (im_out, 0, 0, 255);
/* Fat Rectangle */
gdImageSetThickness (im_out, 4);
gdImageLine (im_out, 16, 16, 240, 16, green);
gdImageLine (im_out, 240, 16, 240, 240, green);
gdImageLine (im_out, 240, 240, 16, 240, green);
gdImageLine (im_out, 16, 240, 16, 16, green);
gdImageSetThickness (im_out, 1);
/* Circle */
gdImageArc (im_out, 128, 128, 60, 20, 0, 720, blue);
/* Arc */
gdImageArc (im_out, 128, 128, 40, 40, 90, 270, blue);
/* Flood fill: doesn't do much on a continuously
variable tone jpeg original. */
gdImageFill (im_out, 8, 8, blue);
/* Polygon */
points[0].x = 64;
points[0].y = 0;
points[1].x = 0;
points[1].y = 128;
points[2].x = 128;
points[2].y = 128;
gdImageFilledPolygon (im_out, points, 3, green);
/* 2.0.12: Antialiased Polygon */
gdImageSetAntiAliased (im_out, green);
for (i = 0; (i < 3); i++)
{
points[i].x += 128;
}
gdImageFilledPolygon (im_out, points, 3, gdAntiAliased);
/* Brush. A fairly wild example also involving a line style! */
if (im_in)
{
int style[8];
brush = gdImageCreateTrueColor (16, 16);
gdImageCopyResized (brush, im_in,
0, 0, 0, 0,
gdImageSX (brush), gdImageSY (brush),
gdImageSX (im_in), gdImageSY (im_in));
gdImageSetBrush (im_out, brush);
/* With a style, so they won't overprint each other.
Normally, they would, yielding a fat-brush effect. */
style[0] = 0;
style[1] = 0;
style[2] = 0;
style[3] = 0;
style[4] = 0;
style[5] = 0;
style[6] = 0;
style[7] = 1;
gdImageSetStyle (im_out, style, 8);
/* Draw the styled, brushed line */
gdImageLine (im_out, 0, 255, 255, 0, gdStyledBrushed);
}
/* Text (non-truetype; see gdtestft for a freetype demo) */
fonts[0] = gdFontGetTiny ();
fonts[1] = gdFontGetSmall ();
fonts[2] = gdFontGetMediumBold ();
fonts[3] = gdFontGetLarge ();
fonts[4] = gdFontGetGiant ();
y = 0;
for (i = 0; (i <= 4); i++)
{
gdImageString (im_out, fonts[i], 32, 32 + y, (unsigned char *) "hi",
red);
y += fonts[i]->h;
}
y = 0;
for (i = 0; (i <= 4); i++)
{
gdImageStringUp (im_out, fonts[i], 64 + y, 64,
(unsigned char *) "hi", red);
y += fonts[i]->h;
}
/* Random antialiased lines; coordinates all over the image,
but the output will respect a small clipping rectangle */
gdImageSetClip (im_out, 0, gdImageSY (im_out) - 100,
100, gdImageSY (im_out));
/* Fixed seed for reproducibility of results */
srand (100);
for (i = 0; (i < 100); i++)
{
int x1 = rand () % gdImageSX (im_out);
int y1 = rand () % gdImageSY (im_out);
int x2 = rand () % gdImageSX (im_out);
int y2 = rand () % gdImageSY (im_out);
gdImageSetAntiAliased (im_out, white);
gdImageLine (im_out, x1, y1, x2, y2, gdAntiAliased);
}
/* Make output image interlaced (progressive, in the case of JPEG) */
gdImageInterlace (im_out, 1);
out = fopen ("demoout.png", "wb");
/* Write PNG */
gdImagePng (im_out, out);
fclose (out);
out = fopen ("demoout.gif", "wb");
/* Write GIF (2.0.28) */
gdImageGif (im_out, out);
fclose (out);
/* 2.0.12: also write a paletteized png comparable to the gif */
out = fopen ("demooutp.png", "wb");
gdImageTrueColorToPalette (im_out, 0, 256);
gdImagePng (im_out, out);
fclose (out);
gdImageDestroy (im_out);
if (im_in)
{
gdImageDestroy (im_in);
}
#else
fprintf (stderr, "No PNG library support.\n");
#endif /* HAVE_LIBPNG */
return 0;
}
void graficotorta(int n, long cantidad[], int estado[]) {
gdImagePtr imagen;
FILE *archivo;
char titulo[513];
char etiqueta[512];
int blanco, negro, color;
gdFontPtr fuente = gdFontGetSmall();
imagen = gdImageCreateTrueColor(IMG_WIDTH, IMG_HEIGHT);
int i;
int angEtiqueta, xEtiqueta, yEtiqueta;
float eqgrados;
int iniciotrozo, fintrozo;
long suma = 0;
int aprox;
for (i=0; i<n; i++) {
suma = suma + cantidad[i];
}
eqgrados = 360.0/suma;
if (imagen) {
blanco = gdImageColorAllocate(imagen, 255, 255, 255);
negro = gdImageColorAllocate(imagen, 0, 0, 0);
// Pintamos el fondo Blanco
gdImageFill(imagen, 0, 0, blanco);
iniciotrozo = 0;
for (i=0; i<n; i++) {
fintrozo = (int) iniciotrozo+cantidad[i]*eqgrados;
angEtiqueta = (iniciotrozo + fintrozo) / 2;
xEtiqueta = cos(angEtiqueta*PI/180) * 220 + 400;
yEtiqueta = sin(angEtiqueta*PI/180) * 220 + 290;
// Color
color = gdImageColorAllocate(imagen, color_aleatoreo(), color_aleatoreo(), color_aleatoreo());
//Pintamos fondo el trozo
gdImageFilledArc(imagen, 400, 300, 400, 400, iniciotrozo, fintrozo, color, gdArc);
//Etiqueta de peticion
memset(etiqueta, 0, 513);
snprintf(etiqueta, 512, "peticion %s",intStr(estado[i]));
gdImageString(imagen, fuente, xEtiqueta-25, yEtiqueta, (unsigned char *) etiqueta, negro);
//Correccion de aproximacion para el porcentaje
aprox = cantidad[i] * 1000 / suma;
aprox = aprox%10;
if (aprox>=5)
aprox = 1;
else
aprox = 0;
//Etiqueta de porcentaje
memset(etiqueta, 0, 513);
snprintf(etiqueta, 512, "%s%%",longStr(cantidad[i]*100/suma+aprox));
if (cantidad[i]*100/suma<3){ //Para que la etiqueta sea legible
xEtiqueta = xEtiqueta + 52;
yEtiqueta = yEtiqueta - 15;
}
gdImageString(imagen, fuente, xEtiqueta, yEtiqueta+15, (unsigned char *) etiqueta, negro);
iniciotrozo = (int) iniciotrozo+cantidad[i]*eqgrados;
}
//Pintamos borde del circulo
gdImageArc(imagen, 400, 300, 400, 400, 0, 360, negro);
// Coloco el título
memset(titulo, 0, 513);
snprintf(titulo, 512, "Peticiones Por Estado");
gdImageString(imagen, fuente, (int) IMG_WIDTH * 0.4, 25, (unsigned char *) titulo, negro);
// Pintamos Borde
gdImageLine(imagen, BORDE_ANCHO, BORDE_ALTO, (IMG_WIDTH - BORDE_ANCHO), BORDE_ALTO, negro); //linea horiz superior
gdImageLine(imagen, BORDE_ANCHO, (IMG_HEIGHT - BORDE_ALTO), (IMG_WIDTH - BORDE_ANCHO), (IMG_HEIGHT - BORDE_ALTO), negro); //linea horiz inferior
gdImageLine(imagen, BORDE_ANCHO, BORDE_ALTO, BORDE_ANCHO, (IMG_HEIGHT - BORDE_ALTO), negro); //linea vertical izquierda
gdImageLine(imagen, (IMG_WIDTH - BORDE_ANCHO), BORDE_ALTO, (IMG_WIDTH - BORDE_ANCHO), (IMG_HEIGHT - BORDE_ALTO), negro); //linea horiz derecha
// Guardar imagen
archivo = fopen("graficot.jpg", "wb");
if (archivo != NULL) {
gdImageJpeg(imagen, archivo, 100);
fclose(archivo);
}
gdImageDestroy(imagen);
}
}
int DrawString(gdImagePtr image, char *szString, int x, int y, char* font, int size, int color, TEXT_ALIGN align)
{
int brect[8];
gdFontPtr pFont;
char* err;
int offsetX = 0, offsetY = 0;
if(image)
{
/* use TTF */
if(font && strlen(font) != 0 && size > 0)
{
err = gdImageStringFT(NULL, brect, 0, font,size,0.,0,0,szString);
if (err)
{
/* if error occur, use native font */
return DrawString(image, szString, x, y, "", size, color, align);
}
switch(align) {
case TA_CENTERED:
offsetX = -(brect[2]-brect[0])/2;
offsetY = +(brect[3]-brect[5])/2;
break;
case TA_TOPLEFT:
offsetX = 0;
offsetY = (brect[3]-brect[5]);
break;
case TA_RIGHTBOTTOM:
offsetX = -(brect[2]-brect[0]);
offsetY = 0;
break;
}
err = gdImageStringFT( image,brect,
color,font, size, 0.,
x+offsetX,
y+offsetY,
szString);
if (err)
{
/* if error occur, use native font */
return DrawString(image, szString, x, y, "", size, color, align);
}
}
/* use native GD fonts */
else
{
/* negative size */
switch(size) {
case UF_TINY:
pFont = gdFontGetTiny();
break;
case UF_SMALL:
pFont = gdFontGetSmall();
break;
case UF_MEDIUM:
pFont = gdFontGetMediumBold();
break;
case UF_LARGE:
pFont = gdFontGetLarge();
break;
case UF_GIANT:
pFont = gdFontGetGiant();
break;
default:
pFont = gdFontGetMediumBold();
break;
}
/* positive size */
if(size > 0)
{
if(size > 9)
{
pFont = gdFontGetGiant();
}
else
{
pFont = gdFontGetSmall();
}
}
switch(align) {
case TA_CENTERED:
offsetX = -(int)(strlen(szString) * pFont->w)/2;
offsetY = (int)-pFont->h/2;
break;
case TA_TOPLEFT:
offsetX = offsetY = 0;
break;
case TA_RIGHTBOTTOM:
offsetX = -(int)(strlen(szString) * pFont->w);
offsetY = -pFont->h;
break;
}
gdImageString( image, pFont,
x+offsetX,
y+offsetY,
(unsigned char*)szString, color);
}
return OK;
}
return FAILURE;
}
