MagickCore  6.9.10
Convert, Edit, Or Compose Bitmap Images
pixel-accessor.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2018 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  https://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 #include <math.h>
22 #include "magick/gem.h"
23 #include "magick/pixel.h"
24 
25 #if defined(__cplusplus) || defined(c_plusplus)
26 extern "C" {
27 #endif
28 
29 #define ClampPixelRed(pixel) ClampToQuantum((pixel)->red)
30 #define ClampPixelGreen(pixel) ClampToQuantum((pixel)->green)
31 #define ClampPixelBlue(pixel) ClampToQuantum((pixel)->blue)
32 #define ClampPixelIndex(indexes) ClampToQuantum(*(indexes))
33 #define ClampPixelOpacity(pixel) ClampToQuantum((pixel)->opacity)
34 #define GetPixela(pixel) ((pixel)->green)
35 #define GetPixelb(pixel) ((pixel)->blue)
36 #define GetPixelAlpha(pixel) (QuantumRange-(pixel)->opacity)
37 #define GetPixelBlack(indexes) (*(indexes))
38 #define GetPixelBlue(pixel) ((pixel)->blue)
39 #define GetPixelCb(pixel) ((pixel)->green)
40 #define GetPixelCr(pixel) ((pixel)->blue)
41 #define GetPixelCyan(pixel) ((pixel)->red)
42 #define GetPixelGray(pixel) ((pixel)->red)
43 #define GetPixelGreen(pixel) ((pixel)->green)
44 #define GetPixelIndex(indexes) (*(indexes))
45 #define GetPixelL(pixel) ((pixel)->red)
46 #define GetPixelLabel(pixel) ((ssize_t) (pixel)->red)
47 #define GetPixelMagenta(pixel) ((pixel)->green)
48 #define GetPixelNext(pixel) ((pixel)+1)
49 #define GetPixelOpacity(pixel) ((pixel)->opacity)
50 #define GetPixelRed(pixel) ((pixel)->red)
51 #define GetPixelRGB(pixel,packet) \
52 { \
53  (packet)->red=GetPixelRed((pixel)); \
54  (packet)->green=GetPixelGreen((pixel)); \
55  (packet)->blue=GetPixelBlue((pixel)); \
56 }
57 #define GetPixelRGBO(pixel,packet) \
58 { \
59  (packet)->red=GetPixelRed((pixel)); \
60  (packet)->green=GetPixelGreen((pixel)); \
61  (packet)->blue=GetPixelBlue((pixel)); \
62  (packet)->opacity=GetPixelOpacity((pixel)); \
63 }
64 #define GetPixelY(pixel) ((pixel)->red)
65 #define GetPixelYellow(pixel) ((pixel)->blue)
66 #define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
67 #define SetPixelAlpha(pixel,value) \
68  ((pixel)->opacity=(Quantum) (QuantumRange-(value)))
69 #define SetPixelb(pixel,value) ((pixel)->blue=(Quantum) (value))
70 #define SetPixelBlack(indexes,value) (*(indexes)=(Quantum) (value))
71 #define SetPixelBlue(pixel,value) ((pixel)->blue=(Quantum) (value))
72 #define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
73 #define SetPixelCr(pixel,value) ((pixel)->blue=(Quantum) (value))
74 #define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
75 #define SetPixelGray(pixel,value) \
76  ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
77 #define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
78 #define SetPixelIndex(indexes,value) (*(indexes)=(IndexPacket) (value))
79 #define SetPixelL(pixel,value) ((pixel)->red=(Quantum) (value))
80 #define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
81 #define SetPixelOpacity(pixel,value) ((pixel)->opacity=(Quantum) (value))
82 #define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
83 #define SetPixelRgb(pixel,packet) \
84 { \
85  SetPixelRed(pixel,(packet)->red); \
86  SetPixelGreen(pixel,(packet)->green); \
87  SetPixelBlue(pixel,(packet)->blue); \
88 }
89 #define SetPixelRGBA(pixel,packet) \
90 { \
91  SetPixelRed(pixel,(packet)->red); \
92  SetPixelGreen(pixel,(packet)->green); \
93  SetPixelBlue(pixel,(packet)->blue); \
94  SetPixelAlpha(pixel,(QuantumRange-(packet)->opacity)); \
95 }
96 #define SetPixelRGBO(pixel,packet) \
97 { \
98  SetPixelRed(pixel,(packet)->red); \
99  SetPixelGreen(pixel,(packet)->green); \
100  SetPixelBlue(pixel,(packet)->blue); \
101  SetPixelOpacity(pixel,(packet)->opacity); \
102 }
103 #define SetPixelYellow(pixel,value) ((pixel)->blue=(Quantum) (value))
104 #define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
105 
107 {
108  return(x < 0.0f ? -x : x);
109 }
110 
111 static inline Quantum ClampPixel(const MagickRealType value)
112 {
113  if (value < 0.0f)
114  return(0);
115  if (value >= (MagickRealType) QuantumRange)
116  return((Quantum) QuantumRange);
117 #if !defined(MAGICKCORE_HDRI_SUPPORT)
118  return((Quantum) (value+0.5f));
119 #else
120  return((Quantum) value);
121 #endif
122 }
123 
124 static inline double PerceptibleReciprocal(const double x)
125 {
126  double
127  sign;
128 
129  /*
130  Return 1/x where x is perceptible (not unlimited or infinitesimal).
131  */
132  sign=x < 0.0 ? -1.0 : 1.0;
133  if ((sign*x) >= MagickEpsilon)
134  return(1.0/x);
135  return(sign/MagickEpsilon);
136 }
137 
139  const PixelPacket *magick_restrict pixel)
140 {
142  intensity;
143 
144  (void) image;
145  intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
146  0.072186f*pixel->blue);
147  return(intensity);
148 }
149 
151  const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
152 {
154  intensity;
155 
156  if (image->colorspace != sRGBColorspace)
157  {
158  intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
159  0.072186f*pixel->blue);
160  return(intensity);
161  }
162  intensity=(MagickRealType) (0.212656f*DecodePixelGamma((MagickRealType)
163  pixel->red)+0.715158f*DecodePixelGamma((MagickRealType) pixel->green)+
164  0.072186f*DecodePixelGamma((MagickRealType) pixel->blue));
165  return(intensity);
166 }
167 
168 static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
169  const QuantumAny range)
170 {
171  Quantum
172  quantum;
173 
174 #if !defined(MAGICKCORE_HDRI_SUPPORT)
176  (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
177 #else
179  (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range);
180 #endif
181  return(pixel == quantum ? MagickTrue : MagickFalse);
182 }
183 
184 static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
185 {
187  green_blue,
188  red_green;
189 
190  red_green=(MagickRealType) pixel->red-pixel->green;
191  green_blue=(MagickRealType) pixel->green-pixel->blue;
192  if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
194  return(MagickTrue);
195  return(MagickFalse);
196 }
197 
199 {
201  green_blue,
202  red,
203  red_green;
204 
205  red=(MagickRealType) pixel->red;
206  if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
208  return(MagickFalse);
209  red_green=(MagickRealType) pixel->red-pixel->green;
210  green_blue=(MagickRealType) pixel->green-pixel->blue;
211  if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
213  return(MagickTrue);
214  return(MagickFalse);
215 }
216 
217 static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
218 {
220  intensity;
221 
222  if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
223  return(pixel->red);
224  intensity=(MagickRealType) (0.212656*pixel->red+0.715158*pixel->green+
225  0.072186*pixel->blue);
226  return(ClampToQuantum(intensity));
227 }
228 
229 static inline void SetPixelViaMagickPixel(const Image *magick_restrict image,
230  const MagickPixelPacket *magick_restrict magick_pixel,
232 {
233  pixel->red=ClampToQuantum(magick_pixel->red);
234  pixel->green=ClampToQuantum(magick_pixel->green);
235  pixel->blue=ClampToQuantum(magick_pixel->blue);
236  if (image->matte != MagickFalse)
237  pixel->opacity=ClampToQuantum(magick_pixel->opacity);
238 }
239 
240 #if defined(__cplusplus) || defined(c_plusplus)
241 }
242 #endif
243 
244 #endif
#define magick_restrict
Definition: MagickCore.h:41
MagickDoubleType MagickRealType
Definition: magick-type.h:123
static MagickRealType GetPixelLuma(const Image *magick_restrict image, const PixelPacket *magick_restrict pixel)
Definition: pixel-accessor.h:138
Definition: colorspace.h:40
Quantum blue
Definition: pixel.h:143
static MagickRealType GetPixelLuminance(const Image *magick_restrict image, const PixelPacket *magick_restrict pixel)
Definition: pixel-accessor.h:150
static MagickRealType AbsolutePixelValue(const MagickRealType x)
Definition: pixel-accessor.h:106
Definition: pixel.h:131
Quantum green
Definition: pixel.h:143
#define MagickEpsilon
Definition: magick-type.h:115
Definition: image.h:152
MagickExport MagickRealType DecodePixelGamma(const MagickRealType pixel)
Definition: pixel.c:255
static void SetPixelViaMagickPixel(const Image *magick_restrict image, const MagickPixelPacket *magick_restrict magick_pixel, PixelPacket *magick_restrict pixel)
Definition: pixel-accessor.h:229
MagickBooleanType
Definition: magick-type.h:189
static double PerceptibleReciprocal(const double x)
Definition: pixel-accessor.h:124
Quantum red
Definition: pixel.h:143
Definition: pixel.h:104
static MagickBooleanType IsPixelAtDepth(const Quantum pixel, const QuantumAny range)
Definition: pixel-accessor.h:168
static Quantum ClampPixel(const MagickRealType value)
Definition: pixel-accessor.h:111
Definition: magick-type.h:192
#define QuantumScale
Definition: magick-type.h:118
static Quantum PixelPacketIntensity(const PixelPacket *pixel)
Definition: pixel-accessor.h:217
static MagickBooleanType IsPixelGray(const PixelPacket *pixel)
Definition: pixel-accessor.h:184
static Quantum ClampToQuantum(const MagickRealType value)
Definition: quantum.h:87
Definition: magick-type.h:191
unsigned short Quantum
Definition: magick-type.h:85
static MagickBooleanType IsPixelMonochrome(const PixelPacket *pixel)
Definition: pixel-accessor.h:198
MagickSizeType QuantumAny
Definition: magick-type.h:148
#define QuantumRange
Definition: magick-type.h:86