• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %                                                                             %
4 %                                                                             %
5 %                                                                             %
6 %                      PPPP   IIIII  X   X  EEEEE  L                          %
7 %                      P   P    I     X X   E      L                          %
8 %                      PPPP     I      X    EEE    L                          %
9 %                      P        I     X X   E      L                          %
10 %                      P      IIIII  X   X  EEEEE  LLLLL                      %
11 %                                                                             %
12 %                         W   W   AAA   N   N  DDDD                           %
13 %                         W   W  A   A  NN  N  D   D                          %
14 %                         W W W  AAAAA  N N N  D   D                          %
15 %                         WW WW  A   A  N  NN  D   D                          %
16 %                         W   W  A   A  N   N  DDDD                           %
17 %                                                                             %
18 %                                                                             %
19 %                    MagickWand Image Pixel Wand Methods                      %
20 %                                                                             %
21 %                              Software Design                                %
22 %                                   Cristy                                    %
23 %                                March 2003                                   %
24 %                                                                             %
25 %                                                                             %
26 %  Copyright 1999-2016 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 %    http://www.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/pixel-wand-private.h"
53 #include "MagickWand/wand.h"
54 
55 /*
56   Define declarations.
57 */
58 #define PixelWandId  "PixelWand"
59 
60 /*
61   Typedef declarations.
62 */
63 struct _PixelWand
64 {
65   size_t
66     id;
67 
68   char
69     name[MagickPathExtent];
70 
71   ExceptionInfo
72     *exception;
73 
74   PixelInfo
75     pixel;
76 
77   size_t
78     count;
79 
80   MagickBooleanType
81     debug;
82 
83   size_t
84     signature;
85 };
86 
87 /*
88 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
89 %                                                                             %
90 %                                                                             %
91 %                                                                             %
92 %   C l e a r P i x e l W a n d                                               %
93 %                                                                             %
94 %                                                                             %
95 %                                                                             %
96 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
97 %
98 %  ClearPixelWand() clears resources associated with the wand.
99 %
100 %  The format of the ClearPixelWand method is:
101 %
102 %      void ClearPixelWand(PixelWand *wand)
103 %
104 %  A description of each parameter follows:
105 %
106 %    o wand: the pixel wand.
107 %
108 */
ClearPixelWand(PixelWand * wand)109 WandExport void ClearPixelWand(PixelWand *wand)
110 {
111   assert(wand != (PixelWand *) NULL);
112   assert(wand->signature == MagickWandSignature);
113   if (wand->debug != MagickFalse)
114     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
115   ClearMagickException(wand->exception);
116   wand->pixel.colorspace=sRGBColorspace;
117   wand->debug=IsEventLogging();
118 }
119 
120 /*
121 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
122 %                                                                             %
123 %                                                                             %
124 %                                                                             %
125 %   C l o n e P i x e l W a n d                                               %
126 %                                                                             %
127 %                                                                             %
128 %                                                                             %
129 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
130 %
131 %  ClonePixelWand() makes an exact copy of the specified wand.
132 %
133 %  The format of the ClonePixelWand method is:
134 %
135 %      PixelWand *ClonePixelWand(const PixelWand *wand)
136 %
137 %  A description of each parameter follows:
138 %
139 %    o wand: the magick wand.
140 %
141 */
ClonePixelWand(const PixelWand * wand)142 WandExport PixelWand *ClonePixelWand(const PixelWand *wand)
143 {
144   PixelWand
145     *clone_wand;
146 
147   assert(wand != (PixelWand *) NULL);
148   assert(wand->signature == MagickWandSignature);
149   if (wand->debug != MagickFalse)
150     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
151   clone_wand=(PixelWand *) AcquireMagickMemory(sizeof(*clone_wand));
152   if (clone_wand == (PixelWand *) NULL)
153     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
154       wand->name);
155   (void) ResetMagickMemory(clone_wand,0,sizeof(*clone_wand));
156   clone_wand->id=AcquireWandId();
157   (void) FormatLocaleString(clone_wand->name,MagickPathExtent,"%s-%.20g",
158     PixelWandId,(double) clone_wand->id);
159   clone_wand->exception=AcquireExceptionInfo();
160   InheritException(clone_wand->exception,wand->exception);
161   clone_wand->pixel=wand->pixel;
162   clone_wand->count=wand->count;
163   clone_wand->debug=IsEventLogging();
164   if (clone_wand->debug != MagickFalse)
165     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",clone_wand->name);
166   clone_wand->signature=MagickWandSignature;
167   return(clone_wand);
168 }
169 
170 /*
171 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
172 %                                                                             %
173 %                                                                             %
174 %                                                                             %
175 %   C l o n e P i x e l W a n d s                                             %
176 %                                                                             %
177 %                                                                             %
178 %                                                                             %
179 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
180 %
181 %  ClonePixelWands() makes an exact copy of the specified wands.
182 %
183 %  The format of the ClonePixelWands method is:
184 %
185 %      PixelWand **ClonePixelWands(const PixelWand **wands,
186 %        const size_t number_wands)
187 %
188 %  A description of each parameter follows:
189 %
190 %    o wands: the magick wands.
191 %
192 %    o number_wands: the number of wands.
193 %
194 */
ClonePixelWands(const PixelWand ** wands,const size_t number_wands)195 WandExport PixelWand **ClonePixelWands(const PixelWand **wands,
196   const size_t number_wands)
197 {
198   register ssize_t
199     i;
200 
201   PixelWand
202     **clone_wands;
203 
204   clone_wands=(PixelWand **) AcquireQuantumMemory((size_t) number_wands,
205     sizeof(*clone_wands));
206   if (clone_wands == (PixelWand **) NULL)
207     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
208       GetExceptionMessage(errno));
209   for (i=0; i < (ssize_t) number_wands; i++)
210     clone_wands[i]=ClonePixelWand(wands[i]);
211   return(clone_wands);
212 }
213 
214 /*
215 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
216 %                                                                             %
217 %                                                                             %
218 %                                                                             %
219 %   D e s t r o y P i x e l W a n d                                           %
220 %                                                                             %
221 %                                                                             %
222 %                                                                             %
223 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
224 %
225 %  DestroyPixelWand() deallocates resources associated with a PixelWand.
226 %
227 %  The format of the DestroyPixelWand method is:
228 %
229 %      PixelWand *DestroyPixelWand(PixelWand *wand)
230 %
231 %  A description of each parameter follows:
232 %
233 %    o wand: the pixel wand.
234 %
235 */
DestroyPixelWand(PixelWand * wand)236 WandExport PixelWand *DestroyPixelWand(PixelWand *wand)
237 {
238   assert(wand != (PixelWand *) NULL);
239   assert(wand->signature == MagickWandSignature);
240   if (wand->debug != MagickFalse)
241     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
242   wand->exception=DestroyExceptionInfo(wand->exception);
243   wand->signature=(~MagickWandSignature);
244   RelinquishWandId(wand->id);
245   wand=(PixelWand *) RelinquishMagickMemory(wand);
246   return(wand);
247 }
248 
249 /*
250 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
251 %                                                                             %
252 %                                                                             %
253 %                                                                             %
254 %   D e s t r o y P i x e l W a n d s                                         %
255 %                                                                             %
256 %                                                                             %
257 %                                                                             %
258 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
259 %
260 %  DestroyPixelWands() deallocates resources associated with an array of
261 %  pixel wands.
262 %
263 %  The format of the DestroyPixelWands method is:
264 %
265 %      PixelWand **DestroyPixelWands(PixelWand **wand,
266 %        const size_t number_wands)
267 %
268 %  A description of each parameter follows:
269 %
270 %    o wand: the pixel wand.
271 %
272 %    o number_wands: the number of wands.
273 %
274 */
DestroyPixelWands(PixelWand ** wand,const size_t number_wands)275 WandExport PixelWand **DestroyPixelWands(PixelWand **wand,
276   const size_t number_wands)
277 {
278   register ssize_t
279     i;
280 
281   assert(wand != (PixelWand **) NULL);
282   assert(*wand != (PixelWand *) NULL);
283   assert((*wand)->signature == MagickWandSignature);
284   if ((*wand)->debug != MagickFalse)
285     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",(*wand)->name);
286   for (i=(ssize_t) number_wands-1; i >= 0; i--)
287     wand[i]=DestroyPixelWand(wand[i]);
288   wand=(PixelWand **) RelinquishMagickMemory(wand);
289   return(wand);
290 }
291 
292 /*
293 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
294 %                                                                             %
295 %                                                                             %
296 %                                                                             %
297 %   I s P i x e l W a n d S i m i l a r                                       %
298 %                                                                             %
299 %                                                                             %
300 %                                                                             %
301 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
302 %
303 %  IsPixelWandSimilar() returns MagickTrue if the distance between two
304 %  colors is less than the specified distance.
305 %
306 %  The format of the IsPixelWandSimilar method is:
307 %
308 %      MagickBooleanType IsPixelWandSimilar(PixelWand *p,PixelWand *q,
309 %        const double fuzz)
310 %
311 %  A description of each parameter follows:
312 %
313 %    o p: the pixel wand.
314 %
315 %    o q: the pixel wand.
316 %
317 %    o fuzz: any two colors that are less than or equal to this distance
318 %      squared are consider similar.
319 %
320 */
IsPixelWandSimilar(PixelWand * p,PixelWand * q,const double fuzz)321 WandExport MagickBooleanType IsPixelWandSimilar(PixelWand *p,PixelWand *q,
322   const double fuzz)
323 {
324   assert(p != (PixelWand *) NULL);
325   assert(p->signature == MagickWandSignature);
326   if (p->debug != MagickFalse)
327     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",p->name);
328   assert(q != (PixelWand *) NULL);
329   assert(q->signature == MagickWandSignature);
330   if (q->debug != MagickFalse)
331     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",q->name);
332   p->pixel.fuzz=fuzz;
333   q->pixel.fuzz=fuzz;
334   return(IsFuzzyEquivalencePixelInfo(&p->pixel,&q->pixel));
335 }
336 
337 /*
338 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
339 %                                                                             %
340 %                                                                             %
341 %                                                                             %
342 %   I s P i x e l W a n d                                                     %
343 %                                                                             %
344 %                                                                             %
345 %                                                                             %
346 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
347 %
348 %  IsPixelWand() returns MagickTrue if the wand is verified as a pixel wand.
349 %
350 %  The format of the IsPixelWand method is:
351 %
352 %      MagickBooleanType IsPixelWand(const PixelWand *wand)
353 %
354 %  A description of each parameter follows:
355 %
356 %    o wand: the magick wand.
357 %
358 */
IsPixelWand(const PixelWand * wand)359 WandExport MagickBooleanType IsPixelWand(const PixelWand *wand)
360 {
361   if (wand == (const PixelWand *) NULL)
362     return(MagickFalse);
363   if (wand->signature != MagickWandSignature)
364     return(MagickFalse);
365   if (LocaleNCompare(wand->name,PixelWandId,strlen(PixelWandId)) != 0)
366     return(MagickFalse);
367   return(MagickTrue);
368 }
369 
370 /*
371 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
372 %                                                                             %
373 %                                                                             %
374 %                                                                             %
375 %   N e w P i x e l W a n d                                                   %
376 %                                                                             %
377 %                                                                             %
378 %                                                                             %
379 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
380 %
381 %  NewPixelWand() returns a new pixel wand.
382 %
383 %  The format of the NewPixelWand method is:
384 %
385 %      PixelWand *NewPixelWand(void)
386 %
387 */
NewPixelWand(void)388 WandExport PixelWand *NewPixelWand(void)
389 {
390   const char
391     *quantum;
392 
393   PixelWand
394     *wand;
395 
396   size_t
397     depth;
398 
399   depth=MAGICKCORE_QUANTUM_DEPTH;
400   quantum=GetMagickQuantumDepth(&depth);
401   if (depth != MAGICKCORE_QUANTUM_DEPTH)
402     ThrowWandFatalException(WandError,"QuantumDepthMismatch",quantum);
403   wand=(PixelWand *) AcquireMagickMemory(sizeof(*wand));
404   if (wand == (PixelWand *) NULL)
405     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
406       GetExceptionMessage(errno));
407   (void) ResetMagickMemory(wand,0,sizeof(*wand));
408   wand->id=AcquireWandId();
409   (void) FormatLocaleString(wand->name,MagickPathExtent,"%s-%.20g",PixelWandId,
410     (double) wand->id);
411   wand->exception=AcquireExceptionInfo();
412   GetPixelInfo((Image *) NULL,&wand->pixel);
413   wand->debug=IsEventLogging();
414   if (wand->debug != MagickFalse)
415     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
416   wand->signature=MagickWandSignature;
417   return(wand);
418 }
419 
420 /*
421 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
422 %                                                                             %
423 %                                                                             %
424 %                                                                             %
425 %   N e w P i x e l W a n d s                                                 %
426 %                                                                             %
427 %                                                                             %
428 %                                                                             %
429 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
430 %
431 %  NewPixelWands() returns an array of pixel wands.
432 %
433 %  The format of the NewPixelWands method is:
434 %
435 %      PixelWand **NewPixelWands(const size_t number_wands)
436 %
437 %  A description of each parameter follows:
438 %
439 %    o number_wands: the number of wands.
440 %
441 */
NewPixelWands(const size_t number_wands)442 WandExport PixelWand **NewPixelWands(const size_t number_wands)
443 {
444   register ssize_t
445     i;
446 
447   PixelWand
448     **wands;
449 
450   wands=(PixelWand **) AcquireQuantumMemory((size_t) number_wands,
451     sizeof(*wands));
452   if (wands == (PixelWand **) NULL)
453     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
454       GetExceptionMessage(errno));
455   for (i=0; i < (ssize_t) number_wands; i++)
456     wands[i]=NewPixelWand();
457   return(wands);
458 }
459 
460 /*
461 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
462 %                                                                             %
463 %                                                                             %
464 %                                                                             %
465 %   P i x e l C l e a r E x c e p t i o n                                     %
466 %                                                                             %
467 %                                                                             %
468 %                                                                             %
469 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
470 %
471 %  PixelClearException() clear any exceptions associated with the iterator.
472 %
473 %  The format of the PixelClearException method is:
474 %
475 %      MagickBooleanType PixelClearException(PixelWand *wand)
476 %
477 %  A description of each parameter follows:
478 %
479 %    o wand: the pixel wand.
480 %
481 */
PixelClearException(PixelWand * wand)482 WandExport MagickBooleanType PixelClearException(PixelWand *wand)
483 {
484   assert(wand != (PixelWand *) NULL);
485   assert(wand->signature == MagickWandSignature);
486   if (wand->debug != MagickFalse)
487     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
488   ClearMagickException(wand->exception);
489   return(MagickTrue);
490 }
491 
492 /*
493 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
494 %                                                                             %
495 %                                                                             %
496 %                                                                             %
497 %   P i x e l G e t A l p h a                                                 %
498 %                                                                             %
499 %                                                                             %
500 %                                                                             %
501 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
502 %
503 %  PixelGetAlpha() returns the normalized alpha value of the pixel wand.
504 %
505 %  The format of the PixelGetAlpha method is:
506 %
507 %      double PixelGetAlpha(const PixelWand *wand)
508 %
509 %  A description of each parameter follows:
510 %
511 %    o wand: the pixel wand.
512 %
513 */
PixelGetAlpha(const PixelWand * wand)514 WandExport double PixelGetAlpha(const PixelWand *wand)
515 {
516   assert(wand != (const PixelWand *) NULL);
517   assert(wand->signature == MagickWandSignature);
518   if (wand->debug != MagickFalse)
519     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
520   return((double) QuantumScale*wand->pixel.alpha);
521 }
522 
523 /*
524 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
525 %                                                                             %
526 %                                                                             %
527 %                                                                             %
528 %   P i x e l G e t A l p h a Q u a n t u m                                   %
529 %                                                                             %
530 %                                                                             %
531 %                                                                             %
532 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
533 %
534 %  PixelGetAlphaQuantum() returns the alpha value of the pixel wand.
535 %
536 %  The format of the PixelGetAlphaQuantum method is:
537 %
538 %      Quantum PixelGetAlphaQuantum(const PixelWand *wand)
539 %
540 %  A description of each parameter follows:
541 %
542 %    o wand: the pixel wand.
543 %
544 */
PixelGetAlphaQuantum(const PixelWand * wand)545 WandExport Quantum PixelGetAlphaQuantum(const PixelWand *wand)
546 {
547   assert(wand != (const PixelWand *) NULL);
548   assert(wand->signature == MagickWandSignature);
549   if (wand->debug != MagickFalse)
550     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
551   return(ClampToQuantum(wand->pixel.alpha));
552 }
553 
554 /*
555 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
556 %                                                                             %
557 %                                                                             %
558 %                                                                             %
559 %   P i x e l G e t B l a c k                                                 %
560 %                                                                             %
561 %                                                                             %
562 %                                                                             %
563 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
564 %
565 %  PixelGetBlack() returns the normalized black color of the pixel wand.
566 %
567 %  The format of the PixelGetBlack method is:
568 %
569 %      double PixelGetBlack(const PixelWand *wand)
570 %
571 %  A description of each parameter follows:
572 %
573 %    o wand: the pixel wand.
574 %
575 */
PixelGetBlack(const PixelWand * wand)576 WandExport double PixelGetBlack(const PixelWand *wand)
577 {
578   assert(wand != (const PixelWand *) NULL);
579   assert(wand->signature == MagickWandSignature);
580   if (wand->debug != MagickFalse)
581     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
582   return((double) QuantumScale*wand->pixel.black);
583 }
584 
585 /*
586 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
587 %                                                                             %
588 %                                                                             %
589 %                                                                             %
590 %   P i x e l G e t B l a c k Q u a n t u m                                   %
591 %                                                                             %
592 %                                                                             %
593 %                                                                             %
594 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
595 %
596 %  PixelGetBlackQuantum() returns the black color of the pixel wand.
597 %
598 %  The format of the PixelGetBlackQuantum method is:
599 %
600 %      Quantum PixelGetBlackQuantum(const PixelWand *wand)
601 %
602 %  A description of each parameter follows:
603 %
604 %    o wand: the pixel wand.
605 %
606 */
PixelGetBlackQuantum(const PixelWand * wand)607 WandExport Quantum PixelGetBlackQuantum(const PixelWand *wand)
608 {
609   assert(wand != (const PixelWand *) NULL);
610   assert(wand->signature == MagickWandSignature);
611   if (wand->debug != MagickFalse)
612     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
613   return(ClampToQuantum(wand->pixel.black));
614 }
615 
616 /*
617 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
618 %                                                                             %
619 %                                                                             %
620 %                                                                             %
621 %   P i x e l G e t B l u e                                                   %
622 %                                                                             %
623 %                                                                             %
624 %                                                                             %
625 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
626 %
627 %  PixelGetBlue() returns the normalized blue color of the pixel wand.
628 %
629 %  The format of the PixelGetBlue method is:
630 %
631 %      double PixelGetBlue(const PixelWand *wand)
632 %
633 %  A description of each parameter follows:
634 %
635 %    o wand: the pixel wand.
636 %
637 */
PixelGetBlue(const PixelWand * wand)638 WandExport double PixelGetBlue(const PixelWand *wand)
639 {
640   assert(wand != (const PixelWand *) NULL);
641   assert(wand->signature == MagickWandSignature);
642   if (wand->debug != MagickFalse)
643     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
644   return((double) QuantumScale*wand->pixel.blue);
645 }
646 
647 /*
648 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
649 %                                                                             %
650 %                                                                             %
651 %                                                                             %
652 %   P i x e l G e t B l u e Q u a n t u m                                     %
653 %                                                                             %
654 %                                                                             %
655 %                                                                             %
656 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
657 %
658 %  PixelGetBlueQuantum() returns the blue color of the pixel wand.
659 %
660 %  The format of the PixelGetBlueQuantum method is:
661 %
662 %      Quantum PixelGetBlueQuantum(const PixelWand *wand)
663 %
664 %  A description of each parameter follows:
665 %
666 %    o wand: the pixel wand.
667 %
668 */
PixelGetBlueQuantum(const PixelWand * wand)669 WandExport Quantum PixelGetBlueQuantum(const PixelWand *wand)
670 {
671   assert(wand != (const PixelWand *) NULL);
672   assert(wand->signature == MagickWandSignature);
673   if (wand->debug != MagickFalse)
674     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
675   return(ClampToQuantum(wand->pixel.blue));
676 }
677 
678 /*
679 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
680 %                                                                             %
681 %                                                                             %
682 %                                                                             %
683 %   P i x e l G e t C o l o r A s S t r i n g                                 %
684 %                                                                             %
685 %                                                                             %
686 %                                                                             %
687 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
688 %
689 %  PixelGetColorAsString() returnsd the color of the pixel wand as a string.
690 %
691 %  The format of the PixelGetColorAsString method is:
692 %
693 %      char *PixelGetColorAsString(PixelWand *wand)
694 %
695 %  A description of each parameter follows:
696 %
697 %    o wand: the pixel wand.
698 %
699 */
PixelGetColorAsString(const PixelWand * wand)700 WandExport char *PixelGetColorAsString(const PixelWand *wand)
701 {
702   char
703     *color;
704 
705   PixelInfo
706     pixel;
707 
708   assert(wand != (const PixelWand *) NULL);
709   assert(wand->signature == MagickWandSignature);
710   if (wand->debug != MagickFalse)
711     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
712   pixel=wand->pixel;
713   color=AcquireString((const char *) NULL);
714   GetColorTuple(&pixel,MagickFalse,color);
715   return(color);
716 }
717 
718 /*
719 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
720 %                                                                             %
721 %                                                                             %
722 %                                                                             %
723 %   P i x e l G e t C o l o r A s N o r m a l i z e d S t r i n g             %
724 %                                                                             %
725 %                                                                             %
726 %                                                                             %
727 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
728 %
729 %  PixelGetColorAsNormalizedString() returns the normalized color of the pixel
730 %  wand as a string.
731 %
732 %  The format of the PixelGetColorAsNormalizedString method is:
733 %
734 %      char *PixelGetColorAsNormalizedString(PixelWand *wand)
735 %
736 %  A description of each parameter follows:
737 %
738 %    o wand: the pixel wand.
739 %
740 */
PixelGetColorAsNormalizedString(const PixelWand * wand)741 WandExport char *PixelGetColorAsNormalizedString(const PixelWand *wand)
742 {
743   char
744     color[2*MagickPathExtent];
745 
746   assert(wand != (const PixelWand *) NULL);
747   assert(wand->signature == MagickWandSignature);
748   if (wand->debug != MagickFalse)
749     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
750   (void) FormatLocaleString(color,MagickPathExtent,"%g,%g,%g",(double)
751     (QuantumScale*wand->pixel.red),(double) (QuantumScale*wand->pixel.green),
752     (double) (QuantumScale*wand->pixel.blue));
753   if (wand->pixel.colorspace == CMYKColorspace)
754     (void) FormatLocaleString(color+strlen(color),MagickPathExtent,",%g",
755       (double) (QuantumScale*wand->pixel.black));
756   if (wand->pixel.alpha_trait != UndefinedPixelTrait)
757     (void) FormatLocaleString(color+strlen(color),MagickPathExtent,",%g",
758       (double) (QuantumScale*wand->pixel.alpha));
759   return(ConstantString(color));
760 }
761 
762 /*
763 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
764 %                                                                             %
765 %                                                                             %
766 %                                                                             %
767 %   P i x e l G e t C o l o r C o u n t                                       %
768 %                                                                             %
769 %                                                                             %
770 %                                                                             %
771 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
772 %
773 %  PixelGetColorCount() returns the color count associated with this color.
774 %
775 %  The format of the PixelGetColorCount method is:
776 %
777 %      size_t PixelGetColorCount(const PixelWand *wand)
778 %
779 %  A description of each parameter follows:
780 %
781 %    o wand: the pixel wand.
782 %
783 */
PixelGetColorCount(const PixelWand * wand)784 WandExport size_t PixelGetColorCount(const PixelWand *wand)
785 {
786   assert(wand != (const PixelWand *) NULL);
787   assert(wand->signature == MagickWandSignature);
788   if (wand->debug != MagickFalse)
789     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
790   return(wand->count);
791 }
792 
793 /*
794 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
795 %                                                                             %
796 %                                                                             %
797 %                                                                             %
798 %   P i x e l G e t C y a n                                                   %
799 %                                                                             %
800 %                                                                             %
801 %                                                                             %
802 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
803 %
804 %  PixelGetCyan() returns the normalized cyan color of the pixel wand.
805 %
806 %  The format of the PixelGetCyan method is:
807 %
808 %      double PixelGetCyan(const PixelWand *wand)
809 %
810 %  A description of each parameter follows:
811 %
812 %    o wand: the pixel wand.
813 %
814 */
PixelGetCyan(const PixelWand * wand)815 WandExport double PixelGetCyan(const PixelWand *wand)
816 {
817   assert(wand != (const PixelWand *) NULL);
818   assert(wand->signature == MagickWandSignature);
819   if (wand->debug != MagickFalse)
820     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
821   return((double) QuantumScale*wand->pixel.red);
822 }
823 
824 /*
825 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
826 %                                                                             %
827 %                                                                             %
828 %                                                                             %
829 %   P i x e l G e t C y a n Q u a n t u m                                     %
830 %                                                                             %
831 %                                                                             %
832 %                                                                             %
833 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
834 %
835 %  PixelGetCyanQuantum() returns the cyan color of the pixel wand.
836 %
837 %  The format of the PixelGetCyanQuantum method is:
838 %
839 %      Quantum PixelGetCyanQuantum(const PixelWand *wand)
840 %
841 %  A description of each parameter follows:
842 %
843 %    o wand: the pixel wand.
844 %
845 */
PixelGetCyanQuantum(const PixelWand * wand)846 WandExport Quantum PixelGetCyanQuantum(const PixelWand *wand)
847 {
848   assert(wand != (const PixelWand *) NULL);
849   assert(wand->signature == MagickWandSignature);
850   if (wand->debug != MagickFalse)
851     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
852   return(ClampToQuantum(wand->pixel.red));
853 }
854 
855 /*
856 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
857 %                                                                             %
858 %                                                                             %
859 %                                                                             %
860 %   P i x e l G e t E x c e p t i o n                                         %
861 %                                                                             %
862 %                                                                             %
863 %                                                                             %
864 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
865 %
866 %  PixelGetException() returns the severity, reason, and description of any
867 %  error that occurs when using other methods in this API.
868 %
869 %  The format of the PixelGetException method is:
870 %
871 %      char *PixelGetException(const PixelWand *wand,ExceptionType *severity)
872 %
873 %  A description of each parameter follows:
874 %
875 %    o wand: the pixel wand.
876 %
877 %    o severity: the severity of the error is returned here.
878 %
879 */
PixelGetException(const PixelWand * wand,ExceptionType * severity)880 WandExport char *PixelGetException(const PixelWand *wand,
881   ExceptionType *severity)
882 {
883   char
884     *description;
885 
886   assert(wand != (const PixelWand *) NULL);
887   assert(wand->signature == MagickWandSignature);
888   if (wand->debug != MagickFalse)
889     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
890   assert(severity != (ExceptionType *) NULL);
891   *severity=wand->exception->severity;
892   description=(char *) AcquireQuantumMemory(2UL*MagickPathExtent,
893     sizeof(*description));
894   if (description == (char *) NULL)
895     ThrowWandFatalException(ResourceLimitFatalError,"MemoryAllocationFailed",
896       wand->name);
897   *description='\0';
898   if (wand->exception->reason != (char *) NULL)
899     (void) CopyMagickString(description,GetLocaleExceptionMessage(
900       wand->exception->severity,wand->exception->reason),MagickPathExtent);
901   if (wand->exception->description != (char *) NULL)
902     {
903       (void) ConcatenateMagickString(description," (",MagickPathExtent);
904       (void) ConcatenateMagickString(description,GetLocaleExceptionMessage(
905         wand->exception->severity,wand->exception->description),
906         MagickPathExtent);
907       (void) ConcatenateMagickString(description,")",MagickPathExtent);
908     }
909   return(description);
910 }
911 
912 /*
913 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
914 %                                                                             %
915 %                                                                             %
916 %                                                                             %
917 %   P i x e l G e t E x c e p t i o n T y p e                                 %
918 %                                                                             %
919 %                                                                             %
920 %                                                                             %
921 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
922 %
923 %  PixelGetExceptionType() the exception type associated with the wand.  If
924 %  no exception has occurred, UndefinedExceptionType is returned.
925 %
926 %  The format of the PixelGetExceptionType method is:
927 %
928 %      ExceptionType PixelGetExceptionType(const PixelWand *wand)
929 %
930 %  A description of each parameter follows:
931 %
932 %    o wand: the magick wand.
933 %
934 */
PixelGetExceptionType(const PixelWand * wand)935 WandExport ExceptionType PixelGetExceptionType(const PixelWand *wand)
936 {
937   assert(wand != (const PixelWand *) NULL);
938   assert(wand->signature == MagickWandSignature);
939   if (wand->debug != MagickFalse)
940     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
941   return(wand->exception->severity);
942 }
943 
944 /*
945 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
946 %                                                                             %
947 %                                                                             %
948 %                                                                             %
949 %   P i x e l G e t F u z z                                                   %
950 %                                                                             %
951 %                                                                             %
952 %                                                                             %
953 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
954 %
955 %  PixelGetFuzz() returns the normalized fuzz value of the pixel wand.
956 %
957 %  The format of the PixelGetFuzz method is:
958 %
959 %      double PixelGetFuzz(const PixelWand *wand)
960 %
961 %  A description of each parameter follows:
962 %
963 %    o wand: the pixel wand.
964 %
965 */
PixelGetFuzz(const PixelWand * wand)966 WandExport double PixelGetFuzz(const PixelWand *wand)
967 {
968   assert(wand != (const PixelWand *) NULL);
969   assert(wand->signature == MagickWandSignature);
970   if (wand->debug != MagickFalse)
971     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
972   return((double) wand->pixel.fuzz);
973 }
974 
975 /*
976 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
977 %                                                                             %
978 %                                                                             %
979 %                                                                             %
980 %   P i x e l G e t G r e e n                                                 %
981 %                                                                             %
982 %                                                                             %
983 %                                                                             %
984 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
985 %
986 %  PixelGetGreen() returns the normalized green color of the pixel wand.
987 %
988 %  The format of the PixelGetGreen method is:
989 %
990 %      double PixelGetGreen(const PixelWand *wand)
991 %
992 %  A description of each parameter follows:
993 %
994 %    o wand: the pixel wand.
995 %
996 */
PixelGetGreen(const PixelWand * wand)997 WandExport double PixelGetGreen(const PixelWand *wand)
998 {
999   assert(wand != (const PixelWand *) NULL);
1000   assert(wand->signature == MagickWandSignature);
1001   if (wand->debug != MagickFalse)
1002     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1003   return((double) QuantumScale*wand->pixel.green);
1004 }
1005 
1006 /*
1007 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1008 %                                                                             %
1009 %                                                                             %
1010 %                                                                             %
1011 %   P i x e l G e t G r e e n Q u a n t u m                                   %
1012 %                                                                             %
1013 %                                                                             %
1014 %                                                                             %
1015 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1016 %
1017 %  PixelGetGreenQuantum() returns the green color of the pixel wand.
1018 %
1019 %  The format of the PixelGetGreenQuantum method is:
1020 %
1021 %      Quantum PixelGetGreenQuantum(const PixelWand *wand)
1022 %
1023 %  A description of each parameter follows:
1024 %
1025 %    o wand: the pixel wand.
1026 %
1027 */
PixelGetGreenQuantum(const PixelWand * wand)1028 WandExport Quantum PixelGetGreenQuantum(const PixelWand *wand)
1029 {
1030   assert(wand != (const PixelWand *) NULL);
1031   assert(wand->signature == MagickWandSignature);
1032   if (wand->debug != MagickFalse)
1033     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1034   return(ClampToQuantum(wand->pixel.green));
1035 }
1036 
1037 /*
1038 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1039 %                                                                             %
1040 %                                                                             %
1041 %                                                                             %
1042 %   P i x e l G e t H S L                                                     %
1043 %                                                                             %
1044 %                                                                             %
1045 %                                                                             %
1046 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1047 %
1048 %  PixelGetHSL() returns the normalized HSL color of the pixel wand.
1049 %
1050 %  The format of the PixelGetHSL method is:
1051 %
1052 %      void PixelGetHSL(const PixelWand *wand,double *hue,double *saturation,
1053 %        double *lightness)
1054 %
1055 %  A description of each parameter follows:
1056 %
1057 %    o wand: the pixel wand.
1058 %
1059 %    o hue,saturation,lightness: Return the pixel hue, saturation, and
1060 %      brightness.
1061 %
1062 */
PixelGetHSL(const PixelWand * wand,double * hue,double * saturation,double * lightness)1063 WandExport void PixelGetHSL(const PixelWand *wand,double *hue,
1064   double *saturation,double *lightness)
1065 {
1066   assert(wand != (const PixelWand *) NULL);
1067   assert(wand->signature == MagickWandSignature);
1068   if (wand->debug != MagickFalse)
1069     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1070   ConvertRGBToHSL((double) ClampToQuantum(wand->pixel.red),(double)
1071     ClampToQuantum(wand->pixel.green),(double) ClampToQuantum(wand->pixel.blue),
1072     hue,saturation,lightness);
1073 }
1074 
1075 /*
1076 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1077 %                                                                             %
1078 %                                                                             %
1079 %                                                                             %
1080 %   P i x e l G e t I n d e x                                                 %
1081 %                                                                             %
1082 %                                                                             %
1083 %                                                                             %
1084 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1085 %
1086 %  PixelGetIndex() returns the colormap index from the pixel wand.
1087 %
1088 %  The format of the PixelGetIndex method is:
1089 %
1090 %      Quantum PixelGetIndex(const PixelWand *wand)
1091 %
1092 %  A description of each parameter follows:
1093 %
1094 %    o wand: the pixel wand.
1095 %
1096 */
PixelGetIndex(const PixelWand * wand)1097 WandExport Quantum PixelGetIndex(const PixelWand *wand)
1098 {
1099   assert(wand != (const PixelWand *) NULL);
1100   assert(wand->signature == MagickWandSignature);
1101   if (wand->debug != MagickFalse)
1102     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1103   return((Quantum) wand->pixel.black);
1104 }
1105 
1106 /*
1107 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1108 %                                                                             %
1109 %                                                                             %
1110 %                                                                             %
1111 %   P i x e l G e t M a g e n t a                                             %
1112 %                                                                             %
1113 %                                                                             %
1114 %                                                                             %
1115 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1116 %
1117 %  PixelGetMagenta() returns the normalized magenta color of the pixel wand.
1118 %
1119 %  The format of the PixelGetMagenta method is:
1120 %
1121 %      double PixelGetMagenta(const PixelWand *wand)
1122 %
1123 %  A description of each parameter follows:
1124 %
1125 %    o wand: the pixel wand.
1126 %
1127 */
PixelGetMagenta(const PixelWand * wand)1128 WandExport double PixelGetMagenta(const PixelWand *wand)
1129 {
1130   assert(wand != (const PixelWand *) NULL);
1131   assert(wand->signature == MagickWandSignature);
1132   if (wand->debug != MagickFalse)
1133     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1134   return((double) QuantumScale*wand->pixel.green);
1135 }
1136 
1137 /*
1138 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1139 %                                                                             %
1140 %                                                                             %
1141 %                                                                             %
1142 %   P i x e l G e t M a g e n t a Q u a n t u m                               %
1143 %                                                                             %
1144 %                                                                             %
1145 %                                                                             %
1146 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1147 %
1148 %  PixelGetMagentaQuantum() returns the magenta color of the pixel wand.
1149 %
1150 %  The format of the PixelGetMagentaQuantum method is:
1151 %
1152 %      Quantum PixelGetMagentaQuantum(const PixelWand *wand)
1153 %
1154 %  A description of each parameter follows:
1155 %
1156 %    o wand: the pixel wand.
1157 %
1158 */
PixelGetMagentaQuantum(const PixelWand * wand)1159 WandExport Quantum PixelGetMagentaQuantum(const PixelWand *wand)
1160 {
1161   assert(wand != (const PixelWand *) NULL);
1162   assert(wand->signature == MagickWandSignature);
1163   if (wand->debug != MagickFalse)
1164     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1165   return(ClampToQuantum(wand->pixel.green));
1166 }
1167 
1168 /*
1169 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1170 %                                                                             %
1171 %                                                                             %
1172 %                                                                             %
1173 %   P i x e l G e t M a g i c k C o l o r                                     %
1174 %                                                                             %
1175 %                                                                             %
1176 %                                                                             %
1177 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1178 %
1179 %  PixelGetMagickColor() gets the magick color of the pixel wand.
1180 %
1181 %  The format of the PixelGetMagickColor method is:
1182 %
1183 %      void PixelGetMagickColor(PixelWand *wand,PixelInfo *color)
1184 %
1185 %  A description of each parameter follows:
1186 %
1187 %    o wand: the pixel wand.
1188 %
1189 %    o color:  The pixel wand color is returned here.
1190 %
1191 */
PixelGetMagickColor(const PixelWand * wand,PixelInfo * color)1192 WandExport void PixelGetMagickColor(const PixelWand *wand,
1193   PixelInfo *color)
1194 {
1195   assert(wand != (const PixelWand *) NULL);
1196   assert(wand->signature == MagickWandSignature);
1197   if (wand->debug != MagickFalse)
1198     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1199   assert(color != (PixelInfo *) NULL);
1200   *color=wand->pixel;
1201 }
1202 
1203 /*
1204 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1205 %                                                                             %
1206 %                                                                             %
1207 %                                                                             %
1208 %   P i x e l G e t P i x e l                                                 %
1209 %                                                                             %
1210 %                                                                             %
1211 %                                                                             %
1212 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1213 %
1214 %  PixelGetPixel() returns the pixel wand pixel.
1215 %
1216 %  The format of the PixelGetPixel method is:
1217 %
1218 %      PixelInfo PixelGetPixel(const PixelWand *wand)
1219 %
1220 %  A description of each parameter follows:
1221 %
1222 %    o wand: the pixel wand.
1223 %
1224 */
PixelGetPixel(const PixelWand * wand)1225 WandExport PixelInfo PixelGetPixel(const PixelWand *wand)
1226 {
1227   assert(wand != (const PixelWand *) NULL);
1228   assert(wand->signature == MagickWandSignature);
1229   if (wand->debug != MagickFalse)
1230     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1231   return(wand->pixel);
1232 }
1233 
1234 /*
1235 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1236 %                                                                             %
1237 %                                                                             %
1238 %                                                                             %
1239 %   P i x e l G e t Q u a n t u m P a c k e t                                 %
1240 %                                                                             %
1241 %                                                                             %
1242 %                                                                             %
1243 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1244 %
1245 %  PixelGetQuantumPacket() gets the packet of the pixel wand as a PixelInfo.
1246 %
1247 %  The format of the PixelGetQuantumPacket method is:
1248 %
1249 %      void PixelGetQuantumPacket(PixelWand *wand,PixelInfo *packet)
1250 %
1251 %  A description of each parameter follows:
1252 %
1253 %    o wand: the pixel wand.
1254 %
1255 %    o packet:  The pixel wand packet is returned here.
1256 %
1257 */
PixelGetQuantumPacket(const PixelWand * wand,PixelInfo * packet)1258 WandExport void PixelGetQuantumPacket(const PixelWand *wand,PixelInfo *packet)
1259 {
1260   assert(wand != (const PixelWand *) NULL);
1261   assert(wand->signature == MagickWandSignature);
1262   if (wand->debug != MagickFalse)
1263     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1264   assert(packet != (PixelInfo *) NULL);
1265   packet->storage_class=wand->pixel.storage_class;
1266   packet->colorspace=wand->pixel.colorspace;
1267   packet->depth=wand->pixel.depth;
1268   packet->fuzz=wand->pixel.fuzz;
1269   packet->count=wand->pixel.count;
1270   packet->index=wand->pixel.index;
1271   packet->alpha=(double) ClampToQuantum(wand->pixel.alpha);
1272   packet->alpha_trait=wand->pixel.alpha_trait;
1273   if (wand->pixel.colorspace == CMYKColorspace)
1274     {
1275       packet->red=(double) ClampToQuantum(QuantumRange-(wand->pixel.red*
1276         (QuantumRange-wand->pixel.black)+wand->pixel.black));
1277       packet->green=(double) ClampToQuantum(QuantumRange-(wand->pixel.green*
1278         (QuantumRange-wand->pixel.black)+wand->pixel.black));
1279       packet->blue=(double) ClampToQuantum(QuantumRange-(wand->pixel.blue*
1280         (QuantumRange-wand->pixel.black)+wand->pixel.black));
1281       packet->black=(double) ClampToQuantum(wand->pixel.black);
1282       return;
1283     }
1284   packet->red=(double) ClampToQuantum(wand->pixel.red);
1285   packet->green=(double) ClampToQuantum(wand->pixel.green);
1286   packet->blue=(double) ClampToQuantum(wand->pixel.blue);
1287 }
1288 
1289 /*
1290 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1291 %                                                                             %
1292 %                                                                             %
1293 %                                                                             %
1294 %   P i x e l G e t Q u a n t u m P i x e l                                   %
1295 %                                                                             %
1296 %                                                                             %
1297 %                                                                             %
1298 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1299 %
1300 %  PixelGetQuantumPixel() gets the pixel of the pixel wand as a PixelInfo.
1301 %
1302 %  The format of the PixelGetQuantumPixel method is:
1303 %
1304 %      void PixelGetQuantumPixel(const Image *image,const PixelWand *wand,
1305 %        Quantum *pixel)
1306 %
1307 %  A description of each parameter follows:
1308 %
1309 %    o wand: the pixel wand.
1310 %
1311 %    o pixel:  The pixel wand pixel is returned here.
1312 %
1313 */
PixelGetQuantumPixel(const Image * image,const PixelWand * wand,Quantum * pixel)1314 WandExport void PixelGetQuantumPixel(const Image *image,const PixelWand *wand,
1315   Quantum *pixel)
1316 {
1317   assert(wand != (const PixelWand *) NULL);
1318   assert(wand->signature == MagickWandSignature);
1319   if (wand->debug != MagickFalse)
1320     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1321   assert(pixel != (Quantum *) NULL);
1322   SetPixelAlpha(image,ClampToQuantum(wand->pixel.alpha),pixel);
1323   if (wand->pixel.colorspace == CMYKColorspace)
1324     {
1325       SetPixelRed(image,ClampToQuantum(QuantumRange-
1326         (wand->pixel.red*(QuantumRange-wand->pixel.black)+wand->pixel.black)),
1327         pixel);
1328       SetPixelGreen(image,ClampToQuantum(QuantumRange-
1329         (wand->pixel.green*(QuantumRange-wand->pixel.black)+wand->pixel.black)),
1330         pixel);
1331       SetPixelBlue(image,ClampToQuantum(QuantumRange-
1332         (wand->pixel.blue*(QuantumRange-wand->pixel.black)+wand->pixel.black)),
1333         pixel);
1334       SetPixelBlack(image,ClampToQuantum(wand->pixel.black),pixel);
1335       return;
1336     }
1337   SetPixelRed(image,ClampToQuantum(wand->pixel.red),pixel);
1338   SetPixelGreen(image,ClampToQuantum(wand->pixel.green),pixel);
1339   SetPixelBlue(image,ClampToQuantum(wand->pixel.blue),pixel);
1340 }
1341 
1342 /*
1343 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1344 %                                                                             %
1345 %                                                                             %
1346 %                                                                             %
1347 %   P i x e l G e t R e d                                                     %
1348 %                                                                             %
1349 %                                                                             %
1350 %                                                                             %
1351 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1352 %
1353 %  PixelGetRed() returns the normalized red color of the pixel wand.
1354 %
1355 %  The format of the PixelGetRed method is:
1356 %
1357 %      double PixelGetRed(const PixelWand *wand)
1358 %
1359 %  A description of each parameter follows:
1360 %
1361 %    o wand: the pixel wand.
1362 %
1363 */
PixelGetRed(const PixelWand * wand)1364 WandExport double PixelGetRed(const PixelWand *wand)
1365 {
1366   assert(wand != (const PixelWand *) NULL);
1367   assert(wand->signature == MagickWandSignature);
1368   if (wand->debug != MagickFalse)
1369     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1370   return((double) QuantumScale*wand->pixel.red);
1371 }
1372 
1373 /*
1374 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1375 %                                                                             %
1376 %                                                                             %
1377 %                                                                             %
1378 %   P i x e l G e t R e d Q u a n t u m                                       %
1379 %                                                                             %
1380 %                                                                             %
1381 %                                                                             %
1382 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1383 %
1384 %  PixelGetRedQuantum() returns the red color of the pixel wand.
1385 %
1386 %  The format of the PixelGetRedQuantum method is:
1387 %
1388 %      Quantum PixelGetRedQuantum(const PixelWand *wand)
1389 %
1390 %  A description of each parameter follows:
1391 %
1392 %    o wand: the pixel wand.
1393 %
1394 */
PixelGetRedQuantum(const PixelWand * wand)1395 WandExport Quantum PixelGetRedQuantum(const PixelWand *wand)
1396 {
1397   assert(wand != (const PixelWand *) NULL);
1398   assert(wand->signature == MagickWandSignature);
1399   if (wand->debug != MagickFalse)
1400     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1401   return(ClampToQuantum(wand->pixel.red));
1402 }
1403 
1404 /*
1405 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1406 %                                                                             %
1407 %                                                                             %
1408 %                                                                             %
1409 %   P i x e l G e t Y e l l o w                                               %
1410 %                                                                             %
1411 %                                                                             %
1412 %                                                                             %
1413 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1414 %
1415 %  PixelGetYellow() returns the normalized yellow color of the pixel wand.
1416 %
1417 %  The format of the PixelGetYellow method is:
1418 %
1419 %      double PixelGetYellow(const PixelWand *wand)
1420 %
1421 %  A description of each parameter follows:
1422 %
1423 %    o wand: the pixel wand.
1424 %
1425 */
PixelGetYellow(const PixelWand * wand)1426 WandExport double PixelGetYellow(const PixelWand *wand)
1427 {
1428   assert(wand != (const PixelWand *) NULL);
1429   assert(wand->signature == MagickWandSignature);
1430   if (wand->debug != MagickFalse)
1431     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1432   return((double) QuantumScale*wand->pixel.blue);
1433 }
1434 
1435 /*
1436 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1437 %                                                                             %
1438 %                                                                             %
1439 %                                                                             %
1440 %   P i x e l G e t Y e l l o w Q u a n t u m                                 %
1441 %                                                                             %
1442 %                                                                             %
1443 %                                                                             %
1444 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1445 %
1446 %  PixelGetYellowQuantum() returns the yellow color of the pixel wand.
1447 %
1448 %  The format of the PixelGetYellowQuantum method is:
1449 %
1450 %      Quantum PixelGetYellowQuantum(const PixelWand *wand)
1451 %
1452 %  A description of each parameter follows:
1453 %
1454 %    o wand: the pixel wand.
1455 %
1456 */
PixelGetYellowQuantum(const PixelWand * wand)1457 WandExport Quantum PixelGetYellowQuantum(const PixelWand *wand)
1458 {
1459   assert(wand != (const PixelWand *) NULL);
1460   assert(wand->signature == MagickWandSignature);
1461   if (wand->debug != MagickFalse)
1462     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1463   return(ClampToQuantum(wand->pixel.blue));
1464 }
1465 
1466 /*
1467 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1468 %                                                                             %
1469 %                                                                             %
1470 %                                                                             %
1471 %   P i x e l S e t A l p h a                                                 %
1472 %                                                                             %
1473 %                                                                             %
1474 %                                                                             %
1475 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1476 %
1477 %  PixelSetAlpha() sets the normalized alpha value of the pixel wand.
1478 %
1479 %  The format of the PixelSetAlpha method is:
1480 %
1481 %      void PixelSetAlpha(PixelWand *wand,const double alpha)
1482 %
1483 %  A description of each parameter follows:
1484 %
1485 %    o wand: the pixel wand.
1486 %
1487 %    o alpha: the level of transparency: 1.0 is fully opaque and 0.0 is fully
1488 %      transparent.
1489 %
1490 */
PixelSetAlpha(PixelWand * wand,const double alpha)1491 WandExport void PixelSetAlpha(PixelWand *wand,const double alpha)
1492 {
1493   assert(wand != (const PixelWand *) NULL);
1494   assert(wand->signature == MagickWandSignature);
1495   if (wand->debug != MagickFalse)
1496     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1497   wand->pixel.alpha=(double) ClampToQuantum(QuantumRange*alpha);
1498 }
1499 
1500 /*
1501 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1502 %                                                                             %
1503 %                                                                             %
1504 %                                                                             %
1505 %   P i x e l S e t A l p h a Q u a n t u m                                   %
1506 %                                                                             %
1507 %                                                                             %
1508 %                                                                             %
1509 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1510 %
1511 %  PixelSetAlphaQuantum() sets the alpha value of the pixel wand.
1512 %
1513 %  The format of the PixelSetAlphaQuantum method is:
1514 %
1515 %      void PixelSetAlphaQuantum(PixelWand *wand,const Quantum alpha)
1516 %
1517 %  A description of each parameter follows:
1518 %
1519 %    o wand: the pixel wand.
1520 %
1521 %    o alpha: the alpha value.
1522 %
1523 */
PixelSetAlphaQuantum(PixelWand * wand,const Quantum alpha)1524 WandExport void PixelSetAlphaQuantum(PixelWand *wand,const Quantum alpha)
1525 {
1526   assert(wand != (const PixelWand *) NULL);
1527   assert(wand->signature == MagickWandSignature);
1528   if (wand->debug != MagickFalse)
1529     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1530   wand->pixel.alpha=(double) alpha;
1531 }
1532 
1533 /*
1534 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1535 %                                                                             %
1536 %                                                                             %
1537 %                                                                             %
1538 %   P i x e l S e t B l a c k                                                 %
1539 %                                                                             %
1540 %                                                                             %
1541 %                                                                             %
1542 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1543 %
1544 %  PixelSetBlack() sets the normalized black color of the pixel wand.
1545 %
1546 %  The format of the PixelSetBlack method is:
1547 %
1548 %      void PixelSetBlack(PixelWand *wand,const double black)
1549 %
1550 %  A description of each parameter follows:
1551 %
1552 %    o wand: the pixel wand.
1553 %
1554 %    o black: the black color.
1555 %
1556 */
PixelSetBlack(PixelWand * wand,const double black)1557 WandExport void PixelSetBlack(PixelWand *wand,const double black)
1558 {
1559   assert(wand != (const PixelWand *) NULL);
1560   assert(wand->signature == MagickWandSignature);
1561   if (wand->debug != MagickFalse)
1562     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1563   wand->pixel.black=(double) ClampToQuantum(QuantumRange*black);
1564 }
1565 
1566 /*
1567 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1568 %                                                                             %
1569 %                                                                             %
1570 %                                                                             %
1571 %   P i x e l S e t B l a c k Q u a n t u m                                   %
1572 %                                                                             %
1573 %                                                                             %
1574 %                                                                             %
1575 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1576 %
1577 %  PixelSetBlackQuantum() sets the black color of the pixel wand.
1578 %
1579 %  The format of the PixelSetBlackQuantum method is:
1580 %
1581 %      void PixelSetBlackQuantum(PixelWand *wand,const Quantum black)
1582 %
1583 %  A description of each parameter follows:
1584 %
1585 %    o wand: the pixel wand.
1586 %
1587 %    o black: the black color.
1588 %
1589 */
PixelSetBlackQuantum(PixelWand * wand,const Quantum black)1590 WandExport void PixelSetBlackQuantum(PixelWand *wand,const Quantum black)
1591 {
1592   assert(wand != (const PixelWand *) NULL);
1593   assert(wand->signature == MagickWandSignature);
1594   if (wand->debug != MagickFalse)
1595     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1596   wand->pixel.black=(double) black;
1597 }
1598 
1599 /*
1600 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1601 %                                                                             %
1602 %                                                                             %
1603 %                                                                             %
1604 %   P i x e l S e t B l u e                                                   %
1605 %                                                                             %
1606 %                                                                             %
1607 %                                                                             %
1608 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1609 %
1610 %  PixelSetBlue() sets the normalized blue color of the pixel wand.
1611 %
1612 %  The format of the PixelSetBlue method is:
1613 %
1614 %      void PixelSetBlue(PixelWand *wand,const double blue)
1615 %
1616 %  A description of each parameter follows:
1617 %
1618 %    o wand: the pixel wand.
1619 %
1620 %    o blue: the blue color.
1621 %
1622 */
PixelSetBlue(PixelWand * wand,const double blue)1623 WandExport void PixelSetBlue(PixelWand *wand,const double blue)
1624 {
1625   assert(wand != (const PixelWand *) NULL);
1626   assert(wand->signature == MagickWandSignature);
1627   if (wand->debug != MagickFalse)
1628     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1629   wand->pixel.blue=(double) ClampToQuantum(QuantumRange*blue);
1630 }
1631 
1632 /*
1633 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1634 %                                                                             %
1635 %                                                                             %
1636 %                                                                             %
1637 %   P i x e l S e t B l u e Q u a n t u m                                     %
1638 %                                                                             %
1639 %                                                                             %
1640 %                                                                             %
1641 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1642 %
1643 %  PixelSetBlueQuantum() sets the blue color of the pixel wand.
1644 %
1645 %  The format of the PixelSetBlueQuantum method is:
1646 %
1647 %      void PixelSetBlueQuantum(PixelWand *wand,const Quantum blue)
1648 %
1649 %  A description of each parameter follows:
1650 %
1651 %    o wand: the pixel wand.
1652 %
1653 %    o blue: the blue color.
1654 %
1655 */
PixelSetBlueQuantum(PixelWand * wand,const Quantum blue)1656 WandExport void PixelSetBlueQuantum(PixelWand *wand,const Quantum blue)
1657 {
1658   assert(wand != (const PixelWand *) NULL);
1659   assert(wand->signature == MagickWandSignature);
1660   if (wand->debug != MagickFalse)
1661     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1662   wand->pixel.blue=(double) blue;
1663 }
1664 
1665 /*
1666 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1667 %                                                                             %
1668 %                                                                             %
1669 %                                                                             %
1670 %   P i x e l S e t C o l o r                                                 %
1671 %                                                                             %
1672 %                                                                             %
1673 %                                                                             %
1674 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1675 %
1676 %  PixelSetColor() sets the color of the pixel wand with a string (e.g.
1677 %  "blue", "#0000ff", "rgb(0,0,255)", "cmyk(100,100,100,10)", etc.).
1678 %
1679 %  The format of the PixelSetColor method is:
1680 %
1681 %      MagickBooleanType PixelSetColor(PixelWand *wand,const char *color)
1682 %
1683 %  A description of each parameter follows:
1684 %
1685 %    o wand: the pixel wand.
1686 %
1687 %    o color: the pixel wand color.
1688 %
1689 */
PixelSetColor(PixelWand * wand,const char * color)1690 WandExport MagickBooleanType PixelSetColor(PixelWand *wand,const char *color)
1691 {
1692   MagickBooleanType
1693     status;
1694 
1695   PixelInfo
1696     pixel;
1697 
1698   assert(wand != (const PixelWand *) NULL);
1699   assert(wand->signature == MagickWandSignature);
1700   if (wand->debug != MagickFalse)
1701     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1702   status=QueryColorCompliance(color,AllCompliance,&pixel,wand->exception);
1703   if (status != MagickFalse)
1704     wand->pixel=pixel;
1705   return(status);
1706 }
1707 
1708 /*
1709 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1710 %                                                                             %
1711 %                                                                             %
1712 %                                                                             %
1713 %   P i x e l S e t C o l o r C o u n t                                       %
1714 %                                                                             %
1715 %                                                                             %
1716 %                                                                             %
1717 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1718 %
1719 %  PixelSetColorCount() sets the color count of the pixel wand.
1720 %
1721 %  The format of the PixelSetColorCount method is:
1722 %
1723 %      void PixelSetColorCount(PixelWand *wand,const size_t count)
1724 %
1725 %  A description of each parameter follows:
1726 %
1727 %    o wand: the pixel wand.
1728 %
1729 %    o count: the number of this particular color.
1730 %
1731 */
PixelSetColorCount(PixelWand * wand,const size_t count)1732 WandExport void PixelSetColorCount(PixelWand *wand,const size_t count)
1733 {
1734   assert(wand != (const PixelWand *) NULL);
1735   assert(wand->signature == MagickWandSignature);
1736   if (wand->debug != MagickFalse)
1737     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1738   wand->count=count;
1739 }
1740 
1741 /*
1742 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1743 %                                                                             %
1744 %                                                                             %
1745 %                                                                             %
1746 %   P i x e l S e t C o l o r F r o m W a n d                                 %
1747 %                                                                             %
1748 %                                                                             %
1749 %                                                                             %
1750 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1751 %
1752 %  PixelSetColorFromWand() sets the color of the pixel wand.
1753 %
1754 %  The format of the PixelSetColorFromWand method is:
1755 %
1756 %      void PixelSetColorFromWand(PixelWand *wand,const PixelWand *color)
1757 %
1758 %  A description of each parameter follows:
1759 %
1760 %    o wand: the pixel wand.
1761 %
1762 %    o color: set the pixel wand color here.
1763 %
1764 */
PixelSetColorFromWand(PixelWand * wand,const PixelWand * color)1765 WandExport void PixelSetColorFromWand(PixelWand *wand,const PixelWand *color)
1766 {
1767   assert(wand != (const PixelWand *) NULL);
1768   assert(wand->signature == MagickWandSignature);
1769   if (wand->debug != MagickFalse)
1770     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1771   assert(color != (const PixelWand *) NULL);
1772   wand->pixel=color->pixel;
1773 }
1774 
1775 /*
1776 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1777 %                                                                             %
1778 %                                                                             %
1779 %                                                                             %
1780 %   P i x e l S e t C y a n                                                   %
1781 %                                                                             %
1782 %                                                                             %
1783 %                                                                             %
1784 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1785 %
1786 %  PixelSetCyan() sets the normalized cyan color of the pixel wand.
1787 %
1788 %  The format of the PixelSetCyan method is:
1789 %
1790 %      void PixelSetCyan(PixelWand *wand,const double cyan)
1791 %
1792 %  A description of each parameter follows:
1793 %
1794 %    o wand: the pixel wand.
1795 %
1796 %    o cyan: the cyan color.
1797 %
1798 */
PixelSetCyan(PixelWand * wand,const double cyan)1799 WandExport void PixelSetCyan(PixelWand *wand,const double cyan)
1800 {
1801   assert(wand != (const PixelWand *) NULL);
1802   assert(wand->signature == MagickWandSignature);
1803   if (wand->debug != MagickFalse)
1804     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1805   wand->pixel.red=(double) ClampToQuantum(QuantumRange*cyan);
1806 }
1807 
1808 /*
1809 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1810 %                                                                             %
1811 %                                                                             %
1812 %                                                                             %
1813 %   P i x e l S e t C y a n Q u a n t u m                                     %
1814 %                                                                             %
1815 %                                                                             %
1816 %                                                                             %
1817 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1818 %
1819 %  PixelSetCyanQuantum() sets the cyan color of the pixel wand.
1820 %
1821 %  The format of the PixelSetCyanQuantum method is:
1822 %
1823 %      void PixelSetCyanQuantum(PixelWand *wand,const Quantum cyan)
1824 %
1825 %  A description of each parameter follows:
1826 %
1827 %    o wand: the pixel wand.
1828 %
1829 %    o cyan: the cyan color.
1830 %
1831 */
PixelSetCyanQuantum(PixelWand * wand,const Quantum cyan)1832 WandExport void PixelSetCyanQuantum(PixelWand *wand,const Quantum cyan)
1833 {
1834   assert(wand != (const PixelWand *) NULL);
1835   assert(wand->signature == MagickWandSignature);
1836   if (wand->debug != MagickFalse)
1837     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1838   wand->pixel.red=(double) cyan;
1839 }
1840 
1841 /*
1842 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1843 %                                                                             %
1844 %                                                                             %
1845 %                                                                             %
1846 %   P i x e l S e t F u z z                                                   %
1847 %                                                                             %
1848 %                                                                             %
1849 %                                                                             %
1850 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1851 %
1852 %  PixelSetFuzz() sets the fuzz value of the pixel wand.
1853 %
1854 %  The format of the PixelSetFuzz method is:
1855 %
1856 %      void PixelSetFuzz(PixelWand *wand,const double fuzz)
1857 %
1858 %  A description of each parameter follows:
1859 %
1860 %    o wand: the pixel wand.
1861 %
1862 %    o fuzz: the fuzz value.
1863 %
1864 */
PixelSetFuzz(PixelWand * wand,const double fuzz)1865 WandExport void PixelSetFuzz(PixelWand *wand,const double fuzz)
1866 {
1867   assert(wand != (const PixelWand *) NULL);
1868   assert(wand->signature == MagickWandSignature);
1869   if (wand->debug != MagickFalse)
1870     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1871   wand->pixel.fuzz=(double) fuzz;
1872 }
1873 
1874 /*
1875 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1876 %                                                                             %
1877 %                                                                             %
1878 %                                                                             %
1879 %   P i x e l S e t G r e e n                                                 %
1880 %                                                                             %
1881 %                                                                             %
1882 %                                                                             %
1883 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1884 %
1885 %  PixelSetGreen() sets the normalized green color of the pixel wand.
1886 %
1887 %  The format of the PixelSetGreen method is:
1888 %
1889 %      void PixelSetGreen(PixelWand *wand,const double green)
1890 %
1891 %  A description of each parameter follows:
1892 %
1893 %    o wand: the pixel wand.
1894 %
1895 %    o green: the green color.
1896 %
1897 */
PixelSetGreen(PixelWand * wand,const double green)1898 WandExport void PixelSetGreen(PixelWand *wand,const double green)
1899 {
1900   assert(wand != (const PixelWand *) NULL);
1901   assert(wand->signature == MagickWandSignature);
1902   if (wand->debug != MagickFalse)
1903     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1904   wand->pixel.green=(double) ClampToQuantum(QuantumRange*green);
1905 }
1906 
1907 /*
1908 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1909 %                                                                             %
1910 %                                                                             %
1911 %                                                                             %
1912 %   P i x e l S e t G r e e n Q u a n t u m                                   %
1913 %                                                                             %
1914 %                                                                             %
1915 %                                                                             %
1916 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1917 %
1918 %  PixelSetGreenQuantum() sets the green color of the pixel wand.
1919 %
1920 %  The format of the PixelSetGreenQuantum method is:
1921 %
1922 %      void PixelSetGreenQuantum(PixelWand *wand,const Quantum green)
1923 %
1924 %  A description of each parameter follows:
1925 %
1926 %    o wand: the pixel wand.
1927 %
1928 %    o green: the green color.
1929 %
1930 */
PixelSetGreenQuantum(PixelWand * wand,const Quantum green)1931 WandExport void PixelSetGreenQuantum(PixelWand *wand,const Quantum green)
1932 {
1933   assert(wand != (const PixelWand *) NULL);
1934   assert(wand->signature == MagickWandSignature);
1935   if (wand->debug != MagickFalse)
1936     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1937   wand->pixel.green=(double) green;
1938 }
1939 
1940 /*
1941 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1942 %                                                                             %
1943 %                                                                             %
1944 %                                                                             %
1945 %   P i x e l S e t H S L                                                     %
1946 %                                                                             %
1947 %                                                                             %
1948 %                                                                             %
1949 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1950 %
1951 %  PixelSetHSL() sets the normalized HSL color of the pixel wand.
1952 %
1953 %  The format of the PixelSetHSL method is:
1954 %
1955 %      void PixelSetHSL(PixelWand *wand,const double hue,
1956 %        const double saturation,const double lightness)
1957 %
1958 %  A description of each parameter follows:
1959 %
1960 %    o wand: the pixel wand.
1961 %
1962 %    o hue,saturation,lightness: Return the pixel hue, saturation, and
1963 %      brightness.
1964 %
1965 */
PixelSetHSL(PixelWand * wand,const double hue,const double saturation,const double lightness)1966 WandExport void PixelSetHSL(PixelWand *wand,const double hue,
1967   const double saturation,const double lightness)
1968 {
1969   double
1970     blue,
1971     green,
1972     red;
1973 
1974   assert(wand != (const PixelWand *) NULL);
1975   assert(wand->signature == MagickWandSignature);
1976   if (wand->debug != MagickFalse)
1977     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
1978   ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
1979   wand->pixel.red=(double) red;
1980   wand->pixel.green=(double) green;
1981   wand->pixel.blue=(double) blue;
1982 }
1983 
1984 /*
1985 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1986 %                                                                             %
1987 %                                                                             %
1988 %                                                                             %
1989 %   P i x e l S e t I n d e x                                                 %
1990 %                                                                             %
1991 %                                                                             %
1992 %                                                                             %
1993 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1994 %
1995 %  PixelSetIndex() sets the colormap index of the pixel wand.
1996 %
1997 %  The format of the PixelSetIndex method is:
1998 %
1999 %      void PixelSetIndex(PixelWand *wand,const Quantum index)
2000 %
2001 %  A description of each parameter follows:
2002 %
2003 %    o wand: the pixel wand.
2004 %
2005 %    o index: the colormap index.
2006 %
2007 */
PixelSetIndex(PixelWand * wand,const Quantum index)2008 WandExport void PixelSetIndex(PixelWand *wand,const Quantum index)
2009 {
2010   assert(wand != (const PixelWand *) NULL);
2011   assert(wand->signature == MagickWandSignature);
2012   if (wand->debug != MagickFalse)
2013     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2014   wand->pixel.index=(double) index;
2015 }
2016 
2017 /*
2018 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2019 %                                                                             %
2020 %                                                                             %
2021 %                                                                             %
2022 %   P i x e l S e t M a g e n t a                                             %
2023 %                                                                             %
2024 %                                                                             %
2025 %                                                                             %
2026 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2027 %
2028 %  PixelSetMagenta() sets the normalized magenta color of the pixel wand.
2029 %
2030 %  The format of the PixelSetMagenta method is:
2031 %
2032 %      void PixelSetMagenta(PixelWand *wand,const double magenta)
2033 %
2034 %  A description of each parameter follows:
2035 %
2036 %    o wand: the pixel wand.
2037 %
2038 %    o magenta: the magenta color.
2039 %
2040 */
PixelSetMagenta(PixelWand * wand,const double magenta)2041 WandExport void PixelSetMagenta(PixelWand *wand,const double magenta)
2042 {
2043   assert(wand != (const PixelWand *) NULL);
2044   assert(wand->signature == MagickWandSignature);
2045   if (wand->debug != MagickFalse)
2046     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2047   wand->pixel.green=(double) ClampToQuantum(QuantumRange*magenta);
2048 }
2049 
2050 /*
2051 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2052 %                                                                             %
2053 %                                                                             %
2054 %                                                                             %
2055 %   P i x e l S e t M a g e n t a Q u a n t u m                               %
2056 %                                                                             %
2057 %                                                                             %
2058 %                                                                             %
2059 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2060 %
2061 %  PixelSetMagentaQuantum() sets the magenta color of the pixel wand.
2062 %
2063 %  The format of the PixelSetMagentaQuantum method is:
2064 %
2065 %      void PixelSetMagentaQuantum(PixelWand *wand,
2066 %        const Quantum magenta)
2067 %
2068 %  A description of each parameter follows:
2069 %
2070 %    o wand: the pixel wand.
2071 %
2072 %    o magenta: the green magenta.
2073 %
2074 */
PixelSetMagentaQuantum(PixelWand * wand,const Quantum magenta)2075 WandExport void PixelSetMagentaQuantum(PixelWand *wand,const Quantum magenta)
2076 {
2077   assert(wand != (const PixelWand *) NULL);
2078   assert(wand->signature == MagickWandSignature);
2079   if (wand->debug != MagickFalse)
2080     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2081   wand->pixel.green=(double) magenta;
2082 }
2083 
2084 /*
2085 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2086 %                                                                             %
2087 %                                                                             %
2088 %                                                                             %
2089 %   P i x e l S e t P i x e l C o l o r                                       %
2090 %                                                                             %
2091 %                                                                             %
2092 %                                                                             %
2093 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2094 %
2095 %  PixelSetPixelColor() sets the color of the pixel wand.
2096 %
2097 %  The format of the PixelSetPixelColor method is:
2098 %
2099 %      void PixelSetPixelColor(PixelWand *wand,const PixelInfo *color)
2100 %
2101 %  A description of each parameter follows:
2102 %
2103 %    o wand: the pixel wand.
2104 %
2105 %    o color: the pixel wand color.
2106 %
2107 */
PixelSetPixelColor(PixelWand * wand,const PixelInfo * color)2108 WandExport void PixelSetPixelColor(PixelWand *wand,const PixelInfo *color)
2109 {
2110   assert(wand != (const PixelWand *) NULL);
2111   assert(wand->signature == MagickWandSignature);
2112   if (wand->debug != MagickFalse)
2113     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2114   assert(color != (const PixelInfo *) NULL);
2115   wand->pixel=(*color);
2116 }
2117 
2118 /*
2119 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2120 %                                                                             %
2121 %                                                                             %
2122 %                                                                             %
2123 %   P i x e l S e t Q u a n t u m P i x e l                                   %
2124 %                                                                             %
2125 %                                                                             %
2126 %                                                                             %
2127 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2128 %
2129 %  PixelSetQuantumPixel() sets the pixel of the pixel wand.
2130 %
2131 %  The format of the PixelSetQuantumPixel method is:
2132 %
2133 %      void PixelSetQuantumPixel(const Image *image,const Quantum *pixel,
2134 %        PixelWand *wand)
2135 %
2136 %  A description of each parameter follows:
2137 %
2138 %    o wand: the pixel wand.
2139 %
2140 %    o pixel: the pixel wand pixel.
2141 %
2142 */
PixelSetQuantumPixel(const Image * image,const Quantum * pixel,PixelWand * wand)2143 WandExport void PixelSetQuantumPixel(const Image *image,const Quantum *pixel,
2144   PixelWand *wand)
2145 {
2146   assert(wand != (const PixelWand *) NULL);
2147   assert(wand->signature == MagickWandSignature);
2148   if (wand->debug != MagickFalse)
2149     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2150   assert(pixel != (Quantum *) NULL);
2151   wand->pixel.red=(double) GetPixelRed(image,pixel);
2152   wand->pixel.green=(double) GetPixelGreen(image,pixel);
2153   wand->pixel.blue=(double) GetPixelBlue(image,pixel);
2154   wand->pixel.black=(double) GetPixelBlack(image,pixel);
2155   wand->pixel.alpha=(double) GetPixelAlpha(image,pixel);
2156   wand->pixel.alpha_trait=GetPixelAlpha(image,pixel) != OpaqueAlpha ?
2157     BlendPixelTrait : UndefinedPixelTrait;
2158 }
2159 
2160 /*
2161 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2162 %                                                                             %
2163 %                                                                             %
2164 %                                                                             %
2165 %   P i x e l S e t R e d                                                     %
2166 %                                                                             %
2167 %                                                                             %
2168 %                                                                             %
2169 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2170 %
2171 %  PixelSetRed() sets the normalized red color of the pixel wand.
2172 %
2173 %  The format of the PixelSetRed method is:
2174 %
2175 %      void PixelSetRed(PixelWand *wand,const double red)
2176 %
2177 %  A description of each parameter follows:
2178 %
2179 %    o wand: the pixel wand.
2180 %
2181 %    o red: the red color.
2182 %
2183 */
PixelSetRed(PixelWand * wand,const double red)2184 WandExport void PixelSetRed(PixelWand *wand,const double red)
2185 {
2186   assert(wand != (const PixelWand *) NULL);
2187   assert(wand->signature == MagickWandSignature);
2188   if (wand->debug != MagickFalse)
2189     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2190   wand->pixel.red=(double) ClampToQuantum(QuantumRange*red);
2191 }
2192 
2193 /*
2194 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2195 %                                                                             %
2196 %                                                                             %
2197 %                                                                             %
2198 %   P i x e l S e t R e d Q u a n t u m                                       %
2199 %                                                                             %
2200 %                                                                             %
2201 %                                                                             %
2202 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2203 %
2204 %  PixelSetRedQuantum() sets the red color of the pixel wand.
2205 %
2206 %  The format of the PixelSetRedQuantum method is:
2207 %
2208 %      void PixelSetRedQuantum(PixelWand *wand,const Quantum red)
2209 %
2210 %  A description of each parameter follows:
2211 %
2212 %    o wand: the pixel wand.
2213 %
2214 %    o red: the red color.
2215 %
2216 */
PixelSetRedQuantum(PixelWand * wand,const Quantum red)2217 WandExport void PixelSetRedQuantum(PixelWand *wand,const Quantum red)
2218 {
2219   assert(wand != (const PixelWand *) NULL);
2220   assert(wand->signature == MagickWandSignature);
2221   if (wand->debug != MagickFalse)
2222     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2223   wand->pixel.red=(double) red;
2224 }
2225 
2226 /*
2227 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2228 %                                                                             %
2229 %                                                                             %
2230 %                                                                             %
2231 %   P i x e l S e t Y e l l o w                                               %
2232 %                                                                             %
2233 %                                                                             %
2234 %                                                                             %
2235 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2236 %
2237 %  PixelSetYellow() sets the normalized yellow color of the pixel wand.
2238 %
2239 %  The format of the PixelSetYellow method is:
2240 %
2241 %      void PixelSetYellow(PixelWand *wand,const double yellow)
2242 %
2243 %  A description of each parameter follows:
2244 %
2245 %    o wand: the pixel wand.
2246 %
2247 %    o yellow: the yellow color.
2248 %
2249 */
PixelSetYellow(PixelWand * wand,const double yellow)2250 WandExport void PixelSetYellow(PixelWand *wand,const double yellow)
2251 {
2252   assert(wand != (const PixelWand *) NULL);
2253   assert(wand->signature == MagickWandSignature);
2254   if (wand->debug != MagickFalse)
2255     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2256   wand->pixel.blue=(double) ClampToQuantum(QuantumRange*yellow);
2257 }
2258 
2259 /*
2260 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2261 %                                                                             %
2262 %                                                                             %
2263 %                                                                             %
2264 %   P i x e l S e t Y e l l o w Q u a n t u m                                 %
2265 %                                                                             %
2266 %                                                                             %
2267 %                                                                             %
2268 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2269 %
2270 %  PixelSetYellowQuantum() sets the yellow color of the pixel wand.
2271 %
2272 %  The format of the PixelSetYellowQuantum method is:
2273 %
2274 %      void PixelSetYellowQuantum(PixelWand *wand,const Quantum yellow)
2275 %
2276 %  A description of each parameter follows:
2277 %
2278 %    o wand: the pixel wand.
2279 %
2280 %    o yellow: the yellow color.
2281 %
2282 */
PixelSetYellowQuantum(PixelWand * wand,const Quantum yellow)2283 WandExport void PixelSetYellowQuantum(PixelWand *wand,const Quantum yellow)
2284 {
2285   assert(wand != (const PixelWand *) NULL);
2286   assert(wand->signature == MagickWandSignature);
2287   if (wand->debug != MagickFalse)
2288     (void) LogMagickEvent(WandEvent,GetMagickModule(),"%s",wand->name);
2289   wand->pixel.blue=(double) yellow;
2290 }
2291