Quantize using an Octree More...

Inheritance diagram for ImageResizer.Plugins.PrettyGifs.OctreeQuantizer:

Collaboration diagram for ImageResizer.Plugins.PrettyGifs.OctreeQuantizer:

Public Member Functions
	OctreeQuantizer (int maxColors, int maxColorBits)
	Construct the octree quantizer More...

override void	Reset ()
	Clears the octree More...

void	Reset (int maxColors, int maxColorBits)
	Clears the octree and reconfigures color settings More...

Public Member Functions inherited from ImageResizer.Plugins.PrettyGifs.Quantizer
	Quantizer (bool fixedPalette)
	Construct the quantizer More...

Bitmap	Quantize (Image src)
	Quantize an image and return the resulting output bitmap More...

Public Attributes
float[,]	DitherMatrix
	a Floyd-Steinberg dither matrix new float[,] {{0,0,0}, {0,0,0.44f}, {0.19f,0.31f,0.06f}}; More...

float	DitherPercent = .3f

Protected Member Functions
override void	InitialQuantizePixel (Color32 pixel)
	Process the pixel in the first pass of the algorithm More...

override byte	QuantizePixel (Color32 pixel)
	Override this to process the pixel in the second pass of the algorithm More...

override ColorPalette	GetPalette (ColorPalette original)
	Retrieve the palette for the quantized image More...

Protected Member Functions inherited from ImageResizer.Plugins.PrettyGifs.Quantizer
virtual void	ValidatePropertyValues ()

Bitmap	QuantizeFullTrust (Bitmap firstPass, Bitmap copy, Bitmap copy2, Bitmap output)

Bitmap	QuantizeLowTrust (Bitmap firstPass, Bitmap copy, Bitmap copy2, Bitmap output)

virtual void	AnalyzeImage (BitmapData sourceData, int width, int height)
	Execute the first pass through the pixels in the image More...

virtual void	AnalyzeImageLowTrust (Bitmap b, int width, int height)

virtual void	QuantizeImage (BitmapData sourceData, BitmapData intermediate, Bitmap output, int width, int height, Rectangle bounds)
	Execute a second pass through the bitmap. If dithering is enabled, sourceData will be modified. More...

void	AdjustNeighborSource (int offsetX, int offsetY, int deltaR, int deltaG, int deltaB, int deltaA)
	Can only be called from QuantizePixel... This is how dithering is done... 5-18-09 ndj More...

byte	ToByte (int i)

Protected Attributes
bool	_dither = false

Properties
bool	Dither `[get, set]`
	Uses a Floyd-Steinberg dither More...

Properties inherited from ImageResizer.Plugins.PrettyGifs.Quantizer
bool	FixedPalette `[get]`
	(Readonly) If true, the algorithm can do everything in QuantizePixel, and InitialQuantizePixel will not be called. Implies ResizeForFirstPass=False and FourPass=false= More...

int	PixelSize `[get]`
	The number of bytes in a ARGB structure. Should be 4 More...

bool	FullTrust `[get, set]`
	If true, pointer arithmetic will be used instead of GetPixel. GetPixel is much slower. If false, OmitFinalStage will be assumed true, as only palette generation is possible in low trust. Defaults to true. More...

bool	ResizeForFirstPass `[get, set]`
	If true, the first pass (InitialQuantizePixel) will be performed on a size-limited version of the original image to control performance. Ignored if FixedPalette=True More...

long	FirstPassPixelCount `[get, set]`
	The approximate number of pixels to use when making a scaled copy of the image for the first pass. Only used when ResizeForFirstPass=True and FirstPassPixelThreshold is exceeded. More...

long	FirstPassPixelThreshold `[get, set]`
	The maximum number of pixels the original image may contain before a scaled copy is made for the first pass. Only relevant when ResizeForFirstPass=True More...

bool	FourPass `[get, set]`
	If true, image is re-paletted after quantization - forces 2 clones of the original image to be created. FixedPalette and OmitFinalStage should be false if this is used. More...

bool	OmitFinalStage `[get, set]`
	If true, a 32-bit image with an 8-bit palette will be returned instead of an 8-bit image, which GDI can save using median-cut quantization. Much faster than our final quantization pass, although it can't do transparency. Assumed true if FullTrust is false. More...

Detailed Description

Quantize using an Octree

Definition at line 27 of file OctreeQuantizer.cs.

Constructor & Destructor Documentation

ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.OctreeQuantizer	(	int	maxColors,
		int	maxColorBits
	)

inline

Construct the octree quantizer

The Octree quantizer is a two pass algorithm. The initial pass sets up the octree, the second pass quantizes a color based on the nodes in the tree

Parameters

maxColors	The maximum number of colors to return
maxColorBits	The number of significant bits

Definition at line 38 of file OctreeQuantizer.cs.

                                                                             : base ( false )
                 {
             Reset(maxColors, maxColorBits);
                 }

Member Function Documentation

override ColorPalette ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.GetPalette ( ColorPalette original )

inlineprotectedvirtual

Retrieve the palette for the quantized image

Parameters

original Any old palette, this is overrwritten

Returns: The new color palette

Implements ImageResizer.Plugins.PrettyGifs.Quantizer.

