(no commit message)

diff --git a/MagickCore/accelerate.c b/MagickCore/accelerate.c
index c7b0b44c3fc940cc0f73a0925358c60ea576a25a..9eecd4d3ba70e5b9e789103112da62aa97c05e88 100644 (file)
--- a/MagickCore/accelerate.c
+++ b/MagickCore/accelerate.c
@@ -195,7 +195,7 @@ static const char
     "#endif\n"
     "}\n"
     "\n"
-    "static inline float MagickEpsilonReciprocal(const float x)\n"
+    "static inline float PerceptibleReciprocal(const float x)\n"
     "{\n"
     "  float sign = x < (float) 0.0 ? (float) -1.0 : (float) 1.0;\n"
     "  return((sign*x) >= MagickEpsilon ? (float) 1.0/x : sign*((float) 1.0/\n"
@@ -302,7 +302,7 @@ static const char
     "      break;\n"
     "    }\n"
     "  }\n"
-    "  gamma=MagickEpsilonReciprocal(gamma);\n"
+    "  gamma=PerceptibleReciprocal(gamma);\n"
     "  const unsigned long index = y*columns+x;\n"
     "  output[index].x=ClampToQuantum(gamma*sum.x);\n"
     "  output[index].y=ClampToQuantum(gamma*sum.y);\n"

