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            1181 Magick++/lib/Image.cpp   return(Color(constImage()->matte_color.red,constImage()->matte_color.green,
green            2984 Magick++/lib/Image.cpp   target.green=pixel.green;
green            3012 Magick++/lib/Image.cpp   target.green=pixel.green;
green            3401 Magick++/lib/Image.cpp   black.green=pixel.green;
green            3408 Magick++/lib/Image.cpp   white.green=pixel.green;
green            3432 Magick++/lib/Image.cpp   black.green=pixel.green;
green            3439 Magick++/lib/Image.cpp   white.green=pixel.green;
green            4549 Magick++/lib/Image.cpp   statistics->green.minimum=minimum;
green            4550 Magick++/lib/Image.cpp   statistics->green.maximum=maximum;
green            4551 Magick++/lib/Image.cpp   (void) GetImageChannelMean(constImage(),GreenChannel,&statistics->green.mean,
green            4552 Magick++/lib/Image.cpp     &statistics->green.standard_deviation,exceptionInfo);
green            4554 Magick++/lib/Image.cpp     &statistics->green.kurtosis,&statistics->green.skewness,exceptionInfo);
green            5160 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            2126 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            3739 coders/dcm.c               image->colormap[i].green=(Quantum) index;
green            3756 coders/dcm.c               image->colormap[i].green=(Quantum) index;
green            3938 coders/dcm.c                   pixel.green=1U*image->colormap[index].green;
green            3946 coders/dcm.c                       pixel.green=(unsigned int) ReadDCMByte(stream_info,image);
green            3952 coders/dcm.c                       pixel.green=ReadDCMShort(stream_info,image);
green            3956 coders/dcm.c                   pixel.green&=mask;
green            3961 coders/dcm.c                       pixel.green=scale[pixel.green];
green            3966 coders/dcm.c               SetPixelGreen(q,pixel.green);
green            4050 coders/dcm.c                     pixel.green=1U*image->colormap[index].green;
green            4058 coders/dcm.c                         pixel.green=(unsigned int) ReadDCMByte(stream_info,image);
green            4064 coders/dcm.c                         pixel.green=ReadDCMShort(stream_info,image);
green            4068 coders/dcm.c                     pixel.green&=mask;
green            4073 coders/dcm.c                         pixel.green=scale[pixel.green];
green            4080 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             645 coders/fpx.c   static void SetColorBalance(double red,double green,double blue,
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             468 coders/jp2.c                q->green=q->red;
green             480 coders/jp2.c                q->green=ClampToQuantum(pixel);
green            1022 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             590 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            1520 coders/miff.c              SetPixelGreen(q,pixel.green);
green            1836 coders/miff.c            value=ScaleQuantumToLong(pixel.green);
green            1862 coders/miff.c            value=ScaleQuantumToShort(pixel.green);
green            1888 coders/miff.c            value=(unsigned char) ScaleQuantumToChar(pixel.green);
green            2359 coders/miff.c                pixel=ScaleQuantumToLong(image->colormap[i].green);
green            2372 coders/miff.c                pixel=ScaleQuantumToShort(image->colormap[i].green);
green            2386 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            3166 coders/msl.c             pixel.green=0.0;
green            3216 coders/msl.c                         pixel.green=StringToDouble(value,(char **) NULL);
green            3245 coders/msl.c                 (double) pixel.red,(double) pixel.green,(double) pixel.blue);
green            3261 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            2598 coders/pdf.c                 Ascii85Encode(image,ScaleQuantumToChar(image->colormap[i].green));
green            2605 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            2727 coders/png.c                         background.green=(png_uint_16)
green            2728 coders/png.c                           mng_info->global_plte[background.index].green;
green            2734 coders/png.c                           mng_info->global_plte[background.index].green;
green            2775 coders/png.c           ping_background->green *= bkgd_scale;
green            2784 coders/png.c                    ping_background->red,ping_background->green,
green            2787 coders/png.c                    ping_background->green,ping_background->blue);
green            2793 coders/png.c           image->background_color.green=
green            2794 coders/png.c               ScaleShortToQuantum(ping_background->green);
green            2805 coders/png.c               (double) image->background_color.green,
green            2831 coders/png.c             (int)ping_trans_color->green > max_sample ||
green            2850 coders/png.c             transparent_color.green= scale_to_short*ping_trans_color->green;
green            2863 coders/png.c                 transparent_color.green=transparent_color.opacity;
green            2953 coders/png.c               image->colormap[i].green=ScaleCharToQuantum(palette[i].green);
green            2960 coders/png.c               image->colormap[i].green=0;
green            2979 coders/png.c               image->colormap[i].green=(Quantum) (i*scale);
green            3184 coders/png.c                       == transparent_color.green &&
green            3499 coders/png.c                     == transparent_color.green &&
green            4406 coders/png.c               image->background_color.green=image->background_color.red;
green            4413 coders/png.c               image->background_color.green=ScaleCharToQuantum(p[3]);
green            5284 coders/png.c                   mng_info->mng_global_bkgd.green=
green            5310 coders/png.c                   mng_background_color.green=
green            5341 coders/png.c                     mng_info->global_plte[i].green=p[3*i+1];
green            5351 coders/png.c                 mng_info->global_plte[i].green=i;
green            6013 coders/png.c                   mng_info->global_sbit.green=p[1];
green            7961 coders/png.c     ping_background.green = 0;
green            7967 coders/png.c     ping_trans_color.green=0;
green            8421 coders/png.c                       (int) image->colormap[i].green,
green            8434 coders/png.c                       (int) image->colormap[i].green,
green            8505 coders/png.c                          ping_trans_color.green=
green            8569 coders/png.c                     (int) image->background_color.green,
green            8575 coders/png.c                    opaque[i].green == image->background_color.green &&
green            8708 coders/png.c                   if (colormap[i].red != colormap[i].green ||
green            8782 coders/png.c                         image->colormap[i].green ==
green            8818 coders/png.c                           (int) image->colormap[i].green,
green            9093 coders/png.c             ScaleQuantumToChar(image->background_color.green) == 0x00 &&
green            9136 coders/png.c                   ScaleQuantumToChar(image->colormap[i].green) == 0x00 &&
green            9208 coders/png.c                        ping_trans_color.green &&
green            9231 coders/png.c                       image->colormap[i].green == image->colormap[0].green &&
green            9483 coders/png.c          ping_background.green=(png_uint_16)
green            9484 coders/png.c            (ScaleQuantumToShort(image->background_color.green) & mask);
green            9489 coders/png.c          ping_background.gray=(png_uint_16) ping_background.green;
green            9535 coders/png.c           palette[i].green=ScaleQuantumToChar(image->colormap[i].green);
green            9544 coders/png.c               (long) i,palette[i].red,palette[i].green,palette[i].blue);
green            9815 coders/png.c                 ping_trans_color.green=(png_uint_16)
green            9816 coders/png.c                   (ScaleQuantumToShort(image->colormap[0].green) & mask);
green            9848 coders/png.c                     ping_trans_color.green&=0xff;
green            9859 coders/png.c                 ping_trans_color.green&=0xff;
green            9979 coders/png.c                     palette[i].green=ScaleQuantumToChar(image->colormap[i].green);
green            10051 coders/png.c                     (int) ping_trans_color.green,
green            10056 coders/png.c               ping_trans_color.green*=0x0101;
green            10065 coders/png.c                     (int) ping_trans_color.green,
green            10153 coders/png.c                           (int) ping_background.green,
green            10447 coders/png.c                         (int) palette[i].green,
green            10456 coders/png.c                         (int) palette[i].green,
green            10610 coders/png.c                           (int) ping_background.green,
green            10726 coders/png.c                          (int) ping_trans_color.green,
green            12386 coders/png.c         green,
green            12400 coders/png.c       green=ScaleQuantumToChar(image->background_color.green);
green            12405 coders/png.c       *(chunk+7)=green;
green            12956 coders/png.c           green,
green            13034 coders/png.c                   next_image->background_color.green !=
green            13035 coders/png.c                   next_image->next->background_color.green ||
green            13380 coders/png.c            green=ScaleQuantumToShort(image->background_color.green);
green            13383 coders/png.c            PNGShort(chunk+6,green);
green            13416 coders/png.c              chunk[5+i*3]=ScaleQuantumToChar(image->colormap[i].green) & 0xff;
green            13468 coders/png.c                     chunk[5+i*3]=ScaleQuantumToChar(image->colormap[i].green);
green            1186 coders/ps.c          q=PopHexPixel(hex_digits,ScaleQuantumToChar(pixel.green),q); \
green            2047 coders/ps.c                          (GetPixelGreen(p) == pixel.green) &&
green            2168 coders/ps.c                  ScaleQuantumToChar(image->colormap[i].green),
green            2213 coders/ps.c                      pixel.green=GetPixelGreen(p);
green            1020 coders/ps2.c                 ScaleQuantumToChar(image->colormap[i].green),
green            1514 coders/ps3.c                     pixel=ScaleQuantumToChar(image->colormap[i].green);
green            1527 coders/ps3.c                     pixel=ScaleQuantumToChar(image->colormap[i].green);
green            1220 coders/psd.c           color.green=color.red;
green            1883 coders/psd.c               image->colormap[i].green=ScaleCharToQuantum((unsigned char)
green            2716 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             538 coders/rle.c               image->colormap[i].green=ScaleCharToQuantum((unsigned char) i);
green             546 coders/rle.c                 image->colormap[i].green=ScaleCharToQuantum(*(p+map_length));
green             595 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             353 coders/tga.c               pixel.green=pixel.red;
green             370 coders/tga.c               pixel.green=ScaleAnyToQuantum((1UL*(k & 0x03) << 3)+
green             381 coders/tga.c               pixel.green=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
green             391 coders/tga.c               pixel.green=ScaleCharToQuantum((unsigned char) ReadBlobByte(image));
green             458 coders/tga.c                   pixel.green=ScaleCharToQuantum((unsigned char) index);
green             478 coders/tga.c               pixel.green=ScaleAnyToQuantum((1UL*(k & 0x03) << 3)+
green             496 coders/tga.c               pixel.green=ScaleCharToQuantum(pixels[1]);
green             508 coders/tga.c               pixel.green=ScaleCharToQuantum(pixels[1]);
green             520 coders/tga.c         SetPixelGreen(q,pixel.green);
green             683 coders/tga.c                 green,
green             686 coders/tga.c                 green=(unsigned char) ScaleQuantumToAny(GetPixelGreen(p),range);
green             688 coders/tga.c                   ((green & 0x07) << 5);
green             693 coders/tga.c                   ((green & 0x18) >> 3));
green             859 coders/tga.c           green,
green             875 coders/tga.c               green=(unsigned char) ScaleQuantumToAny(image->colormap[i].green,
green             878 coders/tga.c                 range)) | ((green & 0x07) << 5);
green             882 coders/tga.c                 range) << 2) | ((green & 0x18) >> 3);
green             887 coders/tga.c               *q++=ScaleQuantumToChar(image->colormap[i].green);
green            1538 coders/tiff.c                    image->colormap[i].green=ClampToQuantum(((double)
green            3836 coders/tiff.c            *green,
green            3843 coders/tiff.c          green=(uint16 *) AcquireQuantumMemory(65536,sizeof(*green));
green            3845 coders/tiff.c          if ((red == (uint16 *) NULL) || (green == (uint16 *) NULL) ||
green            3852 coders/tiff.c          (void) ResetMagickMemory(green,0,65536*sizeof(*green));
green            3857 coders/tiff.c            green[i]=ScaleQuantumToShort(image->colormap[i].green);
green            3860 coders/tiff.c          (void) TIFFSetField(tiff,TIFFTAG_COLORMAP,red,green,blue);
green            3862 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             770 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             455 coders/viff.c                image->colormap[i].green=ScaleCharToQuantum((unsigned char)
green             461 coders/viff.c                image->colormap[i % image->colors].green=ScaleCharToQuantum(
green             704 coders/viff.c                      ConstrainColormapIndex(image,index)].green);
green            1135 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             344 coders/xwd.c           colors[i].green=color.green;
green             475 coders/xwd.c                     index].green));
green             535 coders/xwd.c             image->colormap[i].green=ScaleShortToQuantum(colors[i].green);
green             794 coders/xwd.c           colors[i].green=ScaleQuantumToShort(image->colormap[i].green);
green             810 coders/xwd.c           color.green=colors[i].green;
green              47 magick/accelerate-private.h     green,
green              54 magick/accelerate-private.h     green,
green             393 magick/accelerate-private.h     float green = getGreen(p);
green             405 magick/accelerate-private.h       intensity = (red + green + blue) / 3.0;
green             410 magick/accelerate-private.h       intensity = max(max(red, green), blue);
green             415 magick/accelerate-private.h       intensity = (min(min(red, green), blue) +
green             416 magick/accelerate-private.h         max(max(red, green), blue)) / 2.0;
green             421 magick/accelerate-private.h       intensity = (float)(((float)red*red + green*green + blue*blue) /
green             435 magick/accelerate-private.h       intensity = 0.298839*red + 0.586811*green + 0.114350*blue;
green             448 magick/accelerate-private.h       intensity = 0.298839*red + 0.586811*green + 0.114350*blue;
green             462 magick/accelerate-private.h       intensity = 0.212656*red + 0.715158*green + 0.072186*blue;
green             475 magick/accelerate-private.h       intensity = 0.212656*red + 0.715158*green + 0.072186*blue;
green             480 magick/accelerate-private.h       intensity = (float)(sqrt((float)red*red + green*green + blue*blue) /
green            1495 magick/accelerate-private.h         CLQuantum red, green, blue, opacity;
green            1516 magick/accelerate-private.h             green = getGreen(eValue);
green            1541 magick/accelerate-private.h         im[c]=(CLPixelType)(blue, green, red, opacity);
green            1959 magick/accelerate-private.h         CLQuantum red, green, blue, opacity;
green            1973 magick/accelerate-private.h             green = getRed(eValue);
green            1982 magick/accelerate-private.h             im[c]=(CLPixelType)(blue, green, red, opacity);
green            2138 magick/accelerate-private.h         green,
green            2143 magick/accelerate-private.h     green=(float)getGreen(pixel);
green            2154 magick/accelerate-private.h           intensity=(red+green+blue)/3.0;
green            2159 magick/accelerate-private.h           intensity=max(max(red,green),blue);
green            2164 magick/accelerate-private.h           intensity=(min(min(red,green),blue)+
green            2165 magick/accelerate-private.h               max(max(red,green),blue))/2.0;
green            2170 magick/accelerate-private.h           intensity=(float) (((float) red*red+green*green+
green            2184 magick/accelerate-private.h           intensity=0.298839*red+0.586811*green+0.114350*blue;
green            2197 magick/accelerate-private.h           intensity=0.298839*red+0.586811*green+0.114350*blue;
green            2211 magick/accelerate-private.h           intensity=0.212656*red+0.715158*green+0.072186*blue;
green            2224 magick/accelerate-private.h           intensity=0.212656*red+0.715158*green+0.072186*blue;
green            2229 magick/accelerate-private.h           intensity=(float) (sqrt((float) red*red+green*green+
green            2384 magick/accelerate-private.h   inline void ConvertRGBToHSL(const CLQuantum red,const CLQuantum green, const CLQuantum blue,
green            2395 magick/accelerate-private.h   tmax=max(QuantumScale*red,max(QuantumScale*green, QuantumScale*blue));
green            2396 magick/accelerate-private.h   tmin=min(QuantumScale*red,min(QuantumScale*green, QuantumScale*blue));
green            2410 magick/accelerate-private.h     *hue=(QuantumScale*green-QuantumScale*blue)/c;
green            2411 magick/accelerate-private.h     if ((QuantumScale*green) < (QuantumScale*blue))
green            2415 magick/accelerate-private.h     if (tmax == (QuantumScale*green))
green            2418 magick/accelerate-private.h       *hue=4.0+(QuantumScale*red-QuantumScale*green)/c;
green            2428 magick/accelerate-private.h       CLQuantum *red,CLQuantum *green,CLQuantum *blue)
green            2503 magick/accelerate-private.h     *green=ClampToQuantum(QuantumRange*g);
green            2508 magick/accelerate-private.h     CLQuantum *red,CLQuantum *green,CLQuantum *blue)
green            2518 magick/accelerate-private.h     ConvertRGBToHSL(*red,*green,*blue,&hue,&saturation,&lightness);
green            2526 magick/accelerate-private.h     ConvertHSLToRGB(hue,saturation,lightness,red,green,blue);
green            2545 magick/accelerate-private.h         green,
green            2549 magick/accelerate-private.h     green=getGreen(pixel);
green            2558 magick/accelerate-private.h               &red, &green, &blue);
green            2566 magick/accelerate-private.h     setGreen(&filteredPixel, green);
green            2081 magick/accelerate.c   black.green=0.0;
green            2082 magick/accelerate.c   white.green=MaxRange(QuantumRange);
green            2092 magick/accelerate.c     black.green=(MagickRealType) i;
green            2100 magick/accelerate.c     white.green=(MagickRealType) i;
green            2196 magick/accelerate.c       if (i < (ssize_t) black.green)
green            2197 magick/accelerate.c         stretch_map[i].green=0;
green            2199 magick/accelerate.c         if (i > (ssize_t) white.green)
green            2200 magick/accelerate.c           stretch_map[i].green=QuantumRange;
green            2202 magick/accelerate.c           if (black.green != white.green)
green            2203 magick/accelerate.c             stretch_map[i].green=ScaleMapToQuantum((MagickRealType) (MaxMap*
green            2204 magick/accelerate.c                   (i-black.green)/(white.green-black.green)));
green            2268 magick/accelerate.c         if (black.green != white.green)
green            2269 magick/accelerate.c           image->colormap[i].green=stretch_map[
green            2270 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].green)].green;
green            3435 magick/accelerate.c       intensity.green+=histogram[i].s[1];
green            3464 magick/accelerate.c     if (((channel & GreenChannel) != 0) && (white.green != black.green))
green            3465 magick/accelerate.c       equalize_map[i].green=ScaleMapToQuantum((MagickRealType) ((MaxMap*
green            3466 magick/accelerate.c               (map[i].green-black.green))/(white.green-black.green)));
green            3495 magick/accelerate.c           image->colormap[i].green=equalize_map[
green            3496 magick/accelerate.c             ScaleQuantumToMap(image->colormap[i].green)].red;
green            3507 magick/accelerate.c       if (((channel & GreenChannel) != 0) && (white.green != black.green))
green            3508 magick/accelerate.c         image->colormap[i].green=equalize_map[
green            3509 magick/accelerate.c           ScaleQuantumToMap(image->colormap[i].green)].green;
green            4905 magick/accelerate.c   biasPixel.s[1] = bias.green;
green            5233 magick/accelerate.c   biasPixel.s[1] = bias.green;
green            1928 magick/annotate.c           SetPixelGreen(q,fill_color.green);
green             351 magick/attribute.c             if (IsPixelAtDepth(image->colormap[i].green,range) == MagickFalse)
green            1102 magick/attribute.c           image->colormap[i].green=ScaleAnyToQuantum(ScaleQuantumToAny(
green            1103 magick/attribute.c             ClampPixel(image->colormap[i].green),range),range);
green            3253 magick/cache.c   composite->green=gamma*MagickOver_(p->green,alpha,q->green,beta);
green            3327 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            1463 magick/color.c       color=pixel->green;
green            1553 magick/color.c       status&=color.green == SVGCompliant(color.green);
green            1717 magick/color.c   pixel=(MagickRealType) GetPixelGreen(p)-q->green;
green            2026 magick/color.c   pixel=GetPixelGreen(p)-q->green;
green            2440 magick/color.c         pixel.green*(QuantumRange-pixel.index)+pixel.index)))));
green            2447 magick/color.c   SetPixelGreen(color,ClampToQuantum(pixel.green));
green            2622 magick/color.c             pixel.red=pixel.green;
green            2623 magick/color.c             pixel.green=pixel.blue;
green            2653 magick/color.c             pixel.red=pixel.green;
green            2654 magick/color.c             pixel.green=pixel.blue;
green            2680 magick/color.c       color->green=(MagickRealType) ScaleAnyToQuantum(pixel.green,range);
green            2775 magick/color.c             color->green=(MagickRealType) ClampToQuantum((MagickRealType)
green            2798 magick/color.c                 color->green=(MagickRealType) ClampToQuantum((MagickRealType)
green            2807 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             108 magick/colorspace.c static inline void ConvertRGBToCMY(const Quantum red,const Quantum green,
green             112 magick/colorspace.c   *magenta=QuantumScale*(QuantumRange-green);
green             116 magick/colorspace.c static void ConvertRGBToLab(const Quantum red,const Quantum green,
green             124 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             136 magick/colorspace.c static void ConvertRGBToLMS(const Quantum red,const Quantum green,
green             144 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             148 magick/colorspace.c static void ConvertRGBToLuv(const Quantum red,const Quantum green,
green             156 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             160 magick/colorspace.c static void ConvertRGBToxyY(const Quantum red,const Quantum green,
green             168 magick/colorspace.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             174 magick/colorspace.c static void ConvertRGBToYPbPr(const Quantum red,const Quantum green,
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             182 magick/colorspace.c static void ConvertRGBToYCbCr(const Quantum red,const Quantum green,
green             185 magick/colorspace.c   ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
green             188 magick/colorspace.c static void ConvertRGBToYUV(const Quantum red,const Quantum green,
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             196 magick/colorspace.c static void ConvertRGBToYDbDr(const Quantum red,const Quantum green,
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             204 magick/colorspace.c static void ConvertRGBToYIQ(const Quantum red,const Quantum green,
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            1454 magick/colorspace.c   const double yellow,Quantum *red,Quantum *green,Quantum *blue)
green            1457 magick/colorspace.c   *green=ClampToQuantum(QuantumRange*(1.0-magenta));
green            1470 magick/colorspace.c   const double S,Quantum *red,Quantum *green,Quantum *blue)
green            1478 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green            1482 magick/colorspace.c   const double v,Quantum *red,Quantum *green,Quantum *blue)
green            1490 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green            1503 magick/colorspace.c   const double b,Quantum *red,Quantum *green,Quantum *blue)
green            1511 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green            1515 magick/colorspace.c   const double cap_Y,Quantum *red,Quantum *green,Quantum *blue)
green            1525 magick/colorspace.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green            1529 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
green            1533 magick/colorspace.c   *green=ClampToQuantum(QuantumRange*(0.99999975910502514331*Y-
green            1540 magick/colorspace.c   const double Cr,Quantum *red,Quantum *green,Quantum *blue)
green            1542 magick/colorspace.c   ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
green            1546 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
green            1550 magick/colorspace.c   *green=ClampToQuantum(QuantumRange*(Y-0.12913289889050927*(Db-0.5)+
green            1557 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
green            1561 magick/colorspace.c   *green=ClampToQuantum(QuantumRange*(Y-0.2721220993185104464*(I-0.5)-
green            1568 magick/colorspace.c   Quantum *red,Quantum *green,Quantum *blue)
green            1572 magick/colorspace.c   *green=ClampToQuantum(QuantumRange*(Y-0.3946101641414141437*(U-0.5)-
green            2047 magick/colorspace.c             green,
green            2057 magick/colorspace.c               ConvertCMYToRGB(X,Y,Z,&red,&green,&blue);
green            2062 magick/colorspace.c               ConvertHCLToRGB(X,Y,Z,&red,&green,&blue);
green            2067 magick/colorspace.c               ConvertHCLpToRGB(X,Y,Z,&red,&green,&blue);
green            2072 magick/colorspace.c               ConvertHSBToRGB(X,Y,Z,&red,&green,&blue);
green            2077 magick/colorspace.c               ConvertHSIToRGB(X,Y,Z,&red,&green,&blue);
green            2082 magick/colorspace.c               ConvertHSLToRGB(X,Y,Z,&red,&green,&blue);
green            2087 magick/colorspace.c               ConvertHSVToRGB(X,Y,Z,&red,&green,&blue);
green            2092 magick/colorspace.c               ConvertHWBToRGB(X,Y,Z,&red,&green,&blue);
green            2097 magick/colorspace.c               ConvertLabToRGB(X,Y,Z,&red,&green,&blue);
green            2103 magick/colorspace.c               ConvertLCHabToRGB(X,Y,Z,&red,&green,&blue);
green            2108 magick/colorspace.c               ConvertLCHuvToRGB(X,Y,Z,&red,&green,&blue);
green            2113 magick/colorspace.c               ConvertLMSToRGB(X,Y,Z,&red,&green,&blue);
green            2118 magick/colorspace.c               ConvertLuvToRGB(X,Y,Z,&red,&green,&blue);
green            2123 magick/colorspace.c               ConvertxyYToRGB(X,Y,Z,&red,&green,&blue);
green            2128 magick/colorspace.c               ConvertXYZToRGB(X,Y,Z,&red,&green,&blue);
green            2133 magick/colorspace.c               ConvertYCbCrToRGB(X,Y,Z,&red,&green,&blue);
green            2138 magick/colorspace.c               ConvertYDbDrToRGB(X,Y,Z,&red,&green,&blue);
green            2143 magick/colorspace.c               ConvertYIQToRGB(X,Y,Z,&red,&green,&blue);
green            2148 magick/colorspace.c               ConvertYPbPrToRGB(X,Y,Z,&red,&green,&blue);
green            2153 magick/colorspace.c               ConvertYUVToRGB(X,Y,Z,&red,&green,&blue);
green            2159 magick/colorspace.c               green=ClampToQuantum(QuantumRange*Y);
green            2165 magick/colorspace.c           SetPixelGreen(q,ClampToQuantum((MagickRealType) green));
green            2265 magick/colorspace.c             green,
green            2270 magick/colorspace.c           green=ClampToQuantum(EncodePixelGamma((MagickRealType)
green            2275 magick/colorspace.c           SetPixelGreen(q,green);
green            2331 magick/colorspace.c             green,
green            2335 magick/colorspace.c           green=ClampToQuantum(EncodePixelGamma((MagickRealType)
green            2340 magick/colorspace.c           SetPixelGreen(q,green);
green            2570 magick/colorspace.c             green,
green            2574 magick/colorspace.c           green=ScaleQuantumToMap(GetPixelGreen(q));
green            2576 magick/colorspace.c           pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
green            2577 magick/colorspace.c           pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
green            2578 magick/colorspace.c           pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
green            2583 magick/colorspace.c               pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.green/
green            2591 magick/colorspace.c               pixel.green=(MagickRealType) ScaleMapToQuantum(pixel.green);
green            2595 magick/colorspace.c           SetPixelGreen(q,ClampToQuantum(pixel.green));
green            2635 magick/colorspace.c           green,
green            2639 magick/colorspace.c         green=ScaleQuantumToMap(image->colormap[i].green);
green            2641 magick/colorspace.c         pixel.red=x_map[red].x+y_map[green].x+z_map[blue].x;
green            2642 magick/colorspace.c         pixel.green=x_map[red].y+y_map[green].y+z_map[blue].y;
green            2643 magick/colorspace.c         pixel.blue=x_map[red].z+y_map[green].z+z_map[blue].z;
green            2648 magick/colorspace.c             pixel.green=QuantumRange*YCCMap[RoundToYCC(1024.0*pixel.green/
green            2656 magick/colorspace.c             pixel.green=(MagickRealType) ScaleMapToQuantum(pixel.green);
green            2660 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             651 magick/composite.c   MagickRealType *red,MagickRealType *green,MagickRealType *blue)
green             666 magick/composite.c   assert(green != (MagickRealType *) NULL);
green             711 magick/composite.c   *green=QuantumRange*(g+m);
green             715 magick/composite.c static void CompositeHCL(const MagickRealType red,const MagickRealType green,
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            1170 magick/composite.c     composite->green=ModulusAdd(p->green,Sa,q->green,Da);
green            1182 magick/composite.c       composite->green=ModulusAdd(p->green,1.0,q->green,1.0);
green            1222 magick/composite.c     composite->green=ModulusSubtract(p->green,Sa,q->green,Da);
green            1234 magick/composite.c       composite->green=ModulusSubtract(p->green,1.0,q->green,1.0);
green            1265 magick/composite.c     composite->green=gamma*Multiply(QuantumScale*p->green*Sa,Sa,QuantumScale*
green            1266 magick/composite.c       q->green*Da,Da);
green            1279 magick/composite.c       composite->green=QuantumScale*p->green*q->green;
green            1312 magick/composite.c   composite->green=gamma*Out(p->green,Sa,q->green,Da);
green            1349 magick/composite.c   composite->green=gamma*PegtopLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green            1350 magick/composite.c     q->green*Da,Da);
green            1389 magick/composite.c   composite->green=gamma*PinLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green            1390 magick/composite.c     q->green*Da,Da);
green            1427 magick/composite.c     composite->green=gamma*Screen(p->green*Sa,q->green*Da);
green            1439 magick/composite.c       composite->green=QuantumRange*Screen(QuantumScale*p->green,
green            1440 magick/composite.c            QuantumScale*q->green);
green            1502 magick/composite.c   composite->green=gamma*SoftLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green            1503 magick/composite.c     q->green*Da,Da);
green            1535 magick/composite.c   composite->green=Threshold(p->green,q->green,threshold,amount);
green            1575 magick/composite.c   composite->green=gamma*VividLight(QuantumScale*p->green*Sa,Sa,QuantumScale*
green            1576 magick/composite.c     q->green*Da,Da);
green            1604 magick/composite.c   composite->green=gamma*Xor(p->green*Sa,Sa,q->green*Da,Da);
green            2367 magick/composite.c       canvas.green=(MagickRealType) GetPixelGreen(q);
green            2376 magick/composite.c           canvas.green=(MagickRealType) QuantumRange-canvas.green;
green            2424 magick/composite.c               composite.green=(MagickRealType) QuantumRange-composite.green;
green            2431 magick/composite.c             ClampPixel(composite.green) : ClampToQuantum(composite.green));
green            2448 magick/composite.c       source.green=(MagickRealType) GetPixelGreen(p);
green            2458 magick/composite.c           source.green=(MagickRealType) QuantumRange-source.green;
green            2721 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green            2725 magick/composite.c           HCLComposite(hue,chroma,luma,&composite.red,&composite.green,
green            2738 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green            2740 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&hue,&sans,&sans);
green            2742 magick/composite.c             &composite.green,&composite.blue);
green            2756 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green            2758 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&sans,&chroma,
green            2761 magick/composite.c             &composite.green,&composite.blue);
green            2775 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&hue,
green            2777 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&sans,&sans,
green            2780 magick/composite.c             &composite.green,&composite.blue);
green            2794 magick/composite.c           CompositeHCL(canvas.red,canvas.green,canvas.blue,&sans,
green            2796 magick/composite.c           CompositeHCL(source.red,source.green,source.blue,&hue,&chroma,&sans);
green            2798 magick/composite.c             &composite.green,&composite.blue);
green            2812 magick/composite.c           composite.green=source.green;
green            2851 magick/composite.c           composite.green=(MagickRealType) QuantumRange-composite.green;
green            2858 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             956 magick/deprecate.c   threshold.green=geometry_info.sigma;
green             958 magick/deprecate.c     threshold.green=threshold.red;
green             963 magick/deprecate.c   status&=BilevelImageChannel(image,GreenChannel,threshold.green);
green            2286 magick/deprecate.c   pixel.green=GetPixelGreen(p)-(MagickRealType)
green            2288 magick/deprecate.c   distance+=pixel.green*pixel.green;
green            3432 magick/deprecate.c   const double lightness,Quantum *red,Quantum *green,Quantum *blue)
green            3445 magick/deprecate.c   assert(green != (Quantum *) NULL);
green            3456 magick/deprecate.c   *green=ClampToQuantum((MagickRealType) QuantumRange*g);
green            3573 magick/deprecate.c   p=(pixels[3].green-pixels[2].green)-(pixels[0].green-pixels[1].green);
green            3574 magick/deprecate.c   q=(pixels[0].green-pixels[1].green)-p;
green            3575 magick/deprecate.c   r=pixels[2].green-pixels[0].green;
green            3576 magick/deprecate.c   s=pixels[1].green;
green            3577 magick/deprecate.c   pixel->green=(dx*dx2*p)+(dx2*q)+(dx*r)+s;
green            3675 magick/deprecate.c             pixels[i].green*=alpha[i];
green            3683 magick/deprecate.c         pixel.green+=gamma*0.0625*pixels[i].green;
green            3720 magick/deprecate.c             pixels[i].green*=alpha[i];
green            3766 magick/deprecate.c             pixels[i].green*=alpha[i];
green            3781 magick/deprecate.c       pixel.green=gamma*((1.0-delta.y)*((1.0-delta.x)*pixels[0].green+delta.x*
green            3782 magick/deprecate.c         pixels[1].green)+delta.y*((1.0-delta.x)*pixels[2].green+
green            3783 magick/deprecate.c         delta.x*pixels[3].green));
green            3875 magick/deprecate.c             pixels[i].green*=alpha[i];
green            3901 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[2].green,
green            3902 magick/deprecate.c                 pixels[3].green,pixels[0].green);
green            3921 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[1].green,
green            3922 magick/deprecate.c                 pixels[0].green,pixels[3].green);
green            3946 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[0].green,
green            3947 magick/deprecate.c                 pixels[1].green,pixels[2].green);
green            3967 magick/deprecate.c               pixel.green=gamma*MeshInterpolate(&delta,pixels[3].green,
green            3968 magick/deprecate.c                 pixels[2].green,pixels[1].green);
green            4035 magick/deprecate.c               pixels[n].green*=alpha[n];
green            4044 magick/deprecate.c           pixel.green+=gamma*dx*dy*pixels[n].green;
green            7240 magick/deprecate.c     pixel.green=geometry_info.sigma;
green            7242 magick/deprecate.c     pixel.green=pixel.red;
green            7254 magick/deprecate.c       pixel.green*=QuantumRange/100.0f;
green            7287 magick/deprecate.c         SetPixelGreen(q,image->colormap[(ssize_t) index].green);
green            7296 magick/deprecate.c         SetPixelGreen(q,(MagickRealType) q->green <= pixel.green
green            7382 magick/deprecate.c MagickExport void TransformHSL(const Quantum red,const Quantum green,
green            7400 magick/deprecate.c   g=QuantumScale*green;
green            3711 magick/display.c             q->green=ScaleShortToQuantum(color.green);
green            3740 magick/display.c                         q->green=ScaleShortToQuantum(color.green);
green            3755 magick/display.c                       (*image)->colormap[i].green=ScaleShortToQuantum(
green            3756 magick/display.c                         color.green);
green            3782 magick/display.c                 target.green=(MagickRealType)
green            3783 magick/display.c                   ScaleShortToQuantum(border_color.green);
green            3813 magick/display.c                 q->green=ScaleShortToQuantum(color.green);
green            10063 magick/display.c                 target.green=(MagickRealType)
green            10064 magick/display.c                   ScaleShortToQuantum(border_color.green);
green            12281 magick/display.c   (*image)->background_color.green=ScaleShortToQuantum(
green            12282 magick/display.c     windows->pixel_info->pen_colors[pen_id].green);
green            3090 magick/distort.c               pixel.green   = coeff[x]*i +coeff[x+1]*j
green            3110 magick/distort.c               pixel.green   = coeff[x]*i     + coeff[x+1]*j +
green            3132 magick/distort.c             if ( channel & GreenChannel   ) pixel.green   = 0.0;
green            3147 magick/distort.c                 pixel.green   += arguments[x++]*weight;
green            3157 magick/distort.c             if ( channel & GreenChannel   ) pixel.green   /= denominator;
green            3181 magick/distort.c                 if ( channel & GreenChannel   ) pixel.green   = arguments[x++];
green            3209 magick/distort.c                 if ( channel & GreenChannel   ) pixel.green   = arguments[x++];
green            3223 magick/distort.c           pixel.green=ClampPixel(QuantumRange*pixel.green);
green            4304 magick/draw.c                target.green=(MagickRealType) draw_info->border_color.green;
green            4415 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            3452 magick/effect.c             qixel.green+=pixel.green;
green            3466 magick/effect.c             SetPixelGreen(q,ClampToQuantum(normalize*qixel.green));
green            3491 magick/effect.c             qixel.green+=alpha*pixel.green;
green            3507 magick/effect.c             SetPixelGreen(q,ClampToQuantum(gamma*qixel.green));
green            3794 magick/effect.c       pixel.green=bias.green;
green            3812 magick/effect.c                   pixel.green+=(*k)*GetPixelGreen(p+u+j);
green            3826 magick/effect.c                 SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green            3888 magick/effect.c                   pixel.green+=(*k)*alpha*GetPixelGreen(p+u+j);
green            3903 magick/effect.c                 SetPixelGreen(q,ClampToQuantum(gamma*pixel.green));
green            4627 magick/effect.c     pixel.green=bias.green;
green            4644 magick/effect.c           pixel.green=GetPixelGreen(p)-(MagickRealType) q->green;
green            4645 magick/effect.c           if (fabs(2.0*pixel.green) < quantum_threshold)
green            4646 magick/effect.c             pixel.green=(MagickRealType) GetPixelGreen(p);
green            4648 magick/effect.c             pixel.green=(MagickRealType) GetPixelGreen(p)+(pixel.green*gain);
green            4649 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             913 magick/enhance.c static void Contrast(const int sign,Quantum *red,Quantum *green,Quantum *blue)
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            3460 magick/enhance.c   Quantum *green,Quantum *blue)
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            3483 magick/enhance.c   Quantum *green,Quantum *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            3506 magick/enhance.c   Quantum *red,Quantum *green,Quantum *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            3529 magick/enhance.c   Quantum *red,Quantum *green,Quantum *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            3552 magick/enhance.c   Quantum *red,Quantum *green,Quantum *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            3575 magick/enhance.c   Quantum *green,Quantum *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            3598 magick/enhance.c   Quantum *green,Quantum *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            3621 magick/enhance.c   Quantum *green,Quantum *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            3644 magick/enhance.c   Quantum *green,Quantum *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            1484 magick/fx.c            case GreenChannel: return(QuantumScale*pixel.green);
green            1631 magick/fx.c            return(QuantumScale*pixel.green);
green            1664 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
green            1708 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
green            1717 magick/fx.c              luma=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
green            1725 magick/fx.c              luminance=0.212656*pixel.red+0.715158*pixel.green+0.072186*pixel.blue;
green            1740 magick/fx.c            return(QuantumScale*pixel.green);
green            1798 magick/fx.c              ConvertRGBToHSL(ClampToQuantum(pixel.red),ClampToQuantum(pixel.green),
green            3798 magick/fx.c          SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green            3799 magick/fx.c            v.green)/2.0,plasma));
green            3818 magick/fx.c              SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green            3819 magick/fx.c                v.green)/2.0,plasma));
green            3847 magick/fx.c              SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green            3848 magick/fx.c                v.green)/2.0,plasma));
green            3871 magick/fx.c              SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green            3872 magick/fx.c                v.green)/2.0,plasma));
green            3898 magick/fx.c          SetPixelGreen(q,PlasmaPixel(random_info,(MagickRealType) (u.green+
green            3899 magick/fx.c            v.green)/2.0,plasma));
green            4392 magick/fx.c          SetPixelGreen(q,border_image->background_color.green);
green            4551 magick/fx.c            pixel.green=pixel.red;
green            4684 magick/fx.c              if ((double) image->colormap[i].green > threshold)
green            4685 magick/fx.c                image->colormap[i].green=QuantumRange-image->colormap[i].green;
green            5339 magick/fx.c      pixel.green=geometry_info.rho;
green            5343 magick/fx.c        pixel.green=geometry_info.sigma;
green            5350 magick/fx.c      color_vector.green=(MagickRealType) (pixel.green*tint.green/100.0-
green            5399 magick/fx.c          pixel.green=(MagickRealType) GetPixelGreen(p)+color_vector.green*(1.0-
green            5401 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              87 magick/gem.c     const double luma,Quantum *red,Quantum *green,Quantum *blue)
green             102 magick/gem.c     assert(green != (Quantum *) NULL);
green             147 magick/gem.c     *green=ClampToQuantum(QuantumRange*(g+m));
green             180 magick/gem.c     const double luma,Quantum *red,Quantum *green,Quantum *blue)
green             196 magick/gem.c     assert(green != (Quantum *) NULL);
green             253 magick/gem.c     *green=ClampToQuantum(QuantumRange*(z*g+m));
green             285 magick/gem.c     const double brightness,Quantum *red,Quantum *green,Quantum *blue)
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             388 magick/gem.c     const double intensity,Quantum *red,Quantum *green,Quantum *blue)
green             400 magick/gem.c     assert(green != (Quantum *) NULL);
green             429 magick/gem.c     *green=ClampToQuantum(QuantumRange*g);
green             461 magick/gem.c     const double lightness,Quantum *red,Quantum *green,Quantum *blue)
green             476 magick/gem.c     assert(green != (Quantum *) NULL);
green             539 magick/gem.c     *green=ClampToQuantum(QuantumRange*g);
green             571 magick/gem.c     const double value,Quantum *red,Quantum *green,Quantum *blue)
green             586 magick/gem.c     assert(green != (Quantum *) NULL);
green             646 magick/gem.c     *green=ClampToQuantum(QuantumRange*g);
green             678 magick/gem.c     const double blackness,Quantum *red,Quantum *green,Quantum *blue)
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             762 magick/gem.c     const double hue,Quantum *red,Quantum *green,Quantum *blue)
green             773 magick/gem.c     assert(green != (Quantum *) NULL);
green             776 magick/gem.c     ConvertXYZToRGB(X,Y,Z,red,green,blue);
green             815 magick/gem.c     const double hue,Quantum *red,Quantum *green,Quantum *blue)
green             826 magick/gem.c     assert(green != (Quantum *) NULL);
green             829 magick/gem.c     ConvertXYZToRGB(X,Y,Z,red,green,blue);
green             860 magick/gem.c   MagickExport void ConvertRGBToHCL(const Quantum red,const Quantum green,
green             878 magick/gem.c     g=(double) green;
green             889 magick/gem.c         if (green == (Quantum) max)
green             927 magick/gem.c   MagickExport void ConvertRGBToHCLp(const Quantum red,const Quantum green,
green             945 magick/gem.c     g=(double) green;
green             956 magick/gem.c         if (green == (Quantum) max)
green             994 magick/gem.c   MagickExport void ConvertRGBToHSB(const Quantum red,const Quantum green,
green            1015 magick/gem.c     g=(double) green;
green            1070 magick/gem.c   MagickExport void ConvertRGBToHSI(const Quantum red,const Quantum 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            1127 magick/gem.c   MagickExport void ConvertRGBToHSL(const Quantum red,const Quantum green,
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            1199 magick/gem.c   MagickExport void ConvertRGBToHSV(const Quantum red,const Quantum green,
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            1268 magick/gem.c   MagickExport void ConvertRGBToHWB(const Quantum red,const Quantum green,
green            1287 magick/gem.c     g=(double) green;
green            1345 magick/gem.c   MagickExport void ConvertRGBToLCHab(const Quantum red,const Quantum green,
green            1359 magick/gem.c     ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green            1406 magick/gem.c   MagickExport void ConvertRGBToLCHuv(const Quantum red,const Quantum green,
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            1150 magick/histogram.c   if (color_2->pixel.green != color_1->pixel.green)
green            1151 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            1884 magick/image.c       if ((pixel.green < 0.0) || (pixel.green > QuantumRange) ||
green            1885 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             364 magick/paint.c             SetPixelGreen(q,ClampToQuantum(fill.green));
green            1018 magick/paint.c             SetPixelGreen(q,ClampToQuantum(conform_fill.green));
green            1295 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              47 magick/pixel-accessor.h #define GetPixelMagenta(pixel) ((pixel)->green)
green              54 magick/pixel-accessor.h   (packet)->green=GetPixelGreen((pixel)); \
green              60 magick/pixel-accessor.h   (packet)->green=GetPixelGreen((pixel)); \
green              66 magick/pixel-accessor.h #define SetPixela(pixel,value) ((pixel)->green=(Quantum) (value))
green              72 magick/pixel-accessor.h #define SetPixelCb(pixel,value) ((pixel)->green=(Quantum) (value))
green              76 magick/pixel-accessor.h   ((pixel)->red=(pixel)->green=(pixel)->blue=(Quantum) (value))
green              77 magick/pixel-accessor.h #define SetPixelGreen(pixel,value) ((pixel)->green=(Quantum) (value))
green              80 magick/pixel-accessor.h #define SetPixelMagenta(pixel,value) ((pixel)->green=(Quantum) (value))
green              86 magick/pixel-accessor.h   SetPixelGreen(pixel,(packet)->green); \
green              92 magick/pixel-accessor.h   SetPixelGreen(pixel,(packet)->green); \
green              99 magick/pixel-accessor.h   SetPixelGreen(pixel,(packet)->green); \
green             144 magick/pixel-accessor.h   intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
green             157 magick/pixel-accessor.h       intensity=(MagickRealType) (0.212656f*pixel->red+0.715158f*pixel->green+
green             162 magick/pixel-accessor.h     pixel->red)+0.715158f*DecodePixelGamma((MagickRealType) pixel->green)+
green             189 magick/pixel-accessor.h   red_green=(MagickRealType) pixel->red-pixel->green;
green             190 magick/pixel-accessor.h   green_blue=(MagickRealType) pixel->green-pixel->blue;
green             208 magick/pixel-accessor.h   red_green=(MagickRealType) pixel->red-pixel->green;
green             209 magick/pixel-accessor.h   green_blue=(MagickRealType) pixel->green-pixel->blue;
green             221 magick/pixel-accessor.h   if ((pixel->red  == pixel->green) && (pixel->green == pixel->blue))
green             223 magick/pixel-accessor.h   intensity=(MagickRealType) (0.212656*pixel->red+0.715158*pixel->green+
green             233 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            2116 magick/pixel.c     green,
green            2121 magick/pixel.c   green=pixel->green;
green            2127 magick/pixel.c       intensity=(red+green+blue)/3.0;
green            2132 magick/pixel.c       intensity=MagickMax(MagickMax(red,green),blue);
green            2137 magick/pixel.c       intensity=(MagickMin(MagickMin(red,green),blue)+
green            2138 magick/pixel.c         MagickMax(MagickMax(red,green),blue))/2.0;
green            2143 magick/pixel.c       intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
green            2152 magick/pixel.c           green=EncodePixelGamma(green);
green            2155 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
green            2163 magick/pixel.c           green=DecodePixelGamma(green);
green            2166 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
green            2175 magick/pixel.c           green=EncodePixelGamma(green);
green            2178 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
green            2186 magick/pixel.c           green=DecodePixelGamma(green);
green            2189 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
green            2194 magick/pixel.c       intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
green            2235 magick/pixel.c   pixel->green=0.0;
green            2290 magick/pixel.c     green,
green            2295 magick/pixel.c   green=pixel->green;
green            2301 magick/pixel.c       intensity=(red+green+blue)/3.0;
green            2306 magick/pixel.c       intensity=MagickMax(MagickMax(red,green),blue);
green            2311 magick/pixel.c       intensity=(MagickMin(MagickMin(red,green),blue)+
green            2312 magick/pixel.c         MagickMax(MagickMax(red,green),blue))/2.0;
green            2317 magick/pixel.c       intensity=(MagickRealType) (((double) red*red+green*green+blue*blue)/
green            2326 magick/pixel.c           green=EncodePixelGamma(green);
green            2329 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
green            2337 magick/pixel.c           green=DecodePixelGamma(green);
green            2340 magick/pixel.c       intensity=0.298839*red+0.586811*green+0.114350*blue;
green            2349 magick/pixel.c           green=EncodePixelGamma(green);
green            2352 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
green            2360 magick/pixel.c           green=DecodePixelGamma(green);
green            2363 magick/pixel.c       intensity=0.212656*red+0.715158*green+0.072186*blue;
green            2368 magick/pixel.c       intensity=(MagickRealType) (sqrt((double) red*red+green*green+blue*blue)/
green            4342 magick/pixel.c       pixel->green=(MagickRealType) GetPixelGreen(color);
green            4354 magick/pixel.c   pixel->green=(*alpha*GetPixelGreen(color));
green            4495 magick/pixel.c       pixel->green=0.0;
green            4506 magick/pixel.c         pixel->green+=gamma*pixels[0].green;
green            4513 magick/pixel.c       pixel->green*=gamma;
green            4556 magick/pixel.c       pixel->green=gamma*(epsilon.y*(epsilon.x*pixels[0].green+delta.x*
green            4557 magick/pixel.c         pixels[1].green)+delta.y*(epsilon.x*pixels[2].green+delta.x*
green            4558 magick/pixel.c         pixels[3].green));
green            4601 magick/pixel.c               pixels[i].green+=pixels[i+2].green;
green            4618 magick/pixel.c             pixels[0].green+=pixels[1].green;
green            4626 magick/pixel.c       pixel->green=alpha[0]*pixels[0].green;  /* divide by sum of alpha */
green            4660 magick/pixel.c       pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
green            4661 magick/pixel.c         pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
green            4662 magick/pixel.c         cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
green            4663 magick/pixel.c         cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
green            4664 magick/pixel.c         pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
green            4665 magick/pixel.c         cx[1]*pixels[13].green+cx[2]*pixels[14].green+cx[3]*pixels[15].green));
green            4774 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[2].green,
green            4775 magick/pixel.c                 pixels[3].green,pixels[0].green);
green            4795 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[1].green,
green            4796 magick/pixel.c                 pixels[0].green,pixels[3].green);
green            4821 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[0].green,
green            4822 magick/pixel.c                 pixels[1].green,pixels[2].green);
green            4843 magick/pixel.c               pixel->green=gamma*MeshInterpolate(&delta,pixels[3].green,
green            4844 magick/pixel.c                 pixels[2].green,pixels[1].green);
green            4897 magick/pixel.c       pixel->green=(cy[0]*(cx[0]*pixels[0].green+cx[1]*pixels[1].green+cx[2]*
green            4898 magick/pixel.c         pixels[2].green+cx[3]*pixels[3].green)+cy[1]*(cx[0]*pixels[4].green+
green            4899 magick/pixel.c         cx[1]*pixels[5].green+cx[2]*pixels[6].green+cx[3]*pixels[7].green)+
green            4900 magick/pixel.c         cy[2]*(cx[0]*pixels[8].green+cx[1]*pixels[9].green+cx[2]*
green            4901 magick/pixel.c         pixels[10].green+cx[3]*pixels[11].green)+cy[3]*(cx[0]*pixels[12].green+
green            4902 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             435 magick/quantize.c       alpha_pixel->green=(MagickRealType) GetPixelGreen(pixel);
green             442 magick/quantize.c   alpha_pixel->green=alpha*GetPixelGreen(pixel);
green             636 magick/quantize.c       image->colormap[0].green=intensity;
green             639 magick/quantize.c       image->colormap[1].green=(double) QuantumRange-intensity;
green             766 magick/quantize.c   midpoint.green=(MagickRealType) QuantumRange/2.0;
green             811 magick/quantize.c         mid.green+=(id & 2) != 0 ? bisect : -bisect;
green             835 magick/quantize.c         error.green=QuantumScale*(pixel.green-mid.green);
green             839 magick/quantize.c         distance=(double) (error.red*error.red+error.green*error.green+
green             852 magick/quantize.c       node_info->total_color.green+=count*QuantumScale*ClampPixel(pixel.green);
green             912 magick/quantize.c         mid.green+=(id & 2) != 0 ? bisect : -bisect;
green             936 magick/quantize.c         error.green=QuantumScale*(pixel.green-mid.green);
green             940 magick/quantize.c         distance=(double) (error.red*error.red+error.green*error.green+
green             953 magick/quantize.c       node_info->total_color.green+=count*QuantumScale*ClampPixel(pixel.green);
green            1228 magick/quantize.c             QuantumRange*node_info->total_color.green)));
green            1246 magick/quantize.c                 QuantumRange*node_info->total_color.green)));
green            1260 magick/quantize.c                 gamma*QuantumRange*node_info->total_color.green)));
green            1433 magick/quantize.c     GreenShift(ScaleQuantumToChar(ClampPixel(pixel->green))) |
green            1525 magick/quantize.c           pixel.green+=7*current[u-v].green/16;
green            1535 magick/quantize.c               pixel.green+=previous[u+v].green/16;
green            1541 magick/quantize.c           pixel.green+=5*previous[u].green/16;
green            1548 magick/quantize.c               pixel.green+=3*previous[u-v].green/16;
green            1555 magick/quantize.c       pixel.green=(MagickRealType) ClampPixel(pixel.green);
green            1607 magick/quantize.c       current[u].green=pixel.green-color.green;
green            1766 magick/quantize.c         pixel.green+=p->weights[i]*p->error[i].green;
green            1772 magick/quantize.c       pixel.green=(MagickRealType) ClampPixel(pixel.green);
green            1826 magick/quantize.c       p->error[ErrorQueueLength-1].green=pixel.green-color.green;
green            2167 magick/quantize.c         image->colormap[index].green));
green            2323 magick/quantize.c         image->colormap[i].green=PosterizePixel(image->colormap[i].green);
green            2452 magick/quantize.c   parent->total_color.green+=node_info->total_color.green;
green            2625 magick/quantize.c       image->colormap[i].green=GetPixelGreen(q);
green            3371 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             626 magick/resample.c         pixel->green += weight*pixels->green;
green             666 magick/resample.c     pixel->opacity = pixel->red = pixel->green = pixel->blue = 0;
green             684 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             548 magick/shear.c       background.green+=QuantumScale*GetPixelGreen(p);
green             558 magick/shear.c   image->background_color.green=ClampToQuantum((MagickRealType) QuantumRange*
green             559 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             407 magick/vision.c       object[id].color.green+=p->green;
green             450 magick/vision.c     object[i].color.green=object[i].color.green/object[i].area;
green             568 magick/vision.c         component_image->colormap[i].green=ClampToQuantum(
green             569 magick/vision.c           object[i].color.green);
green            2089 magick/widget.c           windows->widget.pixel_info->matte_color.green,
green             578 magick/xwindow-private.h   if ((pixel->red  == pixel->green) && (pixel->green == pixel->blue))
green             580 magick/xwindow-private.h   intensity=0.21265*pixel->red+0.715158*pixel->green+0.072186*pixel->blue;
green             113 magick/xwindow.c   ((ScaleQuantumToShort(XGreenGamma((color)->green))*map->green_max/65535L)* \
green             125 magick/xwindow.c   (((color)->green*map->green_max/65535L)*map->green_mult)+ \
green             175 magick/xwindow.c     green,
green             574 magick/xwindow.c           SetPixelGreen(q,ScaleShortToQuantum(pixel->box_color.green));
green             586 magick/xwindow.c           SetPixelGreen(q,ScaleShortToQuantum(pixel->pen_color.green));
green            1056 magick/xwindow.c     pixel.green=colors[i].green-(MagickRealType) color->green;
green            1057 magick/xwindow.c     distance+=pixel.green*pixel.green;
green            2172 magick/xwindow.c       color.green=ClampToQuantum((MagickRealType) (green_map[i][j][(int)
green            2177 magick/xwindow.c         (((size_t) color.green & 0xe0) >> 3) |
green            2448 magick/xwindow.c           SetPixelGreen(q,ScaleShortToQuantum(pixel->pen_color.green));
green            3074 magick/xwindow.c   pixel->highlight_color.green=(unsigned short) (((MagickRealType)
green            3075 magick/xwindow.c     pixel->matte_color.green*ScaleQuantumToShort(HighlightModulate))/65535L+
green            3088 magick/xwindow.c   pixel->shadow_color.green=(unsigned short) (((MagickRealType)
green            3089 magick/xwindow.c     pixel->matte_color.green*ScaleQuantumToShort(ShadowModulate))/65535L);
green            3099 magick/xwindow.c   pixel->depth_color.green=(unsigned short) (((MagickRealType)
green            3100 magick/xwindow.c     pixel->matte_color.green*ScaleQuantumToShort(DepthModulate))/65535L);
green            3110 magick/xwindow.c   pixel->trough_color.green=(unsigned short) (((MagickRealType)
green            3111 magick/xwindow.c     pixel->matte_color.green*ScaleQuantumToShort(TroughModulate))/65535L);
green            3858 magick/xwindow.c   pixel.green=ScaleShortToQuantum(color.green);
green            4211 magick/xwindow.c                       green,
green            4220 magick/xwindow.c                     green=0;
green            4230 magick/xwindow.c                       colors[i].pixel=(unsigned long) (red | green | blue);
green            4235 magick/xwindow.c                       green+=green_bit;
green            4236 magick/xwindow.c                       if (green > window_info[id].visual->green_mask)
green            4237 magick/xwindow.c                         green=0;
green            4337 magick/xwindow.c                     colors[index].green));
green            4393 magick/xwindow.c               composite_image->colormap[colors[i].pixel].green=
green            4394 magick/xwindow.c                 ScaleShortToQuantum(colors[i].green);
green            7563 magick/xwindow.c   intensity=0.298839*pixel->red+0.586811*pixel->green+0.114350*pixel->blue;
green            7775 magick/xwindow.c         color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
green            7781 magick/xwindow.c             color.green=gray_value;
green            7862 magick/xwindow.c             diversity[i].green=image->colormap[i].green;
green            7908 magick/xwindow.c             color.green=
green            7909 magick/xwindow.c               ScaleQuantumToShort(XGreenGamma(image->colormap[index].green));
green            7916 magick/xwindow.c                 color.green=gray_value;
green            7945 magick/xwindow.c             color.green=
green            7946 magick/xwindow.c               ScaleQuantumToShort(XGreenGamma(image->colormap[index].green));
green            7953 magick/xwindow.c                 color.green=gray_value;
green            8036 magick/xwindow.c         color.green=ScaleQuantumToShort(XGreenGamma(image->colormap[i].green));
green            8042 magick/xwindow.c             color.green=gray_value;
green            8090 magick/xwindow.c           color.green=color.blue;
green            8102 magick/xwindow.c           color.green=(unsigned int) 0;
green            8104 magick/xwindow.c             color.green=(unsigned short) ((size_t)
green            8139 magick/xwindow.c           pixel->background_color.green=
green            8140 magick/xwindow.c             (~pixel->foreground_color.green);
green            8559 magick/xwindow.c   color->green=0;
green            8578 magick/xwindow.c       color->green=xcolor.green;
green            9034 magick/xwindow.c   pixel.pen_color.green=ScaleQuantumToShort(draw_info->fill.green);
green              98 tests/validate.c static inline void ConvertRGBToXYZ(const double red,const double green,
green             107 tests/validate.c   g=QuantumScale*DecodePixelGamma(green);
green             139 tests/validate.c static void ConvertRGBToLab(const double red,const double green,
green             147 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             180 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
green             191 tests/validate.c   *green=ClampToQuantum(EncodePixelGamma(QuantumRange*g));
green             196 tests/validate.c   const double b,Quantum *red,Quantum *green,Quantum *blue)
green             204 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green             207 tests/validate.c static void ConvertRGBToYPbPr(const double red,const double green,
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             215 tests/validate.c static void ConvertRGBToYCbCr(const double red,const double green,
green             218 tests/validate.c   ConvertRGBToYPbPr(red,green,blue,Y,Cb,Cr);
green             222 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
green             226 tests/validate.c   *green=ClampToQuantum(QuantumRange*(0.99999975910502514331*Y-
green             233 tests/validate.c   const double Cr,Quantum *red,Quantum *green,Quantum *blue)
green             235 tests/validate.c   ConvertYPbPrToRGB(Y,Cb,Cr,red,green,blue);
green             247 tests/validate.c   const double S,Quantum *red,Quantum *green,Quantum *blue)
green             255 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green             266 tests/validate.c static void ConvertRGBToLMS(const double red,const double green,
green             274 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             296 tests/validate.c static void ConvertRGBToLuv(const double red,const double green,
green             304 tests/validate.c   ConvertRGBToXYZ(red,green,blue,&X,&Y,&Z);
green             323 tests/validate.c   const double v,Quantum *red,Quantum *green,Quantum *blue)
green             331 tests/validate.c   ConvertXYZToRGB(X,Y,Z,red,green,blue);
green             334 tests/validate.c static void ConvertRGBToYDbDr(const double red,const double green,
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             343 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
green             347 tests/validate.c   *green=ClampToQuantum(QuantumRange*(Y-0.12913289889050927*(Db-0.5)+
green             353 tests/validate.c static void ConvertRGBToYIQ(const double red,const double green,
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             362 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
green             366 tests/validate.c   *green=ClampToQuantum(QuantumRange*(Y-0.2721220993185104464*(I-0.5)-
green             372 tests/validate.c static void ConvertRGBToYUV(const double red,const double green,
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             381 tests/validate.c   Quantum *red,Quantum *green,Quantum *blue)
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            2382 wand/drawing-wand.c   pixel->green=(MagickRealType) GetPixelGreen(color);
green             580 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            1874 wand/pixel-wand.c WandExport void PixelSetGreen(PixelWand *wand,const double green)
green            1880 wand/pixel-wand.c   wand->pixel.green=(MagickRealType) ClampToQuantum((MagickRealType)
green            1881 wand/pixel-wand.c     QuantumRange*green);
green            1908 wand/pixel-wand.c WandExport void PixelSetGreenQuantum(PixelWand *wand,const Quantum 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);