MagickWand 7.1.2
Convert, Edit, Or Compose Bitmap Images
Loading...
Searching...
No Matches
magick-image.c
1/*
2%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3% %
4% %
5% %
6% M M AAA GGGG IIIII CCCC K K %
7% MM MM A A G I C K K %
8% M M M AAAAA G GGG I C KKK %
9% M M A A G G I C K K %
10% M M A A GGGG IIIII CCCC K K %
11% %
12% IIIII M M AAA GGGG EEEEE %
13% I MM MM A A G E %
14% I M M M AAAAA G GG EEE %
15% I M M A A G G E %
16% IIIII M M A A GGGG EEEEE %
17% %
18% %
19% MagickWand Image Methods %
20% %
21% Software Design %
22% Cristy %
23% August 2003 %
24% %
25% %
26% Copyright @ 1999 ImageMagick Studio LLC, a non-profit organization %
27% dedicated to making software imaging solutions freely available. %
28% %
29% You may not use this file except in compliance with the License. You may %
30% obtain a copy of the License at %
31% %
32% https://imagemagick.org/script/license.php %
33% %
34% Unless required by applicable law or agreed to in writing, software %
35% distributed under the License is distributed on an "AS IS" BASIS, %
36% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
37% See the License for the specific language governing permissions and %
38% limitations under the License. %
39% %
40%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
41%
42%
43%
44*/
45␌
46/*
47 Include declarations.
48*/
49#include "MagickWand/studio.h"
50#include "MagickWand/MagickWand.h"
51#include "MagickWand/magick-wand-private.h"
52#include "MagickWand/wand.h"
53#include "MagickWand/pixel-wand-private.h"
54#include "MagickCore/image-private.h"
55#include "MagickCore/nt-base-private.h"
56␌
57/*
58 Define declarations.
59*/
60#define MagickWandId "MagickWand"
61␌
62/*
63%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
64% %
65% %
66% %
67+ C l o n e M a g i c k W a n d F r o m I m a g e s %
68% %
69% %
70% %
71%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
72%
73% CloneMagickWandFromImages() clones the magick wand and inserts a new image
74% list.
75%
76% The format of the CloneMagickWandFromImages method is:
77%
78% MagickWand *CloneMagickWandFromImages(const MagickWand *wand,
79% Image *images)
80%
81% A description of each parameter follows:
82%
83% o wand: the magick wand.
84%
85% o images: replace the image list with these image(s).
86%
87*/
88static MagickWand *CloneMagickWandFromImages(const MagickWand *wand,
89 Image *images)
90{
91 MagickWand
92 *clone_wand;
93
94 assert(wand != (MagickWand *) NULL);
95 assert(wand->signature == MagickWandSignature);
96 if (wand->debug != MagickFalse)
97 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
98 clone_wand=(MagickWand *) AcquireCriticalMemory(sizeof(*clone_wand));
99 (void) memset(clone_wand,0,sizeof(*clone_wand));
100 clone_wand->id=AcquireWandId();
101 (void) FormatLocaleString(clone_wand->name,MagickPathExtent,"%s-%.20g",
102 MagickWandId,(double) clone_wand->id);
103 clone_wand->exception=AcquireExceptionInfo();
104 InheritException(clone_wand->exception,wand->exception);
105 clone_wand->image_info=CloneImageInfo(wand->image_info);
106 clone_wand->images=images;
107 clone_wand->debug=IsEventLogging();
108 clone_wand->signature=MagickWandSignature;
109 if (clone_wand->debug != MagickFalse)
110 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",clone_wand->name);
111 return(clone_wand);
112}
113␌
114/*
115%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
116% %
117% %
118% %
119% G e t I m a g e F r o m M a g i c k W a n d %
120% %
121% %
122% %
123%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
124%
125% GetImageFromMagickWand() returns the current image from the magick wand.
126%
127% The format of the GetImageFromMagickWand method is:
128%
129% Image *GetImageFromMagickWand(const MagickWand *wand)
130%
131% A description of each parameter follows:
132%
133% o wand: the magick wand.
134%
135*/
136WandExport Image *GetImageFromMagickWand(const MagickWand *wand)
137{
138 assert(wand != (MagickWand *) NULL);
139 assert(wand->signature == MagickWandSignature);
140 if (wand->debug != MagickFalse)
141 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
142 if (wand->images == (Image *) NULL)
143 {
144 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
145 "ContainsNoImages","`%s'",wand->name);
146 return((Image *) NULL);
147 }
148 return(wand->images);
149}
150␌
151/*
152%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
153% %
154% %
155% %
156% M a g i c k A d a p t i v e B l u r I m a g e %
157% %
158% %
159% %
160%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
161%
162% MagickAdaptiveBlurImage() adaptively blurs the image by blurring
163% less intensely near image edges and more intensely far from edges. We
164% blur the image with a Gaussian operator of the given radius and standard
165% deviation (sigma). For reasonable results, radius should be larger than
166% sigma. Use a radius of 0 and MagickAdaptiveBlurImage() selects a
167% suitable radius for you.
168%
169% The format of the MagickAdaptiveBlurImage method is:
170%
171% MagickBooleanType MagickAdaptiveBlurImage(MagickWand *wand,
172% const double radius,const double sigma)
173%
174% A description of each parameter follows:
175%
176% o wand: the magick wand.
177%
178% o radius: the radius of the Gaussian, in pixels, not counting the center
179% pixel.
180%
181% o sigma: the standard deviation of the Gaussian, in pixels.
182%
183*/
184WandExport MagickBooleanType MagickAdaptiveBlurImage(MagickWand *wand,
185 const double radius,const double sigma)
186{
187 Image
188 *sharp_image;
189
190 assert(wand != (MagickWand *) NULL);
191 assert(wand->signature == MagickWandSignature);
192 if (wand->debug != MagickFalse)
193 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
194 if (wand->images == (Image *) NULL)
195 ThrowWandException(WandError,"ContainsNoImages",wand->name);
196 sharp_image=AdaptiveBlurImage(wand->images,radius,sigma,wand->exception);
197 if (sharp_image == (Image *) NULL)
198 return(MagickFalse);
199 ReplaceImageInList(&wand->images,sharp_image);
200 return(MagickTrue);
201}
202␌
203/*
204%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
205% %
206% %
207% %
208% M a g i c k A d a p t i v e R e s i z e I m a g e %
209% %
210% %
211% %
212%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
213%
214% MagickAdaptiveResizeImage() adaptively resize image with data dependent
215% triangulation.
216%
217% MagickBooleanType MagickAdaptiveResizeImage(MagickWand *wand,
218% const size_t columns,const size_t rows)
219%
220% A description of each parameter follows:
221%
222% o wand: the magick wand.
223%
224% o columns: the number of columns in the scaled image.
225%
226% o rows: the number of rows in the scaled image.
227%
228*/
229WandExport MagickBooleanType MagickAdaptiveResizeImage(MagickWand *wand,
230 const size_t columns,const size_t rows)
231{
232 Image
233 *resize_image;
234
235 assert(wand != (MagickWand *) NULL);
236 assert(wand->signature == MagickWandSignature);
237 if (wand->debug != MagickFalse)
238 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
239 if (wand->images == (Image *) NULL)
240 ThrowWandException(WandError,"ContainsNoImages",wand->name);
241 resize_image=AdaptiveResizeImage(wand->images,columns,rows,wand->exception);
242 if (resize_image == (Image *) NULL)
243 return(MagickFalse);
244 ReplaceImageInList(&wand->images,resize_image);
245 return(MagickTrue);
246}
247␌
248/*
249%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
250% %
251% %
252% %
253% M a g i c k A d a p t i v e S h a r p e n I m a g e %
254% %
255% %
256% %
257%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
258%
259% MagickAdaptiveSharpenImage() adaptively sharpens the image by sharpening
260% more intensely near image edges and less intensely far from edges. We
261% sharpen the image with a Gaussian operator of the given radius and standard
262% deviation (sigma). For reasonable results, radius should be larger than
263% sigma. Use a radius of 0 and MagickAdaptiveSharpenImage() selects a
264% suitable radius for you.
265%
266% The format of the MagickAdaptiveSharpenImage method is:
267%
268% MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *wand,
269% const double radius,const double sigma)
270%
271% A description of each parameter follows:
272%
273% o wand: the magick wand.
274%
275% o radius: the radius of the Gaussian, in pixels, not counting the center
276% pixel.
277%
278% o sigma: the standard deviation of the Gaussian, in pixels.
279%
280*/
281WandExport MagickBooleanType MagickAdaptiveSharpenImage(MagickWand *wand,
282 const double radius,const double sigma)
283{
284 Image
285 *sharp_image;
286
287 assert(wand != (MagickWand *) NULL);
288 assert(wand->signature == MagickWandSignature);
289 if (wand->debug != MagickFalse)
290 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
291 if (wand->images == (Image *) NULL)
292 ThrowWandException(WandError,"ContainsNoImages",wand->name);
293 sharp_image=AdaptiveSharpenImage(wand->images,radius,sigma,wand->exception);
294 if (sharp_image == (Image *) NULL)
295 return(MagickFalse);
296 ReplaceImageInList(&wand->images,sharp_image);
297 return(MagickTrue);
298}
299␌
300/*
301%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
302% %
303% %
304% %
305% M a g i c k A d a p t i v e T h r e s h o l d I m a g e %
306% %
307% %
308% %
309%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
310%
311% MagickAdaptiveThresholdImage() selects an individual threshold for each pixel
312% based on the range of intensity values in its local neighborhood. This
313% allows for thresholding of an image whose global intensity histogram
314% doesn't contain distinctive peaks.
315%
316% The format of the AdaptiveThresholdImage method is:
317%
318% MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *wand,
319% const size_t width,const size_t height,const double bias)
320%
321% A description of each parameter follows:
322%
323% o wand: the magick wand.
324%
325% o width: the width of the local neighborhood.
326%
327% o height: the height of the local neighborhood.
328%
329% o offset: the mean bias.
330%
331*/
332WandExport MagickBooleanType MagickAdaptiveThresholdImage(MagickWand *wand,
333 const size_t width,const size_t height,const double bias)
334{
335 Image
336 *threshold_image;
337
338 assert(wand != (MagickWand *) NULL);
339 assert(wand->signature == MagickWandSignature);
340 if (wand->debug != MagickFalse)
341 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
342 if (wand->images == (Image *) NULL)
343 ThrowWandException(WandError,"ContainsNoImages",wand->name);
344 threshold_image=AdaptiveThresholdImage(wand->images,width,height,bias,
345 wand->exception);
346 if (threshold_image == (Image *) NULL)
347 return(MagickFalse);
348 ReplaceImageInList(&wand->images,threshold_image);
349 return(MagickTrue);
350}
351␌
352/*
353%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
354% %
355% %
356% %
357% M a g i c k A d d I m a g e %
358% %
359% %
360% %
361%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
362%
363% MagickAddImage() adds a clone of the images from the second wand and
364% inserts them into the first wand.
365%
366% Use MagickSetLastIterator(), to append new images into an existing wand,
367% current image will be set to last image so later adds with also be
368% appended to end of wand.
369%
370% Use MagickSetFirstIterator() to prepend new images into wand, any more
371% images added will also be prepended before other images in the wand.
372% However the order of a list of new images will not change.
373%
374% Otherwise the new images will be inserted just after the current image,
375% and any later image will also be added after this current image but
376% before the previously added images. Caution is advised when multiple
377% image adds are inserted into the middle of the wand image list.
378%
379% The format of the MagickAddImage method is:
380%
381% MagickBooleanType MagickAddImage(MagickWand *wand,
382% const MagickWand *add_wand)
383%
384% A description of each parameter follows:
385%
386% o wand: the magick wand.
387%
388% o add_wand: A wand that contains the image list to be added
389%
390*/
391static inline MagickBooleanType InsertImageInWand(MagickWand *wand,
392 Image *images)
393{
394 if (wand->images == (Image *) NULL)
395 {
396 /*
397 No images in wand, just add them, set current as appropriate.
398 */
399 if (wand->insert_before != MagickFalse)
400 wand->images=GetFirstImageInList(images);
401 else
402 wand->images=GetLastImageInList(images);
403 return(MagickTrue);
404 }
405 if ((wand->insert_before != MagickFalse) &&
406 (wand->images->previous == (Image *) NULL))
407 {
408 /*
409 User jumped to first image, so prepend new images - remain active.
410 */
411 PrependImageToList(&wand->images,images);
412 wand->images=GetFirstImageInList(images);
413 return(MagickTrue);
414 }
415 /*
416 Note you should never have 'insert_before' true when current image is not
417 the first image in the wand! That is no insert before current image, only
418 after current image.
419 */
420 if (wand->images->next == (Image *) NULL)
421 {
422 /*
423 At last image, append new images.
424 */
425 InsertImageInList(&wand->images,images);
426 wand->images=GetLastImageInList(images);
427 return(MagickTrue);
428 }
429 /*
430 Insert new images, just after the current image.
431 */
432 InsertImageInList(&wand->images,images);
433 return(MagickTrue);
434}
435
436WandExport MagickBooleanType MagickAddImage(MagickWand *wand,
437 const MagickWand *add_wand)
438{
439 Image
440 *images;
441
442 assert(wand != (MagickWand *) NULL);
443 assert(wand->signature == MagickWandSignature);
444 if (wand->debug != MagickFalse)
445 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
446 assert(add_wand != (MagickWand *) NULL);
447 assert(add_wand->signature == MagickWandSignature);
448 if (add_wand->images == (Image *) NULL)
449 ThrowWandException(WandError,"ContainsNoImages",add_wand->name);
450 /*
451 Clone images in second wand, and insert into first.
452 */
453 images=CloneImageList(add_wand->images,wand->exception);
454 if (images == (Image *) NULL)
455 return(MagickFalse);
456 return(InsertImageInWand(wand,images));
457}
458␌
459/*
460%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
461% %
462% %
463% %
464% M a g i c k A d d N o i s e I m a g e %
465% %
466% %
467% %
468%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
469%
470% MagickAddNoiseImage() adds random noise to the image.
471%
472% The format of the MagickAddNoiseImage method is:
473%
474% MagickBooleanType MagickAddNoiseImage(MagickWand *wand,
475% const NoiseType noise_type,const double attenuate)
476%
477% A description of each parameter follows:
478%
479% o wand: the magick wand.
480%
481% o noise_type: The type of noise: Uniform, Gaussian, Multiplicative,
482% Impulse, Laplacian, or Poisson.
483%
484% o attenuate: attenuate the random distribution.
485%
486*/
487WandExport MagickBooleanType MagickAddNoiseImage(MagickWand *wand,
488 const NoiseType noise_type,const double attenuate)
489{
490 Image
491 *noise_image;
492
493 assert(wand != (MagickWand *) NULL);
494 assert(wand->signature == MagickWandSignature);
495 if (wand->debug != MagickFalse)
496 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
497 if (wand->images == (Image *) NULL)
498 ThrowWandException(WandError,"ContainsNoImages",wand->name);
499 noise_image=AddNoiseImage(wand->images,noise_type,attenuate,wand->exception);
500 if (noise_image == (Image *) NULL)
501 return(MagickFalse);
502 ReplaceImageInList(&wand->images,noise_image);
503 return(MagickTrue);
504}
505␌
506/*
507%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
508% %
509% %
510% %
511% M a g i c k A f f i n e T r a n s f o r m I m a g e %
512% %
513% %
514% %
515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
516%
517% MagickAffineTransformImage() transforms an image as dictated by the affine
518% matrix of the drawing wand.
519%
520% The format of the MagickAffineTransformImage method is:
521%
522% MagickBooleanType MagickAffineTransformImage(MagickWand *wand,
523% const DrawingWand *drawing_wand)
524%
525% A description of each parameter follows:
526%
527% o wand: the magick wand.
528%
529% o drawing_wand: the draw wand.
530%
531*/
532WandExport MagickBooleanType MagickAffineTransformImage(MagickWand *wand,
533 const DrawingWand *drawing_wand)
534{
535 DrawInfo
536 *draw_info;
537
538 Image
539 *affine_image;
540
541 assert(wand != (MagickWand *) NULL);
542 assert(wand->signature == MagickWandSignature);
543 if (wand->debug != MagickFalse)
544 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
545 if (wand->images == (Image *) NULL)
546 ThrowWandException(WandError,"ContainsNoImages",wand->name);
547 draw_info=PeekDrawingWand(drawing_wand);
548 if (draw_info == (DrawInfo *) NULL)
549 return(MagickFalse);
550 affine_image=AffineTransformImage(wand->images,&draw_info->affine,
551 wand->exception);
552 draw_info=DestroyDrawInfo(draw_info);
553 if (affine_image == (Image *) NULL)
554 return(MagickFalse);
555 ReplaceImageInList(&wand->images,affine_image);
556 return(MagickTrue);
557}
558␌
559/*
560%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
561% %
562% %
563% %
564% M a g i c k A n n o t a t e I m a g e %
565% %
566% %
567% %
568%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
569%
570% MagickAnnotateImage() annotates an image with text.
571%
572% The format of the MagickAnnotateImage method is:
573%
574% MagickBooleanType MagickAnnotateImage(MagickWand *wand,
575% const DrawingWand *drawing_wand,const double x,const double y,
576% const double angle,const char *text)
577%
578% A description of each parameter follows:
579%
580% o wand: the magick wand.
581%
582% o drawing_wand: the draw wand.
583%
584% o x: x ordinate to left of text
585%
586% o y: y ordinate to text baseline
587%
588% o angle: rotate text relative to this angle.
589%
590% o text: text to draw
591%
592*/
593WandExport MagickBooleanType MagickAnnotateImage(MagickWand *wand,
594 const DrawingWand *drawing_wand,const double x,const double y,
595 const double angle,const char *text)
596{
597 char
598 geometry[MagickPathExtent];
599
600 DrawInfo
601 *draw_info;
602
603 MagickBooleanType
604 status;
605
606 assert(wand != (MagickWand *) NULL);
607 assert(wand->signature == MagickWandSignature);
608 if (wand->debug != MagickFalse)
609 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
610 if (wand->images == (Image *) NULL)
611 ThrowWandException(WandError,"ContainsNoImages",wand->name);
612 draw_info=PeekDrawingWand(drawing_wand);
613 if (draw_info == (DrawInfo *) NULL)
614 return(MagickFalse);
615 (void) CloneString(&draw_info->text,text);
616 (void) FormatLocaleString(geometry,MagickPathExtent,"%+g%+g",x,y);
617 draw_info->affine.sx=cos((double) DegreesToRadians(fmod(angle,360.0)));
618 draw_info->affine.rx=sin((double) DegreesToRadians(fmod(angle,360.0)));
619 draw_info->affine.ry=(-sin((double) DegreesToRadians(fmod(angle,360.0))));
620 draw_info->affine.sy=cos((double) DegreesToRadians(fmod(angle,360.0)));
621 (void) CloneString(&draw_info->geometry,geometry);
622 status=AnnotateImage(wand->images,draw_info,wand->exception);
623 draw_info=DestroyDrawInfo(draw_info);
624 return(status);
625}
626␌
627/*
628%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
629% %
630% %
631% %
632% M a g i c k A n i m a t e I m a g e s %
633% %
634% %
635% %
636%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
637%
638% MagickAnimateImages() animates an image or image sequence.
639%
640% The format of the MagickAnimateImages method is:
641%
642% MagickBooleanType MagickAnimateImages(MagickWand *wand,
643% const char *server_name)
644%
645% A description of each parameter follows:
646%
647% o wand: the magick wand.
648%
649% o server_name: the X server name.
650%
651*/
652WandExport MagickBooleanType MagickAnimateImages(MagickWand *wand,
653 const char *server_name)
654{
655 MagickBooleanType
656 status;
657
658 assert(wand != (MagickWand *) NULL);
659 assert(wand->signature == MagickWandSignature);
660 if (wand->debug != MagickFalse)
661 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
662 (void) CloneString(&wand->image_info->server_name,server_name);
663 status=AnimateImages(wand->image_info,wand->images,wand->exception);
664 return(status);
665}
666␌
667/*
668%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
669% %
670% %
671% %
672% M a g i c k A p p e n d I m a g e s %
673% %
674% %
675% %
676%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
677%
678% MagickAppendImages() append the images in a wand from the current image
679% onwards, creating a new wand with the single image result. This is
680% affected by the gravity and background settings of the first image.
681%
682% Typically you would call either MagickResetIterator() or
683% MagickSetFirstImage() before calling this function to ensure that all
684% the images in the wand's image list will be appended together.
685%
686% The format of the MagickAppendImages method is:
687%
688% MagickWand *MagickAppendImages(MagickWand *wand,
689% const MagickBooleanType stack)
690%
691% A description of each parameter follows:
692%
693% o wand: the magick wand.
694%
695% o stack: By default, images are stacked left-to-right. Set stack to
696% MagickTrue to stack them top-to-bottom.
697%
698*/
699WandExport MagickWand *MagickAppendImages(MagickWand *wand,
700 const MagickBooleanType stack)
701{
702 Image
703 *append_image;
704
705 assert(wand != (MagickWand *) NULL);
706 assert(wand->signature == MagickWandSignature);
707 if (wand->debug != MagickFalse)
708 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
709 if (wand->images == (Image *) NULL)
710 return((MagickWand *) NULL);
711 append_image=AppendImages(wand->images,stack,wand->exception);
712 if (append_image == (Image *) NULL)
713 return((MagickWand *) NULL);
714 return(CloneMagickWandFromImages(wand,append_image));
715}
716␌
717/*
718%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
719% %
720% %
721% %
722% M a g i c k A u t o G a m m a I m a g e %
723% %
724% %
725% %
726%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
727%
728% MagickAutoGammaImage() extracts the 'mean' from the image and adjust the
729% image to try make set its gamma appropriately.
730%
731% The format of the MagickAutoGammaImage method is:
732%
733% MagickBooleanType MagickAutoGammaImage(MagickWand *wand)
734%
735% A description of each parameter follows:
736%
737% o wand: the magick wand.
738%
739*/
740WandExport MagickBooleanType MagickAutoGammaImage(MagickWand *wand)
741{
742 MagickBooleanType
743 status;
744
745 assert(wand != (MagickWand *) NULL);
746 assert(wand->signature == MagickWandSignature);
747 if (wand->debug != MagickFalse)
748 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
749 if (wand->images == (Image *) NULL)
750 ThrowWandException(WandError,"ContainsNoImages",wand->name);
751 status=AutoGammaImage(wand->images,wand->exception);
752 return(status);
753}
754␌
755/*
756%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
757% %
758% %
759% %
760% M a g i c k A u t o L e v e l I m a g e %
761% %
762% %
763% %
764%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
765%
766% MagickAutoLevelImage() adjusts the levels of a particular image channel by
767% scaling the minimum and maximum values to the full quantum range.
768%
769% The format of the MagickAutoLevelImage method is:
770%
771% MagickBooleanType MagickAutoLevelImage(MagickWand *wand)
772%
773% A description of each parameter follows:
774%
775% o wand: the magick wand.
776%
777*/
778WandExport MagickBooleanType MagickAutoLevelImage(MagickWand *wand)
779{
780 MagickBooleanType
781 status;
782
783 assert(wand != (MagickWand *) NULL);
784 assert(wand->signature == MagickWandSignature);
785 if (wand->debug != MagickFalse)
786 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
787 if (wand->images == (Image *) NULL)
788 ThrowWandException(WandError,"ContainsNoImages",wand->name);
789 status=AutoLevelImage(wand->images,wand->exception);
790 return(status);
791}
792
793/*
794%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
795% %
796% %
797% %
798% M a g i c k A u t o O r i e n t I m a g e %
799% %
800% %
801% %
802%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
803%
804% MagickAutoOrientImage() adjusts an image so that its orientation is suitable
805$ for viewing (i.e. top-left orientation).
806%
807% The format of the MagickAutoOrientImage method is:
808%
809% MagickBooleanType MagickAutoOrientImage(MagickWand *image)
810%
811% A description of each parameter follows:
812%
813% o wand: the magick wand.
814%
815*/
816WandExport MagickBooleanType MagickAutoOrientImage(MagickWand *wand)
817{
818
819 Image
820 *orient_image;
821
822 assert(wand != (MagickWand *) NULL);
823 assert(wand->signature == MagickWandSignature);
824 if (wand->debug != MagickFalse)
825 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
826 if (wand->images == (Image *) NULL)
827 ThrowWandException(WandError,"ContainsNoImages",wand->name);
828 orient_image=AutoOrientImage(wand->images,wand->images->orientation,
829 wand->exception);
830 if (orient_image == (Image *) NULL)
831 return(MagickFalse);
832 ReplaceImageInList(&wand->images,orient_image);
833 return(MagickTrue);
834}
835␌
836/*
837%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
838% %
839% %
840% %
841% M a g i c k A u t o T h r e s h o l d I m a g e %
842% %
843% %
844% %
845%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
846%
847% MagickAutoThresholdImage() automatically performs image thresholding
848% dependent on which method you specify.
849%
850% The format of the AutoThresholdImage method is:
851%
852% MagickBooleanType MagickAutoThresholdImage(MagickWand *wand,
853% const AutoThresholdMethod method)
854%
855% A description of each parameter follows:
856%
857% o wand: the magick wand.
858%
859% o method: choose from KapurThresholdMethod, OTSUThresholdMethod, or
860% TriangleThresholdMethod.
861%
862*/
863WandExport MagickBooleanType MagickAutoThresholdImage(MagickWand *wand,
864 const AutoThresholdMethod method)
865{
866 assert(wand != (MagickWand *) NULL);
867 assert(wand->signature == MagickWandSignature);
868 if (wand->debug != MagickFalse)
869 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
870 if (wand->images == (Image *) NULL)
871 ThrowWandException(WandError,"ContainsNoImages",wand->name);
872 return(AutoThresholdImage(wand->images,method,wand->exception));
873}
874␌
875/*
876%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
877% %
878% %
879% %
880% M a g i c k B i l a t e r a l B l u r I m a g e %
881% %
882% %
883% %
884%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
885%
886% MagickBilateralBlurImage() is a non-linear, edge-preserving, and
887% noise-reducing smoothing filter for images. It replaces the intensity of
888% each pixel with a weighted average of intensity values from nearby pixels.
889% This weight is based on a Gaussian distribution. The weights depend not
890% only on Euclidean distance of pixels, but also on the radiometric
891% differences (e.g., range differences, such as color intensity, depth
892% distance, etc.). This preserves sharp edges.
893%
894% The format of the MagickBilateralBlurImage method is:
895%
896% MagickBooleanType MagickBilateralBlurImage(MagickWand *wand,
897% const double radius,const double sigma,const double intensity_sigma,
898% const double spatial_sigma)
899%
900% A description of each parameter follows:
901%
902% o wand: the magick wand.
903%
904% o radius: the radius of the Gaussian, in pixels, not counting the center
905% pixel.
906%
907% o sigma: the standard deviation of the , in pixels.
908%
909% o intensity_sigma: sigma in the intensity space. A larger value means
910% that farther colors within the pixel neighborhood (see spatial_sigma)
911% will be mixed together, resulting in larger areas of semi-equal color.
912%
913% o spatial_sigma: sigma in the coordinate space. A larger value means that
914% farther pixels influence each other as long as their colors are close
915% enough (see intensity_sigma ). When the neighborhood diameter is greater
916% than zero, it specifies the neighborhood size regardless of
917% spatial_sigma. Otherwise, the neighborhood diameter is proportional to
918% spatial_sigma.
919%
920*/
921WandExport MagickBooleanType MagickBilateralBlurImage(MagickWand *wand,
922 const double radius,const double sigma,const double intensity_sigma,
923 const double spatial_sigma)
924{
925 Image
926 *blur_image;
927
928 assert(wand != (MagickWand *) NULL);
929 assert(wand->signature == MagickWandSignature);
930 if (wand->debug != MagickFalse)
931 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
932 if (wand->images == (Image *) NULL)
933 ThrowWandException(WandError,"ContainsNoImages",wand->name);
934 blur_image=BilateralBlurImage(wand->images,(size_t) radius,(size_t) sigma,
935 intensity_sigma,spatial_sigma,wand->exception);
936 if (blur_image == (Image *) NULL)
937 return(MagickFalse);
938 ReplaceImageInList(&wand->images,blur_image);
939 return(MagickTrue);
940}
941␌
942/*
943%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
944% %
945% %
946% %
947% M a g i c k B l a c k T h r e s h o l d I m a g e %
948% %
949% %
950% %
951%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
952%
953% MagickBlackThresholdImage() is like MagickThresholdImage() but forces all
954% pixels below the threshold into black while leaving all pixels above the
955% threshold unchanged.
956%
957% The format of the MagickBlackThresholdImage method is:
958%
959% MagickBooleanType MagickBlackThresholdImage(MagickWand *wand,
960% const PixelWand *threshold)
961%
962% A description of each parameter follows:
963%
964% o wand: the magick wand.
965%
966% o threshold: the pixel wand.
967%
968*/
969WandExport MagickBooleanType MagickBlackThresholdImage(MagickWand *wand,
970 const PixelWand *threshold)
971{
972 char
973 thresholds[MagickPathExtent];
974
975 assert(wand != (MagickWand *) NULL);
976 assert(wand->signature == MagickWandSignature);
977 if (wand->debug != MagickFalse)
978 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
979 if (wand->images == (Image *) NULL)
980 ThrowWandException(WandError,"ContainsNoImages",wand->name);
981 (void) FormatLocaleString(thresholds,MagickPathExtent,
982 "%g" "," "%g" "," "%g" "," "%g",
983 (double) PixelGetRedQuantum(threshold),
984 (double) PixelGetGreenQuantum(threshold),
985 (double) PixelGetBlueQuantum(threshold),
986 (double) PixelGetAlphaQuantum(threshold));
987 return(BlackThresholdImage(wand->images,thresholds,wand->exception));
988}
989␌
990/*
991%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
992% %
993% %
994% %
995% M a g i c k B l u e S h i f t I m a g e %
996% %
997% %
998% %
999%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1000%
1001% MagickBlueShiftImage() mutes the colors of the image to simulate a scene at
1002% nighttime in the moonlight.
1003%
1004% The format of the MagickBlueShiftImage method is:
1005%
1006% MagickBooleanType MagickBlueShiftImage(MagickWand *wand,
1007% const double factor)
1008%
1009% A description of each parameter follows:
1010%
1011% o wand: the magick wand.
1012%
1013% o factor: the blue shift factor (default 1.5)
1014%
1015*/
1016WandExport MagickBooleanType MagickBlueShiftImage(MagickWand *wand,
1017 const double factor)
1018{
1019 Image
1020 *shift_image;
1021
1022 assert(wand != (MagickWand *) NULL);
1023 assert(wand->signature == MagickWandSignature);
1024 if (wand->debug != MagickFalse)
1025 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1026 if (wand->images == (Image *) NULL)
1027 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1028 shift_image=BlueShiftImage(wand->images,factor,wand->exception);
1029 if (shift_image == (Image *) NULL)
1030 return(MagickFalse);
1031 ReplaceImageInList(&wand->images,shift_image);
1032 return(MagickTrue);
1033}
1034␌
1035/*
1036%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1037% %
1038% %
1039% %
1040% M a g i c k B l u r I m a g e %
1041% %
1042% %
1043% %
1044%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1045%
1046% MagickBlurImage() blurs an image. We convolve the image with a
1047% gaussian operator of the given radius and standard deviation (sigma).
1048% For reasonable results, the radius should be larger than sigma. Use a
1049% radius of 0 and BlurImage() selects a suitable radius for you.
1050%
1051% The format of the MagickBlurImage method is:
1052%
1053% MagickBooleanType MagickBlurImage(MagickWand *wand,const double radius,
1054% const double sigma)
1055%
1056% A description of each parameter follows:
1057%
1058% o wand: the magick wand.
1059%
1060% o radius: the radius of the Gaussian, in pixels, not counting the center
1061% pixel.
1062%
1063% o sigma: the standard deviation of the , in pixels.
1064%
1065*/
1066WandExport MagickBooleanType MagickBlurImage(MagickWand *wand,
1067 const double radius,const double sigma)
1068{
1069 Image
1070 *blur_image;
1071
1072 assert(wand != (MagickWand *) NULL);
1073 assert(wand->signature == MagickWandSignature);
1074 if (wand->debug != MagickFalse)
1075 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1076 if (wand->images == (Image *) NULL)
1077 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1078 blur_image=BlurImage(wand->images,radius,sigma,wand->exception);
1079 if (blur_image == (Image *) NULL)
1080 return(MagickFalse);
1081 ReplaceImageInList(&wand->images,blur_image);
1082 return(MagickTrue);
1083}
1084␌
1085/*
1086%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1087% %
1088% %
1089% %
1090% M a g i c k B o r d e r I m a g e %
1091% %
1092% %
1093% %
1094%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1095%
1096% MagickBorderImage() surrounds the image with a border of the color defined
1097% by the bordercolor pixel wand.
1098%
1099% The format of the MagickBorderImage method is:
1100%
1101% MagickBooleanType MagickBorderImage(MagickWand *wand,
1102% const PixelWand *bordercolor,const size_t width,
1103% const size_t height,const CompositeOperator compose)
1104%
1105% A description of each parameter follows:
1106%
1107% o wand: the magick wand.
1108%
1109% o bordercolor: the border color pixel wand.
1110%
1111% o width: the border width.
1112%
1113% o height: the border height.
1114%
1115% o compose: the composite operator.
1116%
1117*/
1118WandExport MagickBooleanType MagickBorderImage(MagickWand *wand,
1119 const PixelWand *bordercolor,const size_t width,const size_t height,
1120 const CompositeOperator compose)
1121{
1122 Image
1123 *border_image;
1124
1125 RectangleInfo
1126 border_info;
1127
1128 assert(wand != (MagickWand *) NULL);
1129 assert(wand->signature == MagickWandSignature);
1130 if (wand->debug != MagickFalse)
1131 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1132 if (wand->images == (Image *) NULL)
1133 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1134 border_info.width=width;
1135 border_info.height=height;
1136 border_info.x=0;
1137 border_info.y=0;
1138 PixelGetQuantumPacket(bordercolor,&wand->images->border_color);
1139 border_image=BorderImage(wand->images,&border_info,compose,wand->exception);
1140 if (border_image == (Image *) NULL)
1141 return(MagickFalse);
1142 ReplaceImageInList(&wand->images,border_image);
1143 return(MagickTrue);
1144}
1145␌
1146/*
1147%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1148% %
1149% %
1150% %
1151% M a g i c k B r i g h t n e s s C o n t r a s t S t r e t c h I m a g e %
1152% %
1153% %
1154% %
1155%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1156%
1157% Use MagickBrightnessContrastImage() to change the brightness and/or contrast
1158% of an image. It converts the brightness and contrast parameters into slope
1159% and intercept and calls a polynomial function to apply to the image.
1160
1161%
1162% The format of the MagickBrightnessContrastImage method is:
1163%
1164% MagickBooleanType MagickBrightnessContrastImage(MagickWand *wand,
1165% const double brightness,const double contrast)
1166%
1167% A description of each parameter follows:
1168%
1169% o wand: the magick wand.
1170%
1171% o brightness: the brightness percent (-100 .. 100).
1172%
1173% o contrast: the contrast percent (-100 .. 100).
1174%
1175*/
1176WandExport MagickBooleanType MagickBrightnessContrastImage(
1177 MagickWand *wand,const double brightness,const double contrast)
1178{
1179 MagickBooleanType
1180 status;
1181
1182 assert(wand != (MagickWand *) NULL);
1183 assert(wand->signature == MagickWandSignature);
1184 if (wand->debug != MagickFalse)
1185 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1186 if (wand->images == (Image *) NULL)
1187 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1188 status=BrightnessContrastImage(wand->images,brightness,contrast,
1189 wand->exception);
1190 return(status);
1191}
1192␌
1193/*
1194%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1195% %
1196% %
1197% %
1198% M a g i c k C a n n y E d g e I m a g e %
1199% %
1200% %
1201% %
1202%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1203%
1204% MagickCannyEdgeImage() uses a multi-stage algorithm to detect a wide range of
1205% edges in images.
1206%
1207% The format of the MagickCannyEdgeImage method is:
1208%
1209% MagickBooleanType MagickCannyEdgeImage(MagickWand *wand,
1210% const double radius,const double sigma,const double lower_percent,
1211% const double upper_percent)
1212%
1213% A description of each parameter follows:
1214%
1215% o wand: the magick wand.
1216%
1217% o radius: the radius of the gaussian smoothing filter.
1218%
1219% o sigma: the sigma of the gaussian smoothing filter.
1220%
1221% o lower_percent: percentage of edge pixels in the lower threshold.
1222%
1223% o upper_percent: percentage of edge pixels in the upper threshold.
1224%
1225*/
1226WandExport MagickBooleanType MagickCannyEdgeImage(MagickWand *wand,
1227 const double radius,const double sigma,const double lower_percent,
1228 const double upper_percent)
1229{
1230 Image
1231 *edge_image;
1232
1233 assert(wand != (MagickWand *) NULL);
1234 assert(wand->signature == MagickWandSignature);
1235 if (wand->debug != MagickFalse)
1236 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1237 if (wand->images == (Image *) NULL)
1238 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1239 edge_image=CannyEdgeImage(wand->images,radius,sigma,lower_percent,
1240 upper_percent,wand->exception);
1241 if (edge_image == (Image *) NULL)
1242 return(MagickFalse);
1243 ReplaceImageInList(&wand->images,edge_image);
1244 return(MagickTrue);
1245}
1246␌
1247/*
1248%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1249% %
1250% %
1251% %
1252% M a g i c k C h a n n e l F x I m a g e %
1253% %
1254% %
1255% %
1256%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1257%
1258% MagickChannelFxImage() applies a channel expression to the specified image.
1259% The expression consists of one or more channels, either mnemonic or numeric
1260% (e.g. red, 1), separated by actions as follows:
1261%
1262% <=> exchange two channels (e.g. red<=>blue)
1263% => transfer a channel to another (e.g. red=>green)
1264% , separate channel operations (e.g. red, green)
1265% | read channels from next input image (e.g. red | green)
1266% ; write channels to next output image (e.g. red; green; blue)
1267%
1268% A channel without a operation symbol implies extract. For example, to create
1269% 3 grayscale images from the red, green, and blue channels of an image, use:
1270%
1271% -channel-fx "red; green; blue"
1272%
1273% The format of the MagickChannelFxImage method is:
1274%
1275% MagickWand *MagickChannelFxImage(MagickWand *wand,const char *expression)
1276%
1277% A description of each parameter follows:
1278%
1279% o wand: the magick wand.
1280%
1281% o expression: the expression.
1282%
1283*/
1284WandExport MagickWand *MagickChannelFxImage(MagickWand *wand,
1285 const char *expression)
1286{
1287 Image
1288 *fx_image;
1289
1290 assert(wand != (MagickWand *) NULL);
1291 assert(wand->signature == MagickWandSignature);
1292 if (wand->debug != MagickFalse)
1293 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1294 if (wand->images == (Image *) NULL)
1295 return((MagickWand *) NULL);
1296 fx_image=ChannelFxImage(wand->images,expression,wand->exception);
1297 if (fx_image == (Image *) NULL)
1298 return((MagickWand *) NULL);
1299 return(CloneMagickWandFromImages(wand,fx_image));
1300}
1301␌
1302/*
1303%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1304% %
1305% %
1306% %
1307% M a g i c k C h a r c o a l I m a g e %
1308% %
1309% %
1310% %
1311%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1312%
1313% MagickCharcoalImage() simulates a charcoal drawing.
1314%
1315% The format of the MagickCharcoalImage method is:
1316%
1317% MagickBooleanType MagickCharcoalImage(MagickWand *wand,
1318% const double radius,const double sigma)
1319%
1320% A description of each parameter follows:
1321%
1322% o wand: the magick wand.
1323%
1324% o radius: the radius of the Gaussian, in pixels, not counting the center
1325% pixel.
1326%
1327% o sigma: the standard deviation of the Gaussian, in pixels.
1328%
1329*/
1330WandExport MagickBooleanType MagickCharcoalImage(MagickWand *wand,
1331 const double radius,const double sigma)
1332{
1333 Image
1334 *charcoal_image;
1335
1336 assert(wand != (MagickWand *) NULL);
1337 assert(wand->signature == MagickWandSignature);
1338 if (wand->debug != MagickFalse)
1339 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1340 if (wand->images == (Image *) NULL)
1341 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1342 charcoal_image=CharcoalImage(wand->images,radius,sigma,wand->exception);
1343 if (charcoal_image == (Image *) NULL)
1344 return(MagickFalse);
1345 ReplaceImageInList(&wand->images,charcoal_image);
1346 return(MagickTrue);
1347}
1348␌
1349/*
1350%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1351% %
1352% %
1353% %
1354% M a g i c k C h o p I m a g e %
1355% %
1356% %
1357% %
1358%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1359%
1360% MagickChopImage() removes a region of an image and collapses the image to
1361% occupy the removed portion
1362%
1363% The format of the MagickChopImage method is:
1364%
1365% MagickBooleanType MagickChopImage(MagickWand *wand,
1366% const size_t width,const size_t height,const ssize_t x,
1367% const ssize_t y)
1368%
1369% A description of each parameter follows:
1370%
1371% o wand: the magick wand.
1372%
1373% o width: the region width.
1374%
1375% o height: the region height.
1376%
1377% o x: the region x offset.
1378%
1379% o y: the region y offset.
1380%
1381%
1382*/
1383WandExport MagickBooleanType MagickChopImage(MagickWand *wand,
1384 const size_t width,const size_t height,const ssize_t x,
1385 const ssize_t y)
1386{
1387 Image
1388 *chop_image;
1389
1390 RectangleInfo
1391 chop;
1392
1393 assert(wand != (MagickWand *) NULL);
1394 assert(wand->signature == MagickWandSignature);
1395 if (wand->debug != MagickFalse)
1396 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1397 if (wand->images == (Image *) NULL)
1398 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1399 chop.width=width;
1400 chop.height=height;
1401 chop.x=x;
1402 chop.y=y;
1403 chop_image=ChopImage(wand->images,&chop,wand->exception);
1404 if (chop_image == (Image *) NULL)
1405 return(MagickFalse);
1406 ReplaceImageInList(&wand->images,chop_image);
1407 return(MagickTrue);
1408}
1409␌
1410/*
1411%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1412% %
1413% %
1414% %
1415% M a g i c k C L A H E I m a g e %
1416% %
1417% %
1418% %
1419%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1420%
1421% MagickCLAHEImage() is a variant of adaptive histogram equalization in which
1422% the contrast amplification is limited, so as to reduce this problem of noise
1423% amplification.
1424%
1425% The format of the CLAHEImage method is:
1426%
1427% MagickBooleanType MagickCLAHEImage(MagickWand *wand,const size_t width,
1428% const size_t height,const double number_bins,const double clip_limit)
1429%
1430% A description of each parameter follows:
1431%
1432% o wand: the magick wand.
1433%
1434% o width: the width of the tile divisions to use in horizontal direction.
1435%
1436% o height: the height of the tile divisions to use in vertical direction.
1437%
1438% o number_bins: number of bins for histogram ("dynamic range"). Although
1439% parameter is currently a double, it is cast to size_t internally.
1440%
1441% o clip_limit: contrast limit for localised changes in contrast. A limit
1442% less than 1 results in standard non-contrast limited AHE.
1443%
1444*/
1445WandExport MagickBooleanType MagickCLAHEImage(MagickWand *wand,
1446 const size_t width,const size_t height,const double number_bins,
1447 const double clip_limit)
1448{
1449 MagickBooleanType
1450 status;
1451
1452 assert(wand != (MagickWand *) NULL);
1453 assert(wand->signature == MagickWandSignature);
1454 if (wand->debug != MagickFalse)
1455 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1456 if (wand->images == (Image *) NULL)
1457 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1458 status=CLAHEImage(wand->images,width,height,(size_t) number_bins,clip_limit,
1459 wand->exception);
1460 return(status);
1461}
1462␌
1463/*
1464%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1465% %
1466% %
1467% %
1468% M a g i c k C l a m p I m a g e %
1469% %
1470% %
1471% %
1472%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1473%
1474% MagickClampImage() restricts the color range from 0 to the quantum depth.
1475%
1476% The format of the MagickClampImage method is:
1477%
1478% MagickBooleanType MagickClampImage(MagickWand *wand)
1479%
1480% A description of each parameter follows:
1481%
1482% o wand: the magick wand.
1483%
1484% o channel: the channel.
1485%
1486*/
1487WandExport MagickBooleanType MagickClampImage(MagickWand *wand)
1488{
1489 assert(wand != (MagickWand *) NULL);
1490 assert(wand->signature == MagickWandSignature);
1491 if (wand->debug != MagickFalse)
1492 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1493 if (wand->images == (Image *) NULL)
1494 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1495 return(ClampImage(wand->images,wand->exception));
1496}
1497␌
1498/*
1499%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1500% %
1501% %
1502% %
1503% M a g i c k C l i p I m a g e %
1504% %
1505% %
1506% %
1507%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1508%
1509% MagickClipImage() clips along the first path from the 8BIM profile, if
1510% present.
1511%
1512% The format of the MagickClipImage method is:
1513%
1514% MagickBooleanType MagickClipImage(MagickWand *wand)
1515%
1516% A description of each parameter follows:
1517%
1518% o wand: the magick wand.
1519%
1520*/
1521WandExport MagickBooleanType MagickClipImage(MagickWand *wand)
1522{
1523 MagickBooleanType
1524 status;
1525
1526 assert(wand != (MagickWand *) NULL);
1527 assert(wand->signature == MagickWandSignature);
1528 if (wand->debug != MagickFalse)
1529 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1530 if (wand->images == (Image *) NULL)
1531 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1532 status=ClipImage(wand->images,wand->exception);
1533 return(status);
1534}
1535␌
1536/*
1537%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1538% %
1539% %
1540% %
1541% M a g i c k C l i p I m a g e P a t h %
1542% %
1543% %
1544% %
1545%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1546%
1547% MagickClipImagePath() clips along the named paths from the 8BIM profile, if
1548% present. Later operations take effect inside the path. Id may be a number
1549% if preceded with #, to work on a numbered path, e.g., "#1" to use the first
1550% path.
1551%
1552% The format of the MagickClipImagePath method is:
1553%
1554% MagickBooleanType MagickClipImagePath(MagickWand *wand,
1555% const char *pathname,const MagickBooleanType inside)
1556%
1557% A description of each parameter follows:
1558%
1559% o wand: the magick wand.
1560%
1561% o pathname: name of clipping path resource. If name is preceded by #, use
1562% clipping path numbered by name.
1563%
1564% o inside: if non-zero, later operations take effect inside clipping path.
1565% Otherwise later operations take effect outside clipping path.
1566%
1567*/
1568WandExport MagickBooleanType MagickClipImagePath(MagickWand *wand,
1569 const char *pathname,const MagickBooleanType inside)
1570{
1571 MagickBooleanType
1572 status;
1573
1574 assert(wand != (MagickWand *) NULL);
1575 assert(wand->signature == MagickWandSignature);
1576 if (wand->debug != MagickFalse)
1577 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1578 if (wand->images == (Image *) NULL)
1579 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1580 status=ClipImagePath(wand->images,pathname,inside,wand->exception);
1581 return(status);
1582}
1583␌
1584/*
1585%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1586% %
1587% %
1588% %
1589% M a g i c k C l u t I m a g e %
1590% %
1591% %
1592% %
1593%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1594%
1595% MagickClutImage() replaces colors in the image from a color lookup table.
1596%
1597% The format of the MagickClutImage method is:
1598%
1599% MagickBooleanType MagickClutImage(MagickWand *wand,
1600% const MagickWand *clut_wand,const PixelInterpolateMethod method)
1601%
1602% A description of each parameter follows:
1603%
1604% o wand: the magick wand.
1605%
1606% o clut_image: the clut image.
1607%
1608% o method: the pixel interpolation method.
1609%
1610*/
1611WandExport MagickBooleanType MagickClutImage(MagickWand *wand,
1612 const MagickWand *clut_wand,const PixelInterpolateMethod method)
1613{
1614 MagickBooleanType
1615 status;
1616
1617 assert(wand != (MagickWand *) NULL);
1618 assert(wand->signature == MagickWandSignature);
1619 if (wand->debug != MagickFalse)
1620 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1621 if ((wand->images == (Image *) NULL) || (clut_wand->images == (Image *) NULL))
1622 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1623 status=ClutImage(wand->images,clut_wand->images,method,wand->exception);
1624 return(status);
1625}
1626␌
1627/*
1628%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1629% %
1630% %
1631% %
1632% M a g i c k C o a l e s c e I m a g e s %
1633% %
1634% %
1635% %
1636%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1637%
1638% MagickCoalesceImages() composites a set of images while respecting any page
1639% offsets and disposal methods. GIF, MIFF, and MNG animation sequences
1640% typically start with an image background and each subsequent image
1641% varies in size and offset. MagickCoalesceImages() returns a new sequence
1642% where each image in the sequence is the same size as the first and
1643% composited with the next image in the sequence.
1644%
1645% The format of the MagickCoalesceImages method is:
1646%
1647% MagickWand *MagickCoalesceImages(MagickWand *wand)
1648%
1649% A description of each parameter follows:
1650%
1651% o wand: the magick wand.
1652%
1653*/
1654WandExport MagickWand *MagickCoalesceImages(MagickWand *wand)
1655{
1656 Image
1657 *coalesce_image;
1658
1659 assert(wand != (MagickWand *) NULL);
1660 assert(wand->signature == MagickWandSignature);
1661 if (wand->debug != MagickFalse)
1662 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1663 if (wand->images == (Image *) NULL)
1664 return((MagickWand *) NULL);
1665 coalesce_image=CoalesceImages(wand->images,wand->exception);
1666 if (coalesce_image == (Image *) NULL)
1667 return((MagickWand *) NULL);
1668 return(CloneMagickWandFromImages(wand,coalesce_image));
1669}
1670␌
1671/*
1672%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1673% %
1674% %
1675% %
1676% M a g i c k C o l o r D e c i s i o n I m a g e %
1677% %
1678% %
1679% %
1680%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1681%
1682% MagickColorDecisionListImage() accepts a lightweight Color Correction
1683% Collection (CCC) file which solely contains one or more color corrections
1684% and applies the color correction to the image. Here is a sample CCC file:
1685%
1686% <ColorCorrectionCollection xmlns="urn:ASC:CDL:v1.2">
1687% <ColorCorrection id="cc03345">
1688% <SOPNode>
1689% <Slope> 0.9 1.2 0.5 </Slope>
1690% <Offset> 0.4 -0.5 0.6 </Offset>
1691% <Power> 1.0 0.8 1.5 </Power>
1692% </SOPNode>
1693% <SATNode>
1694% <Saturation> 0.85 </Saturation>
1695% </SATNode>
1696% </ColorCorrection>
1697% </ColorCorrectionCollection>
1698%
1699% which includes the offset, slope, and power for each of the RGB channels
1700% as well as the saturation.
1701%
1702% The format of the MagickColorDecisionListImage method is:
1703%
1704% MagickBooleanType MagickColorDecisionListImage(MagickWand *wand,
1705% const char *color_correction_collection)
1706%
1707% A description of each parameter follows:
1708%
1709% o wand: the magick wand.
1710%
1711% o color_correction_collection: the color correction collection in XML.
1712%
1713*/
1714WandExport MagickBooleanType MagickColorDecisionListImage(MagickWand *wand,
1715 const char *color_correction_collection)
1716{
1717 MagickBooleanType
1718 status;
1719
1720 assert(wand != (MagickWand *) NULL);
1721 assert(wand->signature == MagickWandSignature);
1722 if (wand->debug != MagickFalse)
1723 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1724 if (wand->images == (Image *) NULL)
1725 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1726 status=ColorDecisionListImage(wand->images,color_correction_collection,
1727 wand->exception);
1728 return(status);
1729}
1730␌
1731/*
1732%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1733% %
1734% %
1735% %
1736% M a g i c k C o l o r i z e I m a g e %
1737% %
1738% %
1739% %
1740%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1741%
1742% MagickColorizeImage() blends the fill color with each pixel in the image.
1743%
1744% The format of the MagickColorizeImage method is:
1745%
1746% MagickBooleanType MagickColorizeImage(MagickWand *wand,
1747% const PixelWand *colorize,const PixelWand *blend)
1748%
1749% A description of each parameter follows:
1750%
1751% o wand: the magick wand.
1752%
1753% o colorize: the colorize pixel wand.
1754%
1755% o alpha: the alpha pixel wand.
1756%
1757*/
1758WandExport MagickBooleanType MagickColorizeImage(MagickWand *wand,
1759 const PixelWand *colorize,const PixelWand *blend)
1760{
1761 char
1762 percent_blend[MagickPathExtent];
1763
1764 Image
1765 *colorize_image;
1766
1767 PixelInfo
1768 target;
1769
1770 assert(wand != (MagickWand *) NULL);
1771 assert(wand->signature == MagickWandSignature);
1772 if (wand->debug != MagickFalse)
1773 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1774 if (wand->images == (Image *) NULL)
1775 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1776 GetPixelInfo(wand->images,&target);
1777 if (target.colorspace != CMYKColorspace)
1778 (void) FormatLocaleString(percent_blend,MagickPathExtent,
1779 "%g,%g,%g,%g",(double) (100.0*QuantumScale*
1780 (double) PixelGetRedQuantum(blend)),(double) (100.0*QuantumScale*
1781 (double) PixelGetGreenQuantum(blend)),(double) (100.0*QuantumScale*
1782 (double) PixelGetBlueQuantum(blend)),(double) (100.0*QuantumScale*
1783 (double) PixelGetAlphaQuantum(blend)));
1784 else
1785 (void) FormatLocaleString(percent_blend,MagickPathExtent,
1786 "%g,%g,%g,%g,%g",(double) (100.0*QuantumScale*
1787 (double) PixelGetRedQuantum(blend)),(double) (100.0*QuantumScale*
1788 (double) PixelGetGreenQuantum(blend)),(double) (100.0*QuantumScale*
1789 (double) PixelGetBlueQuantum(blend)),(double) (100.0*QuantumScale*
1790 (double) PixelGetBlackQuantum(blend)),(double) (100.0*QuantumScale*
1791 (double) PixelGetAlphaQuantum(blend)));
1792 target=PixelGetPixel(colorize);
1793 colorize_image=ColorizeImage(wand->images,percent_blend,&target,
1794 wand->exception);
1795 if (colorize_image == (Image *) NULL)
1796 return(MagickFalse);
1797 ReplaceImageInList(&wand->images,colorize_image);
1798 return(MagickTrue);
1799}
1800␌
1801/*
1802%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1803% %
1804% %
1805% %
1806% M a g i c k C o l o r M a t r i x I m a g e %
1807% %
1808% %
1809% %
1810%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1811%
1812% MagickColorMatrixImage() apply color transformation to an image. The method
1813% permits saturation changes, hue rotation, luminance to alpha, and various
1814% other effects. Although variable-sized transformation matrices can be used,
1815% typically one uses a 5x5 matrix for an RGBA image and a 6x6 for CMYKA
1816% (or RGBA with offsets). The matrix is similar to those used by Adobe Flash
1817% except offsets are in column 6 rather than 5 (in support of CMYKA images)
1818% and offsets are normalized (divide Flash offset by 255).
1819%
1820% The format of the MagickColorMatrixImage method is:
1821%
1822% MagickBooleanType MagickColorMatrixImage(MagickWand *wand,
1823% const KernelInfo *color_matrix)
1824%
1825% A description of each parameter follows:
1826%
1827% o wand: the magick wand.
1828%
1829% o color_matrix: the color matrix.
1830%
1831*/
1832WandExport MagickBooleanType MagickColorMatrixImage(MagickWand *wand,
1833 const KernelInfo *color_matrix)
1834{
1835 Image
1836 *color_image;
1837
1838 assert(wand != (MagickWand *) NULL);
1839 assert(wand->signature == MagickWandSignature);
1840 if (wand->debug != MagickFalse)
1841 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1842 if (color_matrix == (const KernelInfo *) NULL)
1843 return(MagickFalse);
1844 if (wand->images == (Image *) NULL)
1845 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1846 color_image=ColorMatrixImage(wand->images,color_matrix,wand->exception);
1847 if (color_image == (Image *) NULL)
1848 return(MagickFalse);
1849 ReplaceImageInList(&wand->images,color_image);
1850 return(MagickTrue);
1851}
1852␌
1853/*
1854%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1855% %
1856% %
1857% %
1858% M a g i c k C o l o r T h r e s h o l d I m a g e %
1859% %
1860% %
1861% %
1862%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1863%
1864% MagickColorThresholdImage() forces all pixels in the color range to white
1865% otherwise black.
1866%
1867% The format of the MagickColorThresholdImage method is:
1868%
1869% MagickBooleanType MagickColorThresholdImage(MagickWand *wand,
1870% const PixelWand *start_color,const PixelWand *stop_color)
1871%
1872% A description of each parameter follows:
1873%
1874% o wand: the magick wand.
1875%
1876% o start_color: the start color pixel wand.
1877%
1878% o stop_color: the stop color pixel wand.
1879%
1880*/
1881WandExport MagickBooleanType MagickColorThresholdImage(MagickWand *wand,
1882 const PixelWand *start_color,const PixelWand *stop_color)
1883{
1884 PixelInfo
1885 start,
1886 stop;
1887
1888 assert(wand != (MagickWand *) NULL);
1889 assert(wand->signature == MagickWandSignature);
1890 if (wand->debug != MagickFalse)
1891 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1892 if (wand->images == (Image *) NULL)
1893 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1894 PixelGetMagickColor(start_color,&start);
1895 PixelGetMagickColor(stop_color,&stop);
1896 return(ColorThresholdImage(wand->images,&start,&stop,wand->exception));
1897}
1898␌
1899/*
1900%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1901% %
1902% %
1903% %
1904% M a g i c k C o m b i n e I m a g e s %
1905% %
1906% %
1907% %
1908%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1909%
1910% MagickCombineImages() combines one or more images into a single image. The
1911% grayscale value of the pixels of each image in the sequence is assigned in
1912% order to the specified channels of the combined image. The typical
1913% ordering would be image 1 => Red, 2 => Green, 3 => Blue, etc.
1914%
1915% The format of the MagickCombineImages method is:
1916%
1917% MagickWand *MagickCombineImages(MagickWand *wand,
1918% const ColorspaceType colorspace)
1919%
1920% A description of each parameter follows:
1921%
1922% o wand: the magick wand.
1923%
1924% o colorspace: the colorspace.
1925%
1926*/
1927WandExport MagickWand *MagickCombineImages(MagickWand *wand,
1928 const ColorspaceType colorspace)
1929{
1930 Image
1931 *combine_image;
1932
1933 assert(wand != (MagickWand *) NULL);
1934 assert(wand->signature == MagickWandSignature);
1935 if (wand->debug != MagickFalse)
1936 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1937 if (wand->images == (Image *) NULL)
1938 return((MagickWand *) NULL);
1939 combine_image=CombineImages(wand->images,colorspace,wand->exception);
1940 if (combine_image == (Image *) NULL)
1941 return((MagickWand *) NULL);
1942 return(CloneMagickWandFromImages(wand,combine_image));
1943}
1944␌
1945/*
1946%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1947% %
1948% %
1949% %
1950% M a g i c k C o m m e n t I m a g e %
1951% %
1952% %
1953% %
1954%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1955%
1956% MagickCommentImage() adds a comment to your image.
1957%
1958% The format of the MagickCommentImage method is:
1959%
1960% MagickBooleanType MagickCommentImage(MagickWand *wand,
1961% const char *comment)
1962%
1963% A description of each parameter follows:
1964%
1965% o wand: the magick wand.
1966%
1967% o comment: the image comment.
1968%
1969*/
1970WandExport MagickBooleanType MagickCommentImage(MagickWand *wand,
1971 const char *comment)
1972{
1973 MagickBooleanType
1974 status;
1975
1976 assert(wand != (MagickWand *) NULL);
1977 assert(wand->signature == MagickWandSignature);
1978 if (wand->debug != MagickFalse)
1979 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1980 if (wand->images == (Image *) NULL)
1981 ThrowWandException(WandError,"ContainsNoImages",wand->name);
1982 status=SetImageProperty(wand->images,"comment",comment,wand->exception);
1983 return(status);
1984}
1985␌
1986/*
1987%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1988% %
1989% %
1990% %
1991% M a g i c k C o m p a r e I m a g e L a y e r s %
1992% %
1993% %
1994% %
1995%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1996%
1997% MagickCompareImagesLayers() compares each image with the next in a sequence
1998% and returns the maximum bounding region of any pixel differences it
1999% discovers.
2000%
2001% The format of the MagickCompareImagesLayers method is:
2002%
2003% MagickWand *MagickCompareImagesLayers(MagickWand *wand,
2004% const LayerMethod method)
2005%
2006% A description of each parameter follows:
2007%
2008% o wand: the magick wand.
2009%
2010% o method: the compare method.
2011%
2012*/
2013WandExport MagickWand *MagickCompareImagesLayers(MagickWand *wand,
2014 const LayerMethod method)
2015{
2016 Image
2017 *layers_image;
2018
2019 assert(wand != (MagickWand *) NULL);
2020 assert(wand->signature == MagickWandSignature);
2021 if (wand->debug != MagickFalse)
2022 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2023 if (wand->images == (Image *) NULL)
2024 return((MagickWand *) NULL);
2025 layers_image=CompareImagesLayers(wand->images,method,wand->exception);
2026 if (layers_image == (Image *) NULL)
2027 return((MagickWand *) NULL);
2028 return(CloneMagickWandFromImages(wand,layers_image));
2029}
2030␌
2031/*
2032%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2033% %
2034% %
2035% %
2036% M a g i c k C o m p a r e I m a g e s %
2037% %
2038% %
2039% %
2040%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2041%
2042% MagickCompareImages() compares an image to a reconstructed image and returns
2043% the specified difference image.
2044%
2045% The format of the MagickCompareImages method is:
2046%
2047% MagickWand *MagickCompareImages(MagickWand *wand,
2048% const MagickWand *reference,const MetricType metric,
2049% double *distortion)
2050%
2051% A description of each parameter follows:
2052%
2053% o wand: the magick wand.
2054%
2055% o reference: the reference wand.
2056%
2057% o metric: the metric.
2058%
2059% o distortion: the computed distortion between the images.
2060%
2061*/
2062WandExport MagickWand *MagickCompareImages(MagickWand *wand,
2063 const MagickWand *reference,const MetricType metric,double *distortion)
2064{
2065 Image
2066 *compare_image;
2067
2068
2069 assert(wand != (MagickWand *) NULL);
2070 assert(wand->signature == MagickWandSignature);
2071 if (wand->debug != MagickFalse)
2072 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2073 if ((wand->images == (Image *) NULL) || (reference->images == (Image *) NULL))
2074 {
2075 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
2076 "ContainsNoImages","`%s'",wand->name);
2077 return((MagickWand *) NULL);
2078 }
2079 compare_image=CompareImages(wand->images,reference->images,metric,distortion,
2080 wand->exception);
2081 if (compare_image == (Image *) NULL)
2082 return((MagickWand *) NULL);
2083 return(CloneMagickWandFromImages(wand,compare_image));
2084}
2085␌
2086/*
2087%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2088% %
2089% %
2090% %
2091% M a g i c k C o m p l e x I m a g e s %
2092% %
2093% %
2094% %
2095%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2096%
2097% MagickComplexImages() performs complex mathematics on an image sequence.
2098%
2099% The format of the MagickComplexImages method is:
2100%
2101% MagickWand *MagickComplexImages(MagickWand *wand,
2102% const ComplexOperator op)
2103%
2104% A description of each parameter follows:
2105%
2106% o wand: the magick wand.
2107%
2108% o op: A complex operator. Choose from AddComplexOperator,
2109% ConjugateComplexOperator,DivideComplexOperator,
2110% MagnitudePhaseComplexOperator,MultiplyComplexOperator,
2111% RealImaginaryComplexOperator, SubtractComplexOperator.
2112%
2113*/
2114WandExport MagickWand *MagickComplexImages(MagickWand *wand,
2115 const ComplexOperator op)
2116{
2117 Image
2118 *complex_image;
2119
2120 assert(wand != (MagickWand *) NULL);
2121 assert(wand->signature == MagickWandSignature);
2122 if (wand->debug != MagickFalse)
2123 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2124 if (wand->images == (Image *) NULL)
2125 return((MagickWand *) NULL);
2126 complex_image=ComplexImages(wand->images,op,wand->exception);
2127 if (complex_image == (Image *) NULL)
2128 return((MagickWand *) NULL);
2129 return(CloneMagickWandFromImages(wand,complex_image));
2130}
2131␌
2132/*
2133%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2134% %
2135% %
2136% %
2137% M a g i c k C o m p o s i t e I m a g e %
2138% %
2139% %
2140% %
2141%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2142%
2143% MagickCompositeImage() composite one image onto another at the specified
2144% offset.
2145%
2146% The format of the MagickCompositeImage method is:
2147%
2148% MagickBooleanType MagickCompositeImage(MagickWand *wand,
2149% const MagickWand *source_wand,const CompositeOperator compose,
2150% const MagickBooleanType clip_to_self,const ssize_t x,const ssize_t y)
2151%
2152% A description of each parameter follows:
2153%
2154% o wand: the magick wand holding the destination images
2155%
2156% o source_image: the magick wand holding source image.
2157%
2158% o compose: This operator affects how the composite is applied to the
2159% image. The default is Over. These are some of the compose methods
2160% available.
2161%
2162% OverCompositeOp InCompositeOp OutCompositeOp
2163% AtopCompositeOp XorCompositeOp PlusCompositeOp
2164% MinusCompositeOp AddCompositeOp SubtractCompositeOp
2165% DifferenceCompositeOp BumpmapCompositeOp CopyCompositeOp
2166% DisplaceCompositeOp
2167%
2168% o clip_to_self: set to MagickTrue to limit composition to area composed.
2169%
2170% o x: the column offset of the composited image.
2171%
2172% o y: the row offset of the composited image.
2173%
2174*/
2175WandExport MagickBooleanType MagickCompositeImage(MagickWand *wand,
2176 const MagickWand *source_wand,const CompositeOperator compose,
2177 const MagickBooleanType clip_to_self,const ssize_t x,const ssize_t y)
2178{
2179 MagickBooleanType
2180 status;
2181
2182 assert(wand != (MagickWand *) NULL);
2183 assert(wand->signature == MagickWandSignature);
2184 if (wand->debug != MagickFalse)
2185 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2186 if ((wand->images == (Image *) NULL) ||
2187 (source_wand->images == (Image *) NULL))
2188 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2189 status=CompositeImage(wand->images,source_wand->images,compose,clip_to_self,
2190 x,y,wand->exception);
2191 return(status);
2192}
2193␌
2194/*
2195%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2196% %
2197% %
2198% %
2199% M a g i c k C o m p o s i t e I m a g e G r a v i t y %
2200% %
2201% %
2202% %
2203%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2204%
2205% MagickCompositeImageGravity() composite one image onto another using the
2206% specified gravity.
2207%
2208% The format of the MagickCompositeImageGravity method is:
2209%
2210% MagickBooleanType MagickCompositeImageGravity(MagickWand *wand,
2211% const MagickWand *source_wand,const CompositeOperator compose,
2212% const GravityType gravity)
2213%
2214% A description of each parameter follows:
2215%
2216% o wand: the magick wand holding the destination images
2217%
2218% o source_image: the magick wand holding source image.
2219%
2220% o compose: This operator affects how the composite is applied to the
2221% image. The default is Over. These are some of the compose methods
2222% available.
2223%
2224% OverCompositeOp InCompositeOp OutCompositeOp
2225% AtopCompositeOp XorCompositeOp PlusCompositeOp
2226% MinusCompositeOp AddCompositeOp SubtractCompositeOp
2227% DifferenceCompositeOp BumpmapCompositeOp CopyCompositeOp
2228% DisplaceCompositeOp
2229%
2230% o gravity: positioning gravity (NorthWestGravity, NorthGravity,
2231% NorthEastGravity, WestGravity, CenterGravity,
2232% EastGravity, SouthWestGravity, SouthGravity,
2233% SouthEastGravity)
2234%
2235*/
2236WandExport MagickBooleanType MagickCompositeImageGravity(MagickWand *wand,
2237 const MagickWand *source_wand,const CompositeOperator compose,
2238 const GravityType gravity)
2239{
2240 MagickBooleanType
2241 status;
2242
2243 RectangleInfo
2244 geometry;
2245
2246 assert(wand != (MagickWand *) NULL);
2247 assert(wand->signature == MagickWandSignature);
2248 if (wand->debug != MagickFalse)
2249 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2250 if ((wand->images == (Image *) NULL) ||
2251 (source_wand->images == (Image *) NULL))
2252 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2253 SetGeometry(source_wand->images,&geometry);
2254 GravityAdjustGeometry(wand->images->columns,wand->images->rows,gravity,
2255 &geometry);
2256 status=CompositeImage(wand->images,source_wand->images,compose,MagickTrue,
2257 geometry.x,geometry.y,wand->exception);
2258 return(status);
2259}
2260␌
2261/*
2262%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2263% %
2264% %
2265% %
2266% M a g i c k C o m p o s i t e L a y e r s %
2267% %
2268% %
2269% %
2270%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2271%
2272% MagickCompositeLayers() composite the images in the source wand over the
2273% images in the destination wand in sequence, starting with the current
2274% image in both lists.
2275%
2276% Each layer from the two image lists are composted together until the end of
2277% one of the image lists is reached. The offset of each composition is also
2278% adjusted to match the virtual canvas offsets of each layer. As such the
2279% given offset is relative to the virtual canvas, and not the actual image.
2280%
2281% Composition uses given x and y offsets, as the 'origin' location of the
2282% source images virtual canvas (not the real image) allowing you to compose a
2283% list of 'layer images' into the destination images. This makes it well
2284% suitable for directly composing 'Clears Frame Animations' or 'Coalesced
2285% Animations' onto a static or other 'Coalesced Animation' destination image
2286% list. GIF disposal handling is not looked at.
2287%
2288% Special case:- If one of the image sequences is the last image (just a
2289% single image remaining), that image is repeatedly composed with all the
2290% images in the other image list. Either the source or destination lists may
2291% be the single image, for this situation.
2292%
2293% In the case of a single destination image (or last image given), that image
2294% will ve cloned to match the number of images remaining in the source image
2295% list.
2296%
2297% This is equivalent to the "-layer Composite" Shell API operator.
2298%
2299% The format of the MagickCompositeLayers method is:
2300%
2301% MagickBooleanType MagickCompositeLayers(MagickWand *wand,
2302% const MagickWand *source_wand, const CompositeOperator compose,
2303% const ssize_t x,const ssize_t y)
2304%
2305% A description of each parameter follows:
2306%
2307% o wand: the magick wand holding destination images
2308%
2309% o source_wand: the wand holding the source images
2310%
2311% o compose, x, y: composition arguments
2312%
2313*/
2314WandExport MagickBooleanType MagickCompositeLayers(MagickWand *wand,
2315 const MagickWand *source_wand,const CompositeOperator compose,
2316 const ssize_t x,const ssize_t y)
2317{
2318 MagickBooleanType
2319 status;
2320
2321 assert(wand != (MagickWand *) NULL);
2322 assert(wand->signature == MagickWandSignature);
2323 if (wand->debug != MagickFalse)
2324 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2325 if ((wand->images == (Image *) NULL) ||
2326 (source_wand->images == (Image *) NULL))
2327 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2328 CompositeLayers(wand->images,compose,source_wand->images,x,y,wand->exception);
2329 status=MagickTrue; /* FUTURE: determine status from exceptions */
2330 return(status);
2331}
2332␌
2333/*
2334%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2335% %
2336% %
2337% %
2338% M a g i c k C o n n e c t e d C o m p o n e n t s I m a g e %
2339% %
2340% %
2341% %
2342%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2343%
2344% MagickConnectedComponentsImage() returns the connected-components of the
2345% image uniquely labeled. The returned connected components image colors
2346% member defines the number of unique objects. Choose from 4 or 8-way
2347% connectivity.
2348%
2349% The format of the MagickConnectedComponentsImage method is:
2350%
2351% MagickBooleanType MagickConnectedComponentsImage(MagickWand *wand,
2352% const size_t connectivity,CCObjectInfo **objects)
2353%
2354% A description of each parameter follows:
2355%
2356% o wand: the magick wand.
2357%
2358% o connectivity: how many neighbors to visit, choose from 4 or 8.
2359%
2360% o objects: return the attributes of each unique object.
2361%
2362*/
2363WandExport MagickBooleanType MagickConnectedComponentsImage(MagickWand *wand,
2364 const size_t connectivity,CCObjectInfo **objects)
2365{
2366 Image
2367 *connected_components_image;
2368
2369 assert(wand != (MagickWand *) NULL);
2370 assert(wand->signature == MagickWandSignature);
2371 if (wand->debug != MagickFalse)
2372 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2373 if (wand->images == (Image *) NULL)
2374 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2375 connected_components_image=ConnectedComponentsImage(wand->images,connectivity,
2376 objects,wand->exception);
2377 if (connected_components_image == (Image *) NULL)
2378 return(MagickFalse);
2379 ReplaceImageInList(&wand->images,connected_components_image);
2380 return(MagickTrue);
2381}
2382␌
2383/*
2384%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2385% %
2386% %
2387% %
2388% M a g i c k C o n t r a s t I m a g e %
2389% %
2390% %
2391% %
2392%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2393%
2394% MagickContrastImage() enhances the intensity differences between the lighter
2395% and darker elements of the image. Set sharpen to a value other than 0 to
2396% increase the image contrast otherwise the contrast is reduced.
2397%
2398% The format of the MagickContrastImage method is:
2399%
2400% MagickBooleanType MagickContrastImage(MagickWand *wand,
2401% const MagickBooleanType sharpen)
2402%
2403% A description of each parameter follows:
2404%
2405% o wand: the magick wand.
2406%
2407% o sharpen: Increase or decrease image contrast.
2408%
2409%
2410*/
2411WandExport MagickBooleanType MagickContrastImage(MagickWand *wand,
2412 const MagickBooleanType sharpen)
2413{
2414 MagickBooleanType
2415 status;
2416
2417 assert(wand != (MagickWand *) NULL);
2418 assert(wand->signature == MagickWandSignature);
2419 if (wand->debug != MagickFalse)
2420 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2421 if (wand->images == (Image *) NULL)
2422 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2423 status=ContrastImage(wand->images,sharpen,wand->exception);
2424 return(status);
2425}
2426␌
2427/*
2428%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2429% %
2430% %
2431% %
2432% M a g i c k C o n t r a s t S t r e t c h I m a g e %
2433% %
2434% %
2435% %
2436%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2437%
2438% MagickContrastStretchImage() enhances the contrast of a color image by
2439% adjusting the pixels color to span the entire range of colors available.
2440% You can also reduce the influence of a particular channel with a gamma
2441% value of 0.
2442%
2443% The format of the MagickContrastStretchImage method is:
2444%
2445% MagickBooleanType MagickContrastStretchImage(MagickWand *wand,
2446% const double black_point,const double white_point)
2447%
2448% A description of each parameter follows:
2449%
2450% o wand: the magick wand.
2451%
2452% o black_point: the black point.
2453%
2454% o white_point: the white point.
2455%
2456*/
2457WandExport MagickBooleanType MagickContrastStretchImage(MagickWand *wand,
2458 const double black_point,const double white_point)
2459{
2460 MagickBooleanType
2461 status;
2462
2463 assert(wand != (MagickWand *) NULL);
2464 assert(wand->signature == MagickWandSignature);
2465 if (wand->debug != MagickFalse)
2466 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2467 if (wand->images == (Image *) NULL)
2468 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2469 status=ContrastStretchImage(wand->images,black_point,white_point,
2470 wand->exception);
2471 return(status);
2472}
2473␌
2474/*
2475%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2476% %
2477% %
2478% %
2479% M a g i c k C o n v o l v e I m a g e %
2480% %
2481% %
2482% %
2483%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2484%
2485% MagickConvolveImage() applies a custom convolution kernel to the image.
2486%
2487% The format of the MagickConvolveImage method is:
2488%
2489% MagickBooleanType MagickConvolveImage(MagickWand *wand,
2490% const KernelInfo *kernel)
2491%
2492% A description of each parameter follows:
2493%
2494% o wand: the magick wand.
2495%
2496% o kernel: An array of doubles representing the convolution kernel.
2497%
2498*/
2499WandExport MagickBooleanType MagickConvolveImage(MagickWand *wand,
2500 const KernelInfo *kernel)
2501{
2502 Image
2503 *filter_image;
2504
2505 assert(wand != (MagickWand *) NULL);
2506 assert(wand->signature == MagickWandSignature);
2507 if (wand->debug != MagickFalse)
2508 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2509 if (kernel == (const KernelInfo *) NULL)
2510 return(MagickFalse);
2511 if (wand->images == (Image *) NULL)
2512 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2513 filter_image=ConvolveImage(wand->images,kernel,wand->exception);
2514 if (filter_image == (Image *) NULL)
2515 return(MagickFalse);
2516 ReplaceImageInList(&wand->images,filter_image);
2517 return(MagickTrue);
2518}
2519␌
2520/*
2521%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2522% %
2523% %
2524% %
2525% M a g i c k C r o p I m a g e %
2526% %
2527% %
2528% %
2529%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2530%
2531% MagickCropImage() extracts a region of the image.
2532%
2533% The format of the MagickCropImage method is:
2534%
2535% MagickBooleanType MagickCropImage(MagickWand *wand,
2536% const size_t width,const size_t height,const ssize_t x,const ssize_t y)
2537%
2538% A description of each parameter follows:
2539%
2540% o wand: the magick wand.
2541%
2542% o width: the region width.
2543%
2544% o height: the region height.
2545%
2546% o x: the region x-offset.
2547%
2548% o y: the region y-offset.
2549%
2550*/
2551WandExport MagickBooleanType MagickCropImage(MagickWand *wand,
2552 const size_t width,const size_t height,const ssize_t x,const ssize_t y)
2553{
2554 Image
2555 *crop_image;
2556
2557 RectangleInfo
2558 crop;
2559
2560 assert(wand != (MagickWand *) NULL);
2561 assert(wand->signature == MagickWandSignature);
2562 if (wand->debug != MagickFalse)
2563 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2564 if (wand->images == (Image *) NULL)
2565 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2566 crop.width=width;
2567 crop.height=height;
2568 crop.x=x;
2569 crop.y=y;
2570 crop_image=CropImage(wand->images,&crop,wand->exception);
2571 if (crop_image == (Image *) NULL)
2572 return(MagickFalse);
2573 ReplaceImageInList(&wand->images,crop_image);
2574 return(MagickTrue);
2575}
2576␌
2577/*
2578%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2579% %
2580% %
2581% %
2582% M a g i c k C y c l e C o l o r m a p I m a g e %
2583% %
2584% %
2585% %
2586%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2587%
2588% MagickCycleColormapImage() displaces an image's colormap by a given number
2589% of positions. If you cycle the colormap a number of times you can produce
2590% a psychodelic effect.
2591%
2592% The format of the MagickCycleColormapImage method is:
2593%
2594% MagickBooleanType MagickCycleColormapImage(MagickWand *wand,
2595% const ssize_t displace)
2596%
2597% A description of each parameter follows:
2598%
2599% o wand: the magick wand.
2600%
2601% o pixel_wand: the pixel wand.
2602%
2603*/
2604WandExport MagickBooleanType MagickCycleColormapImage(MagickWand *wand,
2605 const ssize_t displace)
2606{
2607 MagickBooleanType
2608 status;
2609
2610 assert(wand != (MagickWand *) NULL);
2611 assert(wand->signature == MagickWandSignature);
2612 if (wand->debug != MagickFalse)
2613 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2614 if (wand->images == (Image *) NULL)
2615 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2616 status=CycleColormapImage(wand->images,displace,wand->exception);
2617 return(status);
2618}
2619␌
2620/*
2621%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2622% %
2623% %
2624% %
2625% M a g i c k C o n s t i t u t e I m a g e %
2626% %
2627% %
2628% %
2629%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2630%
2631% MagickConstituteImage() adds an image to the wand comprised of the pixel
2632% data you supply. The pixel data must be in scanline order top-to-bottom.
2633% The data can be char, short int, int, float, or double. Float and double
2634% require the pixels to be normalized [0..1], otherwise [0..Max], where Max
2635% is the maximum value the type can accomodate (e.g. 255 for char). For
2636% example, to create a 640x480 image from unsigned red-green-blue character
2637% data, use
2638%
2639% MagickConstituteImage(wand,640,480,"RGB",CharPixel,pixels);
2640%
2641% The format of the MagickConstituteImage method is:
2642%
2643% MagickBooleanType MagickConstituteImage(MagickWand *wand,
2644% const size_t columns,const size_t rows,const char *map,
2645% const StorageType storage,void *pixels)
2646%
2647% A description of each parameter follows:
2648%
2649% o wand: the magick wand.
2650%
2651% o columns: width in pixels of the image.
2652%
2653% o rows: height in pixels of the image.
2654%
2655% o map: This string reflects the expected ordering of the pixel array.
2656% It can be any combination or order of R = red, G = green, B = blue,
2657% A = alpha (0 is transparent), O = alpha (0 is opaque), C = cyan,
2658% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
2659% P = pad.
2660%
2661% o storage: Define the data type of the pixels. Float and double types are
2662% expected to be normalized [0..1] otherwise [0..QuantumRange]. Choose from
2663% these types: CharPixel, DoublePixel, FloatPixel, IntegerPixel,
2664% LongPixel, QuantumPixel, or ShortPixel.
2665%
2666% o pixels: This array of values contain the pixel components as defined by
2667% map and type. You must preallocate this array where the expected
2668% length varies depending on the values of width, height, map, and type.
2669%
2670%
2671*/
2672WandExport MagickBooleanType MagickConstituteImage(MagickWand *wand,
2673 const size_t columns,const size_t rows,const char *map,
2674 const StorageType storage,const void *pixels)
2675{
2676 Image
2677 *images;
2678
2679 assert(wand != (MagickWand *) NULL);
2680 assert(wand->signature == MagickWandSignature);
2681 if (wand->debug != MagickFalse)
2682 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2683 images=ConstituteImage(columns,rows,map,storage,pixels,wand->exception);
2684 if (images == (Image *) NULL)
2685 return(MagickFalse);
2686 return(InsertImageInWand(wand,images));
2687}
2688␌
2689/*
2690%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2691% %
2692% %
2693% %
2694% M a g i c k D e c i p h e r I m a g e %
2695% %
2696% %
2697% %
2698%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2699%
2700% MagickDecipherImage() converts cipher pixels to plain pixels.
2701%
2702% The format of the MagickDecipherImage method is:
2703%
2704% MagickBooleanType MagickDecipherImage(MagickWand *wand,
2705% const char *passphrase)
2706%
2707% A description of each parameter follows:
2708%
2709% o wand: the magick wand.
2710%
2711% o passphrase: the passphrase.
2712%
2713*/
2714WandExport MagickBooleanType MagickDecipherImage(MagickWand *wand,
2715 const char *passphrase)
2716{
2717 assert(wand != (MagickWand *) NULL);
2718 assert(wand->signature == MagickWandSignature);
2719 if (wand->debug != MagickFalse)
2720 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2721 if (wand->images == (Image *) NULL)
2722 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2723 return(DecipherImage(wand->images,passphrase,wand->exception));
2724}
2725␌
2726/*
2727%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2728% %
2729% %
2730% %
2731% M a g i c k D e c o n s t r u c t I m a g e s %
2732% %
2733% %
2734% %
2735%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2736%
2737% MagickDeconstructImages() compares each image with the next in a sequence
2738% and returns the maximum bounding region of any pixel differences it
2739% discovers.
2740%
2741% The format of the MagickDeconstructImages method is:
2742%
2743% MagickWand *MagickDeconstructImages(MagickWand *wand)
2744%
2745% A description of each parameter follows:
2746%
2747% o wand: the magick wand.
2748%
2749*/
2750WandExport MagickWand *MagickDeconstructImages(MagickWand *wand)
2751{
2752 Image
2753 *deconstruct_image;
2754
2755 assert(wand != (MagickWand *) NULL);
2756 assert(wand->signature == MagickWandSignature);
2757 if (wand->debug != MagickFalse)
2758 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2759 if (wand->images == (Image *) NULL)
2760 return((MagickWand *) NULL);
2761 deconstruct_image=CompareImagesLayers(wand->images,CompareAnyLayer,
2762 wand->exception);
2763 if (deconstruct_image == (Image *) NULL)
2764 return((MagickWand *) NULL);
2765 return(CloneMagickWandFromImages(wand,deconstruct_image));
2766}
2767␌
2768/*
2769%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2770% %
2771% %
2772% %
2773% M a g i c k D e s k e w I m a g e %
2774% %
2775% %
2776% %
2777%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2778%
2779% MagickDeskewImage() removes skew from the image. Skew is an artifact that
2780% occurs in scanned images because of the camera being misaligned,
2781% imperfections in the scanning or surface, or simply because the paper was
2782% not placed completely flat when scanned.
2783%
2784% The format of the MagickDeskewImage method is:
2785%
2786% MagickBooleanType MagickDeskewImage(MagickWand *wand,
2787% const double threshold)
2788%
2789% A description of each parameter follows:
2790%
2791% o wand: the magick wand.
2792%
2793% o threshold: separate background from foreground.
2794%
2795*/
2796WandExport MagickBooleanType MagickDeskewImage(MagickWand *wand,
2797 const double threshold)
2798{
2799 Image
2800 *sepia_image;
2801
2802 assert(wand != (MagickWand *) NULL);
2803 assert(wand->signature == MagickWandSignature);
2804 if (wand->debug != MagickFalse)
2805 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2806 if (wand->images == (Image *) NULL)
2807 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2808 sepia_image=DeskewImage(wand->images,threshold,wand->exception);
2809 if (sepia_image == (Image *) NULL)
2810 return(MagickFalse);
2811 ReplaceImageInList(&wand->images,sepia_image);
2812 return(MagickTrue);
2813}
2814␌
2815/*
2816%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2817% %
2818% %
2819% %
2820% M a g i c k D e s p e c k l e I m a g e %
2821% %
2822% %
2823% %
2824%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2825%
2826% MagickDespeckleImage() reduces the speckle noise in an image while
2827% preserving the edges of the original image.
2828%
2829% The format of the MagickDespeckleImage method is:
2830%
2831% MagickBooleanType MagickDespeckleImage(MagickWand *wand)
2832%
2833% A description of each parameter follows:
2834%
2835% o wand: the magick wand.
2836%
2837*/
2838WandExport MagickBooleanType MagickDespeckleImage(MagickWand *wand)
2839{
2840 Image
2841 *despeckle_image;
2842
2843 assert(wand != (MagickWand *) NULL);
2844 assert(wand->signature == MagickWandSignature);
2845 if (wand->debug != MagickFalse)
2846 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2847 if (wand->images == (Image *) NULL)
2848 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2849 despeckle_image=DespeckleImage(wand->images,wand->exception);
2850 if (despeckle_image == (Image *) NULL)
2851 return(MagickFalse);
2852 ReplaceImageInList(&wand->images,despeckle_image);
2853 return(MagickTrue);
2854}
2855␌
2856/*
2857%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2858% %
2859% %
2860% %
2861% M a g i c k D e s t r o y I m a g e %
2862% %
2863% %
2864% %
2865%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2866%
2867% MagickDestroyImage() dereferences an image, deallocating memory associated
2868% with the image if the reference count becomes zero.
2869%
2870% The format of the MagickDestroyImage method is:
2871%
2872% Image *MagickDestroyImage(Image *image)
2873%
2874% A description of each parameter follows:
2875%
2876% o image: the image.
2877%
2878*/
2879WandExport Image *MagickDestroyImage(Image *image)
2880{
2881 return(DestroyImage(image));
2882}
2883␌
2884/*
2885%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2886% %
2887% %
2888% %
2889% M a g i c k D i s p l a y I m a g e %
2890% %
2891% %
2892% %
2893%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2894%
2895% MagickDisplayImage() displays an image.
2896%
2897% The format of the MagickDisplayImage method is:
2898%
2899% MagickBooleanType MagickDisplayImage(MagickWand *wand,
2900% const char *server_name)
2901%
2902% A description of each parameter follows:
2903%
2904% o wand: the magick wand.
2905%
2906% o server_name: the X server name.
2907%
2908*/
2909WandExport MagickBooleanType MagickDisplayImage(MagickWand *wand,
2910 const char *server_name)
2911{
2912 Image
2913 *image;
2914
2915 MagickBooleanType
2916 status;
2917
2918 assert(wand != (MagickWand *) NULL);
2919 assert(wand->signature == MagickWandSignature);
2920 if (wand->debug != MagickFalse)
2921 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2922 if (wand->images == (Image *) NULL)
2923 ThrowWandException(WandError,"ContainsNoImages",wand->name);
2924 image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
2925 if (image == (Image *) NULL)
2926 return(MagickFalse);
2927 (void) CloneString(&wand->image_info->server_name,server_name);
2928 status=DisplayImages(wand->image_info,image,wand->exception);
2929 image=DestroyImage(image);
2930 return(status);
2931}
2932␌
2933/*
2934%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2935% %
2936% %
2937% %
2938% M a g i c k D i s p l a y I m a g e s %
2939% %
2940% %
2941% %
2942%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2943%
2944% MagickDisplayImages() displays an image or image sequence.
2945%
2946% The format of the MagickDisplayImages method is:
2947%
2948% MagickBooleanType MagickDisplayImages(MagickWand *wand,
2949% const char *server_name)
2950%
2951% A description of each parameter follows:
2952%
2953% o wand: the magick wand.
2954%
2955% o server_name: the X server name.
2956%
2957*/
2958WandExport MagickBooleanType MagickDisplayImages(MagickWand *wand,
2959 const char *server_name)
2960{
2961 MagickBooleanType
2962 status;
2963
2964 assert(wand != (MagickWand *) NULL);
2965 assert(wand->signature == MagickWandSignature);
2966 if (wand->debug != MagickFalse)
2967 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2968 (void) CloneString(&wand->image_info->server_name,server_name);
2969 status=DisplayImages(wand->image_info,wand->images,wand->exception);
2970 return(status);
2971}
2972␌
2973/*
2974%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2975% %
2976% %
2977% %
2978% M a g i c k D i s t o r t I m a g e %
2979% %
2980% %
2981% %
2982%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2983%
2984% MagickDistortImage() distorts an image using various distortion methods, by
2985% mapping color lookups of the source image to a new destination image
2986% usually of the same size as the source image, unless 'bestfit' is set to
2987% true.
2988%
2989% If 'bestfit' is enabled, and distortion allows it, the destination image is
2990% adjusted to ensure the whole source 'image' will just fit within the final
2991% destination image, which will be sized and offset accordingly. Also in
2992% many cases the virtual offset of the source image will be taken into
2993% account in the mapping.
2994%
2995% The format of the MagickDistortImage method is:
2996%
2997% MagickBooleanType MagickDistortImage(MagickWand *wand,
2998% const DistortMethod method,const size_t number_arguments,
2999% const double *arguments,const MagickBooleanType bestfit)
3000%
3001% A description of each parameter follows:
3002%
3003% o image: the image to be distorted.
3004%
3005% o method: the method of image distortion.
3006%
3007% ArcDistortion always ignores the source image offset, and always
3008% 'bestfit' the destination image with the top left corner offset
3009% relative to the polar mapping center.
3010%
3011% Bilinear has no simple inverse mapping so it does not allow 'bestfit'
3012% style of image distortion.
3013%
3014% Affine, Perspective, and Bilinear, do least squares fitting of the
3015% distortion when more than the minimum number of control point pairs
3016% are provided.
3017%
3018% Perspective, and Bilinear, falls back to a Affine distortion when less
3019% that 4 control point pairs are provided. While Affine distortions let
3020% you use any number of control point pairs, that is Zero pairs is a
3021% no-Op (viewport only) distortion, one pair is a translation and two
3022% pairs of control points do a scale-rotate-translate, without any
3023% shearing.
3024%
3025% o number_arguments: the number of arguments given for this distortion
3026% method.
3027%
3028% o arguments: the arguments for this distortion method.
3029%
3030% o bestfit: Attempt to resize destination to fit distorted source.
3031%
3032*/
3033WandExport MagickBooleanType MagickDistortImage(MagickWand *wand,
3034 const DistortMethod method,const size_t number_arguments,
3035 const double *arguments,const MagickBooleanType bestfit)
3036{
3037 Image
3038 *distort_image;
3039
3040 assert(wand != (MagickWand *) NULL);
3041 assert(wand->signature == MagickWandSignature);
3042 if (wand->debug != MagickFalse)
3043 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3044 if (wand->images == (Image *) NULL)
3045 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3046 distort_image=DistortImage(wand->images,method,number_arguments,arguments,
3047 bestfit,wand->exception);
3048 if (distort_image == (Image *) NULL)
3049 return(MagickFalse);
3050 ReplaceImageInList(&wand->images,distort_image);
3051 return(MagickTrue);
3052}
3053␌
3054/*
3055%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3056% %
3057% %
3058% %
3059% M a g i c k D r a w I m a g e %
3060% %
3061% %
3062% %
3063%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3064%
3065% MagickDrawImage() renders the drawing wand on the current image.
3066%
3067% The format of the MagickDrawImage method is:
3068%
3069% MagickBooleanType MagickDrawImage(MagickWand *wand,
3070% const DrawingWand *drawing_wand)
3071%
3072% A description of each parameter follows:
3073%
3074% o wand: the magick wand.
3075%
3076% o drawing_wand: the draw wand.
3077%
3078*/
3079WandExport MagickBooleanType MagickDrawImage(MagickWand *wand,
3080 const DrawingWand *drawing_wand)
3081{
3082 char
3083 *primitive;
3084
3085 DrawInfo
3086 *draw_info;
3087
3088 MagickBooleanType
3089 status;
3090
3091 assert(wand != (MagickWand *) NULL);
3092 assert(wand->signature == MagickWandSignature);
3093 if (wand->debug != MagickFalse)
3094 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3095 if (wand->images == (Image *) NULL)
3096 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3097 draw_info=PeekDrawingWand(drawing_wand);
3098 if ((draw_info == (DrawInfo *) NULL) ||
3099 (draw_info->primitive == (char *) NULL))
3100 return(MagickFalse);
3101 primitive=AcquireString(draw_info->primitive);
3102 draw_info=DestroyDrawInfo(draw_info);
3103 draw_info=CloneDrawInfo(wand->image_info,(DrawInfo *) NULL);
3104 draw_info->primitive=primitive;
3105 status=DrawImage(wand->images,draw_info,wand->exception);
3106 draw_info=DestroyDrawInfo(draw_info);
3107 return(status);
3108}
3109␌
3110/*
3111%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3112% %
3113% %
3114% %
3115% M a g i c k E d g e I m a g e %
3116% %
3117% %
3118% %
3119%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3120%
3121% MagickEdgeImage() enhance edges within the image with a convolution filter
3122% of the given radius. Use a radius of 0 and Edge() selects a suitable
3123% radius for you.
3124%
3125% The format of the MagickEdgeImage method is:
3126%
3127% MagickBooleanType MagickEdgeImage(MagickWand *wand,const double radius)
3128%
3129% A description of each parameter follows:
3130%
3131% o wand: the magick wand.
3132%
3133% o radius: the radius of the pixel neighborhood.
3134%
3135*/
3136WandExport MagickBooleanType MagickEdgeImage(MagickWand *wand,
3137 const double radius)
3138{
3139 Image
3140 *edge_image;
3141
3142 assert(wand != (MagickWand *) NULL);
3143 assert(wand->signature == MagickWandSignature);
3144 if (wand->debug != MagickFalse)
3145 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3146 if (wand->images == (Image *) NULL)
3147 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3148 edge_image=EdgeImage(wand->images,radius,wand->exception);
3149 if (edge_image == (Image *) NULL)
3150 return(MagickFalse);
3151 ReplaceImageInList(&wand->images,edge_image);
3152 return(MagickTrue);
3153}
3154␌
3155/*
3156%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3157% %
3158% %
3159% %
3160% M a g i c k E m b o s s I m a g e %
3161% %
3162% %
3163% %
3164%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3165%
3166% MagickEmbossImage() returns a grayscale image with a three-dimensional
3167% effect. We convolve the image with a Gaussian operator of the given radius
3168% and standard deviation (sigma). For reasonable results, radius should be
3169% larger than sigma. Use a radius of 0 and Emboss() selects a suitable
3170% radius for you.
3171%
3172% The format of the MagickEmbossImage method is:
3173%
3174% MagickBooleanType MagickEmbossImage(MagickWand *wand,const double radius,
3175% const double sigma)
3176%
3177% A description of each parameter follows:
3178%
3179% o wand: the magick wand.
3180%
3181% o radius: the radius of the Gaussian, in pixels, not counting the center
3182% pixel.
3183%
3184% o sigma: the standard deviation of the Gaussian, in pixels.
3185%
3186*/
3187WandExport MagickBooleanType MagickEmbossImage(MagickWand *wand,
3188 const double radius,const double sigma)
3189{
3190 Image
3191 *emboss_image;
3192
3193 assert(wand != (MagickWand *) NULL);
3194 assert(wand->signature == MagickWandSignature);
3195 if (wand->debug != MagickFalse)
3196 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3197 if (wand->images == (Image *) NULL)
3198 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3199 emboss_image=EmbossImage(wand->images,radius,sigma,wand->exception);
3200 if (emboss_image == (Image *) NULL)
3201 return(MagickFalse);
3202 ReplaceImageInList(&wand->images,emboss_image);
3203 return(MagickTrue);
3204}
3205␌
3206/*
3207%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3208% %
3209% %
3210% %
3211% M a g i c k E n c i p h e r I m a g e %
3212% %
3213% %
3214% %
3215%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3216%
3217% MagickEncipherImage() converts plaint pixels to cipher pixels.
3218%
3219% The format of the MagickEncipherImage method is:
3220%
3221% MagickBooleanType MagickEncipherImage(MagickWand *wand,
3222% const char *passphrase)
3223%
3224% A description of each parameter follows:
3225%
3226% o wand: the magick wand.
3227%
3228% o passphrase: the passphrase.
3229%
3230*/
3231WandExport MagickBooleanType MagickEncipherImage(MagickWand *wand,
3232 const char *passphrase)
3233{
3234 assert(wand != (MagickWand *) NULL);
3235 assert(wand->signature == MagickWandSignature);
3236 if (wand->debug != MagickFalse)
3237 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3238 if (wand->images == (Image *) NULL)
3239 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3240 return(EncipherImage(wand->images,passphrase,wand->exception));
3241}
3242␌
3243/*
3244%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3245% %
3246% %
3247% %
3248% M a g i c k E n h a n c e I m a g e %
3249% %
3250% %
3251% %
3252%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3253%
3254% MagickEnhanceImage() applies a digital filter that improves the quality of a
3255% noisy image.
3256%
3257% The format of the MagickEnhanceImage method is:
3258%
3259% MagickBooleanType MagickEnhanceImage(MagickWand *wand)
3260%
3261% A description of each parameter follows:
3262%
3263% o wand: the magick wand.
3264%
3265*/
3266WandExport MagickBooleanType MagickEnhanceImage(MagickWand *wand)
3267{
3268 Image
3269 *enhance_image;
3270
3271 assert(wand != (MagickWand *) NULL);
3272 assert(wand->signature == MagickWandSignature);
3273 if (wand->debug != MagickFalse)
3274 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3275 if (wand->images == (Image *) NULL)
3276 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3277 enhance_image=EnhanceImage(wand->images,wand->exception);
3278 if (enhance_image == (Image *) NULL)
3279 return(MagickFalse);
3280 ReplaceImageInList(&wand->images,enhance_image);
3281 return(MagickTrue);
3282}
3283␌
3284/*
3285%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3286% %
3287% %
3288% %
3289% M a g i c k E q u a l i z e I m a g e %
3290% %
3291% %
3292% %
3293%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3294%
3295% MagickEqualizeImage() equalizes the image histogram.
3296%
3297% The format of the MagickEqualizeImage method is:
3298%
3299% MagickBooleanType MagickEqualizeImage(MagickWand *wand)
3300%
3301% A description of each parameter follows:
3302%
3303% o wand: the magick wand.
3304%
3305% o channel: the image channel(s).
3306%
3307*/
3308WandExport MagickBooleanType MagickEqualizeImage(MagickWand *wand)
3309{
3310 MagickBooleanType
3311 status;
3312
3313 assert(wand != (MagickWand *) NULL);
3314 assert(wand->signature == MagickWandSignature);
3315 if (wand->debug != MagickFalse)
3316 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3317 if (wand->images == (Image *) NULL)
3318 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3319 status=EqualizeImage(wand->images,wand->exception);
3320 return(status);
3321}
3322␌
3323/*
3324%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3325% %
3326% %
3327% %
3328% M a g i c k E v a l u a t e I m a g e %
3329% %
3330% %
3331% %
3332%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3333%
3334% MagickEvaluateImage() applies an arithmetic, relational, or logical
3335% expression to an image. Use these operators to lighten or darken an image,
3336% to increase or decrease contrast in an image, or to produce the "negative"
3337% of an image.
3338%
3339% The format of the MagickEvaluateImage method is:
3340%
3341% MagickBooleanType MagickEvaluateImage(MagickWand *wand,
3342% const MagickEvaluateOperator operator,const double value)
3343% MagickBooleanType MagickEvaluateImages(MagickWand *wand,
3344% const MagickEvaluateOperator operator)
3345%
3346% A description of each parameter follows:
3347%
3348% o wand: the magick wand.
3349%
3350% o op: A channel operator.
3351%
3352% o value: A value value.
3353%
3354*/
3355
3356WandExport MagickWand *MagickEvaluateImages(MagickWand *wand,
3357 const MagickEvaluateOperator op)
3358{
3359 Image
3360 *evaluate_image;
3361
3362 assert(wand != (MagickWand *) NULL);
3363 assert(wand->signature == MagickWandSignature);
3364 if (wand->debug != MagickFalse)
3365 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3366 if (wand->images == (Image *) NULL)
3367 return((MagickWand *) NULL);
3368 evaluate_image=EvaluateImages(wand->images,op,wand->exception);
3369 if (evaluate_image == (Image *) NULL)
3370 return((MagickWand *) NULL);
3371 return(CloneMagickWandFromImages(wand,evaluate_image));
3372}
3373
3374WandExport MagickBooleanType MagickEvaluateImage(MagickWand *wand,
3375 const MagickEvaluateOperator op,const double value)
3376{
3377 MagickBooleanType
3378 status;
3379
3380 assert(wand != (MagickWand *) NULL);
3381 assert(wand->signature == MagickWandSignature);
3382 if (wand->debug != MagickFalse)
3383 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3384 if (wand->images == (Image *) NULL)
3385 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3386 status=EvaluateImage(wand->images,op,value,wand->exception);
3387 return(status);
3388}
3389␌
3390/*
3391%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3392% %
3393% %
3394% %
3395% M a g i c k E x p o r t I m a g e P i x e l s %
3396% %
3397% %
3398% %
3399%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3400%
3401% MagickExportImagePixels() extracts pixel data from an image and returns it
3402% to you. The method returns MagickTrue on success otherwise MagickFalse if
3403% an error is encountered. The data is returned as char, short int, int,
3404% ssize_t, float, or double in the order specified by map.
3405%
3406% Suppose you want to extract the first scanline of a 640x480 image as
3407% character data in red-green-blue order:
3408%
3409% MagickExportImagePixels(wand,0,0,640,1,"RGB",CharPixel,pixels);
3410%
3411% The format of the MagickExportImagePixels method is:
3412%
3413% MagickBooleanType MagickExportImagePixels(MagickWand *wand,
3414% const ssize_t x,const ssize_t y,const size_t columns,
3415% const size_t rows,const char *map,const StorageType storage,
3416% void *pixels)
3417%
3418% A description of each parameter follows:
3419%
3420% o wand: the magick wand.
3421%
3422% o x, y, columns, rows: These values define the perimeter
3423% of a region of pixels you want to extract.
3424%
3425% o map: This string reflects the expected ordering of the pixel array.
3426% It can be any combination or order of R = red, G = green, B = blue,
3427% A = alpha (0 is transparent), O = alpha (0 is opaque), C = cyan,
3428% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
3429% P = pad.
3430%
3431% o storage: Define the data type of the pixels. Float and double types are
3432% expected to be normalized [0..1] otherwise [0..QuantumRange]. Choose from
3433% these types: CharPixel, DoublePixel, FloatPixel, IntegerPixel,
3434% LongPixel, QuantumPixel, or ShortPixel.
3435%
3436% o pixels: This array of values contain the pixel components as defined by
3437% map and type. You must preallocate this array where the expected
3438% length varies depending on the values of width, height, map, and type.
3439%
3440*/
3441WandExport MagickBooleanType MagickExportImagePixels(MagickWand *wand,
3442 const ssize_t x,const ssize_t y,const size_t columns,
3443 const size_t rows,const char *map,const StorageType storage,
3444 void *pixels)
3445{
3446 MagickBooleanType
3447 status;
3448
3449 assert(wand != (MagickWand *) NULL);
3450 assert(wand->signature == MagickWandSignature);
3451 if (wand->debug != MagickFalse)
3452 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3453 if (wand->images == (Image *) NULL)
3454 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3455 status=ExportImagePixels(wand->images,x,y,columns,rows,map,
3456 storage,pixels,wand->exception);
3457 return(status);
3458}
3459␌
3460/*
3461%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3462% %
3463% %
3464% %
3465% M a g i c k E x t e n t I m a g e %
3466% %
3467% %
3468% %
3469%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3470%
3471% MagickExtentImage() extends the image as defined by the geometry, gravity,
3472% and wand background color. Set the (x,y) offset of the geometry to move
3473% the original wand relative to the extended wand.
3474%
3475% The format of the MagickExtentImage method is:
3476%
3477% MagickBooleanType MagickExtentImage(MagickWand *wand,const size_t width,
3478% const size_t height,const ssize_t x,const ssize_t y)
3479%
3480% A description of each parameter follows:
3481%
3482% o wand: the magick wand.
3483%
3484% o width: the region width.
3485%
3486% o height: the region height.
3487%
3488% o x: the region x offset.
3489%
3490% o y: the region y offset.
3491%
3492*/
3493WandExport MagickBooleanType MagickExtentImage(MagickWand *wand,
3494 const size_t width,const size_t height,const ssize_t x,const ssize_t y)
3495{
3496 Image
3497 *extent_image;
3498
3499 RectangleInfo
3500 extent;
3501
3502 assert(wand != (MagickWand *) NULL);
3503 assert(wand->signature == MagickWandSignature);
3504 if (wand->debug != MagickFalse)
3505 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3506 if (wand->images == (Image *) NULL)
3507 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3508 extent.width=width;
3509 extent.height=height;
3510 extent.x=x;
3511 extent.y=y;
3512 extent_image=ExtentImage(wand->images,&extent,wand->exception);
3513 if (extent_image == (Image *) NULL)
3514 return(MagickFalse);
3515 ReplaceImageInList(&wand->images,extent_image);
3516 return(MagickTrue);
3517}
3518␌
3519/*
3520%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3521% %
3522% %
3523% %
3524% M a g i c k F l i p I m a g e %
3525% %
3526% %
3527% %
3528%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3529%
3530% MagickFlipImage() creates a vertical mirror image by reflecting the pixels
3531% around the central x-axis.
3532%
3533% The format of the MagickFlipImage method is:
3534%
3535% MagickBooleanType MagickFlipImage(MagickWand *wand)
3536%
3537% A description of each parameter follows:
3538%
3539% o wand: the magick wand.
3540%
3541*/
3542WandExport MagickBooleanType MagickFlipImage(MagickWand *wand)
3543{
3544 Image
3545 *flip_image;
3546
3547 assert(wand != (MagickWand *) NULL);
3548 assert(wand->signature == MagickWandSignature);
3549 if (wand->debug != MagickFalse)
3550 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3551 if (wand->images == (Image *) NULL)
3552 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3553 flip_image=FlipImage(wand->images,wand->exception);
3554 if (flip_image == (Image *) NULL)
3555 return(MagickFalse);
3556 ReplaceImageInList(&wand->images,flip_image);
3557 return(MagickTrue);
3558}
3559␌
3560/*
3561%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3562% %
3563% %
3564% %
3565% M a g i c k F l o o d f i l l P a i n t I m a g e %
3566% %
3567% %
3568% %
3569%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3570%
3571% MagickFloodfillPaintImage() changes the color value of any pixel that matches
3572% target and is an immediate neighbor. If the method FillToBorderMethod is
3573% specified, the color value is changed for any neighbor pixel that does not
3574% match the bordercolor member of image.
3575%
3576% The format of the MagickFloodfillPaintImage method is:
3577%
3578% MagickBooleanType MagickFloodfillPaintImage(MagickWand *wand,
3579% const PixelWand *fill,const double fuzz,const PixelWand *bordercolor,
3580% const ssize_t x,const ssize_t y,const MagickBooleanType invert)
3581%
3582% A description of each parameter follows:
3583%
3584% o wand: the magick wand.
3585%
3586% o fill: the floodfill color pixel wand.
3587%
3588% o fuzz: By default target must match a particular pixel color
3589% exactly. However, in many cases two colors may differ by a small amount.
3590% The fuzz member of image defines how much tolerance is acceptable to
3591% consider two colors as the same. For example, set fuzz to 10 and the
3592% color red at intensities of 100 and 102 respectively are now interpreted
3593% as the same color for the purposes of the floodfill.
3594%
3595% o bordercolor: the border color pixel wand.
3596%
3597% o x,y: the starting location of the operation.
3598%
3599% o invert: paint any pixel that does not match the target color.
3600%
3601*/
3602WandExport MagickBooleanType MagickFloodfillPaintImage(MagickWand *wand,
3603 const PixelWand *fill,const double fuzz,const PixelWand *bordercolor,
3604 const ssize_t x,const ssize_t y,const MagickBooleanType invert)
3605{
3606 DrawInfo
3607 *draw_info;
3608
3609 MagickBooleanType
3610 status;
3611
3612 PixelInfo
3613 target;
3614
3615 assert(wand != (MagickWand *) NULL);
3616 assert(wand->signature == MagickWandSignature);
3617 if (wand->debug != MagickFalse)
3618 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3619 if (wand->images == (Image *) NULL)
3620 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3621 draw_info=CloneDrawInfo(wand->image_info,(DrawInfo *) NULL);
3622 PixelGetQuantumPacket(fill,&draw_info->fill);
3623 (void) GetOneVirtualPixelInfo(wand->images,TileVirtualPixelMethod,x %
3624 (ssize_t) wand->images->columns,y % (ssize_t) wand->images->rows,&target,
3625 wand->exception);
3626 if (bordercolor != (PixelWand *) NULL)
3627 PixelGetMagickColor(bordercolor,&target);
3628 wand->images->fuzz=fuzz;
3629 status=FloodfillPaintImage(wand->images,draw_info,&target,x,y,invert,
3630 wand->exception);
3631 draw_info=DestroyDrawInfo(draw_info);
3632 return(status);
3633}
3634␌
3635/*
3636%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3637% %
3638% %
3639% %
3640% M a g i c k F l o p I m a g e %
3641% %
3642% %
3643% %
3644%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3645%
3646% MagickFlopImage() creates a horizontal mirror image by reflecting the pixels
3647% around the central y-axis.
3648%
3649% The format of the MagickFlopImage method is:
3650%
3651% MagickBooleanType MagickFlopImage(MagickWand *wand)
3652%
3653% A description of each parameter follows:
3654%
3655% o wand: the magick wand.
3656%
3657*/
3658WandExport MagickBooleanType MagickFlopImage(MagickWand *wand)
3659{
3660 Image
3661 *flop_image;
3662
3663 assert(wand != (MagickWand *) NULL);
3664 assert(wand->signature == MagickWandSignature);
3665 if (wand->debug != MagickFalse)
3666 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3667 if (wand->images == (Image *) NULL)
3668 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3669 flop_image=FlopImage(wand->images,wand->exception);
3670 if (flop_image == (Image *) NULL)
3671 return(MagickFalse);
3672 ReplaceImageInList(&wand->images,flop_image);
3673 return(MagickTrue);
3674}
3675␌
3676/*
3677%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3678% %
3679% %
3680% %
3681% M a g i c k F o u r i e r T r a n s f o r m I m a g e %
3682% %
3683% %
3684% %
3685%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3686%
3687% MagickForwardFourierTransformImage() implements the discrete Fourier
3688% transform (DFT) of the image either as a magnitude / phase or real /
3689% imaginary image pair.
3690%
3691% The format of the MagickForwardFourierTransformImage method is:
3692%
3693% MagickBooleanType MagickForwardFourierTransformImage(MagickWand *wand,
3694% const MagickBooleanType magnitude)
3695%
3696% A description of each parameter follows:
3697%
3698% o wand: the magick wand.
3699%
3700% o magnitude: if true, return as magnitude / phase pair otherwise a real /
3701% imaginary image pair.
3702%
3703*/
3704WandExport MagickBooleanType MagickForwardFourierTransformImage(
3705 MagickWand *wand,const MagickBooleanType magnitude)
3706{
3707 Image
3708 *forward_image;
3709
3710 assert(wand != (MagickWand *) NULL);
3711 assert(wand->signature == MagickWandSignature);
3712 if (wand->debug != MagickFalse)
3713 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3714 if (wand->images == (Image *) NULL)
3715 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3716 forward_image=ForwardFourierTransformImage(wand->images,magnitude,
3717 wand->exception);
3718 if (forward_image == (Image *) NULL)
3719 return(MagickFalse);
3720 ReplaceImageInList(&wand->images,forward_image);
3721 return(MagickTrue);
3722}
3723␌
3724/*
3725%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3726% %
3727% %
3728% %
3729% M a g i c k F r a m e I m a g e %
3730% %
3731% %
3732% %
3733%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3734%
3735% MagickFrameImage() adds a simulated three-dimensional border around the
3736% image. The width and height specify the border width of the vertical and
3737% horizontal sides of the frame. The inner and outer bevels indicate the
3738% width of the inner and outer shadows of the frame.
3739%
3740% The format of the MagickFrameImage method is:
3741%
3742% MagickBooleanType MagickFrameImage(MagickWand *wand,
3743% const PixelWand *matte_color,const size_t width,
3744% const size_t height,const ssize_t inner_bevel,
3745% const ssize_t outer_bevel,const CompositeOperator compose)
3746%
3747% A description of each parameter follows:
3748%
3749% o wand: the magick wand.
3750%
3751% o matte_color: the frame color pixel wand.
3752%
3753% o width: the border width.
3754%
3755% o height: the border height.
3756%
3757% o inner_bevel: the inner bevel width.
3758%
3759% o outer_bevel: the outer bevel width.
3760%
3761% o compose: the composite operator.
3762%
3763*/
3764WandExport MagickBooleanType MagickFrameImage(MagickWand *wand,
3765 const PixelWand *matte_color,const size_t width,const size_t height,
3766 const ssize_t inner_bevel,const ssize_t outer_bevel,
3767 const CompositeOperator compose)
3768{
3769 Image
3770 *frame_image;
3771
3772 FrameInfo
3773 frame_info;
3774
3775 assert(wand != (MagickWand *) NULL);
3776 assert(wand->signature == MagickWandSignature);
3777 if (wand->debug != MagickFalse)
3778 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3779 if (wand->images == (Image *) NULL)
3780 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3781 (void) memset(&frame_info,0,sizeof(frame_info));
3782 frame_info.width=wand->images->columns+2*width;
3783 frame_info.height=wand->images->rows+2*height;
3784 frame_info.x=(ssize_t) width;
3785 frame_info.y=(ssize_t) height;
3786 frame_info.inner_bevel=inner_bevel;
3787 frame_info.outer_bevel=outer_bevel;
3788 PixelGetQuantumPacket(matte_color,&wand->images->matte_color);
3789 frame_image=FrameImage(wand->images,&frame_info,compose,wand->exception);
3790 if (frame_image == (Image *) NULL)
3791 return(MagickFalse);
3792 ReplaceImageInList(&wand->images,frame_image);
3793 return(MagickTrue);
3794}
3795␌
3796/*
3797%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3798% %
3799% %
3800% %
3801% M a g i c k F u n c t i o n I m a g e %
3802% %
3803% %
3804% %
3805%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3806%
3807% MagickFunctionImage() applies an arithmetic, relational, or logical
3808% expression to an image. Use these operators to lighten or darken an image,
3809% to increase or decrease contrast in an image, or to produce the "negative"
3810% of an image.
3811%
3812% The format of the MagickFunctionImage method is:
3813%
3814% MagickBooleanType MagickFunctionImage(MagickWand *wand,
3815% const MagickFunction function,const size_t number_arguments,
3816% const double *arguments)
3817%
3818% A description of each parameter follows:
3819%
3820% o wand: the magick wand.
3821%
3822% o function: the image function.
3823%
3824% o number_arguments: the number of function arguments.
3825%
3826% o arguments: the function arguments.
3827%
3828*/
3829WandExport MagickBooleanType MagickFunctionImage(MagickWand *wand,
3830 const MagickFunction function,const size_t number_arguments,
3831 const double *arguments)
3832{
3833 MagickBooleanType
3834 status;
3835
3836 assert(wand != (MagickWand *) NULL);
3837 assert(wand->signature == MagickWandSignature);
3838 if (wand->debug != MagickFalse)
3839 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3840 if (wand->images == (Image *) NULL)
3841 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3842 status=FunctionImage(wand->images,function,number_arguments,arguments,
3843 wand->exception);
3844 return(status);
3845}
3846␌
3847/*
3848%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3849% %
3850% %
3851% %
3852% M a g i c k F x I m a g e %
3853% %
3854% %
3855% %
3856%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3857%
3858% MagickFxImage() evaluate expression for each pixel in the image.
3859%
3860% The format of the MagickFxImage method is:
3861%
3862% MagickWand *MagickFxImage(MagickWand *wand,const char *expression)
3863%
3864% A description of each parameter follows:
3865%
3866% o wand: the magick wand.
3867%
3868% o expression: the expression.
3869%
3870*/
3871WandExport MagickWand *MagickFxImage(MagickWand *wand,const char *expression)
3872{
3873 Image
3874 *fx_image;
3875
3876 assert(wand != (MagickWand *) NULL);
3877 assert(wand->signature == MagickWandSignature);
3878 if (wand->debug != MagickFalse)
3879 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3880 if (wand->images == (Image *) NULL)
3881 return((MagickWand *) NULL);
3882 fx_image=FxImage(wand->images,expression,wand->exception);
3883 if (fx_image == (Image *) NULL)
3884 return((MagickWand *) NULL);
3885 return(CloneMagickWandFromImages(wand,fx_image));
3886}
3887␌
3888/*
3889%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3890% %
3891% %
3892% %
3893% M a g i c k G a m m a I m a g e %
3894% %
3895% %
3896% %
3897%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3898%
3899% MagickGammaImage() gamma-corrects an image. The same image viewed on
3900% different devices will have perceptual differences in the way the image's
3901% intensities are represented on the screen. Specify individual gamma levels
3902% for the red, green, and blue channels, or adjust all three with the gamma
3903% parameter. Values typically range from 0.8 to 2.3.
3904%
3905% You can also reduce the influence of a particular channel with a gamma
3906% value of 0.
3907%
3908% The format of the MagickGammaImage method is:
3909%
3910% MagickBooleanType MagickGammaImage(MagickWand *wand,const double gamma)
3911%
3912% A description of each parameter follows:
3913%
3914% o wand: the magick wand.
3915%
3916% o level: Define the level of gamma correction.
3917%
3918*/
3919WandExport MagickBooleanType MagickGammaImage(MagickWand *wand,
3920 const double gamma)
3921{
3922 MagickBooleanType
3923 status;
3924
3925 assert(wand != (MagickWand *) NULL);
3926 assert(wand->signature == MagickWandSignature);
3927 if (wand->debug != MagickFalse)
3928 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3929 if (wand->images == (Image *) NULL)
3930 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3931 status=GammaImage(wand->images,gamma,wand->exception);
3932 return(status);
3933}
3934␌
3935/*
3936%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3937% %
3938% %
3939% %
3940% M a g i c k G a u s s i a n B l u r I m a g e %
3941% %
3942% %
3943% %
3944%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3945%
3946% MagickGaussianBlurImage() blurs an image. We convolve the image with a
3947% Gaussian operator of the given radius and standard deviation (sigma).
3948% For reasonable results, the radius should be larger than sigma. Use a
3949% radius of 0 and MagickGaussianBlurImage() selects a suitable radius for you.
3950%
3951% The format of the MagickGaussianBlurImage method is:
3952%
3953% MagickBooleanType MagickGaussianBlurImage(MagickWand *wand,
3954% const double radius,const double sigma)
3955%
3956% A description of each parameter follows:
3957%
3958% o wand: the magick wand.
3959%
3960% o radius: the radius of the Gaussian, in pixels, not counting the center
3961% pixel.
3962%
3963% o sigma: the standard deviation of the Gaussian, in pixels.
3964%
3965*/
3966WandExport MagickBooleanType MagickGaussianBlurImage(MagickWand *wand,
3967 const double radius,const double sigma)
3968{
3969 Image
3970 *blur_image;
3971
3972 assert(wand != (MagickWand *) NULL);
3973 assert(wand->signature == MagickWandSignature);
3974 if (wand->debug != MagickFalse)
3975 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
3976 if (wand->images == (Image *) NULL)
3977 ThrowWandException(WandError,"ContainsNoImages",wand->name);
3978 blur_image=GaussianBlurImage(wand->images,radius,sigma,wand->exception);
3979 if (blur_image == (Image *) NULL)
3980 return(MagickFalse);
3981 ReplaceImageInList(&wand->images,blur_image);
3982 return(MagickTrue);
3983}
3984␌
3985/*
3986%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3987% %
3988% %
3989% %
3990% M a g i c k G e t I m a g e %
3991% %
3992% %
3993% %
3994%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3995%
3996% MagickGetImage() gets the image at the current image index.
3997%
3998% The format of the MagickGetImage method is:
3999%
4000% MagickWand *MagickGetImage(MagickWand *wand)
4001%
4002% A description of each parameter follows:
4003%
4004% o wand: the magick wand.
4005%
4006*/
4007WandExport MagickWand *MagickGetImage(MagickWand *wand)
4008{
4009 Image
4010 *image;
4011
4012 assert(wand != (MagickWand *) NULL);
4013 assert(wand->signature == MagickWandSignature);
4014 if (wand->debug != MagickFalse)
4015 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4016 if (wand->images == (Image *) NULL)
4017 {
4018 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4019 "ContainsNoImages","`%s'",wand->name);
4020 return((MagickWand *) NULL);
4021 }
4022 image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
4023 if (image == (Image *) NULL)
4024 return((MagickWand *) NULL);
4025 return(CloneMagickWandFromImages(wand,image));
4026}
4027␌
4028/*
4029%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4030% %
4031% %
4032% %
4033% M a g i c k G e t I m a g e A l p h a C h a n n e l %
4034% %
4035% %
4036% %
4037%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4038%
4039% MagickGetImageAlphaChannel() returns MagickFalse if the image alpha channel
4040% is not activated. That is, the image is RGB rather than RGBA or CMYK rather
4041% than CMYKA.
4042%
4043% The format of the MagickGetImageAlphaChannel method is:
4044%
4045% MagickBooleanType MagickGetImageAlphaChannel(MagickWand *wand)
4046%
4047% A description of each parameter follows:
4048%
4049% o wand: the magick wand.
4050%
4051*/
4052WandExport MagickBooleanType MagickGetImageAlphaChannel(MagickWand *wand)
4053{
4054 assert(wand != (MagickWand *) NULL);
4055 assert(wand->signature == MagickWandSignature);
4056 if (wand->debug != MagickFalse)
4057 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4058 if (wand->images == (Image *) NULL)
4059 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4060 return(GetImageAlphaChannel(wand->images));
4061}
4062␌
4063/*
4064%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4065% %
4066% %
4067% %
4068% M a g i c k G e t I m a g e C l i p M a s k %
4069% %
4070% %
4071% %
4072%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4073%
4074% MagickGetImageMask() gets the image clip mask at the current image index.
4075%
4076% The format of the MagickGetImageMask method is:
4077%
4078% MagickWand *MagickGetImageMask(MagickWand *wand)
4079%
4080% A description of each parameter follows:
4081%
4082% o wand: the magick wand.
4083%
4084% o type: type of mask, ReadPixelMask or WritePixelMask.
4085%
4086*/
4087WandExport MagickWand *MagickGetImageMask(MagickWand *wand,
4088 const PixelMask type)
4089{
4090 Image
4091 *image;
4092
4093 assert(wand != (MagickWand *) NULL);
4094 assert(wand->signature == MagickWandSignature);
4095 if (wand->debug != MagickFalse)
4096 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4097 if (wand->images == (Image *) NULL)
4098 {
4099 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4100 "ContainsNoImages","`%s'",wand->name);
4101 return((MagickWand *) NULL);
4102 }
4103 image=GetImageMask(wand->images,type,wand->exception);
4104 if (image == (Image *) NULL)
4105 return((MagickWand *) NULL);
4106 return(CloneMagickWandFromImages(wand,image));
4107}
4108␌
4109/*
4110%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4111% %
4112% %
4113% %
4114% M a g i c k G e t I m a g e B a c k g r o u n d C o l o r %
4115% %
4116% %
4117% %
4118%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4119%
4120% MagickGetImageBackgroundColor() returns the image background color.
4121%
4122% The format of the MagickGetImageBackgroundColor method is:
4123%
4124% MagickBooleanType MagickGetImageBackgroundColor(MagickWand *wand,
4125% PixelWand *background_color)
4126%
4127% A description of each parameter follows:
4128%
4129% o wand: the magick wand.
4130%
4131% o background_color: Return the background color.
4132%
4133*/
4134WandExport MagickBooleanType MagickGetImageBackgroundColor(MagickWand *wand,
4135 PixelWand *background_color)
4136{
4137 assert(wand != (MagickWand *) NULL);
4138 assert(wand->signature == MagickWandSignature);
4139 if (wand->debug != MagickFalse)
4140 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4141 if (wand->images == (Image *) NULL)
4142 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4143 PixelSetPixelColor(background_color,&wand->images->background_color);
4144 return(MagickTrue);
4145}
4146␌
4147/*
4148%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4149% %
4150% %
4151% %
4152% M a g i c k G e t I m a g e B l o b %
4153% %
4154% %
4155% %
4156%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4157%
4158% MagickGetImageBlob() implements direct to memory image formats. It returns
4159% the image as a blob (a formatted "file" in memory) and its length, starting
4160% from the current position in the image sequence. Use MagickSetImageFormat()
4161% to set the format to write to the blob (GIF, JPEG, PNG, etc.).
4162%
4163% Utilize MagickResetIterator() to ensure the write is from the beginning of
4164% the image sequence.
4165%
4166% Use MagickRelinquishMemory() to free the blob when you are done with it.
4167%
4168% The format of the MagickGetImageBlob method is:
4169%
4170% unsigned char *MagickGetImageBlob(MagickWand *wand,size_t *length)
4171%
4172% A description of each parameter follows:
4173%
4174% o wand: the magick wand.
4175%
4176% o length: the length of the blob.
4177%
4178*/
4179WandExport unsigned char *MagickGetImageBlob(MagickWand *wand,size_t *length)
4180{
4181 unsigned char
4182 *blob;
4183
4184 assert(wand != (MagickWand *) NULL);
4185 assert(wand->signature == MagickWandSignature);
4186 if (wand->debug != MagickFalse)
4187 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4188 if (wand->images == (Image *) NULL)
4189 {
4190 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4191 "ContainsNoImages","`%s'",wand->name);
4192 return((unsigned char *) NULL);
4193 }
4194 blob=(unsigned char *) ImageToBlob(wand->image_info,wand->images,length,
4195 wand->exception);
4196 return(blob);
4197}
4198␌
4199/*
4200%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4201% %
4202% %
4203% %
4204% M a g i c k G e t I m a g e s B l o b %
4205% %
4206% %
4207% %
4208%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4209%
4210% MagickGetImagesBlob() implements direct to memory image formats. It
4211% returns the image sequence as a blob and its length. The format of the image
4212% determines the format of the returned blob (GIF, JPEG, PNG, etc.). To
4213% return a different image format, use MagickSetImageFormat().
4214%
4215% Note, some image formats do not permit multiple images to the same image
4216% stream (e.g. JPEG). in this instance, just the first image of the
4217% sequence is returned as a blob.
4218%
4219% The format of the MagickGetImagesBlob method is:
4220%
4221% unsigned char *MagickGetImagesBlob(MagickWand *wand,size_t *length)
4222%
4223% A description of each parameter follows:
4224%
4225% o wand: the magick wand.
4226%
4227% o length: the length of the blob.
4228%
4229*/
4230WandExport unsigned char *MagickGetImagesBlob(MagickWand *wand,size_t *length)
4231{
4232 unsigned char
4233 *blob;
4234
4235 assert(wand != (MagickWand *) NULL);
4236 assert(wand->signature == MagickWandSignature);
4237 if (wand->debug != MagickFalse)
4238 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4239 if (wand->images == (Image *) NULL)
4240 {
4241 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4242 "ContainsNoImages","`%s'",wand->name);
4243 return((unsigned char *) NULL);
4244 }
4245 blob=(unsigned char *) ImagesToBlob(wand->image_info,GetFirstImageInList(
4246 wand->images),length,wand->exception);
4247 return(blob);
4248}
4249␌
4250/*
4251%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4252% %
4253% %
4254% %
4255% M a g i c k G e t I m a g e B l u e P r i m a r y %
4256% %
4257% %
4258% %
4259%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4260%
4261% MagickGetImageBluePrimary() returns the chromaticity blue primary point for the
4262% image.
4263%
4264% The format of the MagickGetImageBluePrimary method is:
4265%
4266% MagickBooleanType MagickGetImageBluePrimary(MagickWand *wand,double *x,
4267% double *y,double *z)
4268%
4269% A description of each parameter follows:
4270%
4271% o wand: the magick wand.
4272%
4273% o x: the chromaticity blue primary x-point.
4274%
4275% o y: the chromaticity blue primary y-point.
4276%
4277% o z: the chromaticity blue primary z-point.
4278%
4279*/
4280WandExport MagickBooleanType MagickGetImageBluePrimary(MagickWand *wand,
4281 double *x,double *y,double *z)
4282{
4283 assert(wand != (MagickWand *) NULL);
4284 assert(wand->signature == MagickWandSignature);
4285 if (wand->debug != MagickFalse)
4286 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4287 if (wand->images == (Image *) NULL)
4288 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4289 *x=wand->images->chromaticity.blue_primary.x;
4290 *y=wand->images->chromaticity.blue_primary.y;
4291 *z=wand->images->chromaticity.blue_primary.z;
4292 return(MagickTrue);
4293}
4294␌
4295/*
4296%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4297% %
4298% %
4299% %
4300% M a g i c k G e t I m a g e B o r d e r C o l o r %
4301% %
4302% %
4303% %
4304%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4305%
4306% MagickGetImageBorderColor() returns the image border color.
4307%
4308% The format of the MagickGetImageBorderColor method is:
4309%
4310% MagickBooleanType MagickGetImageBorderColor(MagickWand *wand,
4311% PixelWand *border_color)
4312%
4313% A description of each parameter follows:
4314%
4315% o wand: the magick wand.
4316%
4317% o border_color: Return the border color.
4318%
4319*/
4320WandExport MagickBooleanType MagickGetImageBorderColor(MagickWand *wand,
4321 PixelWand *border_color)
4322{
4323 assert(wand != (MagickWand *) NULL);
4324 assert(wand->signature == MagickWandSignature);
4325 if (wand->debug != MagickFalse)
4326 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4327 if (wand->images == (Image *) NULL)
4328 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4329 PixelSetPixelColor(border_color,&wand->images->border_color);
4330 return(MagickTrue);
4331}
4332␌
4333/*
4334%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4335% %
4336% %
4337% %
4338% M a g i c k G e t I m a g e F e a t u r e s %
4339% %
4340% %
4341% %
4342%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4343%
4344% MagickGetImageFeatures() returns features for each channel in the
4345% image in each of four directions (horizontal, vertical, left and right
4346% diagonals) for the specified distance. The features include the angular
4347% second moment, contrast, correlation, sum of squares: variance, inverse
4348% difference moment, sum average, sum variance, sum entropy, entropy,
4349% difference variance, difference entropy, information measures of
4350% correlation 1, information measures of correlation 2, and maximum
4351% correlation coefficient. You can access the red channel contrast, for
4352% example, like this:
4353%
4354% channel_features=MagickGetImageFeatures(wand,1);
4355% contrast=channel_features[RedPixelChannel].contrast[0];
4356%
4357% Use MagickRelinquishMemory() to free the statistics buffer.
4358%
4359% The format of the MagickGetImageFeatures method is:
4360%
4361% ChannelFeatures *MagickGetImageFeatures(MagickWand *wand,
4362% const size_t distance)
4363%
4364% A description of each parameter follows:
4365%
4366% o wand: the magick wand.
4367%
4368% o distance: the distance.
4369%
4370*/
4371WandExport ChannelFeatures *MagickGetImageFeatures(MagickWand *wand,
4372 const size_t distance)
4373{
4374 assert(wand != (MagickWand *) NULL);
4375 assert(wand->signature == MagickWandSignature);
4376 if (wand->debug != MagickFalse)
4377 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4378 if (wand->images == (Image *) NULL)
4379 {
4380 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4381 "ContainsNoImages","`%s'",wand->name);
4382 return((ChannelFeatures *) NULL);
4383 }
4384 return(GetImageFeatures(wand->images,distance,wand->exception));
4385}
4386␌
4387/*
4388%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4389% %
4390% %
4391% %
4392% M a g i c k G e t I m a g e K u r t o s i s %
4393% %
4394% %
4395% %
4396%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4397%
4398% MagickGetImageKurtosis() gets the kurtosis and skewness of one or
4399% more image channels.
4400%
4401% The format of the MagickGetImageKurtosis method is:
4402%
4403% MagickBooleanType MagickGetImageKurtosis(MagickWand *wand,
4404% double *kurtosis,double *skewness)
4405%
4406% A description of each parameter follows:
4407%
4408% o wand: the magick wand.
4409%
4410% o kurtosis: The kurtosis for the specified channel(s).
4411%
4412% o skewness: The skewness for the specified channel(s).
4413%
4414*/
4415WandExport MagickBooleanType MagickGetImageKurtosis(MagickWand *wand,
4416 double *kurtosis,double *skewness)
4417{
4418 MagickBooleanType
4419 status;
4420
4421 assert(wand != (MagickWand *) NULL);
4422 assert(wand->signature == MagickWandSignature);
4423 if (wand->debug != MagickFalse)
4424 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4425 if (wand->images == (Image *) NULL)
4426 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4427 status=GetImageKurtosis(wand->images,kurtosis,skewness,wand->exception);
4428 return(status);
4429}
4430␌
4431/*
4432%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4433% %
4434% %
4435% %
4436% M a g i c k G e t I m a g e M e a n %
4437% %
4438% %
4439% %
4440%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4441%
4442% MagickGetImageMean() gets the mean and standard deviation of one or more
4443% image channels.
4444%
4445% The format of the MagickGetImageMean method is:
4446%
4447% MagickBooleanType MagickGetImageMean(MagickWand *wand,double *mean,
4448% double *standard_deviation)
4449%
4450% A description of each parameter follows:
4451%
4452% o wand: the magick wand.
4453%
4454% o channel: the image channel(s).
4455%
4456% o mean: The mean pixel value for the specified channel(s).
4457%
4458% o standard_deviation: The standard deviation for the specified channel(s).
4459%
4460*/
4461WandExport MagickBooleanType MagickGetImageMean(MagickWand *wand,double *mean,
4462 double *standard_deviation)
4463{
4464 MagickBooleanType
4465 status;
4466
4467 assert(wand != (MagickWand *) NULL);
4468 assert(wand->signature == MagickWandSignature);
4469 if (wand->debug != MagickFalse)
4470 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4471 if (wand->images == (Image *) NULL)
4472 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4473 status=GetImageMean(wand->images,mean,standard_deviation,wand->exception);
4474 return(status);
4475}
4476␌
4477/*
4478%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4479% %
4480% %
4481% %
4482% M a g i c k G e t I m a g e R a n g e %
4483% %
4484% %
4485% %
4486%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4487%
4488% MagickGetImageRange() gets the range for one or more image channels.
4489%
4490% The format of the MagickGetImageRange method is:
4491%
4492% MagickBooleanType MagickGetImageRange(MagickWand *wand,double *minima,
4493% double *maxima)
4494%
4495% A description of each parameter follows:
4496%
4497% o wand: the magick wand.
4498%
4499% o minima: The minimum pixel value for the specified channel(s).
4500%
4501% o maxima: The maximum pixel value for the specified channel(s).
4502%
4503*/
4504WandExport MagickBooleanType MagickGetImageRange(MagickWand *wand,
4505 double *minima,double *maxima)
4506{
4507 MagickBooleanType
4508 status;
4509
4510 assert(wand != (MagickWand *) NULL);
4511 assert(wand->signature == MagickWandSignature);
4512 if (wand->debug != MagickFalse)
4513 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4514 if (wand->images == (Image *) NULL)
4515 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4516 status=GetImageRange(wand->images,minima,maxima,wand->exception);
4517 return(status);
4518}
4519␌
4520/*
4521%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4522% %
4523% %
4524% %
4525% M a g i c k G e t I m a g e S t a t i s t i c s %
4526% %
4527% %
4528% %
4529%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4530%
4531% MagickGetImageStatistics() returns statistics for each channel in the
4532% image. The statistics include the channel depth, its minima and
4533% maxima, the mean, the standard deviation, the kurtosis and the skewness.
4534% You can access the red channel mean, for example, like this:
4535%
4536% channel_statistics=MagickGetImageStatistics(wand);
4537% red_mean=channel_statistics[RedPixelChannel].mean;
4538%
4539% Use MagickRelinquishMemory() to free the statistics buffer.
4540%
4541% The format of the MagickGetImageStatistics method is:
4542%
4543% ChannelStatistics *MagickGetImageStatistics(MagickWand *wand)
4544%
4545% A description of each parameter follows:
4546%
4547% o wand: the magick wand.
4548%
4549*/
4550WandExport ChannelStatistics *MagickGetImageStatistics(MagickWand *wand)
4551{
4552 assert(wand != (MagickWand *) NULL);
4553 assert(wand->signature == MagickWandSignature);
4554 if (wand->debug != MagickFalse)
4555 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4556 if (wand->images == (Image *) NULL)
4557 {
4558 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4559 "ContainsNoImages","`%s'",wand->name);
4560 return((ChannelStatistics *) NULL);
4561 }
4562 return(GetImageStatistics(wand->images,wand->exception));
4563}
4564␌
4565/*
4566%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4567% %
4568% %
4569% %
4570% M a g i c k G e t I m a g e C o l o r m a p C o l o r %
4571% %
4572% %
4573% %
4574%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4575%
4576% MagickGetImageColormapColor() returns the color of the specified colormap
4577% index.
4578%
4579% The format of the MagickGetImageColormapColor method is:
4580%
4581% MagickBooleanType MagickGetImageColormapColor(MagickWand *wand,
4582% const size_t index,PixelWand *color)
4583%
4584% A description of each parameter follows:
4585%
4586% o wand: the magick wand.
4587%
4588% o index: the offset into the image colormap.
4589%
4590% o color: Return the colormap color in this wand.
4591%
4592*/
4593WandExport MagickBooleanType MagickGetImageColormapColor(MagickWand *wand,
4594 const size_t index,PixelWand *color)
4595{
4596 assert(wand != (MagickWand *) NULL);
4597 assert(wand->signature == MagickWandSignature);
4598 if (wand->debug != MagickFalse)
4599 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4600 if (wand->images == (Image *) NULL)
4601 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4602 if ((wand->images->colormap == (PixelInfo *) NULL) ||
4603 (index >= wand->images->colors))
4604 {
4605 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4606 "InvalidColormapIndex","`%s'",wand->name);
4607 return(MagickFalse);
4608 }
4609 PixelSetPixelColor(color,wand->images->colormap+index);
4610 return(MagickTrue);
4611}
4612␌
4613/*
4614%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4615% %
4616% %
4617% %
4618% M a g i c k G e t I m a g e C o l o r s %
4619% %
4620% %
4621% %
4622%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4623%
4624% MagickGetImageColors() gets the number of unique colors in the image.
4625%
4626% The format of the MagickGetImageColors method is:
4627%
4628% size_t MagickGetImageColors(MagickWand *wand)
4629%
4630% A description of each parameter follows:
4631%
4632% o wand: the magick wand.
4633%
4634*/
4635WandExport size_t MagickGetImageColors(MagickWand *wand)
4636{
4637 assert(wand != (MagickWand *) NULL);
4638 assert(wand->signature == MagickWandSignature);
4639 if (wand->debug != MagickFalse)
4640 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4641 if (wand->images == (Image *) NULL)
4642 {
4643 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4644 "ContainsNoImages","`%s'",wand->name);
4645 return(0);
4646 }
4647 return(GetNumberColors(wand->images,(FILE *) NULL,wand->exception));
4648}
4649␌
4650/*
4651%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4652% %
4653% %
4654% %
4655% M a g i c k G e t I m a g e C o l o r s p a c e %
4656% %
4657% %
4658% %
4659%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4660%
4661% MagickGetImageColorspace() gets the image colorspace.
4662%
4663% The format of the MagickGetImageColorspace method is:
4664%
4665% ColorspaceType MagickGetImageColorspace(MagickWand *wand)
4666%
4667% A description of each parameter follows:
4668%
4669% o wand: the magick wand.
4670%
4671*/
4672WandExport ColorspaceType MagickGetImageColorspace(MagickWand *wand)
4673{
4674 assert(wand != (MagickWand *) NULL);
4675 assert(wand->signature == MagickWandSignature);
4676 if (wand->debug != MagickFalse)
4677 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4678 if (wand->images == (Image *) NULL)
4679 {
4680 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4681 "ContainsNoImages","`%s'",wand->name);
4682 return(UndefinedColorspace);
4683 }
4684 return(wand->images->colorspace);
4685}
4686␌
4687/*
4688%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4689% %
4690% %
4691% %
4692% M a g i c k G e t I m a g e C o m p o s e %
4693% %
4694% %
4695% %
4696%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4697%
4698% MagickGetImageCompose() returns the composite operator associated with the
4699% image.
4700%
4701% The format of the MagickGetImageCompose method is:
4702%
4703% CompositeOperator MagickGetImageCompose(MagickWand *wand)
4704%
4705% A description of each parameter follows:
4706%
4707% o wand: the magick wand.
4708%
4709*/
4710WandExport CompositeOperator MagickGetImageCompose(MagickWand *wand)
4711{
4712 assert(wand != (MagickWand *) NULL);
4713 assert(wand->signature == MagickWandSignature);
4714 if (wand->debug != MagickFalse)
4715 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4716 if (wand->images == (Image *) NULL)
4717 {
4718 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4719 "ContainsNoImages","`%s'",wand->name);
4720 return(UndefinedCompositeOp);
4721 }
4722 return(wand->images->compose);
4723}
4724␌
4725/*
4726%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4727% %
4728% %
4729% %
4730% M a g i c k G e t I m a g e C o m p r e s s i o n %
4731% %
4732% %
4733% %
4734%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4735%
4736% MagickGetImageCompression() gets the image compression.
4737%
4738% The format of the MagickGetImageCompression method is:
4739%
4740% CompressionType MagickGetImageCompression(MagickWand *wand)
4741%
4742% A description of each parameter follows:
4743%
4744% o wand: the magick wand.
4745%
4746*/
4747WandExport CompressionType MagickGetImageCompression(MagickWand *wand)
4748{
4749 assert(wand != (MagickWand *) NULL);
4750 assert(wand->signature == MagickWandSignature);
4751 if (wand->debug != MagickFalse)
4752 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4753 if (wand->images == (Image *) NULL)
4754 {
4755 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4756 "ContainsNoImages","`%s'",wand->name);
4757 return(UndefinedCompression);
4758 }
4759 return(wand->images->compression);
4760}
4761␌
4762/*
4763%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4764% %
4765% %
4766% %
4767% M a g i c k G e t I m a g e C o m p r e s s i o n Q u a l i t y %
4768% %
4769% %
4770% %
4771%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4772%
4773% MagickGetImageCompressionQuality() gets the image compression quality.
4774%
4775% The format of the MagickGetImageCompressionQuality method is:
4776%
4777% size_t MagickGetImageCompressionQuality(MagickWand *wand)
4778%
4779% A description of each parameter follows:
4780%
4781% o wand: the magick wand.
4782%
4783*/
4784WandExport size_t MagickGetImageCompressionQuality(MagickWand *wand)
4785{
4786 assert(wand != (MagickWand *) NULL);
4787 assert(wand->signature == MagickWandSignature);
4788 if (wand->debug != MagickFalse)
4789 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4790 if (wand->images == (Image *) NULL)
4791 {
4792 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4793 "ContainsNoImages","`%s'",wand->name);
4794 return(0UL);
4795 }
4796 return(wand->images->quality);
4797}
4798␌
4799/*
4800%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4801% %
4802% %
4803% %
4804% M a g i c k G e t I m a g e D e l a y %
4805% %
4806% %
4807% %
4808%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4809%
4810% MagickGetImageDelay() gets the image delay.
4811%
4812% The format of the MagickGetImageDelay method is:
4813%
4814% size_t MagickGetImageDelay(MagickWand *wand)
4815%
4816% A description of each parameter follows:
4817%
4818% o wand: the magick wand.
4819%
4820*/
4821WandExport size_t MagickGetImageDelay(MagickWand *wand)
4822{
4823 assert(wand != (MagickWand *) NULL);
4824 assert(wand->signature == MagickWandSignature);
4825 if (wand->debug != MagickFalse)
4826 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4827 if (wand->images == (Image *) NULL)
4828 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4829 return(wand->images->delay);
4830}
4831␌
4832/*
4833%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4834% %
4835% %
4836% %
4837% M a g i c k G e t I m a g e D e p t h %
4838% %
4839% %
4840% %
4841%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4842%
4843% MagickGetImageDepth() gets the image depth.
4844%
4845% The format of the MagickGetImageDepth method is:
4846%
4847% size_t MagickGetImageDepth(MagickWand *wand)
4848%
4849% A description of each parameter follows:
4850%
4851% o wand: the magick wand.
4852%
4853*/
4854WandExport size_t MagickGetImageDepth(MagickWand *wand)
4855{
4856 assert(wand != (MagickWand *) NULL);
4857 assert(wand->signature == MagickWandSignature);
4858 if (wand->debug != MagickFalse)
4859 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4860 if (wand->images == (Image *) NULL)
4861 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4862 return(wand->images->depth);
4863}
4864␌
4865/*
4866%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4867% %
4868% %
4869% %
4870% M a g i c k G e t I m a g e D i s p o s e %
4871% %
4872% %
4873% %
4874%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4875%
4876% MagickGetImageDispose() gets the image disposal method.
4877%
4878% The format of the MagickGetImageDispose method is:
4879%
4880% DisposeType MagickGetImageDispose(MagickWand *wand)
4881%
4882% A description of each parameter follows:
4883%
4884% o wand: the magick wand.
4885%
4886*/
4887WandExport DisposeType MagickGetImageDispose(MagickWand *wand)
4888{
4889 assert(wand != (MagickWand *) NULL);
4890 assert(wand->signature == MagickWandSignature);
4891 if (wand->debug != MagickFalse)
4892 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4893 if (wand->images == (Image *) NULL)
4894 {
4895 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4896 "ContainsNoImages","`%s'",wand->name);
4897 return(UndefinedDispose);
4898 }
4899 return((DisposeType) wand->images->dispose);
4900}
4901␌
4902/*
4903%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4904% %
4905% %
4906% %
4907% M a g i c k G e t I m a g e D i s t o r t i o n %
4908% %
4909% %
4910% %
4911%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4912%
4913% MagickGetImageDistortion() compares an image to a reconstructed image and
4914% returns the specified distortion metric.
4915%
4916% The format of the MagickGetImageDistortion method is:
4917%
4918% MagickBooleanType MagickGetImageDistortion(MagickWand *wand,
4919% const MagickWand *reference,const MetricType metric,
4920% double *distortion)
4921%
4922% A description of each parameter follows:
4923%
4924% o wand: the magick wand.
4925%
4926% o reference: the reference wand.
4927%
4928% o metric: the metric.
4929%
4930% o distortion: the computed distortion between the images.
4931%
4932*/
4933WandExport MagickBooleanType MagickGetImageDistortion(MagickWand *wand,
4934 const MagickWand *reference,const MetricType metric,double *distortion)
4935{
4936 MagickBooleanType
4937 status;
4938
4939 assert(wand != (MagickWand *) NULL);
4940 assert(wand->signature == MagickWandSignature);
4941 if (wand->debug != MagickFalse)
4942 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4943 if ((wand->images == (Image *) NULL) || (reference->images == (Image *) NULL))
4944 ThrowWandException(WandError,"ContainsNoImages",wand->name);
4945 status=GetImageDistortion(wand->images,reference->images,metric,distortion,
4946 wand->exception);
4947 return(status);
4948}
4949␌
4950/*
4951%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4952% %
4953% %
4954% %
4955% M a g i c k G e t I m a g e D i s t o r t i o n s %
4956% %
4957% %
4958% %
4959%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4960%
4961% MagickGetImageDistortions() compares one or more pixel channels of an
4962% image to a reconstructed image and returns the specified distortion metrics.
4963%
4964% Use MagickRelinquishMemory() to free the metrics when you are done with them.
4965%
4966% The format of the MagickGetImageDistortion method is:
4967%
4968% double *MagickGetImageDistortion(MagickWand *wand,
4969% const MagickWand *reference,const MetricType metric)
4970%
4971% A description of each parameter follows:
4972%
4973% o wand: the magick wand.
4974%
4975% o reference: the reference wand.
4976%
4977% o metric: the metric.
4978%
4979*/
4980WandExport double *MagickGetImageDistortions(MagickWand *wand,
4981 const MagickWand *reference,const MetricType metric)
4982{
4983 double
4984 *channel_distortion;
4985
4986 assert(wand != (MagickWand *) NULL);
4987 assert(wand->signature == MagickWandSignature);
4988 if (wand->debug != MagickFalse)
4989 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
4990 assert(reference != (MagickWand *) NULL);
4991 assert(reference->signature == MagickWandSignature);
4992 if ((wand->images == (Image *) NULL) || (reference->images == (Image *) NULL))
4993 {
4994 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
4995 "ContainsNoImages","`%s'",wand->name);
4996 return((double *) NULL);
4997 }
4998 channel_distortion=GetImageDistortions(wand->images,reference->images,
4999 metric,wand->exception);
5000 return(channel_distortion);
5001}
5002␌
5003/*
5004%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5005% %
5006% %
5007% %
5008% M a g i c k G e t I m a g e E n d i a n %
5009% %
5010% %
5011% %
5012%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5013%
5014% MagickGetImageEndian() gets the image endian.
5015%
5016% The format of the MagickGetImageEndian method is:
5017%
5018% EndianType MagickGetImageEndian(MagickWand *wand)
5019%
5020% A description of each parameter follows:
5021%
5022% o wand: the magick wand.
5023%
5024*/
5025WandExport EndianType MagickGetImageEndian(MagickWand *wand)
5026{
5027 assert(wand != (MagickWand *) NULL);
5028 assert(wand->signature == MagickWandSignature);
5029 if (wand->debug != MagickFalse)
5030 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5031 if (wand->images == (Image *) NULL)
5032 {
5033 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5034 "ContainsNoImages","`%s'",wand->name);
5035 return(UndefinedEndian);
5036 }
5037 return(wand->images->endian);
5038}
5039␌
5040/*
5041%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5042% %
5043% %
5044% %
5045% M a g i c k G e t I m a g e F i l e n a m e %
5046% %
5047% %
5048% %
5049%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5050%
5051% MagickGetImageFilename() returns the filename of a particular image in a
5052% sequence.
5053%
5054% The format of the MagickGetImageFilename method is:
5055%
5056% char *MagickGetImageFilename(MagickWand *wand)
5057%
5058% A description of each parameter follows:
5059%
5060% o wand: the magick wand.
5061%
5062*/
5063WandExport char *MagickGetImageFilename(MagickWand *wand)
5064{
5065 assert(wand != (MagickWand *) NULL);
5066 assert(wand->signature == MagickWandSignature);
5067 if (wand->debug != MagickFalse)
5068 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5069 if (wand->images == (Image *) NULL)
5070 {
5071 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5072 "ContainsNoImages","`%s'",wand->name);
5073 return((char *) NULL);
5074 }
5075 return(AcquireString(wand->images->filename));
5076}
5077␌
5078/*
5079%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5080% %
5081% %
5082% %
5083% M a g i c k G e t I m a g e F i l t e r %
5084% %
5085% %
5086% %
5087%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5088%
5089% MagickGetImageFilter() gets the image filter.
5090%
5091% The format of the MagickGetImageFilter method is:
5092%
5093% FilterType MagickGetImageFilter(MagickWand *wand)
5094%
5095% A description of each parameter follows:
5096%
5097% o wand: the magick wand.
5098%
5099*/
5100WandExport FilterType MagickGetImageFilter(MagickWand *wand)
5101{
5102 assert(wand != (MagickWand *) NULL);
5103 assert(wand->signature == MagickWandSignature);
5104 if (wand->debug != MagickFalse)
5105 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5106 if (wand->images == (Image *) NULL)
5107 {
5108 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5109 "ContainsNoImages","`%s'",wand->name);
5110 return(UndefinedFilter);
5111 }
5112 return(wand->images->filter);
5113}
5114␌
5115/*
5116%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5117% %
5118% %
5119% %
5120% M a g i c k G e t I m a g e F o r m a t %
5121% %
5122% %
5123% %
5124%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5125%
5126% MagickGetImageFormat() returns the format of a particular image in a
5127% sequence.
5128%
5129% The format of the MagickGetImageFormat method is:
5130%
5131% char *MagickGetImageFormat(MagickWand *wand)
5132%
5133% A description of each parameter follows:
5134%
5135% o wand: the magick wand.
5136%
5137*/
5138WandExport char *MagickGetImageFormat(MagickWand *wand)
5139{
5140 assert(wand != (MagickWand *) NULL);
5141 assert(wand->signature == MagickWandSignature);
5142 if (wand->debug != MagickFalse)
5143 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5144 if (wand->images == (Image *) NULL)
5145 {
5146 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5147 "ContainsNoImages","`%s'",wand->name);
5148 return((char *) NULL);
5149 }
5150 return(AcquireString(wand->images->magick));
5151}
5152␌
5153/*
5154%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5155% %
5156% %
5157% %
5158% M a g i c k G e t I m a g e F u z z %
5159% %
5160% %
5161% %
5162%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5163%
5164% MagickGetImageFuzz() gets the image fuzz.
5165%
5166% The format of the MagickGetImageFuzz method is:
5167%
5168% double MagickGetImageFuzz(MagickWand *wand)
5169%
5170% A description of each parameter follows:
5171%
5172% o wand: the magick wand.
5173%
5174*/
5175WandExport double MagickGetImageFuzz(MagickWand *wand)
5176{
5177 assert(wand != (MagickWand *) NULL);
5178 assert(wand->signature == MagickWandSignature);
5179 if (wand->debug != MagickFalse)
5180 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5181 if (wand->images == (Image *) NULL)
5182 {
5183 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5184 "ContainsNoImages","`%s'",wand->name);
5185 return(0.0);
5186 }
5187 return(wand->images->fuzz);
5188}
5189␌
5190/*
5191%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5192% %
5193% %
5194% %
5195% M a g i c k G e t I m a g e G a m m a %
5196% %
5197% %
5198% %
5199%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5200%
5201% MagickGetImageGamma() gets the image gamma.
5202%
5203% The format of the MagickGetImageGamma method is:
5204%
5205% double MagickGetImageGamma(MagickWand *wand)
5206%
5207% A description of each parameter follows:
5208%
5209% o wand: the magick wand.
5210%
5211*/
5212WandExport double MagickGetImageGamma(MagickWand *wand)
5213{
5214 assert(wand != (MagickWand *) NULL);
5215 assert(wand->signature == MagickWandSignature);
5216 if (wand->debug != MagickFalse)
5217 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5218 if (wand->images == (Image *) NULL)
5219 {
5220 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5221 "ContainsNoImages","`%s'",wand->name);
5222 return(0.0);
5223 }
5224 return(wand->images->gamma);
5225}
5226␌
5227/*
5228%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5229% %
5230% %
5231% %
5232% M a g i c k G e t I m a g e G r a v i t y %
5233% %
5234% %
5235% %
5236%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5237%
5238% MagickGetImageGravity() gets the image gravity.
5239%
5240% The format of the MagickGetImageGravity method is:
5241%
5242% GravityType MagickGetImageGravity(MagickWand *wand)
5243%
5244% A description of each parameter follows:
5245%
5246% o wand: the magick wand.
5247%
5248*/
5249WandExport GravityType MagickGetImageGravity(MagickWand *wand)
5250{
5251 assert(wand != (MagickWand *) NULL);
5252 assert(wand->signature == MagickWandSignature);
5253 if (wand->debug != MagickFalse)
5254 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5255 if (wand->images == (Image *) NULL)
5256 {
5257 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5258 "ContainsNoImages","`%s'",wand->name);
5259 return(UndefinedGravity);
5260 }
5261 return(wand->images->gravity);
5262}
5263␌
5264/*
5265%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5266% %
5267% %
5268% %
5269% M a g i c k G e t I m a g e G r e e n P r i m a r y %
5270% %
5271% %
5272% %
5273%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5274%
5275% MagickGetImageGreenPrimary() returns the chromaticity green primary point.
5276%
5277% The format of the MagickGetImageGreenPrimary method is:
5278%
5279% MagickBooleanType MagickGetImageGreenPrimary(MagickWand *wand,double *x,
5280% double *y,double *z)
5281%
5282% A description of each parameter follows:
5283%
5284% o wand: the magick wand.
5285%
5286% o x: the chromaticity green primary x-point.
5287%
5288% o y: the chromaticity green primary y-point.
5289%
5290% o z: the chromaticity green primary z-point.
5291%
5292*/
5293WandExport MagickBooleanType MagickGetImageGreenPrimary(MagickWand *wand,
5294 double *x,double *y,double *z)
5295{
5296 assert(wand != (MagickWand *) NULL);
5297 assert(wand->signature == MagickWandSignature);
5298 if (wand->debug != MagickFalse)
5299 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5300 if (wand->images == (Image *) NULL)
5301 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5302 *x=wand->images->chromaticity.green_primary.x;
5303 *y=wand->images->chromaticity.green_primary.y;
5304 *z=wand->images->chromaticity.green_primary.z;
5305 return(MagickTrue);
5306}
5307␌
5308/*
5309%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5310% %
5311% %
5312% %
5313% M a g i c k G e t I m a g e H e i g h t %
5314% %
5315% %
5316% %
5317%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5318%
5319% MagickGetImageHeight() returns the image height.
5320%
5321% The format of the MagickGetImageHeight method is:
5322%
5323% size_t MagickGetImageHeight(MagickWand *wand)
5324%
5325% A description of each parameter follows:
5326%
5327% o wand: the magick wand.
5328%
5329*/
5330WandExport size_t MagickGetImageHeight(MagickWand *wand)
5331{
5332 assert(wand != (MagickWand *) NULL);
5333 assert(wand->signature == MagickWandSignature);
5334 if (wand->debug != MagickFalse)
5335 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5336 if (wand->images == (Image *) NULL)
5337 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5338 return(wand->images->rows);
5339}
5340␌
5341/*
5342%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5343% %
5344% %
5345% %
5346% M a g i c k G e t I m a g e H i s t o g r a m %
5347% %
5348% %
5349% %
5350%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5351%
5352% MagickGetImageHistogram() returns the image histogram as an array of
5353% PixelWand wands.
5354%
5355% The format of the MagickGetImageHistogram method is:
5356%
5357% PixelWand **MagickGetImageHistogram(MagickWand *wand,
5358% size_t *number_colors)
5359%
5360% A description of each parameter follows:
5361%
5362% o wand: the magick wand.
5363%
5364% o number_colors: the number of unique colors in the image and the number
5365% of pixel wands returned.
5366%
5367*/
5368WandExport PixelWand **MagickGetImageHistogram(MagickWand *wand,
5369 size_t *number_colors)
5370{
5371 PixelInfo
5372 *histogram;
5373
5374 PixelWand
5375 **pixel_wands;
5376
5377 ssize_t
5378 i;
5379
5380 assert(wand != (MagickWand *) NULL);
5381 assert(wand->signature == MagickWandSignature);
5382 if (wand->debug != MagickFalse)
5383 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5384 if (wand->images == (Image *) NULL)
5385 {
5386 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5387 "ContainsNoImages","`%s'",wand->name);
5388 return((PixelWand **) NULL);
5389 }
5390 histogram=GetImageHistogram(wand->images,number_colors,wand->exception);
5391 if (histogram == (PixelInfo *) NULL)
5392 return((PixelWand **) NULL);
5393 pixel_wands=NewPixelWands(*number_colors);
5394 for (i=0; i < (ssize_t) *number_colors; i++)
5395 {
5396 PixelSetPixelColor(pixel_wands[i],&histogram[i]);
5397 PixelSetColorCount(pixel_wands[i],(size_t) histogram[i].count);
5398 }
5399 histogram=(PixelInfo *) RelinquishMagickMemory(histogram);
5400 return(pixel_wands);
5401}
5402␌
5403/*
5404%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5405% %
5406% %
5407% %
5408% M a g i c k G e t I m a g e I n t e r l a c e S c h e m e %
5409% %
5410% %
5411% %
5412%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5413%
5414% MagickGetImageInterlaceScheme() gets the image interlace scheme.
5415%
5416% The format of the MagickGetImageInterlaceScheme method is:
5417%
5418% InterlaceType MagickGetImageInterlaceScheme(MagickWand *wand)
5419%
5420% A description of each parameter follows:
5421%
5422% o wand: the magick wand.
5423%
5424*/
5425WandExport InterlaceType MagickGetImageInterlaceScheme(MagickWand *wand)
5426{
5427 assert(wand != (MagickWand *) NULL);
5428 assert(wand->signature == MagickWandSignature);
5429 if (wand->debug != MagickFalse)
5430 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5431 if (wand->images == (Image *) NULL)
5432 {
5433 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5434 "ContainsNoImages","`%s'",wand->name);
5435 return(UndefinedInterlace);
5436 }
5437 return(wand->images->interlace);
5438}
5439␌
5440/*
5441%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5442% %
5443% %
5444% %
5445% M a g i c k G e t I m a g e I n t e r p o l a t e M e t h o d %
5446% %
5447% %
5448% %
5449%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5450%
5451% MagickGetImageInterpolateMethod() returns the interpolation method for the
5452% specified image.
5453%
5454% The format of the MagickGetImageInterpolateMethod method is:
5455%
5456% PixelInterpolateMethod MagickGetImageInterpolateMethod(MagickWand *wand)
5457%
5458% A description of each parameter follows:
5459%
5460% o wand: the magick wand.
5461%
5462*/
5463WandExport PixelInterpolateMethod MagickGetImageInterpolateMethod(
5464 MagickWand *wand)
5465{
5466 assert(wand != (MagickWand *) NULL);
5467 assert(wand->signature == MagickWandSignature);
5468 if (wand->debug != MagickFalse)
5469 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5470 if (wand->images == (Image *) NULL)
5471 {
5472 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5473 "ContainsNoImages","`%s'",wand->name);
5474 return(UndefinedInterpolatePixel);
5475 }
5476 return(wand->images->interpolate);
5477}
5478␌
5479/*
5480%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5481% %
5482% %
5483% %
5484% M a g i c k G e t I m a g e I t e r a t i o n s %
5485% %
5486% %
5487% %
5488%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5489%
5490% MagickGetImageIterations() gets the image iterations.
5491%
5492% The format of the MagickGetImageIterations method is:
5493%
5494% size_t MagickGetImageIterations(MagickWand *wand)
5495%
5496% A description of each parameter follows:
5497%
5498% o wand: the magick wand.
5499%
5500*/
5501WandExport size_t MagickGetImageIterations(MagickWand *wand)
5502{
5503 assert(wand != (MagickWand *) NULL);
5504 assert(wand->signature == MagickWandSignature);
5505 if (wand->debug != MagickFalse)
5506 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5507 if (wand->images == (Image *) NULL)
5508 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5509 return(wand->images->iterations);
5510}
5511␌
5512/*
5513%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5514% %
5515% %
5516% %
5517% M a g i c k G e t I m a g e L e n g t h %
5518% %
5519% %
5520% %
5521%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5522%
5523% MagickGetImageLength() returns the image length in bytes.
5524%
5525% The format of the MagickGetImageLength method is:
5526%
5527% MagickBooleanType MagickGetImageLength(MagickWand *wand,
5528% MagickSizeType *length)
5529%
5530% A description of each parameter follows:
5531%
5532% o wand: the magick wand.
5533%
5534% o length: the image length in bytes.
5535%
5536*/
5537WandExport MagickBooleanType MagickGetImageLength(MagickWand *wand,
5538 MagickSizeType *length)
5539{
5540 assert(wand != (MagickWand *) NULL);
5541 assert(wand->signature == MagickWandSignature);
5542 if (wand->debug != MagickFalse)
5543 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5544 if (wand->images == (Image *) NULL)
5545 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5546 *length=GetBlobSize(wand->images);
5547 return(MagickTrue);
5548}
5549␌
5550/*
5551%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5552% %
5553% %
5554% %
5555% M a g i c k G e t I m a g e M a t t e C o l o r %
5556% %
5557% %
5558% %
5559%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5560%
5561% MagickGetImageMatteColor() returns the image matte color.
5562%
5563% The format of the MagickGetImageMatteColor method is:
5564%
5565% MagickBooleanType MagickGetImageMatteColor(MagickWand *wand,
5566% PixelWand *matte_color)
5567%
5568% A description of each parameter follows:
5569%
5570% o wand: the magick wand.
5571%
5572% o matte_color: return the alpha color.
5573%
5574*/
5575WandExport MagickBooleanType MagickGetImageMatteColor(MagickWand *wand,
5576 PixelWand *matte_color)
5577{
5578 assert(wand != (MagickWand *)NULL);
5579 assert(wand->signature == MagickWandSignature);
5580 if (wand->debug != MagickFalse)
5581 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5582 if (wand->images == (Image *)NULL)
5583 ThrowWandException(WandError, "ContainsNoImages", wand->name);
5584 PixelSetPixelColor(matte_color,&wand->images->matte_color);
5585 return(MagickTrue);
5586}
5587␌
5588/*
5589%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5590% %
5591% %
5592% %
5593% M a g i c k G e t I m a g e O r i e n t a t i o n %
5594% %
5595% %
5596% %
5597%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5598%
5599% MagickGetImageOrientation() returns the image orientation.
5600%
5601% The format of the MagickGetImageOrientation method is:
5602%
5603% OrientationType MagickGetImageOrientation(MagickWand *wand)
5604%
5605% A description of each parameter follows:
5606%
5607% o wand: the magick wand.
5608%
5609*/
5610WandExport OrientationType MagickGetImageOrientation(MagickWand *wand)
5611{
5612 assert(wand != (MagickWand *) NULL);
5613 assert(wand->signature == MagickWandSignature);
5614 if (wand->debug != MagickFalse)
5615 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5616 if (wand->images == (Image *) NULL)
5617 {
5618 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5619 "ContainsNoImages","`%s'",wand->name);
5620 return(UndefinedOrientation);
5621 }
5622 return(wand->images->orientation);
5623}
5624␌
5625/*
5626%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5627% %
5628% %
5629% %
5630% M a g i c k G e t I m a g e P a g e %
5631% %
5632% %
5633% %
5634%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5635%
5636% MagickGetImagePage() returns the page geometry associated with the image.
5637%
5638% The format of the MagickGetImagePage method is:
5639%
5640% MagickBooleanType MagickGetImagePage(MagickWand *wand,
5641% size_t *width,size_t *height,ssize_t *x,ssize_t *y)
5642%
5643% A description of each parameter follows:
5644%
5645% o wand: the magick wand.
5646%
5647% o width: the page width.
5648%
5649% o height: the page height.
5650%
5651% o x: the page x-offset.
5652%
5653% o y: the page y-offset.
5654%
5655*/
5656WandExport MagickBooleanType MagickGetImagePage(MagickWand *wand,
5657 size_t *width,size_t *height,ssize_t *x,ssize_t *y)
5658{
5659 assert(wand != (const MagickWand *) NULL);
5660 assert(wand->signature == MagickWandSignature);
5661 if (wand->debug != MagickFalse)
5662 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5663 if (wand->images == (Image *) NULL)
5664 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5665 *width=wand->images->page.width;
5666 *height=wand->images->page.height;
5667 *x=wand->images->page.x;
5668 *y=wand->images->page.y;
5669 return(MagickTrue);
5670}
5671␌
5672/*
5673%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5674% %
5675% %
5676% %
5677% M a g i c k G e t I m a g e P i x e l C o l o r %
5678% %
5679% %
5680% %
5681%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5682%
5683% MagickGetImagePixelColor() gets the color of the specified pixel.
5684%
5685% The format of the MagickGetImagePixelColor method is:
5686%
5687% MagickBooleanType MagickGetImagePixelColor(MagickWand *wand,
5688% const ssize_t x,const ssize_t y,PixelWand *color)
5689%
5690% A description of each parameter follows:
5691%
5692% o wand: the magick wand.
5693%
5694% o x,y: the pixel offset into the image.
5695%
5696% o color: Return the colormap color in this wand.
5697%
5698*/
5699WandExport MagickBooleanType MagickGetImagePixelColor(MagickWand *wand,
5700 const ssize_t x,const ssize_t y,PixelWand *color)
5701{
5702 const Quantum
5703 *p;
5704
5705 CacheView
5706 *image_view;
5707
5708 assert(wand != (MagickWand *) NULL);
5709 assert(wand->signature == MagickWandSignature);
5710 if (wand->debug != MagickFalse)
5711 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5712 if (wand->images == (Image *) NULL)
5713 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5714 image_view=AcquireVirtualCacheView(wand->images,wand->exception);
5715 p=GetCacheViewVirtualPixels(image_view,x,y,1,1,wand->exception);
5716 if (p == (const Quantum *) NULL)
5717 {
5718 image_view=DestroyCacheView(image_view);
5719 return(MagickFalse);
5720 }
5721 PixelSetQuantumPixel(wand->images,p,color);
5722 image_view=DestroyCacheView(image_view);
5723 return(MagickTrue);
5724}
5725␌
5726/*
5727%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5728% %
5729% %
5730% %
5731% M a g i c k G e t I m a g e R e d P r i m a r y %
5732% %
5733% %
5734% %
5735%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5736%
5737% MagickGetImageRedPrimary() returns the chromaticity red primary point.
5738%
5739% The format of the MagickGetImageRedPrimary method is:
5740%
5741% MagickBooleanType MagickGetImageRedPrimary(MagickWand *wand,double *x,
5742% double *y, double *z)
5743%
5744% A description of each parameter follows:
5745%
5746% o wand: the magick wand.
5747%
5748% o x: the chromaticity red primary x-point.
5749%
5750% o y: the chromaticity red primary y-point.
5751%
5752% o z: the chromaticity red primary z-point.
5753%
5754*/
5755WandExport MagickBooleanType MagickGetImageRedPrimary(MagickWand *wand,
5756 double *x,double *y,double *z)
5757{
5758 assert(wand != (MagickWand *) NULL);
5759 assert(wand->signature == MagickWandSignature);
5760 if (wand->debug != MagickFalse)
5761 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5762 if (wand->images == (Image *) NULL)
5763 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5764 *x=wand->images->chromaticity.red_primary.x;
5765 *y=wand->images->chromaticity.red_primary.y;
5766 *z=wand->images->chromaticity.red_primary.z;
5767 return(MagickTrue);
5768}
5769␌
5770/*
5771%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5772% %
5773% %
5774% %
5775% M a g i c k G e t I m a g e R e g i o n %
5776% %
5777% %
5778% %
5779%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5780%
5781% MagickGetImageRegion() extracts a region of the image and returns it as a
5782% a new wand.
5783%
5784% The format of the MagickGetImageRegion method is:
5785%
5786% MagickWand *MagickGetImageRegion(MagickWand *wand,
5787% const size_t width,const size_t height,const ssize_t x,
5788% const ssize_t y)
5789%
5790% A description of each parameter follows:
5791%
5792% o wand: the magick wand.
5793%
5794% o width: the region width.
5795%
5796% o height: the region height.
5797%
5798% o x: the region x offset.
5799%
5800% o y: the region y offset.
5801%
5802*/
5803WandExport MagickWand *MagickGetImageRegion(MagickWand *wand,
5804 const size_t width,const size_t height,const ssize_t x,
5805 const ssize_t y)
5806{
5807 Image
5808 *region_image;
5809
5810 RectangleInfo
5811 region;
5812
5813 assert(wand != (MagickWand *) NULL);
5814 assert(wand->signature == MagickWandSignature);
5815 if (wand->debug != MagickFalse)
5816 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5817 if (wand->images == (Image *) NULL)
5818 return((MagickWand *) NULL);
5819 region.width=width;
5820 region.height=height;
5821 region.x=x;
5822 region.y=y;
5823 region_image=CropImage(wand->images,&region,wand->exception);
5824 if (region_image == (Image *) NULL)
5825 return((MagickWand *) NULL);
5826 return(CloneMagickWandFromImages(wand,region_image));
5827}
5828␌
5829/*
5830%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5831% %
5832% %
5833% %
5834% M a g i c k G e t I m a g e R e n d e r i n g I n t e n t %
5835% %
5836% %
5837% %
5838%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5839%
5840% MagickGetImageRenderingIntent() gets the image rendering intent.
5841%
5842% The format of the MagickGetImageRenderingIntent method is:
5843%
5844% RenderingIntent MagickGetImageRenderingIntent(MagickWand *wand)
5845%
5846% A description of each parameter follows:
5847%
5848% o wand: the magick wand.
5849%
5850*/
5851WandExport RenderingIntent MagickGetImageRenderingIntent(MagickWand *wand)
5852{
5853 assert(wand != (MagickWand *) NULL);
5854 assert(wand->signature == MagickWandSignature);
5855 if (wand->debug != MagickFalse)
5856 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5857 if (wand->images == (Image *) NULL)
5858 {
5859 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5860 "ContainsNoImages","`%s'",wand->name);
5861 return(UndefinedIntent);
5862 }
5863 return((RenderingIntent) wand->images->rendering_intent);
5864}
5865␌
5866/*
5867%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5868% %
5869% %
5870% %
5871% M a g i c k G e t I m a g e R e s o l u t i o n %
5872% %
5873% %
5874% %
5875%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5876%
5877% MagickGetImageResolution() gets the image X and Y resolution.
5878%
5879% The format of the MagickGetImageResolution method is:
5880%
5881% MagickBooleanType MagickGetImageResolution(MagickWand *wand,double *x,
5882% double *y)
5883%
5884% A description of each parameter follows:
5885%
5886% o wand: the magick wand.
5887%
5888% o x: the image x-resolution.
5889%
5890% o y: the image y-resolution.
5891%
5892*/
5893WandExport MagickBooleanType MagickGetImageResolution(MagickWand *wand,
5894 double *x,double *y)
5895{
5896 assert(wand != (MagickWand *) NULL);
5897 assert(wand->signature == MagickWandSignature);
5898 if (wand->debug != MagickFalse)
5899 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5900 if (wand->images == (Image *) NULL)
5901 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5902 *x=wand->images->resolution.x;
5903 *y=wand->images->resolution.y;
5904 return(MagickTrue);
5905}
5906␌
5907/*
5908%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5909% %
5910% %
5911% %
5912% M a g i c k G e t I m a g e S c e n e %
5913% %
5914% %
5915% %
5916%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5917%
5918% MagickGetImageScene() gets the image scene.
5919%
5920% The format of the MagickGetImageScene method is:
5921%
5922% size_t MagickGetImageScene(MagickWand *wand)
5923%
5924% A description of each parameter follows:
5925%
5926% o wand: the magick wand.
5927%
5928*/
5929WandExport size_t MagickGetImageScene(MagickWand *wand)
5930{
5931 assert(wand != (MagickWand *) NULL);
5932 assert(wand->signature == MagickWandSignature);
5933 if (wand->debug != MagickFalse)
5934 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5935 if (wand->images == (Image *) NULL)
5936 ThrowWandException(WandError,"ContainsNoImages",wand->name);
5937 return(wand->images->scene);
5938}
5939␌
5940/*
5941%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5942% %
5943% %
5944% %
5945% M a g i c k G e t I m a g e S i g n a t u r e %
5946% %
5947% %
5948% %
5949%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5950%
5951% MagickGetImageSignature() generates an SHA-256 message digest for the image
5952% pixel stream.
5953%
5954% The format of the MagickGetImageSignature method is:
5955%
5956% char *MagickGetImageSignature(MagickWand *wand)
5957%
5958% A description of each parameter follows:
5959%
5960% o wand: the magick wand.
5961%
5962*/
5963WandExport char *MagickGetImageSignature(MagickWand *wand)
5964{
5965 const char
5966 *value;
5967
5968 MagickBooleanType
5969 status;
5970
5971 assert(wand != (MagickWand *) NULL);
5972 assert(wand->signature == MagickWandSignature);
5973 if (wand->debug != MagickFalse)
5974 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
5975 if (wand->images == (Image *) NULL)
5976 {
5977 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
5978 "ContainsNoImages","`%s'",wand->name);
5979 return((char *) NULL);
5980 }
5981 status=SignatureImage(wand->images,wand->exception);
5982 if (status == MagickFalse)
5983 return((char *) NULL);
5984 value=GetImageProperty(wand->images,"signature",wand->exception);
5985 if (value == (const char *) NULL)
5986 return((char *) NULL);
5987 return(AcquireString(value));
5988}
5989␌
5990/*
5991%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5992% %
5993% %
5994% %
5995% M a g i c k G e t I m a g e T i c k s P e r S e c o n d %
5996% %
5997% %
5998% %
5999%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6000%
6001% MagickGetImageTicksPerSecond() gets the image ticks-per-second.
6002%
6003% The format of the MagickGetImageTicksPerSecond method is:
6004%
6005% size_t MagickGetImageTicksPerSecond(MagickWand *wand)
6006%
6007% A description of each parameter follows:
6008%
6009% o wand: the magick wand.
6010%
6011*/
6012WandExport size_t MagickGetImageTicksPerSecond(MagickWand *wand)
6013{
6014 assert(wand != (MagickWand *) NULL);
6015 assert(wand->signature == MagickWandSignature);
6016 if (wand->debug != MagickFalse)
6017 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6018 if (wand->images == (Image *) NULL)
6019 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6020 return((size_t) wand->images->ticks_per_second);
6021}
6022␌
6023/*
6024%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6025% %
6026% %
6027% %
6028% M a g i c k G e t I m a g e T y p e %
6029% %
6030% %
6031% %
6032%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6033%
6034% MagickGetImageType() gets the potential image type:
6035%
6036% Bilevel Grayscale GrayscaleMatte
6037% Palette PaletteMatte TrueColor
6038% TrueColorMatte ColorSeparation ColorSeparationMatte
6039%
6040% The format of the MagickGetImageType method is:
6041%
6042% ImageType MagickGetImageType(MagickWand *wand)
6043%
6044% A description of each parameter follows:
6045%
6046% o wand: the magick wand.
6047%
6048*/
6049WandExport ImageType MagickGetImageType(MagickWand *wand)
6050{
6051 assert(wand != (MagickWand *) NULL);
6052 assert(wand->signature == MagickWandSignature);
6053 if (wand->debug != MagickFalse)
6054 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6055 if (wand->images == (Image *) NULL)
6056 {
6057 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6058 "ContainsNoImages","`%s'",wand->name);
6059 return(UndefinedType);
6060 }
6061 return(GetImageType(wand->images));
6062}
6063␌
6064/*
6065%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6066% %
6067% %
6068% %
6069% M a g i c k G e t I m a g e U n i t s %
6070% %
6071% %
6072% %
6073%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6074%
6075% MagickGetImageUnits() gets the image units of resolution.
6076%
6077% The format of the MagickGetImageUnits method is:
6078%
6079% ResolutionType MagickGetImageUnits(MagickWand *wand)
6080%
6081% A description of each parameter follows:
6082%
6083% o wand: the magick wand.
6084%
6085*/
6086WandExport ResolutionType MagickGetImageUnits(MagickWand *wand)
6087{
6088 assert(wand != (MagickWand *) NULL);
6089 assert(wand->signature == MagickWandSignature);
6090 if (wand->debug != MagickFalse)
6091 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6092 if (wand->images == (Image *) NULL)
6093 {
6094 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6095 "ContainsNoImages","`%s'",wand->name);
6096 return(UndefinedResolution);
6097 }
6098 return(wand->images->units);
6099}
6100␌
6101/*
6102%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6103% %
6104% %
6105% %
6106% M a g i c k G e t I m a g e V i r t u a l P i x e l M e t h o d %
6107% %
6108% %
6109% %
6110%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6111%
6112% MagickGetImageVirtualPixelMethod() returns the virtual pixel method for the
6113% specified image.
6114%
6115% The format of the MagickGetImageVirtualPixelMethod method is:
6116%
6117% VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *wand)
6118%
6119% A description of each parameter follows:
6120%
6121% o wand: the magick wand.
6122%
6123*/
6124WandExport VirtualPixelMethod MagickGetImageVirtualPixelMethod(MagickWand *wand)
6125{
6126 assert(wand != (MagickWand *) NULL);
6127 assert(wand->signature == MagickWandSignature);
6128 if (wand->debug != MagickFalse)
6129 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6130 if (wand->images == (Image *) NULL)
6131 {
6132 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6133 "ContainsNoImages","`%s'",wand->name);
6134 return(UndefinedVirtualPixelMethod);
6135 }
6136 return(GetImageVirtualPixelMethod(wand->images));
6137}
6138␌
6139/*
6140%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6141% %
6142% %
6143% %
6144% M a g i c k G e t I m a g e W h i t e P o i n t %
6145% %
6146% %
6147% %
6148%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6149%
6150% MagickGetImageWhitePoint() returns the chromaticity white point.
6151%
6152% The format of the MagickGetImageWhitePoint method is:
6153%
6154% MagickBooleanType MagickGetImageWhitePoint(MagickWand *wand,double *x,
6155% double *y,double *z)
6156%
6157% A description of each parameter follows:
6158%
6159% o wand: the magick wand.
6160%
6161% o x: the chromaticity white x-point.
6162%
6163% o y: the chromaticity white y-point.
6164%
6165% o z: the chromaticity white z-point.
6166%
6167*/
6168WandExport MagickBooleanType MagickGetImageWhitePoint(MagickWand *wand,
6169 double *x,double *y,double *z)
6170{
6171 assert(wand != (MagickWand *) NULL);
6172 assert(wand->signature == MagickWandSignature);
6173 if (wand->debug != MagickFalse)
6174 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6175 if (wand->images == (Image *) NULL)
6176 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6177 *x=wand->images->chromaticity.white_point.x;
6178 *y=wand->images->chromaticity.white_point.y;
6179 *z=wand->images->chromaticity.white_point.z;
6180 return(MagickTrue);
6181}
6182␌
6183/*
6184%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6185% %
6186% %
6187% %
6188% M a g i c k G e t I m a g e W i d t h %
6189% %
6190% %
6191% %
6192%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6193%
6194% MagickGetImageWidth() returns the image width.
6195%
6196% The format of the MagickGetImageWidth method is:
6197%
6198% size_t MagickGetImageWidth(MagickWand *wand)
6199%
6200% A description of each parameter follows:
6201%
6202% o wand: the magick wand.
6203%
6204*/
6205WandExport size_t MagickGetImageWidth(MagickWand *wand)
6206{
6207 assert(wand != (MagickWand *) NULL);
6208 assert(wand->signature == MagickWandSignature);
6209 if (wand->debug != MagickFalse)
6210 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6211 if (wand->images == (Image *) NULL)
6212 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6213 return(wand->images->columns);
6214}
6215␌
6216/*
6217%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6218% %
6219% %
6220% %
6221% M a g i c k G e t N u m b e r I m a g e s %
6222% %
6223% %
6224% %
6225%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6226%
6227% MagickGetNumberImages() returns the number of images associated with a
6228% magick wand.
6229%
6230% The format of the MagickGetNumberImages method is:
6231%
6232% size_t MagickGetNumberImages(MagickWand *wand)
6233%
6234% A description of each parameter follows:
6235%
6236% o wand: the magick wand.
6237%
6238*/
6239WandExport size_t MagickGetNumberImages(MagickWand *wand)
6240{
6241 assert(wand != (MagickWand *) NULL);
6242 assert(wand->signature == MagickWandSignature);
6243 if (wand->debug != MagickFalse)
6244 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6245 return(GetImageListLength(wand->images));
6246}
6247␌
6248/*
6249%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6250% %
6251% %
6252% %
6253% M a g i c k I m a g e G e t T o t a l I n k D e n s i t y %
6254% %
6255% %
6256% %
6257%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6258%
6259% MagickGetImageTotalInkDensity() gets the image total ink density.
6260%
6261% The format of the MagickGetImageTotalInkDensity method is:
6262%
6263% double MagickGetImageTotalInkDensity(MagickWand *wand)
6264%
6265% A description of each parameter follows:
6266%
6267% o wand: the magick wand.
6268%
6269*/
6270WandExport double MagickGetImageTotalInkDensity(MagickWand *wand)
6271{
6272 assert(wand != (MagickWand *) NULL);
6273 assert(wand->signature == MagickWandSignature);
6274 if (wand->debug != MagickFalse)
6275 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6276 if (wand->images == (Image *) NULL)
6277 {
6278 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6279 "ContainsNoImages","`%s'",wand->name);
6280 return(0.0);
6281 }
6282 return(GetImageTotalInkDensity(wand->images,wand->exception));
6283}
6284␌
6285/*
6286%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6287% %
6288% %
6289% %
6290% M a g i c k H a l d C l u t I m a g e %
6291% %
6292% %
6293% %
6294%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6295%
6296% MagickHaldClutImage() replaces colors in the image from a Hald color lookup
6297% table. A Hald color lookup table is a 3-dimensional color cube mapped to 2
6298% dimensions. Create it with the HALD coder. You can apply any color
6299% transformation to the Hald image and then use this method to apply the
6300% transform to the image.
6301%
6302% The format of the MagickHaldClutImage method is:
6303%
6304% MagickBooleanType MagickHaldClutImage(MagickWand *wand,
6305% const MagickWand *hald_wand)
6306%
6307% A description of each parameter follows:
6308%
6309% o wand: the magick wand.
6310%
6311% o hald_image: the hald CLUT image.
6312%
6313*/
6314WandExport MagickBooleanType MagickHaldClutImage(MagickWand *wand,
6315 const MagickWand *hald_wand)
6316{
6317 MagickBooleanType
6318 status;
6319
6320 assert(wand != (MagickWand *) NULL);
6321 assert(wand->signature == MagickWandSignature);
6322 if (wand->debug != MagickFalse)
6323 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6324 if ((wand->images == (Image *) NULL) || (hald_wand->images == (Image *) NULL))
6325 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6326 status=HaldClutImage(wand->images,hald_wand->images,wand->exception);
6327 return(status);
6328}
6329␌
6330/*
6331%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6332% %
6333% %
6334% %
6335% M a g i c k H a s N e x t I m a g e %
6336% %
6337% %
6338% %
6339%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6340%
6341% MagickHasNextImage() returns MagickTrue if the wand has more images when
6342% traversing the list in the forward direction
6343%
6344% The format of the MagickHasNextImage method is:
6345%
6346% MagickBooleanType MagickHasNextImage(MagickWand *wand)
6347%
6348% A description of each parameter follows:
6349%
6350% o wand: the magick wand.
6351%
6352*/
6353WandExport MagickBooleanType MagickHasNextImage(MagickWand *wand)
6354{
6355 assert(wand != (MagickWand *) NULL);
6356 assert(wand->signature == MagickWandSignature);
6357 if (wand->debug != MagickFalse)
6358 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6359 if (wand->images == (Image *) NULL)
6360 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6361 if (GetNextImageInList(wand->images) == (Image *) NULL)
6362 return(MagickFalse);
6363 return(MagickTrue);
6364}
6365␌
6366/*
6367%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6368% %
6369% %
6370% %
6371% M a g i c k H a s P r e v i o u s I m a g e %
6372% %
6373% %
6374% %
6375%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6376%
6377% MagickHasPreviousImage() returns MagickTrue if the wand has more images when
6378% traversing the list in the reverse direction
6379%
6380% The format of the MagickHasPreviousImage method is:
6381%
6382% MagickBooleanType MagickHasPreviousImage(MagickWand *wand)
6383%
6384% A description of each parameter follows:
6385%
6386% o wand: the magick wand.
6387%
6388*/
6389WandExport MagickBooleanType MagickHasPreviousImage(MagickWand *wand)
6390{
6391 assert(wand != (MagickWand *) NULL);
6392 assert(wand->signature == MagickWandSignature);
6393 if (wand->debug != MagickFalse)
6394 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6395 if (wand->images == (Image *) NULL)
6396 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6397 if (GetPreviousImageInList(wand->images) == (Image *) NULL)
6398 return(MagickFalse);
6399 return(MagickTrue);
6400}
6401␌
6402/*
6403%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6404% %
6405% %
6406% %
6407% M a g i c k H o u g h L i n e I m a g e %
6408% %
6409% %
6410% %
6411%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6412%
6413% MagickHoughLineImage() can be used in conjunction with any binary edge
6414% extracted image (we recommend Canny) to identify lines in the image. The
6415% algorithm accumulates counts for every white pixel for every possible
6416% orientation (for angles from 0 to 179 in 1 degree increments) and distance
6417% from the center of the image to the corner (in 1 px increments) and stores
6418% the counts in an accumulator matrix of angle vs distance. The size of the
6419% accumulator is 180x(diagonal/2). Next it searches this space for peaks in
6420% counts and converts the locations of the peaks to slope and intercept in the
6421% normal x,y input image space. Use the slope/intercepts to find the endpoints
6422% clipped to the bounds of the image. The lines are then drawn. The counts are
6423% a measure of the length of the lines.
6424%
6425% The format of the MagickHoughLineImage method is:
6426%
6427% MagickBooleanType MagickHoughLineImage(MagickWand *wand,
6428% const size_t width,const size_t height,const size_t threshold)
6429%
6430% A description of each parameter follows:
6431%
6432% o wand: the magick wand.
6433%
6434% o width, height: find line pairs as local maxima in this neighborhood.
6435%
6436% o threshold: the line count threshold.
6437%
6438*/
6439WandExport MagickBooleanType MagickHoughLineImage(MagickWand *wand,
6440 const size_t width,const size_t height,const size_t threshold)
6441{
6442 Image
6443 *lines_image;
6444
6445 assert(wand != (MagickWand *) NULL);
6446 assert(wand->signature == MagickWandSignature);
6447 if (wand->debug != MagickFalse)
6448 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6449 if (wand->images == (Image *) NULL)
6450 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6451 lines_image=HoughLineImage(wand->images,width,height,threshold,
6452 wand->exception);
6453 if (lines_image == (Image *) NULL)
6454 return(MagickFalse);
6455 ReplaceImageInList(&wand->images,lines_image);
6456 return(MagickTrue);
6457}
6458␌
6459/*
6460%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6461% %
6462% %
6463% %
6464% M a g i c k I d e n t i f y I m a g e %
6465% %
6466% %
6467% %
6468%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6469%
6470% MagickIdentifyImage() identifies an image by printing its attributes to the
6471% file. Attributes include the image width, height, size, and others.
6472%
6473% The format of the MagickIdentifyImage method is:
6474%
6475% const char *MagickIdentifyImage(MagickWand *wand)
6476%
6477% A description of each parameter follows:
6478%
6479% o wand: the magick wand.
6480%
6481*/
6482WandExport char *MagickIdentifyImage(MagickWand *wand)
6483{
6484 char
6485 *description,
6486 filename[MagickPathExtent];
6487
6488 FILE
6489 *file;
6490
6491 int
6492 unique_file;
6493
6494 assert(wand != (MagickWand *) NULL);
6495 assert(wand->signature == MagickWandSignature);
6496 if (wand->debug != MagickFalse)
6497 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6498 if (wand->images == (Image *) NULL)
6499 {
6500 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6501 "ContainsNoImages","`%s'",wand->name);
6502 return((char *) NULL);
6503 }
6504 description=(char *) NULL;
6505 unique_file=AcquireUniqueFileResource(filename);
6506 file=(FILE *) NULL;
6507 if (unique_file != -1)
6508 file=fdopen(unique_file,"wb");
6509 if ((unique_file == -1) || (file == (FILE *) NULL))
6510 {
6511 (void) RelinquishUniqueFileResource(filename);
6512 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6513 "UnableToCreateTemporaryFile","`%s'",wand->name);
6514 return((char *) NULL);
6515 }
6516 (void) IdentifyImage(wand->images,file,MagickTrue,wand->exception);
6517 (void) fclose(file);
6518 description=FileToString(filename,~0UL,wand->exception);
6519 (void) RelinquishUniqueFileResource(filename);
6520 return(description);
6521}
6522
6523/*
6524%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6525% %
6526% %
6527% %
6528% M a g i c k I d e n t i f y I m a g e T y p e %
6529% %
6530% %
6531% %
6532%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6533%
6534% MagickIdentifyImageType() gets the potential image type:
6535%
6536% Bilevel Grayscale GrayscaleMatte
6537% Palette PaletteMatte TrueColor
6538% TrueColorMatte ColorSeparation ColorSeparationMatte
6539%
6540% To ensure the image type matches its potential, use MagickSetImageType():
6541%
6542% (void) MagickSetImageType(wand,MagickIdentifyImageType(wand));
6543%
6544% The format of the MagickIdentifyImageType method is:
6545%
6546% ImageType MagickIdentifyImageType(MagickWand *wand)
6547%
6548% A description of each parameter follows:
6549%
6550% o wand: the magick wand.
6551%
6552*/
6553WandExport ImageType MagickIdentifyImageType(MagickWand *wand)
6554{
6555 assert(wand != (MagickWand *) NULL);
6556 assert(wand->signature == MagickWandSignature);
6557 if (wand->debug != MagickFalse)
6558 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6559 if (wand->images == (Image *) NULL)
6560 {
6561 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
6562 "ContainsNoImages","`%s'",wand->name);
6563 return(UndefinedType);
6564 }
6565 return(IdentifyImageType(wand->images,wand->exception));
6566}
6567
6568/*
6569%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6570% %
6571% %
6572% %
6573% M a g i c k I m p l o d e I m a g e %
6574% %
6575% %
6576% %
6577%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6578%
6579% MagickImplodeImage() creates a new image that is a copy of an existing
6580% one with the image pixels "implode" by the specified percentage. It
6581% allocates the memory necessary for the new Image structure and returns a
6582% pointer to the new image.
6583%
6584% The format of the MagickImplodeImage method is:
6585%
6586% MagickBooleanType MagickImplodeImage(MagickWand *wand,
6587% const double radius,const PixelInterpolateMethod method)
6588%
6589% A description of each parameter follows:
6590%
6591% o wand: the magick wand.
6592%
6593% o amount: Define the extent of the implosion.
6594%
6595% o method: the pixel interpolation method.
6596%
6597*/
6598WandExport MagickBooleanType MagickImplodeImage(MagickWand *wand,
6599 const double amount,const PixelInterpolateMethod method)
6600{
6601 Image
6602 *implode_image;
6603
6604 assert(wand != (MagickWand *) NULL);
6605 assert(wand->signature == MagickWandSignature);
6606 if (wand->debug != MagickFalse)
6607 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6608 if (wand->images == (Image *) NULL)
6609 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6610 implode_image=ImplodeImage(wand->images,amount,method,wand->exception);
6611 if (implode_image == (Image *) NULL)
6612 return(MagickFalse);
6613 ReplaceImageInList(&wand->images,implode_image);
6614 return(MagickTrue);
6615}
6616␌
6617/*
6618%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6619% %
6620% %
6621% %
6622% M a g i c k I m p o r t I m a g e P i x e l s %
6623% %
6624% %
6625% %
6626%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6627%
6628% MagickImportImagePixels() accepts pixel datand stores it in the image at the
6629% location you specify. The method returns MagickTrue on success otherwise
6630% MagickFalse if an error is encountered. The pixel data can be either char,
6631% short int, int, ssize_t, float, or double in the order specified by map.
6632%
6633% Suppose your want to upload the first scanline of a 640x480 image from
6634% character data in red-green-blue order:
6635%
6636% MagickImportImagePixels(wand,0,0,640,1,"RGB",CharPixel,pixels);
6637%
6638% The format of the MagickImportImagePixels method is:
6639%
6640% MagickBooleanType MagickImportImagePixels(MagickWand *wand,
6641% const ssize_t x,const ssize_t y,const size_t columns,
6642% const size_t rows,const char *map,const StorageType storage,
6643% const void *pixels)
6644%
6645% A description of each parameter follows:
6646%
6647% o wand: the magick wand.
6648%
6649% o x, y, columns, rows: These values define the perimeter of a region
6650% of pixels you want to define.
6651%
6652% o map: This string reflects the expected ordering of the pixel array.
6653% It can be any combination or order of R = red, G = green, B = blue,
6654% A = alpha (0 is transparent), O = alpha (0 is opaque), C = cyan,
6655% Y = yellow, M = magenta, K = black, I = intensity (for grayscale),
6656% P = pad.
6657%
6658% o storage: Define the data type of the pixels. Float and double types are
6659% expected to be normalized [0..1] otherwise [0..QuantumRange]. Choose from
6660% these types: CharPixel, ShortPixel, IntegerPixel, LongPixel, FloatPixel,
6661% or DoublePixel.
6662%
6663% o pixels: This array of values contain the pixel components as defined by
6664% map and type. You must preallocate this array where the expected
6665% length varies depending on the values of width, height, map, and type.
6666%
6667*/
6668WandExport MagickBooleanType MagickImportImagePixels(MagickWand *wand,
6669 const ssize_t x,const ssize_t y,const size_t columns,const size_t rows,
6670 const char *map,const StorageType storage,const void *pixels)
6671{
6672 MagickBooleanType
6673 status;
6674
6675 assert(wand != (MagickWand *) NULL);
6676 assert(wand->signature == MagickWandSignature);
6677 if (wand->debug != MagickFalse)
6678 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6679 if (wand->images == (Image *) NULL)
6680 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6681 status=ImportImagePixels(wand->images,x,y,columns,rows,map,storage,pixels,
6682 wand->exception);
6683 return(status);
6684}
6685␌
6686/*
6687%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6688% %
6689% %
6690% %
6691% M a g i c k I n t e r p o l a t i v e R e s i z e I m a g e %
6692% %
6693% %
6694% %
6695%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6696%
6697% MagickInterpolativeResizeImage() resize image using a interpolative
6698% method.
6699%
6700% MagickBooleanType MagickInterpolativeResizeImage(MagickWand *wand,
6701% const size_t columns,const size_t rows,
6702% const PixelInterpolateMethod method)
6703%
6704% A description of each parameter follows:
6705%
6706% o wand: the magick wand.
6707%
6708% o columns: the number of columns in the scaled image.
6709%
6710% o rows: the number of rows in the scaled image.
6711%
6712% o interpolate: the pixel interpolation method.
6713%
6714*/
6715WandExport MagickBooleanType MagickInterpolativeResizeImage(MagickWand *wand,
6716 const size_t columns,const size_t rows,const PixelInterpolateMethod method)
6717{
6718 Image
6719 *resize_image;
6720
6721 assert(wand != (MagickWand *) NULL);
6722 assert(wand->signature == MagickWandSignature);
6723 if (wand->debug != MagickFalse)
6724 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6725 if (wand->images == (Image *) NULL)
6726 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6727 resize_image=InterpolativeResizeImage(wand->images,columns,rows,method,
6728 wand->exception);
6729 if (resize_image == (Image *) NULL)
6730 return(MagickFalse);
6731 ReplaceImageInList(&wand->images,resize_image);
6732 return(MagickTrue);
6733}
6734␌
6735/*
6736%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6737% %
6738% %
6739% %
6740% M a g i c k I n v e r s e F o u r i e r T r a n s f o r m I m a g e %
6741% %
6742% %
6743% %
6744%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6745%
6746% MagickInverseFourierTransformImage() implements the inverse discrete
6747% Fourier transform (DFT) of the image either as a magnitude / phase or real /
6748% imaginary image pair.
6749%
6750% The format of the MagickInverseFourierTransformImage method is:
6751%
6752% MagickBooleanType MagickInverseFourierTransformImage(
6753% MagickWand *magnitude_wand,MagickWand *phase_wand,
6754% const MagickBooleanType magnitude)
6755%
6756% A description of each parameter follows:
6757%
6758% o magnitude_wand: the magnitude or real wand.
6759%
6760% o phase_wand: the phase or imaginary wand.
6761%
6762% o magnitude: if true, return as magnitude / phase pair otherwise a real /
6763% imaginary image pair.
6764%
6765*/
6766WandExport MagickBooleanType MagickInverseFourierTransformImage(
6767 MagickWand *magnitude_wand,MagickWand *phase_wand,
6768 const MagickBooleanType magnitude)
6769{
6770 Image
6771 *inverse_image;
6772
6773 MagickWand
6774 *wand;
6775
6776 assert(magnitude_wand != (MagickWand *) NULL);
6777 assert(magnitude_wand->signature == MagickWandSignature);
6778 if (magnitude_wand->debug != MagickFalse)
6779 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",
6780 magnitude_wand->name);
6781 wand=magnitude_wand;
6782 if (magnitude_wand->images == (Image *) NULL)
6783 ThrowWandException(WandError,"ContainsNoImages",
6784 magnitude_wand->name);
6785 assert(phase_wand != (MagickWand *) NULL);
6786 assert(phase_wand->signature == MagickWandSignature);
6787 inverse_image=InverseFourierTransformImage(magnitude_wand->images,
6788 phase_wand->images,magnitude,wand->exception);
6789 if (inverse_image == (Image *) NULL)
6790 return(MagickFalse);
6791 ReplaceImageInList(&wand->images,inverse_image);
6792 return(MagickTrue);
6793}
6794␌
6795/*
6796%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6797% %
6798% %
6799% %
6800% M a g i c k K m e a n s I m a g e %
6801% %
6802% %
6803% %
6804%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6805%
6806% MagickKmeansImage() applies k-means color reduction to an image. This is a
6807% colorspace clustering or segmentation technique.
6808%
6809% The format of the MagickKmeansImage method is:
6810%
6811% MagickBooleanType MagickKmeansImage(MagickWand *wand,
6812% const size_t number_colors, const size_t max_iterations,
6813% const double tolerance)
6814%
6815% A description of each parameter follows:
6816%
6817% o wand: the magick wand.
6818%
6819% o number_colors: number of colors to use as seeds.
6820%
6821% o max_iterations: maximum number of iterations while converging.
6822%
6823% o tolerance: the maximum tolerance.
6824%
6825*/
6826WandExport MagickBooleanType MagickKmeansImage(MagickWand *wand,
6827 const size_t number_colors,const size_t max_iterations,
6828 const double tolerance)
6829{
6830 MagickBooleanType
6831 status;
6832
6833 assert(wand != (MagickWand *) NULL);
6834 assert(wand->signature == MagickWandSignature);
6835 if (wand->debug != MagickFalse)
6836 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6837 if (wand->images == (Image *) NULL)
6838 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6839 status=KmeansImage(wand->images,number_colors,max_iterations,tolerance,
6840 wand->exception);
6841 return(status);
6842}
6843␌
6844/*
6845%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6846% %
6847% %
6848% %
6849% M a g i c k K u w a h a r a I m a g e %
6850% %
6851% %
6852% %
6853%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6854%
6855% Use MagickKuwaharaImage() is an edge preserving noise reduction filter.
6856%
6857% The format of the MagickKuwaharaImage method is:
6858%
6859% MagickBooleanType MagickKuwaharaImage(MagickWand *wand,
6860% const double radius,const double sigma)
6861%
6862% A description of each parameter follows:
6863%
6864% o wand: the magick wand.
6865%
6866% o radius: the square window radius.
6867%
6868% o sigma: the standard deviation of the Gaussian, in pixels.
6869%
6870*/
6871WandExport MagickBooleanType MagickKuwaharaImage(MagickWand *wand,
6872 const double radius,const double sigma)
6873{
6874 Image
6875 *kuwahara_image;
6876
6877 assert(wand != (MagickWand *) NULL);
6878 assert(wand->signature == MagickWandSignature);
6879 if (wand->debug != MagickFalse)
6880 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6881 if (wand->images == (Image *) NULL)
6882 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6883 kuwahara_image=KuwaharaImage(wand->images,radius,sigma,wand->exception);
6884 if (kuwahara_image == (Image *) NULL)
6885 return(MagickFalse);
6886 ReplaceImageInList(&wand->images,kuwahara_image);
6887 return(MagickTrue);
6888}
6889␌
6890/*
6891%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6892% %
6893% %
6894% %
6895% M a g i c k L a b e l I m a g e %
6896% %
6897% %
6898% %
6899%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6900%
6901% MagickLabelImage() adds a label to your image.
6902%
6903% The format of the MagickLabelImage method is:
6904%
6905% MagickBooleanType MagickLabelImage(MagickWand *wand,const char *label)
6906%
6907% A description of each parameter follows:
6908%
6909% o wand: the magick wand.
6910%
6911% o label: the image label.
6912%
6913*/
6914WandExport MagickBooleanType MagickLabelImage(MagickWand *wand,
6915 const char *label)
6916{
6917 MagickBooleanType
6918 status;
6919
6920 assert(wand != (MagickWand *) NULL);
6921 assert(wand->signature == MagickWandSignature);
6922 if (wand->debug != MagickFalse)
6923 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6924 if (wand->images == (Image *) NULL)
6925 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6926 status=SetImageProperty(wand->images,"label",label,wand->exception);
6927 return(status);
6928}
6929␌
6930/*
6931%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6932% %
6933% %
6934% %
6935% M a g i c k L e v e l I m a g e %
6936% %
6937% %
6938% %
6939%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6940%
6941% MagickLevelImage() adjusts the levels of an image by scaling the colors
6942% falling between specified white and black points to the full available
6943% quantum range. The parameters provided represent the black, mid, and white
6944% points. The black point specifies the darkest color in the image. Colors
6945% darker than the black point are set to zero. Mid point specifies a gamma
6946% correction to apply to the image. White point specifies the lightest color
6947% in the image. Colors brighter than the white point are set to the maximum
6948% quantum value.
6949%
6950% The format of the MagickLevelImage method is:
6951%
6952% MagickBooleanType MagickLevelImage(MagickWand *wand,
6953% const double black_point,const double gamma,const double white_point)
6954%
6955% A description of each parameter follows:
6956%
6957% o wand: the magick wand.
6958%
6959% o channel: Identify which channel to level: RedPixelChannel,
6960% GreenPixelChannel, etc.
6961%
6962% o black_point: the black point.
6963%
6964% o gamma: the gamma.
6965%
6966% o white_point: the white point.
6967%
6968*/
6969WandExport MagickBooleanType MagickLevelImage(MagickWand *wand,
6970 const double black_point,const double gamma,const double white_point)
6971{
6972 MagickBooleanType
6973 status;
6974
6975 assert(wand != (MagickWand *) NULL);
6976 assert(wand->signature == MagickWandSignature);
6977 if (wand->debug != MagickFalse)
6978 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
6979 if (wand->images == (Image *) NULL)
6980 ThrowWandException(WandError,"ContainsNoImages",wand->name);
6981 status=LevelImage(wand->images,black_point,white_point,gamma,
6982 wand->exception);
6983 return(status);
6984}
6985␌
6986/*
6987%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6988% %
6989% %
6990% %
6991% M a g i c k L e v e l I m a g e C o l o r s %
6992% %
6993% %
6994% %
6995%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6996%
6997% MagickLevelImageColors() maps the given color to "black" and "white" values,
6998% linearly spreading out the colors, and level values on a channel by channel
6999% bases, as per LevelImage(). The given colors allows you to specify
7000% different level ranges for each of the color channels separately.
7001%
7002% The format of the MagickLevelImageColors method is:
7003%
7004% MagickBooleanType MagickLevelImageColors(MagickWand *wand,
7005% const PixelWand *black_color,const PixelWand *white_color,
7006% const MagickBooleanType invert)
7007%
7008% A description of each parameter follows:
7009%
7010% o wand: the magick wand.
7011%
7012% o black_color: the black color.
7013%
7014% o white_color: the white color.
7015%
7016% o invert: if true map the colors (levelize), rather than from (level)
7017%
7018*/
7019WandExport MagickBooleanType MagickLevelImageColors(MagickWand *wand,
7020 const PixelWand *black_color,const PixelWand *white_color,
7021 const MagickBooleanType invert)
7022{
7023 MagickBooleanType
7024 status;
7025
7026 PixelInfo
7027 black,
7028 white;
7029
7030 assert(wand != (MagickWand *) NULL);
7031 assert(wand->signature == MagickWandSignature);
7032 if (wand->debug != MagickFalse)
7033 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7034 if (wand->images == (Image *) NULL)
7035 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7036 PixelGetMagickColor(black_color,&black);
7037 PixelGetMagickColor(white_color,&white);
7038 status=LevelImageColors(wand->images,&black,&white,invert,wand->exception);
7039 return(status);
7040}
7041␌
7042/*
7043%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7044% %
7045% %
7046% %
7047% M a g i c k L e v e l i z e I m a g e %
7048% %
7049% %
7050% %
7051%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7052%
7053% MagickLevelizeImage() applies the reversed MagickLevelImage(). It compresses
7054% the full range of color values, so that they lie between the given black and
7055% white points. Gamma is applied before the values are mapped. It can be
7056% used to de-contrast a greyscale image to the exact levels specified.
7057%
7058% The format of the MagickLevelizeImage method is:
7059%
7060% MagickBooleanType MagickLevelizeImage(MagickWand *wand,
7061% const double black_point, const double white_point,const double gamma)
7062%
7063% A description of each parameter follows:
7064%
7065% o wand: the magick wand.
7066%
7067% o black_point: The level to map zero (black) to.
7068%
7069% o white_point: The level to map QuantumRange (white) to.
7070%
7071% o gamma: adjust gamma by this factor before mapping values.
7072%
7073*/
7074WandExport MagickBooleanType MagickLevelizeImage(MagickWand *wand,
7075 const double black_point,const double gamma,const double white_point)
7076{
7077 MagickBooleanType
7078 status;
7079
7080 assert(wand != (MagickWand *) NULL);
7081 assert(wand->signature == MagickWandSignature);
7082 if (wand->debug != MagickFalse)
7083 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7084 if (wand->images == (Image *) NULL)
7085 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7086 status=LevelizeImage(wand->images,black_point,white_point,gamma,
7087 wand->exception);
7088 return(status);
7089}
7090␌
7091/*
7092%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7093% %
7094% %
7095% %
7096% M a g i c k L i n e a r S t r e t c h I m a g e %
7097% %
7098% %
7099% %
7100%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7101%
7102% MagickLinearStretchImage() stretches with saturation the image intensity.
7103%
7104% You can also reduce the influence of a particular channel with a gamma
7105% value of 0.
7106%
7107% The format of the MagickLinearStretchImage method is:
7108%
7109% MagickBooleanType MagickLinearStretchImage(MagickWand *wand,
7110% const double black_point,const double white_point)
7111%
7112% A description of each parameter follows:
7113%
7114% o wand: the magick wand.
7115%
7116% o black_point: the black point.
7117%
7118% o white_point: the white point.
7119%
7120*/
7121WandExport MagickBooleanType MagickLinearStretchImage(MagickWand *wand,
7122 const double black_point,const double white_point)
7123{
7124 MagickBooleanType
7125 status;
7126
7127 assert(wand != (MagickWand *) NULL);
7128 assert(wand->signature == MagickWandSignature);
7129 if (wand->debug != MagickFalse)
7130 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7131 if (wand->images == (Image *) NULL)
7132 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7133 status=LinearStretchImage(wand->images,black_point,white_point,
7134 wand->exception);
7135 return(status);
7136}
7137␌
7138/*
7139%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7140% %
7141% %
7142% %
7143% M a g i c k L i q u i d R e s c a l e I m a g e %
7144% %
7145% %
7146% %
7147%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7148%
7149% MagickLiquidRescaleImage() rescales image with seam carving.
7150%
7151% MagickBooleanType MagickLiquidRescaleImage(MagickWand *wand,
7152% const size_t columns,const size_t rows,
7153% const double delta_x,const double rigidity)
7154%
7155% A description of each parameter follows:
7156%
7157% o wand: the magick wand.
7158%
7159% o columns: the number of columns in the scaled image.
7160%
7161% o rows: the number of rows in the scaled image.
7162%
7163% o delta_x: maximum seam transversal step (0 means straight seams).
7164%
7165% o rigidity: introduce a bias for non-straight seams (typically 0).
7166%
7167*/
7168WandExport MagickBooleanType MagickLiquidRescaleImage(MagickWand *wand,
7169 const size_t columns,const size_t rows,const double delta_x,
7170 const double rigidity)
7171{
7172 Image
7173 *rescale_image;
7174
7175 assert(wand != (MagickWand *) NULL);
7176 assert(wand->signature == MagickWandSignature);
7177 if (wand->debug != MagickFalse)
7178 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7179 if (wand->images == (Image *) NULL)
7180 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7181 rescale_image=LiquidRescaleImage(wand->images,columns,rows,delta_x,
7182 rigidity,wand->exception);
7183 if (rescale_image == (Image *) NULL)
7184 return(MagickFalse);
7185 ReplaceImageInList(&wand->images,rescale_image);
7186 return(MagickTrue);
7187}
7188
7189/*
7190%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7191% %
7192% %
7193% %
7194% M a g i c k L o c a l C o n t r a s t I m a g e %
7195% %
7196% %
7197% %
7198%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7199%
7200% MagickLocalContrastImage() attempts to increase the appearance of
7201% large-scale light-dark transitions. Local contrast enhancement works
7202% similarly to sharpening with an unsharp mask, however the mask is instead
7203% created using an image with a greater blur distance.
7204%
7205% MagickBooleanType MagickLocalContrastImage(MagickWand *wand,
7206% const double radius,const double strength)
7207%
7208% A description of each parameter follows:
7209%
7210% o image: the image.
7211%
7212% o radius: the radius of the Gaussian, in pixels, not counting
7213% the center pixel.
7214%
7215% o strength: the strength of the blur mask in percentage.
7216%
7217*/
7218WandExport MagickBooleanType MagickLocalContrastImage(MagickWand *wand,
7219 const double radius, const double strength)
7220{
7221 Image
7222 *contrast_image;
7223
7224 assert(wand != (MagickWand *)NULL);
7225 assert(wand->signature == MagickWandSignature);
7226 if (wand->debug != MagickFalse)
7227 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s", wand->name);
7228 if (wand->images == (Image *)NULL)
7229 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7230 contrast_image=LocalContrastImage(wand->images,radius,strength,
7231 wand->exception);
7232 if (contrast_image == (Image *)NULL)
7233 return(MagickFalse);
7234 ReplaceImageInList(&wand->images,contrast_image);
7235 return(MagickTrue);
7236}
7237␌
7238/*
7239%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7240% %
7241% %
7242% %
7243% M a g i c k M a g n i f y I m a g e %
7244% %
7245% %
7246% %
7247%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7248%
7249% MagickMagnifyImage() is a convenience method that scales an image
7250% proportionally to twice its original size.
7251%
7252% The format of the MagickMagnifyImage method is:
7253%
7254% MagickBooleanType MagickMagnifyImage(MagickWand *wand)
7255%
7256% A description of each parameter follows:
7257%
7258% o wand: the magick wand.
7259%
7260*/
7261WandExport MagickBooleanType MagickMagnifyImage(MagickWand *wand)
7262{
7263 Image
7264 *magnify_image;
7265
7266 assert(wand != (MagickWand *) NULL);
7267 assert(wand->signature == MagickWandSignature);
7268 if (wand->debug != MagickFalse)
7269 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7270 if (wand->images == (Image *) NULL)
7271 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7272 magnify_image=MagnifyImage(wand->images,wand->exception);
7273 if (magnify_image == (Image *) NULL)
7274 return(MagickFalse);
7275 ReplaceImageInList(&wand->images,magnify_image);
7276 return(MagickTrue);
7277}
7278␌
7279/*
7280%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7281% %
7282% %
7283% %
7284% M a g i c k M e a n S h i f t I m a g e %
7285% %
7286% %
7287% %
7288%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7289%
7290% MagickMeanShiftImage() delineate arbitrarily shaped clusters in the image. For
7291% each pixel, it visits all the pixels in the neighborhood specified by
7292% the window centered at the pixel and excludes those that are outside the
7293% radius=(window-1)/2 surrounding the pixel. From those pixels, it finds those
7294% that are within the specified color distance from the current mean, and
7295% computes a new x,y centroid from those coordinates and a new mean. This new
7296% x,y centroid is used as the center for a new window. This process iterates
7297% until it converges and the final mean is replaces the (original window
7298% center) pixel value. It repeats this process for the next pixel, etc.,
7299% until it processes all pixels in the image. Results are typically better with
7300% colorspaces other than sRGB. We recommend YIQ, YUV or YCbCr.
7301%
7302% The format of the MagickMeanShiftImage method is:
7303%
7304% MagickBooleanType MagickMeanShiftImage(MagickWand *wand,
7305% const size_t number_terms,const double *terms)
7306%
7307% A description of each parameter follows:
7308%
7309% o wand: the magick wand.
7310%
7311% o width, height: find pixels in this neighborhood.
7312%
7313% o color_distance: the color distance.
7314%
7315*/
7316WandExport MagickBooleanType MagickMeanShiftImage(MagickWand *wand,
7317 const size_t width,const size_t height,const double color_distance)
7318{
7319 Image
7320 *mean_image;
7321
7322 assert(wand != (MagickWand *) NULL);
7323 assert(wand->signature == MagickWandSignature);
7324 if (wand->debug != MagickFalse)
7325 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7326 if (wand->images == (Image *) NULL)
7327 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7328 mean_image=MeanShiftImage(wand->images,width,height,color_distance,
7329 wand->exception);
7330 if (mean_image == (Image *) NULL)
7331 return(MagickFalse);
7332 ReplaceImageInList(&wand->images,mean_image);
7333 return(MagickTrue);
7334}
7335␌
7336/*
7337%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7338% %
7339% %
7340% %
7341% M a g i c k M e r g e I m a g e L a y e r s %
7342% %
7343% %
7344% %
7345%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7346%
7347% MagickMergeImageLayers() composes all the image layers from the current
7348% given image onward to produce a single image of the merged layers.
7349%
7350% The inital canvas's size depends on the given LayerMethod, and is
7351% initialized using the first images background color. The images
7352% are then composited onto that image in sequence using the given
7353% composition that has been assigned to each individual image.
7354%
7355% The format of the MagickMergeImageLayers method is:
7356%
7357% MagickWand *MagickMergeImageLayers(MagickWand *wand,
7358% const LayerMethod method)
7359%
7360% A description of each parameter follows:
7361%
7362% o wand: the magick wand.
7363%
7364% o method: the method of selecting the size of the initial canvas.
7365%
7366% MergeLayer: Merge all layers onto a canvas just large enough
7367% to hold all the actual images. The virtual canvas of the
7368% first image is preserved but otherwise ignored.
7369%
7370% FlattenLayer: Use the virtual canvas size of first image.
7371% Images which fall outside this canvas is clipped.
7372% This can be used to 'fill out' a given virtual canvas.
7373%
7374% MosaicLayer: Start with the virtual canvas of the first image,
7375% enlarging left and right edges to contain all images.
7376% Images with negative offsets will be clipped.
7377%
7378*/
7379WandExport MagickWand *MagickMergeImageLayers(MagickWand *wand,
7380 const LayerMethod method)
7381{
7382 Image
7383 *mosaic_image;
7384
7385 assert(wand != (MagickWand *) NULL);
7386 assert(wand->signature == MagickWandSignature);
7387 if (wand->debug != MagickFalse)
7388 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7389 if (wand->images == (Image *) NULL)
7390 return((MagickWand *) NULL);
7391 mosaic_image=MergeImageLayers(wand->images,method,wand->exception);
7392 if (mosaic_image == (Image *) NULL)
7393 return((MagickWand *) NULL);
7394 return(CloneMagickWandFromImages(wand,mosaic_image));
7395}
7396␌
7397/*
7398%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7399% %
7400% %
7401% %
7402% M a g i c k M i n i f y I m a g e %
7403% %
7404% %
7405% %
7406%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7407%
7408% MagickMinifyImage() is a convenience method that scales an image
7409% proportionally to one-half its original size
7410%
7411% The format of the MagickMinifyImage method is:
7412%
7413% MagickBooleanType MagickMinifyImage(MagickWand *wand)
7414%
7415% A description of each parameter follows:
7416%
7417% o wand: the magick wand.
7418%
7419*/
7420WandExport MagickBooleanType MagickMinifyImage(MagickWand *wand)
7421{
7422 Image
7423 *minify_image;
7424
7425 assert(wand != (MagickWand *) NULL);
7426 assert(wand->signature == MagickWandSignature);
7427 if (wand->debug != MagickFalse)
7428 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7429 if (wand->images == (Image *) NULL)
7430 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7431 minify_image=MinifyImage(wand->images,wand->exception);
7432 if (minify_image == (Image *) NULL)
7433 return(MagickFalse);
7434 ReplaceImageInList(&wand->images,minify_image);
7435 return(MagickTrue);
7436}
7437␌
7438/*
7439%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7440% %
7441% %
7442% %
7443% M a g i c k M o d u l a t e I m a g e %
7444% %
7445% %
7446% %
7447%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7448%
7449% MagickModulateImage() lets you control the brightness, saturation, and hue
7450% of an image. Hue is the percentage of absolute rotation from the current
7451% position. For example 50 results in a counter-clockwise rotation of 90
7452% degrees, 150 results in a clockwise rotation of 90 degrees, with 0 and 200
7453% both resulting in a rotation of 180 degrees.
7454%
7455% To increase the color brightness by 20% and decrease the color saturation by
7456% 10% and leave the hue unchanged, use: 120,90,100.
7457%
7458% The format of the MagickModulateImage method is:
7459%
7460% MagickBooleanType MagickModulateImage(MagickWand *wand,
7461% const double brightness,const double saturation,const double hue)
7462%
7463% A description of each parameter follows:
7464%
7465% o wand: the magick wand.
7466%
7467% o brightness: the percent change in brightness.
7468%
7469% o saturation: the percent change in saturation.
7470%
7471% o hue: the percent change in hue.
7472%
7473*/
7474WandExport MagickBooleanType MagickModulateImage(MagickWand *wand,
7475 const double brightness,const double saturation,const double hue)
7476{
7477 char
7478 modulate[MagickPathExtent];
7479
7480 MagickBooleanType
7481 status;
7482
7483 assert(wand != (MagickWand *) NULL);
7484 assert(wand->signature == MagickWandSignature);
7485 if (wand->debug != MagickFalse)
7486 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7487 if (wand->images == (Image *) NULL)
7488 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7489 (void) FormatLocaleString(modulate,MagickPathExtent,"%g,%g,%g",
7490 brightness,saturation,hue);
7491 status=ModulateImage(wand->images,modulate,wand->exception);
7492 return(status);
7493}
7494␌
7495/*
7496%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7497% %
7498% %
7499% %
7500% M a g i c k M o n t a g e I m a g e %
7501% %
7502% %
7503% %
7504%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7505%
7506% MagickMontageImage() creates a composite image by combining several
7507% separate images. The images are tiled on the composite image with the name
7508% of the image optionally appearing just below the individual tile.
7509%
7510% The format of the MagickMontageImage method is:
7511%
7512% MagickWand *MagickMontageImage(MagickWand *wand,
7513% const DrawingWand drawing_wand,const char *tile_geometry,
7514% const char *thumbnail_geometry,const MontageMode mode,
7515% const char *frame)
7516%
7517% A description of each parameter follows:
7518%
7519% o wand: the magick wand.
7520%
7521% o drawing_wand: the drawing wand. The font name, size, and color are
7522% obtained from this wand.
7523%
7524% o tile_geometry: the number of tiles per row and page (e.g. 6x4+0+0).
7525%
7526% o thumbnail_geometry: Preferred image size and border size of each
7527% thumbnail (e.g. 120x120+4+3>).
7528%
7529% o mode: Thumbnail framing mode: Frame, Unframe, or Concatenate.
7530%
7531% o frame: Surround the image with an ornamental border (e.g. 15x15+3+3).
7532% The frame color is that of the thumbnail's matte color.
7533%
7534*/
7535WandExport MagickWand *MagickMontageImage(MagickWand *wand,
7536 const DrawingWand *drawing_wand,const char *tile_geometry,
7537 const char *thumbnail_geometry,const MontageMode mode,const char *frame)
7538{
7539 char
7540 *font;
7541
7542 Image
7543 *montage_image;
7544
7545 MontageInfo
7546 *montage_info;
7547
7548 PixelWand
7549 *pixel_wand;
7550
7551 assert(wand != (MagickWand *) NULL);
7552 assert(wand->signature == MagickWandSignature);
7553 if (wand->debug != MagickFalse)
7554 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7555 if (wand->images == (Image *) NULL)
7556 return((MagickWand *) NULL);
7557 montage_info=CloneMontageInfo(wand->image_info,(MontageInfo *) NULL);
7558 switch (mode)
7559 {
7560 case FrameMode:
7561 {
7562 (void) CloneString(&montage_info->frame,"15x15+3+3");
7563 montage_info->shadow=MagickTrue;
7564 break;
7565 }
7566 case UnframeMode:
7567 {
7568 montage_info->frame=(char *) NULL;
7569 montage_info->shadow=MagickFalse;
7570 montage_info->border_width=0;
7571 break;
7572 }
7573 case ConcatenateMode:
7574 {
7575 montage_info->frame=(char *) NULL;
7576 montage_info->shadow=MagickFalse;
7577 (void) CloneString(&montage_info->geometry,"+0+0");
7578 montage_info->border_width=0;
7579 break;
7580 }
7581 default:
7582 break;
7583 }
7584 font=DrawGetFont(drawing_wand);
7585 if (font != (char *) NULL)
7586 (void) CloneString(&montage_info->font,font);
7587 if (frame != (char *) NULL)
7588 (void) CloneString(&montage_info->frame,frame);
7589 montage_info->pointsize=DrawGetFontSize(drawing_wand);
7590 pixel_wand=NewPixelWand();
7591 DrawGetFillColor(drawing_wand,pixel_wand);
7592 PixelGetQuantumPacket(pixel_wand,&montage_info->fill);
7593 DrawGetStrokeColor(drawing_wand,pixel_wand);
7594 PixelGetQuantumPacket(pixel_wand,&montage_info->stroke);
7595 pixel_wand=DestroyPixelWand(pixel_wand);
7596 if (thumbnail_geometry != (char *) NULL)
7597 (void) CloneString(&montage_info->geometry,thumbnail_geometry);
7598 if (tile_geometry != (char *) NULL)
7599 (void) CloneString(&montage_info->tile,tile_geometry);
7600 montage_image=MontageImageList(wand->image_info,montage_info,wand->images,
7601 wand->exception);
7602 montage_info=DestroyMontageInfo(montage_info);
7603 if (montage_image == (Image *) NULL)
7604 return((MagickWand *) NULL);
7605 return(CloneMagickWandFromImages(wand,montage_image));
7606}
7607␌
7608/*
7609%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7610% %
7611% %
7612% %
7613% M a g i c k M o r p h I m a g e s %
7614% %
7615% %
7616% %
7617%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7618%
7619% MagickMorphImages() method morphs a set of images. Both the image pixels
7620% and size are linearly interpolated to give the appearance of a
7621% meta-morphosis from one image to the next.
7622%
7623% The format of the MagickMorphImages method is:
7624%
7625% MagickWand *MagickMorphImages(MagickWand *wand,
7626% const size_t number_frames)
7627%
7628% A description of each parameter follows:
7629%
7630% o wand: the magick wand.
7631%
7632% o number_frames: the number of in-between images to generate.
7633%
7634*/
7635WandExport MagickWand *MagickMorphImages(MagickWand *wand,
7636 const size_t number_frames)
7637{
7638 Image
7639 *morph_image;
7640
7641 assert(wand != (MagickWand *) NULL);
7642 assert(wand->signature == MagickWandSignature);
7643 if (wand->debug != MagickFalse)
7644 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7645 if (wand->images == (Image *) NULL)
7646 return((MagickWand *) NULL);
7647 morph_image=MorphImages(wand->images,number_frames,wand->exception);
7648 if (morph_image == (Image *) NULL)
7649 return((MagickWand *) NULL);
7650 return(CloneMagickWandFromImages(wand,morph_image));
7651}
7652␌
7653/*
7654%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7655% %
7656% %
7657% %
7658% M a g i c k M o r p h o l o g y I m a g e %
7659% %
7660% %
7661% %
7662%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7663%
7664% MagickMorphologyImage() applies a user supplied kernel to the image
7665% according to the given morphology method.
7666%
7667% The format of the MagickMorphologyImage method is:
7668%
7669% MagickBooleanType MagickMorphologyImage(MagickWand *wand,
7670% const MorphologyMethod method,const ssize_t iterations,
7671% const KernelInfo *kernel)
7672%
7673% A description of each parameter follows:
7674%
7675% o wand: the magick wand.
7676%
7677% o method: the morphology method to be applied.
7678%
7679% o iterations: apply the operation this many times (or no change).
7680% A value of -1 means loop until no change found. How this is applied
7681% may depend on the morphology method. Typically this is a value of 1.
7682%
7683% o kernel: An array of doubles representing the morphology kernel.
7684%
7685*/
7686WandExport MagickBooleanType MagickMorphologyImage(MagickWand *wand,
7687 const MorphologyMethod method,const ssize_t iterations,
7688 const KernelInfo *kernel)
7689{
7690 Image
7691 *morphology_image;
7692
7693 assert(wand != (MagickWand *) NULL);
7694 assert(wand->signature == MagickWandSignature);
7695 if (wand->debug != MagickFalse)
7696 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7697 if (kernel == (const KernelInfo *) NULL)
7698 return(MagickFalse);
7699 if (wand->images == (Image *) NULL)
7700 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7701 morphology_image=MorphologyImage(wand->images,method,iterations,kernel,
7702 wand->exception);
7703 if (morphology_image == (Image *) NULL)
7704 return(MagickFalse);
7705 ReplaceImageInList(&wand->images,morphology_image);
7706 return(MagickTrue);
7707}
7708␌
7709/*
7710%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7711% %
7712% %
7713% %
7714% M a g i c k M o t i o n B l u r I m a g e %
7715% %
7716% %
7717% %
7718%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7719%
7720% MagickMotionBlurImage() simulates motion blur. We convolve the image with a
7721% Gaussian operator of the given radius and standard deviation (sigma).
7722% For reasonable results, radius should be larger than sigma. Use a
7723% radius of 0 and MotionBlurImage() selects a suitable radius for you.
7724% Angle gives the angle of the blurring motion.
7725%
7726% The format of the MagickMotionBlurImage method is:
7727%
7728% MagickBooleanType MagickMotionBlurImage(MagickWand *wand,
7729% const double radius,const double sigma,const double angle)
7730%
7731% A description of each parameter follows:
7732%
7733% o wand: the magick wand.
7734%
7735% o radius: the radius of the Gaussian, in pixels, not counting
7736% the center pixel.
7737%
7738% o sigma: the standard deviation of the Gaussian, in pixels.
7739%
7740% o angle: Apply the effect along this angle.
7741%
7742*/
7743WandExport MagickBooleanType MagickMotionBlurImage(MagickWand *wand,
7744 const double radius,const double sigma,const double angle)
7745{
7746 Image
7747 *blur_image;
7748
7749 assert(wand != (MagickWand *) NULL);
7750 assert(wand->signature == MagickWandSignature);
7751 if (wand->debug != MagickFalse)
7752 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7753 if (wand->images == (Image *) NULL)
7754 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7755 blur_image=MotionBlurImage(wand->images,radius,sigma,angle,wand->exception);
7756 if (blur_image == (Image *) NULL)
7757 return(MagickFalse);
7758 ReplaceImageInList(&wand->images,blur_image);
7759 return(MagickTrue);
7760}
7761␌
7762/*
7763%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7764% %
7765% %
7766% %
7767% M a g i c k N e g a t e I m a g e %
7768% %
7769% %
7770% %
7771%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7772%
7773% MagickNegateImage() negates the colors in the reference image. The
7774% Grayscale option means that only grayscale values within the image are
7775% negated.
7776%
7777% You can also reduce the influence of a particular channel with a gamma
7778% value of 0.
7779%
7780% The format of the MagickNegateImage method is:
7781%
7782% MagickBooleanType MagickNegateImage(MagickWand *wand,
7783% const MagickBooleanType gray)
7784%
7785% A description of each parameter follows:
7786%
7787% o wand: the magick wand.
7788%
7789% o gray: If MagickTrue, only negate grayscale pixels within the image.
7790%
7791*/
7792WandExport MagickBooleanType MagickNegateImage(MagickWand *wand,
7793 const MagickBooleanType gray)
7794{
7795 MagickBooleanType
7796 status;
7797
7798 assert(wand != (MagickWand *) NULL);
7799 assert(wand->signature == MagickWandSignature);
7800 if (wand->debug != MagickFalse)
7801 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7802 if (wand->images == (Image *) NULL)
7803 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7804 status=NegateImage(wand->images,gray,wand->exception);
7805 return(status);
7806}
7807␌
7808/*
7809%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7810% %
7811% %
7812% %
7813% M a g i c k N e w I m a g e %
7814% %
7815% %
7816% %
7817%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7818%
7819% MagickNewImage() adds a blank image canvas of the specified size and
7820% background color to the wand.
7821%
7822% The format of the MagickNewImage method is:
7823%
7824% MagickBooleanType MagickNewImage(MagickWand *wand,
7825% const size_t columns,const size_t rows,
7826% const PixelWand *background)
7827%
7828% A description of each parameter follows:
7829%
7830% o wand: the magick wand.
7831%
7832% o width: the image width.
7833%
7834% o height: the image height.
7835%
7836% o background: the image color.
7837%
7838*/
7839WandExport MagickBooleanType MagickNewImage(MagickWand *wand,const size_t width,
7840 const size_t height,const PixelWand *background)
7841{
7842 Image
7843 *images;
7844
7845 PixelInfo
7846 pixel;
7847
7848 assert(wand != (MagickWand *) NULL);
7849 assert(wand->signature == MagickWandSignature);
7850 if (wand->debug != MagickFalse)
7851 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7852 PixelGetMagickColor(background,&pixel);
7853 images=NewMagickImage(wand->image_info,width,height,&pixel,wand->exception);
7854 if (images == (Image *) NULL)
7855 return(MagickFalse);
7856 return(InsertImageInWand(wand,images));
7857}
7858␌
7859/*
7860%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7861% %
7862% %
7863% %
7864% M a g i c k N e x t I m a g e %
7865% %
7866% %
7867% %
7868%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7869%
7870% MagickNextImage() sets the next image in the wand as the current image.
7871%
7872% It is typically used after MagickResetIterator(), after which its first use
7873% will set the first image as the current image (unless the wand is empty).
7874%
7875% It will return MagickFalse when no more images are left to be returned
7876% which happens when the wand is empty, or the current image is the last
7877% image.
7878%
7879% When the above condition (end of image list) is reached, the iterator is
7880% automatically set so that you can start using MagickPreviousImage() to
7881% again iterate over the images in the reverse direction, starting with the
7882% last image (again). You can jump to this condition immediately using
7883% MagickSetLastIterator().
7884%
7885% The format of the MagickNextImage method is:
7886%
7887% MagickBooleanType MagickNextImage(MagickWand *wand)
7888%
7889% A description of each parameter follows:
7890%
7891% o wand: the magick wand.
7892%
7893*/
7894WandExport MagickBooleanType MagickNextImage(MagickWand *wand)
7895{
7896 assert(wand != (MagickWand *) NULL);
7897 assert(wand->signature == MagickWandSignature);
7898 if (wand->debug != MagickFalse)
7899 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7900 if (wand->images == (Image *) NULL)
7901 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7902 wand->insert_before=MagickFalse; /* Inserts is now appended */
7903 if (wand->image_pending != MagickFalse)
7904 {
7905 wand->image_pending=MagickFalse;
7906 return(MagickTrue);
7907 }
7908 if (GetNextImageInList(wand->images) == (Image *) NULL)
7909 {
7910 wand->image_pending=MagickTrue; /* No image, PreviousImage re-gets */
7911 return(MagickFalse);
7912 }
7913 wand->images=GetNextImageInList(wand->images);
7914 return(MagickTrue);
7915}
7916␌
7917/*
7918%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7919% %
7920% %
7921% %
7922% M a g i c k N o r m a l i z e I m a g e %
7923% %
7924% %
7925% %
7926%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7927%
7928% MagickNormalizeImage() enhances the contrast of a color image by adjusting
7929% the pixels color to span the entire range of colors available
7930%
7931% You can also reduce the influence of a particular channel with a gamma
7932% value of 0.
7933%
7934% The format of the MagickNormalizeImage method is:
7935%
7936% MagickBooleanType MagickNormalizeImage(MagickWand *wand)
7937%
7938% A description of each parameter follows:
7939%
7940% o wand: the magick wand.
7941%
7942*/
7943WandExport MagickBooleanType MagickNormalizeImage(MagickWand *wand)
7944{
7945 MagickBooleanType
7946 status;
7947
7948 assert(wand != (MagickWand *) NULL);
7949 assert(wand->signature == MagickWandSignature);
7950 if (wand->debug != MagickFalse)
7951 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7952 if (wand->images == (Image *) NULL)
7953 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7954 status=NormalizeImage(wand->images,wand->exception);
7955 return(status);
7956}
7957␌
7958/*
7959%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7960% %
7961% %
7962% %
7963% M a g i c k O i l P a i n t I m a g e %
7964% %
7965% %
7966% %
7967%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7968%
7969% MagickOilPaintImage() applies a special effect filter that simulates an oil
7970% painting. Each pixel is replaced by the most frequent color occurring
7971% in a circular region defined by radius.
7972%
7973% The format of the MagickOilPaintImage method is:
7974%
7975% MagickBooleanType MagickOilPaintImage(MagickWand *wand,
7976% const double radius,const double sigma)
7977%
7978% A description of each parameter follows:
7979%
7980% o wand: the magick wand.
7981%
7982% o radius: the radius of the circular neighborhood.
7983%
7984% o sigma: the standard deviation of the Gaussian, in pixels.
7985%
7986*/
7987WandExport MagickBooleanType MagickOilPaintImage(MagickWand *wand,
7988 const double radius,const double sigma)
7989{
7990 Image
7991 *paint_image;
7992
7993 assert(wand != (MagickWand *) NULL);
7994 assert(wand->signature == MagickWandSignature);
7995 if (wand->debug != MagickFalse)
7996 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
7997 if (wand->images == (Image *) NULL)
7998 ThrowWandException(WandError,"ContainsNoImages",wand->name);
7999 paint_image=OilPaintImage(wand->images,radius,sigma,wand->exception);
8000 if (paint_image == (Image *) NULL)
8001 return(MagickFalse);
8002 ReplaceImageInList(&wand->images,paint_image);
8003 return(MagickTrue);
8004}
8005␌
8006/*
8007%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8008% %
8009% %
8010% %
8011% M a g i c k O p a q u e P a i n t I m a g e %
8012% %
8013% %
8014% %
8015%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8016%
8017% MagickOpaquePaintImage() changes any pixel that matches color with the color
8018% defined by fill.
8019%
8020% The format of the MagickOpaquePaintImage method is:
8021%
8022% MagickBooleanType MagickOpaquePaintImage(MagickWand *wand,
8023% const PixelWand *target,const PixelWand *fill,const double fuzz,
8024% const MagickBooleanType invert)
8025%
8026% A description of each parameter follows:
8027%
8028% o wand: the magick wand.
8029%
8030% o target: Change this target color to the fill color within the image.
8031%
8032% o fill: the fill pixel wand.
8033%
8034% o fuzz: By default target must match a particular pixel color
8035% exactly. However, in many cases two colors may differ by a small amount.
8036% The fuzz member of image defines how much tolerance is acceptable to
8037% consider two colors as the same. For example, set fuzz to 10 and the
8038% color red at intensities of 100 and 102 respectively are now interpreted
8039% as the same color for the purposes of the floodfill.
8040%
8041% o invert: paint any pixel that does not match the target color.
8042%
8043*/
8044WandExport MagickBooleanType MagickOpaquePaintImage(MagickWand *wand,
8045 const PixelWand *target,const PixelWand *fill,const double fuzz,
8046 const MagickBooleanType invert)
8047{
8048 MagickBooleanType
8049 status;
8050
8051 PixelInfo
8052 fill_pixel,
8053 target_pixel;
8054
8055 assert(wand != (MagickWand *) NULL);
8056 assert(wand->signature == MagickWandSignature);
8057 if (wand->debug != MagickFalse)
8058 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8059 if (wand->images == (Image *) NULL)
8060 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8061 PixelGetMagickColor(target,&target_pixel);
8062 PixelGetMagickColor(fill,&fill_pixel);
8063 wand->images->fuzz=fuzz;
8064 status=OpaquePaintImage(wand->images,&target_pixel,&fill_pixel,invert,
8065 wand->exception);
8066 return(status);
8067}
8068␌
8069/*
8070%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8071% %
8072% %
8073% %
8074% M a g i c k O p t i m i z e I m a g e L a y e r s %
8075% %
8076% %
8077% %
8078%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8079%
8080% MagickOptimizeImageLayers() compares each image the GIF disposed forms of the
8081% previous image in the sequence. From this it attempts to select the
8082% smallest cropped image to replace each frame, while preserving the results
8083% of the animation.
8084%
8085% The format of the MagickOptimizeImageLayers method is:
8086%
8087% MagickWand *MagickOptimizeImageLayers(MagickWand *wand)
8088%
8089% A description of each parameter follows:
8090%
8091% o wand: the magick wand.
8092%
8093*/
8094WandExport MagickWand *MagickOptimizeImageLayers(MagickWand *wand)
8095{
8096 Image
8097 *optimize_image;
8098
8099 assert(wand != (MagickWand *) NULL);
8100 assert(wand->signature == MagickWandSignature);
8101 if (wand->debug != MagickFalse)
8102 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8103 if (wand->images == (Image *) NULL)
8104 return((MagickWand *) NULL);
8105 optimize_image=OptimizeImageLayers(wand->images,wand->exception);
8106 if (optimize_image == (Image *) NULL)
8107 return((MagickWand *) NULL);
8108 return(CloneMagickWandFromImages(wand,optimize_image));
8109}
8110␌
8111/*
8112%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8113% %
8114% %
8115% %
8116% M a g i c k O p t i m i z e I m a g e T r a n s p a r e n c y %
8117% %
8118% %
8119% %
8120%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8121%
8122% MagickOptimizeImageTransparency() takes a frame optimized GIF animation, and
8123% compares the overlayed pixels against the disposal image resulting from all
8124% the previous frames in the animation. Any pixel that does not change the
8125% disposal image (and thus does not effect the outcome of an overlay) is made
8126% transparent.
8127%
8128% WARNING: This modifies the current images directly, rather than generate
8129% a new image sequence.
8130% The format of the MagickOptimizeImageTransparency method is:
8131%
8132% MagickBooleanType MagickOptimizeImageTransparency(MagickWand *wand)
8133%
8134% A description of each parameter follows:
8135%
8136% o wand: the magick wand.
8137%
8138*/
8139WandExport MagickBooleanType MagickOptimizeImageTransparency(MagickWand *wand)
8140{
8141 assert(wand != (MagickWand *) NULL);
8142 assert(wand->signature == MagickWandSignature);
8143 if (wand->debug != MagickFalse)
8144 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8145 if (wand->images == (Image *) NULL)
8146 return(MagickFalse);
8147 OptimizeImageTransparency(wand->images,wand->exception);
8148 return(MagickTrue);
8149}
8150␌
8151/*
8152%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8153% %
8154% %
8155% %
8156% M a g i c k O r d e r e d D i t h e r I m a g e %
8157% %
8158% %
8159% %
8160%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8161%
8162% MagickOrderedDitherImage() performs an ordered dither based on a number
8163% of pre-defined dithering threshold maps, but over multiple intensity levels,
8164% which can be different for different channels, according to the input
8165% arguments.
8166%
8167% The format of the MagickOrderedDitherImage method is:
8168%
8169% MagickBooleanType MagickOrderedDitherImage(MagickWand *wand,
8170% const char *threshold_map)
8171%
8172% A description of each parameter follows:
8173%
8174% o image: the image.
8175%
8176% o threshold_map: A string containing the name of the threshold dither
8177% map to use, followed by zero or more numbers representing the number of
8178% color levels tho dither between.
8179%
8180% Any level number less than 2 is equivalent to 2, and means only binary
8181% dithering will be applied to each color channel.
8182%
8183% No numbers also means a 2 level (bitmap) dither will be applied to all
8184% channels, while a single number is the number of levels applied to each
8185% channel in sequence. More numbers will be applied in turn to each of
8186% the color channels.
8187%
8188% For example: "o3x3,6" generates a 6 level posterization of the image
8189% with a ordered 3x3 diffused pixel dither being applied between each
8190% level. While checker,8,8,4 will produce a 332 colormaped image with
8191% only a single checkerboard hash pattern (50% grey) between each color
8192% level, to basically double the number of color levels with a bare
8193% minimum of dithering.
8194%
8195*/
8196WandExport MagickBooleanType MagickOrderedDitherImage(MagickWand *wand,
8197 const char *threshold_map)
8198{
8199 MagickBooleanType
8200 status;
8201
8202 assert(wand != (MagickWand *) NULL);
8203 assert(wand->signature == MagickWandSignature);
8204 if (wand->debug != MagickFalse)
8205 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8206 if (wand->images == (Image *) NULL)
8207 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8208 status=OrderedDitherImage(wand->images,threshold_map,wand->exception);
8209 return(status);
8210}
8211␌
8212/*
8213%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8214% %
8215% %
8216% %
8217% M a g i c k P i n g I m a g e %
8218% %
8219% %
8220% %
8221%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8222%
8223% MagickPingImage() is the same as MagickReadImage() except the only valid
8224% information returned is the image width, height, size, and format. It
8225% is designed to efficiently obtain this information from a file without
8226% reading the entire image sequence into memory.
8227%
8228% The format of the MagickPingImage method is:
8229%
8230% MagickBooleanType MagickPingImage(MagickWand *wand,const char *filename)
8231%
8232% A description of each parameter follows:
8233%
8234% o wand: the magick wand.
8235%
8236% o filename: the image filename.
8237%
8238*/
8239WandExport MagickBooleanType MagickPingImage(MagickWand *wand,
8240 const char *filename)
8241{
8242 Image
8243 *images;
8244
8245 ImageInfo
8246 *ping_info;
8247
8248 assert(wand != (MagickWand *) NULL);
8249 assert(wand->signature == MagickWandSignature);
8250 if (wand->debug != MagickFalse)
8251 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8252 ping_info=CloneImageInfo(wand->image_info);
8253 if (filename != (const char *) NULL)
8254 (void) CopyMagickString(ping_info->filename,filename,MagickPathExtent);
8255 images=PingImage(ping_info,wand->exception);
8256 ping_info=DestroyImageInfo(ping_info);
8257 if (images == (Image *) NULL)
8258 return(MagickFalse);
8259 return(InsertImageInWand(wand,images));
8260}
8261␌
8262/*
8263%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8264% %
8265% %
8266% %
8267% M a g i c k P i n g I m a g e B l o b %
8268% %
8269% %
8270% %
8271%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8272%
8273% MagickPingImageBlob() pings an image or image sequence from a blob.
8274%
8275% The format of the MagickPingImageBlob method is:
8276%
8277% MagickBooleanType MagickPingImageBlob(MagickWand *wand,
8278% const void *blob,const size_t length)
8279%
8280% A description of each parameter follows:
8281%
8282% o wand: the magick wand.
8283%
8284% o blob: the blob.
8285%
8286% o length: the blob length.
8287%
8288*/
8289WandExport MagickBooleanType MagickPingImageBlob(MagickWand *wand,
8290 const void *blob,const size_t length)
8291{
8292 Image
8293 *images;
8294
8295 assert(wand != (MagickWand *) NULL);
8296 assert(wand->signature == MagickWandSignature);
8297 if (wand->debug != MagickFalse)
8298 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8299 images=PingBlob(wand->image_info,blob,length,wand->exception);
8300 if (images == (Image *) NULL)
8301 return(MagickFalse);
8302 return(InsertImageInWand(wand,images));
8303}
8304␌
8305/*
8306%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8307% %
8308% %
8309% %
8310% M a g i c k P i n g I m a g e F i l e %
8311% %
8312% %
8313% %
8314%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8315%
8316% MagickPingImageFile() pings an image or image sequence from an open file
8317% descriptor.
8318%
8319% The format of the MagickPingImageFile method is:
8320%
8321% MagickBooleanType MagickPingImageFile(MagickWand *wand,FILE *file)
8322%
8323% A description of each parameter follows:
8324%
8325% o wand: the magick wand.
8326%
8327% o file: the file descriptor.
8328%
8329*/
8330WandExport MagickBooleanType MagickPingImageFile(MagickWand *wand,FILE *file)
8331{
8332 Image
8333 *images;
8334
8335 ImageInfo
8336 *read_info;
8337
8338 assert(wand != (MagickWand *) NULL);
8339 assert(wand->signature == MagickWandSignature);
8340 assert(file != (FILE *) NULL);
8341 if (wand->debug != MagickFalse)
8342 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8343 read_info=CloneImageInfo(wand->image_info);
8344 SetImageInfoFile(read_info,file);
8345 images=PingImage(read_info,wand->exception);
8346 read_info=DestroyImageInfo(read_info);
8347 if (images == (Image *) NULL)
8348 return(MagickFalse);
8349 return(InsertImageInWand(wand,images));
8350}
8351␌
8352/*
8353%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8354% %
8355% %
8356% %
8357% M a g i c k P o l a r o i d I m a g e %
8358% %
8359% %
8360% %
8361%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8362%
8363% MagickPolaroidImage() simulates a Polaroid picture.
8364%
8365% The format of the MagickPolaroidImage method is:
8366%
8367% MagickBooleanType MagickPolaroidImage(MagickWand *wand,
8368% const DrawingWand *drawing_wand,const char *caption,const double angle,
8369% const PixelInterpolateMethod method)
8370%
8371% A description of each parameter follows:
8372%
8373% o wand: the magick wand.
8374%
8375% o drawing_wand: the draw wand.
8376%
8377% o caption: the Polaroid caption.
8378%
8379% o angle: Apply the effect along this angle.
8380%
8381% o method: the pixel interpolation method.
8382%
8383*/
8384WandExport MagickBooleanType MagickPolaroidImage(MagickWand *wand,
8385 const DrawingWand *drawing_wand,const char *caption,const double angle,
8386 const PixelInterpolateMethod method)
8387{
8388 DrawInfo
8389 *draw_info;
8390
8391 Image
8392 *polaroid_image;
8393
8394 assert(wand != (MagickWand *) NULL);
8395 assert(wand->signature == MagickWandSignature);
8396 if (wand->debug != MagickFalse)
8397 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8398 if (wand->images == (Image *) NULL)
8399 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8400 draw_info=PeekDrawingWand(drawing_wand);
8401 if (draw_info == (DrawInfo *) NULL)
8402 return(MagickFalse);
8403 polaroid_image=PolaroidImage(wand->images,draw_info,caption,angle,method,
8404 wand->exception);
8405 if (polaroid_image == (Image *) NULL)
8406 return(MagickFalse);
8407 ReplaceImageInList(&wand->images,polaroid_image);
8408 return(MagickTrue);
8409}
8410␌
8411/*
8412%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8413% %
8414% %
8415% %
8416% M a g i c k P o l y n o m i a l I m a g e %
8417% %
8418% %
8419% %
8420%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8421%
8422% MagickPolynomialImage() returns an image where each pixel is the sum of the
8423% pixels in the image sequence after applying its corresponding terms
8424% (coefficient and degree pairs).
8425%
8426% The format of the MagickPolynomialImage method is:
8427%
8428% MagickBooleanType MagickPolynomialImage(MagickWand *wand,
8429% const size_t number_terms,const double *terms)
8430%
8431% A description of each parameter follows:
8432%
8433% o wand: the magick wand.
8434%
8435% o number_terms: the number of terms in the list. The actual list length
8436% is 2 x number_terms + 1 (the constant).
8437%
8438% o terms: the list of polynomial coefficients and degree pairs and a
8439% constant.
8440%
8441*/
8442WandExport MagickBooleanType MagickPolynomialImage(MagickWand *wand,
8443 const size_t number_terms,const double *terms)
8444{
8445 Image
8446 *polynomial_image;
8447
8448 assert(wand != (MagickWand *) NULL);
8449 assert(wand->signature == MagickWandSignature);
8450 if (wand->debug != MagickFalse)
8451 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8452 if (wand->images == (Image *) NULL)
8453 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8454 polynomial_image=PolynomialImage(wand->images,number_terms,terms,
8455 wand->exception);
8456 if (polynomial_image == (Image *) NULL)
8457 return(MagickFalse);
8458 ReplaceImageInList(&wand->images,polynomial_image);
8459 return(MagickTrue);
8460}
8461␌
8462/*
8463%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8464% %
8465% %
8466% %
8467% M a g i c k P o s t e r i z e I m a g e %
8468% %
8469% %
8470% %
8471%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8472%
8473% MagickPosterizeImage() reduces the image to a limited number of color level.
8474%
8475% The format of the MagickPosterizeImage method is:
8476%
8477% MagickBooleanType MagickPosterizeImage(MagickWand *wand,
8478% const size_t levels,const DitherMethod method)
8479%
8480% A description of each parameter follows:
8481%
8482% o wand: the magick wand.
8483%
8484% o levels: Number of color levels allowed in each channel. Very low values
8485% (2, 3, or 4) have the most visible effect.
8486%
8487% o method: choose the dither method: UndefinedDitherMethod,
8488% NoDitherMethod, RiemersmaDitherMethod, or FloydSteinbergDitherMethod.
8489%
8490*/
8491WandExport MagickBooleanType MagickPosterizeImage(MagickWand *wand,
8492 const size_t levels,const DitherMethod dither)
8493{
8494 MagickBooleanType
8495 status;
8496
8497 assert(wand != (MagickWand *) NULL);
8498 assert(wand->signature == MagickWandSignature);
8499 if (wand->debug != MagickFalse)
8500 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8501 if (wand->images == (Image *) NULL)
8502 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8503 status=PosterizeImage(wand->images,levels,dither,wand->exception);
8504 return(status);
8505}
8506␌
8507/*
8508%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8509% %
8510% %
8511% %
8512% M a g i c k P r e v i e w I m a g e s %
8513% %
8514% %
8515% %
8516%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8517%
8518% MagickPreviewImages() tiles 9 thumbnails of the specified image with an
8519% image processing operation applied at varying strengths. This helpful
8520% to quickly pin-point an appropriate parameter for an image processing
8521% operation.
8522%
8523% The format of the MagickPreviewImages method is:
8524%
8525% MagickWand *MagickPreviewImages(MagickWand *wand,
8526% const PreviewType preview)
8527%
8528% A description of each parameter follows:
8529%
8530% o wand: the magick wand.
8531%
8532% o preview: the preview type.
8533%
8534*/
8535WandExport MagickWand *MagickPreviewImages(MagickWand *wand,
8536 const PreviewType preview)
8537{
8538 Image
8539 *preview_image;
8540
8541 assert(wand != (MagickWand *) NULL);
8542 assert(wand->signature == MagickWandSignature);
8543 if (wand->debug != MagickFalse)
8544 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8545 if (wand->images == (Image *) NULL)
8546 return((MagickWand *) NULL);
8547 preview_image=PreviewImage(wand->images,preview,wand->exception);
8548 if (preview_image == (Image *) NULL)
8549 return((MagickWand *) NULL);
8550 return(CloneMagickWandFromImages(wand,preview_image));
8551}
8552␌
8553/*
8554%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8555% %
8556% %
8557% %
8558% M a g i c k P r e v i o u s I m a g e %
8559% %
8560% %
8561% %
8562%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8563%
8564% MagickPreviousImage() sets the previous image in the wand as the current
8565% image.
8566%
8567% It is typically used after MagickSetLastIterator(), after which its first
8568% use will set the last image as the current image (unless the wand is empty).
8569%
8570% It will return MagickFalse when no more images are left to be returned
8571% which happens when the wand is empty, or the current image is the first
8572% image. At that point the iterator is than reset to again process images in
8573% the forward direction, again starting with the first image in list. Images
8574% added at this point are prepended.
8575%
8576% Also at that point any images added to the wand using MagickAddImages() or
8577% MagickReadImages() will be prepended before the first image. In this sense
8578% the condition is not quite exactly the same as MagickResetIterator().
8579%
8580% The format of the MagickPreviousImage method is:
8581%
8582% MagickBooleanType MagickPreviousImage(MagickWand *wand)
8583%
8584% A description of each parameter follows:
8585%
8586% o wand: the magick wand.
8587%
8588*/
8589WandExport MagickBooleanType MagickPreviousImage(MagickWand *wand)
8590{
8591 assert(wand != (MagickWand *) NULL);
8592 assert(wand->signature == MagickWandSignature);
8593 if (wand->debug != MagickFalse)
8594 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8595 if (wand->images == (Image *) NULL)
8596 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8597 if (wand->image_pending != MagickFalse)
8598 {
8599 wand->image_pending=MagickFalse; /* image returned no longer pending */
8600 return(MagickTrue);
8601 }
8602 if (GetPreviousImageInList(wand->images) == (Image *) NULL)
8603 {
8604 wand->image_pending=MagickTrue; /* Next now re-gets first image */
8605 wand->insert_before=MagickTrue; /* insert/add prepends new images */
8606 return(MagickFalse);
8607 }
8608 wand->images=GetPreviousImageInList(wand->images);
8609 return(MagickTrue);
8610}
8611␌
8612/*
8613%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8614% %
8615% %
8616% %
8617% M a g i c k Q u a n t i z e I m a g e %
8618% %
8619% %
8620% %
8621%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8622%
8623% MagickQuantizeImage() analyzes the colors within a reference image and
8624% chooses a fixed number of colors to represent the image. The goal of the
8625% algorithm is to minimize the color difference between the input and output
8626% image while minimizing the processing time.
8627%
8628% The format of the MagickQuantizeImage method is:
8629%
8630% MagickBooleanType MagickQuantizeImage(MagickWand *wand,
8631% const size_t number_colors,const ColorspaceType colorspace,
8632% const size_t treedepth,const DitherMethod dither_method,
8633% const MagickBooleanType measure_error)
8634%
8635% A description of each parameter follows:
8636%
8637% o wand: the magick wand.
8638%
8639% o number_colors: the number of colors.
8640%
8641% o colorspace: Perform color reduction in this colorspace, typically
8642% RGBColorspace.
8643%
8644% o treedepth: Normally, this integer value is zero or one. A zero or
8645% one tells Quantize to choose a optimal tree depth of Log4(number_colors).% A tree of this depth generally allows the best representation of the
8646% reference image with the least amount of memory and the fastest
8647% computational speed. In some cases, such as an image with low color
8648% dispersion (a few number of colors), a value other than
8649% Log4(number_colors) is required. To expand the color tree completely,
8650% use a value of 8.
8651%
8652% o dither_method: choose from UndefinedDitherMethod, NoDitherMethod,
8653% RiemersmaDitherMethod, FloydSteinbergDitherMethod.
8654%
8655% o measure_error: A value other than zero measures the difference between
8656% the original and quantized images. This difference is the total
8657% quantization error. The error is computed by summing over all pixels
8658% in an image the distance squared in RGB space between each reference
8659% pixel value and its quantized value.
8660%
8661*/
8662WandExport MagickBooleanType MagickQuantizeImage(MagickWand *wand,
8663 const size_t number_colors,const ColorspaceType colorspace,
8664 const size_t treedepth,const DitherMethod dither_method,
8665 const MagickBooleanType measure_error)
8666{
8667 MagickBooleanType
8668 status;
8669
8670 QuantizeInfo
8671 *quantize_info;
8672
8673 assert(wand != (MagickWand *) NULL);
8674 assert(wand->signature == MagickWandSignature);
8675 if (wand->debug != MagickFalse)
8676 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8677 if (wand->images == (Image *) NULL)
8678 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8679 quantize_info=CloneQuantizeInfo((QuantizeInfo *) NULL);
8680 quantize_info->number_colors=number_colors;
8681 quantize_info->dither_method=dither_method;
8682 quantize_info->tree_depth=treedepth;
8683 quantize_info->colorspace=colorspace;
8684 quantize_info->measure_error=measure_error;
8685 status=QuantizeImage(quantize_info,wand->images,wand->exception);
8686 quantize_info=DestroyQuantizeInfo(quantize_info);
8687 return(status);
8688}
8689␌
8690/*
8691%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8692% %
8693% %
8694% %
8695% M a g i c k Q u a n t i z e I m a g e s %
8696% %
8697% %
8698% %
8699%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8700%
8701% MagickQuantizeImages() analyzes the colors within a sequence of images and
8702% chooses a fixed number of colors to represent the image. The goal of the
8703% algorithm is to minimize the color difference between the input and output
8704% image while minimizing the processing time.
8705%
8706% The format of the MagickQuantizeImages method is:
8707%
8708% MagickBooleanType MagickQuantizeImages(MagickWand *wand,
8709% const size_t number_colors,const ColorspaceType colorspace,
8710% const size_t treedepth,const DitherMethod dither_method,
8711% const MagickBooleanType measure_error)
8712%
8713% A description of each parameter follows:
8714%
8715% o wand: the magick wand.
8716%
8717% o number_colors: the number of colors.
8718%
8719% o colorspace: Perform color reduction in this colorspace, typically
8720% RGBColorspace.
8721%
8722% o treedepth: Normally, this integer value is zero or one. A zero or
8723% one tells Quantize to choose a optimal tree depth of Log4(number_colors).% A tree of this depth generally allows the best representation of the
8724% reference image with the least amount of memory and the fastest
8725% computational speed. In some cases, such as an image with low color
8726% dispersion (a few number of colors), a value other than
8727% Log4(number_colors) is required. To expand the color tree completely,
8728% use a value of 8.
8729%
8730% o dither_method: choose from these dither methods: NoDitherMethod,
8731% RiemersmaDitherMethod, or FloydSteinbergDitherMethod.
8732%
8733% o measure_error: A value other than zero measures the difference between
8734% the original and quantized images. This difference is the total
8735% quantization error. The error is computed by summing over all pixels
8736% in an image the distance squared in RGB space between each reference
8737% pixel value and its quantized value.
8738%
8739*/
8740WandExport MagickBooleanType MagickQuantizeImages(MagickWand *wand,
8741 const size_t number_colors,const ColorspaceType colorspace,
8742 const size_t treedepth,const DitherMethod dither_method,
8743 const MagickBooleanType measure_error)
8744{
8745 MagickBooleanType
8746 status;
8747
8748 QuantizeInfo
8749 *quantize_info;
8750
8751 assert(wand != (MagickWand *) NULL);
8752 assert(wand->signature == MagickWandSignature);
8753 if (wand->debug != MagickFalse)
8754 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8755 if (wand->images == (Image *) NULL)
8756 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8757 quantize_info=CloneQuantizeInfo((QuantizeInfo *) NULL);
8758 quantize_info->number_colors=number_colors;
8759 quantize_info->dither_method=dither_method;
8760 quantize_info->tree_depth=treedepth;
8761 quantize_info->colorspace=colorspace;
8762 quantize_info->measure_error=measure_error;
8763 status=QuantizeImages(quantize_info,wand->images,wand->exception);
8764 quantize_info=DestroyQuantizeInfo(quantize_info);
8765 return(status);
8766}
8767␌
8768/*
8769%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8770% %
8771% %
8772% %
8773% M a g i c k R a n g e T h r e s h o l d I m a g e %
8774% %
8775% %
8776% %
8777%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8778%
8779% MagickRangeThresholdImage() applies soft and hard thresholding.
8780%
8781% The format of the RangeThresholdImage method is:
8782%
8783% MagickBooleanType MagickRangeThresholdImage(MagickWand *wand,
8784% const double low_black,const double low_white,const double high_white,
8785% const double high_black)
8786%
8787% A description of each parameter follows:
8788%
8789% o wand: the magick wand.
8790%
8791% o low_black: Define the minimum threshold value.
8792%
8793% o low_white: Define the maximum threshold value.
8794%
8795% o high_white: Define the minimum threshold value.
8796%
8797% o low_white: Define the maximum threshold value.
8798%
8799*/
8800WandExport MagickBooleanType MagickRangeThresholdImage(MagickWand *wand,
8801 const double low_black,const double low_white,const double high_white,
8802 const double high_black)
8803{
8804 MagickBooleanType
8805 status;
8806
8807 assert(wand != (MagickWand *) NULL);
8808 assert(wand->signature == MagickWandSignature);
8809 if (wand->debug != MagickFalse)
8810 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8811 if (wand->images == (Image *) NULL)
8812 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8813 status=RangeThresholdImage(wand->images,low_black,low_white,
8814 high_white,high_black,wand->exception);
8815 return(status);
8816}
8817␌
8818/*
8819%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8820% %
8821% %
8822% %
8823% M a g i c k R o t a t i o n a l B l u r I m a g e %
8824% %
8825% %
8826% %
8827%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8828%
8829% MagickRotationalBlurImage() rotational blurs an image.
8830%
8831% The format of the MagickRotationalBlurImage method is:
8832%
8833% MagickBooleanType MagickRotationalBlurImage(MagickWand *wand,
8834% const double angle)
8835%
8836% A description of each parameter follows:
8837%
8838% o wand: the magick wand.
8839%
8840% o angle: the angle of the blur in degrees.
8841%
8842*/
8843WandExport MagickBooleanType MagickRotationalBlurImage(MagickWand *wand,
8844 const double angle)
8845{
8846 Image
8847 *blur_image;
8848
8849 assert(wand != (MagickWand *) NULL);
8850 assert(wand->signature == MagickWandSignature);
8851 if (wand->debug != MagickFalse)
8852 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8853 if (wand->images == (Image *) NULL)
8854 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8855 blur_image=RotationalBlurImage(wand->images,angle,wand->exception);
8856 if (blur_image == (Image *) NULL)
8857 return(MagickFalse);
8858 ReplaceImageInList(&wand->images,blur_image);
8859 return(MagickTrue);
8860}
8861␌
8862/*
8863%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8864% %
8865% %
8866% %
8867% M a g i c k R a i s e I m a g e %
8868% %
8869% %
8870% %
8871%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8872%
8873% MagickRaiseImage() creates a simulated three-dimensional button-like effect
8874% by lightening and darkening the edges of the image. Members width and
8875% height of raise_info define the width of the vertical and horizontal
8876% edge of the effect.
8877%
8878% The format of the MagickRaiseImage method is:
8879%
8880% MagickBooleanType MagickRaiseImage(MagickWand *wand,
8881% const size_t width,const size_t height,const ssize_t x,
8882% const ssize_t y,const MagickBooleanType raise)
8883%
8884% A description of each parameter follows:
8885%
8886% o wand: the magick wand.
8887%
8888% o width,height,x,y: Define the dimensions of the area to raise.
8889%
8890% o raise: A value other than zero creates a 3-D raise effect,
8891% otherwise it has a lowered effect.
8892%
8893*/
8894WandExport MagickBooleanType MagickRaiseImage(MagickWand *wand,
8895 const size_t width,const size_t height,const ssize_t x,
8896 const ssize_t y,const MagickBooleanType raise)
8897{
8898 MagickBooleanType
8899 status;
8900
8901 RectangleInfo
8902 raise_info;
8903
8904 assert(wand != (MagickWand *) NULL);
8905 assert(wand->signature == MagickWandSignature);
8906 if (wand->debug != MagickFalse)
8907 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8908 if (wand->images == (Image *) NULL)
8909 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8910 raise_info.width=width;
8911 raise_info.height=height;
8912 raise_info.x=x;
8913 raise_info.y=y;
8914 status=RaiseImage(wand->images,&raise_info,raise,wand->exception);
8915 return(status);
8916}
8917␌
8918/*
8919%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8920% %
8921% %
8922% %
8923% M a g i c k R a n d o m T h r e s h o l d I m a g e %
8924% %
8925% %
8926% %
8927%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8928%
8929% MagickRandomThresholdImage() changes the value of individual pixels based on
8930% the intensity of each pixel compared to threshold. The result is a
8931% high-contrast, two color image.
8932%
8933% The format of the MagickRandomThresholdImage method is:
8934%
8935% MagickBooleanType MagickRandomThresholdImage(MagickWand *wand,
8936% const double low,const double high)
8937%
8938% A description of each parameter follows:
8939%
8940% o wand: the magick wand.
8941%
8942% o low,high: Specify the high and low thresholds. These values range from
8943% 0 to QuantumRange.
8944%
8945*/
8946WandExport MagickBooleanType MagickRandomThresholdImage(MagickWand *wand,
8947 const double low,const double high)
8948{
8949 assert(wand != (MagickWand *) NULL);
8950 assert(wand->signature == MagickWandSignature);
8951 if (wand->debug != MagickFalse)
8952 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
8953 if (wand->images == (Image *) NULL)
8954 ThrowWandException(WandError,"ContainsNoImages",wand->name);
8955 return(RandomThresholdImage(wand->images,low,high,wand->exception));
8956}
8957␌
8958/*
8959%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8960% %
8961% %
8962% %
8963% M a g i c k R e a d I m a g e %
8964% %
8965% %
8966% %
8967%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8968%
8969% MagickReadImage() reads an image or image sequence. The images are inserted
8970% just before the current image pointer position.
8971%
8972% Use MagickSetFirstIterator(), to insert new images before all the current
8973% images in the wand, MagickSetLastIterator() to append add to the end,
8974% MagickSetIteratorIndex() to place images just after the given index.
8975%
8976% The format of the MagickReadImage method is:
8977%
8978% MagickBooleanType MagickReadImage(MagickWand *wand,const char *filename)
8979%
8980% A description of each parameter follows:
8981%
8982% o wand: the magick wand.
8983%
8984% o filename: the image filename.
8985%
8986*/
8987WandExport MagickBooleanType MagickReadImage(MagickWand *wand,
8988 const char *filename)
8989{
8990 Image
8991 *images;
8992
8993 ImageInfo
8994 *read_info;
8995
8996 assert(wand != (MagickWand *) NULL);
8997 assert(wand->signature == MagickWandSignature);
8998 if (wand->debug != MagickFalse)
8999 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9000 read_info=CloneImageInfo(wand->image_info);
9001 if (filename != (const char *) NULL)
9002 (void) CopyMagickString(read_info->filename,filename,MagickPathExtent);
9003 images=ReadImage(read_info,wand->exception);
9004 read_info=DestroyImageInfo(read_info);
9005 if (images == (Image *) NULL)
9006 return(MagickFalse);
9007 return(InsertImageInWand(wand,images));
9008}
9009␌
9010/*
9011%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9012% %
9013% %
9014% %
9015% M a g i c k R e a d I m a g e B l o b %
9016% %
9017% %
9018% %
9019%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9020%
9021% MagickReadImageBlob() reads an image or image sequence from a blob.
9022% In all other respects it is like MagickReadImage().
9023%
9024% The format of the MagickReadImageBlob method is:
9025%
9026% MagickBooleanType MagickReadImageBlob(MagickWand *wand,
9027% const void *blob,const size_t length)
9028%
9029% A description of each parameter follows:
9030%
9031% o wand: the magick wand.
9032%
9033% o blob: the blob.
9034%
9035% o length: the blob length.
9036%
9037*/
9038WandExport MagickBooleanType MagickReadImageBlob(MagickWand *wand,
9039 const void *blob,const size_t length)
9040{
9041 Image
9042 *images;
9043
9044 assert(wand != (MagickWand *) NULL);
9045 assert(wand->signature == MagickWandSignature);
9046 if (wand->debug != MagickFalse)
9047 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9048 images=BlobToImage(wand->image_info,blob,length,wand->exception);
9049 if (images == (Image *) NULL)
9050 return(MagickFalse);
9051 return(InsertImageInWand(wand,images));
9052}
9053␌
9054/*
9055%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9056% %
9057% %
9058% %
9059% M a g i c k R e a d I m a g e F i l e %
9060% %
9061% %
9062% %
9063%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9064%
9065% MagickReadImageFile() reads an image or image sequence from an already
9066% opened file descriptor. Otherwise it is like MagickReadImage().
9067%
9068% The format of the MagickReadImageFile method is:
9069%
9070% MagickBooleanType MagickReadImageFile(MagickWand *wand,FILE *file)
9071%
9072% A description of each parameter follows:
9073%
9074% o wand: the magick wand.
9075%
9076% o file: the file descriptor.
9077%
9078*/
9079WandExport MagickBooleanType MagickReadImageFile(MagickWand *wand,FILE *file)
9080{
9081 Image
9082 *images;
9083
9084 ImageInfo
9085 *read_info;
9086
9087 assert(wand != (MagickWand *) NULL);
9088 assert(wand->signature == MagickWandSignature);
9089 assert(file != (FILE *) NULL);
9090 if (wand->debug != MagickFalse)
9091 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9092 read_info=CloneImageInfo(wand->image_info);
9093 SetImageInfoFile(read_info,file);
9094 images=ReadImage(read_info,wand->exception);
9095 read_info=DestroyImageInfo(read_info);
9096 if (images == (Image *) NULL)
9097 return(MagickFalse);
9098 return(InsertImageInWand(wand,images));
9099}
9100␌
9101/*
9102%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9103% %
9104% %
9105% %
9106% M a g i c k R e m a p I m a g e %
9107% %
9108% %
9109% %
9110%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9111%
9112% MagickRemapImage() replaces the colors of an image with the closest color
9113% from a reference image.
9114%
9115% The format of the MagickRemapImage method is:
9116%
9117% MagickBooleanType MagickRemapImage(MagickWand *wand,
9118% const MagickWand *remap_wand,const DitherMethod method)
9119%
9120% A description of each parameter follows:
9121%
9122% o wand: the magick wand.
9123%
9124% o affinity: the affinity wand.
9125%
9126% o method: choose from these dither methods: NoDitherMethod,
9127% RiemersmaDitherMethod, or FloydSteinbergDitherMethod.
9128%
9129*/
9130WandExport MagickBooleanType MagickRemapImage(MagickWand *wand,
9131 const MagickWand *remap_wand,const DitherMethod dither_method)
9132{
9133 MagickBooleanType
9134 status;
9135
9136 QuantizeInfo
9137 *quantize_info;
9138
9139 assert(wand != (MagickWand *) NULL);
9140 assert(wand->signature == MagickWandSignature);
9141 if (wand->debug != MagickFalse)
9142 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9143 if ((wand->images == (Image *) NULL) ||
9144 (remap_wand->images == (Image *) NULL))
9145 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9146 quantize_info=AcquireQuantizeInfo(wand->image_info);
9147 quantize_info->dither_method=dither_method;
9148 status=RemapImage(quantize_info,wand->images,remap_wand->images,
9149 wand->exception);
9150 quantize_info=DestroyQuantizeInfo(quantize_info);
9151 return(status);
9152}
9153␌
9154/*
9155%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9156% %
9157% %
9158% %
9159% M a g i c k R e m o v e I m a g e %
9160% %
9161% %
9162% %
9163%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9164%
9165% MagickRemoveImage() removes an image from the image list.
9166%
9167% The format of the MagickRemoveImage method is:
9168%
9169% MagickBooleanType MagickRemoveImage(MagickWand *wand)
9170%
9171% A description of each parameter follows:
9172%
9173% o wand: the magick wand.
9174%
9175% o insert: the splice wand.
9176%
9177*/
9178WandExport MagickBooleanType MagickRemoveImage(MagickWand *wand)
9179{
9180 assert(wand != (MagickWand *) NULL);
9181 assert(wand->signature == MagickWandSignature);
9182 if (wand->debug != MagickFalse)
9183 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9184 if (wand->images == (Image *) NULL)
9185 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9186 DeleteImageFromList(&wand->images);
9187 return(MagickTrue);
9188}
9189␌
9190/*
9191%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9192% %
9193% %
9194% %
9195% M a g i c k R e s a m p l e I m a g e %
9196% %
9197% %
9198% %
9199%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9200%
9201% MagickResampleImage() resample image to desired resolution.
9202%
9203% Bessel Blackman Box
9204% Catrom Cubic Gaussian
9205% Hanning Hermite Lanczos
9206% Mitchell Point Quadratic
9207% Sinc Triangle
9208%
9209% Most of the filters are FIR (finite impulse response), however, Bessel,
9210% Gaussian, and Sinc are IIR (infinite impulse response). Bessel and Sinc
9211% are windowed (brought down to zero) with the Blackman filter.
9212%
9213% The format of the MagickResampleImage method is:
9214%
9215% MagickBooleanType MagickResampleImage(MagickWand *wand,
9216% const double x_resolution,const double y_resolution,
9217% const FilterType filter)
9218%
9219% A description of each parameter follows:
9220%
9221% o wand: the magick wand.
9222%
9223% o x_resolution: the new image x resolution.
9224%
9225% o y_resolution: the new image y resolution.
9226%
9227% o filter: Image filter to use.
9228%
9229*/
9230WandExport MagickBooleanType MagickResampleImage(MagickWand *wand,
9231 const double x_resolution,const double y_resolution,const FilterType filter)
9232{
9233 Image
9234 *resample_image;
9235
9236 assert(wand != (MagickWand *) NULL);
9237 assert(wand->signature == MagickWandSignature);
9238 if (wand->debug != MagickFalse)
9239 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9240 if (wand->images == (Image *) NULL)
9241 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9242 resample_image=ResampleImage(wand->images,x_resolution,y_resolution,filter,
9243 wand->exception);
9244 if (resample_image == (Image *) NULL)
9245 return(MagickFalse);
9246 ReplaceImageInList(&wand->images,resample_image);
9247 return(MagickTrue);
9248}
9249␌
9250/*
9251%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9252% %
9253% %
9254% %
9255% M a g i c k R e s e t I m a g e P a g e %
9256% %
9257% %
9258% %
9259%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9260%
9261% MagickResetImagePage() resets the Wand page canvas and position.
9262%
9263% The format of the MagickResetImagePage method is:
9264%
9265% MagickBooleanType MagickResetImagePage(MagickWand *wand,
9266% const char *page)
9267%
9268% A description of each parameter follows:
9269%
9270% o wand: the magick wand.
9271%
9272% o page: the relative page specification.
9273%
9274*/
9275WandExport MagickBooleanType MagickResetImagePage(MagickWand *wand,
9276 const char *page)
9277{
9278 assert(wand != (MagickWand *) NULL);
9279 assert(wand->signature == MagickWandSignature);
9280 if (wand->debug != MagickFalse)
9281 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9282 if (wand->images == (Image *) NULL)
9283 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9284 if ((page == (char *) NULL) || (*page == '\0'))
9285 {
9286 (void) ParseAbsoluteGeometry("0x0+0+0",&wand->images->page);
9287 return(MagickTrue);
9288 }
9289 return(ResetImagePage(wand->images,page));
9290}
9291␌
9292/*
9293%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9294% %
9295% %
9296% %
9297% M a g i c k R e s i z e I m a g e %
9298% %
9299% %
9300% %
9301%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9302%
9303% MagickResizeImage() scales an image to the desired dimensions with one of
9304% these filters:
9305%
9306% Bessel Blackman Box
9307% Catrom Cubic Gaussian
9308% Hanning Hermite Lanczos
9309% Mitchell Point Quadratic
9310% Sinc Triangle
9311%
9312% Most of the filters are FIR (finite impulse response), however, Bessel,
9313% Gaussian, and Sinc are IIR (infinite impulse response). Bessel and Sinc
9314% are windowed (brought down to zero) with the Blackman filter.
9315%
9316% The format of the MagickResizeImage method is:
9317%
9318% MagickBooleanType MagickResizeImage(MagickWand *wand,
9319% const size_t columns,const size_t rows,const FilterType filter)
9320%
9321% A description of each parameter follows:
9322%
9323% o wand: the magick wand.
9324%
9325% o columns: the number of columns in the scaled image.
9326%
9327% o rows: the number of rows in the scaled image.
9328%
9329% o filter: Image filter to use.
9330%
9331*/
9332WandExport MagickBooleanType MagickResizeImage(MagickWand *wand,
9333 const size_t columns,const size_t rows,const FilterType filter)
9334{
9335 Image
9336 *resize_image;
9337
9338 assert(wand != (MagickWand *) NULL);
9339 assert(wand->signature == MagickWandSignature);
9340 if (wand->debug != MagickFalse)
9341 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9342 if (wand->images == (Image *) NULL)
9343 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9344 resize_image=ResizeImage(wand->images,columns,rows,filter,wand->exception);
9345 if (resize_image == (Image *) NULL)
9346 return(MagickFalse);
9347 ReplaceImageInList(&wand->images,resize_image);
9348 return(MagickTrue);
9349}
9350␌
9351/*
9352%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9353% %
9354% %
9355% %
9356% M a g i c k R o l l I m a g e %
9357% %
9358% %
9359% %
9360%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9361%
9362% MagickRollImage() offsets an image as defined by x and y.
9363%
9364% The format of the MagickRollImage method is:
9365%
9366% MagickBooleanType MagickRollImage(MagickWand *wand,const ssize_t x,
9367% const size_t y)
9368%
9369% A description of each parameter follows:
9370%
9371% o wand: the magick wand.
9372%
9373% o x: the x offset.
9374%
9375% o y: the y offset.
9376%
9377%
9378*/
9379WandExport MagickBooleanType MagickRollImage(MagickWand *wand,
9380 const ssize_t x,const ssize_t y)
9381{
9382 Image
9383 *roll_image;
9384
9385 assert(wand != (MagickWand *) NULL);
9386 assert(wand->signature == MagickWandSignature);
9387 if (wand->debug != MagickFalse)
9388 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9389 if (wand->images == (Image *) NULL)
9390 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9391 roll_image=RollImage(wand->images,x,y,wand->exception);
9392 if (roll_image == (Image *) NULL)
9393 return(MagickFalse);
9394 ReplaceImageInList(&wand->images,roll_image);
9395 return(MagickTrue);
9396}
9397␌
9398/*
9399%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9400% %
9401% %
9402% %
9403% M a g i c k R o t a t e I m a g e %
9404% %
9405% %
9406% %
9407%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9408%
9409% MagickRotateImage() rotates an image the specified number of degrees. Empty
9410% triangles left over from rotating the image are filled with the
9411% background color.
9412%
9413% The format of the MagickRotateImage method is:
9414%
9415% MagickBooleanType MagickRotateImage(MagickWand *wand,
9416% const PixelWand *background,const double degrees)
9417%
9418% A description of each parameter follows:
9419%
9420% o wand: the magick wand.
9421%
9422% o background: the background pixel wand.
9423%
9424% o degrees: the number of degrees to rotate the image.
9425%
9426%
9427*/
9428WandExport MagickBooleanType MagickRotateImage(MagickWand *wand,
9429 const PixelWand *background,const double degrees)
9430{
9431 Image
9432 *rotate_image;
9433
9434 assert(wand != (MagickWand *) NULL);
9435 assert(wand->signature == MagickWandSignature);
9436 if (wand->debug != MagickFalse)
9437 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9438 if (wand->images == (Image *) NULL)
9439 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9440 PixelGetQuantumPacket(background,&wand->images->background_color);
9441 rotate_image=RotateImage(wand->images,degrees,wand->exception);
9442 if (rotate_image == (Image *) NULL)
9443 return(MagickFalse);
9444 ReplaceImageInList(&wand->images,rotate_image);
9445 return(MagickTrue);
9446}
9447␌
9448/*
9449%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9450% %
9451% %
9452% %
9453% M a g i c k S a m p l e I m a g e %
9454% %
9455% %
9456% %
9457%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9458%
9459% MagickSampleImage() scales an image to the desired dimensions with pixel
9460% sampling. Unlike other scaling methods, this method does not introduce
9461% any additional color into the scaled image.
9462%
9463% The format of the MagickSampleImage method is:
9464%
9465% MagickBooleanType MagickSampleImage(MagickWand *wand,
9466% const size_t columns,const size_t rows)
9467%
9468% A description of each parameter follows:
9469%
9470% o wand: the magick wand.
9471%
9472% o columns: the number of columns in the scaled image.
9473%
9474% o rows: the number of rows in the scaled image.
9475%
9476%
9477*/
9478WandExport MagickBooleanType MagickSampleImage(MagickWand *wand,
9479 const size_t columns,const size_t rows)
9480{
9481 Image
9482 *sample_image;
9483
9484 assert(wand != (MagickWand *) NULL);
9485 assert(wand->signature == MagickWandSignature);
9486 if (wand->debug != MagickFalse)
9487 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9488 if (wand->images == (Image *) NULL)
9489 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9490 sample_image=SampleImage(wand->images,columns,rows,wand->exception);
9491 if (sample_image == (Image *) NULL)
9492 return(MagickFalse);
9493 ReplaceImageInList(&wand->images,sample_image);
9494 return(MagickTrue);
9495}
9496␌
9497/*
9498%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9499% %
9500% %
9501% %
9502% M a g i c k S c a l e I m a g e %
9503% %
9504% %
9505% %
9506%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9507%
9508% MagickScaleImage() scales the size of an image to the given dimensions.
9509%
9510% The format of the MagickScaleImage method is:
9511%
9512% MagickBooleanType MagickScaleImage(MagickWand *wand,
9513% const size_t columns,const size_t rows)
9514%
9515% A description of each parameter follows:
9516%
9517% o wand: the magick wand.
9518%
9519% o columns: the number of columns in the scaled image.
9520%
9521% o rows: the number of rows in the scaled image.
9522%
9523%
9524*/
9525WandExport MagickBooleanType MagickScaleImage(MagickWand *wand,
9526 const size_t columns,const size_t rows)
9527{
9528 Image
9529 *scale_image;
9530
9531 assert(wand != (MagickWand *) NULL);
9532 assert(wand->signature == MagickWandSignature);
9533 if (wand->debug != MagickFalse)
9534 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9535 if (wand->images == (Image *) NULL)
9536 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9537 scale_image=ScaleImage(wand->images,columns,rows,wand->exception);
9538 if (scale_image == (Image *) NULL)
9539 return(MagickFalse);
9540 ReplaceImageInList(&wand->images,scale_image);
9541 return(MagickTrue);
9542}
9543␌
9544/*
9545%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9546% %
9547% %
9548% %
9549% M a g i c k S e g m e n t I m a g e %
9550% %
9551% %
9552% %
9553%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9554%
9555% MagickSegmentImage() segments an image by analyzing the histograms of the
9556% color components and identifying units that are homogeneous with the fuzzy
9557% C-means technique.
9558%
9559% The format of the SegmentImage method is:
9560%
9561% MagickBooleanType MagickSegmentImage(MagickWand *wand,
9562% const ColorspaceType colorspace,const MagickBooleanType verbose,
9563% const double cluster_threshold,const double smooth_threshold)
9564%
9565% A description of each parameter follows.
9566%
9567% o wand: the wand.
9568%
9569% o colorspace: the image colorspace.
9570%
9571% o verbose: Set to MagickTrue to print detailed information about the
9572% identified classes.
9573%
9574% o cluster_threshold: This represents the minimum number of pixels
9575% contained in a hexahedra before it can be considered valid (expressed as
9576% a percentage).
9577%
9578% o smooth_threshold: the smoothing threshold eliminates noise in the second
9579% derivative of the histogram. As the value is increased, you can expect a
9580% smoother second derivative.
9581%
9582*/
9583MagickExport MagickBooleanType MagickSegmentImage(MagickWand *wand,
9584 const ColorspaceType colorspace,const MagickBooleanType verbose,
9585 const double cluster_threshold,const double smooth_threshold)
9586{
9587 MagickBooleanType
9588 status;
9589
9590 assert(wand != (MagickWand *) NULL);
9591 assert(wand->signature == MagickWandSignature);
9592 if (wand->debug != MagickFalse)
9593 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9594 if (wand->images == (Image *) NULL)
9595 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9596 status=SegmentImage(wand->images,colorspace,verbose,cluster_threshold,
9597 smooth_threshold,wand->exception);
9598 return(status);
9599}
9600␌
9601/*
9602%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9603% %
9604% %
9605% %
9606% M a g i c k S e l e c t i v e B l u r I m a g e %
9607% %
9608% %
9609% %
9610%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9611%
9612% MagickSelectiveBlurImage() selectively blur an image within a contrast
9613% threshold. It is similar to the unsharpen mask that sharpens everything with
9614% contrast above a certain threshold.
9615%
9616% The format of the MagickSelectiveBlurImage method is:
9617%
9618% MagickBooleanType MagickSelectiveBlurImage(MagickWand *wand,
9619% const double radius,const double sigma,const double threshold)
9620%
9621% A description of each parameter follows:
9622%
9623% o wand: the magick wand.
9624%
9625% o radius: the radius of the gaussian, in pixels, not counting the center
9626% pixel.
9627%
9628% o sigma: the standard deviation of the gaussian, in pixels.
9629%
9630% o threshold: only pixels within this contrast threshold are included
9631% in the blur operation.
9632%
9633*/
9634WandExport MagickBooleanType MagickSelectiveBlurImage(MagickWand *wand,
9635 const double radius,const double sigma,const double threshold)
9636{
9637 Image
9638 *blur_image;
9639
9640 assert(wand != (MagickWand *) NULL);
9641 assert(wand->signature == MagickWandSignature);
9642 if (wand->debug != MagickFalse)
9643 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9644 if (wand->images == (Image *) NULL)
9645 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9646 blur_image=SelectiveBlurImage(wand->images,radius,sigma,threshold,
9647 wand->exception);
9648 if (blur_image == (Image *) NULL)
9649 return(MagickFalse);
9650 ReplaceImageInList(&wand->images,blur_image);
9651 return(MagickTrue);
9652}
9653␌
9654/*
9655%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9656% %
9657% %
9658% %
9659% M a g i c k S e p a r a t e I m a g e C h a n n e l %
9660% %
9661% %
9662% %
9663%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9664%
9665% MagickSeparateImage() separates a channel from the image and returns a
9666% grayscale image. A channel is a particular color component of each pixel
9667% in the image.
9668%
9669% The format of the MagickSeparateImage method is:
9670%
9671% MagickBooleanType MagickSeparateImage(MagickWand *wand,
9672% const ChannelType channel)
9673%
9674% A description of each parameter follows:
9675%
9676% o wand: the magick wand.
9677%
9678% o channel: the channel.
9679%
9680*/
9681WandExport MagickBooleanType MagickSeparateImage(MagickWand *wand,
9682 const ChannelType channel)
9683{
9684 Image
9685 *separate_image;
9686
9687 assert(wand != (MagickWand *) NULL);
9688 assert(wand->signature == MagickWandSignature);
9689 if (wand->debug != MagickFalse)
9690 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9691 if (wand->images == (Image *) NULL)
9692 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9693 separate_image=SeparateImage(wand->images,channel,wand->exception);
9694 if (separate_image == (Image *) NULL)
9695 return(MagickFalse);
9696 ReplaceImageInList(&wand->images,separate_image);
9697 return(MagickTrue);
9698}
9699␌
9700/*
9701%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9702% %
9703% %
9704% %
9705% M a g i c k S e p i a T o n e I m a g e %
9706% %
9707% %
9708% %
9709%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9710%
9711% MagickSepiaToneImage() applies a special effect to the image, similar to the
9712% effect achieved in a photo darkroom by sepia toning. Threshold ranges from
9713% 0 to QuantumRange and is a measure of the extent of the sepia toning. A
9714% threshold of 80% is a good starting point for a reasonable tone.
9715%
9716% The format of the MagickSepiaToneImage method is:
9717%
9718% MagickBooleanType MagickSepiaToneImage(MagickWand *wand,
9719% const double threshold)
9720%
9721% A description of each parameter follows:
9722%
9723% o wand: the magick wand.
9724%
9725% o threshold: Define the extent of the sepia toning.
9726%
9727*/
9728WandExport MagickBooleanType MagickSepiaToneImage(MagickWand *wand,
9729 const double threshold)
9730{
9731 Image
9732 *sepia_image;
9733
9734 assert(wand != (MagickWand *) NULL);
9735 assert(wand->signature == MagickWandSignature);
9736 if (wand->debug != MagickFalse)
9737 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9738 if (wand->images == (Image *) NULL)
9739 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9740 sepia_image=SepiaToneImage(wand->images,threshold,wand->exception);
9741 if (sepia_image == (Image *) NULL)
9742 return(MagickFalse);
9743 ReplaceImageInList(&wand->images,sepia_image);
9744 return(MagickTrue);
9745}
9746␌
9747/*
9748%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9749% %
9750% %
9751% %
9752% M a g i c k S e t I m a g e %
9753% %
9754% %
9755% %
9756%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9757%
9758% MagickSetImage() replaces the last image returned by MagickSetIteratorIndex(),
9759% MagickNextImage(), MagickPreviousImage() with the images from the specified
9760% wand.
9761%
9762% The format of the MagickSetImage method is:
9763%
9764% MagickBooleanType MagickSetImage(MagickWand *wand,
9765% const MagickWand *set_wand)
9766%
9767% A description of each parameter follows:
9768%
9769% o wand: the magick wand.
9770%
9771% o set_wand: the set_wand wand.
9772%
9773*/
9774WandExport MagickBooleanType MagickSetImage(MagickWand *wand,
9775 const MagickWand *set_wand)
9776{
9777 Image
9778 *images;
9779
9780 assert(wand != (MagickWand *) NULL);
9781 assert(wand->signature == MagickWandSignature);
9782 if (wand->debug != MagickFalse)
9783 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9784 assert(set_wand != (MagickWand *) NULL);
9785 assert(set_wand->signature == MagickWandSignature);
9786 if (wand->debug != MagickFalse)
9787 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",set_wand->name);
9788 if (set_wand->images == (Image *) NULL)
9789 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9790 images=CloneImageList(set_wand->images,wand->exception);
9791 if (images == (Image *) NULL)
9792 return(MagickFalse);
9793 ReplaceImageInList(&wand->images,images);
9794 return(MagickTrue);
9795}
9796␌
9797/*
9798%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9799% %
9800% %
9801% %
9802% M a g i c k S e t I m a g e A l p h a C h a n n e l %
9803% %
9804% %
9805% %
9806%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9807%
9808% MagickSetImageAlphaChannel() activates, deactivates, resets, or sets the
9809% alpha channel.
9810%
9811% The format of the MagickSetImageAlphaChannel method is:
9812%
9813% MagickBooleanType MagickSetImageAlphaChannel(MagickWand *wand,
9814% const AlphaChannelOption alpha_type)
9815%
9816% A description of each parameter follows:
9817%
9818% o wand: the magick wand.
9819%
9820% o alpha_type: the alpha channel type: ActivateAlphaChannel,
9821% DeactivateAlphaChannel, OpaqueAlphaChannel, or SetAlphaChannel.
9822%
9823*/
9824WandExport MagickBooleanType MagickSetImageAlphaChannel(MagickWand *wand,
9825 const AlphaChannelOption alpha_type)
9826{
9827 assert(wand != (MagickWand *) NULL);
9828 assert(wand->signature == MagickWandSignature);
9829 if (wand->debug != MagickFalse)
9830 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9831 if (wand->images == (Image *) NULL)
9832 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9833 return(SetImageAlphaChannel(wand->images,alpha_type,wand->exception));
9834}
9835␌
9836/*
9837%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9838% %
9839% %
9840% %
9841% M a g i c k S e t I m a g e B a c k g r o u n d C o l o r %
9842% %
9843% %
9844% %
9845%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9846%
9847% MagickSetImageBackgroundColor() sets the image background color.
9848%
9849% The format of the MagickSetImageBackgroundColor method is:
9850%
9851% MagickBooleanType MagickSetImageBackgroundColor(MagickWand *wand,
9852% const PixelWand *background)
9853%
9854% A description of each parameter follows:
9855%
9856% o wand: the magick wand.
9857%
9858% o background: the background pixel wand.
9859%
9860*/
9861WandExport MagickBooleanType MagickSetImageBackgroundColor(MagickWand *wand,
9862 const PixelWand *background)
9863{
9864 assert(wand != (MagickWand *) NULL);
9865 assert(wand->signature == MagickWandSignature);
9866 if (wand->debug != MagickFalse)
9867 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9868 if (wand->images == (Image *) NULL)
9869 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9870 PixelGetQuantumPacket(background,&wand->images->background_color);
9871 return(MagickTrue);
9872}
9873␌
9874/*
9875%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9876% %
9877% %
9878% %
9879% M a g i c k S e t I m a g e B l u e P r i m a r y %
9880% %
9881% %
9882% %
9883%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9884%
9885% MagickSetImageBluePrimary() sets the image chromaticity blue primary point.
9886%
9887% The format of the MagickSetImageBluePrimary method is:
9888%
9889% MagickBooleanType MagickSetImageBluePrimary(MagickWand *wand,
9890% const double x,const double y,const double z)
9891%
9892% A description of each parameter follows:
9893%
9894% o wand: the magick wand.
9895%
9896% o x: the blue primary x-point.
9897%
9898% o y: the blue primary y-point.
9899%
9900% o z: the blue primary z-point.
9901%
9902*/
9903WandExport MagickBooleanType MagickSetImageBluePrimary(MagickWand *wand,
9904 const double x,const double y,const double z)
9905{
9906 assert(wand != (MagickWand *) NULL);
9907 assert(wand->signature == MagickWandSignature);
9908 if (wand->debug != MagickFalse)
9909 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9910 if (wand->images == (Image *) NULL)
9911 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9912 wand->images->chromaticity.blue_primary.x=x;
9913 wand->images->chromaticity.blue_primary.y=y;
9914 wand->images->chromaticity.blue_primary.z=z;
9915 return(MagickTrue);
9916}
9917␌
9918/*
9919%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9920% %
9921% %
9922% %
9923% M a g i c k S e t I m a g e B o r d e r C o l o r %
9924% %
9925% %
9926% %
9927%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9928%
9929% MagickSetImageBorderColor() sets the image border color.
9930%
9931% The format of the MagickSetImageBorderColor method is:
9932%
9933% MagickBooleanType MagickSetImageBorderColor(MagickWand *wand,
9934% const PixelWand *border)
9935%
9936% A description of each parameter follows:
9937%
9938% o wand: the magick wand.
9939%
9940% o border: the border pixel wand.
9941%
9942*/
9943WandExport MagickBooleanType MagickSetImageBorderColor(MagickWand *wand,
9944 const PixelWand *border)
9945{
9946 assert(wand != (MagickWand *) NULL);
9947 assert(wand->signature == MagickWandSignature);
9948 if (wand->debug != MagickFalse)
9949 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9950 if (wand->images == (Image *) NULL)
9951 ThrowWandException(WandError,"ContainsNoImages",wand->name);
9952 PixelGetQuantumPacket(border,&wand->images->border_color);
9953 return(MagickTrue);
9954}
9955␌
9956/*
9957%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9958% %
9959% %
9960% %
9961% M a g i c k S e t I m a g e C h a n n e l M a s k %
9962% %
9963% %
9964% %
9965%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9966%
9967% MagickSetImageChannelMask() sets image channel mask.
9968%
9969% The format of the MagickSetImageChannelMask method is:
9970%
9971% ChannelType MagickSetImageChannelMask(MagickWand *wand,
9972% const ChannelType channel_mask)
9973%
9974% A description of each parameter follows:
9975%
9976% o wand: the magick wand.
9977%
9978% o channel_mask: the channel_mask wand.
9979%
9980*/
9981WandExport ChannelType MagickSetImageChannelMask(MagickWand *wand,
9982 const ChannelType channel_mask)
9983{
9984 assert(wand != (MagickWand *) NULL);
9985 assert(wand->signature == MagickWandSignature);
9986 if (wand->debug != MagickFalse)
9987 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
9988 return(SetImageChannelMask(wand->images,channel_mask));
9989}
9990␌
9991/*
9992%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9993% %
9994% %
9995% %
9996% M a g i c k S e t I m a g e M a s k %
9997% %
9998% %
9999% %
10000%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10001%
10002% MagickSetImageMask() sets image clip mask.
10003%
10004% The format of the MagickSetImageMask method is:
10005%
10006% MagickBooleanType MagickSetImageMask(MagickWand *wand,
10007% const PixelMask type,const MagickWand *clip_mask)
10008%
10009% A description of each parameter follows:
10010%
10011% o wand: the magick wand.
10012%
10013% o type: type of mask, ReadPixelMask or WritePixelMask.
10014%
10015% o clip_mask: the clip_mask wand.
10016%
10017*/
10018WandExport MagickBooleanType MagickSetImageMask(MagickWand *wand,
10019 const PixelMask type,const MagickWand *clip_mask)
10020{
10021 assert(wand != (MagickWand *) NULL);
10022 assert(wand->signature == MagickWandSignature);
10023 if (wand->debug != MagickFalse)
10024 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10025 assert(clip_mask != (MagickWand *) NULL);
10026 assert(clip_mask->signature == MagickWandSignature);
10027 if (clip_mask->debug != MagickFalse)
10028 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",clip_mask->name);
10029 if (clip_mask->images == (Image *) NULL)
10030 ThrowWandException(WandError,"ContainsNoImages",clip_mask->name);
10031 return(SetImageMask(wand->images,type,clip_mask->images,wand->exception));
10032}
10033␌
10034/*
10035%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10036% %
10037% %
10038% %
10039% M a g i c k S e t I m a g e C o l o r %
10040% %
10041% %
10042% %
10043%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10044%
10045% MagickSetImageColor() set the entire wand canvas to the specified color.
10046%
10047% The format of the MagickSetImageColor method is:
10048%
10049% MagickBooleanType MagickSetImageColor(MagickWand *wand,
10050% const PixelWand *color)
10051%
10052% A description of each parameter follows:
10053%
10054% o wand: the magick wand.
10055%
10056% o background: the image color.
10057%
10058*/
10059WandExport MagickBooleanType MagickSetImageColor(MagickWand *wand,
10060 const PixelWand *color)
10061{
10062 PixelInfo
10063 pixel;
10064
10065 assert(wand != (MagickWand *) NULL);
10066 assert(wand->signature == MagickWandSignature);
10067 if (wand->debug != MagickFalse)
10068 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10069 PixelGetMagickColor(color,&pixel);
10070 return(SetImageColor(wand->images,&pixel,wand->exception));
10071}
10072␌
10073/*
10074%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10075% %
10076% %
10077% %
10078% M a g i c k S e t I m a g e C o l o r m a p C o l o r %
10079% %
10080% %
10081% %
10082%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10083%
10084% MagickSetImageColormapColor() sets the color of the specified colormap
10085% index.
10086%
10087% The format of the MagickSetImageColormapColor method is:
10088%
10089% MagickBooleanType MagickSetImageColormapColor(MagickWand *wand,
10090% const size_t index,const PixelWand *color)
10091%
10092% A description of each parameter follows:
10093%
10094% o wand: the magick wand.
10095%
10096% o index: the offset into the image colormap.
10097%
10098% o color: Return the colormap color in this wand.
10099%
10100*/
10101WandExport MagickBooleanType MagickSetImageColormapColor(MagickWand *wand,
10102 const size_t index,const PixelWand *color)
10103{
10104 assert(wand != (MagickWand *) NULL);
10105 assert(wand->signature == MagickWandSignature);
10106 if (wand->debug != MagickFalse)
10107 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10108 if (wand->images == (Image *) NULL)
10109 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10110 if ((wand->images->colormap == (PixelInfo *) NULL) ||
10111 (index >= wand->images->colors))
10112 ThrowWandException(WandError,"InvalidColormapIndex",wand->name);
10113 PixelGetQuantumPacket(color,wand->images->colormap+index);
10114 return(SyncImage(wand->images,wand->exception));
10115}
10116␌
10117/*
10118%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10119% %
10120% %
10121% %
10122% M a g i c k S e t I m a g e C o l o r s p a c e %
10123% %
10124% %
10125% %
10126%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10127%
10128% MagickSetImageColorspace() sets the image colorspace. But does not modify
10129% the image data.
10130%
10131% The format of the MagickSetImageColorspace method is:
10132%
10133% MagickBooleanType MagickSetImageColorspace(MagickWand *wand,
10134% const ColorspaceType colorspace)
10135%
10136% A description of each parameter follows:
10137%
10138% o wand: the magick wand.
10139%
10140% o colorspace: the image colorspace: UndefinedColorspace, RGBColorspace,
10141% GRAYColorspace, TransparentColorspace, OHTAColorspace, XYZColorspace,
10142% YCbCrColorspace, YCCColorspace, YIQColorspace, YPbPrColorspace,
10143% YPbPrColorspace, YUVColorspace, CMYKColorspace, sRGBColorspace,
10144% HSLColorspace, or HWBColorspace.
10145%
10146*/
10147WandExport MagickBooleanType MagickSetImageColorspace(MagickWand *wand,
10148 const ColorspaceType colorspace)
10149{
10150 assert(wand != (MagickWand *) NULL);
10151 assert(wand->signature == MagickWandSignature);
10152 if (wand->debug != MagickFalse)
10153 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10154 if (wand->images == (Image *) NULL)
10155 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10156 return(SetImageColorspace(wand->images,colorspace,wand->exception));
10157}
10158␌
10159/*
10160%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10161% %
10162% %
10163% %
10164% M a g i c k S e t I m a g e C o m p o s e %
10165% %
10166% %
10167% %
10168%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10169%
10170% MagickSetImageCompose() sets the image composite operator, useful for
10171% specifying how to composite the image thumbnail when using the
10172% MagickMontageImage() method.
10173%
10174% The format of the MagickSetImageCompose method is:
10175%
10176% MagickBooleanType MagickSetImageCompose(MagickWand *wand,
10177% const CompositeOperator compose)
10178%
10179% A description of each parameter follows:
10180%
10181% o wand: the magick wand.
10182%
10183% o compose: the image composite operator.
10184%
10185*/
10186WandExport MagickBooleanType MagickSetImageCompose(MagickWand *wand,
10187 const CompositeOperator compose)
10188{
10189 assert(wand != (MagickWand *) NULL);
10190 assert(wand->signature == MagickWandSignature);
10191 if (wand->debug != MagickFalse)
10192 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10193 if (wand->images == (Image *) NULL)
10194 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10195 wand->images->compose=compose;
10196 return(MagickTrue);
10197}
10198␌
10199/*
10200%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10201% %
10202% %
10203% %
10204% M a g i c k S e t I m a g e C o m p r e s s i o n %
10205% %
10206% %
10207% %
10208%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10209%
10210% MagickSetImageCompression() sets the image compression.
10211%
10212% The format of the MagickSetImageCompression method is:
10213%
10214% MagickBooleanType MagickSetImageCompression(MagickWand *wand,
10215% const CompressionType compression)
10216%
10217% A description of each parameter follows:
10218%
10219% o wand: the magick wand.
10220%
10221% o compression: the image compression type.
10222%
10223*/
10224WandExport MagickBooleanType MagickSetImageCompression(MagickWand *wand,
10225 const CompressionType compression)
10226{
10227 assert(wand != (MagickWand *) NULL);
10228 assert(wand->signature == MagickWandSignature);
10229 if (wand->debug != MagickFalse)
10230 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10231 if (wand->images == (Image *) NULL)
10232 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10233 wand->images->compression=compression;
10234 return(MagickTrue);
10235}
10236␌
10237/*
10238%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10239% %
10240% %
10241% %
10242% M a g i c k S e t I m a g e C o m p r e s s i o n Q u a l i t y %
10243% %
10244% %
10245% %
10246%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10247%
10248% MagickSetImageCompressionQuality() sets the image compression quality.
10249%
10250% The format of the MagickSetImageCompressionQuality method is:
10251%
10252% MagickBooleanType MagickSetImageCompressionQuality(MagickWand *wand,
10253% const size_t quality)
10254%
10255% A description of each parameter follows:
10256%
10257% o wand: the magick wand.
10258%
10259% o quality: the image compression tlityype.
10260%
10261*/
10262WandExport MagickBooleanType MagickSetImageCompressionQuality(MagickWand *wand,
10263 const size_t quality)
10264{
10265 assert(wand != (MagickWand *) NULL);
10266 assert(wand->signature == MagickWandSignature);
10267 if (wand->debug != MagickFalse)
10268 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10269 if (wand->images == (Image *) NULL)
10270 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10271 wand->images->quality=quality;
10272 return(MagickTrue);
10273}
10274␌
10275/*
10276%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10277% %
10278% %
10279% %
10280% M a g i c k S e t I m a g e D e l a y %
10281% %
10282% %
10283% %
10284%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10285%
10286% MagickSetImageDelay() sets the image delay.
10287%
10288% The format of the MagickSetImageDelay method is:
10289%
10290% MagickBooleanType MagickSetImageDelay(MagickWand *wand,
10291% const size_t delay)
10292%
10293% A description of each parameter follows:
10294%
10295% o wand: the magick wand.
10296%
10297% o delay: the image delay in ticks-per-second units.
10298%
10299*/
10300WandExport MagickBooleanType MagickSetImageDelay(MagickWand *wand,
10301 const size_t delay)
10302{
10303 assert(wand != (MagickWand *) NULL);
10304 assert(wand->signature == MagickWandSignature);
10305 if (wand->debug != MagickFalse)
10306 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10307 if (wand->images == (Image *) NULL)
10308 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10309 wand->images->delay=delay;
10310 return(MagickTrue);
10311}
10312␌
10313/*
10314%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10315% %
10316% %
10317% %
10318% M a g i c k S e t I m a g e D e p t h %
10319% %
10320% %
10321% %
10322%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10323%
10324% MagickSetImageDepth() sets the image depth.
10325%
10326% The format of the MagickSetImageDepth method is:
10327%
10328% MagickBooleanType MagickSetImageDepth(MagickWand *wand,
10329% const size_t depth)
10330%
10331% A description of each parameter follows:
10332%
10333% o wand: the magick wand.
10334%
10335% o depth: the image depth in bits: 8, 16, or 32.
10336%
10337*/
10338WandExport MagickBooleanType MagickSetImageDepth(MagickWand *wand,
10339 const size_t depth)
10340{
10341 assert(wand != (MagickWand *) NULL);
10342 assert(wand->signature == MagickWandSignature);
10343 if (wand->debug != MagickFalse)
10344 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10345 if (wand->images == (Image *) NULL)
10346 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10347 return(SetImageDepth(wand->images,depth,wand->exception));
10348}
10349␌
10350/*
10351%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10352% %
10353% %
10354% %
10355% M a g i c k S e t I m a g e D i s p o s e %
10356% %
10357% %
10358% %
10359%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10360%
10361% MagickSetImageDispose() sets the image disposal method.
10362%
10363% The format of the MagickSetImageDispose method is:
10364%
10365% MagickBooleanType MagickSetImageDispose(MagickWand *wand,
10366% const DisposeType dispose)
10367%
10368% A description of each parameter follows:
10369%
10370% o wand: the magick wand.
10371%
10372% o dispose: the image disposal type.
10373%
10374*/
10375WandExport MagickBooleanType MagickSetImageDispose(MagickWand *wand,
10376 const DisposeType dispose)
10377{
10378 assert(wand != (MagickWand *) NULL);
10379 assert(wand->signature == MagickWandSignature);
10380 if (wand->debug != MagickFalse)
10381 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10382 if (wand->images == (Image *) NULL)
10383 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10384 wand->images->dispose=dispose;
10385 return(MagickTrue);
10386}
10387␌
10388/*
10389%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10390% %
10391% %
10392% %
10393% M a g i c k S e t I m a g e E n d i a n %
10394% %
10395% %
10396% %
10397%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10398%
10399% MagickSetImageEndian() sets the image endian method.
10400%
10401% The format of the MagickSetImageEndian method is:
10402%
10403% MagickBooleanType MagickSetImageEndian(MagickWand *wand,
10404% const EndianType endian)
10405%
10406% A description of each parameter follows:
10407%
10408% o wand: the magick wand.
10409%
10410% o endian: the image endian type.
10411%
10412*/
10413WandExport MagickBooleanType MagickSetImageEndian(MagickWand *wand,
10414 const EndianType endian)
10415{
10416 assert(wand != (MagickWand *) NULL);
10417 assert(wand->signature == MagickWandSignature);
10418 if (wand->debug != MagickFalse)
10419 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10420 if (wand->images == (Image *) NULL)
10421 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10422 wand->images->endian=endian;
10423 return(MagickTrue);
10424}
10425␌
10426/*
10427%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10428% %
10429% %
10430% %
10431% M a g i c k S e t I m a g e E x t e n t %
10432% %
10433% %
10434% %
10435%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10436%
10437% MagickSetImageExtent() sets the image size (i.e. columns & rows).
10438%
10439% The format of the MagickSetImageExtent method is:
10440%
10441% MagickBooleanType MagickSetImageExtent(MagickWand *wand,
10442% const size_t columns,const unsigned rows)
10443%
10444% A description of each parameter follows:
10445%
10446% o wand: the magick wand.
10447%
10448% o columns: The image width in pixels.
10449%
10450% o rows: The image height in pixels.
10451%
10452*/
10453WandExport MagickBooleanType MagickSetImageExtent(MagickWand *wand,
10454 const size_t columns,const size_t rows)
10455{
10456 assert(wand != (MagickWand *) NULL);
10457 assert(wand->signature == MagickWandSignature);
10458 if (wand->debug != MagickFalse)
10459 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10460 if (wand->images == (Image *) NULL)
10461 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10462 return(SetImageExtent(wand->images,columns,rows,wand->exception));
10463}
10464␌
10465/*
10466%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10467% %
10468% %
10469% %
10470% M a g i c k S e t I m a g e F i l e n a m e %
10471% %
10472% %
10473% %
10474%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10475%
10476% MagickSetImageFilename() sets the filename of a particular image in a
10477% sequence.
10478%
10479% The format of the MagickSetImageFilename method is:
10480%
10481% MagickBooleanType MagickSetImageFilename(MagickWand *wand,
10482% const char *filename)
10483%
10484% A description of each parameter follows:
10485%
10486% o wand: the magick wand.
10487%
10488% o filename: the image filename.
10489%
10490*/
10491WandExport MagickBooleanType MagickSetImageFilename(MagickWand *wand,
10492 const char *filename)
10493{
10494 assert(wand != (MagickWand *) NULL);
10495 assert(wand->signature == MagickWandSignature);
10496 if (wand->debug != MagickFalse)
10497 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10498 if (wand->images == (Image *) NULL)
10499 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10500 if (filename == (const char *) NULL)
10501 return(MagickFalse);
10502 (void) CopyMagickString(wand->images->filename,filename,MagickPathExtent);
10503 return(MagickTrue);
10504}
10505␌
10506/*
10507%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10508% %
10509% %
10510% %
10511% M a g i c k S e t I m a g e G r a v i t y %
10512% %
10513% %
10514% %
10515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10516%
10517% MagickSetImageFilter() sets the image filter type.
10518%
10519% The format of the MagickSetImageFilter method is:
10520%
10521% MagickBooleanType MagickSetImageFilter(MagickWand *wand,
10522% const FilterType filter)
10523%
10524% A description of each parameter follows:
10525%
10526% o wand: the magick wand.
10527%
10528% o filter: Bartlett, Blackman, Bohman, Box, Catrom, Cosine, Cubic,
10529% CubicSpline, Gaussian, Hamming, Hann, Hermite, Jinc, Kaiser, Lagrange,
10530% Lanczos, Lanczos2, Lanczos2Sharp, LanczosRadius, LanczosSharp, Mitchell,
10531% Parzen, Point, Quadratic, Robidoux, RobidouxSharp, Sinc, SincFast,
10532% Spline, Triangle, Undefined, Welch.
10533%
10534*/
10535WandExport MagickBooleanType MagickSetImageFilter(MagickWand *wand,
10536 const FilterType filter)
10537{
10538 assert(wand != (MagickWand *) NULL);
10539 assert(wand->signature == MagickWandSignature);
10540 if (wand->debug != MagickFalse)
10541 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10542 if (wand->images == (Image *) NULL)
10543 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10544 wand->images->filter=filter;
10545 return(MagickTrue);
10546}
10547␌
10548/*
10549%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10550% %
10551% %
10552% %
10553% M a g i c k S e t I m a g e F o r m a t %
10554% %
10555% %
10556% %
10557%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10558%
10559% MagickSetImageFormat() sets the format of a particular image in a
10560% sequence.
10561%
10562% The format of the MagickSetImageFormat method is:
10563%
10564% MagickBooleanType MagickSetImageFormat(MagickWand *wand,
10565% const char *format)
10566%
10567% A description of each parameter follows:
10568%
10569% o wand: the magick wand.
10570%
10571% o format: the image format.
10572%
10573*/
10574WandExport MagickBooleanType MagickSetImageFormat(MagickWand *wand,
10575 const char *format)
10576{
10577 const MagickInfo
10578 *magick_info;
10579
10580 assert(wand != (MagickWand *) NULL);
10581 assert(wand->signature == MagickWandSignature);
10582 if (wand->debug != MagickFalse)
10583 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10584 if (wand->images == (Image *) NULL)
10585 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10586 if ((format == (char *) NULL) || (*format == '\0'))
10587 {
10588 *wand->images->magick='\0';
10589 return(MagickTrue);
10590 }
10591 magick_info=GetMagickInfo(format,wand->exception);
10592 if (magick_info == (const MagickInfo *) NULL)
10593 return(MagickFalse);
10594 ClearMagickException(wand->exception);
10595 (void) CopyMagickString(wand->images->magick,format,MagickPathExtent);
10596 LocaleUpper(wand->images->magick);
10597 return(MagickTrue);
10598}
10599␌
10600/*
10601%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10602% %
10603% %
10604% %
10605% M a g i c k S e t I m a g e F u z z %
10606% %
10607% %
10608% %
10609%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10610%
10611% MagickSetImageFuzz() sets the image fuzz.
10612%
10613% The format of the MagickSetImageFuzz method is:
10614%
10615% MagickBooleanType MagickSetImageFuzz(MagickWand *wand,
10616% const double fuzz)
10617%
10618% A description of each parameter follows:
10619%
10620% o wand: the magick wand.
10621%
10622% o fuzz: the image fuzz.
10623%
10624*/
10625WandExport MagickBooleanType MagickSetImageFuzz(MagickWand *wand,
10626 const double fuzz)
10627{
10628 assert(wand != (MagickWand *) NULL);
10629 assert(wand->signature == MagickWandSignature);
10630 if (wand->debug != MagickFalse)
10631 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10632 if (wand->images == (Image *) NULL)
10633 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10634 wand->images->fuzz=fuzz;
10635 return(MagickTrue);
10636}
10637␌
10638/*
10639%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10640% %
10641% %
10642% %
10643% M a g i c k S e t I m a g e G a m m a %
10644% %
10645% %
10646% %
10647%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10648%
10649% MagickSetImageGamma() sets the image gamma.
10650%
10651% The format of the MagickSetImageGamma method is:
10652%
10653% MagickBooleanType MagickSetImageGamma(MagickWand *wand,
10654% const double gamma)
10655%
10656% A description of each parameter follows:
10657%
10658% o wand: the magick wand.
10659%
10660% o gamma: the image gamma.
10661%
10662*/
10663WandExport MagickBooleanType MagickSetImageGamma(MagickWand *wand,
10664 const double gamma)
10665{
10666 assert(wand != (MagickWand *) NULL);
10667 assert(wand->signature == MagickWandSignature);
10668 if (wand->debug != MagickFalse)
10669 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10670 if (wand->images == (Image *) NULL)
10671 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10672 wand->images->gamma=gamma;
10673 return(MagickTrue);
10674}
10675␌
10676/*
10677%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10678% %
10679% %
10680% %
10681% M a g i c k S e t I m a g e G r a v i t y %
10682% %
10683% %
10684% %
10685%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10686%
10687% MagickSetImageGravity() sets the image gravity type.
10688%
10689% The format of the MagickSetImageGravity method is:
10690%
10691% MagickBooleanType MagickSetImageGravity(MagickWand *wand,
10692% const GravityType gravity)
10693%
10694% A description of each parameter follows:
10695%
10696% o wand: the magick wand.
10697%
10698% o gravity: positioning gravity (NorthWestGravity, NorthGravity,
10699% NorthEastGravity, WestGravity, CenterGravity,
10700% EastGravity, SouthWestGravity, SouthGravity,
10701% SouthEastGravity)
10702%
10703*/
10704WandExport MagickBooleanType MagickSetImageGravity(MagickWand *wand,
10705 const GravityType gravity)
10706{
10707 assert(wand != (MagickWand *) NULL);
10708 assert(wand->signature == MagickWandSignature);
10709 if (wand->debug != MagickFalse)
10710 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10711 if (wand->images == (Image *) NULL)
10712 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10713 wand->images->gravity=gravity;
10714 return(MagickTrue);
10715}
10716␌
10717/*
10718%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10719% %
10720% %
10721% %
10722% M a g i c k S e t I m a g e G r e e n P r i m a r y %
10723% %
10724% %
10725% %
10726%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10727%
10728% MagickSetImageGreenPrimary() sets the image chromaticity green primary
10729% point.
10730%
10731% The format of the MagickSetImageGreenPrimary method is:
10732%
10733% MagickBooleanType MagickSetImageGreenPrimary(MagickWand *wand,
10734% const double x,const double y,const double z)
10735%
10736% A description of each parameter follows:
10737%
10738% o wand: the magick wand.
10739%
10740% o x: the green primary x-point.
10741%
10742% o y: the green primary y-point.
10743%
10744% o z: the green primary z-point.
10745%
10746*/
10747WandExport MagickBooleanType MagickSetImageGreenPrimary(MagickWand *wand,
10748 const double x,const double y,const double z)
10749{
10750 assert(wand != (MagickWand *) NULL);
10751 assert(wand->signature == MagickWandSignature);
10752 if (wand->debug != MagickFalse)
10753 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10754 if (wand->images == (Image *) NULL)
10755 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10756 wand->images->chromaticity.green_primary.x=x;
10757 wand->images->chromaticity.green_primary.y=y;
10758 wand->images->chromaticity.green_primary.z=z;
10759 return(MagickTrue);
10760}
10761␌
10762/*
10763%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10764% %
10765% %
10766% %
10767% M a g i c k S e t I m a g e I n t e r l a c e S c h e m e %
10768% %
10769% %
10770% %
10771%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10772%
10773% MagickSetImageInterlaceScheme() sets the image interlace scheme.
10774%
10775% The format of the MagickSetImageInterlaceScheme method is:
10776%
10777% MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *wand,
10778% const InterlaceType interlace)
10779%
10780% A description of each parameter follows:
10781%
10782% o wand: the magick wand.
10783%
10784% o interlace: the image interlace scheme: NoInterlace, LineInterlace,
10785% PlaneInterlace, PartitionInterlace.
10786%
10787*/
10788WandExport MagickBooleanType MagickSetImageInterlaceScheme(MagickWand *wand,
10789 const InterlaceType interlace)
10790{
10791 assert(wand != (MagickWand *) NULL);
10792 assert(wand->signature == MagickWandSignature);
10793 if (wand->debug != MagickFalse)
10794 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10795 if (wand->images == (Image *) NULL)
10796 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10797 wand->images->interlace=interlace;
10798 return(MagickTrue);
10799}
10800␌
10801/*
10802%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10803% %
10804% %
10805% %
10806% M a g i c k S e t I m a g e I n t e r p o l a t e M e t h o d %
10807% %
10808% %
10809% %
10810%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10811%
10812% MagickSetImageInterpolateMethod() sets the image interpolate pixel method.
10813%
10814% The format of the MagickSetImageInterpolateMethod method is:
10815%
10816% MagickBooleanType MagickSetImageInterpolateMethod(MagickWand *wand,
10817% const PixelInterpolateMethod method)
10818%
10819% A description of each parameter follows:
10820%
10821% o wand: the magick wand.
10822%
10823% o method: the image interpole pixel methods: choose from Undefined,
10824% Average, Bicubic, Bilinear, Filter, Integer, Mesh, NearestNeighbor.
10825%
10826*/
10827
10828WandExport MagickBooleanType MagickSetImagePixelInterpolateMethod(
10829 MagickWand *wand,const PixelInterpolateMethod method)
10830{
10831 return(MagickSetImageInterpolateMethod(wand,method));
10832}
10833
10834WandExport MagickBooleanType MagickSetImageInterpolateMethod(
10835 MagickWand *wand,const PixelInterpolateMethod method)
10836{
10837 assert(wand != (MagickWand *) NULL);
10838 assert(wand->signature == MagickWandSignature);
10839 if (wand->debug != MagickFalse)
10840 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10841 if (wand->images == (Image *) NULL)
10842 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10843 wand->images->interpolate=method;
10844 return(MagickTrue);
10845}
10846␌
10847/*
10848%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10849% %
10850% %
10851% %
10852% M a g i c k S e t I m a g e I t e r a t i o n s %
10853% %
10854% %
10855% %
10856%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10857%
10858% MagickSetImageIterations() sets the image iterations.
10859%
10860% The format of the MagickSetImageIterations method is:
10861%
10862% MagickBooleanType MagickSetImageIterations(MagickWand *wand,
10863% const size_t iterations)
10864%
10865% A description of each parameter follows:
10866%
10867% o wand: the magick wand.
10868%
10869% o delay: the image delay in 1/100th of a second.
10870%
10871*/
10872WandExport MagickBooleanType MagickSetImageIterations(MagickWand *wand,
10873 const size_t iterations)
10874{
10875 assert(wand != (MagickWand *) NULL);
10876 assert(wand->signature == MagickWandSignature);
10877 if (wand->debug != MagickFalse)
10878 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10879 if (wand->images == (Image *) NULL)
10880 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10881 wand->images->iterations=iterations;
10882 return(MagickTrue);
10883}
10884␌
10885/*
10886%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10887% %
10888% %
10889% %
10890% M a g i c k S e t I m a g e M a t t e %
10891% %
10892% %
10893% %
10894%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10895%
10896% MagickSetImageMatte() sets the image matte channel.
10897%
10898% The format of the MagickSetImageMatte method is:
10899%
10900% MagickBooleanType MagickSetImageMatte(MagickWand *wand,
10901% const MagickBooleanType *matte)
10902%
10903% A description of each parameter follows:
10904%
10905% o wand: the magick wand.
10906%
10907% o matte: Set to MagickTrue to enable the image matte channel otherwise
10908% MagickFalse.
10909%
10910*/
10911WandExport MagickBooleanType MagickSetImageMatte(MagickWand *wand,
10912 const MagickBooleanType matte)
10913{
10914 assert(wand != (MagickWand *) NULL);
10915 assert(wand->signature == MagickWandSignature);
10916 if (wand->debug != MagickFalse)
10917 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
10918 if (wand->images == (Image *) NULL)
10919 ThrowWandException(WandError,"ContainsNoImages",wand->name);
10920 if (matte == MagickFalse)
10921 wand->images->alpha_trait=UndefinedPixelTrait;
10922 else
10923 {
10924 if (wand->images->alpha_trait == UndefinedPixelTrait)
10925 (void) SetImageAlpha(wand->images,OpaqueAlpha,wand->exception);
10926 wand->images->alpha_trait=BlendPixelTrait;
10927 }
10928 return(MagickTrue);
10929}
10930␌
10931/*
10932%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10933% %
10934% %
10935% %
10936% M a g i c k S e t I m a g e M a t t e C o l o r %
10937% %
10938% %
10939% %
10940%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10941%
10942% MagickSetImageMatteColor() sets the image alpha color.
10943%
10944% The format of the MagickSetImageMatteColor method is:
10945%
10946% MagickBooleanType MagickSetImageMatteColor(MagickWand *wand,
10947% const PixelWand *matte)
10948%
10949% A description of each parameter follows:
10950%
10951% o wand: the magick wand.
10952%
10953% o matte: the alpha pixel wand.
10954%
10955*/
10956WandExport MagickBooleanType MagickSetImageMatteColor(MagickWand *wand,
10957 const PixelWand *alpha)
10958{
10959 assert(wand != (MagickWand *)NULL);
10960 assert(wand->signature == MagickWandSignature);
10961 if (wand->debug != MagickFalse)
10962 (void) LogMagickEvent(WandEvent, GetMagickModule(), "%s", wand->name);
10963 if (wand->images == (Image *)NULL)
10964 ThrowWandException(WandError, "ContainsNoImages", wand->name);
10965 PixelGetQuantumPacket(alpha,&wand->images->matte_color);
10966 return(MagickTrue);
10967}
10968␌
10969/*
10970%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10971% %
10972% %
10973% %
10974% M a g i c k S e t I m a g e O p a c i t y %
10975% %
10976% %
10977% %
10978%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10979%
10980% MagickSetImageAlpha() sets the image to the specified alpha level.
10981%
10982% The format of the MagickSetImageAlpha method is:
10983%
10984% MagickBooleanType MagickSetImageAlpha(MagickWand *wand,
10985% const double alpha)
10986%
10987% A description of each parameter follows:
10988%
10989% o wand: the magick wand.
10990%
10991% o alpha: the level of transparency: 1.0 is fully opaque and 0.0 is fully
10992% transparent.
10993%
10994*/
10995WandExport MagickBooleanType MagickSetImageAlpha(MagickWand *wand,
10996 const double alpha)
10997{
10998 MagickBooleanType
10999 status;
11000
11001 assert(wand != (MagickWand *) NULL);
11002 assert(wand->signature == MagickWandSignature);
11003 if (wand->debug != MagickFalse)
11004 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11005 if (wand->images == (Image *) NULL)
11006 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11007 status=SetImageAlpha(wand->images,ClampToQuantum((double) QuantumRange*alpha),
11008 wand->exception);
11009 return(status);
11010}
11011␌
11012/*
11013%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11014% %
11015% %
11016% %
11017% M a g i c k S e t I m a g e O r i e n t a t i o n %
11018% %
11019% %
11020% %
11021%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11022%
11023% MagickSetImageOrientation() sets the image orientation.
11024%
11025% The format of the MagickSetImageOrientation method is:
11026%
11027% MagickBooleanType MagickSetImageOrientation(MagickWand *wand,
11028% const OrientationType orientation)
11029%
11030% A description of each parameter follows:
11031%
11032% o wand: the magick wand.
11033%
11034% o orientation: the image orientation type.
11035%
11036*/
11037WandExport MagickBooleanType MagickSetImageOrientation(MagickWand *wand,
11038 const OrientationType orientation)
11039{
11040 assert(wand != (MagickWand *) NULL);
11041 assert(wand->signature == MagickWandSignature);
11042 if (wand->debug != MagickFalse)
11043 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11044 if (wand->images == (Image *) NULL)
11045 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11046 wand->images->orientation=orientation;
11047 return(MagickTrue);
11048}
11049␌
11050/*
11051%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11052% %
11053% %
11054% %
11055% M a g i c k S e t I m a g e P a g e %
11056% %
11057% %
11058% %
11059%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11060%
11061% MagickSetImagePage() sets the page geometry of the image.
11062%
11063% The format of the MagickSetImagePage method is:
11064%
11065% MagickBooleanType MagickSetImagePage(MagickWand *wand,const size_t width,% const size_t height,const ssize_t x,const ssize_t y)
11066%
11067% A description of each parameter follows:
11068%
11069% o wand: the magick wand.
11070%
11071% o width: the page width.
11072%
11073% o height: the page height.
11074%
11075% o x: the page x-offset.
11076%
11077% o y: the page y-offset.
11078%
11079*/
11080WandExport MagickBooleanType MagickSetImagePage(MagickWand *wand,
11081 const size_t width,const size_t height,const ssize_t x,
11082 const ssize_t y)
11083{
11084 assert(wand != (MagickWand *) NULL);
11085 assert(wand->signature == MagickWandSignature);
11086 if (wand->debug != MagickFalse)
11087 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11088 if (wand->images == (Image *) NULL)
11089 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11090 wand->images->page.width=width;
11091 wand->images->page.height=height;
11092 wand->images->page.x=x;
11093 wand->images->page.y=y;
11094 return(MagickTrue);
11095}
11096␌
11097/*
11098%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11099% %
11100% %
11101% %
11102% M a g i c k S e t I m a g e P i x e l C o l o r %
11103% %
11104% %
11105% %
11106%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11107%
11108% MagickSetImagePixelColor() sets the color of the specified pixel.
11109%
11110% The format of the MagickSetImagePixelColor method is:
11111%
11112% MagickBooleanType MagickSetImagePixelColor(MagickWand *wand,
11113% const ssize_t x,const ssize_t y,const PixelWand *color)
11114%
11115% A description of each parameter follows:
11116%
11117% o wand: the magick wand.
11118%
11119% o x,y: the pixel offset into the image.
11120%
11121% o color: Return the colormap color in this wand.
11122%
11123*/
11124WandExport MagickBooleanType MagickSetImagePixelColor(MagickWand *wand,
11125 const ssize_t x,const ssize_t y,const PixelWand *color)
11126{
11127 Quantum
11128 *q;
11129
11130 CacheView
11131 *image_view;
11132
11133 assert(wand != (MagickWand *) NULL);
11134 assert(wand->signature == MagickWandSignature);
11135 if (wand->debug != MagickFalse)
11136 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11137 if (wand->images == (Image *) NULL)
11138 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11139 image_view=AcquireAuthenticCacheView(wand->images,wand->exception);
11140 q=GetCacheViewAuthenticPixels(image_view,x,y,1,1,wand->exception);
11141 if (q == (Quantum *) NULL)
11142 {
11143 image_view=DestroyCacheView(image_view);
11144 return(MagickFalse);
11145 }
11146 PixelGetQuantumPixel(wand->images,color,q);
11147 image_view=DestroyCacheView(image_view);
11148 return(MagickTrue);
11149}
11150␌
11151/*
11152%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11153% %
11154% %
11155% %
11156% M a g i c k S e t I m a g e P r o g r e s s M o n i t o r %
11157% %
11158% %
11159% %
11160%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11161%
11162% MagickSetImageProgressMonitor() sets the wand image progress monitor to the
11163% specified method and returns the previous progress monitor if any. The
11164% progress monitor method looks like this:
11165%
11166% MagickBooleanType MagickProgressMonitor(const char *text,
11167% const MagickOffsetType offset,const MagickSizeType span,
11168% void *client_data)
11169%
11170% If the progress monitor returns MagickFalse, the current operation is
11171% interrupted.
11172%
11173% The format of the MagickSetImageProgressMonitor method is:
11174%
11175% MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *wand
11176% const MagickProgressMonitor progress_monitor,void *client_data)
11177%
11178% A description of each parameter follows:
11179%
11180% o wand: the magick wand.
11181%
11182% o progress_monitor: Specifies a pointer to a method to monitor progress
11183% of an image operation.
11184%
11185% o client_data: Specifies a pointer to any client data.
11186%
11187*/
11188WandExport MagickProgressMonitor MagickSetImageProgressMonitor(MagickWand *wand,
11189 const MagickProgressMonitor progress_monitor,void *client_data)
11190{
11191 MagickProgressMonitor
11192 previous_monitor;
11193
11194 assert(wand != (MagickWand *) NULL);
11195 assert(wand->signature == MagickWandSignature);
11196 if (wand->debug != MagickFalse)
11197 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11198 if (wand->images == (Image *) NULL)
11199 {
11200 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
11201 "ContainsNoImages","`%s'",wand->name);
11202 return((MagickProgressMonitor) NULL);
11203 }
11204 previous_monitor=SetImageProgressMonitor(wand->images,
11205 progress_monitor,client_data);
11206 return(previous_monitor);
11207}
11208␌
11209/*
11210%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11211% %
11212% %
11213% %
11214% M a g i c k S e t I m a g e R e d P r i m a r y %
11215% %
11216% %
11217% %
11218%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11219%
11220% MagickSetImageRedPrimary() sets the image chromaticity red primary point.
11221%
11222% The format of the MagickSetImageRedPrimary method is:
11223%
11224% MagickBooleanType MagickSetImageRedPrimary(MagickWand *wand,
11225% const double x,const double y,const double z)
11226%
11227% A description of each parameter follows:
11228%
11229% o wand: the magick wand.
11230%
11231% o x: the red primary x-point.
11232%
11233% o y: the red primary y-point.
11234%
11235% o z: the red primary z-point.
11236%
11237*/
11238WandExport MagickBooleanType MagickSetImageRedPrimary(MagickWand *wand,
11239 const double x,const double y,const double z)
11240{
11241 assert(wand != (MagickWand *) NULL);
11242 assert(wand->signature == MagickWandSignature);
11243 if (wand->debug != MagickFalse)
11244 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11245 if (wand->images == (Image *) NULL)
11246 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11247 wand->images->chromaticity.red_primary.x=x;
11248 wand->images->chromaticity.red_primary.y=y;
11249 wand->images->chromaticity.red_primary.z=z;
11250 return(MagickTrue);
11251}
11252␌
11253/*
11254%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11255% %
11256% %
11257% %
11258% M a g i c k S e t I m a g e R e n d e r i n g I n t e n t %
11259% %
11260% %
11261% %
11262%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11263%
11264% MagickSetImageRenderingIntent() sets the image rendering intent.
11265%
11266% The format of the MagickSetImageRenderingIntent method is:
11267%
11268% MagickBooleanType MagickSetImageRenderingIntent(MagickWand *wand,
11269% const RenderingIntent rendering_intent)
11270%
11271% A description of each parameter follows:
11272%
11273% o wand: the magick wand.
11274%
11275% o rendering_intent: the image rendering intent: UndefinedIntent,
11276% SaturationIntent, PerceptualIntent, AbsoluteIntent, or RelativeIntent.
11277%
11278*/
11279WandExport MagickBooleanType MagickSetImageRenderingIntent(MagickWand *wand,
11280 const RenderingIntent rendering_intent)
11281{
11282 assert(wand != (MagickWand *) NULL);
11283 assert(wand->signature == MagickWandSignature);
11284 if (wand->debug != MagickFalse)
11285 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11286 if (wand->images == (Image *) NULL)
11287 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11288 wand->images->rendering_intent=rendering_intent;
11289 return(MagickTrue);
11290}
11291␌
11292/*
11293%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11294% %
11295% %
11296% %
11297% M a g i c k S e t I m a g e R e s o l u t i o n %
11298% %
11299% %
11300% %
11301%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11302%
11303% MagickSetImageResolution() sets the image resolution.
11304%
11305% The format of the MagickSetImageResolution method is:
11306%
11307% MagickBooleanType MagickSetImageResolution(MagickWand *wand,
11308% const double x_resolution,const double y_resolution)
11309%
11310% A description of each parameter follows:
11311%
11312% o wand: the magick wand.
11313%
11314% o x_resolution: the image x resolution.
11315%
11316% o y_resolution: the image y resolution.
11317%
11318*/
11319WandExport MagickBooleanType MagickSetImageResolution(MagickWand *wand,
11320 const double x_resolution,const double y_resolution)
11321{
11322 assert(wand != (MagickWand *) NULL);
11323 assert(wand->signature == MagickWandSignature);
11324 if (wand->debug != MagickFalse)
11325 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11326 if (wand->images == (Image *) NULL)
11327 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11328 wand->images->resolution.x=x_resolution;
11329 wand->images->resolution.y=y_resolution;
11330 return(MagickTrue);
11331}
11332␌
11333/*
11334%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11335% %
11336% %
11337% %
11338% M a g i c k S e t I m a g e S c e n e %
11339% %
11340% %
11341% %
11342%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11343%
11344% MagickSetImageScene() sets the image scene.
11345%
11346% The format of the MagickSetImageScene method is:
11347%
11348% MagickBooleanType MagickSetImageScene(MagickWand *wand,
11349% const size_t scene)
11350%
11351% A description of each parameter follows:
11352%
11353% o wand: the magick wand.
11354%
11355% o delay: the image scene number.
11356%
11357*/
11358WandExport MagickBooleanType MagickSetImageScene(MagickWand *wand,
11359 const size_t scene)
11360{
11361 assert(wand != (MagickWand *) NULL);
11362 assert(wand->signature == MagickWandSignature);
11363 if (wand->debug != MagickFalse)
11364 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11365 if (wand->images == (Image *) NULL)
11366 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11367 wand->images->scene=scene;
11368 return(MagickTrue);
11369}
11370␌
11371/*
11372%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11373% %
11374% %
11375% %
11376% M a g i c k S e t I m a g e T i c k s P e r S e c o n d %
11377% %
11378% %
11379% %
11380%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11381%
11382% MagickSetImageTicksPerSecond() sets the image ticks-per-second.
11383%
11384% The format of the MagickSetImageTicksPerSecond method is:
11385%
11386% MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *wand,
11387% const ssize_t ticks_per-second)
11388%
11389% A description of each parameter follows:
11390%
11391% o wand: the magick wand.
11392%
11393% o ticks_per_second: the units to use for the image delay.
11394%
11395*/
11396WandExport MagickBooleanType MagickSetImageTicksPerSecond(MagickWand *wand,
11397 const ssize_t ticks_per_second)
11398{
11399 assert(wand != (MagickWand *) NULL);
11400 assert(wand->signature == MagickWandSignature);
11401 if (wand->debug != MagickFalse)
11402 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11403 if (wand->images == (Image *) NULL)
11404 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11405 wand->images->ticks_per_second=ticks_per_second;
11406 return(MagickTrue);
11407}
11408␌
11409/*
11410%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11411% %
11412% %
11413% %
11414% M a g i c k S e t I m a g e T y p e %
11415% %
11416% %
11417% %
11418%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11419%
11420% MagickSetImageType() sets the image type.
11421%
11422% The format of the MagickSetImageType method is:
11423%
11424% MagickBooleanType MagickSetImageType(MagickWand *wand,
11425% const ImageType image_type)
11426%
11427% A description of each parameter follows:
11428%
11429% o wand: the magick wand.
11430%
11431% o image_type: the image type: UndefinedType, BilevelType, GrayscaleType,
11432% GrayscaleAlphaType, PaletteType, PaletteAlphaType, TrueColorType,
11433% TrueColorAlphaType, ColorSeparationType, ColorSeparationAlphaType,
11434% or OptimizeType.
11435%
11436*/
11437WandExport MagickBooleanType MagickSetImageType(MagickWand *wand,
11438 const ImageType image_type)
11439{
11440 assert(wand != (MagickWand *) NULL);
11441 assert(wand->signature == MagickWandSignature);
11442 if (wand->debug != MagickFalse)
11443 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11444 if (wand->images == (Image *) NULL)
11445 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11446 return(SetImageType(wand->images,image_type,wand->exception));
11447}
11448␌
11449/*
11450%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11451% %
11452% %
11453% %
11454% M a g i c k S e t I m a g e U n i t s %
11455% %
11456% %
11457% %
11458%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11459%
11460% MagickSetImageUnits() sets the image units of resolution.
11461%
11462% The format of the MagickSetImageUnits method is:
11463%
11464% MagickBooleanType MagickSetImageUnits(MagickWand *wand,
11465% const ResolutionType units)
11466%
11467% A description of each parameter follows:
11468%
11469% o wand: the magick wand.
11470%
11471% o units: the image units of resolution : UndefinedResolution,
11472% PixelsPerInchResolution, or PixelsPerCentimeterResolution.
11473%
11474*/
11475WandExport MagickBooleanType MagickSetImageUnits(MagickWand *wand,
11476 const ResolutionType units)
11477{
11478 assert(wand != (MagickWand *) NULL);
11479 assert(wand->signature == MagickWandSignature);
11480 if (wand->debug != MagickFalse)
11481 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11482 if (wand->images == (Image *) NULL)
11483 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11484 wand->images->units=units;
11485 return(MagickTrue);
11486}
11487␌
11488/*
11489%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11490% %
11491% %
11492% %
11493% M a g i c k S e t I m a g e V i r t u a l P i x e l M e t h o d %
11494% %
11495% %
11496% %
11497%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11498%
11499% MagickSetImageVirtualPixelMethod() sets the image virtual pixel method.
11500%
11501% The format of the MagickSetImageVirtualPixelMethod method is:
11502%
11503% VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *wand,
11504% const VirtualPixelMethod method)
11505%
11506% A description of each parameter follows:
11507%
11508% o wand: the magick wand.
11509%
11510% o method: the image virtual pixel method : UndefinedVirtualPixelMethod,
11511% ConstantVirtualPixelMethod, EdgeVirtualPixelMethod,
11512% MirrorVirtualPixelMethod, or TileVirtualPixelMethod.
11513%
11514*/
11515WandExport VirtualPixelMethod MagickSetImageVirtualPixelMethod(MagickWand *wand,
11516 const VirtualPixelMethod method)
11517{
11518 assert(wand != (MagickWand *) NULL);
11519 assert(wand->signature == MagickWandSignature);
11520 if (wand->debug != MagickFalse)
11521 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11522 if (wand->images == (Image *) NULL)
11523 return(UndefinedVirtualPixelMethod);
11524 return(SetImageVirtualPixelMethod(wand->images,method,wand->exception));
11525}
11526␌
11527/*
11528%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11529% %
11530% %
11531% %
11532% M a g i c k S e t I m a g e W h i t e P o i n t %
11533% %
11534% %
11535% %
11536%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11537%
11538% MagickSetImageWhitePoint() sets the image chromaticity white point.
11539%
11540% The format of the MagickSetImageWhitePoint method is:
11541%
11542% MagickBooleanType MagickSetImageWhitePoint(MagickWand *wand,
11543% const double x,const double y,const double z)
11544%
11545% A description of each parameter follows:
11546%
11547% o wand: the magick wand.
11548%
11549% o x: the white x-point.
11550%
11551% o y: the white y-point.
11552%
11553% o z: the white z-point.
11554%
11555*/
11556WandExport MagickBooleanType MagickSetImageWhitePoint(MagickWand *wand,
11557 const double x,const double y,const double z)
11558{
11559 assert(wand != (MagickWand *) NULL);
11560 assert(wand->signature == MagickWandSignature);
11561 if (wand->debug != MagickFalse)
11562 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11563 if (wand->images == (Image *) NULL)
11564 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11565 wand->images->chromaticity.white_point.x=x;
11566 wand->images->chromaticity.white_point.y=y;
11567 wand->images->chromaticity.white_point.z=z;
11568 return(MagickTrue);
11569}
11570␌
11571/*
11572%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11573% %
11574% %
11575% %
11576% M a g i c k S h a d e I m a g e C h a n n e l %
11577% %
11578% %
11579% %
11580%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11581%
11582% MagickShadeImage() shines a distant light on an image to create a
11583% three-dimensional effect. You control the positioning of the light with
11584% azimuth and elevation; azimuth is measured in degrees off the x axis
11585% and elevation is measured in pixels above the Z axis.
11586%
11587% The format of the MagickShadeImage method is:
11588%
11589% MagickBooleanType MagickShadeImage(MagickWand *wand,
11590% const MagickBooleanType gray,const double azimuth,
11591% const double elevation)
11592%
11593% A description of each parameter follows:
11594%
11595% o wand: the magick wand.
11596%
11597% o gray: A value other than zero shades the intensity of each pixel.
11598%
11599% o azimuth, elevation: Define the light source direction.
11600%
11601*/
11602WandExport MagickBooleanType MagickShadeImage(MagickWand *wand,
11603 const MagickBooleanType gray,const double azimuth,const double elevation)
11604{
11605 Image
11606 *shade_image;
11607
11608 assert(wand != (MagickWand *) NULL);
11609 assert(wand->signature == MagickWandSignature);
11610 if (wand->debug != MagickFalse)
11611 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11612 if (wand->images == (Image *) NULL)
11613 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11614 shade_image=ShadeImage(wand->images,gray,azimuth,elevation,wand->exception);
11615 if (shade_image == (Image *) NULL)
11616 return(MagickFalse);
11617 ReplaceImageInList(&wand->images,shade_image);
11618 return(MagickTrue);
11619}
11620␌
11621/*
11622%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11623% %
11624% %
11625% %
11626% M a g i c k S h a d o w I m a g e %
11627% %
11628% %
11629% %
11630%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11631%
11632% MagickShadowImage() simulates an image shadow.
11633%
11634% The format of the MagickShadowImage method is:
11635%
11636% MagickBooleanType MagickShadowImage(MagickWand *wand,const double alpha,
11637% const double sigma,const ssize_t x,const ssize_t y)
11638%
11639% A description of each parameter follows:
11640%
11641% o wand: the magick wand.
11642%
11643% o alpha: percentage transparency.
11644%
11645% o sigma: the standard deviation of the Gaussian, in pixels.
11646%
11647% o x: the shadow x-offset.
11648%
11649% o y: the shadow y-offset.
11650%
11651*/
11652WandExport MagickBooleanType MagickShadowImage(MagickWand *wand,
11653 const double alpha,const double sigma,const ssize_t x,const ssize_t y)
11654{
11655 Image
11656 *shadow_image;
11657
11658 assert(wand != (MagickWand *) NULL);
11659 assert(wand->signature == MagickWandSignature);
11660 if (wand->debug != MagickFalse)
11661 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11662 if (wand->images == (Image *) NULL)
11663 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11664 shadow_image=ShadowImage(wand->images,alpha,sigma,x,y,wand->exception);
11665 if (shadow_image == (Image *) NULL)
11666 return(MagickFalse);
11667 ReplaceImageInList(&wand->images,shadow_image);
11668 return(MagickTrue);
11669}
11670␌
11671/*
11672%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11673% %
11674% %
11675% %
11676% M a g i c k S h a r p e n I m a g e %
11677% %
11678% %
11679% %
11680%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11681%
11682% MagickSharpenImage() sharpens an image. We convolve the image with a
11683% Gaussian operator of the given radius and standard deviation (sigma).
11684% For reasonable results, the radius should be larger than sigma. Use a
11685% radius of 0 and MagickSharpenImage() selects a suitable radius for you.
11686%
11687% The format of the MagickSharpenImage method is:
11688%
11689% MagickBooleanType MagickSharpenImage(MagickWand *wand,
11690% const double radius,const double sigma)
11691%
11692% A description of each parameter follows:
11693%
11694% o wand: the magick wand.
11695%
11696% o radius: the radius of the Gaussian, in pixels, not counting the center
11697% pixel.
11698%
11699% o sigma: the standard deviation of the Gaussian, in pixels.
11700%
11701*/
11702WandExport MagickBooleanType MagickSharpenImage(MagickWand *wand,
11703 const double radius,const double sigma)
11704{
11705 Image
11706 *sharp_image;
11707
11708 assert(wand != (MagickWand *) NULL);
11709 assert(wand->signature == MagickWandSignature);
11710 if (wand->debug != MagickFalse)
11711 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11712 if (wand->images == (Image *) NULL)
11713 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11714 sharp_image=SharpenImage(wand->images,radius,sigma,wand->exception);
11715 if (sharp_image == (Image *) NULL)
11716 return(MagickFalse);
11717 ReplaceImageInList(&wand->images,sharp_image);
11718 return(MagickTrue);
11719}
11720␌
11721/*
11722%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11723% %
11724% %
11725% %
11726% M a g i c k S h a v e I m a g e %
11727% %
11728% %
11729% %
11730%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11731%
11732% MagickShaveImage() shaves pixels from the image edges. It allocates the
11733% memory necessary for the new Image structure and returns a pointer to the
11734% new image.
11735%
11736% The format of the MagickShaveImage method is:
11737%
11738% MagickBooleanType MagickShaveImage(MagickWand *wand,
11739% const size_t columns,const size_t rows)
11740%
11741% A description of each parameter follows:
11742%
11743% o wand: the magick wand.
11744%
11745% o columns: the number of columns in the scaled image.
11746%
11747% o rows: the number of rows in the scaled image.
11748%
11749%
11750*/
11751WandExport MagickBooleanType MagickShaveImage(MagickWand *wand,
11752 const size_t columns,const size_t rows)
11753{
11754 Image
11755 *shave_image;
11756
11757 RectangleInfo
11758 shave_info;
11759
11760 assert(wand != (MagickWand *) NULL);
11761 assert(wand->signature == MagickWandSignature);
11762 if (wand->debug != MagickFalse)
11763 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11764 if (wand->images == (Image *) NULL)
11765 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11766 shave_info.width=columns;
11767 shave_info.height=rows;
11768 shave_info.x=0;
11769 shave_info.y=0;
11770 shave_image=ShaveImage(wand->images,&shave_info,wand->exception);
11771 if (shave_image == (Image *) NULL)
11772 return(MagickFalse);
11773 ReplaceImageInList(&wand->images,shave_image);
11774 return(MagickTrue);
11775}
11776␌
11777/*
11778%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11779% %
11780% %
11781% %
11782% M a g i c k S h e a r I m a g e %
11783% %
11784% %
11785% %
11786%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11787%
11788% MagickShearImage() slides one edge of an image along the X or Y axis,
11789% creating a parallelogram. An X direction shear slides an edge along the X
11790% axis, while a Y direction shear slides an edge along the Y axis. The amount
11791% of the shear is controlled by a shear angle. For X direction shears, x_shear
11792% is measured relative to the Y axis, and similarly, for Y direction shears
11793% y_shear is measured relative to the X axis. Empty triangles left over from
11794% shearing the image are filled with the background color.
11795%
11796% The format of the MagickShearImage method is:
11797%
11798% MagickBooleanType MagickShearImage(MagickWand *wand,
11799% const PixelWand *background,const double x_shear,const double y_shear)
11800%
11801% A description of each parameter follows:
11802%
11803% o wand: the magick wand.
11804%
11805% o background: the background pixel wand.
11806%
11807% o x_shear: the number of degrees to shear the image.
11808%
11809% o y_shear: the number of degrees to shear the image.
11810%
11811*/
11812WandExport MagickBooleanType MagickShearImage(MagickWand *wand,
11813 const PixelWand *background,const double x_shear,const double y_shear)
11814{
11815 Image
11816 *shear_image;
11817
11818 assert(wand != (MagickWand *) NULL);
11819 assert(wand->signature == MagickWandSignature);
11820 if (wand->debug != MagickFalse)
11821 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11822 if (wand->images == (Image *) NULL)
11823 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11824 PixelGetQuantumPacket(background,&wand->images->background_color);
11825 shear_image=ShearImage(wand->images,x_shear,y_shear,wand->exception);
11826 if (shear_image == (Image *) NULL)
11827 return(MagickFalse);
11828 ReplaceImageInList(&wand->images,shear_image);
11829 return(MagickTrue);
11830}
11831␌
11832/*
11833%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11834% %
11835% %
11836% %
11837% M a g i c k S i g m o i d a l C o n t r a s t I m a g e %
11838% %
11839% %
11840% %
11841%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11842%
11843% MagickSigmoidalContrastImage() adjusts the contrast of an image with a
11844% non-linear sigmoidal contrast algorithm. Increase the contrast of the
11845% image using a sigmoidal transfer function without saturating highlights or
11846% shadows. Contrast indicates how much to increase the contrast (0 is none;
11847% 3 is typical; 20 is pushing it); mid-point indicates where midtones fall in
11848% the resultant image (0 is white; 50% is middle-gray; 100% is black). Set
11849% sharpen to MagickTrue to increase the image contrast otherwise the contrast
11850% is reduced.
11851%
11852% The format of the MagickSigmoidalContrastImage method is:
11853%
11854% MagickBooleanType MagickSigmoidalContrastImage(MagickWand *wand,
11855% const MagickBooleanType sharpen,const double alpha,const double beta)
11856%
11857% A description of each parameter follows:
11858%
11859% o wand: the magick wand.
11860%
11861% o sharpen: Increase or decrease image contrast.
11862%
11863% o alpha: strength of the contrast, the larger the number the more
11864% 'threshold-like' it becomes.
11865%
11866% o beta: midpoint of the function as a color value 0 to QuantumRange.
11867%
11868*/
11869WandExport MagickBooleanType MagickSigmoidalContrastImage(
11870 MagickWand *wand,const MagickBooleanType sharpen,const double alpha,
11871 const double beta)
11872{
11873 MagickBooleanType
11874 status;
11875
11876 assert(wand != (MagickWand *) NULL);
11877 assert(wand->signature == MagickWandSignature);
11878 if (wand->debug != MagickFalse)
11879 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11880 if (wand->images == (Image *) NULL)
11881 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11882 status=SigmoidalContrastImage(wand->images,sharpen,alpha,beta,
11883 wand->exception);
11884 return(status);
11885}
11886␌
11887/*
11888%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11889% %
11890% %
11891% %
11892% M a g i c k S i m i l a r i t y I m a g e %
11893% %
11894% %
11895% %
11896%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11897%
11898% MagickSimilarityImage() compares the reference image of the image and
11899% returns the best match offset. In addition, it returns a similarity image
11900% such that an exact match location is completely white and if none of the
11901% pixels match, black, otherwise some gray level in-between.
11902%
11903% The format of the MagickSimilarityImage method is:
11904%
11905% MagickWand *MagickSimilarityImage(MagickWand *wand,
11906% const MagickWand *reference,const MetricType metric,
11907% const double similarity_threshold,RectangleInfo *offset,
11908% double *similarity)
11909%
11910% A description of each parameter follows:
11911%
11912% o wand: the magick wand.
11913%
11914% o reference: the reference wand.
11915%
11916% o metric: the metric.
11917%
11918% o similarity_threshold: minimum distortion for (sub)image match.
11919%
11920% o offset: the best match offset of the reference image within the image.
11921%
11922% o similarity: the computed similarity between the images.
11923%
11924*/
11925WandExport MagickWand *MagickSimilarityImage(MagickWand *wand,
11926 const MagickWand *reference,const MetricType metric,
11927 const double similarity_threshold,RectangleInfo *offset,double *similarity)
11928{
11929 Image
11930 *similarity_image;
11931
11932 assert(wand != (MagickWand *) NULL);
11933 assert(wand->signature == MagickWandSignature);
11934 if (wand->debug != MagickFalse)
11935 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11936 if ((wand->images == (Image *) NULL) || (reference->images == (Image *) NULL))
11937 {
11938 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
11939 "ContainsNoImages","`%s'",wand->name);
11940 return((MagickWand *) NULL);
11941 }
11942 similarity_image=SimilarityImage(wand->images,reference->images,metric,
11943 similarity_threshold,offset,similarity,wand->exception);
11944 if (similarity_image == (Image *) NULL)
11945 return((MagickWand *) NULL);
11946 return(CloneMagickWandFromImages(wand,similarity_image));
11947}
11948␌
11949/*
11950%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11951% %
11952% %
11953% %
11954% M a g i c k S k e t c h I m a g e %
11955% %
11956% %
11957% %
11958%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11959%
11960% MagickSketchImage() simulates a pencil sketch. We convolve the image with
11961% a Gaussian operator of the given radius and standard deviation (sigma).
11962% For reasonable results, radius should be larger than sigma. Use a
11963% radius of 0 and SketchImage() selects a suitable radius for you.
11964% Angle gives the angle of the blurring motion.
11965%
11966% The format of the MagickSketchImage method is:
11967%
11968% MagickBooleanType MagickSketchImage(MagickWand *wand,
11969% const double radius,const double sigma,const double angle)
11970%
11971% A description of each parameter follows:
11972%
11973% o wand: the magick wand.
11974%
11975% o radius: the radius of the Gaussian, in pixels, not counting
11976% the center pixel.
11977%
11978% o sigma: the standard deviation of the Gaussian, in pixels.
11979%
11980% o angle: apply the effect along this angle.
11981%
11982*/
11983WandExport MagickBooleanType MagickSketchImage(MagickWand *wand,
11984 const double radius,const double sigma,const double angle)
11985{
11986 Image
11987 *sketch_image;
11988
11989 assert(wand != (MagickWand *) NULL);
11990 assert(wand->signature == MagickWandSignature);
11991 if (wand->debug != MagickFalse)
11992 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
11993 if (wand->images == (Image *) NULL)
11994 ThrowWandException(WandError,"ContainsNoImages",wand->name);
11995 sketch_image=SketchImage(wand->images,radius,sigma,angle,wand->exception);
11996 if (sketch_image == (Image *) NULL)
11997 return(MagickFalse);
11998 ReplaceImageInList(&wand->images,sketch_image);
11999 return(MagickTrue);
12000}
12001␌
12002/*
12003%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12004% %
12005% %
12006% %
12007% M a g i c k S m u s h I m a g e s %
12008% %
12009% %
12010% %
12011%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12012%
12013% MagickSmushImages() takes all images from the current image pointer to the
12014% end of the image list and smushes them to each other top-to-bottom if the
12015% stack parameter is true, otherwise left-to-right.
12016%
12017% The format of the MagickSmushImages method is:
12018%
12019% MagickWand *MagickSmushImages(MagickWand *wand,
12020% const MagickBooleanType stack,const ssize_t offset)
12021%
12022% A description of each parameter follows:
12023%
12024% o wand: the magick wand.
12025%
12026% o stack: By default, images are stacked left-to-right. Set stack to
12027% MagickTrue to stack them top-to-bottom.
12028%
12029% o offset: minimum distance in pixels between images.
12030%
12031*/
12032WandExport MagickWand *MagickSmushImages(MagickWand *wand,
12033 const MagickBooleanType stack,const ssize_t offset)
12034{
12035 Image
12036 *smush_image;
12037
12038 assert(wand != (MagickWand *) NULL);
12039 assert(wand->signature == MagickWandSignature);
12040 if (wand->debug != MagickFalse)
12041 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12042 if (wand->images == (Image *) NULL)
12043 return((MagickWand *) NULL);
12044 smush_image=SmushImages(wand->images,stack,offset,wand->exception);
12045 if (smush_image == (Image *) NULL)
12046 return((MagickWand *) NULL);
12047 return(CloneMagickWandFromImages(wand,smush_image));
12048}
12049␌
12050/*
12051%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12052% %
12053% %
12054% %
12055% M a g i c k S o l a r i z e I m a g e %
12056% %
12057% %
12058% %
12059%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12060%
12061% MagickSolarizeImage() applies a special effect to the image, similar to the
12062% effect achieved in a photo darkroom by selectively exposing areas of photo
12063% sensitive paper to light. Threshold ranges from 0 to QuantumRange and is a
12064% measure of the extent of the solarization.
12065%
12066% The format of the MagickSolarizeImage method is:
12067%
12068% MagickBooleanType MagickSolarizeImage(MagickWand *wand,
12069% const double threshold)
12070%
12071% A description of each parameter follows:
12072%
12073% o wand: the magick wand.
12074%
12075% o threshold: Define the extent of the solarization.
12076%
12077*/
12078WandExport MagickBooleanType MagickSolarizeImage(MagickWand *wand,
12079 const double threshold)
12080{
12081 MagickBooleanType
12082 status;
12083
12084 assert(wand != (MagickWand *) NULL);
12085 assert(wand->signature == MagickWandSignature);
12086 if (wand->debug != MagickFalse)
12087 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12088 if (wand->images == (Image *) NULL)
12089 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12090 status=SolarizeImage(wand->images,threshold,wand->exception);
12091 return(status);
12092}
12093␌
12094/*
12095%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12096% %
12097% %
12098% %
12099% M a g i c k S p a r s e C o l o r I m a g e %
12100% %
12101% %
12102% %
12103%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12104%
12105% MagickSparseColorImage(), given a set of coordinates, interpolates the
12106% colors found at those coordinates, across the whole image, using various
12107% methods.
12108%
12109% The format of the MagickSparseColorImage method is:
12110%
12111% MagickBooleanType MagickSparseColorImage(MagickWand *wand,
12112% const SparseColorMethod method,const size_t number_arguments,
12113% const double *arguments)
12114%
12115% A description of each parameter follows:
12116%
12117% o image: the image to be sparseed.
12118%
12119% o method: the method of image sparseion.
12120%
12121% ArcSparseColorion will always ignore source image offset, and always
12122% 'bestfit' the destination image with the top left corner offset
12123% relative to the polar mapping center.
12124%
12125% Bilinear has no simple inverse mapping so will not allow 'bestfit'
12126% style of image sparseion.
12127%
12128% Affine, Perspective, and Bilinear, will do least squares fitting of
12129% the distortion when more than the minimum number of control point
12130% pairs are provided.
12131%
12132% Perspective, and Bilinear, will fall back to a Affine sparseion when
12133% less than 4 control point pairs are provided. While Affine sparseions
12134% will let you use any number of control point pairs, that is Zero pairs
12135% is a No-Op (viewport only) distortion, one pair is a translation and
12136% two pairs of control points will do a scale-rotate-translate, without
12137% any shearing.
12138%
12139% o number_arguments: the number of arguments given for this sparseion
12140% method.
12141%
12142% o arguments: the arguments for this sparseion method.
12143%
12144*/
12145WandExport MagickBooleanType MagickSparseColorImage(MagickWand *wand,
12146 const SparseColorMethod method,const size_t number_arguments,
12147 const double *arguments)
12148{
12149 Image
12150 *sparse_image;
12151
12152 assert(wand != (MagickWand *) NULL);
12153 assert(wand->signature == MagickWandSignature);
12154 if (wand->debug != MagickFalse)
12155 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12156 if (wand->images == (Image *) NULL)
12157 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12158 sparse_image=SparseColorImage(wand->images,method,number_arguments,arguments,
12159 wand->exception);
12160 if (sparse_image == (Image *) NULL)
12161 return(MagickFalse);
12162 ReplaceImageInList(&wand->images,sparse_image);
12163 return(MagickTrue);
12164}
12165␌
12166/*
12167%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12168% %
12169% %
12170% %
12171% M a g i c k S p l i c e I m a g e %
12172% %
12173% %
12174% %
12175%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12176%
12177% MagickSpliceImage() splices a solid color into the image.
12178%
12179% The format of the MagickSpliceImage method is:
12180%
12181% MagickBooleanType MagickSpliceImage(MagickWand *wand,
12182% const size_t width,const size_t height,const ssize_t x,
12183% const ssize_t y)
12184%
12185% A description of each parameter follows:
12186%
12187% o wand: the magick wand.
12188%
12189% o width: the region width.
12190%
12191% o height: the region height.
12192%
12193% o x: the region x offset.
12194%
12195% o y: the region y offset.
12196%
12197*/
12198WandExport MagickBooleanType MagickSpliceImage(MagickWand *wand,
12199 const size_t width,const size_t height,const ssize_t x,
12200 const ssize_t y)
12201{
12202 Image
12203 *splice_image;
12204
12205 RectangleInfo
12206 splice;
12207
12208 assert(wand != (MagickWand *) NULL);
12209 assert(wand->signature == MagickWandSignature);
12210 if (wand->debug != MagickFalse)
12211 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12212 if (wand->images == (Image *) NULL)
12213 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12214 splice.width=width;
12215 splice.height=height;
12216 splice.x=x;
12217 splice.y=y;
12218 splice_image=SpliceImage(wand->images,&splice,wand->exception);
12219 if (splice_image == (Image *) NULL)
12220 return(MagickFalse);
12221 ReplaceImageInList(&wand->images,splice_image);
12222 return(MagickTrue);
12223}
12224␌
12225/*
12226%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12227% %
12228% %
12229% %
12230% M a g i c k S p r e a d I m a g e %
12231% %
12232% %
12233% %
12234%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12235%
12236% MagickSpreadImage() is a special effects method that randomly displaces each
12237% pixel in a block defined by the radius parameter.
12238%
12239% The format of the MagickSpreadImage method is:
12240%
12241% MagickBooleanType MagickSpreadImage(MagickWand *wand,
12242% const PixelInterpolateMethod method,const double radius)
12243%
12244% A description of each parameter follows:
12245%
12246% o wand: the magick wand.
12247%
12248% o method: interpolation method.
12249%
12250% o radius: Choose a random pixel in a neighborhood of this extent.
12251%
12252*/
12253WandExport MagickBooleanType MagickSpreadImage(MagickWand *wand,
12254 const PixelInterpolateMethod method,const double radius)
12255{
12256 Image
12257 *spread_image;
12258
12259 assert(wand != (MagickWand *) NULL);
12260 assert(wand->signature == MagickWandSignature);
12261 if (wand->debug != MagickFalse)
12262 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12263 if (wand->images == (Image *) NULL)
12264 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12265 spread_image=SpreadImage(wand->images,method,radius,wand->exception);
12266 if (spread_image == (Image *) NULL)
12267 return(MagickFalse);
12268 ReplaceImageInList(&wand->images,spread_image);
12269 return(MagickTrue);
12270}
12271␌
12272/*
12273%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12274% %
12275% %
12276% %
12277% M a g i c k S t a t i s t i c I m a g e %
12278% %
12279% %
12280% %
12281%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12282%
12283% MagickStatisticImage() replace each pixel with corresponding statistic from
12284% the neighborhood of the specified width and height.
12285%
12286% The format of the MagickStatisticImage method is:
12287%
12288% MagickBooleanType MagickStatisticImage(MagickWand *wand,
12289% const StatisticType type,const double width,const size_t height)
12290%
12291% A description of each parameter follows:
12292%
12293% o wand: the magick wand.
12294%
12295% o type: the statistic type (e.g. median, mode, etc.).
12296%
12297% o width: the width of the pixel neighborhood.
12298%
12299% o height: the height of the pixel neighborhood.
12300%
12301*/
12302WandExport MagickBooleanType MagickStatisticImage(MagickWand *wand,
12303 const StatisticType type,const size_t width,const size_t height)
12304{
12305 Image
12306 *statistic_image;
12307
12308 assert(wand != (MagickWand *) NULL);
12309 assert(wand->signature == MagickWandSignature);
12310 if (wand->debug != MagickFalse)
12311 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12312 if (wand->images == (Image *) NULL)
12313 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12314 statistic_image=StatisticImage(wand->images,type,width,height,
12315 wand->exception);
12316 if (statistic_image == (Image *) NULL)
12317 return(MagickFalse);
12318 ReplaceImageInList(&wand->images,statistic_image);
12319 return(MagickTrue);
12320}
12321␌
12322/*
12323%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12324% %
12325% %
12326% %
12327% M a g i c k S t e g a n o I m a g e %
12328% %
12329% %
12330% %
12331%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12332%
12333% MagickSteganoImage() hides a digital watermark within the image.
12334% Recover the hidden watermark later to prove that the authenticity of
12335% an image. Offset defines the start position within the image to hide
12336% the watermark.
12337%
12338% The format of the MagickSteganoImage method is:
12339%
12340% MagickWand *MagickSteganoImage(MagickWand *wand,
12341% const MagickWand *watermark_wand,const ssize_t offset)
12342%
12343% A description of each parameter follows:
12344%
12345% o wand: the magick wand.
12346%
12347% o watermark_wand: the watermark wand.
12348%
12349% o offset: Start hiding at this offset into the image.
12350%
12351*/
12352WandExport MagickWand *MagickSteganoImage(MagickWand *wand,
12353 const MagickWand *watermark_wand,const ssize_t offset)
12354{
12355 Image
12356 *stegano_image;
12357
12358 assert(wand != (MagickWand *) NULL);
12359 assert(wand->signature == MagickWandSignature);
12360 if (wand->debug != MagickFalse)
12361 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12362 if ((wand->images == (Image *) NULL) ||
12363 (watermark_wand->images == (Image *) NULL))
12364 {
12365 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
12366 "ContainsNoImages","`%s'",wand->name);
12367 return((MagickWand *) NULL);
12368 }
12369 wand->images->offset=offset;
12370 stegano_image=SteganoImage(wand->images,watermark_wand->images,
12371 wand->exception);
12372 if (stegano_image == (Image *) NULL)
12373 return((MagickWand *) NULL);
12374 return(CloneMagickWandFromImages(wand,stegano_image));
12375}
12376␌
12377/*
12378%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12379% %
12380% %
12381% %
12382% M a g i c k S t e r e o I m a g e %
12383% %
12384% %
12385% %
12386%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12387%
12388% MagickStereoImage() composites two images and produces a single image that
12389% is the composite of a left and right image of a stereo pair
12390%
12391% The format of the MagickStereoImage method is:
12392%
12393% MagickWand *MagickStereoImage(MagickWand *wand,
12394% const MagickWand *offset_wand)
12395%
12396% A description of each parameter follows:
12397%
12398% o wand: the magick wand.
12399%
12400% o offset_wand: Another image wand.
12401%
12402*/
12403WandExport MagickWand *MagickStereoImage(MagickWand *wand,
12404 const MagickWand *offset_wand)
12405{
12406 Image
12407 *stereo_image;
12408
12409 assert(wand != (MagickWand *) NULL);
12410 assert(wand->signature == MagickWandSignature);
12411 if (wand->debug != MagickFalse)
12412 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12413 if ((wand->images == (Image *) NULL) ||
12414 (offset_wand->images == (Image *) NULL))
12415 {
12416 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
12417 "ContainsNoImages","`%s'",wand->name);
12418 return((MagickWand *) NULL);
12419 }
12420 stereo_image=StereoImage(wand->images,offset_wand->images,wand->exception);
12421 if (stereo_image == (Image *) NULL)
12422 return((MagickWand *) NULL);
12423 return(CloneMagickWandFromImages(wand,stereo_image));
12424}
12425␌
12426/*
12427%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12428% %
12429% %
12430% %
12431% M a g i c k S t r i p I m a g e %
12432% %
12433% %
12434% %
12435%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12436%
12437% MagickStripImage() strips an image of all profiles and comments.
12438%
12439% The format of the MagickStripImage method is:
12440%
12441% MagickBooleanType MagickStripImage(MagickWand *wand)
12442%
12443% A description of each parameter follows:
12444%
12445% o wand: the magick wand.
12446%
12447*/
12448WandExport MagickBooleanType MagickStripImage(MagickWand *wand)
12449{
12450 assert(wand != (MagickWand *) NULL);
12451 assert(wand->signature == MagickWandSignature);
12452 if (wand->debug != MagickFalse)
12453 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12454 if (wand->images == (Image *) NULL)
12455 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12456 return(StripImage(wand->images,wand->exception));
12457}
12458␌
12459/*
12460%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12461% %
12462% %
12463% %
12464% M a g i c k S w i r l I m a g e %
12465% %
12466% %
12467% %
12468%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12469%
12470% MagickSwirlImage() swirls the pixels about the center of the image, where
12471% degrees indicates the sweep of the arc through which each pixel is moved.
12472% You get a more dramatic effect as the degrees move from 1 to 360.
12473%
12474% The format of the MagickSwirlImage method is:
12475%
12476% MagickBooleanType MagickSwirlImage(MagickWand *wand,const double degrees,
12477% const PixelInterpolateMethod method)
12478%
12479% A description of each parameter follows:
12480%
12481% o wand: the magick wand.
12482%
12483% o degrees: Define the tightness of the swirling effect.
12484%
12485% o method: the pixel interpolation method.
12486%
12487*/
12488WandExport MagickBooleanType MagickSwirlImage(MagickWand *wand,
12489 const double degrees,const PixelInterpolateMethod method)
12490{
12491 Image
12492 *swirl_image;
12493
12494 assert(wand != (MagickWand *) NULL);
12495 assert(wand->signature == MagickWandSignature);
12496 if (wand->debug != MagickFalse)
12497 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12498 if (wand->images == (Image *) NULL)
12499 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12500 swirl_image=SwirlImage(wand->images,degrees,method,wand->exception);
12501 if (swirl_image == (Image *) NULL)
12502 return(MagickFalse);
12503 ReplaceImageInList(&wand->images,swirl_image);
12504 return(MagickTrue);
12505}
12506␌
12507/*
12508%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12509% %
12510% %
12511% %
12512% M a g i c k T e x t u r e I m a g e %
12513% %
12514% %
12515% %
12516%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12517%
12518% MagickTextureImage() repeatedly tiles the texture image across and down the
12519% image canvas.
12520%
12521% The format of the MagickTextureImage method is:
12522%
12523% MagickWand *MagickTextureImage(MagickWand *wand,
12524% const MagickWand *texture_wand)
12525%
12526% A description of each parameter follows:
12527%
12528% o wand: the magick wand.
12529%
12530% o texture_wand: the texture wand
12531%
12532*/
12533WandExport MagickWand *MagickTextureImage(MagickWand *wand,
12534 const MagickWand *texture_wand)
12535{
12536 Image
12537 *texture_image;
12538
12539 MagickBooleanType
12540 status;
12541
12542 assert(wand != (MagickWand *) NULL);
12543 assert(wand->signature == MagickWandSignature);
12544 if (wand->debug != MagickFalse)
12545 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12546 if ((wand->images == (Image *) NULL) ||
12547 (texture_wand->images == (Image *) NULL))
12548 {
12549 (void) ThrowMagickException(wand->exception,GetMagickModule(),WandError,
12550 "ContainsNoImages","`%s'",wand->name);
12551 return((MagickWand *) NULL);
12552 }
12553 texture_image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
12554 if (texture_image == (Image *) NULL)
12555 return((MagickWand *) NULL);
12556 status=TextureImage(texture_image,texture_wand->images,wand->exception);
12557 if (status == MagickFalse)
12558 {
12559 texture_image=DestroyImage(texture_image);
12560 return((MagickWand *) NULL);
12561 }
12562 return(CloneMagickWandFromImages(wand,texture_image));
12563}
12564␌
12565/*
12566%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12567% %
12568% %
12569% %
12570% M a g i c k T h r e s h o l d I m a g e %
12571% %
12572% %
12573% %
12574%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12575%
12576% MagickThresholdImage() changes the value of individual pixels based on
12577% the intensity of each pixel compared to threshold. The result is a
12578% high-contrast, two color image.
12579%
12580% The format of the MagickThresholdImage method is:
12581%
12582% MagickBooleanType MagickThresholdImage(MagickWand *wand,
12583% const double threshold)
12584% MagickBooleanType MagickThresholdImageChannel(MagickWand *wand,
12585% const ChannelType channel,const double threshold)
12586%
12587% A description of each parameter follows:
12588%
12589% o wand: the magick wand.
12590%
12591% o channel: the image channel(s).
12592%
12593% o threshold: Define the threshold value.
12594%
12595*/
12596WandExport MagickBooleanType MagickThresholdImage(MagickWand *wand,
12597 const double threshold)
12598{
12599 MagickBooleanType
12600 status;
12601
12602 status=MagickThresholdImageChannel(wand,DefaultChannels,threshold);
12603 return(status);
12604}
12605
12606WandExport MagickBooleanType MagickThresholdImageChannel(MagickWand *wand,
12607 const ChannelType channel,const double threshold)
12608{
12609 MagickBooleanType
12610 status;
12611
12612 ChannelType
12613 channel_mask;
12614
12615 assert(wand != (MagickWand *) NULL);
12616 assert(wand->signature == MagickWandSignature);
12617 if (wand->debug != MagickFalse)
12618 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12619 if (wand->images == (Image *) NULL)
12620 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12621 channel_mask=SetImageChannelMask(wand->images,channel);
12622 status=BilevelImage(wand->images,threshold,wand->exception);
12623 (void) SetImageChannelMask(wand->images,channel_mask);
12624 return(status);
12625}
12626␌
12627/*
12628%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12629% %
12630% %
12631% %
12632% M a g i c k T h u m b n a i l I m a g e %
12633% %
12634% %
12635% %
12636%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12637%
12638% MagickThumbnailImage() changes the size of an image to the given dimensions
12639% and removes any associated profiles. The goal is to produce small low cost
12640% thumbnail images suited for display on the Web.
12641%
12642% The format of the MagickThumbnailImage method is:
12643%
12644% MagickBooleanType MagickThumbnailImage(MagickWand *wand,
12645% const size_t columns,const size_t rows)
12646%
12647% A description of each parameter follows:
12648%
12649% o wand: the magick wand.
12650%
12651% o columns: the number of columns in the scaled image.
12652%
12653% o rows: the number of rows in the scaled image.
12654%
12655*/
12656WandExport MagickBooleanType MagickThumbnailImage(MagickWand *wand,
12657 const size_t columns,const size_t rows)
12658{
12659 Image
12660 *thumbnail_image;
12661
12662 assert(wand != (MagickWand *) NULL);
12663 assert(wand->signature == MagickWandSignature);
12664 if (wand->debug != MagickFalse)
12665 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12666 if (wand->images == (Image *) NULL)
12667 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12668 thumbnail_image=ThumbnailImage(wand->images,columns,rows,wand->exception);
12669 if (thumbnail_image == (Image *) NULL)
12670 return(MagickFalse);
12671 ReplaceImageInList(&wand->images,thumbnail_image);
12672 return(MagickTrue);
12673}
12674␌
12675/*
12676%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12677% %
12678% %
12679% %
12680% M a g i c k T i n t I m a g e %
12681% %
12682% %
12683% %
12684%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12685%
12686% MagickTintImage() applies a color vector to each pixel in the image. The
12687% length of the vector is 0 for black and white and at its maximum for the
12688% midtones. The vector weighting function is
12689% f(x)=(1-(4.0*((x-0.5)*(x-0.5)))).
12690%
12691% The format of the MagickTintImage method is:
12692%
12693% MagickBooleanType MagickTintImage(MagickWand *wand,
12694% const PixelWand *tint,const PixelWand *blend)
12695%
12696% A description of each parameter follows:
12697%
12698% o wand: the magick wand.
12699%
12700% o tint: the tint pixel wand.
12701%
12702% o alpha: the alpha pixel wand.
12703%
12704*/
12705WandExport MagickBooleanType MagickTintImage(MagickWand *wand,
12706 const PixelWand *tint,const PixelWand *blend)
12707{
12708 char
12709 percent_blend[MagickPathExtent];
12710
12711 Image
12712 *tint_image;
12713
12714 PixelInfo
12715 target;
12716
12717 assert(wand != (MagickWand *) NULL);
12718 assert(wand->signature == MagickWandSignature);
12719 if (wand->debug != MagickFalse)
12720 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12721 if (wand->images == (Image *) NULL)
12722 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12723 if (wand->images->colorspace != CMYKColorspace)
12724 (void) FormatLocaleString(percent_blend,MagickPathExtent,
12725 "%g,%g,%g,%g",(double) (100.0*QuantumScale*
12726 (double) PixelGetRedQuantum(blend)),(double) (100.0*QuantumScale*
12727 (double) PixelGetGreenQuantum(blend)),(double) (100.0*QuantumScale*
12728 (double) PixelGetBlueQuantum(blend)),(double) (100.0*QuantumScale*
12729 (double) PixelGetAlphaQuantum(blend)));
12730 else
12731 (void) FormatLocaleString(percent_blend,MagickPathExtent,
12732 "%g,%g,%g,%g,%g",(double) (100.0*QuantumScale*
12733 (double) PixelGetCyanQuantum(blend)),(double) (100.0*QuantumScale*
12734 (double) PixelGetMagentaQuantum(blend)),(double) (100.0*QuantumScale*
12735 (double) PixelGetYellowQuantum(blend)),(double) (100.0*QuantumScale*
12736 (double) PixelGetBlackQuantum(blend)),(double) (100.0*QuantumScale*
12737 (double) PixelGetAlphaQuantum(blend)));
12738 target=PixelGetPixel(tint);
12739 tint_image=TintImage(wand->images,percent_blend,&target,wand->exception);
12740 if (tint_image == (Image *) NULL)
12741 return(MagickFalse);
12742 ReplaceImageInList(&wand->images,tint_image);
12743 return(MagickTrue);
12744}
12745␌
12746/*
12747%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12748% %
12749% %
12750% %
12751% M a g i c k T r a n s f o r m I m a g e C o l o r s p a c e %
12752% %
12753% %
12754% %
12755%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12756%
12757% MagickTransformImageColorspace() transform the image colorspace, setting
12758% the images colorspace while transforming the images data to that
12759% colorspace.
12760%
12761% The format of the MagickTransformImageColorspace method is:
12762%
12763% MagickBooleanType MagickTransformImageColorspace(MagickWand *wand,
12764% const ColorspaceType colorspace)
12765%
12766% A description of each parameter follows:
12767%
12768% o wand: the magick wand.
12769%
12770% o colorspace: the image colorspace: UndefinedColorspace,
12771% sRGBColorspace, RGBColorspace, GRAYColorspace,
12772% OHTAColorspace, XYZColorspace, YCbCrColorspace,
12773% YCCColorspace, YIQColorspace, YPbPrColorspace,
12774% YPbPrColorspace, YUVColorspace, CMYKColorspace,
12775% HSLColorspace, HWBColorspace.
12776%
12777*/
12778WandExport MagickBooleanType MagickTransformImageColorspace(MagickWand *wand,
12779 const ColorspaceType colorspace)
12780{
12781 assert(wand != (MagickWand *) NULL);
12782 assert(wand->signature == MagickWandSignature);
12783 if (wand->debug != MagickFalse)
12784 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12785 if (wand->images == (Image *) NULL)
12786 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12787 return(TransformImageColorspace(wand->images,colorspace,wand->exception));
12788}
12789␌
12790/*
12791%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12792% %
12793% %
12794% %
12795% M a g i c k T r a n s p a r e n t P a i n t I m a g e %
12796% %
12797% %
12798% %
12799%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12800%
12801% MagickTransparentPaintImage() changes any pixel that matches color with the
12802% color defined by fill.
12803%
12804% The format of the MagickTransparentPaintImage method is:
12805%
12806% MagickBooleanType MagickTransparentPaintImage(MagickWand *wand,
12807% const PixelWand *target,const double alpha,const double fuzz,
12808% const MagickBooleanType invert)
12809%
12810% A description of each parameter follows:
12811%
12812% o wand: the magick wand.
12813%
12814% o target: Change this target color to specified alpha value within
12815% the image.
12816%
12817% o alpha: the level of transparency: 1.0 is fully opaque and 0.0 is fully
12818% transparent.
12819%
12820% o fuzz: By default target must match a particular pixel color
12821% exactly. However, in many cases two colors may differ by a small amount.
12822% The fuzz member of image defines how much tolerance is acceptable to
12823% consider two colors as the same. For example, set fuzz to 10 and the
12824% color red at intensities of 100 and 102 respectively are now interpreted
12825% as the same color for the purposes of the floodfill.
12826%
12827% o invert: paint any pixel that does not match the target color.
12828%
12829*/
12830WandExport MagickBooleanType MagickTransparentPaintImage(MagickWand *wand,
12831 const PixelWand *target,const double alpha,const double fuzz,
12832 const MagickBooleanType invert)
12833{
12834 MagickBooleanType
12835 status;
12836
12837 PixelInfo
12838 target_pixel;
12839
12840 assert(wand != (MagickWand *) NULL);
12841 assert(wand->signature == MagickWandSignature);
12842 if (wand->debug != MagickFalse)
12843 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12844 if (wand->images == (Image *) NULL)
12845 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12846 PixelGetMagickColor(target,&target_pixel);
12847 wand->images->fuzz=fuzz;
12848 status=TransparentPaintImage(wand->images,&target_pixel,ClampToQuantum(
12849 (double) QuantumRange*alpha),invert,wand->exception);
12850 return(status);
12851}
12852␌
12853/*
12854%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12855% %
12856% %
12857% %
12858% M a g i c k T r a n s p o s e I m a g e %
12859% %
12860% %
12861% %
12862%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12863%
12864% MagickTransposeImage() creates a vertical mirror image by reflecting the
12865% pixels around the central x-axis while rotating them 90-degrees.
12866%
12867% The format of the MagickTransposeImage method is:
12868%
12869% MagickBooleanType MagickTransposeImage(MagickWand *wand)
12870%
12871% A description of each parameter follows:
12872%
12873% o wand: the magick wand.
12874%
12875*/
12876WandExport MagickBooleanType MagickTransposeImage(MagickWand *wand)
12877{
12878 Image
12879 *transpose_image;
12880
12881 assert(wand != (MagickWand *) NULL);
12882 assert(wand->signature == MagickWandSignature);
12883 if (wand->debug != MagickFalse)
12884 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12885 if (wand->images == (Image *) NULL)
12886 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12887 transpose_image=TransposeImage(wand->images,wand->exception);
12888 if (transpose_image == (Image *) NULL)
12889 return(MagickFalse);
12890 ReplaceImageInList(&wand->images,transpose_image);
12891 return(MagickTrue);
12892}
12893␌
12894/*
12895%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12896% %
12897% %
12898% %
12899% M a g i c k T r a n s v e r s e I m a g e %
12900% %
12901% %
12902% %
12903%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12904%
12905% MagickTransverseImage() creates a horizontal mirror image by reflecting the
12906% pixels around the central y-axis while rotating them 270-degrees.
12907%
12908% The format of the MagickTransverseImage method is:
12909%
12910% MagickBooleanType MagickTransverseImage(MagickWand *wand)
12911%
12912% A description of each parameter follows:
12913%
12914% o wand: the magick wand.
12915%
12916*/
12917WandExport MagickBooleanType MagickTransverseImage(MagickWand *wand)
12918{
12919 Image
12920 *transverse_image;
12921
12922 assert(wand != (MagickWand *) NULL);
12923 assert(wand->signature == MagickWandSignature);
12924 if (wand->debug != MagickFalse)
12925 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12926 if (wand->images == (Image *) NULL)
12927 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12928 transverse_image=TransverseImage(wand->images,wand->exception);
12929 if (transverse_image == (Image *) NULL)
12930 return(MagickFalse);
12931 ReplaceImageInList(&wand->images,transverse_image);
12932 return(MagickTrue);
12933}
12934␌
12935/*
12936%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12937% %
12938% %
12939% %
12940% M a g i c k T r i m I m a g e %
12941% %
12942% %
12943% %
12944%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12945%
12946% MagickTrimImage() remove edges that are the background color from the image.
12947%
12948% The format of the MagickTrimImage method is:
12949%
12950% MagickBooleanType MagickTrimImage(MagickWand *wand,const double fuzz)
12951%
12952% A description of each parameter follows:
12953%
12954% o wand: the magick wand.
12955%
12956% o fuzz: By default target must match a particular pixel color
12957% exactly. However, in many cases two colors may differ by a small amount.
12958% The fuzz member of image defines how much tolerance is acceptable to
12959% consider two colors as the same. For example, set fuzz to 10 and the
12960% color red at intensities of 100 and 102 respectively are now interpreted
12961% as the same color for the purposes of the floodfill.
12962%
12963*/
12964WandExport MagickBooleanType MagickTrimImage(MagickWand *wand,const double fuzz)
12965{
12966 Image
12967 *trim_image;
12968
12969 assert(wand != (MagickWand *) NULL);
12970 assert(wand->signature == MagickWandSignature);
12971 if (wand->debug != MagickFalse)
12972 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
12973 if (wand->images == (Image *) NULL)
12974 ThrowWandException(WandError,"ContainsNoImages",wand->name);
12975 wand->images->fuzz=fuzz;
12976 trim_image=TrimImage(wand->images,wand->exception);
12977 if (trim_image == (Image *) NULL)
12978 return(MagickFalse);
12979 ReplaceImageInList(&wand->images,trim_image);
12980 return(MagickTrue);
12981}
12982␌
12983/*
12984%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12985% %
12986% %
12987% %
12988% M a g i c k U n i q u e I m a g e C o l o r s %
12989% %
12990% %
12991% %
12992%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12993%
12994% MagickUniqueImageColors() discards all but one of any pixel color.
12995%
12996% The format of the MagickUniqueImageColors method is:
12997%
12998% MagickBooleanType MagickUniqueImageColors(MagickWand *wand)
12999%
13000% A description of each parameter follows:
13001%
13002% o wand: the magick wand.
13003%
13004*/
13005WandExport MagickBooleanType MagickUniqueImageColors(MagickWand *wand)
13006{
13007 Image
13008 *unique_image;
13009
13010 assert(wand != (MagickWand *) NULL);
13011 assert(wand->signature == MagickWandSignature);
13012 if (wand->debug != MagickFalse)
13013 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13014 if (wand->images == (Image *) NULL)
13015 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13016 unique_image=UniqueImageColors(wand->images,wand->exception);
13017 if (unique_image == (Image *) NULL)
13018 return(MagickFalse);
13019 ReplaceImageInList(&wand->images,unique_image);
13020 return(MagickTrue);
13021}
13022␌
13023/*
13024%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13025% %
13026% %
13027% %
13028% M a g i c k U n s h a r p M a s k I m a g e %
13029% %
13030% %
13031% %
13032%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13033%
13034% MagickUnsharpMaskImage() sharpens an image. We convolve the image with a
13035% Gaussian operator of the given radius and standard deviation (sigma).
13036% For reasonable results, radius should be larger than sigma. Use a radius
13037% of 0 and UnsharpMaskImage() selects a suitable radius for you.
13038%
13039% The format of the MagickUnsharpMaskImage method is:
13040%
13041% MagickBooleanType MagickUnsharpMaskImage(MagickWand *wand,
13042% const double radius,const double sigma,const double gain,
13043% const double threshold)
13044%
13045% A description of each parameter follows:
13046%
13047% o wand: the magick wand.
13048%
13049% o radius: the radius of the Gaussian, in pixels, not counting the center
13050% pixel.
13051%
13052% o sigma: the standard deviation of the Gaussian, in pixels.
13053%
13054% o gain: the percentage of the difference between the original and the
13055% blur image that is added back into the original.
13056%
13057% o threshold: the threshold in pixels needed to apply the difference gain.
13058%
13059*/
13060WandExport MagickBooleanType MagickUnsharpMaskImage(MagickWand *wand,
13061 const double radius,const double sigma,const double gain,
13062 const double threshold)
13063{
13064 Image
13065 *unsharp_image;
13066
13067 assert(wand != (MagickWand *) NULL);
13068 assert(wand->signature == MagickWandSignature);
13069 if (wand->debug != MagickFalse)
13070 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13071 if (wand->images == (Image *) NULL)
13072 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13073 unsharp_image=UnsharpMaskImage(wand->images,radius,sigma,gain,threshold,
13074 wand->exception);
13075 if (unsharp_image == (Image *) NULL)
13076 return(MagickFalse);
13077 ReplaceImageInList(&wand->images,unsharp_image);
13078 return(MagickTrue);
13079}
13080␌
13081/*
13082%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13083% %
13084% %
13085% %
13086% M a g i c k V i g n e t t e I m a g e %
13087% %
13088% %
13089% %
13090%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13091%
13092% MagickVignetteImage() softens the edges of the image in vignette style.
13093%
13094% The format of the MagickVignetteImage method is:
13095%
13096% MagickBooleanType MagickVignetteImage(MagickWand *wand,
13097% const double radius,const double sigma,const ssize_t x,
13098% const ssize_t y)
13099%
13100% A description of each parameter follows:
13101%
13102% o wand: the magick wand.
13103%
13104% o radius: the radius.
13105%
13106% o sigma: the sigma.
13107%
13108% o x, y: Define the x and y ellipse offset.
13109%
13110*/
13111WandExport MagickBooleanType MagickVignetteImage(MagickWand *wand,
13112 const double radius,const double sigma,const ssize_t x,const ssize_t y)
13113{
13114 Image
13115 *vignette_image;
13116
13117 assert(wand != (MagickWand *) NULL);
13118 assert(wand->signature == MagickWandSignature);
13119 if (wand->debug != MagickFalse)
13120 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13121 if (wand->images == (Image *) NULL)
13122 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13123 vignette_image=VignetteImage(wand->images,radius,sigma,x,y,wand->exception);
13124 if (vignette_image == (Image *) NULL)
13125 return(MagickFalse);
13126 ReplaceImageInList(&wand->images,vignette_image);
13127 return(MagickTrue);
13128}
13129␌
13130/*
13131%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13132% %
13133% %
13134% %
13135% M a g i c k W a v e I m a g e %
13136% %
13137% %
13138% %
13139%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13140%
13141% MagickWaveImage() creates a "ripple" effect in the image by shifting
13142% the pixels vertically along a sine wave whose amplitude and wavelength
13143% is specified by the given parameters.
13144%
13145% The format of the MagickWaveImage method is:
13146%
13147% MagickBooleanType MagickWaveImage(MagickWand *wand,
13148% const double amplitude,const double wave_length,
13149% const PixelInterpolateMethod method)
13150%
13151% A description of each parameter follows:
13152%
13153% o wand: the magick wand.
13154%
13155% o amplitude, wave_length: Define the amplitude and wave length of the
13156% sine wave.
13157%
13158% o method: the pixel interpolation method.
13159%
13160*/
13161WandExport MagickBooleanType MagickWaveImage(MagickWand *wand,
13162 const double amplitude,const double wave_length,
13163 const PixelInterpolateMethod method)
13164{
13165 Image
13166 *wave_image;
13167
13168 assert(wand != (MagickWand *) NULL);
13169 assert(wand->signature == MagickWandSignature);
13170 if (wand->debug != MagickFalse)
13171 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13172 if (wand->images == (Image *) NULL)
13173 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13174 wave_image=WaveImage(wand->images,amplitude,wave_length,method,
13175 wand->exception);
13176 if (wave_image == (Image *) NULL)
13177 return(MagickFalse);
13178 ReplaceImageInList(&wand->images,wave_image);
13179 return(MagickTrue);
13180}
13181␌
13182/*
13183%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13184% %
13185% %
13186% %
13187% M a g i c k W a v e l e t D e n o i s e I m a g e %
13188% %
13189% %
13190% %
13191%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13192%
13193% MagickWaveletDenoiseImage() removes noise from the image using a wavelet
13194% transform. The wavelet transform is a fast hierarchical scheme for
13195% processing an image using a set of consecutive lowpass and high_pass filters,
13196% followed by a decimation. This results in a decomposition into different
13197% scales which can be regarded as different “frequency bands”, determined by
13198% the mother wavelet.
13199%
13200% The format of the MagickWaveletDenoiseImage method is:
13201%
13202% MagickBooleanType MagickWaveletDenoiseImage(MagickWand *wand,
13203% const double threshold,const double softness)
13204%
13205% A description of each parameter follows:
13206%
13207% o wand: the magick wand.
13208%
13209% o threshold: set the threshold for smoothing.
13210%
13211% o softness: attenuate the smoothing threshold.
13212%
13213*/
13214WandExport MagickBooleanType MagickWaveletDenoiseImage(MagickWand *wand,
13215 const double threshold,const double softness)
13216{
13217 Image
13218 *noise_image;
13219
13220 assert(wand != (MagickWand *) NULL);
13221 assert(wand->signature == MagickWandSignature);
13222 if (wand->debug != MagickFalse)
13223 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13224 if (wand->images == (Image *) NULL)
13225 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13226 noise_image=WaveletDenoiseImage(wand->images,threshold,softness,
13227 wand->exception);
13228 if (noise_image == (Image *) NULL)
13229 return(MagickFalse);
13230 ReplaceImageInList(&wand->images,noise_image);
13231 return(MagickTrue);
13232}
13233␌
13234/*
13235%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13236% %
13237% %
13238% %
13239% M a g i c k W h i t e B a l a n c e I m a g e %
13240% %
13241% %
13242% %
13243%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13244%
13245% MagickWhiteBalanceImage() applies white balancing to an image according to
13246% a grayworld assumption in the LAB colorspace.
13247%
13248% The format of the WhiteBalanceImage method is:
13249%
13250% MagickBooleanType WhiteBalanceImage(MagickWand *wand)
13251%
13252% A description of each parameter follows:
13253%
13254% o wand: the magick wand.
13255%
13256*/
13257WandExport MagickBooleanType MagickWhiteBalanceImage(MagickWand *wand)
13258{
13259 MagickBooleanType
13260 status;
13261
13262 assert(wand != (MagickWand *) NULL);
13263 assert(wand->signature == MagickWandSignature);
13264 if (wand->debug != MagickFalse)
13265 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13266 if (wand->images == (Image *) NULL)
13267 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13268 status=WhiteBalanceImage(wand->images, wand->exception);
13269 return(status);
13270}
13271␌
13272/*
13273%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13274% %
13275% %
13276% %
13277% M a g i c k W h i t e T h r e s h o l d I m a g e %
13278% %
13279% %
13280% %
13281%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13282%
13283% MagickWhiteThresholdImage() is like ThresholdImage() but force all pixels
13284% above the threshold into white while leaving all pixels below the threshold
13285% unchanged.
13286%
13287% The format of the MagickWhiteThresholdImage method is:
13288%
13289% MagickBooleanType MagickWhiteThresholdImage(MagickWand *wand,
13290% const PixelWand *threshold)
13291%
13292% A description of each parameter follows:
13293%
13294% o wand: the magick wand.
13295%
13296% o threshold: the pixel wand.
13297%
13298*/
13299WandExport MagickBooleanType MagickWhiteThresholdImage(MagickWand *wand,
13300 const PixelWand *threshold)
13301{
13302 char
13303 thresholds[MagickPathExtent];
13304
13305 assert(wand != (MagickWand *) NULL);
13306 assert(wand->signature == MagickWandSignature);
13307 if (wand->debug != MagickFalse)
13308 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13309 if (wand->images == (Image *) NULL)
13310 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13311 (void) FormatLocaleString(thresholds,MagickPathExtent,
13312 "%g" "," "%g" "," "%g" "," "%g",
13313 (double) PixelGetRedQuantum(threshold),
13314 (double) PixelGetGreenQuantum(threshold),
13315 (double) PixelGetBlueQuantum(threshold),
13316 (double) PixelGetAlphaQuantum(threshold));
13317 return(WhiteThresholdImage(wand->images,thresholds,wand->exception));
13318}
13319␌
13320/*
13321%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13322% %
13323% %
13324% %
13325% M a g i c k W r i t e I m a g e %
13326% %
13327% %
13328% %
13329%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13330%
13331% MagickWriteImage() writes an image to the specified filename. If the
13332% filename parameter is NULL, the image is written to the filename set
13333% by MagickReadImage() or MagickSetImageFilename().
13334%
13335% The format of the MagickWriteImage method is:
13336%
13337% MagickBooleanType MagickWriteImage(MagickWand *wand,
13338% const char *filename)
13339%
13340% A description of each parameter follows:
13341%
13342% o wand: the magick wand.
13343%
13344% o filename: the image filename.
13345%
13346%
13347*/
13348WandExport MagickBooleanType MagickWriteImage(MagickWand *wand,
13349 const char *filename)
13350{
13351 Image
13352 *image;
13353
13354 ImageInfo
13355 *write_info;
13356
13357 MagickBooleanType
13358 status;
13359
13360 assert(wand != (MagickWand *) NULL);
13361 assert(wand->signature == MagickWandSignature);
13362 if (wand->debug != MagickFalse)
13363 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13364 if (wand->images == (Image *) NULL)
13365 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13366 if (filename != (const char *) NULL)
13367 (void) CopyMagickString(wand->images->filename,filename,MagickPathExtent);
13368 image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
13369 if (image == (Image *) NULL)
13370 return(MagickFalse);
13371 write_info=CloneImageInfo(wand->image_info);
13372 write_info->adjoin=MagickTrue;
13373 status=WriteImage(write_info,image,wand->exception);
13374 image=DestroyImage(image);
13375 write_info=DestroyImageInfo(write_info);
13376 return(status);
13377}
13378␌
13379/*
13380%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13381% %
13382% %
13383% %
13384% M a g i c k W r i t e I m a g e F i l e %
13385% %
13386% %
13387% %
13388%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13389%
13390% MagickWriteImageFile() writes an image to an open file descriptor.
13391%
13392% The format of the MagickWriteImageFile method is:
13393%
13394% MagickBooleanType MagickWriteImageFile(MagickWand *wand,FILE *file)
13395%
13396% A description of each parameter follows:
13397%
13398% o wand: the magick wand.
13399%
13400% o file: the file descriptor.
13401%
13402*/
13403WandExport MagickBooleanType MagickWriteImageFile(MagickWand *wand,FILE *file)
13404{
13405 Image
13406 *image;
13407
13408 ImageInfo
13409 *write_info;
13410
13411 MagickBooleanType
13412 status;
13413
13414 assert(wand != (MagickWand *) NULL);
13415 assert(wand->signature == MagickWandSignature);
13416 assert(file != (FILE *) NULL);
13417 if (wand->debug != MagickFalse)
13418 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13419 if (wand->images == (Image *) NULL)
13420 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13421 image=CloneImage(wand->images,0,0,MagickTrue,wand->exception);
13422 if (image == (Image *) NULL)
13423 return(MagickFalse);
13424 write_info=CloneImageInfo(wand->image_info);
13425 SetImageInfoFile(write_info,file);
13426 write_info->adjoin=MagickTrue;
13427 status=WriteImage(write_info,image,wand->exception);
13428 write_info=DestroyImageInfo(write_info);
13429 image=DestroyImage(image);
13430 return(status);
13431}
13432␌
13433/*
13434%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13435% %
13436% %
13437% %
13438% M a g i c k W r i t e I m a g e s %
13439% %
13440% %
13441% %
13442%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13443%
13444% MagickWriteImages() writes an image or image sequence.
13445%
13446% The format of the MagickWriteImages method is:
13447%
13448% MagickBooleanType MagickWriteImages(MagickWand *wand,
13449% const char *filename,const MagickBooleanType adjoin)
13450%
13451% A description of each parameter follows:
13452%
13453% o wand: the magick wand.
13454%
13455% o filename: the image filename.
13456%
13457% o adjoin: join images into a single multi-image file.
13458%
13459*/
13460WandExport MagickBooleanType MagickWriteImages(MagickWand *wand,
13461 const char *filename,const MagickBooleanType adjoin)
13462{
13463 ImageInfo
13464 *write_info;
13465
13466 MagickBooleanType
13467 status;
13468
13469 assert(wand != (MagickWand *) NULL);
13470 assert(wand->signature == MagickWandSignature);
13471 if (wand->debug != MagickFalse)
13472 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13473 if (wand->images == (Image *) NULL)
13474 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13475 write_info=CloneImageInfo(wand->image_info);
13476 write_info->adjoin=adjoin;
13477 status=WriteImages(write_info,wand->images,filename,wand->exception);
13478 write_info=DestroyImageInfo(write_info);
13479 return(status);
13480}
13481␌
13482/*
13483%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13484% %
13485% %
13486% %
13487% M a g i c k W r i t e I m a g e s F i l e %
13488% %
13489% %
13490% %
13491%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13492%
13493% MagickWriteImagesFile() writes an image sequence to an open file descriptor.
13494%
13495% The format of the MagickWriteImagesFile method is:
13496%
13497% MagickBooleanType MagickWriteImagesFile(MagickWand *wand,FILE *file)
13498%
13499% A description of each parameter follows:
13500%
13501% o wand: the magick wand.
13502%
13503% o file: the file descriptor.
13504%
13505*/
13506WandExport MagickBooleanType MagickWriteImagesFile(MagickWand *wand,FILE *file)
13507{
13508 ImageInfo
13509 *write_info;
13510
13511 MagickBooleanType
13512 status;
13513
13514 assert(wand != (MagickWand *) NULL);
13515 assert(wand->signature == MagickWandSignature);
13516 if (wand->debug != MagickFalse)
13517 (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
13518 if (wand->images == (Image *) NULL)
13519 ThrowWandException(WandError,"ContainsNoImages",wand->name);
13520 write_info=CloneImageInfo(wand->image_info);
13521 SetImageInfoFile(write_info,file);
13522 write_info->adjoin=MagickTrue;
13523 status=WriteImages(write_info,wand->images,(const char *) NULL,
13524 wand->exception);
13525 write_info=DestroyImageInfo(write_info);
13526 return(status);
13527}