IntQuantizer and BlackAndWhiteIntPalette

Author: Nycto

src/dither/palette.nim

@@ -5,7 +5,13 @@ type
         ## A palette made of explicit colors
         colors: seq[ColorRGBX]
 
+    BlackAndWhiteIntPaletteObj = object
+
+const BlackAndWhiteIntPalette* = BlackAndWhiteIntPaletteObj()
+    ## A palette that uses integers to represent shades of gray, but the output palette is only black and white
+
 proc palette*(colors: varargs[ColorRGBX]): FixedPalette =
+    ## Creates a palette from the given set of colors
     FixedPalette(colors: colors.toSeq)
 
 proc nearestColor*(palette: FixedPalette, color: ColorRGBX): ColorRGBX =
@@ -37,3 +43,10 @@ proc `+`*(color: ColorRGBX, scalar: int): ColorRGBX =
     ## Add a scalar value to a color
     result = rgbx(color.r + scalar, color.g + scalar, color.b + scalar, color.a)
 
+proc nearestColor*(palette: BlackAndWhiteIntPaletteObj, color: int): int =
+    ## Returns black or white, whichever is closest
+    return if color > 128: 255 else: 0
+
+proc approxMaxColorDistance*(palette: BlackAndWhiteIntPaletteObj): int = 128
+    ## Returns the maximum distance between colors
+

src/dither/quantizer.nim

@@ -6,7 +6,13 @@ type
     ColorQuantizeError = object
         red, green, blue: int
 
+    IntQuantizerObj = object
+
 const ColorQuantizer* = ColorQuantizeObj()
+    ## Quantizer that uses chroma to support RGB values
+
+const IntQuantizer* = IntQuantizerObj()
+    ## Quantizer that uses integers to represent a gray scale
 
 proc quantizeError*(q: ColorQuantizeObj; a, b: ColorRGBX): ColorQuantizeError =
     return ColorQuantizeError(red: a.r.int - b.r.int, green: a.g.int - b.g.int, blue: a.b.int - b.b.int)
@@ -24,3 +30,5 @@ proc `+`(a: uint8, b: SomeInteger): uint8 = clamp(a.int + b.int, 0, 255).uint8
 
 proc `+`*(color: ColorRGBX, error: ColorQuantizeError): ColorRGBX =
     return rgbx(color.r + error.red, color.g + error.green, color.b + error.blue, color.a)
+
+proc quantizeError*(q: IntQuantizerObj, a, b: int): int = a - b

tests/stubs.nim

@@ -7,10 +7,6 @@ type
     OutputImage*[N: static int, T] = object
         pixels: seq[array[N, T]]
 
-    BlackAndWhite* = object
-
-    IntQuantizer* = object
-
 proc newInput*[W: static int, T](pixels: varargs[array[W, T]]): auto = TestInput[W, T](pixels: pixels.toSeq)
 
 proc width*[W: static int, T](image: TestInput[W, T]): int = W
@@ -19,13 +15,6 @@ proc height*[W: static int, T](image: TestInput[W, T]): int = image.pixels.len
 
 proc getPixel*[W: static int, T](image: TestInput[W, T]; x, y: int): T = image.pixels[y][x]
 
-proc nearestColor*(palette: BlackAndWhite, color: int): int =
-    return if color > 128: 255 else: 0
-
-proc quantError*(a, b: int): int = a - b
-
-proc approxMaxColorDistance*(palette: BlackAndWhite): int = 128
-
 proc newOutput*[N: static int, T](): auto = OutputImage[N, T](pixels: newSeq[array[N, T]]())
 
 proc setPixel*[N: static int, T](img: var OutputImage[N, T]; x, y: int, color: T) =
