python语言学习机-音乐谱曲+绘画谱曲双模式新代码

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageDraw, ImageTk
import threading
import time
import math
import os
import pygame
import pygame.midi

class MusicAndPaintBoard:
def __init__(self, root):
self.root = root
self.root.title("学习机 – 音乐谱曲 + 绘画谱曲 双模式")
self.root.geometry("1500×900")

# 通用参数
self.current_mode = "music"
self.canvas_width = 800
self.canvas_height = 500
self.play_speed = 200
self.is_playing = False
self.current_frame = 0
self.frames = []
self.commands = []
self.enable_sound = True

# 初始化 MIDI
self.init_midi()

# MIDI 音符编号 (C4=60)
self.midi_notes = {
'1': 60, # C4 – do
'2': 62, # D4 – re
'3': 64, # E4 – mi
'4': 65, # F4 – fa
'5': 67, # G4 – sol
'6': 69, # A4 – la
'7': 71, # B4 – si
}

# 颜色映射
self.note_colors = {
'1': (255, 80, 80), '2': (255, 165, 80), '3': (255, 255, 80),
'4': (80, 255, 80), '5': (80, 150, 255), '6': (128, 80, 255),
'7': (255, 128, 255),
}

# 绘画模式参数
self.pen_x = self.canvas_width // 2
self.pen_y = self.canvas_height // 2
self.pen_angle = 0
self.pen_down = True
self.pen_color = (0, 0, 0)
self.pen_size = 3
self.step_distance = 25

self.setup_ui()
self.init_background()
self.load_demo()

def init_midi(self):
"""初始化 MIDI"""
try:
pygame.init()
pygame.midi.init()
# 打开默认输出设备
self.midi_output = pygame.midi.Output(0)
self.midi_output.set_instrument(0) # 钢琴音色
print("MIDI 初始化成功")
except Exception as e:
print(f"MIDI 初始化失败: {e}")
self.midi_output = None

def play_midi_note(self, note_num, duration, octave_shift=0):
"""播放 MIDI 音符"""
if not self.enable_sound or self.midi_output is None:
return

try:
# 计算 MIDI 音符编号
midi_note = self.midi_notes[str(note_num)]
if octave_shift == 1:
midi_note += 12 # 高八度
elif octave_shift == -1:
midi_note -= 12 # 低八度

# 播放音符 (note_on, 音量100)
self.midi_output.note_on(midi_note, 100)

# 在单独线程中等待后关闭音符
def stop_note():
time.sleep(duration / 1000.0)
self.midi_output.note_off(midi_note, 100)

threading.Thread(target=stop_note, daemon=True).start()

except Exception as e:
print(f"MIDI 播放失败: {e}")

def setup_ui(self):
"""设置界面"""
# 模式切换栏
mode_frame = ttk.Frame(self.root)
mode_frame.pack(fill=tk.X, padx=10, pady=5)

ttk.Label(mode_frame, text="选择模式:", font=("Arial", 12, "bold")).pack(side=tk.LEFT, padx=5)

self.mode_var = tk.StringVar(value="music")
ttk.Radiobutton(mode_frame, text="🎵 音乐谱曲 (MIDI简谱)",
variable=self.mode_var, value="music",
command=self.switch_mode).pack(side=tk.LEFT, padx=10)
ttk.Radiobutton(mode_frame, text="🎨 绘画谱曲 (数字画谱)",
variable=self.mode_var, value="paint",
command=self.switch_mode).pack(side=tk.LEFT, padx=10)

# 声音开关
self.sound_var = tk.BooleanVar(value=True)
ttk.Checkbutton(mode_frame, text="🔊 MIDI 声音", variable=self.sound_var,
command=self.toggle_sound).pack(side=tk.LEFT, padx=20)

# 测试声音按钮
ttk.Button(mode_frame, text="🎵 测试声音", command=self.test_sound).pack(side=tk.LEFT, padx=5)

# 主容器
main_frame = ttk.Frame(self.root)
main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

