mirror of https://github.com/SixLabors/ImageSharp
Browse Source
Replace quantizer and added wait to semaphore slim. TODO: Replace method call in ImageFactory methods. Former-commit-id: 581dce3f0e11cc6769c4c243034c96683564be94af/merge-core
James South
12 years ago
9 changed files with 940 additions and 881 deletions
@ -1,836 +0,0 @@ |
|||
// --------------------------------------------------------------------------------------------------------------------
|
|||
// <copyright file="ColorQuantizer.cs" company="James South">
|
|||
// Copyright (c) James South.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
// </copyright>
|
|||
// <summary>
|
|||
// The color quantizer.
|
|||
// </summary>
|
|||
// --------------------------------------------------------------------------------------------------------------------
|
|||
|
|||
namespace ImageProcessor.Imaging |
|||
{ |
|||
#region Using
|
|||
using System; |
|||
using System.Diagnostics.CodeAnalysis; |
|||
using System.Drawing; |
|||
using System.Drawing.Imaging; |
|||
using System.Runtime.InteropServices; |
|||
#endregion
|
|||
|
|||
/// <summary>
|
|||
/// The color quantizer.
|
|||
/// </summary>
|
|||
[SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1650:ElementDocumentationMustBeSpelledCorrectly", Justification = "Reviewed. Suppression is OK here.")] |
|||
public static class ColorQuantizer |
|||
{ |
|||
#region Quantize methods
|
|||
/// <summary>The quantize.</summary>
|
|||
/// <param name="image">The image.</param>
|
|||
/// <param name="bitmapPixelFormat">The bitmap pixel format.</param>
|
|||
/// <returns>The quantized image with the recalculated color palette.</returns>
|
|||
public static Bitmap Quantize(Image image, PixelFormat bitmapPixelFormat) |
|||
{ |
|||
// Use dither by default
|
|||
return Quantize(image, bitmapPixelFormat, true); |
|||
} |
|||
|
|||
/// <summary>The quantize.</summary>
|
|||
/// <param name="image">The image.</param>
|
|||
/// <param name="pixelFormat">The pixel format.</param>
|
|||
/// <param name="useDither">The use dither.</param>
|
|||
/// <returns>The quantized image with the recalculated color palette.</returns>
|
|||
public static Bitmap Quantize(Image image, PixelFormat pixelFormat, bool useDither) |
|||
{ |
|||
Bitmap tryBitmap = image as Bitmap; |
|||
|
|||
if (tryBitmap != null && tryBitmap.PixelFormat == PixelFormat.Format32bppArgb) |
|||
{ |
|||
// The image passed to us is ALREADY a bitmap in the right format. No need to create
|
|||
// a copy and work from there.
|
|||
return DoQuantize(tryBitmap, pixelFormat, useDither); |
|||
} |
|||
|
|||
// We use these values a lot
|
|||
int width = image.Width; |
|||
int height = image.Height; |
|||
Rectangle sourceRect = Rectangle.FromLTRB(0, 0, width, height); |
|||
|
|||
// Create a 24-bit rgb version of the source image
|
|||
using (Bitmap bitmapSource = new Bitmap(width, height, PixelFormat.Format32bppArgb)) |
|||
{ |
|||
using (Graphics grfx = Graphics.FromImage(bitmapSource)) |
|||
{ |
|||
grfx.DrawImage(image, sourceRect, 0, 0, width, height, GraphicsUnit.Pixel); |
|||
} |
|||
|
|||
return DoQuantize(bitmapSource, pixelFormat, useDither); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Does the quantize.
|
|||
/// </summary>
|
|||
/// <param name="bitmapSource">The bitmap source.</param>
|
|||
/// <param name="pixelFormat">The pixel format.</param>
|
|||
/// <param name="useDither">if set to <c>true</c> [use dither].</param>
|
|||
/// <returns>The quantized image with the recalculated color palette.</returns>
|
|||
private static Bitmap DoQuantize(Bitmap bitmapSource, PixelFormat pixelFormat, bool useDither) |
|||
{ |
|||
// We use these values a lot
|
|||
int width = bitmapSource.Width; |
|||
int height = bitmapSource.Height; |
|||
Rectangle sourceRect = Rectangle.FromLTRB(0, 0, width, height); |
|||
|
|||
Bitmap bitmapOptimized = null; |
|||
|
|||
try |
|||
{ |
|||
// Create a bitmap with the same dimensions and the desired format
|
|||
bitmapOptimized = new Bitmap(width, height, pixelFormat); |
|||
|
|||
// Lock the bits of the source image for reading.
|
|||
// we will need to write if we do the dither.
|
|||
BitmapData bitmapDataSource = bitmapSource.LockBits( |
|||
sourceRect, |
|||
ImageLockMode.ReadWrite, |
|||
PixelFormat.Format32bppArgb); |
|||
|
|||
try |
|||
{ |
|||
// Perform the first pass, which generates the octree data
|
|||
// Create an Octree
|
|||
Octree octree = new Octree(pixelFormat); |
|||
|
|||
// Stride might be negative, indicating inverted row order.
|
|||
// Allocate a managed buffer for the pixel data, and copy it from the unmanaged pointer.
|
|||
int strideSource = Math.Abs(bitmapDataSource.Stride); |
|||
byte[] sourceDataBuffer = new byte[strideSource * height]; |
|||
Marshal.Copy(bitmapDataSource.Scan0, sourceDataBuffer, 0, sourceDataBuffer.Length); |
|||
|
|||
// We could skip every other row and/or every other column when sampling the colors
|
|||
// of the source image, rather than hitting every other pixel. It doesn't seem to
|
|||
// degrade the resulting image too much. But it doesn't really help the performance
|
|||
// too much because the majority of the time seems to be spent in other places.
|
|||
|
|||
// For every row
|
|||
int rowStartSource = 0; |
|||
for (int ndxRow = 0; ndxRow < height; ndxRow += 1) |
|||
{ |
|||
// For each column
|
|||
for (int ndxCol = 0; ndxCol < width; ndxCol += 1) |
|||
{ |
|||
// Add the color (4 bytes per pixel - ARGB)
|
|||
Pixel pixel = GetSourcePixel(sourceDataBuffer, rowStartSource, ndxCol); |
|||
octree.AddColor(pixel); |
|||
} |
|||
|
|||
rowStartSource += strideSource; |
|||
} |
|||
|
|||
// Get the optimized colors
|
|||
Color[] colors = octree.GetPaletteColors(); |
|||
|
|||
// Set the palette from the octree
|
|||
ColorPalette palette = bitmapOptimized.Palette; |
|||
for (var ndx = 0; ndx < palette.Entries.Length; ++ndx) |
|||
{ |
|||
// Use the colors we calculated
|
|||
// for the rest, just set to transparent
|
|||
palette.Entries[ndx] = (ndx < colors.Length) |
|||
? colors[ndx] |
|||
: Color.Transparent; |
|||
} |
|||
|
|||
bitmapOptimized.Palette = palette; |
|||
|
|||
// Lock the bits of the optimized bitmap for writing.
|
|||
// we will also need to read if we are doing 1bpp or 4bpp
|
|||
BitmapData bitmapDataOutput = bitmapOptimized.LockBits(sourceRect, ImageLockMode.ReadWrite, pixelFormat); |
|||
try |
|||
{ |
|||
// Create a managed array for the destination bytes given the desired color depth
|
|||
// and marshal the unmanaged data to the managed array
|
|||
int strideOutput = Math.Abs(bitmapDataOutput.Stride); |
|||
byte[] bitmapOutputBuffer = new byte[strideOutput * height]; |
|||
|
|||
// For each source pixel, compute the appropriate color index
|
|||
rowStartSource = 0; |
|||
int rowStartOutput = 0; |
|||
|
|||
for (int ndxRow = 0; ndxRow < height; ++ndxRow) |
|||
{ |
|||
// For each column
|
|||
for (int ndxCol = 0; ndxCol < width; ++ndxCol) |
|||
{ |
|||
// Get the source color
|
|||
Pixel pixel = GetSourcePixel(sourceDataBuffer, rowStartSource, ndxCol); |
|||
|
|||
// Get the closest palette index
|
|||
int paletteIndex = octree.GetPaletteIndex(pixel); |
|||
|
|||
// If we want to dither and this isn't the transparent pixel
|
|||
if (useDither && pixel.Alpha != 0) |
|||
{ |
|||
// Calculate the error
|
|||
Color paletteColor = colors[paletteIndex]; |
|||
int deltaRed = pixel.Red - paletteColor.R; |
|||
int deltaGreen = pixel.Green - paletteColor.G; |
|||
int deltaBlue = pixel.Blue - paletteColor.B; |
|||
|
|||
// Propagate the dither error.
|
|||
// we'll use a standard Floyd-Steinberg matrix (1/16):
|
|||
// | 0 0 0 |
|
|||
// | 0 x 7 |
|
|||
// | 3 5 1 |
|
|||
|
|||
// Make sure we're not on the right-hand edge
|
|||
if (ndxCol + 1 < width) |
|||
{ |
|||
DitherSourcePixel(sourceDataBuffer, rowStartSource, ndxCol + 1, deltaRed, deltaGreen, deltaBlue, 7); |
|||
} |
|||
|
|||
// Make sure we're not already on the bottom row
|
|||
if (ndxRow + 1 < height) |
|||
{ |
|||
int nextRow = rowStartSource + strideSource; |
|||
|
|||
// Make sure we're not on the left-hand column
|
|||
if (ndxCol > 0) |
|||
{ |
|||
// Down one row, but back one pixel
|
|||
DitherSourcePixel(sourceDataBuffer, nextRow, ndxCol - 1, deltaRed, deltaGreen, deltaBlue, 3); |
|||
} |
|||
|
|||
// pixel directly below us
|
|||
DitherSourcePixel(sourceDataBuffer, nextRow, ndxCol, deltaRed, deltaGreen, deltaBlue, 5); |
|||
|
|||
// Make sure we're not on the right-hand column
|
|||
if (ndxCol + 1 < width) |
|||
{ |
|||
// Down one row, but right one pixel
|
|||
DitherSourcePixel(sourceDataBuffer, nextRow, ndxCol + 1, deltaRed, deltaGreen, deltaBlue, 1); |
|||
} |
|||
} |
|||
} |
|||
|
|||
// Set the bitmap index based on the format
|
|||
switch (pixelFormat) |
|||
{ |
|||
case PixelFormat.Format8bppIndexed: |
|||
// Each byte is a palette index
|
|||
bitmapOutputBuffer[rowStartOutput + ndxCol] = (byte)paletteIndex; |
|||
break; |
|||
|
|||
case PixelFormat.Format4bppIndexed: |
|||
// Each byte contains two pixels
|
|||
bitmapOutputBuffer[rowStartOutput + (ndxCol >> 1)] |= ((ndxCol & 1) == 1) |
|||
? (byte)(paletteIndex & 0x0f) // lower nibble
|
|||
: (byte)(paletteIndex << 4); // upper nibble
|
|||
break; |
|||
|
|||
case PixelFormat.Format1bppIndexed: |
|||
// Each byte contains eight pixels
|
|||
if (paletteIndex != 0) |
|||
{ |
|||
bitmapOutputBuffer[rowStartOutput + (ndxCol >> 3)] |= (byte)(0x80 >> (ndxCol & 0x07)); |
|||
} |
|||
|
|||
break; |
|||
} |
|||
} |
|||
|
|||
rowStartSource += strideSource; |
|||
rowStartOutput += strideOutput; |
|||
} |
|||
|
|||
// Now copy the calculated pixel bytes from the managed array to the unmanaged bitmap
|
|||
Marshal.Copy(bitmapOutputBuffer, 0, bitmapDataOutput.Scan0, bitmapOutputBuffer.Length); |
|||
} |
|||
finally |
|||
{ |
|||
bitmapOptimized.UnlockBits(bitmapDataOutput); |
|||
bitmapDataOutput = null; |
|||
} |
|||
} |
|||
finally |
|||
{ |
|||
bitmapSource.UnlockBits(bitmapDataSource); |
|||
bitmapDataSource = null; |
|||
} |
|||
} |
|||
catch (Exception) |
|||
{ |
|||
// If any exception is thrown, dispose of the bitmap object
|
|||
// we've been working on before we rethrow and bail
|
|||
if (bitmapOptimized != null) |
|||
{ |
|||
bitmapOptimized.Dispose(); |
|||
} |
|||
|
|||
throw; |
|||
} |
|||
|
|||
// Caller is responsible for disposing of this bitmap!
|
|||
return bitmapOptimized; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Dithers the source pixel.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer.</param>
|
|||
/// <param name="rowStart">The row start.</param>
|
|||
/// <param name="col">The column.</param>
|
|||
/// <param name="deltaRed">The delta red.</param>
|
|||
/// <param name="deltaGreen">The delta green.</param>
|
|||
/// <param name="deltaBlue">The delta blue.</param>
|
|||
/// <param name="weight">The weight.</param>
|
|||
private static void DitherSourcePixel(byte[] buffer, int rowStart, int col, int deltaRed, int deltaGreen, int deltaBlue, int weight) |
|||
{ |
|||
int colorIndex = rowStart + (col * 4); |
|||
buffer[colorIndex + 2] = ChannelAdjustment(buffer[colorIndex + 2], (deltaRed * weight) >> 4); |
|||
buffer[colorIndex + 1] = ChannelAdjustment(buffer[colorIndex + 1], (deltaGreen * weight) >> 4); |
|||
buffer[colorIndex] = ChannelAdjustment(buffer[colorIndex], (deltaBlue * weight) >> 4); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the source pixel.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer.</param>
|
|||
/// <param name="rowStart">The row start.</param>
|
|||
/// <param name="col">The column.</param>
|
|||
/// <returns>The source pixel.</returns>
|
|||
private static Pixel GetSourcePixel(byte[] buffer, int rowStart, int col) |
|||
{ |
|||
int colorIndex = rowStart + (col * 4); |
|||
return new Pixel |
|||
{ |
|||
Alpha = buffer[colorIndex + 3], |
|||
Red = buffer[colorIndex + 2], |
|||
Green = buffer[colorIndex + 1], |
|||
Blue = buffer[colorIndex] |
|||
}; |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
/// <summary>Gets the channel adjustment.</summary>
|
|||
/// <param name="current">The current.</param>
|
|||
/// <param name="offset">The offset.</param>
|
|||
/// <returns>The channel adjustment.</returns>
|
|||
private static byte ChannelAdjustment(byte current, int offset) |
|||
{ |
|||
return (byte)Math.Min(255, Math.Max(0, current + offset)); |
|||
} |
|||
|
|||
#region Octree class
|
|||
|
|||
/// <summary>data structure for storing and reducing colors used in the source image</summary>
|
|||
private class Octree |
|||
{ |
|||
/// <summary>The m_max colors.</summary>
|
|||
private readonly int octreeMaxColors; |
|||
|
|||
/// <summary>The m_reducible nodes.</summary>
|
|||
private readonly OctreeNode[] octreeReducibleNodes; |
|||
|
|||
/// <summary>The m_color count.</summary>
|
|||
private int octreeColorCount; |
|||
|
|||
/// <summary>The m_has transparent.</summary>
|
|||
private bool octreeHasTransparent; |
|||
|
|||
/// <summary>The m_last argb.</summary>
|
|||
private int octreeLastArgb; |
|||
|
|||
/// <summary>The m_last node.</summary>
|
|||
private OctreeNode octreeLastNode; |
|||
|
|||
/// <summary>The m_palette.</summary>
|
|||
private Color[] octreePalette; |
|||
|
|||
/// <summary>The m_root.</summary>
|
|||
private OctreeNode octreeRoot; |
|||
|
|||
/// <summary>Initializes a new instance of the <see cref="Octree"/> class. Constructor</summary>
|
|||
/// <param name="pixelFormat">desired pixel format</param>
|
|||
internal Octree(PixelFormat pixelFormat) |
|||
{ |
|||
// figure out the maximum colors from the pixel format passed in
|
|||
switch (pixelFormat) |
|||
{ |
|||
case PixelFormat.Format1bppIndexed: |
|||
this.octreeMaxColors = 2; |
|||
break; |
|||
|
|||
case PixelFormat.Format4bppIndexed: |
|||
this.octreeMaxColors = 16; |
|||
break; |
|||
|
|||
case PixelFormat.Format8bppIndexed: |
|||
this.octreeMaxColors = 256; |
|||
break; |
|||
|
|||
default: |
|||
throw new ArgumentException("Invalid Pixel Format", "pixelFormat"); |
|||
} |
|||
|
|||
// we need a list for each level that may have reducible nodes.
|
|||
// since the last level (level 7) is only made up of leaf nodes,
|
|||
// we don't need an array entry for it.
|
|||
this.octreeReducibleNodes = new OctreeNode[7]; |
|||
|
|||
// add the initial level-0 root node
|
|||
this.octreeRoot = new OctreeNode(0, this); |
|||
} |
|||
|
|||
/// <summary>Add the given pixel color to the octree</summary>
|
|||
/// <param name="pixel">points to the pixel color we want to add</param>
|
|||
internal void AddColor(Pixel pixel) |
|||
{ |
|||
// If the A value is non-zero (ignore the transparent color)
|
|||
if (pixel.Alpha > 0) |
|||
{ |
|||
// If we have a previous node and this color is the same as the last...
|
|||
if (this.octreeLastNode != null && pixel.Argb == this.octreeLastArgb) |
|||
{ |
|||
// Just add this color to the same last node
|
|||
this.octreeLastNode.AddColor(pixel); |
|||
} |
|||
else |
|||
{ |
|||
// Just start at the root. If a new color is added,
|
|||
// add one to the count (otherwise 0).
|
|||
this.octreeColorCount += this.octreeRoot.AddColor(pixel) ? 1 : 0; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// Flag that we have a transparent color.
|
|||
this.octreeHasTransparent = true; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Given a pixel color, return the index of the palette entry
|
|||
/// we want to use in the reduced image. If the color is not in the
|
|||
/// octree, OctreeNode.GetPaletteIndex will return a negative number.
|
|||
/// In that case, we will have to calculate the palette index the brute-force
|
|||
/// method by computing the least distance to each color in the palette array.
|
|||
/// </summary>
|
|||
/// <param name="pixel">pointer to the pixel color we want to look up</param>
|
|||
/// <returns>index of the palette entry we want to use for this color</returns>
|
|||
internal int GetPaletteIndex(Pixel pixel) |
|||
{ |
|||
int paletteIndex = 0; |
|||
|
|||
// transparent is always the first entry, so if this is transparent,
|
|||
// don't do anything.
|
|||
if (pixel.Alpha > 0) |
|||
{ |
|||
paletteIndex = this.octreeRoot.GetPaletteIndex(pixel); |
|||
|
|||
// returns -1 if this value isn't in the octree.
|
|||
if (paletteIndex < 0) |
|||
{ |
|||
// Use the brute-force method of calculating the closest color
|
|||
// in the palette to the one we want
|
|||
int minDistance = int.MaxValue; |
|||
for (int ndx = 0; ndx < this.octreePalette.Length; ++ndx) |
|||
{ |
|||
Color paletteColor = this.octreePalette[ndx]; |
|||
|
|||
// Calculate the delta for each channel
|
|||
int deltaRed = pixel.Red - paletteColor.R; |
|||
int deltaGreen = pixel.Green - paletteColor.G; |
|||
int deltaBlue = pixel.Blue - paletteColor.B; |
|||
|
|||
// Calculate the distance-squared by summing each channel's square
|
|||
int distance = (deltaRed * deltaRed) + (deltaGreen * deltaGreen) + (deltaBlue * deltaBlue); |
|||
if (distance < minDistance) |
|||
{ |
|||
minDistance = distance; |
|||
paletteIndex = ndx; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
return paletteIndex; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Return a color palette for the computed octree.
|
|||
/// </summary>
|
|||
/// <returns>A color palette for the computed octree</returns>
|
|||
internal Color[] GetPaletteColors() |
|||
{ |
|||
// If we haven't already computed it, compute it now
|
|||
if (this.octreePalette == null) |
|||
{ |
|||
// Start at the second-to-last reducible level
|
|||
int reductionLevel = this.octreeReducibleNodes.Length - 1; |
|||
|
|||
// We want to subtract one from the target if we have a transparent
|
|||
// bit because we want to save room for that special color
|
|||
int targetCount = this.octreeMaxColors - (this.octreeHasTransparent ? 1 : 0); |
|||
|
|||
// While we still have more colors than the target...
|
|||
while (this.octreeColorCount > targetCount) |
|||
{ |
|||
// Find the first reducible node, starting with the last level
|
|||
// that can have reducible nodes
|
|||
while (reductionLevel > 0 && this.octreeReducibleNodes[reductionLevel] == null) |
|||
{ |
|||
--reductionLevel; |
|||
} |
|||
|
|||
if (this.octreeReducibleNodes[reductionLevel] == null) |
|||
{ |
|||
// Shouldn't get here
|
|||
break; |
|||
} |
|||
|
|||
// We should have a node now
|
|||
OctreeNode newLeaf = this.octreeReducibleNodes[reductionLevel]; |
|||
this.octreeReducibleNodes[reductionLevel] = newLeaf.NextReducibleNode; |
|||
this.octreeColorCount -= newLeaf.Reduce() - 1; |
|||
} |
|||
|
|||
if (reductionLevel == 0 && !this.octreeHasTransparent) |
|||
{ |
|||
// If this was the top-most level, we now only have a single color
|
|||
// representing the average. That's not what we want.
|
|||
// use just black and white
|
|||
this.octreePalette = new Color[2]; |
|||
this.octreePalette[0] = Color.Black; |
|||
this.octreePalette[1] = Color.White; |
|||
|
|||
// And empty the octree so it always picks the closer of the black and white entries
|
|||
this.octreeRoot = new OctreeNode(0, this); |
|||
} |
|||
else |
|||
{ |
|||
// Now walk the tree, adding all the remaining colors to the list
|
|||
int paletteIndex = 0; |
|||
this.octreePalette = new Color[this.octreeColorCount + (this.octreeHasTransparent ? 1 : 0)]; |
|||
|
|||
// Add the transparent color if we need it
|
|||
if (this.octreeHasTransparent) |
|||
{ |
|||
this.octreePalette[paletteIndex++] = Color.Transparent; |
|||
} |
|||
|
|||
// Have the nodes insert their leaf colors
|
|||
this.octreeRoot.AddColorsToPalette(this.octreePalette, ref paletteIndex); |
|||
} |
|||
} |
|||
|
|||
return this.octreePalette; |
|||
} |
|||
|
|||
/// <summary>set up the values we need to reuse the given pointer if the next color is argb</summary>
|
|||
/// <param name="node">last node to which we added a color</param>
|
|||
/// <param name="argb">last color we added</param>
|
|||
private void SetLastNode(OctreeNode node, int argb) |
|||
{ |
|||
this.octreeLastNode = node; |
|||
this.octreeLastArgb = argb; |
|||
} |
|||
|
|||
/// <summary>When a reducible node is added, this method is called to add it to the appropriate
|
|||
/// reducible node list (given its level)</summary>
|
|||
/// <param name="reducibleNode">node to add to a reducible list</param>
|
|||
private void AddReducibleNode(OctreeNode reducibleNode) |
|||
{ |
|||
// hook this node into the front of the list.
|
|||
// this means the last one added will be the first in the list.
|
|||
reducibleNode.NextReducibleNode = this.octreeReducibleNodes[reducibleNode.Level]; |
|||
this.octreeReducibleNodes[reducibleNode.Level] = reducibleNode; |
|||
} |
|||
|
|||
#region OctreeNode class
|
|||
|
|||
/// <summary>Node for an Octree structure</summary>
|
|||
private class OctreeNode |
|||
{ |
|||
/// <summary>The s_level masks.</summary>
|
|||
private static readonly byte[] NodeLevelMasks = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; |
|||
|
|||
/// <summary>The m_level.</summary>
|
|||
private readonly int nodeLevel; |
|||
|
|||
/// <summary>The m_octree.</summary>
|
|||
private readonly Octree nodeOctree; |
|||
|
|||
/// <summary>The m_blue sum.</summary>
|
|||
private int nodeBlueSum; |
|||
|
|||
/// <summary>The m_child nodes.</summary>
|
|||
private OctreeNode[] nodeChildNodes; |
|||
|
|||
/// <summary>The m_green sum.</summary>
|
|||
private int nodeGreenSum; |
|||
|
|||
/// <summary>The m_is leaf.</summary>
|
|||
private bool nodeIsLeaf; |
|||
|
|||
/// <summary>The m_palette index.</summary>
|
|||
private int nodePaletteIndex; |
|||
|
|||
/// <summary>
|
|||
/// The pixel count.Information we need to calculate the average color for a set of pixels
|
|||
/// </summary>
|
|||
private int nodePixelCount; |
|||
|
|||
/// <summary>The m_red sum.</summary>
|
|||
private int nodeRedSum; |
|||
|
|||
/// <summary>Initializes a new instance of the <see cref="OctreeNode"/> class. Constructor</summary>
|
|||
/// <param name="level">level for this node</param>
|
|||
/// <param name="octree">owning octree</param>
|
|||
internal OctreeNode(int level, Octree octree) |
|||
{ |
|||
this.nodeOctree = octree; |
|||
this.nodeLevel = level; |
|||
|
|||
// Since there are only eight levels, if we get to level 7
|
|||
// We automatically make this a leaf node
|
|||
this.nodeIsLeaf = level == 7; |
|||
|
|||
if (!this.nodeIsLeaf) |
|||
{ |
|||
// Create the child array
|
|||
this.nodeChildNodes = new OctreeNode[8]; |
|||
|
|||
// Add it to the tree's reducible node list
|
|||
this.nodeOctree.AddReducibleNode(this); |
|||
} |
|||
} |
|||
|
|||
/// <summary>Gets Level.</summary>
|
|||
internal int Level |
|||
{ |
|||
get { return this.nodeLevel; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets NextReducibleNode.
|
|||
/// Once we compute a palette, this will be set
|
|||
/// to the palette index associated with this leaf node.
|
|||
/// Nodes are arranged in linked lists of reducible nodes for a given level.
|
|||
/// this field and property is used to traverse that list.
|
|||
/// </summary>
|
|||
internal OctreeNode NextReducibleNode { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the average color for this node.
|
|||
/// </summary>
|
|||
private Color NodeColor |
|||
{ |
|||
get |
|||
{ |
|||
// Average color is the sum of each channel divided by the pixel count
|
|||
return Color.FromArgb( |
|||
this.nodeRedSum / this.nodePixelCount, |
|||
this.nodeGreenSum / this.nodePixelCount, |
|||
this.nodeBlueSum / this.nodePixelCount); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add the given color to this node if it is a leaf, otherwise recurse
|
|||
/// down the appropriate child
|
|||
/// </summary>
|
|||
/// <param name="pixel">color to add</param>
|
|||
/// <returns>true if a new color was added to the octree</returns>
|
|||
internal bool AddColor(Pixel pixel) |
|||
{ |
|||
bool colorAdded; |
|||
if (this.nodeIsLeaf) |
|||
{ |
|||
// Increase the pixel count for this node, and if
|
|||
// the result is 1, then this is a new color
|
|||
colorAdded = ++this.nodePixelCount == 1; |
|||
|
|||
// Add the color to the running sum for this node
|
|||
this.nodeRedSum += pixel.Red; |
|||
this.nodeGreenSum += pixel.Green; |
|||
this.nodeBlueSum += pixel.Blue; |
|||
|
|||
// Set the last node so we can quickly process adjacent pixels
|
|||
// with the same color
|
|||
this.nodeOctree.SetLastNode(this, pixel.Argb); |
|||
} |
|||
else |
|||
{ |
|||
// Get the index at this level for the rgb values
|
|||
int childIndex = this.GetChildIndex(pixel); |
|||
|
|||
// If there is no child, add one now to the next level
|
|||
if (this.nodeChildNodes[childIndex] == null) |
|||
{ |
|||
this.nodeChildNodes[childIndex] = new OctreeNode(this.nodeLevel + 1, this.nodeOctree); |
|||
} |
|||
|
|||
// Recurse...
|
|||
colorAdded = this.nodeChildNodes[childIndex].AddColor(pixel); |
|||
} |
|||
|
|||
return colorAdded; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Given a source color, return the palette index to use for the reduced image.
|
|||
/// Returns -1 if the color is not represented in the octree (this happens if
|
|||
/// the color has been dithered into a new color that did not appear in the
|
|||
/// original image when the octree was formed in pass 1.
|
|||
/// </summary>
|
|||
/// <param name="pixel">source color to look up</param>
|
|||
/// <returns>palette index to use</returns>
|
|||
internal int GetPaletteIndex(Pixel pixel) |
|||
{ |
|||
int paletteIndex = -1; |
|||
if (this.nodeIsLeaf) |
|||
{ |
|||
// Use this leaf node's palette index
|
|||
paletteIndex = this.nodePaletteIndex; |
|||
} |
|||
else |
|||
{ |
|||
// Get the index at this level for the rgb values
|
|||
var childIndex = this.GetChildIndex(pixel); |
|||
if (this.nodeChildNodes[childIndex] != null) |
|||
{ |
|||
// Recurse...
|
|||
paletteIndex = this.nodeChildNodes[childIndex].GetPaletteIndex(pixel); |
|||
} |
|||
} |
|||
|
|||
return paletteIndex; |
|||
} |
|||
|
|||
/// <summary>Reduce this node by combining all child nodes</summary>
|
|||
/// <returns>number of nodes removed</returns>
|
|||
internal int Reduce() |
|||
{ |
|||
int numReduced = 0; |
|||
if (!this.nodeIsLeaf) |
|||
{ |
|||
// For each child
|
|||
foreach (OctreeNode node in this.nodeChildNodes) |
|||
{ |
|||
if (node != null) |
|||
{ |
|||
OctreeNode childNode = node; |
|||
|
|||
// add the pixel count from the child
|
|||
this.nodePixelCount += childNode.nodePixelCount; |
|||
|
|||
// add the running color sums from the child
|
|||
this.nodeRedSum += childNode.nodeRedSum; |
|||
this.nodeGreenSum += childNode.nodeGreenSum; |
|||
this.nodeBlueSum += childNode.nodeBlueSum; |
|||
|
|||
++numReduced; |
|||
} |
|||
} |
|||
|
|||
this.nodeChildNodes = null; |
|||
this.nodeIsLeaf = true; |
|||
} |
|||
|
|||
return numReduced; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// If this is a leaf node, add its color to the palette array at the given index
|
|||
/// and increment the index. If not a leaf, recurse the children nodes.
|
|||
/// </summary>
|
|||
/// <param name="colorArray">array of colors</param>
|
|||
/// <param name="paletteIndex">index of the next empty slot in the array</param>
|
|||
internal void AddColorsToPalette(Color[] colorArray, ref int paletteIndex) |
|||
{ |
|||
if (this.nodeIsLeaf) |
|||
{ |
|||
// Save our index and increment the running index
|
|||
this.nodePaletteIndex = paletteIndex++; |
|||
|
|||
// The color for this node is the average color, which is created by
|
|||
// dividing the running sums for each channel by the pixel count
|
|||
colorArray[this.nodePaletteIndex] = this.NodeColor; |
|||
} |
|||
else |
|||
{ |
|||
// Just run through all the non-null children and recurse
|
|||
foreach (OctreeNode node in this.nodeChildNodes) |
|||
{ |
|||
if (node != null) |
|||
{ |
|||
node.AddColorsToPalette(colorArray, ref paletteIndex); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Return the child index for a given color.
|
|||
/// Depends on which level this node is in.
|
|||
/// </summary>
|
|||
/// <param name="pixel">color pixel to compute</param>
|
|||
/// <returns>child index (0-7)</returns>
|
|||
private int GetChildIndex(Pixel pixel) |
|||
{ |
|||
// lvl: 0 1 2 3 4 5 6 7
|
|||
// bit: 7 6 5 4 3 2 1 0
|
|||
var shift = 7 - this.nodeLevel; |
|||
int mask = NodeLevelMasks[this.nodeLevel]; |
|||
return ((pixel.Red & mask) >> (shift - 2)) | |
|||
((pixel.Green & mask) >> (shift - 1)) | |
|||
((pixel.Blue & mask) >> shift); |
|||
} |
|||
} |
|||
#endregion
|
|||
} |
|||
#endregion
|
|||
|
|||
#region Pixel class for ARGB values
|
|||
/// <summary>
|
|||
/// Structure of a Format32bppArgb pixel in memory.
|
|||
/// </summary>
|
|||
private class Pixel |
|||
{ |
|||
/// <summary>
|
|||
/// Gets or sets the blue component of the pixel.
|
|||
/// </summary>
|
|||
public byte Blue { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the green component of the pixel.
|
|||
/// </summary>
|
|||
public byte Green { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the red component of the pixel.
|
|||
/// </summary>
|
|||
public byte Red { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the alpha component of the pixel.
|
|||
/// </summary>
|
|||
public byte Alpha { get; set; } |
|||
|
|||
/// <summary>
|
|||
/// Gets the argb combination of the pixel.
|
|||
/// </summary>
|
|||
public int Argb |
|||
{ |
|||
get |
|||
{ |
|||
return this.Alpha << 24 | this.Red << 16 | this.Green << 8 | this.Blue; |
|||
} |
|||
} |
|||
} |
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,558 @@ |
|||
// --------------------------------------------------------------------------------------------------------------------
|
|||
// <copyright file="OctreeQuantizer.cs" company="James South">
|
|||
// Copyright (c) James South.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
// </copyright>
|
|||
// <summary>
|
|||
// Encapsulates methods to calculate the colour palette if an image using an octree pattern.
|
|||
// </summary>
|
|||
// --------------------------------------------------------------------------------------------------------------------
|
|||
|
|||
namespace ImageProcessor.Imaging |
|||
{ |
|||
using System; |
|||
using System.Collections; |
|||
using System.Drawing; |
|||
using System.Drawing.Imaging; |
|||
|
|||
/// <summary>
|
|||
/// Encapsulates methods to calculate the colour palette if an image using an octree pattern.
|
|||
/// </summary>
|
|||
public class OctreeQuantizer : Quantizer |
|||
{ |
|||
/// <summary>
|
|||
/// Stores the tree.
|
|||
/// </summary>
|
|||
private readonly Octree octree; |
|||
|
|||
/// <summary>
|
|||
/// The maximum allowed color depth.
|
|||
/// </summary>
|
|||
private readonly int maxColors; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="OctreeQuantizer"/> class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// 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
|
|||
/// </remarks>
|
|||
/// <param name="maxColors">
|
|||
/// The maximum number of colors to return
|
|||
/// </param>
|
|||
/// <param name="maxColorBits">
|
|||
/// The number of significant bits
|
|||
/// </param>
|
|||
public OctreeQuantizer(int maxColors, int maxColorBits) |
|||
: base(false) |
|||
{ |
|||
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"); |
|||
} |
|||
|
|||
// Construct the octree
|
|||
this.octree = new Octree(maxColorBits); |
|||
this.maxColors = maxColors; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Override this to process the pixel in the first pass of the algorithm
|
|||
/// </summary>
|
|||
/// <param name="pixel">The pixel to quantize</param>
|
|||
/// <remarks>
|
|||
/// This function need only be overridden if your quantize algorithm needs two passes,
|
|||
/// such as an Octree quantizer.
|
|||
/// </remarks>
|
|||
protected override void InitialQuantizePixel(Color32 pixel) |
|||
{ |
|||
// Add the color to the octree
|
|||
this.octree.AddColor(pixel); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Override this to process the pixel in the second pass of the algorithm
|
|||
/// </summary>
|
|||
/// <param name="pixel">The pixel to quantize</param>
|
|||
/// <returns>
|
|||
/// The quantized value
|
|||
/// </returns>
|
|||
protected override byte QuantizePixel(Color32 pixel) |
|||
{ |
|||
// The color at [_maxColors] is set to transparent
|
|||
byte paletteIndex = (byte)this.maxColors; |
|||
|
|||
// Get the palette index if this non-transparent
|
|||
if (pixel.Alpha > 0) |
|||
{ |
|||
paletteIndex = (byte)this.octree.GetPaletteIndex(pixel); |
|||
} |
|||
|
|||
return paletteIndex; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Retrieve the palette for the quantized image
|
|||
/// </summary>
|
|||
/// <param name="original">Any old palette, this is overwritten</param>
|
|||
/// <returns>
|
|||
/// The new color palette
|
|||
/// </returns>
|
|||
protected override ColorPalette GetPalette(ColorPalette original) |
|||
{ |
|||
// First off convert the octree to _maxColors colors
|
|||
ArrayList palette = this.octree.Palletize(this.maxColors - 1); |
|||
|
|||
// Then convert the palette based on those colors
|
|||
for (int index = 0; index < palette.Count; index++) |
|||
{ |
|||
Color testColor = (Color)palette[index]; |
|||
|
|||
// Test set transparent color when color transparency used
|
|||
if (testColor.ToArgb() == Color.Transparent.ToArgb()) |
|||
{ |
|||
testColor = Color.FromArgb(0, 0, 0, 0); |
|||
} |
|||
|
|||
original.Entries[index] = testColor; |
|||
} |
|||
|
|||
// Clear unused palette entries
|
|||
for (int index = palette.Count; index < this.maxColors; index++) |
|||
{ |
|||
original.Entries[index] = Color.FromArgb(255, 0, 0, 0); |
|||
} |
|||
|
|||
// Add the transparent color when alpha transparency used
|
|||
original.Entries[this.maxColors] = Color.FromArgb(0, Color.Transparent); |
|||
return original; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Describes a tree data structure in which each internal node has exactly eight children.
|
|||
/// </summary>
|
|||
private class Octree |
|||
{ |
|||
/// <summary>
|
|||
/// Mask used when getting the appropriate pixels for a given node
|
|||
/// </summary>
|
|||
private static readonly int[] Mask = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }; |
|||
|
|||
/// <summary>
|
|||
/// The root of the octree
|
|||
/// </summary>
|
|||
private readonly OctreeNode root; |
|||
|
|||
/// <summary>
|
|||
/// Array of reducible nodes
|
|||
/// </summary>
|
|||
private readonly OctreeNode[] reducibleNodes; |
|||
|
|||
/// <summary>
|
|||
/// Maximum number of significant bits in the image
|
|||
/// </summary>
|
|||
private readonly int maxColorBits; |
|||
|
|||
/// <summary>
|
|||
/// Number of leaves in the tree
|
|||
/// </summary>
|
|||
private int leafCount; |
|||
|
|||
/// <summary>
|
|||
/// Store the last node quantized
|
|||
/// </summary>
|
|||
private OctreeNode previousNode; |
|||
|
|||
/// <summary>
|
|||
/// Cache the previous color quantized
|
|||
/// </summary>
|
|||
private int previousColor; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="Octree"/> class.
|
|||
/// </summary>
|
|||
/// <param name="maxColorBits">
|
|||
/// The maximum number of significant bits in the image
|
|||
/// </param>
|
|||
public Octree(int maxColorBits) |
|||
{ |
|||
this.maxColorBits = maxColorBits; |
|||
this.leafCount = 0; |
|||
this.reducibleNodes = new OctreeNode[9]; |
|||
this.root = new OctreeNode(0, this.maxColorBits, this); |
|||
this.previousColor = 0; |
|||
this.previousNode = null; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the number of leaves in the tree
|
|||
/// </summary>
|
|||
private int Leaves |
|||
{ |
|||
get { return this.leafCount; } |
|||
set { this.leafCount = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add a given colour value to the octree
|
|||
/// </summary>
|
|||
/// <param name="pixel">
|
|||
/// The color value to add.
|
|||
/// </param>
|
|||
public void AddColor(Color32 pixel) |
|||
{ |
|||
// Check if this request is for the same color as the last
|
|||
if (this.previousColor == pixel.Argb) |
|||
{ |
|||
// If so, check if I have a previous node setup. This will only ocurr if the first color in the image
|
|||
// happens to be black, with an alpha component of zero.
|
|||
if (null == this.previousNode) |
|||
{ |
|||
this.previousColor = pixel.Argb; |
|||
this.root.AddColor(pixel, this.maxColorBits, 0, this); |
|||
} |
|||
else |
|||
{ |
|||
// Just update the previous node
|
|||
this.previousNode.Increment(pixel); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
this.previousColor = pixel.Argb; |
|||
this.root.AddColor(pixel, this.maxColorBits, 0, this); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Convert the nodes in the octree to a palette with a maximum of colorCount colors
|
|||
/// </summary>
|
|||
/// <param name="colorCount">The maximum number of colors</param>
|
|||
/// <returns>An array-list with the palletized colors</returns>
|
|||
public ArrayList Palletize(int colorCount) |
|||
{ |
|||
while (this.Leaves > colorCount) |
|||
{ |
|||
this.Reduce(); |
|||
} |
|||
|
|||
// Now palletized the nodes
|
|||
ArrayList palette = new ArrayList(this.Leaves); |
|||
int paletteIndex = 0; |
|||
this.root.ConstructPalette(palette, ref paletteIndex); |
|||
|
|||
// And return the palette
|
|||
return palette; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Get the palette index for the passed colour.
|
|||
/// </summary>
|
|||
/// <param name="pixel">
|
|||
/// The color to return the palette index for.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The palette index for the passed colour.
|
|||
/// </returns>
|
|||
public int GetPaletteIndex(Color32 pixel) |
|||
{ |
|||
return this.root.GetPaletteIndex(pixel, 0); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Return the array of reducible nodes
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// The array of <see cref="OctreeNode"/>.
|
|||
/// </returns>
|
|||
protected OctreeNode[] ReducibleNodes() |
|||
{ |
|||
return this.reducibleNodes; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Keep track of the previous node that was quantized
|
|||
/// </summary>
|
|||
/// <param name="node">The node last quantized</param>
|
|||
protected void TrackPrevious(OctreeNode node) |
|||
{ |
|||
this.previousNode = node; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reduce the depth of the tree
|
|||
/// </summary>
|
|||
private void Reduce() |
|||
{ |
|||
// Find the deepest level containing at least one reducible node
|
|||
// for (index = _maxColorBits - 1; (index > 0) && (null == _reducibleNodes[index]); index--) ;
|
|||
// Find the deepest level containing at least one reducible node
|
|||
int index = this.maxColorBits - 1; |
|||
while ((index > 0) && (null == this.reducibleNodes[index])) |
|||
{ |
|||
index--; |
|||
} |
|||
|
|||
// Reduce the node most recently added to the list at level 'index'
|
|||
OctreeNode node = this.reducibleNodes[index]; |
|||
this.reducibleNodes[index] = node.NextReducible; |
|||
|
|||
// Decrement the leaf count after reducing the node
|
|||
this.leafCount -= node.Reduce(); |
|||
|
|||
// And just in case I've reduced the last color to be added, and the next color to
|
|||
// be added is the same, invalidate the previousNode...
|
|||
this.previousNode = null; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Class which encapsulates each node in the tree
|
|||
/// </summary>
|
|||
protected class OctreeNode |
|||
{ |
|||
/// <summary>
|
|||
/// Pointers to any child nodes
|
|||
/// </summary>
|
|||
private readonly OctreeNode[] children; |
|||
|
|||
/// <summary>
|
|||
/// Pointer to next reducible node
|
|||
/// </summary>
|
|||
private readonly OctreeNode nextReducible; |
|||
|
|||
/// <summary>
|
|||
/// Flag indicating that this is a leaf node
|
|||
/// </summary>
|
|||
private bool leaf; |
|||
|
|||
/// <summary>
|
|||
/// Number of pixels in this node
|
|||
/// </summary>
|
|||
private int pixelCount; |
|||
|
|||
/// <summary>
|
|||
/// Red component
|
|||
/// </summary>
|
|||
private int red; |
|||
|
|||
/// <summary>
|
|||
/// Green Component
|
|||
/// </summary>
|
|||
private int green; |
|||
|
|||
/// <summary>
|
|||
/// Blue component
|
|||
/// </summary>
|
|||
private int blue; |
|||
|
|||
/// <summary>
|
|||
/// The index of this node in the palette
|
|||
/// </summary>
|
|||
private int paletteIndex; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="OctreeNode"/> class.
|
|||
/// </summary>
|
|||
/// <param name="level">
|
|||
/// The level in the tree = 0 - 7
|
|||
/// </param>
|
|||
/// <param name="colorBits">
|
|||
/// The number of significant color bits in the image
|
|||
/// </param>
|
|||
/// <param name="octree">
|
|||
/// The tree to which this node belongs
|
|||
/// </param>
|
|||
public OctreeNode(int level, int colorBits, Octree octree) |
|||
{ |
|||
// Construct the new node
|
|||
this.leaf = level == colorBits; |
|||
|
|||
this.red = this.green = this.blue = 0; |
|||
this.pixelCount = 0; |
|||
|
|||
// If a leaf, increment the leaf count
|
|||
if (this.leaf) |
|||
{ |
|||
octree.Leaves++; |
|||
this.nextReducible = null; |
|||
this.children = null; |
|||
} |
|||
else |
|||
{ |
|||
// Otherwise add this to the reducible nodes
|
|||
var repNodes = octree.ReducibleNodes(); |
|||
this.nextReducible = repNodes[level]; |
|||
repNodes[level] = this; |
|||
this.children = new OctreeNode[8]; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the next reducible node.
|
|||
/// </summary>
|
|||
public OctreeNode NextReducible |
|||
{ |
|||
get { return this.nextReducible; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Add a color into the tree
|
|||
/// </summary>
|
|||
/// <param name="pixel">The color</param>
|
|||
/// <param name="colorBits">The number of significant color bits</param>
|
|||
/// <param name="level">The level in the tree</param>
|
|||
/// <param name="octree">The tree to which this node belongs</param>
|
|||
public void AddColor(Color32 pixel, int colorBits, int level, Octree octree) |
|||
{ |
|||
// Update the color information if this is a leaf
|
|||
if (this.leaf) |
|||
{ |
|||
this.Increment(pixel); |
|||
|
|||
// Setup the previous node
|
|||
octree.TrackPrevious(this); |
|||
} |
|||
else |
|||
{ |
|||
checked |
|||
{ |
|||
// Go to the next level down in the tree
|
|||
int shift = 7 - level; |
|||
int index = ((pixel.Red & Mask[level]) >> (shift - 2)) | |
|||
((pixel.Green & Mask[level]) >> (shift - 1)) | |
|||
((pixel.Blue & Mask[level]) >> shift); |
|||
|
|||
OctreeNode child = this.children[index]; |
|||
|
|||
if (null == child) |
|||
{ |
|||
// Create a new child node and store in the array
|
|||
child = new OctreeNode(level + 1, colorBits, octree); |
|||
this.children[index] = child; |
|||
} |
|||
|
|||
// Add the color to the child node
|
|||
child.AddColor(pixel, colorBits, level + 1, octree); |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Reduce this node by removing all of its children
|
|||
/// </summary>
|
|||
/// <returns>The number of leaves removed</returns>
|
|||
public int Reduce() |
|||
{ |
|||
this.red = this.green = this.blue = 0; |
|||
int childNodes = 0; |
|||
|
|||
// Loop through all children and add their information to this node
|
|||
for (int index = 0; index < 8; index++) |
|||
{ |
|||
if (null != this.children[index]) |
|||
{ |
|||
this.red += this.children[index].red; |
|||
this.green += this.children[index].green; |
|||
this.blue += this.children[index].blue; |
|||
this.pixelCount += this.children[index].pixelCount; |
|||
++childNodes; |
|||
this.children[index] = null; |
|||
} |
|||
} |
|||
|
|||
// Now change this to a leaf node
|
|||
this.leaf = true; |
|||
|
|||
// Return the number of nodes to decrement the leaf count by
|
|||
return childNodes - 1; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Traverse the tree, building up the color palette
|
|||
/// </summary>
|
|||
/// <param name="palette">The palette</param>
|
|||
/// <param name="index">The current palette index</param>
|
|||
public void ConstructPalette(ArrayList palette, ref int index) |
|||
{ |
|||
if (this.leaf) |
|||
{ |
|||
// Consume the next palette index
|
|||
this.paletteIndex = index++; |
|||
|
|||
// And set the color of the palette entry
|
|||
palette.Add(Color.FromArgb(this.red / this.pixelCount, this.green / this.pixelCount, this.blue / this.pixelCount)); |
|||
} |
|||
else |
|||
{ |
|||
// Loop through children looking for leaves
|
|||
for (int i = 0; i < 8; i++) |
|||
{ |
|||
if (null != this.children[i]) |
|||
{ |
|||
this.children[i].ConstructPalette(palette, ref index); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Return the palette index for the passed color.
|
|||
/// </summary>
|
|||
/// <param name="pixel">
|
|||
/// The pixel.
|
|||
/// </param>
|
|||
/// <param name="level">
|
|||
/// The level.
|
|||
/// </param>
|
|||
/// <returns>
|
|||
/// The palette index for the passed color.
|
|||
/// </returns>
|
|||
public int GetPaletteIndex(Color32 pixel, int level) |
|||
{ |
|||
int index = this.paletteIndex; |
|||
|
|||
if (!this.leaf) |
|||
{ |
|||
checked |
|||
{ |
|||
int shift = 7 - level; |
|||
int i = ((pixel.Red & Mask[level]) >> (shift - 2)) |
|||
| ((pixel.Green & Mask[level]) >> (shift - 1)) |
|||
| ((pixel.Blue & Mask[level]) >> shift); |
|||
|
|||
if (null != this.children[i]) |
|||
{ |
|||
index = this.children[i].GetPaletteIndex(pixel, level + 1); |
|||
} |
|||
else |
|||
{ |
|||
throw new ArgumentException("Didn't expect this!"); |
|||
} |
|||
} |
|||
} |
|||
|
|||
return index; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Increment the pixel count and add to the color information
|
|||
/// </summary>
|
|||
/// <param name="pixel">
|
|||
/// The pixel.
|
|||
/// </param>
|
|||
public void Increment(Color32 pixel) |
|||
{ |
|||
this.pixelCount++; |
|||
this.red += pixel.Red; |
|||
this.green += pixel.Green; |
|||
this.blue += pixel.Blue; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,350 @@ |
|||
// --------------------------------------------------------------------------------------------------------------------
|
|||
// <copyright file="Quantizer.cs" company="James South">
|
|||
// Copyright (c) James South.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
// </copyright>
|
|||
// <summary>
|
|||
// Defines the Quantizer type.
|
|||
// </summary>
|
|||
// --------------------------------------------------------------------------------------------------------------------
|
|||
|
|||
namespace ImageProcessor.Imaging |
|||
{ |
|||
using System; |
|||
using System.Drawing; |
|||
using System.Drawing.Imaging; |
|||
using System.Runtime.InteropServices; |
|||
|
|||
/// <summary>
|
|||
/// Encapsulates methods to calculate the color palette of an image.
|
|||
/// </summary>
|
|||
public abstract class Quantizer |
|||
{ |
|||
/// <summary>
|
|||
/// The flag used to indicate whether a single pass or two passes are needed for quantization.
|
|||
/// </summary>
|
|||
private readonly bool singlePass; |
|||
|
|||
/// <summary>
|
|||
/// The size in bytes of the 32 bytes per pixel Color structure.
|
|||
/// </summary>
|
|||
private readonly int pixelSize; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="T:ImageProcessor.Imaging.Quantizer">Quantizer</see> class.
|
|||
/// </summary>
|
|||
/// <param name="singlePass">
|
|||
/// If set to <see langword="true"/>, then the quantizer will loop through the source pixels once;
|
|||
/// otherwise, <see langword="false"/>.
|
|||
/// </param>
|
|||
protected Quantizer(bool singlePass) |
|||
{ |
|||
this.singlePass = singlePass; |
|||
this.pixelSize = Marshal.SizeOf(typeof(Color32)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Quantizes the given <see cref="T:System.Drawing.Image">Image</see> and returns the resulting output
|
|||
/// <see cref="T:System.Drawing.Bitmap">Bitmap.</see>
|
|||
/// </summary>
|
|||
/// <param name="source">The image to quantize</param>
|
|||
/// <returns>
|
|||
/// A quantized <see cref="T:System.Drawing.Bitmap">Bitmap</see> version of the <see cref="T:System.Drawing.Image">Image</see>
|
|||
/// </returns>
|
|||
public Bitmap Quantize(Image source) |
|||
{ |
|||
// Get the size of the source image
|
|||
int height = source.Height; |
|||
int width = source.Width; |
|||
|
|||
// And construct a rectangle from these dimensions
|
|||
Rectangle bounds = new Rectangle(0, 0, width, height); |
|||
|
|||
// First off take a 32bpp copy of the image
|
|||
Bitmap copy = new Bitmap(width, height, PixelFormat.Format32bppArgb); |
|||
|
|||
// And construct an 8bpp version
|
|||
Bitmap output = new Bitmap(width, height, PixelFormat.Format8bppIndexed); |
|||
|
|||
// 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(source, bounds); |
|||
} |
|||
|
|||
// Define a pointer to the bitmap data
|
|||
BitmapData sourceData = null; |
|||
|
|||
try |
|||
{ |
|||
// Get the source image bits and lock into memory
|
|||
sourceData = copy.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); |
|||
|
|||
// Call the FirstPass function if not a single pass algorithm.
|
|||
// For something like an octree quantizer, this will run through
|
|||
// all image pixels, build a data structure, and create a palette.
|
|||
if (!this.singlePass) |
|||
{ |
|||
this.FirstPass(sourceData, width, height); |
|||
} |
|||
|
|||
// Then set the color palette on the output bitmap. I'm passing in the current palette
|
|||
// as there's no way to construct a new, empty palette.
|
|||
output.Palette = this.GetPalette(output.Palette); |
|||
|
|||
// Then call the second pass which actually does the conversion
|
|||
this.SecondPass(sourceData, output, width, height, bounds); |
|||
} |
|||
finally |
|||
{ |
|||
// Ensure that the bits are unlocked
|
|||
copy.UnlockBits(sourceData); |
|||
} |
|||
|
|||
// Last but not least, return the output bitmap
|
|||
return output; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Execute the first pass through the pixels in the image
|
|||
/// </summary>
|
|||
/// <param name="sourceData">The source data</param>
|
|||
/// <param name="width">The width in pixels of the image</param>
|
|||
/// <param name="height">The height in pixels of the image</param>
|
|||
protected virtual void FirstPass(BitmapData sourceData, int width, int height) |
|||
{ |
|||
// 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 sourceRow = 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 sourcePixel = sourceRow; |
|||
|
|||
// And loop through each column
|
|||
for (int col = 0; col < width; col++) |
|||
{ |
|||
this.InitialQuantizePixel(new Color32(sourcePixel)); |
|||
sourcePixel = (IntPtr)((int)sourcePixel + this.pixelSize); |
|||
} |
|||
|
|||
// Now I have the pixel, call the FirstPassQuantize function...
|
|||
// Add the stride to the source row
|
|||
sourceRow = (IntPtr)((long)sourceRow + sourceData.Stride); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Execute a second pass through the bitmap
|
|||
/// </summary>
|
|||
/// <param name="sourceData">The source bitmap, locked into memory</param>
|
|||
/// <param name="output">The output bitmap</param>
|
|||
/// <param name="width">The width in pixels of the image</param>
|
|||
/// <param name="height">The height in pixels of the image</param>
|
|||
/// <param name="bounds">The bounding rectangle</param>
|
|||
protected virtual void SecondPass(BitmapData sourceData, Bitmap output, int width, int height, Rectangle bounds) |
|||
{ |
|||
BitmapData outputData = null; |
|||
|
|||
try |
|||
{ |
|||
// Lock the output bitmap into memory
|
|||
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 sourceRow = sourceData.Scan0; |
|||
IntPtr sourcePixel = sourceRow; |
|||
IntPtr previousPixel = sourcePixel; |
|||
|
|||
// Now define the destination data pointers
|
|||
IntPtr destinationRow = outputData.Scan0; |
|||
IntPtr destinationPixel = destinationRow; |
|||
|
|||
// And convert the first pixel, so that I have values going into the loop.
|
|||
byte pixelValue = this.QuantizePixel(new Color32(sourcePixel)); |
|||
|
|||
// Assign the value of the first pixel
|
|||
Marshal.WriteByte(destinationPixel, pixelValue); |
|||
|
|||
// Loop through each row
|
|||
for (int row = 0; row < height; row++) |
|||
{ |
|||
// Set the source pixel to the first pixel in this row
|
|||
sourcePixel = sourceRow; |
|||
|
|||
// And set the destination pixel pointer to the first pixel in the row
|
|||
destinationPixel = destinationRow; |
|||
|
|||
// Loop through each pixel on this scan line
|
|||
for (int col = 0; col < width; col++) |
|||
{ |
|||
// 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.
|
|||
if (Marshal.ReadInt32(previousPixel) != Marshal.ReadInt32(sourcePixel)) |
|||
{ |
|||
// Quantize the pixel
|
|||
pixelValue = this.QuantizePixel(new Color32(sourcePixel)); |
|||
|
|||
// And setup the previous pointer
|
|||
previousPixel = sourcePixel; |
|||
} |
|||
|
|||
// And set the pixel in the output
|
|||
Marshal.WriteByte(destinationPixel, pixelValue); |
|||
|
|||
sourcePixel = (IntPtr)((long)sourcePixel + this.pixelSize); |
|||
destinationPixel = (IntPtr)((long)destinationPixel + 1); |
|||
} |
|||
|
|||
// Add the stride to the source row
|
|||
sourceRow = (IntPtr)((long)sourceRow + sourceData.Stride); |
|||
|
|||
// And to the destination row
|
|||
destinationRow = (IntPtr)((long)destinationRow + outputData.Stride); |
|||
} |
|||
} |
|||
finally |
|||
{ |
|||
// Ensure that I unlock the output bits
|
|||
output.UnlockBits(outputData); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Override this to process the pixel in the first pass of the algorithm
|
|||
/// </summary>
|
|||
/// <param name="pixel">The pixel to quantize</param>
|
|||
/// <remarks>
|
|||
/// This function need only be overridden if your quantize algorithm needs two passes,
|
|||
/// such as an Octree quantizer.
|
|||
/// </remarks>
|
|||
protected virtual void InitialQuantizePixel(Color32 pixel) |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Override this to process the pixel in the second pass of the algorithm
|
|||
/// </summary>
|
|||
/// <param name="pixel">The pixel to quantize</param>
|
|||
/// <returns>The quantized value</returns>
|
|||
protected abstract byte QuantizePixel(Color32 pixel); |
|||
|
|||
/// <summary>
|
|||
/// Retrieve the palette for the quantized image
|
|||
/// </summary>
|
|||
/// <param name="original">Any old palette, this is overwritten</param>
|
|||
/// <returns>The new color palette</returns>
|
|||
protected abstract ColorPalette GetPalette(ColorPalette original); |
|||
|
|||
/// <summary>
|
|||
/// Structure that defines a 32 bit color
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This structure is used to read data from a 32 bits per pixel image
|
|||
/// in memory, and is ordered in this manner as this is the way that
|
|||
/// the data is laid out in memory
|
|||
/// </remarks>
|
|||
[StructLayout(LayoutKind.Explicit)] |
|||
public struct Color32 |
|||
{ |
|||
/// <summary>
|
|||
/// Holds the blue component of the colour
|
|||
/// </summary>
|
|||
[FieldOffset(0)] |
|||
private byte blue; |
|||
|
|||
/// <summary>
|
|||
/// Holds the green component of the colour
|
|||
/// </summary>
|
|||
[FieldOffset(1)] |
|||
private byte green; |
|||
|
|||
/// <summary>
|
|||
/// Holds the red component of the colour
|
|||
/// </summary>
|
|||
[FieldOffset(2)] |
|||
private byte red; |
|||
|
|||
/// <summary>
|
|||
/// Holds the alpha component of the colour
|
|||
/// </summary>
|
|||
[FieldOffset(3)] |
|||
private byte alpha; |
|||
|
|||
/// <summary>
|
|||
/// Permits the color32 to be treated as a 32 bit integer.
|
|||
/// </summary>
|
|||
[FieldOffset(0)] |
|||
private int argb; |
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the <see cref="T:ImageProcessor.Imaging.Quantizer.Color32">Color32</see> structure.
|
|||
/// </summary>
|
|||
/// <param name="sourcePixel">The pointer to the pixel.</param>
|
|||
public Color32(IntPtr sourcePixel) |
|||
{ |
|||
this = (Color32)Marshal.PtrToStructure(sourcePixel, typeof(Color32)); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the blue component of the colour
|
|||
/// </summary>
|
|||
public byte Blue |
|||
{ |
|||
get { return this.blue; } |
|||
set { this.blue = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the green component of the colour
|
|||
/// </summary>
|
|||
public byte Green |
|||
{ |
|||
get { return this.green; } |
|||
set { this.green = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the red component of the colour
|
|||
/// </summary>
|
|||
public byte Red |
|||
{ |
|||
get { return this.red; } |
|||
set { this.red = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the alpha component of the colour
|
|||
/// </summary>
|
|||
public byte Alpha |
|||
{ |
|||
get { return this.alpha; } |
|||
set { this.alpha = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets or sets the ARGB component, permitting the color32 to be treated as a 32 bit integer.
|
|||
/// </summary>
|
|||
public int Argb |
|||
{ |
|||
get { return this.argb; } |
|||
set { this.argb = value; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the color for this Color32 object
|
|||
/// </summary>
|
|||
public Color Color |
|||
{ |
|||
get { return Color.FromArgb(this.Alpha, this.Red, this.Green, this.Blue); } |
|||
} |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue