int write_archive_from_mem(char *outname, MagickWand *wand) { int archiveSize = 0; int pageNumber = 1; struct archive *a; struct archive_entry *entry; a = archive_write_new(); archive_write_set_format_ustar(a); archive_write_open_filename(a, outname); char filename[13]; MagickResetIterator(wand); MagickNextImage(wand); // Has to be called after MagickResetIterator to set the first picture as the current do { unsigned char *data; size_t size; data = MagickWriteImageBlob(wand, &size); entry = archive_entry_new(); snprintf(filename, 13, "page_%d", pageNumber++); archive_entry_set_pathname(entry, filename); archive_entry_set_size(entry, size); archive_entry_set_filetype(entry, AE_IFREG); archive_entry_set_perm(entry, 0644); archive_write_header(a, entry); archiveSize += archive_write_data(a, data, size); archive_entry_free(entry); } while (MagickNextImage(wand)); archive_write_close(a); archive_write_free(a); return archiveSize; }
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; }
caddr_t bif_im_ConvertImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; char out_name[64]; caddr_t format = bif_string_arg (qst, args, 2, "IM ConvertImageBlob"); im_init (&env, qst, args, "IM ConvertImageBlob"); im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, 3, -1); im_read (&env); if (env.ime_input_ext != NULL) { if (strlen(format) < 30) { strcpy(out_name, "image."); strcat(out_name, format); } } MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { env.ime_status = MagickSetImageFormat (env.ime_magick_wand, format); MagickSetFilename (env.ime_magick_wand, out_name); if (env.ime_status == MagickFalse) im_leave_with_error (&env, "22023", "IM001", "bif_im_ConvertImageBlob cannot convert image"); } res = im_write (&env); im_leave (&env); return res; }
caddr_t bif_im_CropAndResizeImageBlob(caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; unsigned long width = bif_long_arg (qst, args, 2, "IM CropAndResizeImageBlob"); unsigned long height = bif_long_arg (qst, args, 3, "IM CropAndResizeImageBlob"); long x = bif_long_arg (qst, args, 4, "IM CropAndResizeImageBlob"); long y = bif_long_arg (qst, args, 5, "IM CropAndResizeImageBlob"); long h_size = bif_long_arg (qst, args, 6, "IM ResizeImageBlob"); long v_size = bif_long_arg (qst, args, 7, "IM ResizeImageBlob"); double blur = bif_double_arg (qst, args, 8, "IM ResizeImageBlob"); long filter = bif_long_arg (qst, args, 9, "IM ResizeImageBlob"); if (filter < 0 || filter > 15) filter = PointFilter; im_init (&env, qst, args, "IM CropAndResizeImageBlob"); im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, 10, -1); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickCropImage (env.ime_magick_wand, width, height, x, y); MagickResizeImage (env.ime_magick_wand, h_size, v_size, filter, blur); } res = im_write (&env); im_leave (&env); return res; }
int convert (MagickWand *input, MagickWand **output, convert_t *opts, unsigned char* data, size_t size) { if (convert_density(input, opts) != MagickPass) return -7; if (MagickReadImageBlob(input, data, size) != MagickPass) return -2; if (convert_adjoin(input, output, opts) != MagickPass) return -8; input = *output; MagickResetIterator(input); MagickNextImage(input); // Has to be called after MagickResetIterator to set the first picture as the current do { if (convert_format(input, opts) != MagickPass) return -3; if (convert_scale(input, opts) != MagickPass) return -4; if (convert_rotate(input, opts) != MagickPass) return -5; if (convert_crop(input, opts) != MagickPass) return -6; } while (MagickNextImage(input)); return 0; }
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; }
void scale_height(size_t height) { size_t width = (size_t)round(width_ * ((double)height/height_)); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { MagickResizeImage(magick_wand,width,height,LanczosFilter,1.0); } width_ = width; height_ = height; }
void crop(size_t width, size_t height, size_t x, size_t y) { MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { if(MagickFalse == MagickCropImage(magick_wand,width,height,x,y)) { throw("An error occured"); } } width_ = width; height_ = height; }
void box(size_t width, size_t height, char floated) { double width_ratio = (double)width/width_; double height_ratio = (double)height/height_; size_t new_width, new_height, crop_x, crop_y; if(width_ratio > height_ratio) { new_width = width; new_height = (size_t)(height_ * width_ratio); crop_x = 0; crop_y = 0; if((floated & EIM_FLOAT_BOTTOM) == EIM_FLOAT_BOTTOM) { crop_y = new_height - height; } else if((floated & EIM_FLOAT_TOP) == EIM_FLOAT_TOP) { crop_x = 0; } else//if((floated & EIM_FLOAT_CENTER) == EIM_FLOAT_CENTER) { crop_y = (size_t)(new_height / 2.0 - height / 2.0); } } else { new_width = (size_t)(width_ * height_ratio); new_height = height; crop_y = 0; if((floated & EIM_FLOAT_RIGHT) == EIM_FLOAT_RIGHT) { crop_x = new_width - width; } else if((floated & EIM_FLOAT_LEFT) == EIM_FLOAT_LEFT) { crop_x = 0; } else//if((floated & EIM_FLOAT_CENTER) == EIM_FLOAT_CENTER) { crop_x = (size_t)(new_width / 2.0 - width / 2.0); } } MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { MagickResizeImage(magick_wand,new_width,new_height,LanczosFilter,1.0); MagickCropImage(magick_wand,width,height,crop_x,crop_y); } width_ = width; height_ = height; }
/** * read frame using ImageMagick */ NftResult im_read_frame(struct Ledcat *c, size_t width, size_t height, char *buf) { #if HAVE_IMAGEMAGICK == 1 /* is there an image from a previous read? */ if(MagickHasNextImage(c->mw)) { MagickNextImage(c->mw); } else { /* end-of-stream? */ if(feof(c->file)) return FALSE; /* read file */ if(!MagickReadImageFile(c->mw, c->file)) { im_error(c->mw); return FALSE; } /* reset iterator in case we read more than one file */ //MagickResetIterator(c->mw); } /* turn possible alpha-channel black */ /*PixelWand *pw; if(!(pw = NewPixelWand())) return FALSE; PixelSetColor(pw, "black"); MagickSetImageBackgroundColor(c->mw, pw); DestroyPixelWand(pw);*/ /* get raw-buffer from imagemagick */ if(!(MagickExportImagePixels(c->mw, 0, 0, width, height, c->map, c->storage, buf))) { im_error(c->mw); return FALSE; } /* free resources */ if(!MagickHasNextImage(c->mw)) ClearMagickWand(c->mw); #endif return TRUE; }
caddr_t bif_im_RotateImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; double v_size = bif_double_arg (qst, args, 1, "IM RotateImageFile"); im_init (&env, qst, args, "IM RotateImageFile"); im_env_set_filenames (&env, 0, 2); im_read (&env); im_set_background (&env, "#000000"); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickRotateImage (env.ime_magick_wand, env.ime_background, v_size); } im_write (&env); im_leave (&env); return (0); }
caddr_t bif_im_RotateImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; double v_size = bif_double_arg (qst, args, 2, "IM RotateImageBlob"); im_init (&env, qst, args, "IM RotateImageBlob"); im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, 3, -1); im_read (&env); im_set_background (&env, "#000000"); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickRotateImage (env.ime_magick_wand, env.ime_background, v_size); } res = im_write (&env); im_leave (&env); return res; }
caddr_t bif_im_ThumbnailImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; long v_size = bif_long_arg (qst, args, 1, "IM ThumbnailImageFile"); long h_size = bif_long_arg (qst, args, 2, "IM ThumbnailImageFile"); long filter = bif_long_arg (qst, args, 3, "IM ThumbnailImageFile"); im_init (&env, qst, args, "IM ThumbnailImageFile"); im_env_set_filenames (&env, 0, 4); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickResizeImage (env.ime_magick_wand,v_size, h_size,filter,1.0); MagickProfileImage (env.ime_magick_wand, "*", NULL, 0); } im_write (&env); im_leave (&env); return(0); }
caddr_t bif_im_CropImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; unsigned long width = (unsigned long) bif_long_arg (qst, args, 1, "IM CropImageFile"); unsigned long height = (unsigned long) bif_long_arg (qst, args, 2, "IM CropImageFile"); long x = bif_long_arg (qst, args, 3, "IM CropImageFile"); long y = bif_long_arg (qst, args, 4, "IM CropImageFile"); im_init (&env, qst, args, "IM CropImageFile"); im_env_set_filenames (&env, 0, 5); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickCropImage (env.ime_magick_wand, width, height, x, y); } im_write (&env); im_leave (&env); return (0); }
int resize_image(char* path, char* req_path, size_t size, char* mode) { // Create new image MagickWand* magick_wand = NewMagickWand(); if((uintptr_t)magick_wand < 1) error("Could not initialize ImageMagick (magick_wand is NULL)", EXIT_FAILURE); // Read the Image bool status = MagickReadImage(magick_wand, path); if (status == false) return -1; size_t width = MagickGetImageWidth(magick_wand); size_t height = MagickGetImageHeight(magick_wand); // If the size is bigger than both height and width, redirect to original if(size >= width) return 1; size_t new_height = size; size_t new_width = size; // Unless a square image is requested, calculcate proper aspect ratio if(size != 1 && strcmp(mode, "square")) new_height = height * size / width; /* Turn the image into a thumbnail sequence (for animated GIFs) * Automatically switches to a less cpu intense filter for animated GIFs. */ MagickResetIterator(magick_wand); for(int i = 0; MagickNextImage(magick_wand) != false && i < 250; i++) MagickResizeImage(magick_wand, new_width, new_height, !i ? LanczosFilter : TriangleFilter, 1); // Write the image status = MagickWriteImages(magick_wand, req_path, true); if (status == MagickFalse) error("Could not write image", EXIT_FAILURE) DestroyMagickWand(magick_wand); return 0; }
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; }
caddr_t bif_im_AnnotateImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args) { char * szMe = "IM AnnotateImageBlob"; caddr_t res; caddr_t blob = (caddr_t)bif_arg (qst, args, 0, szMe); long blob_size = box_length (blob) - 1; long x_pos = bif_long_arg (qst, args, 1, szMe); long y_pos = bif_long_arg (qst, args, 2, szMe); caddr_t text = bif_string_arg (qst, args, 3, szMe); int n_args = BOX_ELEMENTS(args); long angle = n_args > 4 ? bif_long_arg (qst, args, 4, szMe) : 0; long f_size = n_args > 5 ? bif_long_arg (qst, args, 5, szMe) : 12; char *text_color = n_args > 6 ? bif_string_arg (qst, args, 6, szMe) : "black" ; dtp_t dtp = DV_TYPE_OF (blob); im_env_t env; im_init (&env, qst, args, "IM AnnotateImageBlob"); if (IS_STRING_DTP (dtp)) blob_size = box_length (blob) - 1; else if (dtp == DV_BIN) blob_size = box_length (blob); else im_leave_with_error (&env, "22023", "IM001", "AnnotateImageBlob needs string or binary as 1-st argument"); im_env_set_blob_ext (&env, 7, -1); env.ime_drawing_wand = NewDrawingWand (); im_read (&env); im_set_background (&env, text_color); DrawSetFillColor (env.ime_drawing_wand, env.ime_background); DrawSetFontSize (env.ime_drawing_wand, f_size); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { env.ime_status = MagickAnnotateImage (env.ime_magick_wand, env.ime_drawing_wand, x_pos, y_pos, angle, text); if (env.ime_status == MagickFalse) im_leave_with_error (&env, "22023", "IM001", "Cannot annotate image"); } res = im_write (&env); im_leave (&env); return res; }
static PyObject * im_NextImage(PyObject *self, PyObject *args) { void *magick_pointer; MagickWand *magick_wand; MagickBooleanType status; if (!PyArg_ParseTuple(args, "O", &magick_pointer)){ Py_INCREF(Py_None); return Py_None; } magick_wand = (MagickWand *) PyCObject_AsVoidPtr(magick_pointer); status = MagickNextImage(magick_wand); if (status == MagickFalse){ return Py_BuildValue("i", 0); } return Py_BuildValue("i", 1); }
caddr_t bif_im_CropImageBlob(caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; unsigned long width = bif_long_arg (qst, args, 2, "IM CropImageBlob"); unsigned long height = bif_long_arg (qst, args, 3, "IM CropImageBlob"); long x = bif_long_arg (qst, args, 4, "IM CropImageBlob"); long y = bif_long_arg (qst, args, 5, "IM CropImageBlob"); im_init (&env, qst, args, "IM CropImageBlob"); im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, 6, -1); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickCropImage (env.ime_magick_wand, width, height, x, y); } res = im_write (&env); im_leave (&env); return res; }
caddr_t bif_im_ResizeImageFile (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; long v_size = bif_long_arg (qst, args, 1, "IM ResizeImageFile"); long h_size = bif_long_arg (qst, args, 2, "IM ResizeImageFile"); double blur = bif_double_arg (qst, args, 3, "IM ResizeImageFile"); long filter = bif_long_arg (qst, args, 4, "IM ResizeImageFile"); if (filter < 0 || filter > 15) filter = PointFilter; im_init (&env, qst, args, "IM ResiseImageFile"); im_env_set_filenames (&env, 0, 5); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickResizeImage (env.ime_magick_wand,v_size, h_size,filter,blur); } im_write (&env); im_leave (&env); return(0); }
void fit(size_t width, size_t height) { double width_ratio = (double)width/width_; double height_ratio = (double)height/height_; size_t new_width, new_height; if(width_ratio < height_ratio) { new_width = width; new_height = (size_t)(height_ * width_ratio); } else { new_width = (size_t)(width_ * height_ratio); new_height = height; } width_ = new_width; height_ = new_height; MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { MagickResizeImage(magick_wand,new_width,new_height,LanczosFilter,1.0); } }
caddr_t bif_im_ThumbnailImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; long v_size = bif_long_arg (qst, args, 2, "IM ThumbnailImageBlob"); long h_size = bif_long_arg (qst, args, 3, "IM ThumbnailImageBlob"); long filter = bif_long_arg (qst, args, 4, "IM ThumbnailImageBlob"); if (filter < 0 || filter > 15) filter = PointFilter; im_init (&env, qst, args, "IM ThumbnailImageBlob"); im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, 5, -1); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickResizeImage (env.ime_magick_wand,v_size, h_size,filter,1.0); MagickProfileImage (env.ime_magick_wand, "*", NULL, 0); } res = im_write (&env); im_leave (&env); return res; }
caddr_t bif_im_ResampleImageBlob (caddr_t * qst, caddr_t * err, state_slot_t ** args) { im_env_t env; caddr_t res; double v_size = bif_double_arg (qst, args, 2, "IM ResampleImageBlob"); double h_size = bif_double_arg (qst, args, 3, "IM ResampleImageBlob"); double blur = bif_double_arg (qst, args, 4, "IM ResampleImageBlob"); long filter = bif_long_arg (qst, args, 5, "IM ResampleImageBlob"); if (filter < 0 || filter > 15) filter = PointFilter; im_init (&env, qst, args, "IM ResampleImageBlob"); im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, 6, -1); im_read (&env); MagickResetIterator (env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { MagickResampleImage (env.ime_magick_wand,v_size, h_size,filter,blur); } res = im_write (&env); im_leave (&env); return res; }
int thumbnail (char *image_name, char *thumbnail_name, int thumb_width, int thumb_height){ MagickWand *magick_wand; MagickBooleanType status; /* Read an image. */ MagickWandGenesis(); magick_wand=NewMagickWand(); status=MagickReadImage(magick_wand, image_name); if (status == MagickFalse) ThrowWandException(magick_wand, 1); /* Turn the images into a thumbnail sequence. */ MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) MagickResizeImage(magick_wand,thumb_width,thumb_height,LanczosFilter,1.0); /* Write the image then destroy it. */ status=MagickWriteImages(magick_wand, thumbnail_name, MagickTrue); if (status == MagickFalse) ThrowWandException(magick_wand, 2); magick_wand=DestroyMagickWand(magick_wand); MagickWandTerminus(); return 0; }
int main(int argc,char **argv) { #define ThrowAPIException(wand) \ { \ description=MagickGetException(wand,&severity); \ (void) FormatLocaleFile(stderr,"%s %s %lu %s\n",GetMagickModule(), \ description); \ description=(char *) MagickRelinquishMemory(description); \ exit(-1); \ } static char CustomOption[] = "custom option", CustomProperty[] = "custom profile"; static unsigned char sRGBProfile[] = { 0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f, 0x02, 0x10, 0x00, 0x00, 0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20, 0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00, 0x61, 0x63, 0x73, 0x70, 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x48, 0x50, 0x20, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x00, 0x6c, 0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14, 0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14, 0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14, 0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c, 0x00, 0x00, 0x00, 0x14, 0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14, 0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x00, 0x70, 0x64, 0x6d, 0x64, 0x64, 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88, 0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c, 0x00, 0x00, 0x00, 0x86, 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24, 0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x14, 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24, 0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x0c, 0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c, 0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c, 0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39, 0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65, 0x74, 0x74, 0x2d, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5, 0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x62, 0x99, 0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xa0, 0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe, 0x00, 0x14, 0x5f, 0x2e, 0x00, 0x10, 0xcf, 0x14, 0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b, 0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00, 0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8f, 0x00, 0x00, 0x00, 0x02, 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00, 0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f, 0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37, 0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a, 0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e, 0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72, 0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86, 0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a, 0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae, 0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1, 0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5, 0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb, 0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01, 0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19, 0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32, 0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c, 0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67, 0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83, 0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1, 0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1, 0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1, 0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03, 0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26, 0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b, 0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71, 0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98, 0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1, 0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb, 0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43, 0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72, 0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2, 0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3, 0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06, 0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b, 0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71, 0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8, 0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1, 0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c, 0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58, 0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96, 0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5, 0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16, 0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59, 0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d, 0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3, 0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b, 0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74, 0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf, 0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b, 0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a, 0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa, 0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb, 0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f, 0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4, 0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb, 0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54, 0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae, 0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b, 0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69, 0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8, 0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a, 0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e, 0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3, 0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a, 0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3, 0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e, 0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b, 0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09, 0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a, 0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec, 0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61, 0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7, 0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f, 0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9, 0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45, 0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3, 0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43, 0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5, 0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49, 0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce, 0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56, 0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0, 0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c, 0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa, 0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89, 0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b, 0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf, 0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45, 0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd, 0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77, 0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14, 0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2, 0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52, 0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5, 0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99, 0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40, 0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9, 0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94, 0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41, 0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0, 0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1, 0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55, 0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a, 0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2, 0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c, 0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7, 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7, 0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a, 0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f, 0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06, 0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0, 0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b, 0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69, 0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39, 0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c, 0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1, 0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7, 0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91, 0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c, 0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a, 0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a, 0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d, 0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1, 0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8, 0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2, 0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae, 0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c, 0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c, 0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f, 0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74, 0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b, 0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65, 0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61, 0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60, 0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61, 0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64, 0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a, 0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72, 0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d, 0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a, 0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a, 0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab, 0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0, 0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7, 0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0, 0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c, 0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a, 0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a, 0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e, 0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93, 0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb, 0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6, 0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13, 0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42, 0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75, 0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9, 0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0, 0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a, 0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56, 0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95, 0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6, 0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a, 0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61, 0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa, 0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5, 0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43, 0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94, 0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7, 0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d, 0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96, 0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1, 0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f, 0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf, 0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12, 0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78, 0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0, 0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b, 0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8, 0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28, 0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b, 0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11, 0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89, 0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04, 0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81, 0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01, 0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84, 0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a, 0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92, 0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d, 0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab, 0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b, 0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce, 0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64, 0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc, 0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98, 0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36, 0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6, 0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a, 0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20, 0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9, 0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75, 0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24, 0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5, 0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89, 0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40, 0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa, 0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6, 0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76, 0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38, 0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd, 0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4, 0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f, 0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c, 0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d, 0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00, 0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6, 0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae, 0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a, 0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68, 0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a, 0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e, 0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15, 0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff, 0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec, 0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb, 0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce, 0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3, 0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc, 0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7, 0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5, 0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6, 0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba, 0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1, 0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb, 0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8, 0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8, 0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb, 0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10, 0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29, 0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44, 0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63, 0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84, 0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9, 0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0, 0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb, 0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28, 0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58, 0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c, 0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2, 0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb, 0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38, 0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77, 0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba, 0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff }; char *description, **options, **profiles, **properties; const char *option, *property; DrawingWand *drawing_wand; ExceptionType severity; MagickWand *clone_wand, *magick_wand; PixelIterator *iterator; PixelWand *background, *border, *fill, **pixels; register ssize_t i; unsigned char *profile; unsigned int status; size_t columns, delay, length, number_options, number_profiles, number_properties, number_wands, rows; (void) argc; (void) argv; MagickWandGenesis(); magick_wand=NewMagickWand(); (void) MagickSetSize(magick_wand,640,480); (void) MagickGetSize(magick_wand,&columns,&rows); if ((columns != 640) || (rows != 480)) { (void) FormatLocaleFile(stderr,"Unexpected magick wand size\n"); exit(1); } (void) FormatLocaleFile(stdout,"Reading images...\n"); { char *p, path[MaxTextExtent]; path[0]=0; p=getenv("SRCDIR"); if (p != (char *) NULL) { (void) strcpy(path,p); if (path[strlen(path)-1] != '/') (void) strcat(path,"/"); } (void) strcat(path,"sequence.miff"); status=MagickReadImage(magick_wand,path); } if (status == MagickFalse) ThrowAPIException(magick_wand); if (MagickGetNumberImages(magick_wand) != 5) (void) FormatLocaleFile(stderr,"read %.20g images; expected 5\n", (double) MagickGetNumberImages(magick_wand)); (void) FormatLocaleFile(stdout,"Iterate forward...\n"); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Iterate reverse...\n"); while (MagickPreviousImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Remove scene 1...\n"); (void) MagickSetIteratorIndex(magick_wand,1); clone_wand=MagickGetImage(magick_wand); status=MagickRemoveImage(magick_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Insert scene 1 back in sequence...\n"); (void) MagickSetIteratorIndex(magick_wand,0); status=MagickAddImage(magick_wand,clone_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Set scene 2 to scene 1...\n"); (void) MagickSetIteratorIndex(magick_wand,2); status=MagickSetImage(magick_wand,clone_wand); clone_wand=DestroyMagickWand(clone_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) (void) FormatLocaleFile(stdout,"index %.20g scene %.20g\n",(double) MagickGetIteratorIndex(magick_wand),(double) MagickGetImageScene(magick_wand)); (void) FormatLocaleFile(stdout,"Apply image processing options...\n"); status=MagickCropImage(magick_wand,60,60,10,10); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); background=NewPixelWand(); status=PixelSetColor(background,"#000000"); if (status == MagickFalse) ThrowAPIException(magick_wand); status=MagickRotateImage(magick_wand,background,90.0); if (status == MagickFalse) ThrowAPIException(magick_wand); border=NewPixelWand(); (void) PixelSetColor(background,"green"); (void) PixelSetColor(border,"black"); status=MagickFloodfillPaintImage(magick_wand,CompositeChannels,background, 0.01*QuantumRange,border,0,0,MagickFalse); if (status == MagickFalse) ThrowAPIException(magick_wand); background=DestroyPixelWand(background); border=DestroyPixelWand(border); drawing_wand=NewDrawingWand(); (void) PushDrawingWand(drawing_wand); (void) DrawRotate(drawing_wand,45); (void) DrawSetFontSize(drawing_wand,18); fill=NewPixelWand(); (void) PixelSetColor(fill,"green"); (void) DrawSetFillColor(drawing_wand,fill); fill=DestroyPixelWand(fill); (void) DrawAnnotation(drawing_wand,15,5,(const unsigned char *) "Magick"); (void) PopDrawingWand(drawing_wand); (void) MagickSetIteratorIndex(magick_wand,1); status=MagickDrawImage(magick_wand,drawing_wand); if (status == MagickFalse) ThrowAPIException(magick_wand); status=MagickAnnotateImage(magick_wand,drawing_wand,70,5,90,"Image"); if (status == MagickFalse) ThrowAPIException(magick_wand); drawing_wand=DestroyDrawingWand(drawing_wand); { unsigned char pixels[27], primary_colors[27] = { 0, 0, 0, 0, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 255, 255, 0, 0, 255, 0, 255, 255, 255, 0, 128, 128, 128, }; (void) MagickSetIteratorIndex(magick_wand,2); status=MagickImportImagePixels(magick_wand,10,10,3,3,"RGB",CharPixel, primary_colors); if (status == MagickFalse) ThrowAPIException(magick_wand); status=MagickExportImagePixels(magick_wand,10,10,3,3,"RGB",CharPixel, pixels); if (status == MagickFalse) ThrowAPIException(magick_wand); for (i=0; i < 9; i++) if (pixels[i] != primary_colors[i]) { (void) FormatLocaleFile(stderr, "Get pixels does not match set pixels\n"); exit(1); } } (void) MagickSetIteratorIndex(magick_wand,3); status=MagickResizeImage(magick_wand,50,50,UndefinedFilter,1.0); if (status == MagickFalse) ThrowAPIException(magick_wand); MagickResetIterator(magick_wand); while (MagickNextImage(magick_wand) != MagickFalse) { (void) MagickSetImageDepth(magick_wand,8); (void) MagickSetImageCompression(magick_wand,RLECompression); } MagickResetIterator(magick_wand); (void) MagickSetIteratorIndex(magick_wand,4); (void) FormatLocaleFile(stdout, "Utilitize pixel iterator to draw diagonal...\n"); iterator=NewPixelIterator(magick_wand); if (iterator == (PixelIterator *) NULL) ThrowAPIException(magick_wand); pixels=PixelGetNextIteratorRow(iterator,&number_wands); for (i=0; pixels != (PixelWand **) NULL; i++) { (void) PixelSetColor(pixels[i],"#224466"); (void) PixelSyncIterator(iterator); pixels=PixelGetNextIteratorRow(iterator,&number_wands); } (void) PixelSyncIterator(iterator); iterator=DestroyPixelIterator(iterator); (void) FormatLocaleFile(stdout,"Write to wandtest_out.miff...\n"); status=MagickWriteImages(magick_wand,"wandtest_out.miff",MagickTrue); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout, "Change image format from \"MIFF\" to \"GIF\"...\n"); status=MagickSetImageFormat(magick_wand,"GIF"); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout,"Set delay between frames to %d seconds...\n", WandDelay); status=MagickSetImageDelay(magick_wand,100*WandDelay); if (status == MagickFalse) ThrowAPIException(magick_wand); delay=MagickGetImageDelay(magick_wand); if (delay != (100*WandDelay)) { (void) FormatLocaleFile(stderr,"Get delay does not match set delay\n"); exit(1); } (void) FormatLocaleFile(stdout,"Write to wandtest_out_0.gif...\n"); status=MagickWriteImages(magick_wand,"wandtest_out.gif",MagickTrue); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout,"Set, list, get, and delete wand option...\n"); status=MagickSetOption(magick_wand,"wand:custom-option",CustomOption); if (status == MagickFalse) ThrowAPIException(magick_wand); option=MagickGetOption(magick_wand,"wand:custom-option"); if ((option == (const char *) NULL) || (strlen(option) != strlen(CustomOption)) || (memcmp(option,CustomOption,strlen(option)) != 0)) { (void) FormatLocaleFile(stderr,"Option does not match\n"); exit(1); } options=MagickGetOptions(magick_wand,"*",&number_options); if (options != (char **) NULL) { for (i=0; i < (ssize_t) number_options; i++) { (void) FormatLocaleFile(stdout," %s\n",options[i]); options[i]=(char *) MagickRelinquishMemory(options[i]); } options=(char **) MagickRelinquishMemory(options); } status=MagickDeleteOption(magick_wand,"wand:custom-option"); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout, "Set, list, get, and delete wand property...\n"); status=MagickSetImageProperty(magick_wand,"wand:custom-property", CustomProperty); if (status == MagickFalse) ThrowAPIException(magick_wand); property=MagickGetImageProperty(magick_wand,"wand:custom-property"); if ((property == (const char *) NULL) || (strlen(property) != strlen(CustomProperty)) || (memcmp(property,CustomProperty,strlen(property)) != 0)) { (void) FormatLocaleFile(stderr,"Property does not match\n"); exit(1); } properties=MagickGetImageProperties(magick_wand,"*",&number_properties); if (properties != (char **) NULL) { for (i=0; i < (ssize_t) number_properties; i++) { (void) FormatLocaleFile(stdout," %s\n",properties[i]); properties[i]=(char *) MagickRelinquishMemory(properties[i]); } properties=(char **) MagickRelinquishMemory(properties); } status=MagickDeleteImageProperty(magick_wand,"wand:custom-property"); if (status == MagickFalse) ThrowAPIException(magick_wand); (void) FormatLocaleFile(stdout, "Set, list, get, and remove sRGB color profile...\n"); status=MagickSetImageProfile(magick_wand,"sRGB",sRGBProfile, sizeof(sRGBProfile)); if (status == MagickFalse) ThrowAPIException(magick_wand); profile=(unsigned char *) MagickGetImageProfile(magick_wand,"sRGB",&length); if ((profile == (unsigned char *) NULL) || (length != sizeof(sRGBProfile)) || (memcmp(profile,sRGBProfile,length) != 0)) { (void) FormatLocaleFile(stderr,"Profile does not match\n"); exit(1); } profile=(unsigned char *) MagickRelinquishMemory(profile); profiles=MagickGetImageProfiles(magick_wand,"*",&number_profiles); if (profiles != (char **) NULL) { for (i=0; i < (ssize_t) number_profiles; i++) { (void) FormatLocaleFile(stdout," %s\n",profiles[i]); profiles[i]=(char *) MagickRelinquishMemory(profiles[i]); } profiles=(char **) MagickRelinquishMemory(profiles); } profile=(unsigned char *) MagickRemoveImageProfile(magick_wand,"sRGB", &length); if ((profile == (unsigned char *) NULL) || (length != sizeof(sRGBProfile)) || (memcmp(profile,sRGBProfile,length) != 0)) { (void) FormatLocaleFile(stderr,"Profile does not match\n"); exit(1); } profile=(unsigned char *) MagickRelinquishMemory(profile); magick_wand=DestroyMagickWand(magick_wand); (void) FormatLocaleFile(stdout,"Wand tests pass.\n"); return(0); }
xcolor_image_t *image_to_xterm(const char *path) { struct winsize ws; ioctl(0, TIOCGWINSZ, &ws); MagickWand *wand; MagickBooleanType status; MagickPixelPacket pixel; PixelIterator *iterator; PixelWand **pixels; MagickWandGenesis(); wand = NewMagickWand(); status = MagickReadImage(wand, path); if(status == MagickFalse) { exit(EXIT_FAILURE); } int **xterm_colors = NULL; MagickResetIterator(wand); size_t row_width = 0; size_t im_height = 0; size_t im_width = 0; size_t width = 0; size_t height = 0; while(MagickNextImage(wand) != MagickFalse) { // Get the actual width and height of the original image im_height = MagickGetImageHeight(wand); im_width = MagickGetImageWidth(wand); // Calculate the new width and height of the image width = min(im_width, (size_t) ws.ws_col); height = ((im_height * width) / im_width) / 2; MagickAdaptiveResizeImage(wand, width, height); // iterate through all the pixels iterator = NewPixelIterator(wand); if((xterm_colors = calloc(height, sizeof(int *))) == NULL) { perror("calloc"); exit(EXIT_FAILURE); } for(size_t y = 0; y < height; y++) { pixels = PixelGetNextIteratorRow(iterator, &row_width); if(pixels == (PixelWand **) NULL) { break; } if((xterm_colors[y] = calloc(row_width, sizeof(int))) == NULL) { perror("calloc"); exit(EXIT_FAILURE); } for(size_t x = 0; x < row_width; x++) { PixelGetMagickColor(pixels[x], &pixel); int xc = rgb_to_xterm((int)(pixel.red / 255) , (int)(pixel.green / 255), (int)(pixel.blue / 255)); xterm_colors[y][x] = xc; } } iterator = DestroyPixelIterator(iterator); break; } // We don't need imagemagick anymore, shut it down wand = DestroyMagickWand(wand); xcolor_image_t *xcolor_image; if((xcolor_image = malloc(sizeof(xcolor_image_t))) == NULL) { perror("malloc"); exit(EXIT_FAILURE); } xcolor_image->x = row_width; xcolor_image->y = height; xcolor_image->pixels = xterm_colors; return xcolor_image; }
caddr_t bif_im_get_impl (caddr_t * qst, caddr_t * err, state_slot_t ** args, int is_file_in, int op, const char *bifname) { im_env_t env; char *strg_value = NULL; unsigned long ul_value = 0; caddr_t res = NULL; int is_string_res = (('A' == op) || ('F' == op) || ('I' == op)); int is_list_res = ('2' == op); int is_key_needed = ('A' == op); caddr_t key = is_key_needed ? bif_string_arg (qst, args, (is_file_in ? 1 : 2), bifname) : NULL; im_init (&env, qst, args, bifname); if (is_file_in) im_env_set_filenames (&env, 0, -1); else { im_env_set_input_blob (&env, 0); im_env_set_blob_ext (&env, (is_key_needed ? 3 : 2), -1); } im_read (&env); MagickResetIterator(env.ime_magick_wand); while (MagickNextImage (env.ime_magick_wand) != MagickFalse) { switch (op) { case 'A': strg_value = MagickGetImageAttribute (env.ime_magick_wand, key); break; case 'F': strg_value = MagickGetImageFormat (env.ime_magick_wand); break; case 'I': strg_value = MagickIdentifyImage (env.ime_magick_wand); break; case 'W': ul_value = MagickGetImageWidth (env.ime_magick_wand); break; case 'H': ul_value = MagickGetImageHeight (env.ime_magick_wand); break; case 'D': ul_value = MagickGetImageDepth (env.ime_magick_wand); break; case '2': ul_value = MagickGetImageWidth (env.ime_magick_wand); if (ul_value) { dk_free_tree (res); res = dk_alloc_box (2 * sizeof (caddr_t), DV_ARRAY_OF_POINTER); ((caddr_t *)res)[0] = box_num (ul_value); ((caddr_t *)res)[1] = box_num (MagickGetImageHeight (env.ime_magick_wand)); } break; } } if (is_string_res) { if (strg_value) { res = box_dv_short_string (strg_value); MagickRelinquishMemory (strg_value); } } else if (!is_list_res) { if (ul_value) res = box_num (ul_value); } if (NULL == res) res = NEW_DB_NULL; im_leave (&env); return res; }