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;
}
static void gd_end_graph_to_file(void)
{
/*
* Windows will do \n -> \r\n translations on stdout unless told otherwise.
*/
#ifdef HAVE_SETMODE
#ifdef O_BINARY
setmode(fileno(Output_file), O_BINARY);
#endif
#endif
/*
* Write IM to OUTFILE as a JFIF-formatted JPEG image, using quality
* JPEG_QUALITY. If JPEG_QUALITY is in the range 0-100, increasing values
* represent higher quality but also larger image size. If JPEG_QUALITY is
* negative, the IJG JPEG library's default quality is used (which
* should be near optimal for many applications). See the IJG JPEG
* library documentation for more details. */
#define JPEG_QUALITY -1
if (Output_lang == GD) {
gdImageGd(im, Output_file);
#ifdef HAVE_LIBZ
} else if (Output_lang == GD2) {
#define GD2_CHUNKSIZE 128
#define GD2_RAW 1
#define GD2_COMPRESSED 2
gdImageGd2(im, Output_file, GD2_CHUNKSIZE, GD2_COMPRESSED);
#endif
#ifdef WITH_GIF
} else if (Output_lang == GIF) {
gdImageGif(im, Output_file);
#endif
#ifdef HAVE_LIBPNG
#ifdef HAVE_LIBZ
} else if (Output_lang == PNG) {
gdImagePng(im, Output_file);
#endif
#endif
#ifdef HAVE_LIBJPEG
} else if (Output_lang == JPEG) {
gdImageJpeg(im, Output_file, JPEG_QUALITY);
#endif
} else if (Output_lang == WBMP) {
/* Use black for the foreground color for the B&W wbmp image. */
gdImageWBMP(im, black, Output_file);
#ifdef HAVE_LIBXPM
} else if (Output_lang == XBM) {
gdImageXbm(im, Output_file);
#endif
}
if (ImageDict) {
dtclose(ImageDict); ImageDict = 0;
}
gdImageDestroy(im);
#ifdef MYTRACE
fprintf(stderr,"gd_end_graph_to_file\n");
#endif
}
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( int argc, char **argv )
{
FILE *fp;
gdImagePtr original, cropped,resized;
if( argc != 3 ) {
printf( "usage: %s in-jpeg out-jpeg\n", argv[0] );
exit( 1 );
}
if( !(fp = fopen( argv[1], "r" )) ) {
printf( "unable to open \"%s\"\n", argv[1] );
exit( 1 );
}
if( !(original = gdImageCreateFromJpeg( fp )) ) {
printf( "unable to load \"%s\"\n", argv[1] );
exit( 1 );
}
fclose( fp );
gdRect crop;
crop.x = 100;
crop.y = 100;
crop.width = original->sx - 200;
crop.height = original->sy - 200;
cropped = gdImageCrop(original, &crop);
gdImageDestroy( original );
original = 0;
if( !(cropped) ) {
printf( "unable to crop image\n" );
exit( 1 );
}
resized = gdImageScale(cropped, crop.width * 0.9, crop.height * 0.9);
gdImageDestroy( cropped );
cropped = 0;
if( !(resized) ) {
printf( "unable to resize image\n" );
exit( 1 );
}
//gdImageSharpen is extremely slow
//gdImageSharpen( resized, 75 );
if( !(fp = fopen( argv[2], "w" )) ) {
printf( "unable to open \"%s\"\n", argv[2] );
exit( 1 );
}
gdImageJpeg( resized, fp, -1 );
fclose( fp );
gdImageDestroy( resized );
return( 0 );
}
value ImageJpeg(value img,value filename,value quality) {
int _quality = val_int(quality);
ImageData _img = getImage(img);
FILE *_file = openFileWrite(filename);
gdImageJpeg(imageImage(_img),_file,_quality);
fclose(_file);
return val_null;
}
int
graphicsGdImageSaveAsJpeg(gdImage *im, const char *path, int quality)
{
#ifdef GD_JPEG
CALL_WITH_F4(path, "wb", F_WRLCK, gdImageJpeg(im, f, quality));
#else
graphicsGdRaiseCondition("unsupported format: %s", "Jpeg");
return -1;
#endif /* GD_JPEG */
}
int main (int argc, char *argv[]) {
FILE *fp;
gdImagePtr in, out;
int w, h;
/* Help */
if (argc<=4) {
printf("%s input.jpg output.jpg width height\n", argv[0]);
return 1;
}
/* Size */
w = atoi(argv[3]);
h = atoi(argv[4]);
if (w<=0 || h<=0) {
fprintf(stderr, "Bad size %dx%d\n", h, w);
return 2;
}
/* Input */
fp = fopen(argv[1], "rb");
if (!fp) {
fprintf(stderr, "Can't read image %s\n", argv[1]);
return 3;
}
in = gdImageCreateFromJpeg(fp);
fclose(fp);
if (!in) {
fprintf(stderr, "Can't create image from %s\n", argv[1]);
return 4;
}
/* Resize */
gdImageSetInterpolationMethod(in, GD_BILINEAR_FIXED);
out = gdImageScale(in, w, h);
if (!out) {
fprintf(stderr, "gdImageScale fails\n");
return 5;
}
/* Output */
fp = fopen(argv[2], "wb");
if (!fp) {
fprintf(stderr, "Can't save image %s\n", argv[2]);
return 6;
}
gdImageJpeg(out, fp, 90);
fclose(fp);
/* Cleanups */
gdImageDestroy(in);
gdImageDestroy(out);
return 0;
}
void piechart_write(FILE *pieoutf, char *filename, logical jpegcharts) {
#ifdef HAVE_GD
if (jpegcharts)
gdImageJpeg(im, pieoutf, 100);
else
#endif
gdImagePng(im, pieoutf);
debug('F', "Closing %s", filename);
fclose(pieoutf);
gdImageDestroy(im);
}
/*
* Save float luminance image to JPEG via gd
* return -1 on error, 0 otherwise
*/
uint32_t y_float_save( float *data, uint32_t w, uint32_t h, char *name )
{
FILE *f;
gdImage *image;
uint32_t i, j, g, color;
float *dat, d, max;
if(!name)
return(-1);
f = fopen(name, "wb");
if(!f)
{
ERROR("Error opening file for output: %s", name);
ERROR("fopen: %s", strerror(errno));
return(-1);
}
image = gdImageCreateTrueColor(w,h);
if(!image)
{
ERROR("Cannot create image");
fclose(f);
return(-1);
}
max=0;
dat=data;
for(j=0;j<h;j++)
for(i=0;i<w;i++)
{
d = *(dat++);
if(d>max) max=d;
}
dat = data;
for(j=0; j<h; j++){
for(i=0; i<w; i++)
{
d = *(dat++);
g = 0xff * d/max;
color = g + (g<<8) + (g<<16);
color &= 0xffffff;
gdImageSetPixel(image,i,j,color);
}
}
gdImageJpeg(image, f, 255);
gdImageDestroy(image);
return(0);
}
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);
}
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);
}
/* ------------------------------------------------------------------------ */
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(int argc, char *argv[]) {
// Output directory
mkdir("results", S_IRWXU | S_IRWXG | S_IRWXO);
// Directory for reading and file entry
DIR *directory;
struct dirent *entry;
// Main loop
for(directory = opendir("."); (entry = readdir(directory)) != 0;) {
if(strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) continue;
if(strstr(entry->d_name, ".jpg") != entry->d_name + strlen(entry->d_name) - 4) continue;
if(strstr(entry->d_name, ".resized.jpg") == entry->d_name + strlen(entry->d_name) - 12) continue;
printf("Processing <%s>\n", entry->d_name);
FILE *file = fopen(entry->d_name, "r");
gdImagePtr source = gdImageCreateFromJpeg(file);
int source_width = gdImageSX(source);
int source_height = gdImageSY(source);
int destination_width = 1024;
int destination_height = 768;
gdImagePtr destination = gdImageCreateTrueColor(destination_width, destination_height);
gdImageCopyResampled(destination, source, 0, 0, 0, 0, destination_width, destination_height, source_width, source_height);
sprintf(destination_filename, "results/%s.resized.jpg", entry->d_name);
FILE *destination_file = fopen(destination_filename, "w");
fseek(destination_file, 0, SEEK_SET);
gdImageJpeg(destination, destination_file, 90);
fclose(destination_file);
gdImageDestroy(destination);
gdImageDestroy(source);
fclose(file);
}
closedir(directory);
printf("Job done!\n");
return 0;
}
int main(int argc, char** argv) {
if (argc < 3) return 1;
const char* thumb = argv[1];
const char* outname = argv[2];
int thudim = argc < 4 ? 0 : strtol(argv[3], NULL, 0);
if (thudim < 8) thudim = 150;
int qual = argc < 5 ? 0 : strtol(argv[4], NULL, 0);
if (qual < 10) qual = 80;
//fprintf(stderr, "%s -> %s %d %d\n", thumb, outname, thudim, qual);
int fd = -1;
unsigned char* map = NULL;
size_t len = 0;
try {
struct stat st;
if ((fd = open(thumb, O_RDONLY)) == -1 || fstat(fd, &st) ||
(map = (unsigned char*)mmap(NULL, len = st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED)
throw imgdb::io_errno(errno);
if (map[0] == 'B' && map[1] == 'M') {
fprintf(stderr, "Bitmap file, ignoring.\n");
exit(64);
}
AutoGDImage thu(resize_image_data(map, len, thudim, 0, 12*thudim));
FILE *out = fopen(outname, "wb");
if (!out) throw imgdb::io_errno(errno);
gdImageJpeg(thu, out, qual);
fclose(out);
} catch (std::exception& e) {
fprintf(stderr, "Resizer caught exception, what=%s.\n", e.what());
return 1;
}
if (map) munmap(map, len);
if (fd != -1) close(fd);
return 0;
}
void storeImageBackground(gdImagePtr image, const char *fileExtension,
const char *dir, const char *fileName, const char *groupName)
{
char directoryFinal[64];
char redisIndex[4];
long long index;
strcpy(directoryFinal, "");
strcat(directoryFinal, dir);
strcat(directoryFinal, "/");
strcat(directoryFinal, dir);
// Get current image count in database
redisReply *getReply = redisCommand(Context, "SCARD %s", groupName);
index = getReply->integer;
// Get the next
index++;
snprintf(redisIndex, 4, "%lld", index);
freeReplyObject(getReply);
// Regardless store the filename
redisReply *setReply = redisCommand(Context, "SADD %s %s", groupName, fileName);
freeReplyObject(setReply);
strcat(directoryFinal, redisIndex);
strcat(directoryFinal, fileExtension);
// Scale the image
double imageHeight = BACKGROUND_WIDTH*((double)image->sx/(double)image->sy);
int imageHeightRounded = (int)imageHeight;
image = gdImageScale(image, BACKGROUND_WIDTH, imageHeightRounded);
FILE *output = fopen(directoryFinal, "w");
gdImageJpeg(image, output, 100);
fclose(output);
}
static bool picNote(const char *path, char *text)
{
FILE *fp;
int c;
int x, y, w, h;
int rect[8] = { 0 };
gdImagePtr im;
if ((fp = fopen(path, "rb")) == NULL) {
return false;
}
im = gdImageCreateFromJpeg(fp);
fclose(fp);
if (im == NULL) {
return false;
}
c = gdImageColorAllocate(im, 255, 255, 255);
w = gdImageSX(im);
h = gdImageSY(im);
memset(rect, 0x00, sizeof(rect));
gdImageStringFT(NULL, rect, c, "SimHei", 13, 0.0, 0, 0, text);
x = w - rect[4] - 5;
y = h - 10;
gdImageStringFT(im, NULL, c, "SimHei", 13, 0.0, x, y, text);
if ((fp = fopen(path, "wb")) == NULL) {
gdImageDestroy(im);
return false;
}
gdImageJpeg(im, fp, -1);
fclose(fp);
gdImageDestroy(im);
return true;
}
void
dotest (char *font, int size, double incr,
int w, int h, char *string, const char *filename)
{
gdImagePtr im;
FILE *out;
int bg;
int fc;
#if 0
int lc;
#endif
int xc = w / 2;
int yc = h / 2;
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);
#if 0
lc = gdImageColorAllocate (im, 192, 255, 255);
#endif
out = fopen (filename, "wb");
dowheel (im, fc, font, size, incr, xc, yc, 20, string);
#if 0
dolines (im, lc, incr, xc, yc, 20, 120);
#endif
#if defined(HAVE_LIBPNG)
gdImagePng (im, out);
#elif defined(HAVE_LIBJPEG)
gdImageJpeg (im, out, -1);
#endif
fclose (out);
}
bool WriteGDImage(const char * filepath, gdImagePtr gdImg, u8 format, u8 compression)
{
if(gdImg == 0)
return false;
FILE * file = fopen(filepath, "wb");
if(!file)
return false;
switch(format)
{
default:
case IMAGE_PNG:
gdImagePng(gdImg, file);
break;
case IMAGE_JPEG:
gdImageJpeg(gdImg, file, LIMIT(100-compression, 0, 100));
break;
case IMAGE_GIF:
gdImageGif(gdImg, file);
break;
case IMAGE_TIFF:
gdImageTiff(gdImg, file);
break;
case IMAGE_BMP:
gdImageBmp(gdImg, file, compression > 9 ? 9 : compression);
break;
case IMAGE_GD:
gdImageGd(gdImg, file);
break;
case IMAGE_GD2:
gdImageGd2(gdImg, file, 0, LIMIT(compression+1, 1, 2));
break;
}
fclose(file);
return true;
}
int main(int argc, char** argv) {
if (argc < 3) exit(1);
const char* thumb = argv[1];
const char* outname = argv[2];
int thudim = strtol(argv[3], NULL, 0);
int fd = -1;
unsigned char* map = NULL;
size_t len = 0;
try {
struct stat st;
if ((fd = open(thumb, O_RDONLY)) == -1 || fstat(fd, &st) ||
(map = (unsigned char*)mmap(NULL, len = st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED)
throw imgdb::io_errno(errno);
fprintf(stderr, "Mapped %s at %p:%zd.\n", thumb, map, len);
AutoGDImage thu(resize_image_data(map, len, thudim, 0, 12*thudim));
FILE *out = fopen(outname, "wb");
if (!out) throw imgdb::io_errno(errno);
gdImageJpeg(thu, out, 95);
fclose(out);
fprintf(stderr, "OK:%d %d\n", thu->sx, thu->sy);
} catch (std::exception& e) {
fprintf(stderr, "Resizer caught exception, what=%s.\n", e.what());
}
if (map) munmap(map, len);
if (fd != -1) close(fd);
return 0;
}
NEOERR* mimg_zoomout(int ftype, FILE *dst, FILE*src, int width, int height)
{
MCS_NOT_NULLB(dst, src);
int ow, oh;
gdImagePtr im;
FILE *gdin, *gdout;
if (width <= 0 && height <= 0) return STATUS_OK;
gdin = mfile_get_std_from_safe(src);
gdout = mfile_get_std_from_safe(dst);
fseek(src, 0, SEEK_SET);
fseek(dst, 0, SEEK_SET);
switch (ftype) {
case MIMG_TYPE_JPEG:
im = gdImageCreateFromJpeg(gdin);
break;
case MIMG_TYPE_PNG:
im = gdImageCreateFromPng(gdin);
break;
case MIMG_TYPE_GIF:
im = gdImageCreateFromGif(gdin);
break;
case MIMG_TYPE_BMP:
im = gdImageCreateFromWBMP(gdin);
break;
default:
return nerr_raise(NERR_ASSERT, "file type %d not support", ftype);
}
if (!im) return nerr_raise(NERR_ASSERT, "读取图片出错，文件格式错误？");
ow = gdImageSX(im);
oh = gdImageSY(im);
if ((width > 0 && ow > width) ||
(height > 0 && oh > height)) {
if (width <= 0) width = (float)height / oh * ow;
if (height <= 0) height = (float)width / ow * oh;
gdImagePtr dim = gdImageCreateTrueColor(width, height);
gdImageCopyResized(dim, im, 0, 0, 0, 0, width, height, ow, oh);
if (dim) {
switch (ftype) {
case MIMG_TYPE_JPEG:
gdImageJpeg(dim, gdout, 70);
break;
case MIMG_TYPE_PNG:
gdImagePng(dim, gdout);
break;
case MIMG_TYPE_GIF:
gdImageGif(dim, gdout);
break;
case MIMG_TYPE_BMP:
gdImageWBMP(dim, 0, gdout);
break;
default:
return nerr_raise(NERR_ASSERT, "file type %d not suport", ftype);
}
} else return nerr_raise(NERR_ASSERT, "resize image error");
} else {
mfile_copy(dst, src);
}
return STATUS_OK;
}
int SVimage2file(char *directory, char *RENDERfilename, int rendertype, int woffset, int width, int hoffset, int height){
FILE *RENDERfile;
char *renderfile=NULL;
GLubyte *OpenGLimage, *p;
gdImagePtr RENDERimage;
unsigned int r, g, b;
int i,j,rgb_local;
int width_beg, width_end, height_beg, height_end;
int width2, height2;
width_beg=woffset;
width_end=width+woffset;
height_beg=hoffset;
height_end=hoffset+height;
if(clip_rendered_scene==1){
width_beg+=render_clip_left;
width_end-=render_clip_right;
height_beg+=render_clip_bottom;
height_end-=render_clip_top;
}
width2 = width_end-width_beg;
height2 = height_end-height_beg;
if(directory==NULL){
renderfile=get_filename(smokeviewtempdir,RENDERfilename,tempdir_flag);
}
else{
renderfile=get_filename(directory,RENDERfilename,1);
}
if(renderfile == NULL){
fprintf(stderr,"*** Error: Unable to write to %s\n",RENDERfilename);
return 1;
}
RENDERfile = fopen(renderfile, "wb");
if(RENDERfile == NULL){
fprintf(stderr,"*** Error: Unable to write to %s\n",renderfile);
return 1;
}
NewMemory((void **)&OpenGLimage,width2 * height2 * sizeof(GLubyte) * 3);
if(OpenGLimage == NULL){
fprintf(stderr,"*** Error allocating memory buffer for render file:%s\n",renderfile);
fclose(RENDERfile);
return 1;
}
PRINTF("Rendering to: %s .",renderfile);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
/* get the image from the OpenGL frame buffer */
glReadPixels(width_beg, height_beg, width2, height2, GL_RGB, GL_UNSIGNED_BYTE, OpenGLimage);
/* copy the image from OpenGL memory to GIF memory */
p = OpenGLimage;
RENDERimage = gdImageCreateTrueColor(width2,height2);
for (i = height2-1 ; i>=0; i--){
for(j=0;j<width2;j++){
r=*p++; g=*p++; b=*p++;
rgb_local = (r<<16)|(g<<8)|b;
gdImageSetPixel(RENDERimage,j,i,rgb_local);
}
}
if(test_smokesensors==1&&active_smokesensors==1&&show_smokesensors!=0){
int idev;
for(idev=0;idev<ndeviceinfo;idev++){
devicedata *devicei;
int idev_col, idev_row;
int col_offset, row_offset;
unsigned int red=255<<16;
devicei = deviceinfo + idev;
if(devicei->object->visible==0)continue;
if(strcmp(devicei->object->label,"smokesensor")!=0)continue;
idev_row = devicei->screenijk[0];
idev_col = devicei->screenijk[1];
for(col_offset=-3;col_offset<4;col_offset++){
for(row_offset=-3;row_offset<4;row_offset++){
int irow, icol;
irow = idev_row+row_offset;
if(irow<0)irow=0;
if(irow>width-1)irow=width-1;
icol = height - 1 - (idev_col+col_offset);
if(icol<0)icol=0;
if(icol>height-1)icol=height-1;
gdImageSetPixel(RENDERimage,irow,icol,red);
}
}
}
}
/* output the gif image */
switch(rendertype){
case PNG:
gdImagePng(RENDERimage,RENDERfile);
break;
case JPEG:
gdImageJpeg(RENDERimage,RENDERfile,-1);
break;
default:
ASSERT(FFALSE);
break;
}
/* free up memory used by both OpenGL and GIF images */
fclose(RENDERfile);
FREEMEMORY(renderfile);
gdImageDestroy(RENDERimage);
FREEMEMORY(OpenGLimage);
PRINTF(" Completed.\n");
return 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;
}
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);
}
}
/* ======================================================= *\
* PIE
*
* Notes:
* always drawn from 12:00 position clockwise
* 'missing' slices don't get labels
* sum(val[0], ... val[num_points-1]) is assumed to be 100%
\* ======================================================= */
void
GDC_out_pie( short IMGWIDTH,
short IMGHEIGHT,
FILE *img_fptr, /* open file pointer */
GDCPIE_TYPE type,
int num_points,
char *lbl[], /* data labels */
float val[] ) /* data */
{
int i;
gdImagePtr im;
int BGColor,
LineColor,
PlotColor,
EdgeColor,
EdgeColorShd;
CREATE_ARRAY1( SliceColor, int, num_points ); /* int SliceColor[num_points] */
CREATE_ARRAY1( SliceColorShd, int, num_points ); /* int SliceColorShd[num_points] */
float rad = 0.0; /* radius */
float ellipsex = 1.0;
float ellipsey = 1.0 - (float)GDCPIE_perspective/100.0;
float tot_val = 0.0;
float pscl;
int cx, /* affects PX() */
cy; /* affects PY() */
/* ~ 1% for a size of 100 pixs */
/* label sizes will more dictate this */
float min_grphable = ( GDCPIE_other_threshold < 0?
100.0/(float)MIN(IMGWIDTH,IMGHEIGHT):
(float)GDCPIE_other_threshold )/100.0;
short num_slices1 = 0,
num_slices2 = 0;
char any_too_small = FALSE;
CREATE_ARRAY1( others, char, num_points ); /* char others[num_points] */
CREATE_ARRAY2( slice_angle, float, 3, num_points ); /* float slice_angle[3][num_points] */
/* must be used with others[] */
char threeD = ( type == GDC_3DPIE );
int xdepth_3D = 0, /* affects PX() */
ydepth_3D = 0; /* affects PY() */
int do3Dx = 0, /* reserved for macro use */
do3Dy = 0;
CREATE_ARRAY2( pct_lbl, char, num_points, 16 ); /* sizeof or strlen (GDCPIE_percent_fmt)? */
CREATE_ARRAY1( pct_ftsz, struct fnt_sz_t, num_points ); /* struct fnt_sz_t lbl_ftsz[num_points] */
CREATE_ARRAY1( lbl_ftsz, struct fnt_sz_t, num_points ); /* struct fnt_sz_t lbl_ftsz[num_points] */
#ifdef HAVE_LIBFREETYPE
char *gdcpie_title_font = GDCPIE_title_font;
char *gdcpie_label_font = GDCPIE_label_font;
double gdcpie_title_ptsize = GDCPIE_title_ptsize;
double gdcpie_label_ptsize = GDCPIE_label_ptsize;
#else
char *gdcpie_title_font = NULL;
char *gdcpie_label_font = NULL;
double gdcpie_title_ptsize = 0.0;
double gdcpie_label_ptsize = 0.0;
#endif
/* GDCPIE_3d_angle = MOD_360(90-GDCPIE_3d_angle+360); */
pie_3D_rad = TO_RAD( GDCPIE_3d_angle );
xdepth_3D = threeD? (int)( cos((double)MOD_2PI(M_PI_2-pie_3D_rad+2.0*M_PI)) * GDCPIE_3d_depth ): 0;
ydepth_3D = threeD? (int)( sin((double)MOD_2PI(M_PI_2-pie_3D_rad+2.0*M_PI)) * GDCPIE_3d_depth ): 0;
/* xdepth_3D = threeD? (int)( cos(pie_3D_rad) * GDCPIE_3d_depth ): 0; */
/* ydepth_3D = threeD? (int)( sin(pie_3D_rad) * GDCPIE_3d_depth ): 0; */
load_font_conversions();
/* ----- get total value ----- */
for( i=0; i<num_points; ++i )
tot_val += val[i];
/* ----- pie sizing ----- */
/* ----- make width room for labels, depth, etc.: ----- */
/* ----- determine pie's radius ----- */
{
int title_hgt = GDCPIE_title? 1 /* title? horizontal text line */
+ GDCfnt_sz( GDCPIE_title,
GDCPIE_title_size,
gdcpie_title_font, gdcpie_title_ptsize, 0.0, NULL ).h
+ 2:
0;
float last = 0.0;
float label_explode_limit = 0.0;
int cheight,
cwidth;
/* maximum: no labels, explosions */
/* gotta start somewhere */
rad = (float)MIN( (IMGWIDTH/2)/ellipsex-(1+ABS(xdepth_3D)), (IMGHEIGHT/2)/ellipsey-(1+ABS(ydepth_3D))-title_hgt );
/* ok fix center, i.e., no floating re labels, explosion, etc. */
cx = IMGWIDTH/2 /* - xdepth_3D */ ;
cy = (IMGHEIGHT-title_hgt)/2 + title_hgt /* + ydepth_3D */ ;
cheight = (IMGHEIGHT- title_hgt)/2 /* - ydepth_3D */ ;
cwidth = cx;
/* walk around pie. determine spacing to edge */
for( i=0; i<num_points; ++i )
{
float this_pct = val[i]/tot_val; /* should never be > 100% */
float this = this_pct*(2.0*M_PI); /* pie-portion */
if( (this_pct > min_grphable) || /* too small */
(!GDCPIE_missing || !GDCPIE_missing[i]) ) /* still want angles */
{
int this_explode = GDCPIE_explode? GDCPIE_explode[i]: 0;
double this_sin;
double this_cos;
slice_angle[0][i] = this/2.0+last; /* mid-point on full pie */
slice_angle[1][i] = last; /* 1st on full pie */
slice_angle[2][i] = this+last; /* 2nd on full pie */
this_sin = ellipsex*sin( (double)slice_angle[0][i] );
this_cos = ellipsey*cos( (double)slice_angle[0][i] );
if( !GDCPIE_missing || !(GDCPIE_missing[i]) )
{
short lbl_wdth = 0,
lbl_hgt = 0;
float this_y_explode_limit,
this_x_explode_limit;
/* start slice label height, width */
/* accounting for PCT placement, font */
pct_ftsz[i].h = 0;
pct_ftsz[i].w = 0;
if( GDCPIE_percent_fmt &&
GDCPIE_percent_labels != GDCPIE_PCT_NONE )
{
sprintf( pct_lbl[i], GDCPIE_percent_fmt, this_pct * 100.0 );
pct_ftsz[i] = GDCfnt_sz( pct_lbl[i],
GDCPIE_label_size,
gdcpie_label_font, gdcpie_label_ptsize, 0.0, NULL );
lbl_wdth = pct_ftsz[i].w;
lbl_hgt = pct_ftsz[i].h;
}
if( lbl && lbl[i] )
{
lbl_ftsz[i] = GDCfnt_sz( lbl[i],
GDCPIE_label_size,
gdcpie_label_font, gdcpie_label_ptsize, 0.0, NULL );
if( GDCPIE_percent_labels == GDCPIE_PCT_ABOVE ||
GDCPIE_percent_labels == GDCPIE_PCT_BELOW )
{
lbl_wdth = MAX( pct_ftsz[i].w, lbl_ftsz[i].w );
lbl_hgt = pct_ftsz[i].h + lbl_ftsz[i].h + 1;
}
else
if( GDCPIE_percent_labels == GDCPIE_PCT_RIGHT ||
GDCPIE_percent_labels == GDCPIE_PCT_LEFT )
{
lbl_wdth = pct_ftsz[i].w + lbl_ftsz[i].w + 1;
lbl_hgt = MAX( pct_ftsz[i].h, lbl_ftsz[i].h );
}
else /* GDCPIE_PCT_NONE */
{
lbl_wdth = lbl_ftsz[i].w;
lbl_hgt = lbl_ftsz[i].h;
}
}
else
lbl_wdth = lbl_hgt = 0;
/* end label height, width */
/* diamiter limited by this point's: explosion, label */
/* (radius to box @ slice_angle) - (explode) - (projected label size) */
/* radius constraint due to labels */
this_y_explode_limit = (float)this_cos==0.0? FLT_MAX:
( (float)( (double)cheight/ABS(this_cos) ) -
(float)( this_explode + (lbl&&lbl[i]? GDCPIE_label_dist: 0) ) -
(float)( lbl_hgt/2 ) / (float)ABS(this_cos) );
this_x_explode_limit = (float)this_sin==0.0? FLT_MAX:
( (float)( (double)cwidth/ABS(this_sin) ) -
(float)( this_explode + (lbl&&lbl[i]? GDCPIE_label_dist: 0) ) -
(float)( lbl_wdth ) / (float)ABS(this_sin) );
rad = MIN( rad, this_y_explode_limit );
rad = MIN( rad, this_x_explode_limit );
/* ok at this radius (which is most likely larger than final) */
/* adjust for inter-label spacing */
/* if( lbl[i] && *lbl[i] ) */
/* { */
/* char which_edge = slice_angle[0][i] > M_PI? +1: -1; // which semi */
/* last_label_yedge = cheight - (int)( (rad + // top or bottom of label */
/* (float)(this_explode + */
/* (float)GDCPIE_label_dist)) * (float)this_cos ) + */
/* ( (GDC_fontc[GDCPIE_label_size].h+1)/2 + */
/* GDC_label_spacing )*which_edge; */
/* } */
/* radius constriant due to exploded depth */
/* at each edge of the slice, and the middle */
/* this is really stupid */
/* this section uses a different algorithm then above, but does the same thing */
/* could be combined, but each is ugly enough! */
/* PROTECT /0 */
if( threeD )
{
short j;
int this_y_explode_pos;
int this_x_explode_pos;
/* first N E S W (actually no need for N) */
if( (slice_angle[1][i] < M_PI_2 && M_PI_2 < slice_angle[2][i]) && /* E */
(this_x_explode_pos=OX(i,M_PI_2,1)) > cx+cwidth )
rad -= (float)ABS( (double)(1+this_x_explode_pos-(cx+cwidth))/sin(M_PI_2) );
if( (slice_angle[1][i] < 3.0*M_PI_2 && 3.0*M_PI_2 < slice_angle[2][i]) && /* W */
(this_x_explode_pos=OX(i,3.0*M_PI_2,1)) < cx-cwidth )
rad -= (float)ABS( (double)(this_x_explode_pos-(cx+cwidth))/sin(3.0*M_PI_2) );
if( (slice_angle[1][i] < M_PI && M_PI < slice_angle[2][i]) && /* S */
(this_y_explode_pos=OY(i,M_PI,1)) > cy+cheight )
rad -= (float)ABS( (double)(1+this_y_explode_pos-(cy+cheight))/cos(M_PI) );
for( j=0; j<3; ++j )
{
this_y_explode_pos = IY(i,j,1);
if( this_y_explode_pos < cy-cheight )
rad -= (float)ABS( (double)((cy-cheight)-this_y_explode_pos)/cos((double)slice_angle[j][i]) );
if( this_y_explode_pos > cy+cheight )
rad -= (float)ABS( (double)(1+this_y_explode_pos-(cy+cheight))/cos((double)slice_angle[j][i]) );
this_x_explode_pos = IX(i,j,1);
if( this_x_explode_pos < cx-cwidth )
rad -= (float)ABS( (double)((cx-cwidth)-this_x_explode_pos)/sin((double)slice_angle[j][i]) );
if( this_x_explode_pos > cx+cwidth )
rad -= (float)ABS( (double)(1+this_x_explode_pos-(cx+cwidth))/sin((double)slice_angle[j][i]) );
}
}
}
others[i] = FALSE;
}
else
{
others[i] = TRUE;
slice_angle[0][i] = -FLT_MAX;
}
last += this;
}
}
/* ----- go ahead and start the image ----- */
im = gdImageCreate( IMGWIDTH, IMGHEIGHT );
/* --- allocate the requested colors --- */
BGColor = clrallocate( im, GDCPIE_BGColor );
LineColor = clrallocate( im, GDCPIE_LineColor );
PlotColor = clrallocate( im, GDCPIE_PlotColor );
if( GDCPIE_EdgeColor != GDC_NOCOLOR )
{
EdgeColor = clrallocate( im, GDCPIE_EdgeColor );
if( threeD )
EdgeColorShd = clrshdallocate( im, GDCPIE_EdgeColor );
}
/* --- set color for each slice --- */
for( i=0; i<num_points; ++i )
if( GDCPIE_Color )
{
unsigned long slc_clr = GDCPIE_Color[i];
SliceColor[i] = clrallocate( im, slc_clr );
if( threeD )
SliceColorShd[i] = clrshdallocate( im, slc_clr );
}
else
{
SliceColor[i] = PlotColor;
if( threeD )
SliceColorShd[i] = clrshdallocate( im, GDCPIE_PlotColor );
}
pscl = (2.0*M_PI)/tot_val;
/* ----- calc: smallest a slice can be ----- */
/* 1/2 circum / num slices per side. */
/* determined by number of labels that'll fit (height) */
/* scale to user values */
/* ( M_PI / (IMGHEIGHT / (SFONTHGT+1)) ) */
/* min_grphable = tot_val / */
/* ( 2.0 * (float)IMGHEIGHT / (float)(SFONTHGT+1+TFONTHGT+2) ); */
if( threeD )
{
/* draw background shaded pie */
{
float rad1 = rad * 3.0/4.0;
for( i=0; i<num_points; ++i )
if( !(others[i]) &&
(!GDCPIE_missing || !GDCPIE_missing[i]) )
{
int edge_color = GDCPIE_EdgeColor == GDC_NOCOLOR? SliceColorShd[i]:
EdgeColorShd;
gdImageLine( im, CX(i,1), CY(i,1), IX(i,1,1), IY(i,1,1), edge_color );
gdImageLine( im, CX(i,1), CY(i,1), IX(i,2,1), IY(i,2,1), edge_color );
gdImageArc( im, CX(i,1), CY(i,1),
(int)(rad*ellipsex*2.0), (int)(rad*ellipsey*2.0),
TO_INT_DEG_FLOOR(slice_angle[1][i])+270,
TO_INT_DEG_CEIL(slice_angle[2][i])+270,
edge_color );
/* gdImageFilledArc( im, CX(i,1), CY(i,1), */
/* rad*ellipsex*2, rad*ellipsey*2, */
/* TO_INT_DEG_FLOOR(slice_angle[1][i])+270, */
/* TO_INT_DEG_CEIL(slice_angle[2][i])+270, */
/* SliceColorShd[i], */
/* gdPie ); */
/* attempt to fill, if slice is wide enough */
if( (ABS(IX(i,1,1)-IX(i,2,1)) + ABS(IY(i,1,1)-IY(i,2,1))) > 2 )
{
float rad = rad1; /* local override */
gdImageFillToBorder( im, IX(i,0,1), IY(i,0,1), edge_color, SliceColorShd[i] );
}
}
}
/* fill in connection to foreground pie */
/* this is where we earn our keep */
{
int t,
num_slice_angles = 0;
CREATE_ARRAY1( tmp_slice, struct tmp_slice_t, 4*num_points+4 ); /* should only need 2*num_points+2 */
for( i=0; i<num_points; ++i )
if( !GDCPIE_missing || !GDCPIE_missing[i] )
{
if( RAD_DIST1(slice_angle[1][i]) < RAD_DIST2(slice_angle[0][i]) )
tmp_slice[num_slice_angles].hidden = FALSE;
else
tmp_slice[num_slice_angles].hidden = TRUE;
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = slice_angle[1][i];
if( RAD_DIST1(slice_angle[2][i]) < RAD_DIST2(slice_angle[0][i]) )
tmp_slice[num_slice_angles].hidden = FALSE;
else
tmp_slice[num_slice_angles].hidden = TRUE;
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = slice_angle[2][i];
/* identify which 2 slices (i) have a tangent parallel to depth angle */
if( slice_angle[1][i]<MOD_2PI(pie_3D_rad+M_PI_2) && slice_angle[2][i]>MOD_2PI(pie_3D_rad+M_PI_2) )
{
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].hidden = FALSE;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = MOD_2PI( pie_3D_rad+M_PI_2 );
}
if( slice_angle[1][i]<MOD_2PI(pie_3D_rad+3.0*M_PI_2) && slice_angle[2][i]>MOD_2PI(pie_3D_rad+3.0*M_PI_2) )
{
tmp_slice[num_slice_angles].i = i;
tmp_slice[num_slice_angles].hidden = FALSE;
tmp_slice[num_slice_angles].slice = slice_angle[0][i];
tmp_slice[num_slice_angles++].angle = MOD_2PI( pie_3D_rad+3.0*M_PI_2 );
}
}
qsort( tmp_slice, num_slice_angles, sizeof(struct tmp_slice_t), ocmpr );
for( t=0; t<num_slice_angles; ++t )
{
gdPoint gdp[4];
i = tmp_slice[t].i;
gdp[0].x = CX(i,0); gdp[0].y = CY(i,0);
gdp[1].x = CX(i,1); gdp[1].y = CY(i,1);
gdp[2].x = OX(i,tmp_slice[t].angle,1); gdp[2].y = OY(i,tmp_slice[t].angle,1);
gdp[3].x = OX(i,tmp_slice[t].angle,0); gdp[3].y = OY(i,tmp_slice[t].angle,0);
if( !(tmp_slice[t].hidden) )
gdImageFilledPolygon( im, gdp, 4, SliceColorShd[i] );
else
{
rad -= 2.0; /* no peeking */
gdp[0].x = OX(i,slice_angle[0][i],0); gdp[0].y = OY(i,slice_angle[0][i],0);
gdp[1].x = OX(i,slice_angle[0][i],1); gdp[1].y = OY(i,slice_angle[0][i],1);
rad += 2.0;
gdp[2].x = OX(i,slice_angle[1][i],1); gdp[2].y = OY(i,slice_angle[1][i],1);
gdp[3].x = OX(i,slice_angle[1][i],0); gdp[3].y = OY(i,slice_angle[1][i],0);
gdImageFilledPolygon( im, gdp, 4, SliceColorShd[i] );
gdp[2].x = OX(i,slice_angle[2][i],1); gdp[2].y = OY(i,slice_angle[2][i],1);
gdp[3].x = OX(i,slice_angle[2][i],0); gdp[3].y = OY(i,slice_angle[2][i],0);
gdImageFilledPolygon( im, gdp, 4, SliceColorShd[i] );
}
if( GDCPIE_EdgeColor != GDC_NOCOLOR )
{
gdImageLine( im, CX(i,0), CY(i,0), CX(i,1), CY(i,1), EdgeColorShd );
gdImageLine( im, OX(i,tmp_slice[t].angle,0), OY(i,tmp_slice[t].angle,0),
OX(i,tmp_slice[t].angle,1), OY(i,tmp_slice[t].angle,1),
EdgeColorShd );
}
}
FREE_ARRAY1( tmp_slice );
}
}
/* ----- pie face ----- */
{
/* float last = 0.0; */
float rad1 = rad * 3.0/4.0;
for( i=0; i<num_points; ++i )
if( !others[i] &&
(!GDCPIE_missing || !GDCPIE_missing[i]) )
{
int edge_color = GDCPIE_EdgeColor == GDC_NOCOLOR? SliceColor[i]:
EdgeColorShd;
/* last += val[i]; */
/* EXPLODE_CX_CY( slice_angle[0][i], i ); */
gdImageLine( im, CX(i,0), CY(i,0), IX(i,1,0), IY(i,1,0), edge_color );
gdImageLine( im, CX(i,0), CY(i,0), IX(i,2,0), IY(i,2,0), edge_color );
gdImageArc( im, CX(i,0), CY(i,0),
(int)(rad*ellipsex*2.0), (int)(rad*ellipsey*2.0),
(TO_INT_DEG_FLOOR(slice_angle[1][i])+270)%360,
(TO_INT_DEG_CEIL(slice_angle[2][i])+270)%360,
edge_color );
/* antialiasing here */
/* likely only on the face? */
/* bugs in gd2.0.0 */
/* arc doesn't honor deg>360 */
/* arcs from gdImageFilledArc() don't match with gdImageArc() */
/* angles are off */
/* doesn't always fill completely */
/* gdImageFilledArc( im, CX(i,0), CY(i,0), */
/* (int)(rad*ellipsex*2.0), (int)(rad*ellipsey*2.0), */
/* (TO_INT_DEG_FLOOR(slice_angle[1][i])+270)%360, */
/* (TO_INT_DEG_CEIL(slice_angle[2][i])+270)%360, */
/* SliceColor[i], */
/* gdPie ); */
/* attempt to fill, if slice is wide enough */
{
float rad = rad1; /* local override */
if( (ABS(IX(i,1,1)-IX(i,2,1)) + ABS(IY(i,1,1)-IY(i,2,1))) > 2 )
{
gdImageFillToBorder( im, IX(i,0,0), IY(i,0,0), edge_color, SliceColor[i] );
}
/* catch missed pixels on narrow slices */
gdImageLine( im, CX(i,0), CY(i,0), IX(i,0,0), IY(i,0,0), SliceColor[i] );
}
}
}
if( GDCPIE_title )
{
struct fnt_sz_t tftsz = GDCfnt_sz( GDCPIE_title,
GDCPIE_title_size,
gdcpie_title_font, gdcpie_title_ptsize, 0.0, NULL );
GDCImageStringNL( im,
&GDC_fontc[GDCPIE_title_size],
gdcpie_title_font, gdcpie_title_ptsize,
0.0,
IMGWIDTH/2 - tftsz.w/2,
1,
GDCPIE_title,
LineColor,
GDC_JUSTIFY_CENTER,
NULL );
}
/* labels */
if( lbl )
{
float liner = rad;
rad += GDCPIE_label_dist;
for( i=0; i<num_points; ++i )
{
if( !others[i] &&
(!GDCPIE_missing || !GDCPIE_missing[i]) )
{
int lblx, pctx,
lbly, pcty,
linex, liney;
lbly = (liney = IY(i,0,0))-lbl_ftsz[i].h / 2;
lblx = pctx = linex = IX(i,0,0);
if( slice_angle[0][i] > M_PI ) /* which semicircle */
{
lblx -= lbl_ftsz[i].w;
pctx = lblx;
++linex;
}
else
--linex;
switch( GDCPIE_percent_labels )
{
case GDCPIE_PCT_LEFT: if( slice_angle[0][i] > M_PI )
pctx -= lbl_ftsz[i].w-1;
else
lblx += pct_ftsz[i].w+1;
pcty = IY(i,0,0) - ( 1+pct_ftsz[i].h ) / 2;
break;
case GDCPIE_PCT_RIGHT: if( slice_angle[0][i] > M_PI )
lblx -= pct_ftsz[i].w-1;
else
pctx += lbl_ftsz[i].w+1;
pcty = IY(i,0,0) - ( 1+pct_ftsz[i].h ) / 2;
break;
case GDCPIE_PCT_ABOVE: lbly += (1+pct_ftsz[i].h) / 2;
pcty = lbly - pct_ftsz[i].h;
break;
case GDCPIE_PCT_BELOW: lbly -= (1+pct_ftsz[i].h) / 2;
pcty = lbly + lbl_ftsz[i].h;
break;
case GDCPIE_PCT_NONE:
default:;
}
if( GDCPIE_percent_labels != GDCPIE_PCT_NONE )
GDCImageStringNL( im,
&GDC_fontc[GDCPIE_label_size],
gdcpie_label_font, gdcpie_label_ptsize,
0.0,
slice_angle[0][i] <= M_PI? pctx:
pctx+lbl_ftsz[i].w-pct_ftsz[i].w,
pcty,
pct_lbl[i],
LineColor,
GDC_JUSTIFY_CENTER,
NULL );
if( lbl[i] )
GDCImageStringNL( im,
&GDC_fontc[GDCPIE_label_size],
gdcpie_label_font, gdcpie_label_ptsize,
0.0,
lblx,
lbly,
lbl[i],
LineColor,
slice_angle[0][i] <= M_PI? GDC_JUSTIFY_LEFT:
GDC_JUSTIFY_RIGHT,
NULL );
if( GDCPIE_label_line )
{
float rad = liner;
gdImageLine( im, linex, liney, IX(i,0,0), IY(i,0,0), LineColor );
}
}
}
rad -= GDCPIE_label_dist;
}
fflush( img_fptr );
switch( GDC_image_type )
{
#ifdef HAVE_JPEG
case GDC_JPEG: gdImageJpeg( im, img_fptr, GDC_jpeg_quality ); break;
#endif
case GDC_WBMP: gdImageWBMP( im, PlotColor, img_fptr ); break;
case GDC_GIF: gdImageGif( im, img_fptr); break;
case GDC_PNG:
default: gdImagePng( im, img_fptr );
}
FREE_ARRAY1( lbl_ftsz );
FREE_ARRAY1( pct_ftsz );
FREE_ARRAY2( pct_lbl );
FREE_ARRAY2( slice_angle );
FREE_ARRAY1( others );
FREE_ARRAY1( SliceColorShd );
FREE_ARRAY1( SliceColor );
gdImageDestroy(im);
return;
}
static VALUE fastimage_native_resize(
VALUE self,
VALUE rb_in, VALUE rb_out,
VALUE rb_w, VALUE rb_h,
VALUE rb_image_type,
VALUE rb_jpeg_quality,
VALUE rb_orientation
) {
char *filename_in = StringValuePtr(rb_in);
char *filename_out = StringValuePtr(rb_out);
int w = NUM2INT(rb_w);
int h = NUM2INT(rb_h);
int image_type = NUM2INT(rb_image_type);
int jpeg_quality = NUM2INT(rb_jpeg_quality);
int orientation = NUM2INT(rb_orientation);
gdImagePtr im_in, im_out;
FILE *in, *out;
int trans = 0, x = 0, y = 0, f = 0;
in = fopen(filename_in, "rb");
if (!in) return Qnil;
switch(image_type) {
case 0: im_in = gdImageCreateFromJpeg(in);
break;
case 1: im_in = gdImageCreateFromPng(in);
break;
case 2: im_in = gdImageCreateFromGif(in);
trans = gdImageGetTransparent(im_in);
/* find a transparent pixel, then turn off transparency
so that it copies correctly */
if (trans >= 0) {
for (x=0; x<gdImageSX(im_in); x++) {
for (y=0; y<gdImageSY(im_in); y++) {
if (gdImageGetPixel(im_in, x, y) == trans) {
f = 1;
break;
}
}
if (f) break;
}
gdImageColorTransparent(im_in, -1);
if (!f) trans = -1; /* no transparent pixel found */
}
break;
}
if (!im_in) {
fclose(in);
return Qnil;
}
/* Handle orientation */
if (orientation == 5 || orientation == 6) {
im_in = gdImageRotateInterpolated(im_in, 270.0, 0);
}
if (orientation == 7 || orientation == 8) {
im_in = gdImageRotateInterpolated(im_in, 90.0, 0);
}
if (!im_in) {
fclose(in);
return Qnil;
}
if (orientation == 2 || orientation == 5 || orientation == 7) {
gdImageFlipHorizontal(im_in);
}
if (orientation == 3) {
gdImageFlipBoth(im_in);
}
if (orientation == 4) {
gdImageFlipVertical(im_in);
}
/* Compute target size */
if (w == 0 || h == 0) {
int originalWidth = gdImageSX(im_in);
int originalHeight = gdImageSY(im_in);
if (h != 0) {
w = (int)(h * originalWidth / originalHeight);
} else if (w != 0) {
h = (int)(w * originalHeight / originalWidth);
} else {
w = originalWidth;
h = originalHeight;
}
}
im_out = gdImageCreateTrueColor(w, h); /* must be truecolor */
if (im_out) {
if (image_type == 1) {
gdImageAlphaBlending(im_out, 0); /* handle transparency correctly */
gdImageSaveAlpha(im_out, 1);
}
fclose(in);
} else {
fclose(in);
return Qnil;
}
/* Now copy the original */
gdImageCopyResampled(im_out, im_in, 0, 0, 0, 0,
gdImageSX(im_out), gdImageSY(im_out),
gdImageSX(im_in), gdImageSY(im_in));
out = fopen(filename_out, "wb");
if (out) {
switch(image_type) {
case 0: gdImageJpeg(im_out, out, jpeg_quality);
break;
case 1: gdImagePng(im_out, out);
break;
case 2: gdImageTrueColorToPalette(im_out, 0, 256);
if (trans >= 0) {
trans = gdImageGetPixel(im_out, x, y); /* get the color index of our transparent pixel */
gdImageColorTransparent(im_out, trans); /* may not always work as hoped */
}
gdImageGif(im_out, out);
break;
}
fclose(out);
}
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return Qnil;
}
int main(int argc, char *argv[])
{
#ifndef HAVE_LIBFREETYPE
(void)argc;
(void)argv;
/* 2.0.12 */
fprintf(stderr, "annotate is not useful without freetype.\n"
"Install freetype, then './configure; make clean; make install'\n"
"the gd library again.\n"
);
return 1;
#else
gdImagePtr im;
char *iin, *iout;
FILE *in, *out;
char s[1024];
int bounds[8];
int lines = 1;
int color = gdTrueColor(0, 0, 0);
char font[1024];
int size = 12;
int align = left;
int x = 0, y = 0;
char *fontError;
strcpy(font, "times");
if(argc != 3) {
fprintf(stderr, "Usage: annotate imagein.jpg imageout.jpg\n\n");
fprintf(stderr, "Standard input should consist of\n");
fprintf(stderr, "lines in the following formats:\n");
fprintf(stderr, "color r g b (0-255 each) [a (0-127, 0 is opaque)]\n");
fprintf(stderr, "font fontname (max name length 1024)\n");
fprintf(stderr, "size pointsize\n");
fprintf(stderr, "align (left|right|center)\n");
fprintf(stderr, "move x y\n");
fprintf(stderr, "text actual-output-text\n\n");
fprintf(stderr,
"If the file 'paris.ttf' exists in /usr/share/fonts/truetype or in a\n");
fprintf(stderr,
"location specified in the GDFONTPATH environment variable, 'font paris' is\n");
fprintf(stderr,
"sufficient. You may also specify the full, rooted path of a font file.\n");
exit(1);
}
iin = argv[1];
iout = argv[2];
in = fopen(iin, "rb");
if(!in) {
fprintf(stderr, "Couldn't open %s\n", iin);
exit(2);
}
#ifdef HAVE_LIBJPEG
im = gdImageCreateFromJpeg(in);
#else
fprintf(stderr, "No JPEG library support available.\n");
exit(1);
#endif
fclose(in);
if(!im) {
fprintf(stderr, "%s did not load properly\n", iin);
exit(3);
}
while(fgets(s, sizeof(s), stdin)) {
char *st;
char *text;
st = strtok(s, " \t\r\n");
if(!st) {
/* Be nice about blank lines */
continue;
}
if(!strcmp(st, "font")) {
char *st = strtok(0, " \t\r\n");
if(!st) {
goto badLine;
} else {
const unsigned int font_len = strlen(st);
if (font_len >= 1024) {
fprintf(stderr, "Font maximum length is 1024, %d given\n", font_len);
goto badLine;
}
strncpy(font, st, font_len);
}
} else if(!strcmp(st, "align")) {
char *st = strtok(0, " \t\r\n");
if(!st) {
goto badLine;
}
if(!strcmp(st, "left")) {
align = 0;
} else if(!strcmp(st, "center")) {
align = 1;
} else if(!strcmp(st, "right")) {
align = 2;
}
} else if(!strcmp(st, "size")) {
char *st = strtok(0, " \t\r\n");
if(!st) {
goto badLine;
}
size = atoi(st);
} else if(!strcmp(st, "color")) {
char *st = strtok(0, "\r\n");
int r, g, b, a = 0;
if(!st) {
goto badLine;
}
if(sscanf(st, "%d %d %d %d", &r, &g, &b, &a) < 3) {
fprintf(stderr, "Bad color at line %d\n", lines);
exit(2);
}
color = gdTrueColorAlpha(r, g, b, a);
} else if(!strcmp(st, "move")) {
char *st = strtok(0, "\r\n");
if(!st) {
goto badLine;
}
if(sscanf(st, "%d %d", &x, &y) != 2) {
fprintf(stderr, "Missing coordinates at line %d\n", lines);
exit(3);
}
} else if(!strcmp(st, "text")) {
int rx = x;
text = strtok(0, "\r\n");
if(!text) {
text = "";
}
gdImageStringFT(0, bounds, color, font, size, 0, x, y, text);
switch(align) {
case left:
break;
case center:
rx -= (bounds[2] - bounds[0]) / 2;
break;
case right:
rx -= (bounds[2] - bounds[0]);
break;
}
fontError = gdImageStringFT(im, 0, color, font, size, 0, rx, y, text);
if(fontError) {
fprintf(stderr, "font error at line %d: %s\n", lines, fontError);
exit(7);
}
y -= (bounds[7] - bounds[1]);
} else {
goto badLine;
}
lines++;
continue;
badLine:
fprintf(stderr, "Bad syntax, line %d\n", lines);
exit(4);
}
out = fopen(iout, "wb");
if(!out) {
fprintf(stderr, "Cannot create %s\n", iout);
exit(5);
}
#ifdef HAVE_LIBJPEG
gdImageJpeg(im, out, 95);
#else
fprintf(stderr, "No JPEG library support available.\n");
#endif
gdImageDestroy(im);
fclose(out);
return 0;
#endif /* HAVE_LIBFREETYPE */
}
int fswc_output(fswebcam_config_t *config, char *name, gdImage *image)
{
char filename[FILENAME_MAX];
gdImage *im;
FILE *f;
if(!name) return(-1);
if(!strncmp(name, "-", 2) && config->background)
{
ERROR("stdout is unavailable in background mode.");
return(-1);
}
fswc_strftime(filename, FILENAME_MAX, name,
config->start, config->gmt);
/* Create a temporary image buffer. */
im = fswc_gdImageDuplicate(image);
if(!im)
{
ERROR("Out of memory.");
return(-1);
}
/* Draw the underlay. */
fswc_draw_overlay(config, config->underlay, im);
/* Draw the banner. */
if(config->banner != NO_BANNER)
{
char *err;
/* Check if drawing text works */
err = gdImageStringFT(NULL, NULL, 0, config->font, config->fontsize, 0.0, 0, 0, "");
if(!err) fswc_draw_banner(config, im);
else
{
/* Can't load the font - display a warning */
WARN("Unable to load font '%s': %s", config->font, err);
WARN("Disabling the the banner.");
}
}
/* Draw the overlay. */
fswc_draw_overlay(config, config->overlay, im);
/* Write to a file if a filename was given, otherwise stdout. */
if(strncmp(name, "-", 2)) f = fopen(filename, "wb");
else f = stdout;
if(!f)
{
ERROR("Error opening file for output: %s", filename);
ERROR("fopen: %s", strerror(errno));
gdImageDestroy(im);
return(-1);
}
/* Write the compressed image. */
switch(config->format)
{
case FORMAT_JPEG:
MSG("Writing JPEG image to '%s'.", filename);
gdImageJpeg(im, f, config->compression);
break;
case FORMAT_PNG:
MSG("Writing PNG image to '%s'.", filename);
gdImagePngEx(im, f, config->compression);
break;
}
if(f != stdout) fclose(f);
gdImageDestroy(im);
return(0);
}
/*********************************************************************//*!
* @brief Query the current state of the application and see what else
* we need to get from it
*
* Depending on the current state of the application, other additional
* parameters may be queried.
*
* @return SUCCESS or an appropriate error code otherwise
*//*********************************************************************/
static OSC_ERR QueryApp()
{
OSC_ERR err;
/* First, get the current state of the algorithm. */
err = OscIpcGetParam(cgi.ipcChan, &cgi.appState, GET_APP_STATE, sizeof(struct APPLICATION_STATE));
if (err != SUCCESS)
{
/* This request is defined in all states, and thus must succeed. */
OscLog(ERROR, "CGI: Error querying application! (%d)\n", err);
return err;
}
switch(cgi.appState.enAppMode)
{
case APP_OFF:
/* Algorithm is off, nothing else to do. */
break;
case APP_CAPTURE_ON:
if (cgi.appState.bNewImageReady)
{
FILE* F;
uint16 r,c;
uint8* pData;
uint32 dataSiz, i;
uint16 oType;
/* If there is a new image ready, request it from the application. */
/* We get TWICE the size of an image because metadata might be available */
err = OscIpcGetParam(cgi.ipcChan, cgi.imgBuf, GET_NEW_IMG, NUM_COLORS*nc*nr*2);
if (err != SUCCESS)
{
OscLog(DEBUG, "CGI: Getting new image failed! (%d)\n", err);
return err;
}
//we have to take care of the different ways gdlib treats gray and color data
#if NUM_COLORS == 1
//create gd image and ...
gdImagePtr im_out = gdImageCreate(nc, nr);
//initialize with sensor image
for(r = 0; r < nr; r++)
{
//in case the original image should not be modified replace the following loop by the memcpy statement
//memcpy(im_out->pixels[r], cgi.imgBuf+r*nc, nc*sizeof(uint8));
for(c = 0; c < nc; c++)
{
im_out->pixels[r][c] = (*(cgi.imgBuf+r*nc+c) & 0xfe);//mask out first bit -> only even gray values
}
}
//allocate color palette (255 is red -> we did not change the sensor image!! should rather use a LUT)
for(c = 0; c < 256; c++)
{
if((c%2) && c > 255-2*MAX_NUM_COLORS){
i = (255-c)/2;
gdImageColorAllocate (im_out, colorLUT[i][0], colorLUT[i][1], colorLUT[i][2]);
} else {
gdImageColorAllocate (im_out, c, c, c);
}
}
#else
//create gd image and ...
gdImagePtr im_out = gdImageCreateTrueColor(nc, nr);
//initialize with sensor image
for(r = 0; r < nr; r++)
{
for(c = 0; c < nc; c++)
{
uint8* p = (cgi.imgBuf+r*3*nc+3*c);
im_out->tpixels[r][c] = gdTrueColor(p[2], p[1], p[0]);
}
}
#endif
//there might be additional data to be written to image
pData = (uint8*) (cgi.imgBuf+NUM_COLORS*nc*nr);
memcpy(&dataSiz, pData, sizeof(uint32));
//OscLog(DEBUG, "received %d number of bytes\n", dataSiz);
pData += sizeof(uint32);//skip dataSiz
if(dataSiz)
{
i = 0;
while(i < dataSiz)
{
memcpy(&oType, pData+i, sizeof(uint16));
i += sizeof(uint16);
switch(oType) {
case OBJ_LINE:
{
struct IMG_LINE imgLine;
memcpy(&imgLine, pData+i, sizLine);
i += sizLine;
//OscLog(DEBUG, "received line (%d,%d)-(%d,%d), color(%d)\n", imgLine.x1, imgLine.y1, imgLine.x2, imgLine.y2, (int) imgLine.color);
gdImageLine(im_out, imgLine.x1, imgLine.y1, imgLine.x2, imgLine.y2, colorLoolUp(imgLine.color));
break;
}
case OBJ_RECT:
{
struct IMG_RECT imgRect;
memcpy(&imgRect, pData+i, sizRect);
i += sizRect;
//OscLog(DEBUG, "received rect (%d,%d)-(%d,%d), %s, color(%d)\n", imgRect.left, imgRect.bottom, imgRect.right, imgRect.top, imgRect.recFill ? "fill" : "not fill", (int) imgRect.color);
if(imgRect.recFill) {
gdImageFilledRectangle(im_out, imgRect.left, imgRect.bottom, imgRect.right, imgRect.top, colorLoolUp(imgRect.color));
} else {
gdImageRectangle(im_out, imgRect.left, imgRect.bottom, imgRect.right, imgRect.top, colorLoolUp(imgRect.color));
}
break;
}
case OBJ_STRING:
{
gdFontPtr font = gdFontSmall;
struct IMG_STRING imgString;
memcpy(&imgString, pData+i, sizString);
i += sizString;
//OscLog(DEBUG, "received string (%d,%d), font %d, %s, color(%d)\n", imgString.xPos, imgString.yPos, imgString.font, pData+i, imgString.color);
switch(imgString.font)
{
case GIANT:
font = gdFontGiant;
break;
case LARGE:
font = gdFontLarge;
break;
case MEDIUMBOLD:
font = gdFontMediumBold;
break;
case SMALL:
font = gdFontSmall;
break;
case TINY:
font = gdFontTiny;
break;
default:
break;//set in definition of font
}
gdImageString(im_out, font, imgString.xPos, imgString.yPos, pData+i, colorLoolUp(imgString.color));
i += imgString.len;
}
}
}
}
F = fopen(IMG_FN, "wb");
//gdImageGif(im_out, F);
gdImageJpeg(im_out, F, 80);
fclose(F);
gdImageDestroy(im_out);
return SUCCESS;
}
break;
default:
OscLog(ERROR, "%s: Invalid application mode (%d)!\n", __func__, cgi.appState.enAppMode);
break;
}
return SUCCESS;
}
static VALUE fir_resize_image(VALUE self, VALUE raw_filename_in, VALUE raw_filename_out, VALUE raw_width, VALUE raw_height, VALUE raw_image_type, VALUE raw_jpeg_quality) {
gdImagePtr im_in, im_out;
FILE *in, *out;
char *filename_in; char *filename_out;
int w; int h; int image_type; int jpeg_quality;
int trans = 0, x = 0, y = 0, f = 0;
filename_in = RSTRING_PTR(raw_filename_in);
filename_out = RSTRING_PTR(raw_filename_out);
w = NUM2INT(raw_width);
h = NUM2INT(raw_height);
image_type = NUM2INT(raw_image_type);
jpeg_quality = NUM2INT(raw_jpeg_quality);
in = fopen(filename_in, "rb");
if (!in) return Qnil;
switch(image_type) {
case 0: im_in = gdImageCreateFromJpeg(in);
break;
case 1: im_in = gdImageCreateFromPng(in);
break;
case 2: im_in = gdImageCreateFromGif(in);
trans = gdImageGetTransparent(im_in);
/* find a transparent pixel, then turn off transparency
so that it copies correctly */
if (trans >= 0) {
for (x=0; x<gdImageSX(im_in); x++) {
for (y=0; y<gdImageSY(im_in); y++) {
if (gdImageGetPixel(im_in, x, y) == trans) {
f = 1;
break;
}
}
if (f) break;
}
gdImageColorTransparent(im_in, -1);
if (!f) trans = -1; /* no transparent pixel found */
}
break;
default: return Qnil;
}
if (w == 0 || h == 0) {
int originalWidth = gdImageSX(im_in);
int originalHeight = gdImageSY(im_in);
if (w == 0) {
w = (int)(h * originalWidth / originalHeight);
} else {
h = (int)(w * originalHeight / originalWidth);
}
}
im_out = gdImageCreateTrueColor(w, h); /* must be truecolor */
if (image_type == 1) {
gdImageAlphaBlending(im_out, 0); /* handle transparency correctly */
gdImageSaveAlpha(im_out, 1);
}
fclose(in);
/* Now copy the original */
gdImageCopyResampled(im_out, im_in, 0, 0, 0, 0,
gdImageSX(im_out), gdImageSY(im_out),
gdImageSX(im_in), gdImageSY(im_in));
out = fopen(filename_out, "wb");
if (out) {
switch(image_type) {
case 0: gdImageJpeg(im_out, out, jpeg_quality);
break;
case 1: gdImagePng(im_out, out);
break;
case 2: gdImageTrueColorToPalette(im_out, 0, 256);
if (trans >= 0) {
trans = gdImageGetPixel(im_out, x, y); /* get the color index of our transparent pixel */
gdImageColorTransparent(im_out, trans); /* may not always work as hoped */
}
gdImageGif(im_out, out);
break;
}
fclose(out);
}
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return Qnil;
}
