87 | 6 | 7 | It's a simple python package to play videos in a terminal using [ASCII](https://en.wikipedia.org/wiki/ASCII) characters. 8 | 9 |
10 | 11 |  12 | 13 |17 | 18 | - [🇺🇸 English](./README.md) 19 | - [🇪🇸 Español](./translations/README_es.md) 20 | - [🇹🇼 繁體中文](./translations/README_zh-TW.md) 21 | 22 |
23 |
86 |
87 |
111 |
--------------------------------------------------------------------------------
/bin/video-to-ascii:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import argparse
4 | from video_to_ascii import player
5 |
6 | CLI_DESC = "It is a simple python package to play videos in the terminal using colored characters as pixels or other useful outputs"
7 | EPILOG = ("\033[1;37mThanks for trying video-to-ascii!\033[0m")
8 |
9 | PARSER = argparse.ArgumentParser(prog='video-to-ascii', description=CLI_DESC, epilog=EPILOG)
10 | PARSER.add_argument('-f', '--file', type=str, dest='file', help='input video file', action='store', required=True)
11 | PARSER.add_argument('--strategy', default='ascii-color', type=str, dest='strategy',
12 | choices=["ascii-color", "just-ascii", "filled-ascii"], help='choose an strategy to render the output', action='store')
13 | PARSER.add_argument('-o', '--output', type=str, dest='output', help='output file to export', action='store')
14 | PARSER.add_argument('--output-format', default='sh', type=str, dest='output_format',
15 | choices=["sh", "json"], help='choose an output format to render the output', action='store')
16 | PARSER.add_argument('--with-audio', dest='with_audio', help='play audio', action='store_true')
17 |
18 | ARGS = PARSER.parse_args()
19 |
20 | player.play(ARGS.file, strategy=ARGS.strategy, output=ARGS.output, output_format=ARGS.output_format, play_audio=ARGS.with_audio)
21 |
--------------------------------------------------------------------------------
/images/8-bit_color_table.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/8-bit_color_table.png
--------------------------------------------------------------------------------
/images/Luminosity.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
47 |
--------------------------------------------------------------------------------
/images/LuminosityFunction.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
47 |
--------------------------------------------------------------------------------
/images/Simpsons.apng:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/Simpsons.apng
--------------------------------------------------------------------------------
/images/Simpsons.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/Simpsons.gif
--------------------------------------------------------------------------------
/images/Simpsonsv2.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/Simpsonsv2.gif
--------------------------------------------------------------------------------
/images/Strategies.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/Strategies.png
--------------------------------------------------------------------------------
/images/display-colors.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/display-colors.jpg
--------------------------------------------------------------------------------
/images/export.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/export.png
--------------------------------------------------------------------------------
/images/imgBrightnes.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/imgBrightnes.png
--------------------------------------------------------------------------------
/images/imgPixelImage.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/imgPixelImage.png
--------------------------------------------------------------------------------
/images/imgPixelSection.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/imgPixelSection.png
--------------------------------------------------------------------------------
/images/imgResizing.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/imgResizing.png
--------------------------------------------------------------------------------
/images/imgTerminal.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/imgTerminal.png
--------------------------------------------------------------------------------
/images/imgVideoFrames.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/imgVideoFrames.png
--------------------------------------------------------------------------------
/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/images/logo.png
--------------------------------------------------------------------------------
/images/logo.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | opencv-python
2 | xtermcolor
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | import sys
2 | from setuptools import setup, find_packages
3 | from setuptools.command.install import install
4 | from setuptools.command.develop import develop
5 | from setuptools.command.egg_info import egg_info
6 |
7 | def install_package(package):
8 | import pip
9 | try:
10 | from pip._internal import main
11 | main.main(['install', package])
12 | except AttributeError:
13 | from pip import __main__
14 | __main__._main(['install', package])
15 |
16 | if "--with-audio" in sys.argv:
17 | install_package('opencv-python')
18 | install_package('pyaudio')
19 | sys.argv.remove("--with-audio")
20 | else:
21 | install_package('opencv-python')
22 |
23 | setup(
24 | name="video_to_ascii",
25 | version="1.3.0",
26 | author="Joel Ibaceta",
27 | author_email="mail@joelibaceta.com",
28 | license='MIT',
29 | description="It is a simple python package to play videos in the terminal",
30 | long_description="A simple tool to play a video using ascii characters instead of pixels",
31 | url="https://github.com/joelibaceta/video-to-ascii",
32 | project_urls={
33 | 'Source': 'https://github.com/joelibaceta/video-to-ascii',
34 | 'Tracker': 'https://github.com/joelibaceta/video-to-ascii/issues'
35 | },
36 | packages=find_packages(),
37 | include_package_data=True,
38 | install_requires=['xtermcolor', 'ffmpeg-python'],
39 | classifiers=[
40 | "Programming Language :: Python :: 3",
41 | "Intended Audience :: Developers",
42 | "License :: OSI Approved :: MIT License",
43 | "Operating System :: OS Independent",
44 | ],
45 | keywords='video ascii terminal opencv',
46 | entry_points={
47 | "console_scripts": [
48 | 'video-to-ascii=video_to_ascii.cli:main'
49 | ]
50 | }
51 | )
52 |
--------------------------------------------------------------------------------
/translations/README_es.md:
--------------------------------------------------------------------------------
1 | 6 | 7 | Es un paquete de Python simple para reproducir videos en una terminal usando caracteres [ASCII](https://en.wikipedia.org/wiki/ASCII). 8 | 9 | [](https://opencollective.com/video-to-ascii) [](https://badge.fury.io/py/video-to-ascii) 10 | [](https://codeclimate.com/github/joelibaceta/video-to-terminal/maintainability) 11 | [](https://github.com/joelibaceta/video-to-ascii) 12 | [](http://hits.dwyl.io/joelibaceta/https://github.com/joelibaceta/video-to-ascii) 13 | 14 |  15 | 16 |
17 | 18 |22 | 23 | - [🇺🇸 English](../README.md) 24 | - [🇪🇸 Español](./README_es.md) 25 | - [🇹🇼 繁體中文](./README_zh-TW.md) 26 | 27 |
28 |
90 | 
91 |
120 |
121 | ### Contribuyentes Financieros
122 |
123 | Conviértete en un contribuyente financiero y ayúdanos a sostener nuestra comunidad.. [[Contribute](https://opencollective.com/video-to-ascii/contribute/)].
124 |
125 | O tal vez sólo me [compre un café](https://ko-fi.com/joelibaceta).
126 |
127 | #### Individuos
128 |
129 | 
130 |
131 | #### Organizaciones
132 |
133 | Apoye este proyecto con su organización. Su logotipo se mostrará aquí con un enlace a su sitio web. [[Contribute](https://opencollective.com/video-to-ascii/contribute)]
134 |
135 | 
136 | 
137 | 
138 | 
139 | 
140 | 
141 | 
142 | 
143 | 
144 | 
145 |
146 |
--------------------------------------------------------------------------------
/translations/README_zh-TW.md:
--------------------------------------------------------------------------------
1 | 6 | 7 | 一款用來在終端機中使用 [ASCII](https://en.wikipedia.org/wiki/ASCII) 字元播放影片的 Python 套件。 8 | 9 | [](https://opencollective.com/video-to-ascii) [](https://badge.fury.io/py/video-to-ascii) 10 | [](https://codeclimate.com/github/joelibaceta/video-to-terminal/maintainability) 11 | [](https://github.com/joelibaceta/video-to-ascii) 12 | [](http://hits.dwyl.io/joelibaceta/https://github.com/joelibaceta/video-to-ascii) 13 | 14 |
15 | 16 |  17 | 18 |22 | 23 | - [🇺🇸 English](../README.md) 24 | - [🇪🇸 Español](./README_es.md) 25 | - [🇹🇼 繁體中文](./README_zh-TW.md) 26 | 27 |
28 |
91 |
92 |
122 |
123 | ### 財務貢獻者
124 |
125 | 成為財務貢獻者，並幫助我們維持我們的社群。[[Contribute](https://opencollective.com/video-to-ascii/contribute/)].
126 |
127 | 或者是 [贊助我一杯咖啡](https://ko-fi.com/joelibaceta)。
128 |
129 | #### 個人贊助
130 |
131 |
132 |
133 | #### 機構贊助
134 |
135 | 與您的組織一起支持此項目。您的組織徽章將顯示在此處，並帶有指向您網站的鏈接。[[Contribute](https://opencollective.com/video-to-ascii/contribute)]
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
--------------------------------------------------------------------------------
/video_to_ascii/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jankozik/video2ascii/5c9ae77234e4e7c6effb5935b30c77b19d367598/video_to_ascii/__init__.py
--------------------------------------------------------------------------------
/video_to_ascii/cli.py:
--------------------------------------------------------------------------------
1 | """This module contains a CLI interface"""
2 |
3 | from . import player
4 |
5 | def main():
6 | import argparse
7 |
8 | CLI_DESC = "It is a simple python package to play videos in the terminal using colored characters as pixels or other useful outputs"
9 | EPILOG = ("\033[1;37mThanks for trying video-to-ascii!\033[0m")
10 |
11 | PARSER = argparse.ArgumentParser(prog='video-to-ascii', description=CLI_DESC, epilog=EPILOG)
12 | PARSER.add_argument('-f', '--file', type=str, dest='file', help='input video file', action='store', required=True)
13 | PARSER.add_argument('--strategy', default='ascii-color', type=str, dest='strategy',
14 | choices=["ascii-color", "just-ascii", "filled-ascii"], help='choose an strategy to render the output', action='store')
15 | PARSER.add_argument('-o', '--output', type=str, dest='output', help='output file to export', action='store')
16 | PARSER.add_argument('-a','--with-audio', dest='with_audio', help='play audio track', action='store_true')
17 |
18 | ARGS = PARSER.parse_args()
19 |
20 | try:
21 | player.play(ARGS.file, strategy=ARGS.strategy, output=ARGS.output, play_audio=ARGS.with_audio)
22 | except (KeyboardInterrupt):
23 | pass
24 |
25 | if __name__ == '__main__':
26 | main()
27 |
--------------------------------------------------------------------------------
/video_to_ascii/player.py:
--------------------------------------------------------------------------------
1 | """This module contains a set of functions to use the video_to_ascii from cli"""
2 |
3 | import tempfile
4 | from . import video_engine as ve
5 |
6 | def play(filename, strategy=None, output=None, output_format=None, play_audio=False):
7 | """
8 | Play or export a video from a file by default using ascii chars in terminal
9 | """
10 | engine = ve.VideoEngine()
11 | engine.load_video_from_file(filename)
12 | if play_audio:
13 | import ffmpeg
14 | temp_dir = tempfile.gettempdir()
15 | temp_file_path = temp_dir + "/temp-audiofile-for-vta.wav"
16 | stream = ffmpeg.input(filename)
17 | stream = ffmpeg.output(stream, temp_file_path)
18 | stream = ffmpeg.overwrite_output(stream)
19 | ffmpeg.run(stream)
20 | engine.with_audio = True
21 | if strategy is not None:
22 | engine.set_strategy(strategy)
23 | engine.play(output, output_format)
24 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/__init__.py:
--------------------------------------------------------------------------------
1 | from . import ascii_bw_strategy as bw
2 | from . import ascii_color_strategy as color
3 | from . import ascii_color_filled_strategy as filled
4 |
5 | STRATEGIES = {
6 | "default": color.AsciiColorStrategy(),
7 | "ascii-color": color.AsciiColorStrategy(),
8 | "just-ascii": bw.AsciiBWStrategy(),
9 | "filled-ascii": filled.AsciiColorFilledStrategy()
10 | }
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/ascii_bw_strategy.py:
--------------------------------------------------------------------------------
1 | """
2 | This module contains a class AsciiColorStrategy, to process video frames and build an ascii output
3 | """
4 |
5 | from . import ascii_strategy as strategy
6 | import sys
7 | if sys.platform != 'win32':
8 | from . import image_processor as ipe
9 | else:
10 | from . import image_processor_win as ipe
11 |
12 | class AsciiBWStrategy(strategy.AsciiStrategy):
13 | """Print each frame in the terminal using one color ascii characters"""
14 |
15 | def apply_pixel_to_ascii_strategy(self, pixel):
16 | """
17 | Define a pixel parsing strategy to use colored chars
18 |
19 | Args:
20 | pixel: a single video frame
21 |
22 | Returns:
23 | str: The resulting set of chars as a unique string
24 | """
25 | return ipe.pixel_to_ascii(pixel, colored=0)
26 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/ascii_color_filled_strategy.py:
--------------------------------------------------------------------------------
1 | """
2 | This module contains a class AsciiColorStrategy, to process video frames and build an ascii output
3 | """
4 |
5 | from . import ascii_strategy as strategy
6 | import sys
7 |
8 | if sys.platform != 'win32':
9 | from . import image_processor as ipe
10 | else:
11 | from . import image_processor_win as ipe
12 |
13 | class AsciiColorFilledStrategy(strategy.AsciiStrategy):
14 | """Print each frame in the terminal using ascii characters"""
15 |
16 | def apply_pixel_to_ascii_strategy(self, pixel):
17 | """
18 | Define a pixel parsing strategy to use high density colored chars
19 |
20 | Args:
21 | pixel: a single video frame
22 |
23 | Returns:
24 | str: The resulting set of colored chars as a unique string
25 | """
26 | return ipe.pixel_to_ascii(pixel, density=2)
27 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/ascii_color_strategy.py:
--------------------------------------------------------------------------------
1 | """
2 | This module contains a class AsciiColorStrategy, to process video frames and build an ascii output
3 | """
4 |
5 | from . import ascii_strategy as strategy
6 | import sys
7 | if sys.platform != 'win32':
8 | from . import image_processor as ipe
9 | else:
10 | from . import image_processor_win as ipe
11 |
12 | class AsciiColorStrategy(strategy.AsciiStrategy):
13 | """Print each frame in the terminal using ascii characters"""
14 |
15 | def apply_pixel_to_ascii_strategy(self, pixel):
16 | """
17 | Define a pixel parsing strategy to use colored chars
18 |
19 | Args:
20 | pixel: a single video frame
21 |
22 | Returns:
23 | str: The resulting set of colored chars as a unique string
24 | """
25 | return ipe.pixel_to_ascii(pixel, density=1)
26 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/ascii_strategy.py:
--------------------------------------------------------------------------------
1 | """
2 | This module contains a class AsciiColorStrategy, to process video frames and build an ascii output
3 | """
4 |
5 | import time
6 | import sys
7 | import os
8 | import cv2
9 | import tempfile
10 |
11 | PLATFORM = 0
12 | if sys.platform != 'win32':
13 | PLATFORM = 1
14 |
15 | from . import render_strategy as re
16 | if PLATFORM:
17 | from . import image_processor as ipe
18 | else:
19 | from . import image_processor_win as ipe
20 | from os import get_terminal_size as _term_size
21 | DEFAULT_TERMINAL_SIZE = _term_size().columns, _term_size().lines
22 |
23 | class AsciiStrategy(re.RenderStrategy):
24 | """Print each frame in the terminal using ascii characters"""
25 |
26 | def convert_frame_pixels_to_ascii(self, frame, dimensions=DEFAULT_TERMINAL_SIZE, new_line_chars=False):
27 | """
28 | Replace all pixels with colored chars and return the resulting string
29 |
30 | This method iterates each pixel of one video frame
31 | respecting the dimensions of the printing area
32 | to truncate the width if necessary
33 | and use the pixel_to_ascii method to convert one pixel
34 | into a character with the appropriate color.
35 | Finally joins the set of chars in a string ready to print.
36 |
37 | Args:
38 | frame: a single video frame
39 | dimensions: an array with the printing area dimensions
40 | in pixels [rows, cols]
41 | new_line_chars: if should append a new line character
42 | at end of each row
43 |
44 | Returns:
45 | str: The resulting set of colored chars as a unique string
46 |
47 | """
48 | cols, _ = dimensions
49 | h, w, _ = frame.shape
50 |
51 | printing_width = int(min(int(cols), (w*2))/2)
52 | pad = max(int(cols) - printing_width*2, 0)
53 |
54 |
55 | msg = ''
56 | for j in range(h-1):
57 | for i in range(printing_width):
58 | pixel = frame[j][i]
59 | msg += self.apply_pixel_to_ascii_strategy(pixel)
60 | if new_line_chars:
61 | msg += "\n"
62 | else:
63 | msg += " " * (pad)
64 | msg += "\r\n"
65 | return msg
66 |
67 | def apply_pixel_to_ascii_strategy(self, pixel):
68 | return ipe.pixel_to_ascii(pixel)
69 |
70 | def apply_end_line_modifier(self, msg):
71 | return msg
72 |
73 | def render(self, cap, output=None, output_format=None, with_audio=False):
74 | """
75 | Iterate each video frame to print a set of ascii chars
76 |
77 | This method reads each video frame from a opencv video capture
78 | resizing the frame and truncate the width if necessary to
79 | print correctly the final string built with the method
80 | convert_frame_pixels_to_ascii.
81 | Finally each final string is printed correctly, if the process
82 | was done too fast will sleep the necessary time to comply
83 | with the fps expected (30 fps by default).
84 |
85 | Args:
86 | cap: An OpenCV video capture
87 | output: If the render should be exported to a bash file
88 | """
89 |
90 | v_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
91 | v_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
92 | length = cap.get(cv2.CAP_PROP_FRAME_COUNT)
93 | fps = cap.get(cv2.CAP_PROP_FPS)
94 | fps = fps or 30
95 |
96 | if with_audio:
97 | import pyaudio
98 | import wave
99 |
100 | temp_dir = tempfile.gettempdir()
101 | temp_file_path = temp_dir + "/temp-audiofile-for-vta.wav"
102 | wave_file = wave.open(temp_file_path, 'rb')
103 | chunk = int(wave_file.getframerate() / fps)
104 | p = pyaudio.PyAudio()
105 |
106 | stream = p.open(format =
107 | p.get_format_from_width(wave_file.getsampwidth()),
108 | channels = wave_file.getnchannels(),
109 | rate = wave_file.getframerate(),
110 | output = True)
111 |
112 | data = wave_file.readframes(chunk)
113 |
114 |
115 | if output is not None:
116 | file = open(output, 'w+')
117 |
118 | if output_format == 'sh':
119 | file.write("#!/bin/bash \n")
120 | file.write("echo -en '\033[2J' \n")
121 | file.write("echo -en '\u001b[0;0H' \n")
122 |
123 | time_delta = 1./fps
124 | counter=0
125 | if PLATFORM:
126 | sys.stdout.write("echo -en '\033[2J' \n")
127 | else:
128 | sys.stdout.write('\033[2J')
129 | # read each frame
130 | while cap.isOpened():
131 | t0 = time.process_time()
132 | if PLATFORM:
133 | rows, cols = os.popen('stty size', 'r').read().split()
134 | else:
135 | cols, rows = os.get_terminal_size()
136 | _ret, frame = cap.read()
137 | if frame is None:
138 | break
139 | if with_audio:
140 | data = wave_file.readframes(chunk)
141 | stream.write(data)
142 | # sleep if the process was too fast
143 | if output is None:
144 | if PLATFORM:
145 | sys.stdout.write('\u001b[0;0H')
146 | else:
147 | sys.stdout.write("\x1b[0;0H")
148 | # scale each frame according to terminal dimensions
149 | resized_frame = self.resize_frame(frame, (cols, rows))
150 | # convert frame pixels to colored string
151 | msg = self.convert_frame_pixels_to_ascii(resized_frame, (cols, rows))
152 | t1 = time.process_time()
153 | delta = time_delta - (t1 - t0)
154 | if delta > 0:
155 | time.sleep(delta)
156 | sys.stdout.write(msg) # Print the final string
157 | else:
158 | print(self.build_progress(counter, length))
159 | if PLATFORM:
160 | print("\u001b[2A")
161 | else:
162 | print("\x1b[2A")
163 |
164 | if output_format == 'sh':
165 | resized_frame = self.resize_frame(frame)
166 | msg = self.convert_frame_pixels_to_ascii(resized_frame, new_line_chars=True)
167 | file.write("sleep 0.033 \n")
168 | file.write("echo -en '" + msg + "'" + "\n" )
169 | file.write("echo -en '\u001b[0;0H' \n")
170 | elif output_format == 'json':
171 | # scale each frame according to terminal dimensions
172 | resized_frame = self.resize_frame(frame, (cols, rows))
173 | msg = self.convert_frame_pixels_to_ascii(resized_frame, (cols, rows), new_line_chars=True)
174 | lines = msg.split("\n")
175 | # remove last line breaks (\n\r) which generate two extra unwanted array elements
176 | lines = lines[0:-2]
177 | # opening brackets
178 | file.write("[[\n" if counter == 0 else ",[\n")
179 | for i in range(len(lines)):
180 | file.write(f"\"{lines[i]}\"")
181 | # closing brackets
182 | file.write("]\n" if i == (len(lines) - 1) else ",\n")
183 |
184 | counter += 1
185 | if with_audio:
186 | stream.close()
187 | p.terminate()
188 | if PLATFORM:
189 | sys.stdout.write("echo -en '\033[2J' \n")
190 | else:
191 | os.system('cls') or None
192 |
193 | # close the frame array
194 | if output is not None and output_format == 'json':
195 | file.write(f"]\n")
196 |
197 | def build_progress(self, progress, total):
198 | """Build a progress bar in the terminal"""
199 | progress_percent = int(progress / total * 100)
200 | adjusted_size_percent = int((20 / 100) * progress_percent)
201 | progress_bar = ('█' * adjusted_size_percent) + ('░' * (20-adjusted_size_percent))
202 | return " " + "|" + progress_bar + "| " + str(progress_percent) + "%"
203 |
204 | def resize_frame(self, frame, dimensions=DEFAULT_TERMINAL_SIZE):
205 | """
206 | Resize a frame to meet the terminal dimensions
207 |
208 | Calculating the output terminal dimensions (cols, rows),
209 | we can get a reduction factor to resize the frame
210 | according to the height of the terminal mainly
211 | to print each frame at a time, using all the available rows
212 |
213 | Args:
214 | frame: Frame to resize
215 | dimensions: If you want to set a printer area size (cols, rows)
216 | Returns:
217 | A resized frame
218 | """
219 | height, width, _ = frame.shape
220 | _, rows = dimensions
221 | reduction_factor = (float(rows)) / height * 100
222 | reduced_width = int(width * reduction_factor / 100)
223 | reduced_height = int(height * reduction_factor / 100)
224 | dimension = (reduced_width, reduced_height)
225 | resized_frame = cv2.resize(frame, dimension, interpolation=cv2.INTER_LINEAR)
226 | return resized_frame
227 |
228 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/image_processor.py:
--------------------------------------------------------------------------------
1 | """Module with useful functions to image processing"""
2 |
3 | import colorsys
4 | from xtermcolor import colorize
5 |
6 | CHARS_LIGHT = [' ', ' ', '.', ':', '!', '+', '*', 'e', '$', '@', '8']
7 | CHARS_COLOR = ['.', '*', 'e', 's', '◍']
8 | CHARS_FILLED = ['░', '▒', '▓', '█']
9 |
10 | DENSITY = [CHARS_LIGHT, CHARS_COLOR, CHARS_FILLED]
11 |
12 | def brightness_to_ascii(i, density=0):
13 | """
14 | Get an appropriate char of brightness from a rgb color
15 | """
16 | chars_collection = DENSITY[density]
17 | size = len(chars_collection) - 1
18 | index = int(size * i / 255)
19 | return chars_collection[index]
20 |
21 | def colorize_char(char, ansi_color):
22 | """
23 | Get an appropriate char of brightness from a rgb color
24 | """
25 | str_colorized = colorize(char, ansi=ansi_color)
26 | return str_colorized
27 |
28 | def pixel_to_ascii(pixel, colored=True, density=0):
29 | """
30 | Convert a pixel to char
31 | """
32 | bgr = tuple(float(x) for x in pixel[:3])
33 | rgb = tuple(reversed(bgr))
34 | char = ''
35 | if colored:
36 | bright = rgb_to_brightness(*rgb)
37 | rgb = increase_saturation(*rgb)
38 | char = brightness_to_ascii(bright, density)
39 | ansi_color = rgb_to_ansi(*rgb)
40 | char = colorize(char*2, ansi=ansi_color)
41 | else:
42 | bright = rgb_to_brightness(*rgb, grayscale=True)
43 | char = brightness_to_ascii(bright, density)
44 | char = char*2
45 | return char
46 |
47 | def increase_saturation(r, g, b):
48 | """
49 | Increase the saturation from rgb and return the new value as rgb tuple
50 | """
51 | h, s, v = colorsys.rgb_to_hsv(r, g, b)
52 | s = min(s+0.3, 1.0)
53 | return colorsys.hsv_to_rgb(h, s, v)
54 |
55 | def rgb_to_brightness(r, g, b, grayscale=False):
56 | """
57 | Calc a brightness factor according to rgb color
58 | """
59 | if grayscale:
60 | return 0.2126*r + 0.7152*g + 0.0722*b
61 | else:
62 | return 0.267*r + 0.642*g + 0.091*b
63 |
64 | def rgb_to_ansi(r, g, b):
65 | """
66 | Convert an rgb color to ansi color
67 | """
68 | (r, g, b) = int(r), int(g), int(b)
69 | if r == g & g == b:
70 | if r < 8:
71 | return int(16)
72 | if r > 248:
73 | return int(230)
74 | return int(round(((r - 8) / 247) * 24) + 232)
75 |
76 | to_ansi_range = lambda a: int(round(a / 51.0))
77 | r_in_range = to_ansi_range(r)
78 | g_in_range = to_ansi_range(g)
79 | b_in_range = to_ansi_range(b)
80 | ansi = 16 + (36 * r_in_range) + (6 * g_in_range) + b_in_range
81 | return int(ansi)
82 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/image_processor_win.py:
--------------------------------------------------------------------------------
1 | """Module with useful functions to image processing"""
2 | """Windows-compatibility module"""
3 |
4 | from colored import fg, attr
5 | import colorsys
6 |
7 | CHARS_LIGHT = [' ', ' ', '.', ':', '!', '+', '*', 'e', '$', '@', '8']
8 | CHARS_COLOR = ['.', '*', 'e', 's', '◍']
9 | CHARS_FILLED = ['░', '▒', '▓', '█']
10 |
11 | DENSITY = [CHARS_LIGHT, CHARS_COLOR, CHARS_FILLED]
12 |
13 | def rgb_to_colorhex(r, g, b):
14 | R = format(int(r), 'x')
15 | if len(R) == 1:
16 | R = '0'+format(int(r), 'x')
17 | G = format(int(g), 'x')
18 | if len(G) == 1:
19 | G = '0'+format(int(g), 'x')
20 | B = format(int(b), 'x')
21 | if len(B) == 1:
22 | B = '0'+format(int(b), 'x')
23 | return f'#{R.upper()}{G.upper()}{B.upper()}'
24 |
25 | def brightness_to_ascii(i, density=0):
26 | """
27 | Get an appropriate char of brightness from a rgb color
28 | """
29 | chars_collection = DENSITY[density]
30 | size = len(chars_collection) - 1
31 | index = int(size * i / 255)
32 | return chars_collection[index]
33 |
34 | def colorize_char(char, colorhex):
35 | """
36 | Get an appropriate char of brightness from a rgb color
37 | """
38 | str_colorized = fg(colorhex)+char+attr('reset')
39 | return str_colorized
40 |
41 | def pixel_to_ascii(pixel, colored=True, density=0):
42 | """
43 | Convert a pixel to char
44 | """
45 | bgr = tuple(float(x) for x in pixel[:3])
46 | rgb = tuple(reversed(bgr))
47 | char = ''
48 | if colored:
49 | bright = rgb_to_brightness(*rgb)
50 | rgb = increase_saturation(*rgb)
51 | char = brightness_to_ascii(bright, density)
52 | hex_color = rgb_to_colorhex(*rgb)
53 | char = fg(hex_color)+char*2+attr('reset')
54 | else:
55 | bright = rgb_to_brightness(*rgb, grayscale=True)
56 | char = brightness_to_ascii(bright, density)
57 | char = char*2
58 | return char
59 |
60 | def increase_saturation(r, g, b):
61 | """
62 | Increase the saturation from rgb and return the new value as rgb tuple
63 | """
64 | h, s, v = colorsys.rgb_to_hsv(r, g, b)
65 | s = min(s+0.3, 1.0)
66 | return colorsys.hsv_to_rgb(h, s, v)
67 |
68 | def rgb_to_brightness(r, g, b, grayscale=False):
69 | """
70 | Calc a brightness factor according to rgb color
71 | """
72 | if grayscale:
73 | return 0.2126*r + 0.7152*g + 0.0722*b
74 | else:
75 | return 0.267*r + 0.642*g + 0.091*b
76 |
--------------------------------------------------------------------------------
/video_to_ascii/render_strategy/render_strategy.py:
--------------------------------------------------------------------------------
1 | """This module has an abstract class for render strategies"""
2 |
3 | from abc import ABC, abstractmethod
4 |
5 | class RenderStrategy(ABC):
6 | """An abstract class to guide about how to implement a render_strategy class"""
7 |
8 | @abstractmethod
9 | def render(self, cap, output=None, with_audio=False):
10 | """
11 | This method must be implemented with the necessary instructions to process the video frames and generate the output
12 | """
13 | raise Exception("NotImplementedException")
14 |
--------------------------------------------------------------------------------
/video_to_ascii/video_engine.py:
--------------------------------------------------------------------------------
1 | """This module has a class for video processing"""
2 |
3 | import cv2
4 | from . import render_strategy as re
5 |
6 | class VideoEngine:
7 | """
8 | A class to encapsulate a video processing methods and persist variables across the process
9 | """
10 |
11 | def __init__(self, strategy="default"):
12 | strategy_object = re.STRATEGIES[strategy]
13 | self.render_strategy = strategy_object
14 | self.read_buffer = None
15 | self.with_audio = False
16 |
17 | def set_strategy(self, strategy):
18 | """
19 | Set a render strategy
20 | """
21 | strategy_object = re.STRATEGIES[strategy]
22 | self.render_strategy = strategy_object
23 |
24 | def load_video_from_file(self, filename):
25 | """
26 | Load a video file into the engine and set a read buffer
27 | """
28 | cap = cv2.VideoCapture(filename)
29 | self.read_buffer = cap
30 |
31 | def play(self, output=None, output_format=None):
32 | """
33 | Play the video captured using an specific render strategy
34 | """
35 |
36 | self.render_strategy.render(self.read_buffer,
37 | output=output,
38 | output_format=output_format,
39 | with_audio=self.with_audio)
40 |
--------------------------------------------------------------------------------