MagickCore  6.9.13-8
Convert, Edit, Or Compose Bitmap Images
pixel-accessor.h
1 /*
2  Copyright 1999 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. You may
6  obtain a copy of the License at
7 
8  https://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) ((double) QuantumRange-(double) (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) ((double) QuantumRange-(double) (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 
106 static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
107 {
108  return(x < 0.0 ? -x : x);
109 }
110 
111 static inline Quantum ClampPixel(const MagickRealType value)
112 {
113  if (value < 0.0)
114  return((Quantum) 0);
115  if (value >= (MagickRealType) QuantumRange)
116  return((Quantum) QuantumRange);
117 #if !defined(MAGICKCORE_HDRI_SUPPORT)
118  return((Quantum) (value+0.5));
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 
138 static inline MagickRealType GetPixelLuma(
139  const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
140 {
141  MagickRealType
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 
150 static inline MagickRealType GetPixelLuminance(
151  const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
152 {
153  MagickRealType
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.212656*DecodePixelGamma((MagickRealType)
163  pixel->red)+0.715158*DecodePixelGamma((MagickRealType) pixel->green)+
164  0.072186*DecodePixelGamma((MagickRealType) pixel->blue));
165  return(intensity);
166 }
167 
168 static inline void GetPixelPacketRGBA(const Quantum red,const Quantum green,
169  const Quantum blue,const Quantum opacity,PixelPacket *magick_restrict pixel)
170 {
171  pixel->red=red;
172  pixel->green=green;
173  pixel->blue=blue;
174  pixel->opacity=opacity;
175 }
176 
177 static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
178  const QuantumAny range)
179 {
180  Quantum
181  quantum;
182 
183  if (range == 0)
184  return(MagickTrue);
185 #if !defined(MAGICKCORE_HDRI_SUPPORT)
186  quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
187  (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
188 #else
189  quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
190  (((MagickRealType) range*(MagickRealType) pixel)/(MagickRealType) QuantumRange+
191  0.5)))/(MagickRealType) range);
192 #endif
193  return(pixel == quantum ? MagickTrue : MagickFalse);
194 }
195 
196 static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
197 {
198  MagickRealType
199  green_blue,
200  red_green;
201 
202  red_green=(MagickRealType) pixel->red-(MagickRealType) pixel->green;
203  green_blue=(MagickRealType) pixel->green-(MagickRealType) pixel->blue;
204  if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
205  ((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
206  return(MagickTrue);
207  return(MagickFalse);
208 }
209 
210 static inline MagickBooleanType IsPixelMonochrome(
211  const PixelPacket *pixel)
212 {
213  MagickRealType
214  green_blue,
215  red,
216  red_green;
217 
218  red=(MagickRealType) pixel->red;
219  if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
220  (AbsolutePixelValue(red-(double) QuantumRange) >= MagickEpsilon))
221  return(MagickFalse);
222  red_green=(MagickRealType) pixel->red-(double) pixel->green;
223  green_blue=(MagickRealType) pixel->green-(double) pixel->blue;
224  if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
225  ((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
226  return(MagickTrue);
227  return(MagickFalse);
228 }
229 
230 static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
231 {
232  MagickRealType
233  intensity;
234 
235  if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
236  return(pixel->red);
237  intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
238  0.072186f*pixel->blue);
239  return(ClampToQuantum(intensity));
240 }
241 
242 static inline void SetPixelViaMagickPixel(const Image *magick_restrict image,
243  const MagickPixelPacket *magick_restrict magick_pixel,
244  PixelPacket *magick_restrict pixel)
245 {
246  pixel->red=ClampToQuantum(magick_pixel->red);
247  pixel->green=ClampToQuantum(magick_pixel->green);
248  pixel->blue=ClampToQuantum(magick_pixel->blue);
249  if (image->matte != MagickFalse)
250  pixel->opacity=ClampToQuantum(magick_pixel->opacity);
251 }
252 
253 #if defined(__cplusplus) || defined(c_plusplus)
254 }
255 #endif
256 
257 #endif
Definition: image.h:133