精华内容
下载资源
问答
  • python分析乐谱和音乐的包music21

    千次阅读 2020-02-28 15:24:00
    计算机分析音乐的包: Music21 is a Python-based toolkit for computer-aided musicology 完整示例代码 # -*- coding:utf-8 -*- # /usr/bin/python ''' ------------------------------------------------- File ...

    music21

    • 计算机分析音乐的包:
    • Music21 is a Python-based toolkit for computer-aided musicology

    完整示例代码

    # -*- coding:utf-8 -*-
    # /usr/bin/python
    '''
    -------------------------------------------------
       File Name   : music21_learning
       Description :  AIM: 计算机辅助音乐分析工具包。
    由卡特伯特实验室在麻省理工学院开发。 迈克尔·斯科特·卡斯伯特,首席调查员。 音乐21的发展得到了 西弗学院和新英格兰大学的慷慨大方
                      Functions: 1. 
                                 2. 
       Envs        :  python == 
                      pip install music21 -i https://pypi.douban.com/simple
       Author      :  yanerrol
       Date        : 2020/2/27  22:37
    -------------------------------------------------
       Change Activity:
              2020/2/27 : text
    -------------------------------------------------
    '''
    __author__ = 'yanerrol'
    
    from music21 import *
    
    # 创建音符
    f = note.Note('F5#')# 创建一个音高为F5的音符
    print(f.name)
    print(f.step) #
    展开全文
  • 关于电子功用-便携式电子乐谱仪的说明分析.rar
  • 乐谱

    2019-10-02 18:04:22
    分析】 二分查找。 var f,s: array [ 0 .. 50001 ] of longint; i,x,n,q,t,l,r,mid:longint; begin readln(n,q); s[ 0 ]:= 0 ; for i:= 1 to n do begin read (x); s[i]:=s[i- 1 ]+x;...

    【题目描述】
    Farmer John准备教他的奶牛弹一首歌。这首歌由N个音阶组成,第i个音阶要弹Bi次。奶牛从第0时刻开始弹,因此她从第0时刻到第B1-1时刻都在弹第1个音阶,从第B1时刻到第B1+B2-1时刻都在弹第2个音阶……现在有Q个问题:在时刻[t,t+1]中,奶牛弹的是哪个音阶?
    【输入格式】
    第一行两个整数N,Q
    接下来N行,第i+1行一个整数Bi
    接下来Q行,每行一个整数t
    【输出格式】
    对于每个询问给出答案
    【样例输入】
    3 5
    2
    1
    3
    2
    3
    4
    0
    1
    【样例输出】
    2
    3
    3
    1
    1
    【数据范围】
    1<=N<=50000
    1<=Bi<=10000
    1<=Q<=50000
    【分析】
    二分查找。

    var
      f,s:array[0..50001]of longint;
      i,x,n,q,t,l,r,mid:longint;
    begin
      readln(n,q);
      s[0]:=0;
      for i:=1 to n do begin
        read(x);
          s[i]:=s[i-1]+x;
            f[i]:=s[i]-1;
      end;
      for i:=1 to q do begin
        readln(t);
        l:=1;r:=n;
          while l<=r do
          begin
                mid:=(l+r) div 2;
            if (t<=f[mid])and(t>=f[mid-1]+1) then break;
                if t>f[mid] then l:=mid+1 else r:=mid-1;
            end;
            writeln(mid);
      end;
    end.

    转载于:https://www.cnblogs.com/JRX2015U43/p/6533538.html

    展开全文
  • #资源达人分享计划#
  • 将洛奇的MML乐谱转为beep(蜂鸣器)乐谱转换器制作音高频率表词法分析、语法分析token转换为beep谱用法使用C++播放 最近对蜂鸣器音乐感兴趣,但是找不到乐谱,于是想把其他乐谱转为蜂鸣器乐谱。直接用MIDI转换很困难...

    最近对蜂鸣器音乐感兴趣,但是找不到乐谱,于是想把其他乐谱转为蜂鸣器乐谱。直接用MIDI转换很困难,因为MIDI一个音轨可以同时发出不同的音,所以我想到了用以前玩过的游戏中的乐谱(MML乐谱参考

    本文完整源码

    转换器制作

    音高频率表

    首先要知道每个音高对应的频率,按照十二平均律算,标准音高A4是440Hz,一个半音相差21/12倍,一个八度相差2倍

    FREQ_TABLE = [[0 for scale in range(12)] for octave in range(9)]
    
    
    def gen_freq_table():
        global FREQ_TABLE
        # A4标准音高
        FREQ_TABLE[4][9] = 440
        # 十二平均律
        for scale in range(8, -1, -1):
            FREQ_TABLE[4][scale] = FREQ_TABLE[4][scale + 1] / 2 ** (1 / 12)
        for scale in range(10, 12):
            FREQ_TABLE[4][scale] = FREQ_TABLE[4][scale - 1] * 2 ** (1 / 12)
        for octave in range(3, -1, -1):
            for scale in range(12):
                FREQ_TABLE[octave][scale] = FREQ_TABLE[octave + 1][scale] / 2
        for octave in range(5, 9):
            for scale in range(12):
                FREQ_TABLE[octave][scale] = FREQ_TABLE[octave - 1][scale] * 2
        for octave in range(9):
            for scale in range(12):
                FREQ_TABLE[octave][scale] = round(FREQ_TABLE[octave][scale])
    
    
    gen_freq_table()
    

    生成表后直接硬编码即可

    # 音程 -> 音阶 -> 频率,按十二平均律算
    FREQ_TABLE = [
        [16, 17, 18, 19, 21, 22, 23, 24, 26, 28, 29, 31],  # C0~B0(未使用)
        [33, 35, 37, 39, 41, 44, 46, 49, 52, 55, 58, 62],  # C1~B1
        [65, 69, 73, 78, 82, 87, 92, 98, 104, 110, 117, 123],
        [131, 139, 147, 156, 165, 175, 185, 196, 208, 220, 233, 247],
        [262, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494],  # C4~B4
        [523, 554, 587, 622, 659, 698, 740, 784, 831, 880, 932, 988],
        [1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1976],
        [2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951],
        [4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902]
    ]
    

    词法分析、语法分析

    因为宏语言比较简单,这两部分就和在一起写了。输入MML字符串,输出音符、预设音长等token

    # Token等定义略
    
    class SyntaxAnalyzer:
        """语法分析器(兼词法分析器)"""
    
        # 字符 -> 音阶索引
        SCALE = {
            'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11
        }
    
        def __init__(self):
            self._mml = ''
            self._index = 0
            self._line = 1
            self._col = 1
    
            self._res = [[]]
    
        def _preprocess(self):
            self._mml = self._mml.upper()
            self._index = 0
            self._line = 1
            self._col = 1
            if self._mml.startswith('MML@'):
                self._index += 4
                self._col += 4
    
            self._res = [[]]
    
        def parse(self, mml: str) -> List[List[Token]]:
            """返回音轨数组,每个音轨包含多个Token"""
    
            self._mml = mml
            self._preprocess()
    
            while self._index < len(self._mml):
                line = self._line
                col = self._col
                if self._cur_char == ',':
                    # 新音轨
                    self._read_char()
                    self._res.append([])
    
                elif self._cur_char == ';':
                    # 结束
                    self._read_char()
                    break
    
                elif self._cur_char in 'CDEFGAB':
                    # 音符
                    self._output(self._read_note())
    
                elif self._cur_char == 'R':
                    # 休止符
                    self._read_char()
                    self._output(Pause(line, col, self._read_length()))
    
                elif self._cur_char == '&':
                    # 连接
                    self._read_char()
                    self._output(Joiner(line, col))
    
                elif self._cur_char == 'L':
                    # 预设音长
                    self._read_char()
                    self._output(DefaultLength(line, col, self._read_length()))
    
                elif self._cur_char == 'T':
                    # 播放速度
                    self._read_char()
                    tempo = self._read_number()
                    if tempo is not None and not 32 <= tempo <= 255:
                        raise MmlError(line, col, f'tempo = {tempo},速度超出范围')
                    self._output(Tempo(line, col, tempo))
    
                elif self._cur_char == 'V':
                    # 音量
                    self._read_char()
                    volume = self._read_number()
                    if volume is not None and not 0 <= volume <= 15:
                        raise MmlError(line, col, f'volume = {volume},音量超出范围')
                    self._output(Volume(line, col, volume))
    
                elif self._cur_char == 'O':
                    # 音程
                    self._read_char()
                    octave = self._read_number()
                    if octave is not None and not 1 <= octave <= 8:
                        raise MmlError(line, col, f'octave = {octave},音程超出范围')
                    self._output(Octave(line, col, octave))
    
                elif self._cur_char in '><':
                    # 改变音程
                    self._output(ChangeOctave(line, col, 1 if self._cur_char == '>' else -1))
                    self._read_char()
    
                elif self._cur_char == 'N':
                    # 绝对音高
                    self._read_char()
                    note_index = self._read_number()
                    if note_index is None or not 1 <= note_index <= 96:
                        raise MmlError(line, col, f'note_index = {note_index},绝对音高超出范围')
                    self._output(AbsoluteNote(line, col, note_index))
    
                elif self._cur_char in ' \t\r':
                    # 空白
                    self._read_char()
    
                elif self._cur_char == '\n':
                    # 新行
                    self._read_char()
                    self._line += 1
                    self._col = 1
    
                else:
                    # 错误字符
                    raise MmlError(line, col, f'未预料到的字符"{self._cur_char}"')
    
            return self._res
        
        def _output(self, token):
            self._res[-1].append(token)
        
        def _read_char(self):
            res = self._mml[self._index]
            self._index += 1
            self._col += 1
            return res
        
        @property
        def _cur_char(self):
            return self._mml[self._index]
    
        def _read_number(self):
            """读数字,非数字则返回None"""
    
            if self._index >= len(self._mml) or not '0' <= self._cur_char <= '9':
                return None
            res = 0
            while self._index < len(self._mml) and '0' <= self._cur_char <= '9':
                res = res * 10 + int(self._cur_char)
                self._read_char()
            return res
    
        def _read_length(self):
            length = self._read_number()
            has_dot = False
            if self._index < len(self._mml) and self._cur_char == '.':
                has_dot = True
                self._read_char()
            return Length(length, has_dot)
    
        def _read_note(self):
            line = self._line
            col = self._col
    
            scale = self.SCALE[self._cur_char]
            self._read_char()
            if self._index < len(self._mml):
                if self._cur_char in '+#':
                    scale += 1
                    self._read_char()
                elif self._cur_char == '-':
                    scale -= 1
                    self._read_char()
            return Note(line, col, scale, self._read_length())
    

    token转换为beep谱

    这里要考虑tempo是所有音轨共用的,后面的音轨优先,所以每次选时间最小的音轨处理,如果时间相同则选择后面的音轨

    按照4分音符为一拍,持续时间计算方法: d u r a t i o n ( m s ) = 6 0 ( s / m i n ) / t e m p o ( b e a t / m i n ) ∗ 4 ( b e a t / 全 音 符 ) / l e n g t h ( 全 音 符 − 1 ) ∗ 100 0 ( m s / s ) duration_{(ms)} = 60_{(s/min)} / tempo_{(beat/min)} * 4_{(beat/全音符)} / length_{(全音符^{-1})} * 1000_{(ms/s)} duration(ms)=60(s/min)/tempo(beat/min)4(beat/)/length(1)1000(ms/s)

    class MmlParser:
        class _Track:
            def __init__(self, tokens):
                self.tokens = tokens
                self.index = 0
                # 音程
                self.octave = DEFAULT_OCTAVE
                # 预设音长
                self.default_length = DEFAULT_LENGTH
                # 播放速度(BPM,一分钟几拍)
                self.tempo = None
                # 下一个音符开始时间
                self.time = 0
                # 前面有一个连接符,正在连接状态
                self.is_joining = False
                self.beep_res = []
    
            def output(self, frequency, duration):
                self.time += duration
                if not self.is_joining:
                    self.beep_res.append([frequency, duration])
                    return
                if not self.beep_res:
                    raise MmlError(self.tokens[self.index].line, self.tokens[self.index].col, '缺少被连接的音符')
                if self.beep_res[-1][0] == frequency:
                    self.beep_res[-1][1] += duration
                else:
                    self.beep_res.append([frequency, duration])
                self.is_joining = False
    
        def __init__(self):
            self._tracks = []
    
        def parse(self, mml: str) -> List[List[List[int]]]:
            """转换MML乐谱到beep谱
    
            返回音轨数组,每个音轨包含多个音符,每个音符为[频率(Hz), 持续时间(ms)],频率为0代表延时
            """
    
            self._tracks = [self._Track(tokens) for tokens in SyntaxAnalyzer().parse(mml)]
    
            track = self._get_next_track_to_process()
            while track is not None:
                token = track.tokens[track.index]
                if isinstance(token, Note):
                    # 音符
                    octave = track.octave
                    scale = token.scale
                    if scale < 0:
                        scale = 11
                        octave -= 1
                    elif scale >= 12:
                        scale = 0
                        octave += 1
                    if not 1 <= octave <= 8:
                        raise MmlError(token.line, token.col, f'octave = {octave},音程超出范围')
                    track.output(FREQ_TABLE[octave][scale], self._get_duration(track, token.length))
    
                elif isinstance(token, Pause):
                    # 休止符
                    track.output(0, self._get_duration(track, token.length))
    
                elif isinstance(token, Joiner):
                    # 连接
                    track.is_joining = True
    
                elif isinstance(token, DefaultLength):
                    # 预设音长
                    length = token.length.length or DEFAULT_LENGTH
                    if token.length.has_dot:
                        length /= 1.5
                    track.default_length = length
    
                elif isinstance(token, Tempo):
                    # 播放速度
                    track.tempo = token.tempo
    
                elif isinstance(token, Octave):
                    # 音程
                    track.octave = token.octave or DEFAULT_OCTAVE
    
                elif isinstance(token, ChangeOctave):
                    # 改变音程
                    track.octave += token.delta_octave
    
                elif isinstance(token, AbsoluteNote):
                    # 绝对音高
                    note_index = token.note_index - 1
                    octave = note_index // 12 + 1
                    scale = note_index % 12
                    track.output(FREQ_TABLE[octave][scale], self._get_duration(track, Length()))
    
                track.index += 1
                track = self._get_next_track_to_process()
    
            return [track.beep_res for track in self._tracks]
    
        def _get_next_track_to_process(self):
            res = None
            for track in self._tracks:
                if track.index >= len(track.tokens):
                    # 这条音轨已经处理完
                    continue
                if res is None or track.time <= res.time:
                    # 时间小的先处理,如果时间一样先处理后面的音轨
                    res = track
            return res
    
        def _get_duration(self, track, length: Length):
            tempo = None
            # tempo共用,后面的音轨优先
            for track_ in reversed(self._tracks):
                if track_.tempo is not None:
                    tempo = track_.tempo
                    break
            if tempo is None:
                tempo = DEFAULT_TEMPO
    
            length_ = length.length or track.default_length
            if length.has_dot:
                length_ /= 1.5
    
            return round(60 / tempo * 4 / length_ * 1000)
    

    用法

        with open(args.mml_file) as f:
            mml = f.read()
        res = MmlParser().parse(mml)
        with open(args.beep_file, 'w') as f:
            json.dump(res[args.track], f)
    

    使用C++播放

    不推荐在Windows7以及更新版本的Windows系统玩beep音乐,因为Win7以上的Beep是用声卡模拟的(API参考),和蜂鸣器声音相差大,而且播放太快会不发声

    #include <Windows.h>
    
    struct Note {
        unsigned int frequency;
        unsigned int duration;
    };
    
    extern std::vector<Note> notes; // 定义在另一个cpp文件
    
    int main() {
        for (auto [frequency, duration] : notes) {
            if (frequency == 0) // 延时
                Sleep(duration);
            else
                Beep(frequency, duration);
        }
    
        return 0;
    }
    
    展开全文
  • 使用Gabor变换,我们分析了两首著名歌曲的音频片段,并能够导出特定乐器演奏的音符的频率。然后,由于我们知道音符的确切频率,因此我们能够为该乐器重新创建乐谱。另外,在该项目中,我们能够将某些乐器与音频片段...
  • 乐谱的发展与西方音乐的发展是紧密相连的,乐谱是钢琴演奏与教学中的一个至关重要的问题。以下是由学习啦小编整理关于钢琴乐谱基础知识的内容,希望大家喜欢!钢琴乐谱基础知识1、“1=do”那是简谱,不是钢琴谱。钢琴...

    乐谱的发展与西方音乐的发展是紧密相连的,乐谱是钢琴演奏与教学中的一个至关重要的问题。以下是由学习啦小编整理关于钢琴乐谱基础知识的内容,希望大家喜欢!

    钢琴乐谱基础知识

    1、“1=do”那是简谱,不是钢琴谱。钢琴谱里都是用调号来表示调式的。 先说说简谱中其他每个调哪里是do: b1=do是降C调,#1=do是升C调,b2=do是降D调,2=do是D调,#2=do是升D调,b3=do是降E调,3=do是E调,#3=do是升E调,b4=do是降F调,4=do是F调,#4=do是升F调,b5=do是降G调,5=do是G调,#5=do是升G调,b6=do是降A调,6=do是A调,#6=do是升A调,b7=do是降B调,7=do是B调,#7=do是升B调

    2、以下是钢琴谱(即五线谱中)调与调号的关系: 升号与降号统称调号。 以下一切内容均指在西洋大小调体系中的情况。 1、升号调总结: 一个升号是G大调或e小调, 两个升号是D大调或b小调, 三个升号是A大调或升f小调, 四个升号是E大调或升c小调, 五个升号是B大调或升g小调, 六个升号是升F大调或升d小调, 七个升号是升C大调或升a小调, 八个升号是升G大调或升e小调, 九个升号是升D大调或升b小调, 十个升号是升A大调或重升f小调, 十一个升号是升E大调或重升c小调, 十二个升号是升B大调或重升g小调, 十三个升号是重升F大调或重升d小调, …… 注意观察规律:升号数量每增加一次,大调和小调的主音(即调名中字母所表示的音)就升高纯五度。以大调为例,C升高纯五度是G,G升高纯五度是D,D升高纯五度是A,A升高纯五度是E,E升高纯五度是B,B升高纯五度是升F,……,以此类推。这叫做“调的五度循环”。当然,以一个升号至七个升号的居多。

    3、怎样由升号的数量推求所升的音?方法如下: 首先列举: 一个升号是升F, 两个升号是升F和升C, 三个升号是升F、升C和升G, 四个升号是升F、升C、升G和升D, 五个升号是升F、升C、升G、升D和升A, 六个升号是升F、升C、升G、升D、升A和升E, 七个升号是升F、升C、升G、升D、升A、升E和升B, 八个升号是升F、升C、升G、升D、升A、升E、升B和升F

    注意观察规律:升号的数量从一开始增加时,所升的最后一个音分别为(此时记唱名)fa、do、sol、re、la、mi、si、fa、do、sol、re、la、mi、si、fa……(每种加上上述它前面的所有音后就构成了该种调所升的所有音),规律为:从fa开始,先降纯四度,再升纯五度,再降纯四度,再升纯五度,再降纯四度,再升纯五度,再降纯四度,再升纯五度,再降纯四度,再升纯五度,以此类推(再观察上述从一个升号到八个升号的列举,仔细体会)。另外,由于从八个升号的调开始,所升的音就有重复的了,因此,要记得把重复的音合并成重升。例如:八个升号的调本来是升F、升C、升G、升D、升A、升E、升B和升F,那么合并后就应该是重升F、升C、升G、升D、升A、升E和升B。再例如:十三个升号的调本来是升F、升C、升G、升D、升A、升E、升B、升F、升C、升G、升D、升A、升E,合并后就应该是重升F、重升C、重升G、重升D、重升A、重升E和升B。

    4、降号调总结:降号调的所有项目均正好与升号调相反,本来对照升号调就可以了,但为了清楚起见,我还是都列出来吧。 一个降号是F大调或d小调, 两个降号是降B大调或g小调, 三个降号是降E大调或c小调, 四个降号是降A大调或f小调, 五个降号是降D大调或降b小调, 六个降号是降G大调或降e小调, 七个降号是降C大调或降a小调, 八个降号是降F大调或降d小调, 九个降号是重降B大调或降g小调, 十个降号是重降E大调或降c小调, 十一个降号是重降A大调或降f小调, 十二个降号是重降D大调或重降b小调, 十三个降号是重降G大调或重降e小调, …… 注意观察规律:降号数量每增加一次,大调和小调的主音(即调名中字母所表示的音)就降低纯五度。以大调为例,F降低纯五度是降B,降B降低纯五度是降E,降E降低纯五度是降A,降A降低纯五度是降D,降D降低纯五度是降G,降G降低纯五度是降C,……,以此类推。这叫做“调的五度循环”。当然,以一个降号至七个降号的居多。

    5、怎样由降号的数量推求所降的音?方法如下: 首先列举: 一个降号是降B, 两个降号是降B和降E, 三个降号是降B、降E和降A, 四个降号是降B、降E、降A和降D, 五个降号是降B、降E、降A、降D和降G, 六个降号是降B、降E、降A、降D、降G和降C, 七个降号是降B、降E、降A、降D、降G、降C和降F, 八个降号是降B、降E、降A、降D、降G、降C、降F和降B, …… 注意观察规律:降号的数量从一开始增加时,所降的最后一个音分别为(此时记唱名)si、mi、la、re、sol、do、fa、si、mi、la、re、sol、do、fa、si……(每种加上上述它前面的所有音后就构成了该种调所降的所有音),规律为:从si开始,先升纯四度,再降纯五度,再升纯四度,再降纯五度,再升纯四度,再降纯五度,再升纯四度,再降纯五度,再升纯四度,再降纯五度,以此类推(再观察上述从一个降号到八个降号的列举,仔细体会)。另外,由于从八个降号的调开始,所降的音就有重复的了,因此,要记得把重复的音合并成重降。例如:八个降号的调本来是降B、降E、降A、降D、降G、降C、降F和降B,那么合并后就应该是重降B、降E、降A、降D、降G、降C、降F。再例如:十三个降号的调本来是降B、降E、降A、降D、降G、降C、降F、降B、降E、降A、降D、降G、降C,合并后就应该是重降B、重降E、重降A、重降D、重降G、重降C、降F。

    钢琴的历史发展

    五线谱的前身可追溯到中世纪的纽姆记谱法及有量记谱法。纽姆谱以横线为标准,用符号表示音的高低,但不显示音值长短。从7世纪起,这种记谱法出现于欧洲天主教堂内,最初只用1根线代表F音高,11世纪经阿雷佐的圭多逐步发展成4根线。规定音高为d、f、a、c,并将f线画成红色,c线画成黄色(后成为五线谱中高音及低音谱号的起源)。13世纪有人使用第5根线,成为五线谱的前身。16世纪又有加线的办法,使音高的记载更完备。

    有量记谱法为13世纪科隆教士弗兰科创始。这种记谱法用音符、休止符和记号严格规定了音的长短,是对纽姆谱的补充和丰富。在1450年左右,音符是涂以黑色的,称为有量黑符,以后改用空心音符,称为有量白符,这种记谱法在西方使用到17世纪左右。

    五线谱在前两者的基础上出现,到17世纪逐步完善,18世纪开始定型而沿用至今。如小节线原用于文字谱,17世纪末被五线谱所采用;升降记号通用于18世纪,表情记号取有量记谱法;装饰音记号源于纽姆谱,17世纪系统化用于五线谱。

    看钢琴谱的四大原则

    背口诀

    在五线谱中,高音谱表的5条线是自下而上的排列的

    请跟我说:高音谱表一线mi 二线sol三弦si 四线re 五线fa

    低音谱表中五条线的顺序是自上而下的排列

    请跟我说:低音谱表一线la 二线fa 三弦re 四线si五线sol

    一定要根据键盘来背这些线上的音,高音谱表上的一线mi是在中央C右侧的那个MI,低音谱表上的一线la 是在中央C左侧的那个la ,然后按照线的顺序高音谱表上线上的音依次向右侧排列,低音谱表上线上的音依次向左侧排列。

    音的进行方向和音之间的距离

    在五线谱上,音越来越往高走,在琴键上就会越来越往右侧走,反之,则往左侧走。这就是五线谱上音的走向和键盘上音的走向的关系。在五线谱中,相邻的两个线上音之间的关系是隔一个音的关系;相邻的两个间(就是线与线之间的空格)上的音之间的关系是隔一个音的关系;相邻的线与间之间的音的关系是挨着的关系。

    五线谱上音与音之间的基本关系就是这三种。那么,其它的距离关系都可以通过音与音之间所隔的线和间来间接推算出来。比如,高音谱表上三线si,那么有一个音在在五线上方的间里,那么这个音可以用几种方法可以找到。

    第一种就是背线上的音,高音谱表五线fa ,那这个音比fa又高一个,则这个音就是sol;

    第二种方法,就是通过三线si来计算,这两个音之间隔了两条线。那么线和线之间的音是隔一个音的关系,那么最上面的线就和si 是隔一个音再隔一个音的关系,则比最高的线再高一个音就应该是sal 。

    要上下两行对着一起看

    要两行一起,上下对着看五线谱,比如上面一行有一个单音,下面一行有一个和弦,那么就将这几个音一起看,同时反应手指在键盘上的位置,然后再横向的看下一组音,同样是上下对着看。这样,就可以看到两个声部之间的交叉点和配合了(就是对位),也可以看到两个声部的走向,也可以缩小注意力集中的范围,做到100%正确。

    先看(上下对着看第一个音)

    à分析

    用哪个手弹奏,用哪个手指弹奏,弹奏哪个音,弹奏几拍,节奏是什么样的,两个手之间的节奏是怎么配合的(也就是对位) ,用什么弹奏方法来弹奏等等。

    à分析好后,用相应的手指弹奏下去,弹奏这个音的同时,眼睛再用同样的方法继续看下一个音,再分析 ,再弹奏……如此这样连贯看、想、弹下去。

    猜你感兴趣:

    展开全文
  • 基于深度学习的端到端乐谱音符识别.pdf
  • 乐谱识别中的音符图像分割技术进行了研究,采用游程分析与二次投影技术对乐谱图像进行处理。文中结合乐谱的语法特征对乐谱图像进行分析,先对图像中的音乐音符进行初步分类,对每一类的音符采用不同的处理方法,...
  • 乐谱分析乐谱转换为用于训练与合成的上下文标注是歌声合成系统的前端部分。 标准的MIDI MIDI(music Instrument Digital interface),中文称为数字接口,是一个工业标准的电子通信协议。 编号为128的MIDI消息...
  • 音乐信号音符/乐谱提取

    千次阅读 2017-03-05 19:10:53
    本实验使用时频分析的方法完成音乐信号的音符提取。时频分析选择短时傅里叶变换(STFT)完成。其具体方法是将信号用一定长度的窗进行分割成若干帧,对每一帧分别作傅里叶变换,得到它们的频率信息,而每一帧对应的位置...
  • 乐谱识别中音符分割技术的研究,王育峰,赵力,本文对乐谱识别中的音符图像分割技术进行了研究,采用游程分析与二次投影技术对乐谱图像进行处理。文中结合乐谱的语法特征对乐谱
  • 基于自动识别乐谱音乐的研究,董向林,,本文描述了基于自动识别乐谱的方法,分析了音符与频率之间的对应关系,通过对计算机发声频率的控制来发出不同的声音,完成对乐谱
  • 节奏大师乐谱破解 续

    千次阅读 2013-12-14 23:26:41
     BABY写的《精明的程序员——节奏大师乐谱破解》  我是在ta的基础上,进行更细致的分析,其实是因为偷懒。但有些细节我也没弄清。 内文  工具:IDA和EmEditor  首先,下载节奏大师ios越狱的包,将后缀.ipa改为...
  • 精明的程序员——节奏大师乐谱破解

    万次阅读 多人点赞 2013-12-05 23:11:51
    节奏大师乐谱破解
  • 本科毕业论文(科研训练、毕业设计)题 目:基于乐谱输入的弦乐播放系统的设计与实现姓 名:学 院:软件学院系:软件工程专 业:软件工程年 级:学 号:指导教师: 职称:年 月摘 要在计算机高速发展的今天,本环境对...
  • 根据乐谱合成钢琴音乐

    千次阅读 2017-03-05 19:17:53
    本次实验首先分析钢琴部分音符的频域包络和时域包络,得到其频域谐频与基频的关系以及时域声音强度衰减的特征规律,让后根据此特征并结合已知的音乐基频合成钢琴音乐。 分别分析钢琴Do ReMi Fa四个音的频谱,即对四...
  • 文章阐明古琴艺术的数字化应从元数据方案设计、古琴乐谱的编码方案...提出和分析乐谱识别中谱字提取的包围盒 算法,选取古琴乐谱“广陵散”为样本图像,实验结果表明,数据处理量可较传统的区域标记算法降低12 .5% 。
  • 节奏大师乐谱破解

    2013-12-09 13:54:11
    分析游戏,我发现节奏大师每首音乐都有规律的谱面,这肯定是分析乐谱文件生成的。如果我也能分析出乐谱文件的格式,而生成一些touch event,岂不是更加简单,连capture screen和图像分析都不用考虑了。 于是乎,...
  • 用于图像分析的 用于 SVM 的 用于 MIDI 创作的 杂项。 scipy matplotlib 谨防! HearMe 当前需要一组不在此存储库中的训练图像(无论如何都试图远离/改进此方法)。 但是,使用来自 sklearn 的更高效的 p​​...
  • 眼看乐谱,少看键盘和手看谱的过程是眼脑手耳并用、协调的过程。在眼睛看到乐谱,通过大脑的思考,把信息传递给手指,手指在键盘上弹出声音这个过程中,需要学生注意力高度集中,需要学生根据准确的音程指距感、和弦...
  • 1. 使用MATLAB及其自带的GUI界面,制作简易钢琴,使其输出声音逼近真实值,并能对输入乐谱和打开的声音文件进行波形分析和声音播放。 2. 实现音效测试分析功能(频率响应,频谱图,相位图,时域图,自相关,短时能量...
  • 灰色关联分析法灰色关联分析“交响曲”乐谱概要演奏开始灰色关联分析的前奏灰色关联分析的高潮灰色关联分析的尾声参考函数代码参考文献 灰色关联分析“交响曲” 乐谱概要 1、确定比较对象(评价对象)和参考数列; 2...
  • musescore.com 上所有乐谱和用户的非官方数据集,致力于大数据分析/数据科学/机器学习。 所有数据都是通过迭代来收集的。 jsonl文件采用 ( ) 格式。 学习音乐只需要乐谱文件? 试试 。 在 Google BigQuery 中 ...
  • 5 第3章 系统总体设计与关键技术 7 3.1 系统总体设计 7 3.1.1 音乐播放器的工作原理 7 3.1.2 音阶对应频率计数初值的计算 8 3.1.3 乐曲节拍的计算 8 3.1.4 乐谱在程序中的编制 9 3.2 系统中应用的关键技术 9...
  • Virtual Piano 自动播放乐谱

    千次阅读 2010-11-27 13:55:00
    原理分析  首先,要制作这么一个游戏,首先需要一个MiDi发声引擎:最终在 codeproject 上面找到了一个不错的开源MIDI引擎:MIDIWrapper 网址: http://www.codeproject.com/KB/audio-video/midiwrapper.aspx ...
  • 傅里叶分析

    2018-02-02 09:47:00
    要让读者在不看任何数学公式的情况下理解傅里叶分析。 傅里叶分析不仅仅是一个数学工具,更是一种可以彻底颠覆一个人以前世界观的思维模式。但不幸的是,傅里叶分析的公式看起来太复杂了,所以很多大一新生上来就懵...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,467
精华内容 586
关键字:

如何分析乐谱