red               201 Magick++/lib/Color.cpp       redQuantum( target_color.red );
red               242 Magick++/lib/Color.cpp   pixel.red=_pixel->red;
red               304 Magick++/lib/Color.cpp   Quantum red, green, blue;
red               309 Magick++/lib/Color.cpp 		 &red,
red               313 Magick++/lib/Color.cpp   redQuantum   ( red );
red               349 Magick++/lib/Color.cpp   Quantum red, green, blue;
red               353 Magick++/lib/Color.cpp 		 &red,
red               358 Magick++/lib/Color.cpp   redQuantum   ( red );
red               387 Magick++/lib/Color.cpp   Quantum red, green, blue;
red               391 Magick++/lib/Color.cpp 		 &red,
red               396 Magick++/lib/Color.cpp   redQuantum   ( red );
red               425 Magick++/lib/Color.cpp   Quantum red, green, blue;
red               429 Magick++/lib/Color.cpp 		 &red,
red               434 Magick++/lib/Color.cpp   redQuantum   ( red );
red              1204 Magick++/lib/Image.cpp   target.red=pixel.red;
red              1235 Magick++/lib/Image.cpp   target.red=p->red;
red              1272 Magick++/lib/Image.cpp   target.red=static_cast<PixelPacket>(borderColor_).red;
red              1526 Magick++/lib/Image.cpp   black.red=pixel.red;
red              1534 Magick++/lib/Image.cpp   white.red=pixel.red;
red              1556 Magick++/lib/Image.cpp   black.red=pixel.red;
red              1564 Magick++/lib/Image.cpp   white.red=pixel.red;
red              1632 Magick++/lib/Image.cpp   target.red=static_cast<PixelPacket>(target_).red;
red              3604 Magick++/lib/Image.cpp   return Color( constImage()->matte_color.red,
red              3959 Magick++/lib/Image.cpp   statistics->red.minimum=minimum;
red              3960 Magick++/lib/Image.cpp 	statistics->red.maximum=maximum;
red              3962 Magick++/lib/Image.cpp     &statistics->red.mean,&statistics->red.standard_deviation,&exceptionInfo);
red              3964 Magick++/lib/Image.cpp     &statistics->red.kurtosis,&statistics->red.skewness,&exceptionInfo);
red                94 Magick++/lib/Magick++/Color.h         return (0.299*(_pixel->red)+0.587*(_pixel->green)+0.114*(_pixel->blue));
red               260 Magick++/lib/Magick++/Color.h     void           red ( double red_ );
red               261 Magick++/lib/Magick++/Color.h     double         red ( void ) const;
red               322 Magick++/lib/Magick++/Color.h   _pixel->red     = 0;
red               330 Magick++/lib/Magick++/Color.h   _pixel->red = red_;
red               336 Magick++/lib/Magick++/Color.h   return _pixel->red;
red              1157 Magick++/lib/Magick++/Image.h    ImageChannelStatistics red;
red              2172 Magick++/lib/Magick++/STL.h                            ( Color(histogram_array[i].pixel.red,
red                34 Magick++/tests/color.cpp 	double red;
red                57 Magick++/tests/color.cpp 	    ColorRGB colorMatch( colorMap[i].red,
red               541 coders/bmp.c       red;
red               910 coders/bmp.c             image->colormap[i].red=ScaleCharToQuantum(*p++);
red               994 coders/bmp.c             while (((bmp_info.red_mask << shift.red) & 0x80000000UL) == 0)
red               995 coders/bmp.c               shift.red++;
red              1005 coders/bmp.c           sample=shift.red;
red              1008 coders/bmp.c           quantum_bits.red=ClampToQuantum((MagickRealType) sample-shift.red);
red              1171 coders/bmp.c               red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
red              1172 coders/bmp.c               if (quantum_bits.red == 5)
red              1173 coders/bmp.c                 red|=((red & 0xe000) >> 5);
red              1174 coders/bmp.c               if (quantum_bits.red <= 8)
red              1175 coders/bmp.c                 red|=((red & 0xff00) >> 8);
red              1191 coders/bmp.c               SetPixelRed(q,ScaleShortToQuantum((unsigned short) red));
red              1275 coders/bmp.c               red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
red              1276 coders/bmp.c               if (quantum_bits.red == 8)
red              1277 coders/bmp.c                 red|=(red >> 8);
red              1287 coders/bmp.c               SetPixelRed(q,ScaleShortToQuantum((unsigned short) red));
red              2062 coders/bmp.c             *q++=ScaleQuantumToChar(image->colormap[i].red);
red               456 coders/cut.c             image->colormap[i].red=(Quantum) ReadBlobLSBShort(palette);
red               459 coders/cut.c                 image->colormap[i].red=ClampToQuantum(((double)
red               460 coders/cut.c                   image->colormap[i].red*QuantumRange+(PalHeader.MaxRed>>1))/
red               494 coders/cut.c             image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
red               566 coders/cut.c                     if(image->colormap[i].red!=sample) goto Finish;
red               571 coders/cut.c                 image->colormap[1].red=image->colormap[1].green=
red              3662 coders/dcm.c               image->colormap[i].red=index;
red              3686 coders/dcm.c               image->colormap[i].red=index;
red              3874 coders/dcm.c                   pixel.red=1UL*image->colormap[index].red;
red              3882 coders/dcm.c                       pixel.red=(size_t) ReadDCMByte(stream_info,image);
red              3890 coders/dcm.c                           pixel.red=ReadDCMMSBShort(stream_info,image);
red              3896 coders/dcm.c                           pixel.red=ReadDCMLSBShort(stream_info,image);
red              3901 coders/dcm.c                   pixel.red&=mask;
red              3906 coders/dcm.c                       pixel.red=scale[pixel.red];
red              3911 coders/dcm.c               SetPixelRed(q,pixel.red);
red              4006 coders/dcm.c                     pixel.red=1UL*image->colormap[index].red;
red              4014 coders/dcm.c                         pixel.red=(size_t) ReadDCMByte(stream_info,image);
red              4022 coders/dcm.c                             pixel.red=ReadDCMMSBShort(stream_info,image);
red              4028 coders/dcm.c                             pixel.red=ReadDCMLSBShort(stream_info,image);
red              4033 coders/dcm.c                     pixel.red&=mask;
red              4038 coders/dcm.c                         pixel.red=scale[pixel.red];
red              4044 coders/dcm.c                   (((size_t) pixel.red) << 8)));
red               233 coders/debug.c           (double) pixel.red,(double) pixel.green,(double) pixel.blue);
red               603 coders/dib.c           image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1265 coders/dib.c               *q++=ScaleQuantumToChar(image->colormap[i].red);
red               725 coders/djvu.c    image->colormap[0].red=QuantumRange;
red               728 coders/djvu.c    image->colormap[1].red=0;
red               290 coders/dps.c           red,
red               296 coders/dps.c         red=0;
red               304 coders/dps.c           colors[i].pixel=red | green | blue;
red               306 coders/dps.c           red+=red_bit;
red               307 coders/dps.c           if (red > visual_info->red_mask)
red               308 coders/dps.c             red=0;
red               386 coders/dps.c               SetPixelRed(q,ScaleShortToQuantum(colors[index].red));
red               443 coders/dps.c           image->colormap[colors[i].pixel].red=ScaleShortToQuantum(colors[i].red);
red               599 coders/emf.c         pBits->rgbRed=ScaleQuantumToChar(image->background_color.red);
red               170 coders/fax.c     image->colormap[0].red=QuantumRange;
red               173 coders/fax.c     image->colormap[1].red=(Quantum) 0;
red               688 coders/fpx.c     red=sqrt((double) red)-1.0;
red               693 coders/fpx.c     red_effect.byc2=0.299*red;
red               695 coders/fpx.c     red_effect.bc1y=(-0.299)*red;
red               696 coders/fpx.c     red_effect.bc1c1=1.0-0.299*red;
red               697 coders/fpx.c     red_effect.bc1c2=(-0.299)*red;
red               699 coders/fpx.c     red_effect.bc2y=0.701*red;
red               701 coders/fpx.c     red_effect.bc2c2=1.0+0.402*red;
red              1300 coders/gif.c             image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1340 coders/gif.c             image->colormap[i].red=ScaleCharToQuantum(*p++);
red              1639 coders/gif.c               image->colormap[opacity].red=image->transparent_color.red;
red              1652 coders/gif.c         *q++=ScaleQuantumToChar(image->colormap[i].red);
red               133 coders/hald.c        red;
red               150 coders/hald.c        for (red=0; red < (ssize_t) cube_size; red++)
red               153 coders/hald.c            (QuantumRange*red/(cube_size-1.0))));
red               277 coders/histogram.c         histogram[ScaleQuantumToChar(GetPixelRed(p))].red++;
red               285 coders/histogram.c   maximum=histogram[0].red;
red               288 coders/histogram.c     if (((channel & RedChannel) != 0) && (maximum < histogram[x].red))
red               289 coders/histogram.c       maximum=histogram[x].red;
red               310 coders/histogram.c         y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].red-0.5);
red               388 coders/icon.c              image->colormap[i].red=(Quantum) ScaleCharToQuantum(*p++);
red              1183 coders/icon.c                *q++=ScaleQuantumToChar(next->colormap[i].red);
red               208 coders/jbig.c    image->colormap[0].red=0;
red               211 coders/jbig.c    image->colormap[1].red=QuantumRange;
red              1267 coders/jpeg.c            image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
red              1268 coders/jpeg.c            image->colormap[i].green=image->colormap[i].red;
red              1269 coders/jpeg.c            image->colormap[i].blue=image->colormap[i].red;
red              1275 coders/jpeg.c            image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
red               186 coders/map.c         image->colormap[i].red=ScaleCharToQuantum(*p++);
red               195 coders/map.c         image->colormap[i].red=(Quantum) quantum;
red               402 coders/map.c         *q++=(unsigned char) image->colormap[i].red;
red               409 coders/map.c         *q++=(unsigned char) ((size_t) image->colormap[i].red >> 8);
red               410 coders/map.c         *q++=(unsigned char) image->colormap[i].red;
red              1202 coders/miff.c                    image->colormap[i].red=ScaleCharToQuantum(pixel);
red              1218 coders/miff.c                    image->colormap[i].red=ScaleShortToQuantum(pixel);
red              1234 coders/miff.c                    image->colormap[i].red=ScaleLongToQuantum(pixel);
red              1488 coders/miff.c              SetPixelRed(q,pixel.red);
red              1797 coders/miff.c        value=ScaleQuantumToLong(pixel.red);
red              1823 coders/miff.c        value=ScaleQuantumToShort(pixel.red);
red              1849 coders/miff.c        value=(unsigned char) ScaleQuantumToChar(pixel.red);
red              2333 coders/miff.c                pixel=ScaleQuantumToLong(image->colormap[i].red);
red              2346 coders/miff.c                pixel=ScaleQuantumToShort(image->colormap[i].red);
red              2359 coders/miff.c                pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
red               879 coders/mpc.c                     image->colormap[i].red=ScaleCharToQuantum(pixel);
red               895 coders/mpc.c                     image->colormap[i].red=ScaleShortToQuantum(pixel);
red               911 coders/mpc.c                     image->colormap[i].red=ScaleLongToQuantum(pixel);
red              1408 coders/mpc.c                 pixel=ScaleQuantumToLong(image->colormap[i].red);
red              1420 coders/mpc.c                 pixel=ScaleQuantumToShort(image->colormap[i].red);
red              1433 coders/mpc.c                 pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
red              3148 coders/msl.c             pixel.red=0.0;
red              3211 coders/msl.c                         pixel.red=StringToDouble(value,(char **) NULL);
red              3228 coders/msl.c                 (double) pixel.red,(double) pixel.green,(double) pixel.blue);
red              3238 coders/msl.c                 (void) GammaImageChannel(msl_info->image[n],RedChannel,pixel.red);
red               362 coders/palm.c          transpix.red=(MagickRealType) (QuantumRange*ReadBlobByte(image)/31);
red               378 coders/palm.c                image->colormap[(int) index].red=
red               391 coders/palm.c              image->colormap[(int) index].red=
red               735 coders/palm.c    transpix.red=0;
red               812 coders/palm.c                  image->colormap[count].red));
red               870 coders/palm.c                  transpix.red=GetPixelRed(p);
red               956 coders/palm.c          (void) WriteBlobByte(image,(unsigned char) ((31*transpix.red)/QuantumRange));
red               426 coders/pango.c       fill_color.red=ScaleCharToQuantum(*p++);
red               435 coders/pango.c       fill_color.red*=gamma;
red               763 coders/pcl.c                 ScaleQuantumToChar(image->colormap[i].red),
red               376 coders/pcx.c         image->colormap[i].red=ScaleCharToQuantum(*p++);
red               457 coders/pcx.c                 image->colormap[0].red=(Quantum) 0;
red               460 coders/pcx.c                 image->colormap[1].red=QuantumRange;
red               475 coders/pcx.c                     image->colormap[i].red=ScaleCharToQuantum(*p++);
red               984 coders/pcx.c           *q++=ScaleQuantumToChar(image->colormap[i].red);
red              2366 coders/pdf.c                 Ascii85Encode(image,ScaleQuantumToChar(image->colormap[i].red));
red              2372 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              1023 coders/pict.c              image->background_color.red=(Quantum)
red              1133 coders/pict.c                        tile_image->colormap[j].red=(Quantum)
red              1145 coders/pict.c                        tile_image->colormap[i].red=(Quantum) (QuantumRange-
red              1146 coders/pict.c                          tile_image->colormap[i].red);
red              1198 coders/pict.c                        tile_image->colormap[(ssize_t) index].red);
red              1876 coders/pict.c            image->colormap[i].red));
red              1932 coders/pict.c            *red;
red              1934 coders/pict.c          red=scanline;
red              1943 coders/pict.c            red=scanline;
red              1949 coders/pict.c                red=scanline+image->columns;
red              1955 coders/pict.c              *red++=ScaleQuantumToChar(GetPixelRed(p));
red               103 coders/pix.c       red;
red               167 coders/pix.c       red=(Quantum) 0;
red               189 coders/pix.c                   red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               196 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               465 coders/png.c        unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red); \
red               466 coders/png.c        (pixelpacket).red=ScaleCharToQuantum((lbr_bits)); \
red               546 coders/png.c        unsigned short lbr_bits=ScaleQuantumToShort((pixelpacket).red); \
red               547 coders/png.c        (pixelpacket).red=ScaleShortToQuantum((lbr_bits)); \
red              1024 coders/png.c              QuantumToCharToQuantumEqQuantum(image->background_color.red) &&
red              1037 coders/png.c                      image->colormap[indx].red) &&
red              1660 coders/png.c       if ((a->colormap[i].red != b->colormap[i].red) ||
red              2241 coders/png.c     transparent_color.red=65537;
red              2842 coders/png.c                         background.red=(png_uint_16)
red              2843 coders/png.c                           mng_info->global_plte[background.index].red;
red              2885 coders/png.c               "    raw ping_background=(%d,%d,%d).",ping_background->red,
red              2902 coders/png.c           ping_background->red *= bkgd_scale;
red              2912 coders/png.c                 "    ping_background=(%d,%d,%d).",ping_background->red,
red              2916 coders/png.c           image->background_color.red=
red              2917 coders/png.c               ScaleShortToQuantum(ping_background->red);
red              2930 coders/png.c               (double) image->background_color.red,
red              2956 coders/png.c             ((int)ping_trans_color->red > max_sample ||
red              2975 coders/png.c             transparent_color.red= scale_to_short*ping_trans_color->red;
red              2990 coders/png.c                 transparent_color.red=transparent_color.opacity;
red              3080 coders/png.c               image->colormap[i].red=ScaleCharToQuantum(palette[i].red);
red              3087 coders/png.c               image->colormap[i].red=0;
red              3105 coders/png.c               image->colormap[i].red=(Quantum) (i*scale);
red              3305 coders/png.c                       == transparent_color.red &&
red              3588 coders/png.c                    if (ScaleQuantumToShort(image->colormap[x].red) ==
red              3619 coders/png.c                     == transparent_color.red &&
red              4519 coders/png.c               image->background_color.red=ScaleCharToQuantum(p[1]);
red              4520 coders/png.c               image->background_color.green=image->background_color.red;
red              4521 coders/png.c               image->background_color.blue=image->background_color.red;
red              4526 coders/png.c               image->background_color.red=ScaleCharToQuantum(p[1]);
red              5386 coders/png.c                   mng_info->mng_global_bkgd.red=
red              5412 coders/png.c                   mng_background_color.red=
red              5445 coders/png.c                     mng_info->global_plte[i].red=p[3*i];
red              5455 coders/png.c                 mng_info->global_plte[i].red=i;
red              6099 coders/png.c                   mng_info->global_sbit.red=p[0];
red              7995 coders/png.c     ping_background.red = 0;
red              8001 coders/png.c     ping_trans_color.red=0;
red              8515 coders/png.c                       (int) image->colormap[i].red,
red              8528 coders/png.c                       (int) image->colormap[i].red,
red              8598 coders/png.c                          ping_trans_color.red=
red              8663 coders/png.c                     (int) image->background_color.red,
red              8669 coders/png.c                if (opaque[i].red == image->background_color.red &&
red              8809 coders/png.c                   if (colormap[i].red != colormap[i].green ||
red              8810 coders/png.c                       colormap[i].red != colormap[i].blue)
red              8820 coders/png.c                  if (colormap[i].red != 0 && colormap[i].red != QuantumRange)
red              8881 coders/png.c                         image->colormap[i].red ==
red              8918 coders/png.c                           (int) image->colormap[i].red,
red              9190 coders/png.c         if (ScaleQuantumToChar(image->background_color.red) == 0x49 &&
red              9194 coders/png.c            image->background_color.red=ScaleCharToQuantum(0x24);
red              9229 coders/png.c               if (ScaleQuantumToChar(image->colormap[i].red) == 0x49 &&
red              9233 coders/png.c                  image->colormap[i].red=ScaleCharToQuantum(0x24);
red              9300 coders/png.c                        ping_trans_color.red &&
red              9324 coders/png.c                   if (image->colormap[i].red == image->colormap[0].red &&
red              9562 coders/png.c          ping_background.red=(png_uint_16)
red              9563 coders/png.c            (ScaleQuantumToShort(image->background_color.red) & mask);
red              9617 coders/png.c           palette[i].red=ScaleQuantumToChar(image->colormap[i].red);
red              9627 coders/png.c               (long) i,palette[i].red,palette[i].green,palette[i].blue);
red              9896 coders/png.c                 ping_trans_color.red=(png_uint_16)
red              9897 coders/png.c                   (ScaleQuantumToShort(image->colormap[0].red) & mask);
red              9931 coders/png.c                     ping_trans_color.red&=0xff;
red              9942 coders/png.c                 ping_trans_color.red&=0xff;
red              10021 coders/png.c                      intensity=ScaleQuantumToChar(image->colormap[i].red);
red              10062 coders/png.c                     palette[i].red=ScaleQuantumToChar(image->colormap[i].red);
red              10134 coders/png.c                     (int) ping_trans_color.red,
red              10139 coders/png.c               ping_trans_color.red*=0x0101;
red              10148 coders/png.c                     (int) ping_trans_color.red,
red              10236 coders/png.c                           (int) ping_background.red,
red              10530 coders/png.c                         (int) palette[i].red,
red              10539 coders/png.c                         (int) palette[i].red,
red              10693 coders/png.c                           (int) ping_background.red,
red              10783 coders/png.c                          (int) ping_trans_color.red,
red              12539 coders/png.c         red;
red              12551 coders/png.c       red=ScaleQuantumToChar(image->background_color.red);
red              12555 coders/png.c       *(chunk+5)=red;
red              13112 coders/png.c           red,
red              13189 coders/png.c               if (next_image->background_color.red !=
red              13190 coders/png.c                   next_image->next->background_color.red ||
red              13536 coders/png.c            red=ScaleQuantumToShort(image->background_color.red);
red              13539 coders/png.c            PNGShort(chunk+4,red);
red              13572 coders/png.c              chunk[4+i*3]=ScaleQuantumToChar(image->colormap[i].red) & 0xff;
red              13624 coders/png.c                     chunk[4+i*3]=ScaleQuantumToChar(image->colormap[i].red);
red               573 coders/pnm.c               pixel.red=(MagickRealType) PNMInteger(image,10);
red               578 coders/pnm.c                   pixel.red=(MagickRealType) scale[ConstrainPixel(image,(ssize_t)
red               579 coders/pnm.c                     pixel.red,max_value)];
red               585 coders/pnm.c               SetPixelRed(q,pixel.red);
red              1064 coders/ps.c          q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.red),q); \
red              1920 coders/ps.c                      if ((GetPixelRed(p) == pixel.red) &&
red              2041 coders/ps.c                  ScaleQuantumToChar(image->colormap[i].red),
red              2086 coders/ps.c                      pixel.red=GetPixelRed(p);
red              1013 coders/ps2.c                 ScaleQuantumToChar(image->colormap[i].red),
red              1501 coders/ps3.c                     pixel=ScaleQuantumToChar(image->colormap[i].red);
red              1514 coders/ps3.c                     pixel=ScaleQuantumToChar(image->colormap[i].red);
red               891 coders/psd.c               image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red              2192 coders/psd.c           (void) WriteBlobByte(image,ScaleQuantumToChar(image->colormap[i].red));
red               486 coders/rle.c               image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
red               494 coders/rle.c                 image->colormap[i].red=ScaleCharToQuantum(*p);
red               537 coders/rle.c                   SetPixelRed(q,image->colormap[*p++].red);
red               199 coders/stegano.c             SetBit(indexes,i,GetBit(pixel.red,j));
red               360 coders/sun.c             image->colormap[i].red=ScaleCharToQuantum(sun_colormap[i]);
red               543 coders/sun.c                       GetPixelRed(q)].red);
red               931 coders/sun.c                 image->colormap[i].red));
red              2841 coders/svg.c               100.0*QuantumScale*image->background_color.red,
red              3012 coders/svg.c                   fill_color.red=ScaleCharToQuantum(*p++);
red              3014 coders/svg.c                   fill_color.red=ScaleCharToQuantum(*p++);
red              3028 coders/svg.c                     fill_color.red*=gamma;
red               311 coders/tga.c               pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               312 coders/tga.c               pixel.green=pixel.red;
red               313 coders/tga.c               pixel.blue=pixel.red;
red               328 coders/tga.c               pixel.red=ScaleAnyToQuantum(1UL*(k & 0x7c) >> 2,range);
red               341 coders/tga.c               pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               351 coders/tga.c               pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red               416 coders/tga.c                   pixel.red=ScaleCharToQuantum((unsigned char) index);
red               436 coders/tga.c               pixel.red=ScaleAnyToQuantum(1UL*(k & 0x7c) >> 2,range);
red               456 coders/tga.c               pixel.red=ScaleCharToQuantum(pixels[2]);
red               468 coders/tga.c               pixel.red=ScaleCharToQuantum(pixels[2]);
red               478 coders/tga.c         SetPixelRed(q,pixel.red);
red               796 coders/tga.c           *q++=ScaleQuantumToChar(image->colormap[i].red);
red              1318 coders/tiff.c                    image->colormap[i].red=ClampToQuantum(((double)
red              3421 coders/tiff.c            *red;
red              3426 coders/tiff.c          red=(uint16 *) AcquireQuantumMemory(65536,sizeof(*red));
red              3429 coders/tiff.c          if ((red == (uint16 *) NULL) || (green == (uint16 *) NULL) ||
red              3435 coders/tiff.c          (void) ResetMagickMemory(red,0,65536*sizeof(*red));
red              3440 coders/tiff.c            red[i]=ScaleQuantumToShort(image->colormap[i].red);
red              3444 coders/tiff.c          (void) TIFFSetField(tiff,TIFFTAG_COLORMAP,red,green,blue);
red              3445 coders/tiff.c          red=(uint16 *) RelinquishMagickMemory(red);
red               217 coders/tim.c             image->colormap[i].red=ScaleCharToQuantum(
red               462 coders/txt.c                   &y_offset,&pixel.red,&pixel.green,&pixel.blue,&pixel.index,
red               466 coders/txt.c                   &y_offset,&pixel.red,&pixel.green,&pixel.blue,&pixel.index);
red               471 coders/txt.c                 &y_offset,&pixel.red,&pixel.green,&pixel.blue,&pixel.opacity);
red               474 coders/txt.c                 &y_offset,&pixel.red,&pixel.green,&pixel.blue);
red               485 coders/txt.c           SetPixelRed(q,ScaleAnyToQuantum(pixel.red,range));
red               345 coders/uyvy.c            (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red));
red               350 coders/uyvy.c        pixel.red=(double) GetPixelRed(p);
red               468 coders/viff.c                image->colormap[i].red=ScaleCharToQuantum((unsigned char) value);
red               701 coders/viff.c                      GetPixelRed(q)].red);
red              1137 coders/viff.c              *q++=ScaleQuantumToChar(image->colormap[i].red);
red              1052 coders/wpg.c                     image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red              1109 coders/wpg.c                         image->colormap[i].red=ScaleCharToQuantum(WPG1_Palette[i].Red);
red              1125 coders/wpg.c                     if(image->colormap[0].red==0 &&
red              1128 coders/wpg.c                        image->colormap[1].red==0 &&
red              1132 coders/wpg.c                         image->colormap[1].red =
red              1237 coders/wpg.c                     image->colormap[i].red=ScaleCharToQuantum((char)
red               283 coders/xbm.c     image->colormap[0].red=QuantumRange;
red               286 coders/xbm.c     image->colormap[1].red=(Quantum) 0;
red               170 coders/xcf.c       red,
red               395 coders/xcf.c               SetPixelRed(q,ScaleCharToQuantum(xcfdata->red));
red               948 coders/xpm.c             image->colormap[opacity].red=image->transparent_color.red;
red               303 coders/xwd.c           colors[i].red=color.red;
red               319 coders/xwd.c             MSBOrderShort((unsigned char *) &colors[i].red,3*
red               320 coders/xwd.c               sizeof(colors[i].red));
red               411 coders/xwd.c                   index].red));
red               468 coders/xwd.c             image->colormap[i].red=ScaleShortToQuantum(colors[i].red);
red               726 coders/xwd.c           colors[i].red=ScaleQuantumToShort(image->colormap[i].red);
red               735 coders/xwd.c               MSBOrderShort((unsigned char *) &colors[i].red,
red               736 coders/xwd.c                 3*sizeof(colors[i].red));
red               742 coders/xwd.c           color.red=colors[i].red;
red              1822 magick/annotate.c           SetPixelRed(q,fill_color.red);
red               350 magick/attribute.c             status|=image->colormap[i].red != ScaleAnyToQuantum(
red               351 magick/attribute.c               ScaleQuantumToAny(image->colormap[i].red,range),range);
red               983 magick/attribute.c           image->colormap[i].red=ScaleAnyToQuantum(ScaleQuantumToAny(
red               984 magick/attribute.c             image->colormap[i].red,range),range);
red              3206 magick/cache.c   composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
red              3280 magick/cache.c     SetPixelRed(q,ClampToQuantum(beta.red));
red               697 magick/channel.c               SetPixelRed(q,pixel.red);
red               824 magick/channel.c           q->red=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->red,
red               825 magick/channel.c             (MagickRealType) q->opacity,(MagickRealType) pixel.red,
red                36 magick/color-private.h     red;
red                38 magick/color-private.h   red=(MagickRealType) p->red;
red                41 magick/color-private.h   if ((fabs(red-q->red) < MagickEpsilon) &&
red                64 magick/color-private.h   if (fabs(p->red-q->red) >= MagickEpsilon)
red                81 magick/color-private.h   if ((fabs(pixel->red-pixel->green) < MagickEpsilon) &&
red                91 magick/color-private.h     return(pixel->red);
red                92 magick/color-private.h   return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red                99 magick/color-private.h     return(ClampToQuantum(pixel->red));
red               100 magick/color-private.h   return(ClampToQuantum(0.212656*pixel->red+0.715158*pixel->green+
red               110 magick/color-private.h     red;
red               113 magick/color-private.h     return(pixel->red);
red               115 magick/color-private.h     return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red               116 magick/color-private.h   red=EncodePixelGamma(pixel->red);
red               119 magick/color-private.h   return(0.212656*red+0.715158*green+0.072186*blue);
red               128 magick/color-private.h     red;
red               131 magick/color-private.h     return(pixel->red);
red               133 magick/color-private.h     return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red               134 magick/color-private.h   red=DecodePixelGamma(pixel->red);
red               137 magick/color-private.h   return(0.212656*red+0.715158*green+0.072186*blue);
red                84 magick/color.c     red,
red              1034 magick/color.c       color=pixel->red;
red              1344 magick/color.c       color=pixel->red;
red              1438 magick/color.c       status=color.red == SVGCompliant(color.red);
red              1858 magick/color.c   pixel=p->red-q->red;
red              2330 magick/color.c     color_info->color.red=(MagickRealType) ScaleCharToQuantum(
red              2404 magick/color.c         pixel.red*(QuantumRange-pixel.index)+pixel.index)))));
red              2413 magick/color.c   SetPixelRed(color,ClampToQuantum(pixel.red));
red              2589 magick/color.c             pixel.red=pixel.green;
red              2620 magick/color.c             pixel.red=pixel.green;
red              2645 magick/color.c       color->red=(MagickRealType) ScaleAnyToQuantum(pixel.red,range);
red              2735 magick/color.c             color->red=(MagickRealType) ClampToQuantum(scale*geometry_info.rho);
red              2759 magick/color.c               color->green=color->red;
red              2760 magick/color.c               color->blue=color->red;
red              2784 magick/color.c                   360.0,geometry_info.sigma,geometry_info.xi,&pixel.red,
red              2790 magick/color.c                     &pixel.red,&pixel.green,&pixel.blue);
red              2795 magick/color.c                       &pixel.red,&pixel.green,&pixel.blue);
red              2799 magick/color.c                       &pixel.red,&pixel.green,&pixel.blue);
red              2801 magick/color.c               color->red=(MagickRealType) pixel.red;
red              2816 magick/color.c   color->red=(MagickRealType) p->color.red;
red              2924 magick/color.c     if (((p->compliance & compliance) != 0) && ((p->color.red == color->red)) &&
red               153 magick/colormap.c     image->colormap[i].red=(Quantum) pixel;
red                38 magick/colorspace-private.h     red,
red                43 magick/colorspace-private.h       red=QuantumScale*pixel->red;
red                49 magick/colorspace-private.h       red=DecodePixelGamma(pixel->red);
red                53 magick/colorspace-private.h   if ((fabs(red) < MagickEpsilon) && (fabs(green) < MagickEpsilon) &&
red                59 magick/colorspace-private.h   cyan=(MagickRealType) (1.0-red);
red                71 magick/colorspace-private.h   pixel->red=QuantumRange*cyan;
red               111 magick/colorspace.c   *cyan=QuantumScale*(QuantumRange-red);
red               124 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               144 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               156 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               163 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               164 magick/colorspace.c   *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
red               165 magick/colorspace.c   *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
red               171 magick/colorspace.c   ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
red               177 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               178 magick/colorspace.c   *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
red               179 magick/colorspace.c   *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
red               185 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               186 magick/colorspace.c   *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
red               187 magick/colorspace.c   *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
red               193 magick/colorspace.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               194 magick/colorspace.c   *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
red               195 magick/colorspace.c   *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
red               296 magick/colorspace.c           pixel.red=(MagickRealType) pixel.red;
red               432 magick/colorspace.c             red;
red               434 magick/colorspace.c           red=ClampToQuantum((MagickRealType) GetPixelRed(q));
red               441 magick/colorspace.c               ConvertRGBToCMY(red,green,blue,&X,&Y,&Z);
red               446 magick/colorspace.c               ConvertRGBToHCL(red,green,blue,&X,&Y,&Z);
red               451 magick/colorspace.c               ConvertRGBToHCLp(red,green,blue,&X,&Y,&Z);
red               456 magick/colorspace.c               ConvertRGBToHSB(red,green,blue,&X,&Y,&Z);
red               461 magick/colorspace.c               ConvertRGBToHSI(red,green,blue,&X,&Y,&Z);
red               466 magick/colorspace.c               ConvertRGBToHSL(red,green,blue,&X,&Y,&Z);
red               471 magick/colorspace.c               ConvertRGBToHSV(red,green,blue,&X,&Y,&Z);
red               476 magick/colorspace.c               ConvertRGBToHWB(red,green,blue,&X,&Y,&Z);
red               481 magick/colorspace.c               ConvertRGBToLab(red,green,blue,&X,&Y,&Z);
red               487 magick/colorspace.c               ConvertRGBToLCHab(red,green,blue,&X,&Y,&Z);
red               492 magick/colorspace.c               ConvertRGBToLCHuv(red,green,blue,&X,&Y,&Z);
red               497 magick/colorspace.c               ConvertRGBToLMS(red,green,blue,&X,&Y,&Z);
red               502 magick/colorspace.c               ConvertRGBToLuv(red,green,blue,&X,&Y,&Z);
red               507 magick/colorspace.c               ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               512 magick/colorspace.c               ConvertRGBToYCbCr(red,green,blue,&X,&Y,&Z);
red               517 magick/colorspace.c               ConvertRGBToYDbDr(red,green,blue,&X,&Y,&Z);
red               522 magick/colorspace.c               ConvertRGBToYIQ(red,green,blue,&X,&Y,&Z);
red               527 magick/colorspace.c               ConvertRGBToYPbPr(red,green,blue,&X,&Y,&Z);
red               532 magick/colorspace.c               ConvertRGBToYUV(red,green,blue,&X,&Y,&Z);
red               638 magick/colorspace.c             red;
red               640 magick/colorspace.c           red=ClampToQuantum((MagickRealType) GetPixelRed(q));
red               643 magick/colorspace.c           SetPixelRed(q,logmap[ScaleQuantumToMap(red)]);
red               701 magick/colorspace.c             red;
red               703 magick/colorspace.c           red=ClampToQuantum(DecodePixelGamma((MagickRealType)
red               709 magick/colorspace.c           SetPixelRed(q,red);
red               983 magick/colorspace.c           red;
red               996 magick/colorspace.c           red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
red              1002 magick/colorspace.c           pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
red              1004 magick/colorspace.c           pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
red              1006 magick/colorspace.c           pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
red              1008 magick/colorspace.c           SetPixelRed(q,ScaleMapToQuantum(pixel.red));
red              1038 magick/colorspace.c         red;
red              1048 magick/colorspace.c         red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
red              1049 magick/colorspace.c           image->colormap[i].red));
red              1054 magick/colorspace.c         pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
red              1055 magick/colorspace.c         pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
red              1056 magick/colorspace.c         pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
red              1057 magick/colorspace.c         image->colormap[i].red=ScaleMapToQuantum(pixel.red);
red              1231 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(1.0-cyan));
red              1253 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1265 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1279 magick/colorspace.c   pixel->red=((QuantumRange-(QuantumScale*pixel->red*
red              1296 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red              1302 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(0.99999999999914679361*Y-
red              1313 magick/colorspace.c   ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
red              1319 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
red              1330 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
red              1341 magick/colorspace.c   *red=ClampToQuantum(QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
red              1815 magick/colorspace.c             red;
red              1824 magick/colorspace.c               ConvertCMYToRGB(X,Y,Z,&red,&green,&blue);
red              1829 magick/colorspace.c               ConvertHCLToRGB(X,Y,Z,&red,&green,&blue);
red              1834 magick/colorspace.c               ConvertHCLpToRGB(X,Y,Z,&red,&green,&blue);
red              1839 magick/colorspace.c               ConvertHSBToRGB(X,Y,Z,&red,&green,&blue);
red              1844 magick/colorspace.c               ConvertHSIToRGB(X,Y,Z,&red,&green,&blue);
red              1849 magick/colorspace.c               ConvertHSLToRGB(X,Y,Z,&red,&green,&blue);
red              1854 magick/colorspace.c               ConvertHSVToRGB(X,Y,Z,&red,&green,&blue);
red              1859 magick/colorspace.c               ConvertHWBToRGB(X,Y,Z,&red,&green,&blue);
red              1864 magick/colorspace.c               ConvertLabToRGB(X,Y,Z,&red,&green,&blue);
red              1870 magick/colorspace.c               ConvertLCHabToRGB(X,Y,Z,&red,&green,&blue);
red              1875 magick/colorspace.c               ConvertLCHuvToRGB(X,Y,Z,&red,&green,&blue);
red              1880 magick/colorspace.c               ConvertLMSToRGB(X,Y,Z,&red,&green,&blue);
red              1885 magick/colorspace.c               ConvertLuvToRGB(X,Y,Z,&red,&green,&blue);
red              1890 magick/colorspace.c               ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
red              1895 magick/colorspace.c               ConvertYCbCrToRGB(X,Y,Z,&red,&green,&blue);
red              1900 magick/colorspace.c               ConvertYDbDrToRGB(X,Y,Z,&red,&green,&blue);
red              1905 magick/colorspace.c               ConvertYIQToRGB(X,Y,Z,&red,&green,&blue);
red              1910 magick/colorspace.c               ConvertYPbPrToRGB(X,Y,Z,&red,&green,&blue);
red              1915 magick/colorspace.c               ConvertYUVToRGB(X,Y,Z,&red,&green,&blue);
red              1921 magick/colorspace.c           SetPixelRed(q,ClampToQuantum((MagickRealType) red));
red              2023 magick/colorspace.c             red;
red              2025 magick/colorspace.c           red=ClampToQuantum((MagickRealType)
red              2031 magick/colorspace.c           SetPixelRed(q,red);
red              2089 magick/colorspace.c             red;
red              2091 magick/colorspace.c           red=ClampToQuantum(EncodePixelGamma((MagickRealType) GetPixelRed(q)));
red              2096 magick/colorspace.c           SetPixelRed(q,red);
red              2328 magick/colorspace.c             red;
red              2330 magick/colorspace.c           red=ScaleQuantumToMap(GetPixelRed(q));
red              2333 magick/colorspace.c           pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
red              2334 magick/colorspace.c           pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
red              2335 magick/colorspace.c           pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
red              2338 magick/colorspace.c               pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
red              2347 magick/colorspace.c               pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
red              2351 magick/colorspace.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red              2393 magick/colorspace.c           red;
red              2395 magick/colorspace.c         red=ScaleQuantumToMap(image->colormap[i].red);
red              2398 magick/colorspace.c         pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
red              2399 magick/colorspace.c         pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
red              2400 magick/colorspace.c         pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
red              2403 magick/colorspace.c             pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
red              2412 magick/colorspace.c             pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
red              2416 magick/colorspace.c         image->colormap[i].red=ClampToQuantum(pixel.red);
red               102 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               219 magick/composite.c   composite->red=Atop(p->red,Sa,q->red,1.0);
red               237 magick/composite.c   composite->red=QuantumScale*intensity*q->red;
red               250 magick/composite.c   composite->red=0.0;
red               292 magick/composite.c   composite->red=gamma*ColorBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               293 magick/composite.c     q->red*Da,Da);
red               354 magick/composite.c   composite->red=gamma*ColorDodge(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               355 magick/composite.c     q->red*Da,Da);
red               389 magick/composite.c     composite->red=gamma*Darken(p->red,p->opacity,q->red,q->opacity);
red               399 magick/composite.c       composite->red=MagickMin(p->red,q->red);
red               433 magick/composite.c       composite->red = from_p ? p->red : q->red;
red               468 magick/composite.c     composite->red=gamma*Difference(p->red,Sa,q->red,Da);
red               478 magick/composite.c       composite->red=fabs(p->red - q->red);
red               523 magick/composite.c     composite->red=gamma*Divide(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               524 magick/composite.c       q->red*Da,Da);
red               537 magick/composite.c       composite->red=QuantumRange*
red               538 magick/composite.c           Divide(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0);
red               572 magick/composite.c     composite->red=gamma*Exclusion(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               573 magick/composite.c       q->red*Da,Da);
red               586 magick/composite.c       composite->red=QuantumRange*
red               587 magick/composite.c           Exclusion(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0);
red               621 magick/composite.c   composite->red=gamma*HardLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               622 magick/composite.c     q->red*Da,Da);
red               663 magick/composite.c   assert(red != (MagickRealType *) NULL);
red               708 magick/composite.c   *red=QuantumRange*(r+m);
red               730 magick/composite.c   r=(double) red;
red               739 magick/composite.c     if (red == (MagickRealType) max)
red               773 magick/composite.c   composite->red=gamma*In(p->red,Sa,q->red,Da);
red               804 magick/composite.c     composite->red=gamma*Lighten(p->red,p->opacity,q->red,q->opacity);
red               814 magick/composite.c       composite->red=MagickMax(p->red,q->red);
red               848 magick/composite.c       composite->red = from_p ? p->red : q->red;
red               886 magick/composite.c   composite->red=gamma*(p->red*Sa+q->red*Da);
red               919 magick/composite.c   composite->red=gamma*LinearBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               920 magick/composite.c     q->red*Da,Da);
red               962 magick/composite.c   composite->red=gamma*LinearLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red               963 magick/composite.c     q->red*Da,Da);
red              1017 magick/composite.c     composite->red=gamma*Mathematics(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1018 magick/composite.c       q->red*Da,Da,args);
red              1031 magick/composite.c       composite->red=QuantumRange*
red              1032 magick/composite.c           Mathematics(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0,args);
red              1072 magick/composite.c       composite->red=p->red+q->red;
red              1112 magick/composite.c     composite->red=gamma*Minus(p->red*Sa,Sa,q->red*Da,Da);
red              1122 magick/composite.c       composite->red=p->red-q->red;
red              1161 magick/composite.c     composite->red=ModulusAdd(p->red,Sa,q->red,Da);
red              1172 magick/composite.c       composite->red=ModulusAdd(p->red,1.0,q->red,1.0);
red              1211 magick/composite.c     composite->red=ModulusSubtract(p->red,Sa,q->red,Da);
red              1222 magick/composite.c       composite->red=ModulusSubtract(p->red,1.0,q->red,1.0);
red              1253 magick/composite.c     composite->red=gamma*Multiply(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1254 magick/composite.c       q->red*Da,Da);
red              1267 magick/composite.c       composite->red=QuantumScale*p->red*q->red;
red              1299 magick/composite.c   composite->red=gamma*Out(p->red,Sa,q->red,Da);
red              1335 magick/composite.c   composite->red=gamma*PegtopLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1336 magick/composite.c     q->red*Da,Da);
red              1375 magick/composite.c   composite->red=gamma*PinLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1376 magick/composite.c     q->red*Da,Da);
red              1414 magick/composite.c     composite->red=gamma*Screen(p->red*Sa,q->red*Da);
red              1424 magick/composite.c       composite->red=QuantumRange*Screen(QuantumScale*p->red,
red              1425 magick/composite.c            QuantumScale*q->red);
red              1488 magick/composite.c   composite->red=gamma*SoftLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1489 magick/composite.c     q->red*Da,Da);
red              1522 magick/composite.c   composite->red=Threshold(p->red,q->red,threshold,amount);
red              1561 magick/composite.c   composite->red=gamma*VividLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red              1562 magick/composite.c     q->red*Da,Da);
red              1591 magick/composite.c   composite->red=gamma*Xor(p->red*Sa,Sa,q->red*Da,Da);
red              2348 magick/composite.c       destination.red=(MagickRealType) GetPixelRed(q);
red              2357 magick/composite.c           destination.red=(MagickRealType) QuantumRange-destination.red;
red              2405 magick/composite.c               composite.red=(MagickRealType) QuantumRange-composite.red;
red              2410 magick/composite.c           SetPixelRed(q,ClampToQuantum(composite.red));
red              2423 magick/composite.c       source.red=(MagickRealType) GetPixelRed(p);
red              2433 magick/composite.c           source.red=(MagickRealType) QuantumRange-source.red;
red              2692 magick/composite.c           CompositeHCL(destination.red,destination.green,destination.blue,&hue,
red              2696 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2709 magick/composite.c           CompositeHCL(destination.red,destination.green,destination.blue,&hue,
red              2711 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&hue,&sans,&sans);
red              2712 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2727 magick/composite.c           CompositeHCL(destination.red,destination.green,destination.blue,&hue,
red              2729 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&sans,&chroma,
red              2731 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2746 magick/composite.c           CompositeHCL(destination.red,destination.green,destination.blue,&hue,
red              2748 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&sans,&sans,
red              2750 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2765 magick/composite.c           CompositeHCL(destination.red,destination.green,destination.blue,&sans,
red              2767 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&hue,&chroma,
red              2769 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,
red              2778 magick/composite.c           composite.red=source.red;
red              2824 magick/composite.c           composite.red=(MagickRealType) QuantumRange-composite.red;
red              2829 magick/composite.c       SetPixelRed(q,ClampToQuantum(composite.red));
red               258 magick/decorate.c   accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
red               259 magick/decorate.c     AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
red               266 magick/decorate.c   highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
red               267 magick/decorate.c     HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
red               274 magick/decorate.c   shadow.red=QuantumScale*matte.red*ShadowModulate;
red               279 magick/decorate.c   trough.red=QuantumScale*matte.red*TroughModulate;
red               916 magick/deprecate.c   threshold.red=geometry_info.rho;
red               919 magick/deprecate.c     threshold.green=threshold.red;
red               922 magick/deprecate.c     threshold.blue=threshold.red;
red               923 magick/deprecate.c   status=BilevelImageChannel(image,RedChannel,threshold.red);
red              2199 magick/deprecate.c   pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
red              2200 magick/deprecate.c   distance=pixel.red*pixel.red;
red              3329 magick/deprecate.c   assert(red != (Quantum *) NULL);
red              3340 magick/deprecate.c   *red=ClampToQuantum((MagickRealType) QuantumRange*r);
red              3460 magick/deprecate.c   p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
red              3461 magick/deprecate.c   q=(pixels[0].red-pixels[1].red)-p;
red              3462 magick/deprecate.c   r=pixels[2].red-pixels[0].red;
red              3463 magick/deprecate.c   s=pixels[1].red;
red              3464 magick/deprecate.c   pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
red              3566 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3574 magick/deprecate.c         pixel.red+=gamma*0.0625*pixels[i].red;
red              3609 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3652 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3665 magick/deprecate.c       pixel.red=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].red+delta.x*
red              3666 magick/deprecate.c         pixels[1].red)+delta.y*((1.0-delta.x)*pixels[2].red+delta.x*
red              3667 magick/deprecate.c         pixels[3].red));
red              3761 magick/deprecate.c             pixels[i].red*=alpha[i];
red              3786 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[2].red,
red              3787 magick/deprecate.c                 pixels[3].red,pixels[0].red);
red              3806 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[1].red,
red              3807 magick/deprecate.c                 pixels[0].red,pixels[3].red);
red              3831 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[0].red,
red              3832 magick/deprecate.c                 pixels[1].red,pixels[2].red);
red              3852 magick/deprecate.c               pixel.red=gamma*MeshInterpolate(&delta,pixels[3].red,
red              3853 magick/deprecate.c                 pixels[2].red,pixels[1].red);
red              3921 magick/deprecate.c               pixels[n].red*=alpha[n];
red              3930 magick/deprecate.c           pixel.red+=gamma*dx*dy*pixels[n].red;
red              6977 magick/deprecate.c   pixel.red=geometry_info.rho;
red              6981 magick/deprecate.c     pixel.green=pixel.red;
red              6985 magick/deprecate.c     pixel.blue=pixel.red;
red              6992 magick/deprecate.c       pixel.red*=QuantumRange/100.0f;
red              7002 magick/deprecate.c       if (pixel.red == 0)
red              7023 magick/deprecate.c         index=(IndexPacket) (GetPixelIntensity(image,q) <= pixel.red ? 0 : 1);
red              7025 magick/deprecate.c         SetPixelRed(q,image->colormap[(ssize_t) index].red);
red              7033 magick/deprecate.c         SetPixelRed(q,(MagickRealType) q->red <= pixel.red
red              7146 magick/deprecate.c   r=QuantumScale*red;
red              3723 magick/display.c             q->red=ScaleShortToQuantum(color.red);
red              3752 magick/display.c                         q->red=ScaleShortToQuantum(color.red);
red              3767 magick/display.c                       (*image)->colormap[i].red=ScaleShortToQuantum(color.red);
red              3793 magick/display.c                 target.red=(MagickRealType)
red              3794 magick/display.c                   ScaleShortToQuantum(border_color.red);
red              3825 magick/display.c                 q->red=ScaleShortToQuantum(color.red);
red              10074 magick/display.c                 target.red=(MagickRealType)
red              10075 magick/display.c                   ScaleShortToQuantum(border_color.red);
red              12291 magick/display.c   (*image)->background_color.red=ScaleShortToQuantum(
red              12292 magick/display.c     windows->pixel_info->pen_colors[pen_id].red);
red              3096 magick/distort.c               pixel.red     = coeff[x]*i +coeff[x+1]*j
red              3116 magick/distort.c               pixel.red     = coeff[x]*i     + coeff[x+1]*j +
red              3140 magick/distort.c             if ( channel & RedChannel     ) pixel.red     = 0.0;
red              3154 magick/distort.c                 pixel.red     += arguments[x++]*weight;
red              3165 magick/distort.c             if ( channel & RedChannel     ) pixel.red     /= denominator;
red              3186 magick/distort.c                 if ( channel & RedChannel     ) pixel.red     = arguments[x++];
red              3198 magick/distort.c         if ( channel & RedChannel     ) pixel.red     *= QuantumRange;
red              4276 magick/draw.c                target.red=(MagickRealType) draw_info->border_color.red;
red              4387 magick/draw.c                target.red=(MagickRealType) draw_info->border_color.red;
red               340 magick/effect.c       pixel.red=bias.red;
red               355 magick/effect.c             pixel.red+=(*k)*alpha*GetPixelRed(p);
red               372 magick/effect.c         SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red               663 magick/effect.c       pixel.red=bias.red;
red               677 magick/effect.c             pixel.red+=(*k)*alpha*GetPixelRed(p);
red               694 magick/effect.c         SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              1596 magick/effect.c       pixel.red=bias.red;
red              1609 magick/effect.c               pixel.red+=(*k)*kernel_pixels[u].red;
red              1617 magick/effect.c             SetPixelRed(q,ClampToQuantum(pixel.red));
red              1670 magick/effect.c               pixel.red+=(*k)*alpha*GetPixelRed(kernel_pixels+u);
red              1680 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              2052 magick/effect.c             qixel.red+=(*k)*pixel.red;
red              2064 magick/effect.c             SetPixelRed(q,ClampToQuantum(qixel.red));
red              2088 magick/effect.c             qixel.red+=(*k)*alpha*pixel.red;
red              2102 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
red              2863 magick/effect.c             qixel.red+=pixel.red;
red              2876 magick/effect.c             SetPixelRed(q,ClampToQuantum(normalize*qixel.red));
red              2903 magick/effect.c             qixel.red+=alpha*pixel.red;
red              2918 magick/effect.c             SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
red              3206 magick/effect.c       pixel.red=bias.red;
red              3224 magick/effect.c                   pixel.red+=(*k)*GetPixelRed(p+u+j);
red              3237 magick/effect.c                 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              3300 magick/effect.c                   pixel.red+=(*k)*alpha*GetPixelRed(p+u+j);
red              3314 magick/effect.c                 SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              4035 magick/effect.c     pixel.red=bias.red;
red              4044 magick/effect.c           pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
red              4045 magick/effect.c           if (fabs(2.0*pixel.red) < quantum_threshold)
red              4046 magick/effect.c             pixel.red=(MagickRealType) GetPixelRed(p);
red              4048 magick/effect.c             pixel.red=(MagickRealType) GetPixelRed(p)+(pixel.red*gain);
red              4049 magick/effect.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red               369 magick/enhance.c       red,
red               432 magick/enhance.c   color_correction.red.slope=1.0;
red               433 magick/enhance.c   color_correction.red.offset=0.0;
red               434 magick/enhance.c   color_correction.red.power=1.0;
red               464 magick/enhance.c                 color_correction.red.slope=StringToDouble(token,(char **) NULL);
red               496 magick/enhance.c                 color_correction.red.offset=StringToDouble(token,
red               529 magick/enhance.c                 color_correction.red.power=StringToDouble(token,(char **) NULL);
red               569 magick/enhance.c         "  color_correction.red.slope: %g",color_correction.red.slope);
red               571 magick/enhance.c         "  color_correction.red.offset: %g",color_correction.red.offset);
red               573 magick/enhance.c         "  color_correction.red.power: %g",color_correction.red.power);
red               595 magick/enhance.c     cdl_map[i].red=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
red               596 magick/enhance.c       MagickRealType) (MaxMap*(pow(color_correction.red.slope*i/MaxMap+
red               597 magick/enhance.c       color_correction.red.offset,color_correction.red.power)))));
red               615 magick/enhance.c         luma=0.212656*image->colormap[i].red+0.715158*image->colormap[i].green+
red               617 magick/enhance.c         image->colormap[i].red=ClampToQuantum(luma+color_correction.saturation*
red               618 magick/enhance.c           cdl_map[ScaleQuantumToMap(image->colormap[i].red)].red-luma);
red               661 magick/enhance.c         (cdl_map[ScaleQuantumToMap(GetPixelRed(q))].red-luma)));
red               919 magick/enhance.c   assert(red != (Quantum *) NULL);
red               925 magick/enhance.c   ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
red               933 magick/enhance.c   ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
red               973 magick/enhance.c         Contrast(sign,&image->colormap[i].red,&image->colormap[i].green,
red               992 magick/enhance.c       red;
red              1010 magick/enhance.c       red=GetPixelRed(q);
red              1013 magick/enhance.c       Contrast(sign,&red,&green,&blue);
red              1014 magick/enhance.c       SetPixelRed(q,red);
red              1203 magick/enhance.c         histogram[ScaleQuantumToMap(intensity)].red++;
red              1213 magick/enhance.c           histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red              1229 magick/enhance.c   black.red=0.0;
red              1230 magick/enhance.c   white.red=MaxRange(QuantumRange);
red              1236 magick/enhance.c         intensity+=histogram[i].red;
red              1240 magick/enhance.c       black.red=(MagickRealType) i;
red              1244 magick/enhance.c         intensity+=histogram[i].red;
red              1248 magick/enhance.c       white.red=(MagickRealType) i;
red              1343 magick/enhance.c         if (i < (ssize_t) black.red)
red              1344 magick/enhance.c           stretch_map[i].red=(Quantum) 0;
red              1346 magick/enhance.c           if (i > (ssize_t) white.red)
red              1347 magick/enhance.c             stretch_map[i].red=QuantumRange;
red              1349 magick/enhance.c             if (black.red != white.red)
red              1350 magick/enhance.c               stretch_map[i].red=ScaleMapToQuantum((MagickRealType) (MaxMap*
red              1351 magick/enhance.c                 (i-black.red)/(white.red-black.red)));
red              1418 magick/enhance.c             if (black.red != white.red)
red              1419 magick/enhance.c               image->colormap[i].red=stretch_map[
red              1420 magick/enhance.c                 ScaleQuantumToMap(image->colormap[i].red)].red;
red              1475 magick/enhance.c           if (black.red != white.red)
red              1477 magick/enhance.c               ScaleQuantumToMap(GetPixelRed(q))].red);
red              1555 magick/enhance.c   mean=((MagickRealType) GetPixelRed(r)+pixel.red)/2; \
red              1556 magick/enhance.c   distance=(MagickRealType) GetPixelRed(r)-(MagickRealType) pixel.red; \
red              1573 magick/enhance.c       aggregate.red+=(weight)*GetPixelRed(r); \
red              1692 magick/enhance.c       SetPixelRed(q,(aggregate.red+(total_weight/2)-1)/total_weight);
red              1839 magick/enhance.c         histogram[ScaleQuantumToMap(ClampToQuantum(intensity))].red++;
red              1846 magick/enhance.c           histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red              1868 magick/enhance.c         intensity.red+=histogram[i].red;
red              1873 magick/enhance.c       intensity.red+=histogram[i].red;
red              1892 magick/enhance.c         if (white.red != black.red)
red              1893 magick/enhance.c           equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red              1894 magick/enhance.c             (map[i].red-black.red))/(white.red-black.red)));
red              1897 magick/enhance.c     if (((channel & RedChannel) != 0) && (white.red != black.red))
red              1898 magick/enhance.c       equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red              1899 magick/enhance.c         (map[i].red-black.red))/(white.red-black.red)));
red              1926 magick/enhance.c             if (white.red != black.red)
red              1928 magick/enhance.c                 image->colormap[i].red=equalize_map[
red              1929 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].red)].red;
red              1931 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].green)].red;
red              1933 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].blue)].red;
red              1935 magick/enhance.c                   ScaleQuantumToMap(image->colormap[i].opacity)].red;
red              1939 magick/enhance.c         if (((channel & RedChannel) != 0) && (white.red != black.red))
red              1940 magick/enhance.c           image->colormap[i].red=equalize_map[
red              1941 magick/enhance.c             ScaleQuantumToMap(image->colormap[i].red)].red;
red              1988 magick/enhance.c           if (white.red != black.red)
red              1991 magick/enhance.c                 ScaleQuantumToMap(GetPixelRed(q))].red);
red              1993 magick/enhance.c                 ScaleQuantumToMap(GetPixelGreen(q))].red);
red              1995 magick/enhance.c                 ScaleQuantumToMap(GetPixelBlue(q))].red);
red              1997 magick/enhance.c                 ScaleQuantumToMap(GetPixelOpacity(q))].red);
red              2000 magick/enhance.c                   ScaleQuantumToMap(GetPixelIndex(indexes+x))].red);
red              2005 magick/enhance.c       if (((channel & RedChannel) != 0) && (white.red != black.red))
red              2007 magick/enhance.c           ScaleQuantumToMap(GetPixelRed(q))].red);
red              2106 magick/enhance.c   gamma.red=geometry_info.rho;
red              2109 magick/enhance.c     gamma.green=gamma.red;
red              2112 magick/enhance.c     gamma.blue=gamma.red;
red              2113 magick/enhance.c   if ((gamma.red == 1.0) && (gamma.green == 1.0) && (gamma.blue == 1.0))
red              2115 magick/enhance.c   if ((gamma.red == gamma.green) && (gamma.green == gamma.blue))
red              2117 magick/enhance.c       BlueChannel),(double) gamma.red);
red              2120 magick/enhance.c       status=GammaImageChannel(image,RedChannel,(double) gamma.red);
red              2180 magick/enhance.c           image->colormap[i].red=gamma_map[ScaleQuantumToMap(
red              2181 magick/enhance.c             image->colormap[i].red)];
red              2200 magick/enhance.c           image->colormap[i].red=QuantumRange*gamma_pow(QuantumScale*
red              2201 magick/enhance.c             image->colormap[i].red,1.0/gamma);
red              2465 magick/enhance.c         red;
red              2467 magick/enhance.c       red=(MagickRealType) q->red;
red              2475 magick/enhance.c           intensity=(red+green+blue)/3.0;
red              2480 magick/enhance.c           intensity=MagickMax(MagickMax(red,green),blue);
red              2485 magick/enhance.c           intensity=(MagickMin(MagickMin(red,green),blue)+
red              2486 magick/enhance.c             MagickMax(MagickMax(red,green),blue))/2.0;
red              2491 magick/enhance.c           intensity=(MagickRealType) (((double) red*red+green*green+
red              2499 magick/enhance.c               red=EncodePixelGamma(red);
red              2503 magick/enhance.c           intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2510 magick/enhance.c               red=DecodePixelGamma(red);
red              2514 magick/enhance.c           intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2522 magick/enhance.c               red=EncodePixelGamma(red);
red              2526 magick/enhance.c           intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2533 magick/enhance.c               red=DecodePixelGamma(red);
red              2537 magick/enhance.c           intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2542 magick/enhance.c           intensity=(MagickRealType) (sqrt((double) red*red+green*green+
red              2749 magick/enhance.c         SetPixelRed(q,ClampToQuantum(pixel.red));
red              2960 magick/enhance.c         image->colormap[i].red=(Quantum) ClampToQuantum(LevelPixel(black_point,
red              2961 magick/enhance.c           white_point,gamma,(MagickRealType) image->colormap[i].red));
red              3140 magick/enhance.c         image->colormap[i].red=LevelizeValue(image->colormap[i].red);
red              3294 magick/enhance.c         status|=LevelImageChannel(image,RedChannel,black_color->red,
red              3295 magick/enhance.c           white_color->red,(double) 1.0);
red              3314 magick/enhance.c         status|=LevelizeImageChannel(image,RedChannel,black_color->red,
red              3315 magick/enhance.c           white_color->red,(double) 1.0);
red              3479 magick/enhance.c   ConvertRGBToHCL(*red,*green,*blue,&hue,&chroma,&luma);
red              3487 magick/enhance.c   ConvertHCLToRGB(hue,chroma,luma,red,green,blue);
red              3502 magick/enhance.c   ConvertRGBToHCLp(*red,*green,*blue,&hue,&chroma,&luma);
red              3510 magick/enhance.c   ConvertHCLpToRGB(hue,chroma,luma,red,green,blue);
red              3525 magick/enhance.c   ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
red              3533 magick/enhance.c   ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
red              3548 magick/enhance.c   ConvertRGBToHSI(*red,*green,*blue,&hue,&saturation,&intensity);
red              3556 magick/enhance.c   ConvertHSIToRGB(hue,saturation,intensity,red,green,blue);
red              3571 magick/enhance.c   ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
red              3579 magick/enhance.c   ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
red              3594 magick/enhance.c   ConvertRGBToHSV(*red,*green,*blue,&hue,&saturation,&value);
red              3602 magick/enhance.c   ConvertHSVToRGB(hue,saturation,value,red,green,blue);
red              3617 magick/enhance.c   ConvertRGBToHWB(*red,*green,*blue,&hue,&whiteness,&blackness);
red              3625 magick/enhance.c   ConvertHWBToRGB(hue,whiteness,blackness,red,green,blue);
red              3640 magick/enhance.c   ConvertRGBToLCHab(*red,*green,*blue,&luma,&chroma,&hue);
red              3648 magick/enhance.c   ConvertLCHabToRGB(luma,chroma,hue,red,green,blue);
red              3663 magick/enhance.c   ConvertRGBToLCHuv(*red,*green,*blue,&luma,&chroma,&hue);
red              3671 magick/enhance.c   ConvertLCHuvToRGB(luma,chroma,hue,red,green,blue);
red              3743 magick/enhance.c         red;
red              3748 magick/enhance.c       red=image->colormap[i].red;
red              3756 magick/enhance.c             &red,&green,&blue);
red              3762 magick/enhance.c             &red,&green,&blue);
red              3768 magick/enhance.c             &red,&green,&blue);
red              3774 magick/enhance.c             &red,&green,&blue);
red              3781 magick/enhance.c             &red,&green,&blue);
red              3787 magick/enhance.c             &red,&green,&blue);
red              3793 magick/enhance.c             &red,&green,&blue);
red              3800 magick/enhance.c             &red,&green,&blue);
red              3806 magick/enhance.c             &red,&green,&blue);
red              3810 magick/enhance.c       image->colormap[i].red=red;
red              3846 magick/enhance.c         red;
red              3848 magick/enhance.c       red=GetPixelRed(q);
red              3856 magick/enhance.c             &red,&green,&blue);
red              3862 magick/enhance.c             &red,&green,&blue);
red              3868 magick/enhance.c             &red,&green,&blue);
red              3875 magick/enhance.c             &red,&green,&blue);
red              3881 magick/enhance.c             &red,&green,&blue);
red              3887 magick/enhance.c             &red,&green,&blue);
red              3893 magick/enhance.c             &red,&green,&blue);
red              3900 magick/enhance.c             &red,&green,&blue);
red              3904 magick/enhance.c       SetPixelRed(q,red);
red              4004 magick/enhance.c           if ((image->colormap[i].red != image->colormap[i].green) ||
red              4008 magick/enhance.c           image->colormap[i].red=QuantumRange-image->colormap[i].red;
red              4416 magick/enhance.c         image->colormap[i].red=ClampToQuantum(sigmoidal_map[
red              4417 magick/enhance.c           ScaleQuantumToMap(image->colormap[i].red)]);
red               217 magick/feature.c     grays[i].red=(~0U);
red               251 magick/feature.c       grays[ScaleQuantumToMap(GetPixelRed(p))].red=
red               277 magick/feature.c     if (grays[i].red != ~0U)
red               278 magick/feature.c       grays[(ssize_t) gray.red++].red=grays[i].red;
red               293 magick/feature.c   number_grays=gray.red;
red               475 magick/feature.c         while (grays[u].red != ScaleQuantumToMap(GetPixelRed(p)))
red               477 magick/feature.c         while (grays[v].red != ScaleQuantumToMap(GetPixelRed(p+offset)))
red               479 magick/feature.c         cooccurrence[u][v].direction[i].red++;
red               480 magick/feature.c         cooccurrence[v][u].direction[i].red++;
red               592 magick/feature.c         cooccurrence[x][y].direction[i].red*=normalize;
red               625 magick/feature.c           cooccurrence[x][y].direction[i].red*
red               626 magick/feature.c           cooccurrence[x][y].direction[i].red;
red               644 magick/feature.c         sum[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
red               651 magick/feature.c         correlation.direction[i].red+=x*y*cooccurrence[x][y].direction[i].red;
red               666 magick/feature.c           cooccurrence[x][y].direction[i].red/((y-x)*(y-x)+1);
red               680 magick/feature.c         density_xy[y+x+2].direction[i].red+=
red               681 magick/feature.c           cooccurrence[x][y].direction[i].red;
red               696 magick/feature.c           cooccurrence[x][y].direction[i].red*
red               697 magick/feature.c           log10(cooccurrence[x][y].direction[i].red+MagickEpsilon);
red               715 magick/feature.c         density_x[x].direction[i].red+=cooccurrence[x][y].direction[i].red;
red               724 magick/feature.c         density_y[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
red               734 magick/feature.c       mean.direction[i].red+=y*sum[y].direction[i].red;
red               735 magick/feature.c       sum_squares.direction[i].red+=y*y*sum[y].direction[i].red;
red               755 magick/feature.c       (correlation.direction[i].red-mean.direction[i].red*
red               756 magick/feature.c       mean.direction[i].red)/(sqrt(sum_squares.direction[i].red-
red               757 magick/feature.c       (mean.direction[i].red*mean.direction[i].red))*sqrt(
red               758 magick/feature.c       sum_squares.direction[i].red-(mean.direction[i].red*
red               759 magick/feature.c       mean.direction[i].red)));
red               805 magick/feature.c         x*density_xy[x].direction[i].red;
red               820 magick/feature.c         density_xy[x].direction[i].red*
red               821 magick/feature.c         log10(density_xy[x].direction[i].red+MagickEpsilon);
red               842 magick/feature.c         density_xy[x].direction[i].red;
red               885 magick/feature.c         variance.direction[i].red+=(y-mean.direction[i].red+1)*
red               886 magick/feature.c           (y-mean.direction[i].red+1)*cooccurrence[x][y].direction[i].red;
red               901 magick/feature.c         density_xy[MagickAbsoluteValue(y-x)].direction[i].red+=
red               902 magick/feature.c           cooccurrence[x][y].direction[i].red;
red               916 magick/feature.c         entropy_xy.direction[i].red-=cooccurrence[x][y].direction[i].red*
red               917 magick/feature.c           log10(cooccurrence[x][y].direction[i].red+MagickEpsilon);
red               929 magick/feature.c         entropy_xy1.direction[i].red-=(cooccurrence[x][y].direction[i].red*
red               930 magick/feature.c           log10(density_x[x].direction[i].red*density_y[y].direction[i].red+
red               948 magick/feature.c         entropy_xy2.direction[i].red-=(density_x[x].direction[i].red*
red               949 magick/feature.c           density_y[y].direction[i].red*log10(density_x[x].direction[i].red*
red               950 magick/feature.c           density_y[y].direction[i].red+MagickEpsilon));
red               970 magick/feature.c       variance.direction[i].red;
red              1001 magick/feature.c       variance.direction[i].red+=density_xy[x].direction[i].red;
red              1008 magick/feature.c       sum_squares.direction[i].red+=density_xy[x].direction[i].red*
red              1009 magick/feature.c         density_xy[x].direction[i].red;
red              1024 magick/feature.c         density_xy[x].direction[i].red*
red              1025 magick/feature.c         log10(density_xy[x].direction[i].red+MagickEpsilon);
red              1043 magick/feature.c       entropy_x.direction[i].red-=(density_x[x].direction[i].red*
red              1044 magick/feature.c         log10(density_x[x].direction[i].red+MagickEpsilon));
red              1055 magick/feature.c       entropy_y.direction[i].red-=(density_y[x].direction[i].red*
red              1056 magick/feature.c         log10(density_y[x].direction[i].red+MagickEpsilon));
red              1072 magick/feature.c       (((double) number_grays*number_grays*sum_squares.direction[i].red)-
red              1073 magick/feature.c       (variance.direction[i].red*variance.direction[i].red))/
red              1097 magick/feature.c       (entropy_xy.direction[i].red-entropy_xy1.direction[i].red)/
red              1098 magick/feature.c       (entropy_x.direction[i].red > entropy_y.direction[i].red ?
red              1099 magick/feature.c        entropy_x.direction[i].red : entropy_y.direction[i].red);
red              1119 magick/feature.c       (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].red-
red              1120 magick/feature.c       entropy_xy.direction[i].red)))));
red              1169 magick/feature.c               pixel.direction[i].red+=cooccurrence[x][y].direction[i].red;
red              1181 magick/feature.c           Q[z][y].direction[i].red+=cooccurrence[z][x].direction[i].red*
red              1182 magick/feature.c             cooccurrence[y][x].direction[i].red/density_x[z].direction[i].red/
red              1183 magick/feature.c             density_y[x].direction[i].red;
red              1186 magick/feature.c             density_x[z].direction[i].green/density_y[x].direction[i].red;
red              1202 magick/feature.c       channel_features[RedChannel].contrast[i]+=z*z*pixel.direction[i].red;
red               548 magick/fx.c          pixel.red=0.5*(GetPixelRed(p)+factor*quantum);
red               556 magick/fx.c          pixel.red=0.5*(pixel.red+factor*quantum);
red               559 magick/fx.c          SetPixelRed(q,ClampToQuantum(pixel.red));
red               745 magick/fx.c      pixel.red=geometry_info.rho;
red               792 magick/fx.c          SetPixelRed(q,((GetPixelRed(p)*(100.0-pixel.red)+
red               793 magick/fx.c            colorize.red*pixel.red)/100.0));
red              1489 magick/fx.c            case RedChannel: return(QuantumScale*pixel.red);
red              1626 magick/fx.c            return(QuantumScale*pixel.red);
red              1673 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red              1717 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red              1726 magick/fx.c              luma=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
red              1734 magick/fx.c              luminance=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
red              1787 magick/fx.c            return(QuantumScale*pixel.red);
red              1800 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red              3738 magick/fx.c            (u.red+v.red)/2.0,plasma));
red              3758 magick/fx.c                (u.red+v.red)/2.0,plasma));
red              3785 magick/fx.c                (u.red+v.red)/2.0,plasma));
red              3809 magick/fx.c                (u.red+v.red)/2.0,plasma));
red              3835 magick/fx.c            (u.red+v.red)/2.0,plasma));
red              4320 magick/fx.c          SetPixelRed(q,border_image->background_color.red);
red              4476 magick/fx.c          pixel.red=(MagickRealType) (QuantumRange*
red              4478 magick/fx.c          pixel.green=pixel.red;
red              4479 magick/fx.c          pixel.blue=pixel.red;
red              4481 magick/fx.c            pixel.index=pixel.red;
red              4605 magick/fx.c              if ((MagickRealType) image->colormap[i].red > threshold)
red              4606 magick/fx.c                image->colormap[i].red=QuantumRange-image->colormap[i].red;
red              5261 magick/fx.c      pixel.red=geometry_info.rho;
red              5265 magick/fx.c        pixel.green=pixel.red;
red              5269 magick/fx.c        pixel.blue=pixel.red;
red              5274 magick/fx.c      color_vector.red=(MagickRealType) (pixel.red*tint.red/100.0-
red              5321 magick/fx.c          pixel.red=(MagickRealType) GetPixelRed(p)+color_vector.red*(1.0-(4.0*
red              5323 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               101 magick/gem.c     assert(red != (Quantum *) NULL);
red               146 magick/gem.c     *red=ClampToQuantum(QuantumRange*(r+m));
red               195 magick/gem.c     assert(red != (Quantum *) NULL);
red               252 magick/gem.c     *red=ClampToQuantum(QuantumRange*(z*r+m));
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               399 magick/gem.c     assert(red != (Quantum *) NULL);
red               428 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
red               475 magick/gem.c     assert(red != (Quantum *) NULL);
red               538 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
red               585 magick/gem.c     assert(red != (Quantum *) NULL);
red               645 magick/gem.c     *red=ClampToQuantum(QuantumRange*r);
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               772 magick/gem.c     assert(red != (Quantum *) NULL);
red               776 magick/gem.c     ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               825 magick/gem.c     assert(red != (Quantum *) NULL);
red               829 magick/gem.c     ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               892 magick/gem.c     r=(double) red;
red               901 magick/gem.c       if (red == (Quantum) max)
red               959 magick/gem.c     r=(double) red;
red               968 magick/gem.c       if (red == (Quantum) max)
red              1029 magick/gem.c     r=(double) red;
red              1098 magick/gem.c     *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
red              1105 magick/gem.c     *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red              1107 magick/gem.c     alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
red              1156 magick/gem.c     max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
red              1158 magick/gem.c     min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red              1168 magick/gem.c     if (max == (QuantumScale*red))
red              1176 magick/gem.c         *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red              1178 magick/gem.c         *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red              1228 magick/gem.c     max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
red              1230 magick/gem.c     min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red              1240 magick/gem.c     if (max == (QuantumScale*red))
red              1248 magick/gem.c         *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red              1250 magick/gem.c         *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red              1301 magick/gem.c     r=(double) red;
red              1374 magick/gem.c     ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red              1435 magick/gem.c     ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               166 magick/histogram.c     ((ScaleQuantumToChar(ClampToQuantum(pixel->red)) >> index) & 0x01) |
red              1104 magick/histogram.c   if (color_2->pixel.red != color_1->pixel.red)
red              1105 magick/histogram.c     return((int) color_1->pixel.red-(int) color_2->pixel.red);
red              1730 magick/image.c       if ((pixel.red < 0.0) || (pixel.red > QuantumRange) ||
red              1731 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              2707 magick/morphology.c         result.red     =
red              2730 magick/morphology.c               result.red     += (*k)*GetPixelRed(k_pixels);
red              2741 magick/morphology.c               SetPixelRed(q,ClampToQuantum(result.red));
red              2775 magick/morphology.c               result.red     += alpha*GetPixelRed(k_pixels);
red              2788 magick/morphology.c             SetPixelRed(q,ClampToQuantum(gamma*result.red));
red              2797 magick/morphology.c         if (   ( p[r].red != GetPixelRed(q))
red              2908 magick/morphology.c       min.red     =
red              2913 magick/morphology.c       max.red     =
red              2919 magick/morphology.c       result.red     = (double) p[r].red;
red              2930 magick/morphology.c           result.red     =
red              2939 magick/morphology.c           result.red = 0.0;  /* result is not used otherwise */
red              2976 magick/morphology.c                     result.red     += (*k)*k_pixels[u].red;
red              2987 magick/morphology.c                   SetPixelRed(q,ClampToQuantum((MagickRealType) result.red));
red              3020 magick/morphology.c                     result.red     += alpha*k_pixels[u].red;
red              3033 magick/morphology.c                 SetPixelRed(q,ClampToQuantum((MagickRealType) (gamma*result.red)));
red              3058 magick/morphology.c                 Minimize(min.red,     (double) k_pixels[u].red);
red              3090 magick/morphology.c                 Maximize(max.red,     (double) k_pixels[u].red);
red              3126 magick/morphology.c                   Minimize(min.red,     (double) k_pixels[u].red);
red              3137 magick/morphology.c                   Maximize(max.red,     (double) k_pixels[u].red);
red              3151 magick/morphology.c             min.red     -= max.red;     Maximize( min.red,     0.0 );
red              3173 magick/morphology.c                 if ( result.red == 0.0 ||
red              3178 magick/morphology.c                   if ( result.red > 0.0 ) changes[id]++;
red              3179 magick/morphology.c                   result.red = 1.0;
red              3204 magick/morphology.c                 if ( result.red == 0.0 ||
red              3208 magick/morphology.c                   if ( result.red > 0.0 ) changes[id]++;
red              3209 magick/morphology.c                   result.red = 1.0;
red              3247 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3281 magick/morphology.c           result.red     -= min.red;
red              3289 magick/morphology.c           result.red     += min.red;
red              3308 magick/morphology.c             SetPixelRed(q,ClampToQuantum(result.red));
red              3322 magick/morphology.c       if (   ( p[r].red != GetPixelRed(q) )
red              3505 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3522 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3580 magick/morphology.c             SetPixelRed(q,ClampToQuantum(result.red));
red              3593 magick/morphology.c       if (   ( p[r].red != GetPixelRed(q) )
red              3697 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3714 magick/morphology.c                 Minimize(result.red,     (*k)+k_pixels[u].red);
red              3770 magick/morphology.c             SetPixelRed(q,ClampToQuantum(result.red));
red              3783 magick/morphology.c       if (   ( p[r].red != GetPixelRed(q) )
red               359 magick/paint.c             SetPixelRed(q,ClampToQuantum(fill.red));
red               862 magick/paint.c             SetPixelRed(q,ClampToQuantum(fill->red));
red              1140 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                49 magick/pixel-accessor.h #define GetPixelRed(pixel) ((pixel)->red)
red                52 magick/pixel-accessor.h   (packet)->red=GetPixelRed((pixel)); \
red                58 magick/pixel-accessor.h   (packet)->red=GetPixelRed((pixel)); \
red                63 magick/pixel-accessor.h #define GetPixelY(pixel) ((pixel)->red)
red                73 magick/pixel-accessor.h #define SetPixelCyan(pixel,value) ((pixel)->red=(Quantum) (value))
red                75 magick/pixel-accessor.h   ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
red                78 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               115 magick/pixel-accessor.h     return((MagickRealType) pixel->red);
red               116 magick/pixel-accessor.h   return(0.212656f*pixel->red+0.715158f*pixel->green+0.072186f*pixel->blue);
red               125 magick/pixel-accessor.h     red;
red               128 magick/pixel-accessor.h     return((MagickRealType) pixel->red);
red               130 magick/pixel-accessor.h     return(0.212656f*pixel->red+0.715158f*pixel->green+0.072186f*pixel->blue);
red               131 magick/pixel-accessor.h   red=DecodePixelGamma((MagickRealType) pixel->red);
red               134 magick/pixel-accessor.h   return(0.212656f*red+0.715158f*green+0.072186f*blue);
red               142 magick/pixel-accessor.h     red;
red               144 magick/pixel-accessor.h   red=(MagickRealType) pixel->red;
red               147 magick/pixel-accessor.h   if ((AbsolutePixelValue(red-green) < MagickEpsilon) &&
red               158 magick/pixel-accessor.h   if ((pixel->red  == pixel->green) && (pixel->green == pixel->blue))
red               159 magick/pixel-accessor.h     return(pixel->red);
red               160 magick/pixel-accessor.h   intensity=0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
red                95 magick/pixel-private.h   pixel->red=(MagickRealType) GetPixelRed(color);
red               110 magick/pixel-private.h   pixel->red=image->bias;
red               120 magick/pixel-private.h   SetPixelRed(color,ClampToQuantum(pixel->red));
red              2038 magick/pixel.c   pixel->red=0.0;
red              2113 magick/pixel.c     red;
red              2116 magick/pixel.c     return((MagickRealType) pixel->red);
red              2117 magick/pixel.c   red=(MagickRealType) pixel->red;
red              2124 magick/pixel.c       intensity=(red+green+blue)/3.0;
red              2129 magick/pixel.c       intensity=MagickMax(MagickMax(red,green),blue);
red              2134 magick/pixel.c       intensity=(MagickMin(MagickMin(red,green),blue)+
red              2135 magick/pixel.c         MagickMax(MagickMax(red,green),blue))/2.0;
red              2140 magick/pixel.c       intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
red              2148 magick/pixel.c           red=EncodePixelGamma(red);
red              2152 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2159 magick/pixel.c           red=DecodePixelGamma(red);
red              2163 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
red              2171 magick/pixel.c           red=EncodePixelGamma(red);
red              2175 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2182 magick/pixel.c           red=DecodePixelGamma(red);
red              2186 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
red              2191 magick/pixel.c       intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
red              4164 magick/pixel.c       pixel->red=(MagickRealType) GetPixelRed(color);
red              4176 magick/pixel.c   pixel->red=(*alpha*GetPixelRed(color));
red              4317 magick/pixel.c       pixel->red=0.0;
red              4327 magick/pixel.c         pixel->red+=gamma*pixels[0].red;
red              4334 magick/pixel.c       pixel->red*=gamma;
red              4373 magick/pixel.c       pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
red              4374 magick/pixel.c         pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
red              4416 magick/pixel.c               pixels[i].red+=pixels[i+2].red;
red              4433 magick/pixel.c             pixels[0].red+=pixels[1].red;
red              4441 magick/pixel.c       pixel->red=alpha[0]*pixels[0].red;
red              4467 magick/pixel.c       pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
red              4468 magick/pixel.c         pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
red              4469 magick/pixel.c         pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
red              4470 magick/pixel.c         pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
red              4471 magick/pixel.c         pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
red              4472 magick/pixel.c         pixels[14].red+cx[3]*pixels[15].red));
red              4582 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
red              4583 magick/pixel.c                 pixels[3].red,pixels[0].red);
red              4603 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
red              4604 magick/pixel.c                 pixels[0].red,pixels[3].red);
red              4629 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
red              4630 magick/pixel.c                 pixels[1].red,pixels[2].red);
red              4651 magick/pixel.c               pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
red              4652 magick/pixel.c                 pixels[2].red,pixels[1].red);
red              4698 magick/pixel.c       pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
red              4699 magick/pixel.c         pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
red              4700 magick/pixel.c         pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
red              4701 magick/pixel.c         pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
red              4702 magick/pixel.c         pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
red              4703 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              2091 magick/property.c           pixel.red=(MagickRealType) QuantumRange*alpha;
red               221 magick/quantize.c     red,
red               443 magick/quantize.c       alpha_pixel->red=(MagickRealType) GetPixelRed(pixel);
red               450 magick/quantize.c   alpha_pixel->red=alpha*GetPixelRed(pixel);
red               796 magick/quantize.c   midpoint.red=(MagickRealType) QuantumRange/2.0;
red               838 magick/quantize.c         mid.red+=(id & 1) != 0 ? bisect : -bisect;
red               859 magick/quantize.c         error.red=QuantumScale*(pixel.red-mid.red);
red               864 magick/quantize.c         node_info->quantize_error+=count*sqrt((double) (error.red*error.red+
red               874 magick/quantize.c       node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
red               928 magick/quantize.c         mid.red+=(id & 1) != 0 ? bisect : -bisect;
red               949 magick/quantize.c         error.red=QuantumScale*(pixel.red-mid.red);
red               954 magick/quantize.c         node_info->quantize_error+=count*sqrt((double) (error.red*error.red+
red               964 magick/quantize.c       node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
red              1232 magick/quantize.c             QuantumRange*node_info->total_color.red)));
red              1250 magick/quantize.c                 QuantumRange*node_info->total_color.red)));
red              1264 magick/quantize.c                 gamma*QuantumRange*node_info->total_color.red)));
red              1438 magick/quantize.c   offset=(ssize_t) (RedShift(ScaleQuantumToChar(ClampPixel(pixel->red))) |
red              1530 magick/quantize.c           pixel.red+=7*current[u-v].red/16;
red              1540 magick/quantize.c               pixel.red+=previous[u+v].red/16;
red              1546 magick/quantize.c           pixel.red+=5*previous[u].red/16;
red              1553 magick/quantize.c               pixel.red+=3*previous[u-v].red/16;
red              1560 magick/quantize.c       pixel.red=(MagickRealType) ClampPixel(pixel.red);
red              1612 magick/quantize.c       current[u].red=pixel.red-color.red;
red              1774 magick/quantize.c         pixel.red+=p->weights[i]*p->error[i].red;
red              1780 magick/quantize.c       pixel.red=(MagickRealType) ClampPixel(pixel.red);
red              1834 magick/quantize.c       p->error[ErrorQueueLength-1].red=pixel.red-color.red;
red              2183 magick/quantize.c       distance=fabs(alpha*GetPixelRed(p)-beta*image->colormap[index].red);
red              2341 magick/quantize.c         image->colormap[i].red=PosterizePixel(image->colormap[i].red);
red              2475 magick/quantize.c   parent->total_color.red+=node_info->total_color.red;
red              2654 magick/quantize.c       image->colormap[i].red=GetPixelRed(q);
red              3297 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               624 magick/resample.c         pixel->red   += weight*pixels->red;
red               665 magick/resample.c     pixel->opacity = pixel->red = pixel->green = pixel->blue = 0;
red               666 magick/resample.c     pixel->red = QuantumRange; /* show pixels for which EWA fails */
red               681 magick/resample.c   pixel->red   = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
red              1867 magick/resize.c     pixel.red=QuantumRange*(packet[0]/255.0);
red              2515 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2520 magick/resize.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red              2548 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2555 magick/resize.c           SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              2756 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2761 magick/resize.c           SetPixelRed(q,ClampToQuantum(pixel.red));
red              2789 magick/resize.c             pixel.red+=alpha*GetPixelRed(p+j);
red              2796 magick/resize.c           SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red              3313 magick/resize.c           x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red              3348 magick/resize.c                 x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red              3362 magick/resize.c             y_vector[x].red+=scale.y*x_vector[x].red;
red              3391 magick/resize.c               x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red              3407 magick/resize.c           pixel.red=y_vector[x].red+span.y*x_vector[x].red;
red              3414 magick/resize.c           s->red=pixel.red;
red              3443 magick/resize.c           SetPixelRed(q,ClampToQuantum(alpha*s->red));
red              3474 magick/resize.c             pixel.red+=span.x*s->red;
red              3481 magick/resize.c             t->red=pixel.red;
red              3500 magick/resize.c             pixel.red+=scale.x*s->red;
red              3514 magick/resize.c           pixel.red+=span.x*s->red;
red              3525 magick/resize.c           t->red=pixel.red;
red              3542 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               966 magick/segment.c     red;
red              1028 magick/segment.c   (void) ResetMagickMemory(&red,0,sizeof(red));
red              1031 magick/segment.c   while (DefineRegion(extrema[Red],&red) != 0)
red              1064 magick/segment.c         cluster->red=red;
red              1087 magick/segment.c       cluster->red=red;
red              1106 magick/segment.c              (cluster->red.left-SafeMargin)) &&
red              1108 magick/segment.c              (cluster->red.right+SafeMargin)) &&
red              1122 magick/segment.c             cluster->red.center+=(MagickRealType)
red              1154 magick/segment.c         cluster->red.center/=cluster->count;
red              1189 magick/segment.c   threshold=(background->red.center+object->red.center)/2.0;
red              1190 magick/segment.c   pixel->red=(MagickRealType) ScaleCharToQuantum((unsigned char)
red               812 magick/shear.c       background.red+=QuantumScale*GetPixelRed(p);
red               821 magick/shear.c   image->background_color.red=ClampToQuantum((MagickRealType) QuantumRange*
red               822 magick/shear.c     background.red/count);
red               558 magick/statistic.c             evaluate_pixel[i].red=ApplyEvaluateOperator(random_info[id],
red               559 magick/statistic.c               GetPixelRed(p),op,evaluate_pixel[i].red);
red               574 magick/statistic.c           SetPixelRed(q,ClampToQuantum(evaluate_pixel[i/2].red));
red               665 magick/statistic.c             evaluate_pixel[x].red=ApplyEvaluateOperator(random_info[id],
red               667 magick/statistic.c               evaluate_pixel[x].red);
red               689 magick/statistic.c             evaluate_pixel[x].red/=number_images;
red               703 magick/statistic.c               evaluate_pixel[x].red*=(MagickRealType) QuantumScale;
red               712 magick/statistic.c           SetPixelRed(q,ClampToQuantum(evaluate_pixel[x].red));
red              1527 magick/statistic.c           if (pixel.red < *minima)
red              1528 magick/statistic.c             *minima=(double) pixel.red;
red              1529 magick/statistic.c           if (pixel.red > *maxima)
red              1530 magick/statistic.c             *maxima=(double) pixel.red;
red              2053 magick/statistic.c         polynomial_pixel[x].red+=coefficient*pow(QuantumScale*p->red,degree);
red              2069 magick/statistic.c       SetPixelRed(q,ClampToQuantum(QuantumRange*polynomial_pixel[x].red));
red              2352 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2397 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2437 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2480 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2528 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2577 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2631 magick/statistic.c   pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red              2868 magick/statistic.c           pixel.red=MagickAbsoluteValue(maximum.red-minimum.red);
red              2914 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              1489 magick/threshold.c     levels.red     = ((channel & RedChannel  )   != 0) ? levels.index : 0;
red              1501 magick/threshold.c         levels.red = (unsigned int) strtoul(p, &p, 10),   (void)(*p == ',' && p++);
red              1527 magick/threshold.c      levels.red, levels.green, levels.blue, levels.opacity, levels.index);
red              1538 magick/threshold.c     levels.red     = levels.red     ? levels.red-1     : 0;
red              1600 magick/threshold.c         if (levels.red) {
red              1601 magick/threshold.c           t = (ssize_t) (QuantumScale*GetPixelRed(q)*(levels.red*d+1));
red              1604 magick/threshold.c             ((l+(t >= threshold))*(MagickRealType) QuantumRange/levels.red)));
red              2067 magick/threshold.c             threshold.red=min_threshold;
red              2070 magick/threshold.c               threshold.red=max_threshold;
red              2072 magick/threshold.c               threshold.red=(MagickRealType) (QuantumRange*
red              2121 magick/threshold.c         SetPixelRed(q,(MagickRealType) GetPixelRed(q) <= threshold.red ?
red              2239 magick/threshold.c   threshold.red=geometry_info.rho;
red              2242 magick/threshold.c     threshold.green=threshold.red;
red              2245 magick/threshold.c     threshold.blue=threshold.red;
red              2248 magick/threshold.c     threshold.opacity=threshold.red;
red              2251 magick/threshold.c     threshold.index=threshold.red;
red              2254 magick/threshold.c       threshold.red*=(MagickRealType) (QuantumRange/100.0);
red              2296 magick/threshold.c           ((MagickRealType) GetPixelRed(q) > threshold.red))
red              2107 magick/widget.c           windows->widget.pixel_info->matte_color.red,
red               596 magick/xwindow-private.h   if ((pixel->red  == pixel->green) && (pixel->green == pixel->blue))
red               597 magick/xwindow-private.h     return((MagickRealType) pixel->red);
red               598 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              1064 magick/xwindow.c     pixel.red=colors[i].red-(MagickRealType) color->red;
red              1065 magick/xwindow.c     distance=pixel.red*pixel.red;
red              2212 magick/xwindow.c       color.red=ClampToQuantum((MagickRealType) (red_map[i][j][(int)
red              2218 magick/xwindow.c       pixel=(size_t) (((size_t) color.red & 0xe0) |
red              2489 magick/xwindow.c           SetPixelRed(q,ScaleShortToQuantum(pixel->pen_color.red));
red              3112 magick/xwindow.c   pixel->highlight_color.red=(unsigned short) ((
red              3113 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(HighlightModulate))/65535L+
red              3127 magick/xwindow.c   pixel->shadow_color.red=(unsigned short) (((MagickRealType)
red              3128 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(ShadowModulate))/65535L);
red              3138 magick/xwindow.c   pixel->depth_color.red=(unsigned short) (((MagickRealType)
red              3139 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(DepthModulate))/65535L);
red              3149 magick/xwindow.c   pixel->trough_color.red=(unsigned short) (((MagickRealType)
red              3150 magick/xwindow.c     pixel->matte_color.red*ScaleQuantumToShort(TroughModulate))/65535L);
red              3898 magick/xwindow.c   pixel.red=ScaleShortToQuantum(color.red);
red              4258 magick/xwindow.c                       red,
red              4264 magick/xwindow.c                     red=0;
red              4275 magick/xwindow.c                       colors[i].pixel=(unsigned long) (red | green | blue);
red              4277 magick/xwindow.c                       red+=red_bit;
red              4278 magick/xwindow.c                       if (red > window_info[id].visual->red_mask)
red              4279 magick/xwindow.c                         red=0;
red              4379 magick/xwindow.c                     colors[index].red));
red              4433 magick/xwindow.c               composite_image->colormap[colors[i].pixel].red=
red              4434 magick/xwindow.c                 ScaleShortToQuantum(colors[i].red);
red              7609 magick/xwindow.c   intensity=0.298839*pixel->red+0.586811*pixel->green+0.114350*pixel->blue;
red              7820 magick/xwindow.c         color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
red              7826 magick/xwindow.c             color.red=gray_value;
red              7907 magick/xwindow.c             diversity[i].red=image->colormap[i].red;
red              7952 magick/xwindow.c             color.red=
red              7953 magick/xwindow.c               ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
red              7961 magick/xwindow.c                 color.red=gray_value;
red              7989 magick/xwindow.c             color.red=
red              7990 magick/xwindow.c               ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
red              7998 magick/xwindow.c                 color.red=gray_value;
red              8081 magick/xwindow.c         color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
red              8087 magick/xwindow.c             color.red=gray_value;
red              8137 magick/xwindow.c           color.red=color.blue;
red              8144 magick/xwindow.c           color.red=(unsigned short) 0;
red              8146 magick/xwindow.c             color.red=(unsigned short) ((size_t)
red              8184 magick/xwindow.c           pixel->background_color.red=(~pixel->foreground_color.red);
red              8602 magick/xwindow.c   color->red=0;
red              8624 magick/xwindow.c       color->red=xcolor.red;
red              9083 magick/xwindow.c   pixel.pen_color.red=ScaleQuantumToShort(draw_info->fill.red);
red               106 tests/validate.c   r=QuantumScale*DecodePixelGamma(red);
red               147 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               190 tests/validate.c   *red=ClampToQuantum(EncodePixelGamma(QuantumRange*r));
red               204 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
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               218 tests/validate.c   ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
red               224 tests/validate.c   *red=ClampToQuantum(QuantumRange*(0.99999999999914679361*Y-
red               235 tests/validate.c   ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
red               276 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               295 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               339 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red               366 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
red               372 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               373 tests/validate.c   *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
red               374 tests/validate.c   *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
red               380 tests/validate.c   *red=ClampToQuantum(QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
red               391 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               392 tests/validate.c   *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
red               393 tests/validate.c   *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
red               399 tests/validate.c   *red=ClampToQuantum(QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
red               410 tests/validate.c   *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red               411 tests/validate.c   *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
red               412 tests/validate.c   *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
red               418 tests/validate.c   *red=ClampToQuantum(QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
red               406 wand/drawing-wand.c       pixel.red=(MagickRealType) GetPixelRed(color);
red              2422 wand/drawing-wand.c   pixel->red=(MagickRealType) GetPixelRed(color);
red               580 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              2234 wand/pixel-wand.c   wand->pixel.red=(MagickRealType) ClampToQuantum((MagickRealType)
red              2235 wand/pixel-wand.c     QuantumRange*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);