/*
- Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization
+ Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization
dedicated to making software imaging solutions freely available.
You may not use this file except in compliance with the License.
#ifndef _MAGICKCORE_COMPOSITE_PRIVATE_H
#define _MAGICKCORE_COMPOSITE_PRIVATE_H
+
+#include "MagickCore/color.h"
+#include "MagickCore/image.h"
+#include "MagickCore/image-private.h"
+#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.h"
+
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
/*
ImageMagick Alpha Composite Inline Methods (special export)
*/
-
-#include "MagickCore/color.h"
-#include "MagickCore/image.h"
-#include "MagickCore/image-private.h"
-#include "MagickCore/pixel-accessor.h"
-
-static inline MagickRealType MagickOver_(const MagickRealType p,
- const MagickRealType alpha,const MagickRealType q,const MagickRealType beta)
+static inline double MagickOver_(const double p,
+ const double alpha,const double q,const double beta)
{
- MagickRealType
+ double
Da,
Sa;
}
static inline void CompositePixelOver(const Image *image,const PixelInfo *p,
- const MagickRealType alpha,const Quantum *q,const MagickRealType beta,
- Quantum *composite)
+ const double alpha,const Quantum *q,const double beta,Quantum *composite)
{
- MagickRealType
+ double
Da,
gamma,
Sa;
+ register ssize_t
+ i;
+
/*
- Compose pixel p over pixel q with the given opacities.
+ Compose pixel p over pixel q with the given alpha.
*/
- if (fabs(alpha-TransparentAlpha) < MagickEpsilon)
- {
- if (composite != q)
- {
- SetPixelRed(image,GetPixelRed(image,q),composite);
- SetPixelGreen(image,GetPixelGreen(image,q),composite);
- SetPixelBlue(image,GetPixelBlue(image,q),composite);
- SetPixelAlpha(image,GetPixelAlpha(image,q),composite);
- }
- return;
- }
Sa=QuantumScale*alpha;
Da=QuantumScale*beta,
gamma=Sa*(-Da)+Sa+Da;
-#if !defined(MAGICKCORE_HDRI_SUPPORT)
- SetPixelAlpha(image,(Quantum) (QuantumRange*gamma+0.5),composite);
- gamma=1.0/(gamma <= MagickEpsilon ? 1.0 : gamma);
- SetPixelRed(image,(Quantum) (gamma*MagickOver_((MagickRealType) p->red,
- alpha,(MagickRealType) GetPixelRed(image,q),beta)+0.5),composite);
- SetPixelGreen(image,(Quantum) (gamma*MagickOver_((MagickRealType) p->green,
- alpha,(MagickRealType) GetPixelGreen(image,q),beta)+0.5),composite);
- SetPixelBlue(image,(Quantum) (gamma*MagickOver_((MagickRealType) p->blue,
- alpha,(MagickRealType) GetPixelBlue(image,q),beta)+0.5),composite);
-#else
- SetPixelAlpha(image,QuantumRange*gamma,composite);
- gamma=1.0/(gamma <= MagickEpsilon ? 1.0 : gamma);
- SetPixelRed(image,(Quantum) (gamma*MagickOver_((MagickRealType) p->red,
- alpha,(MagickRealType) GetPixelRed(image,q),beta)),composite);
- SetPixelGreen(image,(Quantum) (gamma*MagickOver_((MagickRealType) p->green,
- alpha,(MagickRealType) GetPixelGreen(image,q),beta)),composite);
- SetPixelBlue(image,(Quantum) (gamma*MagickOver_((MagickRealType) p->blue,
- alpha,(MagickRealType) GetPixelBlue(image,q),beta)),composite);
-#endif
+ gamma=PerceptibleReciprocal(gamma);
+ for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
+ {
+ PixelChannel
+ channel;
+
+ PixelTrait
+ traits;
+
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
+ if (traits == UndefinedPixelTrait)
+ continue;
+ if (fabs(alpha-TransparentAlpha) < MagickEpsilon)
+ {
+ composite[i]=q[i];
+ continue;
+ }
+ switch (channel)
+ {
+ case RedPixelChannel:
+ {
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->red,alpha,
+ (double) q[i],beta));
+ break;
+ }
+ case GreenPixelChannel:
+ {
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->green,alpha,
+ (double) q[i],beta));
+ break;
+ }
+ case BluePixelChannel:
+ {
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->blue,alpha,
+ (double) q[i],beta));
+ break;
+ }
+ case BlackPixelChannel:
+ {
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->black,alpha,
+ (double) q[i],beta));
+ break;
+ }
+ case AlphaPixelChannel:
+ {
+ composite[i]=ClampToQuantum(QuantumRange*(Sa*(-Da)+Sa+Da));
+ break;
+ }
+ default:
+ {
+ composite[i]=q[i];
+ break;
+ }
+ }
+ }
}
static inline void CompositePixelInfoOver(const PixelInfo *p,
- const MagickRealType alpha,const PixelInfo *q,const MagickRealType beta,
- PixelInfo *composite)
+ const double alpha,const PixelInfo *q,const double beta,PixelInfo *composite)
{
- MagickRealType
+ double
Da,
gamma,
Sa;
/*
Compose pixel p over pixel q with the given opacities.
*/
- if (fabs(alpha-OpaqueAlpha) < MagickEpsilon)
+ if (fabs(alpha-TransparentAlpha) < MagickEpsilon)
{
*composite=(*p);
return;
Sa=QuantumScale*alpha;
Da=QuantumScale*beta,
gamma=Sa*(-Da)+Sa+Da;
- composite->alpha=(MagickRealType) QuantumRange*gamma;
- gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
+ composite->alpha=(double) QuantumRange*gamma;
+ gamma=PerceptibleReciprocal(gamma);
composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
composite->blue=gamma*MagickOver_(p->blue,alpha,q->blue,beta);
composite->black=gamma*MagickOver_(p->black,alpha,q->black,beta);
}
-static inline MagickRealType RoundToUnity(const MagickRealType value)
+static inline double RoundToUnity(const double value)
{
return(value < 0.0 ? 0.0 : (value > 1.0) ? 1.0 : value);
}
static inline void CompositePixelInfoPlus(const PixelInfo *p,
- const MagickRealType alpha,const PixelInfo *q,const MagickRealType beta,
- PixelInfo *composite)
+ const double alpha,const PixelInfo *q,const double beta,PixelInfo *composite)
{
- MagickRealType
+ double
Da,
gamma,
Sa;
Sa=QuantumScale*alpha;
Da=QuantumScale*beta;
gamma=RoundToUnity(Sa+Da); /* 'Plus' blending -- not 'Over' blending */
- composite->alpha=(MagickRealType) QuantumRange*gamma;
- gamma=1.0/(fabs(gamma) <= MagickEpsilon ? 1.0 : gamma);
+ composite->alpha=(double) QuantumRange*gamma;
+ gamma=PerceptibleReciprocal(gamma);
composite->red=gamma*(Sa*p->red+Da*q->red);
composite->green=gamma*(Sa*p->green+Da*q->green);
composite->blue=gamma*(Sa*p->blue+Da*q->blue);
}
static inline void CompositePixelInfoAreaBlend(const PixelInfo *p,
- const MagickRealType alpha,const PixelInfo *q,const MagickRealType beta,
- const MagickRealType area,PixelInfo *composite)
+ const double alpha,const PixelInfo *q,const double beta,const double area,
+ PixelInfo *composite)
{
/*
Blend pixel colors p and q by the amount given and area.
*/
- CompositePixelInfoPlus(p,(MagickRealType) (1.0-area)*alpha,q,(MagickRealType)
- (area*beta),composite);
+ CompositePixelInfoPlus(p,(double) (1.0-area)*alpha,q,(double) (area*beta),
+ composite);
}
static inline void CompositePixelInfoBlend(const PixelInfo *p,
- const MagickRealType alpha,const PixelInfo *q,const MagickRealType beta,
- PixelInfo *composite)
+ const double alpha,const PixelInfo *q,const double beta,PixelInfo *composite)
{
/*
Blend pixel colors p and q by the amount given.
*/
- CompositePixelInfoPlus(p,(MagickRealType) (alpha*p->alpha),q,(MagickRealType)
- (beta*q->alpha),composite);
+ CompositePixelInfoPlus(p,(double) (alpha*p->alpha),q,(double) (beta*q->alpha),
+ composite);
}
#if defined(__cplusplus) || defined(c_plusplus)
projects / imagemagick / blobdiff