int main(int argc,char **argv) {
MagickWand *magick_wand_background;
MagickWand *magick_wand_foreground;
MagickWandGenesis();
magick_wand_background = NewMagickWand();
magick_wand_foreground = NewMagickWand();
MagickReadImage(magick_wand_background, "magick:logo");
MagickReadImage(magick_wand_foreground, "magick:rose");
MagickSetGravity(magick_wand_background, CenterGravity);
MagickSetGravity(magick_wand_foreground, CenterGravity);
MagickCompositeImage(
magick_wand_background,
magick_wand_foreground,
AtopCompositeOp,
0, 0
);
MagickSetFormat(magick_wand_background, "png");
MagickWriteImage(magick_wand_background, "./output/gravity.png");
MagickWandTerminus();
return 0;
}
int main(int argc,char **argv)
{
//creamos la imagen
MagickWand *imagen, *imagen2;
int proporcion = atoi(argv[3]);
//inicializamos la imagen
imagen = NewMagickWand();
imagen2 = NewMagickWand();
//cargamos la imagen
MagickReadImage(imagen,argv[1]);
//imagen2 = CloneMagickWand(imagen);
//llamamos a la funcion de redimension
Resize(imagen,imagen2,proporcion);
//guardamos la imagen en disco
MagickWriteImages(imagen2,argv[2],MagickTrue);
//liberamos memoria destruyendo la imagen
imagen = DestroyMagickWand(imagen2);
//terminamos ejecucion de la libreria
MagickWandTerminus();
return 0;
}
bool
img_init (img_t *im)
{
MagickWandGenesis();
if (im) {
im->screen = (void *) NewMagickWand();
im->banner = (void *) NewMagickWand();
return true;
}
return false;
}
unsigned char *get_transition_image_blob(char *file_buf, int buf_size,
size_t * thumbnail_size, img_transition_info *image_transition_info) {
unsigned char *image_data = NULL;
if (file_buf == NULL)
return NULL;
if (image_transition_info == NULL)
return NULL;
if ((0 == image_transition_info->is_rotate)
&& ('\0' == image_transition_info->transition_str[0])
&& (0 == image_transition_info->is_quality))
return NULL;
MagickBooleanType status;
MagickWand *magick_wand = NULL;
magick_wand = NewMagickWand();
status = MagickReadImageBlob(magick_wand, file_buf, buf_size);
if (status == MagickFalse) {
ThrowWandException(magick_wand);
return NULL;
}
image_data = covert_image(magick_wand, image_transition_info,
thumbnail_size);
magick_wand = DestroyMagickWand(magick_wand);
return image_data;
}
int magickUnsharpMaskImage(const char *imageFile, const char *outputImage, double radius, double sigma, double amount, double threshold){
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)
MagickUnsharpMaskImage(magick_wand, radius, sigma, amount, threshold);
/*
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;
}
int magickCompressImage(const char *imageFile, const char *outputImage, const char *format, int compressionType, double compressionRate){
MagickBooleanType status;
MagickWand *magick_wand;
/*
Read an image.
*/
// printf("compressionRate: %d", compressionRate);
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){
MagickSetFormat(magick_wand, (char *)format);
MagickSetImageCompression(magick_wand, compressionType);
MagickSetImageCompressionQuality(magick_wand, compressionRate);
// }
/*
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;
}
int magickChopImage(const char *imageFile, const char *outputImage, int width, int height, int xPos, int yPos){
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)
MagickChopImage(magick_wand, width, height, xPos, yPos);
/*
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;
}
int magickRotateImage(const char *imageFile, const char *outputImage, double degree){
MagickBooleanType status;
MagickWand *magick_wand;
PixelWand * bg = malloc(sizeof(PixelWand *));
/*
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)
MagickRotateImage(magick_wand, bg, degree);
// MagickSetImageCompression(magick_wand, MW_JPEGCompression);
// MagickUnsharpMaskImage( magick_wand, 4.5, 4.0, 4.5, 0.02 );
/*
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;
}
int magickResizeImage(const char *imageFile, const char *outputImage, int columns, int rows, int magickFilter, double blur){
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)
MagickResizeImage(magick_wand, columns, rows, LanczosFilter, blur);
/*
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;
}
int magickModulateImage(const char *imageFile, const char *outputImage, double brightness, double saturation, double hue){
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)
MagickModulateImage(magick_wand, brightness, saturation, hue);
/*
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;
}
/**
* Helper function to provide a visual interpretation of the accumulator.
*/
void print_accumulator(char* name) {
MagickWand *mw = NULL;
PixelWand **pmw = NULL;
PixelIterator *imw = NULL;
MagickWandGenesis();
unsigned long width, height;
width = _circumference;
height = _dimensions.semi_diagonal;
mw = NewMagickWand();
MagickSetSize(mw, width, height);
MagickReadImage(mw, "xc:black");
imw = NewPixelIterator(mw);
int y, x;
for (y=0; y<height; y++) {
pmw = PixelGetNextIteratorRow(imw, &width);
for (x=0; x< (long) width; x++) {
_CELL_TYPE* cell = &_accumulator[x][height-y-1];
PixelSetRed(pmw[x], 1.0/20.0 * cell->count);
}
PixelSyncIterator(imw);
}
MagickWriteImage(mw, name);
if(mw)
mw = DestroyMagickWand(mw);
MagickWandTerminus();
}
static MagickWand *iac_image_new(const iac_image_read_params_t *params)
{
MagickWand *wand = NULL;
/* Create wand */
wand = NewMagickWand();
if (!wand) {
iac_image_destroy(wand);
return NULL;
}
/* Set width and height of image */
if (MagickSetSize(wand, params->width, params->height) == MagickFalse) {
iac_image_exception(wand);
iac_image_destroy(wand);
return NULL;
}
/* Set format of image */
if (MagickSetFormat(wand, params->format) == MagickFalse) {
iac_image_exception(wand);
iac_image_destroy(wand);
return NULL;
}
/* Set color depth of image */
if (MagickSetDepth(wand, params->depth) == MagickFalse) {
iac_image_exception(wand);
iac_image_destroy(wand);
return NULL;
}
return wand;
}
int barcode_to_png (char *image_name) {
MagickWand *magick_wand;
MagickBooleanType status;
int width, height, pad, half_pad;
/* read a barcode image */
MagickWandGenesis();
magick_wand = NewMagickWand();
MagickSetResolution(magick_wand, 300, 300);
status = MagickReadImage(magick_wand, image_name);
if (status == MagickFalse) ThrowWandException(magick_wand, 1);
/* trim the image, resample it, and pad it by [10% of the long side] per side */
MagickTrimImage(magick_wand, 10);
width = MagickGetImageWidth(magick_wand);
height = MagickGetImageHeight(magick_wand);
pad = determine_padding(width, height);
half_pad = round(pad/2);
MagickExtentImage(magick_wand, width+pad, height+pad, -half_pad, -half_pad);
/* write image (a PNG version and a formatted PS version) */
status=MagickWriteImage(magick_wand, chop_path(image_name, ".png"));
if (status == MagickFalse) ThrowWandException(magick_wand, 2);
status=MagickWriteImage(magick_wand, chop_path(image_name, ".ps"));
if (status == MagickFalse) ThrowWandException(magick_wand, 2);
/* clean up */
magick_wand=DestroyMagickWand(magick_wand);
MagickWandTerminus();
return 0;
}
int main(int argc,char **argv) {
MagickWand *magick_wand;
MagickBooleanType status;
MagickWandGenesis();
magick_wand = NewMagickWand();
MagickSetResourceLimit(MemoryResource, 1000 * 1000);
MagickSetResourceLimit(DiskResource, 1000 * 1000);
status = MagickReadImage(magick_wand, "./images/picture-100M-6000x6000.png");
if (status == MagickFalse) {
printf("Failed to MagickReadImage");
return -1;
}
printf("This shouldn't be reached - the image is larger than the area resource.\n");
MagickSetImageFormat(magick_wand, "png");
status = MagickWriteImages(magick_wand, "./output/resource_output.png", MagickTrue);
if (status == MagickFalse) {
printf("Failed to MagickWriteImages");
return -1;
}
MagickWandTerminus();
return(0);
}
static ngx_int_t
ngx_http_circle_gif_init(ngx_http_circle_gif_loc_conf_t *cglcf)
{
u_int i;
MagickWand *wand;
PixelWand *bg_wand, *fg_wand;
DrawingWand *dwand;
wand = NewMagickWand();
bg_wand = NewPixelWand();
fg_wand = NewPixelWand();
dwand = NewDrawingWand();
if ((cglcf->circle_templates = malloc((1+radius2index(cglcf->max_radius, cglcf))*sizeof(unsigned char*))) == NULL ||
(cglcf->circle_sizes = malloc((1+radius2index(cglcf->max_radius, cglcf))*sizeof(size_t))) == NULL) {
perror("malloc()");
return NGX_ERROR;
}
for (i=0;i<=radius2index(cglcf->max_radius, cglcf);i++) {
cglcf->circle_templates[i] = ngx_http_circle_gif_template(cglcf->min_radius+i*cglcf->step_radius, &cglcf->circle_sizes[i],
wand, bg_wand, fg_wand, dwand);
}
DestroyMagickWand( wand );
DestroyPixelWand( fg_wand );
DestroyPixelWand( bg_wand );
DestroyDrawingWand( dwand );
return i;
}
int main(int argc, char* argv[]) {
MagickWand *mw = NULL;
DrawingWand *dw = NULL;
PixelWand *fill = NULL;
int x,y;
MagickWandGenesis();
mw = NewMagickWand();
MagickReadImage(mw,"logo:");
fill = NewPixelWand();
dw = NewDrawingWand();
PixelSetColor(fill,"green");
DrawSetFillColor(dw,fill);
for (x=200;x<210;x++)
for (y=100;y<110;y++)
DrawPoint(dw,x,y);
MagickDrawImage(mw,dw);
MagickWriteImage(mw,"logo.jpg");
if (dw) dw = DestroyDrawingWand(dw);
if (fill) fill = DestroyPixelWand(fill);
if (mw) mw = DestroyMagickWand(mw);
MagickWandTerminus();
}
int main(int argc,char **argv) {
MagickWand *magick_wand;
MagickBooleanType status;
MagickWandGenesis();
magick_wand = NewMagickWand();
//This is a color image
status = MagickReadImage(magick_wand, "./Biter_500.jpg");
MagickScaleImage(magick_wand, 16, 16);
// MagickQuantizeImage(
// magick_wand,
// //Changing to 255 makes the image change to grayscale
// 255,
// GRAYColorspace,
// 0,
// 0,
// 0
// );
status = MagickWriteImages(magick_wand, "./67258.jpg", MagickTrue);
MagickWandTerminus();
return(0);
}
GmImp::GmImp()
: Cimp()
{
this->wand = nullptr;
char *im_path = NULL;
InitializeMagick(im_path);
this->wand = NewMagickWand();
}
ARUint8* loadImage(char* filename, int* xsize, int* ysize)
{
ARUint8 *dptr;
Image *image;
MagickWand* magick_wand;
magick_wand=NewMagickWand();
if( magick_wand == NULL) {
fprintf(stderr, "bad magickwand\n");
}
MagickBooleanType status=MagickReadImage(magick_wand,filename);
if (status == MagickFalse) {
//fprintf(stderr, "%s can't be read\n", filename);
//exit(1);
//return; //(1);
ThrowWandException(magick_wand);
}
image = GetImageFromMagickWand(magick_wand);
//ContrastImage(image,MagickTrue);
//EnhanceImage(image,&image->exception);
int index;
*xsize = image->columns;
*ysize = image->rows;
dptr = malloc(sizeof(ARUint8) * 3 * image->rows * *xsize);
int y;
index = 0;
for (y=0; y < (long) image->rows; y++)
{
const PixelPacket *p = AcquireImagePixels(image,0,y,*xsize,1,&image->exception);
if (p == (const PixelPacket *) NULL)
break;
int x;
for (x=0; x < (long) *xsize; x++)
{
/// convert to ARUint8 dptr
/// probably a faster way to give the data straight over
/// in BGR format
dptr[index*3+2] = p->red/256;
dptr[index*3+1] = p->green/256;
dptr[index*3] = p->blue/256;
//fprintf(stderr,"%d, %d, %d\t%d\t%d\n", x, y, p->red/256, p->green/256, p->blue/256);
p++;
index++;
}
}
DestroyMagickWand(magick_wand);
return dptr;
}
int main(int argc,char **argv) {
MagickBooleanType status;
PixelWand *pixelWand;
MagickWand *magick_wand_a;
MagickWand *magick_wand_b;
//MagickWand *magick_wand_c;
MagickWandGenesis();
magick_wand_a = NewMagickWand();
status = MagickReadImage(magick_wand_a, "./displaceCompositeA.png");
if (status == MagickFalse) {
ThrowWandException(magick_wand_a);
}
magick_wand_b = NewMagickWand();
status = MagickReadImage(magick_wand_b, "./displaceMask.png");
if (status == MagickFalse) {
ThrowWandException(magick_wand_b);
}
MagickSetImageVirtualPixelMethod(magick_wand_a, TransparentVirtualPixelMethod);
pixelWand = makePixelWand("none");
status = MagickSetImageBackgroundColor(magick_wand_a, pixelWand);
MagickSetOption(magick_wand_a, "compose:args", "300x53.033");
status = MagickCompositeImage(magick_wand_a, magick_wand_b, DisplaceCompositeOp, 0, 0);
if (status == MagickFalse) {
printf("Failed to composite image b");
exit(-1);
}
status = MagickWriteImages(magick_wand_a, "displaceOutputMerged.png", MagickTrue);
MagickWandTerminus();
printf("Finished - please compare displaceOutputMerged.png with the result of:\n\n");
printf("convert displaceCompositeA.png displaceMask.png -virtual-pixel transparent -channel rgba -alpha on -background transparent -define compose:args=300x53.033 -compose displace -composite displaceMerged.png");
return(0);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% N e w M a g i c k W a n d F r o m I m a g e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% NewMagickWandFromImage() returns a wand with an image.
%
% The format of the NewMagickWandFromImage method is:
%
% MagickWand *NewMagickWandFromImage(const Image *image)
%
% A description of each parameter follows:
%
% o image: the image.
%
*/
WandExport MagickWand *NewMagickWandFromImage(const Image *image)
{
MagickWand
*wand;
wand=NewMagickWand();
wand->images=CloneImage(image,0,0,MagickTrue,wand->exception);
return(wand);
}
caddr_t bif_im_DeepZoom4to1 (caddr_t * qst, caddr_t * err, state_slot_t ** args)
{
im_env_t env;
caddr_t res;
int fmt_is_set = 0;
int image_ctr;
im_init (&env, qst, args, "IM DeepZoom4to1");
im_set_background (&env, "#000000");
env.ime_target_magick_wand = NewMagickWand ();
if (MagickFalse == MagickNewImage (env.ime_target_magick_wand, 256, 256, env.ime_background))
im_leave_with_error (&env, "22023", "IM001", "Can not make new image");
if (MagickFalse == MagickSetImageType (env.ime_target_magick_wand, TrueColorType))
im_leave_with_error (&env, "22023", "IM001", "Can not set image type");
if (MagickFalse == MagickSetImageDepth (env.ime_target_magick_wand, 16))
im_leave_with_error (&env, "22023", "IM001", "Can not set image depth");
if (MagickFalse == MagickSetImageExtent (env.ime_target_magick_wand, 256, 256))
im_leave_with_error (&env, "22023", "IM001", "Can not set image extent");
if (MagickFalse == MagickSetImageBackgroundColor (env.ime_target_magick_wand, env.ime_background))
im_leave_with_error (&env, "22023", "IM001", "Can not set image background");
image_ctr = BOX_ELEMENTS (args) / 2;
if (image_ctr > 4)
image_ctr = 4;
while (0 < image_ctr--)
{
if (DV_DB_NULL == DV_TYPE_OF (bif_arg (qst, args, image_ctr*2, "IM DeepZoom4to1")))
continue;
im_env_set_input_blob (&env, image_ctr * 2);
/*im_env_set_blob_ext (&env, 2);*/
im_read (&env);
MagickResetIterator (env.ime_magick_wand);
while (MagickNextImage (env.ime_magick_wand) != MagickFalse)
{
unsigned long v_size, h_size;
if (!fmt_is_set)
{
if (MagickFalse == MagickSetImageFormat (env.ime_target_magick_wand, MagickGetImageFormat (env.ime_magick_wand)))
im_leave_with_error (&env, "22023", "IM001", "Can not set image format");
fmt_is_set = 1;
}
h_size = MagickGetImageWidth (env.ime_magick_wand);
v_size = MagickGetImageHeight (env.ime_magick_wand);
if ((256 < h_size) || (256 < v_size))
continue;
MagickResizeImage (env.ime_magick_wand, h_size/2, v_size/2, BoxFilter, 1.0);
if (MagickFalse == MagickCompositeImage (env.ime_target_magick_wand, env.ime_magick_wand, OverCompositeOp, (image_ctr & 1) * 128, (image_ctr & 2) * 64))
im_leave_with_error (&env, "22023", "IM001", "Can not composite image");
}
im_reset_read (&env);
}
MagickProfileImage (env.ime_target_magick_wand, "*", NULL, 0);
DestroyMagickWand (env.ime_magick_wand);
env.ime_magick_wand = env.ime_target_magick_wand;
env.ime_target_magick_wand = NULL;
res = im_write (&env);
im_leave (&env);
return res;
}
char* get_phone_img(const char *phone_str, size_t *img_size){
if(phone_str == NULL){
return NULL;
}
MagickWand *m_wand = NULL;
PixelWand *p_wand = NULL;
DrawingWand *d_wand = NULL;
/* Create a wand */
m_wand = NewMagickWand();
p_wand = NewPixelWand();
d_wand = NewDrawingWand();
PixelSetColor(p_wand,"white");
int height = 18;
int width = strlen(phone_str) * 130 / 12;
MagickNewImage(m_wand, width,height ,p_wand);
//draw number
PixelSetColor(p_wand,"black");
DrawSetFillColor(d_wand,p_wand);
DrawSetFont (d_wand, "Arial" ) ;
DrawSetFontSize(d_wand,20);
DrawSetStrokeColor(d_wand,p_wand);
DrawAnnotation(d_wand,0,height -2,phone_str);
MagickDrawImage(m_wand,d_wand);
//MagickTrimImage(m_wand,0);
//ImageFormat MUST be SET,otherwise,otherwise we will not MagickGetImageBlob properly
MagickSetImageFormat(m_wand,"JPEG");
char *p = NULL;
char *data = NULL;
p = (char *)MagickGetImageBlob(m_wand,img_size);
if(p != NULL){
data = (char *)malloc(*img_size);
if(data != NULL){
memcpy(data,p,*img_size);
}else{
LOG_PRINT(LOG_INFO, "malloc Failed!");
}
}else{
LOG_PRINT(LOG_INFO, "MagickGetImageBlob Failed!");
}
/* Tidy up */
MagickRelinquishMemory(p);
DestroyMagickWand(m_wand);
DestroyPixelWand(p_wand);
return data;
}
int main(int argc,char **argv)
{
char
filename[MaxTextExtent];
MagickBooleanType
status;
MagickWand
*canvas;
if (argc != 2)
{
(void) printf ("Usage: %s filename\n",argv[0]);
exit(1);
}
(void) CopyMagickString(filename,argv[1],MaxTextExtent);
/*
Create canvas image.
*/
MagickWandGenesis();
canvas=NewMagickWand();
status=MagickSetSize(canvas,596,842);
if (status == MagickFalse)
ThrowWandException(canvas);
status=MagickReadImage(canvas,"xc:white");
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Scribble on image.
*/
status=ScribbleImage(canvas);
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Set pixel depth to 8.
*/
status=MagickSetImageDepth(canvas,8);
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Set output as RLE compressed.
*/
status=MagickSetImageCompression(canvas,RLECompression);
if (status == MagickFalse)
ThrowWandException(canvas);
/*
Save image to file.
*/
status=MagickWriteImage(canvas,filename);
if (status == MagickFalse)
ThrowWandException(canvas);
canvas=DestroyMagickWand(canvas);
MagickWandTerminus();
return(0);
}
static PyObject *
im_NewImage(PyObject *self, PyObject *args) {
MagickWand *magick_wand;
magick_wand = NewMagickWand();
return Py_BuildValue("O", PyCObject_FromVoidPtr((void *)magick_wand,
(void *)DestroyMagickWand));
}
bool ImageMagickGIFEncoderOpen(struct ImageMagickGIFEncoder* encoder, const char* outfile) {
MagickWandGenesis();
encoder->wand = NewMagickWand();
MagickSetImageFormat(encoder->wand, "GIF");
MagickSetImageDispose(encoder->wand, PreviousDispose);
encoder->outfile = strdup(outfile);
encoder->frame = malloc(VIDEO_HORIZONTAL_PIXELS * VIDEO_VERTICAL_PIXELS * 4);
encoder->currentFrame = 0;
return true;
}
int parse (size_t size, unsigned char *data) {
int writtendata = 0;
MagickWand *input = NewMagickWand();
MagickWand *output = input;
convert_t *opts = (convert_t*) data;
convert_info_t info_data;
size -= sizeof(convert_t);
data += sizeof(convert_t);
int status = convert(input, &output, opts, data, size);
if (status < 0) {
destroy(input, output);
return status;
}
if (opts->format == INFO) {
to_convert_info(output, &info_data);
data = (unsigned char*) &info_data;
size = sizeof(convert_info_t);
writtendata = io_write(size, data);
} else {
if (opts->split) {
// If we split the file then we will make a tarball containing all the pages
char* filename;
filename = tmpnam (NULL);
size = write_archive_from_mem(filename, output);
writtendata = io_write_file_to_stdout(filename);
unlink(filename);
} else {
char *format = MagickGetImageFormat(output);
if(strcmp(format,"PNG") == 0 && opts->quality != 0){
struct bufferAndSize d = pngQuant(output);
writtendata = io_write(d.size, d.data);
free(d.data);
free(format);
}else{
data = MagickWriteImageBlob(output, &size);
writtendata = io_write(size, data);
free(data);
}
destroy(input, output);
}
}
return writtendata;
}
void main(void)
{
clock_t begin, end;
double time_spent;
double imageAspectRatio = 0;
double originalWidth;
double originalHeight;
double masterAspectRatio = 1.77;
MagickWand *m_wand = NULL;
int width,height;
MagickWandGenesis();
m_wand = NewMagickWand();
MagickReadImage(m_wand,"mona-lisa.JPG");
begin = clock();
originalWidth = MagickGetImageWidth(m_wand);
originalHeight = MagickGetImageHeight(m_wand);
imageAspectRatio = originalWidth/originalHeight;
if(imageAspectRatio <= masterAspectRatio)
{
MagickCropImage(m_wand,originalWidth,(int)(originalWidth/masterAspectRatio),0,(originalHeight-(int)(originalWidth/masterAspectRatio))/2 );
printf("%d X %d ",MagickGetImageWidth(m_wand) , MagickGetImageHeight(m_wand));
}
else
{
MagickCropImage(m_wand,(int)(originalHeight * masterAspectRatio),originalHeight,(originalWidth - (int)(originalHeight * masterAspectRatio))/2,0);
}
if (originalWidth > 1920)
MagickResizeImage(m_wand,1920,1080,LanczosFilter,1);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("Time taken is %f\n",time_spent);
// MagickCropImage(m_wand,originalWidth/2,originalHeight/2,0,0);
// Set the compression quality to 95 (high quality = low compression)
//MagickSetImageCompressionQuality(m_wand,95);
/* Write the new image */
MagickWriteImage(m_wand,"master.jpg");
/* Clean up */
if(m_wand)m_wand = DestroyMagickWand(m_wand);
MagickWandTerminus();}
int fuppes_transcoder_transcode_image_mem(plugin_info* plugin,
const unsigned char** inBuffer,
size_t inSize,
unsigned char** outBuffer,
size_t* outSize,
int width, int height,
int less, int greater)
{
MagickBooleanType status;
MagickWand* wand = NewMagickWand();
//printf("magickWand %d\n", 1);
status = MagickReadImageBlob(wand, *inBuffer, inSize);
if(status == MagickFalse) {
plugin->cb.log(plugin, 0, __FILE__, __LINE__,
"error reading image from buffer. size: %d", inSize);
wand = DestroyMagickWand(wand);
return -1;
}
//printf("magickWand %d\n", 2);
MagickWand* wandOut;
char geometry[123];
sprintf(&geometry, "%dx%d", width, height);
//char* geometry = "250x250";
wandOut = MagickTransformImage(wand, "", geometry);
wand = DestroyMagickWand(wand);
if(wandOut == NULL) {
return -1;
}
//printf("magickWand %d\n", 3);
//MagickBooleanType MagickSetFormat(MagickWand *wand,const char *format)
size_t length;
unsigned char* blob;
blob = MagickGetImageBlob(wandOut, &length);
*outBuffer = realloc(*outBuffer, length);
memcpy(*outBuffer, blob, length);
*outSize = length;
MagickRelinquishMemory(blob);
//printf("magickWand %d, %d\n", 4, *outSize);
//MagickRelinquishMemory(wandOut);
wandOut = DestroyMagickWand(wandOut);
return 0;
}
int main(int argc, char **argv){
if (argc != 4){
(void) fprintf(stdout,"Usage: %s palette input-file output-file\n",argv[0]);
exit(0);
}
read_palette(argv[1]);
print_palette();
char *description;
ExceptionType severity;
#define ThrowWandException(wand) \
{ \
description=MagickGetException(wand,&severity); \
(void) fprintf(stderr,"%s %s %lu %s\n",GetMagickModule(),description); \
description=(char *) MagickRelinquishMemory(description); \
exit(-1); \
}
MagickBooleanType status;
MagickPixelPacket pixel;
MagickWand *wand;
WandView *view;
/*
Read an image.
*/
MagickWandGenesis();
wand = NewMagickWand();
status = MagickReadImage(wand, argv[2]);
if (status == MagickFalse) ThrowWandException(wand);
/*
Sigmoidal non-linearity contrast control.
*/
view = NewWandView(wand);
if (view == (WandView *) NULL) ThrowWandException(wand);
status = UpdateWandViewIterator(view, recolor, (void *)NULL);
if (status == MagickFalse) ThrowWandException(wand);
view = DestroyWandView(view);
/*
Write the image then destroy it.
*/
status = MagickWriteImages(wand, argv[3], MagickTrue);
if (status == MagickFalse) ThrowWandException(wand);
wand = DestroyMagickWand(wand);
MagickWandTerminus();
return 0;
}
