int main() { gdImagePtr im, tile; int im_white, im_black, tile_white, tile_black; int x,y, error = 0; FILE *fp; char path[1024]; fputs("flag 0\n", stdout); im = gdImageCreate(150, 150); tile = gdImageCreateTrueColor(36, 36); tile_white = gdImageColorAllocate(tile,255,255,255); tile_black = gdImageColorAllocate(tile,55,0,0); im_white = gdImageColorAllocate(im,255,255,255); im_black = gdImageColorAllocate(im,0,0,0); gdImageFill(tile, 0,0, tile_white); gdImageColorTransparent(tile, tile_black); gdImageColorTransparent(im, im_black); /* create the dots pattern */ for (x=0; x<36; x+=2) { for (y=0; y<36; y+=2) { gdImageSetPixel(tile,x,y,tile_black); } } gdImageSetTile(im,tile); gdImageRectangle(im, 9,9,139,139, im_black); gdImageLine(im, 9,9,139,139, im_black); gdImageFill(im, 11,12, gdTiled); fputs("flag 1\n", stdout); gdImageFill(im, 0, 0, 0xffffff); fputs("flag 2\n", stdout); gdImageFill(im, 0, 0, 0xffffff); fputs("flag 3\n", stdout); sprintf(path, "%s/gdimagefill/bug00002_3_exp.png", GDTEST_TOP_DIR); if (!gdAssertImageEqualsToFile(path, im)) { error = 1; } /* Destroy it */ gdImageDestroy(im); return error; }
FILE *piechart_init(char *filename) { FILE *pieoutf; int xsize, ysize, b1, b2; if ((pieoutf = FOPENWB(filename)) == NULL) { warn('F', TRUE, "Failed to open pie chart file %s for writing: " "ignoring it", filename); return(pieoutf); } debug('F', "Opening %s as pie chart file", filename); #ifdef RISCOS _swix(OS_File, _INR(0,2), 18, filename, 0xb60); /* set PNG filetype */ #endif xsize = normalchart?XSIZE:SHORTXSIZE; ysize = normalchart?YSIZE:SHORTYSIZE; im = gdImageCreate(xsize, ysize); /* The first colour allocated in a new image is the background colour. */ white = gdImageColorAllocate(im, 255, 255, 255); /* white */ black = gdImageColorAllocate(im, 0, 0, 0); /* black */ grey = gdImageColorAllocate(im, 128, 128, 128); /* grey */ lightgrey = gdImageColorAllocate(im, 217, 217, 217); /* light grey */ col = 0; /* Wedge colours. If these change, so must images/sq*. */ colours[col++] = gdImageColorAllocate(im, 255, 0, 0); /* red */ colours[col++] = gdImageColorAllocate(im, 0, 0, 255); /* mid blue */ colours[col++] = gdImageColorAllocate(im, 0, 128, 0); /* green */ colours[col++] = gdImageColorAllocate(im, 255, 128, 0); /* orange */ colours[col++] = gdImageColorAllocate(im, 0, 0, 128); /* navy blue */ colours[col++] = gdImageColorAllocate(im, 0, 255, 0); /* pale green */ colours[col++] = gdImageColorAllocate(im, 255, 128, 128); /* pink */ colours[col++] = gdImageColorAllocate(im, 0, 255, 255); /* cyan */ colours[col++] = gdImageColorAllocate(im, 128, 0, 128); /* purple */ colours[col++] = gdImageColorAllocate(im, 255, 255, 0); /* yellow */ col = 0; totangle = 0.75; /* starting at the top */ boxesy = BOXESTOP; b1 = xsize - 1 - BORDER; b2 = ysize - 1 - BORDER; /* Plot outline of pie, and border of image */ gdImageArc(im, XCENTRE, YCENTRE, DIAMETER + 2, DIAMETER + 2, 0, 360, black); gdImageRectangle(im, BORDER, BORDER, b1, b2, black); gdImageLine(im, xsize - 1, 0, b1, BORDER, black); gdImageLine(im, 0, ysize - 1, BORDER, b2, black); gdImageFill(im, 0, 0, lightgrey); gdImageFill(im, xsize - 1, ysize - 1, grey); gdImageLine(im, 0, 0, BORDER, BORDER, black); gdImageLine(im, xsize - 1, ysize - 1, b1, b2, black); return(pieoutf); }
int main() { gdImagePtr im, tile; int tile_red, tile_blue; int error = 0; char path[1024]; im = gdImageCreate(200, 150); tile = gdImageCreateTrueColor(2, 2); tile_red = gdImageColorAllocate(tile, 255, 0, 0); tile_blue = gdImageColorAllocate(tile, 0, 0, 255); gdImageSetPixel(tile, 0, 0, tile_red); gdImageSetPixel(tile, 1, 1, tile_red); gdImageSetPixel(tile, 1, 0, tile_blue); gdImageSetPixel(tile, 0, 1, tile_blue); gdImageSetTile(im, tile); gdImageFill(im, 11, 12, gdTiled); sprintf(path, "%s/gdimagefill/bug00104_1_exp.png", GDTEST_TOP_DIR); if (!gdAssertImageEqualsToFile(path, im)) { error = 1; } gdImageDestroy(im); gdImageDestroy(tile); return error; }
/* * Bueno, vamos a ver si podemos obtener la pieza * */ int tipojuego_get_tpieza_png( Tipojuego* tj, char* color, char* tpieza, int flags, void** png, int* width, int* height ){ #if GRAPH_ENABLED Tipopieza* tp = tj->tipo_piezas->data[ GETTIPOPIEZA(tj,tpieza) ]; int col = GETCOLOR(tj,color); gdImagePtr gd = graph_tpieza_get_gd( tp, col ); int size = 0; if( flags == GETPNG_PIEZA_CAPTURADA ){ gdImagePtr gd2 = gdImageCreate( gdImageSX( gd ) / 2, gdImageSY( gd ) / 2 ); int transp = gdImageColorAllocate( gd2, 0, 255, 0 ); gdImageColorTransparent( gd2, transp ); gdImageFill( gd2, 0, 0 , transp ); gdImageCopyResized( gd2, gd, 0, 0, 0, 0, gdImageSX(gd2), gdImageSY(gd2), gdImageSX(gd), gdImageSY(gd) ); if( png ) *png = gdImagePngPtr( gd2, &size ); if( width ) *width = gdImageSX( gd2 ); if( height ) *height = gdImageSY( gd2 ); gdImageDestroy( gd2 ); return size; } else { if( png ) *png = gdImagePngPtr( gd, &size ); if( width ) *width = gdImageSX( gd ); if( height ) *height = gdImageSY( gd ); return size; } #endif LOGPRINT( 2, "No compilado con el modulo GD tpieza = %s", tpieza ); return 0; }
int CFunctions::imgFill ( lua_State* luaVM ) { // bool/int imageFill( userdata im, int x, int y, int color ) if ( luaVM ) { if ( lua_type ( luaVM, 1 ) == LUA_TLIGHTUSERDATA && lua_type ( luaVM, 2 ) == LUA_TNUMBER && lua_type ( luaVM, 3 ) == LUA_TNUMBER && lua_type ( luaVM, 4 ) == LUA_TNUMBER ) { gdImagePtr im = mImgManager->GetImage( lua_touserdata( luaVM, 1 ) ); if( im != NULL ) { gdImageFill( im, (int)lua_tonumber( luaVM, 2 ), (int)lua_tonumber( luaVM, 3 ), (int)lua_tonumber( luaVM, 4 ) ); lua_pushboolean( luaVM, true ); } else { lua_pushboolean( luaVM, false ); } return 1; } else { pModuleManager->DebugPrintf( luaVM, "Incorrect parameters in: imageDestroy" ); } } lua_pushboolean( luaVM, false ); return 0; }
result_t Image::fill(int32_t x, int32_t y, int32_t color) { if (!m_image) return CHECK_ERROR(CALL_E_INVALID_CALL); gdImageFill(m_image, x, y, color); return 0; }
int main() { gdImagePtr im, tile; int im_black, tile_black; int x,y, error = 0; /* fputs("flag 0\n", stdout); */ im = gdImageCreate(150, 150); tile = gdImageCreate(36, 36); gdImageColorAllocate(tile,255,255,255); /* allocate white for background color */ tile_black = gdImageColorAllocate(tile,0,0,0); gdImageColorAllocate(im,255,255,255); /* allocate white for background color */ im_black = gdImageColorAllocate(im,0,0,0); /* create the dots pattern */ for (x=0; x<36; x+=2) { for (y=0; y<36; y+=2) { gdImageSetPixel(tile,x,y,tile_black); } } gdImageSetTile(im,tile); gdImageRectangle(im, 9,9,139,139, im_black); gdImageLine(im, 9,9,139,139, im_black); gdImageFill(im, 11,12, gdTiled); /* fputs("flag 1\n", stdout); */ gdImageFill(im, 0, 0, 0xffffff); /* fputs("flag 2\n", stdout); */ gdImageFill(im, 0, 0, 0xffffff); /* fputs("flag 2\n", stdout); */ if (!gdAssertImageEqualsToFile("gdimagefill/bug00002_2_exp.png", im)) { error = 1; } /* Destroy it */ gdImageDestroy(im); gdImageDestroy(tile); return error; }
/* If palette is true, we convert from truecolor to palette at the end, to test gdImageTrueColorToPalette and see file size/ quality tradeoffs. */ void testDrawing (gdImagePtr im_in, double scale, int blending, int palette, char *filename) { gdImagePtr im_out; FILE *out; /* Create output image. */ im_out = gdImageCreateTrueColor ((int) (gdImageSX (im_in) * scale), (int) (gdImageSY (im_in) * scale)); /* Request alpha blending. This causes future drawing operations to perform alpha channel blending with the background, resulting in an opaque image. Without this call, pixels in the foreground color are copied literally, *including* the alpha channel value, resulting in an output image which is potentially not opaque. This flag can be set and cleared as often as desired. */ gdImageAlphaBlending (im_out, blending); /* Flood with light blue. */ gdImageFill (im_out, (int) (gdImageSX (im_in) * scale / 2), (int) (gdImageSY (im_in) * scale / 2), gdTrueColor (192, 192, 255)); /* Copy the source image. Alpha blending should result in compositing against red. With blending turned off, the browser or viewer will composite against its preferred background, or, if it does not support an alpha channel, we will see the original colors for the pixels that ought to be transparent or semitransparent. */ gdImageCopyResampled (im_out, im_in, 0, 0, 0, 0, (int) (gdImageSX (im_in) * scale), (int) (gdImageSY (im_in) * scale), gdImageSX (im_in), gdImageSY (im_in)); /* Write PNG */ out = fopen (filename, "wb"); /* If this image is the result of alpha channel blending, it will not contain an interesting alpha channel itself. Save a little file size by not saving the alpha channel. Otherwise the file would typically be slightly larger. */ gdImageSaveAlpha (im_out, !blending); /* If requested, convert from truecolor to palette. */ if (palette) { /* Dithering, 256 colors. */ gdImageTrueColorToPalette (im_out, 1, 256); } gdImagePng (im_out, out); fclose (out); gdImageDestroy (im_out); }
void doFill(FILE *stream) { float x, y; int c; x = getFloat(stream); y = getFloat(stream); c = getColor(getNumber(stream)); gdImageFill(image, viewx(x), viewy(y), c); }
int main() { gdImagePtr im; FILE *fp; int red, blue, white, black, error = 0; char path[1024]; im = gdImageCreate(50,100); red = gdImageColorAllocate(im, 255, 0, 0); blue = gdImageColorAllocate(im, 0,0,255); white = gdImageColorAllocate(im, 255,255,255); black = gdImageColorAllocate(im, 0,0,0); gdImageFill(im, 0,0, black); gdImageLine(im, 20,20,180,20, white); gdImageLine(im, 20,20,20,70, blue); gdImageLine(im, 20,70,180,70, red); gdImageLine(im, 180,20,180,45, white); gdImageLine(im, 180,70,180,45, red); gdImageLine(im, 20,20,100,45, blue); gdImageLine(im, 20,70,100,45, blue); gdImageLine(im, 100,45,180,45, red); gdImageFill(im, 21,45, blue); gdImageFill(im, 100,69, red); gdImageFill(im, 100,21, white); sprintf(path, "%s/gdimagefill/bug00002_4_exp.png", GDTEST_TOP_DIR); if (!gdAssertImageEqualsToFile(path, im)) { error = 1; } /* Destroy it */ gdImageDestroy(im); return error; }
int main (int argc, char *argv[]) { #ifdef HAVE_LIBFREETYPE FILE *out; int transparent, green, black; gdImagePtr im; im = gdImageCreateTrueColor(100,100); black = gdImageColorResolveAlpha(im, 0, 0, 0, gdAlphaOpaque); green = gdImageColorResolveAlpha(im, 0, gdGreenMax, 0, gdAlphaOpaque); transparent = gdImageColorResolveAlpha(im, gdRedMax-1, gdGreenMax, gdBlueMax, gdAlphaTransparent); gdImageColorTransparent(im, transparent); /* Blending must be off to lay a transparent basecolor. Nothing to blend with anyway. */ gdImageAlphaBlending(im, FALSE); gdImageFill (im, im->sx/2, im->sy/2, transparent); /* Blend everything else together, especially fonts over non-transparent backgrounds */ gdImageAlphaBlending(im, TRUE); gdImageFilledRectangle (im, 30, 30, 70, 70, green); gdImageStringFT (im, NULL, black, "Times", 18, 0, 50, 50, "Hello"); gdImageSaveAlpha (im, TRUE); #ifdef HAVE_LIBPNG out = fopen ("testtr.png", "wb"); gdImagePng (im, out); fclose (out); #else fprintf(stderr, "Compiled without libpng support\n"); #endif /* HAVE_LIBPNG */ gdImageDestroy (im); return 0; #else fprintf(stderr, "Compiled without freetype support\n"); return 0; #endif /* HAVE_LIBFREETYPE */ }
/* Labyrinth als png-Bild abspeichern */ void labyrinth2png(struct rectangle *r, char *filename) { FILE *png; gdImagePtr image; int white, yellow, gray, black, edge, width, height, x, y; edge = 210; width = r->width * edge; height = r->height * edge; if ((png = fopen(filename, "w")) == NULL) { perror("fopen"); exit(EXIT_FAILURE); } if ((image = gdImageCreate(width + 1, height + 1)) == NULL) { perror("gdImageCreate"); exit(EXIT_FAILURE); } /* Farben initialisieren */ white = gdImageColorAllocate(image, RGB_WHITE); yellow = gdImageColorAllocate(image, RGB_YELLOW); gray = gdImageColorAllocate(image, RGB_GRAY); black = gdImageColorAllocate(image, RGB_BLACK); gdImageFill(image, width, height, white); for (y = 0; y < r->height; y++) for (x = 0; x < r->width; x++) if (r->cube[y][x].type != LEER) draw_cube(image, &(r->cube[y][x]), x * edge, y * edge, edge, yellow, gray, black); gdImagePng(image, png); fclose(png); gdImageDestroy(image); }
int main() { gdImagePtr im, tile; char exp[] = "bug00032_exp.png"; FILE *fp; tile = gdImageCreateTrueColor(10, 10); gdImageFill(tile, 0, 0, 0xFFFFFF); gdImageLine(tile, 0,0, 9,9, 0xff0000); gdImageColorTransparent(tile, 0xFFFFFF); im = gdImageCreateTrueColor(50, 50); gdImageFilledRectangle(im, 0, 0, 25, 25, 0x00FF00); gdImageSetTile(im, tile); gdImageFilledRectangle(im, 10, 10, 49, 49, gdTiled); gdAssertImageEqualsToFile(exp_img, im); /* Destroy it */ gdImageDestroy(im); gdImageDestroy(tile); return 0; }
// Prints the error string if in debug, otherwise generates an error image void Error(const char *pcText) { if (g_oCGI.Debug()) { printf("Error: %s\n\n", pcText); printf("Usage: id=<counter_id> [font=<font_name>] [digits=<num_of_digits>]\n"); printf("Note: out.gif will be placed in %s\n", COUNTER_ROOT); } else { gdImagePtr pOutImg = NULL; pOutImg = gdImageCreate(20, 20); if (pOutImg) { int iBlack = gdImageColorAllocate(pOutImg, 0, 0, 0); int iRed = gdImageColorAllocate(pOutImg, 255, 0, 0); gdImageFill(pOutImg, 0, 0, iBlack); gdImageLine(pOutImg, 0, 0, 19, 19, iRed); gdImageLine(pOutImg, 19, 0, 0, 19, iRed); gdImageInterlace(pOutImg, 1); #ifdef WIN32 _setmode(_fileno(stdout), _O_BINARY); #endif printf("Content-type: image/gif\n\n"); gdImageGif(pOutImg, stdout); } } } // Error
// Generates the count image from the count string, returns true if all ok bool CreateImage(const char *pcCount, const char *pcFont, int iDigits) { // Set the spare value int iCountLen = strlen(pcCount); if (iDigits < iCountLen) iDigits = iCountLen; int iSpare = 0; if (iDigits > iCountLen) iSpare = iDigits - iCountLen; // Loop vars char pcDigitName[STR_SIZE] = ""; gdImagePtr pImg = NULL; FILE *pPic = NULL; // Load the zero digit image sprintf(pcDigitName, COUNTER_ZERO, pcFont); pPic = fopen(pcDigitName, "rb+"); if (pPic == NULL) return false; pImg = gdImageCreateFromGif(pPic); fclose(pPic); if (pImg == NULL) return false; // Create the output image gdImagePtr pOutImg = NULL; pOutImg = gdImageCreate(iDigits * pImg->sx, pImg->sy); if (pOutImg == NULL) { gdImageDestroy(pImg); return false; } // Copy the palette info from one to the other... int iColTotal = gdImageColorsTotal(pImg); for (int i = 0; i < iColTotal; i++) { gdImageColorAllocate(pOutImg, gdImageRed(pImg, i), gdImageGreen(pImg, i), gdImageBlue(pImg, i)); } int iTransCol = gdImageGetTransparent(pImg); if (iTransCol >= 0) { gdImageColorTransparent(pOutImg, iTransCol); gdImageFill(pOutImg, 0, 0, iTransCol); } // Loop through each leading zero int iPos = 0; while (iSpare-- > 0) { // paste in the image gdImageCopy(pOutImg, pImg, iPos, 0, 0, 0, pImg->sx, pImg->sy); iPos += pImg->sx; } // Delete the zero image gdImageDestroy(pImg); // Loop through each counter character const char *pcPos = pcCount; while (*pcPos != '\0') { sprintf(pcDigitName, COUNTER_PIC, pcFont, *pcPos); // Load the image pPic = fopen(pcDigitName, "rb+"); if (pPic == NULL) { gdImageDestroy(pOutImg); return false; } pImg = gdImageCreateFromGif(pPic); if (pImg == NULL) { gdImageDestroy(pOutImg); return false; } // Paste in the image gdImageCopy(pOutImg, pImg, iPos, 0, 0, 0, pImg->sx, pImg->sy); iPos += pImg->sx; // Delete the image gdImageDestroy(pImg); // Update the position counter pcPos++; } // Write out the output image if (g_oCGI.Debug()) { char pcGIFName[STR_SIZE] = COUNTER_ROOT; strcat(pcGIFName, "out.gif"); FILE *pGIFFile = NULL; pGIFFile = fopen(pcGIFName, "wb"); if (pGIFFile) { gdImageGif(pOutImg, pGIFFile); fclose(pGIFFile); } } else { gdImageInterlace(pOutImg, 1); #ifdef WIN32 _setmode(_fileno(stdout), _O_BINARY); #endif printf("Content-type: image/gif\n\n"); gdImageGif(pOutImg, stdout); } // Destroy the image gdImageDestroy(pOutImg); return true; } // CreateImage
static void gd_begin_graph(GVC_t * gvc, graph_t * g, box bb, point pb) { char *bgcolor_str = NULL; char *truecolor_str; bool truecolor_p = FALSE; /* try to use cheaper paletted mode */ bool bg_transparent_p = FALSE; int bgcolor; external_surface = gvc->job->external_surface; init1_gd(gvc, g, bb, pb); if (external_surface) { im = (gdImagePtr)gvc->job->surface; } else { truecolor_str = agget(g, "truecolor"); /* allow user to force truecolor */ bgcolor_str = agget(g, "bgcolor"); if (truecolor_str && truecolor_str[0]) truecolor_p = mapbool(truecolor_str); if (bgcolor_str && strcmp(bgcolor_str, "transparent") == 0) { bg_transparent_p = TRUE; if (is_format_truecolor_capable(Output_lang)) truecolor_p = TRUE; /* force truecolor */ } if (GD_has_images(g)) truecolor_p = TRUE; /* force truecolor */ if (truecolor_p) { if (Verbose) fprintf(stderr, "%s: allocating a %dK TrueColor GD image\n", CmdName, ROUND(Viewport.x * Viewport.y * 4 / 1024.)); im = gdImageCreateTrueColor(Viewport.x, Viewport.y); } else { if (Verbose) fprintf(stderr, "%s: allocating a %dK PaletteColor GD image\n", CmdName, ROUND(Viewport.x * Viewport.y / 1024.)); im = gdImageCreate(Viewport.x, Viewport.y); } if (!im) { agerr(AGERR, "gdImageCreate returned NULL. Malloc problem?\n"); return; } } init2_gd(im); if (! external_surface) { if (bgcolor_str && bgcolor_str[0]) if (bg_transparent_p) bgcolor = transparent; else bgcolor = gd_resolve_color(bgcolor_str); else bgcolor = white; cstk[0].fillcolor = bgcolor; /* Blending must be off to lay a transparent bgcolor. Nothing to blend with anyway. */ gdImageAlphaBlending(im, FALSE); gdImageFill(im, im->sx / 2, im->sy / 2, bgcolor); /* Blend everything else together, especially fonts over non-transparent backgrounds */ gdImageAlphaBlending(im, TRUE); } #ifdef MYTRACE fprintf(stderr, "gd_begin_graph\n"); #endif }
static ngx_int_t ngx_http_qrcode_handler(ngx_http_request_t* r) { ngx_http_qrcode_loc_conf_t *qlcf; ngx_int_t code_size; ngx_int_t img_margin, img_width; ngx_int_t fg_color, bg_color; ngx_int_t x, y, posx, posy; int img_stream_len; u_char *encoded_txt; ngx_int_t rc; qlcf = ngx_http_get_module_loc_conf(r, ngx_http_qrcode_module); /* compile args */ rc = ngx_http_qrcode_compile_args(r, qlcf); if (rc != NGX_OK) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to compile args."); return NGX_HTTP_INTERNAL_SERVER_ERROR; } encoded_txt = ngx_pcalloc(r->pool, qlcf->txt.len + 1); ngx_sprintf(encoded_txt, "%V", &qlcf->txt); QRcode *code; code = QRcode_encodeString((char*)encoded_txt, qlcf->version, qlcf->level, qlcf->hint, qlcf->casesensitive); if(code == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to encode content.exception raised by libqrencode: %s", strerror(errno)); return NGX_HTTP_INTERNAL_SERVER_ERROR; } code_size = ((qlcf->size > 2048) ? 1024 : qlcf->size) / code->width; code_size = (code_size == 0) ? 1 : code_size; img_margin = qlcf->margin; img_width = code->width * code_size + 2 * img_margin; gdImagePtr img; img = gdImageCreate(img_width, img_width); fg_color = gdImageColorAllocate(img, qlcf->fg_color[0], qlcf->fg_color[1], qlcf->fg_color[2]); bg_color = gdImageColorAllocate(img, qlcf->bg_color[0], qlcf->bg_color[1], qlcf->bg_color[2]); gdImageFill(img, 0, 0, bg_color); u_char *p = code->data; for (y = 0; y < code->width; y++) { for (x = 0; x < code->width; x++) { if (*p & 1) { posx = x * code_size + img_margin; posy = y * code_size + img_margin; gdImageFilledRectangle(img, posx, posy, posx + code_size, posy + code_size, fg_color); } p++; } } u_char *img_stream; img_stream = gdImagePngPtr(img, &img_stream_len); gdImageDestroy(img); QRcode_free(code); r->headers_out.status = NGX_HTTP_OK; r->headers_out.content_length_n = img_stream_len; ngx_str_set(&r->headers_out.content_type, "image/png"); ngx_http_send_header(r); ngx_buf_t* buffer; buffer = ngx_pcalloc(r->pool, sizeof(ngx_buf_t)); if (buffer == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to allocate response buffer"); return NGX_HTTP_INTERNAL_SERVER_ERROR; } //set up the buffer chain ngx_chain_t out; buffer->pos = img_stream; buffer->last = img_stream + img_stream_len; buffer->memory = 1; buffer->last_buf = 1; out.buf = buffer; out.next = NULL; return ngx_http_output_filter(r, &out); }
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; /* 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) */ gdImageString (im_out, gdFontGiant, 32, 32, (unsigned char *) "hi", red); gdImageStringUp (im_out, gdFontSmall, 64, 64, (unsigned char *) "hi", red); /* 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); /* 2.0.12: also write a paletteized version */ 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 main(void) { /* Input and output files */ FILE *in; FILE *out; /* Input and output images */ gdImagePtr im_in, im_out; /* Brush image */ gdImagePtr brush; /* Color indexes */ int white; int blue; int red; int green; /* Points for polygon */ gdPoint points[3]; /* Create output image, 128 by 128 pixels. */ im_out = gdImageCreate(128, 128); /* First color allocated is background. */ white = gdImageColorAllocate(im_out, 255, 255, 255); /* 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 { im_in = gdImageCreateFromPng(in); fclose(in); /* Now copy, and magnify as we do so */ gdImageCopyResized(im_out, im_in, 16, 16, 0, 0, 96, 96, 127, 127); } red = gdImageColorAllocate(im_out, 255, 0, 0); green = gdImageColorAllocate(im_out, 0, 255, 0); blue = gdImageColorAllocate(im_out, 0, 0, 255); /* Rectangle */ gdImageLine(im_out, 8, 8, 120, 8, green); gdImageLine(im_out, 120, 8, 120, 120, green); gdImageLine(im_out, 120, 120, 8, 120, green); gdImageLine(im_out, 8, 120, 8, 8, green); /* Circle */ gdImageArc(im_out, 64, 64, 30, 10, 0, 360, blue); /* Arc */ gdImageArc(im_out, 64, 64, 20, 20, 45, 135, blue); /* Flood fill */ gdImageFill(im_out, 4, 4, blue); /* Polygon */ points[0].x = 32; points[0].y = 0; points[1].x = 0; points[1].y = 64; points[2].x = 64; points[2].y = 64; gdImageFilledPolygon(im_out, points, 3, green); /* Brush. A fairly wild example also involving a line style! */ if (im_in) { int style[8]; brush = gdImageCreate(8, 8); 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, 127, 127, 0, gdStyledBrushed); } /* Text */ gdImageString(im_out, gdFontGiant, 16, 16, (unsigned char *) "hi", red); gdImageStringUp(im_out, gdFontSmall, 32, 32, (unsigned char *) "hi", red); /* Make output image interlaced (allows "fade in" in some viewers, and in the latest web browsers) */ gdImageInterlace(im_out, 1); out = fopen("demoout.png", "wb"); /* Write PNG */ gdImagePng(im_out, out); fclose(out); gdImageDestroy(im_out); if (im_in) { gdImageDestroy(im_in); } return 0; }
int piechart_wedge(FILE *outf, Outchoices *od, double angle, char *s) { /* The angle is expressed between 0 and 1. Returns col if wedge was big enough to be coloured in, NO_COLOURS for grey, else -1. */ double x, y, newangle, medangle; int colour = black, rc = -1; char t[MAXCHARS]; size_t len; if (angle < 0) { angle = 1.75 - totangle; /* rest of the circle because started at 0.75 */ colour = grey; } else if (col >= NO_COLOURS) angle = 0; /* As a signal not to make a wedge. Can this happen? */ else if (angle >= MINANGLE) colour = colours[col]; if (angle >= MINANGLE || (colour == grey && angle > EPSILON)) { /* plot one edge of wedge */ x = (double)XCENTRE + (double)DIAMETER * cos(totangle * TWOPI) / 2. + PIE_EPSILON; y = (double)YCENTRE + (double)DIAMETER * sin(totangle * TWOPI) / 2. + PIE_EPSILON; gdImageLine(im, XCENTRE, YCENTRE, (int)x, (int)y, black); /* plot other edge of wedge */ newangle = totangle + angle; x = (double)XCENTRE + (double)DIAMETER * cos(newangle * TWOPI) / 2. + PIE_EPSILON; y = (double)YCENTRE + (double)DIAMETER * sin(newangle * TWOPI) / 2. + PIE_EPSILON; gdImageLine(im, XCENTRE, YCENTRE, (int)x, (int)y, black); /* Fill wedge */ medangle = totangle + angle / 2.; x = (double)XCENTRE + (double)DIAMETER * cos(medangle * TWOPI) / 2.5; y = (double)YCENTRE + (double)DIAMETER * sin(medangle * TWOPI) / 2.5; if (gdImageGetPixel(im, (int)x, (int)y) == white) { /* room to colour */ gdImageFill(im, (int)x, (int)y, colour); /* Make label for wedge. If !normalchart, this is done in piechart_key() below instead. (See long comment near bottom of piechart().) */ if (normalchart) { gdImageFilledRectangle(im, BOXESLEFT, boxesy, BOXESLEFT + BOXESSIZE, boxesy + BOXESSIZE, colour); if ((len = strlen(s)) <= MAXCHARS - 1) strcpy(t, s); else { strncpy(t, s, (MAXCHARS - 3) / 2); strcpy(t + (MAXCHARS - 3) / 2, "..."); strncpy(t + (MAXCHARS + 3) / 2, s + len - (MAXCHARS - 4) / 2, (MAXCHARS - 4) / 2); t[MAXCHARS - 1] = '\0'; } #ifdef EBCDIC strtoascii(t); #endif gdImageString(im, font, TEXTLEFT, boxesy + TEXTOFFSET, (unsigned char *)t, black); boxesy += TEXTGAP; } rc = (colour == grey)?NO_COLOURS:col; } /* end if (room to colour) */ totangle = newangle; col++; } return(rc); }
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); } }