]> granicus.if.org Git - imagemagick/blobdiff - magick/gem.c
(no commit message)
[imagemagick] / magick / gem.c
index 60b0a2cf99c76e44dcce9646d193817fb783f5f8..f2cd994e7cbd40f99a0368fdca26f487a80ff3e0 100644 (file)
@@ -17,7 +17,7 @@
 %                                 August 1996                                 %
 %                                                                             %
 %                                                                             %
-%  Copyright 1999-2010 ImageMagick Studio LLC, a non-profit organization      %
+%  Copyright 1999-2011 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.  You may  %
@@ -100,7 +100,7 @@ MagickExport void ConvertHSBToRGB(const double hue,const double saturation,
   assert(blue != (Quantum *) NULL);
   if (saturation == 0.0)
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
       *green=(*red);
       *blue=(*red);
       return;
@@ -115,44 +115,44 @@ MagickExport void ConvertHSBToRGB(const double hue,const double saturation,
     case 0:
     default:
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*brightness);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*t);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*p);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*t);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*p);
       break;
     }
     case 1:
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*q);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*brightness);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*p);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*q);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*p);
       break;
     }
     case 2:
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*p);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*brightness);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*t);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*t);
       break;
     }
     case 3:
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*p);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*q);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*q);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
       break;
     }
     case 4:
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*t);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*p);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*brightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*t);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*brightness);
       break;
     }
     case 5:
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*brightness);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*p);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*q);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*brightness);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*p);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*q);
       break;
     }
   }
@@ -220,12 +220,12 @@ MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
   assert(blue != (Quantum *) NULL);
   if (saturation == 0)
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*lightness);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*lightness);
       *green=(*red);
       *blue=(*red);
       return;
     }
-  if (lightness <= 0.5)
+  if (lightness < 0.5)
     m2=lightness*(saturation+1.0);
   else
     m2=(lightness+saturation)-(lightness*saturation);
@@ -233,9 +233,9 @@ MagickExport void ConvertHSLToRGB(const double hue,const double saturation,
   r=ConvertHueToRGB(m1,m2,hue+1.0/3.0);
   g=ConvertHueToRGB(m1,m2,hue);
   b=ConvertHueToRGB(m1,m2,hue-1.0/3.0);
-  *red=RoundToQuantum((MagickRealType) QuantumRange*r);
-  *green=RoundToQuantum((MagickRealType) QuantumRange*g);
-  *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+  *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+  *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+  *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
 }
 \f
 /*
@@ -276,7 +276,7 @@ MagickExport void ConvertHWBToRGB(const double hue,const double whiteness,
     r,
     v;
 
-  register long
+  register ssize_t
     i;
 
   /*
@@ -288,12 +288,12 @@ MagickExport void ConvertHWBToRGB(const double hue,const double whiteness,
   v=1.0-blackness;
   if (hue == 0.0)
     {
-      *red=RoundToQuantum((MagickRealType) QuantumRange*v);
-      *green=RoundToQuantum((MagickRealType) QuantumRange*v);
-      *blue=RoundToQuantum((MagickRealType) QuantumRange*v);
+      *red=ClampToQuantum((MagickRealType) QuantumRange*v);
+      *green=ClampToQuantum((MagickRealType) QuantumRange*v);
+      *blue=ClampToQuantum((MagickRealType) QuantumRange*v);
       return;
     }
-  i=(long) floor(6.0*hue);
+  i=(ssize_t) floor(6.0*hue);
   f=6.0*hue-i;
   if ((i & 0x01) != 0)
     f=1.0-f;
@@ -309,9 +309,9 @@ MagickExport void ConvertHWBToRGB(const double hue,const double whiteness,
     case 4: r=n; g=whiteness; b=v; break;
     case 5: r=v; g=whiteness; b=n; break;
   }
-  *red=RoundToQuantum((MagickRealType) QuantumRange*r);
-  *green=RoundToQuantum((MagickRealType) QuantumRange*g);
-  *blue=RoundToQuantum((MagickRealType) QuantumRange*b);
+  *red=ClampToQuantum((MagickRealType) QuantumRange*r);
+  *green=ClampToQuantum((MagickRealType) QuantumRange*g);
+  *blue=ClampToQuantum((MagickRealType) QuantumRange*b);
 }
 \f
 /*
@@ -508,14 +508,14 @@ MagickExport void ConvertRGBToHSL(const Quantum red,const Quantum green,
 MagickExport void ConvertRGBToHWB(const Quantum red,const Quantum green,
   const Quantum blue,double *hue,double *whiteness,double *blackness)
 {
+  long
+    i;
+
   MagickRealType
     f,
     v,
     w;
 
-  register long
-    i;
-
   /*
     Convert RGB to HWB colorspace.
   */
