00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #ifndef MAGICKCORE_PIXEL_ACCESSOR_H
00019 #define MAGICKCORE_PIXEL_ACCESSOR_H
00020
00021 #include <math.h>
00022 #include "magick/gem.h"
00023 #include "magick/pixel.h"
00024
00025 #if defined(__cplusplus) || defined(c_plusplus)
00026 extern "C" {
00027 #endif
00028
00029 #define ClampPixelRed(pixel) ClampToQuantum((pixel)->red)
00030 #define ClampPixelGreen(pixel) ClampToQuantum((pixel)->green)
00031 #define ClampPixelBlue(pixel) ClampToQuantum((pixel)->blue)
00032 #define ClampPixelIndex(indexes) ClampToQuantum(*(indexes))
00033 #define ClampPixelOpacity(pixel) ClampToQuantum((pixel)->opacity)
00034 #define GetPixela(pixel) ((pixel)->green)
00035 #define GetPixelb(pixel) ((pixel)->blue)
00036 #define GetPixelAlpha(pixel) (QuantumRange-(pixel)->opacity)
00037 #define GetPixelBlack(indexes) (*(indexes))
00038 #define GetPixelBlue(pixel) ((pixel)->blue)
00039 #define GetPixelCb(pixel) ((pixel)->green)
00040 #define GetPixelCr(pixel) ((pixel)->blue)
00041 #define GetPixelCyan(pixel) ((pixel)->red)
00042 #define GetPixelGray(pixel) ((pixel)->red)
00043 #define GetPixelGreen(pixel) ((pixel)->green)
00044 #define GetPixelIndex(indexes) (*(indexes))
00045 #define GetPixelL(pixel) ((pixel)->red)
00046 #define GetPixelLabel(pixel) ((ssize_t) (pixel)->red)
00047 #define GetPixelMagenta(pixel) ((pixel)->green)
00048 #define GetPixelNext(pixel) ((pixel)+1)
00049 #define GetPixelOpacity(pixel) ((pixel)->opacity)
00050 #define GetPixelRed(pixel) ((pixel)->red)
00051 #define GetPixelRGB(pixel,packet) \
00052 { \
00053 (packet)->red=GetPixelRed((pixel)); \
00054 (packet)->green=GetPixelGreen((pixel)); \
00055 (packet)->blue=GetPixelBlue((pixel)); \
00056 }
00057 #define GetPixelRGBO(pixel,packet) \
00058 { \
00059 (packet)->red=GetPixelRed((pixel)); \
00060 (packet)->green=GetPixelGreen((pixel)); \
00061 (packet)->blue=GetPixelBlue((pixel)); \
00062 (packet)->opacity=GetPixelOpacity((pixel)); \
00063 }
00064 #define GetPixelY(pixel) ((pixel)->red)
00065 #define GetPixelYellow(pixel) ((pixel)->blue)
00066 #define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
00067 #define SetPixelAlpha(pixel,value) \
00068 ((pixel)->opacity=(Quantum) (QuantumRange-(value)))
00069 #define SetPixelb(pixel,value) ((pixel)->blue=(Quantum) (value))
00070 #define SetPixelBlack(indexes,value) (*(indexes)=(Quantum) (value))
00071 #define SetPixelBlue(pixel,value) ((pixel)->blue=(Quantum) (value))
00072 #define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
00073 #define SetPixelCr(pixel,value) ((pixel)->blue=(Quantum) (value))
00074 #define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
00075 #define SetPixelGray(pixel,value) \
00076 ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
00077 #define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
00078 #define SetPixelIndex(indexes,value) (*(indexes)=(IndexPacket) (value))
00079 #define SetPixelL(pixel,value) ((pixel)->red=(Quantum) (value))
00080 #define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
00081 #define SetPixelOpacity(pixel,value) ((pixel)->opacity=(Quantum) (value))
00082 #define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
00083 #define SetPixelRgb(pixel,packet) \
00084 { \
00085 SetPixelRed(pixel,(packet)->red); \
00086 SetPixelGreen(pixel,(packet)->green); \
00087 SetPixelBlue(pixel,(packet)->blue); \
00088 }
00089 #define SetPixelRGBA(pixel,packet) \
00090 { \
00091 SetPixelRed(pixel,(packet)->red); \
00092 SetPixelGreen(pixel,(packet)->green); \
00093 SetPixelBlue(pixel,(packet)->blue); \
00094 SetPixelAlpha(pixel,(QuantumRange-(packet)->opacity)); \
00095 }
00096 #define SetPixelRGBO(pixel,packet) \
00097 { \
00098 SetPixelRed(pixel,(packet)->red); \
00099 SetPixelGreen(pixel,(packet)->green); \
00100 SetPixelBlue(pixel,(packet)->blue); \
00101 SetPixelOpacity(pixel,(packet)->opacity); \
00102 }
00103 #define SetPixelYellow(pixel,value) ((pixel)->blue=(Quantum) (value))
00104 #define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
00105
00106 static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
00107 {
00108 return(x < 0.0f ? -x : x);
00109 }
00110
00111 static inline Quantum ClampPixel(const MagickRealType value)
00112 {
00113 if (value < 0.0f)
00114 return((Quantum) 0);
00115 if (value >= (MagickRealType) QuantumRange)
00116 return((Quantum) QuantumRange);
00117 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00118 return((Quantum) (value+0.5f));
00119 #else
00120 return((Quantum) value);
00121 #endif
00122 }
00123
00124 static inline double PerceptibleReciprocal(const double x)
00125 {
00126 double
00127 sign;
00128
00129
00130
00131
00132 sign=x < 0.0 ? -1.0 : 1.0;
00133 if ((sign*x) >= MagickEpsilon)
00134 return(1.0/x);
00135 return(sign/MagickEpsilon);
00136 }
00137
00138 static inline MagickRealType GetPixelLuma(const Image *magick_restrict image,
00139 const PixelPacket *magick_restrict pixel)
00140 {
00141 MagickRealType
00142 intensity;
00143
00144 (void) image;
00145 intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
00146 0.072186f*pixel->blue);
00147 return(intensity);
00148 }
00149
00150 static inline MagickRealType GetPixelLuminance(
00151 const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
00152 {
00153 MagickRealType
00154 intensity;
00155
00156 if (image->colorspace != sRGBColorspace)
00157 {
00158 intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
00159 0.072186f*pixel->blue);
00160 return(intensity);
00161 }
00162 intensity=(MagickRealType) (0.212656f*DecodePixelGamma((MagickRealType)
00163 pixel->red)+0.715158f*DecodePixelGamma((MagickRealType) pixel->green)+
00164 0.072186f*DecodePixelGamma((MagickRealType) pixel->blue));
00165 return(intensity);
00166 }
00167
00168 static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
00169 const QuantumAny range)
00170 {
00171 Quantum
00172 quantum;
00173
00174 if (range == 0)
00175 return(MagickTrue);
00176 #if !defined(MAGICKCORE_HDRI_SUPPORT)
00177 quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
00178 (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
00179 #else
00180 quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
00181 (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range);
00182 #endif
00183 return(pixel == quantum ? MagickTrue : MagickFalse);
00184 }
00185
00186 static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
00187 {
00188 MagickRealType
00189 green_blue,
00190 red_green;
00191
00192 red_green=(MagickRealType) pixel->red-pixel->green;
00193 green_blue=(MagickRealType) pixel->green-pixel->blue;
00194 if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
00195 ((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
00196 return(MagickTrue);
00197 return(MagickFalse);
00198 }
00199
00200 static inline MagickBooleanType IsPixelMonochrome(const PixelPacket *pixel)
00201 {
00202 MagickRealType
00203 green_blue,
00204 red,
00205 red_green;
00206
00207 red=(MagickRealType) pixel->red;
00208 if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
00209 (AbsolutePixelValue(red-QuantumRange) >= MagickEpsilon))
00210 return(MagickFalse);
00211 red_green=(MagickRealType) pixel->red-pixel->green;
00212 green_blue=(MagickRealType) pixel->green-pixel->blue;
00213 if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
00214 ((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
00215 return(MagickTrue);
00216 return(MagickFalse);
00217 }
00218
00219 static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
00220 {
00221 MagickRealType
00222 intensity;
00223
00224 if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
00225 return(pixel->red);
00226 intensity=(MagickRealType) (0.212656*pixel->red+0.715158*pixel->green+
00227 0.072186*pixel->blue);
00228 return(ClampToQuantum(intensity));
00229 }
00230
00231 static inline void SetPixelViaMagickPixel(const Image *magick_restrict image,
00232 const MagickPixelPacket *magick_restrict magick_pixel,
00233 PixelPacket *magick_restrict pixel)
00234 {
00235 pixel->red=ClampToQuantum(magick_pixel->red);
00236 pixel->green=ClampToQuantum(magick_pixel->green);
00237 pixel->blue=ClampToQuantum(magick_pixel->blue);
00238 if (image->matte != MagickFalse)
00239 pixel->opacity=ClampToQuantum(magick_pixel->opacity);
00240 }
00241
00242 #if defined(__cplusplus) || defined(c_plusplus)
00243 }
00244 #endif
00245
00246 #endif