Add Thresholds concept

Author: Nycto

src/dither.nim

@@ -1,5 +1,5 @@
-import dither/[ordered, types, palette, diffusion, quantizer, matrix]
-export ordered, types, palette, diffusion, quantizer, matrix
+import dither/[ordered, types, palette, diffusion, quantizer, algorithms]
+export ordered, types, palette, diffusion, quantizer, algorithms
 
 proc dither*(input: InputImage, output: var OutputImage, algorithm: DitherModes, palette: Palette) =
     ## Applies the a dithering algorithm to `input` and writes it to `output`

src/dither/matrix.nim src/dither/algorithms.nimsrc/dither/matrix.nim renamed to src/dither/algorithms.nim

@@ -5,9 +5,38 @@ type
         inset*: int
         denominator*: int
 
+    ThresholdMatrix*[N: static int] = array[N, array[N, int]]
+        ## Uses a matrix of integers as a threshold map for ordered dithering
+
 proc matrix[Rows: static int, Cols: static int](inset, denom: int; data: array[Rows, array[Cols, int]]): auto =
     return DiffusionMatrix[Rows, Cols](data: data, inset: inset, denominator: denom)
 
+const Bayer2x2*: ThresholdMatrix[2]  = [
+    [ 0, 2 ],
+    [ 3, 1 ]
+]
+    ## Bayer 2x2 dithering
+
+const Bayer4x4*: ThresholdMatrix[4]  = [
+    [ 1,  9,  3,  11 ],
+    [ 13, 5,  15, 7  ],
+    [ 4,  12, 2,  10 ],
+    [ 16, 8,  14, 6  ]
+]
+    ## Bayer 4x4 dithering
+
+const Bayer8x8*: ThresholdMatrix[8] = [
+    [ 0, 32,  8, 40,  2, 34, 10, 42],
+    [48, 16, 56, 24, 50, 18, 58, 26],
+    [12, 44,  4, 36, 14, 46,  6, 38],
+    [60, 28, 52, 20, 62, 30, 54, 22],
+    [ 3, 35, 11, 43,  1, 33,  9, 41],
+    [51, 19, 59, 27, 49, 17, 57, 25],
+    [15, 47,  7, 39, 13, 45,  5, 37],
+    [63, 31, 55, 23, 61, 29, 53, 21]
+]
+    ## Bayer 8x8 dithering
+
 const FloydSteinberg* = matrix[2, 3](1, 16, [
     [ 0, 0, 7 ],
     [ 3, 5, 1 ]
@@ -41,6 +70,10 @@ const Burkes* = matrix[2, 5](2, 32, [
 ])
     ## Burkes dithering
 
+proc maxThreshold*[N: static int](thresholds: ThresholdMatrix[N]): int = N * N
+
+proc threshold*[N: static int](thresholds: ThresholdMatrix[N], x, y: int): int = thresholds[y mod N][x mod N]
+
 proc rows*[Rows: static int, Cols: static int](matrix: DiffusionMatrix[Rows, Cols]): int =
     ## The number of rows in this matrix
     return Rows

src/dither/ordered.nim

@@ -1,48 +1,29 @@
 import types
 
-type ThresholdMap*[N: static int] = array[N, array[N, int]]
+type
+    Thresholds* = concept t
+        ## Describes the values to add that vary the colors at different offsets
+        t.maxThreshold is int
+        t.threshold(int, int) is int
 
-const Bayer2x2*: ThresholdMap[2]  = [
-    [ 0, 2 ],
-    [ 3, 1 ]
-]
-
-const Bayer4x4*: ThresholdMap[4]  = [
-    [ 1,  9,  3,  11 ],
-    [ 13, 5,  15, 7  ],
-    [ 4,  12, 2,  10 ],
-    [ 16, 8,  14, 6  ]
-]
-
-const Bayer8x8*: ThresholdMap[8] = [
-    [ 0, 32,  8, 40,  2, 34, 10, 42],
-    [48, 16, 56, 24, 50, 18, 58, 26],
-    [12, 44,  4, 36, 14, 46,  6, 38],
-    [60, 28, 52, 20, 62, 30, 54, 22],
-    [ 3, 35, 11, 43,  1, 33,  9, 41],
-    [51, 19, 59, 27, 49, 17, 57, 25],
-    [15, 47,  7, 39, 13, 45,  5, 37],
-    [63, 31, 55, 23, 61, 29, 53, 21]
-]
-
-proc orderedDither*[N, P](
+proc orderedDither*[P](
     input: InputImage[P],
     output: var OutputImage[P],
     palette: Palette[P],
-    thresholds: ThresholdMap[N]
+    thresholds: Thresholds
 ) =
     ## Ordered dithering
     ## * https://en.wikipedia.org/wiki/Ordered_dithering`
     ## * https://bisqwit.iki.fi/story/howto/dither/jy/
 
-    let maxThresholdMap = N * N
+    let maxThresholdMap = thresholds.maxThreshold
 
     # The likely distance between colors in the palette
     let threshold = palette.approxMaxColorDistance
 
     for y in 0..<input.height:
         for x in 0..<input.width:
-            let factor = thresholds[y mod N][x mod N]
+            let factor = thresholds.threshold(x, y)
             let actualPixel = input.getPixel(x, y)
             let adjustdPixel = actualPixel + (factor * threshold div maxThresholdMap)
             let final = palette.nearestColor(adjustdPixel)