/*
- Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization
+ Copyright 1999-2012 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.
#include "MagickCore/image.h"
#include "MagickCore/image-private.h"
#include "MagickCore/pixel-accessor.h"
+#include "MagickCore/pixel-private.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,
+ const double alpha,const Quantum *q,const double beta,
Quantum *composite)
{
- MagickRealType
+ double
Da,
gamma,
Sa;
i;
/*
- Compose pixel p over pixel q with the given opacities.
+ Compose pixel p over pixel q with the given alpha.
*/
Sa=QuantumScale*alpha;
Da=QuantumScale*beta,
gamma=Sa*(-Da)+Sa+Da;
- gamma=1.0/(gamma <= MagickEpsilon ? 1.0 : gamma);
+ gamma=MagickEpsilonReciprocal(gamma);
for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
{
PixelChannel
PixelTrait
traits;
- channel=GetPixelChannelMapChannel(image,i);
- traits=GetPixelChannelMapTraits(image,channel);
+ channel=GetPixelChannelChannel(image,i);
+ traits=GetPixelChannelTraits(image,channel);
if (traits == UndefinedPixelTrait)
continue;
switch (channel)
{
case RedPixelChannel:
{
- composite[i]=ClampToQuantum(gamma*MagickOver_((MagickRealType) p->red,
- alpha,(MagickRealType) q[i],beta));
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->red,
+ alpha,(double) q[i],beta));
break;
}
case GreenPixelChannel:
{
- composite[i]=ClampToQuantum(gamma*MagickOver_((MagickRealType) p->green,
- alpha,(MagickRealType) q[i],beta));
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->green,
+ alpha,(double) q[i],beta));
break;
}
case BluePixelChannel:
{
- composite[i]=ClampToQuantum(gamma*MagickOver_((MagickRealType) p->blue,
- alpha,(MagickRealType) q[i],beta));
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->blue,
+ alpha,(double) q[i],beta));
break;
}
case BlackPixelChannel:
{
- composite[i]=ClampToQuantum(gamma*MagickOver_((MagickRealType) p->black,
- alpha,(MagickRealType) q[i],beta));
+ composite[i]=ClampToQuantum(gamma*MagickOver_((double) p->black,
+ alpha,(double) q[i],beta));
break;
}
case AlphaPixelChannel:
{
- composite[i]=ClampToQuantum(QuantumRange*gamma);
+ composite[i]=ClampToQuantum(QuantumRange*(Sa*(-Da)+Sa+Da));
break;
}
default:
}
static inline void CompositePixelInfoOver(const PixelInfo *p,
- const MagickRealType alpha,const PixelInfo *q,const MagickRealType beta,
+ const double alpha,const PixelInfo *q,const double beta,
PixelInfo *composite)
{
- MagickRealType
+ double
Da,
gamma,
Sa;
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=MagickEpsilonReciprocal(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,
+ 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=MagickEpsilonReciprocal(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)
+ 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,
+ 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)
+ CompositePixelInfoPlus(p,(double) (alpha*p->alpha),q,(double)
(beta*q->alpha),composite);
}