Python绘制钢琴键的实现方法与技巧

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
from matplotlib.collections import PatchCollection
 
class PianoKeyboard:
    def __init__(self, start_note='A0', end_note='C8'):
        """
        钢琴键盘类初始化
        
        Args:
            start_note: 起始音符（如'A0'表示最低音）
            end_note: 结束音符（如'C8'表示最高音）
        """
        # 音符序列定义
        self.notes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
        self.start_note = start_note
        self.end_note = end_note
        
        # 键盘尺寸参数（单位：像素）
        self.white_key_width = 40
        self.white_key_height = 200
        self.black_key_width = 25
        self.black_key_height = 120
        
        # 计算键盘范围
        self.start_octave = int(start_note[-1])
        self.end_octave = int(end_note[-1])
        self.start_note_index = self.notes.index(start_note[:-1])
        self.end_note_index = self.notes.index(end_note[:-1])

def calculate_key_positions(self):
    """计算所有键的精确位置坐标"""
    white_key_positions = []
    black_key_positions = []
    
    # 白键位置计算
    white_key_index = 0
    for octave in range(self.start_octave, self.end_octave + 1):
        for note in self.notes:
            if '#' not in note:  # 白键
                x_position = white_key_index * self.white_key_width
                white_key_positions.append({
                    'note': f"{note}{octave}",
                    'x': x_position,
                    'y': 0,
                    'width': self.white_key_width,
                    'height': self.white_key_height,
                    'type': 'white'
                })
                white_key_index += 1
            else:  # 黑键
                # 黑键位置相对于白键偏移
                if note in ['C#', 'D#']:
                    offset = -0.3 if note == 'C#' else 0.3
                elif note in ['F#', 'G#', 'A#']:
                    offset = -0.45 if note == 'F#' else (0.15 if note == 'G#' else 0.75)
                
                x_position = (white_key_index - 1) * self.white_key_width + offset * self.white_key_width
                black_key_positions.append({
                    'note': f"{note}{octave}",
                    'x': x_position,
                    'y': 0,
                    'width': self.black_key_width,
                    'height': self.black_key_height,
                    'type': 'black'
                })
    
    return white_key_positions, black_key_positions

class PianoRenderer:
    def __init__(self, keyboard):
        """
        钢琴键盘渲染器
        
        Args:
            keyboard: PianoKeyboard实例
        """
        self.keyboard = keyboard
        self.white_keys, self.black_keys = keyboard.calculate_key_positions()
        
        # 使用TRAE IDE的matplotlib集成支持，可以实时预览图形效果
        self.fig, self.ax = plt.subplots(figsize=(12, 6))
        self.setup_figure()
    
    def setup_figure(self):
        """设置图形参数和样式"""
        # 设置坐标轴范围
        total_width = len(self.white_keys) * self.keyboard.white_key_width
        self.ax.set_xlim(0, total_width)
        self.ax.set_ylim(0, self.keyboard.white_key_height + 20)
        
        # 移除坐标轴
        self.ax.set_xticks([])
        self.ax.set_yticks([])
        
        # 设置背景色
        self.fig.patch.set_facecolor('#f0f0f0')
        self.ax.set_facecolor('#f0f0f0')
        
        # 调整布局
        plt.tight_layout()

def render_keys_optimized(self):
    """使用PatchCollection优化批量绘制性能"""
    white_patches = []
    black_patches = []
    
    # 创建白键图形对象
    for key in self.white_keys:
        rect = Rectangle(
            (key['x'], key['y']), 
            key['width'], 
            key['height'],
            facecolor='white',
            edgecolor='black',
            linewidth=1
        )
        white_patches.append(rect)
    
    # 创建黑键图形对象
    for key in self.black_keys:
        rect = Rectangle(
            (key['x'], key['y']), 
            key['width'], 
            key['height'],
            facecolor='black',
            edgecolor='black',
            linewidth=1
        )
        black_patches.append(rect)
    
    # 使用PatchCollection批量添加
    white_collection = PatchCollection(white_patches, match_original=True)
    black_collection = PatchCollection(black_patches, match_original=True)
    
    self.ax.add_collection(white_collection)
    self.ax.add_collection(black_collection)
    
    return white_collection, black_collection

def calculate_black_key_position(self, white_key_index, note_type):
    """
    计算黑键相对于白键的精确位置
    
    Args:
        white_key_index: 白键索引
        note_type: 黑键类型（C#, D#, F#, G#, A#）
    
    Returns:
        相对位置偏移量
    """
    # 黑键位置映射表
    position_map = {
        'C#': 0.7,   # C#位于C和D键之间，偏向C
        'D#': 0.3,   # D#位于D和E键之间，偏向D
        'F#': 0.7,   # F#位于F和G键之间，偏向F
        'G#': 0.5,   # G#位于G和A键之间，居中
        'A#': 0.3    # A#位于A和B键之间，偏向A
    }
    
    return position_map.get(note_type, 0.5)
 
