\subsection{Image To ASCII Art}

Once in a while you may want to enhance the look and feel of your command-line application by adding some ascii art to it.

Luckily, the folowing to recipes allow you to create ascii arts based on images.

As both recipes are quite long, they are not display here, but you can find them in the corresponding repository.

The first one saves the ascii art to a file called \lstinline{out.txt} in your current working directory.

The second one prints the resulting ascii art directly to stdout.

Make sure to checkout the code of the first recipe as it shows you, which arguments you can pass to the file.

\begin{lstlisting}[caption=Usage of both recipes]

$ python img_to_ascii.py --file src/python.png --cols 120

$ python img_to_ascii_2.py src/python.png

\end{lstlisting}

| img_to_ascii(_2) | Create ascii arts based on images |

import sys, random, argparse

import numpy as np

import math

from PIL import Image

gscale1 = "$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\|()1{}[]?-_+~<>i!lI;:,\"^`'. "

gscale2 = '@%#*+=-:. '

def getAverageL(image):

"""

# get image as numpy array

im = np.array(image)

# get shape

w,h = im.shape

# get average

return np.average(im.reshape(w*h))

def covertImageToAscii(fileName, cols, scale, moreLevels):

"""

# declare globals

global gscale1, gscale2

# open image and convert to grayscale

image = Image.open(fileName).convert('L')

# store dimensions

W, H = image.size[0], image.size[1]

print("input image dims: %d x %d" % (W, H))

# compute width of tile

w = W/cols

# compute tile height based on aspect ratio and scale

h = w/scale

# compute number of rows

rows = int(H/h)

print("cols: %d, rows: %d" % (cols, rows))

print("tile dims: %d x %d" % (w, h))

# check if image size is too small

if cols > W or rows > H:

print("Image too small for specified cols!")

exit(0)

# ascii image is a list of character strings

aimg = []

# generate list of dimensions

for j in range(rows):

y1 = int(j*h)

y2 = int((j+1)*h)

# correct last tile

if j == rows-1:

y2 = H

# append an empty string

aimg.append("")

for i in range(cols):

# crop image to tile

x1 = int(i*w)

x2 = int((i+1)*w)

# correct last tile

if i == cols-1:

x2 = W

# crop image to extract tile

img = image.crop((x1, y1, x2, y2))

# get average luminance

avg = int(getAverageL(img))

# look up ascii char

if moreLevels:

gsval = gscale1[int((avg*69)/255)]

else:

gsval = gscale2[int((avg*9)/255)]

# append ascii char to string

aimg[j] += gsval

# return txt image

return aimg

def main():

# create parser

descStr = "This program converts an image into ASCII art."

parser = argparse.ArgumentParser(description=descStr)

# add expected arguments

parser.add_argument('--file', dest='imgFile', required=True)

parser.add_argument('--scale', dest='scale', required=False)

parser.add_argument('--out', dest='outFile', required=False)

parser.add_argument('--cols', dest='cols', required=False)

parser.add_argument('--morelevels',dest='moreLevels',action='store_true')

# parse args

args = parser.parse_args()

imgFile = args.imgFile

# set output file

outFile = 'out.txt'

if args.outFile:

outFile = args.outFile

# set scale default as 0.43 which suits

# a Courier font

scale = 0.43

if args.scale:

scale = float(args.scale)

# set cols

cols = 80

if args.cols:

cols = int(args.cols)

print('generating ASCII art...')

# convert image to ascii txt

aimg = covertImageToAscii(imgFile, cols, scale, args.moreLevels)

# open file

f = open(outFile, 'w')

# write to file

for row in aimg:

f.write(row + '\n')

# cleanup

f.close()

print("ASCII art written to %s" % outFile)

if __name__ == '__main__':

main()

from PIL import Image

ASCII_CHARS = [ '#', '?', '%', '.', 'S', '+', '.', '*', ':', ',', '@']

def scale_image(image, new_width=100):

"""Resizes an image preserving the aspect ratio.

(original_width, original_height) = image.size

aspect_ratio = original_height/float(original_width)

new_height = int(aspect_ratio * new_width)

new_image = image.resize((new_width, new_height))

return new_image

def convert_to_grayscale(image):

return image.convert('L')

def map_pixels_to_ascii_chars(image, range_width=25):

"""Maps each pixel to an ascii char based on the range

pixels_in_image = list(image.getdata())

pixels_to_chars = [ASCII_CHARS[pixel_value//range_width] for pixel_value in

pixels_in_image]

return "".join(pixels_to_chars)

def convert_image_to_ascii(image, new_width=100):

image = scale_image(image)

image = convert_to_grayscale(image)

pixels_to_chars = map_pixels_to_ascii_chars(image)

len_pixels_to_chars = len(pixels_to_chars)

image_ascii = [pixels_to_chars[index: index + new_width] for index in

range(0, len_pixels_to_chars, new_width)]

return "\n".join(image_ascii)

def handle_image_conversion(image_filepath):

image = None

try:

image = Image.open(image_filepath)

except Exception as e:

print("Unable to open image file {image_filepath}.".format(image_filepath=image_filepath))

print(e)

return

image_ascii = convert_image_to_ascii(image)

print(image_ascii)

if __name__=='__main__':

import sys

image_file_path = sys.argv[1]

handle_image_conversion(image_file_path)