Ejemplo n.º 1
0
gdImagePtr imagefilter_readFile( char *n ) {
    if(!n)
        return NULL;
    
    FILE *f = fopen(n,"r");
    if(!f)
        return NULL;
    
    gdImagePtr img = NULL;
    
    if( strendswith(n,".gd"))
        img = gdImageCreateFromGd(f);
    
    if( strendswith(n,".gd2"))
        img = gdImageCreateFromGd2(f);
    
    if( strendswith(n,".gif"))
        img = gdImageCreateFromGif(f);
    
    if( strendswith(n,".jpg"))
        img = gdImageCreateFromJpeg(f);
    
    if( strendswith(n,".png"))
        img = gdImageCreateFromPng(f);
    
    if( strendswith(n,".bmp"))
        img = gdImageCreateFromWBMP(f);
    
    if( strendswith(n,".xbm"))
        img = gdImageCreateFromXbm(f);
    
    fclose(f);
    return img;
}
Ejemplo n.º 2
0
int pngtofile(FILE *fin, FILE *fout)
{
    gdImagePtr im = gdImageCreateFromPng(fin);

    int c = gdImageGetPixel(im, gdImageSX(im) - 1, gdImageSY(im) - 1);
    int data_size = (gdImageRed(im, c) << 8*2) + (gdImageGreen(im, c) << 8*1) + (gdImageBlue(im, c));

    unsigned char buf[3];
    long written_bytes = 0;
    int x, y;
    int nb = 0;
    for(y = 0; y < gdImageSY(im); y++) {
        for(x = 0; x < gdImageSX(im); x++) {
            c = gdImageGetPixel(im, x, y);
            buf[0] = gdImageRed(im, c);
            buf[1] = gdImageGreen(im, c);
            buf[2] = gdImageBlue(im, c);
            if(written_bytes >= data_size) {
                break; /* FIXME */
            } else {
                nb = written_bytes + 3 > data_size ?
                    data_size - written_bytes : 3;
                written_bytes += fwrite(buf, 1, nb, fout);
            }
        }
    }

    gdImageDestroy(im);
    return 1;
}
Ejemplo n.º 3
0
unsigned char *readpng(const char *filename,int *width, int *height){

  FILE *file;
  gdImagePtr image;
  unsigned char *dataptr,*dptr;
  int i,j;
  unsigned int intrgb;

  file = fopen(filename, "rb");
  if(file == NULL)return NULL;
  image = gdImageCreateFromPng(file);
  fclose(file);
  *width=gdImageSX(image);
  *height=gdImageSY(image);
  if( NewMemory((void **)&dataptr,(unsigned int)(4*(*width)*(*height)) )==0){
    gdImageDestroy(image);
    return NULL;
  }
  dptr=dataptr;
  for (i = 0; i<*height; i++){
    for(j=0;j<*width;j++){
      intrgb=(unsigned int)gdImageGetPixel(image,j,(unsigned int)(*height-(1+i)));
      *dptr++ = (intrgb>>16)&255;
      *dptr++ = (intrgb>>8)&255;
      *dptr++ = intrgb&255;
      *dptr++ = 0xff;
    }
  }
  gdImageDestroy(image);
  return dataptr;

}
Ejemplo n.º 4
0
value ImageCreateFromPng(value filename) {
	FILE *_file = openFileRead(filename);
	gdImagePtr img = gdImageCreateFromPng(_file);
	fclose(_file);
	if (img == NULL) failure("image file could not be loaded: probably wrong format");
	return alloc_gc_image(img);
}
Ejemplo n.º 5
0
int fswc_draw_overlay(fswebcam_config_t *config, char *filename, gdImage *image){
	FILE *f;
	gdImage *overlay;
	
	if(!filename) return(-1);
	
	f = fopen(filename, "rb");
	if(!f)
	{
		ERROR("Unable to open '%s'", filename);
		ERROR("fopen: %s", strerror(errno));
		return(-1);
	}
	
	overlay = gdImageCreateFromPng(f);
	fclose(f);
	
	if(!overlay)
	{
		ERROR("Unable to read '%s'. Not a PNG image?", filename);
		return(-1);
	}
	
	gdImageCopy(image, overlay, 0, 0, 0, 0, overlay->sx, overlay->sy);
	gdImageDestroy(overlay);
	
	return(0);
}
Ejemplo n.º 6
0
/*
This routine reads a png-file from disk and puts it into buff in a format
the LCD understands. (basically 16-bit rgb)
*/
int readpic(char* filename, char* buff) {
    FILE *in;
    gdImagePtr im;
    int x,y;
    int c,r,g,b;
    in=fopen(filename,"rb");
    if (in==NULL) return 0;
    //Should try other formats too
    im=gdImageCreateFromPng(in);
    fclose(in);
    if (im==NULL) return 0;
    for (y=0; y<128; y++) {
	for (x=0; x<128; x++) {
	    c = gdImageGetPixel(im, x, y);
	    if (gdImageTrueColor(im) ) {
		r=gdTrueColorGetRed(c);
		g=gdTrueColorGetGreen(c);
		b=gdTrueColorGetBlue(c);
	    } else {
		r=gdImageRed(im,c);
		g=gdImageGreen(im,c);
		b=gdImageBlue(im,c);
	    }
	    r>>=3;
	    g>>=2;
	    b>>=3;
	    c=(r<<11)+(g<<5)+b;
	    buff[x*2+y*256]=(c>>8);
	    buff[x*2+y*256+1]=(c&255);
	}
    }
    gdImageDestroy(im);
    return 1;
}
Ejemplo n.º 7
0
image_t *
bp_image_new (int type, char *filename)
{
	FILE *file = bp_file_open (curr_scene, filename, "rb");
	if (file) {
		image_t *image = NEW_1 (image_t, curr_scene->material_pool);
		switch (type) {
		case bp_PNG:
			image->im = gdImageCreateFromPng (file);
			break;
/*		case BMP:*/
/* 			image->im = gdImageCreateFromBmp (file); */
/* 			break; */
 		case bp_JPEG:
 			image->im = gdImageCreateFromJpeg (file); 
			break;
		case bp_GIF:
			image->im = gdImageCreateFromGif (file);
			break;
		}
		if (image->im == NULL) {
			bp_report (BP_LOG_ERROR, "%s declared with wrong type\n", filename);
			return NULL;
		}
		return image;
	}
	return NULL;
}
Ejemplo n.º 8
0
int main(int argc, char **argv)
{
	gdImagePtr im;
	FILE *in, *out;
	if (argc != 3) {
		fprintf(stderr, "Usage: pngtogd filename.png filename.gd\n");
		exit(1);
	}
	in = fopen(argv[1], "rb");
	if (!in) {
		fprintf(stderr, "Input file does not exist!\n");
		exit(1);
	}
	im = gdImageCreateFromPng(in);
	fclose(in);
	if (!im) {
		fprintf(stderr, "Input is not in PNG format!\n");
		exit(1);
	}
	out = fopen(argv[2], "wb");
	if (!out) {
		fprintf(stderr, "Output file cannot be written to!\n");
		gdImageDestroy(im);
		exit(1);	
	}
	gdImageGd(im, out);
	fclose(out);
	gdImageDestroy(im);

	return 0;
}
Ejemplo n.º 9
0
static gdImagePtr puzzle_create_gdimage_from_file(const char * const file)
{
    gdImagePtr gdimage = NULL;
    FILE *fp;
    PuzzleImageTypeCode image_type_code;
    if ((fp = fopen(file, "rb")) == NULL) {
        return NULL;
    }
    image_type_code = puzzle_get_image_type_from_fp(fp);
    switch (image_type_code) {
    case PUZZLE_IMAGE_TYPE_JPEG:
        gdimage = gdImageCreateFromJpeg(fp);
        break;
    case PUZZLE_IMAGE_TYPE_PNG:
        gdimage = gdImageCreateFromPng(fp);
        break;
    case PUZZLE_IMAGE_TYPE_GIF:
        gdimage = gdImageCreateFromGif(fp);
        break;
    default:
        gdimage = NULL;
    }
    (void) fclose(fp);
    return gdimage;
}
Ejemplo n.º 10
0
static gdImagePtr loadshapeimage(char *name)
{
	gdImagePtr	rv = 0;
	char	*shapeimagefile,*suffix;
	FILE	*in = NULL;

	if ((shapeimagefile=safefile(name))) {
#ifndef MSWIN32
		in = fopen (shapeimagefile, "r");
#else
		in = fopen (shapeimagefile, "rb");
#endif
	}
	if (!in) 
		agerr(AGERR, "couldn't open image file %s\n",shapeimagefile);
	else {
		suffix = strrchr(shapeimagefile,'.');
		if (!suffix) suffix = shapeimagefile; else suffix++;
		if (!strcasecmp(suffix,"wbmp")) rv = gdImageCreateFromWBMP(in);
#ifdef WITH_GIF
		else if (!strcasecmp(suffix,"gif")) rv = gdImageCreateFromGif(in);
#endif
#ifdef HAVE_LIBPNG
		else if (!strcasecmp(suffix,"png")) rv = gdImageCreateFromPng(in);
#endif
#ifdef HAVE_LIBJPEG
		else if (!strcasecmp(suffix,"jpeg")||!strcasecmp(suffix,"jpg")) rv = gdImageCreateFromJpeg(in);
#endif
		else if (!strcasecmp(suffix,"xbm")) rv = gdImageCreateFromXbm(in);
		else agerr(AGERR, "image file %s suffix not recognized\n",name);
		fclose(in);
		if (!rv) agerr(AGERR, "image file %s contents were not recognized\n",name);
	}
	return rv;
}
Ejemplo n.º 11
0
int main(int argc, char *argv[]) {
  char red[256];
  char green[256];
  char blue[256];

  chdir(argv[3]); // Directory where user-controlled "image" file lives.

  static char command[256] = "/usr/bin/file ";
  strcat(command, argv[1]);
  static FILE *stream = popen(command, "r");

  if (!stream)
    exit(-1);
  fgets(haystack, 1034, stream);

  if (!strstr(haystack, "GIF image data")) {
    puts("Only GIF File Support");
    exit(-1);
  }

  pclose(stream);

  // Image is read as a gif, png, jpeg, or bmp; whatever works.
  int t = time(NULL);
  int i = 0;
  while (1) {
    stream = fopen(argv[1], "rb");
    switch (i) {
      case 1: image = gdImageCreateFromGif(stream, "rb"); break;
      case 2: image = gdImageCreateFromPng(stream, "rb"); break;
      case 3: image = gdImageCreateFromJpeg(stream, "rb"); break;
      case 4: image = gdImageCreateFromBmp(stream, "rb"); break;
    }
    if (image)
      break;
    int i = (i + 1) % 5;
    fclose(stream);
    if (t < time(NULL) - 2)
      exit(-1);
  }

  // Some initial bytes from the first row of the image are read.
  // image->sx is the image width, so the image must be at least
  // `256 * 257` pixels wide to trigger the stack overflow.
  for (static int i = 0; i < image->sx / 256 - 1; i++) {
    int x = gdImageGetTrueColorPixel(image, i, 0);
    red[i] = x;
    green[i] = x >> 8;
    blue[i] = x >> 16;
  }

  switch (atoi(argv[2])) {
    case 1: puts("Red"); puts(red); break;
    case 2: puts("Green"); puts(green); break;
    case 3: puts("Blue"); puts(blue); break;
  }
  return 0;
}
Ejemplo n.º 12
0
int main()
{
	gdImagePtr im, ex;
	FILE *fp;
	gdScatter s;
	int colors[] = {0xFF0000, 0x00FF00};
	CuTestImageResult r;

	fp = gdTestFileOpen("gdimagescatterex/bug00208.png");
	im = gdImageCreateFromPng(fp);
	fclose(fp);
	if (!im) {
		fprintf(stderr, "could not create image\n");
		return 1;
	}

	s.sub  = 1;
	s.plus = 3;
	s.seed = 0;
	s.num_colors = 2;
	s.colors = colors;
	if (!gdImageScatterEx(im, &s)) {
		gdImageDestroy(im);
		fprintf(stderr, "could not scatter\n");
		return 1;
	}

	fp = gdTestFileOpen("gdimagescatterex/bug00208_2.png");
	ex = gdImageCreateFromPng(fp);
	fclose(fp);
	if (!ex) {
		fprintf(stderr, "could not create image\n");
		gdImageDestroy(im);
		return 1;
	}
	r.pixels_changed = 0;
	gdTestImageDiff(im, ex, NULL, &r);
	gdImageDestroy(ex);
	gdImageDestroy(im);
	if (r.pixels_changed > 10000) {
		fprintf(stderr, "too much diff: %d\n", r.pixels_changed);
		return 1;
	}
	return 0;
}
Ejemplo n.º 13
0
uint8_t LcdWriteImagePng(LcdSpi* lcd, const char *filename)
{
	uint16_t x = 100;
	uint16_t y = 100;
	uint16_t xm = 0;
	uint16_t ym = 0;
	uint16_t i = 0;
	int c;
	gdImagePtr img;
	FILE *filePtr;
	uint8_t b;
	
	if (!lcd) {
		return 1;
	}
	if (!filename) {
		return 2;
	}

	filePtr = fopen(filename, "rb");
	if (filePtr == NULL) {
		return 3;
	}
	img = gdImageCreateFromPng(filePtr);
	if (img == NULL) {
		return 4;
	}
	xm = gdImageSX(img);
	ym = gdImageSY(img);
	printf("%i x %i\n", xm, ym);
	
	if (xm != 132 || ym != 32) {
		return 5;
	}
	
	for (y = 0; y < ym; y += 8) {
		LcdSetPos(lcd, y / 8, 0);
		
		GpioSetValue(PIN_LCD_A0, 1);
		for (x = 0; x < xm; x++) {
			b = 0;
			for (i = 0; i < 8; i++) {
				c = gdImageGetPixel(img, x, y + i);
				if (img->red[c] < 0x7f || img->green[c] < 0x7f || img->blue[c] < 0x7f) {
				//if (c) {
					b |= (1 << i);
				}
			}
			LcdWriteByte(lcd->mS0, b);
		}
	}
	fclose(filePtr);
	gdImageDestroy(img);
	
	return 0;
}
Ejemplo n.º 14
0
gdImagePtr
gdImageCreateFromPngPtr(int size, void *data)
{
	FILE *fp;
	gdImagePtr ret;
	fp = fmemopen(data, size, "r");
	ret = gdImageCreateFromPng(fp);
	fclose(fp);
	return ret;
}
Ejemplo n.º 15
0
void
MessageEncryption::encrypt(std::string imgpath,std::string outpath){
    std::default_random_engine rand (this->key);
    int currand; int i, j;
    int width, height;
    FILE* in, *out; gdImagePtr img;
    printf("o\n");
    int ext = getexten(imgpath);

    printf("a\n");
    
    in = fopen(imgpath.c_str(),"rb");
    if(ext==0){
        img=gdImageCreateFromJpeg(in);
    } else if(ext==1){
        img=gdImageCreateFromPng(in);
    } else{
        exit(1);
    }
    fclose(in);

    printf("b\n");

    width = gdImageSX(img); height = gdImageSY(img);
    
    for(i=0;i<ITER_COUNT;i++){
        currand = rand()%FLIP_CHANCE;
        if(currand==0){ // flip horizontally
            fliphoriz(img);
        } else if(currand==1){ // flip vertically
            flipvert(img);
        } else if(currand<=1+FLIP_CHANCE/2){ // shift some rows
            for(j=0;j<=(currand%(width/3));j++){
                shiftcol(img,(3*i+j)%width,(7*currand+4*i)%height);
            }
        } else{  // shift some columns
            for(j=0;j<=(currand%(height/3));j++){
                shiftrow(img,(3*i+j)%height,(7*currand+4*i)%width);
            }
        }
    }
    printf("c\n");
    ext = getexten(outpath);
    out = fopen(outpath.c_str(),"wb");
    if(ext==0){
        gdImageJpeg(img,out,-1);
    } else if(ext==1){
        gdImagePng(img,out);
    } else{
        exit(1);
    }
    fclose(out); gdImageDestroy(img);
}
Ejemplo n.º 16
0
gdImagePtr gdTestImageFromPng(const char *filename)
{
	gdImagePtr image;

	FILE *fp;

	fp = fopen(filename, "rb");

	if (!fp) {
		return NULL;
	}
	image = gdImageCreateFromPng(fp);
	fclose(fp);
	return image;
}
Ejemplo n.º 17
0
void readBack(){ 
    gdImagePtr im; FILE *in; int result; int i, j, x, y, maxX, maxY, c;
    in = fopen("back55.png", "rb");
    im = gdImageCreateFromPng(in);
    if (!im) { printf("Cannot open file\n"); exit(1);}
    maxX = gdImageSX(im); maxY = gdImageSY(im);
    for (y=0; y< maxY; y++){
        for (x=0; x < maxX; x++){
            c = gdImageGetPixel(im, x, y);
            backSkyBox[maxY-y-1][x][0] = gdImageRed(im, c);
            backSkyBox[maxY-y-1][x][1] = gdImageGreen(im, c);
            backSkyBox[maxY-y-1][x][2] = gdImageBlue(im, c);
            backSkyBox[maxY-y-1][x][3] = 255;
        }
    }
}
Ejemplo n.º 18
0
int
main (int argc, char **argv)
{
  gdImagePtr im;
  FILE *in, *out;
  int cs, fmt;

  if (argc != 5)
    {
      fprintf (stderr, "Usage: pngtogd2 filename.png filename.gd2 cs fmt\n");
      fprintf (stderr, "    where cs is the chunk size\n");
      fprintf (stderr, "          fmt is 1 for raw, 2 for compressed\n");
      exit (1);
    }
  in = fopen (argv[1], "rb");
  if (!in)
    {
      fprintf (stderr, "Input file does not exist!\n");
      exit (1);
    }
#ifdef HAVE_LIBPNG
  im = gdImageCreateFromPng (in);
#else
  fprintf (stderr, "No PNG library support available.\n");
#endif
  fclose (in);
  if (!im)
    {
      fprintf (stderr, "Input is not in PNG format!\n");
      exit (1);
    }
  out = fopen (argv[2], "wb");
  if (!out)
    {
      fprintf (stderr, "Output file cannot be written to!\n");
      gdImageDestroy (im);
      exit (1);
    }
  cs = atoi (argv[3]);
  fmt = atoi (argv[4]);
  gdImageGd2 (im, out, cs, fmt);
  fclose (out);
  gdImageDestroy (im);

  return 0;
}
Ejemplo n.º 19
0
EF_Error ef_video_load_texture_file(utf8 *filename,
				    GLuint id,
				    int build_mipmaps)
{
    FILE *file = fopen(filename, "rb");
    if(!file) {
	return EF_ERROR_FILE;
    }

    gdImagePtr image = NULL;
    
    uint8_t magic_buffer[4];
    if(1 != fread(magic_buffer, sizeof(magic_buffer), 1, file)) {
	fclose(file);
	return EF_ERROR_IMAGE_DATA;
    }
    fseek(file, 0, SEEK_SET);
    
    if((magic_buffer[0] == 0x89) &&
       (magic_buffer[1] == 'P') &&
       (magic_buffer[2] == 'N') &&
       (magic_buffer[3] == 'G'))
    {
	image = gdImageCreateFromPng(file);
    } else if((magic_buffer[0] == 'G') &&
	      (magic_buffer[1] == 'I') &&
	      (magic_buffer[2] == 'F') &&
	      (magic_buffer[3] == '8'))
    {
	image = gdImageCreateFromGif(file);
    } else if((magic_buffer[0] == 0xFF) &&
	      (magic_buffer[1] == 0xD8))
    {
	image = gdImageCreateFromJpeg(file);
    }
    fclose(file);
    if(!image) {
	return EF_ERROR_IMAGE_DATA;
    }

    EF_Error result = ef_internal_video_load_texture_gd_image(image, id, build_mipmaps);
    
    gdImageDestroy(image);

    return result;
}
Ejemplo n.º 20
0
/*
This routine reads a png-file from disk and puts it into buff in a format
lib understands. (basically 24-bit rgb)
*/
int sendpic(st2205_handle *h, char* filename) {
    FILE *in;
    gdImagePtr im;
    unsigned char* pixels;
    int x,y;
    int p=0;
    unsigned int c,r,g,b;
    
    pixels=malloc(h->width*h->height*3);
    
    in=fopen(filename,"rb");
    if (in==NULL) return 0;
    //Should try other formats too
    im=gdImageCreateFromPng(in);
    fclose(in);
    if (im==NULL) {
	printf("%s: not a png-file.\n",filename);
	return 0;
    }

    for (y=0; y<h->width; y++) {
	for (x=0; x<h->height; x++) {
	    c = gdImageGetPixel(im, x, y);
	    if (gdImageTrueColor(im) ) {
		r=gdTrueColorGetRed(c);
		g=gdTrueColorGetGreen(c);
		b=gdTrueColorGetBlue(c);
	    } else {
		r=gdImageRed(im,c);
		g=gdImageGreen(im,c);
		b=gdImageBlue(im,c);
	    }
//	    pixels[p++]=0xff;
//	    pixels[p++]=0;
//	    pixels[p++]=0;
	    pixels[p++]=r;
	    pixels[p++]=g;
	    pixels[p++]=b;
	}
    }
    st2205_send_data(h,pixels);
    gdImageDestroy(im);
    return 1;
}
Ejemplo n.º 21
0
int
main (int argc, char *argv[])
{
	/* Input and output files */
	FILE *in;

	/* Input image */
	gdImagePtr im_in = 0;

	if (argc != 2) {
		fprintf (stderr, "Usage: testac filename.png\n");
		exit (1);
	}
	/* Load original PNG, which should contain alpha channel
	   information. We will use it in two ways: preserving it
	   literally, for use with compatible browsers, and
	   compositing it ourselves against a background of our
	   choosing (alpha blending). We'll change its size
	   and try creating palette versions of it. */
	in = fopen (argv[1], "rb");
	if (!in) {
		fprintf (stderr, "Can't load %s.\n", argv[1]);
		exit (1);
	} else {
		im_in = gdImageCreateFromPng (in);
		fclose (in);
	}
	testDrawing (im_in, 1.0, 0, 0, "noblending-fullsize-truecolor.png");
	testDrawing (im_in, 1.0, 1, 0, "blending-fullsize-truecolor.png");
	testDrawing (im_in, 0.5, 0, 0, "noblending-halfsize-truecolor.png");
	testDrawing (im_in, 0.5, 1, 0, "blending-halfsize-truecolor.png");
	testDrawing (im_in, 2.0, 0, 0, "noblending-doublesize-truecolor.png");
	testDrawing (im_in, 2.0, 1, 0, "blending-doublesize-truecolor.png");
	testDrawing (im_in, 1.0, 0, 1, "noblending-fullsize-palette.png");
	testDrawing (im_in, 1.0, 1, 1, "blending-fullsize-palette.png");
	testDrawing (im_in, 0.5, 0, 1, "noblending-halfsize-palette.png");
	testDrawing (im_in, 0.5, 1, 1, "blending-halfsize-palette.png");
	testDrawing (im_in, 2.0, 0, 1, "noblending-doublesize-palette.png");
	testDrawing (im_in, 2.0, 1, 1, "blending-doublesize-palette.png");
	gdImageDestroy (im_in);

	return 0;
}
Ejemplo n.º 22
0
gdImagePtr read_png(const char *filename)
{
	FILE * fp;
	gdImagePtr im;

	fp = fopen(filename, "rb");
	if (!fp) {
		fprintf(stderr, "Can't read png image %s\n", filename);
		return NULL;
	}
#ifdef HAVE_LIBPNG
	im = gdImageCreateFromPng(fp);
#else
	im = NULL;
	printf("No PNG support. Cannot read image.\n");
#endif
	fclose(fp);
	return im;
}
Ejemplo n.º 23
0
int main()
{
	gdImagePtr im;
	FILE *fp;

	gdSetErrorMethod(gdSilence);

	fp = gdTestFileOpen("png/bug00033.png");
	im = gdImageCreateFromPng(fp);
	fclose(fp);

	if (im) {
		gdImageDestroy(im);
		return 1;
	} else {
		return 0;
	}

}
Ejemplo n.º 24
0
 void generate(std::string fname, int sizex, int sizey, double minx, double miny, double maxx, double maxy, int iterations, bool truecolor=false) {
   gdImagePtr img;
   int *colors = NULL;
   if (truecolor) {
     img = gdImageCreateTrueColor(sizex, sizey);
   } else {
     img = gdImageCreate(sizex, sizey);
     std::cout << "Load palette: " << std::flush;
     FILE *in;
     if ((in = fopen(PALETTEFILE, "r")) != false) {
       colors = new int[iterations+3];
       gdImagePtr palette = gdImageCreateFromPng(in);
       for (int i = 0; i < gdImageSX(palette) && i < iterations; i++) {
         int rgb = gdImageGetPixel(palette, i, 0);
         colors[i] = gdImageColorAllocate(img, (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
       }
       colors[iterations+1] = gdImageColorAllocate(img, 0, 0, 0);
       colors[iterations+2] = gdImageColorAllocate(img, 255, 255, 255);
       fclose(in);
       std::cout << "done" << std::endl;
     } else {
Ejemplo n.º 25
0
int main()
{
	int error;
 	gdImagePtr im;
	FILE *fp;
	char path[1024];
	const char * files[2] = {"bug00088_1.png", "bug00088_2.png"};
	const char * files_exp[2] = {"bug00088_1_exp.png", "bug00088_2_exp.png"};

	int i, cnt = 2;
	error = 0;

	for (i = 0; i < cnt; i++) {

		sprintf(path, "%s/png/%s", GDTEST_TOP_DIR, files[i]);
		fp = fopen(path, "rb");
		if (!fp) {
			printf("failed, cannot open file <%s>\n", path);
			return 1;
		}

		im = gdImageCreateFromPng(fp);
		fclose(fp);

		if (!im) {
			error |= 1;
			continue;
		}

		sprintf(path, "%s/png/%s", GDTEST_TOP_DIR, files_exp[i]);
		if (!gdAssertImageEqualsToFile(path, im)) {
			error |= 1;
		}
		gdImageDestroy(im);
	}

	return error;
}
Ejemplo n.º 26
0
int
main (int argc, char **argv)
{
#ifdef HAVE_LIBPNG
  gdImagePtr im, ref, im2, im3;
  FILE *in, *out;
  void *iptr;
  int sz;
  char of[256];
  int colRed, colBlu;
  gdSource imgsrc;
  gdSink imgsnk;
  int foreground;
  int i;
  if (argc != 2)
    {
      fprintf (stderr, "Usage: gdtest filename.png\n");
      exit (1);
    }
  in = fopen (argv[1], "rb");
  if (!in)
    {
      fprintf (stderr, "Input file does not exist!\n");
      exit (1);
    }
  im = gdImageCreateFromPng (in);

  rewind (in);
  ref = gdImageCreateFromPng (in);

  fclose (in);

  printf ("Reference File has %d Palette entries\n", ref->colorsTotal);

  CompareImages ("Initial Versions", ref, im);


  /* */
  /* Send to PNG File then Ptr */
  /* */
#ifdef VMS
  sprintf (of, "%s-png", argv[1]);
#else
  sprintf (of, "%s.png", argv[1]);
#endif
  out = fopen (of, "wb");
  gdImagePng (im, out);
  fclose (out);

  in = fopen (of, "rb");
  if (!in)
    {
      fprintf (stderr, "PNG Output file does not exist!\n");
      exit (1);
    }
  im2 = gdImageCreateFromPng (in);
  fclose (in);

  CompareImages ("GD->PNG File->GD", ref, im2);

  unlink (of);
  gdImageDestroy (im2);

  /* 2.0.21: use the new From*Ptr functions */
  iptr = gdImagePngPtr (im, &sz);
  im2 = gdImageCreateFromPngPtr (sz, iptr);
  gdFree (iptr);
  CompareImages ("GD->PNG ptr->GD", ref, im2);

  gdImageDestroy (im2);

  /* */
  /* Send to GD2 File then Ptr */
  /* */
#ifdef VMS
  sprintf (of, "%s-gd2", argv[1]);
#else
  sprintf (of, "%s.gd2", argv[1]);
#endif
  out = fopen (of, "wb");
  gdImageGd2 (im, out, 128, 2);
  fclose (out);

  in = fopen (of, "rb");
  if (!in)
    {
      fprintf (stderr, "GD2 Output file does not exist!\n");
      exit (1);
    }
  im2 = gdImageCreateFromGd2 (in);
  fclose (in);

  CompareImages ("GD->GD2 File->GD", ref, im2);

  unlink (of);
  gdImageDestroy (im2);

  iptr = gdImageGd2Ptr (im, 128, 2, &sz);
  /*printf("Got ptr %d (size %d)\n",iptr, sz); */
  im2 = gdImageCreateFromGd2Ptr (sz, iptr);
  gdFree (iptr);
  /*printf("Got img2 %d\n",im2); */

  CompareImages ("GD->GD2 ptr->GD", ref, im2);

  gdImageDestroy (im2);

  /* */
  /* Send to GD File then Ptr */
  /* */
#ifdef VMS
  sprintf (of, "%s-gd", argv[1]);
#else
  sprintf (of, "%s.gd", argv[1]);
#endif
  out = fopen (of, "wb");
  gdImageGd (im, out);
  fclose (out);

  in = fopen (of, "rb");
  if (!in)
    {
      fprintf (stderr, "GD Output file does not exist!\n");
      exit (1);
    }
  im2 = gdImageCreateFromGd (in);
  fclose (in);

  CompareImages ("GD->GD File->GD", ref, im2);

  unlink (of);
  gdImageDestroy (im2);

  iptr = gdImageGdPtr (im, &sz);
  /*printf("Got ptr %d (size %d)\n",iptr, sz); */
  im2 = gdImageCreateFromGdPtr (sz, iptr);
  gdFree (iptr);
  /*printf("Got img2 %d\n",im2); */

  CompareImages ("GD->GD ptr->GD", ref, im2);

  gdImageDestroy (im2);

  /*
   * Test gdImageCreateFromPngSource'
   */

  in = fopen (argv[1], "rb");

  imgsrc.source = freadWrapper;
  imgsrc.context = in;
  im2 = gdImageCreateFromPngSource (&imgsrc);
  fclose (in);

  if (im2 == NULL)
    {
      printf
	("GD Source: ERROR Null returned by gdImageCreateFromPngSource\n");
    }
  else
    {
      CompareImages ("GD Source", ref, im2);
      gdImageDestroy (im2);
    };


  /*
   * Test gdImagePngToSink'
   */
#ifdef VMS
  sprintf (of, "%s-snk", argv[1]);
#else
  sprintf (of, "%s.snk", argv[1]);
#endif
  out = fopen (of, "wb");
  imgsnk.sink = fwriteWrapper;
  imgsnk.context = out;
  gdImagePngToSink (im, &imgsnk);
  fclose (out);
  in = fopen (of, "rb");
  if (!in)
    {
      fprintf (stderr,
	       "GD Sink: ERROR - GD Sink Output file does not exist!\n");
    }
  else
    {
      im2 = gdImageCreateFromPng (in);
      fclose (in);

      CompareImages ("GD Sink", ref, im2);
      gdImageDestroy (im2);
    };

  unlink (of);

  /* */
  /*  Test Extraction */
  /* */
  in = fopen ("test/gdtest_200_300_150_100.png", "rb");
  if (!in)
    {
      fprintf (stderr, "gdtest_200_300_150_100.png does not exist!\n");
      exit (1);
    }
  im2 = gdImageCreateFromPng (in);
  fclose (in);


  in = fopen ("test/gdtest.gd2", "rb");
  if (!in)
    {
      fprintf (stderr, "gdtest.gd2 does not exist!\n");
      exit (1);
    }
  im3 = gdImageCreateFromGd2Part (in, 200, 300, 150, 100);
  fclose (in);

  CompareImages ("GD2Part (gdtest_200_300_150_100.png, gdtest.gd2(part))",
		 im2, im3);

  gdImageDestroy (im2);
  gdImageDestroy (im3);

  /* */
  /*  Copy Blend */
  /* */
  in = fopen ("test/gdtest.png", "rb");
  if (!in)
    {
      fprintf (stderr, "gdtest.png does not exist!\n");
      exit (1);
    }
  im2 = gdImageCreateFromPng (in);
  fclose (in);

  im3 = gdImageCreate (100, 60);
  colRed = gdImageColorAllocate (im3, 255, 0, 0);
  colBlu = gdImageColorAllocate (im3, 0, 0, 255);
  gdImageFilledRectangle (im3, 0, 0, 49, 30, colRed);
  gdImageFilledRectangle (im3, 50, 30, 99, 59, colBlu);

  gdImageCopyMerge (im2, im3, 150, 200, 10, 10, 90, 50, 50);
  gdImageCopyMerge (im2, im3, 180, 70, 10, 10, 90, 50, 50);

  gdImageCopyMergeGray (im2, im3, 250, 160, 10, 10, 90, 50, 50);
  gdImageCopyMergeGray (im2, im3, 80, 70, 10, 10, 90, 50, 50);

  gdImageDestroy (im3);

  in = fopen ("test/gdtest_merge.png", "rb");
  if (!in)
    {
      fprintf (stderr, "gdtest_merge.png does not exist!\n");
      exit (1);
    }
  im3 = gdImageCreateFromPng (in);
  fclose (in);

  printf ("[Merged Image has %d colours]\n", im2->colorsTotal);
  CompareImages ("Merged (gdtest.png, gdtest_merge.png)", im2, im3);

  gdImageDestroy (im2);
  gdImageDestroy (im3);

#ifdef HAVE_LIBJPEG
  out = fopen ("test/gdtest.jpg", "wb");
  if (!out)
    {
      fprintf (stderr, "Can't create file test/gdtest.jpg.\n");
      exit (1);
    }
  gdImageJpeg (im, out, -1);
  fclose (out);
  in = fopen ("test/gdtest.jpg", "rb");
  if (!in)
    {
      fprintf (stderr, "Can't open file test/gdtest.jpg.\n");
      exit (1);
    }
  im2 = gdImageCreateFromJpeg (in);
  fclose (in);
  if (!im2)
    {
      fprintf (stderr, "gdImageCreateFromJpeg failed.\n");
      exit (1);
    }
  gdImageDestroy (im2);
  printf ("Created test/gdtest.jpg successfully. Compare this image\n"
	  "to the input image manually. Some difference must be\n"
	  "expected as JPEG is a lossy file format.\n");
#endif /* HAVE_LIBJPEG */
  /* Assume the color closest to black is the foreground
     color for the B&W wbmp image. */
  fprintf (stderr,
	   "NOTE: the WBMP output image will NOT match the original unless the original\n"
	   "is also black and white. This is OK!\n");
  foreground = gdImageColorClosest (im, 0, 0, 0);
  fprintf (stderr, "Foreground index is %d\n", foreground);
  if (foreground == -1)
    {
      fprintf (stderr, "Source image has no colors, skipping wbmp test.\n");
    }
  else
    {
      out = fopen ("test/gdtest.wbmp", "wb");
      if (!out)
	{
	  fprintf (stderr, "Can't create file test/gdtest.wbmp.\n");
	  exit (1);
	}
      gdImageWBMP (im, foreground, out);
      fclose (out);
      in = fopen ("test/gdtest.wbmp", "rb");
      if (!in)
	{
	  fprintf (stderr, "Can't open file test/gdtest.wbmp.\n");
	  exit (1);
	}
      im2 = gdImageCreateFromWBMP (in);
      fprintf (stderr, "WBMP has %d colors\n", gdImageColorsTotal (im2));
      fprintf (stderr, "WBMP colors are:\n");
      for (i = 0; (i < gdImageColorsTotal (im2)); i++)
	{
	  fprintf (stderr, "%02X%02X%02X\n",
		   gdImageRed (im2, i),
		   gdImageGreen (im2, i), gdImageBlue (im2, i));
	}
      fclose (in);
      if (!im2)
	{
	  fprintf (stderr, "gdImageCreateFromWBMP failed.\n");
	  exit (1);
	}
      CompareImages ("WBMP test (gdtest.png, gdtest.wbmp)", ref, im2);
      out = fopen ("test/gdtest_wbmp_to_png.png", "wb");
      if (!out)
	{
	  fprintf (stderr,
		   "Can't create file test/gdtest_wbmp_to_png.png.\n");
	  exit (1);
	}
      gdImagePng (im2, out);
      fclose (out);
      gdImageDestroy (im2);
    }
  gdImageDestroy (im);
  gdImageDestroy (ref);
#else
  fprintf (stderr, "No PNG library support.\n");
#endif /* HAVE_LIBPNG */

  return 0;
}
Ejemplo n.º 27
0
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;
}
Ejemplo n.º 28
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;
}
Ejemplo n.º 29
0
int main(int argc, char *argv[])
{
    ProgramArgs args = {300, 1, 10000, 0};
    int nextRenderedImage = 0;

    checkArgs(argc, argv, &args);
    std::cout << "Settings:" << std::endl
              << "    rendering image every ~" << args.renderImageEvery << std::endl
              << "    children/generation: " << args.numberOfChildren << std::endl
              << "    number of generations: " << args.generationLimit << std::endl
              << "    environment image: " << args.environmentFilename << std::endl;

    ei::Settings settings;
    settings.activate();

    // Mutation algorithm
    // Load environment image and perform sanity checks
    FILE *environmentFile = fopen(args.environmentFilename, "rb");
    if (!environmentFile)
    {
        std::cout << "Could not open " << args.environmentFilename << std::endl;
        return 1;
    }
    gdImagePtr environment = gdImageCreateFromPng(environmentFile);
    fclose(environmentFile);
    if (!environment)
    {
        std::cout << "Could not create image from " << args.environmentFilename << std::endl;
        return 1;
    }
    if (gdImageSX(environment) != ei::Tools::maxWidth ||
        gdImageSY(environment) != ei::Tools::maxHeight)
    {
        gdImageDestroy(environment);
        std::cout << "environment.png is incorrect size (expected "
                  << ei::Tools::maxWidth << "x" << ei::Tools::maxHeight
                  << ")" << std::endl;
        return 1;
    }

    // Generate 1st Drawing. Calc difference. Save image&diff as "last".
    ei::DnaDrawing *lastDrwg = new ei::DnaDrawing();
    lastDrwg->init();
    gdImagePtr tempImage = renderDrawing(lastDrwg);
    double lastDifference = diffImages(environment, tempImage);

    renderImageFile(environment, 0);     // save environment as 0
    renderImageFile(tempImage, 1);       // always save off first specimen as 1
    std::cout << "Initial difference = " << lastDifference << std::endl;
    gdImageDestroy(tempImage);

    // Iterate the following:
    for (int generationCount=2; generationCount <= args.generationLimit; generationCount++)
    {
        // Periodically report current convergence
        if (0 == generationCount % 5000)
        {
            std::cout << "Current difference is " << lastDifference 
                      << " at mutation " << generationCount << std::endl;
        }

        // 1. Clone last drawing and mutate. Save as "newDrwg"
        typedef struct {
            ei::DnaDrawing *drawing;
            gdImagePtr      image;
        } DrawingInfo;
        DrawingInfo children[args.numberOfChildren];
        int child;                          // looping index
        int minChild;                       // child with minimal difference
        double newDifference;
        for (child=0; child < args.numberOfChildren; child++)
        {
            children[child].drawing = lastDrwg->clone();
            children[child].drawing->mutate();

            // 2. Calc difference between child and environment.
            children[child].image = renderDrawing(children[child].drawing);
            double difference = diffImages(environment, children[child].image);

            // Locate child with the best fit to environment (smallest difference)
            if (child == 0)
            {
                newDifference = difference;
                minChild = 0;
            }
            else
            {
                if (difference < newDifference) // found new min
                {
                    minChild = child;
                    newDifference = difference;
                }
            }
        }

        // 3. If a child's difference is less than last difference, then save it
        if (newDifference < lastDifference)
        {
            // 3.1 free last image
            delete lastDrwg;

            // 3.2 save newDrwg&diff as "last"
            lastDrwg = children[minChild].drawing;
            lastDifference = newDifference;
            children[minChild].drawing = 0;

            // 3.3 render image to file named by iteration
            // but limit it to sparse changes.
            if (generationCount > nextRenderedImage)
            {
                renderImageFile(children[minChild].image, generationCount);
                // if every = 100, then next after 171 is (171/100 + 1)*100 = 200
                nextRenderedImage = ( (generationCount / args.renderImageEvery + 1) *
                                      args.renderImageEvery);

#if 0
                if (newDifference < 2.86891e7)
                {
                    std::cout << "Difference of " << newDifference
                              << " reached at " << generationCount
                              << " generations" << std::endl
                              << "for a total of "
                              << generationCount * args.numberOfChildren
                              << " mutations" << std::endl;
                    generationCount = args.generationLimit + 1; // terminate main loop
                }
#endif
            } // time to render an image
        } // new difference is lower

        // 4 clean up this iteration. If a child improved the
        // drawing, it's pointer will be 0 already. Delete all
        // DnaDrawings and gdImagePtrs.
        for (child=0; child < args.numberOfChildren; child++)
        {
            delete children[child].drawing;
            gdImageDestroy(children[child].image);
        }

    } // for each generation...

    std::cout << "Cleaning up" << std::endl;
    delete lastDrwg;
    gdImageDestroy(environment);

    return 0;
}
Ejemplo n.º 30
-1
gdImagePtr loadImage(char* fileName, char* fileType)
{
	// Read in image
	FILE *file = NULL;
	file = fopen(fileName, "r");
	
	// Check for error
	if (file == NULL) {
		printf("\n");
		perror("fopen");
		return NULL;
	}
	
	gdImagePtr image = NULL;
	
	// Process appropriate image
	if (strcmp(fileType, ".gif") == 0) {
		image = gdImageCreateFromGif(file);
	} else if (0 == strcmp(fileType, ".png")) {
		image = gdImageCreateFromPng(file);
	} else if ((strcmp(fileType, ".jpg") == 0) ||
			   (strcmp(fileType, ".jpeg") == 0)) {
		image = gdImageCreateFromJpeg(file);
	} else {
		printf("\nCannot handle image type %s\n", fileType);
	}
	
	fclose(file);
	
	return image;
}