]> granicus.if.org Git - imagemagick/blob - MagickCore/gem.c
Make MagickMax()/MagickMin() a macro rather than an inline.
[imagemagick] / MagickCore / gem.c
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %                                                                             %
4 %                                                                             %
5 %                                                                             %
6 %                              GGGG  EEEEE  M   M                             %
7 %                             G      E      MM MM                             %
8 %                             G GG   EEE    M M M                             %
9 %                             G   G  E      M   M                             %
10 %                              GGGG  EEEEE  M   M                             %
11 %                                                                             %
12 %                                                                             %
13 %                    Graphic Gems - Graphic Support Methods                   %
14 %                                                                             %
15 %                               Software Design                               %
16 %                                    Cristy                                   %
17 %                                 August 1996                                 %
18 %                                                                             %
19 %                                                                             %
20 %  Copyright 1999-2015 ImageMagick Studio LLC, a non-profit organization      %
21 %  dedicated to making software imaging solutions freely available.           %
22 %                                                                             %
23 %  You may not use this file except in compliance with the License.  You may  %
24 %  obtain a copy of the License at                                            %
25 %                                                                             %
26 %    http://www.imagemagick.org/script/license.php                            %
27 %                                                                             %
28 %  Unless required by applicable law or agreed to in writing, software        %
29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
31 %  See the License for the specific language governing permissions and        %
32 %  limitations under the License.                                             %
33 %                                                                             %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 %
38 */
39 \f
40 /*
41   Include declarations.
42 */
43 #include "MagickCore/studio.h"
44 #include "MagickCore/color-private.h"
45 #include "MagickCore/draw.h"
46 #include "MagickCore/gem.h"
47 #include "MagickCore/gem-private.h"
48 #include "MagickCore/image.h"
49 #include "MagickCore/image-private.h"
50 #include "MagickCore/log.h"
51 #include "MagickCore/memory_.h"
52 #include "MagickCore/pixel-accessor.h"
53 #include "MagickCore/pixel-private.h"
54 #include "MagickCore/quantum.h"
55 #include "MagickCore/quantum-private.h"
56 #include "MagickCore/random_.h"
57 #include "MagickCore/resize.h"
58 #include "MagickCore/transform.h"
59 #include "MagickCore/signature-private.h"
60 \f
61 /*
62 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
63 %                                                                             %
64 %                                                                             %
65 %                                                                             %
66 %   C o n v e r t H C L T o R G B                                             %
67 %                                                                             %
68 %                                                                             %
69 %                                                                             %
70 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
71 %
72 %  ConvertHCLToRGB() transforms a (hue, chroma, luma) to a (red, green,
73 %  blue) triple.
74 %
75 %  The format of the ConvertHCLToRGBImage method is:
76 %
77 %      void ConvertHCLToRGB(const double hue,const double chroma,
78 %        const double luma,double *red,double *green,double *blue)
79 %
80 %  A description of each parameter follows:
81 %
82 %    o hue, chroma, luma: A double value representing a component of the
83 %      HCL color space.
84 %
85 %    o red, green, blue: A pointer to a pixel component of type Quantum.
86 %
87 */
88 MagickPrivate void ConvertHCLToRGB(const double hue,const double chroma,
89   const double luma,double *red,double *green,double *blue)
90 {
91   double
92     b,
93     c,
94     g,
95     h,
96     m,
97     r,
98     x;
99
100   /*
101     Convert HCL to RGB colorspace.
102   */
103   assert(red != (double *) NULL);
104   assert(green != (double *) NULL);
105   assert(blue != (double *) NULL);
106   h=6.0*hue;
107   c=chroma;
108   x=c*(1.0-fabs(fmod(h,2.0)-1.0));
109   r=0.0;
110   g=0.0;
111   b=0.0;
112   if ((0.0 <= h) && (h < 1.0))
113     {
114       r=c;
115       g=x;
116     }
117   else
118     if ((1.0 <= h) && (h < 2.0))
119       {
120         r=x;
121         g=c;
122       }
123     else
124       if ((2.0 <= h) && (h < 3.0))
125         {
126           g=c;
127           b=x;
128         }
129       else
130         if ((3.0 <= h) && (h < 4.0))
131           {
132             g=x;
133             b=c;
134           }
135         else
136           if ((4.0 <= h) && (h < 5.0))
137             {
138               r=x;
139               b=c;
140             }
141           else
142             if ((5.0 <= h) && (h < 6.0))
143               {
144                 r=c;
145                 b=x;
146               }
147   m=luma-(0.298839*r+0.586811*g+0.114350*b);
148   *red=QuantumRange*(r+m);
149   *green=QuantumRange*(g+m);
150   *blue=QuantumRange*(b+m);
151 }
152 \f
153 /*
154 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
155 %                                                                             %
156 %                                                                             %
157 %                                                                             %
158 %   C o n v e r t H C L p T o R G B                                           %
159 %                                                                             %
160 %                                                                             %
161 %                                                                             %
162 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
163 %
164 %  ConvertHCLpToRGB() transforms a (hue, chroma, luma) to a (red, green,
165 %  blue) triple.  Since HCL colorspace is wider than RGB, we instead choose a
166 %  saturation strategy to project it on the RGB cube.
167 %
168 %  The format of the ConvertHCLpToRGBImage method is:
169 %
170 %      void ConvertHCLpToRGB(const double hue,const double chroma,
171 %        const double luma,double *red,double *green,double *blue)
172 %
173 %  A description of each parameter follows:
174 %
175 %    o hue, chroma, luma: A double value representing a componenet of the
176 %      HCLp color space.
177 %
178 %    o red, green, blue: A pointer to a pixel component of type Quantum.
179 %
180 */
181 MagickPrivate void ConvertHCLpToRGB(const double hue,const double chroma,
182   const double luma,double *red,double *green,double *blue)
183 {
184   double
185     b,
186     c,
187     g,
188     h,
189     m,
190     r,
191     x,
192     z;
193
194   /*
195     Convert HCLp to RGB colorspace.
196   */
197   assert(red != (double *) NULL);
198   assert(green != (double *) NULL);
199   assert(blue != (double *) NULL);
200   h=6.0*hue;
201   c=chroma;
202   x=c*(1.0-fabs(fmod(h,2.0)-1.0));
203   r=0.0;
204   g=0.0;
205   b=0.0;
206   if ((0.0 <= h) && (h < 1.0))
207     {
208       r=c;
209       g=x;
210     }
211   else
212     if ((1.0 <= h) && (h < 2.0))
213       {
214         r=x;
215         g=c;
216       }
217     else
218       if ((2.0 <= h) && (h < 3.0))
219         {
220           g=c;
221           b=x;
222         }
223       else
224         if ((3.0 <= h) && (h < 4.0))
225           {
226             g=x;
227             b=c;
228           }
229         else
230           if ((4.0 <= h) && (h < 5.0))
231             {
232               r=x;
233               b=c;
234             }
235           else
236             if ((5.0 <= h) && (h < 6.0))
237               {
238                 r=c;
239                 b=x;
240               }
241   m=luma-(0.298839*r+0.586811*g+0.114350*b);
242   z=1.0;
243   if (m < 0.0)
244     {
245       z=luma/(luma-m);
246       m=0.0;
247     }
248   else
249     if (m+c > 1.0)
250       {
251         z=(1.0-luma)/(m+c-luma);
252         m=1.0-z*c;
253       }
254   *red=QuantumRange*(z*r+m);
255   *green=QuantumRange*(z*g+m);
256   *blue=QuantumRange*(z*b+m);
257 }
258 \f
259 /*
260 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
261 %                                                                             %
262 %                                                                             %
263 %                                                                             %
264 %   C o n v e r t H S B T o R G B                                             %
265 %                                                                             %
266 %                                                                             %
267 %                                                                             %
268 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
269 %
270 %  ConvertHSBToRGB() transforms a (hue, saturation, brightness) to a (red,
271 %  green, blue) triple.
272 %
273 %  The format of the ConvertHSBToRGBImage method is:
274 %
275 %      void ConvertHSBToRGB(const double hue,const double saturation,
276 %        const double brightness,double *red,double *green,double *blue)
277 %
278 %  A description of each parameter follows:
279 %
280 %    o hue, saturation, brightness: A double value representing a
281 %      component of the HSB color space.
282 %
283 %    o red, green, blue: A pointer to a pixel component of type Quantum.
284 %
285 */
286 MagickPrivate void ConvertHSBToRGB(const double hue,const double saturation,
287   const double brightness,double *red,double *green,double *blue)
288 {
289   double
290     f,
291     h,
292     p,
293     q,
294     t;
295
296   /*
297     Convert HSB to RGB colorspace.
298   */
299   assert(red != (double *) NULL);
300   assert(green != (double *) NULL);
301   assert(blue != (double *) NULL);
302   if (saturation == 0.0)
303     {
304       *red=QuantumRange*brightness;
305       *green=(*red);
306       *blue=(*red);
307       return;
308     }
309   h=6.0*(hue-floor(hue));
310   f=h-floor((double) h);
311   p=brightness*(1.0-saturation);
312   q=brightness*(1.0-saturation*f);
313   t=brightness*(1.0-(saturation*(1.0-f)));
314   switch ((int) h)
315   {
316     case 0:
317     default:
318     {
319       *red=QuantumRange*brightness;
320       *green=QuantumRange*t;
321       *blue=QuantumRange*p;
322       break;
323     }
324     case 1:
325     {
326       *red=QuantumRange*q;
327       *green=QuantumRange*brightness;
328       *blue=QuantumRange*p;
329       break;
330     }
331     case 2:
332     {
333       *red=QuantumRange*p;
334       *green=QuantumRange*brightness;
335       *blue=QuantumRange*t;
336       break;
337     }
338     case 3:
339     {
340       *red=QuantumRange*p;
341       *green=QuantumRange*q;
342       *blue=QuantumRange*brightness;
343       break;
344     }
345     case 4:
346     {
347       *red=QuantumRange*t;
348       *green=QuantumRange*p;
349       *blue=QuantumRange*brightness;
350       break;
351     }
352     case 5:
353     {
354       *red=QuantumRange*brightness;
355       *green=QuantumRange*p;
356       *blue=QuantumRange*q;
357       break;
358     }
359   }
360 }
361 \f
362 /*
363 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
364 %                                                                             %
365 %                                                                             %
366 %                                                                             %
367 %   C o n v e r t H S I T o R G B                                             %
368 %                                                                             %
369 %                                                                             %
370 %                                                                             %
371 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
372 %
373 %  ConvertHSIToRGB() transforms a (hue, saturation, intensity) to a (red,
374 %  green, blue) triple.
375 %
376 %  The format of the ConvertHSIToRGBImage method is:
377 %
378 %      void ConvertHSIToRGB(const double hue,const double saturation,
379 %        const double intensity,double *red,double *green,double *blue)
380 %
381 %  A description of each parameter follows:
382 %
383 %    o hue, saturation, intensity: A double value representing a
384 %      component of the HSI color space.
385 %
386 %    o red, green, blue: A pointer to a pixel component of type Quantum.
387 %
388 */
389 MagickPrivate void ConvertHSIToRGB(const double hue,const double saturation,
390   const double intensity,double *red,double *green,double *blue)
391 {
392   double
393     b,
394     g,
395     h,
396     r;
397
398   /*
399     Convert HSI to RGB colorspace.
400   */
401   assert(red != (double *) NULL);
402   assert(green != (double *) NULL);
403   assert(blue != (double *) NULL);
404   h=360.0*hue;
405   h-=360.0*floor(h/360.0);
406   if (h < 120.0)
407     {
408       b=intensity*(1.0-saturation);
409       r=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
410         (MagickPI/180.0)));
411       g=3.0*intensity-r-b;
412     }
413   else
414     if (h < 240.0)
415       {
416         h-=120.0;
417         r=intensity*(1.0-saturation);
418         g=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
419           (MagickPI/180.0)));
420         b=3.0*intensity-r-g;
421       }
422     else
423       {
424         h-=240.0;
425         g=intensity*(1.0-saturation);
426         b=intensity*(1.0+saturation*cos(h*(MagickPI/180.0))/cos((60.0-h)*
427           (MagickPI/180.0)));
428         r=3.0*intensity-g-b;
429       }
430   *red=QuantumRange*r;
431   *green=QuantumRange*g;
432   *blue=QuantumRange*b;
433 }
434 \f
435 /*
436 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
437 %                                                                             %
438 %                                                                             %
439 %                                                                             %
440 %   C o n v e r t H S L T o R G B                                             %
441 %                                                                             %
442 %                                                                             %
443 %                                                                             %
444 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
445 %
446 %  ConvertHSLToRGB() transforms a (hue, saturation, lightness) to a (red,
447 %  green, blue) triple.
448 %
449 %  The format of the ConvertHSLToRGBImage method is:
450 %
451 %      void ConvertHSLToRGB(const double hue,const double saturation,
452 %        const double lightness,double *red,double *green,double *blue)
453 %
454 %  A description of each parameter follows:
455 %
456 %    o hue, saturation, lightness: A double value representing a
457 %      component of the HSL color space.
458 %
459 %    o red, green, blue: A pointer to a pixel component of type Quantum.
460 %
461 */
462 MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
463   const double lightness,double *red,double *green,double *blue)
464 {
465   double
466     c,
467     h,
468     min,
469     x;
470
471   /*
472     Convert HSL to RGB colorspace.
473   */
474   assert(red != (double *) NULL);
475   assert(green != (double *) NULL);
476   assert(blue != (double *) NULL);
477   h=hue*360.0;
478   if (lightness <= 0.5)
479     c=2.0*lightness*saturation;
480   else
481     c=(2.0-2.0*lightness)*saturation;
482   min=lightness-0.5*c;
483   h-=360.0*floor(h/360.0);
484   h/=60.0;
485   x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
486   switch ((int) floor(h))
487   {
488     case 0:
489     {
490       *red=QuantumRange*(min+c);
491       *green=QuantumRange*(min+x);
492       *blue=QuantumRange*min;
493       break;
494     }
495     case 1:
496     {
497       *red=QuantumRange*(min+x);
498       *green=QuantumRange*(min+c);
499       *blue=QuantumRange*min;
500       break;
501     }
502     case 2:
503     {
504       *red=QuantumRange*min;
505       *green=QuantumRange*(min+c);
506       *blue=QuantumRange*(min+x);
507       break;
508     }
509     case 3:
510     {
511       *red=QuantumRange*min;
512       *green=QuantumRange*(min+x);
513       *blue=QuantumRange*(min+c);
514       break;
515     }
516     case 4:
517     {
518       *red=QuantumRange*(min+x);
519       *green=QuantumRange*min;
520       *blue=QuantumRange*(min+c);
521       break;
522     }
523     case 5:
524     {
525       *red=QuantumRange*(min+c);
526       *green=QuantumRange*min;
527       *blue=QuantumRange*(min+x);
528       break;
529     }
530     default:
531     {
532       *red=0.0;
533       *green=0.0;
534       *blue=0.0;
535     }
536   }
537 }
538 \f
539 /*
540 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
541 %                                                                             %
542 %                                                                             %
543 %                                                                             %
544 %   C o n v e r t H S V T o R G B                                             %
545 %                                                                             %
546 %                                                                             %
547 %                                                                             %
548 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
549 %
550 %  ConvertHSVToRGB() transforms a (hue, saturation, value) to a (red,
551 %  green, blue) triple.
552 %
553 %  The format of the ConvertHSVToRGBImage method is:
554 %
555 %      void ConvertHSVToRGB(const double hue,const double saturation,
556 %        const double value,double *red,double *green,double *blue)
557 %
558 %  A description of each parameter follows:
559 %
560 %    o hue, saturation, value: A double value representing a
561 %      component of the HSV color space.
562 %
563 %    o red, green, blue: A pointer to a pixel component of type Quantum.
564 %
565 */
566 MagickPrivate void ConvertHSVToRGB(const double hue,const double saturation,
567   const double value,double *red,double *green,double *blue)
568 {
569   double
570     c,
571     h,
572     min,
573     x;
574
575   /*
576     Convert HSV to RGB colorspace.
577   */
578   assert(red != (double *) NULL);
579   assert(green != (double *) NULL);
580   assert(blue != (double *) NULL);
581   h=hue*360.0;
582   c=value*saturation;
583   min=value-c;
584   h-=360.0*floor(h/360.0);
585   h/=60.0;
586   x=c*(1.0-fabs(h-2.0*floor(h/2.0)-1.0));
587   switch ((int) floor(h))
588   {
589     case 0:
590     {
591       *red=QuantumRange*(min+c);
592       *green=QuantumRange*(min+x);
593       *blue=QuantumRange*min;
594       break;
595     }
596     case 1:
597     {
598       *red=QuantumRange*(min+x);
599       *green=QuantumRange*(min+c);
600       *blue=QuantumRange*min;
601       break;
602     }
603     case 2:
604     {
605       *red=QuantumRange*min;
606       *green=QuantumRange*(min+c);
607       *blue=QuantumRange*(min+x);
608       break;
609     }
610     case 3:
611     {
612       *red=QuantumRange*min;
613       *green=QuantumRange*(min+x);
614       *blue=QuantumRange*(min+c);
615       break;
616     }
617     case 4:
618     {
619       *red=QuantumRange*(min+x);
620       *green=QuantumRange*min;
621       *blue=QuantumRange*(min+c);
622       break;
623     }
624     case 5:
625     {
626       *red=QuantumRange*(min+c);
627       *green=QuantumRange*min;
628       *blue=QuantumRange*(min+x);
629       break;
630     }
631     default:
632     {
633       *red=0.0;
634       *green=0.0;
635       *blue=0.0;
636     }
637   }
638 }
639 \f
640 /*
641 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
642 %                                                                             %
643 %                                                                             %
644 %                                                                             %
645 %   C o n v e r t H W B T o R G B                                             %
646 %                                                                             %
647 %                                                                             %
648 %                                                                             %
649 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
650 %
651 %  ConvertHWBToRGB() transforms a (hue, whiteness, blackness) to a (red, green,
652 %  blue) triple.
653 %
654 %  The format of the ConvertHWBToRGBImage method is:
655 %
656 %      void ConvertHWBToRGB(const double hue,const double whiteness,
657 %        const double blackness,double *red,double *green,double *blue)
658 %
659 %  A description of each parameter follows:
660 %
661 %    o hue, whiteness, blackness: A double value representing a
662 %      component of the HWB color space.
663 %
664 %    o red, green, blue: A pointer to a pixel component of type Quantum.
665 %
666 */
667 MagickPrivate void ConvertHWBToRGB(const double hue,const double whiteness,
668   const double blackness,double *red,double *green,double *blue)
669 {
670   double
671     b,
672     f,
673     g,
674     n,
675     r,
676     v;
677
678   register ssize_t
679     i;
680
681   /*
682     Convert HWB to RGB colorspace.
683   */
684   assert(red != (double *) NULL);
685   assert(green != (double *) NULL);
686   assert(blue != (double *) NULL);
687   v=1.0-blackness;
688   if (hue == -1.0)
689     {
690       *red=QuantumRange*v;
691       *green=QuantumRange*v;
692       *blue=QuantumRange*v;
693       return;
694     }
695   i=(ssize_t) floor(6.0*hue);
696   f=6.0*hue-i;
697   if ((i & 0x01) != 0)
698     f=1.0-f;
699   n=whiteness+f*(v-whiteness);  /* linear interpolation */
700   switch (i)
701   {
702     default:
703     case 6:
704     case 0: r=v; g=n; b=whiteness; break;
705     case 1: r=n; g=v; b=whiteness; break;
706     case 2: r=whiteness; g=v; b=n; break;
707     case 3: r=whiteness; g=n; b=v; break;
708     case 4: r=n; g=whiteness; b=v; break;
709     case 5: r=v; g=whiteness; b=n; break;
710   }
711   *red=QuantumRange*r;
712   *green=QuantumRange*g;
713   *blue=QuantumRange*b;
714 }
715 \f
716 /*
717 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
718 %                                                                             %
719 %                                                                             %
720 %                                                                             %
721 %   C o n v e r t L C H a b T o R G B                                         %
722 %                                                                             %
723 %                                                                             %
724 %                                                                             %
725 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
726 %
727 %  ConvertLCHabToRGB() transforms a (luma, chroma, hue) to a (red, green,
728 %  blue) triple.
729 %
730 %  The format of the ConvertLCHabToRGBImage method is:
731 %
732 %      void ConvertLCHabToRGB(const double luma,const double chroma,
733 %        const double hue,double *red,double *green,double *blue)
734 %
735 %  A description of each parameter follows:
736 %
737 %    o luma, chroma, hue: A double value representing a component of the
738 %      LCHab color space.
739 %
740 %    o red, green, blue: A pointer to a pixel component of type Quantum.
741 %
742 */
743
744 static inline void ConvertLCHabToXYZ(const double luma,const double chroma,
745   const double hue,double *X,double *Y,double *Z)
746 {
747   ConvertLabToXYZ(luma,chroma*cos(hue*MagickPI/180.0),chroma*
748     sin(hue*MagickPI/180.0),X,Y,Z);
749 }
750
751 MagickPrivate void ConvertLCHabToRGB(const double luma,const double chroma,
752   const double hue,double *red,double *green,double *blue)
753 {
754   double
755     X,
756     Y,
757     Z;
758
759   /*
760     Convert LCHab to RGB colorspace.
761   */
762   assert(red != (double *) NULL);
763   assert(green != (double *) NULL);
764   assert(blue != (double *) NULL);
765   ConvertLCHabToXYZ(100.0*luma,255.0*(chroma-0.5),360.0*hue,&X,&Y,&Z);
766   ConvertXYZToRGB(X,Y,Z,red,green,blue);
767 }
768 \f
769 /*
770 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
771 %                                                                             %
772 %                                                                             %
773 %                                                                             %
774 %   C o n v e r t L C H u v T o R G B                                         %
775 %                                                                             %
776 %                                                                             %
777 %                                                                             %
778 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
779 %
780 %  ConvertLCHuvToRGB() transforms a (luma, chroma, hue) to a (red, green,
781 %  blue) triple.
782 %
783 %  The format of the ConvertLCHuvToRGBImage method is:
784 %
785 %      void ConvertLCHuvToRGB(const double luma,const double chroma,
786 %        const double hue,double *red,double *green,double *blue)
787 %
788 %  A description of each parameter follows:
789 %
790 %    o luma, chroma, hue: A double value representing a component of the
791 %      LCHuv color space.
792 %
793 %    o red, green, blue: A pointer to a pixel component of type Quantum.
794 %
795 */
796
797 static inline void ConvertLCHuvToXYZ(const double luma,const double chroma,
798   const double hue,double *X,double *Y,double *Z)
799 {
800   ConvertLuvToXYZ(luma,chroma*cos(hue*MagickPI/180.0),chroma*
801     sin(hue*MagickPI/180.0),X,Y,Z);
802 }
803
804 MagickPrivate void ConvertLCHuvToRGB(const double luma,const double chroma,
805   const double hue,double *red,double *green,double *blue)
806 {
807   double
808     X,
809     Y,
810     Z;
811
812   /*
813     Convert LCHuv to RGB colorspace.
814   */
815   assert(red != (double *) NULL);
816   assert(green != (double *) NULL);
817   assert(blue != (double *) NULL);
818   ConvertLCHuvToXYZ(100.0*luma,255.0*(chroma-0.5),360.0*hue,&X,&Y,&Z);
819   ConvertXYZToRGB(X,Y,Z,red,green,blue);
820 }
821 \f
822 /*
823 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
824 %                                                                             %
825 %                                                                             %
826 %                                                                             %
827 %   C o n v e r t R G B T o H C L                                             %
828 %                                                                             %
829 %                                                                             %
830 %                                                                             %
831 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
832 %
833 %  ConvertRGBToHCL() transforms a (red, green, blue) to a (hue, chroma,
834 %  luma) triple.
835 %
836 %  The format of the ConvertRGBToHCL method is:
837 %
838 %      void ConvertRGBToHCL(const double red,const double green,
839 %        const double blue,double *hue,double *chroma,double *luma)
840 %
841 %  A description of each parameter follows:
842 %
843 %    o red, green, blue: A Quantum value representing the red, green, and
844 %      blue component of a pixel.
845 %
846 %    o hue, chroma, luma: A pointer to a double value representing a
847 %      component of the HCL color space.
848 %
849 */
850 MagickPrivate void ConvertRGBToHCL(const double red,const double green,
851   const double blue,double *hue,double *chroma,double *luma)
852 {
853   double
854     b,
855     c,
856     g,
857     h,
858     max,
859     r;
860
861   /*
862     Convert RGB to HCL colorspace.
863   */
864   assert(hue != (double *) NULL);
865   assert(chroma != (double *) NULL);
866   assert(luma != (double *) NULL);
867   r=red;
868   g=green;
869   b=blue;
870   max=MagickMax(r,MagickMax(g,b));
871   c=max-(double) MagickMin(r,MagickMin(g,b));
872   h=0.0;
873   if (c == 0.0)
874     h=0.0;
875   else
876     if (red == max)
877       h=fmod((g-b)/c+6.0,6.0);
878     else
879       if (green == max)
880         h=((b-r)/c)+2.0;
881       else
882         if (blue == max)
883           h=((r-g)/c)+4.0;
884   *hue=(h/6.0);
885   *chroma=QuantumScale*c;
886   *luma=QuantumScale*(0.298839*r+0.586811*g+0.114350*b);
887 }
888 \f
889 /*
890 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
891 %                                                                             %
892 %                                                                             %
893 %                                                                             %
894 %   C o n v e r t R G B T o H C L p                                           %
895 %                                                                             %
896 %                                                                             %
897 %                                                                             %
898 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
899 %
900 %  ConvertRGBToHCLp() transforms a (red, green, blue) to a (hue, chroma,
901 %  luma) triple.
902 %
903 %  The format of the ConvertRGBToHCLp method is:
904 %
905 %      void ConvertRGBToHCLp(const double red,const double green,
906 %        const double blue,double *hue,double *chroma,double *luma)
907 %
908 %  A description of each parameter follows:
909 %
910 %    o red, green, blue: A Quantum value representing the red, green, and
911 %      blue component of a pixel.
912 %
913 %    o hue, chroma, luma: A pointer to a double value representing a
914 %      component of the HCL color space.
915 %
916 */
917 MagickPrivate void ConvertRGBToHCLp(const double red,const double green,
918   const double blue,double *hue,double *chroma,double *luma)
919 {
920   double
921     b,
922     c,
923     g,
924     h,
925     max,
926     r;
927
928   /*
929     Convert RGB to HCL colorspace.
930   */
931   assert(hue != (double *) NULL);
932   assert(chroma != (double *) NULL);
933   assert(luma != (double *) NULL);
934   r=red;
935   g=green;
936   b=blue;
937   max=MagickMax(r,MagickMax(g,b));
938   c=max-(double) MagickMin(r,MagickMin(g,b));
939   h=0.0;
940   if (c == 0.0)
941     h=0.0;
942   else
943     if (red == max)
944       h=fmod((g-b)/c+6.0,6.0);
945     else
946       if (green == max)
947         h=((b-r)/c)+2.0;
948       else
949         if (blue == max)
950           h=((r-g)/c)+4.0;
951   *hue=(h/6.0);
952   *chroma=QuantumScale*c;
953   *luma=QuantumScale*(0.298839*r+0.586811*g+0.114350*b);
954 }
955 \f
956 /*
957 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
958 %                                                                             %
959 %                                                                             %
960 %                                                                             %
961 %   C o n v e r t R G B T o H S B                                             %
962 %                                                                             %
963 %                                                                             %
964 %                                                                             %
965 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
966 %
967 %  ConvertRGBToHSB() transforms a (red, green, blue) to a (hue, saturation,
968 %  brightness) triple.
969 %
970 %  The format of the ConvertRGBToHSB method is:
971 %
972 %      void ConvertRGBToHSB(const double red,const double green,
973 %        const double blue,double *hue,double *saturation,double *brightness)
974 %
975 %  A description of each parameter follows:
976 %
977 %    o red, green, blue: A Quantum value representing the red, green, and
978 %      blue component of a pixel..
979 %
980 %    o hue, saturation, brightness: A pointer to a double value representing a
981 %      component of the HSB color space.
982 %
983 */
984 MagickPrivate void ConvertRGBToHSB(const double red,const double green,
985   const double blue,double *hue,double *saturation,double *brightness)
986 {
987   double
988     b,
989     delta,
990     g,
991     max,
992     min,
993     r;
994
995   /*
996     Convert RGB to HSB colorspace.
997   */
998   assert(hue != (double *) NULL);
999   assert(saturation != (double *) NULL);
1000   assert(brightness != (double *) NULL);
1001   *hue=0.0;
1002   *saturation=0.0;
1003   *brightness=0.0;
1004   r=red;
1005   g=green;
1006   b=blue;
1007   min=r < g ? r : g;
1008   if (b < min)
1009     min=b;
1010   max=r > g ? r : g;
1011   if (b > max)
1012     max=b;
1013   if (max == 0.0)
1014     return;
1015   delta=max-min;
1016   *saturation=delta/max;
1017   *brightness=QuantumScale*max;
1018   if (delta == 0.0)
1019     return;
1020   if (r == max)
1021     *hue=(g-b)/delta;
1022   else
1023     if (g == max)
1024       *hue=2.0+(b-r)/delta;
1025     else
1026       *hue=4.0+(r-g)/delta;
1027   *hue/=6.0;
1028   if (*hue < 0.0)
1029     *hue+=1.0;
1030 }
1031 \f
1032 /*
1033 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1034 %                                                                             %
1035 %                                                                             %
1036 %                                                                             %
1037 %   C o n v e r t R G B T o H S I                                             %
1038 %                                                                             %
1039 %                                                                             %
1040 %                                                                             %
1041 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1042 %
1043 %  ConvertRGBToHSI() transforms a (red, green, blue) to a (hue, saturation,
1044 %  intensity) triple.
1045 %
1046 %  The format of the ConvertRGBToHSI method is:
1047 %
1048 %      void ConvertRGBToHSI(const double red,const double green,
1049 %        const double blue,double *hue,double *saturation,double *intensity)
1050 %
1051 %  A description of each parameter follows:
1052 %
1053 %    o red, green, blue: A Quantum value representing the red, green, and
1054 %      blue component of a pixel..
1055 %
1056 %    o hue, saturation, intensity: A pointer to a double value representing a
1057 %      component of the HSI color space.
1058 %
1059 */
1060 MagickPrivate void ConvertRGBToHSI(const double red,const double green,
1061   const double blue,double *hue,double *saturation,double *intensity)
1062 {
1063   double
1064     alpha,
1065     beta;
1066
1067   /*
1068     Convert RGB to HSI colorspace.
1069   */
1070   assert(hue != (double *) NULL);
1071   assert(saturation != (double *) NULL);
1072   assert(intensity != (double *) NULL);
1073   *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
1074   if (*intensity <= 0.0)
1075     {
1076       *hue=0.0;
1077       *saturation=0.0;
1078       return;
1079     }
1080   *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1081     QuantumScale*blue))/(*intensity);
1082   alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
1083   beta=0.8660254037844385*(QuantumScale*green-QuantumScale*blue);
1084   *hue=atan2(beta,alpha)*(180.0/MagickPI)/360.0;
1085   if (*hue < 0.0)
1086     *hue+=1.0;
1087 }
1088 \f
1089 /*
1090 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1091 %                                                                             %
1092 %                                                                             %
1093 %                                                                             %
1094 %   C o n v e r t R G B T o H S L                                             %
1095 %                                                                             %
1096 %                                                                             %
1097 %                                                                             %
1098 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1099 %
1100 %  ConvertRGBToHSL() transforms a (red, green, blue) to a (hue, saturation,
1101 %  lightness) triple.
1102 %
1103 %  The format of the ConvertRGBToHSL method is:
1104 %
1105 %      void ConvertRGBToHSL(const double red,const double green,
1106 %        const double blue,double *hue,double *saturation,double *lightness)
1107 %
1108 %  A description of each parameter follows:
1109 %
1110 %    o red, green, blue: A Quantum value representing the red, green, and
1111 %      blue component of a pixel..
1112 %
1113 %    o hue, saturation, lightness: A pointer to a double value representing a
1114 %      component of the HSL color space.
1115 %
1116 */
1117 MagickExport void ConvertRGBToHSL(const double red,const double green,
1118   const double blue,double *hue,double *saturation,double *lightness)
1119 {
1120   double
1121     c,
1122     max,
1123     min;
1124
1125   /*
1126     Convert RGB to HSL colorspace.
1127   */
1128   assert(hue != (double *) NULL);
1129   assert(saturation != (double *) NULL);
1130   assert(lightness != (double *) NULL);
1131   max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
1132     QuantumScale*blue));
1133   min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1134     QuantumScale*blue));
1135   c=max-min;
1136   *lightness=(max+min)/2.0;
1137   if (c <= 0.0)
1138     {
1139       *hue=0.0;
1140       *saturation=0.0;
1141       return;
1142     }
1143   if (max == (QuantumScale*red))
1144     {
1145       *hue=(QuantumScale*green-QuantumScale*blue)/c;
1146       if ((QuantumScale*green) < (QuantumScale*blue))
1147         *hue+=6.0;
1148     }
1149   else
1150     if (max == (QuantumScale*green))
1151       *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
1152     else
1153       *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
1154   *hue*=60.0/360.0;
1155   if (*lightness <= 0.5)
1156     *saturation=c/(2.0*(*lightness));
1157   else
1158     *saturation=c/(2.0-2.0*(*lightness));
1159 }
1160 \f
1161 /*
1162 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1163 %                                                                             %
1164 %                                                                             %
1165 %                                                                             %
1166 %   C o n v e r t R G B T o H S V                                             %
1167 %                                                                             %
1168 %                                                                             %
1169 %                                                                             %
1170 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1171 %
1172 %  ConvertRGBToHSV() transforms a (red, green, blue) to a (hue, saturation,
1173 %  value) triple.
1174 %
1175 %  The format of the ConvertRGBToHSV method is:
1176 %
1177 %      void ConvertRGBToHSV(const double red,const double green,
1178 %        const double blue,double *hue,double *saturation,double *value)
1179 %
1180 %  A description of each parameter follows:
1181 %
1182 %    o red, green, blue: A Quantum value representing the red, green, and
1183 %      blue component of a pixel..
1184 %
1185 %    o hue, saturation, value: A pointer to a double value representing a
1186 %      component of the HSV color space.
1187 %
1188 */
1189 MagickPrivate void ConvertRGBToHSV(const double red,const double green,
1190   const double blue,double *hue,double *saturation,double *value)
1191 {
1192   double
1193     c,
1194     max,
1195     min;
1196
1197   /*
1198     Convert RGB to HSV colorspace.
1199   */
1200   assert(hue != (double *) NULL);
1201   assert(saturation != (double *) NULL);
1202   assert(value != (double *) NULL);
1203   max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
1204     QuantumScale*blue));
1205   min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1206     QuantumScale*blue));
1207   c=max-min;
1208   *value=max;
1209   if (c <= 0.0)
1210     {
1211       *hue=0.0;
1212       *saturation=0.0;
1213       return;
1214     }
1215   if (max == (QuantumScale*red))
1216     {
1217       *hue=(QuantumScale*green-QuantumScale*blue)/c;
1218       if ((QuantumScale*green) < (QuantumScale*blue))
1219         *hue+=6.0;
1220     }
1221   else
1222     if (max == (QuantumScale*green))
1223       *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
1224     else
1225       *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
1226   *hue*=60.0/360.0;
1227   *saturation=c/max;
1228 }
1229 \f
1230 /*
1231 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1232 %                                                                             %
1233 %                                                                             %
1234 %                                                                             %
1235 %   C o n v e r t R G B T o H W B                                             %
1236 %                                                                             %
1237 %                                                                             %
1238 %                                                                             %
1239 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1240 %
1241 %  ConvertRGBToHWB() transforms a (red, green, blue) to a (hue, whiteness,
1242 %  blackness) triple.
1243 %
1244 %  The format of the ConvertRGBToHWB method is:
1245 %
1246 %      void ConvertRGBToHWB(const double red,const double green,
1247 %        const double blue,double *hue,double *whiteness,double *blackness)
1248 %
1249 %  A description of each parameter follows:
1250 %
1251 %    o red, green, blue: A Quantum value representing the red, green, and
1252 %      blue component of a pixel.
1253 %
1254 %    o hue, whiteness, blackness: A pointer to a double value representing a
1255 %      component of the HWB color space.
1256 %
1257 */
1258 MagickPrivate void ConvertRGBToHWB(const double red,const double green,
1259   const double blue,double *hue,double *whiteness,double *blackness)
1260 {
1261   double
1262     b,
1263     f,
1264     g,
1265     p,
1266     r,
1267     v,
1268     w;
1269
1270   /*
1271     Convert RGB to HWB colorspace.
1272   */
1273   assert(hue != (double *) NULL);
1274   assert(whiteness != (double *) NULL);
1275   assert(blackness != (double *) NULL);
1276   r=red;
1277   g=green;
1278   b=blue;
1279   w=MagickMin(r,MagickMin(g,b));
1280   v=MagickMax(r,MagickMax(g,b));
1281   *blackness=1.0-QuantumScale*v;
1282   *whiteness=QuantumScale*w;
1283   if (v == w)
1284     {
1285       *hue=(-1.0);
1286       return;
1287     }
1288   f=(r == w) ? g-b : ((g == w) ? b-r : r-g);
1289   p=(r == w) ? 3.0 : ((g == w) ? 5.0 : 1.0);
1290   *hue=(p-f/(v-1.0*w))/6.0;
1291 }
1292 \f
1293 /*
1294 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1295 %                                                                             %
1296 %                                                                             %
1297 %                                                                             %
1298 %   C o n v e r t R G B T o L C H a b                                         %
1299 %                                                                             %
1300 %                                                                             %
1301 %                                                                             %
1302 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1303 %
1304 %  ConvertRGBToLCHab() transforms a (red, green, blue) to a (luma, chroma,
1305 %  hue) triple.
1306 %
1307 %  The format of the ConvertRGBToLCHab method is:
1308 %
1309 %      void ConvertRGBToLCHab(const double red,const double green,
1310 %        const double blue,double *luma,double *chroma,double *hue)
1311 %
1312 %  A description of each parameter follows:
1313 %
1314 %    o red, green, blue: A Quantum value representing the red, green, and
1315 %      blue component of a pixel.
1316 %
1317 %    o luma, chroma, hue: A pointer to a double value representing a
1318 %      component of the LCH color space.
1319 %
1320 */
1321
1322 static inline void ConvertXYZToLCHab(const double X,const double Y,
1323   const double Z,double *luma,double *chroma,double *hue)
1324 {
1325   double
1326     a,
1327     b;
1328
1329   ConvertXYZToLab(X,Y,Z,luma,&a,&b);
1330   *chroma=hypot(255.0*(a-0.5),255.0*(b-0.5))/255.0+0.5;
1331   *hue=180.0*atan2(255.0*(b-0.5),255.0*(a-0.5))/MagickPI/360.0;
1332   if (*hue < 0.0)
1333     *hue+=1.0;
1334 }
1335
1336 MagickPrivate void ConvertRGBToLCHab(const double red,const double green,
1337   const double blue,double *luma,double *chroma,double *hue)
1338 {
1339   double
1340     X,
1341     Y,
1342     Z;
1343
1344   /*
1345     Convert RGB to LCHab colorspace.
1346   */
1347   assert(luma != (double *) NULL);
1348   assert(chroma != (double *) NULL);
1349   assert(hue != (double *) NULL);
1350   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1351   ConvertXYZToLCHab(X,Y,Z,luma,chroma,hue);
1352 }
1353 \f
1354 /*
1355 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1356 %                                                                             %
1357 %                                                                             %
1358 %                                                                             %
1359 %   C o n v e r t R G B T o L C H u v                                         %
1360 %                                                                             %
1361 %                                                                             %
1362 %                                                                             %
1363 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1364 %
1365 %  ConvertRGBToLCHuv() transforms a (red, green, blue) to a (luma, chroma,
1366 %  hue) triple.
1367 %
1368 %  The format of the ConvertRGBToLCHuv method is:
1369 %
1370 %      void ConvertRGBToLCHuv(const double red,const double green,
1371 %        const double blue,double *luma,double *chroma,double *hue)
1372 %
1373 %  A description of each parameter follows:
1374 %
1375 %    o red, green, blue: A Quantum value representing the red, green, and
1376 %      blue component of a pixel.
1377 %
1378 %    o luma, chroma, hue: A pointer to a double value representing a
1379 %      component of the LCHuv color space.
1380 %
1381 */
1382
1383 static inline void ConvertXYZToLCHuv(const double X,const double Y,
1384   const double Z,double *luma,double *chroma,double *hue)
1385 {
1386   double
1387     u,
1388     v;
1389
1390   ConvertXYZToLuv(X,Y,Z,luma,&u,&v);
1391   *chroma=hypot(354.0*u-134.0,262.0*v-140.0)/255.0+0.5;
1392   *hue=180.0*atan2(262.0*v-140.0,354.0*u-134.0)/MagickPI/360.0;
1393   if (*hue < 0.0)
1394     *hue+=1.0;
1395 }
1396
1397 MagickPrivate void ConvertRGBToLCHuv(const double red,const double green,
1398   const double blue,double *luma,double *chroma,double *hue)
1399 {
1400   double
1401     X,
1402     Y,
1403     Z;
1404
1405   /*
1406     Convert RGB to LCHuv colorspace.
1407   */
1408   assert(luma != (double *) NULL);
1409   assert(chroma != (double *) NULL);
1410   assert(hue != (double *) NULL);
1411   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1412   ConvertXYZToLCHuv(X,Y,Z,luma,chroma,hue);
1413 }
1414 \f
1415 /*
1416 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1417 %                                                                             %
1418 %                                                                             %
1419 %                                                                             %
1420 %   E x p a n d A f f i n e                                                   %
1421 %                                                                             %
1422 %                                                                             %
1423 %                                                                             %
1424 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1425 %
1426 %  ExpandAffine() computes the affine's expansion factor, i.e. the square root
1427 %  of the factor by which the affine transform affects area. In an affine
1428 %  transform composed of scaling, rotation, shearing, and translation, returns
1429 %  the amount of scaling.
1430 %
1431 %  The format of the ExpandAffine method is:
1432 %
1433 %      double ExpandAffine(const AffineMatrix *affine)
1434 %
1435 %  A description of each parameter follows:
1436 %
1437 %    o expansion: ExpandAffine returns the affine's expansion factor.
1438 %
1439 %    o affine: A pointer the affine transform of type AffineMatrix.
1440 %
1441 */
1442 MagickExport double ExpandAffine(const AffineMatrix *affine)
1443 {
1444   assert(affine != (const AffineMatrix *) NULL);
1445   return(sqrt(fabs(affine->sx*affine->sy-affine->rx*affine->ry)));
1446 }
1447 \f
1448 /*
1449 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1450 %                                                                             %
1451 %                                                                             %
1452 %                                                                             %
1453 %   G e n e r a t e D i f f e r e n t i a l N o i s e                         %
1454 %                                                                             %
1455 %                                                                             %
1456 %                                                                             %
1457 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1458 %
1459 %  GenerateDifferentialNoise() generates differentual noise.
1460 %
1461 %  The format of the GenerateDifferentialNoise method is:
1462 %
1463 %      double GenerateDifferentialNoise(RandomInfo *random_info,
1464 %        const Quantum pixel,const NoiseType noise_type,const double attenuate)
1465 %
1466 %  A description of each parameter follows:
1467 %
1468 %    o random_info: the random info.
1469 %
1470 %    o pixel: noise is relative to this pixel value.
1471 %
1472 %    o noise_type: the type of noise.
1473 %
1474 %    o attenuate:  attenuate the noise.
1475 %
1476 */
1477 MagickPrivate double GenerateDifferentialNoise(RandomInfo *random_info,
1478   const Quantum pixel,const NoiseType noise_type,const double attenuate)
1479 {
1480 #define SigmaUniform  (attenuate*0.015625)
1481 #define SigmaGaussian  (attenuate*0.015625)
1482 #define SigmaImpulse  (attenuate*0.1)
1483 #define SigmaLaplacian (attenuate*0.0390625)
1484 #define SigmaMultiplicativeGaussian  (attenuate*0.5)
1485 #define SigmaPoisson  (attenuate*12.5)
1486 #define SigmaRandom  (attenuate)
1487 #define TauGaussian  (attenuate*0.078125)
1488
1489   double
1490     alpha,
1491     beta,
1492     noise,
1493     sigma;
1494
1495   alpha=GetPseudoRandomValue(random_info);
1496   switch (noise_type)
1497   {
1498     case UniformNoise:
1499     default:
1500     {
1501       noise=(double) (pixel+QuantumRange*SigmaUniform*(alpha-0.5));
1502       break;
1503     }
1504     case GaussianNoise:
1505     {
1506       double
1507         gamma,
1508         tau;
1509
1510       if (alpha == 0.0)
1511         alpha=1.0;
1512       beta=GetPseudoRandomValue(random_info);
1513       gamma=sqrt(-2.0*log(alpha));
1514       sigma=gamma*cos((double) (2.0*MagickPI*beta));
1515       tau=gamma*sin((double) (2.0*MagickPI*beta));
1516       noise=(double) (pixel+sqrt((double) pixel)*SigmaGaussian*sigma+
1517         QuantumRange*TauGaussian*tau);
1518       break;
1519     }
1520     case ImpulseNoise:
1521     {
1522       if (alpha < (SigmaImpulse/2.0))
1523         noise=0.0;
1524       else
1525         if (alpha >= (1.0-(SigmaImpulse/2.0)))
1526           noise=(double) QuantumRange;
1527         else
1528           noise=(double) pixel;
1529       break;
1530     }
1531     case LaplacianNoise:
1532     {
1533       if (alpha <= 0.5)
1534         {
1535           if (alpha <= MagickEpsilon)
1536             noise=(double) (pixel-QuantumRange);
1537           else
1538             noise=(double) (pixel+QuantumRange*SigmaLaplacian*log(2.0*alpha)+
1539               0.5);
1540           break;
1541         }
1542       beta=1.0-alpha;
1543       if (beta <= (0.5*MagickEpsilon))
1544         noise=(double) (pixel+QuantumRange);
1545       else
1546         noise=(double) (pixel-QuantumRange*SigmaLaplacian*log(2.0*beta)+0.5);
1547       break;
1548     }
1549     case MultiplicativeGaussianNoise:
1550     {
1551       sigma=1.0;
1552       if (alpha > MagickEpsilon)
1553         sigma=sqrt(-2.0*log(alpha));
1554       beta=GetPseudoRandomValue(random_info);
1555       noise=(double) (pixel+pixel*SigmaMultiplicativeGaussian*sigma*
1556         cos((double) (2.0*MagickPI*beta))/2.0);
1557       break;
1558     }
1559     case PoissonNoise:
1560     {
1561       double
1562         poisson;
1563
1564       register ssize_t
1565         i;
1566
1567       poisson=exp(-SigmaPoisson*QuantumScale*pixel);
1568       for (i=0; alpha > poisson; i++)
1569       {
1570         beta=GetPseudoRandomValue(random_info);
1571         alpha*=beta;
1572       }
1573       noise=(double) (QuantumRange*i/SigmaPoisson);
1574       break;
1575     }
1576     case RandomNoise:
1577     {
1578       noise=(double) (QuantumRange*SigmaRandom*alpha);
1579       break;
1580     }
1581   }
1582   return(noise);
1583 }
1584 \f
1585 /*
1586 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1587 %                                                                             %
1588 %                                                                             %
1589 %                                                                             %
1590 %   G e t O p t i m a l K e r n e l W i d t h                                 %
1591 %                                                                             %
1592 %                                                                             %
1593 %                                                                             %
1594 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1595 %
1596 %  GetOptimalKernelWidth() computes the optimal kernel radius for a convolution
1597 %  filter.  Start with the minimum value of 3 pixels and walk out until we drop
1598 %  below the threshold of one pixel numerical accuracy.
1599 %
1600 %  The format of the GetOptimalKernelWidth method is:
1601 %
1602 %      size_t GetOptimalKernelWidth(const double radius,
1603 %        const double sigma)
1604 %
1605 %  A description of each parameter follows:
1606 %
1607 %    o width: GetOptimalKernelWidth returns the optimal width of a
1608 %      convolution kernel.
1609 %
1610 %    o radius: the radius of the Gaussian, in pixels, not counting the center
1611 %      pixel.
1612 %
1613 %    o sigma: the standard deviation of the Gaussian, in pixels.
1614 %
1615 */
1616 MagickPrivate size_t GetOptimalKernelWidth1D(const double radius,
1617   const double sigma)
1618 {
1619   double
1620     alpha,
1621     beta,
1622     gamma,
1623     normalize,
1624     value;
1625
1626   register ssize_t
1627     i;
1628
1629   size_t
1630     width;
1631
1632   ssize_t
1633     j;
1634
1635   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1636   if (radius > MagickEpsilon)
1637     return((size_t) (2.0*ceil(radius)+1.0));
1638   gamma=fabs(sigma);
1639   if (gamma <= MagickEpsilon)
1640     return(3UL);
1641   alpha=PerceptibleReciprocal(2.0*gamma*gamma);
1642   beta=(double) PerceptibleReciprocal((double) MagickSQ2PI*gamma);
1643   for (width=5; ; )
1644   {
1645     normalize=0.0;
1646     j=(ssize_t) (width-1)/2;
1647     for (i=(-j); i <= j; i++)
1648       normalize+=exp(-((double) (i*i))*alpha)*beta;
1649     value=exp(-((double) (j*j))*alpha)*beta/normalize;
1650     if ((value < QuantumScale) || (value < MagickEpsilon))
1651       break;
1652     width+=2;
1653   }
1654   return((size_t) (width-2));
1655 }
1656
1657 MagickPrivate size_t GetOptimalKernelWidth2D(const double radius,
1658   const double sigma)
1659 {
1660   double
1661     alpha,
1662     beta,
1663     gamma,
1664     normalize,
1665     value;
1666
1667   size_t
1668     width;
1669
1670   ssize_t
1671     j,
1672     u,
1673     v;
1674
1675   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1676   if (radius > MagickEpsilon)
1677     return((size_t) (2.0*ceil(radius)+1.0));
1678   gamma=fabs(sigma);
1679   if (gamma <= MagickEpsilon)
1680     return(3UL);
1681   alpha=PerceptibleReciprocal(2.0*gamma*gamma);
1682   beta=(double) PerceptibleReciprocal((double) Magick2PI*gamma*gamma);
1683   for (width=5; ; )
1684   {
1685     normalize=0.0;
1686     j=(ssize_t) (width-1)/2;
1687     for (v=(-j); v <= j; v++)
1688       for (u=(-j); u <= j; u++)
1689         normalize+=exp(-((double) (u*u+v*v))*alpha)*beta;
1690     value=exp(-((double) (j*j))*alpha)*beta/normalize;
1691     if ((value < QuantumScale) || (value < MagickEpsilon))
1692       break;
1693     width+=2;
1694   }
1695   return((size_t) (width-2));
1696 }
1697
1698 MagickPrivate size_t  GetOptimalKernelWidth(const double radius,
1699   const double sigma)
1700 {
1701   return(GetOptimalKernelWidth1D(radius,sigma));
1702 }