# 左侧：画布
left_frame = ttk.LabelFrame(main_frame, text="输出区域", padding=10)
left_frame.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

self.canvas = tk.Canvas(left_frame, width=self.canvas_width,
height=self.canvas_height, bg='white',
relief=tk.SUNKEN, borderwidth=2)
self.canvas.pack()

# 状态栏
status_frame = ttk.Frame(left_frame)
status_frame.pack(fill=tk.X, pady=5)
self.status_label = ttk.Label(status_frame, text="就绪 | MIDI 已加载", font=("Arial", 10))
self.status_label.pack(side=tk.LEFT)
self.frame_label = ttk.Label(status_frame, text="")
self.frame_label.pack(side=tk.RIGHT)

# 预览区
preview_frame = ttk.LabelFrame(left_frame, text="帧预览", padding=5)
preview_frame.pack(fill=tk.X, pady=5)
self.preview_canvas = tk.Canvas(preview_frame, height=100, bg='lightgray')
self.preview_canvas.pack(fill=tk.X)

# 右侧：编辑器
right_frame = ttk.Frame(main_frame)
right_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=(10, 0))

# 乐谱/画谱编辑器
editor_frame = ttk.LabelFrame(right_frame, text="简谱编辑器 (数字序列)", padding=10)
editor_frame.pack(fill=tk.BOTH, expand=True)

# 帮助信息
self.help_text = tk.Text(editor_frame, height=8, font=("Courier", 9),
bg='#f0f0f0', wrap=tk.WORD)
self.help_text.pack(fill=tk.X, pady=5)

# 输入区
input_frame = ttk.Frame(editor_frame)
input_frame.pack(fill=tk.BOTH, expand=True, pady=5)

ttk.Label(input_frame, text="简谱序列:").pack(anchor=tk.W)

text_frame = ttk.Frame(input_frame)
text_frame.pack(fill=tk.BOTH, expand=True)

self.score_text = tk.Text(text_frame, height=10, font=("Courier", 12))
self.score_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

score_scrollbar = ttk.Scrollbar(text_frame, orient=tk.VERTICAL, command=self.score_text.yview)
score_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
self.score_text.config(yscrollcommand=score_scrollbar.set)

# 快速音符按钮
notes_frame = ttk.LabelFrame(editor_frame, text="快速输入", padding=5)
notes_frame.pack(fill=tk.X, pady=5)

self.note_buttons_frame = ttk.Frame(notes_frame)
self.note_buttons_frame.pack()
self.update_quick_buttons()

# 控制按钮
control_frame = ttk.Frame(editor_frame)
control_frame.pack(fill=tk.X, pady=5)

ttk.Button(control_frame, text="▶ 播放", command=self.play).pack(side=tk.LEFT, padx=2, expand=True, fill=tk.X)
ttk.Button(control_frame, text="⏸ 暂停", command=self.pause).pack(side=tk.LEFT, padx=2, expand=True, fill=tk.X)
ttk.Button(control_frame, text="⏹ 停止", command=self.stop).pack(side=tk.LEFT, padx=2, expand=True, fill=tk.X)
ttk.Button(control_frame, text="💾 保存", command=self.save_score).pack(side=tk.LEFT, padx=2, expand=True,
fill=tk.X)
ttk.Button(control_frame, text="📁 加载", command=self.load_score).pack(side=tk.LEFT, padx=2, expand=True,
fill=tk.X)
ttk.Button(control_frame, text="📤 导出", command=self.export_file).pack(side=tk.LEFT, padx=2, expand=True,
fill=tk.X)

# 速度控制
speed_frame = ttk.Frame(editor_frame)
speed_frame.pack(fill=tk.X, pady=5)
ttk.Label(speed_frame, text="播放速度:").pack(side=tk.LEFT)
self.speed_var = tk.IntVar(value=120)
speed_scale = ttk.Scale(speed_frame, from_=100, to=1000, variable=self.speed_var,
orient=tk.HORIZONTAL, length=200, command=self.update_speed)
speed_scale.pack(side=tk.LEFT, padx=5, expand=True, fill=tk.X)
self.speed_label = ttk.Label(speed_frame, text="120ms")
self.speed_label.pack(side=tk.LEFT)

