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 static inline Quantum GetPixelAlpha(const Image *image,const Quantum *pixel)
  31 {
  32   return(pixel[image->component_map[AlphaPixelComponent].component]);
  33 }
  34
  35 static inline Quantum GetPixelBlack(const Image *image,const Quantum *pixel)
  36 {
  37   return(pixel[image->component_map[BlackPixelComponent].component]);
  38 }
  39
  40 static inline Quantum GetPixelBlue(const Image *image,const Quantum *pixel)
  41 {
  42   return(pixel[image->component_map[BluePixelComponent].component]);
  43 }
  44
  45 static inline Quantum GetPixelCb(const Image *image,const Quantum *pixel)
  46 {
  47   return(pixel[image->component_map[CbPixelComponent].component]);
  48 }
  49
  50 static inline size_t GetPixelChannels(const Image *image)
  51 {
  52   return(image->pixel_channels);
  53 }
  54
  55 static inline Quantum GetPixelCr(const Image *image,const Quantum *pixel)
  56 {
  57   return(pixel[image->component_map[CrPixelComponent].component]);
  58 }
  59
  60 static inline Quantum GetPixelCyan(const Image *image,const Quantum *pixel)
  61 {
  62   return(pixel[image->component_map[CyanPixelComponent].component]);
  63 }
  64
  65 static inline Quantum GetPixelGray(const Image *image,const Quantum *pixel)
  66 {
  67   return(pixel[image->component_map[GrayPixelComponent].component]);
  68 }
  69
  70 static inline Quantum GetPixelGreen(const Image *image,const Quantum *pixel)
  71 {
  72   return(pixel[image->component_map[GreenPixelComponent].component]);
  73 }
  74
  75 static inline Quantum GetPixelIndex(const Image *image,const Quantum *pixel)
  76 {
  77   return(pixel[image->component_map[IndexPixelComponent].component]);
  78 }
  79
  80 static inline Quantum GetPixelInfoIntensity(const PixelInfo *pixel_info)
  81 {
  82 #if !defined(MAGICKCORE_HDRI_SUPPORT)
  83   return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*pixel_info->blue+0.5));
  84 #else
  85   return((Quantum) (0.299*pixel_info->red+0.587*pixel_info->green+0.114*pixel_info->blue));
  86 #endif
  87 }
  88
  89 static inline Quantum GetPixelInfoLuminance(const PixelInfo *pixel_info)
  90 {
  91   Quantum
  92     luminance;
  93
  94 #if !defined(MAGICKCORE_HDRI_SUPPORT)
  95   luminance=(Quantum) (0.21267*pixel_info->red+0.71516*pixel_info->green+
  96     0.07217*pixel_info->blue+0.5);
  97 #else
  98   luminance=(Quantum) (0.21267*pixel_info->red+0.71516*pixel_info->green+
  99     0.07217*pixel_info->blue);
 100 #endif
 101   return((Quantum) luminance);
 102 }
 103
 104 static inline Quantum GetPixelMagenta(const Image *image,
 105   const Quantum *pixel)
 106 {
 107   return(pixel[image->component_map[MagentaPixelComponent].component]);
 108 }
 109
 110 static inline size_t GetPixelMetacontentExtent(const Image *image)
 111 {
 112   return(image->metacontent_extent);
 113 }
 114
 115 static inline Quantum GetPixelRed(const Image *image,const Quantum *pixel)
 116 {
 117   return(pixel[image->component_map[RedPixelComponent].component]);
 118 }
 119
 120 static inline void GetPixelPacket(const Image *image,const Quantum *pixel,
 121   PixelPacket *packet)
 122 {
 123   packet->red=GetPixelRed(image,pixel);
 124   packet->green=GetPixelGreen(image,pixel);
 125   packet->blue=GetPixelBlue(image,pixel);
 126   packet->alpha=GetPixelAlpha(image,pixel);
 127 }
 128
 129 static inline Quantum GetPixelPacketIntensity(const PixelPacket *pixel)
 130 {
 131 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 132   if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
 133     return(pixel->red);
 134   return((Quantum) (0.299*pixel->red+0.587*pixel->green+0.114*pixel->blue+0.5));
 135 #else
 136   {
 137     double
 138       alpha,
 139       beta;
 140
 141     alpha=pixel->red-pixel->green;
 142     beta=pixel->green-pixel->blue;
 143     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 144       return(pixel->red);
 145     return((Quantum) (0.299*pixel->red+0.587*pixel->green+0.114*pixel->blue));
 146   }
 147 #endif
 148 }
 149
 150 static inline Quantum GetPixelY(const Image *image,const Quantum *pixel)
 151 {
 152   return(pixel[image->component_map[YPixelComponent].component]);
 153 }
 154
 155 static inline Quantum GetPixelYellow(const Image *image,
 156   const Quantum *pixel)
 157 {
 158   return(pixel[image->component_map[YellowPixelComponent].component]);
 159 }
 160
 161 static inline MagickBooleanType IsPixelEquivalent(const Image *image,
 162   const Quantum *p,const PixelPacket *q)
 163 {
 164   if ((GetPixelRed(image,p) == q->red) &&
 165       (GetPixelGreen(image,p) == q->green) &&
 166       (GetPixelBlue(image,p) == q->blue))
 167     return(MagickTrue);
 168   return(MagickFalse);
 169 }
 170
 171 static inline MagickBooleanType IsPixelGray(const Image *image,
 172   const Quantum *pixel)
 173 {
 174 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 175   if ((GetPixelRed(image,pixel) == GetPixelGreen(image,pixel)) &&
 176       (GetPixelGreen(image,pixel) == GetPixelBlue(image,pixel)))
 177     return(MagickTrue);
 178 #else
 179   {
 180     double
 181       alpha,
 182       beta;
 183
 184     alpha=GetPixelRed(image,pixel)-(double) GetPixelGreen(image,pixel);
 185     beta=GetPixelGreen(image,pixel)-(double) GetPixelBlue(image,pixel);
 186     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 187       return(MagickTrue);
 188   }
 189 #endif
 190   return(MagickFalse);
 191 }
 192
 193 static inline MagickBooleanType IsPixelInfoEquivalent(const PixelInfo *p,
 194   const PixelInfo *q)
 195 {
 196 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 197   if ((p->matte != MagickFalse) && (q->matte == MagickFalse) &&
 198       (p->alpha != OpaqueAlpha))
 199     return(MagickFalse);
 200   if ((q->matte != MagickFalse) && (p->matte == MagickFalse) &&
 201       (q->alpha != OpaqueAlpha))
 202     return(MagickFalse);
 203   if ((p->matte != MagickFalse) && (q->matte != MagickFalse))
 204     {
 205       if (p->alpha != q->alpha)
 206         return(MagickFalse);
 207       if (p->alpha == TransparentAlpha)
 208         return(MagickTrue);
 209     }
 210   if (p->red != q->red)
 211     return(MagickFalse);
 212   if (p->green != q->green)
 213     return(MagickFalse);
 214   if (p->blue != q->blue)
 215     return(MagickFalse);
 216   if ((p->colorspace == CMYKColorspace) && (p->black != q->black))
 217     return(MagickFalse);
 218 #else
 219   if ((p->matte != MagickFalse) && (q->matte == MagickFalse) &&
 220       (fabs(p->alpha-OpaqueAlpha) > 0.5))
 221     return(MagickFalse);
 222   if ((q->matte != MagickFalse) && (p->matte == MagickFalse) &&
 223       (fabs(q->alpha-OpaqueAlpha)) > 0.5)
 224     return(MagickFalse);
 225   if ((p->matte != MagickFalse) && (q->matte != MagickFalse))
 226     {
 227       if (fabs(p->alpha-q->alpha) > 0.5)
 228         return(MagickFalse);
 229       if (fabs(p->alpha-TransparentAlpha) <= 0.5)
 230         return(MagickTrue);
 231     }
 232   if (fabs(p->red-q->red) > 0.5)
 233     return(MagickFalse);
 234   if (fabs(p->green-q->green) > 0.5)
 235     return(MagickFalse);
 236   if (fabs(p->blue-q->blue) > 0.5)
 237     return(MagickFalse);
 238   if ((p->colorspace == CMYKColorspace) && (fabs(p->black-q->black) > 0.5))
 239     return(MagickFalse);
 240 #endif
 241   return(MagickTrue);
 242 }
 243
 244 static inline MagickBooleanType IsPixelMonochrome(const Image *image,
 245   const Quantum *pixel)
 246 {
 247 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 248   if (((GetPixelRed(image,pixel) == 0) ||
 249       (GetPixelRed(image,pixel) == (Quantum) QuantumRange)) &&
 250       (GetPixelRed(image,pixel) == GetPixelGreen(image,pixel)) &&
 251       (GetPixelGreen(image,pixel) == GetPixelBlue(image,pixel)))
 252     return(MagickTrue);
 253 #else
 254   {
 255     double
 256       alpha,
 257       beta;
 258
 259     alpha=GetPixelRed(image,pixel)-(double) GetPixelGreen(image,pixel);
 260     beta=GetPixelGreen(image,pixel)-(double) GetPixelBlue(image,pixel);
 261     if (((fabs(GetPixelRed(image,pixel)) <= MagickEpsilon) ||
 262          (fabs(GetPixelRed(image,pixel)-QuantumRange) <= MagickEpsilon)) &&
 263         (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 264       return(MagickTrue);
 265     }
 266 #endif
 267   return(MagickFalse);
 268 }
 269
 270 static inline MagickBooleanType IsPixelPacketEquivalent(const PixelPacket *p,
 271   const PixelPacket *q)
 272 {
 273   if ((p->red == q->red) && (p->green == q->green) && (p->blue == q->blue))
 274     return(MagickTrue);
 275   return(MagickFalse);
 276 }
 277
 278 static inline MagickBooleanType IsPixelPacketGray(const PixelPacket *pixel)
 279 {
 280 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 281   if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
 282     return(MagickTrue);
 283 #else
 284   {
 285     double
 286       alpha,
 287       beta;
 288
 289     alpha=pixel->red-(double) pixel->green;
 290     beta=pixel->green-(double) pixel->blue;
 291     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 292       return(MagickTrue);
 293   }
 294 #endif
 295   return(MagickFalse);
 296 }
 297
 298 static inline MagickBooleanType IsPixelPacketMonochrome(
 299   const PixelPacket *pixel)
 300 {
 301 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 302   if (((pixel->red == 0) || (pixel->red == (Quantum) QuantumRange)) &&
 303       (pixel->red == pixel->green) && (pixel->green == pixel->blue))
 304     return(MagickTrue);
 305 #else
 306   {
 307     double
 308       alpha,
 309       beta;
 310
 311     alpha=pixel->red-(double) pixel->green;
 312     beta=pixel->green-(double) pixel->blue;
 313     if (((fabs(pixel->red) <= MagickEpsilon) ||
 314          (fabs(pixel->red-QuantumRange) <= MagickEpsilon)) &&
 315         (fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 316       return(MagickTrue);
 317     }
 318 #endif
 319   return(MagickFalse);
 320 }
 321
 322 static inline void SetPacketPixelInfo(const Image *image,
 323   const PixelInfo *pixel_info,PixelPacket *packet)
 324 {
 325   packet->red=ClampToQuantum(pixel_info->red);
 326   packet->green=ClampToQuantum(pixel_info->green);
 327   packet->blue=ClampToQuantum(pixel_info->blue);
 328   packet->alpha=ClampToQuantum(pixel_info->alpha);
 329   if (image->colorspace == CMYKColorspace)
 330     packet->black=ClampToQuantum(pixel_info->black);
 331   if (image->storage_class == PseudoClass)
 332     packet->index=ClampToQuantum(pixel_info->index);
 333 }
 334
 335 static inline void SetPixelAlpha(const Image *image,const Quantum alpha,
 336   Quantum *pixel)
 337 {
 338   pixel[image->component_map[AlphaPixelComponent].component]=alpha;
 339 }
 340
 341 static inline void SetPixelBlack(const Image *image,const Quantum black,
 342   Quantum *pixel)
 343 {
 344   pixel[image->component_map[BlackPixelComponent].component]=black;
 345 }
 346
 347 static inline void SetPixelBlue(const Image *image,const Quantum blue,
 348   Quantum *pixel)
 349 {
 350   pixel[image->component_map[BluePixelComponent].component]=blue;
 351 }
 352
 353 static inline void SetPixelCb(const Image *image,const Quantum cb,
 354   Quantum *pixel)
 355 {
 356   pixel[image->component_map[CbPixelComponent].component]=cb;
 357 }
 358
 359 static inline void SetPixelChannels(Image *image,const size_t channels)
 360 {
 361   image->pixel_channels=channels;
 362 }
 363
 364 static inline void SetPixelCr(const Image *image,const Quantum cr,
 365   Quantum *pixel)
 366 {
 367   pixel[image->component_map[CrPixelComponent].component]=cr;
 368 }
 369
 370 static inline void SetPixelCyan(const Image *image,const Quantum cyan,
 371   Quantum *pixel)
 372 {
 373   pixel[image->component_map[CyanPixelComponent].component]=cyan;
 374 }
 375
 376 static inline void SetPixelGray(const Image *image,const Quantum gray,
 377   Quantum *pixel)
 378 {
 379   pixel[image->component_map[GrayPixelComponent].component]=gray;
 380 }
 381
 382 static inline void SetPixelGreen(const Image *image,const Quantum green,
 383   Quantum *pixel)
 384 {
 385   pixel[image->component_map[GreenPixelComponent].component]=green;
 386 }
 387
 388 static inline void SetPixelIndex(const Image *image,const Quantum index,
 389   Quantum *pixel)
 390 {
 391   pixel[image->component_map[IndexPixelComponent].component]=index;
 392 }
 393
 394 static inline void SetPixelInfo(const Image *image,const Quantum *pixel,
 395   PixelInfo *pixel_info)
 396 {
 397   pixel_info->red=(MagickRealType) GetPixelRed(image,pixel);
 398   pixel_info->green=(MagickRealType) GetPixelGreen(image,pixel);
 399   pixel_info->blue=(MagickRealType) GetPixelBlue(image,pixel);
 400   pixel_info->alpha=(MagickRealType) GetPixelAlpha(image,pixel);
 401   if (image->colorspace == CMYKColorspace)
 402     pixel_info->black=(MagickRealType) GetPixelBlack(image,pixel);
 403   if (image->storage_class == PseudoClass)
 404     pixel_info->index=(MagickRealType) GetPixelIndex(image,pixel);
 405 }
 406
 407 static inline void SetPixelInfoBias(const Image *image,
 408   PixelInfo *pixel_info)
 409 {
 410   /*
 411     Obsoleted by MorphologyApply().
 412   */
 413   pixel_info->red=image->bias;
 414   pixel_info->green=image->bias;
 415   pixel_info->blue=image->bias;
 416   pixel_info->alpha=image->bias;
 417   pixel_info->black=image->bias;
 418 }
 419
 420 static inline void SetPixelInfoPacket(const Image *image,
 421   const PixelPacket *pixel,PixelInfo *pixel_info)
 422 {
 423   pixel_info->red=(MagickRealType) pixel->red;
 424   pixel_info->green=(MagickRealType) pixel->green;
 425   pixel_info->blue=(MagickRealType) pixel->blue;
 426   pixel_info->alpha=(MagickRealType) pixel->alpha;
 427   if (image->colorspace == CMYKColorspace)
 428     pixel_info->black=(MagickRealType) pixel->black;
 429   if (image->storage_class == PseudoClass)
 430     pixel_info->index=(MagickRealType) pixel->index;
 431 }
 432
 433 static inline void SetPixelMagenta(const Image *image,const Quantum magenta,
 434   Quantum *pixel)
 435 {
 436   pixel[image->component_map[MagentaPixelComponent].component]=magenta;
 437 }
 438
 439 static inline void SetPixelMetacontentExtent(Image *image,const size_t extent)
 440 {
 441   image->metacontent_extent=extent;
 442 }
 443
 444 static inline void SetPixelRed(const Image *image,const Quantum red,
 445   Quantum *pixel)
 446 {
 447   pixel[image->component_map[RedPixelComponent].component]=red;
 448 }
 449
 450 static inline void SetPixelPacket(const Image *image,const PixelPacket *packet,
 451   Quantum *pixel)
 452 {
 453   SetPixelRed(image,packet->red,pixel);
 454   SetPixelGreen(image,packet->green,pixel);
 455   SetPixelBlue(image,packet->blue,pixel);
 456   SetPixelAlpha(image,packet->alpha,pixel);
 457 }
 458
 459 static inline void SetPixelPixelInfo(const Image *image,
 460   const PixelInfo *pixel_info,Quantum *packet)
 461 {
 462   SetPixelRed(image,ClampToQuantum(pixel_info->red),packet);
 463   SetPixelGreen(image,ClampToQuantum(pixel_info->green),packet);
 464   SetPixelBlue(image,ClampToQuantum(pixel_info->blue),packet);
 465   SetPixelAlpha(image,ClampToQuantum(pixel_info->alpha),packet);
 466   if (image->colorspace == CMYKColorspace)
 467     SetPixelBlack(image,ClampToQuantum(pixel_info->black),packet);
 468 }
 469
 470 static inline void SetPixelYellow(const Image *image,const Quantum yellow,
 471   Quantum *pixel)
 472 {
 473   pixel[image->component_map[YellowPixelComponent].component]=yellow;
 474 }
 475
 476 static inline void SetPixelY(const Image *image,const Quantum y,
 477   Quantum *pixel)
 478 {
 479   pixel[image->component_map[YPixelComponent].component]=y;
 480 }
 481
 482 static inline Quantum GetPixelIntensity(const Image *image,
 483   const Quantum *pixel)
 484 {
 485 #if !defined(MAGICKCORE_HDRI_SUPPORT)
 486   if ((GetPixelRed(image,pixel) == GetPixelGreen(image,pixel)) &&
 487       (GetPixelGreen(image,pixel) == GetPixelBlue(image,pixel)))
 488     return(GetPixelRed(image,pixel));
 489   return((Quantum) (0.299*GetPixelRed(image,pixel)+0.587*
 490     GetPixelGreen(image,pixel)+0.114*GetPixelBlue(image,pixel)+0.5));
 491 #else
 492   {
 493     double
 494       alpha,
 495       beta;
 496
 497     alpha=GetPixelRed(image,pixel)-(double) GetPixelGreen(image,pixel);
 498     beta=GetPixelGreen(image,pixel)-(double) GetPixelBlue(image,pixel);
 499     if ((fabs(alpha) <= MagickEpsilon) && (fabs(beta) <= MagickEpsilon))
 500       return(GetPixelRed(image,pixel));
 501     return((Quantum) (0.299*GetPixelRed(image,pixel)+0.587*
 502       GetPixelGreen(image,pixel)+0.114*GetPixelBlue(image,pixel)));
 503   }
 504 #endif
 505 }
 506
 507 #if defined(__cplusplus) || defined(c_plusplus)
 508 }
 509 #endif
 510
 511 #endif