@@ -41,6 +30,4 @@ proc `==`*[N: static int, M: static int, T](img: var OutputImage[N, T]; values:
 proc intArray*[N: static int](values: Slice[int]): array[N, int] =
     let increment = (values.b - values.a) / (N - 1)
     for i in 0..<N:
-        result[i] = round(increment * i.float).toInt
-
-proc quantizeError*(q: IntQuantizer, a, b: int): int = a - b
+        result[i] = round(increment * i.float).toInt

tests/t_diffusion.nim

@@ -8,7 +8,7 @@ suite "Error diffusion dithering":
     test "Can perform Floyd Steinberg dithering":
         var output = newOutput[20, int]()
 
-        errorDiffusionDither(img, output, BlackAndWhite(), IntQuantizer(), FloydSteinberg)
+        errorDiffusionDither(img, output, BlackAndWhiteIntPalette, IntQuantizer, FloydSteinberg)
 
         check(output == [
             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0, 255],
@@ -26,7 +26,7 @@ suite "Error diffusion dithering":
     test "Can perform Jarvis, Judice, and Ninke dithering":
         var output = newOutput[20, int]()
 
-        errorDiffusionDither(img, output, BlackAndWhite(), IntQuantizer(), JarvisJudiceNinke)
+        errorDiffusionDither(img, output, BlackAndWhiteIntPalette, IntQuantizer, JarvisJudiceNinke)
 
         check(output == [
             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0],
@@ -44,7 +44,7 @@ suite "Error diffusion dithering":
     test "Can perform Stucki dithering":
         var output = newOutput[20, int]()
 
-        errorDiffusionDither(img, output, BlackAndWhite(), IntQuantizer(), Stucki)
+        errorDiffusionDither(img, output, BlackAndWhiteIntPalette, IntQuantizer, Stucki)
 
         check(output == [
             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0],
@@ -62,7 +62,7 @@ suite "Error diffusion dithering":
     test "Can perform Atkinson dithering":
         var output = newOutput[20, int]()
 
-        errorDiffusionDither(img, output, BlackAndWhite(), IntQuantizer(), Atkinson)
+        errorDiffusionDither(img, output, BlackAndWhiteIntPalette, IntQuantizer, Atkinson)
 
         check(output == [
             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255],
@@ -80,7 +80,7 @@ suite "Error diffusion dithering":
     test "Can perform Burkes dithering":
         var output = newOutput[20, int]()
 
-        errorDiffusionDither(img, output, BlackAndWhite(), IntQuantizer(), Burkes)
+        errorDiffusionDither(img, output, BlackAndWhiteIntPalette, IntQuantizer, Burkes)
 
         check(output == [
             [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 255, 0, 255, 0],

tests/t_ordered.nim

@@ -12,7 +12,7 @@ suite "Ordered dithering":
             intArray[10](0..255),
         )
 
-        img.orderedDither(output, BlackAndWhite(), Bayer2x2)
+        img.orderedDither(output, BlackAndWhiteIntPalette, Bayer2x2)
 
         check(output == [
             [ 0, 0, 0, 255, 0, 255, 255, 255, 255, 255],
@@ -33,7 +33,7 @@ suite "Ordered dithering":
             intArray[20](0..255),
         )
 
-        img.orderedDither(output, BlackAndWhite(), Bayer4x4)
+        img.orderedDither(output, BlackAndWhiteIntPalette, Bayer4x4)
 
         check(output == [
             [  0, 0, 0, 0, 0, 255, 0, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255],
@@ -52,7 +52,7 @@ suite "Ordered dithering":
             intArray[10](0..100).toSeq.mapIt(intArray[20](it..(it + 128)))
         )
 
-        img.orderedDither(output, BlackAndWhite(), Bayer8x8)
+        img.orderedDither(output, BlackAndWhiteIntPalette, Bayer8x8)
 
         check(output == [
             [ 0, 0, 0, 0, 0, 0, 0, 255, 0, 0, 0, 255, 0, 255, 0, 255, 0, 255, 255, 255],

tests/t_palette.nim

@@ -13,4 +13,14 @@ suite "Fixed palette":
         check(palette.nearestColor(rgbx(100, 100, 100, 200)) == gray)
 
     test "Can estimate the max distance between colors":
-        check(palette.approxMaxColorDistance == 128)
+        check(palette.approxMaxColorDistance == 128)
+
+suite "Black and white int pallete":
+
+    test "Can return the nearest color":
+        check(BlackAndWhiteIntPalette.nearestColor(10) == 0)
+        check(BlackAndWhiteIntPalette.nearestColor(128) == 0)
+        check(BlackAndWhiteIntPalette.nearestColor(200) == 255)
+
+    test "Can estimate the max distance between colors":
+        check(BlackAndWhiteIntPalette.approxMaxColorDistance == 128)