Definition at line 175 of file OctreeQuantizer.cs.

                 {
                         // First off convert the octree to _maxColors colors
                         ArrayList       palette = _octree.Palletize ( _maxColors - 1 ) ;
 
                         // Then convert the palette based on those colors
                         for ( int index = 0 ; index < palette.Count ; index++ )
                                 original.Entries[index + (TransparencyAtZero ? 1 : 0)] = (Color)palette[index] ;
 
                         // Add the transparent color (Needs to be inserted at 0, not 255)
                         if (TransparencyAtZero)
                 original.Entries[0] = Color.FromArgb(0, 0, 0, 0);
             else
                 original.Entries[_maxColors] = Color.FromArgb ( 0 , 0 , 0 , 0 ) ;
 
             _lastPalette = original; //may-18-2009, ndj: Saving a reference so we can lookup error amounts from QuantizePixel
                         return original ;
                 }

override void ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.InitialQuantizePixel ( Color32 pixel )

inlineprotectedvirtual

Process the pixel in the first pass of the algorithm

Parameters

pixel The pixel to quantize

This function need only be overridden if your quantize algorithm needs two passes, such as an Octree quantizer.

Reimplemented from ImageResizer.Plugins.PrettyGifs.Quantizer.

Definition at line 79 of file OctreeQuantizer.cs.

                 {
                         // Add the color to the octree
                         _octree.AddColor ( pixel ) ;
                 }

override byte ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.QuantizePixel ( Color32 pixel )

inlineprotectedvirtual

Override this to process the pixel in the second pass of the algorithm

Parameters

pixel The pixel to quantize

Returns: The quantized value

Implements ImageResizer.Plugins.PrettyGifs.Quantizer.

Definition at line 112 of file OctreeQuantizer.cs.

                 {
                         byte    paletteIndex;   // The color at [_maxColors] is set to transparent
             
             //TODO: Other sources claim only the first pallete color can be transparent
             //Quote: Second, I've found a solution for preserving GIF transparency when invoking Image::Save(...). The .NET (tested on v2.0) 
             //GIF encoder considers transparent the first color found in the palette, so I've changed some methods (replace them with the supplied ones):
 
                         // Get the palette index if this non-transparent
             if (pixel.Alpha > 0)
             {
                 paletteIndex = (byte)_octree.GetPaletteIndex(pixel);
                 
 
                 //For dithering we need to track 6 pixels. 
 
                 //To dither, we find the error (difference from real pixel to the palette color), and subtract it from the next pixel. When that color is paletted, 
                 //The dither occurs.
                 //The issue is that error adjustments build up, so you're never working off the original color. Hopefully this doesn't cause issues.
                 if (Dither)
                 {
                     Color n = _lastPalette.Entries[paletteIndex]; //The palette version
                     //Calculate error for the current pixel
                     int errorR = n.R - pixel.Red;
                     int errorG = n.G - pixel.Green;
                     int errorB = n.B - pixel.Blue;
                     int errorA = n.A - pixel.Alpha;
 
 
                     for (int y = 1; y < 3;y++)
                         for (int x = 0; x < 3; x++){
                             float adjust = DitherMatrix[y, x] * DitherPercent;//How much of the error should be passed on (in negative form) the this neighbor pixel
                             if (adjust != 0)
                             {
                                
                                 AdjustNeighborSource(x - 1, y - 1, (int)((float)errorR * adjust * -1), 
                                                                    (int)((float)errorG * adjust * -1), 
                                                                    (int)((float)errorB * adjust * -1), 
                                                                    (int)((float)errorA * adjust * -1));
                                    
                             }
                         }
                     
                 }
 
                 if (TransparencyAtZero) paletteIndex++;
             }
             else
             {
                 if (TransparencyAtZero)
                     paletteIndex = 0;
                 else
                     paletteIndex = (byte)_maxColors;
             }
                    
                         return paletteIndex ;
                 }

override void ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.Reset ( )

inlinevirtual

Clears the octree

Reimplemented from ImageResizer.Plugins.PrettyGifs.Quantizer.

Definition at line 45 of file OctreeQuantizer.cs.

         {
             base.Reset();
             Reset(_maxColors, _maxColorBits);
         }

void ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.Reset	(	int	maxColors,
		int	maxColorBits
	)

inline

Clears the octree and reconfigures color settings

Parameters

maxColors
maxColorBits

Definition at line 56 of file OctreeQuantizer.cs.

         {
            
             if (maxColors > 255)
                 throw new ArgumentOutOfRangeException("maxColors", maxColors, "The number of colors should be less than 256");
 
             if ((maxColorBits < 1) | (maxColorBits > 8))
                 throw new ArgumentOutOfRangeException("maxColorBits", maxColorBits, "This should be between 1 and 8");
 
             _maxColorBits = maxColorBits;
             // Construct the octree
             _octree = new Octree(maxColorBits);
             _maxColors = maxColors;
         }

Member Data Documentation

float [,] ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.DitherMatrix

Initial value:

= new float[,] {{0,0,0},
                                                            {0,0,0.44f},
                                                            {0.19f,0.31f,0.06f}}

a Floyd-Steinberg dither matrix new float[,] {{0,0,0}, {0,0,0.44f}, {0.19f,0.31f,0.06f}};

Definition at line 102 of file OctreeQuantizer.cs.

Property Documentation

bool ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.Dither

getset

Uses a Floyd-Steinberg dither

Definition at line 92 of file OctreeQuantizer.cs.

The documentation for this class was generated from the following file:

C:/Users/nathanael/Documents/resizer/Plugins/PrettyGifs/OctreeQuantizer.cs

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation