Compare commits
No commits in common. "file-format" and "main" have entirely different histories.
file-forma
...
main
5
.gitignore
vendored
5
.gitignore
vendored
@ -1,5 +1,2 @@
|
||||
*.png
|
||||
*.jpg
|
||||
!sample-images/*
|
||||
__pycache__
|
||||
*.gif
|
||||
*.jpg
|
||||
23
CTIFC.py
23
CTIFC.py
@ -1,23 +0,0 @@
|
||||
# CTIF CLI
|
||||
|
||||
import argparse
|
||||
|
||||
from PIL import Image
|
||||
|
||||
import ctif
|
||||
|
||||
parser = argparse.ArgumentParser(description='Convert images to CTIF format.')
|
||||
parser.add_argument('image_path', type=str, help='Path to the input image file.')
|
||||
|
||||
def main():
|
||||
args = parser.parse_args()
|
||||
image_path = args.image_path
|
||||
|
||||
image = Image.open(image_path)
|
||||
ctif_image = ctif.CTIF(image)
|
||||
ctif_image.save_image('render.png')
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
||||
|
||||
@ -1,59 +0,0 @@
|
||||
import string
|
||||
|
||||
from PIL import Image
|
||||
|
||||
import pygame as pg
|
||||
|
||||
|
||||
|
||||
|
||||
FONT_PATH = 'fonts/scientifica.ttf'
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
CHARS = (string.ascii_letters + string.punctuation).replace('\\', '').replace('/', '').replace('|', '').replace('-', '')
|
||||
sorted_chars = {}
|
||||
|
||||
for c in CHARS:
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
|
||||
font_w, font_h = font.size(c)
|
||||
|
||||
window = pg.display.set_mode((font_w, font_h))
|
||||
|
||||
rendered_char = font.render(c, False, (255, 255, 255))
|
||||
|
||||
window.blit(rendered_char, (0, 0))
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, 'temp.png')
|
||||
|
||||
pg.quit()
|
||||
|
||||
image = Image.open('temp.png')
|
||||
|
||||
w, h = image.size
|
||||
|
||||
white = 0
|
||||
for pixel_y in range(h):
|
||||
for pixel_x in range(w):
|
||||
pixel = image.getpixel((pixel_x, pixel_y))
|
||||
|
||||
if pixel == (255, 255, 255):
|
||||
white += 1
|
||||
|
||||
sorted_chars[c] = white/(w * h)
|
||||
|
||||
sorted_chars = dict(sorted(sorted_chars.items(), key=lambda item: item[1]))
|
||||
|
||||
chr_str = ''
|
||||
for k, v in sorted_chars.items():
|
||||
chr_str += k
|
||||
|
||||
print(chr_str)
|
||||
|
||||
|
||||
359
ctif.py
359
ctif.py
@ -1,359 +0,0 @@
|
||||
import colorsys
|
||||
import logging
|
||||
import math
|
||||
import os
|
||||
|
||||
from rich.console import Console
|
||||
from PIL import Image, ImageFilter
|
||||
import pygame as pg
|
||||
|
||||
import filters
|
||||
|
||||
logging.getLogger(__name__)
|
||||
|
||||
FONT_PATH = 'fonts/scientifica.ttf'
|
||||
|
||||
TEXT_WIDTH = 6 # on font size 12 monocraft medium
|
||||
TEXT_HEIGHT = 11
|
||||
|
||||
SCALE_FACTOR = 1
|
||||
RESIZE_FACTOR = 0.75
|
||||
|
||||
SCALED_WIDTH = TEXT_WIDTH // SCALE_FACTOR
|
||||
SCALED_HEIGHT = TEXT_HEIGHT // SCALE_FACTOR
|
||||
|
||||
DEBUG = True
|
||||
ANTI_ALIASING = False
|
||||
|
||||
if not os.path.exists('./debug/') and DEBUG:
|
||||
os.makedirs('./debug')
|
||||
|
||||
# '█@?OPoci. '
|
||||
CHARS = list(reversed([
|
||||
u'█',
|
||||
'@',
|
||||
'?',
|
||||
'O',
|
||||
'P',
|
||||
'o',
|
||||
'c',
|
||||
'i',
|
||||
'.',
|
||||
' '
|
||||
]))
|
||||
|
||||
NEW_CHARS = ' .:\',`;_<^~%>"?!ir=clsxzL}ovCS(+eknuFJfj{amwPZtIT)*hbdpqyEGKOVXYgU&ABDHQR[]MNW@$#'
|
||||
|
||||
EDGE_CHARS = '-\\|/'
|
||||
|
||||
ALL_CHARS = [
|
||||
u'█',
|
||||
'@',
|
||||
'?',
|
||||
'O',
|
||||
'P',
|
||||
'o',
|
||||
'c',
|
||||
'i',
|
||||
'.',
|
||||
' ',
|
||||
'|',
|
||||
'/',
|
||||
'-',
|
||||
'\\'
|
||||
]
|
||||
|
||||
# Character Text Image Format
|
||||
class CTIF:
|
||||
colors: list
|
||||
text: str
|
||||
width: int
|
||||
height: int
|
||||
|
||||
def __init__(self, image: Image.Image | None = None):
|
||||
self.colors = []
|
||||
self.text = ""
|
||||
self.width = 0
|
||||
self.height = 0
|
||||
|
||||
if image:
|
||||
self.convert(image)
|
||||
|
||||
def convert(self, image: Image.Image) -> None:
|
||||
if image.mode != 'RGB':
|
||||
image = image.convert('RGB')
|
||||
|
||||
image = image.resize((int(image.width * RESIZE_FACTOR), int(image.height * RESIZE_FACTOR)))
|
||||
logging.debug(f'Image Size: {image.size}')
|
||||
|
||||
L_image = image.convert('L')
|
||||
# logging.debug(f'L_image Size: {L_image.size}')
|
||||
|
||||
dog = filters.difference_of_gaussians(image, blur_strength_2=1)
|
||||
# logging.debug(f'Dog Size: {dog.size}')
|
||||
|
||||
dog.save('debug/dog.png')
|
||||
|
||||
sb, gradient = filters.sobel(dog)
|
||||
# image = image.convert('HSV')
|
||||
|
||||
w, h = sb.size
|
||||
|
||||
sb.save('debug/sobel.png')
|
||||
|
||||
text_grid_width = w // SCALED_WIDTH
|
||||
self.width = text_grid_width
|
||||
|
||||
text_grind_height = h // SCALED_HEIGHT
|
||||
self.height = text_grind_height
|
||||
y_offset = 0
|
||||
|
||||
for y in range(math.floor(h / SCALED_HEIGHT)):
|
||||
x_offset = 0
|
||||
|
||||
for x in range(math.floor(w / SCALED_WIDTH)):
|
||||
histogram = {}
|
||||
|
||||
# Collect the most common char for a group of pixels
|
||||
color = []
|
||||
|
||||
for y2 in range(SCALED_HEIGHT):
|
||||
for x2 in range(SCALED_WIDTH):
|
||||
real_x = x2 + x_offset
|
||||
real_y = y2 + y_offset
|
||||
|
||||
r, g, b = image.getpixel((real_x, real_y))
|
||||
color.append((r, g, b))
|
||||
h, s, v = colorsys.rgb_to_hsv(r, g, b)
|
||||
# print(h, s, v)
|
||||
|
||||
|
||||
gradient_v = gradient[real_y * w + real_x]
|
||||
|
||||
char = ' '
|
||||
|
||||
if gradient_v:
|
||||
char = self._match_gradient(gradient_v)
|
||||
else:
|
||||
char = NEW_CHARS[round(v/(255/len(NEW_CHARS))) - 1]
|
||||
|
||||
if char in histogram:
|
||||
histogram[char] += 1
|
||||
else:
|
||||
histogram[char] = 1
|
||||
|
||||
r, g, b = filters.average_colors(color)
|
||||
color_avg_hsv = colorsys.rgb_to_hsv(r/255, g/255, b/255)
|
||||
self.colors.append(color_avg_hsv)
|
||||
|
||||
# get most common
|
||||
most_common = None
|
||||
score = float('-inf')
|
||||
for char in histogram:
|
||||
if histogram[char] > score:
|
||||
score = histogram[char]
|
||||
most_common = char
|
||||
|
||||
self.text += str(most_common)
|
||||
|
||||
x_offset += SCALED_WIDTH
|
||||
|
||||
y_offset += SCALED_HEIGHT
|
||||
|
||||
# TODO @0x01FE : refactor plz increment by 30 & 60
|
||||
def _match_gradient(self, n: float) -> str:
|
||||
|
||||
n = abs(n)
|
||||
|
||||
if n < math.radians(30):
|
||||
return '|'
|
||||
elif n < math.radians(60):
|
||||
return '/'
|
||||
elif n < math.radians(120):
|
||||
return '-'
|
||||
elif n < math.radians(150):
|
||||
return '\\'
|
||||
elif n < math.radians(210):
|
||||
return '|'
|
||||
elif n < math.radians(240):
|
||||
return '/'
|
||||
elif n < math.radians(300):
|
||||
return '-'
|
||||
elif n < math.radians(330):
|
||||
return '\\'
|
||||
else:
|
||||
return '|'
|
||||
|
||||
def render(self) -> None:
|
||||
console = Console()
|
||||
for i, (color, char) in enumerate(zip(self.colors, self.text)):
|
||||
|
||||
hex_color = '#%x%x%x' % color
|
||||
|
||||
console.print(f'[{hex_color}]{char}', end='')
|
||||
|
||||
if i + 1 % self.width == 0:
|
||||
print()
|
||||
|
||||
def save_image(self, path: str) -> None:
|
||||
logging.debug('Rendering and Saving image...')
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
|
||||
window = pg.display.set_mode((self.width * TEXT_WIDTH, self.height * TEXT_HEIGHT))
|
||||
|
||||
x, y = 0, 0
|
||||
logging.debug(f'Rendering CITF Image with Dim: ({self.width}, {self.height})')
|
||||
for (color, char) in zip(self.colors, self.text):
|
||||
h, s, v = color
|
||||
if char not in EDGE_CHARS:
|
||||
v = (NEW_CHARS.find(char) + 1) * (255/len(NEW_CHARS))/255
|
||||
|
||||
# logging.debug(f'HSV Color: {h, s, v}')
|
||||
|
||||
# Make the bright colors brighter and the darks darker
|
||||
# if v <= 0.4:
|
||||
# v *= 1.5
|
||||
|
||||
|
||||
r, g, b = colorsys.hsv_to_rgb(h, s, v)
|
||||
|
||||
|
||||
# logging.debug(f'RGB Color Before: {r, g, b}')
|
||||
r *= 255
|
||||
g *= 255
|
||||
b *= 255
|
||||
|
||||
r = min(r, 255)
|
||||
g = min(g, 255)
|
||||
b = min(b, 255)
|
||||
# logging.debug(f'RGB Color: {r, g, b}')
|
||||
rendered_char = font.render(char, ANTI_ALIASING, (int(r), int(g), int(b)))
|
||||
window.blit(rendered_char, (x * TEXT_WIDTH, y * TEXT_HEIGHT))
|
||||
|
||||
x += 1
|
||||
|
||||
if x >= self.width:
|
||||
x = 0
|
||||
y += 1
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, path)
|
||||
pg.quit()
|
||||
|
||||
def save_edges(self, path: str) -> None:
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
|
||||
window = pg.display.set_mode((self.width * TEXT_WIDTH, self.height * TEXT_HEIGHT))
|
||||
|
||||
x, y = 0, 0
|
||||
logging.debug(f'Rendering CITF Image with Dim: ({self.width}, {self.height})')
|
||||
for (color, char) in zip(self.colors, self.text):
|
||||
|
||||
if char in EDGE_CHARS:
|
||||
|
||||
h, s, v = color
|
||||
new_color = colorsys.hsv_to_rgb(h, s, 255)
|
||||
|
||||
# print(color)
|
||||
rendered_char = font.render(char, ANTI_ALIASING, new_color)
|
||||
window.blit(rendered_char, (x * TEXT_WIDTH, y * TEXT_HEIGHT))
|
||||
|
||||
x += 1
|
||||
|
||||
if x >= self.width:
|
||||
x = 0
|
||||
y += 1
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, path)
|
||||
pg.quit()
|
||||
|
||||
def save_citf(self, filename: str) -> None:
|
||||
# 1 byte for h, 1 byte for s, 1 byte for character which will be interperated as v when rendering
|
||||
|
||||
bin = bytes()
|
||||
|
||||
# Save Width and Height
|
||||
bin += self.width.to_bytes(2, 'big')
|
||||
bin += self.height.to_bytes(2, 'big')
|
||||
|
||||
for (color, char) in zip(self.colors, self.text):
|
||||
|
||||
h, s, v = color
|
||||
|
||||
h = min(int(h * 255), 255)
|
||||
bin += h.to_bytes(1, 'big')
|
||||
|
||||
s = min(int(s * 255), 255)
|
||||
bin += s.to_bytes(1, 'big')
|
||||
|
||||
# for n in (h, s):
|
||||
# i = int(n * 255)
|
||||
|
||||
# bin += i.to_bytes(1, 'big')
|
||||
|
||||
char_index = (NEW_CHARS + EDGE_CHARS).index(char)
|
||||
|
||||
bin += char_index.to_bytes(1, 'big')
|
||||
if char in EDGE_CHARS:
|
||||
v = min(int(v * 255), 255)
|
||||
bin += v.to_bytes(1, 'big')
|
||||
|
||||
with open(f'{filename}.citf', 'wb+') as file:
|
||||
file.write(bin)
|
||||
|
||||
def read_citf(self, filepath: str) -> None:
|
||||
self.text = ''
|
||||
self.colors = []
|
||||
|
||||
with open(filepath, 'rb') as file:
|
||||
data = file.read()
|
||||
|
||||
# Get Width and Height
|
||||
self.width = int.from_bytes(data[:2], 'big')
|
||||
self.height = int.from_bytes(data[2:4], 'big')
|
||||
|
||||
data = data[4:]
|
||||
|
||||
if len(data) % 3 != 0:
|
||||
logging.error(f"File is bad size. {len(data)}")
|
||||
|
||||
# Read colors and characters
|
||||
i = 0
|
||||
for n in range(1, (int(len(data)/3)) + 1):
|
||||
|
||||
d = data[i:i + 3]
|
||||
|
||||
# print(f'index: {i}')
|
||||
# print(f'index end: {i + 3}')
|
||||
# print(f'data: {d}')
|
||||
|
||||
h = d[0:1]
|
||||
h = int.from_bytes(h, 'big')
|
||||
|
||||
s = d[1:2]
|
||||
s = int.from_bytes(s, 'big')
|
||||
|
||||
|
||||
char_n = d[2:3]
|
||||
char_n = int.from_bytes(char_n, 'big')
|
||||
# print(char_n)
|
||||
char = (NEW_CHARS + EDGE_CHARS)[char_n]
|
||||
|
||||
logging.debug(f'H: {h}, S: {s}, Char: {char}')
|
||||
self.text += char
|
||||
|
||||
if char in EDGE_CHARS:
|
||||
v = d[i+3:i+4]
|
||||
|
||||
v = int.from_bytes(v, 'big')
|
||||
|
||||
self.colors.append((h/255, s/255, v/255))
|
||||
|
||||
i += 4
|
||||
|
||||
else:
|
||||
self.colors.append((h/255, s/255, 255))
|
||||
i += 3
|
||||
BIN
engine.citf
BIN
engine.citf
Binary file not shown.
90
filters.py
90
filters.py
@ -1,90 +0,0 @@
|
||||
import logging
|
||||
|
||||
from PIL import Image, ImageFilter
|
||||
import scipy.signal
|
||||
import numpy as np
|
||||
|
||||
logging.getLogger(__name__)
|
||||
|
||||
sobel_x_kernel = np.array((
|
||||
(1, 0, -1),
|
||||
(2, 0, -2),
|
||||
(1, 0, -1)
|
||||
))
|
||||
|
||||
sobel_y_kernel = np.transpose(sobel_x_kernel)
|
||||
|
||||
def difference_of_gaussians(img: Image.Image, blur_strength_1: float | None = 1.0, blur_strength_2: float | None = 1.2, threshold: int | None = 128*3) -> Image.Image:
|
||||
blur_1 = img.filter(ImageFilter.GaussianBlur(blur_strength_1))
|
||||
blur_2 = img.filter(ImageFilter.GaussianBlur(blur_strength_2))
|
||||
|
||||
w, h = img.size
|
||||
|
||||
dog = Image.new(img.mode, img.size)
|
||||
|
||||
for pixel_y in range(h):
|
||||
for pixel_x in range(w):
|
||||
|
||||
coords = (pixel_x, pixel_y)
|
||||
|
||||
p1 = blur_1.getpixel(coords)
|
||||
p2 = blur_2.getpixel(coords)
|
||||
|
||||
p1 = np.array(p1)
|
||||
p2 = np.array(p2)
|
||||
new_pixel = p2 - p1
|
||||
|
||||
# if new_pixel.sum() < threshold:
|
||||
# new_pixel = np.zeros(3).astype(np.uint8)
|
||||
|
||||
dog.putpixel(coords, tuple(new_pixel.tolist()))
|
||||
|
||||
return dog
|
||||
|
||||
def sobel(img: Image.Image, gradient_threshold: int | None = 20) -> tuple[Image.Image, np.ndarray]:
|
||||
logging.debug(img.size)
|
||||
|
||||
img = img.convert('L')
|
||||
img.save('debug/test-L.png')
|
||||
|
||||
logging.debug('Sobel Operator')
|
||||
|
||||
logging.debug(img.size)
|
||||
|
||||
pixels = np.array(img)
|
||||
logging.debug(f'pixels size: {pixels.size}')
|
||||
|
||||
dx = scipy.signal.correlate(pixels, sobel_x_kernel, mode='same')
|
||||
dy = scipy.signal.correlate(pixels, sobel_y_kernel, mode='same')
|
||||
logging.debug(f'dx size: {dx.size}')
|
||||
|
||||
edges = np.sqrt(np.square(dx) + np.square(dy))
|
||||
edges[edges>255] = 255
|
||||
|
||||
logging.debug(f'edges size: {edges.size}')
|
||||
|
||||
gradient = np.arctan2(dy.flatten(), dx.flatten())
|
||||
gradient = np.absolute(gradient)
|
||||
print(gradient)
|
||||
print(np.average(gradient))
|
||||
gradient[gradient > gradient_threshold] = 0
|
||||
|
||||
pil_edges = edges.astype(np.uint8)
|
||||
newimg = Image.fromarray(pil_edges, mode='L')
|
||||
logging.debug(f'New Img Size: {newimg.size}')
|
||||
|
||||
return (newimg, gradient)
|
||||
|
||||
def average_colors(colors: list) -> tuple:
|
||||
colors = np.array(colors)
|
||||
|
||||
np.average(colors)
|
||||
|
||||
sum = np.zeros(len(colors[0]))
|
||||
for c in colors:
|
||||
sum += c
|
||||
|
||||
sum /= len(colors)
|
||||
|
||||
return tuple(sum.astype(np.uint8).tolist())
|
||||
|
||||
25
main.py
25
main.py
@ -1,25 +0,0 @@
|
||||
import logging
|
||||
|
||||
from PIL import Image
|
||||
import ctif
|
||||
|
||||
|
||||
FORMAT = "%(levelname)s %(filename)s - %(message)s"
|
||||
logging.basicConfig(level=logging.DEBUG, format=FORMAT)
|
||||
|
||||
IMAGE_PATH = 'game_screenshots/deadwell-banner.jpg'
|
||||
|
||||
def main():
|
||||
|
||||
image = Image.open(IMAGE_PATH)
|
||||
i = ctif.CTIF(image)
|
||||
# i.save_citf('engine')
|
||||
# i.read_citf('engine.citf')
|
||||
i.save_image('C:/Users/Jacks/Documents/code/My-Website/app/static/render.png')
|
||||
i.save_edges('debug/edges-render.png')
|
||||
# i.save_image('render.png')
|
||||
# i.save_citf('engine')
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
||||
@ -1,220 +1,352 @@
|
||||
import logging
|
||||
import math
|
||||
import os
|
||||
|
||||
from PIL import Image
|
||||
import pygame as pg
|
||||
|
||||
import filters
|
||||
|
||||
logging.getLogger(__name__)
|
||||
|
||||
FONT_PATH = 'fonts/scientifica.ttf'
|
||||
|
||||
TEXT_WIDTH = 6 # on font size 12 monocraft medium
|
||||
TEXT_HEIGHT = 11
|
||||
|
||||
SCALE_FACTOR = 2
|
||||
RESIZE_FACTOR = 2
|
||||
|
||||
SCALED_WIDTH = TEXT_WIDTH // SCALE_FACTOR
|
||||
SCALED_HEIGHT = TEXT_HEIGHT // SCALE_FACTOR
|
||||
|
||||
DEBUG = True
|
||||
|
||||
if not os.path.exists('./debug/') and DEBUG:
|
||||
os.makedirs('./debug')
|
||||
|
||||
# '█@?OPoci. '
|
||||
CHARS = list(reversed([
|
||||
u'█',
|
||||
'@',
|
||||
'?',
|
||||
'O',
|
||||
'P',
|
||||
'o',
|
||||
'c',
|
||||
'i',
|
||||
'.',
|
||||
' '
|
||||
]))
|
||||
|
||||
|
||||
def asciify(image: Image.Image) -> str:
|
||||
|
||||
image = image.resize((image.width * RESIZE_FACTOR, image.height * RESIZE_FACTOR))
|
||||
logging.debug(f'Image Size: {image.size}')
|
||||
|
||||
L_image = image.convert('L')
|
||||
logging.debug(f'L_image Size: {L_image.size}')
|
||||
|
||||
dog = filters.difference_of_gaussians(image)
|
||||
logging.debug(f'Dog Size: {dog.size}')
|
||||
|
||||
dog.save('dog.png')
|
||||
|
||||
sb, gradient = filters.sobel(dog)
|
||||
|
||||
w, h = sb.size
|
||||
|
||||
sb.save('sobel.png')
|
||||
|
||||
text_grid_width = w / SCALED_WIDTH
|
||||
text_grind_height = h / SCALED_HEIGHT
|
||||
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
window = pg.display.set_mode((text_grid_width * TEXT_WIDTH, text_grind_height * TEXT_HEIGHT))
|
||||
|
||||
y_offset = 0
|
||||
|
||||
for y in range(math.floor(h / SCALED_HEIGHT)):
|
||||
x_offset = 0
|
||||
|
||||
for x in range(math.floor(w / SCALED_WIDTH)):
|
||||
histogram = {}
|
||||
|
||||
# Collect the most common char for a group of pixels
|
||||
colors = []
|
||||
|
||||
for y2 in range(SCALED_HEIGHT):
|
||||
for x2 in range(SCALED_WIDTH):
|
||||
|
||||
real_x = x2 + x_offset
|
||||
real_y = y2 + y_offset
|
||||
|
||||
gradient_v = gradient[real_y * w + real_x]
|
||||
|
||||
char = ' '
|
||||
|
||||
if gradient_v:
|
||||
char = match_gradient(gradient_v)
|
||||
else:
|
||||
char = CHARS[round(L_image.getpixel((real_x, real_y))/(255/len(CHARS))) - 1]
|
||||
|
||||
if char in histogram:
|
||||
histogram[char] += 1
|
||||
else:
|
||||
histogram[char] = 1
|
||||
|
||||
colors.append(image.getpixel((real_x, real_y)))
|
||||
|
||||
color_avg = average_colors(colors)
|
||||
|
||||
# get most common
|
||||
most_common = None
|
||||
score = float('-inf')
|
||||
for char in histogram:
|
||||
if histogram[char] > score:
|
||||
score = histogram[char]
|
||||
most_common = char
|
||||
|
||||
rendered_char = font.render(str(most_common), True, color_avg)
|
||||
window.blit(rendered_char, (x * TEXT_WIDTH, y * TEXT_HEIGHT))
|
||||
|
||||
x_offset += SCALED_WIDTH
|
||||
|
||||
y_offset += SCALED_HEIGHT
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, "render.png")
|
||||
pg.quit()
|
||||
|
||||
if DEBUG:
|
||||
sb.save('debug/sobel-dog.png')
|
||||
dog.save('debug/dog.png')
|
||||
|
||||
# Draw only the ASCII edges
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
window = pg.display.set_mode((text_grid_width * TEXT_WIDTH, text_grind_height * TEXT_HEIGHT))
|
||||
|
||||
y_offset = 0
|
||||
|
||||
for y in range(math.floor(h / SCALED_HEIGHT)):
|
||||
x_offset = 0
|
||||
|
||||
for x in range(math.floor(w / SCALED_WIDTH)):
|
||||
histogram = {}
|
||||
|
||||
# Collect the most common char for a group of pixels
|
||||
colors = []
|
||||
|
||||
for y2 in range(SCALED_HEIGHT):
|
||||
for x2 in range(SCALED_WIDTH):
|
||||
|
||||
real_x = x2 + x_offset
|
||||
real_y = y2 + y_offset
|
||||
|
||||
gradient_v = gradient[real_y * w + real_x]
|
||||
|
||||
char = ' '
|
||||
|
||||
if gradient_v:
|
||||
char = match_gradient(gradient_v)
|
||||
else:
|
||||
char = ' '
|
||||
|
||||
if char in histogram:
|
||||
histogram[char] += 1
|
||||
else:
|
||||
histogram[char] = 1
|
||||
|
||||
colors.append(image.getpixel((real_x, real_y)))
|
||||
|
||||
color_avg = average_colors(colors)
|
||||
|
||||
# get most common
|
||||
most_common = None
|
||||
score = float('-inf')
|
||||
for char in histogram:
|
||||
if histogram[char] > score:
|
||||
score = histogram[char]
|
||||
most_common = char
|
||||
|
||||
rendered_char = font.render(most_common, True, color_avg)
|
||||
window.blit(rendered_char, (x * TEXT_WIDTH, y * TEXT_HEIGHT))
|
||||
|
||||
x_offset += SCALED_WIDTH
|
||||
|
||||
y_offset += SCALED_HEIGHT
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, "debug/edges-render.png")
|
||||
pg.quit()
|
||||
|
||||
# TODO @0x01FE : refactor plz increment by 30 & 60
|
||||
def match_gradient(n: float) -> str:
|
||||
|
||||
n = abs(n)
|
||||
|
||||
if n < math.radians(30):
|
||||
return '|'
|
||||
elif n < math.radians(60):
|
||||
return '/'
|
||||
elif n < math.radians(120):
|
||||
return '-'
|
||||
elif n < math.radians(150):
|
||||
return '\\'
|
||||
elif n < math.radians(210):
|
||||
return '|'
|
||||
elif n < math.radians(240):
|
||||
return '/'
|
||||
elif n < math.radians(300):
|
||||
return '-'
|
||||
elif n < math.radians(330):
|
||||
return '\\'
|
||||
else:
|
||||
return '|'
|
||||
|
||||
def average_colors(colors: list):
|
||||
avg = [0 for x in range(len(colors[0]))]
|
||||
|
||||
for color in colors:
|
||||
for i, num in enumerate(color):
|
||||
avg[i] += num
|
||||
|
||||
for i, n in enumerate(avg):
|
||||
avg[i] /= len(colors)
|
||||
|
||||
return avg
|
||||
# import scipy.ndimage as nd
|
||||
# import imageio.v3 as iio
|
||||
# import numpy as np
|
||||
import math
|
||||
import os
|
||||
|
||||
from PIL import Image, ImageFilter
|
||||
import pygame as pg
|
||||
|
||||
IMAGE_PATH = 'sample-images/sunflower.jpg'
|
||||
FONT_PATH = 'fonts/scientifica.ttf'
|
||||
|
||||
BLUR_STRENGTH_1 = 1
|
||||
BLUR_STRENGTH_2 = 1.2
|
||||
|
||||
DOG_THRESHOLD = 8
|
||||
|
||||
WHITE = (255,255,255)
|
||||
|
||||
TEXT_WIDTH = 6 # on font size 12 monocraft medium
|
||||
TEXT_HEIGHT = 11
|
||||
|
||||
SCALE_FACTOR = 2
|
||||
RESIZE_FACTOR = 2
|
||||
|
||||
SCALED_WIDTH = math.floor(TEXT_WIDTH / SCALE_FACTOR)
|
||||
SCALED_HEIGHT = math.floor(TEXT_HEIGHT / SCALE_FACTOR)
|
||||
|
||||
DEBUG = True
|
||||
|
||||
if not os.path.exists('./debug/') and DEBUG:
|
||||
os.makedirs('./debug')
|
||||
|
||||
# '█@?OPoci. '
|
||||
CHARS = list(reversed([
|
||||
u'█',
|
||||
'@',
|
||||
'?',
|
||||
'O',
|
||||
'P',
|
||||
'o',
|
||||
'c',
|
||||
'i',
|
||||
'.',
|
||||
' '
|
||||
]))
|
||||
|
||||
def main():
|
||||
|
||||
image = Image.open(IMAGE_PATH)
|
||||
image = image.resize((image.width * RESIZE_FACTOR, image.height * RESIZE_FACTOR))
|
||||
|
||||
L_image = image.convert('L')
|
||||
|
||||
blur_1 = image.filter(ImageFilter.GaussianBlur(BLUR_STRENGTH_1))
|
||||
blur_2 = image.filter(ImageFilter.GaussianBlur(BLUR_STRENGTH_2))
|
||||
|
||||
|
||||
print(image.size)
|
||||
dog: Image = difference_of_gaussians(blur_1, blur_2)
|
||||
|
||||
dog.save('dog.png')
|
||||
|
||||
sb, gradient = sobel(dog)
|
||||
|
||||
w, h = sb.size
|
||||
|
||||
sb.save('sobel.png')
|
||||
|
||||
text_grid_width = w / SCALED_WIDTH
|
||||
text_grind_height = h / SCALED_HEIGHT
|
||||
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
window = pg.display.set_mode((text_grid_width * TEXT_WIDTH, text_grind_height * TEXT_HEIGHT))
|
||||
|
||||
y_offset = 0
|
||||
|
||||
for y in range(math.floor(h / SCALED_HEIGHT)):
|
||||
x_offset = 0
|
||||
|
||||
for x in range(math.floor(w / SCALED_WIDTH)):
|
||||
histogram = {}
|
||||
|
||||
# Collect the most common char for a group of pixels
|
||||
colors = []
|
||||
|
||||
for y2 in range(SCALED_HEIGHT):
|
||||
for x2 in range(SCALED_WIDTH):
|
||||
|
||||
real_x = x2 + x_offset
|
||||
real_y = y2 + y_offset
|
||||
|
||||
gradient_v = gradient[real_y * w + real_x]
|
||||
|
||||
char = ' '
|
||||
|
||||
if gradient_v:
|
||||
char = match_gradient(gradient_v)
|
||||
else:
|
||||
char = CHARS[round(L_image.getpixel((real_x, real_y))/(255/len(CHARS))) - 1]
|
||||
|
||||
if char in histogram:
|
||||
histogram[char] += 1
|
||||
else:
|
||||
histogram[char] = 1
|
||||
|
||||
colors.append(image.getpixel((real_x, real_y)))
|
||||
|
||||
color_avg = average_colors(colors)
|
||||
|
||||
# get most common
|
||||
most_common = None
|
||||
score = float('-inf')
|
||||
for char in histogram:
|
||||
if histogram[char] > score:
|
||||
score = histogram[char]
|
||||
most_common = char
|
||||
|
||||
rendered_char = font.render(str(most_common), True, color_avg)
|
||||
window.blit(rendered_char, (x * TEXT_WIDTH, y * TEXT_HEIGHT))
|
||||
|
||||
x_offset += SCALED_WIDTH
|
||||
|
||||
y_offset += SCALED_HEIGHT
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, "render.png")
|
||||
pg.quit()
|
||||
|
||||
if DEBUG:
|
||||
sb.save('debug/sobel-dog.png')
|
||||
dog.save('debug/dog.png')
|
||||
|
||||
# Draw only the ASCII edges
|
||||
pg.init()
|
||||
font = pg.font.Font(FONT_PATH, 12)
|
||||
window = pg.display.set_mode((text_grid_width * TEXT_WIDTH, text_grind_height * TEXT_HEIGHT))
|
||||
|
||||
y_offset = 0
|
||||
|
||||
for y in range(math.floor(h / SCALED_HEIGHT)):
|
||||
x_offset = 0
|
||||
|
||||
for x in range(math.floor(w / SCALED_WIDTH)):
|
||||
histogram = {}
|
||||
|
||||
# Collect the most common char for a group of pixels
|
||||
colors = []
|
||||
|
||||
for y2 in range(SCALED_HEIGHT):
|
||||
for x2 in range(SCALED_WIDTH):
|
||||
|
||||
real_x = x2 + x_offset
|
||||
real_y = y2 + y_offset
|
||||
|
||||
gradient_v = gradient[real_y * w + real_x]
|
||||
|
||||
char = ' '
|
||||
|
||||
if gradient_v:
|
||||
char = match_gradient(gradient_v)
|
||||
else:
|
||||
char = ' '
|
||||
|
||||
if char in histogram:
|
||||
histogram[char] += 1
|
||||
else:
|
||||
histogram[char] = 1
|
||||
|
||||
colors.append(image.getpixel((real_x, real_y)))
|
||||
|
||||
color_avg = average_colors(colors)
|
||||
|
||||
# get most common
|
||||
most_common = None
|
||||
score = float('-inf')
|
||||
for char in histogram:
|
||||
if histogram[char] > score:
|
||||
score = histogram[char]
|
||||
most_common = char
|
||||
|
||||
rendered_char = font.render(most_common, True, color_avg)
|
||||
window.blit(rendered_char, (x * TEXT_WIDTH, y * TEXT_HEIGHT))
|
||||
|
||||
x_offset += SCALED_WIDTH
|
||||
|
||||
y_offset += SCALED_HEIGHT
|
||||
|
||||
pg.display.update()
|
||||
pg.image.save(window, "debug/edges-render.png")
|
||||
pg.quit()
|
||||
|
||||
|
||||
|
||||
|
||||
def subtract_colors(t1: tuple, t2: tuple) -> tuple:
|
||||
|
||||
if type(t1) != tuple:
|
||||
if (t2 - t1) >= DOG_THRESHOLD:
|
||||
return t2 - t1
|
||||
else:
|
||||
return 0
|
||||
|
||||
if len(t1) != len(t2):
|
||||
print('Len of first tuple should equal second tuple probably')
|
||||
exit(1)
|
||||
|
||||
ans = []
|
||||
for i, n in enumerate(t1):
|
||||
ans.append(t2[i] - n)
|
||||
|
||||
return tuple(ans)
|
||||
|
||||
def difference_of_gaussians(blur_1: Image, blur_2: Image) -> Image:
|
||||
|
||||
w, h = blur_1.size
|
||||
|
||||
dog = Image.new(blur_1.mode, blur_1.size)
|
||||
|
||||
for pixel_y in range(0, h):
|
||||
for pixel_x in range(0, w):
|
||||
|
||||
coords = (pixel_x, pixel_y)
|
||||
|
||||
dog.putpixel(coords, subtract_colors(blur_2.getpixel(coords), blur_1.getpixel(coords)))
|
||||
|
||||
return dog
|
||||
|
||||
# Taken from
|
||||
# https://enzoftware.github.io/posts/image-filter-python
|
||||
def sobel(img: Image) -> tuple[Image.Image, list]:
|
||||
if img.mode == 'L':
|
||||
# return sobel_L(img)
|
||||
pass
|
||||
img = img.convert('RGB')
|
||||
|
||||
width, height = img.size
|
||||
|
||||
newimg = Image.new("RGB", (width, height), "white")
|
||||
gradient = [None for x in range(0, width * height)]
|
||||
for x in range(1, width - 1): # ignore the edge pixels for simplicity (1 to width-1)
|
||||
for y in range(1, height - 1): # ignore edge pixels for simplicity (1 to height-1)
|
||||
|
||||
# initialise Gx to 0 and Gy to 0 for every pixel
|
||||
Gx = 0
|
||||
Gy = 0
|
||||
|
||||
# top left pixel
|
||||
r, g, b = img.getpixel((x - 1, y - 1))
|
||||
|
||||
# intensity ranges from 0 to 765 (255 * 3)
|
||||
intensity = r + g + b
|
||||
|
||||
# accumulate the value into Gx, and Gy
|
||||
Gx += -intensity
|
||||
Gy += -intensity
|
||||
|
||||
# remaining left column
|
||||
r, g, b = img.getpixel((x-1, y))
|
||||
|
||||
Gx += -2 * (r + g + b)
|
||||
|
||||
r, g, b = img.getpixel((x-1, y+1))
|
||||
|
||||
Gx += -(r + g + b)
|
||||
Gy += (r + g + b)
|
||||
|
||||
# middle pixels
|
||||
r, g, b = img.getpixel((x, y-1))
|
||||
|
||||
Gy += -2 * (r + g + b)
|
||||
|
||||
r, g, b = img.getpixel((x, y+1))
|
||||
|
||||
Gy += 2 * (r + g + b)
|
||||
|
||||
# right column
|
||||
r, g, b = img.getpixel((x+1, y-1))
|
||||
|
||||
Gx += (r + g + b)
|
||||
Gy += -(r + g + b)
|
||||
|
||||
r, g, b = img.getpixel((x+1, y))
|
||||
|
||||
Gx += 2 * (r + g + b)
|
||||
|
||||
r, g, b = img.getpixel((x+1, y+1))
|
||||
|
||||
Gx += (r + g + b)
|
||||
Gy += (r + g + b)
|
||||
|
||||
# calculate the length of the gradient (Pythagorean theorem)
|
||||
length = math.sqrt((Gx * Gx) + (Gy * Gy))
|
||||
|
||||
# normalise the length of gradient to the range 0 to 255
|
||||
length = length / 4328 * 255
|
||||
|
||||
length = int(length)
|
||||
gradient_v = math.atan2(Gy, Gx)
|
||||
# print(gradient_v)
|
||||
|
||||
# draw the length in the edge image
|
||||
#newpixel = img.putpixel((length,length,length))
|
||||
newimg.putpixel((x,y),(length,length,length))
|
||||
if length < 20:
|
||||
gradient[y * width + x] = gradient_v
|
||||
|
||||
return (newimg, gradient)
|
||||
|
||||
def sobel_L(img: Image) -> tuple[Image.Image, list]:
|
||||
pass
|
||||
|
||||
# TODO @0x01FE : refactor plz increment by 30 & 60
|
||||
def match_gradient(n: float) -> str:
|
||||
|
||||
n = abs(n)
|
||||
|
||||
if n < math.radians(30):
|
||||
return '|'
|
||||
elif n < math.radians(60):
|
||||
return '/'
|
||||
elif n < math.radians(120):
|
||||
return '-'
|
||||
elif n < math.radians(150):
|
||||
return '\\'
|
||||
elif n < math.radians(210):
|
||||
return '|'
|
||||
elif n < math.radians(240):
|
||||
return '/'
|
||||
elif n < math.radians(300):
|
||||
return '-'
|
||||
elif n < math.radians(330):
|
||||
return '\\'
|
||||
else:
|
||||
return '|'
|
||||
|
||||
def average_colors(colors: list):
|
||||
avg = [0 for x in range(len(colors[0]))]
|
||||
|
||||
for color in colors:
|
||||
for i, num in enumerate(color):
|
||||
avg[i] += num
|
||||
|
||||
for i, n in enumerate(avg):
|
||||
avg[i] /= len(colors)
|
||||
|
||||
return avg
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user