/// <summary>
/// Computes the weighted variance of a box.
/// </summary>
/// <param name="c">The cube.</param>
/// <returns>The result.</returns>
private float Variance(ref Data.Box c)
{
float dr = WuQuant.Volume(ref c, this.vmr);
float dg = WuQuant.Volume(ref c, this.vmg);
float db = WuQuant.Volume(ref c, this.vmb);
float da = WuQuant.Volume(ref c, this.vma);
float xx =
this.m2[WuQuant.GetIndex(c.R1, c.G1, c.B1, c.A1)]
- this.m2[WuQuant.GetIndex(c.R1, c.G1, c.B1, c.A0)]
- this.m2[WuQuant.GetIndex(c.R1, c.G1, c.B0, c.A1)]
+ this.m2[WuQuant.GetIndex(c.R1, c.G1, c.B0, c.A0)]
- this.m2[WuQuant.GetIndex(c.R1, c.G0, c.B1, c.A1)]
+ this.m2[WuQuant.GetIndex(c.R1, c.G0, c.B1, c.A0)]
+ this.m2[WuQuant.GetIndex(c.R1, c.G0, c.B0, c.A1)]
- this.m2[WuQuant.GetIndex(c.R1, c.G0, c.B0, c.A0)]
- this.m2[WuQuant.GetIndex(c.R0, c.G1, c.B1, c.A1)]
+ this.m2[WuQuant.GetIndex(c.R0, c.G1, c.B1, c.A0)]
+ this.m2[WuQuant.GetIndex(c.R0, c.G1, c.B0, c.A1)]
- this.m2[WuQuant.GetIndex(c.R0, c.G1, c.B0, c.A0)]
+ this.m2[WuQuant.GetIndex(c.R0, c.G0, c.B1, c.A1)]
- this.m2[WuQuant.GetIndex(c.R0, c.G0, c.B1, c.A0)]
- this.m2[WuQuant.GetIndex(c.R0, c.G0, c.B0, c.A1)]
+ this.m2[WuQuant.GetIndex(c.R0, c.G0, c.B0, c.A0)];
return(xx - (((dr * dr) + (dg * dg) + (db * db) + (da * da)) / WuQuant.Volume(ref c, this.vwt)));
}
/// <summary>
/// Generates the quantized result.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="colorCount">The color count.</param>
/// <param name="width">Width of image</param>
/// <param name="height">Height of image</param>
/// <param name="destPixels">Pixel values are written here. Must provide width*height memory.</param>
/// <param name="padMultiple4">True to write zero padding to make row bytes multiple of 4</param>
/// <returns>Receives colors</returns>
private unsafe uint[] GenerateResult(uint *image, int colorCount, int width, int height, byte *destPixels, bool padMultiple4)
{
uint[] palette = new uint[colorCount];
// rows must be a multiple of 4, hence padding up to 3 bytes for 8-bit indexed pixels
int widthMod4 = width % 4;
int widthZeros = widthMod4 != 0 ? 4 - widthMod4 : 0;
for (int k = 0; k < colorCount; k++)
{
this.Mark(ref this.cube[k], (byte)k);
float weight = WuQuant.Volume(ref this.cube[k], this.vwt);
if (weight != 0)
{
uint a = (byte)(WuQuant.Volume(ref this.cube[k], this.vma) / weight);
uint r = (byte)(WuQuant.Volume(ref this.cube[k], this.vmr) / weight);
uint g = (byte)(WuQuant.Volume(ref this.cube[k], this.vmg) / weight);
uint b = (byte)(WuQuant.Volume(ref this.cube[k], this.vmb) / weight);
palette[k] = (a << 24) | (r << 16) | (g << 8) | b;
}
else
{
palette[k] = 0xFF000000;
}
}
for (int ri = 0; ri < height; ri++)
{
for (int ci = 0; ci < width; ci++)
{
uint pix = image[0];
uint a = ((pix & 0xFF000000) >> 24) >> (8 - WuQuant.INDEXALPHABITS);
uint r = ((pix & 0x00FF0000) >> 16) >> (8 - WuQuant.INDEXBITS);
uint g = ((pix & 0x0000FF00) >> 8) >> (8 - WuQuant.INDEXBITS);
uint b = (pix & 0x000000FF) >> (8 - WuQuant.INDEXBITS);
int ind = WuQuant.GetIndex((int)r + 1, (int)g + 1, (int)b + 1, (int)a + 1);
destPixels[0] = this.tag[ind];
destPixels++;
image++;
}
// write additional zero bytes if requested
if (padMultiple4)
{
for (int c = 0; c < widthZeros; c++)
{
destPixels[0] = 0x00;
destPixels++;
}
}
}
return(palette);
}
private static int Top(ref Data.Box cube, int direction, int position, int[] moment)
{
switch (direction)
{
// Red
case 3:
return(moment[WuQuant.GetIndex(position, cube.G1, cube.B1, cube.A1)]
- moment[WuQuant.GetIndex(position, cube.G1, cube.B1, cube.A0)]
- moment[WuQuant.GetIndex(position, cube.G1, cube.B0, cube.A1)]
+ moment[WuQuant.GetIndex(position, cube.G1, cube.B0, cube.A0)]
- moment[WuQuant.GetIndex(position, cube.G0, cube.B1, cube.A1)]
+ moment[WuQuant.GetIndex(position, cube.G0, cube.B1, cube.A0)]
+ moment[WuQuant.GetIndex(position, cube.G0, cube.B0, cube.A1)]
- moment[WuQuant.GetIndex(position, cube.G0, cube.B0, cube.A0)]);
// Green
case 2:
return(moment[WuQuant.GetIndex(cube.R1, position, cube.B1, cube.A1)]
- moment[WuQuant.GetIndex(cube.R1, position, cube.B1, cube.A0)]
- moment[WuQuant.GetIndex(cube.R1, position, cube.B0, cube.A1)]
+ moment[WuQuant.GetIndex(cube.R1, position, cube.B0, cube.A0)]
- moment[WuQuant.GetIndex(cube.R0, position, cube.B1, cube.A1)]
+ moment[WuQuant.GetIndex(cube.R0, position, cube.B1, cube.A0)]
+ moment[WuQuant.GetIndex(cube.R0, position, cube.B0, cube.A1)]
- moment[WuQuant.GetIndex(cube.R0, position, cube.B0, cube.A0)]);
// Blue
case 1:
return(moment[WuQuant.GetIndex(cube.R1, cube.G1, position, cube.A1)]
- moment[WuQuant.GetIndex(cube.R1, cube.G1, position, cube.A0)]
- moment[WuQuant.GetIndex(cube.R1, cube.G0, position, cube.A1)]
+ moment[WuQuant.GetIndex(cube.R1, cube.G0, position, cube.A0)]
- moment[WuQuant.GetIndex(cube.R0, cube.G1, position, cube.A1)]
+ moment[WuQuant.GetIndex(cube.R0, cube.G1, position, cube.A0)]
+ moment[WuQuant.GetIndex(cube.R0, cube.G0, position, cube.A1)]
- moment[WuQuant.GetIndex(cube.R0, cube.G0, position, cube.A0)]);
// Alpha
case 0:
return(moment[WuQuant.GetIndex(cube.R1, cube.G1, cube.B1, position)]
- moment[WuQuant.GetIndex(cube.R1, cube.G1, cube.B0, position)]
- moment[WuQuant.GetIndex(cube.R1, cube.G0, cube.B1, position)]
+ moment[WuQuant.GetIndex(cube.R1, cube.G0, cube.B0, position)]
- moment[WuQuant.GetIndex(cube.R0, cube.G1, cube.B1, position)]
+ moment[WuQuant.GetIndex(cube.R0, cube.G1, cube.B0, position)]
+ moment[WuQuant.GetIndex(cube.R0, cube.G0, cube.B1, position)]
- moment[WuQuant.GetIndex(cube.R0, cube.G0, cube.B0, position)]);
default:
throw new ArgumentOutOfRangeException("direction");
}
}
