red 200 Magick++/lib/Color.cpp redQuantum( target_color.red );
red 231 Magick++/lib/Color.cpp pixel.red=_pixel->red;
red 336 Magick++/lib/Color.cpp red;
red 338 Magick++/lib/Color.cpp ConvertHSLToRGB(hue_,saturation_,luminosity_,&red,&green,&blue);
red 340 Magick++/lib/Color.cpp redQuantum(red);
red 366 Magick++/lib/Color.cpp red;
red 373 Magick++/lib/Color.cpp ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
red 375 Magick++/lib/Color.cpp redQuantum(red);
red 403 Magick++/lib/Color.cpp red;
red 410 Magick++/lib/Color.cpp ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
red 412 Magick++/lib/Color.cpp redQuantum(red);
red 440 Magick++/lib/Color.cpp red;
red 447 Magick++/lib/Color.cpp ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
red 449 Magick++/lib/Color.cpp redQuantum(red);
red 1127 Magick++/lib/Image.cpp return(Color(constImage()->matte_color.red,constImage()->matte_color.green,
red 2923 Magick++/lib/Image.cpp target.red=pixel.red;
red 2951 Magick++/lib/Image.cpp target.red=pixel.red;
red 3340 Magick++/lib/Image.cpp black.red=pixel.red;
red 3347 Magick++/lib/Image.cpp white.red=pixel.red;
red 3371 Magick++/lib/Image.cpp black.red=pixel.red;
red 3378 Magick++/lib/Image.cpp white.red=pixel.red;
red 4444 Magick++/lib/Image.cpp statistics->red.minimum=minimum;
red 4445 Magick++/lib/Image.cpp statistics->red.maximum=maximum;
red 4446 Magick++/lib/Image.cpp (void) GetImageChannelMean(constImage(),RedChannel,&statistics->red.mean,
red 4447 Magick++/lib/Image.cpp &statistics->red.standard_deviation,exceptionInfo);
red 4449 Magick++/lib/Image.cpp &statistics->red.kurtosis,&statistics->red.skewness,exceptionInfo);
red 5062 Magick++/lib/Image.cpp target.red=target_->red;
red 110 Magick++/lib/Magick++/Color.h return (0.299*(_pixel->red)+0.587*(_pixel->green)+0.114*(_pixel->blue));
red 319 Magick++/lib/Magick++/Color.h void red(double red_);
red 320 Magick++/lib/Magick++/Color.h double red(void) const;
red 425 Magick++/lib/Magick++/Color.h _pixel->red=red_;
red 431 Magick++/lib/Magick++/Color.h return _pixel->red;
red 436 Magick++/lib/Magick++/Color.h _pixel->red=0;
red 80 Magick++/lib/Magick++/Image.h ImageChannelStatistics red;
red 34 Magick++/tests/color.cpp double red;
red 57 Magick++/tests/color.cpp ColorRGB colorMatch( colorMap[i].red,
red 526 coders/bmp.c red;
red 904 coders/bmp.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 1020 coders/bmp.c while (((bmp_info.red_mask << shift.red) & 0x80000000UL) == 0)
red 1021 coders/bmp.c shift.red++;
red 1031 coders/bmp.c sample=shift.red;
red 1034 coders/bmp.c quantum_bits.red=ClampToQuantum((MagickRealType) sample-shift.red);
red 1210 coders/bmp.c red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
red 1211 coders/bmp.c if (quantum_bits.red == 5)
red 1212 coders/bmp.c red|=((red & 0xe000) >> 5);
red 1213 coders/bmp.c if (quantum_bits.red <= 8)
red 1214 coders/bmp.c red|=((red & 0xff00) >> 8);
red 1227 coders/bmp.c SetPixelRed(q,ScaleShortToQuantum((unsigned short) red));
red 1315 coders/bmp.c red=((pixel & bmp_info.red_mask) << shift.red) >> 16;
red 1316 coders/bmp.c if (quantum_bits.red == 8)
red 1317 coders/bmp.c red|=(red >> 8);
red 1324 coders/bmp.c SetPixelRed(q,ScaleShortToQuantum((unsigned short) red));
red 2122 coders/bmp.c *q++=ScaleQuantumToChar(image->colormap[i].red);
red 460 coders/cut.c image->colormap[i].red=(Quantum) ReadBlobLSBShort(palette);
red 463 coders/cut.c image->colormap[i].red=ClampToQuantum(((double)
red 464 coders/cut.c image->colormap[i].red*QuantumRange+(PalHeader.MaxRed>>1))/
red 498 coders/cut.c image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
red 570 coders/cut.c if(image->colormap[i].red!=sample) goto Finish;
red 575 coders/cut.c image->colormap[1].red=image->colormap[1].green=
red 3705 coders/dcm.c image->colormap[i].red=(Quantum) index;
red 3729 coders/dcm.c image->colormap[i].red=(Quantum) index;
red 3905 coders/dcm.c pixel.red=1U*image->colormap[index].red;
red 3913 coders/dcm.c pixel.red=(unsigned int) ReadDCMByte(stream_info,image);
red 3919 coders/dcm.c pixel.red=ReadDCMShort(stream_info,image);
red 3923 coders/dcm.c pixel.red&=mask;
red 3928 coders/dcm.c pixel.red=scale[pixel.red];
red 3933 coders/dcm.c SetPixelRed(q,pixel.red);
red 4017 coders/dcm.c pixel.red=1U*image->colormap[index].red;
red 4025 coders/dcm.c pixel.red=(unsigned int) ReadDCMByte(stream_info,image);
red 4031 coders/dcm.c pixel.red=ReadDCMShort(stream_info,image);
red 4035 coders/dcm.c pixel.red&=mask;
red 4040 coders/dcm.c pixel.red=scale[pixel.red];
red 4046 coders/dcm.c (((size_t) pixel.red) << 8)));
red 233 coders/debug.c (double) pixel.red,(double) pixel.green,(double) pixel.blue);
red 632 coders/dib.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 1293 coders/dib.c *q++=ScaleQuantumToChar(image->colormap[i].red);
red 732 coders/djvu.c image->colormap[0].red=QuantumRange;
red 735 coders/djvu.c image->colormap[1].red=0;
red 282 coders/dps.c red,
red 288 coders/dps.c red=0;
red 296 coders/dps.c colors[i].pixel=red | green | blue;
red 298 coders/dps.c red+=red_bit;
red 299 coders/dps.c if (red > visual_info->red_mask)
red 300 coders/dps.c red=0;
red 384 coders/dps.c SetPixelRed(q,ScaleShortToQuantum(colors[index].red));
red 441 coders/dps.c image->colormap[colors[i].pixel].red=ScaleShortToQuantum(colors[i].red);
red 606 coders/emf.c pBits->rgbRed=ScaleQuantumToChar(image->background_color.red);
red 740 coders/emf.c image->background_color.red),(BYTE) ScaleQuantumToChar(
red 170 coders/fax.c image->colormap[0].red=QuantumRange;
red 173 coders/fax.c image->colormap[1].red=(Quantum) 0;
red 660 coders/fpx.c red=sqrt((double) red)-1.0;
red 665 coders/fpx.c red_effect.byc2=0.299*red;
red 667 coders/fpx.c red_effect.bc1y=(-0.299)*red;
red 668 coders/fpx.c red_effect.bc1c1=1.0-0.299*red;
red 669 coders/fpx.c red_effect.bc1c2=(-0.299)*red;
red 671 coders/fpx.c red_effect.bc2y=0.701*red;
red 673 coders/fpx.c red_effect.bc2c2=1.0+0.402*red;
red 1292 coders/gif.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 1332 coders/gif.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 1641 coders/gif.c image->colormap[opacity].red=image->transparent_color.red;
red 1654 coders/gif.c *q++=ScaleQuantumToChar(image->colormap[i].red);
red 139 coders/hald.c red;
red 155 coders/hald.c for (red=0; red < (ssize_t) cube_size; red++)
red 158 coders/hald.c (QuantumRange*red/(cube_size-1.0))));
red 269 coders/histogram.c histogram[ScaleQuantumToChar(GetPixelRed(p))].red++;
red 277 coders/histogram.c maximum=histogram[0].red;
red 280 coders/histogram.c if (((channel & RedChannel) != 0) && (maximum < histogram[x].red))
red 281 coders/histogram.c maximum=histogram[x].red;
red 304 coders/histogram.c y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].red-0.5);
red 467 coders/icon.c image->colormap[i].red=(Quantum) ScaleCharToQuantum(*p++);
red 1296 coders/icon.c *q++=ScaleQuantumToChar(next->colormap[i].red);
red 219 coders/jbig.c image->colormap[0].red=0;
red 222 coders/jbig.c image->colormap[1].red=QuantumRange;
red 466 coders/jp2.c q->red=ClampToQuantum(pixel);
red 467 coders/jp2.c q->green=q->red;
red 468 coders/jp2.c q->blue=q->red;
red 1010 coders/jp2.c *q=(int) (scale*p->red);
red 1307 coders/jpeg.c image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
red 1308 coders/jpeg.c image->colormap[i].green=image->colormap[i].red;
red 1309 coders/jpeg.c image->colormap[i].blue=image->colormap[i].red;
red 1315 coders/jpeg.c image->colormap[i].red=ScaleCharToQuantum(jpeg_info.colormap[0][i]);
red 584 coders/json.c match=fabs((double) (p->red-target)) < 0.5 ? MagickTrue : MagickFalse;
red 186 coders/map.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 195 coders/map.c image->colormap[i].red=(Quantum) quantum;
red 407 coders/map.c *q++=(unsigned char) image->colormap[i].red;
red 414 coders/map.c *q++=(unsigned char) ((size_t) image->colormap[i].red >> 8);
red 415 coders/map.c *q++=(unsigned char) image->colormap[i].red;
red 1186 coders/miff.c image->colormap[i].red=ScaleCharToQuantum(pixel);
red 1202 coders/miff.c image->colormap[i].red=ScaleShortToQuantum(pixel);
red 1218 coders/miff.c image->colormap[i].red=ScaleLongToQuantum(pixel);
red 1510 coders/miff.c SetPixelRed(q,pixel.red);
red 1823 coders/miff.c value=ScaleQuantumToLong(pixel.red);
red 1849 coders/miff.c value=ScaleQuantumToShort(pixel.red);
red 1875 coders/miff.c value=(unsigned char) ScaleQuantumToChar(pixel.red);
red 2348 coders/miff.c pixel=ScaleQuantumToLong(image->colormap[i].red);
red 2361 coders/miff.c pixel=ScaleQuantumToShort(image->colormap[i].red);
red 2374 coders/miff.c pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
red 880 coders/mpc.c image->colormap[i].red=ScaleCharToQuantum(pixel);
red 896 coders/mpc.c image->colormap[i].red=ScaleShortToQuantum(pixel);
red 912 coders/mpc.c image->colormap[i].red=ScaleLongToQuantum(pixel);
red 1415 coders/mpc.c pixel=ScaleQuantumToLong(image->colormap[i].red);
red 1428 coders/mpc.c pixel=ScaleQuantumToShort(image->colormap[i].red);
red 1441 coders/mpc.c pixel=(unsigned char) ScaleQuantumToChar(image->colormap[i].red);
red 3163 coders/msl.c pixel.red=0.0;
red 3226 coders/msl.c pixel.red=StringToDouble(value,(char **) NULL);
red 3243 coders/msl.c (double) pixel.red,(double) pixel.green,(double) pixel.blue);
red 3253 coders/msl.c (void) GammaImageChannel(msl_info->image[n],RedChannel,pixel.red);
red 360 coders/palm.c transpix.red=(MagickRealType) (QuantumRange*ReadBlobByte(image)/31);
red 376 coders/palm.c image->colormap[(int) index].red=ScaleCharToQuantum(
red 388 coders/palm.c image->colormap[(int) index].red=ScaleCharToQuantum(
red 748 coders/palm.c transpix.red=0;
red 824 coders/palm.c image->colormap[count].red));
red 882 coders/palm.c transpix.red=GetPixelRed(p);
red 968 coders/palm.c (void) WriteBlobByte(image,(unsigned char) ((31*transpix.red)/QuantumRange));
red 401 coders/pango.c cairo_set_source_rgba(cairo_image,QuantumScale*draw_info->fill.red,
red 432 coders/pango.c fill_color.red=ScaleCharToQuantum(*p++);
red 441 coders/pango.c fill_color.red*=gamma;
red 769 coders/pcl.c ScaleQuantumToChar(image->colormap[i].red),
red 372 coders/pcx.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 464 coders/pcx.c image->colormap[0].red=(Quantum) 0;
red 467 coders/pcx.c image->colormap[1].red=QuantumRange;
red 482 coders/pcx.c image->colormap[i].red=ScaleCharToQuantum(*p++);
red 987 coders/pcx.c *q++=ScaleQuantumToChar(image->colormap[i].red);
red 2479 coders/pdf.c Ascii85Encode(image,ScaleQuantumToChar(image->colormap[i].red));
red 2485 coders/pdf.c ScaleQuantumToChar(image->colormap[i].red));
red 83 coders/pes.c red,
red 640 coders/pes.c "fill=\"none\" d=\"M %g %g",blocks[i].color->red,blocks[i].color->green,
red 1061 coders/pict.c image->background_color.red=(Quantum)
red 1173 coders/pict.c tile_image->colormap[j].red=(Quantum)
red 1185 coders/pict.c tile_image->colormap[i].red=(Quantum) (QuantumRange-
red 1186 coders/pict.c tile_image->colormap[i].red);
red 1241 coders/pict.c tile_image->colormap[(ssize_t) index].red);
red 1932 coders/pict.c image->colormap[i].red));
red 1988 coders/pict.c *red;
red 1990 coders/pict.c red=scanline;
red 1999 coders/pict.c red=scanline;
red 2005 coders/pict.c red=scanline+image->columns;
red 2011 coders/pict.c *red++=ScaleQuantumToChar(GetPixelRed(p));
red 103 coders/pix.c red;
red 173 coders/pix.c red=(Quantum) 0;
red 195 coders/pix.c red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red 202 coders/pix.c SetPixelRed(q,red);
red 125 coders/png.c (((color).red == (target).red) && \
red 180 coders/png.c (pixelpacket).red=(ScaleQuantumToChar((pixelpacket).red) < 0x10 ? \
red 245 coders/png.c unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red) & 0xc0; \
red 246 coders/png.c (pixelpacket).red=ScaleCharToQuantum( \
red 328 coders/png.c unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red) & 0xe0; \
red 329 coders/png.c (pixelpacket).red=ScaleCharToQuantum( \
red 385 coders/png.c unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).red) & 0xf0; \
red 386 coders/png.c (pixelpacket).red=ScaleCharToQuantum((lbr_bits | (lbr_bits >> 4))); \
red 865 coders/png.c QuantumToCharToQuantumEqQuantum(image->background_color.red) &&
red 878 coders/png.c image->colormap[indx].red) &&
red 1486 coders/png.c if ((a->colormap[i].red != b->colormap[i].red) ||
red 2079 coders/png.c transparent_color.red=65537;
red 2723 coders/png.c background.red=(png_uint_16)
red 2724 coders/png.c mng_info->global_plte[background.index].red;
red 2773 coders/png.c ping_background->red *= bkgd_scale;
red 2783 coders/png.c ping_background->red,ping_background->green,
red 2785 coders/png.c bkgd_scale,ping_background->red,
red 2789 coders/png.c image->background_color.red=
red 2790 coders/png.c ScaleShortToQuantum(ping_background->red);
red 2803 coders/png.c (double) image->background_color.red,
red 2829 coders/png.c ((int)ping_trans_color->red > max_sample ||
red 2848 coders/png.c transparent_color.red= scale_to_short*ping_trans_color->red;
red 2861 coders/png.c transparent_color.red=transparent_color.opacity;
red 2951 coders/png.c image->colormap[i].red=ScaleCharToQuantum(palette[i].red);
red 2958 coders/png.c image->colormap[i].red=0;
red 2977 coders/png.c image->colormap[i].red=(Quantum) (i*scale);
red 3181 coders/png.c == transparent_color.red &&
red 3465 coders/png.c if (ScaleQuantumToShort(image->colormap[x].red) ==
red 3496 coders/png.c == transparent_color.red &&
red 4404 coders/png.c image->background_color.red=ScaleCharToQuantum(p[1]);
red 4405 coders/png.c image->background_color.green=image->background_color.red;
red 4406 coders/png.c image->background_color.blue=image->background_color.red;
red 4411 coders/png.c image->background_color.red=ScaleCharToQuantum(p[1]);
red 5273 coders/png.c mng_info->mng_global_bkgd.red=
red 5299 coders/png.c mng_background_color.red=
red 5332 coders/png.c mng_info->global_plte[i].red=p[3*i];
red 5342 coders/png.c mng_info->global_plte[i].red=i;
red 6004 coders/png.c mng_info->global_sbit.red=p[0];
red 7952 coders/png.c ping_background.red = 0;
red 7958 coders/png.c ping_trans_color.red=0;
red 8412 coders/png.c (int) image->colormap[i].red,
red 8425 coders/png.c (int) image->colormap[i].red,
red 8495 coders/png.c ping_trans_color.red=
red 8560 coders/png.c (int) image->background_color.red,
red 8566 coders/png.c if (opaque[i].red == image->background_color.red &&
red 8700 coders/png.c if (colormap[i].red != colormap[i].green ||
red 8701 coders/png.c colormap[i].red != colormap[i].blue)
red 8711 coders/png.c if (colormap[i].red != 0 && colormap[i].red != QuantumRange)
red 8772 coders/png.c image->colormap[i].red ==
red 8809 coders/png.c (int) image->colormap[i].red,
red 9084 coders/png.c if (ScaleQuantumToChar(image->background_color.red) == 0x49 &&
red 9088 coders/png.c image->background_color.red=ScaleCharToQuantum(0x24);
red 9127 coders/png.c if (ScaleQuantumToChar(image->colormap[i].red) == 0x49 &&
red 9131 coders/png.c image->colormap[i].red=ScaleCharToQuantum(0x24);
red 9198 coders/png.c ping_trans_color.red &&
red 9222 coders/png.c if (image->colormap[i].red == image->colormap[0].red &&
red 9463 coders/png.c ping_background.red=(png_uint_16)
red 9464 coders/png.c (ScaleQuantumToShort(image->background_color.red) & mask);
red 9517 coders/png.c palette[i].red=ScaleQuantumToChar(image->colormap[i].red);
red 9527 coders/png.c (long) i,palette[i].red,palette[i].green,palette[i].blue);
red 9795 coders/png.c ping_trans_color.red=(png_uint_16)
red 9796 coders/png.c (ScaleQuantumToShort(image->colormap[0].red) & mask);
red 9830 coders/png.c ping_trans_color.red&=0xff;
red 9841 coders/png.c ping_trans_color.red&=0xff;
red 9920 coders/png.c intensity=ScaleQuantumToChar(image->colormap[i].red);
red 9961 coders/png.c palette[i].red=ScaleQuantumToChar(image->colormap[i].red);
red 10033 coders/png.c (int) ping_trans_color.red,
red 10038 coders/png.c ping_trans_color.red*=0x0101;
red 10047 coders/png.c (int) ping_trans_color.red,
red 10135 coders/png.c (int) ping_background.red,
red 10429 coders/png.c (int) palette[i].red,
red 10438 coders/png.c (int) palette[i].red,
red 10592 coders/png.c (int) ping_background.red,
red 10708 coders/png.c (int) ping_trans_color.red,
red 12370 coders/png.c red;
red 12382 coders/png.c red=ScaleQuantumToChar(image->background_color.red);
red 12386 coders/png.c *(chunk+5)=red;
red 12938 coders/png.c red,
red 13015 coders/png.c if (next_image->background_color.red !=
red 13016 coders/png.c next_image->next->background_color.red ||
red 13362 coders/png.c red=ScaleQuantumToShort(image->background_color.red);
red 13365 coders/png.c PNGShort(chunk+4,red);
red 13398 coders/png.c chunk[4+i*3]=ScaleQuantumToChar(image->colormap[i].red) & 0xff;
red 13450 coders/png.c chunk[4+i*3]=ScaleQuantumToChar(image->colormap[i].red);
red 1182 coders/ps.c q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.red),q); \
red 2043 coders/ps.c if ((GetPixelRed(p) == pixel.red) &&
red 2164 coders/ps.c ScaleQuantumToChar(image->colormap[i].red),
red 2209 coders/ps.c pixel.red=GetPixelRed(p);
red 1019 coders/ps2.c ScaleQuantumToChar(image->colormap[i].red),
red 1511 coders/ps3.c pixel=ScaleQuantumToChar(image->colormap[i].red);
red 1524 coders/ps3.c pixel=ScaleQuantumToChar(image->colormap[i].red);
red 1116 coders/psd.c color.red=layer_info->mask.background == 0 ? 0 : QuantumRange;
red 1117 coders/psd.c color.green=color.red;
red 1118 coders/psd.c color.blue=color.red;
red 1119 coders/psd.c color.index=color.red;
red 1766 coders/psd.c image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red 2595 coders/psd.c (void) WriteBlobByte(image,ScaleQuantumToChar(image->colormap[i].red));
red 164 coders/rgf.c image->colormap[0].red=QuantumRange;
red 167 coders/rgf.c image->colormap[1].red=(Quantum) 0;
red 536 coders/rle.c image->colormap[i].red=ScaleCharToQuantum((unsigned char) i);
red 544 coders/rle.c image->colormap[i].red=ScaleCharToQuantum(*p);
red 590 coders/rle.c SetPixelRed(q,image->colormap[(ssize_t) index].red);
red 1044 coders/sixel.c image->colormap[i].red = ScaleCharToQuantum(sixel_palette[i * 4 + 0]);
red 1275 coders/sixel.c image->colormap[opacity].red=image->transparent_color.red;
red 1285 coders/sixel.c sixel_palette[i * 3 + 0] = ScaleQuantumToChar(image->colormap[i].red);
red 195 coders/stegano.c SetBit(indexes,i,GetBit(pixel.red,j));
red 362 coders/sun.c image->colormap[i].red=ScaleCharToQuantum(sun_colormap[i]);
red 543 coders/sun.c GetPixelRed(q)].red);
red 930 coders/sun.c image->colormap[i].red));
red 2845 coders/svg.c 100.0*QuantumScale*image->background_color.red,
red 3039 coders/svg.c fill_color.red=ScaleCharToQuantum(*p++);
red 3041 coders/svg.c fill_color.red=ScaleCharToQuantum(*p++);
red 3055 coders/svg.c fill_color.red*=gamma;
red 334 coders/tga.c pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red 335 coders/tga.c pixel.green=pixel.red;
red 336 coders/tga.c pixel.blue=pixel.red;
red 351 coders/tga.c pixel.red=ScaleAnyToQuantum(1UL*(k & 0x7c) >> 2,range);
red 364 coders/tga.c pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red 374 coders/tga.c pixel.red=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
red 439 coders/tga.c pixel.red=ScaleCharToQuantum((unsigned char) index);
red 459 coders/tga.c pixel.red=ScaleAnyToQuantum(1UL*(k & 0x7c) >> 2,range);
red 479 coders/tga.c pixel.red=ScaleCharToQuantum(pixels[2]);
red 491 coders/tga.c pixel.red=ScaleCharToQuantum(pixels[2]);
red 501 coders/tga.c SetPixelRed(q,pixel.red);
red 850 coders/tga.c ((unsigned char) ScaleQuantumToAny(image->colormap[i].red,
red 857 coders/tga.c *q++=ScaleQuantumToChar(image->colormap[i].red);
red 1497 coders/tiff.c image->colormap[i].red=ClampToQuantum(((double)
red 3771 coders/tiff.c *red;
red 3776 coders/tiff.c red=(uint16 *) AcquireQuantumMemory(65536,sizeof(*red));
red 3779 coders/tiff.c if ((red == (uint16 *) NULL) || (green == (uint16 *) NULL) ||
red 3785 coders/tiff.c (void) ResetMagickMemory(red,0,65536*sizeof(*red));
red 3790 coders/tiff.c red[i]=ScaleQuantumToShort(image->colormap[i].red);
red 3794 coders/tiff.c (void) TIFFSetField(tiff,TIFFTAG_COLORMAP,red,green,blue);
red 3795 coders/tiff.c red=(uint16 *) RelinquishMagickMemory(red);
red 218 coders/tim.c image->colormap[i].red=ScaleCharToQuantum(
red 474 coders/txt.c red;
red 476 coders/txt.c red=0.0;
red 492 coders/txt.c &y_offset,&red,&opacity);
red 493 coders/txt.c green=red;
red 494 coders/txt.c blue=red;
red 497 coders/txt.c (void) sscanf(text,"%ld,%ld: (%lf%*[%,]",&x_offset,&y_offset,&red);
red 498 coders/txt.c green=red;
red 499 coders/txt.c blue=red;
red 508 coders/txt.c &x_offset,&y_offset,&red,&green,&blue,&index,&opacity);
red 513 coders/txt.c &y_offset,&red,&green,&blue,&index);
red 522 coders/txt.c &x_offset,&y_offset,&red,&green,&blue,&opacity);
red 526 coders/txt.c &x_offset,&y_offset,&red,&green,&blue);
red 532 coders/txt.c red*=0.01*range;
red 543 coders/txt.c pixel.red=ScaleAnyToQuantum((QuantumAny) (red+0.5),range);
red 551 coders/txt.c SetPixelRed(q,pixel.red);
red 351 coders/uyvy.c (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.red));
red 356 coders/uyvy.c pixel.red=(double) GetPixelRed(p);
red 452 coders/viff.c image->colormap[i].red=ScaleCharToQuantum((unsigned char) value);
red 699 coders/viff.c ConstrainColormapIndex(image,index)].red);
red 1131 coders/viff.c *q++=ScaleQuantumToChar(image->colormap[i].red);
red 1076 coders/wpg.c image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red 1135 coders/wpg.c image->colormap[i].red=ScaleCharToQuantum(WPG1_Palette[i].Red);
red 1151 coders/wpg.c if(image->colormap[0].red==0 &&
red 1154 coders/wpg.c image->colormap[1].red==0 &&
red 1158 coders/wpg.c image->colormap[1].red =
red 1276 coders/wpg.c image->colormap[i].red=ScaleCharToQuantum((char)
red 287 coders/xbm.c image->colormap[0].red=QuantumRange;
red 290 coders/xbm.c image->colormap[1].red=(Quantum) 0;
red 170 coders/xcf.c red,
red 387 coders/xcf.c SetPixelRed(q,ScaleCharToQuantum(xcfdata->red));
red 1007 coders/xpm.c image->colormap[opacity].red=image->transparent_color.red;
red 341 coders/xwd.c colors[i].red=color.red;
red 357 coders/xwd.c MSBOrderShort((unsigned char *) &colors[i].red,3*
red 358 coders/xwd.c sizeof(colors[i].red));
red 469 coders/xwd.c SetPixelRed(q,ScaleShortToQuantum(colors[(ssize_t) index].red));
red 532 coders/xwd.c image->colormap[i].red=ScaleShortToQuantum(colors[i].red);
red 789 coders/xwd.c colors[i].red=ScaleQuantumToShort(image->colormap[i].red);
red 798 coders/xwd.c MSBOrderShort((unsigned char *) &colors[i].red,
red 799 coders/xwd.c 3*sizeof(colors[i].red));
red 805 coders/xwd.c color.red=colors[i].red;
red 40 magick/accelerate-private.h red,
red 49 magick/accelerate-private.h red,
red 244 magick/accelerate-private.h float red = getRed(p);
red 251 magick/accelerate-private.h return red;
red 257 magick/accelerate-private.h intensity=(red+green+blue)/3.0;
red 262 magick/accelerate-private.h intensity=max(max(red,green),blue);
red 267 magick/accelerate-private.h intensity=(min(min(red,green),blue)+
red 268 magick/accelerate-private.h max(max(red,green),blue))/2.0;
red 273 magick/accelerate-private.h intensity=(float) (((float) red*red+green*green+blue*blue)/
red 287 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
red 300 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
red 314 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
red 327 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
red 332 magick/accelerate-private.h intensity=(float) (sqrt((float) red*red+green*green+blue*blue)/
red 688 magick/accelerate-private.h CLQuantum red, green, blue, opacity;
red 699 magick/accelerate-private.h red = getRed(eValue);
red 734 magick/accelerate-private.h im[c]=(CLPixelType)(blue, green, red, opacity);
red 755 magick/accelerate-private.h CLQuantum red, green, blue, opacity;
red 766 magick/accelerate-private.h red = getRed(eValue);
red 778 magick/accelerate-private.h im[c]=(CLPixelType)(blue, green, red, opacity);
red 1753 magick/accelerate-private.h inline void ConvertRGBToHSL(const CLQuantum red,const CLQuantum green, const CLQuantum blue,
red 1764 magick/accelerate-private.h tmax=max(QuantumScale*red,max(QuantumScale*green, QuantumScale*blue));
red 1765 magick/accelerate-private.h tmin=min(QuantumScale*red,min(QuantumScale*green, QuantumScale*blue));
red 1777 magick/accelerate-private.h if (tmax == (QuantumScale*red))
red 1785 magick/accelerate-private.h *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red 1787 magick/accelerate-private.h *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red 1797 magick/accelerate-private.h CLQuantum *red,CLQuantum *green,CLQuantum *blue)
red 1871 magick/accelerate-private.h *red=ClampToQuantum(QuantumRange*r);
red 1877 magick/accelerate-private.h CLQuantum *red,CLQuantum *green,CLQuantum *blue)
red 1887 magick/accelerate-private.h ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
red 1895 magick/accelerate-private.h ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
red 1915 magick/accelerate-private.h red;
red 1917 magick/accelerate-private.h red=getRed(pixel);
red 1927 magick/accelerate-private.h &red, &green, &blue);
red 1934 magick/accelerate-private.h setRed(&filteredPixel, red);
red 1959 magick/accelerate-private.h red;
red 1961 magick/accelerate-private.h red=(float)getRed(pixel);
red 1973 magick/accelerate-private.h intensity=(red+green+blue)/3.0;
red 1978 magick/accelerate-private.h intensity=max(max(red,green),blue);
red 1983 magick/accelerate-private.h intensity=(min(min(red,green),blue)+
red 1984 magick/accelerate-private.h max(max(red,green),blue))/2.0;
red 1989 magick/accelerate-private.h intensity=(float) (((float) red*red+green*green+
red 2003 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2016 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2030 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2043 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2048 magick/accelerate-private.h intensity=(float) (sqrt((float) red*red+green*green+
red 1820 magick/accelerate.c biasPixel.s[0] = bias.red;
red 4687 magick/accelerate.c intensity.red+=histogram[i].s[2];
red 4692 magick/accelerate.c intensity.red+=histogram[i].s[2];
red 4715 magick/accelerate.c if (white.red != black.red)
red 4716 magick/accelerate.c equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red 4717 magick/accelerate.c (map[i].red-black.red))/(white.red-black.red)));
red 4720 magick/accelerate.c if (((channel & RedChannel) != 0) && (white.red != black.red))
red 4721 magick/accelerate.c equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red 4722 magick/accelerate.c (map[i].red-black.red))/(white.red-black.red)));
red 4750 magick/accelerate.c if (white.red != black.red)
red 4752 magick/accelerate.c image->colormap[i].red=equalize_map[
red 4753 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].red)].red;
red 4755 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].green)].red;
red 4757 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].blue)].red;
red 4759 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].opacity)].red;
red 4763 magick/accelerate.c if (((channel & RedChannel) != 0) && (white.red != black.red))
red 4764 magick/accelerate.c image->colormap[i].red=equalize_map[
red 4765 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].red)].red;
red 5182 magick/accelerate.c black.red=0.0;
red 5183 magick/accelerate.c white.red=MaxRange(QuantumRange);
red 5193 magick/accelerate.c black.red=(MagickRealType) i;
red 5201 magick/accelerate.c white.red=(MagickRealType) i;
red 5306 magick/accelerate.c if (i < (ssize_t) black.red)
red 5307 magick/accelerate.c stretch_map[i].red=(Quantum) 0;
red 5309 magick/accelerate.c if (i > (ssize_t) white.red)
red 5310 magick/accelerate.c stretch_map[i].red=QuantumRange;
red 5312 magick/accelerate.c if (black.red != white.red)
red 5313 magick/accelerate.c stretch_map[i].red=ScaleMapToQuantum((MagickRealType) (MaxMap*
red 5314 magick/accelerate.c (i-black.red)/(white.red-black.red)));
red 5384 magick/accelerate.c if (black.red != white.red)
red 5385 magick/accelerate.c image->colormap[i].red=stretch_map[
red 5386 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].red)].red;
red 6702 magick/accelerate.c biasPixel.s[0] = bias.red;
red 1844 magick/annotate.c SetPixelRed(q,fill_color.red);
red 348 magick/attribute.c if (IsPixelAtDepth(image->colormap[i].red,range) == MagickFalse)
red 879 magick/attribute.c image->colormap[i].red=ScaleAnyToQuantum(ScaleQuantumToAny(
red 880 magick/attribute.c ClampPixel(image->colormap[i].red),range),range);
red 3247 magick/cache.c composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
red 3322 magick/cache.c SetPixelRed(q,ClampToQuantum(beta.red));
red 778 magick/channel.c SetPixelRed(q,pixel.red);
red 940 magick/channel.c q->red=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->red,
red 941 magick/channel.c (MagickRealType) q->opacity,(MagickRealType) pixel.red,
red 50 magick/color-private.h red;
red 52 magick/color-private.h red=(MagickRealType) p->red;
red 55 magick/color-private.h if ((fabs((double) (red-q->red)) < MagickEpsilon) &&
red 78 magick/color-private.h if (fabs((double) (p->red-q->red)) >= MagickEpsilon)
red 95 magick/color-private.h if ((fabs((double) (pixel->red-pixel->green)) < MagickEpsilon) &&
red 105 magick/color-private.h return(pixel->red);
red 106 magick/color-private.h return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red 113 magick/color-private.h return(ClampToQuantum(pixel->red));
red 114 magick/color-private.h return(ClampToQuantum(0.212656*pixel->red+0.715158*pixel->green+
red 123 magick/color-private.h red;
red 126 magick/color-private.h return(pixel->red);
red 128 magick/color-private.h return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red 129 magick/color-private.h red=EncodePixelGamma(pixel->red);
red 132 magick/color-private.h return(0.212656*red+0.715158*green+0.072186*blue);
red 141 magick/color-private.h red;
red 144 magick/color-private.h return(pixel->red);
red 146 magick/color-private.h return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
red 147 magick/color-private.h red=DecodePixelGamma(pixel->red);
red 150 magick/color-private.h return(0.212656*red+0.715158*green+0.072186*blue);
red 85 magick/color.c red,
red 880 magick/color.c color_info->color.red=(MagickRealType) ScaleCharToQuantum(
red 1133 magick/color.c color=pixel->red;
red 1454 magick/color.c color=pixel->red;
red 1548 magick/color.c status=color.red == SVGCompliant(color.red);
red 2008 magick/color.c pixel=p->red-q->red;
red 2435 magick/color.c pixel.red*(QuantumRange-pixel.index)+pixel.index)))));
red 2444 magick/color.c SetPixelRed(color,ClampToQuantum(pixel.red));
red 2620 magick/color.c pixel.red=pixel.green;
red 2651 magick/color.c pixel.red=pixel.green;
red 2677 magick/color.c color->red=(MagickRealType) ScaleAnyToQuantum(pixel.red,range);
red 2770 magick/color.c color->red=(MagickRealType) ClampToQuantum(scale*geometry_info.rho);
red 2803 magick/color.c color->green=color->red;
red 2804 magick/color.c color->blue=color->red;
red 2828 magick/color.c 360.0,geometry_info.sigma,geometry_info.xi,&pixel.red,
red 2834 magick/color.c &pixel.red,&pixel.green,&pixel.blue);
red 2839 magick/color.c &pixel.red,&pixel.green,&pixel.blue);
red 2843 magick/color.c &pixel.red,&pixel.green,&pixel.blue);
red 2845 magick/color.c color->red=(MagickRealType) pixel.red;
red 2861 magick/color.c color->red=(MagickRealType) p->color.red;
red 2969 magick/color.c if (((p->compliance & compliance) != 0) && ((p->color.red == color->red)) &&
red 135 magick/colormap.c image->colormap[i].red=(Quantum) pixel;
red 32 magick/colorspace-private.h pixel->red=((QuantumRange-(QuantumScale*pixel->red*(QuantumRange-
red 48 magick/colorspace-private.h red,
red 53 magick/colorspace-private.h red=QuantumScale*pixel->red;
red 59 magick/colorspace-private.h red=QuantumScale*DecodePixelGamma(pixel->red);
red 63 magick/colorspace-private.h if ((fabs((double) red) < MagickEpsilon) &&
red 70 magick/colorspace-private.h cyan=(MagickRealType) (1.0-red);
red 82 magick/colorspace-private.h pixel->red=QuantumRange*cyan;
red 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 168 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red 177 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 178 magick/colorspace.c *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
red 179 magick/colorspace.c *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
red 185 magick/colorspace.c ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
red 191 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 192 magick/colorspace.c *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
red 193 magick/colorspace.c *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
red 199 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 200 magick/colorspace.c *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
red 201 magick/colorspace.c *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
red 207 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 208 magick/colorspace.c *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
red 209 magick/colorspace.c *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
red 309 magick/colorspace.c pixel.red=(MagickRealType) pixel.red;
red 446 magick/colorspace.c red;
red 448 magick/colorspace.c red=ClampToQuantum((MagickRealType) GetPixelRed(q));
red 455 magick/colorspace.c ConvertRGBToCMY(red,green,blue,&X,&Y,&Z);
red 460 magick/colorspace.c ConvertRGBToHCL(red,green,blue,&X,&Y,&Z);
red 465 magick/colorspace.c ConvertRGBToHCLp(red,green,blue,&X,&Y,&Z);
red 470 magick/colorspace.c ConvertRGBToHSB(red,green,blue,&X,&Y,&Z);
red 475 magick/colorspace.c ConvertRGBToHSI(red,green,blue,&X,&Y,&Z);
red 480 magick/colorspace.c ConvertRGBToHSL(red,green,blue,&X,&Y,&Z);
red 485 magick/colorspace.c ConvertRGBToHSV(red,green,blue,&X,&Y,&Z);
red 490 magick/colorspace.c ConvertRGBToHWB(red,green,blue,&X,&Y,&Z);
red 495 magick/colorspace.c ConvertRGBToLab(red,green,blue,&X,&Y,&Z);
red 501 magick/colorspace.c ConvertRGBToLCHab(red,green,blue,&X,&Y,&Z);
red 506 magick/colorspace.c ConvertRGBToLCHuv(red,green,blue,&X,&Y,&Z);
red 511 magick/colorspace.c ConvertRGBToLMS(red,green,blue,&X,&Y,&Z);
red 516 magick/colorspace.c ConvertRGBToLuv(red,green,blue,&X,&Y,&Z);
red 521 magick/colorspace.c ConvertRGBToxyY(red,green,blue,&X,&Y,&Z);
red 526 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red 531 magick/colorspace.c ConvertRGBToYCbCr(red,green,blue,&X,&Y,&Z);
red 536 magick/colorspace.c ConvertRGBToYDbDr(red,green,blue,&X,&Y,&Z);
red 541 magick/colorspace.c ConvertRGBToYIQ(red,green,blue,&X,&Y,&Z);
red 546 magick/colorspace.c ConvertRGBToYPbPr(red,green,blue,&X,&Y,&Z);
red 551 magick/colorspace.c ConvertRGBToYUV(red,green,blue,&X,&Y,&Z);
red 556 magick/colorspace.c X=QuantumScale*red;
red 662 magick/colorspace.c red;
red 664 magick/colorspace.c red=ClampToQuantum(DecodePixelGamma((MagickRealType)
red 670 magick/colorspace.c SetPixelRed(q,logmap[ScaleQuantumToMap(red)]);
red 728 magick/colorspace.c red;
red 730 magick/colorspace.c red=ClampToQuantum(DecodePixelGamma((MagickRealType)
red 736 magick/colorspace.c SetPixelRed(q,red);
red 1010 magick/colorspace.c red;
red 1023 magick/colorspace.c red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
red 1029 magick/colorspace.c pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
red 1031 magick/colorspace.c pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
red 1033 magick/colorspace.c pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
red 1035 magick/colorspace.c SetPixelRed(q,ScaleMapToQuantum(pixel.red));
red 1065 magick/colorspace.c red;
red 1075 magick/colorspace.c red=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
red 1076 magick/colorspace.c image->colormap[i].red));
red 1081 magick/colorspace.c pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
red 1082 magick/colorspace.c pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
red 1083 magick/colorspace.c pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
red 1084 magick/colorspace.c image->colormap[i].red=ScaleMapToQuantum(pixel.red);
red 1273 magick/colorspace.c *red=ClampToQuantum(QuantumRange*(1.0-cyan));
red 1295 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
red 1307 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
red 1328 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
red 1342 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
red 1348 magick/colorspace.c *red=ClampToQuantum(QuantumRange*(0.99999999999914679361*Y-
red 1359 magick/colorspace.c ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
red 1365 magick/colorspace.c *red=ClampToQuantum(QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
red 1376 magick/colorspace.c *red=ClampToQuantum(QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
red 1387 magick/colorspace.c *red=ClampToQuantum(QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
red 1865 magick/colorspace.c red;
red 1874 magick/colorspace.c ConvertCMYToRGB(X,Y,Z,&red,&green,&blue);
red 1879 magick/colorspace.c ConvertHCLToRGB(X,Y,Z,&red,&green,&blue);
red 1884 magick/colorspace.c ConvertHCLpToRGB(X,Y,Z,&red,&green,&blue);
red 1889 magick/colorspace.c ConvertHSBToRGB(X,Y,Z,&red,&green,&blue);
red 1894 magick/colorspace.c ConvertHSIToRGB(X,Y,Z,&red,&green,&blue);
red 1899 magick/colorspace.c ConvertHSLToRGB(X,Y,Z,&red,&green,&blue);
red 1904 magick/colorspace.c ConvertHSVToRGB(X,Y,Z,&red,&green,&blue);
red 1909 magick/colorspace.c ConvertHWBToRGB(X,Y,Z,&red,&green,&blue);
red 1914 magick/colorspace.c ConvertLabToRGB(X,Y,Z,&red,&green,&blue);
red 1920 magick/colorspace.c ConvertLCHabToRGB(X,Y,Z,&red,&green,&blue);
red 1925 magick/colorspace.c ConvertLCHuvToRGB(X,Y,Z,&red,&green,&blue);
red 1930 magick/colorspace.c ConvertLMSToRGB(X,Y,Z,&red,&green,&blue);
red 1935 magick/colorspace.c ConvertLuvToRGB(X,Y,Z,&red,&green,&blue);
red 1940 magick/colorspace.c ConvertxyYToRGB(X,Y,Z,&red,&green,&blue);
red 1945 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
red 1950 magick/colorspace.c ConvertYCbCrToRGB(X,Y,Z,&red,&green,&blue);
red 1955 magick/colorspace.c ConvertYDbDrToRGB(X,Y,Z,&red,&green,&blue);
red 1960 magick/colorspace.c ConvertYIQToRGB(X,Y,Z,&red,&green,&blue);
red 1965 magick/colorspace.c ConvertYPbPrToRGB(X,Y,Z,&red,&green,&blue);
red 1970 magick/colorspace.c ConvertYUVToRGB(X,Y,Z,&red,&green,&blue);
red 1975 magick/colorspace.c red=ClampToQuantum(QuantumRange*X);
red 1981 magick/colorspace.c SetPixelRed(q,ClampToQuantum((MagickRealType) red));
red 2083 magick/colorspace.c red;
red 2085 magick/colorspace.c red=ClampToQuantum(EncodePixelGamma((MagickRealType)
red 2091 magick/colorspace.c SetPixelRed(q,red);
red 2149 magick/colorspace.c red;
red 2151 magick/colorspace.c red=ClampToQuantum(EncodePixelGamma((MagickRealType) GetPixelRed(q)));
red 2156 magick/colorspace.c SetPixelRed(q,red);
red 2388 magick/colorspace.c red;
red 2390 magick/colorspace.c red=ScaleQuantumToMap(GetPixelRed(q));
red 2393 magick/colorspace.c pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
red 2394 magick/colorspace.c pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
red 2395 magick/colorspace.c pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
red 2398 magick/colorspace.c pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
red 2407 magick/colorspace.c pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
red 2411 magick/colorspace.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 2453 magick/colorspace.c red;
red 2455 magick/colorspace.c red=ScaleQuantumToMap(image->colormap[i].red);
red 2458 magick/colorspace.c pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
red 2459 magick/colorspace.c pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
red 2460 magick/colorspace.c pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
red 2463 magick/colorspace.c pixel.red=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.red/
red 2472 magick/colorspace.c pixel.red=(MagickRealType) ScaleMapToQuantum(pixel.red);
red 2476 magick/colorspace.c image->colormap[i].red=ClampToQuantum(pixel.red);
red 104 magick/composite-private.h composite->red=gamma*MagickOver_(p->red,alpha,q->red,beta);
red 128 magick/composite-private.h composite->red=gamma*(Sa*p->red+Da*q->red);
red 209 magick/composite.c composite->red=Atop(p->red,Sa,q->red,1.0);
red 227 magick/composite.c composite->red=QuantumScale*intensity*q->red;
red 239 magick/composite.c composite->red=0.0;
red 281 magick/composite.c composite->red=gamma*ColorBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 282 magick/composite.c q->red*Da,Da);
red 343 magick/composite.c composite->red=gamma*ColorDodge(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 344 magick/composite.c q->red*Da,Da);
red 378 magick/composite.c composite->red=gamma*Darken(p->red,p->opacity,q->red,q->opacity);
red 388 magick/composite.c composite->red=MagickMin(p->red,q->red);
red 422 magick/composite.c composite->red = from_p ? p->red : q->red;
red 457 magick/composite.c composite->red=gamma*Difference(p->red,Sa,q->red,Da);
red 467 magick/composite.c composite->red=fabs((double) (p->red-q->red));
red 512 magick/composite.c composite->red=gamma*Divide(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 513 magick/composite.c q->red*Da,Da);
red 526 magick/composite.c composite->red=QuantumRange*
red 527 magick/composite.c Divide(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0);
red 561 magick/composite.c composite->red=gamma*Exclusion(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 562 magick/composite.c q->red*Da,Da);
red 575 magick/composite.c composite->red=QuantumRange*Exclusion(QuantumScale*p->red,1.0,
red 576 magick/composite.c QuantumScale*q->red,1.0);
red 610 magick/composite.c composite->red=gamma*HardLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 611 magick/composite.c q->red*Da,Da);
red 643 magick/composite.c composite->red=gamma*HardMix(p->red*Sa,q->red*Da);
red 665 magick/composite.c assert(red != (MagickRealType *) NULL);
red 710 magick/composite.c *red=QuantumRange*(r+m);
red 732 magick/composite.c r=(double) red;
red 741 magick/composite.c if (red == (MagickRealType) max)
red 777 magick/composite.c composite->red=gamma*In(p->red,Sa,q->red,Da);
red 808 magick/composite.c composite->red=gamma*Lighten(p->red,p->opacity,q->red,q->opacity);
red 818 magick/composite.c composite->red=MagickMax(p->red,q->red);
red 852 magick/composite.c composite->red = from_p ? p->red : q->red;
red 890 magick/composite.c composite->red=gamma*(p->red*Sa+q->red*Da);
red 923 magick/composite.c composite->red=gamma*LinearBurn(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 924 magick/composite.c q->red*Da,Da);
red 966 magick/composite.c composite->red=gamma*LinearLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 967 magick/composite.c q->red*Da,Da);
red 1021 magick/composite.c composite->red=gamma*Mathematics(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 1022 magick/composite.c q->red*Da,Da,args);
red 1035 magick/composite.c composite->red=QuantumRange*
red 1036 magick/composite.c Mathematics(QuantumScale*p->red,1.0,QuantumScale*q->red,1.0,args);
red 1076 magick/composite.c composite->red=p->red+q->red;
red 1118 magick/composite.c composite->red=gamma*Minus(p->red*Sa,Sa,q->red*Da,Da);
red 1128 magick/composite.c composite->red=p->red-q->red;
red 1167 magick/composite.c composite->red=ModulusAdd(p->red,Sa,q->red,Da);
red 1178 magick/composite.c composite->red=ModulusAdd(p->red,1.0,q->red,1.0);
red 1217 magick/composite.c composite->red=ModulusSubtract(p->red,Sa,q->red,Da);
red 1228 magick/composite.c composite->red=ModulusSubtract(p->red,1.0,q->red,1.0);
red 1259 magick/composite.c composite->red=gamma*Multiply(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 1260 magick/composite.c q->red*Da,Da);
red 1273 magick/composite.c composite->red=QuantumScale*p->red*q->red;
red 1307 magick/composite.c composite->red=gamma*Out(p->red,Sa,q->red,Da);
red 1343 magick/composite.c composite->red=gamma*PegtopLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 1344 magick/composite.c q->red*Da,Da);
red 1383 magick/composite.c composite->red=gamma*PinLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 1384 magick/composite.c q->red*Da,Da);
red 1422 magick/composite.c composite->red=gamma*Screen(p->red*Sa,q->red*Da);
red 1432 magick/composite.c composite->red=QuantumRange*Screen(QuantumScale*p->red,
red 1433 magick/composite.c QuantumScale*q->red);
red 1496 magick/composite.c composite->red=gamma*SoftLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 1497 magick/composite.c q->red*Da,Da);
red 1530 magick/composite.c composite->red=Threshold(p->red,q->red,threshold,amount);
red 1569 magick/composite.c composite->red=gamma*VividLight(QuantumScale*p->red*Sa,Sa,QuantumScale*
red 1570 magick/composite.c q->red*Da,Da);
red 1599 magick/composite.c composite->red=gamma*Xor(p->red*Sa,Sa,q->red*Da,Da);
red 2362 magick/composite.c canvas.red=(MagickRealType) GetPixelRed(q);
red 2371 magick/composite.c canvas.red=(MagickRealType) QuantumRange-canvas.red;
red 2419 magick/composite.c composite.red=(MagickRealType) QuantumRange-composite.red;
red 2425 magick/composite.c ClampPixel(composite.red) : ClampToQuantum(composite.red));
red 2443 magick/composite.c source.red=(MagickRealType) GetPixelRed(p);
red 2453 magick/composite.c source.red=(MagickRealType) QuantumRange-source.red;
red 2717 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red 2721 magick/composite.c HCLComposite(hue,chroma,luma,&composite.red,&composite.green,
red 2734 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red 2736 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&hue,&sans,&sans);
red 2737 magick/composite.c HCLComposite(hue,chroma,luma,&composite.red,
red 2752 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red 2754 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&sans,&chroma,
red 2756 magick/composite.c HCLComposite(hue,chroma,luma,&composite.red,
red 2771 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
red 2773 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&sans,&sans,
red 2775 magick/composite.c HCLComposite(hue,chroma,luma,&composite.red,
red 2790 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&sans,
red 2792 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&hue,&chroma,&sans);
red 2793 magick/composite.c HCLComposite(hue,chroma,luma,&composite.red,
red 2802 magick/composite.c composite.red=source.red;
red 2846 magick/composite.c composite.red=(MagickRealType) QuantumRange-composite.red;
red 2852 magick/composite.c ClampPixel(composite.red) : ClampToQuantum(composite.red));
red 254 magick/decorate.c accentuate.red=(MagickRealType) (QuantumScale*((QuantumRange-
red 255 magick/decorate.c AccentuateModulate)*matte.red+(QuantumRange*AccentuateModulate)));
red 262 magick/decorate.c highlight.red=(MagickRealType) (QuantumScale*((QuantumRange-
red 263 magick/decorate.c HighlightModulate)*matte.red+(QuantumRange*HighlightModulate)));
red 270 magick/decorate.c shadow.red=QuantumScale*matte.red*ShadowModulate;
red 275 magick/decorate.c trough.red=QuantumScale*matte.red*TroughModulate;
red 953 magick/deprecate.c threshold.red=geometry_info.rho;
red 956 magick/deprecate.c threshold.green=threshold.red;
red 959 magick/deprecate.c threshold.blue=threshold.red;
red 960 magick/deprecate.c status=BilevelImageChannel(image,RedChannel,threshold.red);
red 2280 magick/deprecate.c pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
red 2281 magick/deprecate.c distance=pixel.red*pixel.red;
red 3442 magick/deprecate.c assert(red != (Quantum *) NULL);
red 3453 magick/deprecate.c *red=ClampToQuantum((MagickRealType) QuantumRange*r);
red 3566 magick/deprecate.c p=(pixels[3].red-pixels[2].red)-(pixels[0].red-pixels[1].red);
red 3567 magick/deprecate.c q=(pixels[0].red-pixels[1].red)-p;
red 3568 magick/deprecate.c r=pixels[2].red-pixels[0].red;
red 3569 magick/deprecate.c s=pixels[1].red;
red 3570 magick/deprecate.c pixel->red=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
red 3672 magick/deprecate.c pixels[i].red*=alpha[i];
red 3680 magick/deprecate.c pixel.red+=gamma*0.0625*pixels[i].red;
red 3717 magick/deprecate.c pixels[i].red*=alpha[i];
red 3763 magick/deprecate.c pixels[i].red*=alpha[i];
red 3776 magick/deprecate.c pixel.red=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].red+delta.x*
red 3777 magick/deprecate.c pixels[1].red)+delta.y*((1.0-delta.x)*pixels[2].red+delta.x*
red 3778 magick/deprecate.c pixels[3].red));
red 3872 magick/deprecate.c pixels[i].red*=alpha[i];
red 3897 magick/deprecate.c pixel.red=gamma*MeshInterpolate(&delta,pixels[2].red,
red 3898 magick/deprecate.c pixels[3].red,pixels[0].red);
red 3917 magick/deprecate.c pixel.red=gamma*MeshInterpolate(&delta,pixels[1].red,
red 3918 magick/deprecate.c pixels[0].red,pixels[3].red);
red 3942 magick/deprecate.c pixel.red=gamma*MeshInterpolate(&delta,pixels[0].red,
red 3943 magick/deprecate.c pixels[1].red,pixels[2].red);
red 3963 magick/deprecate.c pixel.red=gamma*MeshInterpolate(&delta,pixels[3].red,
red 3964 magick/deprecate.c pixels[2].red,pixels[1].red);
red 4032 magick/deprecate.c pixels[n].red*=alpha[n];
red 4041 magick/deprecate.c pixel.red+=gamma*dx*dy*pixels[n].red;
red 7236 magick/deprecate.c pixel.red=geometry_info.rho;
red 7240 magick/deprecate.c pixel.green=pixel.red;
red 7244 magick/deprecate.c pixel.blue=pixel.red;
red 7251 magick/deprecate.c pixel.red*=QuantumRange/100.0f;
red 7261 magick/deprecate.c if (pixel.red == 0)
red 7282 magick/deprecate.c index=(IndexPacket) (GetPixelIntensity(image,q) <= pixel.red ? 0 : 1);
red 7284 magick/deprecate.c SetPixelRed(q,image->colormap[(ssize_t) index].red);
red 7292 magick/deprecate.c SetPixelRed(q,(MagickRealType) q->red <= pixel.red
red 7397 magick/deprecate.c r=QuantumScale*red;
red 3711 magick/display.c q->red=ScaleShortToQuantum(color.red);
red 3740 magick/display.c q->red=ScaleShortToQuantum(color.red);
red 3755 magick/display.c (*image)->colormap[i].red=ScaleShortToQuantum(color.red);
red 3781 magick/display.c target.red=(MagickRealType)
red 3782 magick/display.c ScaleShortToQuantum(border_color.red);
red 3813 magick/display.c q->red=ScaleShortToQuantum(color.red);
red 10062 magick/display.c target.red=(MagickRealType)
red 10063 magick/display.c ScaleShortToQuantum(border_color.red);
red 12280 magick/display.c (*image)->background_color.red=ScaleShortToQuantum(
red 12281 magick/display.c windows->pixel_info->pen_colors[pen_id].red);
red 3080 magick/distort.c pixel.red = coeff[x]*i +coeff[x+1]*j
red 3100 magick/distort.c pixel.red = coeff[x]*i + coeff[x+1]*j +
red 3124 magick/distort.c if ( channel & RedChannel ) pixel.red = 0.0;
red 3138 magick/distort.c pixel.red += arguments[x++]*weight;
red 3149 magick/distort.c if ( channel & RedChannel ) pixel.red /= denominator;
red 3174 magick/distort.c if ( channel & RedChannel ) pixel.red = arguments[x++];
red 3187 magick/distort.c pixel.red=ClampPixel(QuantumRange*pixel.red);
red 4305 magick/draw.c target.red=(MagickRealType) draw_info->border_color.red;
red 4416 magick/draw.c target.red=(MagickRealType) draw_info->border_color.red;
red 346 magick/effect.c pixel.red=bias.red;
red 361 magick/effect.c pixel.red+=(*k)*alpha*GetPixelRed(p);
red 378 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 669 magick/effect.c pixel.red=bias.red;
red 683 magick/effect.c pixel.red+=(*k)*alpha*GetPixelRed(p);
red 700 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 1635 magick/effect.c pixel.red=bias.red;
red 1648 magick/effect.c pixel.red+=(*k)*kernel_pixels[u].red;
red 1656 magick/effect.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 1709 magick/effect.c pixel.red+=(*k)*alpha*GetPixelRed(kernel_pixels+u);
red 1719 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 2104 magick/effect.c qixel.red+=(*k)*pixel.red;
red 2116 magick/effect.c SetPixelRed(q,ClampToQuantum(qixel.red));
red 2140 magick/effect.c qixel.red+=(*k)*alpha*pixel.red;
red 2154 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
red 2389 magick/effect.c mean.red+=(double) k->red;
red 2394 magick/effect.c mean.red/=(double) (width*width);
red 3179 magick/effect.c qixel.red+=pixel.red;
red 3192 magick/effect.c SetPixelRed(q,ClampToQuantum(normalize*qixel.red));
red 3218 magick/effect.c qixel.red+=alpha*pixel.red;
red 3233 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*qixel.red));
red 3521 magick/effect.c pixel.red=bias.red;
red 3539 magick/effect.c pixel.red+=(*k)*GetPixelRed(p+u+j);
red 3552 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 3615 magick/effect.c pixel.red+=(*k)*alpha*GetPixelRed(p+u+j);
red 3629 magick/effect.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 4355 magick/effect.c pixel.red=bias.red;
red 4364 magick/effect.c pixel.red=GetPixelRed(p)-(MagickRealType) GetPixelRed(q);
red 4365 magick/effect.c if (fabs(2.0*pixel.red) < quantum_threshold)
red 4366 magick/effect.c pixel.red=(MagickRealType) GetPixelRed(p);
red 4368 magick/effect.c pixel.red=(MagickRealType) GetPixelRed(p)+(pixel.red*gain);
red 4369 magick/effect.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 373 magick/enhance.c red,
red 436 magick/enhance.c color_correction.red.slope=1.0;
red 437 magick/enhance.c color_correction.red.offset=0.0;
red 438 magick/enhance.c color_correction.red.power=1.0;
red 468 magick/enhance.c color_correction.red.slope=StringToDouble(token,(char **) NULL);
red 500 magick/enhance.c color_correction.red.offset=StringToDouble(token,
red 533 magick/enhance.c color_correction.red.power=StringToDouble(token,(char **) NULL);
red 573 magick/enhance.c " color_correction.red.slope: %g",color_correction.red.slope);
red 575 magick/enhance.c " color_correction.red.offset: %g",color_correction.red.offset);
red 577 magick/enhance.c " color_correction.red.power: %g",color_correction.red.power);
red 599 magick/enhance.c cdl_map[i].red=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
red 600 magick/enhance.c MagickRealType) (MaxMap*(pow(color_correction.red.slope*i/MaxMap+
red 601 magick/enhance.c color_correction.red.offset,color_correction.red.power)))));
red 619 magick/enhance.c luma=0.212656*image->colormap[i].red+0.715158*image->colormap[i].green+
red 621 magick/enhance.c image->colormap[i].red=ClampToQuantum(luma+color_correction.saturation*
red 622 magick/enhance.c cdl_map[ScaleQuantumToMap(image->colormap[i].red)].red-luma);
red 665 magick/enhance.c (cdl_map[ScaleQuantumToMap(GetPixelRed(q))].red-luma)));
red 923 magick/enhance.c assert(red != (Quantum *) NULL);
red 929 magick/enhance.c ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
red 937 magick/enhance.c ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
red 976 magick/enhance.c Contrast(sign,&image->colormap[i].red,&image->colormap[i].green,
red 1000 magick/enhance.c red;
red 1018 magick/enhance.c red=GetPixelRed(q);
red 1021 magick/enhance.c Contrast(sign,&red,&green,&blue);
red 1022 magick/enhance.c SetPixelRed(q,red);
red 1217 magick/enhance.c histogram[ScaleQuantumToMap(intensity)].red++;
red 1227 magick/enhance.c histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red 1243 magick/enhance.c black.red=0.0;
red 1244 magick/enhance.c white.red=MaxRange(QuantumRange);
red 1250 magick/enhance.c intensity+=histogram[i].red;
red 1254 magick/enhance.c black.red=(MagickRealType) i;
red 1258 magick/enhance.c intensity+=histogram[i].red;
red 1262 magick/enhance.c white.red=(MagickRealType) i;
red 1357 magick/enhance.c if (i < (ssize_t) black.red)
red 1358 magick/enhance.c stretch_map[i].red=(Quantum) 0;
red 1360 magick/enhance.c if (i > (ssize_t) white.red)
red 1361 magick/enhance.c stretch_map[i].red=QuantumRange;
red 1363 magick/enhance.c if (black.red != white.red)
red 1364 magick/enhance.c stretch_map[i].red=ScaleMapToQuantum((MagickRealType) (MaxMap*
red 1365 magick/enhance.c (i-black.red)/(white.red-black.red)));
red 1432 magick/enhance.c if (black.red != white.red)
red 1433 magick/enhance.c image->colormap[i].red=stretch_map[
red 1434 magick/enhance.c ScaleQuantumToMap(image->colormap[i].red)].red;
red 1489 magick/enhance.c if (black.red != white.red)
red 1491 magick/enhance.c ScaleQuantumToMap(GetPixelRed(q))].red);
red 1569 magick/enhance.c mean=QuantumScale*((double) GetPixelRed(r)+pixel.red)/2.0; \
red 1570 magick/enhance.c distance=QuantumScale*((double) GetPixelRed(r)-pixel.red); \
red 1583 magick/enhance.c aggregate.red+=(weight)*GetPixelRed(r); \
red 1707 magick/enhance.c SetPixelRed(q,(aggregate.red+(total_weight/2)-1)/total_weight);
red 1858 magick/enhance.c histogram[ScaleQuantumToMap(ClampToQuantum(intensity))].red++;
red 1865 magick/enhance.c histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red 1887 magick/enhance.c intensity.red+=histogram[i].red;
red 1892 magick/enhance.c intensity.red+=histogram[i].red;
red 1911 magick/enhance.c if (white.red != black.red)
red 1912 magick/enhance.c equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red 1913 magick/enhance.c (map[i].red-black.red))/(white.red-black.red)));
red 1916 magick/enhance.c if (((channel & RedChannel) != 0) && (white.red != black.red))
red 1917 magick/enhance.c equalize_map[i].red=ScaleMapToQuantum((MagickRealType) ((MaxMap*
red 1918 magick/enhance.c (map[i].red-black.red))/(white.red-black.red)));
red 1945 magick/enhance.c if (white.red != black.red)
red 1947 magick/enhance.c image->colormap[i].red=equalize_map[
red 1948 magick/enhance.c ScaleQuantumToMap(image->colormap[i].red)].red;
red 1950 magick/enhance.c ScaleQuantumToMap(image->colormap[i].green)].red;
red 1952 magick/enhance.c ScaleQuantumToMap(image->colormap[i].blue)].red;
red 1954 magick/enhance.c ScaleQuantumToMap(image->colormap[i].opacity)].red;
red 1958 magick/enhance.c if (((channel & RedChannel) != 0) && (white.red != black.red))
red 1959 magick/enhance.c image->colormap[i].red=equalize_map[
red 1960 magick/enhance.c ScaleQuantumToMap(image->colormap[i].red)].red;
red 2007 magick/enhance.c if (white.red != black.red)
red 2010 magick/enhance.c ScaleQuantumToMap(GetPixelRed(q))].red);
red 2012 magick/enhance.c ScaleQuantumToMap(GetPixelGreen(q))].red);
red 2014 magick/enhance.c ScaleQuantumToMap(GetPixelBlue(q))].red);
red 2016 magick/enhance.c ScaleQuantumToMap(GetPixelOpacity(q))].red);
red 2019 magick/enhance.c ScaleQuantumToMap(GetPixelIndex(indexes+x))].red);
red 2024 magick/enhance.c if (((channel & RedChannel) != 0) && (white.red != black.red))
red 2026 magick/enhance.c ScaleQuantumToMap(GetPixelRed(q))].red);
red 2125 magick/enhance.c gamma.red=geometry_info.rho;
red 2128 magick/enhance.c gamma.green=gamma.red;
red 2131 magick/enhance.c gamma.blue=gamma.red;
red 2132 magick/enhance.c if ((gamma.red == 1.0) && (gamma.green == 1.0) && (gamma.blue == 1.0))
red 2134 magick/enhance.c if ((gamma.red == gamma.green) && (gamma.green == gamma.blue))
red 2136 magick/enhance.c BlueChannel),(double) gamma.red);
red 2139 magick/enhance.c status=GammaImageChannel(image,RedChannel,(double) gamma.red);
red 2199 magick/enhance.c image->colormap[i].red=gamma_map[ScaleQuantumToMap(
red 2200 magick/enhance.c image->colormap[i].red)];
red 2219 magick/enhance.c image->colormap[i].red=QuantumRange*gamma_pow(QuantumScale*
red 2220 magick/enhance.c image->colormap[i].red,1.0/gamma);
red 2456 magick/enhance.c red;
red 2458 magick/enhance.c red=(MagickRealType) q->red;
red 2466 magick/enhance.c intensity=(red+green+blue)/3.0;
red 2471 magick/enhance.c intensity=MagickMax(MagickMax(red,green),blue);
red 2476 magick/enhance.c intensity=(MagickMin(MagickMin(red,green),blue)+
red 2477 magick/enhance.c MagickMax(MagickMax(red,green),blue))/2.0;
red 2482 magick/enhance.c intensity=(MagickRealType) (((double) red*red+green*green+
red 2490 magick/enhance.c red=EncodePixelGamma(red);
red 2494 magick/enhance.c intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2501 magick/enhance.c red=DecodePixelGamma(red);
red 2505 magick/enhance.c intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2513 magick/enhance.c red=EncodePixelGamma(red);
red 2517 magick/enhance.c intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2524 magick/enhance.c red=DecodePixelGamma(red);
red 2528 magick/enhance.c intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2533 magick/enhance.c intensity=(MagickRealType) (sqrt((double) red*red+green*green+
red 2740 magick/enhance.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 2951 magick/enhance.c image->colormap[i].red=(Quantum) ClampToQuantum(LevelPixel(black_point,
red 2952 magick/enhance.c white_point,gamma,(MagickRealType) image->colormap[i].red));
red 3131 magick/enhance.c image->colormap[i].red=LevelizeValue(image->colormap[i].red);
red 3285 magick/enhance.c status&=LevelImageChannel(image,RedChannel,black_color->red,
red 3286 magick/enhance.c white_color->red,(double) 1.0);
red 3305 magick/enhance.c status&=LevelizeImageChannel(image,RedChannel,black_color->red,
red 3306 magick/enhance.c white_color->red,(double) 1.0);
red 3470 magick/enhance.c ConvertRGBToHCL(*red,*green,*blue,&hue,&chroma,&luma);
red 3478 magick/enhance.c ConvertHCLToRGB(hue,chroma,luma,red,green,blue);
red 3493 magick/enhance.c ConvertRGBToHCLp(*red,*green,*blue,&hue,&chroma,&luma);
red 3501 magick/enhance.c ConvertHCLpToRGB(hue,chroma,luma,red,green,blue);
red 3516 magick/enhance.c ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
red 3524 magick/enhance.c ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
red 3539 magick/enhance.c ConvertRGBToHSI(*red,*green,*blue,&hue,&saturation,&intensity);
red 3547 magick/enhance.c ConvertHSIToRGB(hue,saturation,intensity,red,green,blue);
red 3562 magick/enhance.c ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
red 3570 magick/enhance.c ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
red 3585 magick/enhance.c ConvertRGBToHSV(*red,*green,*blue,&hue,&saturation,&value);
red 3593 magick/enhance.c ConvertHSVToRGB(hue,saturation,value,red,green,blue);
red 3608 magick/enhance.c ConvertRGBToHWB(*red,*green,*blue,&hue,&whiteness,&blackness);
red 3616 magick/enhance.c ConvertHWBToRGB(hue,whiteness,blackness,red,green,blue);
red 3631 magick/enhance.c ConvertRGBToLCHab(*red,*green,*blue,&luma,&chroma,&hue);
red 3639 magick/enhance.c ConvertLCHabToRGB(luma,chroma,hue,red,green,blue);
red 3654 magick/enhance.c ConvertRGBToLCHuv(*red,*green,*blue,&luma,&chroma,&hue);
red 3662 magick/enhance.c ConvertLCHuvToRGB(luma,chroma,hue,red,green,blue);
red 3734 magick/enhance.c red;
red 3739 magick/enhance.c red=image->colormap[i].red;
red 3747 magick/enhance.c &red,&green,&blue);
red 3753 magick/enhance.c &red,&green,&blue);
red 3759 magick/enhance.c &red,&green,&blue);
red 3765 magick/enhance.c &red,&green,&blue);
red 3772 magick/enhance.c &red,&green,&blue);
red 3778 magick/enhance.c &red,&green,&blue);
red 3784 magick/enhance.c &red,&green,&blue);
red 3791 magick/enhance.c &red,&green,&blue);
red 3797 magick/enhance.c &red,&green,&blue);
red 3801 magick/enhance.c image->colormap[i].red=red;
red 3844 magick/enhance.c red;
red 3846 magick/enhance.c red=GetPixelRed(q);
red 3854 magick/enhance.c &red,&green,&blue);
red 3860 magick/enhance.c &red,&green,&blue);
red 3866 magick/enhance.c &red,&green,&blue);
red 3873 magick/enhance.c &red,&green,&blue);
red 3879 magick/enhance.c &red,&green,&blue);
red 3885 magick/enhance.c &red,&green,&blue);
red 3891 magick/enhance.c &red,&green,&blue);
red 3898 magick/enhance.c &red,&green,&blue);
red 3902 magick/enhance.c SetPixelRed(q,red);
red 4002 magick/enhance.c if ((image->colormap[i].red != image->colormap[i].green) ||
red 4006 magick/enhance.c image->colormap[i].red=QuantumRange-image->colormap[i].red;
red 4422 magick/enhance.c image->colormap[i].red=ClampToQuantum(sigmoidal_map[
red 4423 magick/enhance.c ScaleQuantumToMap(image->colormap[i].red)]);
red 178 magick/feature.c q->red=QuantumRange;
red 223 magick/feature.c q->red=QuantumRange;
red 513 magick/feature.c q->red=0;
red 708 magick/feature.c grays[i].red=(~0U);
red 742 magick/feature.c grays[ScaleQuantumToMap(GetPixelRed(p))].red=
red 768 magick/feature.c if (grays[i].red != ~0U)
red 769 magick/feature.c grays[(ssize_t) gray.red++].red=grays[i].red;
red 784 magick/feature.c number_grays=gray.red;
red 966 magick/feature.c while (grays[u].red != ScaleQuantumToMap(GetPixelRed(p)))
red 968 magick/feature.c while (grays[v].red != ScaleQuantumToMap(GetPixelRed(p+offset)))
red 970 magick/feature.c cooccurrence[u][v].direction[i].red++;
red 971 magick/feature.c cooccurrence[v][u].direction[i].red++;
red 1083 magick/feature.c cooccurrence[x][y].direction[i].red*=normalize;
red 1116 magick/feature.c cooccurrence[x][y].direction[i].red*
red 1117 magick/feature.c cooccurrence[x][y].direction[i].red;
red 1135 magick/feature.c sum[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
red 1142 magick/feature.c correlation.direction[i].red+=x*y*cooccurrence[x][y].direction[i].red;
red 1157 magick/feature.c cooccurrence[x][y].direction[i].red/((y-x)*(y-x)+1);
red 1171 magick/feature.c density_xy[y+x+2].direction[i].red+=
red 1172 magick/feature.c cooccurrence[x][y].direction[i].red;
red 1187 magick/feature.c cooccurrence[x][y].direction[i].red*
red 1188 magick/feature.c MagickLog10(cooccurrence[x][y].direction[i].red);
red 1206 magick/feature.c density_x[x].direction[i].red+=cooccurrence[x][y].direction[i].red;
red 1215 magick/feature.c density_y[y].direction[i].red+=cooccurrence[x][y].direction[i].red;
red 1225 magick/feature.c mean.direction[i].red+=y*sum[y].direction[i].red;
red 1226 magick/feature.c sum_squares.direction[i].red+=y*y*sum[y].direction[i].red;
red 1246 magick/feature.c (correlation.direction[i].red-mean.direction[i].red*
red 1247 magick/feature.c mean.direction[i].red)/(sqrt(sum_squares.direction[i].red-
red 1248 magick/feature.c (mean.direction[i].red*mean.direction[i].red))*sqrt(
red 1249 magick/feature.c sum_squares.direction[i].red-(mean.direction[i].red*
red 1250 magick/feature.c mean.direction[i].red)));
red 1296 magick/feature.c x*density_xy[x].direction[i].red;
red 1311 magick/feature.c density_xy[x].direction[i].red*
red 1312 magick/feature.c MagickLog10(density_xy[x].direction[i].red);
red 1333 magick/feature.c density_xy[x].direction[i].red;
red 1376 magick/feature.c variance.direction[i].red+=(y-mean.direction[i].red+1)*
red 1377 magick/feature.c (y-mean.direction[i].red+1)*cooccurrence[x][y].direction[i].red;
red 1392 magick/feature.c density_xy[MagickAbsoluteValue(y-x)].direction[i].red+=
red 1393 magick/feature.c cooccurrence[x][y].direction[i].red;
red 1407 magick/feature.c entropy_xy.direction[i].red-=cooccurrence[x][y].direction[i].red*
red 1408 magick/feature.c MagickLog10(cooccurrence[x][y].direction[i].red);
red 1420 magick/feature.c entropy_xy1.direction[i].red-=(cooccurrence[x][y].direction[i].red*
red 1421 magick/feature.c MagickLog10(density_x[x].direction[i].red*
red 1422 magick/feature.c density_y[y].direction[i].red));
red 1438 magick/feature.c entropy_xy2.direction[i].red-=(density_x[x].direction[i].red*
red 1439 magick/feature.c density_y[y].direction[i].red*MagickLog10(
red 1440 magick/feature.c density_x[x].direction[i].red*density_y[y].direction[i].red));
red 1459 magick/feature.c variance.direction[i].red;
red 1490 magick/feature.c variance.direction[i].red+=density_xy[x].direction[i].red;
red 1497 magick/feature.c sum_squares.direction[i].red+=density_xy[x].direction[i].red*
red 1498 magick/feature.c density_xy[x].direction[i].red;
red 1513 magick/feature.c density_xy[x].direction[i].red*
red 1514 magick/feature.c MagickLog10(density_xy[x].direction[i].red);
red 1532 magick/feature.c entropy_x.direction[i].red-=(density_x[x].direction[i].red*
red 1533 magick/feature.c MagickLog10(density_x[x].direction[i].red));
red 1544 magick/feature.c entropy_y.direction[i].red-=(density_y[x].direction[i].red*
red 1545 magick/feature.c MagickLog10(density_y[x].direction[i].red));
red 1561 magick/feature.c (((double) number_grays*number_grays*sum_squares.direction[i].red)-
red 1562 magick/feature.c (variance.direction[i].red*variance.direction[i].red))/
red 1586 magick/feature.c (entropy_xy.direction[i].red-entropy_xy1.direction[i].red)/
red 1587 magick/feature.c (entropy_x.direction[i].red > entropy_y.direction[i].red ?
red 1588 magick/feature.c entropy_x.direction[i].red : entropy_y.direction[i].red);
red 1608 magick/feature.c (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].red-
red 1609 magick/feature.c entropy_xy.direction[i].red)))));
red 1658 magick/feature.c pixel.direction[i].red+=cooccurrence[x][y].direction[i].red;
red 1670 magick/feature.c Q[z][y].direction[i].red+=cooccurrence[z][x].direction[i].red*
red 1671 magick/feature.c cooccurrence[y][x].direction[i].red/density_x[z].direction[i].red/
red 1672 magick/feature.c density_y[x].direction[i].red;
red 1675 magick/feature.c density_x[z].direction[i].green/density_y[x].direction[i].red;
red 1691 magick/feature.c channel_features[RedChannel].contrast[i]+=z*z*pixel.direction[i].red;
red 2232 magick/feature.c distance=(mean_pixel.red-pixel.red)*(mean_pixel.red-pixel.red)+
red 2239 magick/feature.c sum_pixel.red+=pixel.red;
red 2251 magick/feature.c mean_pixel.red=gamma*sum_pixel.red;
red 2259 magick/feature.c 255.0*QuantumScale*(mean_pixel.red-previous_pixel.red)*
red 2260 magick/feature.c 255.0*QuantumScale*(mean_pixel.red-previous_pixel.red)+
red 2268 magick/feature.c q->red=ClampToQuantum(mean_pixel.red);
red 267 magick/fourier.c Cr->red=Ar->red+Br->red;
red 268 magick/fourier.c Ci->red=Ai->red+Bi->red;
red 283 magick/fourier.c Cr->red=Ar->red;
red 284 magick/fourier.c Ci->red=(-Bi->red);
red 301 magick/fourier.c gamma=PerceptibleReciprocal(Br->red*Br->red+Bi->red*Bi->red+snr);
red 302 magick/fourier.c Cr->red=gamma*(Ar->red*Br->red+Ai->red*Bi->red);
red 303 magick/fourier.c Ci->red=gamma*(Ai->red*Br->red-Ar->red*Bi->red);
red 324 magick/fourier.c Cr->red=sqrt(Ar->red*Ar->red+Ai->red*Ai->red);
red 325 magick/fourier.c Ci->red=atan2(Ai->red,Ar->red)/(2.0*MagickPI)+0.5;
red 339 magick/fourier.c Cr->red=QuantumScale*(Ar->red*Br->red-Ai->red*Bi->red);
red 340 magick/fourier.c Ci->red=QuantumScale*(Ai->red*Br->red+Ar->red*Bi->red);
red 356 magick/fourier.c Cr->red=Ar->red*cos(2.0*MagickPI*(Ai->red-0.5));
red 357 magick/fourier.c Ci->red=Ar->red*sin(2.0*MagickPI*(Ai->red-0.5));
red 371 magick/fourier.c Cr->red=Ar->red-Br->red;
red 372 magick/fourier.c Ci->red=Ai->red-Bi->red;
red 551 magick/fx.c pixel.red=0.5*(GetPixelRed(p)+factor*quantum);
red 559 magick/fx.c pixel.red=0.5*(pixel.red+factor*quantum);
red 562 magick/fx.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 748 magick/fx.c pixel.red=geometry_info.rho;
red 795 magick/fx.c SetPixelRed(q,((GetPixelRed(p)*(100.0-pixel.red)+
red 796 magick/fx.c colorize.red*pixel.red)/100.0));
red 1487 magick/fx.c case RedChannel: return(QuantumScale*pixel.red);
red 1621 magick/fx.c return(QuantumScale*pixel.red);
red 1668 magick/fx.c ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red 1712 magick/fx.c ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red 1721 magick/fx.c luma=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
red 1729 magick/fx.c luminance=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
red 1789 magick/fx.c return(QuantumScale*pixel.red);
red 1802 magick/fx.c ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
red 3757 magick/fx.c SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/2.0,
red 3777 magick/fx.c SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/
red 3806 magick/fx.c SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/
red 3830 magick/fx.c SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+
red 3831 magick/fx.c v.red)/2.0,plasma));
red 3857 magick/fx.c SetPixelRed(q,PlasmaPixel(random_info,(MagickRealType) (u.red+v.red)/2.0,
red 4352 magick/fx.c SetPixelRed(q,border_image->background_color.red);
red 4511 magick/fx.c pixel.red=(MagickRealType) (QuantumRange*
red 4513 magick/fx.c pixel.green=pixel.red;
red 4514 magick/fx.c pixel.blue=pixel.red;
red 4516 magick/fx.c pixel.index=pixel.red;
red 4643 magick/fx.c if ((double) image->colormap[i].red > threshold)
red 4644 magick/fx.c image->colormap[i].red=QuantumRange-image->colormap[i].red;
red 5300 magick/fx.c pixel.red=geometry_info.rho;
red 5310 magick/fx.c color_vector.red=(MagickRealType) (pixel.red*tint.red/100.0-
red 5357 magick/fx.c pixel.red=(MagickRealType) GetPixelRed(p)+color_vector.red*(1.0-(4.0*
red 5359 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 877 magick/gem.c r=(double) red;
red 886 magick/gem.c if (red == (Quantum) max)
red 944 magick/gem.c r=(double) red;
red 953 magick/gem.c if (red == (Quantum) max)
red 1014 magick/gem.c r=(double) red;
red 1083 magick/gem.c *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
red 1090 magick/gem.c *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red 1092 magick/gem.c alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
red 1141 magick/gem.c max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
red 1143 magick/gem.c min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red 1153 magick/gem.c if (max == (QuantumScale*red))
red 1161 magick/gem.c *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red 1163 magick/gem.c *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red 1213 magick/gem.c max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
red 1215 magick/gem.c min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
red 1225 magick/gem.c if (max == (QuantumScale*red))
red 1233 magick/gem.c *hue=2.0+(QuantumScale*blue-QuantumScale*red)/c;
red 1235 magick/gem.c *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
red 1286 magick/gem.c r=(double) red;
red 1359 magick/gem.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red 1420 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 354 magick/identify.c match=fabs((double) (p->red-target)) < 0.5 ? MagickTrue : MagickFalse;
red 1876 magick/image.c if ((pixel.red < 0.0) || (pixel.red > QuantumRange) ||
red 1877 magick/image.c (pixel.red != (QuantumAny) pixel.red))
red 1327 magick/mac.c image->colormap[x].red=
red 1328 magick/mac.c (*(picture_info.theColorTable))->ctTable[x].rgb.red;
red 1368 magick/mac.c SetPixelRed(q,ScaleCharToQuantum(Pixel.red & 0xff));
red 968 magick/matrix.c q->red=ClampToQuantum(value);
red 969 magick/matrix.c q->green=q->red;
red 970 magick/matrix.c q->blue=q->red;
red 2714 magick/morphology.c result.red =
red 2737 magick/morphology.c result.red += (*k)*GetPixelRed(k_pixels);
red 2748 magick/morphology.c SetPixelRed(q,ClampToQuantum(result.red));
red 2782 magick/morphology.c result.red += alpha*GetPixelRed(k_pixels);
red 2796 magick/morphology.c SetPixelRed(q,ClampToQuantum(gamma*result.red));
red 2805 magick/morphology.c if ( ( p[r].red != GetPixelRed(q))
red 2917 magick/morphology.c min.red =
red 2922 magick/morphology.c max.red =
red 2928 magick/morphology.c result.red = (double) p[r].red;
red 2939 magick/morphology.c result.red =
red 2948 magick/morphology.c result.red = 0.0; /* result is not used otherwise */
red 2985 magick/morphology.c result.red += (*k)*k_pixels[u].red;
red 2996 magick/morphology.c SetPixelRed(q,ClampToQuantum((MagickRealType) result.red));
red 3029 magick/morphology.c result.red += alpha*k_pixels[u].red;
red 3043 magick/morphology.c SetPixelRed(q,ClampToQuantum((MagickRealType) (gamma*result.red)));
red 3068 magick/morphology.c Minimize(min.red, (double) k_pixels[u].red);
red 3099 magick/morphology.c Maximize(max.red, (double) k_pixels[u].red);
red 3135 magick/morphology.c Minimize(min.red, (double) k_pixels[u].red);
red 3146 magick/morphology.c Maximize(max.red, (double) k_pixels[u].red);
red 3160 magick/morphology.c min.red -= max.red; Maximize( min.red, 0.0 );
red 3182 magick/morphology.c if ( result.red == 0.0 ||
red 3187 magick/morphology.c if ( result.red > 0.0 ) changes[id]++;
red 3188 magick/morphology.c result.red = 1.0;
red 3213 magick/morphology.c if ( result.red == 0.0 ||
red 3217 magick/morphology.c if ( result.red > 0.0 ) changes[id]++;
red 3218 magick/morphology.c result.red = 1.0;
red 3256 magick/morphology.c Minimize(result.red, (*k)+k_pixels[u].red);
red 3290 magick/morphology.c result.red -= min.red;
red 3298 magick/morphology.c result.red += min.red;
red 3317 magick/morphology.c SetPixelRed(q,ClampToQuantum(result.red));
red 3331 magick/morphology.c if ( ( p[r].red != GetPixelRed(q) )
red 3515 magick/morphology.c Minimize(result.red, (*k)+k_pixels[u].red);
red 3532 magick/morphology.c Minimize(result.red, (*k)+k_pixels[u].red);
red 3590 magick/morphology.c SetPixelRed(q,ClampToQuantum(result.red));
red 3603 magick/morphology.c if ( ( p[r].red != GetPixelRed(q) )
red 3708 magick/morphology.c Minimize(result.red, (*k)+k_pixels[u].red);
red 3725 magick/morphology.c Minimize(result.red, (*k)+k_pixels[u].red);
red 3781 magick/morphology.c SetPixelRed(q,ClampToQuantum(result.red));
red 3794 magick/morphology.c if ( ( p[r].red != GetPixelRed(q) )
red 359 magick/paint.c SetPixelRed(q,ClampToQuantum(fill.red));
red 856 magick/paint.c SetPixelRed(q,ClampToQuantum(conform_fill.red));
red 1134 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 81 magick/pixel-accessor.h #define SetPixelRed(pixel,value) ((pixel)->red=(Quantum) (value))
red 84 magick/pixel-accessor.h SetPixelRed(pixel,(packet)->red); \
red 90 magick/pixel-accessor.h SetPixelRed(pixel,(packet)->red); \
red 97 magick/pixel-accessor.h SetPixelRed(pixel,(packet)->red); \
red 103 magick/pixel-accessor.h #define SetPixelY(pixel,value) ((pixel)->red=(Quantum) (value))
red 148 magick/pixel-accessor.h intensity=0.212656f*gamma*pixel->red+0.715158f*gamma*pixel->green+
red 166 magick/pixel-accessor.h intensity=0.212656f*gamma*pixel->red+0.715158f*gamma*pixel->green+
red 170 magick/pixel-accessor.h intensity=0.212656f*DecodePixelGamma(gamma*pixel->red)+
red 198 magick/pixel-accessor.h red_green=(MagickRealType) pixel->red-pixel->green;
red 211 magick/pixel-accessor.h if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
red 212 magick/pixel-accessor.h return(pixel->red);
red 213 magick/pixel-accessor.h intensity=0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
red 220 magick/pixel-accessor.h pixel->red=ClampToQuantum(magick_pixel->red);
red 81 magick/pixel-private.h pixel->red=(MagickRealType) GetPixelRed(color);
red 96 magick/pixel-private.h pixel->red=image->bias;
red 106 magick/pixel-private.h SetPixelRed(color,ClampToQuantum(pixel->red));
red 2119 magick/pixel.c red;
red 2124 magick/pixel.c red=gamma*pixel->red;
red 2131 magick/pixel.c intensity=(red+green+blue)/3.0;
red 2136 magick/pixel.c intensity=MagickMax(MagickMax(red,green),blue);
red 2141 magick/pixel.c intensity=(MagickMin(MagickMin(red,green),blue)+
red 2142 magick/pixel.c MagickMax(MagickMax(red,green),blue))/2.0;
red 2147 magick/pixel.c intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
red 2155 magick/pixel.c red=EncodePixelGamma(red);
red 2159 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2166 magick/pixel.c red=DecodePixelGamma(red);
red 2170 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2178 magick/pixel.c red=EncodePixelGamma(red);
red 2182 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2189 magick/pixel.c red=DecodePixelGamma(red);
red 2193 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2198 magick/pixel.c intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
red 2238 magick/pixel.c pixel->red=0.0;
red 2297 magick/pixel.c red;
red 2302 magick/pixel.c red=gamma*pixel->red;
red 2309 magick/pixel.c intensity=(red+green+blue)/3.0;
red 2314 magick/pixel.c intensity=MagickMax(MagickMax(red,green),blue);
red 2319 magick/pixel.c intensity=(MagickMin(MagickMin(red,green),blue)+
red 2320 magick/pixel.c MagickMax(MagickMax(red,green),blue))/2.0;
red 2325 magick/pixel.c intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
red 2333 magick/pixel.c red=EncodePixelGamma(red);
red 2337 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2344 magick/pixel.c red=DecodePixelGamma(red);
red 2348 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
red 2356 magick/pixel.c red=EncodePixelGamma(red);
red 2360 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2367 magick/pixel.c red=DecodePixelGamma(red);
red 2371 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
red 2376 magick/pixel.c intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
red 4349 magick/pixel.c pixel->red=(MagickRealType) GetPixelRed(color);
red 4361 magick/pixel.c pixel->red=(*alpha*GetPixelRed(color));
red 4502 magick/pixel.c pixel->red=0.0;
red 4513 magick/pixel.c pixel->red+=gamma*pixels[0].red;
red 4520 magick/pixel.c pixel->red*=gamma;
red 4562 magick/pixel.c pixel->red=gamma*(epsilon.y*(epsilon.x*pixels[0].red+delta.x*
red 4563 magick/pixel.c pixels[1].red)+delta.y*(epsilon.x*pixels[2].red+delta.x*pixels[3].red));
red 4608 magick/pixel.c pixels[i].red+=pixels[i+2].red;
red 4625 magick/pixel.c pixels[0].red+=pixels[1].red;
red 4633 magick/pixel.c pixel->red=alpha[0]*pixels[0].red;
red 4662 magick/pixel.c pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
red 4663 magick/pixel.c pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
red 4664 magick/pixel.c pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
red 4665 magick/pixel.c pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
red 4666 magick/pixel.c pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
red 4667 magick/pixel.c pixels[14].red+cx[3]*pixels[15].red));
red 4780 magick/pixel.c pixel->red=gamma*MeshInterpolate(&delta,pixels[2].red,
red 4781 magick/pixel.c pixels[3].red,pixels[0].red);
red 4801 magick/pixel.c pixel->red=gamma*MeshInterpolate(&delta,pixels[1].red,
red 4802 magick/pixel.c pixels[0].red,pixels[3].red);
red 4827 magick/pixel.c pixel->red=gamma*MeshInterpolate(&delta,pixels[0].red,
red 4828 magick/pixel.c pixels[1].red,pixels[2].red);
red 4849 magick/pixel.c pixel->red=gamma*MeshInterpolate(&delta,pixels[3].red,
red 4850 magick/pixel.c pixels[2].red,pixels[1].red);
red 4899 magick/pixel.c pixel->red=(cy[0]*(cx[0]*pixels[0].red+cx[1]*pixels[1].red+cx[2]*
red 4900 magick/pixel.c pixels[2].red+cx[3]*pixels[3].red)+cy[1]*(cx[0]*pixels[4].red+cx[1]*
red 4901 magick/pixel.c pixels[5].red+cx[2]*pixels[6].red+cx[3]*pixels[7].red)+cy[2]*(cx[0]*
red 4902 magick/pixel.c pixels[8].red+cx[1]*pixels[9].red+cx[2]*pixels[10].red+cx[3]*
red 4903 magick/pixel.c pixels[11].red)+cy[3]*(cx[0]*pixels[12].red+cx[1]*pixels[13].red+cx[2]*
red 4904 magick/pixel.c pixels[14].red+cx[3]*pixels[15].red));
red 87 magick/pixel.h red,
red 97 magick/pixel.h red,
red 122 magick/pixel.h red,
red 136 magick/pixel.h red,
red 145 magick/pixel.h red,
red 153 magick/pixel.h red,
red 2163 magick/property.c pixel.red=(MagickRealType) QuantumRange*alpha;
red 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 781 magick/quantize.c midpoint.red=(MagickRealType) QuantumRange/2.0;
red 826 magick/quantize.c mid.red+=(id & 1) != 0 ? bisect : -bisect;
red 850 magick/quantize.c error.red=QuantumScale*(pixel.red-mid.red);
red 855 magick/quantize.c distance=(double) (error.red*error.red+error.green*error.green+
red 867 magick/quantize.c node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
red 924 magick/quantize.c mid.red+=(id & 1) != 0 ? bisect : -bisect;
red 948 magick/quantize.c error.red=QuantumScale*(pixel.red-mid.red);
red 953 magick/quantize.c distance=(double) (error.red*error.red+error.green*error.green+
red 965 magick/quantize.c node_info->total_color.red+=count*QuantumScale*ClampPixel(pixel.red);
red 1233 magick/quantize.c QuantumRange*node_info->total_color.red)));
red 1251 magick/quantize.c QuantumRange*node_info->total_color.red)));
red 1265 magick/quantize.c gamma*QuantumRange*node_info->total_color.red)));
red 1439 magick/quantize.c offset=(ssize_t) (RedShift(ScaleQuantumToChar(ClampPixel(pixel->red))) |
red 1531 magick/quantize.c pixel.red+=7*current[u-v].red/16;
red 1541 magick/quantize.c pixel.red+=previous[u+v].red/16;
red 1547 magick/quantize.c pixel.red+=5*previous[u].red/16;
red 1554 magick/quantize.c pixel.red+=3*previous[u-v].red/16;
red 1561 magick/quantize.c pixel.red=(MagickRealType) ClampPixel(pixel.red);
red 1613 magick/quantize.c current[u].red=pixel.red-color.red;
red 1772 magick/quantize.c pixel.red+=p->weights[i]*p->error[i].red;
red 1778 magick/quantize.c pixel.red=(MagickRealType) ClampPixel(pixel.red);
red 1832 magick/quantize.c p->error[ErrorQueueLength-1].red=pixel.red-color.red;
red 2168 magick/quantize.c image->colormap[index].red));
red 2328 magick/quantize.c image->colormap[i].red=PosterizePixel(image->colormap[i].red);
red 2462 magick/quantize.c parent->total_color.red+=node_info->total_color.red;
red 2641 magick/quantize.c image->colormap[i].red=GetPixelRed(q);
red 3391 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 682 magick/resample.c pixel->red = (MagickRealType) ClampToQuantum(divisor_c*pixel->red);
red 1934 magick/resize.c pixel.red=QuantumRange*(packet[0]/255.0);
red 2573 magick/resize.c pixel.red+=alpha*GetPixelRed(p+j);
red 2578 magick/resize.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 2606 magick/resize.c pixel.red+=alpha*GetPixelRed(p+j);
red 2613 magick/resize.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 2819 magick/resize.c pixel.red+=alpha*GetPixelRed(p+j);
red 2824 magick/resize.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 2852 magick/resize.c pixel.red+=alpha*GetPixelRed(p+j);
red 2859 magick/resize.c SetPixelRed(q,ClampToQuantum(gamma*pixel.red));
red 3393 magick/resize.c x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red 3428 magick/resize.c x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red 3442 magick/resize.c y_vector[x].red+=scale.y*x_vector[x].red;
red 3471 magick/resize.c x_vector[x].red=(MagickRealType) (alpha*GetPixelRed(p));
red 3487 magick/resize.c pixel.red=y_vector[x].red+span.y*x_vector[x].red;
red 3494 magick/resize.c s->red=pixel.red;
red 3523 magick/resize.c SetPixelRed(q,ClampToQuantum(alpha*s->red));
red 3554 magick/resize.c pixel.red+=span.x*s->red;
red 3561 magick/resize.c t->red=pixel.red;
red 3580 magick/resize.c pixel.red+=scale.x*s->red;
red 3594 magick/resize.c pixel.red+=span.x*s->red;
red 3605 magick/resize.c t->red=pixel.red;
red 3622 magick/resize.c SetPixelRed(q,ClampToQuantum(alpha*t->red));
red 140 magick/segment.c red,
red 263 magick/segment.c red;
red 292 magick/segment.c (void) ResetMagickMemory(&red,0,sizeof(red));
red 295 magick/segment.c while (DefineRegion(extrema[Red],&red) != 0)
red 324 magick/segment.c cluster->red=red;
red 344 magick/segment.c cluster->red=red;
red 373 magick/segment.c (cluster->red.left-SafeMargin)) &&
red 375 magick/segment.c (cluster->red.right+SafeMargin)) &&
red 389 magick/segment.c cluster->red.center+=(MagickRealType) ScaleQuantumToChar(GetPixelRed(p));
red 429 magick/segment.c cluster->red.center/=cluster->count;
red 479 magick/segment.c cluster->red.left,(double) cluster->red.right,(double)
red 494 magick/segment.c cluster->red.center,(double) cluster->green.center,(double)
red 520 magick/segment.c image->colormap[i].red=ScaleCharToQuantum((unsigned char)
red 521 magick/segment.c (cluster->red.center+0.5));
red 568 magick/segment.c if (((ssize_t) ScaleQuantumToChar(q->red) >=
red 569 magick/segment.c (cluster->red.left-SafeMargin)) &&
red 570 magick/segment.c ((ssize_t) ScaleQuantumToChar(q->red) <=
red 571 magick/segment.c (cluster->red.right+SafeMargin)) &&
red 609 magick/segment.c distance_squared=squares[(ssize_t) ScaleQuantumToChar(q->red)-
red 619 magick/segment.c distance_squared=squares[(ssize_t) ScaleQuantumToChar(q->red)-
red 944 magick/segment.c red;
red 1006 magick/segment.c (void) ResetMagickMemory(&red,0,sizeof(red));
red 1009 magick/segment.c while (DefineRegion(extrema[Red],&red) != 0)
red 1042 magick/segment.c cluster->red=red;
red 1065 magick/segment.c cluster->red=red;
red 1084 magick/segment.c (cluster->red.left-SafeMargin)) &&
red 1086 magick/segment.c (cluster->red.right+SafeMargin)) &&
red 1100 magick/segment.c cluster->red.center+=(MagickRealType)
red 1132 magick/segment.c cluster->red.center/=cluster->count;
red 1169 magick/segment.c threshold=(background->red.center+object->red.center)/2.0;
red 1170 magick/segment.c pixel->red=(MagickRealType) ScaleCharToQuantum((unsigned char)
red 546 magick/shear.c background.red+=QuantumScale*GetPixelRed(p);
red 555 magick/shear.c image->background_color.red=ClampToQuantum((MagickRealType) QuantumRange*
red 556 magick/shear.c background.red/count);
red 557 magick/statistic.c evaluate_pixel[i].red=ApplyEvaluateOperator(random_info[id],
red 558 magick/statistic.c GetPixelRed(p),op,evaluate_pixel[i].red);
red 573 magick/statistic.c SetPixelRed(q,ClampToQuantum(evaluate_pixel[i/2].red));
red 662 magick/statistic.c evaluate_pixel[x].red=ApplyEvaluateOperator(random_info[id],
red 664 magick/statistic.c evaluate_pixel[x].red);
red 686 magick/statistic.c evaluate_pixel[x].red/=number_images;
red 695 magick/statistic.c evaluate_pixel[x].red=sqrt((double) evaluate_pixel[x].red/
red 714 magick/statistic.c evaluate_pixel[x].red*=(MagickRealType) QuantumScale;
red 723 magick/statistic.c SetPixelRed(q,ClampToQuantum(evaluate_pixel[x].red));
red 1700 magick/statistic.c M00[RedChannel]+=QuantumScale*pixel.red;
red 1701 magick/statistic.c M10[RedChannel]+=x*QuantumScale*pixel.red;
red 1702 magick/statistic.c M01[RedChannel]+=y*QuantumScale*pixel.red;
red 1762 magick/statistic.c centroid[RedChannel].y)*QuantumScale*pixel.red;
red 1764 magick/statistic.c centroid[RedChannel].x)*QuantumScale*pixel.red;
red 1766 magick/statistic.c centroid[RedChannel].y)*QuantumScale*pixel.red;
red 1769 magick/statistic.c pixel.red;
red 1772 magick/statistic.c pixel.red;
red 1775 magick/statistic.c centroid[RedChannel].y)*QuantumScale*pixel.red;
red 1778 magick/statistic.c pixel.red;
red 1781 magick/statistic.c pixel.red;
red 2196 magick/statistic.c if (pixel.red < *minima)
red 2197 magick/statistic.c *minima=(double) pixel.red;
red 2198 magick/statistic.c if (pixel.red > *maxima)
red 2199 magick/statistic.c *maxima=(double) pixel.red;
red 2432 magick/statistic.c histogram[ScaleQuantumToMap(GetPixelRed(p))].red++;
red 2494 magick/statistic.c if (histogram[i].red > 0.0)
red 2495 magick/statistic.c number_bins.red++;
red 2500 magick/statistic.c if ((image->matte != MagickFalse) && (histogram[i].red > 0.0))
red 2502 magick/statistic.c if ((image->colorspace == CMYKColorspace) && (histogram[i].red > 0.0))
red 2507 magick/statistic.c histogram[i].red/=area;
red 2508 magick/statistic.c channel_statistics[RedChannel].entropy+=-histogram[i].red*
red 2509 magick/statistic.c MagickLog10(histogram[i].red)/MagickLog10((double) number_bins.red);
red 2779 magick/statistic.c polynomial_pixel[x].red+=coefficient*pow(QuantumScale*p->red,degree);
red 2800 magick/statistic.c SetPixelRed(q,ClampToQuantum(QuantumRange*polynomial_pixel[x].red));
red 3082 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3127 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3167 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3210 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3258 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3307 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3353 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3407 magick/statistic.c pixel->red=(MagickRealType) ScaleShortToQuantum(channels[0]);
red 3637 magick/statistic.c pixel.red=MagickAbsoluteValue(maximum.red-minimum.red);
red 3688 magick/statistic.c SetPixelRed(q,ClampToQuantum(pixel.red));
red 275 magick/threshold.c channel_bias.red+=r[u].red;
red 283 magick/threshold.c channel_sum.red+=r[u].red;
red 299 magick/threshold.c channel_sum.red-=channel_bias.red;
red 307 magick/threshold.c channel_bias.red+=r[0].red;
red 313 magick/threshold.c channel_sum.red+=r[width-1].red;
red 322 magick/threshold.c mean.red=(MagickRealType) (channel_sum.red/number_pixels+offset);
red 328 magick/threshold.c SetPixelRed(q,((MagickRealType) GetPixelRed(q) <= mean.red) ?
red 615 magick/threshold.c threshold.red=geometry_info.rho;
red 618 magick/threshold.c threshold.green=threshold.red;
red 621 magick/threshold.c threshold.blue=threshold.red;
red 624 magick/threshold.c threshold.opacity=threshold.red;
red 627 magick/threshold.c threshold.index=threshold.red;
red 630 magick/threshold.c threshold.red*=(MagickRealType) (QuantumRange/100.0);
red 672 magick/threshold.c ((MagickRealType) GetPixelRed(q) < threshold.red))
red 1495 magick/threshold.c levels.red = ((channel & RedChannel ) != 0) ? levels.index : 0;
red 1507 magick/threshold.c levels.red = (unsigned int) strtoul(p, &p, 10), (void)(*p == ',' && p++);
red 1533 magick/threshold.c levels.red, levels.green, levels.blue, levels.opacity, levels.index);
red 1544 magick/threshold.c levels.red = levels.red ? levels.red-1 : 0;
red 1606 magick/threshold.c if (levels.red) {
red 1607 magick/threshold.c t = (ssize_t) (QuantumScale*GetPixelRed(q)*(levels.red*d+1));
red 1610 magick/threshold.c ((l+(t >= threshold))*(MagickRealType) QuantumRange/levels.red)));
red 2069 magick/threshold.c threshold.red=min_threshold;
red 2072 magick/threshold.c threshold.red=max_threshold;
red 2074 magick/threshold.c threshold.red=(MagickRealType) (QuantumRange*
red 2123 magick/threshold.c SetPixelRed(q,(MagickRealType) GetPixelRed(q) <= threshold.red ?
red 2241 magick/threshold.c threshold.red=geometry_info.rho;
red 2244 magick/threshold.c threshold.green=threshold.red;
red 2247 magick/threshold.c threshold.blue=threshold.red;
red 2250 magick/threshold.c threshold.opacity=threshold.red;
red 2253 magick/threshold.c threshold.index=threshold.red;
red 2256 magick/threshold.c threshold.red*=(MagickRealType) (QuantumRange/100.0);
red 2298 magick/threshold.c ((MagickRealType) GetPixelRed(q) > threshold.red))
red 196 magick/vision.c i=(ssize_t) p->red;
red 259 magick/vision.c j=(ssize_t) p->red;
red 293 magick/vision.c if ((ssize_t) q->red == i)
red 295 magick/vision.c q->red=(Quantum) id;
red 296 magick/vision.c q->green=q->red;
red 297 magick/vision.c q->blue=q->red;
red 377 magick/vision.c i=(ssize_t) q->red;
red 386 magick/vision.c object[i].color.red+=p->red;
red 404 magick/vision.c object[i].color.red=object[i].color.red/object[i].area;
red 657 magick/vision.c q->red=(Quantum) (id > (ssize_t) QuantumRange ? (ssize_t) QuantumRange :
red 659 magick/vision.c q->green=q->red;
red 660 magick/vision.c q->blue=q->red;
red 2088 magick/widget.c windows->widget.pixel_info->matte_color.red,
red 599 magick/xwindow-private.h if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
red 600 magick/xwindow-private.h return((MagickRealType) pixel->red);
red 601 magick/xwindow-private.h intensity=0.21265*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
red 112 magick/xwindow.c ((ScaleQuantumToShort(XRedGamma((color)->red))*map->red_max/65535L)* \
red 125 magick/xwindow.c (((color)->red*map->red_max/65535L)*map->red_mult)+ \
red 175 magick/xwindow.c red,
red 574 magick/xwindow.c SetPixelRed(q,ScaleShortToQuantum(pixel->box_color.red));
red 586 magick/xwindow.c SetPixelRed(q,ScaleShortToQuantum(pixel->pen_color.red));
red 1053 magick/xwindow.c pixel.red=colors[i].red-(MagickRealType) color->red;
red 1054 magick/xwindow.c distance=pixel.red*pixel.red;
red 2171 magick/xwindow.c color.red=ClampToQuantum((MagickRealType) (red_map[i][j][(int)
red 2177 magick/xwindow.c pixel=(size_t) (((size_t) color.red & 0xe0) |
red 2448 magick/xwindow.c SetPixelRed(q,ScaleShortToQuantum(pixel->pen_color.red));
red 3072 magick/xwindow.c pixel->highlight_color.red=(unsigned short) (((MagickRealType)
red 3073 magick/xwindow.c pixel->matte_color.red*ScaleQuantumToShort(HighlightModulate))/65535L+
red 3087 magick/xwindow.c pixel->shadow_color.red=(unsigned short) (((MagickRealType)
red 3088 magick/xwindow.c pixel->matte_color.red*ScaleQuantumToShort(ShadowModulate))/65535L);
red 3098 magick/xwindow.c pixel->depth_color.red=(unsigned short) (((MagickRealType)
red 3099 magick/xwindow.c pixel->matte_color.red*ScaleQuantumToShort(DepthModulate))/65535L);
red 3109 magick/xwindow.c pixel->trough_color.red=(unsigned short) (((MagickRealType)
red 3110 magick/xwindow.c pixel->matte_color.red*ScaleQuantumToShort(TroughModulate))/65535L);
red 3858 magick/xwindow.c pixel.red=ScaleShortToQuantum(color.red);
red 4214 magick/xwindow.c red,
red 4220 magick/xwindow.c red=0;
red 4231 magick/xwindow.c colors[i].pixel=(unsigned long) (red | green | blue);
red 4233 magick/xwindow.c red+=red_bit;
red 4234 magick/xwindow.c if (red > window_info[id].visual->red_mask)
red 4235 magick/xwindow.c red=0;
red 4335 magick/xwindow.c colors[index].red));
red 4392 magick/xwindow.c composite_image->colormap[colors[i].pixel].red=
red 4393 magick/xwindow.c ScaleShortToQuantum(colors[i].red);
red 7564 magick/xwindow.c intensity=0.298839*pixel->red+0.586811*pixel->green+0.114350*pixel->blue;
red 7775 magick/xwindow.c color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
red 7781 magick/xwindow.c color.red=gray_value;
red 7862 magick/xwindow.c diversity[i].red=image->colormap[i].red;
red 7907 magick/xwindow.c color.red=
red 7908 magick/xwindow.c ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
red 7916 magick/xwindow.c color.red=gray_value;
red 7944 magick/xwindow.c color.red=
red 7945 magick/xwindow.c ScaleQuantumToShort(XRedGamma(image->colormap[index].red));
red 7953 magick/xwindow.c color.red=gray_value;
red 8036 magick/xwindow.c color.red=ScaleQuantumToShort(XRedGamma(image->colormap[i].red));
red 8042 magick/xwindow.c color.red=gray_value;
red 8092 magick/xwindow.c color.red=color.blue;
red 8099 magick/xwindow.c color.red=(unsigned short) 0;
red 8101 magick/xwindow.c color.red=(unsigned short) ((size_t)
red 8139 magick/xwindow.c pixel->background_color.red=(~pixel->foreground_color.red);
red 8559 magick/xwindow.c color->red=0;
red 8578 magick/xwindow.c color->red=xcolor.red;
red 9034 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 255 tests/validate.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
red 274 tests/validate.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red 304 tests/validate.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
red 331 tests/validate.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
red 337 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 338 tests/validate.c *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
red 339 tests/validate.c *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
red 345 tests/validate.c *red=ClampToQuantum(QuantumRange*(Y+9.2303716147657e-05*(Db-0.5)-
red 356 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 357 tests/validate.c *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
red 358 tests/validate.c *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
red 364 tests/validate.c *red=ClampToQuantum(QuantumRange*(Y+0.9562957197589482261*(I-0.5)+
red 375 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
red 376 tests/validate.c *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
red 377 tests/validate.c *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
red 383 tests/validate.c *red=ClampToQuantum(QuantumRange*(Y-3.945707070708279e-05*(U-0.5)+
red 297 wand/drawing-wand.c pixel.red=(MagickRealType) GetPixelRed(color);
red 2380 wand/drawing-wand.c pixel->red=(MagickRealType) GetPixelRed(color);
red 576 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);