Index

Modules: dither, dither/algorithms, dither/diffusion, dither/ordered, dither/palette, dither/quantizer, dither/types.

API symbols

`*`:

• quantizer: `*`(error: ColorQuantizeError; scalar: int): ColorQuantizeError

`+`:

• palette: `+`(color: ColorRGBX; scalar: int): ColorRGBX
• quantizer: `+`(a, b: ColorQuantizeError): ColorQuantizeError
• quantizer: `+`(color: ColorRGBX; error: ColorQuantizeError): ColorRGBX

`div`:

• quantizer: `div`(error: ColorQuantizeError; scalar: int): ColorQuantizeError

approxMaxColorDistance:

• palette: approxMaxColorDistance(palette: BlackAndWhiteIntPaletteObj): int
• palette: approxMaxColorDistance(palette: FixedPalette): int

Atkinson:

• algorithms: Atkinson

Bayer2x2:

• algorithms: Bayer2x2

Bayer4x4:

• algorithms: Bayer4x4

Bayer8x8:

• algorithms: Bayer8x8

BlackAndWhiteIntPalette:

• palette: BlackAndWhiteIntPalette

Burkes:

• algorithms: Burkes

ColorQuantizer:

• quantizer: ColorQuantizer

columns:

• algorithms: columns[Rows: static int; Cols: static int](matrix: DiffusionMatrix[Rows, Cols]): int

DiffusionMatrix:

• algorithms: DiffusionMatrix

Diffusor:

• diffusion: Diffusor

dither:

• dither: dither(input: InputImage; output: var OutputImage; algorithm: DitherModes; palette: Palette)

DitherModes:

• types: DitherModes

errorDiffusionDither:

• diffusion: errorDiffusionDither[C, E](input: InputImage[C]; output: var OutputImage[C]; palette: Palette[C]; quantizer: Quantizer[C, E]; diffusor: Diffusor)

FixedPalette:

• palette: FixedPalette

FloydSteinberg:

• algorithms: FloydSteinberg

InputImage:

• types: InputImage

IntQuantizer:

• quantizer: IntQuantizer

JarvisJudiceNinke:

• algorithms: JarvisJudiceNinke

maxThreshold:

• algorithms: maxThreshold[N: static int](thresholds: ThresholdMatrix[N]): int

nearestColor:

• palette: nearestColor(palette: BlackAndWhiteIntPaletteObj; color: int): int
• palette: nearestColor(palette: FixedPalette; color: ColorRGBX): ColorRGBX

numerator:

• algorithms: numerator[Rows: static int; Cols: static int]( matrix: DiffusionMatrix[Rows, Cols]; row, column: int): int

orderedDither:

• ordered: orderedDither[P](input: InputImage[P]; output: var OutputImage[P]; palette: Palette[P]; thresholds: Thresholds)

OutputImage:

• types: OutputImage

palette:

• palette: palette(colors: varargs[ColorRGBX]): FixedPalette

Palette:

• types: Palette

quantizeError:

• quantizer: quantizeError(q: ColorQuantizeObj; a, b: ColorRGBX): ColorQuantizeError
• quantizer: quantizeError(q: IntQuantizerObj; a, b: int): int

Quantizer:

• diffusion: Quantizer

rows:

• algorithms: rows[Rows: static int; Cols: static int](matrix: DiffusionMatrix[Rows, Cols]): int

Stucki:

• algorithms: Stucki

threshold:

• algorithms: threshold[N: static int](thresholds: ThresholdMatrix[N]; x, y: int): int

ThresholdMatrix:

• algorithms: ThresholdMatrix

Thresholds:

• ordered: Thresholds