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);