Abstract Quantizer class - handles the messy, algorithm-independent details of quantization. Subclasses must implement InitialQuantizePixel, GetPallete(), and QuantizePixel. Not thread-safe! More...

Inheritance diagram for ImageResizer.Plugins.PrettyGifs.Quantizer:

[legend]

Classes
struct	Color32
	Struct that defines a 32 bpp colour More...

Public Member Functions
	Quantizer (bool fixedPalette)
	Construct the quantizer More...

virtual void	Reset ()
	Resets the quantizer so it can process a new image. More...

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

Protected Member Functions
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)

virtual void	InitialQuantizePixel (Color32 pixel)
	Override this to process the pixel in the first pass of the algorithm More...

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

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

Properties
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

Abstract Quantizer class - handles the messy, algorithm-independent details of quantization. Subclasses must implement InitialQuantizePixel, GetPallete(), and QuantizePixel. Not thread-safe!

Definition at line 31 of file Quantizer.cs.

Constructor & Destructor Documentation

ImageResizer.Plugins.PrettyGifs.Quantizer.Quantizer ( bool fixedPalette )

inline

Construct the quantizer

Parameters

fixedPalette If true, the quantization only needs to loop through the source pixels once - InitialQuantiize

If you construct this class with a true value for singlePass, then the code will, when quantizing your image, only call the 'QuantizeImage' function. If two passes are required, the code will call 'InitialQuantizeImage' and then 'QuantizeImage'.

Definition at line 122 of file Quantizer.cs.

         {
             _fixedPalette = fixedPalette;
             _pixelSize = Marshal.SizeOf(typeof (Color32));
         }

Member Function Documentation

void ImageResizer.Plugins.PrettyGifs.Quantizer.AdjustNeighborSource	(	int	offsetX,
		int	offsetY,
		int	deltaR,
		int	deltaG,
		int	deltaB,
		int	deltaA
	)

inlineprotected

Can only be called from QuantizePixel... This is how dithering is done... 5-18-09 ndj

Parameters

offsetX
offsetY
deltaR
deltaG
deltaB
deltaA

Definition at line 461 of file Quantizer.cs.

         {
             if (secondPassIntermediate == null) return;
             int x = secondPassX + offsetX;
             int y = secondPassY + offsetY;
             if (x < 0 || x >= secondPassIntermediate.Width) return; //do nothing;
             if (y < 0 || y >= secondPassIntermediate.Height) return; //do nothing
             IntPtr p = (IntPtr)((long)secondPassIntermediate.Scan0 + ((long)y * (long)secondPassIntermediate.Stride) + (PixelSize * x));
             //Read the original color
             Color32 c = new Color32(p);
 
             c.Red = ToByte((int)c.Red + deltaR);
             c.Green = ToByte((int)c.Green + deltaG);
             c.Blue = ToByte((int)c.Blue + deltaB);
             c.Alpha = ToByte((int)c.Alpha + deltaA);
             
             Marshal.StructureToPtr(c, p, true); //False to not dispose old block. Since no reference to it exists (I believe PtrToStructure from Color32 copies, not references), this should be safe
   
         }

virtual void ImageResizer.Plugins.PrettyGifs.Quantizer.AnalyzeImage	(	BitmapData	sourceData,
		int	width,
		int	height
	)

inlineprotectedvirtual

Execute the first pass through the pixels in the image

Parameters

sourceData	The source data
width	The width in pixels of the image
height	The height in pixels of the image

Definition at line 323 of file Quantizer.cs.

         {
             // Define the source data pointers. The source row is a byte to
             // keep addition of the stride value easier (as this is in bytes)              
             IntPtr pSourceRow = sourceData.Scan0;
 
             // Loop through each row
             for (int row = 0; row < height; row++)
             {
                 // Set the source pixel to the first pixel in this row
                 IntPtr pSourcePixel = pSourceRow;
 
                 // And loop through each column
                 for (int col = 0; col < width; col++)
                 {            
                     InitialQuantizePixel(new Color32(pSourcePixel)); 
                     pSourcePixel = (IntPtr)((long)pSourcePixel + PixelSize); //Increment afterwards
                 }       // Now I have the pixel, call the FirstPassQuantize function...
 
                 // Add the stride to the source row
                 pSourceRow = (IntPtr)((long)pSourceRow + sourceData.Stride);
             }
         }

abstract ColorPalette ImageResizer.Plugins.PrettyGifs.Quantizer.GetPalette ( ColorPalette original )

protectedpure virtual

Retrieve the palette for the quantized image

Parameters

original Any old palette, this is overrwritten

Returns: The new color palette

Implemented in ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.

virtual void ImageResizer.Plugins.PrettyGifs.Quantizer.InitialQuantizePixel ( Color32 pixel )

inlineprotectedvirtual

Override this to 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 in ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.

Definition at line 513 of file Quantizer.cs.

514 {

515 }