diff --git a/MagickCore/colorspace.c b/MagickCore/colorspace.c
index 091aa54a507b131a2a6f1d5d90dee093e3cf83c9..0a12985e047ae430ea6d19247fe720d3fa194e16 100644 (file)
--- a/MagickCore/colorspace.c
+++ b/MagickCore/colorspace.c
@@ -203,7 +203,7 @@ static inline void ConvertXYZToLuv(const double X,const double Y,const double Z,
     *L=(double) (116.0f*pow(Y/D65Y,1.0/3.0)-16.0f);
   else
     *L=CIEK*(Y/D65Y);
-  alpha=MagickEpsilonReciprocal(X+15.0f*Y+3.0f*Z);
+  alpha=PerceptibleReciprocal(X+15.0f*Y+3.0f*Z);
   *u=13.0f*(*L)*((4.0f*alpha*X)-(4.0f*D65X/(D65X+15.0f*D65Y+3.0f*D65Z)));
   *v=13.0f*(*L)*((9.0f*alpha*Y)-(9.0f*D65Y/(D65X+15.0f*D65Y+3.0f*D65Z)));
   *L/=100.0f;
@@ -945,7 +945,7 @@ static MagickBooleanType sRGBTransformImage(Image *image,
       gamma=DisplayGamma;
       value=GetImageProperty(image,"gamma",exception);
       if (value != (const char *) NULL)
-        gamma=MagickEpsilonReciprocal(StringToDouble(value,(char **) NULL));
+        gamma=PerceptibleReciprocal(StringToDouble(value,(char **) NULL));
       film_gamma=FilmGamma;
       value=GetImageProperty(image,"film-gamma",exception);
       if (value != (const char *) NULL)
@@ -2898,7 +2898,7 @@ static MagickBooleanType TransformsRGBImage(Image *image,
       gamma=DisplayGamma;
       value=GetImageProperty(image,"gamma",exception);
       if (value != (const char *) NULL)
-        gamma=MagickEpsilonReciprocal(StringToDouble(value,(char **) NULL));
+        gamma=PerceptibleReciprocal(StringToDouble(value,(char **) NULL));
       film_gamma=FilmGamma;
       value=GetImageProperty(image,"film-gamma",exception);
       if (value != (const char *) NULL)

diff --git a/MagickCore/compare.c b/MagickCore/compare.c
index 408ae529e74d103958ccba2f7522828a08ca87b4..015b5d52aed2d0e1ba4cce2bf0d5e5097d8f60cb 100644 (file)
--- a/MagickCore/compare.c
+++ b/MagickCore/compare.c
@@ -949,7 +949,7 @@ static MagickBooleanType GetNormalizedCrossCorrelationDistortion(
     channel=GetPixelChannelChannel(image,i);
     gamma=image_statistics[i].standard_deviation*
       reconstruct_statistics[channel].standard_deviation;
-    gamma=MagickEpsilonReciprocal(gamma);
+    gamma=PerceptibleReciprocal(gamma);
     distortion[i]=QuantumRange*gamma*distortion[i];
     distortion[CompositePixelChannel]+=distortion[i]*distortion[i];
   }

diff --git a/MagickCore/composite-private.h b/MagickCore/composite-private.h
index 380431c1c6a1032f3edfbf1393f496bb8106b691..27033a592e9804332371e2dca2fa5f8b6245f476 100644 (file)
--- a/MagickCore/composite-private.h
+++ b/MagickCore/composite-private.h
@@ -61,7 +61,7 @@ static inline void CompositePixelOver(const Image *image,const PixelInfo *p,
   Sa=QuantumScale*alpha;
   Da=QuantumScale*beta,
   gamma=Sa*(-Da)+Sa+Da;
-  gamma=MagickEpsilonReciprocal(gamma);
+  gamma=PerceptibleReciprocal(gamma);
   for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
   {
     PixelChannel
@@ -131,7 +131,7 @@ static inline void CompositePixelInfoOver(const PixelInfo *p,
   Da=QuantumScale*beta,
   gamma=Sa*(-Da)+Sa+Da;
   composite->alpha=(double) QuantumRange*gamma;
-  gamma=MagickEpsilonReciprocal(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);
@@ -159,7 +159,7 @@ static inline void CompositePixelInfoPlus(const PixelInfo *p,
   Da=QuantumScale*beta;
   gamma=RoundToUnity(Sa+Da);  /* 'Plus' blending -- not 'Over' blending */
   composite->alpha=(double) QuantumRange*gamma;
-  gamma=MagickEpsilonReciprocal(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);

diff --git a/MagickCore/composite.c b/MagickCore/composite.c
index f3b9d06eda72217a880d645631b29d7566f4118f..a33243b1b10bf6d3dd5c2f576a2a2419e70e25ef 100644 (file)
--- a/MagickCore/composite.c
+++ b/MagickCore/composite.c
@@ -527,7 +527,7 @@ static MagickBooleanType CompositeOverImage(Image *image,
         */
         Sc=(MagickRealType) GetPixelChannel(composite_image,channel,p);
         Dc=(MagickRealType) q[i];
-        gamma=MagickEpsilonReciprocal(alpha);
+        gamma=PerceptibleReciprocal(alpha);
         q[i]=ClampToQuantum(gamma*(Sa*Sc-Sa*Da*Dc+Da*Dc));
       }
       p+=GetPixelChannels(composite_image);
@@ -1689,7 +1689,7 @@ MagickExport MagickBooleanType CompositeImage(Image *image,
           default:
             break;
         }
-        gamma=MagickEpsilonReciprocal(alpha);
+        gamma=PerceptibleReciprocal(alpha);
         pixel=Dc;
         switch (compose)
         {

diff --git a/MagickCore/distort.c b/MagickCore/distort.c
index 16a2b47cd158c9e5501cf9cb9bfcfbea1dcc74d8..00365a0f3a62a04ad691e73ca69ba052e1adc0e1 100644 (file)
--- a/MagickCore/distort.c
+++ b/MagickCore/distort.c
@@ -105,7 +105,7 @@ static void InvertAffineCoefficients(const double *coeff,double *inverse)
   /* From "Digital Image Warping" by George Wolberg, page 50 */
   double determinant;
 
-  determinant=MagickEpsilonReciprocal(coeff[0]*coeff[4]-coeff[1]*coeff[3]);
+  determinant=PerceptibleReciprocal(coeff[0]*coeff[4]-coeff[1]*coeff[3]);
   inverse[0]=determinant*coeff[4];
   inverse[1]=determinant*(-coeff[1]);
   inverse[2]=determinant*(coeff[1]*coeff[5]-coeff[2]*coeff[4]);
@@ -120,7 +120,7 @@ static void InvertPerspectiveCoefficients(const double *coeff,
   /* From "Digital Image Warping" by George Wolberg, page 53 */
   double determinant;
 
-  determinant=MagickEpsilonReciprocal(coeff[0]*coeff[4]-coeff[3]*coeff[1]);
+  determinant=PerceptibleReciprocal(coeff[0]*coeff[4]-coeff[3]*coeff[1]);
   inverse[0]=determinant*(coeff[4]-coeff[7]*coeff[5]);
   inverse[1]=determinant*(coeff[7]*coeff[2]-coeff[1]);
   inverse[2]=determinant*(coeff[1]*coeff[5]-coeff[4]*coeff[2]);
@@ -1799,28 +1799,28 @@ MagickExport Image *DistortImage(const Image *image,DistortImageMethod method,
         s.x = (double) image->page.x;
         s.y = (double) image->page.y;
         scale=inverse[6]*s.x+inverse[7]*s.y+1.0;
-        scale=MagickEpsilonReciprocal(scale);
+        scale=PerceptibleReciprocal(scale);
         d.x = scale*(inverse[0]*s.x+inverse[1]*s.y+inverse[2]);
         d.y = scale*(inverse[3]*s.x+inverse[4]*s.y+inverse[5]);
         InitalBounds(d);
         s.x = (double) image->page.x+image->columns;
         s.y = (double) image->page.y;
         scale=inverse[6]*s.x+inverse[7]*s.y+1.0;
-        scale=MagickEpsilonReciprocal(scale);
+        scale=PerceptibleReciprocal(scale);
         d.x = scale*(inverse[0]*s.x+inverse[1]*s.y+inverse[2]);
         d.y = scale*(inverse[3]*s.x+inverse[4]*s.y+inverse[5]);
         ExpandBounds(d);
         s.x = (double) image->page.x;
         s.y = (double) image->page.y+image->rows;
         scale=inverse[6]*s.x+inverse[7]*s.y+1.0;
-        scale=MagickEpsilonReciprocal(scale);
+        scale=PerceptibleReciprocal(scale);
         d.x = scale*(inverse[0]*s.x+inverse[1]*s.y+inverse[2]);
         d.y = scale*(inverse[3]*s.x+inverse[4]*s.y+inverse[5]);
         ExpandBounds(d);
         s.x = (double) image->page.x+image->columns;
         s.y = (double) image->page.y+image->rows;
         scale=inverse[6]*s.x+inverse[7]*s.y+1.0;
-        scale=MagickEpsilonReciprocal(scale);
+        scale=PerceptibleReciprocal(scale);
         d.x = scale*(inverse[0]*s.x+inverse[1]*s.y+inverse[2]);
         d.y = scale*(inverse[3]*s.x+inverse[4]*s.y+inverse[5]);
         ExpandBounds(d);

diff --git a/MagickCore/draw.c b/MagickCore/draw.c
index fc792353bfc9f43393138072c97cf682a54b5481..6a7622176d53a47f45a19c08f8428927fb16a756 100644 (file)
--- a/MagickCore/draw.c
+++ b/MagickCore/draw.c
@@ -1043,7 +1043,7 @@ static AffineMatrix InverseAffineMatrix(const AffineMatrix *affine)
   double
     determinant;
 
-  determinant=MagickEpsilonReciprocal(affine->sx*affine->sy-affine->rx*
+  determinant=PerceptibleReciprocal(affine->sx*affine->sy-affine->rx*
     affine->ry);
   inverse_affine.sx=determinant*affine->sy;
   inverse_affine.rx=determinant*(-affine->rx);
@@ -3184,7 +3184,7 @@ static inline double GetStopColorOffset(const GradientInfo *gradient,
       q.y=(double) y-gradient_vector->y1;
       length=sqrt(q.x*q.x+q.y*q.y);
       gamma=sqrt(p.x*p.x+p.y*p.y)*length;
-      gamma=MagickEpsilonReciprocal(gamma);
+      gamma=PerceptibleReciprocal(gamma);
       scale=p.x*q.x+p.y*q.y;
       offset=gamma*scale*length;
       return(offset);
@@ -3696,7 +3696,7 @@ static double GetFillAlpha(PolygonInfo *polygon_info,const double mid,
             }
           else
             {
-              alpha=MagickEpsilonReciprocal(alpha);
+              alpha=PerceptibleReciprocal(alpha);
               beta=delta.x*(y-q->y)-delta.y*(x-q->x);
               distance=alpha*beta*beta;
             }
@@ -5000,7 +5000,7 @@ static void TraceArcPath(PrimitiveInfo *primitive_info,const PointInfo start,
   points[1].y=(double) (cosine*end.y/radii.y-sine*end.x/radii.y);
   alpha=points[1].x-points[0].x;
   beta=points[1].y-points[0].y;
-  factor=MagickEpsilonReciprocal(alpha*alpha+beta*beta)-0.25;
+  factor=PerceptibleReciprocal(alpha*alpha+beta*beta)-0.25;
   if (factor <= 0.0)
     factor=0.0;
   else

diff --git a/MagickCore/effect.c b/MagickCore/effect.c
index bb7ae64694ea2164581a96fcc6fae2f53be906b2..cc297d51668a6cacef780fd053149ed06377f59c 100644 (file)
--- a/MagickCore/effect.c
+++ b/MagickCore/effect.c
@@ -277,7 +277,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
     }
     if (fabs(normalize) < MagickEpsilon)
       normalize=MagickEpsilon;
-    normalize=MagickEpsilonReciprocal(normalize);
+    normalize=PerceptibleReciprocal(normalize);
     for (k=0; k < (j*j); k++)
       kernel[i][k]=normalize*kernel[i][k];
   }
@@ -407,7 +407,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
                 pixels+=GetPixelChannels(image);
               }
             }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -425,7 +425,7 @@ MagickExport Image *AdaptiveBlurImage(const Image *image,const double radius,
             pixels+=GetPixelChannels(image);
           }
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       q+=GetPixelChannels(blur_image);
@@ -602,7 +602,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
     }
     if (fabs(normalize) < MagickEpsilon)
       normalize=MagickEpsilon;
-    normalize=MagickEpsilonReciprocal(normalize);
+    normalize=PerceptibleReciprocal(normalize);
     for (k=0; k < (j*j); k++)
       kernel[i][k]=normalize*kernel[i][k];
   }
@@ -732,7 +732,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
                 pixels+=GetPixelChannels(image);
               }
             }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(sharp_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -750,7 +750,7 @@ MagickExport Image *AdaptiveSharpenImage(const Image *image,const double radius,
             pixels+=GetPixelChannels(image);
           }
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(sharp_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       q+=GetPixelChannels(sharp_image);
@@ -1046,7 +1046,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
           k++;
           pixels+=GetPixelChannels(image);
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -1171,7 +1171,7 @@ MagickExport Image *BlurImage(const Image *image,const double radius,
           k++;
           pixels+=GetPixelChannels(blur_image);
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(blur_image);
@@ -2052,7 +2052,7 @@ MagickExport Image *MotionBlurImage(const Image *image,const double radius,
           gamma+=(*k)*alpha;
           k++;
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -2830,7 +2830,7 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
               pixel+=r[i];
               gamma++;
             }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -2848,7 +2848,7 @@ MagickExport Image *RadialBlurImage(const Image *image,const double angle,
           pixel+=GetPixelAlpha(image,r)*r[i];
           gamma+=GetPixelAlpha(image,r);
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);
@@ -3152,7 +3152,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
                 SetPixelChannel(blur_image,channel,p[center+i],q);
                 continue;
               }
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
             continue;
           }
@@ -3181,7 +3181,7 @@ MagickExport Image *SelectiveBlurImage(const Image *image,const double radius,
             SetPixelChannel(blur_image,channel,p[center+i],q);
             continue;
           }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(blur_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       p+=GetPixelChannels(image);

diff --git a/MagickCore/feature.c b/MagickCore/feature.c
index 0a4d096996e379772e9d26d3950ba64ec9727e09..00600931abd550d45b4e1a9f32edae46ca9246e2 100644 (file)
--- a/MagickCore/feature.c
+++ b/MagickCore/feature.c
@@ -572,7 +572,7 @@ MagickExport ChannelFeatures *GetImageFeatures(const Image *image,
         break;
       }
     }
-    normalize=MagickEpsilonReciprocal(normalize);
+    normalize=PerceptibleReciprocal(normalize);
     for (y=0; y < (ssize_t) number_grays; y++)
     {
       register ssize_t

diff --git a/MagickCore/gem.c b/MagickCore/gem.c
index 8b89d27392368ef538b67b8804419cb4d9f81336..3ff7cc03f972257dc2b91006f7bf710e67c5ab45 100644 (file)
--- a/MagickCore/gem.c
+++ b/MagickCore/gem.c
@@ -950,8 +950,8 @@ MagickPrivate size_t GetOptimalKernelWidth1D(const double radius,
   gamma=fabs(sigma);
   if (gamma <= MagickEpsilon)
     return(3UL);
-  alpha=MagickEpsilonReciprocal(2.0*gamma*gamma);
-  beta=(double) MagickEpsilonReciprocal((double) MagickSQ2PI*gamma);
+  alpha=PerceptibleReciprocal(2.0*gamma*gamma);
+  beta=(double) PerceptibleReciprocal((double) MagickSQ2PI*gamma);
   for (width=5; ; )
   {
     normalize=0.0;
@@ -990,8 +990,8 @@ MagickPrivate size_t GetOptimalKernelWidth2D(const double radius,
   gamma=fabs(sigma);
   if (gamma <= MagickEpsilon)
     return(3UL);
-  alpha=MagickEpsilonReciprocal(2.0*gamma*gamma);
-  beta=(double) MagickEpsilonReciprocal((double) Magick2PI*gamma*gamma);
+  alpha=PerceptibleReciprocal(2.0*gamma*gamma);
+  beta=(double) PerceptibleReciprocal((double) Magick2PI*gamma*gamma);
   for (width=5; ; )
   {
     normalize=0.0;

diff --git a/MagickCore/image.c b/MagickCore/image.c
index 54c849470cd533132b32525b53903b3673b4a1ee..0751d9bb5cc1f2563391c1eaa7fb4d6a21566c76 100644 (file)
--- a/MagickCore/image.c
+++ b/MagickCore/image.c
@@ -2090,7 +2090,7 @@ static inline void FlattenPixelInfo(const Image *image,const PixelInfo *p,
   Sa=QuantumScale*alpha;
   Da=QuantumScale*beta,
   gamma=Sa*(-Da)+Sa+Da;
-  gamma=MagickEpsilonReciprocal(gamma);
+  gamma=PerceptibleReciprocal(gamma);
   for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
   {
     PixelChannel

diff --git a/MagickCore/matrix.c b/MagickCore/matrix.c
index 512c8610a44875670dfddf41dcdd01c444d00e1f..02d412394d70c10995ad38f5d82434c332d31ee8 100644 (file)
--- a/MagickCore/matrix.c
+++ b/MagickCore/matrix.c
@@ -268,7 +268,7 @@ MagickPrivate MagickBooleanType GaussJordanElimination(double **matrix,
     columns[i]=column;
     if (matrix[column][column] == 0.0)
       return(MagickFalse);  /* singularity */
-    scale=MagickEpsilonReciprocal(matrix[column][column]);
+    scale=PerceptibleReciprocal(matrix[column][column]);
     matrix[column][column]=1.0;
     for (j=0; j < (ssize_t) rank; j++)
       matrix[column][j]*=scale;

diff --git a/MagickCore/pixel-private.h b/MagickCore/pixel-private.h
index b2fcb1519dcfa9983fa59719ebf6ca2875e694bb..337a04faa949174a561ee3ac1801ca8e68736d37 100644 (file)
--- a/MagickCore/pixel-private.h
+++ b/MagickCore/pixel-private.h
@@ -22,11 +22,14 @@
 extern "C" {
 #endif
 
-static inline double MagickEpsilonReciprocal(const double x)
+static inline double PerceptibleReciprocal(const double x)
 {
   double
     sign;
 
+  /*
+    Return 1/x where x is perceptible (not unlimited or infinitesimal).
+  */
   sign=x < 0.0 ? -1.0 : 1.0;
   if ((sign*x) >= MagickEpsilon)
     return(1.0/x);

diff --git a/MagickCore/pixel.c b/MagickCore/pixel.c
index 22fb4a10f8d193f1861ab67dcc9b90c568baaabe..95e58d50de23b604c398de139c0c3b9c72c0fc27 100644 (file)
--- a/MagickCore/pixel.c
+++ b/MagickCore/pixel.c
@@ -4142,7 +4142,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
         }
       for (i=0; i < (ssize_t) count; i++)
       {
-        gamma=MagickEpsilonReciprocal(alpha[i])/count;
+        gamma=PerceptibleReciprocal(alpha[i])/count;
         *pixel+=gamma*pixels[i];
       }
       break;
@@ -4179,7 +4179,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
       epsilon.y=1.0-delta.y;
       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
         (epsilon.x*alpha[2]+delta.x*alpha[3])));
-      gamma=MagickEpsilonReciprocal(gamma);
+      gamma=PerceptibleReciprocal(gamma);
       *pixel=gamma*(epsilon.y*(epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*
         (epsilon.x*pixels[2]+delta.x*pixels[3]));
       break;
@@ -4233,9 +4233,9 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
             pixels[0]+=pixels[1];
           }
       if (channel != AlphaPixelChannel)
-        gamma=MagickEpsilonReciprocal(alpha[0]); /* (color) 1/alpha_weights */
+        gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
       else
-        gamma=MagickEpsilonReciprocal(gamma); /* (alpha) 1/number_of_pixels */
+        gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
       *pixel=gamma*pixels[0];
       break;
     }
@@ -4268,7 +4268,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
       CatromWeights((double) (x-x_offset),&cx);
       CatromWeights((double) (y-y_offset),&cy);
       gamma=(channel == AlphaPixelChannel ? (double) 1.0 :
-        MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+        PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
         alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
         alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
         alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
@@ -4386,7 +4386,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
               */
               delta.y=1.0-delta.y;
               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               *pixel=gamma*MeshInterpolate(&delta,pixels[2],pixels[3],
                 pixels[0]);
             }
@@ -4397,7 +4397,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
               */
               delta.x=1.0-delta.x;
               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               *pixel=gamma*MeshInterpolate(&delta,pixels[1],pixels[0],
                 pixels[3]);
             }
@@ -4413,7 +4413,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
                 Top-left triangle (pixel: 0, diagonal: 1-2).
               */
               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               *pixel=gamma*MeshInterpolate(&delta,pixels[0],pixels[1],
                 pixels[2]);
             }
@@ -4425,7 +4425,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
               delta.x=1.0-delta.x;
               delta.y=1.0-delta.y;
               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               *pixel=gamma*MeshInterpolate(&delta,pixels[3],pixels[2],
                 pixels[1]);
             }
@@ -4461,7 +4461,7 @@ MagickExport MagickBooleanType InterpolatePixelChannel(const Image *image,
       SplineWeights((double) (x-x_offset),&cx);
       SplineWeights((double) (y-y_offset),&cy);
       gamma=(channel == AlphaPixelChannel ? (double) 1.0 :
-        MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+        PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
         alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
         alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
         alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
@@ -4623,7 +4623,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
           alpha[j]=QuantumScale*GetPixelAlpha(source,p+j*
             GetPixelChannels(source));
           pixels[j]*=alpha[j];
-          gamma=MagickEpsilonReciprocal(alpha[j]);
+          gamma=PerceptibleReciprocal(alpha[j]);
           sum+=gamma*pixels[j];
         }
         sum/=count;
@@ -4663,7 +4663,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
         if ((traits & BlendPixelTrait) == 0)
           {
             gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
-            gamma=MagickEpsilonReciprocal(gamma);
+            gamma=PerceptibleReciprocal(gamma);
             SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
               (epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*
               pixels[2]+delta.x*pixels[3]))),pixel);
@@ -4681,7 +4681,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
         pixels[3]*=alpha[3];
         gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
           (epsilon.x*alpha[2]+delta.x*alpha[3])));
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(destination,channel,ClampToQuantum(gamma*(epsilon.y*
           (epsilon.x*pixels[0]+delta.x*pixels[1])+delta.y*(epsilon.x*pixels[2]+
           delta.x*pixels[3]))),pixel);
@@ -4749,9 +4749,9 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
                pixels[0]+=pixels[1];
              }
         if ((traits & BlendPixelTrait) == 0)
-          gamma=MagickEpsilonReciprocal(alpha[0]); /* (color) 1/alpha_weights */
+          gamma=PerceptibleReciprocal(alpha[0]); /* (color) 1/alpha_weights */
         else
-          gamma=MagickEpsilonReciprocal(gamma); /* (alpha) 1/number_of_pixels */
+          gamma=PerceptibleReciprocal(gamma); /* (alpha) 1/number_of_pixels */
         SetPixelChannel(destination,channel,ClampToQuantum(gamma*pixels[0]),
           pixel);
       }
@@ -4797,7 +4797,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
         CatromWeights((double) (x-x_offset),&cx);
         CatromWeights((double) (y-y_offset),&cy);
         gamma=((traits & BlendPixelTrait) ? (double) (1.0) :
-          MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+          PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
           alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
           alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
           alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
@@ -4963,7 +4963,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
                 */
                 delta.y=1.0-delta.y;
                 gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
-                gamma=MagickEpsilonReciprocal(gamma);
+                gamma=PerceptibleReciprocal(gamma);
                 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
                   MeshInterpolate(&delta,pixels[2],pixels[3],pixels[0])),pixel);
               }
@@ -4974,7 +4974,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
                 */
                 delta.x=1.0-delta.x;
                 gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
-                gamma=MagickEpsilonReciprocal(gamma);
+                gamma=PerceptibleReciprocal(gamma);
                 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
                   MeshInterpolate(&delta,pixels[1],pixels[0],pixels[3])),pixel);
               }
