ascii tests

examples/convert_img.py

@@ -2,7 +2,6 @@
 from pathlib import Path
 from PIL import Image
 from pil2ansi import convert_img, Palettes
-import numpy as np
 
 # Image.MAX_IMAGE_PIXELS = None
 
@@ -25,15 +24,6 @@
 img_path = Path(args.img_path).as_posix()
 img = Image.open(img_path)
 
-img: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
-img.putpixel((0, 0), (255, 0, 0, 0))
-img.putpixel((0, 6), (255, 0, 0, 0))
-img.putpixel((4, 0), (255, 0, 0, 0))
-img.putpixel((4, 6), (255, 0, 0, 0))
-
-img_data_list = list(img.getdata())
-print(np.array(img_data_list).reshape(5,7,4))
-
 # convert to ansi
 out = convert_img(
     img=img,
@@ -43,5 +33,4 @@
 )
 
 # print to terminal
-print(repr(out))
 print(out)

examples/debug.py

@@ -0,0 +1,68 @@
+from pil2ansi import convert_img, Palettes, Palette
+from PIL import Image
+
+palettes: list = [Palettes.color, Palettes.grayscale, Palettes.grayscale_inverted, Palettes.ascii]
+reset: str = "\033[0m"
+
+def print_palette(palette: Palette):
+    print(f"\nPalette: {palette.__class__.__name__}")
+    if palette.pil_color == "LA":
+        for i in range(256):
+            print(f"{reset}{palette.pixel_to_color((i, 255), (i, 255))} {reset}", end="")
+            if (i + 1) % (256 / 4) == 0:
+                print("\n", end="")
+    else:
+        for i in range(256):
+            print(f"{reset}{palette.pixel_to_color((i, 0, 0, 255), (i, 0, 0, 255))} {reset}", end="")
+            if (i + 1) % (256 / 4) == 0:
+                print("\n", end="")
+        for i in range(256):
+            print(f"{reset}{palette.pixel_to_color((0, i, 0, 255), (0, i, 0, 255))} {reset}", end="")
+            if (i + 1) % (256 / 4) == 0:
+                print("\n", end="")
+        for i in range(256):
+            print(f"{reset}{palette.pixel_to_color((0, 0, i, 255), (0, 0, i, 255))} {reset}", end="")
+            if (i + 1) % (256 / 4) == 0:
+                print("\n", end="")
+
+for palette in palettes: print_palette(palette)
+
+# 2x2
+img_2x2: Image.Image = Image.new("RGBA", (2, 2), (255, 0, 0, 255))
+
+# 4x4
+img_4x4: Image.Image = Image.new("RGBA", (4, 4), (255, 0, 0, 255))
+
+# 4x4 with transparent corners
+img_4x4_alpha: Image.Image = Image.new("RGBA", (4, 4), (255, 0, 0, 255))
+img_4x4_alpha.putpixel((0, 0), (255, 0, 0, 0))
+img_4x4_alpha.putpixel((0, 3), (255, 0, 0, 0))
+img_4x4_alpha.putpixel((3, 0), (255, 0, 0, 0))
+img_4x4_alpha.putpixel((3, 3), (255, 0, 0, 0))
+
+# 5x7
+img_5x7: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
+
+# 5x7 with transparent corners
+img_5x7_alpha: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
+img_5x7_alpha.putpixel((0, 0), (255, 0, 0, 0))
+img_5x7_alpha.putpixel((0, 6), (255, 0, 0, 0))
+img_5x7_alpha.putpixel((4, 0), (255, 0, 0, 0))
+img_5x7_alpha.putpixel((4, 6), (255, 0, 0, 0))
+
+
+print("\n2x2")
+for palette in palettes: print(convert_img(img_2x2, palette))
+
+print("\n4x4")
+for palette in palettes: print(convert_img(img_4x4, palette))
+
+print("\n5x7")
+for palette in palettes: print(convert_img(img_5x7, palette))
+
+print("\n4x4 with transparent corners")
+for palette in palettes: print(convert_img(img_4x4_alpha, palette))
+
+print("\n5x7 with transparent corners")
+for palette in palettes: print(convert_img(img_5x7_alpha, palette))
+

src/pil2ansi.py

