MagickCore  6.8.9
composite-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2014 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  http://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 image composite private methods.
17 */
18 #ifndef _MAGICKCORE_COMPOSITE_PRIVATE_H
19 #define _MAGICKCORE_COMPOSITE_PRIVATE_H
20 
21 #include "magick/color.h"
22 #include "magick/image.h"
23 #include "magick/image-private.h"
24 #include "magick/pixel-private.h"
25 
26 #if defined(__cplusplus) || defined(c_plusplus)
27 extern "C" {
28 #endif
29 
30 /*
31  ImageMagick Alpha Composite Inline Methods (special export)
32 */
33 static inline MagickRealType RoundToUnity(const MagickRealType value)
34 {
35  return(value < 0.0 ? 0.0 : (value > 1.0) ? 1.0 : value);
36 }
37 
39  const MagickRealType alpha,const MagickRealType q,const MagickRealType beta)
40 {
41  return((1.0-QuantumScale*alpha)*p+(1.0-QuantumScale*beta)*q*
42  QuantumScale*alpha);
43 }
44 
45 static inline void MagickCompositeOver(const PixelPacket *p,
46  const MagickRealType alpha,const PixelPacket *q,const MagickRealType beta,
47  PixelPacket *composite)
48 {
49  double
50  gamma;
51 
52  /*
53  Compose pixel p over pixel q with the given opacities.
54  */
55  if (alpha == TransparentOpacity)
56  {
57  if (composite != q)
58  *composite=(*q);
59  return;
60  }
61  gamma=1.0-QuantumScale*QuantumScale*alpha*beta;
62 #if !defined(MAGICKCORE_HDRI_SUPPORT)
63  composite->opacity=(Quantum) (QuantumRange*(1.0-gamma)+0.5);
64  gamma=PerceptibleReciprocal(gamma);
65  SetPixelRed(composite,gamma*MagickOver_((MagickRealType)
66  GetPixelRed(p),alpha,(MagickRealType) GetPixelRed(q),beta)+0.5);
67  SetPixelGreen(composite,gamma*MagickOver_((MagickRealType)
68  GetPixelGreen(p),alpha,(MagickRealType) GetPixelGreen(q),beta)+0.5);
69  SetPixelBlue(composite,gamma*MagickOver_((MagickRealType)
70  GetPixelBlue(p),alpha,(MagickRealType) GetPixelBlue(q),beta)+0.5);
71 #else
72  SetPixelOpacity(composite,QuantumRange*(1.0-gamma));
73  gamma=PerceptibleReciprocal(gamma);
74  SetPixelRed(composite,gamma*MagickOver_((MagickRealType)
75  GetPixelRed(p),alpha,(MagickRealType) GetPixelRed(q),beta));
76  SetPixelGreen(composite,gamma*MagickOver_((MagickRealType)
77  GetPixelGreen(p),alpha,(MagickRealType) GetPixelGreen(q),beta));
78  SetPixelBlue(composite,gamma*MagickOver_((MagickRealType)
79  GetPixelBlue(p),alpha,(MagickRealType) GetPixelBlue(q),beta));
80 #endif
81 }
82 
83 static inline void MagickPixelCompositeOver(const MagickPixelPacket *p,
84  const MagickRealType alpha,const MagickPixelPacket *q,
85  const MagickRealType beta,MagickPixelPacket *composite)
86 {
87  double
88  gamma;
89 
90  /*
91  Compose pixel p over pixel q with the given opacities.
92  */
93  if (alpha == OpaqueOpacity)
94  {
95  *composite=(*p);
96  return;
97  }
98  gamma=1.0-QuantumScale*QuantumScale*alpha*beta;
99  composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
100  gamma=PerceptibleReciprocal(gamma);
101  composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
102  composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
103  composite->blue=gamma*MagickOver_(p->blue,alpha,q->blue,beta);
104  if (q->colorspace == CMYKColorspace)
105  composite->index=gamma*MagickOver_(p->index,alpha,q->index,beta);
106 }
107 
108 static inline void MagickPixelCompositePlus(const MagickPixelPacket *p,
109  const MagickRealType alpha,const MagickPixelPacket *q,
110  const MagickRealType beta,MagickPixelPacket *composite)
111 {
112  double
113  gamma;
114 
116  Da,
117  Sa;
118 
119  /*
120  Add two pixels with the given opacities.
121  */
122  Sa=1.0-QuantumScale*alpha;
123  Da=1.0-QuantumScale*beta;
124  gamma=RoundToUnity(Sa+Da); /* 'Plus' blending -- not 'Over' blending */
125  composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
126  gamma=PerceptibleReciprocal(gamma);
127  composite->red=gamma*(Sa*p->red+Da*q->red);
128  composite->green=gamma*(Sa*p->green+Da*q->green);
129  composite->blue=gamma*(Sa*p->blue+Da*q->blue);
130  if (q->colorspace == CMYKColorspace)
131  composite->index=gamma*(Sa*p->index+Da*q->index);
132 }
133 
134 /*
135  Blend pixel colors p and q by the amount given.
136 */
137 static inline void MagickPixelCompositeBlend(const MagickPixelPacket *p,
138  const MagickRealType alpha,const MagickPixelPacket *q,
139  const MagickRealType beta,MagickPixelPacket *composite)
140 {
143  (QuantumRange-q->opacity)),composite);
144 }
145 
146 /*
147  Blend pixel colors p and q by the amount given and area.
148 */
150  const MagickRealType alpha,const MagickPixelPacket *q,
151  const MagickRealType beta,const MagickRealType area,
152  MagickPixelPacket *composite)
153 {
156  beta)),composite);
157 }
158 
159 #if defined(__cplusplus) || defined(c_plusplus)
160 }
161 #endif
162 
163 #endif
MagickRealType opacity
Definition: pixel.h:122
#define GetPixelBlue(pixel)
Definition: pixel-accessor.h:38
ColorspaceType colorspace
Definition: pixel.h:110
static void MagickPixelCompositeBlend(const MagickPixelPacket *p, const MagickRealType alpha, const MagickPixelPacket *q, const MagickRealType beta, MagickPixelPacket *composite)
Definition: composite-private.h:137
#define GetPixelGreen(pixel)
Definition: pixel-accessor.h:43
static void MagickPixelCompositeOver(const MagickPixelPacket *p, const MagickRealType alpha, const MagickPixelPacket *q, const MagickRealType beta, MagickPixelPacket *composite)
Definition: composite-private.h:83
static MagickRealType RoundToUnity(const MagickRealType value)
Definition: composite-private.h:33
float MagickRealType
Definition: magick-type.h:79
Definition: pixel.h:131
#define GetPixelRed(pixel)
Definition: pixel-accessor.h:50
#define SetPixelGreen(pixel, value)
Definition: pixel-accessor.h:77
Definition: pixel.h:104
static MagickRealType MagickOver_(const MagickRealType p, const MagickRealType alpha, const MagickRealType q, const MagickRealType beta)
Definition: composite-private.h:38
#define SetPixelRed(pixel, value)
Definition: pixel-accessor.h:87
Quantum opacity
Definition: pixel.h:143
#define TransparentOpacity
Definition: image.h:28
static void MagickCompositeOver(const PixelPacket *p, const MagickRealType alpha, const PixelPacket *q, const MagickRealType beta, PixelPacket *composite)
Definition: composite-private.h:45
#define QuantumScale
Definition: magick-type.h:145
Definition: colorspace.h:39
#define SetPixelOpacity(pixel, value)
Definition: pixel-accessor.h:85
MagickRealType red
Definition: pixel.h:122
static void MagickPixelCompositePlus(const MagickPixelPacket *p, const MagickRealType alpha, const MagickPixelPacket *q, const MagickRealType beta, MagickPixelPacket *composite)
Definition: composite-private.h:108
unsigned short Quantum
Definition: magick-type.h:96
#define OpaqueOpacity
Definition: image.h:27
static void MagickPixelCompositeAreaBlend(const MagickPixelPacket *p, const MagickRealType alpha, const MagickPixelPacket *q, const MagickRealType beta, const MagickRealType area, MagickPixelPacket *composite)
Definition: composite-private.h:149
MagickRealType green
Definition: pixel.h:122
MagickRealType blue
Definition: pixel.h:122
static double PerceptibleReciprocal(const double x)
Definition: pixel-private.h:78
#define SetPixelBlue(pixel, value)
Definition: pixel-accessor.h:71
MagickRealType index
Definition: pixel.h:122
#define QuantumRange
Definition: magick-type.h:97