@@ -4990,7 +4990,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
                   Top-left triangle (pixel: 0, diagonal: 1-2).
                 */
                 gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
-                gamma=MagickEpsilonReciprocal(gamma);
+                gamma=PerceptibleReciprocal(gamma);
                 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
                   MeshInterpolate(&delta,pixels[0],pixels[1],pixels[2])),pixel);
               }
@@ -5002,7 +5002,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
                 delta.x=1.0-delta.x;
                 delta.y=1.0-delta.y;
                 gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
-                gamma=MagickEpsilonReciprocal(gamma);
+                gamma=PerceptibleReciprocal(gamma);
                 SetPixelChannel(destination,channel,ClampToQuantum(gamma*
                   MeshInterpolate(&delta,pixels[3],pixels[2],pixels[1])),pixel);
               }
@@ -5050,7 +5050,7 @@ MagickExport MagickBooleanType InterpolatePixelChannels(const Image *source,
         SplineWeights((double) (x-x_offset),&cx);
         SplineWeights((double) (y-y_offset),&cy);
         gamma=((traits & BlendPixelTrait) ? (double) (1.0) :
-          MagickEpsilonReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
+          PerceptibleReciprocal(cy[0]*(cx[0]*alpha[0]+cx[1]*alpha[1]+cx[2]*
           alpha[2]+cx[3]*alpha[3])+cy[1]*(cx[0]*alpha[4]+cx[1]*alpha[5]+cx[2]*
           alpha[6]+cx[3]*alpha[7])+cy[2]*(cx[0]*alpha[8]+cx[1]*alpha[9]+cx[2]*
           alpha[10]+cx[3]*alpha[11])+cy[3]*(cx[0]*alpha[12]+cx[1]*alpha[13]+
@@ -5207,7 +5207,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
       for (i=0; i < (ssize_t) count; i++)
       {
         AlphaBlendPixelInfo(image,p,pixels,alpha);
-        gamma=MagickEpsilonReciprocal(alpha[0]);
+        gamma=PerceptibleReciprocal(alpha[0]);
         pixel->red+=gamma*pixels[0].red;
         pixel->green+=gamma*pixels[0].green;
         pixel->blue+=gamma*pixels[0].blue;
@@ -5249,7 +5249,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
       epsilon.y=1.0-delta.y;
       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
         (epsilon.x*alpha[2]+delta.x*alpha[3])));
-      gamma=MagickEpsilonReciprocal(gamma);
+      gamma=PerceptibleReciprocal(gamma);
       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
@@ -5263,7 +5263,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
           pixels[1].black)+delta.y*(epsilon.x*pixels[2].black+delta.x*
           pixels[3].black));
       gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
-      gamma=MagickEpsilonReciprocal(gamma);
+      gamma=PerceptibleReciprocal(gamma);
       pixel->alpha=(epsilon.y*(epsilon.x*pixels[0].alpha+delta.x*
         pixels[1].alpha)+delta.y*(epsilon.x*pixels[2].alpha+delta.x*
         pixels[3].alpha));
@@ -5316,7 +5316,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
             pixels[0].alpha+=pixels[1].alpha;
           }
       gamma=1.0/gamma;
