void _BptDrawWorker(gdImagePtr im, LPBPTREE bpt, LPBTNODE node, int level, int index, int xpos) { unsigned int i; LPBTLEAF leaf; LPBTNODE child; int x1, x2, y1, y2, newxpos; char buf[32]; if (node->nitems & BT_LEAF) { leaf = (LPBTLEAF)node; x1 = xpos - LEAF_CX / 2; x2 = xpos + LEAF_CX / 2; y1 = level * 45 + 15; y2 = y1 + LEAF_CY; gdImageFilledRectangle(im, x1, y1, x2, y2, bgcolor); for (i = 0; i != BTNITEMS(leaf); i++) { sprintf(buf, "%f, %d", leaf->items[i].key, leaf->items[i].val); gdImageString(im, gdFontGetTiny(), x1 + 2, y1 + i * 12, (unsigned char *)buf, fgcolor); } } else { x1 = xpos - (node->nitems * 16) / 2; x2 = xpos + (node->nitems * 16) / 2; y1 = level * 45 + 15; y2 = y1 + NODE_CY / 2; y1 -= NODE_CY / 2; gdImageFilledRectangle(im, x1, y1, x2, y2, bgcolor); for (i = 0; i != node->nitems; i++) { sprintf(buf, "%f|", node->keys[i]); gdImageString(im, gdFontGetTiny(), x1 + 16 * i + 1, y1 + 2, (unsigned char *)buf, fgcolor); } level++; for (i = 0; i != node->nitems + 1; i++) { child = (LPBTNODE)(bpt->baseaddr + node->choffs[i]); if (child->nitems & BT_LEAF) newxpos = xpos + (int)(((float)i - (float)node->nitems / 2.f) * NODE_CX); else newxpos = xpos + (int)(((float)i - (float)node->nitems / 2.f) * NODE_CX * ((float)35 / (float)(level * 2))); gdImageLine(im, x1 + i * 16, y2, newxpos, level * 45 + 15, fgcolor); _BptDrawWorker(im, bpt, child, level, i, newxpos); } } }
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 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); }
int filetopng(FILE *fin, FILE *fout, int im_w, char *banner) { struct stat fin_stat; gdImagePtr im = NULL; fstat(fileno(fin), &fin_stat); long data_size = fin_stat.st_size; int im_w_bytes = im_w * 3; int im_h = ((data_size + im_w_bytes - 1) / im_w_bytes) + BANNER_HEIGHT; /* ceil((float)data_size / im_w_bytes) + BANNER_HEIGHT */ im = gdImageCreateTrueColor(im_w, im_h); unsigned char buf[3]; long bytes_read = 0; long total_bytes = 0; int x = 0; int y = 0; while((bytes_read = fread(buf, 1, 3, fin)) > 0) { total_bytes += bytes_read; gdImageSetPixel(im, x, y, gdImageColorAllocate(im, buf[0], buf[1], buf[2])); if(x + 1 < im_w) { x++; } else { x = 0; y++; } } gdImageFilledRectangle(im, 0, gdImageSY(im) - BANNER_HEIGHT, im_w - 1, gdImageSY(im) + BANNER_HEIGHT, gdImageColorAllocate(im, 255, 255, 255)); gdImageString(im, (gdFontPtr) gdFontGetTiny(), 5, gdImageSY(im) - BANNER_HEIGHT, (unsigned char *)banner, gdImageColorAllocate(im, 0, 0, 0)); /* store data_size at last pixel */ gdImageSetPixel(im, gdImageSX(im) - 1, gdImageSY(im) - 1, gdImageColorAllocate(im, (data_size & 0xff0000) >> 8*2, (data_size & 0xff00) >> 8*1, data_size & 0xff)); if(verbose) fprintf(stderr, "Width: %d\nHeight: %d\n", im_w, im_h); gdImagePng(im, fout); /* int c = gdImageGetPixel(im, gdImageSX(im) - 1, gdImageSY(im) - 1); int ds = (gdImageRed(im, c) << 8*2) + (gdImageGreen(im, c) << 8*1) + (gdImageBlue(im, c)); printf("debug: ds %d, data_size %d\n", ds, data_size); //printf("c: %d %d %d\n", (data_size & 0xff0000) >> 8*2, (data_size & 0xff00) >> 8*1, data_size & 0xff); //printf("d: %d %d %d\n", (gdImageRed(im, c) << 8*2), (gdImageGreen(im, c) << 8*1), (gdImageBlue(im, c))); */ gdImageDestroy(im); return 1; }
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; }
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; }