MagickCore  6.9.13-26
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 MagickRealType GetPixelLuma(
125  const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
126 {
127  MagickRealType
128  intensity;
129 
130  (void) image;
131  intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
132  0.072186f*pixel->blue);
133  return(intensity);
134 }
135 
136 static inline MagickRealType GetPixelLuminance(
137  const Image *magick_restrict image,const PixelPacket *magick_restrict pixel)
138 {
139  MagickRealType
140  intensity;
141 
142  if (image->colorspace != sRGBColorspace)
143  {
144  intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
145  0.072186f*pixel->blue);
146  return(intensity);
147  }
148  intensity=(MagickRealType) (0.212656*DecodePixelGamma((MagickRealType)
149  pixel->red)+0.715158*DecodePixelGamma((MagickRealType) pixel->green)+
150  0.072186*DecodePixelGamma((MagickRealType) pixel->blue));
151  return(intensity);
152 }
153 
154 static inline void GetPixelPacketRGBA(const Quantum red,const Quantum green,
155  const Quantum blue,const Quantum opacity,PixelPacket *magick_restrict pixel)
156 {
157  pixel->red=red;
158  pixel->green=green;
159  pixel->blue=blue;
160  pixel->opacity=opacity;
161 }
162 
163 static inline MagickBooleanType IsPixelAtDepth(const Quantum pixel,
164  const QuantumAny range)
165 {
166  Quantum
167  quantum;
168 
169  if (range == 0)
170  return(MagickTrue);
171 #if !defined(MAGICKCORE_HDRI_SUPPORT)
172  quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
173  (((MagickRealType) range*pixel)/QuantumRange+0.5)))/range+0.5);
174 #else
175  quantum=(Quantum) (((MagickRealType) QuantumRange*((QuantumAny)
176  (((MagickRealType) range*(MagickRealType) pixel)/(MagickRealType) QuantumRange+
177  0.5)))/(MagickRealType) range);
178 #endif
179  return(pixel == quantum ? MagickTrue : MagickFalse);
180 }
181 
182 static inline MagickBooleanType IsPixelGray(const PixelPacket *pixel)
183 {
184  MagickRealType
185  green_blue,
186  red_green;
187 
188  red_green=(MagickRealType) pixel->red-(MagickRealType) pixel->green;
189  green_blue=(MagickRealType) pixel->green-(MagickRealType) pixel->blue;
190  if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
191  ((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
192  return(MagickTrue);
193  return(MagickFalse);
194 }
195 
196 static inline MagickBooleanType IsPixelMonochrome(
197  const PixelPacket *pixel)
198 {
199  MagickRealType
200  green_blue,
201  red,
202  red_green;
203 
204  red=(MagickRealType) pixel->red;
205  if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
206  (AbsolutePixelValue(red-(double) QuantumRange) >= MagickEpsilon))
207  return(MagickFalse);
208  red_green=(MagickRealType) pixel->red-(double) pixel->green;
209  green_blue=(MagickRealType) pixel->green-(double) pixel->blue;
210  if (((QuantumScale*AbsolutePixelValue(red_green)) < MagickEpsilon) &&
211  ((QuantumScale*AbsolutePixelValue(green_blue)) < MagickEpsilon))
212  return(MagickTrue);
213  return(MagickFalse);
214 }
215 
216 static inline Quantum PixelPacketIntensity(const PixelPacket *pixel)
217 {
218  MagickRealType
219  intensity;
220 
221  if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
222  return(pixel->red);
223  intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
224  0.072186f*pixel->blue);
225  return(ClampToQuantum(intensity));
226 }
227 
228 static inline void SetPixelViaMagickPixel(const Image *magick_restrict image,
229  const MagickPixelPacket *magick_restrict magick_pixel,
230  PixelPacket *magick_restrict pixel)
231 {
232  pixel->red=ClampToQuantum(magick_pixel->red);
233  pixel->green=ClampToQuantum(magick_pixel->green);
234  pixel->blue=ClampToQuantum(magick_pixel->blue);
235  if (image->matte != MagickFalse)
236  pixel->opacity=ClampToQuantum(magick_pixel->opacity);
237 }
238 
239 #if defined(__cplusplus) || defined(c_plusplus)
240 }
241 #endif
242 
243 #endif
Definition: image.h:133