green 201 Magick++/lib/Color.cpp greenQuantum( target_color.green );
green 232 Magick++/lib/Color.cpp pixel.green=_pixel->green;
green 335 Magick++/lib/Color.cpp green,
green 338 Magick++/lib/Color.cpp ConvertHSLToRGB(hue_,saturation_,luminosity_,&red,&green,&blue);
green 341 Magick++/lib/Color.cpp greenQuantum(green);
green 365 Magick++/lib/Color.cpp green,
green 373 Magick++/lib/Color.cpp ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
green 376 Magick++/lib/Color.cpp greenQuantum(green);
green 402 Magick++/lib/Color.cpp green,
green 410 Magick++/lib/Color.cpp ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
green 413 Magick++/lib/Color.cpp greenQuantum(green);
green 439 Magick++/lib/Color.cpp green,
green 447 Magick++/lib/Color.cpp ConvertHSLToRGB(hue,saturation,luminosity,&red,&green,&blue);
green 450 Magick++/lib/Color.cpp greenQuantum(green);
green 1127 Magick++/lib/Image.cpp return(Color(constImage()->matte_color.red,constImage()->matte_color.green,
green 2924 Magick++/lib/Image.cpp target.green=pixel.green;
green 2952 Magick++/lib/Image.cpp target.green=pixel.green;
green 3341 Magick++/lib/Image.cpp black.green=pixel.green;
green 3348 Magick++/lib/Image.cpp white.green=pixel.green;
green 3372 Magick++/lib/Image.cpp black.green=pixel.green;
green 3379 Magick++/lib/Image.cpp white.green=pixel.green;
green 4452 Magick++/lib/Image.cpp statistics->green.minimum=minimum;
green 4453 Magick++/lib/Image.cpp statistics->green.maximum=maximum;
green 4454 Magick++/lib/Image.cpp (void) GetImageChannelMean(constImage(),GreenChannel,&statistics->green.mean,
green 4455 Magick++/lib/Image.cpp &statistics->green.standard_deviation,exceptionInfo);
green 4457 Magick++/lib/Image.cpp &statistics->green.kurtosis,&statistics->green.skewness,exceptionInfo);
green 5063 Magick++/lib/Image.cpp target.green=target_->green;
green 110 Magick++/lib/Magick++/Color.h return (0.299*(_pixel->red)+0.587*(_pixel->green)+0.114*(_pixel->blue));
green 315 Magick++/lib/Magick++/Color.h void green(double green_);
green 316 Magick++/lib/Magick++/Color.h double green(void) const;
green 414 Magick++/lib/Magick++/Color.h _pixel->green=green_;
green 420 Magick++/lib/Magick++/Color.h return _pixel->green;
green 437 Magick++/lib/Magick++/Color.h _pixel->green=0;
green 81 Magick++/lib/Magick++/Image.h ImageChannelStatistics green;
green 35 Magick++/tests/color.cpp double green;
green 58 Magick++/tests/color.cpp colorMap[i].green,
green 524 coders/bmp.c green,
green 903 coders/bmp.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 1023 coders/bmp.c while (((bmp_info.green_mask << shift.green) & 0x80000000UL) == 0)
green 1024 coders/bmp.c shift.green++;
green 1035 coders/bmp.c sample=shift.green;
green 1038 coders/bmp.c quantum_bits.green=ClampToQuantum((MagickRealType) sample-shift.green);
green 1215 coders/bmp.c green=((pixel & bmp_info.green_mask) << shift.green) >> 16;
green 1216 coders/bmp.c if (quantum_bits.green == 5)
green 1217 coders/bmp.c green|=((green & 0xe000) >> 5);
green 1218 coders/bmp.c if (quantum_bits.green == 6)
green 1219 coders/bmp.c green|=((green & 0xc000) >> 6);
green 1220 coders/bmp.c if (quantum_bits.green <= 8)
green 1221 coders/bmp.c green|=((green & 0xff00) >> 8);
green 1228 coders/bmp.c SetPixelGreen(q,ScaleShortToQuantum((unsigned short) green));
green 1318 coders/bmp.c green=((pixel & bmp_info.green_mask) << shift.green) >> 16;
green 1319 coders/bmp.c if (quantum_bits.green == 8)
green 1320 coders/bmp.c green|=(green >> 8);
green 1325 coders/bmp.c SetPixelGreen(q,ScaleShortToQuantum((unsigned short) green));
green 2121 coders/bmp.c *q++=ScaleQuantumToChar(image->colormap[i].green);
green 467 coders/cut.c image->colormap[i].green=(Quantum) ReadBlobLSBShort(palette);
green 470 coders/cut.c image->colormap[i].green=ClampToQuantum
green 471 coders/cut.c (((double) image->colormap[i].green*QuantumRange+(PalHeader.MaxGreen>>1))/PalHeader.MaxGreen);
green 499 coders/cut.c image->colormap[i].green=ScaleCharToQuantum((unsigned char) i);
green 571 coders/cut.c if(image->colormap[i].green!=sample) goto Finish;
green 575 coders/cut.c image->colormap[1].red=image->colormap[1].green=
green 3713 coders/dcm.c image->colormap[i].green=(Quantum) index;
green 3730 coders/dcm.c image->colormap[i].green=(Quantum) index;
green 3906 coders/dcm.c pixel.green=1U*image->colormap[index].green;
green 3914 coders/dcm.c pixel.green=(unsigned int) ReadDCMByte(stream_info,image);
green 3920 coders/dcm.c pixel.green=ReadDCMShort(stream_info,image);
green 3924 coders/dcm.c pixel.green&=mask;
green 3929 coders/dcm.c pixel.green=scale[pixel.green];
green 3934 coders/dcm.c SetPixelGreen(q,pixel.green);
green 4018 coders/dcm.c pixel.green=1U*image->colormap[index].green;
green 4026 coders/dcm.c pixel.green=(unsigned int) ReadDCMByte(stream_info,image);
green 4032 coders/dcm.c pixel.green=ReadDCMShort(stream_info,image);
green 4036 coders/dcm.c pixel.green&=mask;
green 4041 coders/dcm.c pixel.green=scale[pixel.green];
green 4048 coders/dcm.c (((size_t) pixel.green) << 8)));
green 233 coders/debug.c (double) pixel.red,(double) pixel.green,(double) pixel.blue);
green 631 coders/dib.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 1292 coders/dib.c *q++=ScaleQuantumToChar(image->colormap[i].green);
green 733 coders/djvu.c image->colormap[0].green=QuantumRange;
green 736 coders/djvu.c image->colormap[1].green=0;
green 280 coders/dps.c green,
green 289 coders/dps.c green=0;
green 296 coders/dps.c colors[i].pixel=red | green | blue;
green 301 coders/dps.c green+=green_bit;
green 302 coders/dps.c if (green > visual_info->green_mask)
green 303 coders/dps.c green=0;
green 386 coders/dps.c SetPixelGreen(q,ScaleShortToQuantum(colors[index].green));
green 442 coders/dps.c image->colormap[colors[i].pixel].green=
green 443 coders/dps.c ScaleShortToQuantum(colors[i].green);
green 607 coders/emf.c pBits->rgbGreen=ScaleQuantumToChar(image->background_color.green);
green 741 coders/emf.c image->background_color.green),(BYTE) ScaleQuantumToChar(
green 171 coders/fax.c image->colormap[0].green=QuantumRange;
green 174 coders/fax.c image->colormap[1].green=(Quantum) 0;
green 661 coders/fpx.c green=sqrt((double) green)-1.0;
green 680 coders/fpx.c green_effect.byc1=(-0.114)*green;
green 681 coders/fpx.c green_effect.byc2=(-0.299)*green;
green 683 coders/fpx.c green_effect.bc1y=(-0.587)*green;
green 684 coders/fpx.c green_effect.bc1c1=1.0-0.473*green;
green 685 coders/fpx.c green_effect.bc1c2=0.299*green;
green 687 coders/fpx.c green_effect.bc2y=(-0.587)*green;
green 688 coders/fpx.c green_effect.bc2c1=0.114*green;
green 689 coders/fpx.c green_effect.bc2c2=1.0-0.288*green;
green 1293 coders/gif.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 1333 coders/gif.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 1642 coders/gif.c image->colormap[opacity].green=image->transparent_color.green;
green 1655 coders/gif.c *q++=ScaleQuantumToChar(image->colormap[i].green);
green 138 coders/hald.c green,
green 153 coders/hald.c for (green=0; green < (ssize_t) cube_size; green++)
green 160 coders/hald.c (QuantumRange*green/(cube_size-1.0))));
green 271 coders/histogram.c histogram[ScaleQuantumToChar(GetPixelGreen(p))].green++;
green 282 coders/histogram.c if (((channel & GreenChannel) != 0) && (maximum < histogram[x].green))
green 283 coders/histogram.c maximum=histogram[x].green;
green 314 coders/histogram.c y=(ssize_t) ceil(histogram_image->rows-scale*histogram[x].green-0.5);
green 466 coders/icon.c image->colormap[i].green=(Quantum) ScaleCharToQuantum(*p++);
green 1295 coders/icon.c *q++=ScaleQuantumToChar(next->colormap[i].green);
green 220 coders/jbig.c image->colormap[0].green=0;
green 223 coders/jbig.c image->colormap[1].green=QuantumRange;
green 467 coders/jp2.c q->green=q->red;
green 479 coders/jp2.c q->green=ClampToQuantum(pixel);
green 1020 coders/jp2.c *q=(int) (scale*p->green);
green 1308 coders/jpeg.c image->colormap[i].green=image->colormap[i].red;
green 1316 coders/jpeg.c image->colormap[i].green=ScaleCharToQuantum(jpeg_info.colormap[1][i]);
green 589 coders/json.c match=fabs((double) (p->green-target)) < 0.5 ? MagickTrue :
green 187 coders/map.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 198 coders/map.c image->colormap[i].green=(Quantum) quantum;
green 408 coders/map.c *q++=(unsigned char) image->colormap[i].green;
green 416 coders/map.c *q++=(unsigned char) ((size_t) image->colormap[i].green >> 8);
green 417 coders/map.c *q++=(unsigned char) image->colormap[i].green;
green 227 coders/mat.c if ((int) f / 2.0 > q->green)
green 293 coders/mat.c if ((int) f / 2.0 > q->green)
green 1188 coders/miff.c image->colormap[i].green=ScaleCharToQuantum(pixel);
green 1204 coders/miff.c image->colormap[i].green=ScaleShortToQuantum(pixel);
green 1220 coders/miff.c image->colormap[i].green=ScaleLongToQuantum(pixel);
green 1511 coders/miff.c SetPixelGreen(q,pixel.green);
green 1827 coders/miff.c value=ScaleQuantumToLong(pixel.green);
green 1853 coders/miff.c value=ScaleQuantumToShort(pixel.green);
green 1879 coders/miff.c value=(unsigned char) ScaleQuantumToChar(pixel.green);
green 2350 coders/miff.c pixel=ScaleQuantumToLong(image->colormap[i].green);
green 2363 coders/miff.c pixel=ScaleQuantumToShort(image->colormap[i].green);
green 2377 coders/miff.c image->colormap[i].green);
green 882 coders/mpc.c image->colormap[i].green=ScaleCharToQuantum(pixel);
green 898 coders/mpc.c image->colormap[i].green=ScaleShortToQuantum(pixel);
green 914 coders/mpc.c image->colormap[i].green=ScaleLongToQuantum(pixel);
green 1417 coders/mpc.c pixel=ScaleQuantumToLong(image->colormap[i].green);
green 1430 coders/mpc.c pixel=ScaleQuantumToShort(image->colormap[i].green);
green 1444 coders/mpc.c image->colormap[i].green);
green 3164 coders/msl.c pixel.green=0.0;
green 3214 coders/msl.c pixel.green=StringToDouble(value,(char **) NULL);
green 3243 coders/msl.c (double) pixel.red,(double) pixel.green,(double) pixel.blue);
green 3259 coders/msl.c pixel.green);
green 361 coders/palm.c transpix.green=(MagickRealType) (QuantumRange*ReadBlobByte(image)/63);
green 378 coders/palm.c image->colormap[(int) index].green=ScaleCharToQuantum(
green 390 coders/palm.c image->colormap[(int) index].green=ScaleCharToQuantum(
green 749 coders/palm.c transpix.green=0;
green 826 coders/palm.c ScaleQuantumToChar(image->colormap[count].green));
green 883 coders/palm.c transpix.green=GetPixelGreen(p);
green 969 coders/palm.c (void) WriteBlobByte(image,(unsigned char) ((63*transpix.green)/QuantumRange));
green 402 coders/pango.c QuantumScale*draw_info->fill.green,QuantumScale*draw_info->fill.blue,
green 431 coders/pango.c fill_color.green=ScaleCharToQuantum(*p++);
green 440 coders/pango.c fill_color.green*=gamma;
green 770 coders/pcl.c ScaleQuantumToChar(image->colormap[i].green),
green 373 coders/pcx.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 465 coders/pcx.c image->colormap[0].green=(Quantum) 0;
green 468 coders/pcx.c image->colormap[1].green=QuantumRange;
green 483 coders/pcx.c image->colormap[i].green=ScaleCharToQuantum(*p++);
green 988 coders/pcx.c *q++=ScaleQuantumToChar(image->colormap[i].green);
green 2480 coders/pdf.c Ascii85Encode(image,ScaleQuantumToChar(image->colormap[i].green));
green 2487 coders/pdf.c ScaleQuantumToChar(image->colormap[i].green));
green 84 coders/pes.c green,
green 640 coders/pes.c "fill=\"none\" d=\"M %g %g",blocks[i].color->red,blocks[i].color->green,
green 1063 coders/pict.c image->background_color.green=(Quantum)
green 1175 coders/pict.c tile_image->colormap[j].green=(Quantum)
green 1187 coders/pict.c tile_image->colormap[i].green=(Quantum) (QuantumRange-
green 1188 coders/pict.c tile_image->colormap[i].green);
green 1243 coders/pict.c tile_image->colormap[(ssize_t) index].green);
green 1934 coders/pict.c image->colormap[i].green));
green 1986 coders/pict.c *green,
green 1991 coders/pict.c green=scanline+image->columns;
green 2000 coders/pict.c green=scanline+image->columns;
green 2006 coders/pict.c green=scanline+2*image->columns;
green 2012 coders/pict.c *green++=ScaleQuantumToChar(GetPixelGreen(p));
green 102 coders/pix.c green,
green 174 coders/pix.c green=(Quantum) 0;
green 194 coders/pix.c green=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
green 201 coders/pix.c SetPixelGreen(q,green);
green 126 coders/png.c ((color).green == (target).green) && \
green 184 coders/png.c (pixelpacket).green=(ScaleQuantumToChar((pixelpacket).green) < 0x10 ? \
green 251 coders/png.c unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).green) & 0xc0; \
green 252 coders/png.c (pixelpacket).green=ScaleCharToQuantum( \
green 334 coders/png.c unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).green) & 0xe0; \
green 335 coders/png.c (pixelpacket).green=ScaleCharToQuantum( \
green 390 coders/png.c unsigned char lbr_bits=ScaleQuantumToChar((pixelpacket).green) & 0xf0; \
green 391 coders/png.c (pixelpacket).green=ScaleCharToQuantum((lbr_bits | (lbr_bits >> 4))); \
green 866 coders/png.c QuantumToCharToQuantumEqQuantum(image->background_color.green) &&
green 880 coders/png.c image->colormap[indx].green) &&
green 1487 coders/png.c (a->colormap[i].green != b->colormap[i].green) ||
green 2080 coders/png.c transparent_color.green=65537;
green 2726 coders/png.c background.green=(png_uint_16)
green 2727 coders/png.c mng_info->global_plte[background.index].green;
green 2733 coders/png.c mng_info->global_plte[background.index].green;
green 2774 coders/png.c ping_background->green *= bkgd_scale;
green 2783 coders/png.c ping_background->red,ping_background->green,
green 2786 coders/png.c ping_background->green,ping_background->blue);
green 2792 coders/png.c image->background_color.green=
green 2793 coders/png.c ScaleShortToQuantum(ping_background->green);
green 2804 coders/png.c (double) image->background_color.green,
green 2830 coders/png.c (int)ping_trans_color->green > max_sample ||
green 2849 coders/png.c transparent_color.green= scale_to_short*ping_trans_color->green;
green 2862 coders/png.c transparent_color.green=transparent_color.opacity;
green 2952 coders/png.c image->colormap[i].green=ScaleCharToQuantum(palette[i].green);
green 2959 coders/png.c image->colormap[i].green=0;
green 2978 coders/png.c image->colormap[i].green=(Quantum) (i*scale);
green 3183 coders/png.c == transparent_color.green &&
green 3498 coders/png.c == transparent_color.green &&
green 4405 coders/png.c image->background_color.green=image->background_color.red;
green 4412 coders/png.c image->background_color.green=ScaleCharToQuantum(p[3]);
green 5276 coders/png.c mng_info->mng_global_bkgd.green=
green 5302 coders/png.c mng_background_color.green=
green 5333 coders/png.c mng_info->global_plte[i].green=p[3*i+1];
green 5343 coders/png.c mng_info->global_plte[i].green=i;
green 6005 coders/png.c mng_info->global_sbit.green=p[1];
green 7953 coders/png.c ping_background.green = 0;
green 7959 coders/png.c ping_trans_color.green=0;
green 8413 coders/png.c (int) image->colormap[i].green,
green 8426 coders/png.c (int) image->colormap[i].green,
green 8497 coders/png.c ping_trans_color.green=
green 8561 coders/png.c (int) image->background_color.green,
green 8567 coders/png.c opaque[i].green == image->background_color.green &&
green 8700 coders/png.c if (colormap[i].red != colormap[i].green ||
green 8774 coders/png.c image->colormap[i].green ==
green 8810 coders/png.c (int) image->colormap[i].green,
green 9085 coders/png.c ScaleQuantumToChar(image->background_color.green) == 0x00 &&
green 9128 coders/png.c ScaleQuantumToChar(image->colormap[i].green) == 0x00 &&
green 9200 coders/png.c ping_trans_color.green &&
green 9223 coders/png.c image->colormap[i].green == image->colormap[0].green &&
green 9466 coders/png.c ping_background.green=(png_uint_16)
green 9467 coders/png.c (ScaleQuantumToShort(image->background_color.green) & mask);
green 9472 coders/png.c ping_background.gray=(png_uint_16) ping_background.green;
green 9518 coders/png.c palette[i].green=ScaleQuantumToChar(image->colormap[i].green);
green 9527 coders/png.c (long) i,palette[i].red,palette[i].green,palette[i].blue);
green 9798 coders/png.c ping_trans_color.green=(png_uint_16)
green 9799 coders/png.c (ScaleQuantumToShort(image->colormap[0].green) & mask);
green 9831 coders/png.c ping_trans_color.green&=0xff;
green 9842 coders/png.c ping_trans_color.green&=0xff;
green 9962 coders/png.c palette[i].green=ScaleQuantumToChar(image->colormap[i].green);
green 10034 coders/png.c (int) ping_trans_color.green,
green 10039 coders/png.c ping_trans_color.green*=0x0101;
green 10048 coders/png.c (int) ping_trans_color.green,
green 10136 coders/png.c (int) ping_background.green,
green 10430 coders/png.c (int) palette[i].green,
green 10439 coders/png.c (int) palette[i].green,
green 10593 coders/png.c (int) ping_background.green,
green 10709 coders/png.c (int) ping_trans_color.green,
green 12369 coders/png.c green,
green 12383 coders/png.c green=ScaleQuantumToChar(image->background_color.green);
green 12388 coders/png.c *(chunk+7)=green;
green 12939 coders/png.c green,
green 13017 coders/png.c next_image->background_color.green !=
green 13018 coders/png.c next_image->next->background_color.green ||
green 13363 coders/png.c green=ScaleQuantumToShort(image->background_color.green);
green 13366 coders/png.c PNGShort(chunk+6,green);
green 13399 coders/png.c chunk[5+i*3]=ScaleQuantumToChar(image->colormap[i].green) & 0xff;
green 13451 coders/png.c chunk[5+i*3]=ScaleQuantumToChar(image->colormap[i].green);
green 1183 coders/ps.c q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.green),q); \
green 2044 coders/ps.c (GetPixelGreen(p) == pixel.green) &&
green 2165 coders/ps.c ScaleQuantumToChar(image->colormap[i].green),
green 2210 coders/ps.c pixel.green=GetPixelGreen(p);
green 1020 coders/ps2.c ScaleQuantumToChar(image->colormap[i].green),
green 1513 coders/ps3.c pixel=ScaleQuantumToChar(image->colormap[i].green);
green 1526 coders/ps3.c pixel=ScaleQuantumToChar(image->colormap[i].green);
green 1117 coders/psd.c color.green=color.red;
green 1769 coders/psd.c image->colormap[i].green=ScaleCharToQuantum((unsigned char)
green 2600 coders/psd.c image->colormap[i].green));
green 165 coders/rgf.c image->colormap[0].green=QuantumRange;
green 168 coders/rgf.c image->colormap[1].green=(Quantum) 0;
green 537 coders/rle.c image->colormap[i].green=ScaleCharToQuantum((unsigned char) i);
green 545 coders/rle.c image->colormap[i].green=ScaleCharToQuantum(*(p+map_length));
green 594 coders/rle.c SetPixelGreen(q,image->colormap[(ssize_t) index].green);
green 604 coders/sgi.c q->green=ScaleCharToQuantum(*(p+1));
green 1045 coders/sixel.c image->colormap[i].green = ScaleCharToQuantum(sixel_palette[i * 4 + 1]);
green 1276 coders/sixel.c image->colormap[opacity].green=image->transparent_color.green;
green 1286 coders/sixel.c sixel_palette[i * 3 + 1] = ScaleQuantumToChar(image->colormap[i].green);
green 200 coders/stegano.c SetBit(indexes,i,GetBit(pixel.green,j));
green 367 coders/sun.c image->colormap[i].green=ScaleCharToQuantum(sun_colormap[i]);
green 545 coders/sun.c GetPixelGreen(q)].green);
green 933 coders/sun.c image->colormap[i].green));
green 2846 coders/svg.c 100.0*QuantumScale*image->background_color.green,
green 3038 coders/svg.c fill_color.green=ScaleCharToQuantum(*p++);
green 3042 coders/svg.c fill_color.green=ScaleCharToQuantum(*p++);
green 3054 coders/svg.c fill_color.green*=gamma;
green 335 coders/tga.c pixel.green=pixel.red;
green 352 coders/tga.c pixel.green=ScaleAnyToQuantum((1UL*(k & 0x03) << 3)+
green 363 coders/tga.c pixel.green=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
green 373 coders/tga.c pixel.green=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
green 440 coders/tga.c pixel.green=ScaleCharToQuantum((unsigned char) index);
green 460 coders/tga.c pixel.green=ScaleAnyToQuantum((1UL*(k & 0x03) << 3)+
green 478 coders/tga.c pixel.green=ScaleCharToQuantum(pixels[1]);
green 490 coders/tga.c pixel.green=ScaleCharToQuantum(pixels[1]);
green 502 coders/tga.c SetPixelGreen(q,pixel.green);
green 665 coders/tga.c green,
green 668 coders/tga.c green=(unsigned char) ScaleQuantumToAny(GetPixelGreen(p),range);
green 670 coders/tga.c ((green & 0x07) << 5);
green 675 coders/tga.c ((green & 0x18) >> 3));
green 828 coders/tga.c green,
green 844 coders/tga.c green=(unsigned char) ScaleQuantumToAny(image->colormap[i].green,
green 847 coders/tga.c range)) | ((green & 0x07) << 5);
green 851 coders/tga.c range) << 2) | ((green & 0x18) >> 3);
green 856 coders/tga.c *q++=ScaleQuantumToChar(image->colormap[i].green);
green 1499 coders/tiff.c image->colormap[i].green=ClampToQuantum(((double)
green 3770 coders/tiff.c *green,
green 3777 coders/tiff.c green=(uint16 *) AcquireQuantumMemory(65536,sizeof(*green));
green 3779 coders/tiff.c if ((red == (uint16 *) NULL) || (green == (uint16 *) NULL) ||
green 3786 coders/tiff.c (void) ResetMagickMemory(green,0,65536*sizeof(*green));
green 3791 coders/tiff.c green[i]=ScaleQuantumToShort(image->colormap[i].green);
green 3794 coders/tiff.c (void) TIFFSetField(tiff,TIFFTAG_COLORMAP,red,green,blue);
green 3796 coders/tiff.c green=(uint16 *) RelinquishMagickMemory(green);
green 216 coders/tim.c image->colormap[i].green=ScaleCharToQuantum(
green 471 coders/txt.c green,
green 477 coders/txt.c green=0.0;
green 493 coders/txt.c green=red;
green 498 coders/txt.c green=red;
green 508 coders/txt.c &x_offset,&y_offset,&red,&green,&blue,&index,&opacity);
green 513 coders/txt.c &y_offset,&red,&green,&blue,&index);
green 522 coders/txt.c &x_offset,&y_offset,&red,&green,&blue,&opacity);
green 526 coders/txt.c &x_offset,&y_offset,&red,&green,&blue);
green 533 coders/txt.c green*=0.01*range;
green 540 coders/txt.c green+=(range+1)/2.0;
green 544 coders/txt.c pixel.green=ScaleAnyToQuantum((QuantumAny) (green+0.5),range);
green 552 coders/txt.c SetPixelGreen(q,pixel.green);
green 764 coders/txt.c pixel.green-=(QuantumRange+1)/2.0;
green 348 coders/uyvy.c pixel.green=(pixel.green+GetPixelGreen(p))/2;
green 350 coders/uyvy.c (void) WriteBlobByte(image,ScaleQuantumToChar((Quantum) pixel.green));
green 357 coders/uyvy.c pixel.green=(double) GetPixelGreen(p);
green 453 coders/viff.c image->colormap[i].green=ScaleCharToQuantum((unsigned char)
green 459 coders/viff.c image->colormap[i % image->colors].green=ScaleCharToQuantum(
green 702 coders/viff.c ConstrainColormapIndex(image,index)].green);
green 1133 coders/viff.c *q++=ScaleQuantumToChar(image->colormap[i].green);
green 1078 coders/wpg.c image->colormap[i].green=ScaleCharToQuantum((unsigned char)
green 1136 coders/wpg.c image->colormap[i].green=ScaleCharToQuantum(WPG1_Palette[i].Green);
green 1152 coders/wpg.c image->colormap[0].green==0 &&
green 1155 coders/wpg.c image->colormap[1].green==0 &&
green 1159 coders/wpg.c image->colormap[1].green =
green 1278 coders/wpg.c image->colormap[i].green=ScaleCharToQuantum((char)
green 288 coders/xbm.c image->colormap[0].green=QuantumRange;
green 291 coders/xbm.c image->colormap[1].green=(Quantum) 0;
green 171 coders/xcf.c green,
green 388 coders/xcf.c SetPixelGreen(q,ScaleCharToQuantum(xcfdata->green));
green 1008 coders/xpm.c image->colormap[opacity].green=image->transparent_color.green;
green 342 coders/xwd.c colors[i].green=color.green;
green 473 coders/xwd.c index].green));
green 533 coders/xwd.c image->colormap[i].green=ScaleShortToQuantum(colors[i].green);
green 790 coders/xwd.c colors[i].green=ScaleQuantumToShort(image->colormap[i].green);
green 806 coders/xwd.c color.green=colors[i].green;
green 41 magick/accelerate-private.h green,
green 48 magick/accelerate-private.h green,
green 245 magick/accelerate-private.h float green = getGreen(p);
green 257 magick/accelerate-private.h intensity=(red+green+blue)/3.0;
green 262 magick/accelerate-private.h intensity=max(max(red,green),blue);
green 267 magick/accelerate-private.h intensity=(min(min(red,green),blue)+
green 268 magick/accelerate-private.h max(max(red,green),blue))/2.0;
green 273 magick/accelerate-private.h intensity=(float) (((float) red*red+green*green+blue*blue)/
green 287 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
green 300 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
green 314 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
green 327 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
green 332 magick/accelerate-private.h intensity=(float) (sqrt((float) red*red+green*green+blue*blue)/
green 688 magick/accelerate-private.h CLQuantum red, green, blue, opacity;
green 709 magick/accelerate-private.h green = getGreen(eValue);
green 734 magick/accelerate-private.h im[c]=(CLPixelType)(blue, green, red, opacity);
green 755 magick/accelerate-private.h CLQuantum red, green, blue, opacity;
green 769 magick/accelerate-private.h green = getRed(eValue);
green 778 magick/accelerate-private.h im[c]=(CLPixelType)(blue, green, red, opacity);
green 1753 magick/accelerate-private.h inline void ConvertRGBToHSL(const CLQuantum red,const CLQuantum green, const CLQuantum blue,
green 1764 magick/accelerate-private.h tmax=max(QuantumScale*red,max(QuantumScale*green, QuantumScale*blue));
green 1765 magick/accelerate-private.h tmin=min(QuantumScale*red,min(QuantumScale*green, QuantumScale*blue));
green 1779 magick/accelerate-private.h *hue=(QuantumScale*green-QuantumScale*blue)/c;
green 1780 magick/accelerate-private.h if ((QuantumScale*green) < (QuantumScale*blue))
green 1784 magick/accelerate-private.h if (tmax == (QuantumScale*green))
green 1787 magick/accelerate-private.h *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
green 1797 magick/accelerate-private.h CLQuantum *red,CLQuantum *green,CLQuantum *blue)
green 1872 magick/accelerate-private.h *green=ClampToQuantum(QuantumRange*g);
green 1877 magick/accelerate-private.h CLQuantum *red,CLQuantum *green,CLQuantum *blue)
green 1887 magick/accelerate-private.h ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
green 1895 magick/accelerate-private.h ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
green 1914 magick/accelerate-private.h green,
green 1918 magick/accelerate-private.h green=getGreen(pixel);
green 1927 magick/accelerate-private.h &red, &green, &blue);
green 1935 magick/accelerate-private.h setGreen(&filteredPixel, green);
green 1957 magick/accelerate-private.h green,
green 1962 magick/accelerate-private.h green=(float)getGreen(pixel);
green 1973 magick/accelerate-private.h intensity=(red+green+blue)/3.0;
green 1978 magick/accelerate-private.h intensity=max(max(red,green),blue);
green 1983 magick/accelerate-private.h intensity=(min(min(red,green),blue)+
green 1984 magick/accelerate-private.h max(max(red,green),blue))/2.0;
green 1989 magick/accelerate-private.h intensity=(float) (((float) red*red+green*green+
green 2003 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2016 magick/accelerate-private.h intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2030 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2043 magick/accelerate-private.h intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2048 magick/accelerate-private.h intensity=(float) (sqrt((float) red*red+green*green+
green 1821 magick/accelerate.c biasPixel.s[1] = bias.green;
green 4694 magick/accelerate.c intensity.green+=histogram[i].s[1];
green 4723 magick/accelerate.c if (((channel & GreenChannel) != 0) && (white.green != black.green))
green 4724 magick/accelerate.c equalize_map[i].green=ScaleMapToQuantum((MagickRealType) ((MaxMap*
green 4725 magick/accelerate.c (map[i].green-black.green))/(white.green-black.green)));
green 4754 magick/accelerate.c image->colormap[i].green=equalize_map[
green 4755 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].green)].red;
green 4766 magick/accelerate.c if (((channel & GreenChannel) != 0) && (white.green != black.green))
green 4767 magick/accelerate.c image->colormap[i].green=equalize_map[
green 4768 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].green)].green;
green 5203 magick/accelerate.c black.green=0.0;
green 5204 magick/accelerate.c white.green=MaxRange(QuantumRange);
green 5214 magick/accelerate.c black.green=(MagickRealType) i;
green 5222 magick/accelerate.c white.green=(MagickRealType) i;
green 5318 magick/accelerate.c if (i < (ssize_t) black.green)
green 5319 magick/accelerate.c stretch_map[i].green=0;
green 5321 magick/accelerate.c if (i > (ssize_t) white.green)
green 5322 magick/accelerate.c stretch_map[i].green=QuantumRange;
green 5324 magick/accelerate.c if (black.green != white.green)
green 5325 magick/accelerate.c stretch_map[i].green=ScaleMapToQuantum((MagickRealType) (MaxMap*
green 5326 magick/accelerate.c (i-black.green)/(white.green-black.green)));
green 5390 magick/accelerate.c if (black.green != white.green)
green 5391 magick/accelerate.c image->colormap[i].green=stretch_map[
green 5392 magick/accelerate.c ScaleQuantumToMap(image->colormap[i].green)].green;
green 6703 magick/accelerate.c biasPixel.s[1] = bias.green;
green 1845 magick/annotate.c SetPixelGreen(q,fill_color.green);
green 351 magick/attribute.c if (IsPixelAtDepth(image->colormap[i].green,range) == MagickFalse)
green 882 magick/attribute.c image->colormap[i].green=ScaleAnyToQuantum(ScaleQuantumToAny(
green 883 magick/attribute.c ClampPixel(image->colormap[i].green),range),range);
green 3248 magick/cache.c composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
green 3323 magick/cache.c SetPixelGreen(q,ClampToQuantum(beta.green));
green 779 magick/channel.c SetPixelGreen(q,pixel.green);
green 943 magick/channel.c q->green=ClampToQuantum(gamma*MagickOver_((MagickRealType) q->green,
green 944 magick/channel.c (MagickRealType) q->opacity,(MagickRealType) pixel.green,
green 49 magick/color-private.h green,
green 53 magick/color-private.h green=(MagickRealType) p->green;
green 56 magick/color-private.h (fabs((double) (green-q->green)) < MagickEpsilon) &&
green 80 magick/color-private.h if (fabs((double) (p->green-q->green)) >= MagickEpsilon)
green 95 magick/color-private.h if ((fabs((double) (pixel->red-pixel->green)) < MagickEpsilon) &&
green 96 magick/color-private.h (fabs((double) (pixel->green-pixel->blue)) < MagickEpsilon))
green 106 magick/color-private.h return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
green 114 magick/color-private.h return(ClampToQuantum(0.212656*pixel->red+0.715158*pixel->green+
green 122 magick/color-private.h green,
green 128 magick/color-private.h return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
green 130 magick/color-private.h green=EncodePixelGamma(pixel->green);
green 132 magick/color-private.h return(0.212656*red+0.715158*green+0.072186*blue);
green 140 magick/color-private.h green,
green 146 magick/color-private.h return(0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue);
green 148 magick/color-private.h green=DecodePixelGamma(pixel->green);
green 150 magick/color-private.h return(0.212656*red+0.715158*green+0.072186*blue);
green 86 magick/color.c green,
green 882 magick/color.c color_info->color.green=(MagickRealType) ScaleCharToQuantum(
green 1138 magick/color.c color=pixel->green;
green 1459 magick/color.c color=pixel->green;
green 1549 magick/color.c status&=color.green == SVGCompliant(color.green);
green 1715 magick/color.c pixel=(MagickRealType) GetPixelGreen(p)-q->green;
green 2024 magick/color.c pixel=GetPixelGreen(p)-q->green;
green 2438 magick/color.c pixel.green*(QuantumRange-pixel.index)+pixel.index)))));
green 2445 magick/color.c SetPixelGreen(color,ClampToQuantum(pixel.green));
green 2620 magick/color.c pixel.red=pixel.green;
green 2621 magick/color.c pixel.green=pixel.blue;
green 2651 magick/color.c pixel.red=pixel.green;
green 2652 magick/color.c pixel.green=pixel.blue;
green 2678 magick/color.c color->green=(MagickRealType) ScaleAnyToQuantum(pixel.green,range);
green 2772 magick/color.c color->green=(MagickRealType) ClampToQuantum(scale*
green 2794 magick/color.c color->green=(MagickRealType) ClampToQuantum(scale*
green 2803 magick/color.c color->green=color->red;
green 2829 magick/color.c &pixel.green,&pixel.blue);
green 2834 magick/color.c &pixel.red,&pixel.green,&pixel.blue);
green 2839 magick/color.c &pixel.red,&pixel.green,&pixel.blue);
green 2843 magick/color.c &pixel.red,&pixel.green,&pixel.blue);
green 2846 magick/color.c color->green=(MagickRealType) pixel.green;
green 2862 magick/color.c color->green=(MagickRealType) p->color.green;
green 2970 magick/color.c (p->color.green == color->green) && (p->color.blue == color->blue) &&
green 136 magick/colormap.c image->colormap[i].green=(Quantum) pixel;
green 34 magick/colorspace-private.h pixel->green=((QuantumRange-(QuantumScale*pixel->green*(QuantumRange-
green 46 magick/colorspace-private.h green,
green 54 magick/colorspace-private.h green=QuantumScale*pixel->green;
green 60 magick/colorspace-private.h green=QuantumScale*DecodePixelGamma(pixel->green);
green 64 magick/colorspace-private.h (fabs((double) green) < MagickEpsilon) &&
green 71 magick/colorspace-private.h magenta=(MagickRealType) (1.0-green);
green 83 magick/colorspace-private.h pixel->green=QuantumRange*magenta;
green 112 magick/colorspace.c *magenta=QuantumScale*(QuantumRange-green);
green 124 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 144 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 156 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 168 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 177 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 178 magick/colorspace.c *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
green 179 magick/colorspace.c *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
green 185 magick/colorspace.c ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
green 191 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 192 magick/colorspace.c *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
green 193 magick/colorspace.c *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
green 199 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 200 magick/colorspace.c *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
green 201 magick/colorspace.c *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
green 207 magick/colorspace.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 208 magick/colorspace.c *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
green 209 magick/colorspace.c *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
green 310 magick/colorspace.c pixel.green=(MagickRealType) pixel.green;
green 445 magick/colorspace.c green,
green 449 magick/colorspace.c green=ClampToQuantum((MagickRealType) GetPixelGreen(q));
green 455 magick/colorspace.c ConvertRGBToCMY(red,green,blue,&X,&Y,&Z);
green 460 magick/colorspace.c ConvertRGBToHCL(red,green,blue,&X,&Y,&Z);
green 465 magick/colorspace.c ConvertRGBToHCLp(red,green,blue,&X,&Y,&Z);
green 470 magick/colorspace.c ConvertRGBToHSB(red,green,blue,&X,&Y,&Z);
green 475 magick/colorspace.c ConvertRGBToHSI(red,green,blue,&X,&Y,&Z);
green 480 magick/colorspace.c ConvertRGBToHSL(red,green,blue,&X,&Y,&Z);
green 485 magick/colorspace.c ConvertRGBToHSV(red,green,blue,&X,&Y,&Z);
green 490 magick/colorspace.c ConvertRGBToHWB(red,green,blue,&X,&Y,&Z);
green 495 magick/colorspace.c ConvertRGBToLab(red,green,blue,&X,&Y,&Z);
green 501 magick/colorspace.c ConvertRGBToLCHab(red,green,blue,&X,&Y,&Z);
green 506 magick/colorspace.c ConvertRGBToLCHuv(red,green,blue,&X,&Y,&Z);
green 511 magick/colorspace.c ConvertRGBToLMS(red,green,blue,&X,&Y,&Z);
green 516 magick/colorspace.c ConvertRGBToLuv(red,green,blue,&X,&Y,&Z);
green 521 magick/colorspace.c ConvertRGBToxyY(red,green,blue,&X,&Y,&Z);
green 526 magick/colorspace.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 531 magick/colorspace.c ConvertRGBToYCbCr(red,green,blue,&X,&Y,&Z);
green 536 magick/colorspace.c ConvertRGBToYDbDr(red,green,blue,&X,&Y,&Z);
green 541 magick/colorspace.c ConvertRGBToYIQ(red,green,blue,&X,&Y,&Z);
green 546 magick/colorspace.c ConvertRGBToYPbPr(red,green,blue,&X,&Y,&Z);
green 551 magick/colorspace.c ConvertRGBToYUV(red,green,blue,&X,&Y,&Z);
green 557 magick/colorspace.c Y=QuantumScale*green;
green 661 magick/colorspace.c green,
green 666 magick/colorspace.c green=ClampToQuantum(DecodePixelGamma((MagickRealType)
green 671 magick/colorspace.c SetPixelGreen(q,logmap[ScaleQuantumToMap(green)]);
green 727 magick/colorspace.c green,
green 732 magick/colorspace.c green=ClampToQuantum(DecodePixelGamma((MagickRealType)
green 737 magick/colorspace.c SetPixelGreen(q,green);
green 1009 magick/colorspace.c green,
green 1025 magick/colorspace.c green=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
green 1029 magick/colorspace.c pixel.red=(x_map[red].x+y_map[green].x+z_map[blue].x)+
green 1031 magick/colorspace.c pixel.green=(x_map[red].y+y_map[green].y+z_map[blue].y)+
green 1033 magick/colorspace.c pixel.blue=(x_map[red].z+y_map[green].z+z_map[blue].z)+
green 1036 magick/colorspace.c SetPixelGreen(q,ScaleMapToQuantum(pixel.green));
green 1064 magick/colorspace.c green,
green 1077 magick/colorspace.c green=ScaleQuantumToMap(ClampToQuantum((MagickRealType)
green 1078 magick/colorspace.c image->colormap[i].green));
green 1081 magick/colorspace.c pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x+primary_info.x;
green 1082 magick/colorspace.c pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y+primary_info.y;
green 1083 magick/colorspace.c pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z+primary_info.z;
green 1085 magick/colorspace.c image->colormap[i].green=ScaleMapToQuantum(pixel.green);
green 1274 magick/colorspace.c *green=ClampToQuantum(QuantumRange*(1.0-magenta));
green 1295 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 1307 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 1328 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 1342 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 1350 magick/colorspace.c *green=ClampToQuantum(QuantumRange*(0.99999975910502514331*Y-
green 1359 magick/colorspace.c ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
green 1367 magick/colorspace.c *green=ClampToQuantum(QuantumRange*(Y-0.12913289889050927*(Db-0.5)+
green 1378 magick/colorspace.c *green=ClampToQuantum(QuantumRange*(Y-0.2721220993185104464*(I-0.5)-
green 1389 magick/colorspace.c *green=ClampToQuantum(QuantumRange*(Y-0.3946101641414141437*(U-0.5)-
green 1864 magick/colorspace.c green,
green 1874 magick/colorspace.c ConvertCMYToRGB(X,Y,Z,&red,&green,&blue);
green 1879 magick/colorspace.c ConvertHCLToRGB(X,Y,Z,&red,&green,&blue);
green 1884 magick/colorspace.c ConvertHCLpToRGB(X,Y,Z,&red,&green,&blue);
green 1889 magick/colorspace.c ConvertHSBToRGB(X,Y,Z,&red,&green,&blue);
green 1894 magick/colorspace.c ConvertHSIToRGB(X,Y,Z,&red,&green,&blue);
green 1899 magick/colorspace.c ConvertHSLToRGB(X,Y,Z,&red,&green,&blue);
green 1904 magick/colorspace.c ConvertHSVToRGB(X,Y,Z,&red,&green,&blue);
green 1909 magick/colorspace.c ConvertHWBToRGB(X,Y,Z,&red,&green,&blue);
green 1914 magick/colorspace.c ConvertLabToRGB(X,Y,Z,&red,&green,&blue);
green 1920 magick/colorspace.c ConvertLCHabToRGB(X,Y,Z,&red,&green,&blue);
green 1925 magick/colorspace.c ConvertLCHuvToRGB(X,Y,Z,&red,&green,&blue);
green 1930 magick/colorspace.c ConvertLMSToRGB(X,Y,Z,&red,&green,&blue);
green 1935 magick/colorspace.c ConvertLuvToRGB(X,Y,Z,&red,&green,&blue);
green 1940 magick/colorspace.c ConvertxyYToRGB(X,Y,Z,&red,&green,&blue);
green 1945 magick/colorspace.c ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
green 1950 magick/colorspace.c ConvertYCbCrToRGB(X,Y,Z,&red,&green,&blue);
green 1955 magick/colorspace.c ConvertYDbDrToRGB(X,Y,Z,&red,&green,&blue);
green 1960 magick/colorspace.c ConvertYIQToRGB(X,Y,Z,&red,&green,&blue);
green 1965 magick/colorspace.c ConvertYPbPrToRGB(X,Y,Z,&red,&green,&blue);
green 1970 magick/colorspace.c ConvertYUVToRGB(X,Y,Z,&red,&green,&blue);
green 1976 magick/colorspace.c green=ClampToQuantum(QuantumRange*Y);
green 1982 magick/colorspace.c SetPixelGreen(q,ClampToQuantum((MagickRealType) green));
green 2082 magick/colorspace.c green,
green 2087 magick/colorspace.c green=ClampToQuantum(EncodePixelGamma((MagickRealType)
green 2092 magick/colorspace.c SetPixelGreen(q,green);
green 2148 magick/colorspace.c green,
green 2152 magick/colorspace.c green=ClampToQuantum(EncodePixelGamma((MagickRealType)
green 2157 magick/colorspace.c SetPixelGreen(q,green);
green 2387 magick/colorspace.c green,
green 2391 magick/colorspace.c green=ScaleQuantumToMap(GetPixelGreen(q));
green 2393 magick/colorspace.c pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
green 2394 magick/colorspace.c pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
green 2395 magick/colorspace.c pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
green 2400 magick/colorspace.c pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.green/
green 2408 magick/colorspace.c pixel.green=(MagickRealType) ScaleMapToQuantum(pixel.green);
green 2412 magick/colorspace.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 2452 magick/colorspace.c green,
green 2456 magick/colorspace.c green=ScaleQuantumToMap(image->colormap[i].green);
green 2458 magick/colorspace.c pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
green 2459 magick/colorspace.c pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
green 2460 magick/colorspace.c pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
green 2465 magick/colorspace.c pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.green/
green 2473 magick/colorspace.c pixel.green=(MagickRealType) ScaleMapToQuantum(pixel.green);
green 2477 magick/colorspace.c image->colormap[i].green=ClampToQuantum(pixel.green);
green 105 magick/composite-private.h composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
green 129 magick/composite-private.h composite->green=gamma*(Sa*p->green+Da*q->green);
green 210 magick/composite.c composite->green=Atop(p->green,Sa,q->green,1.0);
green 228 magick/composite.c composite->green=QuantumScale*intensity*q->green;
green 240 magick/composite.c composite->green=0.0;
green 283 magick/composite.c composite->green=gamma*ColorBurn(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 284 magick/composite.c q->green*Da,Da);
green 345 magick/composite.c composite->green=gamma*ColorDodge(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 346 magick/composite.c q->green*Da,Da);
green 379 magick/composite.c composite->green=gamma*Darken(p->green,p->opacity,q->green,q->opacity);
green 390 magick/composite.c composite->green=MagickMin(p->green,q->green);
green 424 magick/composite.c composite->green = from_p ? p->green : q->green;
green 458 magick/composite.c composite->green=gamma*Difference(p->green,Sa,q->green,Da);
green 469 magick/composite.c composite->green=fabs((double) (p->green-q->green));
green 514 magick/composite.c composite->green=gamma*Divide(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 515 magick/composite.c q->green*Da,Da);
green 529 magick/composite.c composite->green=QuantumRange*
green 530 magick/composite.c Divide(QuantumScale*p->green,1.0,QuantumScale*q->green,1.0);
green 563 magick/composite.c composite->green=gamma*Exclusion(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 564 magick/composite.c q->green*Da,Da);
green 578 magick/composite.c composite->green=QuantumRange*Exclusion(QuantumScale*p->green,1.0,
green 579 magick/composite.c QuantumScale*q->green,1.0);
green 612 magick/composite.c composite->green=gamma*HardLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 613 magick/composite.c q->green*Da,Da);
green 644 magick/composite.c composite->green=gamma*HardMix(p->green*Sa,q->green*Da);
green 666 magick/composite.c assert(green != (MagickRealType *) NULL);
green 711 magick/composite.c *green=QuantumRange*(g+m);
green 733 magick/composite.c g=(double) green;
green 744 magick/composite.c if (green == (MagickRealType) max)
green 778 magick/composite.c composite->green=gamma*In(p->green,Sa,q->green,Da);
green 809 magick/composite.c composite->green=gamma*Lighten(p->green,p->opacity,q->green,q->opacity);
green 820 magick/composite.c composite->green=MagickMax(p->green,q->green);
green 854 magick/composite.c composite->green = from_p ? p->green : q->green;
green 891 magick/composite.c composite->green=gamma*(p->green*Sa+q->green*Da);
green 925 magick/composite.c composite->green=gamma*LinearBurn(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 926 magick/composite.c q->green*Da,Da);
green 968 magick/composite.c composite->green=gamma*LinearLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 969 magick/composite.c q->green*Da,Da);
green 1023 magick/composite.c composite->green=gamma*Mathematics(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 1024 magick/composite.c q->green*Da,Da,args);
green 1038 magick/composite.c composite->green=QuantumRange*
green 1039 magick/composite.c Mathematics(QuantumScale*p->green,1.0,QuantumScale*q->green,1.0,args);
green 1078 magick/composite.c composite->green=p->green+q->green;
green 1119 magick/composite.c composite->green=gamma*Minus(p->green*Sa,Sa,q->green*Da,Da);
green 1130 magick/composite.c composite->green=p->green-q->green;
green 1168 magick/composite.c composite->green=ModulusAdd(p->green,Sa,q->green,Da);
green 1180 magick/composite.c composite->green=ModulusAdd(p->green,1.0,q->green,1.0);
green 1218 magick/composite.c composite->green=ModulusSubtract(p->green,Sa,q->green,Da);
green 1230 magick/composite.c composite->green=ModulusSubtract(p->green,1.0,q->green,1.0);
green 1261 magick/composite.c composite->green=gamma*Multiply(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 1262 magick/composite.c q->green*Da,Da);
green 1275 magick/composite.c composite->green=QuantumScale*p->green*q->green;
green 1308 magick/composite.c composite->green=gamma*Out(p->green,Sa,q->green,Da);
green 1345 magick/composite.c composite->green=gamma*PegtopLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 1346 magick/composite.c q->green*Da,Da);
green 1385 magick/composite.c composite->green=gamma*PinLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 1386 magick/composite.c q->green*Da,Da);
green 1423 magick/composite.c composite->green=gamma*Screen(p->green*Sa,q->green*Da);
green 1435 magick/composite.c composite->green=QuantumRange*Screen(QuantumScale*p->green,
green 1436 magick/composite.c QuantumScale*q->green);
green 1498 magick/composite.c composite->green=gamma*SoftLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 1499 magick/composite.c q->green*Da,Da);
green 1531 magick/composite.c composite->green=Threshold(p->green,q->green,threshold,amount);
green 1571 magick/composite.c composite->green=gamma*VividLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green 1572 magick/composite.c q->green*Da,Da);
green 1600 magick/composite.c composite->green=gamma*Xor(p->green*Sa,Sa,q->green*Da,Da);
green 2363 magick/composite.c canvas.green=(MagickRealType) GetPixelGreen(q);
green 2372 magick/composite.c canvas.green=(MagickRealType) QuantumRange-canvas.green;
green 2420 magick/composite.c composite.green=(MagickRealType) QuantumRange-composite.green;
green 2427 magick/composite.c ClampPixel(composite.green) : ClampToQuantum(composite.green));
green 2444 magick/composite.c source.green=(MagickRealType) GetPixelGreen(p);
green 2454 magick/composite.c source.green=(MagickRealType) QuantumRange-source.green;
green 2717 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green 2721 magick/composite.c HCLComposite(hue,chroma,luma,&composite.red,&composite.green,
green 2734 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green 2736 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&hue,&sans,&sans);
green 2738 magick/composite.c &composite.green,&composite.blue);
green 2752 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green 2754 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&sans,&chroma,
green 2757 magick/composite.c &composite.green,&composite.blue);
green 2771 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green 2773 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&sans,&sans,
green 2776 magick/composite.c &composite.green,&composite.blue);
green 2790 magick/composite.c CompositeHCL(canvas.red,canvas.green,canvas.blue,&sans,
green 2792 magick/composite.c CompositeHCL(source.red,source.green,source.blue,&hue,&chroma,&sans);
green 2794 magick/composite.c &composite.green,&composite.blue);
green 2808 magick/composite.c composite.green=source.green;
green 2847 magick/composite.c composite.green=(MagickRealType) QuantumRange-composite.green;
green 2854 magick/composite.c ClampPixel(composite.green) : ClampToQuantum(composite.green));
green 256 magick/decorate.c accentuate.green=(MagickRealType) (QuantumScale*((QuantumRange-
green 257 magick/decorate.c AccentuateModulate)*matte.green+(QuantumRange*AccentuateModulate)));
green 264 magick/decorate.c highlight.green=(MagickRealType) (QuantumScale*((QuantumRange-
green 265 magick/decorate.c HighlightModulate)*matte.green+(QuantumRange*HighlightModulate)));
green 271 magick/decorate.c shadow.green=QuantumScale*matte.green*ShadowModulate;
green 276 magick/decorate.c trough.green=QuantumScale*matte.green*TroughModulate;
green 954 magick/deprecate.c threshold.green=geometry_info.sigma;
green 956 magick/deprecate.c threshold.green=threshold.red;
green 961 magick/deprecate.c status&=BilevelImageChannel(image,GreenChannel,threshold.green);
green 2284 magick/deprecate.c pixel.green=GetPixelGreen(p)-(MagickRealType)
green 2286 magick/deprecate.c distance+=pixel.green*pixel.green;
green 3443 magick/deprecate.c assert(green != (Quantum *) NULL);
green 3454 magick/deprecate.c *green=ClampToQuantum((MagickRealType) QuantumRange*g);
green 3571 magick/deprecate.c p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
green 3572 magick/deprecate.c q=(pixels[0].green-pixels[1].green)-p;
green 3573 magick/deprecate.c r=pixels[2].green-pixels[0].green;
green 3574 magick/deprecate.c s=pixels[1].green;
green 3575 magick/deprecate.c pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
green 3673 magick/deprecate.c pixels[i].green*=alpha[i];
green 3681 magick/deprecate.c pixel.green+=gamma*0.0625*pixels[i].green;
green 3718 magick/deprecate.c pixels[i].green*=alpha[i];
green 3764 magick/deprecate.c pixels[i].green*=alpha[i];
green 3779 magick/deprecate.c pixel.green=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].green+delta.x*
green 3780 magick/deprecate.c pixels[1].green)+delta.y*((1.0-delta.x)*pixels[2].green+
green 3781 magick/deprecate.c delta.x*pixels[3].green));
green 3873 magick/deprecate.c pixels[i].green*=alpha[i];
green 3899 magick/deprecate.c pixel.green=gamma*MeshInterpolate(&delta,pixels[2].green,
green 3900 magick/deprecate.c pixels[3].green,pixels[0].green);
green 3919 magick/deprecate.c pixel.green=gamma*MeshInterpolate(&delta,pixels[1].green,
green 3920 magick/deprecate.c pixels[0].green,pixels[3].green);
green 3944 magick/deprecate.c pixel.green=gamma*MeshInterpolate(&delta,pixels[0].green,
green 3945 magick/deprecate.c pixels[1].green,pixels[2].green);
green 3965 magick/deprecate.c pixel.green=gamma*MeshInterpolate(&delta,pixels[3].green,
green 3966 magick/deprecate.c pixels[2].green,pixels[1].green);
green 4033 magick/deprecate.c pixels[n].green*=alpha[n];
green 4042 magick/deprecate.c pixel.green+=gamma*dx*dy*pixels[n].green;
green 7238 magick/deprecate.c pixel.green=geometry_info.sigma;
green 7240 magick/deprecate.c pixel.green=pixel.red;
green 7252 magick/deprecate.c pixel.green*=QuantumRange/100.0f;
green 7285 magick/deprecate.c SetPixelGreen(q,image->colormap[(ssize_t) index].green);
green 7294 magick/deprecate.c SetPixelGreen(q,(MagickRealType) q->green <= pixel.green
green 7398 magick/deprecate.c g=QuantumScale*green;
green 3712 magick/display.c q->green=ScaleShortToQuantum(color.green);
green 3741 magick/display.c q->green=ScaleShortToQuantum(color.green);
green 3756 magick/display.c (*image)->colormap[i].green=ScaleShortToQuantum(
green 3757 magick/display.c color.green);
green 3783 magick/display.c target.green=(MagickRealType)
green 3784 magick/display.c ScaleShortToQuantum(border_color.green);
green 3814 magick/display.c q->green=ScaleShortToQuantum(color.green);
green 10064 magick/display.c target.green=(MagickRealType)
green 10065 magick/display.c ScaleShortToQuantum(border_color.green);
green 12282 magick/display.c (*image)->background_color.green=ScaleShortToQuantum(
green 12283 magick/display.c windows->pixel_info->pen_colors[pen_id].green);
green 3083 magick/distort.c pixel.green = coeff[x]*i +coeff[x+1]*j
green 3103 magick/distort.c pixel.green = coeff[x]*i + coeff[x+1]*j +
green 3125 magick/distort.c if ( channel & GreenChannel ) pixel.green = 0.0;
green 3140 magick/distort.c pixel.green += arguments[x++]*weight;
green 3150 magick/distort.c if ( channel & GreenChannel ) pixel.green /= denominator;
green 3175 magick/distort.c if ( channel & GreenChannel ) pixel.green = arguments[x++];
green 3189 magick/distort.c pixel.green=ClampPixel(QuantumRange*pixel.green);
green 4306 magick/draw.c target.green=(MagickRealType) draw_info->border_color.green;
green 4417 magick/draw.c target.green=(MagickRealType) draw_info->border_color.green;
green 347 magick/effect.c pixel.green=bias.green;
green 363 magick/effect.c pixel.green+=(*k)*alpha*GetPixelGreen(p);
green 380 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 670 magick/effect.c pixel.green=bias.green;
green 685 magick/effect.c pixel.green+=(*k)*alpha*GetPixelGreen(p);
green 702 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 1636 magick/effect.c pixel.green=bias.green;
green 1649 magick/effect.c pixel.green+=(*k)*kernel_pixels[u].green;
green 1658 magick/effect.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 1710 magick/effect.c pixel.green+=(*k)*alpha*GetPixelGreen(kernel_pixels+u);
green 1721 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 2105 magick/effect.c qixel.green+=(*k)*pixel.green;
green 2118 magick/effect.c SetPixelGreen(q,ClampToQuantum(qixel.green));
green 2141 magick/effect.c qixel.green+=(*k)*alpha*pixel.green;
green 2156 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*qixel.green));
green 2390 magick/effect.c mean.green+=(double) k->green;
green 2395 magick/effect.c mean.green/=(double) (width*width);
green 3180 magick/effect.c qixel.green+=pixel.green;
green 3194 magick/effect.c SetPixelGreen(q,ClampToQuantum(normalize*qixel.green));
green 3219 magick/effect.c qixel.green+=alpha*pixel.green;
green 3235 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*qixel.green));
green 3522 magick/effect.c pixel.green=bias.green;
green 3540 magick/effect.c pixel.green+=(*k)*GetPixelGreen(p+u+j);
green 3554 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 3616 magick/effect.c pixel.green+=(*k)*alpha*GetPixelGreen(p+u+j);
green 3631 magick/effect.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 4356 magick/effect.c pixel.green=bias.green;
green 4373 magick/effect.c pixel.green=GetPixelGreen(p)-(MagickRealType) q->green;
green 4374 magick/effect.c if (fabs(2.0*pixel.green) < quantum_threshold)
green 4375 magick/effect.c pixel.green=(MagickRealType) GetPixelGreen(p);
green 4377 magick/effect.c pixel.green=(MagickRealType) GetPixelGreen(p)+(pixel.green*gain);
green 4378 magick/effect.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 374 magick/enhance.c green,
green 439 magick/enhance.c color_correction.green.slope=1.0;
green 440 magick/enhance.c color_correction.green.offset=0.0;
green 441 magick/enhance.c color_correction.green.power=1.0;
green 473 magick/enhance.c color_correction.green.slope=StringToDouble(token,
green 506 magick/enhance.c color_correction.green.offset=StringToDouble(token,
green 538 magick/enhance.c color_correction.green.power=StringToDouble(token,
green 579 magick/enhance.c " color_correction.green.slope: %g",color_correction.green.slope);
green 581 magick/enhance.c " color_correction.green.offset: %g",color_correction.green.offset);
green 583 magick/enhance.c " color_correction.green.power: %g",color_correction.green.power);
green 602 magick/enhance.c cdl_map[i].green=ClampToQuantum((MagickRealType) ScaleMapToQuantum((
green 603 magick/enhance.c MagickRealType) (MaxMap*(pow(color_correction.green.slope*i/MaxMap+
green 604 magick/enhance.c color_correction.green.offset,color_correction.green.power)))));
green 619 magick/enhance.c luma=0.212656*image->colormap[i].red+0.715158*image->colormap[i].green+
green 623 magick/enhance.c image->colormap[i].green=ClampToQuantum(luma+
green 625 magick/enhance.c image->colormap[i].green)].green-luma);
green 667 magick/enhance.c (cdl_map[ScaleQuantumToMap(GetPixelGreen(q))].green-luma)));
green 924 magick/enhance.c assert(green != (Quantum *) NULL);
green 929 magick/enhance.c ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
green 937 magick/enhance.c ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
green 976 magick/enhance.c Contrast(sign,&image->colormap[i].red,&image->colormap[i].green,
green 999 magick/enhance.c green,
green 1019 magick/enhance.c green=GetPixelGreen(q);
green 1021 magick/enhance.c Contrast(sign,&red,&green,&blue);
green 1023 magick/enhance.c SetPixelGreen(q,green);
green 1218 magick/enhance.c histogram[ScaleQuantumToMap(intensity)].green++;
green 1229 magick/enhance.c histogram[ScaleQuantumToMap(GetPixelGreen(p))].green++;
green 1264 magick/enhance.c black.green=0.0;
green 1265 magick/enhance.c white.green=MaxRange(QuantumRange);
green 1271 magick/enhance.c intensity+=histogram[i].green;
green 1275 magick/enhance.c black.green=(MagickRealType) i;
green 1279 magick/enhance.c intensity+=histogram[i].green;
green 1283 magick/enhance.c white.green=(MagickRealType) i;
green 1369 magick/enhance.c if (i < (ssize_t) black.green)
green 1370 magick/enhance.c stretch_map[i].green=0;
green 1372 magick/enhance.c if (i > (ssize_t) white.green)
green 1373 magick/enhance.c stretch_map[i].green=QuantumRange;
green 1375 magick/enhance.c if (black.green != white.green)
green 1376 magick/enhance.c stretch_map[i].green=ScaleMapToQuantum((MagickRealType) (MaxMap*
green 1377 magick/enhance.c (i-black.green)/(white.green-black.green)));
green 1438 magick/enhance.c if (black.green != white.green)
green 1439 magick/enhance.c image->colormap[i].green=stretch_map[
green 1440 magick/enhance.c ScaleQuantumToMap(image->colormap[i].green)].green;
green 1495 magick/enhance.c if (black.green != white.green)
green 1497 magick/enhance.c ScaleQuantumToMap(GetPixelGreen(q))].green);
green 1572 magick/enhance.c mean=QuantumScale*((double) GetPixelGreen(r)+pixel.green)/2.0; \
green 1573 magick/enhance.c distance=QuantumScale*((double) GetPixelGreen(r)-pixel.green); \
green 1584 magick/enhance.c aggregate.green+=(weight)*GetPixelGreen(r); \
green 1708 magick/enhance.c SetPixelGreen(q,(aggregate.green+(total_weight/2)-1)/total_weight);
green 1867 magick/enhance.c histogram[ScaleQuantumToMap(GetPixelGreen(p))].green++;
green 1894 magick/enhance.c intensity.green+=histogram[i].green;
green 1919 magick/enhance.c if (((channel & GreenChannel) != 0) && (white.green != black.green))
green 1920 magick/enhance.c equalize_map[i].green=ScaleMapToQuantum((MagickRealType) ((MaxMap*
green 1921 magick/enhance.c (map[i].green-black.green))/(white.green-black.green)));
green 1949 magick/enhance.c image->colormap[i].green=equalize_map[
green 1950 magick/enhance.c ScaleQuantumToMap(image->colormap[i].green)].red;
green 1961 magick/enhance.c if (((channel & GreenChannel) != 0) && (white.green != black.green))
green 1962 magick/enhance.c image->colormap[i].green=equalize_map[
green 1963 magick/enhance.c ScaleQuantumToMap(image->colormap[i].green)].green;
green 2027 magick/enhance.c if (((channel & GreenChannel) != 0) && (white.green != black.green))
green 2029 magick/enhance.c ScaleQuantumToMap(GetPixelGreen(q))].green);
green 2126 magick/enhance.c gamma.green=geometry_info.sigma;
green 2128 magick/enhance.c gamma.green=gamma.red;
green 2132 magick/enhance.c if ((gamma.red == 1.0) && (gamma.green == 1.0) && (gamma.blue == 1.0))
green 2134 magick/enhance.c if ((gamma.red == gamma.green) && (gamma.green == gamma.blue))
green 2140 magick/enhance.c status&=GammaImageChannel(image,GreenChannel,(double) gamma.green);
green 2202 magick/enhance.c image->colormap[i].green=gamma_map[ScaleQuantumToMap(
green 2203 magick/enhance.c image->colormap[i].green)];
green 2222 magick/enhance.c image->colormap[i].green=QuantumRange*gamma_pow(QuantumScale*
green 2223 magick/enhance.c image->colormap[i].green,1.0/gamma);
green 2454 magick/enhance.c green,
green 2459 magick/enhance.c green=(MagickRealType) q->green;
green 2466 magick/enhance.c intensity=(red+green+blue)/3.0;
green 2471 magick/enhance.c intensity=MagickMax(MagickMax(red,green),blue);
green 2476 magick/enhance.c intensity=(MagickMin(MagickMin(red,green),blue)+
green 2477 magick/enhance.c MagickMax(MagickMax(red,green),blue))/2.0;
green 2482 magick/enhance.c intensity=(MagickRealType) (((double) red*red+green*green+
green 2491 magick/enhance.c green=EncodePixelGamma(green);
green 2494 magick/enhance.c intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2502 magick/enhance.c green=DecodePixelGamma(green);
green 2505 magick/enhance.c intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2514 magick/enhance.c green=EncodePixelGamma(green);
green 2517 magick/enhance.c intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2525 magick/enhance.c green=DecodePixelGamma(green);
green 2528 magick/enhance.c intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2533 magick/enhance.c intensity=(MagickRealType) (sqrt((double) red*red+green*green+
green 2742 magick/enhance.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 2954 magick/enhance.c image->colormap[i].green=(Quantum) ClampToQuantum(LevelPixel(
green 2956 magick/enhance.c image->colormap[i].green));
green 3133 magick/enhance.c image->colormap[i].green=LevelizeValue(image->colormap[i].green);
green 3288 magick/enhance.c status&=LevelImageChannel(image,GreenChannel,black_color->green,
green 3289 magick/enhance.c white_color->green,(double) 1.0);
green 3308 magick/enhance.c status&=LevelizeImageChannel(image,GreenChannel,black_color->green,
green 3309 magick/enhance.c white_color->green,(double) 1.0);
green 3470 magick/enhance.c ConvertRGBToHCL(*red,*green,*blue,&hue,&chroma,&luma);
green 3478 magick/enhance.c ConvertHCLToRGB(hue,chroma,luma,red,green,blue);
green 3493 magick/enhance.c ConvertRGBToHCLp(*red,*green,*blue,&hue,&chroma,&luma);
green 3501 magick/enhance.c ConvertHCLpToRGB(hue,chroma,luma,red,green,blue);
green 3516 magick/enhance.c ConvertRGBToHSB(*red,*green,*blue,&hue,&saturation,&brightness);
green 3524 magick/enhance.c ConvertHSBToRGB(hue,saturation,brightness,red,green,blue);
green 3539 magick/enhance.c ConvertRGBToHSI(*red,*green,*blue,&hue,&saturation,&intensity);
green 3547 magick/enhance.c ConvertHSIToRGB(hue,saturation,intensity,red,green,blue);
green 3562 magick/enhance.c ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
green 3570 magick/enhance.c ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
green 3585 magick/enhance.c ConvertRGBToHSV(*red,*green,*blue,&hue,&saturation,&value);
green 3593 magick/enhance.c ConvertHSVToRGB(hue,saturation,value,red,green,blue);
green 3608 magick/enhance.c ConvertRGBToHWB(*red,*green,*blue,&hue,&whiteness,&blackness);
green 3616 magick/enhance.c ConvertHWBToRGB(hue,whiteness,blackness,red,green,blue);
green 3631 magick/enhance.c ConvertRGBToLCHab(*red,*green,*blue,&luma,&chroma,&hue);
green 3639 magick/enhance.c ConvertLCHabToRGB(luma,chroma,hue,red,green,blue);
green 3654 magick/enhance.c ConvertRGBToLCHuv(*red,*green,*blue,&luma,&chroma,&hue);
green 3662 magick/enhance.c ConvertLCHuvToRGB(luma,chroma,hue,red,green,blue);
green 3733 magick/enhance.c green,
green 3740 magick/enhance.c green=image->colormap[i].green;
green 3747 magick/enhance.c &red,&green,&blue);
green 3753 magick/enhance.c &red,&green,&blue);
green 3759 magick/enhance.c &red,&green,&blue);
green 3765 magick/enhance.c &red,&green,&blue);
green 3772 magick/enhance.c &red,&green,&blue);
green 3778 magick/enhance.c &red,&green,&blue);
green 3784 magick/enhance.c &red,&green,&blue);
green 3791 magick/enhance.c &red,&green,&blue);
green 3797 magick/enhance.c &red,&green,&blue);
green 3802 magick/enhance.c image->colormap[i].green=green;
green 3843 magick/enhance.c green,
green 3847 magick/enhance.c green=GetPixelGreen(q);
green 3854 magick/enhance.c &red,&green,&blue);
green 3860 magick/enhance.c &red,&green,&blue);
green 3866 magick/enhance.c &red,&green,&blue);
green 3873 magick/enhance.c &red,&green,&blue);
green 3879 magick/enhance.c &red,&green,&blue);
green 3885 magick/enhance.c &red,&green,&blue);
green 3891 magick/enhance.c &red,&green,&blue);
green 3898 magick/enhance.c &red,&green,&blue);
green 3903 magick/enhance.c SetPixelGreen(q,green);
green 4002 magick/enhance.c if ((image->colormap[i].red != image->colormap[i].green) ||
green 4003 magick/enhance.c (image->colormap[i].green != image->colormap[i].blue))
green 4008 magick/enhance.c image->colormap[i].green=QuantumRange-image->colormap[i].green;
green 4425 magick/enhance.c image->colormap[i].green=ClampToQuantum(sigmoidal_map[
green 4426 magick/enhance.c ScaleQuantumToMap(image->colormap[i].green)]);
green 179 magick/feature.c q->green=QuantumRange;
green 224 magick/feature.c q->green=QuantumRange;
green 514 magick/feature.c q->green=0;
green 709 magick/feature.c grays[i].green=(~0U);
green 744 magick/feature.c grays[ScaleQuantumToMap(GetPixelGreen(p))].green=
green 770 magick/feature.c if (grays[i].green != ~0U)
green 771 magick/feature.c grays[(ssize_t) gray.green++].green=grays[i].green;
green 785 magick/feature.c if (gray.green > number_grays)
green 786 magick/feature.c number_grays=gray.green;
green 974 magick/feature.c while (grays[u].green != ScaleQuantumToMap(GetPixelGreen(p)))
green 976 magick/feature.c while (grays[v].green != ScaleQuantumToMap(GetPixelGreen(p+offset)))
green 978 magick/feature.c cooccurrence[u][v].direction[i].green++;
green 979 magick/feature.c cooccurrence[v][u].direction[i].green++;
green 1084 magick/feature.c cooccurrence[x][y].direction[i].green*=normalize;
green 1119 magick/feature.c cooccurrence[x][y].direction[i].green*
green 1120 magick/feature.c cooccurrence[x][y].direction[i].green;
green 1136 magick/feature.c sum[y].direction[i].green+=cooccurrence[x][y].direction[i].green;
green 1143 magick/feature.c correlation.direction[i].green+=x*y*
green 1144 magick/feature.c cooccurrence[x][y].direction[i].green;
green 1159 magick/feature.c cooccurrence[x][y].direction[i].green/((y-x)*(y-x)+1);
green 1173 magick/feature.c density_xy[y+x+2].direction[i].green+=
green 1174 magick/feature.c cooccurrence[x][y].direction[i].green;
green 1190 magick/feature.c cooccurrence[x][y].direction[i].green*
green 1191 magick/feature.c MagickLog10(cooccurrence[x][y].direction[i].green);
green 1207 magick/feature.c density_x[x].direction[i].green+=cooccurrence[x][y].direction[i].green;
green 1216 magick/feature.c density_y[y].direction[i].green+=cooccurrence[x][y].direction[i].green;
green 1227 magick/feature.c mean.direction[i].green+=y*sum[y].direction[i].green;
green 1228 magick/feature.c sum_squares.direction[i].green+=y*y*sum[y].direction[i].green;
green 1252 magick/feature.c (correlation.direction[i].green-mean.direction[i].green*
green 1253 magick/feature.c mean.direction[i].green)/(sqrt(sum_squares.direction[i].green-
green 1254 magick/feature.c (mean.direction[i].green*mean.direction[i].green))*sqrt(
green 1255 magick/feature.c sum_squares.direction[i].green-(mean.direction[i].green*
green 1256 magick/feature.c mean.direction[i].green)));
green 1298 magick/feature.c x*density_xy[x].direction[i].green;
green 1314 magick/feature.c density_xy[x].direction[i].green*
green 1315 magick/feature.c MagickLog10(density_xy[x].direction[i].green);
green 1337 magick/feature.c density_xy[x].direction[i].green;
green 1378 magick/feature.c variance.direction[i].green+=(y-mean.direction[i].green+1)*
green 1379 magick/feature.c (y-mean.direction[i].green+1)*cooccurrence[x][y].direction[i].green;
green 1394 magick/feature.c density_xy[MagickAbsoluteValue(y-x)].direction[i].green+=
green 1395 magick/feature.c cooccurrence[x][y].direction[i].green;
green 1409 magick/feature.c entropy_xy.direction[i].green-=cooccurrence[x][y].direction[i].green*
green 1410 magick/feature.c MagickLog10(cooccurrence[x][y].direction[i].green);
green 1423 magick/feature.c entropy_xy1.direction[i].green-=(cooccurrence[x][y].direction[i].green*
green 1424 magick/feature.c MagickLog10(density_x[x].direction[i].green*
green 1425 magick/feature.c density_y[y].direction[i].green));
green 1441 magick/feature.c entropy_xy2.direction[i].green-=(density_x[x].direction[i].green*
green 1442 magick/feature.c density_y[y].direction[i].green*MagickLog10(
green 1443 magick/feature.c density_x[x].direction[i].green*density_y[y].direction[i].green));
green 1461 magick/feature.c variance.direction[i].green;
green 1491 magick/feature.c variance.direction[i].green+=density_xy[x].direction[i].green;
green 1499 magick/feature.c sum_squares.direction[i].green+=density_xy[x].direction[i].green*
green 1500 magick/feature.c density_xy[x].direction[i].green;
green 1516 magick/feature.c density_xy[x].direction[i].green*
green 1517 magick/feature.c MagickLog10(density_xy[x].direction[i].green);
green 1534 magick/feature.c entropy_x.direction[i].green-=(density_x[x].direction[i].green*
green 1535 magick/feature.c MagickLog10(density_x[x].direction[i].green));
green 1546 magick/feature.c entropy_y.direction[i].green-=(density_y[x].direction[i].green*
green 1547 magick/feature.c MagickLog10(density_y[x].direction[i].green));
green 1565 magick/feature.c (((double) number_grays*number_grays*sum_squares.direction[i].green)-
green 1566 magick/feature.c (variance.direction[i].green*variance.direction[i].green))/
green 1590 magick/feature.c (entropy_xy.direction[i].green-entropy_xy1.direction[i].green)/
green 1591 magick/feature.c (entropy_x.direction[i].green > entropy_y.direction[i].green ?
green 1592 magick/feature.c entropy_x.direction[i].green : entropy_y.direction[i].green);
green 1611 magick/feature.c (sqrt(fabs(1.0-exp(-2.0*(entropy_xy2.direction[i].green-
green 1612 magick/feature.c entropy_xy.direction[i].green)))));
green 1659 magick/feature.c pixel.direction[i].green+=cooccurrence[x][y].direction[i].green;
green 1673 magick/feature.c Q[z][y].direction[i].green+=cooccurrence[z][x].direction[i].green*
green 1674 magick/feature.c cooccurrence[y][x].direction[i].green/
green 1675 magick/feature.c density_x[z].direction[i].green/density_y[x].direction[i].red;
green 1692 magick/feature.c channel_features[GreenChannel].contrast[i]+=z*z*pixel.direction[i].green;
green 2233 magick/feature.c (mean_pixel.green-pixel.green)*(mean_pixel.green-pixel.green)+
green 2240 magick/feature.c sum_pixel.green+=pixel.green;
green 2252 magick/feature.c mean_pixel.green=gamma*sum_pixel.green;
green 2261 magick/feature.c 255.0*QuantumScale*(mean_pixel.green-previous_pixel.green)*
green 2262 magick/feature.c 255.0*QuantumScale*(mean_pixel.green-previous_pixel.green)+
green 2269 magick/feature.c q->green=ClampToQuantum(mean_pixel.green);
green 269 magick/fourier.c Cr->green=Ar->green+Br->green;
green 270 magick/fourier.c Ci->green=Ai->green+Bi->green;
green 285 magick/fourier.c Cr->green=Ar->green;
green 286 magick/fourier.c Ci->green=(-Bi->green);
green 304 magick/fourier.c gamma=PerceptibleReciprocal(Br->green*Br->green+Bi->green*Bi->green+
green 306 magick/fourier.c Cr->green=gamma*(Ar->green*Br->green+Ai->green*Bi->green);
green 307 magick/fourier.c Ci->green=gamma*(Ai->green*Br->green-Ar->green*Bi->green);
green 326 magick/fourier.c Cr->green=sqrt(Ar->green*Ar->green+Ai->green*Ai->green);
green 327 magick/fourier.c Ci->green=atan2(Ai->green,Ar->green)/(2.0*MagickPI)+0.5;
green 341 magick/fourier.c Cr->green=QuantumScale*(Ar->green*Br->green-Ai->green*Bi->green);
green 342 magick/fourier.c Ci->green=QuantumScale*(Ai->green*Br->green+Ar->green*Bi->green);
green 358 magick/fourier.c Cr->green=Ar->green*cos(2.0*MagickPI*(Ai->green-0.5));
green 359 magick/fourier.c Ci->green=Ar->green*sin(2.0*MagickPI*(Ai->green-0.5));
green 373 magick/fourier.c Cr->green=Ar->green-Br->green;
green 374 magick/fourier.c Ci->green=Ai->green-Bi->green;
green 552 magick/fx.c pixel.green=0.5*(GetPixelGreen(p)+factor*quantum);
green 560 magick/fx.c pixel.green=0.5*(pixel.green+factor*quantum);
green 563 magick/fx.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 749 magick/fx.c pixel.green=geometry_info.rho;
green 753 magick/fx.c pixel.green=geometry_info.sigma;
green 797 magick/fx.c SetPixelGreen(q,((GetPixelGreen(p)*(100.0-pixel.green)+
green 798 magick/fx.c colorize.green*pixel.green)/100.0));
green 1488 magick/fx.c case GreenChannel: return(QuantumScale*pixel.green);
green 1635 magick/fx.c return(QuantumScale*pixel.green);
green 1668 magick/fx.c ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
green 1712 magick/fx.c ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
green 1721 magick/fx.c luma=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
green 1729 magick/fx.c luminance=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
green 1744 magick/fx.c return(QuantumScale*pixel.green);
green 1802 magick/fx.c ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
green 3759 magick/fx.c SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green 3760 magick/fx.c v.green)/2.0,plasma));
green 3779 magick/fx.c SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green 3780 magick/fx.c v.green)/2.0,plasma));
green 3808 magick/fx.c SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green 3809 magick/fx.c v.green)/2.0,plasma));
green 3832 magick/fx.c SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green 3833 magick/fx.c v.green)/2.0,plasma));
green 3859 magick/fx.c SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green 3860 magick/fx.c v.green)/2.0,plasma));
green 4353 magick/fx.c SetPixelGreen(q,border_image->background_color.green);
green 4513 magick/fx.c pixel.green=pixel.red;
green 4646 magick/fx.c if ((double) image->colormap[i].green > threshold)
green 4647 magick/fx.c image->colormap[i].green=QuantumRange-image->colormap[i].green;
green 5301 magick/fx.c pixel.green=geometry_info.rho;
green 5305 magick/fx.c pixel.green=geometry_info.sigma;
green 5312 magick/fx.c color_vector.green=(MagickRealType) (pixel.green*tint.green/100.0-
green 5361 magick/fx.c pixel.green=(MagickRealType) GetPixelGreen(p)+color_vector.green*(1.0-
green 5363 magick/fx.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 85 magick/gem-private.h static inline void ConvertRGBToXYZ(const Quantum red,const Quantum green,
green 97 magick/gem-private.h g=QuantumScale*DecodePixelGamma((MagickRealType) green);
green 150 magick/gem-private.h Quantum *red,Quantum *green,Quantum *blue)
green 158 magick/gem-private.h assert(green != (Quantum *) NULL);
green 164 magick/gem-private.h *green=ClampToQuantum((MagickRealType) EncodePixelGamma(QuantumRange*g));
green 102 magick/gem.c assert(green != (Quantum *) NULL);
green 147 magick/gem.c *green=ClampToQuantum(QuantumRange*(g+m));
green 196 magick/gem.c assert(green != (Quantum *) NULL);
green 253 magick/gem.c *green=ClampToQuantum(QuantumRange*(z*g+m));
green 298 magick/gem.c assert(green != (Quantum *) NULL);
green 303 magick/gem.c *green=(*red);
green 318 magick/gem.c *green=ClampToQuantum(QuantumRange*t);
green 325 magick/gem.c *green=ClampToQuantum(QuantumRange*brightness);
green 332 magick/gem.c *green=ClampToQuantum(QuantumRange*brightness);
green 339 magick/gem.c *green=ClampToQuantum(QuantumRange*q);
green 346 magick/gem.c *green=ClampToQuantum(QuantumRange*p);
green 353 magick/gem.c *green=ClampToQuantum(QuantumRange*p);
green 400 magick/gem.c assert(green != (Quantum *) NULL);
green 429 magick/gem.c *green=ClampToQuantum(QuantumRange*g);
green 476 magick/gem.c assert(green != (Quantum *) NULL);
green 539 magick/gem.c *green=ClampToQuantum(QuantumRange*g);
green 586 magick/gem.c assert(green != (Quantum *) NULL);
green 646 magick/gem.c *green=ClampToQuantum(QuantumRange*g);
green 695 magick/gem.c assert(green != (Quantum *) NULL);
green 701 magick/gem.c *green=ClampToQuantum(QuantumRange*v);
green 722 magick/gem.c *green=ClampToQuantum(QuantumRange*g);
green 773 magick/gem.c assert(green != (Quantum *) NULL);
green 776 magick/gem.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 826 magick/gem.c assert(green != (Quantum *) NULL);
green 829 magick/gem.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 878 magick/gem.c g=(double) green;
green 889 magick/gem.c if (green == (Quantum) max)
green 945 magick/gem.c g=(double) green;
green 956 magick/gem.c if (green == (Quantum) max)
green 1015 magick/gem.c g=(double) green;
green 1083 magick/gem.c *intensity=(QuantumScale*red+QuantumScale*green+QuantumScale*blue)/3.0;
green 1090 magick/gem.c *saturation=1.0-MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
green 1092 magick/gem.c alpha=0.5*(2.0*QuantumScale*red-QuantumScale*green-QuantumScale*blue);
green 1093 magick/gem.c beta=0.8660254037844385*(QuantumScale*green-QuantumScale*blue);
green 1141 magick/gem.c max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
green 1143 magick/gem.c min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
green 1155 magick/gem.c *hue=(QuantumScale*green-QuantumScale*blue)/c;
green 1156 magick/gem.c if ((QuantumScale*green) < (QuantumScale*blue))
green 1160 magick/gem.c if (max == (QuantumScale*green))
green 1163 magick/gem.c *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
green 1213 magick/gem.c max=MagickMax(QuantumScale*red,MagickMax(QuantumScale*green,
green 1215 magick/gem.c min=MagickMin(QuantumScale*red,MagickMin(QuantumScale*green,
green 1227 magick/gem.c *hue=(QuantumScale*green-QuantumScale*blue)/c;
green 1228 magick/gem.c if ((QuantumScale*green) < (QuantumScale*blue))
green 1232 magick/gem.c if (max == (QuantumScale*green))
green 1235 magick/gem.c *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
green 1287 magick/gem.c g=(double) green;
green 1359 magick/gem.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 1420 magick/gem.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 167 magick/histogram.c ((ScaleQuantumToChar(ClampToQuantum(pixel->green)) >> index) & 0x01) << 1 |
green 1106 magick/histogram.c if (color_2->pixel.green != color_1->pixel.green)
green 1107 magick/histogram.c return((int) color_1->pixel.green-(int) color_2->pixel.green);
green 359 magick/identify.c match=fabs((double) (p->green-target)) < 0.5 ? MagickTrue :
green 1879 magick/image.c if ((pixel.green < 0.0) || (pixel.green > QuantumRange) ||
green 1880 magick/image.c (pixel.green != (QuantumAny) pixel.green))
green 1329 magick/mac.c image->colormap[x].green=
green 1330 magick/mac.c (*(picture_info.theColorTable))->ctTable[x].rgb.green;
green 1369 magick/mac.c SetPixelGreen(q,ScaleCharToQuantum(Pixel.green & 0xff));
green 969 magick/matrix.c q->green=q->red;
green 2715 magick/morphology.c result.green =
green 2738 magick/morphology.c result.green += (*k)*GetPixelGreen(k_pixels);
green 2750 magick/morphology.c SetPixelGreen(q,ClampToQuantum(result.green));
green 2783 magick/morphology.c result.green += alpha*GetPixelGreen(k_pixels);
green 2797 magick/morphology.c SetPixelGreen(q,ClampToQuantum(gamma*result.green));
green 2806 magick/morphology.c || ( p[r].green != GetPixelGreen(q))
green 2918 magick/morphology.c min.green =
green 2923 magick/morphology.c max.green =
green 2929 magick/morphology.c result.green = (double) p[r].green;
green 2940 magick/morphology.c result.green =
green 2986 magick/morphology.c result.green += (*k)*k_pixels[u].green;
green 2998 magick/morphology.c SetPixelGreen(q,ClampToQuantum((MagickRealType) result.green));
green 3030 magick/morphology.c result.green += alpha*k_pixels[u].green;
green 3044 magick/morphology.c SetPixelGreen(q,ClampToQuantum((MagickRealType) (gamma*result.green)));
green 3069 magick/morphology.c Minimize(min.green, (double) k_pixels[u].green);
green 3100 magick/morphology.c Maximize(max.green, (double) k_pixels[u].green);
green 3136 magick/morphology.c Minimize(min.green, (double) k_pixels[u].green);
green 3147 magick/morphology.c Maximize(max.green, (double) k_pixels[u].green);
green 3161 magick/morphology.c min.green -= max.green; Maximize( min.green, 0.0 );
green 3257 magick/morphology.c Minimize(result.green, (*k)+k_pixels[u].green);
green 3291 magick/morphology.c result.green -= min.green;
green 3299 magick/morphology.c result.green += min.green;
green 3319 magick/morphology.c SetPixelGreen(q,ClampToQuantum(result.green));
green 3332 magick/morphology.c || ( p[r].green != GetPixelGreen(q) )
green 3516 magick/morphology.c Minimize(result.green, (*k)+k_pixels[u].green);
green 3533 magick/morphology.c Minimize(result.green, (*k)+k_pixels[u].green);
green 3592 magick/morphology.c SetPixelGreen(q,ClampToQuantum(result.green));
green 3604 magick/morphology.c || ( p[r].green != GetPixelGreen(q) )
green 3709 magick/morphology.c Minimize(result.green, (*k)+k_pixels[u].green);
green 3726 magick/morphology.c Minimize(result.green, (*k)+k_pixels[u].green);
green 3783 magick/morphology.c SetPixelGreen(q,ClampToQuantum(result.green));
green 3795 magick/morphology.c || ( p[r].green != GetPixelGreen(q) )
green 361 magick/paint.c SetPixelGreen(q,ClampToQuantum(fill.green));
green 858 magick/paint.c SetPixelGreen(q,ClampToQuantum(conform_fill.green));
green 1135 magick/paint.c (pixel.green >= low->green) && (pixel.green <= high->green) &&
green 30 magick/pixel-accessor.h #define ClampPixelGreen(pixel) ClampToQuantum((pixel)->green)
green 34 magick/pixel-accessor.h #define GetPixela(pixel) ((pixel)->green)
green 39 magick/pixel-accessor.h #define GetPixelCb(pixel) ((pixel)->green)
green 43 magick/pixel-accessor.h #define GetPixelGreen(pixel) ((pixel)->green)
green 46 magick/pixel-accessor.h #define GetPixelMagenta(pixel) ((pixel)->green)
green 53 magick/pixel-accessor.h (packet)->green=GetPixelGreen((pixel)); \
green 59 magick/pixel-accessor.h (packet)->green=GetPixelGreen((pixel)); \
green 65 magick/pixel-accessor.h #define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
green 71 magick/pixel-accessor.h #define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
green 75 magick/pixel-accessor.h ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
green 76 magick/pixel-accessor.h #define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
green 79 magick/pixel-accessor.h #define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
green 85 magick/pixel-accessor.h SetPixelGreen(pixel,(packet)->green); \
green 91 magick/pixel-accessor.h SetPixelGreen(pixel,(packet)->green); \
green 98 magick/pixel-accessor.h SetPixelGreen(pixel,(packet)->green); \
green 148 magick/pixel-accessor.h intensity=0.212656f*gamma*pixel->red+0.715158f*gamma*pixel->green+
green 166 magick/pixel-accessor.h intensity=0.212656f*gamma*pixel->red+0.715158f*gamma*pixel->green+
green 171 magick/pixel-accessor.h 0.715158f*DecodePixelGamma(gamma*pixel->green)+
green 198 magick/pixel-accessor.h red_green=(MagickRealType) pixel->red-pixel->green;
green 199 magick/pixel-accessor.h green_blue=(MagickRealType) pixel->green-pixel->blue;
green 211 magick/pixel-accessor.h if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
green 213 magick/pixel-accessor.h intensity=0.212656*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
green 221 magick/pixel-accessor.h pixel->green=ClampToQuantum(magick_pixel->green);
green 82 magick/pixel-private.h pixel->green=(MagickRealType) GetPixelGreen(color);
green 97 magick/pixel-private.h pixel->green=image->bias;
green 107 magick/pixel-private.h SetPixelGreen(color,ClampToQuantum(pixel->green));
green 2117 magick/pixel.c green,
green 2125 magick/pixel.c green=gamma*pixel->green;
green 2131 magick/pixel.c intensity=(red+green+blue)/3.0;
green 2136 magick/pixel.c intensity=MagickMax(MagickMax(red,green),blue);
green 2141 magick/pixel.c intensity=(MagickMin(MagickMin(red,green),blue)+
green 2142 magick/pixel.c MagickMax(MagickMax(red,green),blue))/2.0;
green 2147 magick/pixel.c intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
green 2156 magick/pixel.c green=EncodePixelGamma(green);
green 2159 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2167 magick/pixel.c green=DecodePixelGamma(green);
green 2170 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2179 magick/pixel.c green=EncodePixelGamma(green);
green 2182 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2190 magick/pixel.c green=DecodePixelGamma(green);
green 2193 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2198 magick/pixel.c intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
green 2239 magick/pixel.c pixel->green=0.0;
green 2295 magick/pixel.c green,
green 2303 magick/pixel.c green=gamma*pixel->green;
green 2309 magick/pixel.c intensity=(red+green+blue)/3.0;
green 2314 magick/pixel.c intensity=MagickMax(MagickMax(red,green),blue);
green 2319 magick/pixel.c intensity=(MagickMin(MagickMin(red,green),blue)+
green 2320 magick/pixel.c MagickMax(MagickMax(red,green),blue))/2.0;
green 2325 magick/pixel.c intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
green 2334 magick/pixel.c green=EncodePixelGamma(green);
green 2337 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2345 magick/pixel.c green=DecodePixelGamma(green);
green 2348 magick/pixel.c intensity=0.298839*red+0.586811*green+0.114350*blue;
green 2357 magick/pixel.c green=EncodePixelGamma(green);
green 2360 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2368 magick/pixel.c green=DecodePixelGamma(green);
green 2371 magick/pixel.c intensity=0.212656*red+0.715158*green+0.072186*blue;
green 2376 magick/pixel.c intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
green 4350 magick/pixel.c pixel->green=(MagickRealType) GetPixelGreen(color);
green 4362 magick/pixel.c pixel->green=(*alpha*GetPixelGreen(color));
green 4503 magick/pixel.c pixel->green=0.0;
green 4514 magick/pixel.c pixel->green+=gamma*pixels[0].green;
green 4521 magick/pixel.c pixel->green*=gamma;
green 4564 magick/pixel.c pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
green 4565 magick/pixel.c pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
green 4566 magick/pixel.c pixels[3].green));
green 4609 magick/pixel.c pixels[i].green+=pixels[i+2].green;
green 4626 magick/pixel.c pixels[0].green+=pixels[1].green;
green 4634 magick/pixel.c pixel->green=alpha[0]*pixels[0].green; /* divide by sum of alpha */
green 4668 magick/pixel.c pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
green 4669 magick/pixel.c pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
green 4670 magick/pixel.c cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
green 4671 magick/pixel.c cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
green 4672 magick/pixel.c pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
green 4673 magick/pixel.c cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
green 4782 magick/pixel.c pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
green 4783 magick/pixel.c pixels[3].green,pixels[0].green);
green 4803 magick/pixel.c pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
green 4804 magick/pixel.c pixels[0].green,pixels[3].green);
green 4829 magick/pixel.c pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
green 4830 magick/pixel.c pixels[1].green,pixels[2].green);
green 4851 magick/pixel.c pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
green 4852 magick/pixel.c pixels[2].green,pixels[1].green);
green 4905 magick/pixel.c pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
green 4906 magick/pixel.c pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
green 4907 magick/pixel.c cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
green 4908 magick/pixel.c cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
green 4909 magick/pixel.c pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
green 4910 magick/pixel.c cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
green 88 magick/pixel.h green,
green 98 magick/pixel.h green,
green 123 magick/pixel.h green,
green 137 magick/pixel.h green,
green 144 magick/pixel.h green,
green 154 magick/pixel.h green,
green 2166 magick/property.c pixel.green=(MagickRealType) QuantumRange*alpha;
green 222 magick/quantize.c green,
green 444 magick/quantize.c alpha_pixel->green=(MagickRealType) GetPixelGreen(pixel);
green 451 magick/quantize.c alpha_pixel->green=alpha*GetPixelGreen(pixel);
green 782 magick/quantize.c midpoint.green=(MagickRealType) QuantumRange/2.0;
green 827 magick/quantize.c mid.green+=(id & 2) != 0 ? bisect : -bisect;
green 851 magick/quantize.c error.green=QuantumScale*(pixel.green-mid.green);
green 855 magick/quantize.c distance=(double) (error.red*error.red+error.green*error.green+
green 868 magick/quantize.c node_info->total_color.green+=count*QuantumScale*ClampPixel(pixel.green);
green 925 magick/quantize.c mid.green+=(id & 2) != 0 ? bisect : -bisect;
green 949 magick/quantize.c error.green=QuantumScale*(pixel.green-mid.green);
green 953 magick/quantize.c distance=(double) (error.red*error.red+error.green*error.green+
green 966 magick/quantize.c node_info->total_color.green+=count*QuantumScale*ClampPixel(pixel.green);
green 1235 magick/quantize.c QuantumRange*node_info->total_color.green)));
green 1253 magick/quantize.c QuantumRange*node_info->total_color.green)));
green 1267 magick/quantize.c gamma*QuantumRange*node_info->total_color.green)));
green 1440 magick/quantize.c GreenShift(ScaleQuantumToChar(ClampPixel(pixel->green))) |
green 1532 magick/quantize.c pixel.green+=7*current[u-v].green/16;
green 1542 magick/quantize.c pixel.green+=previous[u+v].green/16;
green 1548 magick/quantize.c pixel.green+=5*previous[u].green/16;
green 1555 magick/quantize.c pixel.green+=3*previous[u-v].green/16;
green 1562 magick/quantize.c pixel.green=(MagickRealType) ClampPixel(pixel.green);
green 1614 magick/quantize.c current[u].green=pixel.green-color.green;
green 1773 magick/quantize.c pixel.green+=p->weights[i]*p->error[i].green;
green 1779 magick/quantize.c pixel.green=(MagickRealType) ClampPixel(pixel.green);
green 1833 magick/quantize.c p->error[ErrorQueueLength-1].green=pixel.green-color.green;
green 2174 magick/quantize.c image->colormap[index].green));
green 2330 magick/quantize.c image->colormap[i].green=PosterizePixel(image->colormap[i].green);
green 2463 magick/quantize.c parent->total_color.green+=node_info->total_color.green;
green 2642 magick/quantize.c image->colormap[i].green=GetPixelGreen(q);
green 3392 magick/quantize.c image->colormap[image->colors].green=GetPixelGreen(q);
green 517 magick/resample.c resample_filter->average_pixel.green *= weight;
green 526 magick/resample.c resample_filter->average_pixel.green +=
green 527 magick/resample.c weight*resample_filter->image->background_color.green;
green 536 magick/resample.c resample_filter->average_pixel.green /= divisor_c;
green 554 magick/resample.c pixel->red = pixel->green = pixel->blue = 0.0;
green 625 magick/resample.c pixel->green += weight*pixels->green;
green 665 magick/resample.c pixel->opacity = pixel->red = pixel->green = pixel->blue = 0;
green 683 magick/resample.c pixel->green = (MagickRealType) ClampToQuantum(divisor_c*pixel->green);
green 1935 magick/resize.c pixel.green=QuantumRange*(packet[1]/255.0);
green 2574 magick/resize.c pixel.green+=alpha*GetPixelGreen(p+j);
green 2579 magick/resize.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 2607 magick/resize.c pixel.green+=alpha*GetPixelGreen(p+j);
green 2614 magick/resize.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 2820 magick/resize.c pixel.green+=alpha*GetPixelGreen(p+j);
green 2825 magick/resize.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 2853 magick/resize.c pixel.green+=alpha*GetPixelGreen(p+j);
green 2860 magick/resize.c SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green 3394 magick/resize.c x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
green 3429 magick/resize.c x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
green 3443 magick/resize.c y_vector[x].green+=scale.y*x_vector[x].green;
green 3472 magick/resize.c x_vector[x].green=(MagickRealType) (alpha*GetPixelGreen(p));
green 3488 magick/resize.c pixel.green=y_vector[x].green+span.y*x_vector[x].green;
green 3495 magick/resize.c s->green=pixel.green;
green 3524 magick/resize.c SetPixelGreen(q,ClampToQuantum(alpha*s->green));
green 3555 magick/resize.c pixel.green+=span.x*s->green;
green 3562 magick/resize.c t->green=pixel.green;
green 3581 magick/resize.c pixel.green+=scale.x*s->green;
green 3595 magick/resize.c pixel.green+=span.x*s->green;
green 3606 magick/resize.c t->green=pixel.green;
green 3623 magick/resize.c SetPixelGreen(q,ClampToQuantum(alpha*t->green));
green 141 magick/segment.c green,
green 262 magick/segment.c green,
green 293 magick/segment.c (void) ResetMagickMemory(&green,0,sizeof(green));
green 297 magick/segment.c green.index=0;
green 298 magick/segment.c while (DefineRegion(extrema[Green],&green) != 0)
green 325 magick/segment.c cluster->green=green;
green 345 magick/segment.c cluster->green=green;
green 377 magick/segment.c (cluster->green.left-SafeMargin)) &&
green 379 magick/segment.c (cluster->green.right+SafeMargin)) &&
green 390 magick/segment.c cluster->green.center+=(MagickRealType)
green 430 magick/segment.c cluster->green.center/=cluster->count;
green 480 magick/segment.c cluster->green.left,(double) cluster->green.right,(double)
green 494 magick/segment.c cluster->red.center,(double) cluster->green.center,(double)
green 522 magick/segment.c image->colormap[i].green=ScaleCharToQuantum((unsigned char)
green 523 magick/segment.c (cluster->green.center+0.5));
green 572 magick/segment.c ((ssize_t) ScaleQuantumToChar(q->green) >=
green 573 magick/segment.c (cluster->green.left-SafeMargin)) &&
green 574 magick/segment.c ((ssize_t) ScaleQuantumToChar(q->green) <=
green 575 magick/segment.c (cluster->green.right+SafeMargin)) &&
green 611 magick/segment.c squares[(ssize_t) ScaleQuantumToChar(q->green)-
green 621 magick/segment.c squares[(ssize_t) ScaleQuantumToChar(q->green)-
green 943 magick/segment.c green,
green 1007 magick/segment.c (void) ResetMagickMemory(&green,0,sizeof(green));
green 1011 magick/segment.c green.index=0;
green 1012 magick/segment.c while (DefineRegion(extrema[Green],&green) != 0)
green 1043 magick/segment.c cluster->green=green;
green 1066 magick/segment.c cluster->green=green;
green 1088 magick/segment.c (cluster->green.left-SafeMargin)) &&
green 1090 magick/segment.c (cluster->green.right+SafeMargin)) &&
green 1102 magick/segment.c cluster->green.center+=(MagickRealType)
green 1133 magick/segment.c cluster->green.center/=cluster->count;
green 1172 magick/segment.c threshold=(background->green.center+object->green.center)/2.0;
green 1173 magick/segment.c pixel->green=(MagickRealType) ScaleCharToQuantum((unsigned char)
green 547 magick/shear.c background.green+=QuantumScale*GetPixelGreen(p);
green 557 magick/shear.c image->background_color.green=ClampToQuantum((MagickRealType) QuantumRange*
green 558 magick/shear.c background.green/count);
green 559 magick/statistic.c evaluate_pixel[i].green=ApplyEvaluateOperator(random_info[id],
green 560 magick/statistic.c GetPixelGreen(p),op,evaluate_pixel[i].green);
green 574 magick/statistic.c SetPixelGreen(q,ClampToQuantum(evaluate_pixel[i/2].green));
green 665 magick/statistic.c evaluate_pixel[x].green=ApplyEvaluateOperator(random_info[id],
green 667 magick/statistic.c evaluate_pixel[x].green);
green 687 magick/statistic.c evaluate_pixel[x].green/=number_images;
green 697 magick/statistic.c evaluate_pixel[x].green=sqrt((double) evaluate_pixel[x].green/
green 715 magick/statistic.c evaluate_pixel[x].green*=(MagickRealType) QuantumScale;
green 724 magick/statistic.c SetPixelGreen(q,ClampToQuantum(evaluate_pixel[x].green));
green 1703 magick/statistic.c M00[GreenChannel]+=QuantumScale*pixel.green;
green 1704 magick/statistic.c M10[GreenChannel]+=x*QuantumScale*pixel.green;
green 1705 magick/statistic.c M01[GreenChannel]+=y*QuantumScale*pixel.green;
green 1783 magick/statistic.c centroid[GreenChannel].y)*QuantumScale*pixel.green;
green 1785 magick/statistic.c centroid[GreenChannel].x)*QuantumScale*pixel.green;
green 1787 magick/statistic.c centroid[GreenChannel].y)*QuantumScale*pixel.green;
green 1790 magick/statistic.c pixel.green;
green 1793 magick/statistic.c pixel.green;
green 1796 magick/statistic.c centroid[GreenChannel].y)*QuantumScale*pixel.green;
green 1799 magick/statistic.c pixel.green;
green 1802 magick/statistic.c pixel.green;
green 2203 magick/statistic.c if (pixel.green < *minima)
green 2204 magick/statistic.c *minima=(double) pixel.green;
green 2205 magick/statistic.c if (pixel.green > *maxima)
green 2206 magick/statistic.c *maxima=(double) pixel.green;
green 2433 magick/statistic.c histogram[ScaleQuantumToMap(GetPixelGreen(p))].green++;
green 2496 magick/statistic.c if (histogram[i].green > 0.0)
green 2497 magick/statistic.c number_bins.green++;
green 2510 magick/statistic.c histogram[i].green/=area;
green 2511 magick/statistic.c channel_statistics[GreenChannel].entropy+=-histogram[i].green*
green 2512 magick/statistic.c MagickLog10(histogram[i].green)/MagickLog10((double) number_bins.green);
green 2781 magick/statistic.c polynomial_pixel[x].green+=coefficient*pow(QuantumScale*p->green,
green 2801 magick/statistic.c SetPixelGreen(q,ClampToQuantum(QuantumRange*polynomial_pixel[x].green));
green 3083 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3128 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3168 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3211 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3259 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3308 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3354 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3408 magick/statistic.c pixel->green=(MagickRealType) ScaleShortToQuantum(channels[1]);
green 3638 magick/statistic.c pixel.green=MagickAbsoluteValue(maximum.green-minimum.green);
green 3690 magick/statistic.c SetPixelGreen(q,ClampToQuantum(pixel.green));
green 276 magick/threshold.c channel_bias.green+=r[u].green;
green 284 magick/threshold.c channel_sum.green+=r[u].green;
green 300 magick/threshold.c channel_sum.green-=channel_bias.green;
green 308 magick/threshold.c channel_bias.green+=r[0].green;
green 314 magick/threshold.c channel_sum.green+=r[width-1].green;
green 323 magick/threshold.c mean.green=(MagickRealType) (channel_sum.green/number_pixels+offset);
green 330 magick/threshold.c SetPixelGreen(q,((MagickRealType) GetPixelGreen(q) <= mean.green) ?
green 616 magick/threshold.c threshold.green=geometry_info.sigma;
green 618 magick/threshold.c threshold.green=threshold.red;
green 631 magick/threshold.c threshold.green*=(MagickRealType) (QuantumRange/100.0);
green 675 magick/threshold.c ((MagickRealType) GetPixelGreen(q) < threshold.green))
green 1496 magick/threshold.c levels.green = ((channel & GreenChannel) != 0) ? levels.index : 0;
green 1509 magick/threshold.c levels.green = (unsigned int) strtoul(p, &p, 10), (void)(*p == ',' && p++);
green 1533 magick/threshold.c levels.red, levels.green, levels.blue, levels.opacity, levels.index);
green 1545 magick/threshold.c levels.green = levels.green ? levels.green-1 : 0;
green 1612 magick/threshold.c if (levels.green) {
green 1614 magick/threshold.c (levels.green*d+1));
green 1617 magick/threshold.c ((l+(t >= threshold))*(MagickRealType) QuantumRange/levels.green)));
green 2080 magick/threshold.c threshold.green=min_threshold;
green 2083 magick/threshold.c threshold.green=max_threshold;
green 2085 magick/threshold.c threshold.green=(MagickRealType) (QuantumRange*
green 2126 magick/threshold.c SetPixelGreen(q,(MagickRealType) GetPixelGreen(q) <= threshold.green ?
green 2242 magick/threshold.c threshold.green=geometry_info.sigma;
green 2244 magick/threshold.c threshold.green=threshold.red;
green 2257 magick/threshold.c threshold.green*=(MagickRealType) (QuantumRange/100.0);
green 2301 magick/threshold.c ((MagickRealType) GetPixelGreen(q) > threshold.green))
green 497 magick/transform.c q->green=ClampToQuantum(QuantumRange-GetPixelIntensity(images,p));
green 296 magick/vision.c q->green=q->red;
green 387 magick/vision.c object[i].color.green+=p->green;
green 405 magick/vision.c object[i].color.green=object[i].color.green/object[i].area;
green 659 magick/vision.c q->green=q->red;
green 2089 magick/widget.c windows->widget.pixel_info->matte_color.green,
green 599 magick/xwindow-private.h if ((pixel->red == pixel->green) && (pixel->green == pixel->blue))
green 601 magick/xwindow-private.h intensity=0.21265*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
green 114 magick/xwindow.c ((ScaleQuantumToShort(XGreenGamma((color)->green))*map->green_max/65535L)* \
green 126 magick/xwindow.c (((color)->green*map->green_max/65535L)*map->green_mult)+ \
green 176 magick/xwindow.c green,
green 575 magick/xwindow.c SetPixelGreen(q,ScaleShortToQuantum(pixel->box_color.green));
green 587 magick/xwindow.c SetPixelGreen(q,ScaleShortToQuantum(pixel->pen_color.green));
green 1057 magick/xwindow.c pixel.green=colors[i].green-(MagickRealType) color->green;
green 1058 magick/xwindow.c distance+=pixel.green*pixel.green;
green 2173 magick/xwindow.c color.green=ClampToQuantum((MagickRealType) (green_map[i][j][(int)
green 2178 magick/xwindow.c (((size_t) color.green & 0xe0) >> 3) |
green 2449 magick/xwindow.c SetPixelGreen(q,ScaleShortToQuantum(pixel->pen_color.green));
green 3075 magick/xwindow.c pixel->highlight_color.green=(unsigned short) (((MagickRealType)
green 3076 magick/xwindow.c pixel->matte_color.green*ScaleQuantumToShort(HighlightModulate))/65535L+
green 3089 magick/xwindow.c pixel->shadow_color.green=(unsigned short) (((MagickRealType)
green 3090 magick/xwindow.c pixel->matte_color.green*ScaleQuantumToShort(ShadowModulate))/65535L);
green 3100 magick/xwindow.c pixel->depth_color.green=(unsigned short) (((MagickRealType)
green 3101 magick/xwindow.c pixel->matte_color.green*ScaleQuantumToShort(DepthModulate))/65535L);
green 3111 magick/xwindow.c pixel->trough_color.green=(unsigned short) (((MagickRealType)
green 3112 magick/xwindow.c pixel->matte_color.green*ScaleQuantumToShort(TroughModulate))/65535L);
green 3859 magick/xwindow.c pixel.green=ScaleShortToQuantum(color.green);
green 4212 magick/xwindow.c green,
green 4221 magick/xwindow.c green=0;
green 4231 magick/xwindow.c colors[i].pixel=(unsigned long) (red | green | blue);
green 4236 magick/xwindow.c green+=green_bit;
green 4237 magick/xwindow.c if (green > window_info[id].visual->green_mask)
green 4238 magick/xwindow.c green=0;
green 4338 magick/xwindow.c colors[index].green));
green 4394 magick/xwindow.c composite_image->colormap[colors[i].pixel].green=
green 4395 magick/xwindow.c ScaleShortToQuantum(colors[i].green);
green 7564 magick/xwindow.c intensity=0.298839*pixel->red+0.586811*pixel->green+0.114350*pixel->blue;
green 7776 magick/xwindow.c color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
green 7782 magick/xwindow.c color.green=gray_value;
green 7863 magick/xwindow.c diversity[i].green=image->colormap[i].green;
green 7909 magick/xwindow.c color.green=
green 7910 magick/xwindow.c ScaleQuantumToShort(XGreenGamma(image->colormap[index].green));
green 7917 magick/xwindow.c color.green=gray_value;
green 7946 magick/xwindow.c color.green=
green 7947 magick/xwindow.c ScaleQuantumToShort(XGreenGamma(image->colormap[index].green));
green 7954 magick/xwindow.c color.green=gray_value;
green 8037 magick/xwindow.c color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
green 8043 magick/xwindow.c color.green=gray_value;
green 8091 magick/xwindow.c color.green=color.blue;
green 8103 magick/xwindow.c color.green=(unsigned int) 0;
green 8105 magick/xwindow.c color.green=(unsigned short) ((size_t)
green 8140 magick/xwindow.c pixel->background_color.green=
green 8141 magick/xwindow.c (~pixel->foreground_color.green);
green 8560 magick/xwindow.c color->green=0;
green 8579 magick/xwindow.c color->green=xcolor.green;
green 9035 magick/xwindow.c pixel.pen_color.green=ScaleQuantumToShort(draw_info->fill.green);
green 107 tests/validate.c g=QuantumScale*DecodePixelGamma(green);
green 147 tests/validate.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 191 tests/validate.c *green=ClampToQuantum(EncodePixelGamma(QuantumRange*g));
green 204 tests/validate.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 210 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 211 tests/validate.c *Pb=QuantumScale*((-0.1687367)*red-0.331264*green+0.5*blue)+0.5;
green 212 tests/validate.c *Pr=QuantumScale*(0.5*red-0.418688*green-0.081312*blue)+0.5;
green 218 tests/validate.c ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
green 226 tests/validate.c *green=ClampToQuantum(QuantumRange*(0.99999975910502514331*Y-
green 235 tests/validate.c ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
green 255 tests/validate.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 274 tests/validate.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 304 tests/validate.c ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green 331 tests/validate.c ConvertXYZToRGB(X,Y,Z,red,green,blue);
green 337 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 338 tests/validate.c *Db=QuantumScale*(-0.450*red-0.883*green+1.333*blue)+0.5;
green 339 tests/validate.c *Dr=QuantumScale*(-1.333*red+1.116*green+0.217*blue)+0.5;
green 347 tests/validate.c *green=ClampToQuantum(QuantumRange*(Y-0.12913289889050927*(Db-0.5)+
green 356 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 357 tests/validate.c *I=QuantumScale*(0.595716*red-0.274453*green-0.321263*blue)+0.5;
green 358 tests/validate.c *Q=QuantumScale*(0.211456*red-0.522591*green+0.311135*blue)+0.5;
green 366 tests/validate.c *green=ClampToQuantum(QuantumRange*(Y-0.2721220993185104464*(I-0.5)-
green 375 tests/validate.c *Y=QuantumScale*(0.298839*red+0.586811*green+0.114350*blue);
green 376 tests/validate.c *U=QuantumScale*((-0.147)*red-0.289*green+0.436*blue)+0.5;
green 377 tests/validate.c *V=QuantumScale*(0.615*red-0.515*green-0.100*blue)+0.5;
green 385 tests/validate.c *green=ClampToQuantum(QuantumRange*(Y-0.3946101641414141437*(U-0.5)-
green 298 wand/drawing-wand.c pixel.green=(MagickRealType) GetPixelGreen(color);
green 2381 wand/drawing-wand.c pixel->green=(MagickRealType) GetPixelGreen(color);
green 578 wand/mogrify.c sparse_arguments[x++] = QuantumScale*color.green;
green 752 wand/pixel-wand.c (double) (QuantumScale*wand->pixel.green),
green 1003 wand/pixel-wand.c return((double) QuantumScale*wand->pixel.green);
green 1034 wand/pixel-wand.c return(ClampToQuantum(wand->pixel.green));
green 1071 wand/pixel-wand.c wand->pixel.green),ClampToQuantum(wand->pixel.blue),hue,saturation,
green 1134 wand/pixel-wand.c return((double) QuantumScale*wand->pixel.green);
green 1165 wand/pixel-wand.c return(ClampToQuantum(wand->pixel.green));
green 1301 wand/pixel-wand.c color->green=ClampToQuantum((MagickRealType) QuantumRange-
green 1302 wand/pixel-wand.c (wand->pixel.green*(QuantumRange-wand->pixel.index)+
green 1309 wand/pixel-wand.c color->green=ClampToQuantum(wand->pixel.green);
green 1880 wand/pixel-wand.c wand->pixel.green=(MagickRealType) ClampToQuantum((MagickRealType)
green 1881 wand/pixel-wand.c QuantumRange*green);
green 1914 wand/pixel-wand.c wand->pixel.green=(MagickRealType) green;
green 1948 wand/pixel-wand.c green,
green 1955 wand/pixel-wand.c ConvertHSLToRGB(hue,saturation,lightness,&red,&green,&blue);
green 1957 wand/pixel-wand.c wand->pixel.green=(MagickRealType) green;
green 2024 wand/pixel-wand.c wand->pixel.green=(MagickRealType) ClampToQuantum((MagickRealType)
green 2059 wand/pixel-wand.c wand->pixel.green=(MagickRealType) magenta;
green 2198 wand/pixel-wand.c wand->pixel.green=(MagickRealType) color->green;
green 85 www/source/contrast.c pixel.green=SigmoidalContrast(pixel.green);
green 30 www/source/core/sigmoidal-contrast.c pixels[x].green=RoundToQuantum(SigmoidalContrast(pixels[x].green));
green 31 www/source/wand/sigmoidal-contrast.c pixel.green=SigmoidalContrast(pixel.green);