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 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
136static 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
154static 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
163static 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
182static 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
196static 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
216static 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
228static 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