int magickThumbnailImage(const char *imageFile, const char *outputImage, int columns, int rows){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
MagickWandGenesis();
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, (char *)imageFile);
if (status == MagickFalse){
ThrowWandException(magick_wand);
}
/*
Turn the images into a thumbnail sequence.
*/
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
MagickThumbnailImage(magick_wand, columns, rows);
/*
Write the image then destroy it.
*/
status=MagickWriteImages(magick_wand, (char *)outputImage, MagickTrue);
if (status == MagickFalse)
ThrowWandException(magick_wand);
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return status;
}
apr_status_t
dims_thumbnail_operation (dims_request_rec *d, char *args, char **err) {
MagickStatusType flags;
RectangleInfo rec;
char *resize_args = apr_psprintf(d->pool, "%s^", args);
flags = ParseSizeGeometry(GetImageFromMagickWand(d->wand), resize_args, &rec);
if(!(flags & AllValues)) {
*err = "Parsing thumbnail (resize) geometry failed";
return DIMS_FAILURE;
}
if (d->optimize_resize) {
size_t orig_width;
size_t orig_height;
RectangleInfo sampleRec = rec;
sampleRec.width *= d->optimize_resize;
sampleRec.height *= d->optimize_resize;
orig_width = MagickGetImageWidth(d->wand);
orig_height = MagickGetImageHeight(d->wand);
if(sampleRec.width < orig_width && sampleRec.height < orig_height) {
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, d->r, "Sampling image down to %dx%d before resizing.", sampleRec.width, sampleRec.height);
MAGICK_CHECK(MagickSampleImage(d->wand, sampleRec.width, sampleRec.height), d);
}
}
MAGICK_CHECK(MagickThumbnailImage(d->wand, rec.width, rec.height), d);
if(!(flags & PercentValue)) {
flags = ParseAbsoluteGeometry(args, &rec);
if(!(flags & AllValues)) {
*err = "Parsing thumbnail (crop) geometry failed";
return DIMS_FAILURE;
}
MAGICK_CHECK(MagickCropImage(d->wand, rec.width, rec.height, rec.x, rec.y), d);
}
MAGICK_CHECK(MagickSetImagePage(d->wand, rec.width, rec.height, rec.x, rec.y), d);
return DIMS_SUCCESS;
}
apr_status_t
dims_legacy_thumbnail_operation (dims_request_rec *d, char *args, char **err) {
MagickStatusType flags;
RectangleInfo rec;
long width, height;
int x, y;
char *resize_args = apr_psprintf(d->pool, "%s^", args);
flags = ParseSizeGeometry(GetImageFromMagickWand(d->wand), resize_args, &rec);
if(!(flags & AllValues)) {
*err = "Parsing thumbnail (resize) geometry failed";
return DIMS_FAILURE;
}
if(rec.width < 200 && rec.height < 200) {
MAGICK_CHECK(MagickThumbnailImage(d->wand, rec.width, rec.height), d);
} else {
MAGICK_CHECK(MagickScaleImage(d->wand, rec.width, rec.height), d);
}
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, d->r,
"legacy_thumbnail will resize to %ldx%ld", rec.width, rec.height);
flags = ParseAbsoluteGeometry(args, &rec);
if(!(flags & AllValues)) {
*err = "Parsing thumbnail (crop) geometry failed";
return DIMS_FAILURE;
}
width = MagickGetImageWidth(d->wand);
height = MagickGetImageHeight(d->wand);
x = (width / 2) - (rec.width / 2);
y = (height / 2) - (rec.height / 2);
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, d->r,
"legacy_thumbnail will crop to %ldx%ld+%d+%d", rec.width, rec.height, x, y);
MAGICK_CHECK(MagickCropImage(d->wand, rec.width, rec.height, x, y), d);
return DIMS_SUCCESS;
}
char *get_thumbnail(char *full_filename, char *thumbnail_str, size_t *thumbnail_size)
{
char image_data = NULL;
if(full_filename == NULL || thumbnail_str == NULL)
return NULL;
MagickBooleanType status;
MagickWand *magick_wand, *tmp_magick_wand;
magick_wand=NewMagickWand();
status=MagickReadImage(magick_wand, full_filename);
if (status == MagickFalse)
ThrowWandException(magick_wand);
size_t height = MagickGetImageHeight(magick_wand);
size_t width = MagickGetImageWidth(magick_wand);
ssize_t i, j;
ParseMetaGeometry(thumbnail_str, &i, &j, &width, &height);
if(width <= 0 || height <= 0)
{
logError("%s%s:Geometry %s error\n", __FILE__, __func__, thumbnail_str);
}
else
{
/*
if(is_gif(full_filename))
{
tmp_magick_wand = magick_wand;
magick_wand = MagickCoalesceImages(tmp_magick_wand);
tmp_magick_wand = DestroyMagickWand(tmp_magick_wand);
}
*/
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse)
{
MagickThumbnailImage(magick_wand,height,width);
}
image_data = MagickGetImagesBlob(magick_wand, thumbnail_size);
}
magick_wand=DestroyMagickWand(magick_wand);
return image_data;
}
unsigned char* generate_thumbnail( const void *image, const size_t size, size_t *new_size )
{
MagickWand *magick_wand, *magick_wand_canvas;
PixelWand *pixel_wand;
unsigned int cols, rows, ncols, nrows;
unsigned char *new_blob;
// Initialize MagickWand:
MagickWandGenesis();
magick_wand = NewMagickWand();
magick_wand_canvas = NewMagickWand();
pixel_wand = NewPixelWand();
// Read image from memory:
DoMagick( magick_wand, MagickReadImageBlob( magick_wand, image, size ) );
// If input consists of several images, we'll only take the first one:
MagickResetIterator( magick_wand );
MagickSetFirstIterator( magick_wand );
// Get image size:
cols = MagickGetImageWidth( magick_wand );
rows = MagickGetImageHeight( magick_wand );
printf("Image size: %ix%i\n", (int)cols, (int)rows);
if (cols==0 || rows==0)
{
fprintf(stderr, "generateThumbnail: Warning, imagesize==0, skipping image...\n");
pixel_wand = DestroyPixelWand( pixel_wand );
magick_wand_canvas = DestroyMagickWand( magick_wand_canvas );
magick_wand = DestroyMagickWand( magick_wand );
MagickWandTerminus();
return NULL;
}
if (cols >= rows)
{
ncols = 98;
nrows = (rows*98)/cols;
}
else
{
nrows = 98;
ncols = (cols*98)/rows;
}
// Convert the image into a thumbnail:
DoMagick( magick_wand, MagickThumbnailImage( magick_wand, ncols, nrows ) );
PixelSetColor( pixel_wand, "#8f7f6f" );
DoMagick( magick_wand, MagickBorderImage( magick_wand, pixel_wand, 1, 1 ) );
DoMagick( magick_wand, MagickSetImageBackgroundColor( magick_wand, pixel_wand ) );
PixelSetColor( pixel_wand, "white" );
DoMagick( magick_wand_canvas, MagickNewImage( magick_wand_canvas, 100, 100, pixel_wand ) );
DoMagick( magick_wand_canvas, MagickCompositeImage( magick_wand_canvas, magick_wand, OverCompositeOp, 49-(ncols/2), 49-(nrows/2) ) );
// DoMagick( magick_wand_canvas, MagickWriteImage( magick_wand_canvas, "thumbnail.png" ) );
DoMagick( magick_wand_canvas, MagickSetImageFormat( magick_wand_canvas, "PNG" ) );
new_blob = MagickGetImageBlob( magick_wand_canvas, new_size );
// unsigned char *MagickGetImageBlob(MagickWand *wand,size_t *length)
pixel_wand = DestroyPixelWand( pixel_wand );
magick_wand = DestroyMagickWand( magick_wand );
magick_wand_canvas = DestroyMagickWand( magick_wand_canvas );
MagickWandTerminus();
return new_blob;
}
unsigned char *covert_image(MagickWand *magick_wand,
img_transition_info *image_transition_info, size_t *thumbnail_size) {
unsigned char *image_data = NULL;
MagickBooleanType status;
// MagickWand *tmp_magick_wand = NULL;
PixelWand *background = NULL;
size_t height = MagickGetImageHeight(magick_wand);
size_t old_height = height;
size_t width = MagickGetImageWidth(magick_wand);
size_t old_width = width;
int is_crop = 0;
int is_Crop = 0;
int is_thumbnail = 0;
ssize_t i = 0, j = 0;
char is_gif_flag = 0;
char is_jpeg_flag = 0;
int do_quality = 0;
char *fileformat = NULL;
size_t cw = 0; //crop weight
size_t ch = 0; //crop height
size_t x_offset = 0;
size_t y_offset = 0;
fileformat = MagickGetImageFormat(magick_wand);
if (fileformat == NULL) {
return NULL;
}
if (0 == strcasecmp(fileformat, image_format[GIFEXT])) {
is_gif_flag = 1;
} else if (0 == strcasecmp(fileformat, image_format[JPEGEXT])) {
is_jpeg_flag = 1;
} else if (0 == strcasecmp(fileformat, image_format[JPGEXT])) {
is_jpeg_flag = 1;
}
fileformat = (char *) MagickRelinquishMemory(fileformat); //free();
if ('c' == image_transition_info->transition_str[0]) {
is_crop = 1;
} else if ('C' == image_transition_info->transition_str[0]) {
is_Crop = 1;
} else {
is_thumbnail = 1;
}
if (is_crop) {
ParseMetaGeometry(image_transition_info->transition_str + 1, &i, &j,
&width, &height);
} else if (is_thumbnail) {
ParseMetaGeometry(image_transition_info->transition_str, &i, &j, &width,
&height);
if (old_width == width && height == old_height) //���ߴ���ͬ����������
is_thumbnail = 0;
} else if (is_Crop) {
if (0
>= get_Crop_width_height(
image_transition_info->transition_str + 1, &cw, &ch,
&x_offset, &y_offset)) {
logError("%s%s:Crop %s error\n", __FILE__, __func__,
image_transition_info->transition_str + 1);
return NULL;
}
#if 0
if(cw > width || ch > height) {
image_data = MagickGetImagesBlob(magick_wand, thumbnail_size);
magick_wand = DestroyMagickWand(magick_wand);
return image_data;
}
#endif
//�õ�height��width,�����Ӧ��x_offset,yoffset;
get_Crop_offset_and_wh(cw, ch, &width, &height, &x_offset, &y_offset);
}
if (old_width == width && height == old_height && (is_Crop == 0)
&& (image_transition_info->is_rotate == 0)
&& (image_transition_info->is_quality == 0)) {
image_data = MagickGetImagesBlob(magick_wand, thumbnail_size);
} else if (width <= 0 || height <= 0) {
logError("%s%s:Geometry %s error\n", __FILE__, __func__,
image_transition_info->transition_str);
} else {
/*
* if type of the image is GIF, maybe have more than one frame, so do this different
* from others
*/
// if (is_gif_flag) {
// tmp_magick_wand = magick_wand;
// magick_wand = MagickCoalesceImages(tmp_magick_wand);
// tmp_magick_wand = magick_wand;
// magick_wand = MagickOptimizeImageLayers(tmp_magick_wand);
// tmp_magick_wand = DestroyMagickWand(tmp_magick_wand);
// }
/*
* if size of the image less than 800 * 600 and that's type is JPEG, then do
* quality 100 OP
*/
if ((old_width < 800) && (old_height < 600) && is_jpeg_flag
&& is_crop != 1 && (image_transition_info->is_quality == 0)) {
do_quality = 1;
}
background = NewPixelWand();
status = PixelSetColor(background, "#000000");
/* for gif
MagickResetIterator(magick_wand);
*/
MagickWand *tmp_magick_wand = MagickGetImage(magick_wand);
// while (MagickNextImage(tmp_magick_wand) != MagickFalse) {
if (do_quality) {
MagickSetImageCompressionQuality(tmp_magick_wand, 100);
MagickStripImage(tmp_magick_wand);
}
if (is_thumbnail == 1) {
MagickThumbnailImage(tmp_magick_wand, width, height);
} else if (is_crop == 1) {
MagickCropImage(tmp_magick_wand, width, height, i, j);
} else if (is_Crop == 1) {
MagickThumbnailImage(tmp_magick_wand, width, height);
MagickCropImage(tmp_magick_wand, cw, ch, x_offset, y_offset);
if (is_gif_flag) { // gif should thumbnail again
MagickThumbnailImage(tmp_magick_wand, cw, ch);
}
}
if (image_transition_info->is_rotate == 1) {
MagickRotateImage(tmp_magick_wand, background,
(double) (image_transition_info->degree));
}
if (image_transition_info->is_quality) {
MagickSetImageCompressionQuality(tmp_magick_wand,
image_transition_info->quality);
}
MagickStripImage(tmp_magick_wand);
// }
background = DestroyPixelWand(background);
image_data = MagickGetImagesBlob(tmp_magick_wand, thumbnail_size);
tmp_magick_wand = DestroyMagickWand(tmp_magick_wand);
//
// if (is_gif_flag) {
// magick_wand = DestroyMagickWand(magick_wand);
// }
}
return image_data;
}
unsigned char *get_thumbnail(char *full_filename, char *thumbnail_str,
size_t *thumbnail_size, int is_rotate, int rotate_degree) {
unsigned char *image_data = NULL;
if (full_filename == NULL || thumbnail_str == NULL)
return NULL;
MagickBooleanType status;
MagickWand *tmp_magick_wand = NULL;
MagickWand *magick_wand = NULL;
magick_wand = NewMagickWand();
status = MagickReadImage(magick_wand, full_filename);
if (status == MagickFalse) {
ThrowWandException(magick_wand);
return NULL;
}
PixelWand *background = NULL;
size_t height = MagickGetImageHeight(magick_wand);
size_t old_height = height;
size_t width = MagickGetImageWidth(magick_wand);
size_t old_width = width;
ssize_t i = 0, j = 0;
int is_crop = 0;
char is_gif_flag = 0;
char is_jpeg_flag = 0;
int do_quality = 0;
char *fileformat = NULL;
fileformat = MagickGetImageFormat(magick_wand);
if (fileformat == NULL) {
return NULL;
}
if (0 == strcasecmp(fileformat, image_format[GIFEXT])) {
is_gif_flag = 1;
} else if (0 == strcasecmp(fileformat, image_format[JPEGEXT])) {
is_jpeg_flag = 1;
} else if (0 == strcasecmp(fileformat, image_format[JPGEXT])) {
is_jpeg_flag = 1;
}
fileformat = (char *)MagickRelinquishMemory(fileformat); //free();
if( 'C' == *thumbnail_str ||'c' == *thumbnail_str ) {
is_crop = 1;
}
if(is_crop) {
ParseMetaGeometry(thumbnail_str + 1, &i, &j, &width, &height);
} else {
ParseMetaGeometry(thumbnail_str, &i, &j, &width, &height);
}
if (old_width == width && height == old_height) {
image_data = MagickGetImagesBlob(magick_wand, thumbnail_size);
} else if (width <= 0 || height <= 0) {
logError("%s%s:Geometry %s error\n", __FILE__, __func__, thumbnail_str);
} else {
/*
* if type of the image is GIF, maybe have more than one frame, so do this different
* from others
*/
if (is_gif_flag) {
tmp_magick_wand = magick_wand;
magick_wand = MagickCoalesceImages(tmp_magick_wand);
tmp_magick_wand = DestroyMagickWand(tmp_magick_wand);
}
/*
* if size of the image less than 800 * 600 and that's type is JPEG, then do
* quality 100 OP
*/
if ((old_width < 800) && (old_height < 600) && is_jpeg_flag && is_crop != 1) {
do_quality = 1;
}
MagickResetIterator(magick_wand);
while (MagickNextImage(magick_wand) != MagickFalse) {
if(do_quality) {
MagickSetImageCompressionQuality(magick_wand, 100);
MagickStripImage(magick_wand);
}
if(is_crop == 0)
MagickThumbnailImage(magick_wand, width, height);
else {
logInfo("crop Image %ld, %ld", i, j);
MagickCropImage(magick_wand, width, height, i, j);
}
if(is_rotate == 1) {
background=NewPixelWand();
status=PixelSetColor(background,"#000000");
MagickRotateImage(magick_wand, background,(double)rotate_degree);
background=DestroyPixelWand(background);
}
}
image_data = MagickGetImagesBlob(magick_wand, thumbnail_size);
}
magick_wand = DestroyMagickWand(magick_wand);
return image_data;
}