def generate_keyboard_layout(self):
    """生成完整的键盘布局数据"""
    layout = []
    white_key_count = 0
    
    # 生成八度循环
    for octave in range(self.start_octave, self.end_octave + 1):
        for i, note in enumerate(self.notes):
            if '#' not in note:
                # 白键
                key_data = {
                    'note': f"{note}{octave}",
                    'frequency': self.calculate_frequency(note, octave),
                    'position': white_key_count,
                    'type': 'white',
                    'geometry': {
                        'x': white_key_count * self.white_key_width,
                        'y': 0,
                        'width': self.white_key_width,
                        'height': self.white_key_height
                    }
                }
                layout.append(key_data)
                white_key_count += 1
            else:
                # 黑键 - 需要找到对应的白键位置
                base_note = note.replace('#', '')
                base_position = None
                
                # 找到基础音的位置
                for key in layout:
                    if key['note'] == f"{base_note}{octave}" and key['type'] == 'white':
                        base_position = key['position']
                        break
                
                if base_position is not None:
                    offset = self.calculate_black_key_position(base_position, note)
                    
                    key_data = {
                        'note': f"{note}{octave}",
                        'frequency': self.calculate_frequency(note, octave),
                        'base_position': base_position,
                        'offset': offset,
                        'type': 'black',
                        'geometry': {
                            'x': (base_position + offset) * self.white_key_width - self.black_key_width/2,
                            'y': 0,
                            'width': self.black_key_width,
                            'height': self.black_key_height
                        }
                    }
                    layout.append(key_data)
    
    return layout

def calculate_frequency(self, note, octave):
    """
    根据音符和八度计算频率
    
    Args:
        note: 音符名称（如'C', 'C#'）
        octave: 八度数（0-8）
    
    Returns:
        频率值（Hz）
    """
    # A4 = 440Hz的标准
    note_positions = {'C': -9, 'C#': -8, 'D': -7, 'D#': -6, 'E': -5, 'F': -4, 
                     'F#': -3, 'G': -2, 'G#': -1, 'A': 0, 'A#': 1, 'B': 2}
    
    # 计算相对于A4的半音数
    semitones_from_a4 = (octave - 4) * 12 + note_positions[note]
    
    # 使用十二平均律计算频率
    frequency = 440 * (2 ** (semitones_from_a4 / 12))
    
    return round(frequency, 2)

from matplotlib.widgets import Button
import matplotlib.animation as animation
 
class InteractivePiano(PianoRenderer):
    def __init__(self, keyboard):
        super().__init__(keyboard)
        self.pressed_keys = set()
        self.key_rects = {}  # 存储键的图形对象
        self.setup_interaction()
        
    def setup_interaction(self):
        """设置交互功能"""
        # 连接鼠标事件
        self.fig.canvas.mpl_connect('button_press_event', self.on_key_press)
        self.fig.canvas.mpl_connect('button_release_event', self.on_key_release)
        self.fig.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
        
        # 存储所有键的图形对象引用
        self.store_key_references()
        
        # 启用交互模式
        plt.ion()
    
    def store_key_references(self):
        """存储所有键的图形对象引用以便快速访问"""
        # 创建白键
        for key in self.white_keys:
            rect = Rectangle(
                (key['x'], key['y']), 
                key['width'], 
                key['height'],
                facecolor='white',
                edgecolor='black',
                linewidth=1,
                picker=True  # 启用拾取功能
            )
            self.ax.add_patch(rect)
            self.key_rects[key['note']] = rect
        
        # 创建黑键
        for key in self.black_keys:
            rect = Rectangle(
                (key['x'], key['y']), 
                key['width'], 
                key['height'],
                facecolor='black',
                edgecolor='black',
                linewidth=1,
                picker=True
            )
            self.ax.add_patch(rect)
            self.key_rects[key['note']] = rect

import numpy as np
import sounddevice as sd
 
