public void DitherPerformanceTest(bool errorDiffusion) { using var bmpRef = Icons.Information.ExtractBitmap(new Size(256, 256)); IQuantizer quantizer = PredefinedColorsQuantizer.SystemDefault8BppPalette(); IDitherer ditherer = errorDiffusion ? (IDitherer)ErrorDiffusionDitherer.FloydSteinberg : OrderedDitherer.Bayer8x8; new PerformanceTest { TestName = $"{bmpRef.Width}x{bmpRef.Height}@{bmpRef.GetColorCount()} {(errorDiffusion ? "Error Diffusion" : "Ordered")}", Iterations = 100, CpuAffinity = null } .AddCase(() => { using var result = bmpRef.CloneBitmap(); result.Dither(quantizer, ditherer); }, "BitmapExtensions.Dither") .AddCase(() => { using var result = bmpRef.CloneBitmap(); using (IBitmapDataInternal bitmapData = BitmapDataFactory.CreateBitmapData(result, ImageLockMode.ReadWrite)) using (IQuantizingSession quantizingSession = quantizer.Initialize(bitmapData)) using (IDitheringSession ditheringSession = ditherer.Initialize(bitmapData, quantizingSession)) { var row = bitmapData.DoGetRow(0); int width = bitmapData.Width; do { for (int x = 0; x < width; x++) { row.DoSetColor32(x, ditheringSession.GetDitheredColor(row.DoGetColor32(x), x, row.Index)); } } while (row.MoveNextRow()); } }, "Sequential dithering") .DoTest() .DumpResults(Console.Out); }
public void ClearWithDitheringTest(PixelFormat pixelFormat, uint argb, bool errorDiffusion) { const int size = 512; Color color = Color.FromArgb((int)argb); var ditherer = errorDiffusion ? (IDitherer)ErrorDiffusionDitherer.FloydSteinberg : OrderedDitherer.Bayer8x8; new PerformanceTest { TestName = $"{pixelFormat} {size}x{size} {(errorDiffusion ? "Error Diffusion" : "Ordered Dithering")}", Iterations = 10, CpuAffinity = null } .AddCase(() => { using var bmp = new Bitmap(size, size, pixelFormat); using IBitmapDataInternal acc = BitmapDataFactory.CreateBitmapData(bmp, ImageLockMode.ReadWrite); IQuantizer quantizer = PredefinedColorsQuantizer.FromBitmapData(acc); var c = new Color32(color); using (IQuantizingSession quantizingSession = quantizer.Initialize(acc)) using (IDitheringSession ditheringSession = ditherer.Initialize(acc, quantizingSession)) { IReadWriteBitmapDataRow row = acc.DoGetRow(0); do { for (int x = 0; x < acc.Width; x++) { row[x] = ditheringSession.GetDitheredColor(c, x, row.Index); } } while (row.MoveNextRow()); } }, "Sequential clear") .AddCase(() => { using var bmp = new Bitmap(size, size, pixelFormat); bmp.Clear(color, ditherer); }, "BitmapDataAccessor.Clear") .DoTest() .DumpResults(Console.Out); }
private void PerformDrawWithDithering(IQuantizingSession quantizingSession, IDitheringSession ditheringSession) { IBitmapDataInternal source = Source; IBitmapDataInternal target = Target; Point sourceLocation = SourceRectangle.Location; Point targetLocation = TargetRectangle.Location; int sourceWidth = SourceRectangle.Width; // Sequential processing if (ditheringSession.IsSequential || SourceRectangle.Width < parallelThreshold >> ditheringScale) { 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) { IDitheringSession session = ditheringSession; IBitmapDataRowInternal rowSrc = source.DoGetRow(sourceLocation.Y + y); IBitmapDataRowInternal rowDst = target.DoGetRow(targetLocation.Y + y); int offsetSrc = sourceLocation.X; int offsetDst = targetLocation.X; byte alphaThreshold = quantizingSession.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.GetDitheredColor(colorSrc, x, y)); 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.GetDitheredColor(colorSrc, x, y)); } } #endregion }
internal void PerformCopyWithDithering(IQuantizingSession quantizingSession, IDitheringSession ditheringSession, bool skipTransparent) { // Sequential processing if (ditheringSession.IsSequential || SourceRectangle.Width < parallelThreshold >> ditheringScale) { 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; } // we can pass x, y to the dithering session because if there is an offset it was initialized by a properly clipped rectangle 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, ditheringSession.GetDitheredColor(colorSrc, x, y)); } rowSrc.MoveNextRow(); rowDst.MoveNextRow(); context.Progress?.Increment(); } return; } // Parallel processing 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 => { IDitheringSession session = ditheringSession; 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 = quantizingSession.AlphaThreshold; bool skip = skipTransparent; // we can pass x, y to the dithering session because if there is an offset it was initialized by a properly clipped rectangle for (int x = 0; x < width; x++) { Color32 colorSrc = rowSrc.DoGetColor32(x + offsetSrc); if (skip && colorSrc.A < alphaThreshold) { continue; } rowDst.DoSetColor32(x + offsetDst, session.GetDitheredColor(colorSrc, x, y)); } }); }