Bitmap ImageResizer.Plugins.PrettyGifs.Quantizer.Quantize ( Image src )

inline

Quantize an image and return the resulting output bitmap

Parameters

source The image to quantize

Returns: A quantized version of the image

Definition at line 151 of file Quantizer.cs.

                                           {
             //We just set up the Bitmap copies and handle their disposal - the real work happens in 
             // QuantizeFullTrust and QuantizeLowTrust
             Bitmap firstPass = null;
             Bitmap copy = null;
             Bitmap copy2 = null;
             Bitmap tempOutput = null;
             Bitmap result = null;
             try {
                 // First off take a 32bpp copy of 'source' if it's not a 32bpp Bitmap instance.
                 copy = src as Bitmap;
                 if (FourPass || copy == null || !src.PixelFormat.Equals(PixelFormat.Format32bppArgb)) {
                     copy = new Bitmap(src.Width, src.Height, PixelFormat.Format32bppArgb);
 
                     // Now lock the bitmap into memory
                     using (Graphics g = Graphics.FromImage(copy)) {
                         g.PageUnit = GraphicsUnit.Pixel;
 
                         // Draw the source image onto the copy bitmap,
                         // which will effect a widening as appropriate.
                         g.DrawImage(src, new Point(0, 0));
 
                     }
                 }
 
                 firstPass = copy;
                 //If we should make a resized version for the first pass, let's do it.
                 if (!FixedPalette && ResizeForFirstPass && FirstPassPixelThreshold < copy.Width * copy.Height) {
                     double factor = FirstPassPixelCount / ((double)copy.Width * (double)copy.Height);
                     firstPass = new Bitmap((int)Math.Floor((double)copy.Width * factor), (int)Math.Floor((double)copy.Height * factor), PixelFormat.Format32bppArgb);
                     using (Graphics g = Graphics.FromImage(firstPass)) {
                         //Use the low-quality settings - we want the original colors of the image, nearest neighbor is better than bicubic spline here.
                         g.PageUnit = GraphicsUnit.Pixel;
                         g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
                         g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighSpeed;
                         g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.None;
                         g.DrawImage(copy, 0, 0, firstPass.Width, firstPass.Height);
                     }
                 }
                 copy2 = null;
                 if (FourPass) {
                     copy2 = new Bitmap(src.Width, src.Height, PixelFormat.Format32bppArgb);
                     using (Graphics g = Graphics.FromImage(copy2)) {
                         g.PageUnit = GraphicsUnit.Pixel;
                         g.DrawImage(src, new Point(0, 0));
                     }
                 }
                 // And make an 8-bit output image
                 tempOutput = new Bitmap(OmitFinalStage ? 2 : src.Width, OmitFinalStage ? 2 : src.Height, PixelFormat.Format8bppIndexed);
 
                 //Full trust and low trust are implemented differently. 
                 if (FullTrust) {
                     result = QuantizeFullTrust(firstPass, copy, copy2, tempOutput);
                 } else {
                     result = QuantizeLowTrust(firstPass, copy, copy2, tempOutput);
                 }
                 return result;
             } finally {
                 if (firstPass != null && firstPass != copy && firstPass != src && firstPass != result) firstPass.Dispose();
                 if (copy != null && copy != src && copy != result) copy.Dispose();
                 if (copy2 != null && copy2 != src && copy2 != result) copy2.Dispose();
                 if (tempOutput != null && tempOutput != src && tempOutput != result) tempOutput.Dispose();
             }
 
         }

virtual void ImageResizer.Plugins.PrettyGifs.Quantizer.QuantizeImage	(	BitmapData	sourceData,
		BitmapData	intermediate,
		Bitmap	output,
		int	width,
		int	height,
		Rectangle	bounds
	)

inlineprotectedvirtual

Execute a second pass through the bitmap. If dithering is enabled, sourceData will be modified.

Parameters

sourceData	The source bitmap, locked into memory
intermediate	The intermediate bitmap, used for 4-pass quantization. If specified, output will not actually be modified
output	The output bitmap
width	The width in pixels of the image
height	The height in pixels of the image
bounds	The bounding rectangle