@@ -132,22 +132,25 @@ def convert_img(
                 if i < img.height - 1:
                     pixel_bg = pixels[(i + 1) * img.width + j]
                 else:
-                    pixel_bg = tuple(pixel_fg[:-1] + (0,)) # makebg transparent on last row
+                    pixel_bg = tuple(pixel_fg[:-1] + (0,)) # make bg transparent on last row
 
                 if alpha == False:
                     pixel_fg = tuple(pixel_fg[:-1] + (255,))
                     pixel_bg = tuple(pixel_bg[:-1] + (255,))
 
-                if pixel_fg[-1] == 0 and pixel_bg[-1] == 0:
+                if palette == Palettes.ascii: 
+                    if pixel_fg[-1] == 0:
+                        ascii_str += f"{reset_char}{transparent_char}"
+                    else:
+                        ascii_str += f"{reset_char}{palette.pixel_to_color(pixel_fg=pixel_fg, pixel_bg=pixel_fg)}"
+                elif pixel_fg[-1] == 0 and pixel_bg[-1] == 0:
                     ascii_str += f"{reset_char}{transparent_char}"
                 elif pixel_fg[-1] == 0:
                     ascii_str += f"{reset_char}{palette.pixel_to_color(pixel_fg=pixel_bg, pixel_bg=pixel_fg)}"
-                    if palette != Palettes.ascii:
-                        ascii_str += unicode_lower_char
+                    ascii_str += unicode_lower_char
                 else:
                     ascii_str += f"{reset_char}{palette.pixel_to_color(pixel_fg=pixel_fg, pixel_bg=pixel_bg)}"
-                    if palette != Palettes.ascii:
-                        ascii_str += unicode_upper_char
+                    ascii_str += unicode_upper_char
             else:
                 continue
 

tests/test_convert_img.py

@@ -17,6 +17,9 @@ class TestConvertImg:
     LA_red_alpha_upper_out: str = f"{reset_char}\033[38;5;238;48;1m{unicode_lower_char}"
     LA_red_alpha_lower_out: str = f"{reset_char}\033[38;5;238;48;1m{unicode_upper_char}"
 
+    ASCII_red_out: str = f"{reset_char}:"
+    ASCII_alpha_out: str = f"{reset_char} "
+
     end_row_out: str = f"{reset_char}\n"
 
     def test_convert_img_color_2x2(self):
@@ -95,13 +98,8 @@ def test_convert_img_color_alpha_5x7(self):
             + self.transparent_char
             + self.end_row_out
         )
+
         out = convert_img(img, Palettes.color, alpha=True)
-        print(repr(expected_out))
-        print("\n")
-        print(repr(out))
-        print(expected_out)
-        print("\n")
-        print(out)
 
         assert len(img.getdata()) == 35
         assert img.width == 5
@@ -116,5 +114,158 @@ def test_convert_img_grayscale_2x2(self):
         assert img.width == 2
         assert out == expected_out
 
+    def test_convert_img_grayscale_4x4(self):
+        img: Image.Image = Image.new("RGBA", (4, 4), (255, 0, 0, 255))
+        expected_out: str = (self.LA_red_out * 4 + self.end_row_out) * 2
+        out = convert_img(img, Palettes.grayscale)
+
+        assert len(img.getdata()) == 16
+        assert img.width == 4
+        assert out == expected_out
+
+    def test_convert_img_grayscale_5x7(self):
+        img: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
+        expected_out: str = (self.LA_red_out * 5 + self.end_row_out) * 3
+        expected_out += self.LA_red_end_row_out * 5 + self.end_row_out
+        out = convert_img(img, Palettes.grayscale)
+
+        assert len(img.getdata()) == 35
+        assert img.width == 5
+        assert out == expected_out
+
+    def test_convert_img_grayscale_alpha_4x4(self):
+        img: Image.Image = Image.new("RGBA", (4, 4), (255, 0, 0, 255))
+        img.putpixel((0, 0), (255, 0, 0, 0))
+        img.putpixel((0, 3), (255, 0, 0, 0))
+        img.putpixel((3, 0), (255, 0, 0, 0))
+        img.putpixel((3, 3), (255, 0, 0, 0))
+
+        expected_out: str = (
+            self.LA_red_alpha_upper_out 
+            + (self.LA_red_out * 2) 
+            + self.LA_red_alpha_upper_out  
+            + self.end_row_out
+        )
+        expected_out += (
+            self.LA_red_alpha_lower_out 
+            + (self.LA_red_out * 2) 
+            + self.LA_red_alpha_lower_out 
+            + self.end_row_out
+        )
+        out = convert_img(img, Palettes.grayscale, alpha=True)
 
