granicus.if.org Git - imagemagick/blob - 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-2014 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
 851 static inline double MagickMax(const double x,const double y)
 852 {
 853   if (x > y)
 854     return(x);
 855   return(y);
 856 }
 857
 858 static inline double MagickMin(const double x,const double y)
 859 {
 860   if (x < y)
 861     return(x);
 862   return(y);
 863 }
 864
 865 MagickPrivate void ConvertRGBToHCL(const double red,const double green,
 866   const double blue,double *hue,double *chroma,double *luma)
 867 {
 868   double
 869     b,
 870     c,
 871     g,
 872     h,
 873     max,
 874     r;
 875
 876   /*
 877     Convert RGB to HCL colorspace.
 878   */
 879   assert(hue != (double *) NULL);
 880   assert(chroma != (double *) NULL);
 881   assert(luma != (double *) NULL);
 882   r=red;
 883   g=green;
 884   b=blue;
 885   max=MagickMax(r,MagickMax(g,b));
 886   c=max-(double) MagickMin(r,MagickMin(g,b));
 887   h=0.0;
 888   if (c == 0.0)
 889     h=0.0;
 890   else
 891     if (red == max)
 892       h=fmod((g-b)/c+6.0,6.0);
 893     else
 894       if (green == max)
 895         h=((b-r)/c)+2.0;
 896       else
 897         if (blue == max)
 898           h=((r-g)/c)+4.0;
 899   *hue=(h/6.0);
 900   *chroma=QuantumScale*c;
 901   *luma=QuantumScale*(0.298839*r+0.586811*g+0.114350*b);
 902 }
 903 \f
 904 /*
 905 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 906 %                                                                             %
 907 %                                                                             %
 908 %                                                                             %
 909 %   C o n v e r t R G B T o H C L p                                           %
 910 %                                                                             %
 911 %                                                                             %
 912 %                                                                             %
 913 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 914 %
 915 %  ConvertRGBToHCLp() transforms a (red, green, blue) to a (hue, chroma,
 916 %  luma) triple.
 917 %
 918 %  The format of the ConvertRGBToHCLp method is:
 919 %
 920 %      void ConvertRGBToHCLp(const double red,const double green,
 921 %        const double blue,double *hue,double *chroma,double *luma)
 922 %
 923 %  A description of each parameter follows:
 924 %
 925 %    o red, green, blue: A Quantum value representing the red, green, and
 926 %      blue component of a pixel.
 927 %
 928 %    o hue, chroma, luma: A pointer to a double value representing a
 929 %      component of the HCL color space.
 930 %
 931 */
 932 MagickPrivate void ConvertRGBToHCLp(const double red,const double green,
 933   const double blue,double *hue,double *chroma,double *luma)
 934 {
 935   double
 936     b,
 937     c,
 938     g,
 939     h,
 940     max,
 941     r;
 942
 943   /*
 944     Convert RGB to HCL colorspace.
 945   */
 946   assert(hue != (double *) NULL);
 947   assert(chroma != (double *) NULL);
 948   assert(luma != (double *) NULL);
 949   r=red;
 950   g=green;
 951   b=blue;
 952   max=MagickMax(r,MagickMax(g,b));
 953   c=max-(double) MagickMin(r,MagickMin(g,b));
 954   h=0.0;
 955   if (c == 0.0)
 956     h=0.0;
 957   else
 958     if (red == max)
 959       h=fmod((g-b)/c+6.0,6.0);
 960     else
 961       if (green == max)
 962         h=((b-r)/c)+2.0;
 963       else
 964         if (blue == max)
 965           h=((r-g)/c)+4.0;
 966   *hue=(h/6.0);
 967   *chroma=QuantumScale*c;
 968   *luma=QuantumScale*(0.298839*r+0.586811*g+0.114350*b);
 969 }
 970 \f
 971 /*
 972 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 973 %                                                                             %
 974 %                                                                             %
 975 %                                                                             %
 976 %   C o n v e r t R G B T o H S B                                             %
 977 %                                                                             %
 978 %                                                                             %
 979 %                                                                             %
 980 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 981 %
 982 %  ConvertRGBToHSB() transforms a (red, green, blue) to a (hue, saturation,
 983 %  brightness) triple.
 984 %
 985 %  The format of the ConvertRGBToHSB method is:
 986 %
 987 %      void ConvertRGBToHSB(const double red,const double green,
 988 %        const double blue,double *hue,double *saturation,double *brightness)
 989 %
 990 %  A description of each parameter follows:
 991 %
 992 %    o red, green, blue: A Quantum value representing the red, green, and
 993 %      blue component of a pixel..
 994 %
 995 %    o hue, saturation, brightness: A pointer to a double value representing a
 996 %      component of the HSB color space.
 997 %
 998 */
 999 MagickPrivate void ConvertRGBToHSB(const double red,const double green,
1000   const double blue,double *hue,double *saturation,double *brightness)
1001 {
1002   double
1003     b,
1004     delta,
1005     g,
1006     max,
1007     min,
1008     r;
1009
1010   /*
1011     Convert RGB to HSB colorspace.
1012   */
1013   assert(hue != (double *) NULL);
1014   assert(saturation != (double *) NULL);
1015   assert(brightness != (double *) NULL);
1016   *hue=0.0;
1017   *saturation=0.0;
1018   *brightness=0.0;
1019   r=red;
1020   g=green;
1021   b=blue;
1022   min=r < g ? r : g;
1023   if (b < min)
1024     min=b;
1025   max=r > g ? r : g;
1026   if (b > max)
1027     max=b;
1028   if (max == 0.0)
1029     return;
1030   delta=max-min;
1031   *saturation=delta/max;
1032   *brightness=QuantumScale*max;
1033   if (delta == 0.0)
1034     return;
1035   if (r == max)
1036     *hue=(g-b)/delta;
1037   else
1038     if (g == max)
1039       *hue=2.0+(b-r)/delta;
1040     else
1041       *hue=4.0+(r-g)/delta;
1042   *hue/=6.0;
1043   if (*hue < 0.0)
1044     *hue+=1.0;
1045 }
1046 \f
1047 /*
1048 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1049 %                                                                             %
1050 %                                                                             %
1051 %                                                                             %
1052 %   C o n v e r t R G B T o H S I                                             %
1053 %                                                                             %
1054 %                                                                             %
1055 %                                                                             %
1056 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1057 %
1058 %  ConvertRGBToHSI() transforms a (red, green, blue) to a (hue, saturation,
1059 %  intensity) triple.
1060 %
1061 %  The format of the ConvertRGBToHSI method is:
1062 %
1063 %      void ConvertRGBToHSI(const double red,const double green,
1064 %        const double blue,double *hue,double *saturation,double *intensity)
1065 %
1066 %  A description of each parameter follows:
1067 %
1068 %    o red, green, blue: A Quantum value representing the red, green, and
1069 %      blue component of a pixel..
1070 %
1071 %    o hue, saturation, intensity: A pointer to a double value representing a
1072 %      component of the HSI color space.
1073 %
1074 */
1075 MagickPrivate void ConvertRGBToHSI(const double red,const double green,
1076   const double blue,double *hue,double *saturation,double *intensity)
1077 {
1078   double
1079     alpha,
1080     beta;
1081
1082   /*
1083     Convert RGB to HSI colorspace.
1084   */
1085   assert(hue != (double *) NULL);
1086   assert(saturation != (double *) NULL);
1087   assert(intensity != (double *) NULL);
1088   *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
1089   if (*intensity <= 0.0)
1090     {
1091       *hue=0.0;
1092       *saturation=0.0;
1093       return;
1094     }
1095   *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1096     QuantumScale*blue))/(*intensity);
1097   alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
1098   beta=0.8660254037844385*(QuantumScale*green-QuantumScale*blue);
1099   *hue=atan2(beta,alpha)*(180.0/MagickPI)/360.0;
1100   if (*hue < 0.0)
1101     *hue+=1.0;
1102 }
1103 \f
1104 /*
1105 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1106 %                                                                             %
1107 %                                                                             %
1108 %                                                                             %
1109 %   C o n v e r t R G B T o H S L                                             %
1110 %                                                                             %
1111 %                                                                             %
1112 %                                                                             %
1113 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1114 %
1115 %  ConvertRGBToHSL() transforms a (red, green, blue) to a (hue, saturation,
1116 %  lightness) triple.
1117 %
1118 %  The format of the ConvertRGBToHSL method is:
1119 %
1120 %      void ConvertRGBToHSL(const double red,const double green,
1121 %        const double blue,double *hue,double *saturation,double *lightness)
1122 %
1123 %  A description of each parameter follows:
1124 %
1125 %    o red, green, blue: A Quantum value representing the red, green, and
1126 %      blue component of a pixel..
1127 %
1128 %    o hue, saturation, lightness: A pointer to a double value representing a
1129 %      component of the HSL color space.
1130 %
1131 */
1132 MagickExport void ConvertRGBToHSL(const double red,const double green,
1133   const double blue,double *hue,double *saturation,double *lightness)
1134 {
1135   double
1136     c,
1137     max,
1138     min;
1139
1140   /*
1141     Convert RGB to HSL colorspace.
1142   */
1143   assert(hue != (double *) NULL);
1144   assert(saturation != (double *) NULL);
1145   assert(lightness != (double *) NULL);
1146   max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
1147     QuantumScale*blue));
1148   min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1149     QuantumScale*blue));
1150   c=max-min;
1151   *lightness=(max+min)/2.0;
1152   if (c <= 0.0)
1153     {
1154       *hue=0.0;
1155       *saturation=0.0;
1156       return;
1157     }
1158   if (max == (QuantumScale*red))
1159     {
1160       *hue=(QuantumScale*green-QuantumScale*blue)/c;
1161       if ((QuantumScale*green) < (QuantumScale*blue))
1162         *hue+=6.0;
1163     }
1164   else
1165     if (max == (QuantumScale*green))
1166       *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
1167     else
1168       *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
1169   *hue*=60.0/360.0;
1170   if (*lightness <= 0.5)
1171     *saturation=c/(2.0*(*lightness));
1172   else
1173     *saturation=c/(2.0-2.0*(*lightness));
1174 }
1175 \f
1176 /*
1177 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1178 %                                                                             %
1179 %                                                                             %
1180 %                                                                             %
1181 %   C o n v e r t R G B T o H S V                                             %
1182 %                                                                             %
1183 %                                                                             %
1184 %                                                                             %
1185 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1186 %
1187 %  ConvertRGBToHSV() transforms a (red, green, blue) to a (hue, saturation,
1188 %  value) triple.
1189 %
1190 %  The format of the ConvertRGBToHSV method is:
1191 %
1192 %      void ConvertRGBToHSV(const double red,const double green,
1193 %        const double blue,double *hue,double *saturation,double *value)
1194 %
1195 %  A description of each parameter follows:
1196 %
1197 %    o red, green, blue: A Quantum value representing the red, green, and
1198 %      blue component of a pixel..
1199 %
1200 %    o hue, saturation, value: A pointer to a double value representing a
1201 %      component of the HSV color space.
1202 %
1203 */
1204 MagickPrivate void ConvertRGBToHSV(const double red,const double green,
1205   const double blue,double *hue,double *saturation,double *value)
1206 {
1207   double
1208     c,
1209     max,
1210     min;
1211
1212   /*
1213     Convert RGB to HSV colorspace.
1214   */
1215   assert(hue != (double *) NULL);
1216   assert(saturation != (double *) NULL);
1217   assert(value != (double *) NULL);
1218   max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
1219     QuantumScale*blue));
1220   min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
1221     QuantumScale*blue));
1222   c=max-min;
1223   *value=max;
1224   if (c <= 0.0)
1225     {
1226       *hue=0.0;
1227       *saturation=0.0;
1228       return;
1229     }
1230   if (max == (QuantumScale*red))
1231     {
1232       *hue=(QuantumScale*green-QuantumScale*blue)/c;
1233       if ((QuantumScale*green) < (QuantumScale*blue))
1234         *hue+=6.0;
1235     }
1236   else
1237     if (max == (QuantumScale*green))
1238       *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
1239     else
1240       *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
1241   *hue*=60.0/360.0;
1242   *saturation=c/max;
1243 }
1244 \f
1245 /*
1246 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1247 %                                                                             %
1248 %                                                                             %
1249 %                                                                             %
1250 %   C o n v e r t R G B T o H W B                                             %
1251 %                                                                             %
1252 %                                                                             %
1253 %                                                                             %
1254 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1255 %
1256 %  ConvertRGBToHWB() transforms a (red, green, blue) to a (hue, whiteness,
1257 %  blackness) triple.
1258 %
1259 %  The format of the ConvertRGBToHWB method is:
1260 %
1261 %      void ConvertRGBToHWB(const double red,const double green,
1262 %        const double blue,double *hue,double *whiteness,double *blackness)
1263 %
1264 %  A description of each parameter follows:
1265 %
1266 %    o red, green, blue: A Quantum value representing the red, green, and
1267 %      blue component of a pixel.
1268 %
1269 %    o hue, whiteness, blackness: A pointer to a double value representing a
1270 %      component of the HWB color space.
1271 %
1272 */
1273 MagickPrivate void ConvertRGBToHWB(const double red,const double green,
1274   const double blue,double *hue,double *whiteness,double *blackness)
1275 {
1276   double
1277     b,
1278     f,
1279     g,
1280     p,
1281     r,
1282     v,
1283     w;
1284
1285   /*
1286     Convert RGB to HWB colorspace.
1287   */
1288   assert(hue != (double *) NULL);
1289   assert(whiteness != (double *) NULL);
1290   assert(blackness != (double *) NULL);
1291   r=red;
1292   g=green;
1293   b=blue;
1294   w=MagickMin(r,MagickMin(g,b));
1295   v=MagickMax(r,MagickMax(g,b));
1296   *blackness=1.0-QuantumScale*v;
1297   *whiteness=QuantumScale*w;
1298   if (v == w)
1299     {
1300       *hue=(-1.0);
1301       return;
1302     }
1303   f=(r == w) ? g-b : ((g == w) ? b-r : r-g);
1304   p=(r == w) ? 3.0 : ((g == w) ? 5.0 : 1.0);
1305   *hue=(p-f/(v-1.0*w))/6.0;
1306 }
1307 \f
1308 /*
1309 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1310 %                                                                             %
1311 %                                                                             %
1312 %                                                                             %
1313 %   C o n v e r t R G B T o L C H a b                                         %
1314 %                                                                             %
1315 %                                                                             %
1316 %                                                                             %
1317 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1318 %
1319 %  ConvertRGBToLCHab() transforms a (red, green, blue) to a (luma, chroma,
1320 %  hue) triple.
1321 %
1322 %  The format of the ConvertRGBToLCHab method is:
1323 %
1324 %      void ConvertRGBToLCHab(const double red,const double green,
1325 %        const double blue,double *luma,double *chroma,double *hue)
1326 %
1327 %  A description of each parameter follows:
1328 %
1329 %    o red, green, blue: A Quantum value representing the red, green, and
1330 %      blue component of a pixel.
1331 %
1332 %    o luma, chroma, hue: A pointer to a double value representing a
1333 %      component of the LCH color space.
1334 %
1335 */
1336
1337 static inline void ConvertXYZToLCHab(const double X,const double Y,
1338   const double Z,double *luma,double *chroma,double *hue)
1339 {
1340   double
1341     a,
1342     b;
1343
1344   ConvertXYZToLab(X,Y,Z,luma,&a,&b);
1345   *chroma=hypot(255.0*(a-0.5),255.0*(b-0.5))/255.0+0.5;
1346   *hue=180.0*atan2(255.0*(b-0.5),255.0*(a-0.5))/MagickPI/360.0;
1347   if (*hue < 0.0)
1348     *hue+=1.0;
1349 }
1350
1351 MagickPrivate void ConvertRGBToLCHab(const double red,const double green,
1352   const double blue,double *luma,double *chroma,double *hue)
1353 {
1354   double
1355     X,
1356     Y,
1357     Z;
1358
1359   /*
1360     Convert RGB to LCHab colorspace.
1361   */
1362   assert(luma != (double *) NULL);
1363   assert(chroma != (double *) NULL);
1364   assert(hue != (double *) NULL);
1365   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1366   ConvertXYZToLCHab(X,Y,Z,luma,chroma,hue);
1367 }
1368 \f
1369 /*
1370 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1371 %                                                                             %
1372 %                                                                             %
1373 %                                                                             %
1374 %   C o n v e r t R G B T o L C H u v                                         %
1375 %                                                                             %
1376 %                                                                             %
1377 %                                                                             %
1378 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1379 %
1380 %  ConvertRGBToLCHuv() transforms a (red, green, blue) to a (luma, chroma,
1381 %  hue) triple.
1382 %
1383 %  The format of the ConvertRGBToLCHuv method is:
1384 %
1385 %      void ConvertRGBToLCHuv(const double red,const double green,
1386 %        const double blue,double *luma,double *chroma,double *hue)
1387 %
1388 %  A description of each parameter follows:
1389 %
1390 %    o red, green, blue: A Quantum value representing the red, green, and
1391 %      blue component of a pixel.
1392 %
1393 %    o luma, chroma, hue: A pointer to a double value representing a
1394 %      component of the LCHuv color space.
1395 %
1396 */
1397
1398 static inline void ConvertXYZToLCHuv(const double X,const double Y,
1399   const double Z,double *luma,double *chroma,double *hue)
1400 {
1401   double
1402     u,
1403     v;
1404
1405   ConvertXYZToLuv(X,Y,Z,luma,&u,&v);
1406   *chroma=hypot(354.0*u-134.0,262.0*v-140.0)/255.0+0.5;
1407   *hue=180.0*atan2(262.0*v-140.0,354.0*u-134.0)/MagickPI/360.0;
1408   if (*hue < 0.0)
1409     *hue+=1.0;
1410 }
1411
1412 MagickPrivate void ConvertRGBToLCHuv(const double red,const double green,
1413   const double blue,double *luma,double *chroma,double *hue)
1414 {
1415   double
1416     X,
1417     Y,
1418     Z;
1419
1420   /*
1421     Convert RGB to LCHuv colorspace.
1422   */
1423   assert(luma != (double *) NULL);
1424   assert(chroma != (double *) NULL);
1425   assert(hue != (double *) NULL);
1426   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
1427   ConvertXYZToLCHuv(X,Y,Z,luma,chroma,hue);
1428 }
1429 \f
1430 /*
1431 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1432 %                                                                             %
1433 %                                                                             %
1434 %                                                                             %
1435 %   E x p a n d A f f i n e                                                   %
1436 %                                                                             %
1437 %                                                                             %
1438 %                                                                             %
1439 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1440 %
1441 %  ExpandAffine() computes the affine's expansion factor, i.e. the square root
1442 %  of the factor by which the affine transform affects area. In an affine
1443 %  transform composed of scaling, rotation, shearing, and translation, returns
1444 %  the amount of scaling.
1445 %
1446 %  The format of the ExpandAffine method is:
1447 %
1448 %      double ExpandAffine(const AffineMatrix *affine)
1449 %
1450 %  A description of each parameter follows:
1451 %
1452 %    o expansion: ExpandAffine returns the affine's expansion factor.
1453 %
1454 %    o affine: A pointer the affine transform of type AffineMatrix.
1455 %
1456 */
1457 MagickExport double ExpandAffine(const AffineMatrix *affine)
1458 {
1459   assert(affine != (const AffineMatrix *) NULL);
1460   return(sqrt(fabs(affine->sx*affine->sy-affine->rx*affine->ry)));
1461 }
1462 \f
1463 /*
1464 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1465 %                                                                             %
1466 %                                                                             %
1467 %                                                                             %
1468 %   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                         %
1469 %                                                                             %
1470 %                                                                             %
1471 %                                                                             %
1472 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1473 %
1474 %  GenerateDifferentialNoise() generates differentual noise.
1475 %
1476 %  The format of the GenerateDifferentialNoise method is:
1477 %
1478 %      double GenerateDifferentialNoise(RandomInfo *random_info,
1479 %        const Quantum pixel,const NoiseType noise_type,const double attenuate)
1480 %
1481 %  A description of each parameter follows:
1482 %
1483 %    o random_info: the random info.
1484 %
1485 %    o pixel: noise is relative to this pixel value.
1486 %
1487 %    o noise_type: the type of noise.
1488 %
1489 %    o attenuate:  attenuate the noise.
1490 %
1491 */
1492 MagickPrivate double GenerateDifferentialNoise(RandomInfo *random_info,
1493   const Quantum pixel,const NoiseType noise_type,const double attenuate)
1494 {
1495 #define SigmaUniform  (attenuate*0.015625)
1496 #define SigmaGaussian  (attenuate*0.015625)
1497 #define SigmaImpulse  (attenuate*0.1)
1498 #define SigmaLaplacian (attenuate*0.0390625)
1499 #define SigmaMultiplicativeGaussian  (attenuate*0.5)
1500 #define SigmaPoisson  (attenuate*12.5)
1501 #define SigmaRandom  (attenuate)
1502 #define TauGaussian  (attenuate*0.078125)
1503
1504   double
1505     alpha,
1506     beta,
1507     noise,
1508     sigma;
1509
1510   alpha=GetPseudoRandomValue(random_info);
1511   switch (noise_type)
1512   {
1513     case UniformNoise:
1514     default:
1515     {
1516       noise=(double) (pixel+QuantumRange*SigmaUniform*(alpha-0.5));
1517       break;
1518     }
1519     case GaussianNoise:
1520     {
1521       double
1522         gamma,
1523         tau;
1524
1525       if (alpha == 0.0)
1526         alpha=1.0;
1527       beta=GetPseudoRandomValue(random_info);
1528       gamma=sqrt(-2.0*log(alpha));
1529       sigma=gamma*cos((double) (2.0*MagickPI*beta));
1530       tau=gamma*sin((double) (2.0*MagickPI*beta));
1531       noise=(double) (pixel+sqrt((double) pixel)*SigmaGaussian*sigma+
1532         QuantumRange*TauGaussian*tau);
1533       break;
1534     }
1535     case ImpulseNoise:
1536     {
1537       if (alpha < (SigmaImpulse/2.0))
1538         noise=0.0;
1539       else
1540         if (alpha >= (1.0-(SigmaImpulse/2.0)))
1541           noise=(double) QuantumRange;
1542         else
1543           noise=(double) pixel;
1544       break;
1545     }
1546     case LaplacianNoise:
1547     {
1548       if (alpha <= 0.5)
1549         {
1550           if (alpha <= MagickEpsilon)
1551             noise=(double) (pixel-QuantumRange);
1552           else
1553             noise=(double) (pixel+QuantumRange*SigmaLaplacian*log(2.0*alpha)+
1554               0.5);
1555           break;
1556         }
1557       beta=1.0-alpha;
1558       if (beta <= (0.5*MagickEpsilon))
1559         noise=(double) (pixel+QuantumRange);
1560       else
1561         noise=(double) (pixel-QuantumRange*SigmaLaplacian*log(2.0*beta)+0.5);
1562       break;
1563     }
1564     case MultiplicativeGaussianNoise:
1565     {
1566       sigma=1.0;
1567       if (alpha > MagickEpsilon)
1568         sigma=sqrt(-2.0*log(alpha));
1569       beta=GetPseudoRandomValue(random_info);
1570       noise=(double) (pixel+pixel*SigmaMultiplicativeGaussian*sigma*
1571         cos((double) (2.0*MagickPI*beta))/2.0);
1572       break;
1573     }
1574     case PoissonNoise:
1575     {
1576       double
1577         poisson;
1578
1579       register ssize_t
1580         i;
1581
1582       poisson=exp(-SigmaPoisson*QuantumScale*pixel);
1583       for (i=0; alpha > poisson; i++)
1584       {
1585         beta=GetPseudoRandomValue(random_info);
1586         alpha*=beta;
1587       }
1588       noise=(double) (QuantumRange*i/SigmaPoisson);
1589       break;
1590     }
1591     case RandomNoise:
1592     {
1593       noise=(double) (QuantumRange*SigmaRandom*alpha);
1594       break;
1595     }
1596   }
1597   return(noise);
1598 }
1599 \f
1600 /*
1601 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1602 %                                                                             %
1603 %                                                                             %
1604 %                                                                             %
1605 %   G e t O p t i m a l K e r n e l W i d t h                                 %
1606 %                                                                             %
1607 %                                                                             %
1608 %                                                                             %
1609 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1610 %
1611 %  GetOptimalKernelWidth() computes the optimal kernel radius for a convolution
1612 %  filter.  Start with the minimum value of 3 pixels and walk out until we drop
1613 %  below the threshold of one pixel numerical accuracy.
1614 %
1615 %  The format of the GetOptimalKernelWidth method is:
1616 %
1617 %      size_t GetOptimalKernelWidth(const double radius,
1618 %        const double sigma)
1619 %
1620 %  A description of each parameter follows:
1621 %
1622 %    o width: GetOptimalKernelWidth returns the optimal width of a
1623 %      convolution kernel.
1624 %
1625 %    o radius: the radius of the Gaussian, in pixels, not counting the center
1626 %      pixel.
1627 %
1628 %    o sigma: the standard deviation of the Gaussian, in pixels.
1629 %
1630 */
1631 MagickPrivate size_t GetOptimalKernelWidth1D(const double radius,
1632   const double sigma)
1633 {
1634   double
1635     alpha,
1636     beta,
1637     gamma,
1638     normalize,
1639     value;
1640
1641   register ssize_t
1642     i;
1643
1644   size_t
1645     width;
1646
1647   ssize_t
1648     j;
1649
1650   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1651   if (radius > MagickEpsilon)
1652     return((size_t) (2.0*ceil(radius)+1.0));
1653   gamma=fabs(sigma);
1654   if (gamma <= MagickEpsilon)
1655     return(3UL);
1656   alpha=PerceptibleReciprocal(2.0*gamma*gamma);
1657   beta=(double) PerceptibleReciprocal((double) MagickSQ2PI*gamma);
1658   for (width=5; ; )
1659   {
1660     normalize=0.0;
1661     j=(ssize_t) (width-1)/2;
1662     for (i=(-j); i <= j; i++)
1663       normalize+=exp(-((double) (i*i))*alpha)*beta;
1664     value=exp(-((double) (j*j))*alpha)*beta/normalize;
1665     if ((value < QuantumScale) || (value < MagickEpsilon))
1666       break;
1667     width+=2;
1668   }
1669   return((size_t) (width-2));
1670 }
1671
1672 MagickPrivate size_t GetOptimalKernelWidth2D(const double radius,
1673   const double sigma)
1674 {
1675   double
1676     alpha,
1677     beta,
1678     gamma,
1679     normalize,
1680     value;
1681
1682   size_t
1683     width;
1684
1685   ssize_t
1686     j,
1687     u,
1688     v;
1689
1690   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1691   if (radius > MagickEpsilon)
1692     return((size_t) (2.0*ceil(radius)+1.0));
1693   gamma=fabs(sigma);
1694   if (gamma <= MagickEpsilon)
1695     return(3UL);
1696   alpha=PerceptibleReciprocal(2.0*gamma*gamma);
1697   beta=(double) PerceptibleReciprocal((double) Magick2PI*gamma*gamma);
1698   for (width=5; ; )
1699   {
1700     normalize=0.0;
1701     j=(ssize_t) (width-1)/2;
1702     for (v=(-j); v <= j; v++)
1703       for (u=(-j); u <= j; u++)
1704         normalize+=exp(-((double) (u*u+v*v))*alpha)*beta;
1705     value=exp(-((double) (j*j))*alpha)*beta/normalize;
1706     if ((value < QuantumScale) || (value < MagickEpsilon))
1707       break;
1708     width+=2;
1709   }
1710   return((size_t) (width-2));
1711 }
1712
1713 MagickPrivate size_t  GetOptimalKernelWidth(const double radius,
1714   const double sigma)
1715 {
1716   return(GetOptimalKernelWidth1D(radius,sigma));
1717 }