Definition at line 371 of file Quantizer.cs.

         {
             secondPassIntermediate = (intermediate != null) ? intermediate : sourceData;// Not thread safe.... But nothing here is anyways...//For dithering - 5-18-09 ndj
             BitmapData outputData = null;
             
             try
             {
                 // Lock the output bitmap into memory
                 if (intermediate == null) outputData = output.LockBits(bounds, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);
 
                 // Define the source data pointers. The source row is a byte to
                 // keep addition of the stride value easier (as this is in bytes)
                 IntPtr pSourceRow = sourceData.Scan0;
                 IntPtr pSourcePixel = pSourceRow;
                 IntPtr pPreviousPixel = pSourcePixel;
 
                 // Now define the destination data pointers
                 IntPtr pDestinationRow = IntPtr.Zero;
                 if (intermediate == null) pDestinationRow = outputData.Scan0;
                 IntPtr pDestinationPixel = pDestinationRow;
 
                 // And convert the first pixel, so that I have values going into the loop
 
                 byte pixelValue = QuantizePixel(new Color32(pSourcePixel));
 
                 // Assign the value of the first pixel
                 if (intermediate == null) Marshal.WriteByte(pDestinationPixel, pixelValue);
 
                 // Loop through each row
                 for (int row = 0; row < height; row++)
                 {
                     secondPassY = row;  //For dithering - 5-18-09 ndj
                     // Set the source pixel to the first pixel in this row
                     pSourcePixel = pSourceRow;
 
                     // And set the destination pixel pointer to the first pixel in the row
                     if (intermediate == null) pDestinationPixel = pDestinationRow;
 
                     // Loop through each pixel on this scan line
                     for (int col = 0; col < width; col++)
                     {
                         secondPassX = col; //For dithering - 5-18-09 ndj
                         // Check if this is the same as the last pixel. If so use that value
                         // rather than calculating it again. This is an inexpensive optimisation.
                         // Nathanael: 2-11-09 changed from ReadByte to ReadInt32 on both.
                         // Otherwise this comparison may return true if only the blue component is the 
                         // same in 2 subsequent pixels.
                         if (Marshal.ReadInt32(pPreviousPixel) != Marshal.ReadInt32(pSourcePixel) || (intermediate != null))
                         {
                             // Quantize the pixel
                             pixelValue = QuantizePixel(new Color32(pSourcePixel));
 
                             // And setup the previous pointer
                             pPreviousPixel = pSourcePixel;
                         }
 
                         // And set the pixel in the output
                         if (intermediate == null) Marshal.WriteByte(pDestinationPixel, pixelValue);
 
                         pSourcePixel = (IntPtr)((long)pSourcePixel + PixelSize);
                         if (intermediate == null) pDestinationPixel = (IntPtr)((long)pDestinationPixel + 1);
 
                     }
 
                     // Add the stride to the source row
                     pSourceRow = (IntPtr)((long)pSourceRow + sourceData.Stride);
 
                     // And to the destination row
                     if (intermediate == null) pDestinationRow = (IntPtr)((long)pDestinationRow + outputData.Stride);
                 }
             }
             finally
             {
                 // Ensure that I unlock the output bits
                 if (intermediate == null) output.UnlockBits(outputData);
                 secondPassIntermediate = null;
             }
         }

abstract byte ImageResizer.Plugins.PrettyGifs.Quantizer.QuantizePixel ( Color32 pixel )

protectedpure virtual

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

Parameters

pixel The pixel to quantize

Returns: The quantized value

Implemented in ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.

virtual void ImageResizer.Plugins.PrettyGifs.Quantizer.Reset ( )

inlinevirtual

Resets the quantizer so it can process a new image.

Reimplemented in ImageResizer.Plugins.PrettyGifs.OctreeQuantizer.

Definition at line 131 of file Quantizer.cs.

         {
             this.secondPassIntermediate = null;
             this.secondPassX = 0;
             this.secondPassY = 0;
           
         }

Property Documentation

long ImageResizer.Plugins.PrettyGifs.Quantizer.FirstPassPixelCount

getset

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.

Definition at line 75 of file Quantizer.cs.

Referenced by ImageResizer.Plugins.PrettyGifs.PrettyGifs.SaveIndexed().

long ImageResizer.Plugins.PrettyGifs.Quantizer.FirstPassPixelThreshold

getset

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

Definition at line 85 of file Quantizer.cs.

Referenced by ImageResizer.Plugins.PrettyGifs.PrettyGifs.SaveIndexed().

bool ImageResizer.Plugins.PrettyGifs.Quantizer.FixedPalette

get

(Readonly) If true, the algorithm can do everything in QuantizePixel, and InitialQuantizePixel will not be called. Implies ResizeForFirstPass=False and FourPass=false=

Definition at line 38 of file Quantizer.cs.

bool ImageResizer.Plugins.PrettyGifs.Quantizer.FourPass

getset

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.

Definition at line 96 of file Quantizer.cs.

bool ImageResizer.Plugins.PrettyGifs.Quantizer.FullTrust

getset

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.

Definition at line 56 of file Quantizer.cs.

bool ImageResizer.Plugins.PrettyGifs.Quantizer.OmitFinalStage

getset

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.

Definition at line 107 of file Quantizer.cs.

int ImageResizer.Plugins.PrettyGifs.Quantizer.PixelSize

get

The number of bytes in a ARGB structure. Should be 4

Definition at line 47 of file Quantizer.cs.

bool ImageResizer.Plugins.PrettyGifs.Quantizer.ResizeForFirstPass

getset

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

Definition at line 66 of file Quantizer.cs.

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

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

Classes

Public Member Functions

Protected Member Functions

Properties

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Property Documentation