Index

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

API symbols

`*`:

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

`+`:

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

`div`:

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

approxMaxColorDistance:

• palette: proc approxMaxColorDistance(palette: FixedPalette): int
• palette: proc approxMaxColorDistance(palette: GreyScalePalette): int

Atkinson:

• algorithms: const Atkinson

Bayer2x2:

• algorithms: const Bayer2x2

Bayer4x4:

• algorithms: const Bayer4x4

Bayer8x8:

• algorithms: const Bayer8x8

BlackAndWhiteIntPalette:

• palette: const BlackAndWhiteIntPalette

Burkes:

• algorithms: const Burkes

ColorQuantizeError:

• quantizer: object ColorQuantizeError

ColorQuantizer:

• quantizer: const ColorQuantizer

columns:

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

DiffusionMatrix:

• algorithms: object DiffusionMatrix

Diffusor:

• diffusion: type Diffusor

dither:

• dither: proc dither[Color, Error](input: InputImage[Color]; output: var OutputImage[Color]; algorithm: DitherModes; palette: Palette[Color]; quantizer: Quantizer[Color, Error])

DitherModes:

• types: enum DitherModes

errorDiffusionDither:

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

FixedPalette:

• palette: type FixedPalette

FloydSteinberg:

• algorithms: const FloydSteinberg

GreyScalePalette:

• palette: type GreyScalePalette

InputImage:

• types: type InputImage

IntQuantizer:

• quantizer: const IntQuantizer

JarvisJudiceNinke:

• algorithms: const JarvisJudiceNinke

maxThreshold:

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

nearestColor:

• palette: proc nearestColor(palette: FixedPalette; color: ColorRGBX): ColorRGBX
• palette: proc nearestColor(palette: GreyScalePalette; color: int): int

newGreyScalePalette:

• palette: proc newGreyScalePalette(numberOfShades: SomeInteger): GreyScalePalette

numerator:

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

orderedDither:

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

OutputImage:

• types: type OutputImage

palette:

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

Palette:

• types: type Palette

quantizeError:

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

Quantizer:

• diffusion: type Quantizer

rows:

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

Stucki:

• algorithms: const Stucki

threshold:

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

ThresholdMatrix:

• algorithms: type ThresholdMatrix

Thresholds:

• ordered: type Thresholds