granicus.if.org Git - imagemagick/blob - MagickCore/pixel-accessor.h

   1 /*
   2   Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization
   3   dedicated to making software imaging solutions freely available.
   4
   5   You may not use this file except in compliance with the License.
   6   obtain a copy of the License at
   7
   8     http://www.imagemagick.org/script/license.php
   9
  10   Unless required by applicable law or agreed to in writing, software
  11   distributed under the License is distributed on an "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   See the License for the specific language governing permissions and
  14   limitations under the License.
  15
  16   MagickCore pixel accessor methods.
  17 */
  18 #ifndef _MAGICKCORE_PIXEL_ACCESSOR_H
  19 #define _MAGICKCORE_PIXEL_ACCESSOR_H
  20
  21 #if defined(__cplusplus) || defined(c_plusplus)
  22 extern "C" {
  23 #endif
  24
  25 #include <math.h>
  26 #include <MagickCore/cache-view.h>
  27 #include <MagickCore/color.h>
  28 #include <MagickCore/image.h>
  29
  30 #undef index
  31
  32 static inline Quantum GetPixelAlpha(const Image *image,const Quantum *pixel)
  33 {
  34   return(pixel[image->channel_map[AlphaPixelChannel].channel]);
  35 }
  36
  37 static inline PixelTrait GetPixelAlphaTraits(const Image *image)
  38 {
  39   return(image->channel_map[AlphaPixelChannel].traits);
  40 }
  41
  42 static inline Quantum GetPixelBlack(const Image *image,const Quantum *pixel)
  43 {
  44   return(pixel[image->channel_map[BlackPixelChannel].channel]);
  45 }
  46
  47 static inline PixelTrait GetPixelBlackTraits(const Image *image)
  48 {
  49   return(image->channel_map[BlackPixelChannel].traits);
  50 }
  51
  52 static inline Quantum GetPixelBlue(const Image *image,const Quantum *pixel)
  53 {
  54   return(pixel[image->channel_map[BluePixelChannel].channel]);
  55 }
  56
  57 static inline PixelTrait GetPixelBlueTraits(const Image *image)
  58 {
  59   return(image->channel_map[BluePixelChannel].traits);
  60 }
  61
  62 static inline Quantum GetPixelCb(const Image *image,const Quantum *pixel)
  63 {
  64   return(pixel[image->channel_map[CbPixelChannel].channel]);
  65 }
  66
  67 static inline PixelTrait GetPixelCbTraits(const Image *image)
  68 {
  69   return(image->channel_map[CbPixelChannel].traits);
  70 }
  71
  72 static inline Quantum GetPixelChannel(const Image *image,
  73   const PixelChannel channel,const Quantum *pixel)
  74 {
  75   return(pixel[image->channel_map[channel].channel]);
  76 }
  77
  78 static inline PixelChannel GetPixelChannelMapChannel(const Image *image,
  79   const PixelChannel channel)
  80 {
  81   return(image->channel_map[channel].channel);
  82 }
  83
  84 static inline PixelTrait GetPixelChannelMapTraits(const Image *image,
  85   const PixelChannel channel)
  86 {
  87   return(image->channel_map[channel].traits);
  88 }
  89
  90 static inline size_t GetPixelChannels(const Image *image)
  91 {
  92   return(image->number_channels);
  93 }
  94
  95 static inline Quantum GetPixelCr(const Image *image,const Quantum *pixel)
  96 {
  97   return(pixel[image->channel_map[CrPixelChannel].channel]);
  98 }
  99
 100 static inline PixelTrait GetPixelCrTraits(const Image *image)
 101 {
 102   return(image->channel_map[CrPixelChannel].traits);
 103 }
 104
 105 static inline Quantum GetPixelCyan(const Image *image,const Quantum *pixel)
 106 {
 107   return(pixel[image->channel_map[CyanPixelChannel].channel]);
 108 }
 109
 110 static inline PixelTrait GetPixelCyanTraits(const Image *image)
 111 {
 112   return(image->channel_map[CyanPixelChannel].traits);
 113 }
 114
 115 static inline Quantum GetPixelGray(const Image *image,const Quantum *pixel)
 116 {
 117   return(pixel[image->channel_map[GrayPixelChannel].channel]);
 118 }
 119
 120 static inline PixelTrait GetPixelGrayTraits(const Image *image)
 121 {
 122   return(image->channel_map[GrayPixelChannel].traits);
 123 }
 124
 125 static inline Quantum GetPixelGreen(const Image *image,const Quantum *pixel)
 126 {
 127   return(pixel[image->channel_map[GreenPixelChannel].channel]);
 128 }
 129
 130 static inline PixelTrait GetPixelGreenTraits(const Image *image)
 131 {
 132   return(image->channel_map[GreenPixelChannel].traits);
 133 }
 134
 135 static inline Quantum GetPixelIndex(const Image *image,const Quantum *pixel)
 136 {
 137   return(pixel[image->channel_map[IndexPixelChannel].channel]);
 138 }
 139
 140 static inline PixelTrait GetPixelIndexTraits(const Image *image)
 141 {
 142   return(image->channel_map[IndexPixelChannel].traits);
 143 }
 144
 145 static inline Quantum GetPixelInfoIntensity(const PixelInfo *pixel_info)
 146 {
 147 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 148   return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*
 149     pixel_info->blue+0.5));
 150 #else
 151   return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*
 152     pixel_info->blue));
 153 #endif
 154 }
 155
 156 static inline Quantum GetPixelInfoLuminance(const PixelInfo *pixel_info)
 157 {
 158   Quantum
 159     luminance;
 160
 161 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 162   luminance=(Quantum) (0.21267*pixel_info->red+0.71516*pixel_info->green+
 163     0.07217*pixel_info->blue+0.5);
 164 #else
 165   luminance=(Quantum) (0.21267*pixel_info->red+0.71516*pixel_info->green+
 166     0.07217*pixel_info->blue);
 167 #endif
 168   return((Quantum) luminance);
 169 }
 170
 171 static inline Quantum GetPixelMagenta(const Image *image,const Quantum *pixel)
 172 {
 173   return(pixel[image->channel_map[MagentaPixelChannel].channel]);
 174 }
 175
 176 static inline PixelTrait GetPixelMagentaTraits(const Image *image)
 177 {
 178   return(image->channel_map[MagentaPixelChannel].traits);
 179 }
 180
 181 static inline size_t GetPixelMetaChannels(const Image *image)
 182 {
 183   return(image->number_meta_channels);
 184 }
 185
 186 static inline size_t GetPixelMetacontentExtent(const Image *image)
 187 {
 188   return(image->metacontent_extent);
 189 }
 190
 191 static inline Quantum GetPixelRed(const Image *image,const Quantum *pixel)
 192 {
 193   return(pixel[image->channel_map[RedPixelChannel].channel]);
 194 }
 195
 196 static inline PixelTrait GetPixelRedTraits(const Image *image)
 197 {
 198   return(image->channel_map[RedPixelChannel].traits);
 199 }
 200
 201 static inline void GetPixelPacket(const Image *image,const Quantum *pixel,
 202   PixelPacket *packet)
 203 {
 204   packet->red=GetPixelRed(image,pixel);
 205   packet->green=GetPixelGreen(image,pixel);
 206   packet->blue=GetPixelBlue(image,pixel);
 207   packet->alpha=GetPixelAlpha(image,pixel);
 208 }
 209
 210 static inline Quantum GetPixelPacketIntensity(const PixelPacket *pixel)
 211 {
 212 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 213   if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
 214     return(pixel->red);
 215   return((Quantum) (0.299*pixel->red+0.587*pixel->green+0.114*pixel->blue+0.5));
 216 #else
 217   {
 218     double
 219       alpha,
 220       beta;
 221
 222     alpha=pixel->red-pixel->green;
 223     beta=pixel->green-pixel->blue;
 224     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 225       return(pixel->red);
 226     return((Quantum) (0.299*pixel->red+0.587*pixel->green+0.114*pixel->blue));
 227   }
 228 #endif
 229 }
 230
 231 static inline PixelTrait GetPixelTraits(const Image *image,
 232   const PixelChannel channel)
 233 {
 234   return(image->channel_map[channel].traits);
 235 }
 236
 237 static inline Quantum GetPixelY(const Image *image,const Quantum *pixel)
 238 {
 239   return(pixel[image->channel_map[YPixelChannel].channel]);
 240 }
 241
 242 static inline PixelTrait GetPixelYTraits(const Image *image)
 243 {
 244   return(image->channel_map[YPixelChannel].traits);
 245 }
 246
 247 static inline Quantum GetPixelYellow(const Image *image,const Quantum *pixel)
 248 {
 249   return(pixel[image->channel_map[YellowPixelChannel].channel]);
 250 }
 251
 252 static inline PixelTrait GetPixelYellowTraits(const Image *image)
 253 {
 254   return(image->channel_map[YellowPixelChannel].traits);
 255 }
 256
 257 static inline MagickBooleanType IsPixelEquivalent(const Image *image,
 258   const Quantum *p,const PixelPacket *q)
 259 {
 260   if ((GetPixelRed(image,p) == q->red) &&
 261       (GetPixelGreen(image,p) == q->green) &&
 262       (GetPixelBlue(image,p) == q->blue))
 263     return(MagickTrue);
 264   return(MagickFalse);
 265 }
 266
 267 static inline MagickBooleanType IsPixelGray(const Image *image,
 268   const Quantum *pixel)
 269 {
 270 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 271   if ((GetPixelRed(image,pixel) == GetPixelGreen(image,pixel)) &&
 272       (GetPixelGreen(image,pixel) == GetPixelBlue(image,pixel)))
 273     return(MagickTrue);
 274 #else
 275   {
 276     double
 277       alpha,
 278       beta;
 279
 280     alpha=GetPixelRed(image,pixel)-(double) GetPixelGreen(image,pixel);
 281     beta=GetPixelGreen(image,pixel)-(double) GetPixelBlue(image,pixel);
 282     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 283       return(MagickTrue);
 284   }
 285 #endif
 286   return(MagickFalse);
 287 }
 288
 289 static inline MagickBooleanType IsPixelInfoEquivalent(const PixelInfo *p,
 290   const PixelInfo *q)
 291 {
 292   if ((p->matte != MagickFalse) && (q->matte == MagickFalse) &&
 293       (fabs(p->alpha-OpaqueAlpha) > 0.5))
 294     return(MagickFalse);
 295   if ((q->matte != MagickFalse) && (p->matte == MagickFalse) &&
 296       (fabs(q->alpha-OpaqueAlpha)) > 0.5)
 297     return(MagickFalse);
 298   if ((p->matte != MagickFalse) && (q->matte != MagickFalse))
 299     {
 300       if (fabs(p->alpha-q->alpha) > 0.5)
 301         return(MagickFalse);
 302       if (fabs(p->alpha-TransparentAlpha) <= 0.5)
 303         return(MagickTrue);
 304     }
 305   if (fabs(p->red-q->red) > 0.5)
 306     return(MagickFalse);
 307   if (fabs(p->green-q->green) > 0.5)
 308     return(MagickFalse);
 309   if (fabs(p->blue-q->blue) > 0.5)
 310     return(MagickFalse);
 311   if ((p->colorspace == CMYKColorspace) && (fabs(p->black-q->black) > 0.5))
 312     return(MagickFalse);
 313   return(MagickTrue);
 314 }
 315
 316 static inline MagickBooleanType IsPixelMonochrome(const Image *image,
 317   const Quantum *pixel)
 318 {
 319 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 320   if (((GetPixelRed(image,pixel) == 0) ||
 321       (GetPixelRed(image,pixel) == (Quantum) QuantumRange)) &&
 322       (GetPixelRed(image,pixel) == GetPixelGreen(image,pixel)) &&
 323       (GetPixelGreen(image,pixel) == GetPixelBlue(image,pixel)))
 324     return(MagickTrue);
 325 #else
 326   {
 327     double
 328       alpha,
 329       beta;
 330
 331     alpha=GetPixelRed(image,pixel)-(double) GetPixelGreen(image,pixel);
 332     beta=GetPixelGreen(image,pixel)-(double) GetPixelBlue(image,pixel);
 333     if (((fabs(GetPixelRed(image,pixel)) <= MagickEpsilon) ||
 334          (fabs(GetPixelRed(image,pixel)-QuantumRange) <= MagickEpsilon)) &&
 335         (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 336       return(MagickTrue);
 337     }
 338 #endif
 339   return(MagickFalse);
 340 }
 341
 342 static inline MagickBooleanType IsPixelPacketEquivalent(const PixelPacket *p,
 343   const PixelPacket *q)
 344 {
 345   if ((p->red == q->red) && (p->green == q->green) && (p->blue == q->blue))
 346     return(MagickTrue);
 347   return(MagickFalse);
 348 }
 349
 350 static inline MagickBooleanType IsPixelPacketGray(const PixelPacket *pixel)
 351 {
 352 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 353   if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
 354     return(MagickTrue);
 355 #else
 356   {
 357     double
 358       alpha,
 359       beta;
 360
 361     alpha=pixel->red-(double) pixel->green;
 362     beta=pixel->green-(double) pixel->blue;
 363     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 364       return(MagickTrue);
 365   }
 366 #endif
 367   return(MagickFalse);
 368 }
 369
 370 static inline MagickBooleanType IsPixelPacketMonochrome(
 371   const PixelPacket *pixel)
 372 {
 373 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 374   if (((pixel->red == 0) || (pixel->red == (Quantum) QuantumRange)) &&
 375       (pixel->red == pixel->green) && (pixel->green == pixel->blue))
 376     return(MagickTrue);
 377 #else
 378   {
 379     double
 380       alpha,
 381       beta;
 382
 383     alpha=pixel->red-(double) pixel->green;
 384     beta=pixel->green-(double) pixel->blue;
 385     if (((fabs(pixel->red) <= MagickEpsilon) ||
 386          (fabs(pixel->red-QuantumRange) <= MagickEpsilon)) &&
 387         (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 388       return(MagickTrue);
 389     }
 390 #endif
 391   return(MagickFalse);
 392 }
 393
 394 static inline void SetPacketPixelInfo(const Image *image,
 395   const PixelInfo *pixel_info,PixelPacket *packet)
 396 {
 397   packet->red=ClampToQuantum(pixel_info->red);
 398   packet->green=ClampToQuantum(pixel_info->green);
 399   packet->blue=ClampToQuantum(pixel_info->blue);
 400   packet->alpha=ClampToQuantum(pixel_info->alpha);
 401   if (image->colorspace == CMYKColorspace)
 402     packet->black=ClampToQuantum(pixel_info->black);
 403   if (image->storage_class == PseudoClass)
 404     packet->index=ClampToQuantum(pixel_info->index);
 405 }
 406
 407 static inline void SetPixelAlpha(const Image *image,const Quantum alpha,
 408   Quantum *pixel)
 409 {
 410   pixel[image->channel_map[AlphaPixelChannel].channel]=alpha;
 411 }
 412
 413 static inline void SetPixelAlphaTraits(Image *image,const PixelTrait traits)
 414 {
 415   image->channel_map[AlphaPixelChannel].traits=traits;
 416 }
 417
 418 static inline void SetPixelBlack(const Image *image,const Quantum black,
 419   Quantum *pixel)
 420 {
 421   pixel[image->channel_map[BlackPixelChannel].channel]=black;
 422 }
 423
 424 static inline void SetPixelBlackTraits(Image *image,const PixelTrait traits)
 425 {
 426   image->channel_map[BlackPixelChannel].traits=traits;
 427 }
 428
 429 static inline void SetPixelBlue(const Image *image,const Quantum blue,
 430   Quantum *pixel)
 431 {
 432   pixel[image->channel_map[BluePixelChannel].channel]=blue;
 433 }
 434
 435 static inline void SetPixelBlueTraits(Image *image,const PixelTrait traits)
 436 {
 437   image->channel_map[BluePixelChannel].traits=traits;
 438 }
 439
 440 static inline void SetPixelCb(const Image *image,const Quantum cb,
 441   Quantum *pixel)
 442 {
 443   pixel[image->channel_map[CbPixelChannel].channel]=cb;
 444 }
 445
 446 static inline void SetPixelCbTraits(Image *image,const PixelTrait traits)
 447 {
 448   image->channel_map[CbPixelChannel].traits=traits;
 449 }
 450
 451 static inline void SetPixelChannel(const Image *image,
 452   const PixelChannel channel,const Quantum quantum,Quantum *pixel)
 453 {
 454   pixel[image->channel_map[channel].channel]=quantum;
 455 }
 456
 457 static inline void SetPixelChannelMapChannel(const Image *image,
 458   const PixelChannel channel,const PixelChannel channels)
 459 {
 460   image->channel_map[channel].channel=channels;
 461 }
 462
 463 static inline void SetPixelChannels(Image *image,const size_t number_channels)
 464 {
 465   image->number_channels=number_channels;
 466 }
 467
 468 static inline void SetPixelChannelTraits(Image *image,
 469   const PixelChannel channel,const PixelTrait traits)
 470 {
 471   image->channel_map[channel].traits=traits;
 472 }
 473
 474 static inline void SetPixelChannelMapTraits(Image *image,
 475   const PixelChannel channel,const PixelTrait traits)
 476 {
 477   image->channel_map[channel].traits=traits;
 478 }
 479
 480 static inline void SetPixelCr(const Image *image,const Quantum cr,
 481   Quantum *pixel)
 482 {
 483   pixel[image->channel_map[CrPixelChannel].channel]=cr;
 484 }
 485
 486 static inline void SetPixelCrTraits(Image *image,const PixelTrait traits)
 487 {
 488   image->channel_map[CrPixelChannel].traits=traits;
 489 }
 490
 491 static inline void SetPixelCyan(const Image *image,const Quantum cyan,
 492   Quantum *pixel)
 493 {
 494   pixel[image->channel_map[CyanPixelChannel].channel]=cyan;
 495 }
 496
 497 static inline void SetPixelGray(const Image *image,const Quantum gray,
 498   Quantum *pixel)
 499 {
 500   pixel[image->channel_map[GrayPixelChannel].channel]=gray;
 501 }
 502
 503 static inline void SetPixelGrayTraits(Image *image,const PixelTrait traits)
 504 {
 505   image->channel_map[GrayPixelChannel].traits=traits;
 506 }
 507
 508 static inline void SetPixelGreen(const Image *image,const Quantum green,
 509   Quantum *pixel)
 510 {
 511   pixel[image->channel_map[GreenPixelChannel].channel]=green;
 512 }
 513
 514 static inline void SetPixelGreenTraits(Image *image,const PixelTrait traits)
 515 {
 516   image->channel_map[GreenPixelChannel].traits=traits;
 517 }
 518
 519 static inline void SetPixelIndex(const Image *image,const Quantum index,
 520   Quantum *pixel)
 521 {
 522   pixel[image->channel_map[IndexPixelChannel].channel]=index;
 523 }
 524
 525 static inline void SetPixelIndexTraits(Image *image,const PixelTrait traits)
 526 {
 527   image->channel_map[IndexPixelChannel].traits=traits;
 528 }
 529
 530 static inline void SetPixelInfo(const Image *image,const Quantum *pixel,
 531   PixelInfo *pixel_info)
 532 {
 533   pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
 534   pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
 535   pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
 536   pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
 537   if (image->colorspace == CMYKColorspace)
 538     pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
 539   if (image->storage_class == PseudoClass)
 540     pixel_info->index=(MagickRealType) GetPixelIndex(image,pixel);
 541 }
 542
 543 static inline void SetPixelInfoBias(const Image *image,PixelInfo *pixel_info)
 544 {
 545   /*
 546     Obsoleted by MorphologyApply().
 547   */
 548   pixel_info->red=image->bias;
 549   pixel_info->green=image->bias;
 550   pixel_info->blue=image->bias;
 551   pixel_info->alpha=image->bias;
 552   pixel_info->black=image->bias;
 553 }
 554
 555 static inline void SetPixelInfoPacket(const Image *image,
 556   const PixelPacket *pixel,PixelInfo *pixel_info)
 557 {
 558   pixel_info->red=(MagickRealType) pixel->red;
 559   pixel_info->green=(MagickRealType) pixel->green;
 560   pixel_info->blue=(MagickRealType) pixel->blue;
 561   pixel_info->alpha=(MagickRealType) pixel->alpha;
 562   if (image->colorspace == CMYKColorspace)
 563     pixel_info->black=(MagickRealType) pixel->black;
 564   if (image->storage_class == PseudoClass)
 565     pixel_info->index=(MagickRealType) pixel->index;
 566 }
 567
 568 static inline void SetPixelMagenta(const Image *image,const Quantum magenta,
 569   Quantum *pixel)
 570 {
 571   pixel[image->channel_map[MagentaPixelChannel].channel]=magenta;
 572 }
 573
 574 static inline void SetPixelMagentaTraits(Image *image,const PixelTrait traits)
 575 {
 576   image->channel_map[MagentaPixelChannel].traits=traits;
 577 }
 578
 579 static inline void SetPixelMetaChannels(Image *image,
 580   const size_t number_meta_channels)
 581 {
 582   image->number_meta_channels=number_meta_channels;
 583 }
 584
 585 static inline void SetPixelMetacontentExtent(Image *image,const size_t extent)
 586 {
 587   image->metacontent_extent=extent;
 588 }
 589
 590 static inline void SetPixelRed(const Image *image,const Quantum red,
 591   Quantum *pixel)
 592 {
 593   pixel[image->channel_map[RedPixelChannel].channel]=red;
 594 }
 595
 596 static inline void SetPixelRedTraits(Image *image,const PixelTrait traits)
 597 {
 598   image->channel_map[RedPixelChannel].traits=traits;
 599 }
 600
 601 static inline void SetPixelPacket(const Image *image,const PixelPacket *packet,
 602   Quantum *pixel)
 603 {
 604   SetPixelRed(image,packet->red,pixel);
 605   SetPixelGreen(image,packet->green,pixel);
 606   SetPixelBlue(image,packet->blue,pixel);
 607   SetPixelAlpha(image,packet->alpha,pixel);
 608 }
 609
 610 static inline void SetPixelPixelInfo(const Image *image,
 611   const PixelInfo *pixel_info,Quantum *packet)
 612 {
 613   SetPixelRed(image,ClampToQuantum(pixel_info->red),packet);
 614   SetPixelGreen(image,ClampToQuantum(pixel_info->green),packet);
 615   SetPixelBlue(image,ClampToQuantum(pixel_info->blue),packet);
 616   SetPixelAlpha(image,ClampToQuantum(pixel_info->alpha),packet);
 617   if (image->colorspace == CMYKColorspace)
 618     SetPixelBlack(image,ClampToQuantum(pixel_info->black),packet);
 619 }
 620
 621 static inline void SetPixelYellow(const Image *image,const Quantum yellow,
 622   Quantum *pixel)
 623 {
 624   pixel[image->channel_map[YellowPixelChannel].channel]=yellow;
 625 }
 626
 627 static inline void SetPixelYellowTraits(Image *image,const PixelTrait traits)
 628 {
 629   image->channel_map[YellowPixelChannel].traits=traits;
 630 }
 631
 632 static inline void SetPixelY(const Image *image,const Quantum y,Quantum *pixel)
 633 {
 634   pixel[image->channel_map[YPixelChannel].channel]=y;
 635 }
 636
 637 static inline void SetPixelYTraits(Image *image,const PixelTrait traits)
 638 {
 639   image->channel_map[YPixelChannel].traits=traits;
 640 }
 641
 642 static inline Quantum GetPixelIntensity(const Image *image,const Quantum *pixel)
 643 {
 644 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 645   if ((GetPixelRed(image,pixel) == GetPixelGreen(image,pixel)) &&
 646       (GetPixelGreen(image,pixel) == GetPixelBlue(image,pixel)))
 647     return(GetPixelRed(image,pixel));
 648   return((Quantum) (0.299*GetPixelRed(image,pixel)+0.587*
 649     GetPixelGreen(image,pixel)+0.114*GetPixelBlue(image,pixel)+0.5));
 650 #else
 651   {
 652     double
 653       alpha,
 654       beta;
 655
 656     alpha=GetPixelRed(image,pixel)-(double) GetPixelGreen(image,pixel);
 657     beta=GetPixelGreen(image,pixel)-(double) GetPixelBlue(image,pixel);
 658     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 659       return(GetPixelRed(image,pixel));
 660     return((Quantum) (0.299*GetPixelRed(image,pixel)+0.587*
 661       GetPixelGreen(image,pixel)+0.114*GetPixelBlue(image,pixel)));
 662   }
 663 #endif
 664 }
 665
 666 static inline Quantum GetPixelLuminance(const Image *image,const Quantum *pixel)
 667 {
 668 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 669   return((Quantum) (0.21267*GetPixelRed(image,pixel)+0.71516*
 670     GetPixelGreen(image,pixel)+0.07217*GetPixelBlue(image,pixel)+0.5));
 671 #else
 672   return((Quantum) (0.21267*GetPixelRed(image,pixel)+0.71516*
 673     GetPixelGreen(image,pixel)+0.07217*GetPixelBlue(image,pixel)));
 674 #endif
 675 }
 676
 677 #if defined(__cplusplus) || defined(c_plusplus)
 678 }
 679 #endif
 680
 681 #endif