# 命令列表
list_frame = ttk.LabelFrame(right_frame, text="解析后的序列", padding=5)
list_frame.pack(fill=tk.BOTH, expand=True, pady=5)

self.command_listbox = tk.Listbox(list_frame, height=6, font=("Courier", 10))
self.command_listbox.pack(fill=tk.BOTH, expand=True)

list_scrollbar = ttk.Scrollbar(list_frame, orient=tk.VERTICAL, command=self.command_listbox.yview)
list_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
self.command_listbox.config(yscrollcommand=list_scrollbar.set)

self.update_help_text()

def test_sound(self):
"""测试 MIDI 声音"""
if self.midi_output:
self.play_midi_note(1, 500, 0)
self.status_label.config(text="测试声音: 播放 do 音")

def toggle_sound(self):
"""切换声音"""
self.enable_sound = self.sound_var.get()

def update_quick_buttons(self):
"""更新快速按钮"""

for widget in self.note_buttons_frame.winfo_children():
widget.destroy()

if self.mode_var.get() == "music":
music_buttons = [
('1 do', '1'), ('2 re', '2'), ('3 mi', '3'), ('4 fa', '4'),
('5 sol', '5'), ('6 la', '6'), ('7 si', '7'),
('- 延长', '-'), ('. 低音', '.'), ("' 高音", "'"),
('| 小节', '|'), ('_ 八分', '_'), ('🎵 示例曲', 'demo_song'), ('清空', 'clear')
]
for i, (text, note) in enumerate(music_buttons):
if note == 'clear':
btn = ttk.Button(self.note_buttons_frame, text=text, width=6,
command=self.clear_score)
else:
btn = ttk.Button(self.note_buttons_frame, text=text, width=6,
command=lambda n=note: self.insert_note(n))
btn.grid(row=i // 7, column=i % 7, padx=2, pady=2)
else:
paint_buttons = [
('1前进', '1'), ('2后退', '2'), ('3左转', '3'), ('4右转', '4'),
('5抬笔', '5'), ('6落笔', '6'), ('7颜色', '7'),
('8画圆', '8'), ('9画方', '9'), ('0清屏', '0'), ('.画点', '.'),
('红', '7 1'), ('绿', '7 2'), ('蓝', '7 3'), ('清空', 'clear'),
('左转45', '3 45'), ('右转45', '4 45')
]
for i, (text, note) in enumerate(paint_buttons):
if note == 'clear':
btn = ttk.Button(self.note_buttons_frame, text=text, width=6,
command=self.clear_score)
else:
btn = ttk.Button(self.note_buttons_frame, text=text, width=6,
command=lambda n=note: self.insert_note(n))
btn.grid(row=i // 9, column=i % 9, padx=2, pady=2)

def update_help_text(self):
"""更新帮助文本"""
self.help_text.delete("1.0", tk.END)

if self.mode_var.get() == "music":
help_text = """
╔══════════════════════════════════════════════════════════════════════════════╗
║ 🎵 音乐简谱编辑器 (MIDI 专业音色) ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ 音符: 1=do 2=re 3=mi 4=fa 5=sol 6=la 7=si ║
║ 时值: – 延长一倍 _ 八分音符 数字后无符号=四分音符 ║
║ 音高: .低音 '高音 (如 1. 低音do, 1' 高音do) ║
║ 使用 MIDI 钢琴音色播放，声音更专业！ ║
║ 示例: 1 2 3 4 5 6 7 | 1- 2- 3- 4- | 1. 2. 3. 4. | 1' 2' 3' 4' ║
╚══════════════════════════════════════════════════════════════════════════════╝
"""
else:
help_text = """
╔══════════════════════════════════════════════════════════════════════════════╗
║ 🎨 绘画简谱编辑器 (支持任意角度) ║
╠══════════════════════════════════════════════════════════════════════════════╣
║ 1=前进 2=后退 3=左转角度 4=右转角度 5=抬笔 6=落笔 ║
║ 7=颜色 8=画圆 9=画方 0=清屏 .=画点 ║
║ ║
║ 角度用法: ║
║ 3 90 – 左转90度 ║
║ 3 45 – 左转45度 ║
║ 4 30 – 右转30度 ║
║ ║
║ 示例1(正方形): 1 1 1 1 3 90 1 1 1 1 3 90 1 1 1 1 3 90 1 1 1 1 ║
║ 示例2(正六边形): 1 1 1 1 3 60 增加6次 ║
║ 示例3：1 3 30 增加11次 ║
╚══════════════════════════════════════════════════════════════════════════════╝
"""
self.help_text.insert(tk.END, help_text)

def switch_mode(self):
"""切换模式"""
self.update_help_text()
self.update_quick_buttons()
self.init_background()
self.load_demo()
self.stop()

def init_background(self):
"""初始化背景"""
self.background = Image.new('RGB', (self.canvas_width, self.canvas_height), (255, 255, 255))
draw = ImageDraw.Draw(self.background)

if self.mode_var.get() == "music":
staff_y = [150, 180, 210, 240, 270]
for y in staff_y:
draw.line((50, y, self.canvas_width – 50, y), fill=(0, 0, 0), width=1)
draw.text((60, 155), "𝄞", fill=(100, 100, 100))
for x in range(100, self.canvas_width – 50, 100):
draw.line((x, 140, x, 280), fill=(0, 0, 0), width=1)
else:
step = 40
for x in range(0, self.canvas_width, step):
draw.line((x, 0, x, self.canvas_height), fill=(230, 230, 230), width=1)
for y in range(0, self.canvas_height, step):
draw.line((0, y, self.canvas_width, y), fill=(230, 230, 230), width=1)
draw.ellipse((self.canvas_width // 2 – 5, self.canvas_height // 2 – 5,
self.canvas_width // 2 + 5, self.canvas_height // 2 + 5),
fill=(200, 200, 200))
draw.line((0, self.canvas_height // 2, self.canvas_width, self.canvas_height // 2),
fill=(180, 180, 180), width=1)
draw.line((self.canvas_width // 2, 0, self.canvas_width // 2, self.canvas_height),
fill=(180, 180, 180), width=1)

self.image = self.background.copy()
self.update_display()

def load_demo(self):
"""加载演示内容"""
if self.mode_var.get() == "music":
demo = "553-5'5'3'-35513-3-1332126.-6.216.116.-"
else:
demo = "553-5'5'3'-35513-3-1332126.-6.216.116.-"
self.score_text.delete("1.0", tk.END)
self.score_text.insert(tk.END, demo)

def insert_note(self, note):
"""插入音符/指令"""
current = self.score_text.get("1.0", tk.END).strip()
if note == 'clear':
self.clear_score()
elif note == 'demo_song':
self.load_demo_song()
else:
new_text = current + " " + note if current else note
self.score_text.delete("1.0", tk.END)
self.score_text.insert(tk.END, new_text)

def load_demo_song(self):
"""加载示例歌曲（送别变奏曲）"""
demo = "5-351'–76-1'-5—5-123-212—-5-351'–76-1'-5—5-234–7.1—-"
self.score_text.delete("1.0", tk.END)
self.score_text.insert(tk.END, demo)
self.status_label.config(text="已加载示例曲谱，点击播放")

def clear_score(self):
"""清空输入"""
self.score_text.delete("1.0", tk.END)

def parse_music_score(self, text):
"""解析音乐简谱（支持无空格连续格式）"""
notes = []

# 先移除所有空格和换行
text = text.strip().replace(' ', '').replace('\\n', '').replace('\\r', '')

i = 0
length = len(text)

while i < length:
char = text[i]

if char == '|':
notes.append(('bar', 0))
i += 1
continue

# 解析音符 (1-7)
if char in self.midi_notes:
note_num = int(char)
duration = 400 # 默认四分音符
octave_shift = 0
i += 1

# 解析后续修饰符
while i < length:
next_char = text[i]
if next_char == '-':
duration = 800 # 延长一倍
i += 1
elif next_char == '_':
duration = 200 # 八分音符
i += 1
elif next_char == '=':
duration = 100 # 十六分音符
i += 1
elif next_char == '.':
octave_shift = -1 # 低音
i += 1
elif next_char == "'":
octave_shift = 1 # 高音
i += 1
else:
break

notes.append(('note', note_num, octave_shift, duration))

# 跳过其他字符（如空格、换行等已经在开头处理了）
else:
i += 1

return notes

def parse_paint_score(self, text):
"""解析绘画简谱"""
commands = []
tokens = text.split()

i = 0
while i < len(tokens):
token = tokens[i]

if token == '1':
commands.append(('forward', self.step_distance))
elif token == '2':
commands.append(('backward', self.step_distance))
elif token == '3':
angle = 90
if i + 1 < len(tokens):
try:
angle = int(tokens[i + 1])
i += 1
except:
pass
commands.append(('left', angle))
elif token == '4':
angle = 90
if i + 1 < len(tokens):
try:
angle = int(tokens[i + 1])
i += 1
except:
pass
commands.append(('right', angle))
elif token == '5':
commands.append(('pen_up',))
elif token == '6':
commands.append(('pen_down',))
elif token == '7':
if i + 1 < len(tokens):
color_num = tokens[i + 1]
color_map = {'1': (255, 0, 0), '2': (0, 255, 0), '3': (0, 0, 255),
'4': (255, 255, 0), '5': (255, 0, 255), '6': (0, 255, 255)}
if color_num in color_map:
commands.append(('color', color_map[color_num]))
i += 1
elif token == '8':
if i + 1 < len(tokens):
try:
radius = int(tokens[i + 1])
commands.append(('circle', radius))
i += 1
except:
commands.append(('circle', 30))
elif token == '9':
if i + 1 < len(tokens):
try:
size = int(tokens[i + 1])
commands.append(('rect', size))
i += 1
except:
commands.append(('rect', 40))
elif token == '0':
commands.append(('clear',))
elif token == '.':
commands.append(('dot',))

i += 1

return commands

def play(self):
"""播放"""
text = self.score_text.get("1.0", tk.END).strip()
if not text:
messagebox.showwarning("警告", "请输入简谱内容！")
return

if self.mode_var.get() == "music":
self.play_music(text)
else:
self.play_paint(text)

def play_music(self, text):
"""播放音乐模式（支持无空格连续简谱）"""
notes = self.parse_music_score(text)

if not notes:
messagebox.showwarning("警告", "无法解析乐谱！")
return

self.commands = notes
self.frames = []
self.note_timing = []
current_img = self.background.copy()
draw = ImageDraw.Draw(current_img)

x_pos = 100
frame_index = 0

for note_info in notes:
if note_info[0] == 'bar':
draw.line((x_pos, 140, x_pos, 280), fill=(0, 0, 0), width=2)
x_pos += 30
for _ in range(2):
self.frames.append(current_img.copy())
frame_index += 1
continue

_, note_num, octave, duration = note_info

# 计算Y位置
base_y = 210
y_pos = base_y – (note_num – 4) * 15 – octave * 20
y_pos = max(50, min(self.canvas_height – 50, y_pos))

# 画音符
color = self.note_colors[str(note_num)]
draw.ellipse((x_pos – 10, y_pos – 10, x_pos + 10, y_pos + 10), fill=color, outline=(0, 0, 0), width=1)
draw.line((x_pos + 10, y_pos, x_pos + 10, y_pos – 40), fill=(0, 0, 0), width=2)

# 添加音符文字
octave_mark = ""
if octave == 1:
octave_mark = "'"
elif octave == -1:
octave_mark = "."
draw.text((x_pos – 8, y_pos – 25), f"{note_num}{octave_mark}", fill=(0, 0, 0))

# 时值标记（延长线）
if duration >= 800:
draw.line((x_pos + 15, y_pos – 20, x_pos + 45, y_pos – 20), fill=(0, 0, 0), width=2)
elif duration <= 200:
draw.line((x_pos + 15, y_pos – 20, x_pos + 25, y_pos – 20), fill=(0, 0, 0), width=1)

# 关键修改：根据声音时长计算帧数，让动画和声音同步
# 帧数 = 声音时长(ms) / 每帧时长(ms)
frame_count = max(2, int(duration / self.play_speed))

start_frame = frame_index
for _ in range(frame_count):
self.frames.append(current_img.copy())
frame_index += 1

# 存储音符信息
self.note_timing.append({
'start_frame': start_frame,
'duration': duration, # 使用原始时长
'note_num': note_num,
'octave': octave
})

# 移动位置，根据时值调整间距
if duration >= 800:
x_pos += 55
elif duration <= 200:
x_pos += 35
else:
x_pos += 45

if x_pos > self.canvas_width – 60:
x_pos = 60

# 结束帧
for _ in range(5):
self.frames.append(current_img.copy())

# 显示解析结果
cmd_list = []
for n in notes:
if n[0] == 'note':
mark = ""
if n[2] == -1:
mark = "."
elif n[2] == 1:
mark = "'"
dur_str = ""
if n[3] >= 800:
dur_str = "-"
elif n[3] <= 200:
dur_str = "_"
cmd_list.append(f"{n[1]}{mark}{dur_str}")
self.update_command_list(cmd_list)

self.start_playback_with_sound()
self.status_label.config(text=f"音乐模式 – 解析 {len([n for n in notes if n[0] == 'note'])} 个音符")

def start_playback_with_sound(self):
"""开始播放（带声音同步）"""
if not self.frames:
messagebox.showwarning("警告", "没有生成动画！")
return

self.current_frame = 0
self.is_playing = True
self.sound_triggered = set() # 记录已触发的声音
self.update_display()
threading.Thread(target=self._play_with_sound, daemon=True).start()

def _play_with_sound(self):
"""带声音同步的播放线程"""
while self.is_playing and self.current_frame < len(self.frames):
# 检查是否需要触发音符声音
for note_info in self.note_timing:
frame_idx = note_info['start_frame']
if frame_idx not in self.sound_triggered and self.current_frame >= frame_idx:
# 到达该音符的起始帧，播放声音
self.sound_triggered.add(frame_idx)
self.play_midi_note(
note_info['note_num'],
note_info['duration'],
note_info['octave']
)

time.sleep(self.play_speed / 1000.0)
self.current_frame += 1
self.root.after(0, self.update_display)
self.root.after(0, self.update_preview)

def play_paint(self, text):
"""播放绘画模式"""
commands = self.parse_paint_score(text)

if not commands:
messagebox.showwarning("警告", "无法解析绘画指令！")
return

self.commands = commands

self.pen_x = self.canvas_width // 2
self.pen_y = self.canvas_height // 2
self.pen_angle = 0
self.pen_down = True
self.pen_color = (0, 0, 0)

self.frames = []
current_img = self.background.copy()
draw = ImageDraw.Draw(current_img)

for cmd in commands:
if cmd[0] == 'forward':
step = cmd[1]
rad = math.radians(self.pen_angle)
new_x = self.pen_x + step * math.cos(rad)
new_y = self.pen_y + step * math.sin(rad)
if self.pen_down:
draw.line((self.pen_x, self.pen_y, new_x, new_y),
fill=self.pen_color, width=self.pen_size)
self.pen_x, self.pen_y = new_x, new_y
for _ in range(10):
self.frames.append(current_img.copy())

elif cmd[0] == 'backward':
step = cmd[1]
rad = math.radians(self.pen_angle)
new_x = self.pen_x – step * math.cos(rad)
new_y = self.pen_y – step * math.sin(rad)
if self.pen_down:
draw.line((self.pen_x, self.pen_y, new_x, new_y),
fill=self.pen_color, width=self.pen_size)
self.pen_x, self.pen_y = new_x, new_y
for _ in range(10):
self.frames.append(current_img.copy())

elif cmd[0] == 'left':
self.pen_angle -= cmd[1]
for _ in range(5):
self.frames.append(current_img.copy())

elif cmd[0] == 'right':
self.pen_angle += cmd[1]
for _ in range(5):
self.frames.append(current_img.copy())

elif cmd[0] == 'pen_up':
self.pen_down = False
for _ in range(5):
self.frames.append(current_img.copy())

elif cmd[0] == 'pen_down':
self.pen_down = True
for _ in range(5):
self.frames.append(current_img.copy())

elif cmd[0] == 'color':
self.pen_color = cmd[1]
for _ in range(5):
self.frames.append(current_img.copy())

elif cmd[0] == 'circle':
radius = cmd[1]
draw.ellipse((self.pen_x – radius, self.pen_y – radius,
self.pen_x + radius, self.pen_y + radius),
outline=self.pen_color, width=self.pen_size)
for _ in range(15):
self.frames.append(current_img.copy())

elif cmd[0] == 'rect':
size = cmd[1]
draw.rectangle((self.pen_x – size, self.pen_y – size,
self.pen_x + size, self.pen_y + size),
outline=self.pen_color, width=self.pen_size)
for _ in range(15):
self.frames.append(current_img.copy())

elif cmd[0] == 'clear':
current_img = self.background.copy()
draw = ImageDraw.Draw(current_img)
for _ in range(5):
self.frames.append(current_img.copy())

elif cmd[0] == 'dot':
draw.ellipse((self.pen_x – 4, self.pen_y – 4,
self.pen_x + 4, self.pen_y + 4),
fill=self.pen_color)
for _ in range(10):
self.frames.append(current_img.copy())

cmd_names = {
'forward': '前进', 'backward': '后退', 'left': '左转', 'right': '右转',
'pen_up': '抬笔', 'pen_down': '落笔', 'color': '换色', 'circle': '画圆',
'rect': '画方', 'clear': '清屏', 'dot': '画点'
}

display_cmds = []
for c in commands:
if c[0] == 'left':
display_cmds.append(f'左转{c[1]}°')
elif c[0] == 'right':
display_cmds.append(f'右转{c[1]}°')
else:
display_cmds.append(cmd_names.get(c[0], c[0]))
self.update_command_list(display_cmds)

self.start_playback()
self.status_label.config(text=f"绘画模式 – 已生成 {len(self.frames)} 帧")

def update_command_list(self, commands):
"""更新命令列表"""
self.command_listbox.delete(0, tk.END)
for i, cmd in enumerate(commands[:30]):
self.command_listbox.insert(tk.END, f"{i + 1}: {cmd}")

def start_playback(self):
"""开始播放"""
if not self.frames:
messagebox.showwarning("警告", "没有生成动画！")
return

self.current_frame = 0
self.is_playing = True
self.update_display()
threading.Thread(target=self._play, daemon=True).start()

def _play(self):
while self.is_playing and self.current_frame < len(self.frames):
time.sleep(self.play_speed / 1000.0)
self.current_frame += 1
self.root.after(0, self.update_display)
self.root.after(0, self.update_preview)

def update_display(self):
"""更新显示"""
if self.current_frame < len(self.frames):
img = self.frames[self.current_frame]
img_resized = img.resize((self.canvas_width, self.canvas_height), Image.Resampling.LANCZOS)
img_tk = ImageTk.PhotoImage(img_resized)
self.canvas.delete("all")
self.canvas.create_image(0, 0, anchor=tk.NW, image=img_tk)
self.canvas.image = img_tk
self.frame_label.config(text=f"帧: {self.current_frame + 1}/{len(self.frames)}")

def update_preview(self):
"""更新预览"""
self.preview_canvas.delete("all")
if not self.frames:
return

preview_height = 80
preview_width = int(preview_height * self.canvas_width / self.canvas_height)
cols = min(10, len(self.frames))

for i in range(cols):
x = i * (preview_width + 5) + 5
frame_idx = int(i * len(self.frames) / cols)
if frame_idx < len(self.frames):
img_small = self.frames[frame_idx].resize((preview_width, preview_height), Image.Resampling.LANCZOS)
img_tk = ImageTk.PhotoImage(img_small)
self.preview_canvas.create_image(x, 10, anchor=tk.NW, image=img_tk)
self.preview_canvas.image = img_tk

def pause(self):
self.is_playing = False
self.status_label.config(text="已暂停")

def stop(self):
self.is_playing = False
self.current_frame = 0
self.update_display()
self.status_label.config(text="已停止")

def update_speed(self, *args):
self.play_speed = self.speed_var.get()
self.speed_label.config(text=f"{self.play_speed}ms")

def save_score(self):
"""保存乐谱/画谱"""
text = self.score_text.get("1.0", tk.END).strip()
if not text:
messagebox.showwarning("警告", "没有内容可保存！")
return

ext = ".music" if self.mode_var.get() == "music" else ".paint"
filename = filedialog.asksaveasfilename(defaultextension=ext,
filetypes=[("简谱文件", f"*{ext}"), ("文本文件", "*.txt")])
if filename:
try:
with open(filename, 'w', encoding='utf-8') as f:
f.write(text)
messagebox.showinfo("成功", f"已保存到: {filename}")
except Exception as e:
messagebox.showerror("错误", f"保存失败: {str(e)}")

def load_score(self):
"""加载乐谱/画谱"""
ext = ".music" if self.mode_var.get() == "music" else ".paint"
filename = filedialog.askopenfilename(filetypes=[("简谱文件", f"*{ext}"), ("文本文件", "*.txt")])
if filename:
try:
with open(filename, 'r', encoding='utf-8') as f:
text = f.read()
self.score_text.delete("1.0", tk.END)
self.score_text.insert(tk.END, text)
messagebox.showinfo("成功", "已加载文件")
except Exception as e:
messagebox.showerror("错误", f"加载失败: {str(e)}")

def export_file(self):
"""导出文件"""
if self.mode_var.get() == "music":
self.export_text()
else:
self.export_gif()

def export_text(self):
"""导出文本格式"""
text = self.score_text.get("1.0", tk.END).strip()
filename = filedialog.asksaveasfilename(defaultextension=".txt",
filetypes=[("文本文件", "*.txt")])
if filename:
try:
with open(filename, 'w', encoding='utf-8') as f:
f.write(f"=== 音乐简谱 ===\\n")
f.write(f"速度: {self.play_speed}ms/拍\\n")
f.write(f"序列:\\n{text}\\n")
messagebox.showinfo("成功", "已导出文件")
except Exception as e:
messagebox.showerror("错误", f"导出失败: {str(e)}")

def export_gif(self):
"""导出GIF"""
if not self.frames:
messagebox.showwarning("警告", "没有动画可导出！请先播放生成动画")
return

filename = filedialog.asksaveasfilename(defaultextension=".gif",
filetypes=[("GIF动画", "*.gif")])
if filename:
try:
self.frames[0].save(filename, save_all=True,
append_images=self.frames[1:],
duration=self.play_speed, loop=0)
messagebox.showinfo("成功", f"GIF已保存！")
except Exception as e:
messagebox.showerror("错误", f"导出失败: {str(e)}")

def __del__(self):
"""清理 MIDI 资源"""
try:
if hasattr(self, 'midi_output') and self.midi_output:
self.midi_output.close()
pygame.midi.quit()
pygame.quit()
except:
pass

if __name__ == "__main__":
root = tk.Tk()
app = MusicAndPaintBoard(root)
root.mainloop()