class PianoAudio:
    def __init__(self, sample_rate=44100):
        """
        钢琴音频系统
        
        Args:
            sample_rate: 采样率
        """
        self.sample_rate = sample_rate
        self.active_notes = {}
        
    def generate_tone(self, frequency, duration=0.5, volume=0.3):
        """
        生成指定频率的音调
        
        Args:
            frequency: 频率（Hz）
            duration: 持续时间（秒）
            volume: 音量（0-1）
        
        Returns:
            音频数据数组
        """
        # 生成时间数组
        t = np.linspace(0, duration, int(self.sample_rate * duration), False)
        
        # 生成正弦波并添加泛音
        fundamental = np.sin(2 * np.pi * frequency * t)
        
        # 添加几个泛音使音色更丰富
        harmonic2 = 0.5 * np.sin(2 * np.pi * frequency * 2 * t)
        harmonic3 = 0.25 * np.sin(2 * np.pi * frequency * 3 * t)
        harmonic4 = 0.125 * np.sin(2 * np.pi * frequency * 4 * t)
        
        # 组合波形
        wave = fundamental + harmonic2 + harmonic3 + harmonic4
        
        # 应用音量包络（ADSR）
        envelope = self.create_envelope(len(wave))
        wave *= envelope
        
        # 应用音量
        wave *= volume
        
        # 转换为立体声
        stereo_wave = np.column_stack([wave, wave])
        
        return stereo_wave
    
    def create_envelope(self, length):
        """创建ADSR音量包络"""
        # 简单的指数衰减包络
        t = np.arange(length)
        decay = np.exp(-t / (length * 0.3))  # 30%的衰减时间常数
        return decay
    
    def play_note(self, note, frequency):
        """播放音符"""
        if note not in self.active_notes:
            # 生成音频数据
            audio_data = self.generate_tone(frequency)
            
            # 播放音频
            sd.play(audio_data, self.sample_rate)
            self.active_notes[note] = True
    
    def stop_note(self, note):
        """停止播放音符"""
        if note in self.active_notes:
            # 这里可以实现淡出的停止效果
            del self.active_notes[note]

class OptimizedPianoRenderer:
    def __init__(self, keyboard):
        self.keyboard = keyboard
        self.render_cache = {}
        self.use_blitting = True
        self.background = None
        
    def render_with_blitting(self):
        """使用blitting技术优化渲染性能"""
        # 保存背景
        self.background = self.fig.canvas.copy_from_bbox(self.ax.bbox)
        
        # 绘制静态元素
        self.render_static_keys()
        
        # 创建动态元素的艺术家列表
        self.dynamic_artists = []
        
        # 使用blitting进行动态更新
        self.fig.canvas.blit(self.ax.bbox)
    
    def update_key_visual(self, note, is_pressed):
        """高效更新键的视觉状态"""
        if note in self.key_rects:
            # 恢复背景
            self.fig.canvas.restore_region(self.background)
            
            # 更新键的颜色
            key_rect = self.key_rects[note]
            if is_pressed:
                key_rect.set_facecolor('#ff6b6b')  # 按下时的颜色
            else:
                # 恢复原色
                original_color = 'white' if '♯' not in note else 'black'
                key_rect.set_facecolor(original_color)
            
            # 重新绘制
            self.ax.draw_artist(key_rect)
            self.fig.canvas.blit(self.ax.bbox)
            
    def implement_level_of_detail(self):
        """实现细节层次（LOD）系统"""
        # 根据缩放级别调整渲染细节
        zoom_level = self.get_current_zoom()
        
        if zoom_level < 0.5:
            # 远距离：简化渲染
            self.render_simplified_keys()
        elif zoom_level < 1.5:
            # 中等距离：标准渲染
            self.render_standard_keys()
        else:
            # 近距离：高质量渲染
            self.render_detailed_keys()

import weakref
import gc
 
class MemoryOptimizedPiano:
    def __init__(self):
        self.weak_ref_cache = weakref.WeakValueDictionary()
        self.object_pool = []
        
    def get_cached_object(self, key):
        """使用弱引用缓存获取对象"""
        return self.weak_ref_cache.get(key)
    
    def cache_object(self, key, obj):
        """缓存对象使用弱引用"""
        self.weak_ref_cache[key] = obj
    
    def object_pooling(self, obj_type, *args, **kwargs):
        """对象池化减少内存分配"""
        # 从池中获取可用对象
        for obj in self.object_pool:
            if type(obj) == obj_type and not obj.in_use:
                obj.reset(*args, **kwargs)
                obj.in_use = True
                return obj
        
        # 创建新对象
        new_obj = obj_type(*args, **kwargs)
        new_obj.in_use = True
        self.object_pool.append(new_obj)
        return new_obj
    
    def cleanup_resources(self):
        """清理未使用的资源"""
        # 强制垃圾回收
        gc.collect()
        
        # 清理对象池
        self.object_pool = [obj for obj in self.object_pool if obj.in_use]

// TRAE IDE会自动识别并补全以下内容：
// 1. Rectangle对象的属性（facecolor, edgecolor等）
// 2. matplotlib的坐标系统参数
// 3. 音频库的频率计算函数

// 在TRAE IDE中，你可以：
// 1. 使用AI助手生成复杂的数学计算代码
// 2. 通过侧边对话快速查询matplotlib文档
// 3. 使用行内对话优化算法性能
// 4. 一键运行和测试交互功能

