gamma             214 Magick++/demo/demo.cpp       example.gamma( 1.6 );
gamma             920 Magick++/lib/Image.cpp   return(constImage()->gamma);
gamma            3189 Magick++/lib/Image.cpp     gamma[MaxTextExtent + 1];
gamma            3191 Magick++/lib/Image.cpp   FormatLocaleString(gamma,MaxTextExtent,"%3.6f",gamma_);
gamma            3194 Magick++/lib/Image.cpp   GammaImage(image(),gamma);
gamma            3201 Magick++/lib/Image.cpp     gamma[MaxTextExtent + 1];
gamma            3203 Magick++/lib/Image.cpp   FormatLocaleString(gamma,MaxTextExtent,"%3.6f/%3.6f/%3.6f/",gammaRed_,
gamma            3207 Magick++/lib/Image.cpp   GammaImage(image(),gamma);
gamma            3366 Magick++/lib/Image.cpp   const double gamma)
gamma            3373 Magick++/lib/Image.cpp     gamma);
gamma            3379 Magick++/lib/Image.cpp   const double black_point,const double white_point,const double gamma)
gamma            3382 Magick++/lib/Image.cpp   (void) LevelImageChannel(image(),channel,black_point,white_point,gamma);
gamma             309 Magick++/lib/Magick++/Image.h     double gamma(void) const;
gamma            1014 Magick++/lib/Magick++/Image.h     void gamma(const double gamma_);
gamma            1015 Magick++/lib/Magick++/Image.h     void gamma(const double gammaRed_,const double gammaGreen_,
gamma             560 Magick++/lib/STL.cpp   image_.gamma( _gammaRed, _gammaGreen, _gammaBlue );
gamma             776 Magick++/tests/attributes.cpp     if ( image.gamma() == 1.0f)
gamma             713 coders/bmp.c                 gamma;
gamma             734 coders/bmp.c               gamma=bmp_info.red_primary.x+bmp_info.red_primary.y+
gamma             736 coders/bmp.c               gamma=PerceptibleReciprocal(gamma);
gamma             737 coders/bmp.c               bmp_info.red_primary.x*=gamma;
gamma             738 coders/bmp.c               bmp_info.red_primary.y*=gamma;
gamma             742 coders/bmp.c               gamma=bmp_info.green_primary.x+bmp_info.green_primary.y+
gamma             744 coders/bmp.c               gamma=PerceptibleReciprocal(gamma);
gamma             745 coders/bmp.c               bmp_info.green_primary.x*=gamma;
gamma             746 coders/bmp.c               bmp_info.green_primary.y*=gamma;
gamma             750 coders/bmp.c               gamma=bmp_info.blue_primary.x+bmp_info.blue_primary.y+
gamma             752 coders/bmp.c               gamma=PerceptibleReciprocal(gamma);
gamma             753 coders/bmp.c               bmp_info.blue_primary.x*=gamma;
gamma             754 coders/bmp.c               bmp_info.blue_primary.y*=gamma;
gamma             767 coders/bmp.c               image->gamma=(bmp_info.gamma_scale.x+bmp_info.gamma_scale.y+
gamma            1672 coders/bmp.c         (profile != (StringInfo *) NULL) || (image->gamma != 0.0) ?  MagickTrue :
gamma             196 coders/cin.c       gamma;
gamma             638 coders/cin.c     cin.origination.gamma=ReadBlobFloat(image);
gamma             640 coders/cin.c     if (IsFloatDefined(cin.origination.gamma) != MagickFalse)
gamma             641 coders/cin.c       image->gamma=cin.origination.gamma;
gamma            1134 coders/cin.c     cin.origination.gamma=image->gamma;
gamma            1135 coders/cin.c     offset+=WriteBlobFloat(image,cin.origination.gamma);
gamma             291 coders/dpx.c       gamma,
gamma            1068 coders/dpx.c         dpx.television.gamma=ReadBlobFloat(image);
gamma            1070 coders/dpx.c         if (IsFloatDefined(dpx.television.gamma) != MagickFalse)
gamma            1072 coders/dpx.c             dpx.television.gamma);
gamma            1902 coders/dpx.c     dpx.television.gamma=0.0f;
gamma            1905 coders/dpx.c       dpx.television.gamma=StringToDouble(value,(char **) NULL);
gamma            1906 coders/dpx.c     offset+=WriteBlobFloat(image,dpx.television.gamma);
gamma             207 coders/exr.c     image->gamma=1.0;
gamma            1197 coders/gif.c                       meta_image->gamma=StringToDouble((char *) info+6,
gamma            1340 coders/gif.c       if (image->gamma == 1.0)
gamma            1748 coders/gif.c           if ((image->gamma != 1.0f/2.2f))
gamma            1766 coders/gif.c                 image->gamma);
gamma             144 coders/hdr.c       gamma;
gamma             306 coders/hdr.c                     image->gamma=StringToDouble(value,(char **) NULL);
gamma             490 coders/hdr.c             gamma=pow(2.0,pixel[3]-(128.0+8.0));
gamma             491 coders/hdr.c             SetPixelRed(q,ClampToQuantum(QuantumRange*gamma*pixel[0]));
gamma             492 coders/hdr.c             SetPixelGreen(q,ClampToQuantum(QuantumRange*gamma*pixel[1]));
gamma             493 coders/hdr.c             SetPixelBlue(q,ClampToQuantum(QuantumRange*gamma*pixel[2]));
gamma             726 coders/hdr.c     if (image->gamma != 0.0)
gamma             728 coders/hdr.c         count=FormatLocaleString(header,MaxTextExtent,"GAMMA=%g\n",image->gamma);
gamma             769 coders/hdr.c           gamma;
gamma             775 coders/hdr.c         gamma=QuantumScale*GetPixelRed(p);
gamma             776 coders/hdr.c         if ((QuantumScale*GetPixelGreen(p)) > gamma)
gamma             777 coders/hdr.c           gamma=QuantumScale*GetPixelGreen(p);
gamma             778 coders/hdr.c         if ((QuantumScale*GetPixelBlue(p)) > gamma)
gamma             779 coders/hdr.c           gamma=QuantumScale*GetPixelBlue(p);
gamma             780 coders/hdr.c         if (gamma > MagickEpsilon)
gamma             785 coders/hdr.c             gamma=frexp(gamma,&exponent)*256.0/gamma;
gamma             786 coders/hdr.c             pixel[0]=(unsigned char) (gamma*QuantumScale*GetPixelRed(p));
gamma             787 coders/hdr.c             pixel[1]=(unsigned char) (gamma*QuantumScale*GetPixelGreen(p));
gamma             788 coders/hdr.c             pixel[2]=(unsigned char) (gamma*QuantumScale*GetPixelBlue(p));
gamma            1230 coders/json.c    if (image->gamma != 0.0)
gamma            1231 coders/json.c      (void) FormatLocaleFile(file,"    \"gamma\": %g,\n",image->gamma);
gamma             762 coders/miff.c                      image->gamma=StringToDouble(options,(char **) NULL);
gamma            2193 coders/miff.c      if (image->gamma != 0.0)
gamma            2196 coders/miff.c            image->gamma);
gamma             476 coders/mpc.c                       image->gamma=StringToDouble(options,(char **) NULL);
gamma            1254 coders/mpc.c       if (image->gamma != 0.0)
gamma            1257 coders/mpc.c             image->gamma);
gamma            3150 coders/msl.c               gamma[MaxTextExtent];
gamma            3168 coders/msl.c             *gamma='\0';
gamma            3211 coders/msl.c                         (void) CopyMagickString(gamma,value,MaxTextExtent);
gamma            3243 coders/msl.c             if (*gamma == '\0')
gamma            3244 coders/msl.c               (void) FormatLocaleString(gamma,MaxTextExtent,"%g,%g,%g",
gamma            3250 coders/msl.c                 (void) GammaImage(msl_info->image[n],gamma);
gamma             428 coders/pango.c         gamma;
gamma             437 coders/pango.c       gamma=1.0-QuantumScale*fill_color.opacity;
gamma             438 coders/pango.c       gamma=PerceptibleReciprocal(gamma);
gamma             439 coders/pango.c       fill_color.blue*=gamma;
gamma             440 coders/pango.c       fill_color.green*=gamma;
gamma             441 coders/pango.c       fill_color.red*=gamma;
gamma             840 coders/pcd.c     image->gamma=1.000f/2.200f;
gamma            2074 coders/png.c         (int) image->colorspace, image->gamma);
gamma            2551 coders/png.c            image->gamma=(float) file_gamma;
gamma            2611 coders/png.c             (image->gamma > .45 && image->gamma < .46)) &&
gamma            3529 coders/png.c           image_gamma = image->gamma;
gamma            3554 coders/png.c         image->gamma = image_gamma;
gamma            3963 coders/png.c         ((image->gamma < .45) || (image->gamma > .46)) &&
gamma            4424 coders/png.c             image->gamma=((float) mng_get_long(p))*0.00001;
gamma            4454 coders/png.c               image->gamma=1.000f/2.200f;
gamma            10551 coders/png.c             (image->gamma < .45 || image->gamma > .46)))
gamma            10553 coders/png.c         if ((mng_info->have_write_global_gama == 0) && (image->gamma != 0.0))
gamma            10563 coders/png.c             png_set_gAMA(ping,ping_info,image->gamma);
gamma            12436 coders/png.c         if (image->gamma != 0.0)
gamma            12444 coders/png.c             PNGLong(chunk+4,(png_uint_32) (100000*image->gamma+0.5));
gamma            13040 coders/png.c               if (next_image->gamma != next_image->next->gamma)
gamma            13282 coders/png.c            if (image->gamma && mng_info->equal_gammas)
gamma            13290 coders/png.c                PNGLong(chunk+4,(png_uint_32) (100000*image->gamma+0.5));
gamma             318 coders/psd.c           gamma;
gamma             320 coders/psd.c         gamma=QuantumScale*GetPixelAlpha(q);
gamma             321 coders/psd.c         if (gamma != 0.0 && gamma != 1.0)
gamma             323 coders/psd.c             SetPixelRed(q,(GetPixelRed(q)-((1.0-gamma)*QuantumRange))/gamma);
gamma             324 coders/psd.c             SetPixelGreen(q,(GetPixelGreen(q)-((1.0-gamma)*QuantumRange))/gamma);
gamma             325 coders/psd.c             SetPixelBlue(q,(GetPixelBlue(q)-((1.0-gamma)*QuantumRange))/gamma);
gamma             116 coders/rla.c         gamma[16+1],
gamma             225 coders/rla.c     count=ReadBlob(image,16,(unsigned char *) rla_info.gamma);
gamma            3049 coders/svg.c                       gamma;
gamma            3051 coders/svg.c                     gamma=1.0-QuantumScale*fill_color.opacity;
gamma            3052 coders/svg.c                     gamma=PerceptibleReciprocal(gamma);
gamma            3053 coders/svg.c                     fill_color.blue*=gamma;
gamma            3054 coders/svg.c                     fill_color.green*=gamma;
gamma            3055 coders/svg.c                     fill_color.red*=gamma;
gamma             650 magick/accelerate-private.h           gamma,
gamma             656 magick/accelerate-private.h         gamma=sqrt(-2.0f*log(alpha));
gamma             657 magick/accelerate-private.h         sigma=gamma*cospi((2.0f*beta));
gamma             658 magick/accelerate-private.h         tau=gamma*sinpi((2.0f*beta));
gamma            1203 magick/accelerate-private.h       gamma,
gamma            1208 magick/accelerate-private.h       gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1209 magick/accelerate-private.h       setOpacityF4(composite, QuantumRange*(1.0-gamma));
gamma            1210 magick/accelerate-private.h       gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1211 magick/accelerate-private.h       setRedF4(composite,gamma*ColorDodge(QuantumScale*getRedF4(*p)*Sa,Sa,QuantumScale*
gamma            1213 magick/accelerate-private.h       setGreenF4(composite,gamma*ColorDodge(QuantumScale*getGreenF4(*p)*Sa,Sa,QuantumScale*
gamma            1215 magick/accelerate-private.h       setBlueF4(composite,gamma*ColorDodge(QuantumScale*getBlueF4(*p)*Sa,Sa,QuantumScale*
gamma            1226 magick/accelerate-private.h         gamma;
gamma            1236 magick/accelerate-private.h       gamma=RoundToUnity(Sa+Da);  /* 'Plus' blending -- not 'Over' blending */
gamma            1237 magick/accelerate-private.h       setOpacityF4(composite,(float) QuantumRange*(1.0-gamma));
gamma            1238 magick/accelerate-private.h       gamma=PerceptibleReciprocal(gamma);
gamma            1239 magick/accelerate-private.h       setRedF4(composite,gamma*(Sa*getRedF4(*p)+Da*getRedF4(*q)));
gamma            1240 magick/accelerate-private.h       setGreenF4(composite,gamma*(Sa*getGreenF4(*p)+Da*getGreenF4(*q)));
gamma            1241 magick/accelerate-private.h       setBlueF4(composite,gamma*(Sa*getBlueF4(*p)+Da*getBlueF4(*q)));
gamma            1625 magick/accelerate-private.h       float gamma = 0.0f;
gamma            1639 magick/accelerate-private.h             gamma += f;
gamma            1662 magick/accelerate-private.h             gamma += g;
gamma            1668 magick/accelerate-private.h         gamma = PerceptibleReciprocal(gamma);
gamma            1669 magick/accelerate-private.h         sum.xyz = gamma*sum.xyz;
gamma            1706 magick/accelerate-private.h       float gamma = 0.0f;
gamma            1724 magick/accelerate-private.h             gamma += f;
gamma            1750 magick/accelerate-private.h             gamma += g;
gamma            1756 magick/accelerate-private.h         gamma = PerceptibleReciprocal(gamma);
gamma            1757 magick/accelerate-private.h         sum.xyz = gamma*sum.xyz;
gamma            2633 magick/accelerate-private.h         float gamma = 0.0f;
gamma            2651 magick/accelerate-private.h           gamma+=k*alpha;
gamma            2653 magick/accelerate-private.h         gamma = PerceptibleReciprocal(gamma);
gamma            2654 magick/accelerate-private.h         pixel.xyz = gamma*pixel.xyz;
gamma            2726 magick/accelerate-private.h           float gamma = 0.0f;
gamma            2738 magick/accelerate-private.h             gamma+=alpha;
gamma            2741 magick/accelerate-private.h           gamma = PerceptibleReciprocal(gamma);
gamma            2743 magick/accelerate-private.h           result.x = gamma*result.x;
gamma            2744 magick/accelerate-private.h           result.y = gamma*result.y;
gamma            2745 magick/accelerate-private.h           result.z = gamma*result.z;
gamma            3074 magick/accelerate-private.h       float gamma = 0.0f;
gamma            3128 magick/accelerate-private.h               gamma+=alpha;
gamma            3150 magick/accelerate-private.h             gammaCache[pixelIndex]+=gamma;
gamma            3173 magick/accelerate-private.h         float gamma = gammaCache[itemID];
gamma            3179 magick/accelerate-private.h           gamma *= density;
gamma            3181 magick/accelerate-private.h         gamma = PerceptibleReciprocal(gamma);
gamma            3184 magick/accelerate-private.h         fp = (CLPixelType) ( ClampToQuantum(gamma*filteredPixel.x)
gamma            3185 magick/accelerate-private.h           , ClampToQuantum(gamma*filteredPixel.y)
gamma            3186 magick/accelerate-private.h           , ClampToQuantum(gamma*filteredPixel.z)
gamma            3267 magick/accelerate-private.h       float gamma = 0.0f;
gamma            3321 magick/accelerate-private.h               gamma+=alpha;
gamma            3343 magick/accelerate-private.h             gammaCache[pixelIndex]+=gamma;
gamma            3366 magick/accelerate-private.h         float gamma = gammaCache[itemID];
gamma            3372 magick/accelerate-private.h           gamma *= density;
gamma            3374 magick/accelerate-private.h         gamma = PerceptibleReciprocal(gamma);
gamma            3377 magick/accelerate-private.h         fp = (CLPixelType) ( ClampToQuantum(gamma*filteredPixel.x)
gamma            3378 magick/accelerate-private.h           , ClampToQuantum(gamma*filteredPixel.y)
gamma            3379 magick/accelerate-private.h           , ClampToQuantum(gamma*filteredPixel.z)
gamma            3243 magick/cache.c     gamma;
gamma            3250 magick/cache.c   gamma=1.0-QuantumScale*QuantumScale*alpha*beta;
gamma            3251 magick/cache.c   gamma=PerceptibleReciprocal(gamma);
gamma            3252 magick/cache.c   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
gamma            3253 magick/cache.c   composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
gamma            3254 magick/cache.c   composite->blue=gamma*MagickOver_(p->blue,alpha,q->blue,beta);
gamma            3256 magick/cache.c     composite->index=gamma*MagickOver_(p->index,alpha,q->index,beta);
gamma             703 magick/channel.c             gamma;
gamma             705 magick/channel.c           gamma=QuantumScale*GetPixelAlpha(q);
gamma             706 magick/channel.c           SetPixelRed(q,ClampToQuantum(gamma*GetPixelRed(q)));
gamma             707 magick/channel.c           SetPixelGreen(q,ClampToQuantum(gamma*GetPixelGreen(q)));
gamma             708 magick/channel.c           SetPixelBlue(q,ClampToQuantum(gamma*GetPixelBlue(q)));
gamma             857 magick/channel.c             gamma;
gamma             860 magick/channel.c           gamma=PerceptibleReciprocal(alpha);
gamma             861 magick/channel.c           SetPixelRed(q,ClampToQuantum(gamma*GetPixelRed(q)));
gamma             862 magick/channel.c           SetPixelGreen(q,ClampToQuantum(gamma*GetPixelGreen(q)));
gamma             863 magick/channel.c           SetPixelBlue(q,ClampToQuantum(gamma*GetPixelBlue(q)));
gamma             934 magick/channel.c             gamma,
gamma             937 magick/channel.c           gamma=1.0-QuantumScale*QuantumScale*q->opacity*pixel.opacity;
gamma             938 magick/channel.c           opacity=(double) QuantumRange*(1.0-gamma);
gamma             939 magick/channel.c           gamma=PerceptibleReciprocal(gamma);
gamma             940 magick/channel.c           q->red=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->red,
gamma             943 magick/channel.c           q->green=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->green,
gamma             946 magick/channel.c           q->blue=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->blue,
gamma             590 magick/colorspace.c         gamma,
gamma             601 magick/colorspace.c       gamma=DisplayGamma;
gamma             604 magick/colorspace.c         gamma=PerceptibleReciprocal(StringToDouble(value,(char **) NULL));
gamma             622 magick/colorspace.c       black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002/
gamma             630 magick/colorspace.c           log10(black+(1.0*i/MaxMap)*(1.0-black))/((gamma/density)*0.002/
gamma            1141 magick/colorspace.c   image->gamma=1.000/2.200;
gamma            1148 magick/colorspace.c         image->gamma=1.0;
gamma            1154 magick/colorspace.c       image->gamma=1.0;
gamma            1399 magick/colorspace.c   if ((image->colorspace == GRAYColorspace) && (image->gamma != 1.0) &&
gamma            2187 magick/colorspace.c         gamma,
gamma            2198 magick/colorspace.c       gamma=DisplayGamma;
gamma            2201 magick/colorspace.c         gamma=PerceptibleReciprocal(StringToDouble(value,(char **) NULL));
gamma            2219 magick/colorspace.c       black=pow(10.0,(reference_black-reference_white)*(gamma/density)*0.002/
gamma            2225 magick/colorspace.c           (pow(10.0,(1024.0*i/MaxMap-reference_white)*(gamma/density)*0.002/
gamma            1141 magick/compare.c       gamma;
gamma            1143 magick/compare.c     gamma=image_statistics[i].standard_deviation*
gamma            1145 magick/compare.c     gamma=PerceptibleReciprocal(gamma);
gamma            1146 magick/compare.c     distortion[i]=QuantumRange*gamma*distortion[i];
gamma              56 magick/composite-private.h     gamma,
gamma              64 magick/composite-private.h   gamma=Sa+Da-Sa*Da;
gamma              67 magick/composite-private.h     RoundToUnity(gamma))));
gamma              68 magick/composite-private.h   gamma=PerceptibleReciprocal(gamma);
gamma              69 magick/composite-private.h   SetPixelRed(composite,ClampToQuantum(gamma*MagickOver_((MagickRealType)
gamma              71 magick/composite-private.h   SetPixelGreen(composite,ClampToQuantum(gamma*MagickOver_((MagickRealType)
gamma              73 magick/composite-private.h   SetPixelBlue(composite,ClampToQuantum(gamma*MagickOver_((MagickRealType)
gamma              76 magick/composite-private.h   SetPixelOpacity(composite,QuantumRange*(1.0-RoundToUnity(gamma)));
gamma              77 magick/composite-private.h   gamma=PerceptibleReciprocal(gamma);
gamma              78 magick/composite-private.h   SetPixelRed(composite,gamma*MagickOver_((MagickRealType)
gamma              80 magick/composite-private.h   SetPixelGreen(composite,gamma*MagickOver_((MagickRealType)
gamma              82 magick/composite-private.h   SetPixelBlue(composite,gamma*MagickOver_((MagickRealType)
gamma              93 magick/composite-private.h     gamma,
gamma             101 magick/composite-private.h   gamma=Sa+Da-Sa*Da;
gamma             102 magick/composite-private.h   composite->opacity=(MagickRealType) (QuantumRange*(1.0-RoundToUnity(gamma)));
gamma             103 magick/composite-private.h   gamma=PerceptibleReciprocal(gamma);
gamma             104 magick/composite-private.h   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
gamma             105 magick/composite-private.h   composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
gamma             106 magick/composite-private.h   composite->blue=gamma*MagickOver_(p->blue,alpha,q->blue,beta);
gamma             108 magick/composite-private.h     composite->index=gamma*MagickOver_(p->index,alpha,q->index,beta);
gamma             117 magick/composite-private.h     gamma,
gamma             125 magick/composite-private.h   gamma=RoundToUnity(Sa+Da);  /* 'Plus' blending -- not 'Over' blending */
gamma             126 magick/composite-private.h   composite->opacity=(MagickRealType) QuantumRange*(1.0-RoundToUnity(gamma));
gamma             127 magick/composite-private.h   gamma=PerceptibleReciprocal(gamma);
gamma             128 magick/composite-private.h   composite->red=gamma*(Sa*p->red+Da*q->red);
gamma             129 magick/composite-private.h   composite->green=gamma*(Sa*p->green+Da*q->green);
gamma             130 magick/composite-private.h   composite->blue=gamma*(Sa*p->blue+Da*q->blue);
gamma             132 magick/composite-private.h     composite->index=gamma*(Sa*p->index+Da*q->index);
gamma             273 magick/composite.c     gamma,
gamma             278 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             279 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             280 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             281 magick/composite.c   composite->red=gamma*ColorBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             283 magick/composite.c   composite->green=gamma*ColorBurn(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             285 magick/composite.c   composite->blue=gamma*ColorBurn(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             288 magick/composite.c     composite->index=gamma*ColorBurn(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma             335 magick/composite.c     gamma,
gamma             340 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             341 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             342 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             343 magick/composite.c   composite->red=gamma*ColorDodge(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             345 magick/composite.c   composite->green=gamma*ColorDodge(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             347 magick/composite.c   composite->blue=gamma*ColorDodge(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             350 magick/composite.c     composite->index=gamma*ColorDodge(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma             372 magick/composite.c     gamma;
gamma             376 magick/composite.c     gamma=1.0-QuantumScale*composite->opacity;
gamma             377 magick/composite.c     gamma=PerceptibleReciprocal(gamma);
gamma             378 magick/composite.c     composite->red=gamma*Darken(p->red,p->opacity,q->red,q->opacity);
gamma             379 magick/composite.c     composite->green=gamma*Darken(p->green,p->opacity,q->green,q->opacity);
gamma             380 magick/composite.c     composite->blue=gamma*Darken(p->blue,p->opacity,q->blue,q->opacity);
gamma             382 magick/composite.c       composite->index=gamma*Darken(p->index,p->opacity,q->index,q->opacity);
gamma             444 magick/composite.c     gamma;
gamma             453 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             454 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             455 magick/composite.c     gamma=PerceptibleReciprocal(gamma);
gamma             457 magick/composite.c     composite->red=gamma*Difference(p->red,Sa,q->red,Da);
gamma             458 magick/composite.c     composite->green=gamma*Difference(p->green,Sa,q->green,Da);
gamma             459 magick/composite.c     composite->blue=gamma*Difference(p->blue,Sa,q->blue,Da);
gamma             461 magick/composite.c       composite->index=gamma*Difference(p->index,Sa,q->index,Da);
gamma             503 magick/composite.c     gamma,
gamma             509 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             510 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             511 magick/composite.c     gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             512 magick/composite.c     composite->red=gamma*Divide(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             514 magick/composite.c     composite->green=gamma*Divide(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             516 magick/composite.c     composite->blue=gamma*Divide(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             519 magick/composite.c       composite->index=gamma*Divide(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma             551 magick/composite.c     gamma,
gamma             558 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             559 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             560 magick/composite.c     gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             561 magick/composite.c     composite->red=gamma*Exclusion(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             563 magick/composite.c     composite->green=gamma*Exclusion(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             565 magick/composite.c     composite->blue=gamma*Exclusion(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             568 magick/composite.c       composite->index=gamma*Exclusion(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma             602 magick/composite.c     gamma,
gamma             607 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             608 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             609 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             610 magick/composite.c   composite->red=gamma*HardLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             612 magick/composite.c   composite->green=gamma*HardLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             614 magick/composite.c   composite->blue=gamma*HardLight(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             617 magick/composite.c     composite->index=gamma*HardLight(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma             635 magick/composite.c     gamma,
gamma             640 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             641 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             642 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             643 magick/composite.c   composite->red=gamma*HardMix(p->red*Sa,q->red*Da);
gamma             644 magick/composite.c   composite->green=gamma*HardMix(p->green*Sa,q->green*Da);
gamma             645 magick/composite.c   composite->blue=gamma*HardMix(p->blue*Sa,q->blue*Da);
gamma             647 magick/composite.c     composite->index=gamma*HardMix(p->index*Sa,q->index*Da);
gamma             766 magick/composite.c     gamma;
gamma             774 magick/composite.c   gamma=Sa*Da;
gamma             775 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             776 magick/composite.c   gamma=PerceptibleReciprocal(gamma);
gamma             777 magick/composite.c   composite->red=gamma*In(p->red,Sa,q->red,Da);
gamma             778 magick/composite.c   composite->green=gamma*In(p->green,Sa,q->green,Da);
gamma             779 magick/composite.c   composite->blue=gamma*In(p->blue,Sa,q->blue,Da);
gamma             781 magick/composite.c     composite->index=gamma*In(p->index,Sa,q->index,Da);
gamma             802 magick/composite.c     gamma;
gamma             806 magick/composite.c     gamma=1.0-QuantumScale*composite->opacity;
gamma             807 magick/composite.c     gamma=PerceptibleReciprocal(gamma);
gamma             808 magick/composite.c     composite->red=gamma*Lighten(p->red,p->opacity,q->red,q->opacity);
gamma             809 magick/composite.c     composite->green=gamma*Lighten(p->green,p->opacity,q->green,q->opacity);
gamma             810 magick/composite.c     composite->blue=gamma*Lighten(p->blue,p->opacity,q->blue,q->opacity);
gamma             812 magick/composite.c       composite->index=gamma*Lighten(p->index,p->opacity,q->index,q->opacity);
gamma             879 magick/composite.c     gamma;
gamma             887 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             888 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             889 magick/composite.c   gamma=PerceptibleReciprocal(gamma);
gamma             890 magick/composite.c   composite->red=gamma*(p->red*Sa+q->red*Da);
gamma             891 magick/composite.c   composite->green=gamma*(p->green*Sa+q->green*Da);
gamma             892 magick/composite.c   composite->blue=gamma*(p->blue*Sa+q->blue*Da);
gamma             894 magick/composite.c     composite->index=gamma*(p->index*Sa+q->index*Da);
gamma             915 magick/composite.c     gamma,
gamma             920 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             921 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             922 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             923 magick/composite.c   composite->red=gamma*LinearBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             925 magick/composite.c   composite->green=gamma*LinearBurn(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             927 magick/composite.c   composite->blue=gamma*LinearBurn(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             930 magick/composite.c     composite->index=gamma*LinearBurn(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma             958 magick/composite.c     gamma,
gamma             963 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma             964 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma             965 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma             966 magick/composite.c   composite->red=gamma*LinearLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma             968 magick/composite.c   composite->green=gamma*LinearLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma             970 magick/composite.c   composite->blue=gamma*LinearLight(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma             973 magick/composite.c     composite->index=gamma*LinearLight(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1009 magick/composite.c     gamma;
gamma            1018 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1019 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1020 magick/composite.c     gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1021 magick/composite.c     composite->red=gamma*Mathematics(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma            1023 magick/composite.c     composite->green=gamma*Mathematics(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma            1025 magick/composite.c     composite->blue=gamma*Mathematics(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma            1028 magick/composite.c       composite->index=gamma*Mathematics(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1106 magick/composite.c     gamma;
gamma            1115 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1116 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1117 magick/composite.c     gamma=PerceptibleReciprocal(gamma);
gamma            1118 magick/composite.c     composite->red=gamma*Minus(p->red*Sa,Sa,q->red*Da,Da);
gamma            1119 magick/composite.c     composite->green=gamma*Minus(p->green*Sa,Sa,q->green*Da,Da);
gamma            1120 magick/composite.c     composite->blue=gamma*Minus(p->blue*Sa,Sa,q->blue*Da,Da);
gamma            1122 magick/composite.c       composite->index=gamma*Minus(p->index*Sa,Sa,q->index*Da,Da);
gamma            1158 magick/composite.c       gamma;
gamma            1166 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1167 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1168 magick/composite.c     gamma=PerceptibleReciprocal(gamma);
gamma            1210 magick/composite.c       gamma;
gamma            1218 magick/composite.c     gamma = RoundToUnity(Sa+Da-Sa*Da);
gamma            1219 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1220 magick/composite.c     gamma=PerceptibleReciprocal(gamma);
gamma            1254 magick/composite.c     gamma,
gamma            1260 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1261 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1262 magick/composite.c     gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1263 magick/composite.c     composite->red=gamma*Multiply(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma            1265 magick/composite.c     composite->green=gamma*Multiply(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma            1267 magick/composite.c     composite->blue=gamma*Multiply(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma            1270 magick/composite.c       composite->index=gamma*Multiply(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1300 magick/composite.c     gamma;
gamma            1308 magick/composite.c   gamma=Sa*(1.0-Da);
gamma            1309 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1310 magick/composite.c   gamma=PerceptibleReciprocal(gamma);
gamma            1311 magick/composite.c   composite->red=gamma*Out(p->red,Sa,q->red,Da);
gamma            1312 magick/composite.c   composite->green=gamma*Out(p->green,Sa,q->green,Da);
gamma            1313 magick/composite.c   composite->blue=gamma*Out(p->blue,Sa,q->blue,Da);
gamma            1315 magick/composite.c     composite->index=gamma*Out(p->index,Sa,q->index,Da);
gamma            1339 magick/composite.c     gamma,
gamma            1344 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1345 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1346 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1347 magick/composite.c   composite->red=gamma*PegtopLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma            1349 magick/composite.c   composite->green=gamma*PegtopLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma            1351 magick/composite.c   composite->blue=gamma*PegtopLight(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma            1354 magick/composite.c     composite->index=gamma*PegtopLight(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1379 magick/composite.c     gamma,
gamma            1384 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1385 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1386 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1387 magick/composite.c   composite->red=gamma*PinLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma            1389 magick/composite.c   composite->green=gamma*PinLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma            1391 magick/composite.c   composite->blue=gamma*PinLight(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma            1394 magick/composite.c     composite->index=gamma*PinLight(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1412 magick/composite.c     gamma;
gamma            1421 magick/composite.c     gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1422 magick/composite.c     composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1425 magick/composite.c     gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1426 magick/composite.c     composite->red=gamma*Screen(p->red*Sa,q->red*Da);
gamma            1427 magick/composite.c     composite->green=gamma*Screen(p->green*Sa,q->green*Da);
gamma            1428 magick/composite.c     composite->blue=gamma*Screen(p->blue*Sa,q->blue*Da);
gamma            1430 magick/composite.c       composite->index=gamma*Screen(p->index*Sa,q->index*Da);
gamma            1492 magick/composite.c     gamma,
gamma            1497 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1498 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1499 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1500 magick/composite.c   composite->red=gamma*SoftLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma            1502 magick/composite.c   composite->green=gamma*SoftLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma            1504 magick/composite.c   composite->blue=gamma*SoftLight(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma            1507 magick/composite.c     composite->index=gamma*SoftLight(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1565 magick/composite.c     gamma,
gamma            1570 magick/composite.c   gamma=RoundToUnity(Sa+Da-Sa*Da); /* over blend, as per SVG doc */
gamma            1571 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1572 magick/composite.c   gamma=QuantumRange/(fabs(gamma) < MagickEpsilon ? MagickEpsilon : gamma);
gamma            1573 magick/composite.c   composite->red=gamma*VividLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
gamma            1575 magick/composite.c   composite->green=gamma*VividLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
gamma            1577 magick/composite.c   composite->blue=gamma*VividLight(QuantumScale*p->blue*Sa,Sa,QuantumScale*
gamma            1580 magick/composite.c     composite->index=gamma*VividLight(QuantumScale*p->index*Sa,Sa,QuantumScale*
gamma            1595 magick/composite.c     gamma,
gamma            1600 magick/composite.c   gamma=Sa+Da-2*Sa*Da;        /* Xor blend mode X=0,Y=1,Z=1 */
gamma            1601 magick/composite.c   composite->opacity=(MagickRealType) QuantumRange*(1.0-gamma);
gamma            1602 magick/composite.c   gamma=PerceptibleReciprocal(gamma);
gamma            1603 magick/composite.c   composite->red=gamma*Xor(p->red*Sa,Sa,q->red*Da,Da);
gamma            1604 magick/composite.c   composite->green=gamma*Xor(p->green*Sa,Sa,q->green*Da,Da);
gamma            1605 magick/composite.c   composite->blue=gamma*Xor(p->blue*Sa,Sa,q->blue*Da,Da);
gamma            1607 magick/composite.c     composite->index=gamma*Xor(p->index*Sa,Sa,q->index*Da,Da);
gamma            3602 magick/deprecate.c     gamma;
gamma            3605 magick/deprecate.c   gamma=1.0*alpha*alpha*alpha;
gamma            3607 magick/deprecate.c   gamma-=4.0*alpha*alpha*alpha;
gamma            3609 magick/deprecate.c   gamma+=6.0*alpha*alpha*alpha;
gamma            3611 magick/deprecate.c   gamma-=4.0*alpha*alpha*alpha;
gamma            3612 magick/deprecate.c   return(gamma/6.0);
gamma            3653 magick/deprecate.c         gamma;
gamma            3680 magick/deprecate.c         gamma=alpha[i];
gamma            3681 magick/deprecate.c         gamma=PerceptibleReciprocal(gamma);
gamma            3682 magick/deprecate.c         pixel.red+=gamma*0.0625*pixels[i].red;
gamma            3683 magick/deprecate.c         pixel.green+=gamma*0.0625*pixels[i].green;
gamma            3684 magick/deprecate.c         pixel.blue+=gamma*0.0625*pixels[i].blue;
gamma            3687 magick/deprecate.c           pixel.index+=gamma*0.0625*pixels[i].index;
gamma            3741 magick/deprecate.c         gamma;
gamma            3775 magick/deprecate.c       gamma=(((1.0-delta.y)*((1.0-delta.x)*alpha[0]+delta.x*alpha[1])+delta.y*
gamma            3777 magick/deprecate.c       gamma=PerceptibleReciprocal(gamma);
gamma            3778 magick/deprecate.c       pixel.red=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].red+delta.x*
gamma            3781 magick/deprecate.c       pixel.green=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].green+delta.x*
gamma            3784 magick/deprecate.c       pixel.blue=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].blue+delta.x*
gamma            3791 magick/deprecate.c         pixel.index=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].index+delta.x*
gamma            3849 magick/deprecate.c         gamma;
gamma            3897 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
gamma            3898 magick/deprecate.c               gamma=PerceptibleReciprocal(gamma);
gamma            3899 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[2].red,
gamma            3901 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[2].green,
gamma            3903 magick/deprecate.c               pixel.blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
gamma            3905 magick/deprecate.c               pixel.opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
gamma            3908 magick/deprecate.c                 pixel.index=gamma*MeshInterpolate(&delta,pixels[2].index,
gamma            3917 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
gamma            3918 magick/deprecate.c               gamma=PerceptibleReciprocal(gamma);
gamma            3919 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[1].red,
gamma            3921 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[1].green,
gamma            3923 magick/deprecate.c               pixel.blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
gamma            3925 magick/deprecate.c               pixel.opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
gamma            3928 magick/deprecate.c                 pixel.index=gamma*MeshInterpolate(&delta,pixels[1].index,
gamma            3942 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
gamma            3943 magick/deprecate.c               gamma=PerceptibleReciprocal(gamma);
gamma            3944 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[0].red,
gamma            3946 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[0].green,
gamma            3948 magick/deprecate.c               pixel.blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
gamma            3950 magick/deprecate.c               pixel.opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
gamma            3953 magick/deprecate.c                 pixel.index=gamma*MeshInterpolate(&delta,pixels[0].index,
gamma            3963 magick/deprecate.c               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
gamma            3964 magick/deprecate.c               gamma=PerceptibleReciprocal(gamma);
gamma            3965 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[3].red,
gamma            3967 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[3].green,
gamma            3969 magick/deprecate.c               pixel.blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
gamma            3971 magick/deprecate.c               pixel.opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
gamma            3974 magick/deprecate.c                 pixel.index=gamma*MeshInterpolate(&delta,pixels[3].index,
gamma            3997 magick/deprecate.c         gamma;
gamma            4041 magick/deprecate.c           gamma=alpha[n];
gamma            4042 magick/deprecate.c           gamma=PerceptibleReciprocal(gamma);
gamma            4043 magick/deprecate.c           pixel.red+=gamma*dx*dy*pixels[n].red;
gamma            4044 magick/deprecate.c           pixel.green+=gamma*dx*dy*pixels[n].green;
gamma            4045 magick/deprecate.c           pixel.blue+=gamma*dx*dy*pixels[n].blue;
gamma            4049 magick/deprecate.c             pixel.index+=gamma*dx*dy*pixels[n].index;
gamma            3208 magick/draw.c          gamma,
gamma            3226 magick/draw.c        gamma=sqrt(p.x*p.x+p.y*p.y)*length;
gamma            3227 magick/draw.c        gamma=PerceptibleReciprocal(gamma);
gamma            3229 magick/draw.c        offset=gamma*scale*length;
gamma            4973 magick/draw.c      gamma,
gamma            5052 magick/draw.c      gamma=(8.0/3.0)*sin(fmod((double) (0.5*beta),DegreesToRadians(360.0)))*
gamma            5056 magick/draw.c        arc_segments),DegreesToRadians(360.0)))-gamma*sin(fmod((double) (alpha+
gamma            5059 magick/draw.c        arc_segments),DegreesToRadians(360.0)))+gamma*cos(fmod((double) (alpha+
gamma            5065 magick/draw.c      points[1].x=(double) (points[2].x+gamma*sin(fmod((double) (alpha+(double)
gamma            5067 magick/draw.c      points[1].y=(double) (points[2].y-gamma*cos(fmod((double) (alpha+(double)
gamma             318 magick/effect.c         gamma;
gamma             331 magick/effect.c       gamma=0.0;
gamma             371 magick/effect.c           gamma+=(*k)*alpha;
gamma             376 magick/effect.c       gamma=PerceptibleReciprocal(gamma);
gamma             378 magick/effect.c         SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma             380 magick/effect.c         SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma             382 magick/effect.c         SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma             387 magick/effect.c         SetPixelIndex(blur_indexes+x,ClampToQuantum(gamma*pixel.index));
gamma             640 magick/effect.c         gamma;
gamma             653 magick/effect.c       gamma=0.0;
gamma             693 magick/effect.c           gamma+=(*k)*alpha;
gamma             698 magick/effect.c       gamma=PerceptibleReciprocal(gamma);
gamma             700 magick/effect.c         SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma             702 magick/effect.c         SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma             704 magick/effect.c         SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma             709 magick/effect.c         SetPixelIndex(sharp_indexes+x,ClampToQuantum(gamma*pixel.index));
gamma            1348 magick/effect.c     gamma,
gamma            1409 magick/effect.c   gamma=PerceptibleReciprocal(normalize);
gamma            1411 magick/effect.c     kernel_info->values[i]*=gamma;
gamma            1700 magick/effect.c             gamma;
gamma            1702 magick/effect.c           gamma=0.0;
gamma            1712 magick/effect.c               gamma+=(*k)*alpha;
gamma            1717 magick/effect.c           gamma=PerceptibleReciprocal(gamma); 
gamma            1719 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma            1721 magick/effect.c             SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma            1723 magick/effect.c             SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma            1760 magick/effect.c               SetPixelIndex(filter_indexes+x,ClampToQuantum(gamma*pixel.index));
gamma            2131 magick/effect.c             gamma;
gamma            2134 magick/effect.c           gamma=0.0;
gamma            2149 magick/effect.c             gamma+=(*k)*alpha;
gamma            2152 magick/effect.c           gamma=PerceptibleReciprocal(gamma);
gamma            2154 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
gamma            2156 magick/effect.c             SetPixelGreen(q,ClampToQuantum(gamma*qixel.green));
gamma            2158 magick/effect.c             SetPixelBlue(q,ClampToQuantum(gamma*qixel.blue));
gamma            2163 magick/effect.c             SetPixelIndex(blur_indexes+x,ClampToQuantum(gamma*qixel.index));
gamma            2763 magick/effect.c     gamma,
gamma            2809 magick/effect.c   gamma=(-0.2f);
gamma            2899 magick/effect.c         gamma+=0.4f;
gamma            2900 magick/effect.c         (void) GammaImageChannel(preview_image,DefaultChannels,gamma);
gamma            2901 magick/effect.c         (void) FormatLocaleString(label,MaxTextExtent,"gamma %g",gamma);
gamma            3479 magick/effect.c             gamma;
gamma            3482 magick/effect.c           gamma=0.0;
gamma            3499 magick/effect.c             gamma+=alpha;
gamma            3502 magick/effect.c           gamma=PerceptibleReciprocal(gamma);
gamma            3505 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
gamma            3507 magick/effect.c             SetPixelGreen(q,ClampToQuantum(gamma*qixel.green));
gamma            3509 magick/effect.c             SetPixelBlue(q,ClampToQuantum(gamma*qixel.blue));
gamma            3514 magick/effect.c             SetPixelIndex(blur_indexes+x,ClampToQuantum(gamma*qixel.index));
gamma            3735 magick/effect.c       gamma;
gamma            3800 magick/effect.c       gamma=0.0;
gamma            3814 magick/effect.c                   gamma+=(*k);
gamma            3820 magick/effect.c           if (gamma != 0.0)
gamma            3822 magick/effect.c               gamma=PerceptibleReciprocal(gamma);
gamma            3824 magick/effect.c                 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma            3826 magick/effect.c                 SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma            3828 magick/effect.c                 SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma            3832 magick/effect.c               gamma=0.0;
gamma            3842 magick/effect.c                       gamma+=(*k);
gamma            3848 magick/effect.c               gamma=PerceptibleReciprocal(gamma);
gamma            3849 magick/effect.c               SetPixelOpacity(q,ClampToQuantum(gamma*pixel.opacity));
gamma            3854 magick/effect.c               gamma=0.0;
gamma            3864 magick/effect.c                       gamma+=(*k);
gamma            3870 magick/effect.c               gamma=PerceptibleReciprocal(gamma);
gamma            3871 magick/effect.c               SetPixelIndex(blur_indexes+x,ClampToQuantum(gamma*pixel.index));
gamma            3891 magick/effect.c                   gamma+=(*k)*alpha;
gamma            3897 magick/effect.c           if (gamma != 0.0)
gamma            3899 magick/effect.c               gamma=PerceptibleReciprocal(gamma);
gamma            3901 magick/effect.c                 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma            3903 magick/effect.c                 SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma            3905 magick/effect.c                 SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma            3926 magick/effect.c               gamma=0.0;
gamma            3938 magick/effect.c                       gamma+=(*k);
gamma            3944 magick/effect.c               gamma=PerceptibleReciprocal(gamma);
gamma            3945 magick/effect.c               SetPixelIndex(blur_indexes+x,ClampToQuantum(gamma*pixel.index));
gamma            4251 magick/effect.c     gamma,
gamma            4311 magick/effect.c   gamma=PerceptibleReciprocal(normalize);
gamma            4313 magick/effect.c     kernel_info->values[i]*=gamma;
gamma             124 magick/enhance.c     gamma,
gamma             139 magick/enhance.c       gamma=log(mean*QuantumScale)/logmean;
gamma             140 magick/enhance.c       return(LevelImageChannel(image,channel,0.0,(double) QuantumRange,gamma));
gamma             150 magick/enhance.c       gamma=log(mean*QuantumScale)/logmean;
gamma             152 magick/enhance.c         gamma);
gamma             158 magick/enhance.c       gamma=log(mean*QuantumScale)/logmean;
gamma             160 magick/enhance.c         gamma);
gamma             166 magick/enhance.c       gamma=log(mean*QuantumScale)/logmean;
gamma             168 magick/enhance.c         gamma);
gamma             175 magick/enhance.c       gamma=log(mean*QuantumScale)/logmean;
gamma             177 magick/enhance.c         gamma);
gamma             184 magick/enhance.c       gamma=log(mean*QuantumScale)/logmean;
gamma             186 magick/enhance.c         gamma);
gamma            2101 magick/enhance.c static inline double gamma_pow(const double value,const double gamma)
gamma            2103 magick/enhance.c   return(value < 0.0 ? value : pow(value,gamma));
gamma            2112 magick/enhance.c     gamma;
gamma            2125 magick/enhance.c   gamma.red=geometry_info.rho;
gamma            2126 magick/enhance.c   gamma.green=geometry_info.sigma;
gamma            2128 magick/enhance.c     gamma.green=gamma.red;
gamma            2129 magick/enhance.c   gamma.blue=geometry_info.xi;
gamma            2131 magick/enhance.c     gamma.blue=gamma.red;
gamma            2132 magick/enhance.c   if ((gamma.red == 1.0) && (gamma.green == 1.0) && (gamma.blue == 1.0))
gamma            2134 magick/enhance.c   if ((gamma.red == gamma.green) && (gamma.green == gamma.blue))
gamma            2136 magick/enhance.c       BlueChannel),(double) gamma.red);
gamma            2139 magick/enhance.c       status=GammaImageChannel(image,RedChannel,(double) gamma.red);
gamma            2140 magick/enhance.c       status&=GammaImageChannel(image,GreenChannel,(double) gamma.green);
gamma            2141 magick/enhance.c       status&=GammaImageChannel(image,BlueChannel,(double) gamma.blue);
gamma            2147 magick/enhance.c   const ChannelType channel,const double gamma)
gamma            2179 magick/enhance.c   if (gamma == 1.0)
gamma            2186 magick/enhance.c   if (gamma != 0.0)
gamma            2189 magick/enhance.c         MagickRealType) (MaxMap*pow((double) i/MaxMap,1.0/gamma))));
gamma            2220 magick/enhance.c             image->colormap[i].red,1.0/gamma);
gamma            2223 magick/enhance.c             image->colormap[i].green,1.0/gamma);
gamma            2226 magick/enhance.c             image->colormap[i].blue,1.0/gamma);
gamma            2231 magick/enhance.c                 image->colormap[i].opacity,1.0/gamma);
gamma            2235 magick/enhance.c                 gamma);
gamma            2302 magick/enhance.c             1.0/gamma));
gamma            2304 magick/enhance.c             1.0/gamma));
gamma            2306 magick/enhance.c             1.0/gamma));
gamma            2312 magick/enhance.c             1.0/gamma));
gamma            2315 magick/enhance.c               GetPixelGreen(q),1.0/gamma));
gamma            2318 magick/enhance.c               1.0/gamma));
gamma            2323 magick/enhance.c                   GetPixelOpacity(q),1.0/gamma));
gamma            2326 magick/enhance.c                   GetPixelAlpha(q),1.0/gamma));
gamma            2355 magick/enhance.c   if (image->gamma != 0.0)
gamma            2356 magick/enhance.c     image->gamma*=gamma;
gamma            2817 magick/enhance.c     gamma,
gamma            2839 magick/enhance.c   gamma=1.0;
gamma            2841 magick/enhance.c     gamma=geometry_info.xi;
gamma            2851 magick/enhance.c       gamma);
gamma            2853 magick/enhance.c     status=LevelizeImage(image,black_point,white_point,gamma);
gamma            2901 magick/enhance.c   const double white_point,const double gamma,const MagickRealType pixel)
gamma            2909 magick/enhance.c     gamma);
gamma            2915 magick/enhance.c   const double gamma)
gamma            2952 magick/enhance.c           white_point,gamma,(MagickRealType) image->colormap[i].red));
gamma            2955 magick/enhance.c           black_point,white_point,gamma,(MagickRealType)
gamma            2959 magick/enhance.c           white_point,gamma,(MagickRealType) image->colormap[i].blue));
gamma            2962 magick/enhance.c           ClampToQuantum(LevelPixel(black_point,white_point,gamma,
gamma            2999 magick/enhance.c         SetPixelRed(q,ClampToQuantum(LevelPixel(black_point,white_point,gamma,
gamma            3002 magick/enhance.c         SetPixelGreen(q,ClampToQuantum(LevelPixel(black_point,white_point,gamma,
gamma            3005 magick/enhance.c         SetPixelBlue(q,ClampToQuantum(LevelPixel(black_point,white_point,gamma,
gamma            3009 magick/enhance.c         SetPixelAlpha(q,ClampToQuantum(LevelPixel(black_point,white_point,gamma,
gamma            3014 magick/enhance.c           white_point,gamma,(MagickRealType) GetPixelIndex(indexes+x))));
gamma            3081 magick/enhance.c   const double black_point,const double white_point,const double gamma)
gamma            3087 magick/enhance.c     gamma);
gamma            3093 magick/enhance.c   const double gamma)
gamma            3097 magick/enhance.c   (QuantumScale*(x)),gamma))*(white_point-black_point)+black_point)
gamma            2199 magick/feature.c           gamma;
gamma            2248 magick/feature.c         gamma=1.0/count;
gamma            2249 magick/feature.c         mean_location.x=gamma*sum_location.x;
gamma            2250 magick/feature.c         mean_location.y=gamma*sum_location.y;
gamma            2251 magick/feature.c         mean_pixel.red=gamma*sum_pixel.red;
gamma            2252 magick/feature.c         mean_pixel.green=gamma*sum_pixel.green;
gamma            2253 magick/feature.c         mean_pixel.blue=gamma*sum_pixel.blue;
gamma            2254 magick/feature.c         mean_pixel.opacity=gamma*sum_pixel.opacity;
gamma             299 magick/fourier.c             gamma;
gamma             301 magick/fourier.c           gamma=PerceptibleReciprocal(Br->red*Br->red+Bi->red*Bi->red+snr);
gamma             302 magick/fourier.c           Cr->red=gamma*(Ar->red*Br->red+Ai->red*Bi->red);
gamma             303 magick/fourier.c           Ci->red=gamma*(Ai->red*Br->red-Ar->red*Bi->red);
gamma             304 magick/fourier.c           gamma=PerceptibleReciprocal(Br->green*Br->green+Bi->green*Bi->green+
gamma             306 magick/fourier.c           Cr->green=gamma*(Ar->green*Br->green+Ai->green*Bi->green);
gamma             307 magick/fourier.c           Ci->green=gamma*(Ai->green*Br->green-Ar->green*Bi->green);
gamma             308 magick/fourier.c           gamma=PerceptibleReciprocal(Br->blue*Br->blue+Bi->blue*Bi->blue+snr);
gamma             309 magick/fourier.c           Cr->blue=gamma*(Ar->blue*Br->blue+Ai->blue*Bi->blue);
gamma             310 magick/fourier.c           Ci->blue=gamma*(Ai->blue*Br->blue-Ar->blue*Bi->blue);
gamma             313 magick/fourier.c               gamma=PerceptibleReciprocal(Br->opacity*Br->opacity+Bi->opacity*
gamma             315 magick/fourier.c               Cr->opacity=gamma*(Ar->opacity*Br->opacity+Ai->opacity*
gamma             317 magick/fourier.c               Ci->opacity=gamma*(Ai->opacity*Br->opacity-Ar->opacity*
gamma             868 magick/fourier.c         gamma;
gamma             874 magick/fourier.c       gamma=PerceptibleReciprocal((double) fourier_info->width*
gamma             880 magick/fourier.c           forward_pixels[i]*=gamma;
gamma             882 magick/fourier.c           forward_pixels[i][0]*=gamma;
gamma             883 magick/fourier.c           forward_pixels[i][1]*=gamma;
gamma            1434 magick/fourier.c         gamma;
gamma            1440 magick/fourier.c       gamma=PerceptibleReciprocal((double) fourier_info->width*
gamma            1446 magick/fourier.c           fourier_pixels[i]*=gamma;
gamma            1448 magick/fourier.c           fourier_pixels[i][0]*=gamma;
gamma            1449 magick/fourier.c           fourier_pixels[i][1]*=gamma;
gamma            2122 magick/fx.c        gamma;
gamma            2209 magick/fx.c              gamma=FxEvaluateSubexpression(fx_info,channel,x,y,++p,depth,beta,
gamma            2211 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) << (size_t) (gamma+0.5));
gamma            2216 magick/fx.c              gamma=FxEvaluateSubexpression(fx_info,channel,x,y,++p,depth,beta,
gamma            2218 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) >> (size_t) (gamma+0.5));
gamma            2259 magick/fx.c              gamma=FxEvaluateSubexpression(fx_info,channel,x,y,++p,depth,beta,
gamma            2261 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) & (size_t) (gamma+0.5));
gamma            2266 magick/fx.c              gamma=FxEvaluateSubexpression(fx_info,channel,x,y,++p,depth,beta,
gamma            2268 magick/fx.c              *beta=(double) ((size_t) (alpha+0.5) | (size_t) (gamma+0.5));
gamma            2279 magick/fx.c              gamma=FxEvaluateSubexpression(fx_info,channel,x,y,p,depth,beta,
gamma            2281 magick/fx.c              *beta=(gamma > 0.0) ? 1.0 : 0.0;
gamma            2292 magick/fx.c              gamma=FxEvaluateSubexpression(fx_info,channel,x,y,p,depth,beta,
gamma            2294 magick/fx.c              *beta=(gamma > 0.0) ? 1.0 : 0.0;
gamma            2300 magick/fx.c                gamma;
gamma            2312 magick/fx.c                gamma=FxEvaluateSubexpression(fx_info,channel,x,y,p,depth,beta,
gamma            2315 magick/fx.c                gamma=FxEvaluateSubexpression(fx_info,channel,x,y,q,depth,beta,
gamma            2317 magick/fx.c              return(gamma);
gamma            2357 magick/fx.c              gamma=alpha*FxEvaluateSubexpression(fx_info,channel,x,y,p,depth,beta,
gamma            2359 magick/fx.c              return(gamma);
gamma            2371 magick/fx.c          gamma=FxEvaluateSubexpression(fx_info,channel,x,y,subexpression,depth,
gamma            2374 magick/fx.c          return(gamma);
gamma            2380 magick/fx.c          gamma=FxEvaluateSubexpression(fx_info,channel,x,y,expression+1,depth,beta,
gamma            2382 magick/fx.c          return(1.0*gamma);
gamma            2386 magick/fx.c          gamma=FxEvaluateSubexpression(fx_info,channel,x,y,expression+1,depth,beta,
gamma            2388 magick/fx.c          return(-1.0*gamma);
gamma            2392 magick/fx.c          gamma=FxEvaluateSubexpression(fx_info,channel,x,y,expression+1,depth,beta,
gamma            2394 magick/fx.c          return((double) (~(size_t) (gamma+0.5)));
gamma            2426 magick/fx.c              gamma=2.0*j1((double) (MagickPI*alpha))/(MagickPI*alpha);
gamma            2427 magick/fx.c              return(gamma*gamma);
gamma            2595 magick/fx.c              gamma=exp((double) (-alpha*alpha/2.0))/sqrt(2.0*MagickPI);
gamma            2596 magick/fx.c              return(gamma);
gamma            2683 magick/fx.c              gamma=(2.0*j1((double) (MagickPI*alpha))/(MagickPI*alpha));
gamma            2684 magick/fx.c              return(gamma);
gamma            2739 magick/fx.c              gamma=alpha-floor((double) (alpha/(*beta)))*(*beta);
gamma            2740 magick/fx.c              return(gamma);
gamma            2835 magick/fx.c              gamma=(sin((double) (MagickPI*alpha))/(MagickPI*alpha));
gamma            2836 magick/fx.c              return(gamma);
gamma            1517 magick/gem.c           gamma,
gamma            1523 magick/gem.c         gamma=sqrt(-2.0*log(alpha));
gamma            1524 magick/gem.c         sigma=gamma*cos((double) (2.0*MagickPI*beta));
gamma            1525 magick/gem.c         tau=gamma*sin((double) (2.0*MagickPI*beta));
gamma            1628 magick/gem.c       gamma,
gamma            1644 magick/gem.c     gamma=fabs(sigma);
gamma            1645 magick/gem.c     if (gamma <= MagickEpsilon)
gamma            1647 magick/gem.c     alpha=PerceptibleReciprocal(2.0*gamma*gamma);
gamma            1648 magick/gem.c     beta=(double) PerceptibleReciprocal((double) MagickSQ2PI*gamma);
gamma            1669 magick/gem.c       gamma,
gamma            1684 magick/gem.c     gamma=fabs(sigma);
gamma            1685 magick/gem.c     if (gamma <= MagickEpsilon)
gamma            1687 magick/gem.c     alpha=PerceptibleReciprocal(2.0*gamma*gamma);
gamma            1688 magick/gem.c     beta=(double) PerceptibleReciprocal((double) Magick2PI*gamma*gamma);
gamma            1113 magick/identify.c   if (image->gamma != 0.0)
gamma            1114 magick/identify.c     (void) FormatLocaleFile(file,"  Gamma: %g\n",image->gamma);
gamma             176 magick/image.c   image->gamma=1.000f/2.200f;
gamma             186 magick/image.h     gamma;
gamma            2766 magick/morphology.c               gamma;  /* divisor, sum of color alpha weighting */
gamma            2775 magick/morphology.c             gamma=0.0;
gamma            2781 magick/morphology.c               gamma += alpha; /* normalize alpha weights only */
gamma            2793 magick/morphology.c             gamma=PerceptibleReciprocal(gamma);
gamma            2795 magick/morphology.c               gamma*=(double) kernel->height/count;
gamma            2796 magick/morphology.c             SetPixelRed(q,ClampToQuantum(gamma*result.red));
gamma            2797 magick/morphology.c             SetPixelGreen(q,ClampToQuantum(gamma*result.green));
gamma            2798 magick/morphology.c             SetPixelBlue(q,ClampToQuantum(gamma*result.blue));
gamma            2801 magick/morphology.c               SetPixelIndex(q_indexes+y,ClampToQuantum(gamma*result.index));
gamma            3015 magick/morphology.c                   gamma;  /* divisor, sum of color alpha weighting */
gamma            3021 magick/morphology.c                 gamma=0.0;
gamma            3028 magick/morphology.c                     gamma += alpha;    /* normalize alpha weights only */
gamma            3040 magick/morphology.c                 gamma=PerceptibleReciprocal(gamma);
gamma            3042 magick/morphology.c                   gamma*=(double) kernel->height*kernel->width/count;
gamma            3043 magick/morphology.c                 SetPixelRed(q,ClampToQuantum((MagickRealType) (gamma*result.red)));
gamma            3044 magick/morphology.c                 SetPixelGreen(q,ClampToQuantum((MagickRealType) (gamma*result.green)));
gamma            3045 magick/morphology.c                 SetPixelBlue(q,ClampToQuantum((MagickRealType) (gamma*result.blue)));
gamma            3048 magick/morphology.c                   SetPixelIndex(q_indexes+x,ClampToQuantum((MagickRealType) (gamma*
gamma            4378 magick/pixel.c     gamma;
gamma            4388 magick/pixel.c   gamma=(*weights)[3]-(*weights)[0];
gamma            4389 magick/pixel.c   (*weights)[1]=alpha-(*weights)[0]+gamma;
gamma            4390 magick/pixel.c   (*weights)[2]=x-(*weights)[3]-gamma;
gamma            4427 magick/pixel.c     gamma;
gamma            4504 magick/pixel.c         gamma=PerceptibleReciprocal(alpha[0]);
gamma            4505 magick/pixel.c         pixel->red+=gamma*pixels[0].red;
gamma            4506 magick/pixel.c         pixel->green+=gamma*pixels[0].green;
gamma            4507 magick/pixel.c         pixel->blue+=gamma*pixels[0].blue;
gamma            4508 magick/pixel.c         pixel->index+=gamma*pixels[0].index;
gamma            4511 magick/pixel.c       gamma=1.0/count;  /* average weighting of each pixel in area */
gamma            4512 magick/pixel.c       pixel->red*=gamma;
gamma            4513 magick/pixel.c       pixel->green*=gamma;
gamma            4514 magick/pixel.c       pixel->blue*=gamma;
gamma            4515 magick/pixel.c       pixel->index*=gamma;
gamma            4516 magick/pixel.c       pixel->opacity*=gamma;
gamma            4551 magick/pixel.c       gamma=((epsilon.y*(epsilon.x*alpha[0]+delta.x*alpha[1])+delta.y*
gamma            4553 magick/pixel.c       gamma=PerceptibleReciprocal(gamma);
gamma            4554 magick/pixel.c       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
gamma            4556 magick/pixel.c       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
gamma            4559 magick/pixel.c       pixel->blue=gamma*(epsilon.y*(epsilon.x*pixels[0].blue+delta.x*
gamma            4563 magick/pixel.c         pixel->index=gamma*(epsilon.y*(epsilon.x*pixels[0].index+delta.x*
gamma            4566 magick/pixel.c       gamma=((epsilon.y*(epsilon.x+delta.x)+delta.y*(epsilon.x+delta.x)));
gamma            4567 magick/pixel.c       gamma=PerceptibleReciprocal(gamma);
gamma            4568 magick/pixel.c       pixel->opacity=gamma*(epsilon.y*(epsilon.x*pixels[0].opacity+delta.x*
gamma            4587 magick/pixel.c       gamma=1.0;  /* number of pixels blended together */
gamma            4598 magick/pixel.c               gamma=2.0;  /* each y pixels have been blended */
gamma            4615 magick/pixel.c             gamma*=2.0;  /* double number of pixels blended */
gamma            4623 magick/pixel.c       gamma=1.0/gamma;  /* 1/sum(pixels) */
gamma            4629 magick/pixel.c       pixel->opacity=gamma*pixels[0].opacity; /* divide by number pixels */
gamma            4770 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[2],alpha[3],alpha[0]);
gamma            4771 magick/pixel.c               gamma=PerceptibleReciprocal(gamma);
gamma            4772 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
gamma            4774 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
gamma            4776 magick/pixel.c               pixel->blue=gamma*MeshInterpolate(&delta,pixels[2].blue,
gamma            4779 magick/pixel.c                 pixel->index=gamma*MeshInterpolate(&delta,pixels[2].index,
gamma            4781 magick/pixel.c               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
gamma            4782 magick/pixel.c               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[2].opacity,
gamma            4791 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[1],alpha[0],alpha[3]);
gamma            4792 magick/pixel.c               gamma=PerceptibleReciprocal(gamma);
gamma            4793 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
gamma            4795 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
gamma            4797 magick/pixel.c               pixel->blue=gamma*MeshInterpolate(&delta,pixels[1].blue,
gamma            4800 magick/pixel.c                 pixel->index=gamma*MeshInterpolate(&delta,pixels[1].index,
gamma            4802 magick/pixel.c               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
gamma            4803 magick/pixel.c               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[1].opacity,
gamma            4817 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[0],alpha[1],alpha[2]);
gamma            4818 magick/pixel.c               gamma=PerceptibleReciprocal(gamma);
gamma            4819 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
gamma            4821 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
gamma            4823 magick/pixel.c               pixel->blue=gamma*MeshInterpolate(&delta,pixels[0].blue,
gamma            4826 magick/pixel.c                 pixel->index=gamma*MeshInterpolate(&delta,pixels[0].index,
gamma            4828 magick/pixel.c               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
gamma            4829 magick/pixel.c               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[0].opacity,
gamma            4839 magick/pixel.c               gamma=MeshInterpolate(&delta,alpha[3],alpha[2],alpha[1]);
gamma            4840 magick/pixel.c               gamma=PerceptibleReciprocal(gamma);
gamma            4841 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
gamma            4843 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
gamma            4845 magick/pixel.c               pixel->blue=gamma*MeshInterpolate(&delta,pixels[3].blue,
gamma            4848 magick/pixel.c                 pixel->index=gamma*MeshInterpolate(&delta,pixels[3].index,
gamma            4850 magick/pixel.c               gamma=MeshInterpolate(&delta,1.0,1.0,1.0);
gamma            4851 magick/pixel.c               pixel->opacity=gamma*MeshInterpolate(&delta,pixels[3].opacity,
gamma             151 magick/property.c   image->gamma=clone_image->gamma;
gamma            2822 magick/property.c             GetMagickPrecision(),image->gamma);
gamma            3872 magick/property.c           image->gamma=StringToDouble(value,(char **) NULL);
gamma            1253 magick/quantize.c                 gamma;
gamma            1255 magick/quantize.c               gamma=(double) (QuantumScale*(QuantumRange-(double) q->opacity));
gamma            1256 magick/quantize.c               gamma=PerceptibleReciprocal(gamma);
gamma            1258 magick/quantize.c                 gamma*QuantumRange*node_info->total_color.red)));
gamma            1260 magick/quantize.c                 gamma*QuantumRange*node_info->total_color.green)));
gamma            1262 magick/quantize.c                 gamma*QuantumRange*node_info->total_color.blue)));
gamma            1143 magick/resample.c   { double alpha, beta, gamma, Major, Minor;
gamma            1148 magick/resample.c     gamma = sqrt(beta*beta + B*B );
gamma            1150 magick/resample.c     if ( alpha - gamma <= MagickEpsilon )
gamma            1153 magick/resample.c       Major= sqrt(2*F/(alpha - gamma));
gamma            1154 magick/resample.c     Minor = sqrt(2*F/(alpha + gamma));
gamma            2598 magick/resize.c             gamma;
gamma            2600 magick/resize.c           gamma=0.0;
gamma            2610 magick/resize.c             gamma+=alpha;
gamma            2612 magick/resize.c           gamma=PerceptibleReciprocal(gamma);
gamma            2613 magick/resize.c           SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma            2614 magick/resize.c           SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma            2615 magick/resize.c           SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma            2627 magick/resize.c               SetPixelIndex(resize_indexes+y,ClampToQuantum(gamma*pixel.index));
gamma            2844 magick/resize.c             gamma;
gamma            2846 magick/resize.c           gamma=0.0;
gamma            2856 magick/resize.c             gamma+=alpha;
gamma            2858 magick/resize.c           gamma=PerceptibleReciprocal(gamma);
gamma            2859 magick/resize.c           SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
gamma            2860 magick/resize.c           SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
gamma            2861 magick/resize.c           SetPixelBlue(q,ClampToQuantum(gamma*pixel.blue));
gamma            2873 magick/resize.c               SetPixelIndex(resize_indexes+x,ClampToQuantum(gamma*pixel.index));
gamma            1704 magick/segment.c     *gamma,
gamma            1711 magick/segment.c   gamma=(double *) AcquireQuantumMemory(256,sizeof(*gamma));
gamma            1712 magick/segment.c   if (gamma == (double *) NULL)
gamma            1717 magick/segment.c     gamma[x]=0.0;
gamma            1720 magick/segment.c     gamma[x]=exp((double) beta*x*x);
gamma            1721 magick/segment.c     if (gamma[x] < MagickEpsilon)
gamma            1728 magick/segment.c       sum+=(double) histogram[u]*gamma[MagickAbsoluteValue(x-u)];
gamma            1731 magick/segment.c   gamma=(double *) RelinquishMagickMemory(gamma);
gamma            3138 magick/xwindow.c           (image->gamma != 0.0))
gamma            3157 magick/xwindow.c           red_gamma*=image->gamma;
gamma            3158 magick/xwindow.c           green_gamma*=image->gamma;
gamma            3159 magick/xwindow.c           blue_gamma*=image->gamma;
gamma            3922 wand/magick-image.c   const double gamma)
gamma            3927 wand/magick-image.c   status=MagickGammaImageChannel(wand,DefaultChannels,gamma);
gamma            3932 wand/magick-image.c   const ChannelType channel,const double gamma)
gamma            3943 wand/magick-image.c   status=GammaImageChannel(wand->images,channel,gamma);
gamma            5303 wand/magick-image.c   return(wand->images->gamma);
gamma            6869 wand/magick-image.c   const double black_point,const double gamma,const double white_point)
gamma            6874 wand/magick-image.c   status=MagickLevelImageChannel(wand,DefaultChannels,black_point,gamma,
gamma            6880 wand/magick-image.c   const ChannelType channel,const double black_point,const double gamma,
gamma            6892 wand/magick-image.c   status=LevelImageChannel(wand->images,channel,black_point,white_point,gamma);
gamma            10499 wand/magick-image.c   const double gamma)
gamma            10507 wand/magick-image.c   wand->images->gamma=gamma;
gamma            1228 wand/mogrify.c               gamma;
gamma            1244 wand/mogrify.c             gamma=0.0;
gamma            1246 wand/mogrify.c               gamma+=kernel_info->values[j];
gamma            1247 wand/mogrify.c             gamma=1.0/(fabs((double) gamma) <= MagickEpsilon ? 1.0 : gamma);
gamma            1249 wand/mogrify.c               kernel_info->values[j]*=gamma;
gamma            1750 wand/mogrify.c               (*image)->gamma=StringToDouble(argv[i+1],(char **) NULL);
gamma            1956 wand/mogrify.c               gamma,
gamma            1971 wand/mogrify.c             gamma=1.0;
gamma            1973 wand/mogrify.c               gamma=geometry_info.xi;
gamma            1983 wand/mogrify.c                 white_point,gamma);
gamma            1986 wand/mogrify.c                 gamma);