Python制作ASCII艺术生成器：从图片到字符画的奇妙转换

一、项目概述与最终效果

1. 项目功能介绍

我们的ASCII艺术生成器将实现以下功能：

• 图片转字符画：支持JPG、PNG等常见格式
• 实时摄像头字符画：将摄像头画面实时转换为ASCII艺术
• 动态参数调整：字符密度、对比度、输出尺寸可调
• 多种输出格式：控制台输出、文本文件、彩色字符画
• 批量处理：支持整个文件夹的图片转换

2. 最终效果预览

在开始编码前，先看看我们的成果：

原始图片：

VC博客的文字图片

转换后的ASCII艺术：

二、环境准备与依赖安装

1. 所需库介绍

# requirements.txt
Pillow>=9.0.0      # 图像处理
opencv-python>=4.5 # 摄像头支持（可选）
numpy>=1.21        # 数组操作（可选）

2. 安装命令

pip install Pillow opencv-python numpy

三、核心算法实现

1. 图像处理基础类

import os
import sys
from PIL import Image, ImageDraw, ImageFont
import numpy as np
from typing import List, Tuple, Optional

class ImageProcessor:
    """图像处理器 - 负责基础的图像加载和预处理"""
    
    def __init__(self):
        self.supported_formats = {'.jpg', '.jpeg', '.png', '.bmp', '.gif'}
    
    def load_image(self, image_path: str) -> Optional[Image.Image]:
        """加载图像文件"""
        try:
            if not os.path.exists(image_path):
                raise FileNotFoundError(f"图像文件不存在: {image_path}")
            
            # 检查文件格式
            _, ext = os.path.splitext(image_path)
            if ext.lower() not in self.supported_formats:
                raise ValueError(f"不支持的图像格式: {ext}")
            
            image = Image.open(image_path)
            return image.convert('RGB')  # 统一转换为RGB模式
            
        except Exception as e:
            print(f"加载图像失败: {e}")
            return None
    
    def resize_image(self, image: Image.Image, new_width: int = 100) -> Image.Image:
        """调整图像尺寸，保持宽高比"""
        width, height = image.size
        aspect_ratio = height / width
        new_height = int(new_width * aspect_ratio * 0.55)  # 字符高度约为宽度的0.55倍
        return image.resize((new_width, new_height))
    
    def to_grayscale(self, image: Image.Image) -> Image.Image:
        """转换为灰度图像"""
        return image.convert('L')

class ASCIIConverter:
    """ASCII转换器 - 核心转换算法"""
    
    def __init__(self):
        # ASCII字符集，从暗到亮排列
        self.char_sets = {
            'simple': '@%#*+=-:. ',
            'detailed': '$@B%8&WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft/\\|()1{}[]?-_+~<>i!lI;:,"^`\'. ',
            'blocks': '█▓▒░ ',
            'minimal': '@# ',
        }
        
        self.current_chars = self.char_sets['simple']
    
    def set_char_set(self, set_name: str):
        """设置字符集"""
        if set_name in self.char_sets:
            self.current_chars = self.char_sets[set_name]
        else:
            print(f"未知字符集: {set_name}，使用默认简单字符集")
            self.current_chars = self.char_sets['simple']
    
    def pixel_to_ascii(self, pixel_value: int) -> str:
        """将像素值转换为ASCII字符"""
        # 将0-255的像素值映射到字符集的索引
        max_pixel_value = 255
        char_index = int(pixel_value / max_pixel_value * (len(self.current_chars) - 1))
        return self.current_chars[char_index]
    
    def image_to_ascii(self, image: Image.Image, invert: bool = False) -> List[str]:
        """将图像转换为ASCII字符列表"""
        ascii_lines = []
        width, height = image.size
        
        # 转换为灰度图
        grayscale_image = image.convert('L')
        pixels = grayscale_image.load()
        
        for y in range(height):
            line = ""
            for x in range(width):
                pixel_value = pixels[x, y]
                
                # 如果需要反转（黑底白字 -> 白底黑字）
                if invert:
                    pixel_value = 255 - pixel_value
                
                line += self.pixel_to_ascii(pixel_value)
            ascii_lines.append(line)
        
        return ascii_lines

2. 增强版字符画生成器

