# -*- coding: utf-8 -*-
\n"""
\n\u4f5c\u66f2\u8f6f\u4ef6 v3 – \u6574\u5408\u7ecf\u5178\u4f5c\u66f2\u6280\u672f
\n\u652f\u6301：\u5bf9\u4f4d\u6cd5\u3001\u548c\u58f0\u5b66\u3001\u66f2\u5f0f\u5b66\u3001\u914d\u5668\u6cd5\u3001\u73b0\u4ee3\u6280\u6cd5
\n\u8f93\u51fa：\u591a\u58f0\u90e8\u7b80\u8c31 + MIDI\u591a\u8f68
\n"""<\/p>\n
import random
\nimport math
\nimport tkinter as tk
\nfrom tkinter import ttk, scrolledtext, messagebox, filedialog
\nfrom threading import Thread<\/p>\n
# ==================== \u57fa\u7840\u6570\u636e\u5c42 ====================<\/p>\n
# \u8c03\u5f0f\u4e0e\u97f3\u9636
\nKEY_OFFSET = {
\n "C\u5927\u8c03": 0, "C#\u5927\u8c03": 1, "Db\u5927\u8c03": 1,
\n "D\u5927\u8c03": 2, "D#\u5927\u8c03": 3, "Eb\u5927\u8c03": 3,
\n "E\u5927\u8c03": 4, "F\u5927\u8c03": 5, "F#\u5927\u8c03": 6, "Gb\u5927\u8c03": 6,
\n "G\u5927\u8c03": 7, "G#\u5927\u8c03": 8, "Ab\u5927\u8c03": 8,
\n "A\u5927\u8c03": 9, "A#\u5927\u8c03": 10, "Bb\u5927\u8c03": 10,
\n "B\u5927\u8c03": 11,
\n "A\u5c0f\u8c03": 9, "E\u5c0f\u8c03": 4, "D\u5c0f\u8c03": 2,
\n "G\u5c0f\u8c03": 7, "C\u5c0f\u8c03": 0, "F\u5c0f\u8c03": 5,
\n "Bb\u5c0f\u8c03": 10, "Eb\u5c0f\u8c03": 3,
\n}<\/p>\n
# \u97f3\u9636\u7c7b\u578b
\nMAJOR_SCALE = [0, 2, 4, 5, 7, 9, 11]
\nMINOR_SCALE = [0, 2, 3, 5, 7, 8, 10]
\nHARMONIC_MINOR = [0, 2, 3, 5, 7, 8, 11]
\nMELODIC_MINOR_UP = [0, 2, 3, 5, 7, 9, 11]
\nPENTATONIC_MAJOR = [0, 2, 4, 7, 9]
\nPENTATONIC_MINOR = [0, 3, 5, 7, 10]
\nBLUES_SCALE = [0, 3, 5, 6, 7, 10]
\nWHOLE_TONE = [0, 2, 4, 6, 8, 10]
\nOCTATONIC = [0, 1, 3, 4, 6, 7, 9, 10]
\nALL_SEMITONES = list(range(12))<\/p>\n
# \u534a\u97f3 \u2192 \u7b80\u8c31
\nSEMI_MAP = {
\n 0: "1", 1: "1#", 2: "2", 3: "2#",
\n 4: "3", 5: "4", 6: "4#", 7: "5",
\n 8: "5#", 9: "6", 10: "6#", 11: "7",
\n}<\/p>\n
# \u7b80\u8c31 \u2192 MIDI\u97f3\u9ad8（C4=60，\u5373\u7b80\u8c311=C）
\ndef jianpu_to_midi(note_str, base_octave=4):
\n """\u5c06\u7b80\u8c31\u5b57\u7b26\u4e32\u8f6c\u4e3aMIDI\u97f3\u9ad8\u6570\u5b57"""
\n if not note_str or note_str in ['|', ' ', '-', '_']:
\n return None<\/p>\n
num = None
\n sharp = 0
\n oct_shift = 0<\/p>\n
for ch in note_str:
\n if ch in '1234567':
\n num = int(ch)
\n elif ch == '#':
\n sharp = 1
\n elif ch == "'":
\n oct_shift += 1
\n elif ch == '.':
\n oct_shift -= 1<\/p>\n
if num is None:
\n return None<\/p>\n
num_to_semi = {1: 0, 2: 2, 3: 4, 4: 5, 5: 7, 6: 9, 7: 11}
\n semi = num_to_semi[num] + sharp
\n midi = (base_octave + oct_shift) * 12 + 12 + semi
\n return midi<\/p>\n
# ==================== \u98ce\u683c\u914d\u7f6e ====================<\/p>\n
STYLES = {
\n "\u6b22\u5feb": {"scale": MAJOR_SCALE, "rhythms": [0.25, 0.5, 0.5, 0.25, 1.0, 0.5],
\n "step_pref": 2, "oct_range": (-2, 2), "chromatic_prob": 0.2},
\n "\u6292\u60c5": {"scale": MAJOR_SCALE, "rhythms": [0.5, 1.0, 1.0, 0.5, 2.0],
\n "step_pref": 1, "oct_range": (-2, 2), "chromatic_prob": 0.1},
\n "\u6fc0\u6602": {"scale": MAJOR_SCALE, "rhythms": [0.5, 0.5, 0.25, 0.25, 0.5, 1.0],
\n "step_pref": 3, "oct_range": (-2, 3), "chromatic_prob": 0.25},
\n "\u5e73\u9759": {"scale": PENTATONIC_MAJOR, "rhythms": [1.0, 1.0, 0.5, 0.5, 2.0],
\n "step_pref": 1, "oct_range": (-2, 1), "chromatic_prob": 0.05},
\n "\u53e4\u98ce": {"scale": PENTATONIC_MAJOR, "rhythms": [1.0, 0.5, 0.5, 1.0, 0.5, 0.5],
\n "step_pref": 1, "oct_range": (-2, 1), "chromatic_prob": 0.05},
\n "\u8fdb\u884c\u66f2": {"scale": MAJOR_SCALE, "rhythms": [0.5, 0.5, 1.0, 0.5, 0.5, 1.0],
\n "step_pref": 2, "oct_range": (-2, 2), "chromatic_prob": 0.15},
\n "\u821e\u66f2": {"scale": MAJOR_SCALE, "rhythms": [0.25, 0.25, 0.5, 0.25, 0.25, 0.5, 1.0],
\n "step_pref": 2, "oct_range": (-2, 2), "chromatic_prob": 0.2},
\n "\u6447\u6eda": {"scale": MAJOR_SCALE, "rhythms": [0.5, 0.25, 0.25, 0.5, 1.0, 0.5],
\n "step_pref": 3, "oct_range": (-2, 3), "chromatic_prob": 0.3},
\n "\u7235\u58eb": {"scale": MAJOR_SCALE, "rhythms": [0.5, 0.25, 0.5, 0.25, 0.5, 1.0],
\n "step_pref": 2, "oct_range": (-2, 2), "chromatic_prob": 0.5},
\n "\u84dd\u8c03": {"scale": BLUES_SCALE, "rhythms": [0.5, 0.5, 1.0, 0.5, 0.5, 1.0],
\n "step_pref": 2, "oct_range": (-2, 2), "chromatic_prob": 0.3},
\n "\u5168\u97f3\u9636": {"scale": WHOLE_TONE, "rhythms": [0.5, 1.0, 0.5, 1.0, 0.5],
\n "step_pref": 1, "oct_range": (-2, 2), "chromatic_prob": 0.0},
\n "\u516b\u58f0\u97f3\u9636": {"scale": OCTATONIC, "rhythms": [0.25, 0.5, 0.25, 0.5, 1.0],
\n "step_pref": 1, "oct_range": (-2, 2), "chromatic_prob": 0.0},
\n}<\/p>\n
# ==================== \u4f5c\u66f2\u6280\u672f\u5f15\u64ce ====================<\/p>\n
class CounterpointEngine:
\n """\u5bf9\u4f4d\u6cd5\u5f15\u64ce \u2014 \u652f\u6301\u4e8c\u58f0\u90e8\u3001\u4e09\u58f0\u90e8\u3001\u5361\u519c\u3001\u8d4b\u683c"""<\/p>\n
INTERVAL_NAMES = {
\n 0: "\u7eaf\u4e00\u5ea6", 1: "\u5c0f\u4e8c\u5ea6", 2: "\u5927\u4e8c\u5ea6", 3: "\u5c0f\u4e09\u5ea6",
\n 4: "\u5927\u4e09\u5ea6", 5: "\u7eaf\u56db\u5ea6", 6: "\u589e\u56db\u5ea6\/\u51cf\u4e94\u5ea6", 7: "\u7eaf\u4e94\u5ea6",
\n 8: "\u5c0f\u516d\u5ea6", 9: "\u5927\u516d\u5ea6", 10: "\u5c0f\u4e03\u5ea6", 11: "\u5927\u4e03\u5ea6", 12: "\u7eaf\u516b\u5ea6"
\n }<\/p>\n
# \u534f\u548c\u5ea6：3=\u5b8c\u5168\u534f\u548c, 2=\u4e0d\u5b8c\u5168\u534f\u548c, 1=\u4e0d\u534f\u548c, 0=\u7981\u7528
\n CONSONANCE = {
\n 0: 3, 7: 3, 12: 3,
\n 3: 2, 4: 2, 8: 2, 9: 2,
\n 5: 2,
\n 2: 1, 10: 1,
\n 1: 1, 11: 1,
\n 6: 0,
\n }<\/p>\n
def __init__(self, key_offset=0, scale=None):
\n self.key = key_offset
\n self.scale = scale or MAJOR_SCALE
\n self.voices = []
\n self.errors = []<\/p>\n
def get_interval(self, p1, p2):
\n return abs(p1 – p2) % 12<\/p>\n
def is_parallel_fifth(self, v1_prev, v1_curr, v2_prev, v2_curr):
\n prev_int = self.get_interval(v1_prev, v2_prev)
\n curr_int = self.get_interval(v1_curr, v2_curr)
\n return prev_int == 7 and curr_int == 7 and v1_prev != v1_curr<\/p>\n
def is_parallel_octave(self, v1_prev, v1_curr, v2_prev, v2_curr):
\n prev_int = self.get_interval(v1_prev, v2_prev)
\n curr_int = self.get_interval(v1_curr, v2_curr)
\n return prev_int == 0 and curr_int == 0 and v1_prev != v1_curr<\/p>\n
def generate_cantus_firmus(self, n_notes, start_note, scale=None):
\n """\u751f\u6210\u5b9a\u65cb\u5f8b（Cantus Firmus）"""
\n scale = scale or self.scale
\n notes = [start_note]<\/p>\n
for i in range(1, n_notes):
\n prev = notes[-1]
\n step_weights = [0.5, 0.3, 0.15, 0.05]
\n step_type = random.choices([1, 3, 5, random.randint(2, 7)], weights=step_weights)[0]
\n direction = random.choice([-1, 1])
\n new_note = prev + direction * step_type<\/p>\n
new_semi = new_note % 12
\n if new_semi not in scale:
\n candidates = [(s, abs(s – new_semi)) for s in scale]
\n candidates.sort(key=lambda x: x[1])
\n new_note = (new_note \/\/ 12) * 12 + candidates[0][0]<\/p>\n
new_note = max(start_note – 12, min(start_note + 12, new_note))
\n notes.append(new_note)<\/p>\n
final = start_note
\n if notes[-1] != final:
\n notes[-1] = final
\n return notes<\/p>\n
def generate_counterpoint(self, cantus, voice_type="above", species=1):
\n """\u751f\u6210\u5bf9\u4f4d\u65cb\u5f8b"""
\n cp = []
\n octave_offset = 12 if voice_type == "above" else -12<\/p>\n
for i, cf_note in enumerate(cantus):
\n target = cf_note + octave_offset<\/p>\n
if species == 1:
\n candidates = []
\n for offset in [-3, -4, -5, 3, 4, 5, 7, 8, 12]:
\n cand = target + offset
\n if cand % 12 in self.scale:
\n candidates.append(cand)<\/p>\n
if candidates:
\n cp.append(random.choice(candidates))
\n else:
\n cp.append(target + random.choice([3, 4, 5]))<\/p>\n
elif species == 2:
\n if i < len(cantus) – 1:
\n first = target + random.choice([3, 4, 5, 7, 8])
\n step = random.choice([-1, 1])
\n second = first + step
\n cp.extend([first, second])
\n else:
\n cp.append(target + 3)<\/p>\n
return cp<\/p>\n
def generate_canon(self, theme, interval=4, delay=2):
\n """\u751f\u6210\u5361\u519c"""
\n voices = [theme]
\n imitation = [(n + interval) % 12 + (n \/\/ 12) * 12 for n in theme]
\n voices.append(imitation)
\n return voices<\/p>\n
def generate_fugue_subject(self, scale, length=8):
\n """\u751f\u6210\u8d4b\u683c\u4e3b\u9898"""
\n subject = []
\n tonic = scale[0]
\n dominant = scale[4] if len(scale) >= 5 else scale[0] + 7<\/p>\n
subject.append(tonic)
\n subject.append(dominant)<\/p>\n
direction = -1 if random.random() < 0.5 else 1
\n current = dominant
\n for i in range(length – 3):
\n step = random.choice([1, 2]) * direction
\n current += step
\n current_semi = current % 12
\n if current_semi not in scale:
\n current = (current \/\/ 12) * 12 + min(scale, key=lambda s: abs(s – current_semi))
\n subject.append(current)<\/p>\n
subject.append(tonic)
\n return subject<\/p>\n
class HarmonyEngine:
\n """\u548c\u58f0\u5b66\u5f15\u64ce \u2014 \u56db\u90e8\u548c\u58f0\u3001\u548c\u5f26\u8fdb\u884c\u3001\u8c03\u5f0f\u4ea4\u66ff"""<\/p>\n
CHORD_TYPES = {
\n "I": [0, 4, 7],
\n "ii": [2, 5, 9],
\n "iii": [4, 7, 11],
\n "IV": [5, 9, 0],
\n "V": [7, 11, 2],
\n "vi": [9, 0, 4],
\n "vii\u00b0": [11, 2, 5],
\n "V7": [7, 11, 2, 5],
\n "ii7": [2, 5, 9, 0],
\n "viio7": [11, 2, 5, 8],
\n "V\/V": [2, 6, 9],
\n "V\/ii": [9, 1, 4],
\n }<\/p>\n
PROGRESSIONS = {
\n "\u53e4\u5178\u7ec8\u6b62": ["I", "IV", "V", "I"],
\n "\u6b63\u683c\u8fdb\u884c": ["I", "V", "I"],
\n "\u53d8\u683c\u8fdb\u884c": ["I", "IV", "I"],
\n "\u534a\u7ec8\u6b62": ["I", "IV", "V"],
\n "\u963b\u788d\u7ec8\u6b62": ["I", "V", "vi"],
\n "\u5b8c\u5168\u8fdb\u884c": ["I", "vi", "ii", "V", "I"],
\n "\u7235\u58ebii-V-I": ["ii7", "V7", "I"],
\n "\u6d41\u884c\u8fdb\u884c": ["I", "V", "vi", "IV"],
\n "\u84dd\u8c03\u8fdb\u884c": ["I", "IV", "I", "V", "IV", "I"],
\n "\u8c03\u5f0f\u4ea4\u66ff": ["I", "ii", "iii", "IV", "V", "vi", "vii\u00b0", "I"],
\n }<\/p>\n
def __init__(self, key_offset=0, scale=None):
\n self.key = key_offset
\n self.scale = scale or MAJOR_SCALE
\n self.chords = []<\/p>\n
def get_chord_pitches(self, chord_name, inversion=0):
\n base_pitches = self.CHORD_TYPES.get(chord_name, [0, 4, 7])
\n if inversion > 0:
\n base_pitches = base_pitches[inversion:] + [p + 12 for p in base_pitches[:inversion]]
\n return [(p + self.key) % 12 for p in base_pitches]<\/p>\n
def generate_four_part(self, progression_name, n_bars=4):
\n progression = self.PROGRESSIONS.get(progression_name, self.PROGRESSIONS["\u53e4\u5178\u7ec8\u6b62"])
\n ranges = {'S': (60, 81), 'A': (55, 74), 'T': (48, 67), 'B': (40, 60)}
\n voices = {'S': [], 'A': [], 'T': [], 'B': []}<\/p>\n
for bar in range(n_bars):
\n chord_name = progression[bar % len(progression)]
\n chord_pitches = self.get_chord_pitches(chord_name)<\/p>\n
for voice_name in ['B', 'T', 'A', 'S']:
\n v_range = ranges[voice_name]
\n candidates = []
\n for p in chord_pitches:
\n for octv in range(3, 7):
\n midi = p + octv * 12
\n if v_range[0] <= midi <= v_range[1]:
\n candidates.append(midi)<\/p>\n
if candidates:
\n if voices[voice_name]:
\n prev = voices[voice_name][-1]
\n candidates.sort(key=lambda x: abs(x – prev))
\n chosen = candidates[0]
\n else:
\n chosen = random.choice(candidates)
\n voices[voice_name].append(chosen)
\n else:
\n voices[voice_name].append(v_range[0] + 4)<\/p>\n
return voices<\/p>\n
def generate_jazz_changes(self, n_bars=8):
\n jazz_progressions = [
\n ["ii7", "V7", "I", "I"],
\n ["I", "vi", "ii7", "V7"],
\n ["ii7", "V7", "iii", "vi"],
\n ["I", "IV", "ii7", "V7"],
\n ]
\n result = []
\n for bar in range(n_bars):
\n prog = jazz_progressions[bar % len(jazz_progressions)]
\n chord = prog[bar % len(prog)]
\n result.append(chord)
\n return result<\/p>\n
class FormEngine:
\n """\u66f2\u5f0f\u5b66\u5f15\u64ce"""<\/p>\n
def __init__(self, melody_engine=None):
\n self.melody_engine = melody_engine<\/p>\n
def generate_binary(self, theme, n_bars_a=8, n_bars_b=8, style=None):
\n style = style or STYLES["\u6292\u60c5"]
\n section_a = theme[:n_bars_a] if len(theme) >= n_bars_a else theme<\/p>\n
dominant_shift = 7
\n section_b = []
\n for semi, octv, dur in theme[:n_bars_b]:
\n new_semi = (semi + dominant_shift) % 12
\n section_b.append((new_semi, octv, dur))<\/p>\n
return {"A": section_a, "B": section_b}<\/p>\n
def generate_ternary(self, theme, n_bars=8, style=None):
\n style = style or STYLES["\u6292\u60c5"]
\n section_a = theme[:n_bars] if len(theme) >= n_bars else theme<\/p>\n
section_b = []
\n for semi, octv, dur in section_a:
\n new_oct = octv + random.choice([-1, 1])
\n new_dur = dur \/ 2 if dur >= 0.5 else dur
\n section_b.append((semi, new_oct, new_dur))<\/p>\n
section_a_prime = []
\n for semi, octv, dur in section_a:
\n if random.random() < 0.3:
\n neighbor = semi + random.choice([-1, 1])
\n section_a_prime.append((neighbor, octv, dur * 0.25))
\n section_a_prime.append((semi, octv, dur * 0.75))
\n else:
\n section_a_prime.append((semi, octv, dur))<\/p>\n
return {"A": section_a, "B": section_b, "A'": section_a_prime}<\/p>\n
def generate_rondo(self, theme, episodes=2, style=None):
\n style = style or STYLES["\u6b22\u5feb"]
\n result = {"A": theme}<\/p>\n
for i in range(episodes):
\n episode = []
\n for semi, octv, dur in theme:
\n new_semi = (semi + 2) % 12
\n new_oct = octv + random.choice([-1, 0, 1])
\n episode.append((new_semi, new_oct, dur))
\n result[f"\u63d2\u90e8{i+1}"] = episode<\/p>\n
return result<\/p>\n
def generate_variations(self, theme, n_variations=3, style=None):
\n style = style or STYLES["\u6292\u60c5"]
\n variations = {"\u4e3b\u9898": theme}<\/p>\n
techniques = ["\u88c5\u9970\u53d8\u594f", "\u8282\u594f\u53d8\u594f", "\u8c03\u5f0f\u53d8\u594f", "\u97f3\u533a\u53d8\u594f"]<\/p>\n
for i in range(n_variations):
\n tech = techniques[i % len(techniques)]
\n var = []<\/p>\n
for semi, octv, dur in theme:
\n if tech == "\u88c5\u9970\u53d8\u594f":
\n if random.random() < 0.4:
\n passing = semi + random.choice([-1, 1])
\n var.append((passing, octv, dur * 0.3))
\n var.append((semi, octv, dur * 0.7))
\n else:
\n var.append((semi, octv, dur))<\/p>\n
elif tech == "\u8282\u594f\u53d8\u594f":
\n new_dur = dur * random.choice([0.5, 1.0, 2.0])
\n var.append((semi, octv, new_dur))<\/p>\n
elif tech == "\u8c03\u5f0f\u53d8\u594f":
\n new_semi = semi
\n if semi in [4, 9, 11]:
\n new_semi = semi – 1
\n var.append((new_semi, octv, dur))<\/p>\n
elif tech == "\u97f3\u533a\u53d8\u594f":
\n new_oct = octv + random.choice([-1, 1])
\n var.append((semi, new_oct, dur))
\n else:
\n var.append((semi, octv, dur))<\/p>\n
variations[f"\u53d8\u594f{i+1}({tech})"] = var<\/p>\n
return variations<\/p>\n
def generate_sonata(self, theme_group1, theme_group2, n_bars=16, style=None):
\n style = style or STYLES["\u6fc0\u6602"]<\/p>\n
exposition = {
\n "\u4e3b\u90e8(\u4e3b\u8c03)": theme_group1[:n_bars\/\/2],
\n "\u8fde\u63a5\u90e8": theme_group1[n_bars\/\/2:n_bars\/\/2+4],
\n "\u526f\u90e8(\u5c5e\u8c03)": [(semi+7, octv, dur) for semi, octv, dur in theme_group2[:n_bars\/\/2]],
\n }<\/p>\n
development = []
\n for semi, octv, dur in theme_group1 + theme_group2:
\n new_semi = (semi + random.randint(1, 6)) % 12
\n new_dur = dur * random.choice([0.5, 0.5, 0.25])
\n development.append((new_semi, octv, new_dur))<\/p>\n
recapitulation = {
\n "\u4e3b\u90e8\u518d\u73b0": theme_group1[:n_bars\/\/2],
\n "\u526f\u90e8\u518d\u73b0(\u4e3b\u8c03)": theme_group2[:n_bars\/\/2],
\n "\u5c3e\u58f0": theme_group1[:4],
\n }<\/p>\n
return {"\u5448\u793a\u90e8": exposition, "\u5c55\u5f00\u90e8": development, "\u518d\u73b0\u90e8": recapitulation}<\/p>\n
class OrchestrationEngine:
\n """\u914d\u5668\u6cd5\u5f15\u64ce"""<\/p>\n
INSTRUMENTS = {
\n "\u94a2\u7434": 0, "\u660e\u4eae\u94a2\u7434": 1, "\u7535\u94a2\u7434": 2, "\u9152\u5427\u94a2\u7434": 3,
\n "\u98a4\u97f3\u7434": 11, "\u9a6c\u6797\u5df4": 12, "\u6728\u7434": 13, "\u7ba1\u949f": 14,
\n "\u98ce\u7434": 16, "\u6559\u5802\u98ce\u7434": 19, "\u624b\u98ce\u7434": 21, "\u53e3\u7434": 22,
\n "\u5c3c\u9f99\u5409\u4ed6": 24, "\u94a2\u5f26\u5409\u4ed6": 25, "\u7535\u5409\u4ed6": 27, "\u5931\u771f\u5409\u4ed6": 29,
\n "\u8d1d\u53f8": 32, "\u7535\u8d1d\u53f8": 33, "\u65e0\u54c1\u8d1d\u53f8": 35,
\n "\u5c0f\u63d0\u7434": 40, "\u4e2d\u63d0\u7434": 41, "\u5927\u63d0\u7434": 42, "\u4f4e\u97f3\u63d0\u7434": 43,
\n "\u5f26\u4e50\u5408\u594f": 48, "\u5f26\u4e50\u62e8\u594f": 45, "\u7ad6\u7434": 46,
\n "\u957f\u7b1b": 73, "\u53cc\u7c27\u7ba1": 68, "\u5355\u7c27\u7ba1": 71, "\u5df4\u677e": 70,
\n "\u5706\u53f7": 60, "\u5c0f\u53f7": 56, "\u957f\u53f7": 57, "\u5927\u53f7": 58,
\n "\u94dc\u7ba1\u5408\u594f": 61, "\u5408\u6210\u5668\u4e3b\u97f3": 80, "\u5408\u6210\u5668\u94fa\u5e95": 88,
\n "\u7ba1\u5f26\u4e50\u6253\u51fb": 47, "\u5b9a\u97f3\u9f13": 47,
\n }<\/p>\n
RANGES = {
\n "\u94a2\u7434": (21, 108), "\u5c0f\u63d0\u7434": (55, 103), "\u4e2d\u63d0\u7434": (48, 91),
\n "\u5927\u63d0\u7434": (36, 76), "\u4f4e\u97f3\u63d0\u7434": (28, 67),
\n "\u957f\u7b1b": (60, 96), "\u53cc\u7c27\u7ba1": (58, 91), "\u5355\u7c27\u7ba1": (50, 94),
\n "\u5df4\u677e": (34, 75), "\u5706\u53f7": (31, 77), "\u5c0f\u53f7": (54, 86),
\n "\u957f\u53f7": (40, 72), "\u5927\u53f7": (28, 58),
\n "\u4eba\u58f0-\u5973\u9ad8": (60, 84), "\u4eba\u58f0-\u5973\u4f4e": (53, 77),
\n "\u4eba\u58f0-\u7537\u9ad8": (48, 72), "\u4eba\u58f0-\u7537\u4f4e": (40, 64),
\n }<\/p>\n
ENSEMBLES = {
\n "\u5f26\u4e50\u56db\u91cd\u594f": ["\u5c0f\u63d0\u7434", "\u5c0f\u63d0\u7434", "\u4e2d\u63d0\u7434", "\u5927\u63d0\u7434"],
\n "\u94a2\u7434\u4e09\u91cd\u594f": ["\u94a2\u7434", "\u5c0f\u63d0\u7434", "\u5927\u63d0\u7434"],
\n "\u94dc\u7ba1\u4e94\u91cd\u594f": ["\u5c0f\u53f7", "\u5c0f\u53f7", "\u5706\u53f7", "\u957f\u53f7", "\u5927\u53f7"],
\n "\u6728\u7ba1\u4e94\u91cd\u594f": ["\u957f\u7b1b", "\u53cc\u7c27\u7ba1", "\u5355\u7c27\u7ba1", "\u5df4\u677e", "\u5706\u53f7"],
\n "\u7ba1\u5f26\u4e50\u961f": ["\u5c0f\u63d0\u7434", "\u4e2d\u63d0\u7434", "\u5927\u63d0\u7434", "\u4f4e\u97f3\u63d0\u7434",
\n "\u957f\u7b1b", "\u53cc\u7c27\u7ba1", "\u5355\u7c27\u7ba1", "\u5df4\u677e",
\n "\u5706\u53f7", "\u5c0f\u53f7", "\u957f\u53f7", "\u5927\u53f7", "\u94a2\u7434"],
\n "\u6d41\u884c\u4e50\u961f": ["\u94a2\u7434", "\u7535\u5409\u4ed6", "\u8d1d\u53f8", "\u5408\u6210\u5668\u4e3b\u97f3", "\u5f26\u4e50\u5408\u594f"],
\n }<\/p>\n
def __init__(self):
\n self.assignments = []<\/p>\n
def assign_instruments(self, melody, ensemble_name="\u5f26\u4e50\u56db\u91cd\u594f"):
\n instruments = self.ENSEMBLES.get(ensemble_name, ["\u94a2\u7434"])
\n tracks = []<\/p>\n
for i, inst_name in enumerate(instruments):
\n inst_id = self.INSTRUMENTS.get(inst_name, 0)
\n inst_range = self.RANGES.get(inst_name, (36, 84))<\/p>\n
track = []
\n for semi, octv, dur in melody:
\n midi = (4 + octv) * 12 + semi<\/p>\n
if midi < inst_range[0]:
\n midi += 12
\n elif midi > inst_range[1]:
\n midi -= 12<\/p>\n
oct_adjust = 0
\n if inst_name in ["\u4f4e\u97f3\u63d0\u7434", "\u5927\u53f7", "\u4eba\u58f0-\u7537\u4f4e"]:
\n oct_adjust = -1
\n elif inst_name in ["\u5c0f\u63d0\u7434", "\u957f\u7b1b", "\u5c0f\u53f7"]:
\n oct_adjust = 1<\/p>\n
new_semi = midi % 12
\n new_oct = (midi \/\/ 12) – 4 + oct_adjust
\n track.append((new_semi, new_oct, dur, inst_id, inst_name))<\/p>\n
tracks.append(track)<\/p>\n
return tracks<\/p>\n
def generate_texture(self, melody, texture_type="\u4e3b\u8c03"):
\n if texture_type == "\u4e3b\u8c03":
\n accompaniment = []
\n for semi, octv, dur in melody:
\n third = (semi + 4) % 12
\n fifth = (semi + 7) % 12
\n accompaniment.append([
\n (semi, octv – 1, dur, "\u65cb\u5f8b"),
\n (third, octv – 1, dur, "\u4e09\u97f3"),
\n (fifth, octv – 1, dur, "\u4e94\u97f3"),
\n ])
\n return {"\u65cb\u5f8b": melody, "\u4f34\u594f": accompaniment}<\/p>\n
elif texture_type == "\u590d\u8c03":
\n cp = CounterpointEngine()
\n cantus = [semi + (4 + octv) * 12 for semi, octv, dur in melody]
\n counter = cp.generate_counterpoint(cantus, "below", 1)
\n counter_melody = [(c % 12, c \/\/ 12 – 4, 1.0) for c in counter]
\n return {"\u9ad8\u97f3": melody, "\u4f4e\u97f3": counter_melody}<\/p>\n
elif texture_type == "\u5206\u89e3\u548c\u5f26":
\n arpeggio = []
\n for semi, octv, dur in melody:
\n chord_tones = [semi, (semi + 4) % 12, (semi + 7) % 12]
\n for i, tone in enumerate(chord_tones):
\n arpeggio.append((tone, octv – 1, dur \/ 3))
\n return {"\u65cb\u5f8b": melody, "\u7436\u97f3": arpeggio}<\/p>\n
elif texture_type == "\u6301\u7eed\u97f3":
\n drone = []
\n tonic = melody[0][0] if melody else 0
\n for _ in range(len(melody)):
\n drone.append((tonic, -2, 4.0))
\n return {"\u65cb\u5f8b": melody, "\u6301\u7eed\u97f3": drone}<\/p>\n
return {"\u65cb\u5f8b": melody}<\/p>\n
class TwelveToneEngine:
\n """\u5341\u4e8c\u97f3\u6280\u6cd5\u5f15\u64ce"""<\/p>\n
def __init__(self):
\n self.row = None
\n self.matrix = None<\/p>\n
def generate_row(self):
\n row = list(range(12))
\n random.shuffle(row)
\n self.row = row
\n return row<\/p>\n
def build_matrix(self):
\n if not self.row:
\n self.generate_row()<\/p>\n
matrix = []
\n for i in range(12):
\n transposed = [(x + i) % 12 for x in self.row]
\n matrix.append(transposed)<\/p>\n
self.matrix = matrix
\n return matrix<\/p>\n
def get_transformations(self):
\n if not self.row:
\n self.generate_row()<\/p>\n
P = self.row
\n I = [(-x) % 12 for x in self.row]
\n R = list(reversed(self.row))
\n RI = [(-x) % 12 for x in reversed(self.row)]<\/p>\n
return {"P": P, "I": I, "R": R, "RI": RI}<\/p>\n
def generate_piece(self, n_notes=48, use_rhythm=True):
\n transforms = self.get_transformations()
\n forms = ["P", "I", "R", "RI"]
\n piece = []<\/p>\n
for i in range(n_notes \/\/ 12):
\n form = forms[i % 4]
\n row = transforms[form]
\n transposition = random.randint(0, 11)
\n transposed = [(x + transposition) % 12 for x in row]<\/p>\n
for semi in transposed:
\n dur = random.choice([0.5, 1.0, 0.25]) if use_rhythm else 1.0
\n octv = random.randint(-1, 2)
\n piece.append((semi, octv, dur))<\/p>\n
return piece<\/p>\n
class RhythmEngine:
\n """\u8282\u594f\u5f15\u64ce"""<\/p>\n
def __init__(self):
\n self.patterns = []<\/p>\n
def generate_polyrhythm(self, base_pulse, against_pulse, n_beats=4):
\n base_notes = []
\n against_notes = []<\/p>\n
for i in range(base_pulse):
\n base_notes.append((i * n_beats \/ base_pulse, n_beats \/ base_pulse))<\/p>\n
for i in range(against_pulse):
\n against_notes.append((i * n_beats \/ against_pulse, n_beats \/ against_pulse))<\/p>\n
return {"\u57fa\u7840": base_notes, "\u5bf9\u4f4d": against_notes}<\/p>\n
def generate_syncopation(self, pattern, intensity=0.5):
\n syncopated = []
\n for dur in pattern:
\n if random.random() < intensity and dur >= 0.5:
\n syncopated.append(dur * 0.6)
\n syncopated.append(dur * 0.4)
\n else:
\n syncopated.append(dur)
\n return syncopated<\/p>\n
def develop_rhythm(self, motif, technique="\u91cd\u590d"):
\n if technique == "\u91cd\u590d":
\n return motif * 2
\n elif technique == "\u589e\u503c":
\n return [d * 2 for d in motif]
\n elif technique == "\u51cf\u503c":
\n return [d \/ 2 for d in motif]
\n elif technique == "\u9006\u884c":
\n return list(reversed(motif))
\n elif technique == "\u4ea4\u9519":
\n return motif + [max(motif) – d + min(motif) for d in motif]
\n elif technique == "\u5206\u88c2":
\n result = []
\n for d in motif:
\n result.extend([d\/2, d\/2])
\n return result
\n return motif<\/p>\n
def generate_groove(self, style_name="funk", n_bars=4):
\n grooves = {
\n "funk": [0.25, 0.25, 0.25, 0.25, 0.5, 0.5, 0.25, 0.25, 0.5],
\n "bossa": [0.5, 0.25, 0.25, 0.5, 0.25, 0.25, 0.5, 0.5],
\n "shuffle": [0.66, 0.33, 0.66, 0.33, 0.66, 0.33, 0.66, 0.33],
\n "latin": [0.25, 0.25, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25, 0.25, 0.25],
\n "disco": [0.5, 0.5, 0.5, 0.5, 0.25, 0.25, 0.5, 0.5],
\n }
\n pattern = grooves.get(style_name, [0.5, 0.5, 0.5, 0.5])
\n return pattern * n_bars<\/p>\n
class ChanceMusicEngine:
\n """\u5076\u7136\u97f3\u4e50\u5f15\u64ce"""<\/p>\n
def __init__(self):
\n self.parameters = {}<\/p>\n
def dice_composition(self, n_bars=8):
\n fragments = {
\n 1: [(0, 0, 1.0), (2, 0, 1.0), (4, 0, 1.0), (5, 0, 1.0)],
\n 2: [(0, 0, 0.5), (2, 0, 0.5), (4, 0, 1.0), (7, 0, 1.0), (5, 0, 1.0)],
\n 3: [(4, 0, 1.0), (2, 0, 1.0), (0, 0, 2.0)],
\n 4: [(0, 0, 0.5), (4, 0, 0.5), (7, 0, 0.5), (4, 0, 0.5), (5, 0, 1.0), (2, 0, 1.0)],
\n 5: [(2, 0, 1.0), (4, 0, 0.5), (5, 0, 0.5), (7, 0, 1.0), (5, 0, 0.5), (4, 0, 0.5)],
\n 6: [(7, 0, 0.5), (5, 0, 0.5), (4, 0, 1.0), (2, 0, 0.5), (0, 0, 0.5), (2, 0, 0.5), (4, 0, 0.5)],
\n }<\/p>\n
result = []
\n for bar in range(n_bars):
\n dice = random.randint(1, 6)
\n fragment = fragments[dice]
\n result.extend(fragment)<\/p>\n
return result<\/p>\n
def aleatoric_piece(self, n_events=50, pitch_range=(48, 84)):
\n piece = []
\n for _ in range(n_events):
\n pitch = random.randint(*pitch_range)
\n dur = random.choice([0.25, 0.5, 1.0, 2.0, 0.125])
\n velocity = random.randint(30, 120)
\n piece.append((pitch % 12, pitch \/\/ 12 – 4, dur, velocity))
\n return piece<\/p>\n
def cellular_automata_music(self, rule=30, n_generations=32):
\n cells = [0] * n_generations
\n cells[n_generations \/\/ 2] = 1<\/p>\n
piece = []
\n for gen in range(n_generations):
\n active_cells = [i for i, c in enumerate(cells) if c == 1]
\n for ac in active_cells:
\n semi = ac % 12
\n octv = ac \/\/ 12
\n piece.append((semi, octv, 0.5))<\/p>\n
new_cells = cells[:]
\n for i in range(1, n_generations – 1):
\n pattern = (cells[i-1], cells[i], cells[i+1])
\n new_cells[i] = self._apply_rule(rule, pattern)
\n cells = new_cells<\/p>\n
return piece<\/p>\n
def _apply_rule(self, rule, pattern):
\n idx = pattern[0] * 4 + pattern[1] * 2 + pattern[2]
\n return (rule >> idx) & 1<\/p>\n
# ==================== \u7b80\u8c31\u5de5\u5177\u51fd\u6570 ====================<\/p>\n
def semi_to_jianpu(semi, oct_shift=0):
\n """\u534a\u97f3 \u2192 \u7b80\u8c31\u8bb0\u53f7"""
\n base = SEMI_MAP.get(semi, "1")
\n has_sharp = '#' in base<\/p>\n
if not has_sharp:
\n if oct_shift > 0:
\n base += "'" * oct_shift
\n elif oct_shift < 0:
\n base += "." * (-oct_shift)
\n return base<\/p>\n
def format_with_group(base_jianpu, dur):
\n """\u5904\u7406\u62cd\u957f\u548c\u5206\u7ec4\u6807\u8bb0"""
\n if abs(dur – 1.0) < 0.01:
\n return base_jianpu
\n if dur > 1.0:
\n n = int(round(dur))
\n if n >= 2:
\n return base_jianpu + "-" * (n – 1)<\/p>\n
half_count = 0
\n d = dur
\n while d < 0.999 and half_count < 5:
\n d *= 2
\n half_count += 1
\n if half_count > 1:
\n return "(" + base_jianpu + ")" + "\/" * (half_count – 1)
\n elif half_count == 1:
\n return "(" + base_jianpu + ")"
\n return base_jianpu<\/p>\n
def melody_to_score(melody, bar_size=4.0):
\n """\u65cb\u5f8b \u2192 \u6807\u51c6\u7b80\u8c31\u5b57\u7b26\u4e32 (\u5e26 | \u5206\u5c0f\u8282)"""
\n bar_lines = []
\n cur_bar = []
\n cur_dur = 0.0<\/p>\n
for item in melody:
\n if len(item) >= 3:
\n semi, octv, dur = item[0], item[1], item[2]
\n else:
\n continue
\n cur_bar.append((semi, octv, dur))
\n cur_dur += dur
\n if cur_dur >= bar_size – 0.001:
\n s = "".join(
\n format_with_group(semi_to_jianpu(semi, oo), du)
\n for semi, oo, du in cur_bar
\n )
\n bar_lines.append(s)
\n cur_bar = []
\n cur_dur = 0.0<\/p>\n
if cur_bar:
\n s = "".join(
\n format_with_group(semi_to_jianpu(semi, oo), du)
\n for semi, oo, du in cur_bar
\n )
\n bar_lines.append(s)<\/p>\n
return " | ".join(bar_lines)<\/p>\n
def multi_voice_to_score(voices_dict, bar_size=4.0):
\n """\u591a\u58f0\u90e8 \u2192 \u7b80\u8c31"""
\n lines = []
\n for name, melody in voices_dict.items():
\n score = melody_to_score(melody, bar_size)
\n lines.append(f"\u3010{name}\u3011{score}")
\n return "\\\\n".join(lines)<\/p>\n
# ==================== \u57fa\u7840\u65cb\u5f8b\u751f\u6210 ====================<\/p>\n
def gen_melody(n_bars, style, oct_lo, oct_hi, step_pref):
\n """\u751f\u6210\u65cb\u5f8b，\u652f\u6301\u591a\u516b\u5ea6\u53d8\u5316"""
\n scale = style["scale"]
\n chromatic_prob = style.get("chromatic_prob", 0.15)<\/p>\n
cur_semi = scale[0]
\n cur_oct = 0
\n out = []<\/p>\n
for bar in range(n_bars):
\n beats = 0.0
\n bar_notes = []
\n attempts = 0<\/p>\n
while beats < 4.0 and attempts < 50:
\n attempts += 1
\n dur = random.choice(style["rhythms"])
\n if beats + dur > 4.0:
\n dur = 4.0 – beats
\n if dur < 0.125:
\n break<\/p>\n
use_chromatic = random.random() < chromatic_prob<\/p>\n
if use_chromatic:
\n non_scale = [s for s in ALL_SEMITONES if s not in scale]
\n if non_scale:
\n new_semi = random.choice(non_scale)
\n else:
\n new_semi = random.choice(scale)
\n else:
\n if random.random() < 0.6 and cur_semi in scale:
\n cur_idx = scale.index(cur_semi)
\n step = random.choice([-1, 1]) * random.randint(1, min(step_pref, 3))
\n new_idx = max(0, min(len(scale) – 1, cur_idx + step))
\n new_semi = scale[new_idx]
\n else:
\n new_semi = random.choice(scale)<\/p>\n
if random.random() < 0.15:
\n oct_change = random.choice([-2, -1, 0, 0, 0, 1, 2])
\n cur_oct += oct_change
\n cur_oct = max(oct_lo, min(oct_hi, cur_oct))<\/p>\n
bar_notes.append((new_semi, cur_oct, dur))
\n cur_semi = new_semi
\n beats += dur<\/p>\n
if bar == 0 and bar_notes:
\n bar_notes[0] = (scale[0], 0, bar_notes[0][2])
\n cur_semi = scale[0]
\n cur_oct = 0<\/p>\n
if bar_notes and random.random() < 0.25:
\n bar_notes[-1] = (scale[0], 0, max(0.5, bar_notes[-1][2]))
\n cur_semi = scale[0]
\n cur_oct = 0<\/p>\n
out.extend(bar_notes)
\n return out<\/p>\n
# ==================== MIDI\u5bfc\u51fa ====================<\/p>\n
def export_midi(tracks, bpm=120, filename="output.mid", time_signature=(4, 4)):
\n """\u4f7f\u7528mido\u5bfc\u51faMIDI\u6587\u4ef6（\u652f\u6301\u591a\u8f68\u3001\u591a\u901a\u9053\u3001\u5b8c\u6574Meta\u4fe1\u606f）<\/p>\n
Args:
\n tracks: [(instrument_id, notes), …]
\n notes: [(pitch, duration, time_offset), …] \u6216 [(pitch, duration), …]
\n bpm: \u901f\u5ea6
\n filename: \u8f93\u51fa\u8def\u5f84
\n time_signature: (\u5206\u5b50, \u5206\u6bcd)，\u9ed8\u8ba4(4,4)<\/p>\n
Returns:
\n (bool, str): (\u662f\u5426\u6210\u529f, \u72b6\u6001\u4fe1\u606f)
\n """
\n try:
\n import mido
\n from mido import Message, MidiFile, MidiTrack, MetaMessage
\n except ImportError:
\n return False, "\u9700\u8981\u5b89\u88c5 mido \u5e93: pip install mido"<\/p>\n
try:
\n mid = MidiFile(type=1)
\n ticks_per_beat = mid.ticks_per_beat<\/p>\n
# \u63a7\u5236\u8f68：\u5168\u5c40Meta\u4fe1\u606f
\n control_track = MidiTrack()
\n mid.tracks.append(control_track)
\n control_track.append(MetaMessage('time_signature',
\n numerator=time_signature[0],
\n denominator=time_signature[1],
\n clocks_per_click=24,
\n notated_32nd_notes_per_beat=8, time=0))
\n control_track.append(MetaMessage('set_tempo', tempo=mido.bpm2tempo(bpm), time=0))
\n control_track.append(MetaMessage('track_name', name='Control', time=0))<\/p>\n
for track_idx, (inst_id, notes) in enumerate(tracks):
\n track = MidiTrack()
\n mid.tracks.append(track)
\n channel = track_idx % 16
\n track.append(MetaMessage('track_name', name=f'Track{track_idx+1}', time=0))
\n track.append(Message('program_change', program=inst_id % 128,
\n channel=channel, time=0))<\/p>\n
events = []
\n current_time = 0
\n for note_data in notes:
\n if len(note_data) >= 3:
\n pitch, duration, time_offset = int(note_data[0]), float(note_data[1]), float(note_data[2])
\n else:
\n pitch, duration = int(note_data[0]), float(note_data[1])
\n time_offset = current_time<\/p>\n
pitch = max(0, min(127, pitch))
\n start_tick = int(time_offset * ticks_per_beat)
\n end_tick = int((time_offset + duration) * ticks_per_beat)<\/p>\n
events.append((start_tick, 'note_on', pitch, 100, channel))
\n events.append((end_tick, 'note_off', pitch, 0, channel))
\n current_time = time_offset + duration<\/p>\n
events.sort(key=lambda x: x[0])
\n prev_tick = 0
\n for tick, evt_type, pitch, velocity, ch in events:
\n delta = max(0, tick – prev_tick)
\n if evt_type == 'note_on':
\n track.append(Message('note_on', note=pitch, velocity=velocity,
\n channel=ch, time=delta))
\n else:
\n track.append(Message('note_off', note=pitch, velocity=velocity,
\n channel=ch, time=delta))
\n prev_tick = tick<\/p>\n
track.append(MetaMessage('end_of_track', time=0))<\/p>\n
control_track.append(MetaMessage('end_of_track', time=0))
\n mid.save(filename)
\n return True, f"MIDI\u5df2\u5bfc\u51fa: {filename} ({len(tracks)}\u8f68, {bpm}BPM, 4\/4\u62cd)"
\n except Exception as e:
\n return False, f"\u5bfc\u51fa\u5931\u8d25: {str(e)}"<\/p>\n
# ==================== \u4e3b\u5e94\u7528 ====================<\/p>\n
class CompositionApp:
\n """\u4f5c\u66f2\u8f6f\u4ef6\u4e3b\u5e94\u7528 v3"""<\/p>\n
COMPOSITION_TECHNIQUES = {
\n "\u65cb\u5f8b\u751f\u6210": "\u57fa\u4e8e\u98ce\u683c\u53c2\u6570\u7684\u968f\u673a\u65cb\u5f8b\u751f\u6210",
\n "\u5bf9\u4f4d\u6cd5": "\u4e8c\u58f0\u90e8\/\u4e09\u58f0\u90e8\u5bf9\u4f4d\u3001\u5361\u519c\u3001\u8d4b\u683c",
\n "\u548c\u58f0\u5b66": "\u56db\u90e8\u548c\u58f0\u3001\u7235\u58eb\u548c\u5f26\u8fdb\u884c",
\n "\u66f2\u5f0f\u5b66": "\u4e8c\u6bb5\u5f0f\u3001\u4e09\u6bb5\u5f0f\u3001\u56de\u65cb\u66f2\u3001\u53d8\u594f\u3001\u594f\u9e23\u66f2",
\n "\u914d\u5668\u6cd5": "\u4e50\u5668\u5206\u914d\u3001\u7ec7\u4f53\u751f\u6210\u3001\u97f3\u57df\u63a7\u5236",
\n "\u5341\u4e8c\u97f3": "\u5e8f\u5217\u4e3b\u4e49\u4f5c\u66f2\u3001\u97f3\u5217\u53d8\u5f62",
\n "\u8282\u594f\u6280\u6cd5": "\u590d\u8282\u594f\u3001\u5207\u5206\u3001\u5f8b\u52a8\u751f\u6210",
\n "\u5076\u7136\u97f3\u4e50": "\u63b7\u9ab0\u5b50\u4f5c\u66f2\u3001\u5143\u80de\u81ea\u52a8\u673a",
\n }<\/p>\n
def __init__(self, root):
\n self.root = root
\n root.title("\u4f5c\u66f2\u8f6f\u4ef6 v3 – \u7ecf\u5178\u4f5c\u66f2\u6280\u672f\u6574\u5408")<\/p>\n
screen_width = root.winfo_screenwidth()
\n if screen_width < 768:
\n root.attributes('-fullscreen', True)
\n self.font_size = 10
\n self.pad_size = 2
\n self.is_mobile = True
\n else:
\n root.geometry("900×750")
\n self.font_size = 10
\n self.pad_size = 4
\n self.is_mobile = False<\/p>\n
self._build()
\n self._last_score = ""
\n self._current_melody = []
\n self._midi_tracks = []<\/p>\n
def _build(self):
\n main_frame = ttk.Frame(self.root, padding=self.pad_size)
\n main_frame.pack(fill=tk.BOTH, expand=True)<\/p>\n
top_frame = ttk.LabelFrame(main_frame, text="\u4f5c\u66f2\u53c2\u6570", padding=5)
\n top_frame.pack(fill=tk.X, pady=2)<\/p>\n
row1 = ttk.Frame(top_frame)
\n row1.pack(fill=tk.X, pady=1)<\/p>\n
ttk.Label(row1, text="\u8c03\u5f0f:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.cmb_key = ttk.Combobox(row1, values=list(KEY_OFFSET.keys()),
\n width=8, font=("", self.font_size))
\n self.cmb_key.current(7)
\n self.cmb_key.pack(side=tk.LEFT, padx=1)<\/p>\n
ttk.Label(row1, text="\u98ce\u683c:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.cmb_style = ttk.Combobox(row1, values=list(STYLES.keys()),
\n width=8, font=("", self.font_size))
\n self.cmb_style.current(1)
\n self.cmb_style.pack(side=tk.LEFT, padx=1)<\/p>\n
ttk.Label(row1, text="\u5c0f\u8282:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.spn_bars = tk.Spinbox(row1, from_=4, to=64, width=4,
\n font=("", self.font_size))
\n self.spn_bars.delete(0, tk.END)
\n self.spn_bars.insert(0, "16")
\n self.spn_bars.pack(side=tk.LEFT, padx=1)<\/p>\n
ttk.Label(row1, text="BPM:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.spn_bpm = tk.Spinbox(row1, from_=30, to=300, width=4,
\n font=("", self.font_size))
\n self.spn_bpm.delete(0, tk.END)
\n self.spn_bpm.insert(0, "120")
\n self.spn_bpm.pack(side=tk.LEFT, padx=1)<\/p>\n
row2 = ttk.Frame(top_frame)
\n row2.pack(fill=tk.X, pady=2)<\/p>\n
ttk.Label(row2, text="\u4f5c\u66f2\u6280\u672f:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.cmb_technique = ttk.Combobox(row2, values=list(self.COMPOSITION_TECHNIQUES.keys()),
\n width=10, font=("", self.font_size))
\n self.cmb_technique.current(0)
\n self.cmb_technique.pack(side=tk.LEFT, padx=1)<\/p>\n
ttk.Label(row2, text="\u5b50\u7c7b\u578b:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.cmb_sub = ttk.Combobox(row2, values=["\u9ed8\u8ba4"], width=10,
\n font=("", self.font_size))
\n self.cmb_sub.current(0)
\n self.cmb_sub.pack(side=tk.LEFT, padx=1)<\/p>\n
ttk.Label(row2, text="\u53c2\u6570:", font=("", self.font_size)).pack(side=tk.LEFT, padx=2)
\n self.cmb_param = ttk.Combobox(row2, values=["\u9ed8\u8ba4"], width=8,
\n font=("", self.font_size))
\n self.cmb_param.current(0)
\n self.cmb_param.pack(side=tk.LEFT, padx=1)<\/p>\n
self.cmb_technique.bind("<<ComboboxSelected>>", self._update_subtypes)<\/p>\n
btn_frame = ttk.Frame(top_frame)
\n btn_frame.pack(fill=tk.X, pady=3)<\/p>\n
self.btn_generate = ttk.Button(btn_frame, text="\u751f\u6210\u4f5c\u54c1",
\n command=self._do_async, width=10)
\n self.btn_generate.pack(side=tk.LEFT, padx=3)<\/p>\n
ttk.Button(btn_frame, text="\u518d\u6765\u4e00\u9996",
\n command=self._do_again, width=10).pack(side=tk.LEFT, padx=3)<\/p>\n
ttk.Button(btn_frame, text="\u4fdd\u5b58\u7b80\u8c31",
\n command=self._save, width=10).pack(side=tk.LEFT, padx=3)<\/p>\n
ttk.Button(btn_frame, text="\u590d\u5236",
\n command=self._copy, width=8).pack(side=tk.LEFT, padx=3)<\/p>\n
ttk.Button(btn_frame, text="\u5bfc\u51faMIDI",
\n command=self._export_midi, width=10).pack(side=tk.LEFT, padx=3)<\/p>\n
self.lbl_status = ttk.Label(btn_frame, text="\u5c31\u7eea",
\n foreground="green", font=("", self.font_size))
\n self.lbl_status.pack(side=tk.LEFT, padx=5)<\/p>\n
txt_height = 20 if self.is_mobile else 25
\n self.txt = scrolledtext.ScrolledText(main_frame,
\n font=("Consolas", 13),
\n wrap=tk.WORD,
\n height=txt_height)
\n self.txt.pack(fill=tk.BOTH, expand=True, pady=2)<\/p>\n
bot = ttk.Frame(main_frame, padding=2)
\n bot.pack(fill=tk.X)<\/p>\n
tip = "\u4f5c\u66f2\u6280\u672f: \u65cb\u5f8b|\u5bf9\u4f4d|\u548c\u58f0|\u66f2\u5f0f|\u914d\u5668|\u5341\u4e8c\u97f3|\u8282\u594f|\u5076\u7136\u97f3\u4e50 | \u8f93\u51fa: \u591a\u58f0\u90e8\u7b80\u8c31 + MIDI"
\n ttk.Label(bot, text=tip, foreground="gray",
\n font=("", self.font_size – 1 if self.is_mobile else self.font_size),
\n wraplength=800).pack(side=tk.LEFT, padx=4)<\/p>\n
def _update_subtypes(self, event=None):
\n tech = self.cmb_technique.get()<\/p>\n
subtypes = {
\n "\u65cb\u5f8b\u751f\u6210": ["\u5355\u65cb\u5f8b", "\u591a\u58f0\u90e8\u65cb\u5f8b"],
\n "\u5bf9\u4f4d\u6cd5": ["\u4e8c\u58f0\u90e8\u5bf9\u4f4d", "\u4e09\u58f0\u90e8\u5bf9\u4f4d", "\u5361\u519c", "\u8d4b\u683c\u4e3b\u9898"],
\n "\u548c\u58f0\u5b66": ["\u56db\u90e8\u548c\u58f0", "\u7235\u58eb\u548c\u5f26", "\u529f\u80fd\u548c\u58f0\u8fdb\u884c"],
\n "\u66f2\u5f0f\u5b66": ["\u4e8c\u6bb5\u5f0f", "\u4e09\u6bb5\u5f0f", "\u56de\u65cb\u66f2", "\u53d8\u594f\u66f2", "\u594f\u9e23\u66f2\u5f0f"],
\n "\u914d\u5668\u6cd5": ["\u5f26\u4e50\u56db\u91cd\u594f", "\u94a2\u7434\u4e09\u91cd\u594f", "\u7ba1\u5f26\u4e50\u961f", "\u6d41\u884c\u4e50\u961f", "\u7ec7\u4f53\u751f\u6210"],
\n "\u5341\u4e8c\u97f3": ["\u57fa\u7840\u5e8f\u5217", "\u5b8c\u6574\u4f5c\u54c1", "\u97f3\u5217\u77e9\u9635"],
\n "\u8282\u594f\u6280\u6cd5": ["\u590d\u8282\u594f", "\u5207\u5206\u8282\u594f", "\u5f8b\u52a8\u751f\u6210", "\u8282\u594f\u52a8\u673a\u53d1\u5c55"],
\n "\u5076\u7136\u97f3\u4e50": ["\u63b7\u9ab0\u5b50\u4f5c\u66f2", "\u5b8c\u5168\u968f\u673a", "\u5143\u80de\u81ea\u52a8\u673a"],
\n }<\/p>\n
self.cmb_sub['values'] = subtypes.get(tech, ["\u9ed8\u8ba4"])
\n self.cmb_sub.current(0)<\/p>\n
params = {
\n "\u5bf9\u4f4d\u6cd5": ["\u4e00\u97f3\u5bf9\u4e00\u97f3", "\u4e8c\u97f3\u5bf9\u4e00\u97f3", "\u534e\u5f69\u5bf9\u4f4d"],
\n "\u66f2\u5f0f\u5b66": ["8\u5c0f\u8282", "16\u5c0f\u8282", "32\u5c0f\u8282"],
\n "\u914d\u5668\u6cd5": ["\u4e3b\u8c03\u7ec7\u4f53", "\u590d\u8c03\u7ec7\u4f53", "\u5206\u89e3\u548c\u5f26", "\u6301\u7eed\u97f3"],
\n "\u5341\u4e8c\u97f3": ["\u5e26\u8282\u594f", "\u7eaf\u97f3\u5217", "\u77e9\u9635\u5c55\u793a"],
\n "\u8282\u594f\u6280\u6cd5": ["3\u5bf92", "4\u5bf93", "5\u5bf94", "\u5207\u5206", "Shuffle", "Funk", "Bossa"],
\n }
\n self.cmb_param['values'] = params.get(tech, ["\u9ed8\u8ba4"])
\n self.cmb_param.current(0)<\/p>\n
def _do_async(self):
\n self.btn_generate.config(state=tk.DISABLED)
\n self.lbl_status.config(text="\u751f\u6210\u4e2d…", foreground="orange")
\n Thread(target=self._do, daemon=True).start()<\/p>\n
def _do(self):
\n try:
\n key = self.cmb_key.get()
\n style_name = self.cmb_style.get()
\n technique = self.cmb_technique.get()
\n subtype = self.cmb_sub.get()
\n param = self.cmb_param.get()<\/p>\n
try:
\n bars = int(self.spn_bars.get())
\n except:
\n bars = 16
\n try:
\n bpm = int(self.spn_bpm.get())
\n except:
\n bpm = 120<\/p>\n
style = STYLES.get(style_name, STYLES["\u6292\u60c5"])
\n key_offset = KEY_OFFSET.get(key, 0)<\/p>\n
if key.endswith("\u5c0f\u8c03"):
\n scale = MINOR_SCALE
\n elif style_name in ("\u5e73\u9759", "\u53e4\u98ce"):
\n scale = PENTATONIC_MAJOR
\n elif style_name == "\u84dd\u8c03":
\n scale = BLUES_SCALE
\n elif style_name == "\u5168\u97f3\u9636":
\n scale = WHOLE_TONE
\n elif style_name == "\u516b\u58f0\u97f3\u9636":
\n scale = OCTATONIC
\n else:
\n scale = MAJOR_SCALE<\/p>\n
oct_lo, oct_hi = style["oct_range"]
\n melody = gen_melody(bars, style, oct_lo, oct_hi, style["step_pref"])
\n self._current_melody = melody<\/p>\n
result = self._apply_technique(technique, subtype, param, melody,
\n key_offset, scale, style, bars)<\/p>\n
header = f"\u3010{technique} – {subtype}\u3011 | \u98ce\u683c: {style_name}\\\\n"
\n header += "=" * 50 + "\\\\n"<\/p>\n
header += f"[0,{bpm},{key}]\\\\n"
\n full = header + result<\/p>\n
self._last_score = full
\n self.root.after(0, self._render, full)<\/p>\n
except Exception as e:
\n self.root.after(0, self._render, f"\u9519\u8bef: {str(e)}")<\/p>\n
def _melody_to_midi_notes(self, melody):
\n """\u5c06\u65cb\u5f8b\u6570\u636e\u8f6c\u4e3aMIDI\u97f3\u7b26\u5217\u8868 [(pitch, duration, time_offset), …]"""
\n notes = []
\n time = 0
\n for item in melody:
\n if len(item) >= 3:
\n semi, octv, dur = item[0], item[1], item[2]
\n else:
\n continue
\n pitch = (4 + octv) * 12 + semi
\n notes.append((pitch, dur, time))
\n time += dur
\n return notes<\/p>\n
def _build_tracks_from_voices(self, voices_dict, instrument_map=None):
\n """\u4ece\u591a\u58f0\u90e8\u5b57\u5178\u6784\u5efaMIDI\u8f68\u9053\u5217\u8868"""
\n defaults = [0, 32, 40, 48, 56, 60, 73, 80]
\n tracks = []
\n for i, (name, melody) in enumerate(voices_dict.items()):
\n inst = instrument_map.get(name, defaults[i % len(defaults)]) if instrument_map else defaults[i % len(defaults)]
\n tracks.append((inst, self._melody_to_midi_notes(melody)))
\n return tracks<\/p>\n
def _apply_technique(self, technique, subtype, param, melody, key_offset, scale, style, bars):
\n """\u5e94\u7528\u9009\u5b9a\u7684\u4f5c\u66f2\u6280\u672f，\u540c\u65f6\u4fdd\u5b58MIDI\u591a\u8f68\u6570\u636e"""
\n self._midi_tracks = []<\/p>\n
if technique == "\u65cb\u5f8b\u751f\u6210":
\n self._midi_tracks = [(0, self._melody_to_midi_notes(melody))]
\n if subtype == "\u5355\u65cb\u5f8b":
\n return melody_to_score(melody)
\n else:
\n melody2 = gen_melody(bars, style, -1, 1, style["step_pref"])
\n self._midi_tracks = [
\n (0, self._melody_to_midi_notes(melody)),
\n (48, self._melody_to_midi_notes(melody2)),
\n ]
\n return multi_voice_to_score({"\u65cb\u5f8b1": melody, "\u65cb\u5f8b2": melody2})<\/p>\n
elif technique == "\u5bf9\u4f4d\u6cd5":
\n cp = CounterpointEngine(key_offset, scale)<\/p>\n
if subtype == "\u4e8c\u58f0\u90e8\u5bf9\u4f4d":
\n cantus = [semi + (4 + octv) * 12 for semi, octv, dur in melody]
\n counter = cp.generate_counterpoint(cantus, "above", 1)
\n counter_melody = [(c % 12, c \/\/ 12 – 4, 1.0) for c in counter[:len(melody)]]
\n self._midi_tracks = [
\n (0, self._melody_to_midi_notes(melody)),
\n (40, self._melody_to_midi_notes(counter_melody)),
\n ]
\n return multi_voice_to_score({"\u5b9a\u65cb\u5f8b": melody, "\u5bf9\u4f4d\u58f0\u90e8": counter_melody})<\/p>\n
elif subtype == "\u4e09\u58f0\u90e8\u5bf9\u4f4d":
\n cantus = [semi + (4 + octv) * 12 for semi, octv, dur in melody]
\n counter1 = cp.generate_counterpoint(cantus, "above", 1)
\n counter2 = cp.generate_counterpoint(cantus, "below", 1)
\n c1 = [(c % 12, c \/\/ 12 – 4, 1.0) for c in counter1[:len(melody)]]
\n c2 = [(c % 12, c \/\/ 12 – 4, 1.0) for c in counter2[:len(melody)]]
\n self._midi_tracks = [
\n (40, self._melody_to_midi_notes(c1)),
\n (0, self._melody_to_midi_notes(melody)),
\n (32, self._melody_to_midi_notes(c2)),
\n ]
\n return multi_voice_to_score({"\u9ad8\u97f3": c1, "\u4e2d\u97f3": melody, "\u4f4e\u97f3": c2})<\/p>\n
elif subtype == "\u5361\u519c":
\n cantus = [semi + (4 + octv) * 12 for semi, octv, dur in melody[:16]]
\n voices = cp.generate_canon(cantus, interval=7, delay=2)
\n v1 = [(v % 12, v \/\/ 12 – 4, 1.0) for v in voices[0]]
\n v2 = [(v % 12, v \/\/ 12 – 4, 1.0) for v in voices[1]]
\n self._midi_tracks = [
\n (0, self._melody_to_midi_notes(v1)),
\n (48, self._melody_to_midi_notes(v2)),
\n ]
\n header = "\u3010\u5361\u519c \u2014 \u516b\u5ea6\u6a21\u4eff，\u5ef6\u8fdf2\u62cd\u3011"
\n return header + "\\\\n" + multi_voice_to_score({"\u5148\u5bfc": v1, "\u6a21\u4eff": v2})<\/p>\n
elif subtype == "\u8d4b\u683c\u4e3b\u9898":
\n subject = cp.generate_fugue_subject(scale, length=12)
\n subject_melody = [(s % 12, 0, 1.0) for s in subject]
\n self._midi_tracks = [(0, self._melody_to_midi_notes(subject_melody))]
\n return "\u3010\u8d4b\u683c\u4e3b\u9898\u3011\\\\n" + melody_to_score(subject_melody) + "\\\\n\\\\n"<\/p>\n
elif technique == "\u548c\u58f0\u5b66":
\n he = HarmonyEngine(key_offset, scale)<\/p>\n
if subtype == "\u56db\u90e8\u548c\u58f0":
\n progression = random.choice(list(he.PROGRESSIONS.keys()))
\n voices = he.generate_four_part(progression, n_bars=min(bars, 8))
\n result = "\u3010\u56db\u90e8\u548c\u58f0 \u2014 \u548c\u5f26\u8fdb\u884c: " + progression + "\u3011\\\\n"
\n inst_map = {'S': 0, 'A': 48, 'T': 56, 'B': 32}
\n tracks = []
\n for v_name in ['S', 'A', 'T', 'B']:
\n voice_melody = [(p % 12, p \/\/ 12 – 4, 1.0) for p in voices[v_name]]
\n tracks.append((inst_map[v_name], self._melody_to_midi_notes(voice_melody)))
\n result += "\u3010" + v_name + "\u3011" + melody_to_score(voice_melody) + "\\\\n"
\n self._midi_tracks = tracks
\n return result<\/p>\n
elif subtype == "\u7235\u58eb\u548c\u5f26":
\n changes = he.generate_jazz_changes(n_bars=min(bars, 8))
\n result = "\u3010\u7235\u58eb\u548c\u5f26\u8fdb\u884c\u3011\\\\n"
\n for i, ch in enumerate(changes):
\n result += "\u7b2c" + str(i+1) + "\u5c0f\u8282: " + ch + " "
\n if (i + 1) % 4 == 0:
\n result += "\\\\n"
\n self._midi_tracks = [(0, self._melody_to_midi_notes(melody))]
\n return result<\/p>\n
elif subtype == "\u529f\u80fd\u548c\u58f0\u8fdb\u884c":
\n progression = random.choice(list(he.PROGRESSIONS.keys()))
\n prog = he.PROGRESSIONS[progression]
\n result = "\u3010\u529f\u80fd\u548c\u58f0 \u2014 " + progression + "\u3011\\\\n"
\n result += " \u2192 ".join(prog) + "\\\\n"
\n chord_melody = []
\n for chord_name in prog * (bars \/\/ len(prog) + 1):
\n root = he.CHORD_TYPES[chord_name][0]
\n chord_melody.append(((root + key_offset) % 12, 0, 1.0))
\n self._midi_tracks = [(0, self._melody_to_midi_notes(chord_melody[:bars]))]
\n result += "\\\\n\u6839\u97f3\u8fdb\u884c: " + melody_to_score(chord_melody[:bars])
\n return result<\/p>\n
elif technique == "\u66f2\u5f0f\u5b66":
\n fe = FormEngine()<\/p>\n
if subtype == "\u4e8c\u6bb5\u5f0f":
\n form = fe.generate_binary(melody, n_bars_a=bars\/\/2, n_bars_b=bars\/\/2)
\n self._midi_tracks = self._build_tracks_from_voices(form)
\n return "\u3010\u4e8c\u6bb5\u5f0f A-B\u3011\\\\n" + multi_voice_to_score(form)<\/p>\n
elif subtype == "\u4e09\u6bb5\u5f0f":
\n form = fe.generate_ternary(melody, n_bars=bars\/\/3)
\n self._midi_tracks = self._build_tracks_from_voices(form)
\n return "\u3010\u4e09\u6bb5\u5f0f A-B-A'\u3011\\\\n" + multi_voice_to_score(form)<\/p>\n
elif subtype == "\u56de\u65cb\u66f2":
\n form = fe.generate_rondo(melody, episodes=2)
\n self._midi_tracks = self._build_tracks_from_voices(form)
\n return "\u3010\u56de\u65cb\u66f2 A-B-A-C-A\u3011\\\\n" + multi_voice_to_score(form)<\/p>\n
elif subtype == "\u53d8\u594f\u66f2":
\n n_var = 3 if param == "\u9ed8\u8ba4" else int(param[0]) if param[0].isdigit() else 3
\n form = fe.generate_variations(melody, n_variations=n_var)
\n self._midi_tracks = self._build_tracks_from_voices(form)
\n return "\u3010\u53d8\u594f\u66f2\u3011\\\\n" + multi_voice_to_score(form)<\/p>\n
elif subtype == "\u594f\u9e23\u66f2\u5f0f":
\n melody2 = gen_melody(bars, style, -1, 2, style["step_pref"])
\n form = fe.generate_sonata(melody, melody2, n_bars=bars)
\n result = "\u3010\u594f\u9e23\u66f2\u5f0f\u3011\\\\n"
\n all_tracks = []
\n defaults = [0, 48, 40, 56]
\n idx = 0
\n for section_name, section in form["\u5448\u793a\u90e8"].items():
\n result += "— " + section_name + " —\\\\n"
\n result += "\u3010" + section_name + "\u3011" + melody_to_score(section) + "\\\\n"
\n all_tracks.append((defaults[idx % len(defaults)], self._melody_to_midi_notes(section)))
\n idx += 1
\n result += "\\\\n— \u5c55\u5f00\u90e8 —\\\\n"
\n result += melody_to_score(form["\u5c55\u5f00\u90e8"]) + "\\\\n"
\n all_tracks.append((defaults[idx % len(defaults)], self._melody_to_midi_notes(form["\u5c55\u5f00\u90e8"])))
\n idx += 1
\n for section_name, section in form["\u518d\u73b0\u90e8"].items():
\n result += "— " + section_name + " —\\\\n"
\n result += "\u3010" + section_name + "\u3011" + melody_to_score(section) + "\\\\n"
\n all_tracks.append((defaults[idx % len(defaults)], self._melody_to_midi_notes(section)))
\n idx += 1
\n self._midi_tracks = all_tracks
\n return result<\/p>\n
elif technique == "\u914d\u5668\u6cd5":
\n oe = OrchestrationEngine()<\/p>\n
if subtype in ["\u5f26\u4e50\u56db\u91cd\u594f", "\u94a2\u7434\u4e09\u91cd\u594f", "\u7ba1\u5f26\u4e50\u961f", "\u6d41\u884c\u4e50\u961f"]:
\n tracks_data = oe.assign_instruments(melody, subtype)
\n result = "\u3010" + subtype + "\u3011\\\\n"
\n midi_tracks = []
\n for i, track in enumerate(tracks_data):
\n track_melody = [(t[0], t[1], t[2]) for t in track]
\n inst_name = track[0][4] if track else "\u672a\u77e5"
\n inst_id = track[0][3] if track else 0
\n result += "\u3010" + inst_name + "\u3011" + melody_to_score(track_melody) + "\\\\n"
\n midi_tracks.append((inst_id, self._melody_to_midi_notes(track_melody)))
\n self._midi_tracks = midi_tracks
\n return result<\/p>\n
elif subtype == "\u7ec7\u4f53\u751f\u6210":
\n texture_type = param if param in ["\u4e3b\u8c03", "\u590d\u8c03", "\u5206\u89e3\u548c\u5f26", "\u6301\u7eed\u97f3"] else "\u4e3b\u8c03"
\n texture = oe.generate_texture(melody, texture_type)
\n result = "\u3010" + texture_type + "\u7ec7\u4f53\u3011\\\\n"
\n midi_tracks = []
\n defaults = [0, 48, 40, 32]
\n idx = 0
\n for name, content in texture.items():
\n if name == "\u4f34\u594f":
\n result += "\u3010" + name + "\u3011（\u548c\u5f26\u4f34\u594f）\\\\n"
\n if content and isinstance(content[0], list):
\n flat = []
\n for chord_notes in content:
\n if chord_notes:
\n flat.extend(chord_notes)
\n midi_tracks.append((defaults[idx % len(defaults)], self._melody_to_midi_notes(flat)))
\n else:
\n midi_tracks.append((defaults[idx % len(defaults)], self._melody_to_midi_notes(content)))
\n else:
\n result += "\u3010" + name + "\u3011" + melody_to_score(content) + "\\\\n"
\n midi_tracks.append((defaults[idx % len(defaults)], self._melody_to_midi_notes(content)))
\n idx += 1
\n self._midi_tracks = midi_tracks
\n return result<\/p>\n
elif technique == "\u5341\u4e8c\u97f3":
\n tte = TwelveToneEngine()<\/p>\n
if subtype == "\u57fa\u7840\u5e8f\u5217":
\n row = tte.generate_row()
\n self._midi_tracks = [(0, self._melody_to_midi_notes([(r, 0, 0.5) for r in row]))]
\n return "\u3010\u5341\u4e8c\u97f3\u57fa\u7840\u5e8f\u5217\u3011\\\\n" + " ".join(str(x) for x in row) + "\\\\n"<\/p>\n
elif subtype == "\u5b8c\u6574\u4f5c\u54c1":
\n piece = tte.generate_piece(n_notes=min(bars * 4, 48))
\n transforms = tte.get_transformations()
\n result = "\u3010\u5341\u4e8c\u97f3\u6280\u6cd5\u4f5c\u54c1\u3011\\\\n"
\n result += "P: " + " ".join(str(x) for x in transforms['P']) + "\\\\n"
\n result += "I: " + " ".join(str(x) for x in transforms['I']) + "\\\\n"
\n result += "R: " + " ".join(str(x) for x in transforms['R']) + "\\\\n"
\n result += "RI: " + " ".join(str(x) for x in transforms['RI']) + "\\\\n\\\\n"
\n result += melody_to_score(piece)
\n self._midi_tracks = [(0, self._melody_to_midi_notes(piece))]
\n return result<\/p>\n
elif subtype == "\u97f3\u5217\u77e9\u9635":
\n tte.generate_row()
\n matrix = tte.build_matrix()
\n result = "\u3010\u5341\u4e8c\u97f3\u97f3\u5217\u77e9\u9635\u3011\\\\n"
\n result += " " + " ".join(f"{x:2d}" for x in range(12)) + "\\\\n"
\n result += " " + "-" * 37 + "\\\\n"
\n for i, row in enumerate(matrix):
\n result += f"{i:2d}" + " | " + " ".join(f"{x:2d}" for x in row) + "\\\\n"
\n self._midi_tracks = [(0, self._melody_to_midi_notes([(r, 0, 0.5) for r in tte.row]))]
\n return result<\/p>\n
elif technique == "\u8282\u594f\u6280\u6cd5":
\n re = RhythmEngine()<\/p>\n
if subtype == "\u590d\u8282\u594f":
\n if "\u5bf9" in param:
\n parts = param.split("\u5bf9")
\n p1, p2 = int(parts[0]), int(parts[1])
\n else:
\n p1, p2 = 3, 2
\n poly = re.generate_polyrhythm(p1, p2, n_beats=4)
\n result = "\u3010\u590d\u8282\u594f " + str(p1) + "\u5bf9" + str(p2) + "\u3011\\\\n"
\n result += "\u57fa\u7840\u62cd: " + " | ".join([f"{n:.2f}" for n, d in poly["\u57fa\u7840"]]) + "\\\\n"
\n result += "\u5bf9\u4f4d\u62cd: " + " | ".join([f"{n:.2f}" for n, d in poly["\u5bf9\u4f4d"]]) + "\\\\n"
\n self._midi_tracks = [(0, self._melody_to_midi_notes(melody))]
\n return result<\/p>\n
elif subtype == "\u5207\u5206\u8282\u594f":
\n base_pattern = [1.0, 1.0, 1.0, 1.0]
\n syncopated = re.generate_syncopation(base_pattern, intensity=0.6)
\n result = "\u3010\u5207\u5206\u8282\u594f\u3011\\\\n"
\n result += "\u539f\u59cb: " + " | ".join([f"{d:.2f}" for d in base_pattern]) + "\\\\n"
\n result += "\u5207\u5206: " + " | ".join([f"{d:.2f}" for d in syncopated]) + "\\\\n"
\n sync_melody = []
\n for i, (semi, octv, _) in enumerate(melody[:len(syncopated)]):
\n sync_melody.append((semi, octv, syncopated[i]))
\n result += "\\\\n\u65cb\u5f8b: " + melody_to_score(sync_melody)
\n self._midi_tracks = [(0, self._melody_to_midi_notes(sync_melody))]
\n return result<\/p>\n
elif subtype == "\u5f8b\u52a8\u751f\u6210":
\n groove_style = param.lower() if param != "\u9ed8\u8ba4" else "funk"
\n groove = re.generate_groove(groove_style, n_bars=bars \/\/ 4)
\n result = "\u3010" + groove_style.title() + " \u5f8b\u52a8\u3011\\\\n"
\n result += "\u8282\u594f\u578b: " + " ".join([f"{d:.2f}" for d in groove[:16]]) + "…\\\\n"
\n self._midi_tracks = [(0, self._melody_to_midi_notes(melody))]
\n return result<\/p>\n
elif subtype == "\u8282\u594f\u52a8\u673a\u53d1\u5c55":
\n motif = [1.0, 0.5, 0.5]
\n techniques = ["\u91cd\u590d", "\u589e\u503c", "\u51cf\u503c", "\u9006\u884c", "\u5206\u88c2"]
\n result = "\u3010\u8282\u594f\u52a8\u673a\u53d1\u5c55\u3011\\\\n"
\n result += "\u539f\u59cb\u52a8\u673a: " + " | ".join([str(d) for d in motif]) + "\\\\n\\\\n"
\n for tech in techniques:
\n developed = re.develop_rhythm(motif, tech)
\n result += tech + ": " + " | ".join([f"{d:.2f}" for d in developed]) + "\\\\n"
\n self._midi_tracks = [(0, self._melody_to_midi_notes(melody))]
\n return result<\/p>\n
elif technique == "\u5076\u7136\u97f3\u4e50":
\n cme = ChanceMusicEngine()<\/p>\n
if subtype == "\u63b7\u9ab0\u5b50\u4f5c\u66f2":
\n piece = cme.dice_composition(n_bars=min(bars, 8))
\n result = "\u3010\u63b7\u9ab0\u5b50\u4f5c\u66f2（\u83ab\u624e\u7279\u98ce\u683c）\u3011\\\\n"
\n result += melody_to_score(piece)
\n self._midi_tracks = [(0, self._melody_to_midi_notes(piece))]
\n return result<\/p>\n
elif subtype == "\u5b8c\u5168\u968f\u673a":
\n piece = cme.aleatoric_piece(n_events=min(bars * 4, 50))
\n result = "\u3010\u5b8c\u5168\u968f\u673a\u5076\u7136\u97f3\u4e50\u3011\\\\n"
\n result += melody_to_score([(p[0], p[1], p[2]) for p in piece])
\n self._midi_tracks = [(0, self._melody_to_midi_notes([(p[0], p[1], p[2]) for p in piece]))]
\n return result<\/p>\n
elif subtype == "\u5143\u80de\u81ea\u52a8\u673a":
\n piece = cme.cellular_automata_music(rule=30, n_generations=32)
\n result = "\u3010\u5143\u80de\u81ea\u52a8\u673a\u97f3\u4e50 (Rule 30)\u3011\\\\n"
\n result += melody_to_score(piece)
\n self._midi_tracks = [(0, self._melody_to_midi_notes(piece))]
\n return result<\/p>\n
self._midi_tracks = [(0, self._melody_to_midi_notes(melody))]
\n return melody_to_score(melody)<\/p>\n
def _render(self, text): return melody_to_score(melody)<\/p>\n
def _render(self, text):
\n self.txt.delete("1.0", tk.END)
\n self.txt.insert(tk.END, text)
\n n_lines = text.count('\\\\n') + 1
\n self.lbl_status.config(text=f"\u2713 \u5b8c\u6210 ({n_lines} \u884c)", foreground="green")
\n self.btn_generate.config(state=tk.NORMAL)<\/p>\n
def _do_again(self):
\n self._do_async()<\/p>\n
def _save(self):
\n if not self._last_score:
\n messagebox.showinfo("\u63d0\u793a", "\u8bf7\u5148\u751f\u6210\u4f5c\u54c1")
\n return
\n path = filedialog.asksaveasfilename(defaultextension=".txt",
\n filetypes=[("\u7b80\u8c31\u6587\u4ef6", "*.txt")])
\n if path:
\n with open(path, "w", encoding="utf-8") as f:
\n f.write(self._last_score)
\n messagebox.showinfo("\u4fdd\u5b58", f"\u5df2\u4fdd\u5b58\u5230 {path}")<\/p>\n
def _copy(self):
\n if not self._last_score:
\n return
\n self.root.clipboard_clear()
\n self.root.clipboard_append(self._last_score)
\n self.lbl_status.config(text="\u5df2\u590d\u5236", foreground="blue")<\/p>\n
def _export_midi(self):
\n if not self._current_melody:
\n messagebox.showinfo("\u63d0\u793a", "\u8bf7\u5148\u751f\u6210\u65cb\u5f8b")
\n return<\/p>\n
path = filedialog.asksaveasfilename(defaultextension=".mid",
\n filetypes=[("MIDI\u6587\u4ef6", "*.mid")])
\n if not path:
\n return<\/p>\n
try:
\n bpm = int(self.spn_bpm.get())
\n except:
\n bpm = 120<\/p>\n
# \u4f18\u5148\u4f7f\u7528\u5df2\u4fdd\u5b58\u7684\u591a\u8f68\u6570\u636e，\u652f\u6301\u591a\u58f0\u90e8\u5bfc\u51fa
\n if self._midi_tracks and len(self._midi_tracks) > 0:
\n tracks = self._midi_tracks
\n else:
\n notes = []
\n time = 0
\n for semi, octv, dur in self._current_melody:
\n pitch = (4 + octv) * 12 + semi
\n notes.append((pitch, dur, time))
\n time += dur
\n tracks = [(0, notes)]<\/p>\n
success, msg = export_midi(tracks, bpm, path)
\n if success:
\n self.lbl_status.config(text=msg, foreground="green")
\n messagebox.showinfo("\u5bfc\u51fa\u6210\u529f", msg)
\n else:
\n self.lbl_status.config(text=msg, foreground="red")
\n messagebox.showerror("\u5bfc\u51fa\u5931\u8d25", msg)<\/p>\n
if __name__ == "__main__":
\n root = tk.Tk()
\n app = CompositionApp(root)
\n root.mainloop()<\/p>\n","protected":false},"excerpt":{"rendered":"
# -*- coding: utf-8 -*-
\n\\”\\”\\”
\n\u4f5c\u66f2\u8f6f\u4ef6 v3 – \u6574\u5408\u7ecf\u5178\u4f5c\u66f2\u6280\u672f
\n\u652f\u6301：\u5bf9\u4f4d\u6cd5\u3001\u548c\u58f0\u5b66\u3001\u66f2\u5f0f\u5b66\u3001\u914d\u5668\u6cd5\u3001\u73b0\u4ee3\u6280\u6cd5
\n\u8f93\u51fa：\u591a\u58f0\u90e8\u7b80\u8c31 MIDI\u591a\u8f68
\n\\”\\”\\”import random
\nimport math
\nimport tkinter as tk
\nfrom tkinter import ttk, scrolledtext, messagebox, filedialog
\nfrom threading import Thre<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[81,149,427],"topic":[],"class_list":["post-85034","post","type-post","status-publish","format-standard","hentry","category-server","tag-python","tag-windows","tag-427"],"yoast_head":"\n