-      alpha[0]=MagickEpsilonReciprocal(alpha[0]);
+      alpha[0]=PerceptibleReciprocal(alpha[0]);
       pixel->red=alpha[0]*pixels[0].red;
       pixel->green=alpha[0]*pixels[0].green;  /* divide by sum of alpha */
       pixel->blue=alpha[0]*pixels[0].blue;
@@ -5458,7 +5458,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
               */
               delta.y=1.0-delta.y;
               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
                 pixels[3].red,pixels[0].red);
               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
@@ -5479,7 +5479,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
               */
               delta.x=1.0-delta.x;
               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
                 pixels[0].red,pixels[3].red);
               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
@@ -5505,7 +5505,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
                 Top-left triangle (pixel: 0, diagonal: 1-2).
               */
               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
                 pixels[1].red,pixels[2].red);
               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
@@ -5527,7 +5527,7 @@ MagickExport MagickBooleanType InterpolatePixelInfo(const Image *image,
               delta.x=1.0-delta.x;
               delta.y=1.0-delta.y;
               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
                 pixels[2].red,pixels[1].red);
               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,

diff --git a/MagickCore/quantize.c b/MagickCore/quantize.c
index f98e8aaa29cfcf865a340045243ef7d5cdbe5551..5e0e2f8b433a96e7b708c5513fed4270e05206e9 100644 (file)
--- a/MagickCore/quantize.c
+++ b/MagickCore/quantize.c
@@ -1249,7 +1249,7 @@ static size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
       */
       q=image->colormap+image->colors;
       alpha=(double) ((MagickOffsetType) node_info->number_unique);