class AdvancedASCIIConverter(ASCIIConverter):
    """增强版ASCII转换器 - 支持颜色和高级特性"""
    
    def __init__(self):
        super().__init__()
        self.colormap = None
    
    def image_to_colored_ascii(self, image: Image.Image, 
                             output_width: int = 100,
                             preserve_color: bool = True) -> List[str]:
        """生成彩色ASCII艺术（支持终端颜色）"""
        # 调整尺寸
        resized_image = ImageProcessor().resize_image(image, output_width)
        width, height = resized_image.size
        
        ascii_lines = []
        rgb_image = resized_image.convert('RGB')
        grayscale_image = resized_image.convert('L')
        
        rgb_pixels = rgb_image.load()
        gray_pixels = grayscale_image.load()
        
        for y in range(height):
            line = ""
            for x in range(width):
                # 获取灰度值用于选择字符
                gray_value = gray_pixels[x, y]
                ascii_char = self.pixel_to_ascii(gray_value)
                
                if preserve_color:
                    # 获取原始颜色
                    r, g, b = rgb_pixels[x, y]
                    # 使用ANSI颜色代码
                    color_code = self.rgb_to_ansi(r, g, b)
                    colored_char = f"3[38;2;{r};{g};{b}m{ascii_char}3[0m"
                    line += colored_char
                else:
                    line += ascii_char
            
            ascii_lines.append(line)
        
        return ascii_lines
    
    def rgb_to_ansi(self, r: int, g: int, b: int) -> str:
        """RGB颜色转换为ANSI颜色代码"""
        return f"3[38;2;{r};{g};{b}m"
    
    def create_ascii_art_file(self, image_path: str, 
                            output_path: str,
                            width: int = 100,
                            colored: bool = False,
                            invert: bool = False) -> bool:
        """创建ASCII艺术文件"""
        processor = ImageProcessor()
        image = processor.load_image(image_path)
        
        if not image:
            return False
        
        resized_image = processor.resize_image(image, width)
        
        if colored and self.supports_color():
            ascii_lines = self.image_to_colored_ascii(resized_image, width)
        else:
            ascii_lines = self.image_to_ascii(resized_image, invert)
        
        try:
            with open(output_path, 'w', encoding='utf-8') as f:
                for line in ascii_lines:
                    f.write(line + '\n')
            return True
        except Exception as e:
            print(f"保存文件失败: {e}")
            return False
    
    @staticmethod
    def supports_color() -> bool:
        """检查终端是否支持颜色"""
        return sys.platform != "win32" or 'ANSICON' in os.environ

四、实时摄像头ASCII艺术

1. 摄像头字符画实现

try:
    import cv2
    CV2_AVAILABLE = True
except ImportError:
    CV2_AVAILABLE = False
    print("警告: OpenCV未安装，摄像头功能不可用")

class CameraASCII:
    """实时摄像头ASCII艺术"""
    
    def __init__(self, width: int = 100, colored: bool = True):
        self.width = width
        self.colored = colored
        self.converter = AdvancedASCIIConverter()
        self.running = False
        
        if not CV2_AVAILABLE:
            raise ImportError("OpenCV未安装，无法使用摄像头功能")
    
    def start_camera_ascii(self, camera_index: int = 0):
        """启动摄像头ASCII艺术"""
        cap = cv2.VideoCapture(camera_index)
        
        if not cap.isOpened():
            print("无法打开摄像头")
            return
        
        print("摄像头ASCII艺术已启动")
        print("按 'q' 退出，按 'c' 切换颜色模式")
        print("按 '+' 增加宽度，按 '-' 减少宽度")
        
        self.running = True
        
        try:
            while self.running:
                ret, frame = cap.read()
                if not ret:
                    break
                
                # 转换OpenCV BGR到PIL RGB
                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                pil_image = Image.fromarray(frame_rgb)
                
                # 生成ASCII艺术
                if self.colored:
                    ascii_lines = self.converter.image_to_colored_ascii(pil_image, self.width)
                else:
                    ascii_lines = self.converter.image_to_ascii(pil_image)
                
                # 清屏并显示
                self.clear_screen()
                for line in ascii_lines:
                    print(line)
                
                # 处理键盘输入
                key = self.get_key()
                self.handle_input(key)
                
        except KeyboardInterrupt:
            print("\n程序被用户中断")
        finally:
            cap.release()
            cv2.destroyAllWindows()
    
    def clear_screen(self):
        """清屏"""
        os.system('cls' if os.name == 'nt' else 'clear')
    
    def get_key(self) -> str:
        """获取键盘输入（非阻塞）"""
        if sys.platform == "win32":
            # Windows系统
            import msvcrt
            if msvcrt.kbhit():
                return msvcrt.getch().decode()
        else:
            # Unix系统
            import select
            import tty
            import termios
            
            fd = sys.stdin.fileno()
            old_settings = termios.tcgetattr(fd)
            try:
                tty.setraw(sys.stdin.fileno())
                if select.select([sys.stdin], [], [], 0.1)[0]:
                    return sys.stdin.read(1)
            finally:
                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        
        return ''
    
    def handle_input(self, key: str):
        """处理键盘输入"""
        if key == 'q':
            self.running = False
        elif key == 'c':
            self.colored = not self.colored
            print(f"\n颜色模式: {'开启' if self.colored else '关闭'}")
        elif key == '+':
            self.width = min(200, self.width + 10)
            print(f"\n宽度: {self.width}")
        elif key == '-':
            self.width = max(20, self.width - 10)
            print(f"\n宽度: {self.width}")