@@ -634,13 +634,15 @@ MagickExport double GenerateDifferentialNoise(RandomInfo *random_info,
     case GaussianNoise:
     {
       double
+        gamma,
         tau;
 
       if (alpha == 0.0)
         alpha=1.0;
       beta=GetPseudoRandomValue(random_info);
-      sigma=sqrt(-2.0*log(alpha))*cos(2.0*MagickPI*beta);
-      tau=sqrt(-2.0*log(alpha))*sin(2.0*MagickPI*beta);
+      gamma=sqrt(-2.0*log(alpha));
+      sigma=gamma*cos((double) (2.0*MagickPI*beta));
+      tau=gamma*sin((double) (2.0*MagickPI*beta));
       noise=(double) pixel+sqrt((double) pixel)*SigmaGaussian*sigma+
         TauGaussian*tau;
       break;
@@ -653,7 +655,7 @@ MagickExport double GenerateDifferentialNoise(RandomInfo *random_info,
         sigma=sqrt(-2.0*log(alpha));
       beta=GetPseudoRandomValue(random_info);
       noise=(double) pixel+pixel*SigmaMultiplicativeGaussian*sigma/2.0*
-        cos((2.0*MagickPI*beta));
+        cos((double) (2.0*MagickPI*beta));
       break;
     }
     case ImpulseNoise:
@@ -691,7 +693,7 @@ MagickExport double GenerateDifferentialNoise(RandomInfo *random_info,
       double
         poisson;
 
-      register long
+      register ssize_t
         i;
 
       poisson=exp(-SigmaPoisson*ScaleQuantumToChar(pixel));
@@ -705,7 +707,7 @@ MagickExport double GenerateDifferentialNoise(RandomInfo *random_info,
     }
     case RandomNoise:
     {
-      noise=(double) QuantumRange*GetPseudoRandomValue(random_info);
+      noise=(double) QuantumRange*alpha;
       break;
     }
   }
@@ -729,7 +731,7 @@ MagickExport double GenerateDifferentialNoise(RandomInfo *random_info,
 %
 %  The format of the GetOptimalKernelWidth method is:
 %
-%      unsigned long GetOptimalKernelWidth(const double radius,
+%      size_t GetOptimalKernelWidth(const double radius,
 %        const double sigma)
 %
 %  A description of each parameter follows:
@@ -743,84 +745,89 @@ MagickExport double GenerateDifferentialNoise(RandomInfo *random_info,
 %    o sigma: the standard deviation of the Gaussian, in pixels.
 %
 */
-MagickExport unsigned long GetOptimalKernelWidth1D(const double radius,
+MagickExport size_t GetOptimalKernelWidth1D(const double radius,
   const double sigma)
 {
-#define MagickSigma  (fabs(sigma) <= MagickEpsilon ? 1.0 : sigma)
-
-  MagickRealType
+  double
+    alpha,
+    beta,
+    gamma,
     normalize,
     value;
 
-  long
-    j;
-
-  register long
+  register ssize_t
     i;
 
-  unsigned long
+  size_t
     width;
 
+  ssize_t
+    j;
+
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
   if (radius > MagickEpsilon)
-    return((unsigned long) (2.0*ceil(radius)+1.0));
-  if (fabs(sigma) <= MagickEpsilon)
-    return(1UL);
+    return((size_t) (2.0*ceil(radius)+1.0));
+  gamma=fabs(sigma);
+  if (gamma <= MagickEpsilon)
+    return(3UL);
+  alpha=1.0/(2.0*gamma*gamma);
+  beta=(double) (1.0/(MagickSQ2PI*gamma));
   for (width=5; ; )
   {
     normalize=0.0;
-    j=(long) width/2;
+    j=(ssize_t) width/2;
     for (i=(-j); i <= j; i++)
-      normalize+=exp(-((double) i*i)/(2.0*MagickSigma*MagickSigma))/
-        (MagickSQ2PI*MagickSigma);
-    value=exp(-((double) j*j)/(2.0*MagickSigma*MagickSigma))/
-      (MagickSQ2PI*MagickSigma)/normalize;
+      normalize+=exp(-((double) (i*i))*alpha)*beta;
+    value=exp(-((double) (j*j))*alpha)*beta/normalize;
     if ((value < QuantumScale) || (value < MagickEpsilon))
       break;
     width+=2;
   }
-  return((unsigned long) (width-2));
+  return((size_t) (width-2));
 }
 
-MagickExport unsigned long GetOptimalKernelWidth2D(const double radius,
+MagickExport size_t GetOptimalKernelWidth2D(const double radius,
   const double sigma)
 {
   double
+    alpha,
+    beta,
+    gamma,
     normalize,
     value;
 
-  long
+  size_t
+    width;
+
+  ssize_t
     j,
     u,
     v;
 
-  unsigned long
-    width;
-
   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
   if (radius > MagickEpsilon)
-    return((unsigned long) (2.0*ceil(radius)+1.0));
-  if (fabs(sigma) <= MagickEpsilon)
-    return(1UL);
+    return((size_t) (2.0*ceil(radius)+1.0));
+  gamma=fabs(sigma);
+  if (gamma <= MagickEpsilon)
+    return(3UL);
+  alpha=1.0/(2.0*gamma*gamma);
+  beta=(double) (1.0/(Magick2PI*gamma*gamma));
   for (width=5; ; )
   {
     normalize=0.0;
-    j=(long) width/2;
+    j=(ssize_t) width/2;
     for (v=(-j); v <= j; v++)
-    {
       for (u=(-j); u <= j; u++)
-        normalize+=exp(-((double) u*u+v*v)/(2.0*MagickSigma*MagickSigma))/
-          (2.0*MagickPI*MagickSigma*MagickSigma);
-    }
-    value=exp(-((double) j*j)/(2.0*MagickSigma*MagickSigma))/normalize;
+        normalize+=exp(-((double) (u*u+v*v))*alpha)*beta;
+    value=exp(-((double) (j*j))*alpha)*beta/normalize;
     if ((value < QuantumScale) || (value < MagickEpsilon))
       break;
     width+=2;
   }
-  return((unsigned long) (width-2));
+  return((size_t) (width-2));
 }
 
-MagickExport unsigned long  GetOptimalKernelWidth(const double radius,
+MagickExport size_t  GetOptimalKernelWidth(const double radius,
   const double sigma)
 {
   return(GetOptimalKernelWidth1D(radius,sigma));