red               200 Magick++/lib/Color.cpp       redQuantum( target_color.red );
red               231 Magick++/lib/Color.cpp   pixel.red=_pixel->red;
red               336 Magick++/lib/Color.cpp     red;
red               338 Magick++/lib/Color.cpp   ConvertHSLToRGB(hue_,saturation_,luminosity_,&red,&green,&blue);
red               340 Magick++/lib/Color.cpp   redQuantum(red);
red               366 Magick++/lib/Color.cpp     red;
red               373 Magick++/lib/Color.cpp   ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
red               375 Magick++/lib/Color.cpp   redQuantum(red);
red               403 Magick++/lib/Color.cpp     red;
red               410 Magick++/lib/Color.cpp   ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
red               412 Magick++/lib/Color.cpp   redQuantum(red);
red               440 Magick++/lib/Color.cpp     red;
red               447 Magick++/lib/Color.cpp   ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
red               449 Magick++/lib/Color.cpp   redQuantum(red);
red              1181 Magick++/lib/Image.cpp   return(Color(constImage()->matte_color.red,constImage()->matte_color.green,
red              2983 Magick++/lib/Image.cpp   target.red=pixel.red;
red              3011 Magick++/lib/Image.cpp   target.red=pixel.red;
red              3400 Magick++/lib/Image.cpp   black.red=pixel.red;
red              3407 Magick++/lib/Image.cpp   white.red=pixel.red;
red              3431 Magick++/lib/Image.cpp   black.red=pixel.red;
red              3438 Magick++/lib/Image.cpp   white.red=pixel.red;
red              4541 Magick++/lib/Image.cpp   statistics->red.minimum=minimum;
red              4542 Magick++/lib/Image.cpp   statistics->red.maximum=maximum;
red              4543 Magick++/lib/Image.cpp   (void) GetImageChannelMean(constImage(),RedChannel,&statistics->red.mean,
red              4544 Magick++/lib/Image.cpp     &statistics->red.standard_deviation,exceptionInfo);
red              4546 Magick++/lib/Image.cpp     &statistics->red.kurtosis,&statistics->red.skewness,exceptionInfo);
red              5159 Magick++/lib/Image.cpp   target.red=target_->red;
red               110 Magick++/lib/Magick++/Color.h       return (0.299*(_pixel->red)+0.587*(_pixel->green)+0.114*(_pixel->blue));
red               319 Magick++/lib/Magick++/Color.h     void red(double red_);
red               320 Magick++/lib/Magick++/Color.h     double red(void) const;
red               425 Magick++/lib/Magick++/Color.h   _pixel->red=red_;
red               431 Magick++/lib/Magick++/Color.h   return _pixel->red;
red               436 Magick++/lib/Magick++/Color.h   _pixel->red=0;
red                80 Magick++/lib/Magick++/Image.h       ImageChannelStatistics red;
red                34 Magick++/tests/color.cpp 	double red;
red                57 Magick++/tests/color.cpp 	    ColorRGB colorMatch( colorMap[i].red,
red               526 coders/bmp.c       red;
red               904 coders/bmp.c             image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1020 coders/bmp.c             while (((bmp_info.red_mask << shift.red) & 0x80000000UL) == 0)
red              1021 coders/bmp.c               shift.red++;
red              1031 coders/bmp.c           sample=shift.red;
red              1034 coders/bmp.c           quantum_bits.red=ClampToQuantum((MagickRealType) sample-shift.red);
red              1210 coders/bmp.c               red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
red              1211 coders/bmp.c               if (quantum_bits.red == 5)
red              1212 coders/bmp.c                 red|=((red & 0xe000) >> 5);
red              1213 coders/bmp.c               if (quantum_bits.red <= 8)
red              1214 coders/bmp.c                 red|=((red & 0xff00) >> 8);
red              1227 coders/bmp.c               SetPixelRed(q,ScaleShortToQuantum((unsigned short) red));
red              1315 coders/bmp.c               red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
red              1316 coders/bmp.c               if (quantum_bits.red == 8)
red              1317 coders/bmp.c                 red|=(red >> 8);
red              1324 coders/bmp.c               SetPixelRed(q,ScaleShortToQuantum((unsigned short) red));
red              2127 coders/bmp.c             *q++=ScaleQuantumToChar(image->colormap[i].red);
red               460 coders/cut.c             image->colormap[i].red=(Quantum) ReadBlobLSBShort(palette);
red               463 coders/cut.c                 image->colormap[i].red=ClampToQuantum(((double)
red               464 coders/cut.c                   image->colormap[i].red*QuantumRange+(PalHeader.MaxRed>>1))/
red               498 coders/cut.c             image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
red               570 coders/cut.c                     if(image->colormap[i].red!=sample) goto Finish;
red               575 coders/cut.c                 image->colormap[1].red=image->colormap[1].green=
red              3731 coders/dcm.c               image->colormap[i].red=(Quantum) index;
red              3755 coders/dcm.c               image->colormap[i].red=(Quantum) index;
red              3937 coders/dcm.c                   pixel.red=1U*image->colormap[index].red;
red              3945 coders/dcm.c                       pixel.red=(unsigned int) ReadDCMByte(stream_info,image);
red              3951 coders/dcm.c                       pixel.red=ReadDCMShort(stream_info,image);
red              3955 coders/dcm.c                   pixel.red&=mask;
red              3960 coders/dcm.c                       pixel.red=scale[pixel.red];
red              3965 coders/dcm.c               SetPixelRed(q,pixel.red);
red              4049 coders/dcm.c                     pixel.red=1U*image->colormap[index].red;
red              4057 coders/dcm.c                         pixel.red=(unsigned int) ReadDCMByte(stream_info,image);
red              4063 coders/dcm.c                         pixel.red=ReadDCMShort(stream_info,image);
red              4067 coders/dcm.c                     pixel.red&=mask;
red              4072 coders/dcm.c                         pixel.red=scale[pixel.red];
red              4078 coders/dcm.c                   (((size_t) pixel.red) << 8)));
red               233 coders/debug.c           (double) pixel.red,(double) pixel.green,(double) pixel.blue);
red               632 coders/dib.c           image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1293 coders/dib.c               *q++=ScaleQuantumToChar(image->colormap[i].red);
red               732 coders/djvu.c    image->colormap[0].red=QuantumRange;
red               735 coders/djvu.c    image->colormap[1].red=0;
red               282 coders/dps.c           red,
red               288 coders/dps.c         red=0;
red               296 coders/dps.c           colors[i].pixel=red | green | blue;
red               298 coders/dps.c           red+=red_bit;
red               299 coders/dps.c           if (red > visual_info->red_mask)
red               300 coders/dps.c             red=0;
red               384 coders/dps.c               SetPixelRed(q,ScaleShortToQuantum(colors[index].red));
red               441 coders/dps.c           image->colormap[colors[i].pixel].red=ScaleShortToQuantum(colors[i].red);
red               606 coders/emf.c         pBits->rgbRed=ScaleQuantumToChar(image->background_color.red);
red               740 coders/emf.c       image->background_color.red),(BYTE) ScaleQuantumToChar(
red               170 coders/fax.c     image->colormap[0].red=QuantumRange;
red               173 coders/fax.c     image->colormap[1].red=(Quantum) 0;
red               645 coders/fpx.c   static void SetColorBalance(double red,double green,double blue,
red               660 coders/fpx.c     red=sqrt((double) red)-1.0;
red               665 coders/fpx.c     red_effect.byc2=0.299*red;
red               667 coders/fpx.c     red_effect.bc1y=(-0.299)*red;
red               668 coders/fpx.c     red_effect.bc1c1=1.0-0.299*red;
red               669 coders/fpx.c     red_effect.bc1c2=(-0.299)*red;
red               671 coders/fpx.c     red_effect.bc2y=0.701*red;
red               673 coders/fpx.c     red_effect.bc2c2=1.0+0.402*red;
red              1292 coders/gif.c             image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1332 coders/gif.c             image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1641 coders/gif.c               image->colormap[opacity].red=image->transparent_color.red;
red              1654 coders/gif.c         *q++=ScaleQuantumToChar(image->colormap[i].red);
red               139 coders/hald.c        red;
red               155 coders/hald.c        for (red=0; red < (ssize_t) cube_size; red++)
red               158 coders/hald.c            (QuantumRange*red/(cube_size-1.0))));
red               269 coders/histogram.c         histogram[ScaleQuantumToChar(GetPixelRed(p))].red++;
red               277 coders/histogram.c   maximum=histogram[0].red;
red               280 coders/histogram.c     if (((channel & RedChannel) != 0) && (maximum < histogram[x].red))
red               281 coders/histogram.c       maximum=histogram[x].red;
red               304 coders/histogram.c         y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].red-0.5);
red               467 coders/icon.c              image->colormap[i].red=(Quantum) ScaleCharToQuantum(*p++);
red              1296 coders/icon.c                *q++=ScaleQuantumToChar(next->colormap[i].red);
red               219 coders/jbig.c    image->colormap[0].red=0;
red               222 coders/jbig.c    image->colormap[1].red=QuantumRange;
red               467 coders/jp2.c                q->red=ClampToQuantum(pixel);
red               468 coders/jp2.c                q->green=q->red;
red               469 coders/jp2.c                q->blue=q->red;
red              1012 coders/jp2.c               *q=(int) (scale*p->red);
red              1307 coders/jpeg.c            image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
red              1308 coders/jpeg.c            image->colormap[i].green=image->colormap[i].red;
red              1309 coders/jpeg.c            image->colormap[i].blue=image->colormap[i].red;
red              1315 coders/jpeg.c            image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
red               585 coders/json.c            match=fabs((double) (p->red-target)) < 0.5 ? MagickTrue : MagickFalse;
red               186 coders/map.c         image->colormap[i].red=ScaleCharToQuantum(*p++);
red               195 coders/map.c         image->colormap[i].red=(Quantum) quantum;
red               407 coders/map.c         *q++=(unsigned char) image->colormap[i].red;
red               414 coders/map.c         *q++=(unsigned char) ((size_t) image->colormap[i].red >> 8);
red               415 coders/map.c         *q++=(unsigned char) image->colormap[i].red;
red              1186 coders/miff.c                    image->colormap[i].red=ScaleCharToQuantum(pixel);
red              1202 coders/miff.c                    image->colormap[i].red=ScaleShortToQuantum(pixel);
red              1218 coders/miff.c                    image->colormap[i].red=ScaleLongToQuantum(pixel);
red              1519 coders/miff.c              SetPixelRed(q,pixel.red);
red              1832 coders/miff.c        value=ScaleQuantumToLong(pixel.red);
red              1858 coders/miff.c        value=ScaleQuantumToShort(pixel.red);
red              1884 coders/miff.c        value=(unsigned char) ScaleQuantumToChar(pixel.red);
red              2357 coders/miff.c                pixel=ScaleQuantumToLong(image->colormap[i].red);
red              2370 coders/miff.c                pixel=ScaleQuantumToShort(image->colormap[i].red);
red              2383 coders/miff.c                pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
red               880 coders/mpc.c                     image->colormap[i].red=ScaleCharToQuantum(pixel);
red               896 coders/mpc.c                     image->colormap[i].red=ScaleShortToQuantum(pixel);
red               912 coders/mpc.c                     image->colormap[i].red=ScaleLongToQuantum(pixel);
red              1415 coders/mpc.c                 pixel=ScaleQuantumToLong(image->colormap[i].red);
red              1428 coders/mpc.c                 pixel=ScaleQuantumToShort(image->colormap[i].red);
red              1441 coders/mpc.c                 pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
red              3165 coders/msl.c             pixel.red=0.0;
red              3228 coders/msl.c                         pixel.red=StringToDouble(value,(char **) NULL);
red              3245 coders/msl.c                 (double) pixel.red,(double) pixel.green,(double) pixel.blue);
red              3255 coders/msl.c                 (void) GammaImageChannel(msl_info->image[n],RedChannel,pixel.red);
red               360 coders/palm.c          transpix.red=(MagickRealType) (QuantumRange*ReadBlobByte(image)/31);
red               376 coders/palm.c                image->colormap[(int) index].red=ScaleCharToQuantum(
red               388 coders/palm.c            image->colormap[(int) index].red=ScaleCharToQuantum(
red               748 coders/palm.c    transpix.red=0;
red               824 coders/palm.c                  image->colormap[count].red));
red               882 coders/palm.c                  transpix.red=GetPixelRed(p);
red               968 coders/palm.c          (void) WriteBlobByte(image,(unsigned char) ((31*transpix.red)/QuantumRange));
red               401 coders/pango.c   cairo_set_source_rgba(cairo_image,QuantumScale*draw_info->fill.red,
red               432 coders/pango.c       fill_color.red=ScaleCharToQuantum(*p++);
red               441 coders/pango.c       fill_color.red*=gamma;
red               769 coders/pcl.c                 ScaleQuantumToChar(image->colormap[i].red),
red               372 coders/pcx.c         image->colormap[i].red=ScaleCharToQuantum(*p++);
red               464 coders/pcx.c                 image->colormap[0].red=(Quantum) 0;
red               467 coders/pcx.c                 image->colormap[1].red=QuantumRange;
red               482 coders/pcx.c                     image->colormap[i].red=ScaleCharToQuantum(*p++);
red               987 coders/pcx.c           *q++=ScaleQuantumToChar(image->colormap[i].red);
red              2597 coders/pdf.c                 Ascii85Encode(image,ScaleQuantumToChar(image->colormap[i].red));
red              2603 coders/pdf.c               ScaleQuantumToChar(image->colormap[i].red));
red                83 coders/pes.c       red,
red               640 coders/pes.c         "fill=\"none\" d=\"M %g %g",blocks[i].color->red,blocks[i].color->green,
red              1061 coders/pict.c              image->background_color.red=(Quantum)
red              1173 coders/pict.c                        tile_image->colormap[j].red=(Quantum)
red              1185 coders/pict.c                        tile_image->colormap[i].red=(Quantum) (QuantumRange-
red              1186 coders/pict.c                          tile_image->colormap[i].red);
red              1241 coders/pict.c                        tile_image->colormap[(ssize_t) index].red);
red              1932 coders/pict.c            image->colormap[i].red));
red              1988 coders/pict.c            *red;
red              1990 coders/pict.c          red=scanline;
red              1999 coders/pict.c            red=scanline;
red              2005 coders/pict.c                red=scanline+image->columns;
red              2011 coders/pict.c              *red++=ScaleQuantumToChar(GetPixelRed(p));
red               103 coders/pix.c       red;
red               173 coders/pix.c       red=(Quantum) 0;
red               195 coders/pix.c                   red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               202 coders/pix.c           SetPixelRed(q,red);
red               125 coders/png.c          (((color).red == (target).red) && \
red               180 coders/png.c        (pixelpacket).red=(ScaleQuantumToChar((pixelpacket).red) < 0x10 ? \
red               245 coders/png.c        unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red) & 0xc0; \
red               246 coders/png.c        (pixelpacket).red=ScaleCharToQuantum( \
red               328 coders/png.c        unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red) & 0xe0; \
red               329 coders/png.c        (pixelpacket).red=ScaleCharToQuantum( \
red               385 coders/png.c        unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red) & 0xf0; \
red               386 coders/png.c        (pixelpacket).red=ScaleCharToQuantum((lbr_bits | (lbr_bits >> 4))); \
red               865 coders/png.c              QuantumToCharToQuantumEqQuantum(image->background_color.red) &&
red               878 coders/png.c                      image->colormap[indx].red) &&
red              1486 coders/png.c       if ((a->colormap[i].red != b->colormap[i].red) ||
red              2079 coders/png.c     transparent_color.red=65537;
red              2724 coders/png.c                         background.red=(png_uint_16)
red              2725 coders/png.c                           mng_info->global_plte[background.index].red;
red              2774 coders/png.c           ping_background->red *= bkgd_scale;
red              2784 coders/png.c                    ping_background->red,ping_background->green,
red              2786 coders/png.c                    bkgd_scale,ping_background->red,
red              2790 coders/png.c           image->background_color.red=
red              2791 coders/png.c               ScaleShortToQuantum(ping_background->red);
red              2804 coders/png.c               (double) image->background_color.red,
red              2830 coders/png.c             ((int)ping_trans_color->red > max_sample ||
red              2849 coders/png.c             transparent_color.red= scale_to_short*ping_trans_color->red;
red              2862 coders/png.c                 transparent_color.red=transparent_color.opacity;
red              2952 coders/png.c               image->colormap[i].red=ScaleCharToQuantum(palette[i].red);
red              2959 coders/png.c               image->colormap[i].red=0;
red              2978 coders/png.c               image->colormap[i].red=(Quantum) (i*scale);
red              3182 coders/png.c                       == transparent_color.red &&
red              3466 coders/png.c                    if (ScaleQuantumToShort(image->colormap[x].red) ==
red              3497 coders/png.c                     == transparent_color.red &&
red              4405 coders/png.c               image->background_color.red=ScaleCharToQuantum(p[1]);
red              4406 coders/png.c               image->background_color.green=image->background_color.red;
red              4407 coders/png.c               image->background_color.blue=image->background_color.red;
red              4412 coders/png.c               image->background_color.red=ScaleCharToQuantum(p[1]);
red              5281 coders/png.c                   mng_info->mng_global_bkgd.red=
red              5307 coders/png.c                   mng_background_color.red=
red              5340 coders/png.c                     mng_info->global_plte[i].red=p[3*i];
red              5350 coders/png.c                 mng_info->global_plte[i].red=i;
red              6012 coders/png.c                   mng_info->global_sbit.red=p[0];
red              7960 coders/png.c     ping_background.red = 0;
red              7966 coders/png.c     ping_trans_color.red=0;
red              8420 coders/png.c                       (int) image->colormap[i].red,
red              8433 coders/png.c                       (int) image->colormap[i].red,
red              8503 coders/png.c                          ping_trans_color.red=
red              8568 coders/png.c                     (int) image->background_color.red,
red              8574 coders/png.c                if (opaque[i].red == image->background_color.red &&
red              8708 coders/png.c                   if (colormap[i].red != colormap[i].green ||
red              8709 coders/png.c                       colormap[i].red != colormap[i].blue)
red              8719 coders/png.c                  if (colormap[i].red != 0 && colormap[i].red != QuantumRange)
red              8780 coders/png.c                         image->colormap[i].red ==
red              8817 coders/png.c                           (int) image->colormap[i].red,
red              9092 coders/png.c         if (ScaleQuantumToChar(image->background_color.red) == 0x49 &&
red              9096 coders/png.c            image->background_color.red=ScaleCharToQuantum(0x24);
red              9135 coders/png.c               if (ScaleQuantumToChar(image->colormap[i].red) == 0x49 &&
red              9139 coders/png.c                  image->colormap[i].red=ScaleCharToQuantum(0x24);
red              9206 coders/png.c                        ping_trans_color.red &&
red              9230 coders/png.c                   if (image->colormap[i].red == image->colormap[0].red &&
red              9480 coders/png.c          ping_background.red=(png_uint_16)
red              9481 coders/png.c            (ScaleQuantumToShort(image->background_color.red) & mask);
red              9534 coders/png.c           palette[i].red=ScaleQuantumToChar(image->colormap[i].red);
red              9544 coders/png.c               (long) i,palette[i].red,palette[i].green,palette[i].blue);
red              9812 coders/png.c                 ping_trans_color.red=(png_uint_16)
red              9813 coders/png.c                   (ScaleQuantumToShort(image->colormap[0].red) & mask);
red              9847 coders/png.c                     ping_trans_color.red&=0xff;
red              9858 coders/png.c                 ping_trans_color.red&=0xff;
red              9937 coders/png.c                      intensity=ScaleQuantumToChar(image->colormap[i].red);
red              9978 coders/png.c                     palette[i].red=ScaleQuantumToChar(image->colormap[i].red);
red              10050 coders/png.c                     (int) ping_trans_color.red,
red              10055 coders/png.c               ping_trans_color.red*=0x0101;
red              10064 coders/png.c                     (int) ping_trans_color.red,
red              10152 coders/png.c                           (int) ping_background.red,
red              10446 coders/png.c                         (int) palette[i].red,
red              10455 coders/png.c                         (int) palette[i].red,
red              10609 coders/png.c                           (int) ping_background.red,
red              10725 coders/png.c                          (int) ping_trans_color.red,
red              12387 coders/png.c         red;
red              12399 coders/png.c       red=ScaleQuantumToChar(image->background_color.red);
red              12403 coders/png.c       *(chunk+5)=red;
red              12955 coders/png.c           red,
red              13032 coders/png.c               if (next_image->background_color.red !=
red              13033 coders/png.c                   next_image->next->background_color.red ||
red              13379 coders/png.c            red=ScaleQuantumToShort(image->background_color.red);
red              13382 coders/png.c            PNGShort(chunk+4,red);
red              13415 coders/png.c              chunk[4+i*3]=ScaleQuantumToChar(image->colormap[i].red) & 0xff;
red              13467 coders/png.c                     chunk[4+i*3]=ScaleQuantumToChar(image->colormap[i].red);
red              1185 coders/ps.c          q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.red),q); \
red              2046 coders/ps.c                      if ((GetPixelRed(p) == pixel.red) &&
red              2167 coders/ps.c                  ScaleQuantumToChar(image->colormap[i].red),
red              2212 coders/ps.c                      pixel.red=GetPixelRed(p);
red              1019 coders/ps2.c                 ScaleQuantumToChar(image->colormap[i].red),
red              1512 coders/ps3.c                     pixel=ScaleQuantumToChar(image->colormap[i].red);
red              1525 coders/ps3.c                     pixel=ScaleQuantumToChar(image->colormap[i].red);
red              1219 coders/psd.c           color.red=layer_info->mask.background == 0 ? 0 : QuantumRange;
red              1220 coders/psd.c           color.green=color.red;
red              1221 coders/psd.c           color.blue=color.red;
red              1222 coders/psd.c           color.index=color.red;
red              1880 coders/psd.c               image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red              2711 coders/psd.c           (void) WriteBlobByte(image,ScaleQuantumToChar(image->colormap[i].red));
red               164 coders/rgf.c     image->colormap[0].red=QuantumRange;
red               167 coders/rgf.c     image->colormap[1].red=(Quantum) 0;
red               537 coders/rle.c               image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
red               545 coders/rle.c                 image->colormap[i].red=ScaleCharToQuantum(*p);
red               591 coders/rle.c                   SetPixelRed(q,image->colormap[(ssize_t) index].red);
red              1044 coders/sixel.c     image->colormap[i].red   = ScaleCharToQuantum(sixel_palette[i * 4 + 0]);
red              1275 coders/sixel.c           image->colormap[opacity].red=image->transparent_color.red;
red              1285 coders/sixel.c     sixel_palette[i * 3 + 0] = ScaleQuantumToChar(image->colormap[i].red);
red               195 coders/stegano.c             SetBit(indexes,i,GetBit(pixel.red,j));
red               362 coders/sun.c             image->colormap[i].red=ScaleCharToQuantum(sun_colormap[i]);
red               543 coders/sun.c                       GetPixelRed(q)].red);
red               930 coders/sun.c                 image->colormap[i].red));
red              2845 coders/svg.c               100.0*QuantumScale*image->background_color.red,
red              3039 coders/svg.c                   fill_color.red=ScaleCharToQuantum(*p++);
red              3041 coders/svg.c                   fill_color.red=ScaleCharToQuantum(*p++);
red              3055 coders/svg.c                     fill_color.red*=gamma;
red               352 coders/tga.c               pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               353 coders/tga.c               pixel.green=pixel.red;
red               354 coders/tga.c               pixel.blue=pixel.red;
red               369 coders/tga.c               pixel.red=ScaleAnyToQuantum(1UL*(k & 0x7c) >> 2,range);
red               382 coders/tga.c               pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               392 coders/tga.c               pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               457 coders/tga.c                   pixel.red=ScaleCharToQuantum((unsigned char) index);
red               477 coders/tga.c               pixel.red=ScaleAnyToQuantum(1UL*(k & 0x7c) >> 2,range);
red               497 coders/tga.c               pixel.red=ScaleCharToQuantum(pixels[2]);
red               509 coders/tga.c               pixel.red=ScaleCharToQuantum(pixels[2]);
red               519 coders/tga.c         SetPixelRed(q,pixel.red);
red               881 coders/tga.c                 ((unsigned char) ScaleQuantumToAny(image->colormap[i].red,
red               888 coders/tga.c               *q++=ScaleQuantumToChar(image->colormap[i].red);
red              1536 coders/tiff.c                    image->colormap[i].red=ClampToQuantum(((double)
red              3837 coders/tiff.c            *red;
red              3842 coders/tiff.c          red=(uint16 *) AcquireQuantumMemory(65536,sizeof(*red));
red              3845 coders/tiff.c          if ((red == (uint16 *) NULL) || (green == (uint16 *) NULL) ||
red              3851 coders/tiff.c          (void) ResetMagickMemory(red,0,65536*sizeof(*red));
red              3856 coders/tiff.c            red[i]=ScaleQuantumToShort(image->colormap[i].red);
red              3860 coders/tiff.c          (void) TIFFSetField(tiff,TIFFTAG_COLORMAP,red,green,blue);
red              3861 coders/tiff.c          red=(uint16 *) RelinquishMagickMemory(red);
red               218 coders/tim.c             image->colormap[i].red=ScaleCharToQuantum(
red               474 coders/txt.c           red;
red               476 coders/txt.c         red=0.0;
red               492 coders/txt.c                     &y_offset,&red,&opacity);
red               493 coders/txt.c                   green=red;
red               494 coders/txt.c                   blue=red;
red               497 coders/txt.c               (void) sscanf(text,"%ld,%ld: (%lf%*[%,]",&x_offset,&y_offset,&red);
red               498 coders/txt.c               green=red;
red               499 coders/txt.c               blue=red;
red               508 coders/txt.c                     &x_offset,&y_offset,&red,&green,&blue,&index,&opacity);
red               513 coders/txt.c                 &y_offset,&red,&green,&blue,&index);
red               522 coders/txt.c                     &x_offset,&y_offset,&red,&green,&blue,&opacity);
red               526 coders/txt.c                 &x_offset,&y_offset,&red,&green,&blue);
red               532 coders/txt.c               red*=0.01*range;
red               543 coders/txt.c           pixel.red=ScaleAnyToQuantum((QuantumAny) (red+0.5),range);
red               551 coders/txt.c           SetPixelRed(q,pixel.red);
red               351 coders/uyvy.c            (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red));
red               356 coders/uyvy.c        pixel.red=(double) GetPixelRed(p);
red               454 coders/viff.c                image->colormap[i].red=ScaleCharToQuantum((unsigned char) value);
red               701 coders/viff.c                      ConstrainColormapIndex(image,index)].red);
red              1133 coders/viff.c              *q++=ScaleQuantumToChar(image->colormap[i].red);
red              1076 coders/wpg.c                     image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red              1135 coders/wpg.c                         image->colormap[i].red=ScaleCharToQuantum(WPG1_Palette[i].Red);
red              1151 coders/wpg.c                     if(image->colormap[0].red==0 &&
red              1154 coders/wpg.c                        image->colormap[1].red==0 &&
red              1158 coders/wpg.c                         image->colormap[1].red =
red              1276 coders/wpg.c                     image->colormap[i].red=ScaleCharToQuantum((char)
red               287 coders/xbm.c     image->colormap[0].red=QuantumRange;
red               290 coders/xbm.c     image->colormap[1].red=(Quantum) 0;
red               170 coders/xcf.c       red,
red               387 coders/xcf.c               SetPixelRed(q,ScaleCharToQuantum(xcfdata->red));
red              1007 coders/xpm.c             image->colormap[opacity].red=image->transparent_color.red;
red               343 coders/xwd.c           colors[i].red=color.red;
red               359 coders/xwd.c             MSBOrderShort((unsigned char *) &colors[i].red,3*
red               360 coders/xwd.c               sizeof(colors[i].red));
red               471 coders/xwd.c                   SetPixelRed(q,ScaleShortToQuantum(colors[(ssize_t) index].red));
red               534 coders/xwd.c             image->colormap[i].red=ScaleShortToQuantum(colors[i].red);
red               793 coders/xwd.c           colors[i].red=ScaleQuantumToShort(image->colormap[i].red);
red               802 coders/xwd.c               MSBOrderShort((unsigned char *) &colors[i].red,
red               803 coders/xwd.c                 3*sizeof(colors[i].red));
red               809 coders/xwd.c           color.red=colors[i].red;
red                46 magick/accelerate-private.h     red,
red                55 magick/accelerate-private.h     red,
red               392 magick/accelerate-private.h     float red = getRed(p);
red               399 magick/accelerate-private.h       return red;
red               405 magick/accelerate-private.h       intensity = (red + green + blue) / 3.0;
red               410 magick/accelerate-private.h       intensity = max(max(red, green), blue);
red               415 magick/accelerate-private.h       intensity = (min(min(red, green), blue) +
red               416 magick/accelerate-private.h         max(max(red, green), blue)) / 2.0;
red               421 magick/accelerate-private.h       intensity = (float)(((float)red*red + green*green + blue*blue) /
red               435 magick/accelerate-private.h       intensity = 0.298839*red + 0.586811*green + 0.114350*blue;
red               448 magick/accelerate-private.h       intensity = 0.298839*red + 0.586811*green + 0.114350*blue;
red               462 magick/accelerate-private.h       intensity = 0.212656*red + 0.715158*green + 0.072186*blue;
red               475 magick/accelerate-private.h       intensity = 0.212656*red + 0.715158*green + 0.072186*blue;
red               480 magick/accelerate-private.h       intensity = (float)(sqrt((float)red*red + green*green + blue*blue) /
red              1495 magick/accelerate-private.h         CLQuantum red, green, blue, opacity;
red              1506 magick/accelerate-private.h             red = getRed(eValue);
red              1541 magick/accelerate-private.h         im[c]=(CLPixelType)(blue, green, red, opacity);
red              1959 magick/accelerate-private.h         CLQuantum red, green, blue, opacity;
red              1970 magick/accelerate-private.h             red = getRed(eValue);
red              1982 magick/accelerate-private.h             im[c]=(CLPixelType)(blue, green, red, opacity);
red              2140 magick/accelerate-private.h         red;
red              2142 magick/accelerate-private.h     red=(float)getRed(pixel);
red              2154 magick/accelerate-private.h           intensity=(red+green+blue)/3.0;
red              2159 magick/accelerate-private.h           intensity=max(max(red,green),blue);
red              2164 magick/accelerate-private.h           intensity=(min(min(red,green),blue)+
red              2165 magick/accelerate-private.h               max(max(red,green),blue))/2.0;
red              2170 magick/accelerate-private.h           intensity=(float) (((float) red*red+green*green+
red              2184 magick/accelerate-private.h           intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2197 magick/accelerate-private.h           intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2211 magick/accelerate-private.h           intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2224 magick/accelerate-private.h           intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2229 magick/accelerate-private.h           intensity=(float) (sqrt((float) red*red+green*green+
red              2384 magick/accelerate-private.h   inline void ConvertRGBToHSL(const CLQuantum red,const CLQuantum green, const CLQuantum blue,
red              2395 magick/accelerate-private.h   tmax=max(QuantumScale*red,max(QuantumScale*green, QuantumScale*blue));
red              2396 magick/accelerate-private.h   tmin=min(QuantumScale*red,min(QuantumScale*green, QuantumScale*blue));
red              2408 magick/accelerate-private.h   if (tmax == (QuantumScale*red))
red              2416 magick/accelerate-private.h       *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red              2418 magick/accelerate-private.h       *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red              2428 magick/accelerate-private.h       CLQuantum *red,CLQuantum *green,CLQuantum *blue)
red              2502 magick/accelerate-private.h     *red=ClampToQuantum(QuantumRange*r);
red              2508 magick/accelerate-private.h     CLQuantum *red,CLQuantum *green,CLQuantum *blue)
red              2518 magick/accelerate-private.h     ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
red              2526 magick/accelerate-private.h     ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
red              2546 magick/accelerate-private.h         red;
red              2548 magick/accelerate-private.h     red=getRed(pixel);
red              2558 magick/accelerate-private.h               &red, &green, &blue);
red              2565 magick/accelerate-private.h     setRed(&filteredPixel, red);
red              2060 magick/accelerate.c   black.red=0.0;
red              2061 magick/accelerate.c   white.red=MaxRange(QuantumRange);
red              2071 magick/accelerate.c     black.red=(MagickRealType) i;
red              2079 magick/accelerate.c     white.red=(MagickRealType) i;
red              2184 magick/accelerate.c       if (i < (ssize_t) black.red)
red              2185 magick/accelerate.c         stretch_map[i].red=(Quantum) 0;
red              2187 magick/accelerate.c         if (i > (ssize_t) white.red)
red              2188 magick/accelerate.c           stretch_map[i].red=QuantumRange;
red              2190 magick/accelerate.c           if (black.red != white.red)
red              2191 magick/accelerate.c             stretch_map[i].red=ScaleMapToQuantum((MagickRealType) (MaxMap*
red              2192 magick/accelerate.c                   (i-black.red)/(white.red-black.red)));
red              2262 magick/accelerate.c         if (black.red != white.red)
red              2263 magick/accelerate.c           image->colormap[i].red=stretch_map[
red              2264 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].red)].red;
red              3428 magick/accelerate.c       intensity.red+=histogram[i].s[2];
red              3433 magick/accelerate.c       intensity.red+=histogram[i].s[2];
red              3456 magick/accelerate.c       if (white.red != black.red)
red              3457 magick/accelerate.c         equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red              3458 magick/accelerate.c                 (map[i].red-black.red))/(white.red-black.red)));
red              3461 magick/accelerate.c     if (((channel & RedChannel) != 0) && (white.red != black.red))
red              3462 magick/accelerate.c       equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red              3463 magick/accelerate.c               (map[i].red-black.red))/(white.red-black.red)));
red              3491 magick/accelerate.c         if (white.red != black.red)
red              3493 magick/accelerate.c           image->colormap[i].red=equalize_map[
red              3494 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].red)].red;
red              3496 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].green)].red;
red              3498 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].blue)].red;
red              3500 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].opacity)].red;
red              3504 magick/accelerate.c       if (((channel & RedChannel) != 0) && (white.red != black.red))
red              3505 magick/accelerate.c         image->colormap[i].red=equalize_map[
red              3506 magick/accelerate.c           ScaleQuantumToMap(image->colormap[i].red)].red;
red              4904 magick/accelerate.c   biasPixel.s[0] = bias.red;
red              5232 magick/accelerate.c   biasPixel.s[0] = bias.red;
red              1927 magick/annotate.c           SetPixelRed(q,fill_color.red);
red               348 magick/attribute.c             if (IsPixelAtDepth(image->colormap[i].red,range) == MagickFalse)
red              1099 magick/attribute.c           image->colormap[i].red=ScaleAnyToQuantum(ScaleQuantumToAny(
red              1100 magick/attribute.c             ClampPixel(image->colormap[i].red),range),range);
red              3252 magick/cache.c   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
red              3326 magick/cache.c     SetPixelRed(q,ClampToQuantum(beta.red));
red               778 magick/channel.c               SetPixelRed(q,pixel.red);
red               940 magick/channel.c           q->red=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->red,
red               941 magick/channel.c             (MagickRealType) q->opacity,(MagickRealType) pixel.red,
red                50 magick/color-private.h     red;
red                52 magick/color-private.h   red=(MagickRealType) p->red;
red                55 magick/color-private.h   if ((fabs((double) (red-q->red)) < MagickEpsilon) &&
red                78 magick/color-private.h   if (fabs((double) (p->red-q->red)) >= MagickEpsilon)
red                95 magick/color-private.h   if ((fabs((double) (pixel->red-pixel->green)) < MagickEpsilon) &&
red               105 magick/color-private.h     return(pixel->red);
red               106 magick/color-private.h   return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red               113 magick/color-private.h     return(ClampToQuantum(pixel->red));
red               114 magick/color-private.h   return(ClampToQuantum(0.212656*pixel->red+0.715158*pixel->green+
red               123 magick/color-private.h     red;
red               126 magick/color-private.h     return(pixel->red);
red               128 magick/color-private.h     return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red               129 magick/color-private.h   red=EncodePixelGamma(pixel->red);
red               132 magick/color-private.h   return(0.212656*red+0.715158*green+0.072186*blue);
red               141 magick/color-private.h     red;
red               144 magick/color-private.h     return(pixel->red);
red               146 magick/color-private.h     return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red               147 magick/color-private.h   red=DecodePixelGamma(pixel->red);
red               150 magick/color-private.h   return(0.212656*red+0.715158*green+0.072186*blue);
red                85 magick/color.c     red,
red               880 magick/color.c     color_info->color.red=(MagickRealType) ScaleCharToQuantum(
red              1133 magick/color.c       color=pixel->red;
red              1458 magick/color.c       color=pixel->red;
red              1552 magick/color.c       status=color.red == SVGCompliant(color.red);
red              2010 magick/color.c   pixel=p->red-q->red;
red              2437 magick/color.c         pixel.red*(QuantumRange-pixel.index)+pixel.index)))));
red              2446 magick/color.c   SetPixelRed(color,ClampToQuantum(pixel.red));
red              2622 magick/color.c             pixel.red=pixel.green;
red              2653 magick/color.c             pixel.red=pixel.green;
red              2679 magick/color.c       color->red=(MagickRealType) ScaleAnyToQuantum(pixel.red,range);
red              2772 magick/color.c             color->red=(MagickRealType) ClampToQuantum((MagickRealType)
red              2807 magick/color.c               color->green=color->red;
red              2808 magick/color.c               color->blue=color->red;
red              2828 magick/color.c                   360.0,geometry_info.sigma,geometry_info.xi,&pixel.red,
red              2834 magick/color.c                     &pixel.red,&pixel.green,&pixel.blue);
red              2839 magick/color.c                       &pixel.red,&pixel.green,&pixel.blue);
red              2843 magick/color.c                       &pixel.red,&pixel.green,&pixel.blue);
red              2845 magick/color.c               color->red=(MagickRealType) pixel.red;
red              2861 magick/color.c   color->red=(MagickRealType) p->color.red;
red              2969 magick/color.c     if (((p->compliance & compliance) != 0) && ((p->color.red == color->red)) &&
red               135 magick/colormap.c     image->colormap[i].red=(Quantum) pixel;
red                32 magick/colorspace-private.h   pixel->red=((QuantumRange-(QuantumScale*pixel->red*(QuantumRange-
red                48 magick/colorspace-private.h     red,
red                53 magick/colorspace-private.h       red=QuantumScale*pixel->red;
red                59 magick/colorspace-private.h       red=QuantumScale*DecodePixelGamma(pixel->red);
red                63 magick/colorspace-private.h   if ((fabs((double) red) < MagickEpsilon) &&
red                70 magick/colorspace-private.h   cyan=(MagickRealType) (1.0-red);
red                82 magick/colorspace-private.h   pixel->red=QuantumRange*cyan;
red               108 magick/colorspace.c static inline void ConvertRGBToCMY(const Quantum red,const Quantum green,
red               111 magick/colorspace.c   *cyan=QuantumScale*(QuantumRange-red);
red               116 magick/colorspace.c static void ConvertRGBToLab(const Quantum red,const Quantum green,
red               124 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               136 magick/colorspace.c static void ConvertRGBToLMS(const Quantum red,const Quantum green,
red               144 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               148 magick/colorspace.c static void ConvertRGBToLuv(const Quantum red,const Quantum green,
red               156 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               160 magick/colorspace.c static void ConvertRGBToxyY(const Quantum red,const Quantum green,
red               168 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               174 magick/colorspace.c static void ConvertRGBToYPbPr(const Quantum red,const Quantum green,
red               177 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               178 magick/colorspace.c   *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
red               179 magick/colorspace.c   *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
red               182 magick/colorspace.c static void ConvertRGBToYCbCr(const Quantum red,const Quantum green,
red               185 magick/colorspace.c   ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
red               188 magick/colorspace.c static void ConvertRGBToYUV(const Quantum red,const Quantum green,
red               191 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               192 magick/colorspace.c   *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
red               193 magick/colorspace.c   *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
red               196 magick/colorspace.c static void ConvertRGBToYDbDr(const Quantum red,const Quantum green,
red               199 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               200 magick/colorspace.c   *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
red               201 magick/colorspace.c   *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
red               204 magick/colorspace.c static void ConvertRGBToYIQ(const Quantum red,const Quantum green,
red               207 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               208 magick/colorspace.c   *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
red               209 magick/colorspace.c   *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
red               309 magick/colorspace.c           pixel.red=(MagickRealType) pixel.red;
red               446 magick/colorspace.c             red;
red               448 magick/colorspace.c           red=ClampToQuantum((MagickRealType) GetPixelRed(q));
red               455 magick/colorspace.c               ConvertRGBToCMY(red,green,blue,&X,&Y,&Z);
red               460 magick/colorspace.c               ConvertRGBToHCL(red,green,blue,&X,&Y,&Z);
red               465 magick/colorspace.c               ConvertRGBToHCLp(red,green,blue,&X,&Y,&Z);
red               470 magick/colorspace.c               ConvertRGBToHSB(red,green,blue,&X,&Y,&Z);
red               475 magick/colorspace.c               ConvertRGBToHSI(red,green,blue,&X,&Y,&Z);
red               480 magick/colorspace.c               ConvertRGBToHSL(red,green,blue,&X,&Y,&Z);
red               485 magick/colorspace.c               ConvertRGBToHSV(red,green,blue,&X,&Y,&Z);
red               490 magick/colorspace.c               ConvertRGBToHWB(red,green,blue,&X,&Y,&Z);
red               495 magick/colorspace.c               ConvertRGBToLab(red,green,blue,&X,&Y,&Z);
red               501 magick/colorspace.c               ConvertRGBToLCHab(red,green,blue,&X,&Y,&Z);
red               506 magick/colorspace.c               ConvertRGBToLCHuv(red,green,blue,&X,&Y,&Z);
red               511 magick/colorspace.c               ConvertRGBToLMS(red,green,blue,&X,&Y,&Z);
red               516 magick/colorspace.c               ConvertRGBToLuv(red,green,blue,&X,&Y,&Z);
red               521 magick/colorspace.c               ConvertRGBToxyY(red,green,blue,&X,&Y,&Z);
red               526 magick/colorspace.c               ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               531 magick/colorspace.c               ConvertRGBToYCbCr(red,green,blue,&X,&Y,&Z);
red               536 magick/colorspace.c               ConvertRGBToYDbDr(red,green,blue,&X,&Y,&Z);
red               541 magick/colorspace.c               ConvertRGBToYIQ(red,green,blue,&X,&Y,&Z);
red               546 magick/colorspace.c               ConvertRGBToYPbPr(red,green,blue,&X,&Y,&Z);
red               551 magick/colorspace.c               ConvertRGBToYUV(red,green,blue,&X,&Y,&Z);
red               556 magick/colorspace.c               X=QuantumScale*red;
red               662 magick/colorspace.c             red;
red               664 magick/colorspace.c           red=ClampToQuantum(DecodePixelGamma((MagickRealType)
red               670 magick/colorspace.c           SetPixelRed(q,logmap[ScaleQuantumToMap(red)]);
red               728 magick/colorspace.c             red;
red               730 magick/colorspace.c           red=ClampToQuantum(DecodePixelGamma((MagickRealType)
red               736 magick/colorspace.c           SetPixelRed(q,red);
red              1010 magick/colorspace.c           red;
red              1023 magick/colorspace.c           red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
red              1029 magick/colorspace.c           pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
red              1031 magick/colorspace.c           pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
red              1033 magick/colorspace.c           pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
red              1035 magick/colorspace.c           SetPixelRed(q,ScaleMapToQuantum(pixel.red));
red              1065 magick/colorspace.c         red;
red              1075 magick/colorspace.c         red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
red              1076 magick/colorspace.c           image->colormap[i].red));
red              1081 magick/colorspace.c         pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
red              1082 magick/colorspace.c         pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
red              1083 magick/colorspace.c         pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
red              1084 magick/colorspace.c         image->colormap[i].red=ScaleMapToQuantum(pixel.red);
red              1454 magick/colorspace.c   const double yellow,Quantum *red,Quantum *green,Quantum *blue)
red              1456 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(1.0-cyan));
red              1470 magick/colorspace.c   const double S,Quantum *red,Quantum *green,Quantum *blue)
red              1478 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1482 magick/colorspace.c   const double v,Quantum *red,Quantum *green,Quantum *blue)
red              1490 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1503 magick/colorspace.c   const double b,Quantum *red,Quantum *green,Quantum *blue)
red              1511 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1515 magick/colorspace.c   const double cap_Y,Quantum *red,Quantum *green,Quantum *blue)
red              1525 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1529 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
red              1531 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(0.99999999999914679361*Y-
red              1540 magick/colorspace.c   const double Cr,Quantum *red,Quantum *green,Quantum *blue)
red              1542 magick/colorspace.c   ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
red              1546 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
red              1548 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
red              1557 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
red              1559 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
red              1568 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
red              1570 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
red              2048 magick/colorspace.c             red;
red              2057 magick/colorspace.c               ConvertCMYToRGB(X,Y,Z,&red,&green,&blue);
red              2062 magick/colorspace.c               ConvertHCLToRGB(X,Y,Z,&red,&green,&blue);
red              2067 magick/colorspace.c               ConvertHCLpToRGB(X,Y,Z,&red,&green,&blue);
red              2072 magick/colorspace.c               ConvertHSBToRGB(X,Y,Z,&red,&green,&blue);
red              2077 magick/colorspace.c               ConvertHSIToRGB(X,Y,Z,&red,&green,&blue);
red              2082 magick/colorspace.c               ConvertHSLToRGB(X,Y,Z,&red,&green,&blue);
red              2087 magick/colorspace.c               ConvertHSVToRGB(X,Y,Z,&red,&green,&blue);
red              2092 magick/colorspace.c               ConvertHWBToRGB(X,Y,Z,&red,&green,&blue);
red              2097 magick/colorspace.c               ConvertLabToRGB(X,Y,Z,&red,&green,&blue);
red              2103 magick/colorspace.c               ConvertLCHabToRGB(X,Y,Z,&red,&green,&blue);
red              2108 magick/colorspace.c               ConvertLCHuvToRGB(X,Y,Z,&red,&green,&blue);
red              2113 magick/colorspace.c               ConvertLMSToRGB(X,Y,Z,&red,&green,&blue);
red              2118 magick/colorspace.c               ConvertLuvToRGB(X,Y,Z,&red,&green,&blue);
red              2123 magick/colorspace.c               ConvertxyYToRGB(X,Y,Z,&red,&green,&blue);
red              2128 magick/colorspace.c               ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
red              2133 magick/colorspace.c               ConvertYCbCrToRGB(X,Y,Z,&red,&green,&blue);
red              2138 magick/colorspace.c               ConvertYDbDrToRGB(X,Y,Z,&red,&green,&blue);
red              2143 magick/colorspace.c               ConvertYIQToRGB(X,Y,Z,&red,&green,&blue);
red              2148 magick/colorspace.c               ConvertYPbPrToRGB(X,Y,Z,&red,&green,&blue);
red              2153 magick/colorspace.c               ConvertYUVToRGB(X,Y,Z,&red,&green,&blue);
red              2158 magick/colorspace.c               red=ClampToQuantum(QuantumRange*X);
red              2164 magick/colorspace.c           SetPixelRed(q,ClampToQuantum((MagickRealType) red));
red              2266 magick/colorspace.c             red;
red              2268 magick/colorspace.c           red=ClampToQuantum(EncodePixelGamma((MagickRealType)
red              2274 magick/colorspace.c           SetPixelRed(q,red);
red              2332 magick/colorspace.c             red;
red              2334 magick/colorspace.c           red=ClampToQuantum(EncodePixelGamma((MagickRealType) GetPixelRed(q)));
red              2339 magick/colorspace.c           SetPixelRed(q,red);
red              2571 magick/colorspace.c             red;
red              2573 magick/colorspace.c           red=ScaleQuantumToMap(GetPixelRed(q));
red              2576 magick/colorspace.c           pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
red              2577 magick/colorspace.c           pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
red              2578 magick/colorspace.c           pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
red              2581 magick/colorspace.c               pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
red              2590 magick/colorspace.c               pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
red              2594 magick/colorspace.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red              2636 magick/colorspace.c           red;
red              2638 magick/colorspace.c         red=ScaleQuantumToMap(image->colormap[i].red);
red              2641 magick/colorspace.c         pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
red              2642 magick/colorspace.c         pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
red              2643 magick/colorspace.c         pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
red              2646 magick/colorspace.c             pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
red              2655 magick/colorspace.c             pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
red              2659 magick/colorspace.c         image->colormap[i].red=ClampToQuantum(pixel.red);
red               104 magick/composite-private.h   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
red               128 magick/composite-private.h   composite->red=gamma*(Sa*p->red+Da*q->red);
red               209 magick/composite.c   composite->red=Atop(p->red,Sa,q->red,1.0);
red               227 magick/composite.c   composite->red=QuantumScale*intensity*q->red;
red               239 magick/composite.c   composite->red=0.0;
red               281 magick/composite.c   composite->red=gamma*ColorBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               282 magick/composite.c     q->red*Da,Da);
red               343 magick/composite.c   composite->red=gamma*ColorDodge(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               344 magick/composite.c     q->red*Da,Da);
red               378 magick/composite.c     composite->red=gamma*Darken(p->red,p->opacity,q->red,q->opacity);
red               388 magick/composite.c       composite->red=MagickMin(p->red,q->red);
red               422 magick/composite.c       composite->red = from_p ? p->red : q->red;
red               457 magick/composite.c     composite->red=gamma*Difference(p->red,Sa,q->red,Da);
red               467 magick/composite.c       composite->red=fabs((double) (p->red-q->red));
red               512 magick/composite.c     composite->red=gamma*Divide(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               513 magick/composite.c       q->red*Da,Da);
red               526 magick/composite.c       composite->red=QuantumRange*
red               527 magick/composite.c           Divide(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0);
red               561 magick/composite.c     composite->red=gamma*Exclusion(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               562 magick/composite.c       q->red*Da,Da);
red               575 magick/composite.c       composite->red=QuantumRange*Exclusion(QuantumScale*p->red,1.0,
red               576 magick/composite.c         QuantumScale*q->red,1.0);
red               610 magick/composite.c   composite->red=gamma*HardLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               611 magick/composite.c     q->red*Da,Da);
red               643 magick/composite.c   composite->red=gamma*HardMix(p->red*Sa,q->red*Da);
red               651 magick/composite.c   MagickRealType *red,MagickRealType *green,MagickRealType *blue)
red               665 magick/composite.c   assert(red != (MagickRealType *) NULL);
red               710 magick/composite.c   *red=QuantumRange*(r+m);
red               715 magick/composite.c static void CompositeHCL(const MagickRealType red,const MagickRealType green,
red               732 magick/composite.c   r=(double) red;
red               741 magick/composite.c     if (red == (MagickRealType) max)
red               777 magick/composite.c   composite->red=gamma*In(p->red,Sa,q->red,Da);
red               808 magick/composite.c     composite->red=gamma*Lighten(p->red,p->opacity,q->red,q->opacity);
red               818 magick/composite.c       composite->red=MagickMax(p->red,q->red);
red               852 magick/composite.c       composite->red = from_p ? p->red : q->red;
red               890 magick/composite.c   composite->red=gamma*(p->red*Sa+q->red*Da);
red               923 magick/composite.c   composite->red=gamma*LinearBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               924 magick/composite.c     q->red*Da,Da);
red               966 magick/composite.c   composite->red=gamma*LinearLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               967 magick/composite.c     q->red*Da,Da);
red              1021 magick/composite.c     composite->red=gamma*Mathematics(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1022 magick/composite.c       q->red*Da,Da,args);
red              1035 magick/composite.c       composite->red=QuantumRange*
red              1036 magick/composite.c           Mathematics(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0,args);
red              1076 magick/composite.c       composite->red=p->red+q->red;
red              1118 magick/composite.c     composite->red=gamma*Minus(p->red*Sa,Sa,q->red*Da,Da);
red              1128 magick/composite.c       composite->red=p->red-q->red;
red              1169 magick/composite.c     composite->red=ModulusAdd(p->red,Sa,q->red,Da);
red              1180 magick/composite.c       composite->red=ModulusAdd(p->red,1.0,q->red,1.0);
red              1221 magick/composite.c     composite->red=ModulusSubtract(p->red,Sa,q->red,Da);
red              1232 magick/composite.c       composite->red=ModulusSubtract(p->red,1.0,q->red,1.0);
red              1263 magick/composite.c     composite->red=gamma*Multiply(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1264 magick/composite.c       q->red*Da,Da);
red              1277 magick/composite.c       composite->red=QuantumScale*p->red*q->red;
red              1311 magick/composite.c   composite->red=gamma*Out(p->red,Sa,q->red,Da);
red              1347 magick/composite.c   composite->red=gamma*PegtopLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1348 magick/composite.c     q->red*Da,Da);
red              1387 magick/composite.c   composite->red=gamma*PinLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1388 magick/composite.c     q->red*Da,Da);
red              1426 magick/composite.c     composite->red=gamma*Screen(p->red*Sa,q->red*Da);
red              1436 magick/composite.c       composite->red=QuantumRange*Screen(QuantumScale*p->red,
red              1437 magick/composite.c            QuantumScale*q->red);
red              1500 magick/composite.c   composite->red=gamma*SoftLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1501 magick/composite.c     q->red*Da,Da);
red              1534 magick/composite.c   composite->red=Threshold(p->red,q->red,threshold,amount);
red              1573 magick/composite.c   composite->red=gamma*VividLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1574 magick/composite.c     q->red*Da,Da);
red              1603 magick/composite.c   composite->red=gamma*Xor(p->red*Sa,Sa,q->red*Da,Da);
red              2366 magick/composite.c       canvas.red=(MagickRealType) GetPixelRed(q);
red              2375 magick/composite.c           canvas.red=(MagickRealType) QuantumRange-canvas.red;
red              2423 magick/composite.c               composite.red=(MagickRealType) QuantumRange-composite.red;
red              2429 magick/composite.c             ClampPixel(composite.red) : ClampToQuantum(composite.red));
red              2447 magick/composite.c       source.red=(MagickRealType) GetPixelRed(p);
red              2457 magick/composite.c           source.red=(MagickRealType) QuantumRange-source.red;
red              2721 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red              2725 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,&composite.green,
red              2738 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red              2740 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&hue,&sans,&sans);
red              2741 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2756 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red              2758 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&sans,&chroma,
red              2760 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2775 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red              2777 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&sans,&sans,
red              2779 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2794 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&sans,
red              2796 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&hue,&chroma,&sans);
red              2797 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2806 magick/composite.c           composite.red=source.red;
red              2850 magick/composite.c           composite.red=(MagickRealType) QuantumRange-composite.red;
red              2856 magick/composite.c         ClampPixel(composite.red) : ClampToQuantum(composite.red));
red               254 magick/decorate.c   accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
red               255 magick/decorate.c     AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
red               262 magick/decorate.c   highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
red               263 magick/decorate.c     HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
red               270 magick/decorate.c   shadow.red=QuantumScale*matte.red*ShadowModulate;
red               275 magick/decorate.c   trough.red=QuantumScale*matte.red*TroughModulate;
red               955 magick/deprecate.c   threshold.red=geometry_info.rho;
red               958 magick/deprecate.c     threshold.green=threshold.red;
red               961 magick/deprecate.c     threshold.blue=threshold.red;
red               962 magick/deprecate.c   status=BilevelImageChannel(image,RedChannel,threshold.red);
red              2282 magick/deprecate.c   pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
red              2283 magick/deprecate.c   distance=pixel.red*pixel.red;
red              3432 magick/deprecate.c   const double lightness,Quantum *red,Quantum *green,Quantum *blue)
red              3444 magick/deprecate.c   assert(red != (Quantum *) NULL);
red              3455 magick/deprecate.c   *red=ClampToQuantum((MagickRealType) QuantumRange*r);
red              3568 magick/deprecate.c   p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
red              3569 magick/deprecate.c   q=(pixels[0].red-pixels[1].red)-p;
red              3570 magick/deprecate.c   r=pixels[2].red-pixels[0].red;
red              3571 magick/deprecate.c   s=pixels[1].red;
red              3572 magick/deprecate.c   pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
red              3674 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3682 magick/deprecate.c         pixel.red+=gamma*0.0625*pixels[i].red;
red              3719 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3765 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3778 magick/deprecate.c       pixel.red=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].red+delta.x*
red              3779 magick/deprecate.c         pixels[1].red)+delta.y*((1.0-delta.x)*pixels[2].red+delta.x*
red              3780 magick/deprecate.c         pixels[3].red));
red              3874 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3899 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[2].red,
red              3900 magick/deprecate.c                 pixels[3].red,pixels[0].red);
red              3919 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[1].red,
red              3920 magick/deprecate.c                 pixels[0].red,pixels[3].red);
red              3944 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[0].red,
red              3945 magick/deprecate.c                 pixels[1].red,pixels[2].red);
red              3965 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[3].red,
red              3966 magick/deprecate.c                 pixels[2].red,pixels[1].red);
red              4034 magick/deprecate.c               pixels[n].red*=alpha[n];
red              4043 magick/deprecate.c           pixel.red+=gamma*dx*dy*pixels[n].red;
red              7238 magick/deprecate.c   pixel.red=geometry_info.rho;
red              7242 magick/deprecate.c     pixel.green=pixel.red;
red              7246 magick/deprecate.c     pixel.blue=pixel.red;
red              7253 magick/deprecate.c       pixel.red*=QuantumRange/100.0f;
red              7263 magick/deprecate.c       if (pixel.red == 0)
red              7284 magick/deprecate.c         index=(IndexPacket) (GetPixelIntensity(image,q) <= pixel.red ? 0 : 1);
red              7286 magick/deprecate.c         SetPixelRed(q,image->colormap[(ssize_t) index].red);
red              7294 magick/deprecate.c         SetPixelRed(q,(MagickRealType) q->red <= pixel.red
red              7382 magick/deprecate.c MagickExport void TransformHSL(const Quantum red,const Quantum green,
red              7399 magick/deprecate.c   r=QuantumScale*red;
red              3710 magick/display.c             q->red=ScaleShortToQuantum(color.red);
red              3739 magick/display.c                         q->red=ScaleShortToQuantum(color.red);
red              3754 magick/display.c                       (*image)->colormap[i].red=ScaleShortToQuantum(color.red);
red              3780 magick/display.c                 target.red=(MagickRealType)
red              3781 magick/display.c                   ScaleShortToQuantum(border_color.red);
red              3812 magick/display.c                 q->red=ScaleShortToQuantum(color.red);
red              10061 magick/display.c                 target.red=(MagickRealType)
red              10062 magick/display.c                   ScaleShortToQuantum(border_color.red);
red              12279 magick/display.c   (*image)->background_color.red=ScaleShortToQuantum(
red              12280 magick/display.c     windows->pixel_info->pen_colors[pen_id].red);
red              3087 magick/distort.c               pixel.red     = coeff[x]*i +coeff[x+1]*j
red              3107 magick/distort.c               pixel.red     = coeff[x]*i     + coeff[x+1]*j +
red              3131 magick/distort.c             if ( channel & RedChannel     ) pixel.red     = 0.0;
red              3145 magick/distort.c                 pixel.red     += arguments[x++]*weight;
red              3156 magick/distort.c             if ( channel & RedChannel     ) pixel.red     /= denominator;
red              3180 magick/distort.c                 if ( channel & RedChannel     ) pixel.red     = arguments[x++];
red              3208 magick/distort.c                 if ( channel & RedChannel     ) pixel.red     = arguments[x++];
red              3221 magick/distort.c           pixel.red=ClampPixel(QuantumRange*pixel.red);
red              4303 magick/draw.c                target.red=(MagickRealType) draw_info->border_color.red;
red              4414 magick/draw.c                target.red=(MagickRealType) draw_info->border_color.red;
red               346 magick/effect.c       pixel.red=bias.red;
red               361 magick/effect.c             pixel.red+=(*k)*alpha*GetPixelRed(p);
red               378 magick/effect.c         SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red               669 magick/effect.c       pixel.red=bias.red;
red               683 magick/effect.c             pixel.red+=(*k)*alpha*GetPixelRed(p);
red               700 magick/effect.c         SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              1635 magick/effect.c       pixel.red=bias.red;
red              1648 magick/effect.c               pixel.red+=(*k)*kernel_pixels[u].red;
red              1656 magick/effect.c             SetPixelRed(q,ClampToQuantum(pixel.red));
red              1709 magick/effect.c               pixel.red+=(*k)*alpha*GetPixelRed(kernel_pixels+u);
red              1719 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              2104 magick/effect.c             qixel.red+=(*k)*pixel.red;
red              2116 magick/effect.c             SetPixelRed(q,ClampToQuantum(qixel.red));
red              2140 magick/effect.c             qixel.red+=(*k)*alpha*pixel.red;
red              2154 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
red              2389 magick/effect.c           mean.red+=(double) k->red;
red              2394 magick/effect.c         mean.red/=(double) (width*width);
red              3451 magick/effect.c             qixel.red+=pixel.red;
red              3464 magick/effect.c             SetPixelRed(q,ClampToQuantum(normalize*qixel.red));
red              3490 magick/effect.c             qixel.red+=alpha*pixel.red;
red              3505 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
red              3793 magick/effect.c       pixel.red=bias.red;
red              3811 magick/effect.c                   pixel.red+=(*k)*GetPixelRed(p+u+j);
red              3824 magick/effect.c                 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              3887 magick/effect.c                   pixel.red+=(*k)*alpha*GetPixelRed(p+u+j);
red              3901 magick/effect.c                 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              4626 magick/effect.c     pixel.red=bias.red;
red              4635 magick/effect.c           pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
red              4636 magick/effect.c           if (fabs(2.0*pixel.red) < quantum_threshold)
red              4637 magick/effect.c             pixel.red=(MagickRealType) GetPixelRed(p);
red              4639 magick/effect.c             pixel.red=(MagickRealType) GetPixelRed(p)+(pixel.red*gain);
red              4640 magick/effect.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red               373 magick/enhance.c       red,
red               436 magick/enhance.c   color_correction.red.slope=1.0;
red               437 magick/enhance.c   color_correction.red.offset=0.0;
red               438 magick/enhance.c   color_correction.red.power=1.0;
red               468 magick/enhance.c                 color_correction.red.slope=StringToDouble(token,(char **) NULL);
red               500 magick/enhance.c                 color_correction.red.offset=StringToDouble(token,
red               533 magick/enhance.c                 color_correction.red.power=StringToDouble(token,(char **) NULL);
red               573 magick/enhance.c         "  color_correction.red.slope: %g",color_correction.red.slope);
red               575 magick/enhance.c         "  color_correction.red.offset: %g",color_correction.red.offset);
red               577 magick/enhance.c         "  color_correction.red.power: %g",color_correction.red.power);
red               599 magick/enhance.c     cdl_map[i].red=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
red               600 magick/enhance.c       MagickRealType) (MaxMap*(pow(color_correction.red.slope*i/MaxMap+
red               601 magick/enhance.c       color_correction.red.offset,color_correction.red.power)))));
red               619 magick/enhance.c         luma=0.212656*image->colormap[i].red+0.715158*image->colormap[i].green+
red               621 magick/enhance.c         image->colormap[i].red=ClampToQuantum(luma+color_correction.saturation*
red               622 magick/enhance.c           cdl_map[ScaleQuantumToMap(image->colormap[i].red)].red-luma);
red               665 magick/enhance.c         (cdl_map[ScaleQuantumToMap(GetPixelRed(q))].red-luma)));
red               913 magick/enhance.c static void Contrast(const int sign,Quantum *red,Quantum *green,Quantum *blue)
red               923 magick/enhance.c   assert(red != (Quantum *) NULL);
red               929 magick/enhance.c   ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
red               937 magick/enhance.c   ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
red               976 magick/enhance.c         Contrast(sign,&image->colormap[i].red,&image->colormap[i].green,
red              1000 magick/enhance.c       red;
red              1018 magick/enhance.c       red=GetPixelRed(q);
red              1021 magick/enhance.c       Contrast(sign,&red,&green,&blue);
red              1022 magick/enhance.c       SetPixelRed(q,red);
red              1217 magick/enhance.c         histogram[ScaleQuantumToMap(intensity)].red++;
red              1227 magick/enhance.c           histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red              1243 magick/enhance.c   black.red=0.0;
red              1244 magick/enhance.c   white.red=MaxRange(QuantumRange);
red              1250 magick/enhance.c         intensity+=histogram[i].red;
red              1254 magick/enhance.c       black.red=(MagickRealType) i;
red              1258 magick/enhance.c         intensity+=histogram[i].red;
red              1262 magick/enhance.c       white.red=(MagickRealType) i;
red              1357 magick/enhance.c         if (i < (ssize_t) black.red)
red              1358 magick/enhance.c           stretch_map[i].red=(Quantum) 0;
red              1360 magick/enhance.c           if (i > (ssize_t) white.red)
red              1361 magick/enhance.c             stretch_map[i].red=QuantumRange;
red              1363 magick/enhance.c             if (black.red != white.red)
red              1364 magick/enhance.c               stretch_map[i].red=ScaleMapToQuantum((MagickRealType) (MaxMap*
red              1365 magick/enhance.c                 (i-black.red)/(white.red-black.red)));
red              1432 magick/enhance.c             if (black.red != white.red)
red              1433 magick/enhance.c               image->colormap[i].red=stretch_map[
red              1434 magick/enhance.c                 ScaleQuantumToMap(image->colormap[i].red)].red;
red              1489 magick/enhance.c           if (black.red != white.red)
red              1491 magick/enhance.c               ScaleQuantumToMap(GetPixelRed(q))].red);
red              1569 magick/enhance.c   mean=QuantumScale*((double) GetPixelRed(r)+pixel.red)/2.0; \
red              1570 magick/enhance.c   distance=QuantumScale*((double) GetPixelRed(r)-pixel.red); \
red              1583 magick/enhance.c       aggregate.red+=(weight)*GetPixelRed(r); \
red              1707 magick/enhance.c       SetPixelRed(q,(aggregate.red+(total_weight/2)-1)/total_weight);
red              1858 magick/enhance.c         histogram[ScaleQuantumToMap(ClampToQuantum(intensity))].red++;
red              1865 magick/enhance.c           histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red              1887 magick/enhance.c         intensity.red+=histogram[i].red;
red              1892 magick/enhance.c       intensity.red+=histogram[i].red;
red              1911 magick/enhance.c         if (white.red != black.red)
red              1912 magick/enhance.c           equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red              1913 magick/enhance.c             (map[i].red-black.red))/(white.red-black.red)));
red              1916 magick/enhance.c     if (((channel & RedChannel) != 0) && (white.red != black.red))
red              1917 magick/enhance.c       equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red              1918 magick/enhance.c         (map[i].red-black.red))/(white.red-black.red)));
red              1945 magick/enhance.c             if (white.red != black.red)
red              1947 magick/enhance.c                 image->colormap[i].red=equalize_map[
red              1948 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].red)].red;
red              1950 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].green)].red;
red              1952 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].blue)].red;
red              1954 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].opacity)].red;
red              1958 magick/enhance.c         if (((channel & RedChannel) != 0) && (white.red != black.red))
red              1959 magick/enhance.c           image->colormap[i].red=equalize_map[
red              1960 magick/enhance.c             ScaleQuantumToMap(image->colormap[i].red)].red;
red              2007 magick/enhance.c           if (white.red != black.red)
red              2010 magick/enhance.c                 ScaleQuantumToMap(GetPixelRed(q))].red);
red              2012 magick/enhance.c                 ScaleQuantumToMap(GetPixelGreen(q))].red);
red              2014 magick/enhance.c                 ScaleQuantumToMap(GetPixelBlue(q))].red);
red              2016 magick/enhance.c                 ScaleQuantumToMap(GetPixelOpacity(q))].red);
red              2019 magick/enhance.c                   ScaleQuantumToMap(GetPixelIndex(indexes+x))].red);
red              2024 magick/enhance.c       if (((channel & RedChannel) != 0) && (white.red != black.red))
red              2026 magick/enhance.c           ScaleQuantumToMap(GetPixelRed(q))].red);
red              2125 magick/enhance.c   gamma.red=geometry_info.rho;
red              2128 magick/enhance.c     gamma.green=gamma.red;
red              2131 magick/enhance.c     gamma.blue=gamma.red;
red              2132 magick/enhance.c   if ((gamma.red == 1.0) && (gamma.green == 1.0) && (gamma.blue == 1.0))
red              2134 magick/enhance.c   if ((gamma.red == gamma.green) && (gamma.green == gamma.blue))
red              2136 magick/enhance.c       BlueChannel),(double) gamma.red);
red              2139 magick/enhance.c       status=GammaImageChannel(image,RedChannel,(double) gamma.red);
red              2199 magick/enhance.c           image->colormap[i].red=gamma_map[ScaleQuantumToMap(
red              2200 magick/enhance.c             image->colormap[i].red)];
red              2219 magick/enhance.c           image->colormap[i].red=QuantumRange*gamma_pow(QuantumScale*
red              2220 magick/enhance.c             image->colormap[i].red,1.0/gamma);
red              2456 magick/enhance.c         red;
red              2458 magick/enhance.c       red=(MagickRealType) q->red;
red              2466 magick/enhance.c           intensity=(red+green+blue)/3.0;
red              2471 magick/enhance.c           intensity=MagickMax(MagickMax(red,green),blue);
red              2476 magick/enhance.c           intensity=(MagickMin(MagickMin(red,green),blue)+
red              2477 magick/enhance.c             MagickMax(MagickMax(red,green),blue))/2.0;
red              2482 magick/enhance.c           intensity=(MagickRealType) (((double) red*red+green*green+
red              2490 magick/enhance.c               red=EncodePixelGamma(red);
red              2494 magick/enhance.c           intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2501 magick/enhance.c               red=DecodePixelGamma(red);
red              2505 magick/enhance.c           intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2513 magick/enhance.c               red=EncodePixelGamma(red);
red              2517 magick/enhance.c           intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2524 magick/enhance.c               red=DecodePixelGamma(red);
red              2528 magick/enhance.c           intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2533 magick/enhance.c           intensity=(MagickRealType) (sqrt((double) red*red+green*green+
red              2740 magick/enhance.c         SetPixelRed(q,ClampToQuantum(pixel.red));
red              2951 magick/enhance.c         image->colormap[i].red=(Quantum) ClampToQuantum(LevelPixel(black_point,
red              2952 magick/enhance.c           white_point,gamma,(MagickRealType) image->colormap[i].red));
red              3131 magick/enhance.c         image->colormap[i].red=LevelizeValue(image->colormap[i].red);
red              3285 magick/enhance.c         status&=LevelImageChannel(image,RedChannel,black_color->red,
red              3286 magick/enhance.c           white_color->red,(double) 1.0);
red              3305 magick/enhance.c         status&=LevelizeImageChannel(image,RedChannel,black_color->red,
red              3306 magick/enhance.c           white_color->red,(double) 1.0);
red              3459 magick/enhance.c   const double percent_chroma,const double percent_luma,Quantum *red,
red              3470 magick/enhance.c   ConvertRGBToHCL(*red,*green,*blue,&hue,&chroma,&luma);
red              3478 magick/enhance.c   ConvertHCLToRGB(hue,chroma,luma,red,green,blue);
red              3482 magick/enhance.c   const double percent_chroma,const double percent_luma,Quantum *red,
red              3493 magick/enhance.c   ConvertRGBToHCLp(*red,*green,*blue,&hue,&chroma,&luma);
red              3501 magick/enhance.c   ConvertHCLpToRGB(hue,chroma,luma,red,green,blue);
red              3506 magick/enhance.c   Quantum *red,Quantum *green,Quantum *blue)
red              3516 magick/enhance.c   ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
red              3524 magick/enhance.c   ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
red              3529 magick/enhance.c   Quantum *red,Quantum *green,Quantum *blue)
red              3539 magick/enhance.c   ConvertRGBToHSI(*red,*green,*blue,&hue,&saturation,&intensity);
red              3547 magick/enhance.c   ConvertHSIToRGB(hue,saturation,intensity,red,green,blue);
red              3552 magick/enhance.c   Quantum *red,Quantum *green,Quantum *blue)
red              3562 magick/enhance.c   ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
red              3570 magick/enhance.c   ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
red              3574 magick/enhance.c   const double percent_saturation,const double percent_value,Quantum *red,
red              3585 magick/enhance.c   ConvertRGBToHSV(*red,*green,*blue,&hue,&saturation,&value);
red              3593 magick/enhance.c   ConvertHSVToRGB(hue,saturation,value,red,green,blue);
red              3597 magick/enhance.c   const double percent_whiteness,const double percent_blackness,Quantum *red,
red              3608 magick/enhance.c   ConvertRGBToHWB(*red,*green,*blue,&hue,&whiteness,&blackness);
red              3616 magick/enhance.c   ConvertHWBToRGB(hue,whiteness,blackness,red,green,blue);
red              3620 magick/enhance.c   const double percent_chroma,const double percent_hue,Quantum *red,
red              3631 magick/enhance.c   ConvertRGBToLCHab(*red,*green,*blue,&luma,&chroma,&hue);
red              3639 magick/enhance.c   ConvertLCHabToRGB(luma,chroma,hue,red,green,blue);
red              3643 magick/enhance.c   const double percent_chroma,const double percent_hue,Quantum *red,
red              3654 magick/enhance.c   ConvertRGBToLCHuv(*red,*green,*blue,&luma,&chroma,&hue);
red              3662 magick/enhance.c   ConvertLCHuvToRGB(luma,chroma,hue,red,green,blue);
red              3734 magick/enhance.c         red;
red              3739 magick/enhance.c       red=image->colormap[i].red;
red              3747 magick/enhance.c             &red,&green,&blue);
red              3753 magick/enhance.c             &red,&green,&blue);
red              3759 magick/enhance.c             &red,&green,&blue);
red              3765 magick/enhance.c             &red,&green,&blue);
red              3772 magick/enhance.c             &red,&green,&blue);
red              3778 magick/enhance.c             &red,&green,&blue);
red              3784 magick/enhance.c             &red,&green,&blue);
red              3791 magick/enhance.c             &red,&green,&blue);
red              3797 magick/enhance.c             &red,&green,&blue);
red              3801 magick/enhance.c       image->colormap[i].red=red;
red              3844 magick/enhance.c         red;
red              3846 magick/enhance.c       red=GetPixelRed(q);
red              3854 magick/enhance.c             &red,&green,&blue);
red              3860 magick/enhance.c             &red,&green,&blue);
red              3866 magick/enhance.c             &red,&green,&blue);
red              3873 magick/enhance.c             &red,&green,&blue);
red              3879 magick/enhance.c             &red,&green,&blue);
red              3885 magick/enhance.c             &red,&green,&blue);
red              3891 magick/enhance.c             &red,&green,&blue);
red              3898 magick/enhance.c             &red,&green,&blue);
red              3902 magick/enhance.c       SetPixelRed(q,red);
red              4002 magick/enhance.c           if ((image->colormap[i].red != image->colormap[i].green) ||
red              4006 magick/enhance.c           image->colormap[i].red=QuantumRange-image->colormap[i].red;
red              4422 magick/enhance.c         image->colormap[i].red=ClampToQuantum(sigmoidal_map[
red              4423 magick/enhance.c           ScaleQuantumToMap(image->colormap[i].red)]);
red               178 magick/feature.c   q->red=QuantumRange;
red               223 magick/feature.c             q->red=QuantumRange;
red               513 magick/feature.c       q->red=0;
red               708 magick/feature.c     grays[i].red=(~0U);
red               742 magick/feature.c       grays[ScaleQuantumToMap(GetPixelRed(p))].red=
red               768 magick/feature.c     if (grays[i].red != ~0U)
red               769 magick/feature.c       grays[(ssize_t) gray.red++].red=grays[i].red;
red               784 magick/feature.c   number_grays=gray.red;
red               966 magick/feature.c         while (grays[u].red != ScaleQuantumToMap(GetPixelRed(p)))
red               968 magick/feature.c         while (grays[v].red != ScaleQuantumToMap(GetPixelRed(p+offset)))
red               970 magick/feature.c         cooccurrence[u][v].direction[i].red++;
red               971 magick/feature.c         cooccurrence[v][u].direction[i].red++;
red              1083 magick/feature.c         cooccurrence[x][y].direction[i].red*=normalize;
red              1116 magick/feature.c           cooccurrence[x][y].direction[i].red*
red              1117 magick/feature.c           cooccurrence[x][y].direction[i].red;
red              1135 magick/feature.c         sum[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
red              1142 magick/feature.c         correlation.direction[i].red+=x*y*cooccurrence[x][y].direction[i].red;
red              1157 magick/feature.c           cooccurrence[x][y].direction[i].red/((y-x)*(y-x)+1);
red              1171 magick/feature.c         density_xy[y+x+2].direction[i].red+=
red              1172 magick/feature.c           cooccurrence[x][y].direction[i].red;
red              1187 magick/feature.c           cooccurrence[x][y].direction[i].red*
red              1188 magick/feature.c           MagickLog10(cooccurrence[x][y].direction[i].red);
red              1206 magick/feature.c         density_x[x].direction[i].red+=cooccurrence[x][y].direction[i].red;
red              1215 magick/feature.c         density_y[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
red              1225 magick/feature.c       mean.direction[i].red+=y*sum[y].direction[i].red;
red              1226 magick/feature.c       sum_squares.direction[i].red+=y*y*sum[y].direction[i].red;
red              1246 magick/feature.c       (correlation.direction[i].red-mean.direction[i].red*
red              1247 magick/feature.c       mean.direction[i].red)/(sqrt(sum_squares.direction[i].red-
red              1248 magick/feature.c       (mean.direction[i].red*mean.direction[i].red))*sqrt(
red              1249 magick/feature.c       sum_squares.direction[i].red-(mean.direction[i].red*
red              1250 magick/feature.c       mean.direction[i].red)));
red              1296 magick/feature.c         x*density_xy[x].direction[i].red;
red              1311 magick/feature.c         density_xy[x].direction[i].red*
red              1312 magick/feature.c         MagickLog10(density_xy[x].direction[i].red);
red              1333 magick/feature.c         density_xy[x].direction[i].red;
red              1376 magick/feature.c         variance.direction[i].red+=(y-mean.direction[i].red+1)*
red              1377 magick/feature.c           (y-mean.direction[i].red+1)*cooccurrence[x][y].direction[i].red;
red              1392 magick/feature.c         density_xy[MagickAbsoluteValue(y-x)].direction[i].red+=
red              1393 magick/feature.c           cooccurrence[x][y].direction[i].red;
red              1407 magick/feature.c         entropy_xy.direction[i].red-=cooccurrence[x][y].direction[i].red*
red              1408 magick/feature.c           MagickLog10(cooccurrence[x][y].direction[i].red);
red              1420 magick/feature.c         entropy_xy1.direction[i].red-=(cooccurrence[x][y].direction[i].red*
red              1421 magick/feature.c           MagickLog10(density_x[x].direction[i].red*
red              1422 magick/feature.c           density_y[y].direction[i].red));
red              1438 magick/feature.c         entropy_xy2.direction[i].red-=(density_x[x].direction[i].red*
red              1439 magick/feature.c           density_y[y].direction[i].red*MagickLog10(
red              1440 magick/feature.c           density_x[x].direction[i].red*density_y[y].direction[i].red));
red              1459 magick/feature.c       variance.direction[i].red;
red              1490 magick/feature.c       variance.direction[i].red+=density_xy[x].direction[i].red;
red              1497 magick/feature.c       sum_squares.direction[i].red+=density_xy[x].direction[i].red*
red              1498 magick/feature.c         density_xy[x].direction[i].red;
red              1513 magick/feature.c         density_xy[x].direction[i].red*
red              1514 magick/feature.c         MagickLog10(density_xy[x].direction[i].red);
red              1532 magick/feature.c       entropy_x.direction[i].red-=(density_x[x].direction[i].red*
red              1533 magick/feature.c         MagickLog10(density_x[x].direction[i].red));
red              1544 magick/feature.c       entropy_y.direction[i].red-=(density_y[x].direction[i].red*
red              1545 magick/feature.c         MagickLog10(density_y[x].direction[i].red));
red              1561 magick/feature.c       (((double) number_grays*number_grays*sum_squares.direction[i].red)-
red              1562 magick/feature.c       (variance.direction[i].red*variance.direction[i].red))/
red              1586 magick/feature.c       (entropy_xy.direction[i].red-entropy_xy1.direction[i].red)/
red              1587 magick/feature.c       (entropy_x.direction[i].red > entropy_y.direction[i].red ?
red              1588 magick/feature.c        entropy_x.direction[i].red : entropy_y.direction[i].red);
red              1608 magick/feature.c       (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].red-
red              1609 magick/feature.c       entropy_xy.direction[i].red)))));
red              1658 magick/feature.c               pixel.direction[i].red+=cooccurrence[x][y].direction[i].red;
red              1670 magick/feature.c           Q[z][y].direction[i].red+=cooccurrence[z][x].direction[i].red*
red              1671 magick/feature.c             cooccurrence[y][x].direction[i].red/density_x[z].direction[i].red/
red              1672 magick/feature.c             density_y[x].direction[i].red;
red              1675 magick/feature.c             density_x[z].direction[i].green/density_y[x].direction[i].red;
red              1691 magick/feature.c       channel_features[RedChannel].contrast[i]+=z*z*pixel.direction[i].red;
red              2232 magick/feature.c                 distance=(mean_pixel.red-pixel.red)*(mean_pixel.red-pixel.red)+
red              2239 magick/feature.c                     sum_pixel.red+=pixel.red;
red              2251 magick/feature.c         mean_pixel.red=gamma*sum_pixel.red;
red              2259 magick/feature.c           255.0*QuantumScale*(mean_pixel.red-previous_pixel.red)*
red              2260 magick/feature.c           255.0*QuantumScale*(mean_pixel.red-previous_pixel.red)+
red              2268 magick/feature.c       q->red=ClampToQuantum(mean_pixel.red);
red               267 magick/fourier.c           Cr->red=Ar->red+Br->red;
red               268 magick/fourier.c           Ci->red=Ai->red+Bi->red;
red               283 magick/fourier.c           Cr->red=Ar->red;
red               284 magick/fourier.c           Ci->red=(-Bi->red);
red               301 magick/fourier.c           gamma=PerceptibleReciprocal(Br->red*Br->red+Bi->red*Bi->red+snr);
red               302 magick/fourier.c           Cr->red=gamma*(Ar->red*Br->red+Ai->red*Bi->red);
red               303 magick/fourier.c           Ci->red=gamma*(Ai->red*Br->red-Ar->red*Bi->red);
red               324 magick/fourier.c           Cr->red=sqrt(Ar->red*Ar->red+Ai->red*Ai->red);
red               325 magick/fourier.c           Ci->red=atan2(Ai->red,Ar->red)/(2.0*MagickPI)+0.5;
red               339 magick/fourier.c           Cr->red=QuantumScale*(Ar->red*Br->red-Ai->red*Bi->red);
red               340 magick/fourier.c           Ci->red=QuantumScale*(Ai->red*Br->red+Ar->red*Bi->red);
red               356 magick/fourier.c           Cr->red=Ar->red*cos(2.0*MagickPI*(Ai->red-0.5));
red               357 magick/fourier.c           Ci->red=Ar->red*sin(2.0*MagickPI*(Ai->red-0.5));
red               371 magick/fourier.c           Cr->red=Ar->red-Br->red;
red               372 magick/fourier.c           Ci->red=Ai->red-Bi->red;
red               551 magick/fx.c          pixel.red=0.5*(GetPixelRed(p)+factor*quantum);
red               559 magick/fx.c          pixel.red=0.5*(pixel.red+factor*quantum);
red               562 magick/fx.c          SetPixelRed(q,ClampToQuantum(pixel.red));
red               748 magick/fx.c      pixel.red=geometry_info.rho;
red               795 magick/fx.c          SetPixelRed(q,((GetPixelRed(p)*(100.0-pixel.red)+
red               796 magick/fx.c            colorize.red*pixel.red)/100.0));
red              1483 magick/fx.c            case RedChannel: return(QuantumScale*pixel.red);
red              1617 magick/fx.c            return(QuantumScale*pixel.red);
red              1664 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red              1708 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red              1717 magick/fx.c              luma=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
red              1725 magick/fx.c              luminance=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
red              1785 magick/fx.c            return(QuantumScale*pixel.red);
red              1798 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red              3796 magick/fx.c          SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/2.0,
red              3816 magick/fx.c              SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/
red              3845 magick/fx.c              SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/
red              3869 magick/fx.c              SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+
red              3870 magick/fx.c                v.red)/2.0,plasma));
red              3896 magick/fx.c          SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/2.0,
red              4391 magick/fx.c          SetPixelRed(q,border_image->background_color.red);
red              4549 magick/fx.c            pixel.red=(MagickRealType) (QuantumRange*
red              4551 magick/fx.c            pixel.green=pixel.red;
red              4552 magick/fx.c            pixel.blue=pixel.red;
red              4554 magick/fx.c              pixel.index=pixel.red;
red              4681 magick/fx.c              if ((double) image->colormap[i].red > threshold)
red              4682 magick/fx.c                image->colormap[i].red=QuantumRange-image->colormap[i].red;
red              5338 magick/fx.c      pixel.red=geometry_info.rho;
red              5348 magick/fx.c      color_vector.red=(MagickRealType) (pixel.red*tint.red/100.0-
red              5395 magick/fx.c          pixel.red=(MagickRealType) GetPixelRed(p)+color_vector.red*(1.0-(4.0*
red              5397 magick/fx.c          SetPixelRed(q,ClampToQuantum(pixel.red));
red                85 magick/gem-private.h static inline void ConvertRGBToXYZ(const Quantum red,const Quantum green,
red                96 magick/gem-private.h   r=QuantumScale*DecodePixelGamma((MagickRealType) red);
red               150 magick/gem-private.h   Quantum *red,Quantum *green,Quantum *blue)
red               157 magick/gem-private.h   assert(red != (Quantum *) NULL);
red               163 magick/gem-private.h   *red=ClampToQuantum((MagickRealType) EncodePixelGamma(QuantumRange*r));
red                87 magick/gem.c     const double luma,Quantum *red,Quantum *green,Quantum *blue)
red               101 magick/gem.c     assert(red != (Quantum *) NULL);
red               146 magick/gem.c     *red=ClampToQuantum(QuantumRange*(r+m));
red               180 magick/gem.c     const double luma,Quantum *red,Quantum *green,Quantum *blue)
red               195 magick/gem.c     assert(red != (Quantum *) NULL);
red               252 magick/gem.c     *red=ClampToQuantum(QuantumRange*(z*r+m));
red               285 magick/gem.c     const double brightness,Quantum *red,Quantum *green,Quantum *blue)
red               297 magick/gem.c     assert(red != (Quantum *) NULL);
red               302 magick/gem.c         *red=ClampToQuantum(QuantumRange*brightness);
red               303 magick/gem.c         *green=(*red);
red               304 magick/gem.c         *blue=(*red);
red               317 magick/gem.c         *red=ClampToQuantum(QuantumRange*brightness);
red               324 magick/gem.c         *red=ClampToQuantum(QuantumRange*q);
red               331 magick/gem.c         *red=ClampToQuantum(QuantumRange*p);
red               338 magick/gem.c         *red=ClampToQuantum(QuantumRange*p);
red               345 magick/gem.c         *red=ClampToQuantum(QuantumRange*t);
red               352 magick/gem.c         *red=ClampToQuantum(QuantumRange*brightness);
red               388 magick/gem.c     const double intensity,Quantum *red,Quantum *green,Quantum *blue)
red               399 magick/gem.c     assert(red != (Quantum *) NULL);
red               428 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
red               461 magick/gem.c     const double lightness,Quantum *red,Quantum *green,Quantum *blue)
red               475 magick/gem.c     assert(red != (Quantum *) NULL);
red               538 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
red               571 magick/gem.c     const double value,Quantum *red,Quantum *green,Quantum *blue)
red               585 magick/gem.c     assert(red != (Quantum *) NULL);
red               645 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
red               678 magick/gem.c     const double blackness,Quantum *red,Quantum *green,Quantum *blue)
red               694 magick/gem.c     assert(red != (Quantum *) NULL);
red               700 magick/gem.c         *red=ClampToQuantum(QuantumRange*v);
red               721 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
red               762 magick/gem.c     const double hue,Quantum *red,Quantum *green,Quantum *blue)
red               772 magick/gem.c     assert(red != (Quantum *) NULL);
red               776 magick/gem.c     ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               815 magick/gem.c     const double hue,Quantum *red,Quantum *green,Quantum *blue)
red               825 magick/gem.c     assert(red != (Quantum *) NULL);
red               829 magick/gem.c     ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               860 magick/gem.c   MagickExport void ConvertRGBToHCL(const Quantum red,const Quantum green,
red               877 magick/gem.c     r=(double) red;
red               886 magick/gem.c       if (red == (Quantum) max)
red               927 magick/gem.c   MagickExport void ConvertRGBToHCLp(const Quantum red,const Quantum green,
red               944 magick/gem.c     r=(double) red;
red               953 magick/gem.c       if (red == (Quantum) max)
red               994 magick/gem.c   MagickExport void ConvertRGBToHSB(const Quantum red,const Quantum green,
red              1014 magick/gem.c     r=(double) red;
red              1070 magick/gem.c   MagickExport void ConvertRGBToHSI(const Quantum red,const Quantum green,
red              1083 magick/gem.c     *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
red              1090 magick/gem.c     *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red              1092 magick/gem.c     alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
red              1127 magick/gem.c   MagickExport void ConvertRGBToHSL(const Quantum red,const Quantum green,
red              1141 magick/gem.c     max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
red              1143 magick/gem.c     min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red              1153 magick/gem.c     if (max == (QuantumScale*red))
red              1161 magick/gem.c         *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red              1163 magick/gem.c         *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red              1199 magick/gem.c   MagickExport void ConvertRGBToHSV(const Quantum red,const Quantum green,
red              1213 magick/gem.c     max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
red              1215 magick/gem.c     min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red              1225 magick/gem.c     if (max == (QuantumScale*red))
red              1233 magick/gem.c         *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red              1235 magick/gem.c         *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red              1268 magick/gem.c   MagickExport void ConvertRGBToHWB(const Quantum red,const Quantum green,
red              1286 magick/gem.c     r=(double) red;
red              1345 magick/gem.c   MagickExport void ConvertRGBToLCHab(const Quantum red,const Quantum green,
red              1359 magick/gem.c     ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red              1406 magick/gem.c   MagickExport void ConvertRGBToLCHuv(const Quantum red,const Quantum green,
red              1420 magick/gem.c     ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               166 magick/histogram.c     ((ScaleQuantumToChar(ClampToQuantum(pixel->red)) >> index) & 0x01) |
red              1148 magick/histogram.c   if (color_2->pixel.red != color_1->pixel.red)
red              1149 magick/histogram.c     return((int) color_1->pixel.red-(int) color_2->pixel.red);
red               354 magick/identify.c           match=fabs((double) (p->red-target)) < 0.5 ? MagickTrue : MagickFalse;
red              1881 magick/image.c       if ((pixel.red < 0.0) || (pixel.red > QuantumRange) ||
red              1882 magick/image.c           (pixel.red != (QuantumAny) pixel.red))
red              1327 magick/mac.c           image->colormap[x].red=
red              1328 magick/mac.c             (*(picture_info.theColorTable))->ctTable[x].rgb.red;
red              1368 magick/mac.c         SetPixelRed(q,ScaleCharToQuantum(Pixel.red & 0xff));
red               968 magick/matrix.c       q->red=ClampToQuantum(value);
red               969 magick/matrix.c       q->green=q->red;
red               970 magick/matrix.c       q->blue=q->red;
red              2714 magick/morphology.c         result.red     =
red              2737 magick/morphology.c               result.red     += (*k)*GetPixelRed(k_pixels);
red              2748 magick/morphology.c               SetPixelRed(q,ClampToQuantum(result.red));
red              2782 magick/morphology.c               result.red     += alpha*GetPixelRed(k_pixels);
red              2796 magick/morphology.c             SetPixelRed(q,ClampToQuantum(gamma*result.red));
red              2805 magick/morphology.c         if (   ( p[r].red != GetPixelRed(q))
red              2917 magick/morphology.c       min.red     =
red              2922 magick/morphology.c       max.red     =
red              2928 magick/morphology.c       result.red     = (double) p[r].red;
red              2939 magick/morphology.c           result.red     =
red              2948 magick/morphology.c           result.red = 0.0;  /* result is not used otherwise */
red              2985 magick/morphology.c                     result.red     += (*k)*k_pixels[u].red;
red              2996 magick/morphology.c                   SetPixelRed(q,ClampToQuantum((MagickRealType) result.red));
red              3029 magick/morphology.c                     result.red     += alpha*k_pixels[u].red;
red              3043 magick/morphology.c                 SetPixelRed(q,ClampToQuantum((MagickRealType) (gamma*result.red)));
red              3068 magick/morphology.c                 Minimize(min.red,     (double) k_pixels[u].red);
red              3099 magick/morphology.c                 Maximize(max.red,     (double) k_pixels[u].red);
red              3135 magick/morphology.c                   Minimize(min.red,     (double) k_pixels[u].red);
red              3146 magick/morphology.c                   Maximize(max.red,     (double) k_pixels[u].red);
red              3160 magick/morphology.c             min.red     -= max.red;     Maximize( min.red,     0.0 );
red              3182 magick/morphology.c                 if ( result.red == 0.0 ||
red              3187 magick/morphology.c                   if ( result.red > 0.0 ) changes[id]++;
red              3188 magick/morphology.c                   result.red = 1.0;
red              3213 magick/morphology.c                 if ( result.red == 0.0 ||
red              3217 magick/morphology.c                   if ( result.red > 0.0 ) changes[id]++;
red              3218 magick/morphology.c                   result.red = 1.0;
red              3256 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3290 magick/morphology.c           result.red     -= min.red;
red              3298 magick/morphology.c           result.red     += min.red;
red              3317 magick/morphology.c             SetPixelRed(q,ClampToQuantum(result.red));
red              3331 magick/morphology.c       if (   ( p[r].red != GetPixelRed(q) )
red              3515 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3532 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3590 magick/morphology.c             SetPixelRed(q,ClampToQuantum(result.red));
red              3603 magick/morphology.c       if (   ( p[r].red != GetPixelRed(q) )
red              3708 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3725 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3781 magick/morphology.c             SetPixelRed(q,ClampToQuantum(result.red));
red              3794 magick/morphology.c       if (   ( p[r].red != GetPixelRed(q) )
red               362 magick/paint.c             SetPixelRed(q,ClampToQuantum(fill.red));
red              1016 magick/paint.c             SetPixelRed(q,ClampToQuantum(conform_fill.red));
red              1294 magick/paint.c       match=((pixel.red >= low->red) && (pixel.red <= high->red) &&
red                29 magick/pixel-accessor.h #define ClampPixelRed(pixel) ClampToQuantum((pixel)->red)
red                41 magick/pixel-accessor.h #define GetPixelCyan(pixel) ((pixel)->red)
red                42 magick/pixel-accessor.h #define GetPixelGray(pixel) ((pixel)->red)
red                45 magick/pixel-accessor.h #define GetPixelL(pixel) ((pixel)->red)
red                46 magick/pixel-accessor.h #define GetPixelLabel(pixel) ((ssize_t) (pixel)->red)
red                50 magick/pixel-accessor.h #define GetPixelRed(pixel) ((pixel)->red)
red                53 magick/pixel-accessor.h   (packet)->red=GetPixelRed((pixel)); \
red                59 magick/pixel-accessor.h   (packet)->red=GetPixelRed((pixel)); \
red                64 magick/pixel-accessor.h #define GetPixelY(pixel) ((pixel)->red)
red                74 magick/pixel-accessor.h #define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
red                76 magick/pixel-accessor.h   ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
red                79 magick/pixel-accessor.h #define SetPixelL(pixel,value) ((pixel)->red=(Quantum) (value))
red                82 magick/pixel-accessor.h #define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
red                85 magick/pixel-accessor.h   SetPixelRed(pixel,(packet)->red); \
red                91 magick/pixel-accessor.h   SetPixelRed(pixel,(packet)->red); \
red                98 magick/pixel-accessor.h   SetPixelRed(pixel,(packet)->red); \
red               104 magick/pixel-accessor.h #define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
red               144 magick/pixel-accessor.h   intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
red               157 magick/pixel-accessor.h       intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
red               162 magick/pixel-accessor.h     pixel->red)+0.715158f*DecodePixelGamma((MagickRealType) pixel->green)+
red               189 magick/pixel-accessor.h   red_green=(MagickRealType) pixel->red-pixel->green;
red               201 magick/pixel-accessor.h     red,
red               204 magick/pixel-accessor.h   red=(MagickRealType) pixel->red;
red               205 magick/pixel-accessor.h   if ((AbsolutePixelValue(red) >= MagickEpsilon) &&
red               206 magick/pixel-accessor.h       (AbsolutePixelValue(red-QuantumRange) >= MagickEpsilon))
red               208 magick/pixel-accessor.h   red_green=(MagickRealType) pixel->red-pixel->green;
red               221 magick/pixel-accessor.h   if ((pixel->red  == pixel->green) && (pixel->green == pixel->blue))
red               222 magick/pixel-accessor.h     return(pixel->red);
red               223 magick/pixel-accessor.h   intensity=(MagickRealType) (0.212656*pixel->red+0.715158*pixel->green+
red               232 magick/pixel-accessor.h   pixel->red=ClampToQuantum(magick_pixel->red);
red                81 magick/pixel-private.h   pixel->red=(MagickRealType) GetPixelRed(color);
red                96 magick/pixel-private.h   pixel->red=image->bias;
red               106 magick/pixel-private.h   SetPixelRed(color,ClampToQuantum(pixel->red));
red              2118 magick/pixel.c     red;
red              2120 magick/pixel.c   red=pixel->red;
red              2127 magick/pixel.c       intensity=(red+green+blue)/3.0;
red              2132 magick/pixel.c       intensity=MagickMax(MagickMax(red,green),blue);
red              2137 magick/pixel.c       intensity=(MagickMin(MagickMin(red,green),blue)+
red              2138 magick/pixel.c         MagickMax(MagickMax(red,green),blue))/2.0;
red              2143 magick/pixel.c       intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
red              2151 magick/pixel.c           red=EncodePixelGamma(red);
red              2155 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2162 magick/pixel.c           red=DecodePixelGamma(red);
red              2166 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2174 magick/pixel.c           red=EncodePixelGamma(red);
red              2178 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2185 magick/pixel.c           red=DecodePixelGamma(red);
red              2189 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2194 magick/pixel.c       intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
red              2234 magick/pixel.c   pixel->red=0.0;
red              2292 magick/pixel.c     red;
red              2294 magick/pixel.c   red=pixel->red;
red              2301 magick/pixel.c       intensity=(red+green+blue)/3.0;
red              2306 magick/pixel.c       intensity=MagickMax(MagickMax(red,green),blue);
red              2311 magick/pixel.c       intensity=(MagickMin(MagickMin(red,green),blue)+
red              2312 magick/pixel.c         MagickMax(MagickMax(red,green),blue))/2.0;
red              2317 magick/pixel.c       intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
red              2325 magick/pixel.c           red=EncodePixelGamma(red);
red              2329 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2336 magick/pixel.c           red=DecodePixelGamma(red);
red              2340 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2348 magick/pixel.c           red=EncodePixelGamma(red);
red              2352 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2359 magick/pixel.c           red=DecodePixelGamma(red);
red              2363 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2368 magick/pixel.c       intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
red              4341 magick/pixel.c       pixel->red=(MagickRealType) GetPixelRed(color);
red              4353 magick/pixel.c   pixel->red=(*alpha*GetPixelRed(color));
red              4494 magick/pixel.c       pixel->red=0.0;
red              4505 magick/pixel.c         pixel->red+=gamma*pixels[0].red;
red              4512 magick/pixel.c       pixel->red*=gamma;
red              4554 magick/pixel.c       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
red              4555 magick/pixel.c         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
red              4600 magick/pixel.c               pixels[i].red+=pixels[i+2].red;
red              4617 magick/pixel.c             pixels[0].red+=pixels[1].red;
red              4625 magick/pixel.c       pixel->red=alpha[0]*pixels[0].red;
red              4654 magick/pixel.c       pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
red              4655 magick/pixel.c         pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
red              4656 magick/pixel.c         pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
red              4657 magick/pixel.c         pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
red              4658 magick/pixel.c         pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
red              4659 magick/pixel.c         pixels[14].red+cx[3]*pixels[15].red));
red              4772 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
red              4773 magick/pixel.c                 pixels[3].red,pixels[0].red);
red              4793 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
red              4794 magick/pixel.c                 pixels[0].red,pixels[3].red);
red              4819 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
red              4820 magick/pixel.c                 pixels[1].red,pixels[2].red);
red              4841 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
red              4842 magick/pixel.c                 pixels[2].red,pixels[1].red);
red              4891 magick/pixel.c       pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
red              4892 magick/pixel.c         pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
red              4893 magick/pixel.c         pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
red              4894 magick/pixel.c         pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
red              4895 magick/pixel.c         pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
red              4896 magick/pixel.c         pixels[14].red+cx[3]*pixels[15].red));
red                87 magick/pixel.h     red,
red                97 magick/pixel.h     red,
red               122 magick/pixel.h     red,
red               136 magick/pixel.h     red,
red               145 magick/pixel.h     red,
red               153 magick/pixel.h     red,
red              2163 magick/property.c           pixel.red=(MagickRealType) QuantumRange*alpha;
red               434 magick/quantize.c       alpha_pixel->red=(MagickRealType) GetPixelRed(pixel);
red               441 magick/quantize.c   alpha_pixel->red=alpha*GetPixelRed(pixel);
red               635 magick/quantize.c       image->colormap[0].red=intensity;
red               638 magick/quantize.c       image->colormap[1].red=(double) QuantumRange-intensity;
red               765 magick/quantize.c   midpoint.red=(MagickRealType) QuantumRange/2.0;
red               810 magick/quantize.c         mid.red+=(id & 1) != 0 ? bisect : -bisect;
red               834 magick/quantize.c         error.red=QuantumScale*(pixel.red-mid.red);
red               839 magick/quantize.c         distance=(double) (error.red*error.red+error.green*error.green+
red               851 magick/quantize.c       node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
red               911 magick/quantize.c         mid.red+=(id & 1) != 0 ? bisect : -bisect;
red               935 magick/quantize.c         error.red=QuantumScale*(pixel.red-mid.red);
red               940 magick/quantize.c         distance=(double) (error.red*error.red+error.green*error.green+
red               952 magick/quantize.c       node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
red              1226 magick/quantize.c             QuantumRange*node_info->total_color.red)));
red              1244 magick/quantize.c                 QuantumRange*node_info->total_color.red)));
red              1258 magick/quantize.c                 gamma*QuantumRange*node_info->total_color.red)));
red              1432 magick/quantize.c   offset=(ssize_t) (RedShift(ScaleQuantumToChar(ClampPixel(pixel->red))) |
red              1524 magick/quantize.c           pixel.red+=7*current[u-v].red/16;
red              1534 magick/quantize.c               pixel.red+=previous[u+v].red/16;
red              1540 magick/quantize.c           pixel.red+=5*previous[u].red/16;
red              1547 magick/quantize.c               pixel.red+=3*previous[u-v].red/16;
red              1554 magick/quantize.c       pixel.red=(MagickRealType) ClampPixel(pixel.red);
red              1606 magick/quantize.c       current[u].red=pixel.red-color.red;
red              1765 magick/quantize.c         pixel.red+=p->weights[i]*p->error[i].red;
red              1771 magick/quantize.c       pixel.red=(MagickRealType) ClampPixel(pixel.red);
red              1825 magick/quantize.c       p->error[ErrorQueueLength-1].red=pixel.red-color.red;
red              2161 magick/quantize.c         image->colormap[index].red));
red              2321 magick/quantize.c         image->colormap[i].red=PosterizePixel(image->colormap[i].red);
red              2451 magick/quantize.c   parent->total_color.red+=node_info->total_color.red;
red              2624 magick/quantize.c       image->colormap[i].red=GetPixelRed(q);
red              3370 magick/quantize.c                   image->colormap[image->colors].red=GetPixelRed(q);
red               516 magick/resample.c               resample_filter->average_pixel.red *= weight;
red               524 magick/resample.c               resample_filter->average_pixel.red +=
red               525 magick/resample.c                       weight*resample_filter->image->background_color.red;
red               535 magick/resample.c               resample_filter->average_pixel.red /= divisor_c;
red               554 magick/resample.c   pixel->red = pixel->green = pixel->blue = 0.0;
red               625 magick/resample.c         pixel->red   += weight*pixels->red;
red               666 magick/resample.c     pixel->opacity = pixel->red = pixel->green = pixel->blue = 0;
red               667 magick/resample.c     pixel->red = QuantumRange; /* show pixels for which EWA fails */
red               683 magick/resample.c   pixel->red   = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
red              1934 magick/resize.c     pixel.red=QuantumRange*(packet[0]/255.0);
red              2573 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2578 magick/resize.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red              2606 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2613 magick/resize.c           SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              2819 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2824 magick/resize.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red              2852 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2859 magick/resize.c           SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              3393 magick/resize.c           x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red              3428 magick/resize.c                 x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red              3442 magick/resize.c             y_vector[x].red+=scale.y*x_vector[x].red;
red              3471 magick/resize.c               x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red              3487 magick/resize.c           pixel.red=y_vector[x].red+span.y*x_vector[x].red;
red              3494 magick/resize.c           s->red=pixel.red;
red              3523 magick/resize.c           SetPixelRed(q,ClampToQuantum(alpha*s->red));
red              3554 magick/resize.c             pixel.red+=span.x*s->red;
red              3561 magick/resize.c             t->red=pixel.red;
red              3580 magick/resize.c             pixel.red+=scale.x*s->red;
red              3594 magick/resize.c           pixel.red+=span.x*s->red;
red              3605 magick/resize.c           t->red=pixel.red;
red              3622 magick/resize.c         SetPixelRed(q,ClampToQuantum(alpha*t->red));
red               140 magick/segment.c     red,
red               263 magick/segment.c     red;
red               292 magick/segment.c   (void) ResetMagickMemory(&red,0,sizeof(red));
red               295 magick/segment.c   while (DefineRegion(extrema[Red],&red) != 0)
red               324 magick/segment.c         cluster->red=red;
red               344 magick/segment.c       cluster->red=red;
red               373 magick/segment.c              (cluster->red.left-SafeMargin)) &&
red               375 magick/segment.c              (cluster->red.right+SafeMargin)) &&
red               389 magick/segment.c             cluster->red.center+=(MagickRealType) ScaleQuantumToChar(GetPixelRed(p));
red               429 magick/segment.c         cluster->red.center/=cluster->count;
red               479 magick/segment.c           cluster->red.left,(double) cluster->red.right,(double)
red               494 magick/segment.c           cluster->red.center,(double) cluster->green.center,(double)
red               520 magick/segment.c     image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red               521 magick/segment.c       (cluster->red.center+0.5));
red               568 magick/segment.c         if (((ssize_t) ScaleQuantumToChar(q->red) >=
red               569 magick/segment.c              (cluster->red.left-SafeMargin)) &&
red               570 magick/segment.c             ((ssize_t) ScaleQuantumToChar(q->red) <=
red               571 magick/segment.c              (cluster->red.right+SafeMargin)) &&
red               609 magick/segment.c             distance_squared=squares[(ssize_t) ScaleQuantumToChar(q->red)-
red               619 magick/segment.c               distance_squared=squares[(ssize_t) ScaleQuantumToChar(q->red)-
red               944 magick/segment.c     red;
red              1006 magick/segment.c   (void) ResetMagickMemory(&red,0,sizeof(red));
red              1009 magick/segment.c   while (DefineRegion(extrema[Red],&red) != 0)
red              1042 magick/segment.c         cluster->red=red;
red              1065 magick/segment.c       cluster->red=red;
red              1084 magick/segment.c              (cluster->red.left-SafeMargin)) &&
red              1086 magick/segment.c              (cluster->red.right+SafeMargin)) &&
red              1100 magick/segment.c             cluster->red.center+=(MagickRealType)
red              1132 magick/segment.c         cluster->red.center/=cluster->count;
red              1169 magick/segment.c       threshold=(background->red.center+object->red.center)/2.0;
red              1170 magick/segment.c       pixel->red=(MagickRealType) ScaleCharToQuantum((unsigned char)
red               547 magick/shear.c       background.red+=QuantumScale*GetPixelRed(p);
red               556 magick/shear.c   image->background_color.red=ClampToQuantum((MagickRealType) QuantumRange*
red               557 magick/shear.c     background.red/count);
red               557 magick/statistic.c             evaluate_pixel[i].red=ApplyEvaluateOperator(random_info[id],
red               558 magick/statistic.c               GetPixelRed(p),op,evaluate_pixel[i].red);
red               573 magick/statistic.c           SetPixelRed(q,ClampToQuantum(evaluate_pixel[i/2].red));
red               662 magick/statistic.c             evaluate_pixel[x].red=ApplyEvaluateOperator(random_info[id],
red               664 magick/statistic.c               evaluate_pixel[x].red);
red               686 magick/statistic.c             evaluate_pixel[x].red/=number_images;
red               695 magick/statistic.c             evaluate_pixel[x].red=sqrt((double) evaluate_pixel[x].red/
red               714 magick/statistic.c               evaluate_pixel[x].red*=(MagickRealType) QuantumScale;
red               723 magick/statistic.c           SetPixelRed(q,ClampToQuantum(evaluate_pixel[x].red));
red              1700 magick/statistic.c       M00[RedChannel]+=QuantumScale*pixel.red;
red              1701 magick/statistic.c       M10[RedChannel]+=x*QuantumScale*pixel.red;
red              1702 magick/statistic.c       M01[RedChannel]+=y*QuantumScale*pixel.red;
red              1762 magick/statistic.c         centroid[RedChannel].y)*QuantumScale*pixel.red;
red              1764 magick/statistic.c         centroid[RedChannel].x)*QuantumScale*pixel.red;
red              1766 magick/statistic.c         centroid[RedChannel].y)*QuantumScale*pixel.red;
red              1769 magick/statistic.c         pixel.red;
red              1772 magick/statistic.c         pixel.red;
red              1775 magick/statistic.c         centroid[RedChannel].y)*QuantumScale*pixel.red;
red              1778 magick/statistic.c         pixel.red;
red              1781 magick/statistic.c         pixel.red;
red              2196 magick/statistic.c           if (pixel.red < *minima)
red              2197 magick/statistic.c             *minima=(double) pixel.red;
red              2198 magick/statistic.c           if (pixel.red > *maxima)
red              2199 magick/statistic.c             *maxima=(double) pixel.red;
red              2432 magick/statistic.c       histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red              2494 magick/statistic.c     if (histogram[i].red > 0.0)
red              2495 magick/statistic.c       number_bins.red++;
red              2500 magick/statistic.c     if ((image->matte != MagickFalse) && (histogram[i].red > 0.0))
red              2502 magick/statistic.c     if ((image->colorspace == CMYKColorspace) && (histogram[i].red > 0.0))
red              2507 magick/statistic.c     histogram[i].red/=area;
red              2508 magick/statistic.c     channel_statistics[RedChannel].entropy+=-histogram[i].red*
red              2509 magick/statistic.c       MagickLog10(histogram[i].red)/MagickLog10((double) number_bins.red);
red              2779 magick/statistic.c           polynomial_pixel[x].red+=coefficient*pow(QuantumScale*p->red,degree);
red              2800 magick/statistic.c       SetPixelRed(q,ClampToQuantum(QuantumRange*polynomial_pixel[x].red));
red              3082 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3127 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3167 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3210 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3258 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3307 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3353 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3407 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              3637 magick/statistic.c           pixel.red=MagickAbsoluteValue(maximum.red-minimum.red);
red              3688 magick/statistic.c         SetPixelRed(q,ClampToQuantum(pixel.red));
red               275 magick/threshold.c             channel_bias.red+=r[u].red;
red               283 magick/threshold.c         channel_sum.red+=r[u].red;
red               299 magick/threshold.c       channel_sum.red-=channel_bias.red;
red               307 magick/threshold.c         channel_bias.red+=r[0].red;
red               313 magick/threshold.c         channel_sum.red+=r[width-1].red;
red               322 magick/threshold.c       mean.red=(MagickRealType) (channel_sum.red/number_pixels+offset);
red               328 magick/threshold.c       SetPixelRed(q,((MagickRealType) GetPixelRed(q) <= mean.red) ?
red               615 magick/threshold.c   threshold.red=geometry_info.rho;
red               618 magick/threshold.c     threshold.green=threshold.red;
red               621 magick/threshold.c     threshold.blue=threshold.red;
red               624 magick/threshold.c     threshold.opacity=threshold.red;
red               627 magick/threshold.c     threshold.index=threshold.red;
red               630 magick/threshold.c       threshold.red*=(MagickRealType) (QuantumRange/100.0);
red               672 magick/threshold.c           ((MagickRealType) GetPixelRed(q) < threshold.red))
red              1495 magick/threshold.c     levels.red     = ((channel & RedChannel  )   != 0) ? levels.index : 0;
red              1507 magick/threshold.c         levels.red = (unsigned int) strtoul(p, &p, 10),   (void)(*p == ',' && p++);
red              1533 magick/threshold.c      levels.red, levels.green, levels.blue, levels.opacity, levels.index);
red              1544 magick/threshold.c     levels.red     = levels.red     ? levels.red-1     : 0;
red              1606 magick/threshold.c         if (levels.red) {
red              1607 magick/threshold.c           t = (ssize_t) (QuantumScale*GetPixelRed(q)*(levels.red*d+1));
red              1610 magick/threshold.c             ((l+(t >= threshold))*(MagickRealType) QuantumRange/levels.red)));
red              2069 magick/threshold.c             threshold.red=min_threshold;
red              2072 magick/threshold.c               threshold.red=max_threshold;
red              2074 magick/threshold.c               threshold.red=(MagickRealType) (QuantumRange*
red              2123 magick/threshold.c         SetPixelRed(q,(MagickRealType) GetPixelRed(q) <= threshold.red ?
red              2241 magick/threshold.c   threshold.red=geometry_info.rho;
red              2244 magick/threshold.c     threshold.green=threshold.red;
red              2247 magick/threshold.c     threshold.blue=threshold.red;
red              2250 magick/threshold.c     threshold.opacity=threshold.red;
red              2253 magick/threshold.c     threshold.index=threshold.red;
red              2256 magick/threshold.c       threshold.red*=(MagickRealType) (QuantumRange/100.0);
red              2298 magick/threshold.c           ((MagickRealType) GetPixelRed(q) > threshold.red))
red               406 magick/vision.c       object[id].color.red+=p->red;
red               449 magick/vision.c     object[i].color.red=object[i].color.red/object[i].area;
red               567 magick/vision.c         component_image->colormap[i].red=ClampToQuantum(object[i].color.red);
red              2088 magick/widget.c           windows->widget.pixel_info->matte_color.red,
red               578 magick/xwindow-private.h   if ((pixel->red  == pixel->green) && (pixel->green == pixel->blue))
red               579 magick/xwindow-private.h     return((MagickRealType) pixel->red);
red               580 magick/xwindow-private.h   intensity=0.21265*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
red               111 magick/xwindow.c   ((ScaleQuantumToShort(XRedGamma((color)->red))*map->red_max/65535L)* \
red               124 magick/xwindow.c   (((color)->red*map->red_max/65535L)*map->red_mult)+ \
red               174 magick/xwindow.c     red,
red               573 magick/xwindow.c           SetPixelRed(q,ScaleShortToQuantum(pixel->box_color.red));
red               585 magick/xwindow.c           SetPixelRed(q,ScaleShortToQuantum(pixel->pen_color.red));
red              1052 magick/xwindow.c     pixel.red=colors[i].red-(MagickRealType) color->red;
red              1053 magick/xwindow.c     distance=pixel.red*pixel.red;
red              2170 magick/xwindow.c       color.red=ClampToQuantum((MagickRealType) (red_map[i][j][(int)
red              2176 magick/xwindow.c       pixel=(size_t) (((size_t) color.red & 0xe0) |
red              2447 magick/xwindow.c           SetPixelRed(q,ScaleShortToQuantum(pixel->pen_color.red));
red              3071 magick/xwindow.c   pixel->highlight_color.red=(unsigned short) (((MagickRealType)
red              3072 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(HighlightModulate))/65535L+
red              3086 magick/xwindow.c   pixel->shadow_color.red=(unsigned short) (((MagickRealType)
red              3087 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(ShadowModulate))/65535L);
red              3097 magick/xwindow.c   pixel->depth_color.red=(unsigned short) (((MagickRealType)
red              3098 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(DepthModulate))/65535L);
red              3108 magick/xwindow.c   pixel->trough_color.red=(unsigned short) (((MagickRealType)
red              3109 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(TroughModulate))/65535L);
red              3857 magick/xwindow.c   pixel.red=ScaleShortToQuantum(color.red);
red              4213 magick/xwindow.c                       red,
red              4219 magick/xwindow.c                     red=0;
red              4230 magick/xwindow.c                       colors[i].pixel=(unsigned long) (red | green | blue);
red              4232 magick/xwindow.c                       red+=red_bit;
red              4233 magick/xwindow.c                       if (red > window_info[id].visual->red_mask)
red              4234 magick/xwindow.c                         red=0;
red              4334 magick/xwindow.c                     colors[index].red));
red              4391 magick/xwindow.c               composite_image->colormap[colors[i].pixel].red=
red              4392 magick/xwindow.c                 ScaleShortToQuantum(colors[i].red);
red              7563 magick/xwindow.c   intensity=0.298839*pixel->red+0.586811*pixel->green+0.114350*pixel->blue;
red              7774 magick/xwindow.c         color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
red              7780 magick/xwindow.c             color.red=gray_value;
red              7861 magick/xwindow.c             diversity[i].red=image->colormap[i].red;
red              7906 magick/xwindow.c             color.red=
red              7907 magick/xwindow.c               ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
red              7915 magick/xwindow.c                 color.red=gray_value;
red              7943 magick/xwindow.c             color.red=
red              7944 magick/xwindow.c               ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
red              7952 magick/xwindow.c                 color.red=gray_value;
red              8035 magick/xwindow.c         color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
red              8041 magick/xwindow.c             color.red=gray_value;
red              8091 magick/xwindow.c           color.red=color.blue;
red              8098 magick/xwindow.c           color.red=(unsigned short) 0;
red              8100 magick/xwindow.c             color.red=(unsigned short) ((size_t)
red              8138 magick/xwindow.c           pixel->background_color.red=(~pixel->foreground_color.red);
red              8558 magick/xwindow.c   color->red=0;
red              8577 magick/xwindow.c       color->red=xcolor.red;
red              9033 magick/xwindow.c   pixel.pen_color.red=ScaleQuantumToShort(draw_info->fill.red);
red                98 tests/validate.c static inline void ConvertRGBToXYZ(const double red,const double green,
red               106 tests/validate.c   r=QuantumScale*DecodePixelGamma(red);
red               139 tests/validate.c static void ConvertRGBToLab(const double red,const double green,
red               147 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               180 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
red               190 tests/validate.c   *red=ClampToQuantum(EncodePixelGamma(QuantumRange*r));
red               196 tests/validate.c   const double b,Quantum *red,Quantum *green,Quantum *blue)
red               204 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               207 tests/validate.c static void ConvertRGBToYPbPr(const double red,const double green,
red               210 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               211 tests/validate.c   *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
red               212 tests/validate.c   *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
red               215 tests/validate.c static void ConvertRGBToYCbCr(const double red,const double green,
red               218 tests/validate.c   ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
red               222 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
red               224 tests/validate.c   *red=ClampToQuantum(QuantumRange*(0.99999999999914679361*Y-
red               233 tests/validate.c   const double Cr,Quantum *red,Quantum *green,Quantum *blue)
red               235 tests/validate.c   ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
red               247 tests/validate.c   const double S,Quantum *red,Quantum *green,Quantum *blue)
red               255 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               266 tests/validate.c static void ConvertRGBToLMS(const double red,const double green,
red               274 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               296 tests/validate.c static void ConvertRGBToLuv(const double red,const double green,
red               304 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               323 tests/validate.c   const double v,Quantum *red,Quantum *green,Quantum *blue)
red               331 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               334 tests/validate.c static void ConvertRGBToYDbDr(const double red,const double green,
red               337 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               338 tests/validate.c   *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
red               339 tests/validate.c   *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
red               343 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
red               345 tests/validate.c   *red=ClampToQuantum(QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
red               353 tests/validate.c static void ConvertRGBToYIQ(const double red,const double green,
red               356 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               357 tests/validate.c   *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
red               358 tests/validate.c   *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
red               362 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
red               364 tests/validate.c   *red=ClampToQuantum(QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
red               372 tests/validate.c static void ConvertRGBToYUV(const double red,const double green,
red               375 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               376 tests/validate.c   *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
red               377 tests/validate.c   *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
red               381 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
red               383 tests/validate.c   *red=ClampToQuantum(QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
red               297 wand/drawing-wand.c       pixel.red=(MagickRealType) GetPixelRed(color);
red              2381 wand/drawing-wand.c   pixel->red=(MagickRealType) GetPixelRed(color);
red               578 wand/mogrify.c           sparse_arguments[x++] = QuantumScale*color.red;
red               751 wand/pixel-wand.c     (double) (QuantumScale*wand->pixel.red),
red               822 wand/pixel-wand.c   return((double) QuantumScale*wand->pixel.red);
red               853 wand/pixel-wand.c   return(ClampToQuantum(wand->pixel.red));
red              1070 wand/pixel-wand.c   ConvertRGBToHSL(ClampToQuantum(wand->pixel.red),ClampToQuantum(
red              1299 wand/pixel-wand.c       color->red=ClampToQuantum((MagickRealType) QuantumRange-
red              1300 wand/pixel-wand.c         (wand->pixel.red*(QuantumRange-wand->pixel.index)+wand->pixel.index));
red              1308 wand/pixel-wand.c   color->red=ClampToQuantum(wand->pixel.red);
red              1341 wand/pixel-wand.c   return((double) QuantumScale*wand->pixel.red);
red              1372 wand/pixel-wand.c   return(ClampToQuantum(wand->pixel.red));
red              1780 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) ClampToQuantum((MagickRealType)
red              1814 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) cyan;
red              1949 wand/pixel-wand.c     red;
red              1955 wand/pixel-wand.c   ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
red              1956 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) red;
red              2197 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) color->red;
red              2228 wand/pixel-wand.c WandExport void PixelSetRed(PixelWand *wand,const double red)
red              2234 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) ClampToQuantum((MagickRealType)
red              2235 wand/pixel-wand.c     QuantumRange*red);
red              2262 wand/pixel-wand.c WandExport void PixelSetRedQuantum(PixelWand *wand,const Quantum red)
red              2268 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) red;
red                84 www/source/contrast.c       pixel.red=SigmoidalContrast(pixel.red);
red                29 www/source/core/sigmoidal-contrast.c     pixels[x].red=RoundToQuantum(SigmoidalContrast(pixels[x].red));
red                30 www/source/wand/sigmoidal-contrast.c     pixel.red=SigmoidalContrast(pixel.red);