+        assert len(img.getdata()) == 16
+        assert img.width == 4
+        assert out == expected_out
+
+    def test_convert_img_grayscale_alpha_5x7(self):
+        img: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
+        img.putpixel((0, 0), (255, 0, 0, 0))
+        img.putpixel((0, 6), (255, 0, 0, 0))
+        img.putpixel((4, 0), (255, 0, 0, 0))
+        img.putpixel((4, 6), (255, 0, 0, 0))
+
+        expected_out: str = (
+            self.LA_red_alpha_upper_out 
+            + (self.LA_red_out * 3) 
+            + self.LA_red_alpha_upper_out  
+            + self.end_row_out
+        )
+        expected_out += (
+            (self.LA_red_out * 5) 
+            + self.end_row_out
+        ) * 2
+        expected_out += (
+            self.transparent_char
+            + (self.LA_red_alpha_lower_out * 3) 
+            + self.transparent_char
+            + self.end_row_out
+        )
+
+        out = convert_img(img, Palettes.grayscale, alpha=True)
+
+        assert len(img.getdata()) == 35
+        assert img.width == 5
+        assert out == expected_out
+
+    def test_convert_img_ascii_2x2(self):
+        img: Image.Image = Image.new("RGBA", (2, 2), (255, 0, 0, 255))
+        expected_out: str = self.ASCII_red_out * 2 + self.end_row_out
+        out = convert_img(img, Palettes.ascii)
+
+        assert len(img.getdata()) == 4
+        assert img.width == 2
+        assert out == expected_out
+
+    def test_convert_img_ascii_4x4(self):
+        img: Image.Image = Image.new("RGBA", (4, 4), (255, 0, 0, 255))
+        expected_out: str = (self.ASCII_red_out * 4 + self.end_row_out) * 2
+        out = convert_img(img, Palettes.ascii)
+
+        assert len(img.getdata()) == 16
+        assert img.width == 4
+        assert out == expected_out
+
+    def test_convert_img_ascii_5x7(self):
+        img: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
+        expected_out: str = (self.ASCII_red_out * 5 + self.end_row_out) * 3
+        expected_out += self.ASCII_red_out * 5 + self.end_row_out
+        out = convert_img(img, Palettes.ascii)
+
+        assert len(img.getdata()) == 35
+        assert img.width == 5
+        assert out == expected_out
+
+    def test_convert_img_ascii_alpha_4x4(self):
+        img: Image.Image = Image.new("RGBA", (4, 4), (255, 0, 0, 255))
+        img.putpixel((0, 0), (255, 0, 0, 0))
+        img.putpixel((0, 3), (255, 0, 0, 0))
+        img.putpixel((3, 0), (255, 0, 0, 0))
+        img.putpixel((3, 3), (255, 0, 0, 0))
+
+        expected_out: str = (
+            self.ASCII_alpha_out 
+            + (self.ASCII_red_out * 2) 
+            + self.ASCII_alpha_out  
+            + self.end_row_out
+        )
+        expected_out += (
+            (self.ASCII_red_out * 4) 
+            + self.end_row_out
+        )
+        out = convert_img(img, Palettes.ascii, alpha=True)
+
+        assert len(img.getdata()) == 16
+        assert img.width == 4
+        assert out == expected_out
+
+    def test_convert_img_ascii_alpha_5x7(self):
+        img: Image.Image = Image.new("RGBA", (5, 7), (255, 0, 0, 255))
+        img.putpixel((0, 0), (255, 0, 0, 0))
+        img.putpixel((0, 6), (255, 0, 0, 0))
+        img.putpixel((4, 0), (255, 0, 0, 0))
+        img.putpixel((4, 6), (255, 0, 0, 0))
+
+        expected_out: str = (
+            self.ASCII_alpha_out 
+            + (self.ASCII_red_out * 3) 
+            + self.ASCII_alpha_out  
+            + self.end_row_out
+        )
+        expected_out += (
+            (self.ASCII_red_out * 5) 
+            + self.end_row_out
+        ) * 2
+        expected_out += (
+            self.ASCII_alpha_out
+            + (self.ASCII_red_out * 3) 
+            + self.ASCII_alpha_out
+            + self.end_row_out
+        )
+
+        out = convert_img(img, Palettes.ascii, alpha=True)
+
+        assert len(img.getdata()) == 35
+        assert img.width == 5
+        assert out == expected_out