ErrorDiffusionDitherer Class

public sealed class ErrorDiffusionDitherer : IDitherer

Public NotInheritable Class ErrorDiffusionDitherer
	Implements IDitherer

public ref class ErrorDiffusionDitherer sealed : IDitherer

[<SealedAttribute>]
type ErrorDiffusionDitherer = 
    class
        interface IDitherer
    end

Inheritance

Object    ErrorDiffusionDitherer

Implements

IDitherer

The constructor can be used to create an error diffusion ditherer using a custom matrix.

Use the static properties to obtain an instance with predefined parameters.

The ErrorDiffusionDitherer class uses an adaptive dithering technique, which disperses the quantization error of each pixels to the neighboring ones. Thereby the strength of the dithering is automatically adjusted by the algorithm itself, which provides good results also for palettes with uneven color distribution (which is not the case for ordered dithering, for example).

As the dithered result of a pixel depends on the already processed pixels, the ErrorDiffusionDitherer does not support parallel processing, which makes it slower than most of the other dithering methods.

The following table demonstrates the effect of the dithering:

Calculation of the quantization error may happen in two ways. The publicly available algorithms usually calculate the error for each color channels, which usually provides good results with color palettes. However, when quantizing color images with a black and white or grayscale palette, this approach may fail. For example, if the quantizer returns black for a fully saturated blue pixel, the quantization error is zero on the red and green channels and 100% on the blue channel. The problem is that this error cannot be propagated to the neighboring pixels if they have the same color because adding any more blue to already fully saturated blue pixels will not change anything. Therefore, the ErrorDiffusionDitherer can propagate quantization error by brightness based on human perception, which is more appropriate for palettes with grayscale colors. The ErrorDiffusionDitherer tries to auto detect the strategy for each dithering session but this can be overridden by the ConfigureErrorDiffusionMode method.

The following table demonstrates the effect of different strategies:

A typical artifact of error diffusion dithering is a ripple effect, which often appears in homogeneous areas of the dithered image. This is due to the fact that most filters propagate quantization errors mostly to right and down, whereas pixels are processed left-to-right in each line while lines are scanned top-down (raster processing). The ripple effect can be reduced if every second line is processed in the opposite direction (serpentine processing). You can use the ConfigureProcessingDirection method to obtain an ErrorDiffusionDitherer with serpentine processing mode, which processes even lines left-to-right and odd lines right-to-left.

The following table demonstrates the effect of different processing directions:

Reference