五、用户界面与交互

1. 命令行界面

class ASCIIArtGenerator:
"""ASCII艺术生成器 - 主程序"""
def __init__(self):
self.processor = ImageProcessor()
self.converter = AdvancedASCIIConverter()
self.camera = None
# 默认配置
self.config = {
'width': 100,
'colored': True,
'invert': False,
'char_set': 'simple',
'output_dir': 'ascii_art_output'
}
def print_banner(self):
"""打印程序横幅"""
banner = """
╔══════════════════════════════════════════╗
║           ASCII艺术生成器 v1.0           ║
║        从图片到字符画的奇妙转换          ║
╚══════════════════════════════════════════╝
"""
print(banner)
def show_menu(self):
"""显示主菜单"""
menu = """
请选择功能:
1. 单张图片转换
2. 批量图片转换  
3. 实时摄像头ASCII艺术
4. 配置设置
5. 退出程序
输入选择 (1-5): """
return input(menu).strip()
def single_image_conversion(self):
"""单张图片转换"""
image_path = input("请输入图片路径: ").strip()
if not os.path.exists(image_path):
print("文件不存在!")
return
# 显示转换选项
print("\n转换选项:")
print(f"1. 输出宽度: {self.config['width']}")
print(f"2. 彩色输出: {'是' if self.config['colored'] else '否'}")
print(f"3. 反转颜色: {'是' if self.config['invert'] else '否'}")
print(f"4. 字符集: {self.config['char_set']}")
print("5. 开始转换")
print("6. 返回主菜单")
choice = input("请选择: ").strip()
if choice == '5':
self.convert_single_image(image_path)
elif choice == '1':
new_width = input("请输入输出宽度 (20-200): ").strip()
try:
self.config['width'] = int(new_width)
except ValueError:
print("无效的宽度!")
elif choice == '2':
self.config['colored'] = not self.config['colored']
elif choice == '3':
self.config['invert'] = not self.config['invert']
elif choice == '4':
self.select_char_set()
def convert_single_image(self, image_path: str):
"""转换单张图片"""
image = self.processor.load_image(image_path)
if not image:
return
self.converter.set_char_set(self.config['char_set'])
if self.config['colored'] and self.converter.supports_color():
ascii_lines = self.converter.image_to_colored_ascii(
image, self.config['width']
)
else:
ascii_lines = self.converter.image_to_ascii(
image, self.config['invert']
)
# 在控制台显示
print("\n" + "="*50)
print(f"ASCII艺术预览 (宽度: {self.config['width']})")
print("="*50)
for line in ascii_lines:
print(line)
# 询问是否保存
save = input("\n是否保存到文件? (y/n): ").strip().lower()
if save == 'y':
self.save_ascii_art(ascii_lines, image_path)
def save_ascii_art(self, ascii_lines: List[str], original_path: str):
"""保存ASCII艺术到文件"""
# 创建输出目录
os.makedirs(self.config['output_dir'], exist_ok=True)
# 生成输出文件名
original_name = os.path.splitext(os.path.basename(original_path))[0]
output_path = os.path.join(
self.config['output_dir'], 
f"{original_name}_ascii.txt"
)
try:
with open(output_path, 'w', encoding='utf-8') as f:
f.write(f"ASCII Art generated from: {original_path}\n")
f.write(f"Width: {self.config['width']}\n")
f.write(f"Character set: {self.config['char_set']}\n")
f.write("="*50 + "\n")
for line in ascii_lines:
# 移除ANSI颜色代码后保存
clean_line = self.remove_ansi_codes(line)
f.write(clean_line + '\n')
print(f"ASCII艺术已保存到: {output_path}")
except Exception as e:
print(f"保存失败: {e}")
def remove_ansi_codes(self, text: str) -> str:
"""移除ANSI颜色代码"""
import re
ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
return ansi_escape.sub('', text)
def batch_conversion(self):
"""批量图片转换"""
folder_path = input("请输入图片文件夹路径: ").strip()
if not os.path.isdir(folder_path):
print("文件夹不存在!")
return
# 查找所有支持的图片文件
image_files = []
for file in os.listdir(folder_path):
_, ext = os.path.splitext(file)
if ext.lower() in self.processor.supported_formats:
image_files.append(os.path.join(folder_path, file))
if not image_files:
print("文件夹中没有找到支持的图片文件!")
return
print(f"找到 {len(image_files)} 个图片文件")
for i, image_path in enumerate(image_files, 1):
print(f"\n处理文件 {i}/{len(image_files)}: {os.path.basename(image_path)}")
self.convert_single_image(image_path)
def select_char_set(self):
"""选择字符集"""
char_sets = list(self.converter.char_sets.keys())
print("\n可用的字符集:")
for i, char_set in enumerate(char_sets, 1):
sample = self.converter.char_sets[char_set][:10] + "..."
print(f"{i}. {char_set}: {sample}")
try:
choice = int(input("请选择字符集 (1-4): ")) - 1
if 0 <= choice < len(char_sets):
self.config['char_set'] = char_sets[choice]
print(f"已选择字符集: {char_sets[choice]}")
else:
print("无效的选择!")
except ValueError:
print("请输入有效的数字!")
def camera_ascii_art(self):
"""启动摄像头ASCII艺术"""
if not CV2_AVAILABLE:
print("摄像头功能需要安装OpenCV: pip install opencv-python")
return
try:
self.camera = CameraASCII(
width=self.config['width'],
colored=self.config['colored']
)
self.camera.start_camera_ascii()
except Exception as e:
print(f"启动摄像头失败: {e}")
def run(self):
"""运行主程序"""
self.print_banner()
while True:
choice = self.show_menu()
if choice == '1':
self.single_image_conversion()
elif choice == '2':
self.batch_conversion()
elif choice == '3':
self.camera_ascii_art()
elif choice == '4':
self.show_config_menu()
elif choice == '5':
print("感谢使用ASCII艺术生成器!")
break
else:
print("无效的选择，请重新输入!")
input("\n按回车键继续...")
def show_config_menu(self):
"""显示配置菜单"""
print("\n当前配置:")
for key, value in self.config.items():
print(f"  {key}: {value}")
print("\n输入要修改的配置项名称 (或 'back' 返回): ")
config_key = input().strip()
if config_key == 'back':
return
if config_key in self.config:
if config_key == 'width':
new_value = input("请输入新的宽度: ").strip()
try:
self.config[config_key] = int(new_value)
except ValueError:
print("无效的宽度!")
elif config_key in ['colored', 'invert']:
self.config[config_key] = not self.config[config_key]
print(f"{config_key} 已设置为: {self.config[config_key]}")
elif config_key == 'char_set':
self.select_char_set()
elif config_key == 'output_dir':
new_value = input("请输入新的输出目录: ").strip()
self.config[config_key] = new_value
else:
print("无效的配置项!")

