MagickCore 6.9.13
Loading...
Searching...
No Matches
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)
26extern "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
106static inline MagickRealType AbsolutePixelValue(const MagickRealType x)
107{
108 return(x < 0.0 ? -x : x);
109}
110
111static 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
124static 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
138static 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
150static 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
168static 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
177static 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
196static 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
210static 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
230static 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
242static 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
_Image
Definition image.h:134
_MagickPixelPacket
Definition pixel.h:105
_PixelPacket
Definition pixel.h:132