-      alpha=MagickEpsilonReciprocal(alpha);
+      alpha=PerceptibleReciprocal(alpha);
       if (cube_info->associate_alpha == MagickFalse)
         {
           q->red=(double) ClampToQuantum(alpha*QuantumRange*
@@ -1283,7 +1283,7 @@ static size_t DefineImageColormap(Image *image,CubeInfo *cube_info,
                 gamma;
 
               gamma=(double) (QuantumScale*q->alpha);
-              gamma=MagickEpsilonReciprocal(gamma);
+              gamma=PerceptibleReciprocal(gamma);
               q->red=(double) ClampToQuantum(alpha*gamma*QuantumRange*
                 node_info->total_color.red);
               q->green=(double) ClampToQuantum(alpha*gamma*QuantumRange*
@@ -2059,7 +2059,7 @@ static CubeInfo *GetCubeInfo(const QuantizeInfo *quantize_info,
   weight=1.0;
   for (i=0; i < ErrorQueueLength; i++)
   {
-    cube_info->weights[ErrorQueueLength-i-1]=MagickEpsilonReciprocal(weight);
+    cube_info->weights[ErrorQueueLength-i-1]=PerceptibleReciprocal(weight);
     weight*=exp(log(((double) QuantumRange+1.0))/(ErrorQueueLength-1.0));
   }
   /*

diff --git a/MagickCore/quantum-import.c b/MagickCore/quantum-import.c
index 5de3527f8004be0241aa6fbbac8782bee3d1dd2b..7d2afc7b9e1db8a1bc35d6fd388e3de2088c58e8 100644 (file)
--- a/MagickCore/quantum-import.c
+++ b/MagickCore/quantum-import.c
@@ -3610,7 +3610,7 @@ MagickExport size_t ImportQuantumPixels(const Image *image,
             continue;
           }
         Sa=QuantumScale*GetPixelAlpha(image,q);
-        gamma=MagickEpsilonReciprocal(Sa);
+        gamma=PerceptibleReciprocal(Sa);
         for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
         {
           PixelChannel

diff --git a/MagickCore/resize.c b/MagickCore/resize.c
index 73a5d5f822f32a584658c7c5af6a64c979fe4564..9fd168369a2365e867476b4d906e50c854e9b2a3 100644 (file)
--- a/MagickCore/resize.c
+++ b/MagickCore/resize.c
@@ -977,8 +977,8 @@ MagickPrivate ResizeFilter *AcquireResizeFilter(const Image *image,
       value=StringToDouble(artifact,(char **) NULL);
     /* Define coefficents for Gaussian */
     resize_filter->coefficient[0]=value;                 /* note sigma too */
-    resize_filter->coefficient[1]=MagickEpsilonReciprocal(2.0*value*value); /* sigma scaling */
-    resize_filter->coefficient[2]=MagickEpsilonReciprocal(Magick2PI*value*value);
+    resize_filter->coefficient[1]=PerceptibleReciprocal(2.0*value*value); /* sigma scaling */
+    resize_filter->coefficient[2]=PerceptibleReciprocal(Magick2PI*value*value);
        /* normalization - not actually needed or used! */
     if ( value > 0.5 )
       resize_filter->support *= 2*value;  /* increase support linearly */
@@ -999,7 +999,7 @@ MagickPrivate ResizeFilter *AcquireResizeFilter(const Image *image,
       value=StringToDouble(artifact,(char **) NULL)*MagickPI;
     /* Define coefficents for Kaiser Windowing Function */
     resize_filter->coefficient[0]=value;         /* alpha */
-    resize_filter->coefficient[1]=MagickEpsilonReciprocal(I0(value)); /* normalization */
+    resize_filter->coefficient[1]=PerceptibleReciprocal(I0(value)); /* normalization */
   }
 
   /* Support Overrides */
@@ -2235,7 +2235,7 @@ static MagickBooleanType HorizontalFilter(const ResizeFilter *resize_filter,
       return(MagickFalse);
     }
   status=MagickTrue;
-  scale=MagickEpsilonReciprocal(scale);
+  scale=PerceptibleReciprocal(scale);
   image_view=AcquireVirtualCacheView(image,exception);
   resize_view=AcquireAuthenticCacheView(resize_image,exception);
 #if defined(MAGICKCORE_OPENMP_SUPPORT)
@@ -2287,7 +2287,7 @@ static MagickBooleanType HorizontalFilter(const ResizeFilter *resize_filter,
         /*
           Normalize.
         */
-        density=MagickEpsilonReciprocal(density);
+        density=PerceptibleReciprocal(density);
         for (i=0; i < n; i++)
           contribution[i].weight*=density;
       }
@@ -2371,7 +2371,7 @@ static MagickBooleanType HorizontalFilter(const ResizeFilter *resize_filter,
           pixel+=alpha*p[k*GetPixelChannels(image)+i];
           gamma+=alpha;
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(resize_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       q+=GetPixelChannels(resize_image);
@@ -2448,7 +2448,7 @@ static MagickBooleanType VerticalFilter(const ResizeFilter *resize_filter,
       return(MagickFalse);
     }
   status=MagickTrue;
-  scale=MagickEpsilonReciprocal(scale);
+  scale=PerceptibleReciprocal(scale);
   (void) ResetMagickMemory(&zero,0,sizeof(zero));
   image_view=AcquireVirtualCacheView(image,exception);
   resize_view=AcquireAuthenticCacheView(resize_image,exception);
@@ -2501,7 +2501,7 @@ static MagickBooleanType VerticalFilter(const ResizeFilter *resize_filter,
         /*
           Normalize.
         */
-        density=MagickEpsilonReciprocal(density);
+        density=PerceptibleReciprocal(density);
         for (i=0; i < n; i++)
           contribution[i].weight*=density;
       }
@@ -2583,7 +2583,7 @@ static MagickBooleanType VerticalFilter(const ResizeFilter *resize_filter,
           pixel+=alpha*p[k*GetPixelChannels(image)+i];
           gamma+=alpha;
         }
-        gamma=MagickEpsilonReciprocal(gamma);
+        gamma=PerceptibleReciprocal(gamma);
         SetPixelChannel(resize_image,channel,ClampToQuantum(gamma*pixel),q);
       }
       q+=GetPixelChannels(resize_image);
@@ -3213,7 +3213,7 @@ MagickExport Image *ScaleImage(const Image *image,const size_t columns,
               }
             alpha=QuantumScale*scanline[x*GetPixelChannels(image)+
               GetPixelChannelChannel(image,AlphaPixelChannel)];
-            gamma=MagickEpsilonReciprocal(alpha);
+            gamma=PerceptibleReciprocal(alpha);
             SetPixelChannel(scale_image,channel,ClampToQuantum(gamma*scanline[
               x*GetPixelChannels(image)+offset]),q);
           }

diff --git a/MagickCore/segment.c b/MagickCore/segment.c
index d738fa155ec318873ac9a2a3f191899dfc96f392..8dca345487a72b43ca413f6303fa30089db65964 100644 (file)
--- a/MagickCore/segment.c
+++ b/MagickCore/segment.c
@@ -1731,8 +1731,8 @@ static void ScaleSpace(const ssize_t *histogram,const double tau,
   if (gamma == (double *) NULL)
     ThrowFatalException(ResourceLimitFatalError,
       "UnableToAllocateGammaMap");
-  alpha=MagickEpsilonReciprocal(tau*sqrt(2.0*MagickPI));
-  beta=(-1.0*MagickEpsilonReciprocal(2.0*tau*tau));
+  alpha=PerceptibleReciprocal(tau*sqrt(2.0*MagickPI));
+  beta=(-1.0*PerceptibleReciprocal(2.0*tau*tau));
   for (x=0; x <= 255; x++)
     gamma[x]=0.0;
   for (x=0; x <= 255; x++)

diff --git a/MagickCore/statistic.c b/MagickCore/statistic.c
index d6b84b5b13a8609bdc01bf2a465f5cb38ab84fe8..4d631bfcbf9d2718095471823e9f9f080f06ed8d 100644 (file)
--- a/MagickCore/statistic.c
+++ b/MagickCore/statistic.c
@@ -1679,7 +1679,7 @@ MagickExport ChannelStatistics *GetImageStatistics(const Image *image,
     double
       area;
 
-    area=MagickEpsilonReciprocal(channel_statistics[i].area);
+    area=PerceptibleReciprocal(channel_statistics[i].area);
     channel_statistics[i].sum*=area;
     channel_statistics[i].sum_squared*=area;
     channel_statistics[i].sum_cubed*=area;
@@ -1732,7 +1732,7 @@ MagickExport ChannelStatistics *GetImageStatistics(const Image *image,
     double
       standard_deviation;
 
-    standard_deviation=MagickEpsilonReciprocal(
+    standard_deviation=PerceptibleReciprocal(
       channel_statistics[i].standard_deviation);
     channel_statistics[i].skewness=(channel_statistics[i].sum_cubed-3.0*
       channel_statistics[i].mean*channel_statistics[i].sum_squared+2.0*

diff --git a/MagickWand/operation.c b/MagickWand/operation.c
index d8ddb59fd393ec4ad3d868ef2c0c662fbfd76676..15791bec5926c77843cc156bc274aba69a5dcb37 100644 (file)
--- a/MagickWand/operation.c
+++ b/MagickWand/operation.c
@@ -2429,12 +2429,12 @@ static void CLISimpleOperatorImage(MagickCLI *cli_wand,
 #if 0
           /* Using Gamma, via a cache */
           if (IfPlusOp)
-            constant=MagickEpsilonReciprocal(constant);
+            constant=PerceptibleReciprocal(constant);
           (void) GammaImage(_image,constant,_exception);
 #else
           /* Using Evaluate POW, direct update of values - more accurite */
           if (IfNormalOp)
-            constant=MagickEpsilonReciprocal(constant);
+            constant=PerceptibleReciprocal(constant);
           (void) EvaluateImage(_image,PowEvaluateOperator,constant,_exception);
 #endif
           /* Set gamma setting -- Old meaning of "+gamma"

diff --git a/coders/pango.c b/coders/pango.c
index 488a7aac847ea57b2edf1c1dbbd152f86a0b3c9f..9153ba870467888b493f9c40a76b00ccbfa8a83c 100644 (file)
--- a/coders/pango.c
+++ b/coders/pango.c
@@ -424,7 +424,7 @@ static Image *ReadPANGOImage(const ImageInfo *image_info,
         Disassociate alpha.
       */
       gamma=1.0-QuantumScale*fill_color.alpha;
-      gamma=MagickEpsilonReciprocal(gamma);
+      gamma=PerceptibleReciprocal(gamma);
       fill_color.blue*=gamma;
       fill_color.green*=gamma;
       fill_color.red*=gamma;

diff --git a/coders/svg.c b/coders/svg.c
index 14dd119ea2529d73a5810ee2437017c5a33e79c3..9bf127d4583d9effb5fe26c4f593ec1fa7f54242 100644 (file)
--- a/coders/svg.c
+++ b/coders/svg.c
@@ -3017,7 +3017,7 @@ static Image *ReadSVGImage(const ImageInfo *image_info,ExceptionInfo *exception)
                     gamma;
 
                   gamma=QuantumScale*fill_color.alpha;
-                  gamma=MagickEpsilonReciprocal(gamma);
+                  gamma=PerceptibleReciprocal(gamma);
                   fill_color.blue*=gamma;
                   fill_color.green*=gamma;
                   fill_color.red*=gamma;

diff --git a/coders/tiff.c b/coders/tiff.c
index fddbd563df5a1e6cd9c2fe24de9067ae3e03b038..5c72015cdfbb770bacec1ce87328d82513111e0d 100644 (file)
--- a/coders/tiff.c
+++ b/coders/tiff.c
@@ -1081,8 +1081,8 @@ static Image *ReadTIFFImage(const ImageInfo *image_info,
     (void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YRESOLUTION,&y_resolution);
     image->resolution.x=x_resolution;
     image->resolution.y=y_resolution;
-    x_position=(float) MagickEpsilonReciprocal(x_resolution)*image->page.x;
-    y_position=(float) MagickEpsilonReciprocal(y_resolution)*image->page.y;
+    x_position=(float) PerceptibleReciprocal(x_resolution)*image->page.x;
+    y_position=(float) PerceptibleReciprocal(y_resolution)*image->page.y;
     (void) TIFFGetFieldDefaulted(tiff,TIFFTAG_XPOSITION,&x_position);
     (void) TIFFGetFieldDefaulted(tiff,TIFFTAG_YPOSITION,&y_position);
     image->page.x=(ssize_t) ceil(x_position*x_resolution-0.5);