六、使用示例与高级功能

1. 基础使用示例

def quick_demo():
"""快速演示功能"""
generator = ASCIIArtGenerator()
# 示例1: 快速转换图片
sample_image = "example.jpg"  # 替换为你的图片路径
if os.path.exists(sample_image):
print("正在转换示例图片...")
generator.config['width'] = 80
generator.config['colored'] = True
generator.convert_single_image(sample_image)
else:
print("示例图片不存在，跳过演示")
def create_sample_image():
"""创建示例图片（如果没有的话）"""
try:
# 创建一个简单的示例图片
img = Image.new('RGB', (200, 150), color='white')
draw = ImageDraw.Draw(img)
# 画一个笑脸
draw.ellipse([50, 50, 150, 150], outline='black', width=2)  # 脸
draw.ellipse([75, 75, 95, 95], fill='black')  # 左眼
draw.ellipse([105, 75, 125, 95], fill='black')  # 右眼
draw.arc([75, 85, 125, 115], 0, 180, fill='black', width=2)  # 嘴巴
img.save('example.jpg')
print("已创建示例图片: example.jpg")
except Exception as e:
print(f"创建示例图片失败: {e}")
# 高级功能：自定义字符映射
class CustomASCIIConverter(AdvancedASCIIConverter):
"""支持自定义字符映射的转换器"""
def create_custom_char_set(self, chars: str):
"""创建自定义字符集"""
if len(chars) < 2:
print("字符集至少需要2个字符")
return False
self.char_sets['custom'] = chars
self.current_chars = chars
return True
def optimize_char_set_for_image(self, image: Image.Image) -> str:
"""根据图像特性优化字符集"""
# 分析图像对比度
grayscale = image.convert('L')
pixels = list(grayscale.getdata())
contrast = max(pixels) - min(pixels)
if contrast < 50:  # 低对比度图像
return '@#*+-. '  # 使用更平滑的过渡
elif contrast > 150:  # 高对比度图像
return '@%#*+=-: '  # 使用更鲜明的字符
else:
return self.char_sets['detailed']  # 使用详细字符集

