pixel-accessor.h

Go to the documentation of this file.
00001 /*
00002   Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization
00003   dedicated to making software imaging solutions freely available.
00004 
00005   You may not use this file except in compliance with the License.  You may
00006   obtain a copy of the License at
00007 
00008     https://imagemagick.org/script/license.php
00009 
00010   Unless required by applicable law or agreed to in writing, software
00011   distributed under the License is distributed on an "AS IS" BASIS,
00012   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013   See the License for the specific language governing permissions and
00014   limitations under the License.
00015 
00016   MagickCore pixel accessor methods.
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     Return 1/x where x is perceptible (not unlimited or infinitesimal).
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

Generated on 30 Sep 2019 for MagickCore by  doxygen 1.6.1