/// <summary>
/// Computes the weighted variance of a box.
/// </summary>
/// <param name="cube">The cube.</param>
/// <returns>The result.</returns>
private double Variance(Box cube)
{
double dr = WuAlphaColorQuantizer.Volume(cube, this.vmr);
double dg = WuAlphaColorQuantizer.Volume(cube, this.vmg);
double db = WuAlphaColorQuantizer.Volume(cube, this.vmb);
double da = WuAlphaColorQuantizer.Volume(cube, this.vma);
double xx =
this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G1, cube.B1, cube.A1)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G1, cube.B1, cube.A0)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G1, cube.B0, cube.A1)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G1, cube.B0, cube.A0)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G0, cube.B1, cube.A1)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G0, cube.B1, cube.A0)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G0, cube.B0, cube.A1)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R1, cube.G0, cube.B0, cube.A0)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G1, cube.B1, cube.A1)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G1, cube.B1, cube.A0)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G1, cube.B0, cube.A1)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G1, cube.B0, cube.A0)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G0, cube.B1, cube.A1)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G0, cube.B1, cube.A0)]
- this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G0, cube.B0, cube.A1)]
+ this.m2[WuAlphaColorQuantizer.GetIndex(cube.R0, cube.G0, cube.B0, cube.A0)];
return(xx - (((dr * dr) + (dg * dg) + (db * db) + (da * da)) / WuAlphaColorQuantizer.Volume(cube, this.vwt)));
}
/// <summary>
/// Generates the quantized result.
/// </summary>
/// <param name="image">The image.</param>
/// <param name="colorCount">The color count.</param>
/// <param name="cube">The cube.</param>
/// <returns>The result.</returns>
private void GenerateResult(Color[] image, int colorCount, Box[] cube)
{
List <Color> palette = new List <Color>();
for (int k = 0; k < colorCount; k++)
{
this.Mark(cube[k], (byte)k);
double weight = WuAlphaColorQuantizer.Volume(cube[k], this.vwt);
byte A;
byte R;
byte G;
byte B;
if (weight != 0)
{
A = (byte)(Volume(cube[k], this.vma) / weight);
R = (byte)(Volume(cube[k], this.vmr) / weight);
G = (byte)(Volume(cube[k], this.vmg) / weight);
B = (byte)(Volume(cube[k], this.vmb) / weight);
}
else
{
A = 0xff;
R = 0;
G = 0;
B = 0;
}
palette.Add(Color.FromArgb(A, R, G, B));
}
QuantPalette = palette.ToArray();
var length = colorCount == 256 ? image.Length : colorCount == 16 ? image.Length / 2 : throw new Exception("IndexedPixels: unknown pixelformat");
var returned = new byte[length];
for (int i = 0; i < image.Length; i++)
{
var color = image[i];
int a = color.A >> (8 - IndexAlphaBits);
int r = color.R >> (8 - IndexBits);
int g = color.G >> (8 - IndexBits);
int b = color.B >> (8 - IndexBits);
int ind = GetIndex(r + 1, g + 1, b + 1, a + 1);
var value = tag[ind];
switch (colorCount)
{
case 256:
returned[i] = value;
break;
case 16:
if (i % 2 == 0)
{
returned[i / 2] = (byte)(value << 4);
}
else
{
returned[i / 2] |= (byte)(value & 0x0F);
}
break;
case 2:
if (i % 8 == 0)
{
returned[i / 8] = (byte)(value << 7);
}
else
{
returned[i / 8] |= (byte)((value & 0x01) << (7 - (i % 8)));
}
break;
}
}
QuantData = returned;
}
/// <summary>
/// Cuts a box.
/// </summary>
/// <param name="set1">The first set.</param>
/// <param name="set2">The second set.</param>
/// <returns>Returns a value indicating whether the box has been split.</returns>
private bool Cut(Box set1, Box set2)
{
double wholeR = WuAlphaColorQuantizer.Volume(set1, this.vmr);
double wholeG = WuAlphaColorQuantizer.Volume(set1, this.vmg);
double wholeB = WuAlphaColorQuantizer.Volume(set1, this.vmb);
double wholeA = WuAlphaColorQuantizer.Volume(set1, this.vma);
double wholeW = WuAlphaColorQuantizer.Volume(set1, this.vwt);
int cutr;
int cutg;
int cutb;
int cuta;
double maxr = this.Maximize(set1, 3, set1.R0 + 1, set1.R1, out cutr, wholeR, wholeG, wholeB, wholeA, wholeW);
double maxg = this.Maximize(set1, 2, set1.G0 + 1, set1.G1, out cutg, wholeR, wholeG, wholeB, wholeA, wholeW);
double maxb = this.Maximize(set1, 1, set1.B0 + 1, set1.B1, out cutb, wholeR, wholeG, wholeB, wholeA, wholeW);
double maxa = this.Maximize(set1, 0, set1.A0 + 1, set1.A1, out cuta, wholeR, wholeG, wholeB, wholeA, wholeW);
int dir;
if ((maxr >= maxg) && (maxr >= maxb) && (maxr >= maxa))
{
dir = 3;
if (cutr < 0)
{
return(false);
}
}
else if ((maxg >= maxr) && (maxg >= maxb) && (maxg >= maxa))
{
dir = 2;
}
else if ((maxb >= maxr) && (maxb >= maxg) && (maxb >= maxa))
{
dir = 1;
}
else
{
dir = 0;
}
set2.R1 = set1.R1;
set2.G1 = set1.G1;
set2.B1 = set1.B1;
set2.A1 = set1.A1;
switch (dir)
{
// Red
case 3:
set2.R0 = set1.R1 = cutr;
set2.G0 = set1.G0;
set2.B0 = set1.B0;
set2.A0 = set1.A0;
break;
// Green
case 2:
set2.G0 = set1.G1 = cutg;
set2.R0 = set1.R0;
set2.B0 = set1.B0;
set2.A0 = set1.A0;
break;
// Blue
case 1:
set2.B0 = set1.B1 = cutb;
set2.R0 = set1.R0;
set2.G0 = set1.G0;
set2.A0 = set1.A0;
break;
// Alpha
case 0:
set2.A0 = set1.A1 = cuta;
set2.R0 = set1.R0;
set2.G0 = set1.G0;
set2.B0 = set1.B0;
break;
}
set1.Volume = (set1.R1 - set1.R0) * (set1.G1 - set1.G0) * (set1.B1 - set1.B0) * (set1.A1 - set1.A0);
set2.Volume = (set2.R1 - set2.R0) * (set2.G1 - set2.G0) * (set2.B1 - set2.B0) * (set2.A1 - set2.A0);
return(true);
}