public void QuantizePerformanceTest()
{
//using var bmpRef = new Bitmap(@"D:\Letolt\MYSTY8RQER62.jpg");
using var bmpRef = Icons.Information.ExtractBitmap(new Size(256, 256));
IQuantizer quantizer = PredefinedColorsQuantizer.SystemDefault8BppPalette();
new PerformanceTest {
TestName = $"{bmpRef.Width}x{bmpRef.Height}@{bmpRef.GetColorCount()}", Iterations = 100, CpuAffinity = null
}
.AddCase(() =>
{
using var result = bmpRef.CloneBitmap();
result.Quantize(quantizer);
}, "BitmapExtensions.Quantize")
.AddCase(() =>
{
using var result = bmpRef.CloneBitmap();
using (IBitmapDataInternal bitmapData = BitmapDataFactory.CreateBitmapData(result, ImageLockMode.ReadWrite))
using (IQuantizingSession session = quantizer.Initialize(bitmapData))
{
var row = bitmapData.DoGetRow(0);
int width = bitmapData.Width;
do
{
for (int x = 0; x < width; x++)
{
row.DoSetColor32(x, session.GetQuantizedColor(row.DoGetColor32(x)));
}
} while (row.MoveNextRow());
}
}, "Sequential quantization")
.DoTest()
.DumpResults(Console.Out);
}
internal static Color32 BlendOrMakeTransparent(this IQuantizingSession session, Color32 origColor)
{
// the color can be considered fully transparent
if (origColor.A < session.AlphaThreshold)
{
// and even the quantizer returns a transparent color
var c = session.GetQuantizedColor(origColor);
if (c.A == 0)
{
return(c);
}
}
// the color will not be transparent in the end: blending
return(origColor.BlendWithBackground(session.BackColor));
}
internal void PerformCopyWithQuantizer(IQuantizingSession quantizingSession, bool skipTransparent)
{
// Sequential processing
if (SourceRectangle.Width < parallelThreshold >> quantizingScale)
{
context.Progress?.New(DrawingOperation.ProcessingPixels, SourceRectangle.Height);
IBitmapDataRowInternal rowSrc = Source.DoGetRow(SourceRectangle.Y);
IBitmapDataRowInternal rowDst = Target.DoGetRow(TargetRectangle.Y);
byte alphaThreshold = quantizingSession.AlphaThreshold;
for (int y = 0; y < SourceRectangle.Height; y++)
{
if (context.IsCancellationRequested)
{
return;
}
for (int x = 0; x < SourceRectangle.Width; x++)
{
Color32 colorSrc = rowSrc.DoGetColor32(x + SourceRectangle.X);
if (skipTransparent && colorSrc.A < alphaThreshold)
{
continue;
}
rowDst.DoSetColor32(x + TargetRectangle.X, quantizingSession.GetQuantizedColor(colorSrc));
}
rowSrc.MoveNextRow();
rowDst.MoveNextRow();
context.Progress?.Increment();
}
return;
}
IBitmapDataInternal source = Source;
IBitmapDataInternal target = Target;
Point sourceLocation = SourceRectangle.Location;
Point targetLocation = TargetRectangle.Location;
int sourceWidth = SourceRectangle.Width;
ParallelHelper.For(context, DrawingOperation.ProcessingPixels, 0, SourceRectangle.Height, y =>
{
IQuantizingSession session = quantizingSession;
IBitmapDataRowInternal rowSrc = source.DoGetRow(sourceLocation.Y + y);
IBitmapDataRowInternal rowDst = target.DoGetRow(targetLocation.Y + y);
int offsetSrc = sourceLocation.X;
int offsetDst = targetLocation.X;
int width = sourceWidth;
byte alphaThreshold = session.AlphaThreshold;
bool skip = skipTransparent;
for (int x = 0; x < width; x++)
{
Color32 colorSrc = rowSrc.DoGetColor32(x + offsetSrc);
if (skip && colorSrc.A < alphaThreshold)
{
continue;
}
rowDst.DoSetColor32(x + offsetDst, session.GetQuantizedColor(colorSrc));
}
});
}
private void PerformDrawWithQuantizer(IQuantizingSession quantizingSession)
{
IBitmapDataInternal source = Source;
IBitmapDataInternal target = Target;
Point sourceLocation = SourceRectangle.Location;
Point targetLocation = TargetRectangle.Location;
int sourceWidth = SourceRectangle.Width;
// Sequential processing
if (SourceRectangle.Width < parallelThreshold >> quantizingScale)
{
context.Progress?.New(DrawingOperation.ProcessingPixels, SourceRectangle.Height);
for (int y = 0; y < SourceRectangle.Height; y++)
{
if (context.IsCancellationRequested)
{
return;
}
ProcessRow(y);
context.Progress?.Increment();
}
return;
}
// Parallel processing
ParallelHelper.For(context, DrawingOperation.ProcessingPixels, 0, SourceRectangle.Height, ProcessRow);
#region Local Methods
void ProcessRow(int y)
{
IQuantizingSession session = quantizingSession;
IBitmapDataRowInternal rowSrc = source.DoGetRow(sourceLocation.Y + y);
IBitmapDataRowInternal rowDst = target.DoGetRow(targetLocation.Y + y);
int offsetSrc = sourceLocation.X;
int offsetDst = targetLocation.X;
byte alphaThreshold = session.AlphaThreshold;
int width = sourceWidth;
for (int x = 0; x < width; x++)
{
Color32 colorSrc = rowSrc.DoGetColor32(x + offsetSrc);
// fully solid source: overwrite
if (colorSrc.A == Byte.MaxValue)
{
rowDst.DoSetColor32(x + offsetDst, session.GetQuantizedColor(colorSrc));
continue;
}
// fully transparent source: skip
if (colorSrc.A == 0)
{
continue;
}
// source here has a partial transparency: we need to read the target color
int pos = x + offsetDst;
Color32 colorDst = rowDst.DoGetColor32(pos);
// non-transparent target: blending
if (colorDst.A != 0)
{
colorSrc = colorDst.A == Byte.MaxValue
// target pixel is fully solid: simple blending
? colorSrc.BlendWithBackground(colorDst)
// both source and target pixels are partially transparent: complex blending
: colorSrc.BlendWith(colorDst);
}
// overwriting target color only if blended color has high enough alpha
if (colorSrc.A < alphaThreshold)
{
continue;
}
rowDst.DoSetColor32(pos, session.GetQuantizedColor(colorSrc));
}
}
#endregion
}