int main(int argc, char *argv[]) { FILE *pngout = {0}; gdImagePtr img; int fgcol, bgcol; char *str = NULL; char *fname = NULL; if(argc != 5) { fprintf(stderr, "Usage: ./imstr \"STRING\" FFFFFF 000000 image.png\n"); return 1; } else { str = argv[1]; img = gdImageCreate((gdFontGiant->w * strlen(str)) + 2, gdFontGiant->h + 2); setupcolor(argv[2]); bgcol = gdImageColorAllocate(img, red, green, blue); setupcolor(argv[3]); fgcol = gdImageColorAllocate(img, red, green, blue); fname = argv[4]; } gdImageString(img, gdFontGiant, gdImageSX(img) / 2 - (strlen(str) * gdFontGiant->w / 2), gdImageSY(img) / 2 - gdFontGiant->h / 2, str, fgcol); if((pngout = fopen(fname, "w")) == NULL) error(1, 0, "Error - fopen(): %s", fname); else { gdImagePng(img, pngout); fclose(pngout); } gdImageDestroy(img); return 0; }
void makeMeme(char *input, char *output, char *text) { FILE *in, *out; gdImagePtr im; int black; int white; in = fopen(input, "r"); // if (in == NULL) return 1; //im = gdImageCreateFromPng(in); im = gdImageCreateFromJpeg(in); fclose(in); black = gdImageColorAllocate(im, 0, 0, 0); white = gdImageColorAllocate(im, 255, 255, 255); gdImageString(im, gdFontGetLarge(), im->sx / 2 - (strlen(text) * gdFontGetLarge()->w / 2), im->sy - im->sy / 10, text, black); //gdImagePng(im, out); out = fopen(output, "w"); // printf("Meme created!\n"); gdImageJpeg(im, out, 95); gdImageDestroy(im); //if (out == NULL) return 1; fclose(out); //return 0; }
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; }
void dotest (char *font, int w, int h, char *string, const char *filename) { gdImagePtr im; FILE *out; int bg; int fc; im = gdImageCreate (w, h); bg = gdImageColorAllocate (im, 0, 0, 0); gdImageFilledRectangle (im, 1, 1, w - 1, h - 1, bg); fc = gdImageColorAllocate (im, 255, 192, 192); out = fopen (filename, "wb"); dosizes (im, fc, font, 20, 20, string); #if defined(HAVE_LIBPNG) gdImagePng (im, out); #elif defined(HAVE_LIBJPEG) gdImageJpeg (im, out, -1); #endif fclose (out); }
int main(void) { gdImagePtr im; int white, black, r; gdPointPtr points; im = gdImageCreate(100, 100); if (!im) exit(EXIT_FAILURE); white = gdImageColorAllocate(im, 0xff, 0xff, 0xff); black = gdImageColorAllocate(im, 0, 0, 0); gdImageFilledRectangle(im, 0, 0, 99, 99, white); points = (gdPointPtr)gdCalloc(3, sizeof(gdPoint)); if (!points) { gdImageDestroy(im); exit(EXIT_FAILURE); } points[0].x = 10; points[0].y = 10; points[1].x = 50; points[1].y = 70; points[2].x = 90; points[2].y = 30; gdImageOpenPolygon(im, points, 3, black); r = gdAssertImageEqualsToFile(GDTEST_TOP_DIR "/gdimageopenpolygon/gdimageopenpolygon3.png", im); gdFree(points); gdImageDestroy(im); if (!r) exit(EXIT_FAILURE); return EXIT_SUCCESS; }
int main() { gdImagePtr im; int white, black; char *path; im = gdImageCreateTrueColor(6, 6); white = gdImageColorAllocate(im, 255, 255, 255); black = gdImageColorAllocate(im, 0, 0, 0); gdImageFilledRectangle(im, 0,0, 5,5, white); gdImageLine(im, 4,4, 4,4, black); gdImageLine(im, 1,4, 2,4, black); gdImageLine(im, 4,1, 4,2, black); gdImageSetAntiAliased(im, black); gdImageLine(im, 1,1, 1,1, gdAntiAliased); path = gdTestFilePath2("gdimageline", "bug00315_exp.png"); gdAssertImageEqualsToFile(path, im); gdFree(path); gdImageDestroy(im); return gdNumFailures(); }
gdImagePtr ca_make_gif(CA *ca_ptr, int generations, int br, int bg, int bb, int wr, int wg, int wb ) { gdImagePtr img; int black, white; int gen; int cell; img = gdImageCreate(ca_ptr->width, generations); if (!img) { fprintf(stderr,"Can't allocate image!\n"); exit(1); } black = gdImageColorAllocate(img, br, bg, bb); white = gdImageColorAllocate(img, wr, wg, wb); for(gen=0; gen < generations; gen++) { for(cell=0; cell < ca_ptr->width; cell++) { gdImageSetPixel(img, cell, gen, *(ca_ptr->c_row + cell) ? white : black); } ca_gen_next_row(ca_ptr); } return img; }
int main() { gdImagePtr im; int black; FILE *outFile; gdIOCtx *out; off_t length; /* create the test image */ im = gdImageCreate(11, 11); gdImageColorAllocate(im, 255, 255, 255); black = gdImageColorAllocate(im, 0, 0, 0); gdImageArc(im, 5, 5, 10, 10, 0, 360, black); /* write the file to disk, note the file length and delete the file */ outFile = gdTestTempFp(); out = gdNewFileCtx(outFile); gdTestAssert(out != NULL); gdImageXbmCtx(im, "github_bug_170.xbm", 1, out); out->gd_free(out); length = ftello(outFile); fclose(outFile); gdImageDestroy(im); gdTestAssertMsg(length == 250, "expected to write 250 bytes; %jd bytes written", (intmax_t) length); return gdNumFailures(); }
/* -------------------------------------------------------------------- */ void init_monthgraph(char *title) { int i = 0; int xsize = 670; int ysize = 160; imgbuf_mon = gdImageCreate(xsize,ysize); /* allocate color maps, background color first (grey) */ grey = gdImageColorAllocate(imgbuf_mon, 204, 204, 204); dkblue = gdImageColorAllocate(imgbuf_mon, 0, 0, 153); white = gdImageColorAllocate(imgbuf_mon, 255, 255, 255); dkgrey = gdImageColorAllocate(imgbuf_mon, 128, 128, 128); black = gdImageColorAllocate(imgbuf_mon, 0, 0, 0); /* makes shadow effect around the image, 2 pixels wide */ for (i=0; i<2 ;i++) { /* do shadow effect around the image, 2 pixels wide */ gdImageLine(imgbuf_mon, i, i, xsize-i, i, white); gdImageLine(imgbuf_mon, i, i, i, ysize-i, white); gdImageLine(imgbuf_mon, i, ysize-i-1, xsize-i-1, ysize-i-1, dkgrey); gdImageLine(imgbuf_mon, xsize-i-1, i, xsize-i-1, ysize-i-1, dkgrey); } /* draw the inner frame around the data, 2 pixels wide */ gdImageRectangle(imgbuf_mon, 19, 20, xsize-19, ysize-27, black); gdImageFilledRectangle(imgbuf_mon, 20, 21, xsize-20, ysize-28, white); /* draw the outermost black frame line around the image, 1 pixel wide */ gdImageRectangle(imgbuf_mon, 0, 0, xsize-1, ysize-1, black); /* display the graph title */ gdImageString(imgbuf_mon, gdFontMediumBold, 26, 5, (unsigned char*) title, dkblue); if(DEBUG>=2) printf("Finished init_monthgraph().\n"); return; }
int main() { gdImagePtr im; int error = 0; int c, c1, c2, c3, c4, color, i; im = gdImageCreateTrueColor(5, 5); c = gdImageColorExact(im, 255, 0, 255); c2 = gdImageColorExactAlpha(im, 255, 0, 255, 100); gdImageDestroy(im); if (gdTestAssert(c == 0xFF00FF) != 1) { error = -1; } if (gdTestAssert(c2 == 0x64FF00FF) != 1) { error = -1; } im = gdImageCreate(5, 5); c1 = gdImageColorAllocate(im, 255, 0, 255); c2 = gdImageColorAllocate(im, 255, 200, 0); c3 = gdImageColorAllocateAlpha(im, 255, 0, 255, 100); c1 = gdImageColorExact(im, 255, 0, 255); c2 = gdImageColorExact(im, 255, 200, 0); c3 = gdImageColorExactAlpha(im, 255, 0, 255, 100); c4 = gdImageColorExactAlpha(im, 255, 34, 255, 100); if (gdTestAssert(c1 == 0) != 1) { error = -1; } if (gdTestAssert(c2 == 1) != 1) { error = -1; } if (gdTestAssert(c3 == 2) != 1) { error = -1; } if (gdTestAssert(c4 == -1) != 1) { error = -1; } color = gdTrueColorAlpha(gdImageRed(im, c1), gdImageGreen(im, c1), gdImageBlue(im, c1), 0); if (gdTestAssert(color == 0xFF00FF) != 1) { error = -1; } color = gdTrueColorAlpha(gdImageRed(im, c2), gdImageGreen(im, c2), gdImageBlue(im, c2), 0); if (gdTestAssert(color == 0xFFC800) != 1) { error = -1; } color = gdTrueColorAlpha(gdImageRed(im, c3), gdImageGreen(im, c3), gdImageBlue(im, c3), 0); if (gdTestAssert(color == 0xFF00FF) != 1) { error = -1; } gdImageDestroy(im); return error; }
int main() { gdImagePtr src, dst; int r, g, b; void *p; int size = 0; int status = 0; CuTestImageResult result = {0, 0}; src = gdImageCreate(100, 100); if (src == NULL) { gdTestErrorMsg("could not create src\n"); return 1; } r = gdImageColorAllocate(src, 0xFF, 0, 0); g = gdImageColorAllocate(src, 0, 0xFF, 0); b = gdImageColorAllocate(src, 0, 0, 0xFF); gdImageFilledRectangle(src, 0, 0, 99, 99, r); gdImageRectangle(src, 20, 20, 79, 79, g); gdImageEllipse(src, 70, 25, 30, 20, b); #define OUTPUT_GD2(x) do { \ FILE *fp = gdTestTempFp(); \ gdImageGd2(x, fp, (GD2_CHUNKSIZE_MIN+GD2_CHUNKSIZE_MAX)/2, GD2_FMT_COMPRESSED); \ fclose(fp); \ } while (0) OUTPUT_GD2(src); p = gdImageGd2Ptr(src, (GD2_CHUNKSIZE_MIN+GD2_CHUNKSIZE_MAX)/2, GD2_FMT_COMPRESSED, &size); if (p == NULL) { status = 1; gdTestErrorMsg("p is null\n"); goto door0; } if (size <= 0) { status = 1; gdTestErrorMsg("size is non-positive\n"); goto door1; } dst = gdImageCreateFromGd2Ptr(size, p); if (dst == NULL) { status = 1; gdTestErrorMsg("could not create dst\n"); goto door1; } OUTPUT_GD2(dst); gdTestImageDiff(src, dst, NULL, &result); if (result.pixels_changed > 0) { status = 1; gdTestErrorMsg("pixels changed: %d\n", result.pixels_changed); } gdImageDestroy(dst); door1: gdFree(p); door0: gdImageDestroy(src); return status; }
int main() { gdImagePtr src, dst; int b; void *p; int size = 0; int status = 0; CuTestImageResult result = {0, 0}; src = gdImageCreate(100, 100); if (src == NULL) { printf("could not create src\n"); return 1; } gdImageColorAllocate(src, 0xFF, 0xFF, 0xFF); /* allocate white for background color */ b = gdImageColorAllocate(src, 0, 0, 0); gdImageRectangle(src, 20, 20, 79, 79, b); gdImageEllipse(src, 70, 25, 30, 20, b); #define OUTPUT_WBMP(name) do { \ FILE *fp = gdTestTempFp(); \ gdImageWBMP(name, 1, fp); \ fclose(fp); \ } while (0) OUTPUT_WBMP(src); p = gdImageWBMPPtr(src, &size, 1); if (p == NULL) { status = 1; printf("p is null\n"); goto door0; } if (size <= 0) { status = 1; printf("size is non-positive\n"); goto door1; } dst = gdImageCreateFromWBMPPtr(size, p); if (dst == NULL) { status = 1; printf("could not create dst\n"); goto door1; } OUTPUT_WBMP(dst); gdTestImageDiff(src, dst, NULL, &result); if (result.pixels_changed > 0) { status = 1; printf("pixels changed: %d\n", result.pixels_changed); } gdImageDestroy(dst); door1: gdFree(p); door0: gdImageDestroy(src); return status; }
void ColorBlackWhite::allocate(gdImagePtr image, unsigned int max_iterations) { if(colors != NULL) free(); colors = new int[2]; colors[0] = gdImageColorAllocate(image, 0, 0, 0); colors[1] = gdImageColorAllocate(image, 255, 255, 255); }
int main() { /* Declare the image */ gdImagePtr im; /* Declare output files */ FILE *pngout, *jpegout; /* Declare color indexes */ int black; int white; int cyan; int orange; /* Allocate the image: 64 pixels across by 64 pixels tall */ im = gdImageCreate(64, 64); /* Allocate the color black (red, green and blue all minimum). Since this is the first color in a new image, it will be the background color. */ black = gdImageColorAllocate(im, 0, 0, 0); /* Allocate the color white (red, green and blue all maximum). */ white = gdImageColorAllocate(im, 255, 255, 255); /* Allocate the color cyan and orange. */ cyan = gdImageColorAllocate(im, 0, 192, 255); orange = gdImageColorAllocate(im, 255, 128, 0); /* Draw a line from the upper left to the lower right, using white color index. */ gdImageLine(im, 0, 0, 63, 63, white); gdImageLine(im, 15, 0, 15, 63, cyan); gdImageLine(im, 31, 0, 31, 63, orange); /* Open a file for writing. "wb" means "write binary", important under MSDOS, harmless under Unix. */ pngout = fopen("test.png", "wb"); /* Do the same for a JPEG-format file. */ jpegout = fopen("test.jpg", "wb"); /* Output the image to the disk file in PNG format. */ gdImagePng(im, pngout); /* Output the same image in JPEG format, using the default JPEG quality setting. */ gdImageJpeg(im, jpegout, -1); /* Close the files. */ fclose(pngout); fclose(jpegout); /* Destroy the image in memory. */ gdImageDestroy(im); return(0); }
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; }
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 out_err( int IMGWIDTH, int IMGHEIGHT, FILE *fptr, unsigned long BGColor, unsigned long LineColor, char *err_str ) { gdImagePtr im; int lineclr; int bgclr; if( (GDC_hold_img & GDC_REUSE_IMAGE) && GDC_image != (void*)NULL ) im = GDC_image; else im = gdImageCreate( IMGWIDTH, IMGHEIGHT ); bgclr = gdImageColorAllocate( im, l2gdcal(BGColor) ); lineclr = gdImageColorAllocate( im, l2gdcal(LineColor) ); gdImageString( im, gdFontMediumBold, IMGWIDTH/2 - GDC_fontc[GDC_MEDBOLD].w*strlen(err_str)/2, IMGHEIGHT/3, (unsigned char*)err_str, lineclr ); /* usually GDC_generate_img is used in conjunction with hard or hold options */ if( GDC_generate_img ) { fflush(fptr); /* clear anything buffered */ switch( GDC_image_type ) { #ifdef HAVE_JPEG case GDC_JPEG: gdImageJpeg( im, fptr, GDC_jpeg_quality ); break; #endif case GDC_WBMP: gdImageWBMP( im, lineclr, fptr ); break; case GDC_GIF: gdImageGif( im, fptr); break; case GDC_PNG: default: gdImagePng( im, fptr ); } } if( GDC_hold_img & GDC_EXPOSE_IMAGE ) GDC_image = (void*)im; else gdImageDestroy(im); return; }
int create_im (char * name, char * string, int * res, int * sub, rgb backg, rgb foreg) { gdImagePtr im; FILE * background; int act[2]; int back; int fore; char * buf; int y = 0; size_t i; act[0] = res[0] / 2 - (sub[0] * gdFontGetLarge ()->w) / 2; act[1] = res[1] / 2 - (sub[1] * gdFontGetLarge ()->h) / 2; buf = (char *) malloc (((int) get_screen_dims ()[1] / gdFontGetLarge ()->w) * sizeof (char)); im = gdImageCreate (res[0], res[1]); back = gdImageColorAllocate (im, backg.r, backg.g, backg.b); fore = gdImageColorAllocate (im, foreg.r, foreg.g, foreg.b); for (i = 0; i < strlen (string); i++) { if (string[i] != '\n') buf[y++] = string[i]; else { buf[y] = '\0'; y = 0; gdImageString (im, gdFontGetLarge (), act[0], act[1], (unsigned char *) buf, fore); act[1] += gdFontGetLarge ()->h; } } buf[y] = '\0'; gdImageString (im, gdFontGetLarge (), act[0], act[1], (unsigned char *) buf, fore); background = fopen (name, "wb"); gdImageJpeg (im, background, -1); fclose (background); gdImageDestroy (im); return 1; }
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; }
int main(int argc, char **argv) { gdImagePtr A, B, C; unsigned char black, white; unsigned int minSX, minSY, maxSX, maxSY; bool rc; #ifdef HAVE_GD_PNG FILE *f; #endif if (argc < 3) { fprintf(stderr, "Usage: diffimg image1 image2 [outimage]\n"); exit(EX_USAGE); } A = imageLoad(argv[1]); B = imageLoad(argv[2]); minSX = (gdImageSX(A) < gdImageSX(B)) ? gdImageSX(A) : gdImageSX(B); minSY = (gdImageSY(A) < gdImageSY(B)) ? gdImageSY(A) : gdImageSY(B); maxSX = (gdImageSX(A) > gdImageSX(B)) ? gdImageSX(A) : gdImageSX(B); maxSY = (gdImageSY(A) > gdImageSY(B)) ? gdImageSY(A) : gdImageSY(B); C = gdImageCreatePalette (maxSX, maxSY); white = gdImageColorAllocate(C, gdRedMax, gdGreenMax, gdBlueMax); black = gdImageColorAllocate(C, 0, 0, 0); if (maxSX > minSX && maxSY > minSY) gdImageFilledRectangle(C, minSX, minSY, maxSX-1, maxSY-1, black); rc = imageDiff (A, B, C, minSX, minSY, black, white); #ifdef HAVE_GD_PNG if ((argc > 3) && ((f = fopen(argv[3], "wb")))) { gdImagePng (C, f); fclose(f); } else gdImagePng (C, stdout); #else fprintf(stderr, "PNG output support is not available\n"); #endif gdImageDestroy(A); gdImageDestroy(B); gdImageDestroy(C); return (rc ? EXIT_FAILURE : EXIT_SUCCESS); }
/*本函数将code指定的字符写入图片中,将图片大小存储在pic_size中,返回该图片所在的内存地址 写入成功时,返回的内存指针非空 写入失败时,返回的内存指针为空 */ void * sslvpn_write_string_to_pic(s8 *code, s32 *pic_size) { /* Declare color indexes */ s32 black = 0; s32 white = 0; s32 randcolor = 0; s32 i = 0; /* img pointer */ gdImagePtr im; /* Font ptr */ gdFontPtr ftptr=gdFontGetGiant(); /*Picture buffer pointer*/ void *pic_buf_ptr; /* Allocate the image: SSLVPN_VALID_PIC_WIDTH pixels across by SSLVPN_VALID_PIC_HEIGHTS pixels tall */ im = gdImageCreate(SSLVPN_VALID_PIC_WIDTH, SSLVPN_VALID_PIC_HEIGHT); /* Allocate the color white (red, green and blue all maximum). */ /* Since this is the first color in a new image, it will * be the background color. */ white = gdImageColorAllocate(im, 255, 255, 255); /* Allocate the color black (red, green and blue all minimum). */ black = gdImageColorAllocate(im, 0, 0, 0); /* Draw a centered string. */ gdImageString(im, ftptr, (im->sx) / 2 - (strlen(code) * (ftptr->w) / 2), (im->sy) / 2 - ftptr->h / 2, (u8*)code, black); /* Some disturbing points */ for(i = 0; i < SSLVPN_VALID_DISTURB_POINTS; i++) { randcolor = gdImageColorAllocate(im, sslvpn_getRandom(255), sslvpn_getRandom(255), sslvpn_getRandom(255)); gdImageSetPixel(im, sslvpn_getRandom(SSLVPN_VALID_PIC_WIDTH), sslvpn_getRandom(SSLVPN_VALID_PIC_HEIGHT), randcolor); } /* Output the image to buf and asign the length of buf to pic_size. */ pic_buf_ptr = gdImagePngPtr(im, pic_size); /* Destroy the image in memory. */ gdImageDestroy(im); return pic_buf_ptr; }
int BptDraw(LPBPTREE bpt, const char *img_filename) { gdImagePtr im; im = gdImageCreateTrueColor(IMG_CX, IMG_CY); bgcolor = gdImageColorAllocate(im, 0xFF, 0x00, 0x00); fgcolor = gdImageColorAllocate(im, 0xFF, 0xFF, 0xFF); _BptDrawWorker(im, bpt, bpt->root, 0, 0, IMG_CX / 2); ImgSavePng(img_filename, im); gdImageDestroy(im); return 1; }
int main(void) { // Create IP connection IPConnection ipcon; ipcon_create(&ipcon); // Create device object OLED64x48 oled; oled_64x48_create(&oled, UID, &ipcon); // Connect to brickd if(ipcon_connect(&ipcon, HOST, PORT) < 0) { fprintf(stderr, "Could not connect\n"); return 1; } // Don't use device before ipcon is connected // Clear display oled_64x48_clear_display(&oled); // Draw rotating line gdImagePtr image = gdImageCreate(WIDTH, HEIGHT); int black = gdImageColorAllocate(image, 0, 0, 0); int white = gdImageColorAllocate(image, 255, 255, 255); int origin_x = WIDTH / 2; int origin_y = HEIGHT / 2; int length = HEIGHT / 2 - 2; int angle = 0; printf("Press ctrl+c exit\n"); while (true) { double radians = M_PI * angle / 180.0; int x = (int)(origin_x + length * cos(radians)); int y = (int)(origin_y + length * sin(radians)); gdImageFilledRectangle(image, 0, 0, WIDTH, HEIGHT, black); gdImageLine(image, origin_x, origin_y, x, y, white); draw_image(&oled, image); millisleep(25); angle++; } gdImageDestroy(image); ipcon_destroy(&ipcon); // Calls ipcon_disconnect internally return 0; }
const char *generate_verify_num() { /* Declare the image */ gdImagePtr im; /* Declare output files */ //FILE *gifout; /* Declare color indexes */ int black; int white; int x, y, z; int rd; static char s[10]; /* Allocate the image: 64 pixels across by 64 pixels tall */ im = gdImageCreate(40, 16); /* Allocate the color black (red, green and blue all minimum). Since this is the first color in a new image, it will be the background color. */ black = gdImageColorAllocate(im, 0, 0, 0); white = gdImageColorAllocate(im, 255, 255, 255); srandom(time(0)%getpid()); rd=random()%(100000); sprintf(s, "%05d", rd); gdImageString(im, gdFontGetLarge(), 0, 0, s, white); for (z=0; z<20; z++) { x=random()%(im->sx); y=random()%(im->sy); gdImageSetPixel(im, x, y, white); } for (y=0; y<im->sy; y++) { for (x=0; x<im->sx; x++) { if (gdImageGetPixel(im, x, y)) outc('o'); else outc(' '); } outc('\n'); } gdImageDestroy(im); oflush(); return s; }
int main(void) { int i; FILE * out; gdImagePtr im; gdImagePtr prev =NULL; int black; im = gdImageCreate(100, 100); if (!im) { fprintf(stderr, "can't create image"); return 1; } out = fopen("anim.gif", "wb"); if (!out) { fprintf(stderr, "can't create file %s", "anim.gif"); return 1; } gdImageColorAllocate(im, 255, 255, 255); /* allocate white as side effect */ gdImageGifAnimBegin(im, out, 1, -1); for(i = 0; i < 20; i++) { int r,g,b; im = gdImageCreate(100, 100); r = rand() % 255; g = rand() % 255; b = rand() % 255; gdImageColorAllocate(im, 255, 255, 255); /* allocate white as side effect */ black = gdImageColorAllocate(im, r, g, b); printf("(%i, %i, %i)\n",r, g, b); gdImageFilledRectangle(im, rand() % 100, rand() % 100, rand() % 100, rand() % 100, black); gdImageGifAnimAdd(im, out, 1, 0, 0, 10, 1, prev); if(prev) { gdImageDestroy(prev); } prev = im; } gdImageGifAnimEnd(out); fclose(out); return 0; }
static void writePng(char *filename, wlImage pic) { gdImagePtr output; int x, y, i; int palette[16]; FILE *file; output = gdImageCreate(pic->width, pic->height); for (i = 0; i < 16; i++) { palette[i] = gdImageColorAllocate(output, wlPalette[i].red, wlPalette[i].green, wlPalette[i].blue); } for (y = 0; y < pic->height; y++) { for (x = 0; x < pic->width; x++) { gdImageSetPixel(output, x, y, palette[pic->pixels[y * pic->width + x]]); } } file = fopen(filename, "wb"); if (!file) { die("Unable to write PNG to %s: %s\n", filename, strerror(errno)); } gdImagePng(output, file); gdImageDestroy(output); fclose(file); }
int creaBorde( struct MAPA mapa, gdImagePtr im) { int pxmin, pxmax, pymin, pymax; int negro; double xmin, xmax, ymin, ymed, ymax; xmin = proy_mercator_x( mapa.lonmed, mapa.lonmin ); xmax = proy_mercator_x( mapa.lonmed, mapa.lonmax ); pxmin = lrintf(xmin * (double)mapa.escalax + (double)mapa.resx / 2.0); pxmax = lrintf(xmax * (double)mapa.escalax + (double)mapa.resx / 2.0); ymin = proy_mercator_y( mapa.latmin ); ymed = proy_mercator_y( mapa.latmed ); ymax = proy_mercator_y( mapa.latmax ); ymin = ( ymax + ymin ) / 2.0 pymin = lrintf( - ( ymin ) * (double) mapa.escalay + (double) mapa.resy / 2.0); pymax = lrintf( - ( ymax ) * (double) mapa.escalay + (double) mapa.resy / 2.0); // pymin = pymin + lrintf(1.0 * (double)pymin); // pymax = pymax + lrintf(1.0 * (double)pymin); // y = -(float)( py - resy / 2 ) / (float)escalaY + desplazamiento; negro = gdImageColorAllocate( im, 0, 0, 0 ); printf("(xmin,ymin)=(%f,%f) ymin - ymed = %f\n", xmin, ymin, ymin - ymed ); printf("(pxmin,pymin)=(%i,%i)\n", pxmin, pymin ); printf("(xmax,ymax)=(%f,%f) ymin - ymed = %f\n", xmax, ymax, ymed ); printf("(pxmax,pymax)=(%i,%i)\n", pxmax, pymax ); gdImageRectangle( im, pxmin, pymin, pxmax, pymax, negro ); return 0; }
void doColorRange(FILE *stream) { int n, r1, g1, b1, r2, g2, b2, r, g, b; int idx, step, minc, maxc; float alpha, beta; n = getNumber(stream); r1 = getNumber(stream); g1 = getNumber(stream); b1 = getNumber(stream); r2 = getNumber(stream); g2 = getNumber(stream); b2 = getNumber(stream); // fprintf(stderr, "%d (%d, %d, %d) to (%d, %d, %d)\n", n, r1, g1, b1, r2, g2, b2); // rd = r2 - r1; gd = g2 - g1; bd = b2 - b1; for (step = 0; step <= n; step++) { alpha = 1.0 * (n - step) / n; beta = 1.0 * step / n; r = round(alpha * r1 + beta * r2); g = round(alpha * g1 + beta * g2); b = round(alpha * b1 + beta * b2); idx = gdImageColorAllocate(image, r, g, b); // fprintf(stderr, "a=%f, idx=%d (%d, %d, %d)\n", alpha, idx, r, g, b); colors[colorptr] = idx; colorptr++; if (step == 0) { minc = idx; } else { maxc = idx; } } sprintf(cmdresult, "%d-%d", minc, maxc); }
int CFunctions::imgColorAllocate ( lua_State* luaVM ) { // bool/int imageColorAllocate( userdata im, int red, int green, int blue) 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 ) { int ret = gdImageColorAllocate( im, (int)lua_tonumber(luaVM, 2), (int)lua_tonumber(luaVM, 3), (int)lua_tonumber(luaVM, 4) ); if( ret != -1 ) lua_pushnumber( luaVM, ret ); else lua_pushboolean( luaVM, false ); } else { lua_pushboolean( luaVM, false ); } return 1; } else { pModuleManager->DebugPrintf( luaVM, "Incorrect parameters in: imageColorAllocate" ); lua_pushboolean( luaVM, false ); } return 1; } return 0; }
/* saves the data stored in the image_data array of given width and height into an output .png file returns: 0 on success 1 otherwise */ int save_image_data(char *file_name, color_t *imageData, int width, int height) { gdImagePtr img = gdImageCreateTrueColor(width, height); unsigned x, y; for(y = 0; y < height; ++y) { for(x = 0; x < width; ++x) { int index = y*width + x; int gd_color = gdImageColorAllocate(img, imageData[index].r, imageData[index].g, imageData[index].b); gdImageSetPixel(img, x, y, gd_color); } } FILE *img_file = fopen(file_name, "w+"); if (img_file == NULL) { gdImageDestroy(img); perror("error opening file"); return 1; } gdImagePng(img, img_file); gdImageDestroy(img); if (fclose(img_file)) { perror("error closing file"); return 1; } return 0; }