class MusicEducationPiano(InteractivePiano):
    """音乐教育专用钢琴"""
    
    def __init__(self, keyboard):
        super().__init__(keyboard)
        self.learning_mode = 'scale'  # scale, chord, song
        self.current_scale = 'C_major'
        self.highlighted_notes = []
        
    def highlight_scale(self, scale_name):
        """高亮显示音阶"""
        scale_notes = self.get_scale_notes(scale_name)
        
        for note in scale_notes:
            if note in self.key_rects:
                self.key_rects[note].set_facecolor('#4ecdc4')
                self.key_rects[note].set_alpha(0.7)
                self.highlighted_notes.append(note)
        
        self.fig.canvas.draw()
    
    def get_scale_notes(self, scale_name):
        """获取音阶的音符列表"""
        scales = {
            'C_major': ['C', 'D', 'E', 'F', 'G', 'A', 'B'],
            'G_major': ['G', 'A', 'B', 'C', 'D', 'E', 'F#'],
            'F_major': ['F', 'G', 'A', 'A#', 'C', 'D', 'E']
        }
        return scales.get(scale_name, [])

class AudioVisualizer:
    """实时音频可视化器"""
    
    def __init__(self, piano_renderer):
        self.piano = piano_renderer
        self.fft_size = 2048
        self.sample_rate = 44100
        
    def start_realtime_visualization(self):
        """开始实时音频可视化"""
        import pyaudio
        
        # 初始化音频输入
        p = pyaudio.PyAudio()
        stream = p.open(format=pyaudio.paFloat32,
                       channels=1,
                       rate=self.sample_rate,
                       input=True,
                       frames_per_buffer=self.fft_size,
                       stream_callback=self.audio_callback)
        
        stream.start_stream()
        
    def audio_callback(self, in_data, frame_count, time_info, status):
        """音频回调函数"""
        # 将音频数据转换为numpy数组
        audio_data = np.frombuffer(in_data, dtype=np.float32)
        
        # 执行FFT
        fft_data = np.fft.fft(audio_data)
        frequencies = np.fft.fftfreq(len(fft_data), 1/self.sample_rate)
        
        # 分析频率并高亮对应的钢琴键
        self.analyze_and_highlight(frequencies, np.abs(fft_data))
        
        return (in_data, pyaudio.paContinue)

class AIPianoTeacher:
    """AI钢琴教师"""
    
    def __init__(self, piano_interface):
        self.piano = piano_interface
        self.student_progress = {}
        self.difficulty_level = 1
        
    def generate_exercise(self, skill_level):
        """根据技能水平生成练习"""
        # 使用机器学习算法生成个性化练习
        exercises = {
            1: ['C_major_scale', 'simple_melody'],
            2: ['G_major_scale', 'basic_chords'],
            3: ['arpeggios', 'hand_independence']
        }
        
        return exercises.get(skill_level, ['C_major_scale'])
    
    def analyze_performance(self, played_notes, target_notes):
        """分析演奏表现"""
        # 计算准确率
        accuracy = len(set(played_notes) & set(target_notes)) / len(target_notes)
        
        # 计算时间精度
        timing_accuracy = self.calculate_timing_accuracy(played_notes, target_notes)
        
        # 生成反馈
        feedback = {
            'accuracy': accuracy,
            'timing': timing_accuracy,
            'suggestions': self.generate_suggestions(accuracy, timing_accuracy)
        }
        
        return feedback

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Rectangle
import sounddevice as sd
import threading
import time
 
class CompletePianoApplication:
    """完整的钢琴应用"""
    
    def __init__(self):
        # 初始化组件
        self.keyboard = PianoKeyboard('C3', 'C6')  # 三个八度
        self.renderer = InteractivePiano(self.keyboard)
        self.audio = PianoAudio()
        
        # 设置窗口
        self.setup_window()
        
    def setup_window(self):
        """设置应用窗口"""
        plt.style.use('seaborn-darkgrid')
        self.renderer.fig.set_size_inches(15, 8)
        self.renderer.fig.canvas.set_window_title('Python交互式钢琴')
        
        # 添加标题和说明
        self.renderer.ax.set_title('🎹 Python交互式钢琴 - 点击琴键演奏', 
                                   fontsize=16, pad=20)
        
        # 添加键盘标签
        self.add_keyboard_labels()
        
    def add_keyboard_labels(self):
        """添加键盘标签"""
        # 在白键下方添加音符标签
        for key in self.renderer.white_keys:
            self.renderer.ax.text(
                key['x'] + key['width']/2,
                -20,
                key['note'],
                ha='center',
                va='top',
                fontsize=8,
                color='gray'
            )
    
    def run(self):
        """运行应用"""
        print("🎹 Python交互式钢琴已启动！")
        print("点击琴键进行演奏，支持鼠标拖拽")
        print("使用TRAE IDE可以获得更好的开发体验")
        
        plt.show()
 
// 主程序入口
if __name__ == "__main__":
    # 创建应用实例
    app = CompletePianoApplication()
    
    # 运行应用
    app.run()