2. 完整程序入口

def main():
"""主函数"""
print("ASCII艺术生成器启动中...")
# 检查依赖
try:
from PIL import Image
except ImportError:
print("错误: 需要安装Pillow库")
print("请运行: pip install Pillow")
return
# 创建示例图片（如果需要）
if not os.path.exists('example.jpg'):
create_sample_image()
# 启动生成器
generator = ASCIIArtGenerator()
# 检查命令行参数
if len(sys.argv) > 1:
# 命令行模式
image_path = sys.argv[1]
if os.path.exists(image_path):
generator.config['width'] = 100
generator.convert_single_image(image_path)
else:
print(f"文件不存在: {image_path}")
else:
# 交互模式
generator.run()
if __name__ == "__main__":
main()

七、进阶功能扩展

1. 视频转ASCII艺术

class VideoASCIIConverter:
"""视频转ASCII艺术"""
def __init__(self):
if not CV2_AVAILABLE:
raise ImportError("需要安装OpenCV: pip install opencv-python")
self.converter = AdvancedASCIIConverter()
def video_to_ascii(self, video_path: str, output_width: int = 80, 
frame_skip: int = 1, output_file: str = None):
"""将视频转换为ASCII艺术序列"""
cap = cv2.VideoCapture(video_path)
if not cap.isOpened():
print(f"无法打开视频文件: {video_path}")
return
# 获取视频信息
fps = cap.get(cv2.CAP_PROP_FPS)
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
print(f"视频信息: {fps} FPS, 总帧数: {total_frames}")
frame_count = 0
ascii_frames = []
while True:
ret, frame = cap.read()
if not ret:
break
if frame_count % frame_skip == 0:
# 转换帧为ASCII
frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
pil_image = Image.fromarray(frame_rgb)
ascii_frame = self.converter.image_to_ascii(pil_image)
ascii_frames.append(ascii_frame)
# 显示进度
progress = (frame_count / total_frames) * 100
print(f"处理进度: {progress:.1f}%", end='\r')
frame_count += 1
cap.release()
print(f"\n处理完成! 共生成 {len(ascii_frames)} 帧ASCII艺术")
# 保存或播放
if output_file:
self.save_ascii_video(ascii_frames, output_file, fps)
else:
self.play_ascii_video(ascii_frames, fps)
def play_ascii_video(self, ascii_frames: List[List[str]], fps: float):
"""播放ASCII视频"""
import time
frame_delay = 1.0 / fps
print("开始播放ASCII视频 (按Ctrl+C停止)")
try:
for frame in ascii_frames:
start_time = time.time()
# 清屏并显示当前帧
os.system('cls' if os.name == 'nt' else 'clear')
for line in frame:
print(line)
# 控制帧率
elapsed = time.time() - start_time
sleep_time = max(0, frame_delay - elapsed)
time.sleep(sleep_time)
except KeyboardInterrupt:
print("\n播放停止")

2. Web服务版本

try:
from flask import Flask, render_template, request, send_file
FLASK_AVAILABLE = True
except ImportError:
FLASK_AVAILABLE = False
if FLASK_AVAILABLE:
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/convert', methods=['POST'])
def convert_image():
if 'image' not in request.files:
return "没有上传文件", 400
file = request.files['image']
if file.filename == '':
return "没有选择文件", 400
# 保存上传的文件
upload_path = 'uploads/' + file.filename
file.save(upload_path)
# 转换图片
converter = AdvancedASCIIConverter()
width = int(request.form.get('width', 100))
colored = request.form.get('colored') == 'true'
output_path = f"output/{file.filename}_ascii.txt"
success = converter.create_ascii_art_file(
upload_path, output_path, width, colored
)
if success:
return send_file(output_path, as_attachment=True)
else:
return "转换失败", 500
def run_web_server():
"""运行Web服务器"""
print("启动Web服务器: http://localhost:5000")
app.run(debug=True)

八、使用技巧与最佳实践

1. 参数调优指南

def optimization_guide():
"""参数优化指南"""
guide = """
ASCII艺术生成器参数优化指南:
1. 输出宽度 (width)
- 小图片 (50-80): 适合表情包、图标
- 中等图片 (80-120): 适合人物肖像
- 大图片 (120-200): 适合风景照片
2. 字符集选择
- 'simple': 适合高对比度图像
- 'detailed': 适合复杂细节的图像  
- 'blocks': 适合创建像素艺术效果
- 'minimal': 适合抽象艺术
3. 颜色模式
- 开启: 保留原图色彩（需要支持颜色的终端）
- 关闭: 纯黑白艺术，兼容性更好
4. 反转颜色
- 开启: 白底黑字效果
- 关闭: 黑底白字效果（默认）
提示: 对于细节丰富的图片，建议使用较大的宽度和'detailed'字符集
"""
print(guide)

2. 故障排除

def troubleshooting():
"""常见问题解决"""
solutions = """
常见问题解决方案:
1. 图片加载失败
- 检查文件路径是否正确
- 确认文件格式支持 (JPG, PNG, BMP, GIF)
- 检查文件权限
2. ASCII艺术显示异常
- 在Windows CMD中可能不支持颜色，请关闭颜色选项
- 如果字符显示不完整，尝试减小输出宽度
- 确保终端使用等宽字体
3. 摄像头无法启动
- 检查摄像头是否被其他程序占用
- 尝试不同的摄像头索引 (0, 1, 2...)
- 在Linux上可能需要权限: sudo chmod 666 /dev/video0
4. 性能问题
- 对于大图片，减小输出宽度
- 批量处理时关闭实时预览
- 视频处理时增加帧跳过间隔
"""
print(solutions)

总结

通过这个完整的ASCII艺术生成器项目，我们学习了：

1. 图像处理基础：使用Pillow库加载、调整和转换图像
2. 字符映射算法：将像素亮度映射到合适的ASCII字符
3. 实时处理：使用OpenCV实现摄像头实时字符画
4. 用户交互：构建友好的命令行界面
5. 高级特性：彩色输出、批量处理、视频转换等

这个项目不仅有趣实用，还涵盖了Python编程的多个重要概念。你可以进一步扩展功能，比如：

• 添加更多艺术效果滤镜
• 支持动画GIF转换
• 集成到社交媒体应用
• 开发移动端版本

希望这个项目能激发你对Python编程和计算机艺术的兴趣！

---

完整代码获取：所有源代码已在上文中完整呈现，复制即可运行。建议从基础功能开始，逐步体验更高级的特性。

开始创造属于你的ASCII艺术作品吧！有任何问题欢迎在评论区讨论。