Beispiel #1
0
    def make_notes(self, _input, _start, _end, elements):
        # TODO: Ugly should be treated in an non-existing make_measure action
        if len(self.song.tracks[0].measures) > 1:
            self.add_repeat_close(self.song.tracks[0].measures[-2].header)

        current_measure = self.song.tracks[0].measures[-1]
        measure_header = current_measure.header

        self.add_time_signature(measure_header)
        self.add_marker(measure_header)
        self.add_triplet_feel(measure_header)
        self.add_repeat_open(measure_header)
        self.add_tempo(current_measure.voices[0])

        self.add_notes(current_measure.voices[0])

        # Add new measure at the end
        measure = gp.Measure(self.song.tracks[0], gp.MeasureHeader())
        self.song.tracks[0].measures.append(measure)
        self.state.measure_time = 0
        self.state.measure_content.clear()
        self.state.marker = None
        self.state.repeat_open = False
        self.state.repeat_close = None

        return elements
Beispiel #2
0
    def AddDrumsTrack(self, track, t):
        t.tracks.append(guitarpro.Track(t))
        tn = len(t.tracks) - 1

        t.tracks[tn].isPercussionTrack = True
        for s in t.tracks[tn].strings:
            s.value = 0
        t.tracks[tn].measures = []
        m = -1
        for measure in track.measures:
            measureHeader = guitarpro.models.MeasureHeader()
            t.tracks[tn].measures.append(
                guitarpro.Measure(t.tracks[tn], measureHeader))
            m += 1
            t.tracks[tn].measures[m].timeSignature.numerator = measure.upNum
            t.tracks[tn].measures[
                m].timeSignature.denominator.value = measure.downNum
            t.tracks[tn].measures[m].voices = [
                guitarpro.Voice(t.tracks[tn].measures[m])
            ]
            b = -1
            for beat in measure.beats:
                t.tracks[tn].measures[m].voices[0].beats.append(
                    guitarpro.Beat(t.tracks[tn].measures[m].voices[0]))
                b += 1

                if len(beat.notes) > 0:
                    string = 1
                    n = -1
                    for note in beat.notes:
                        t.tracks[tn].measures[m].voices[0].beats[
                            b].notes.append(
                                guitarpro.Note(t.tracks[tn].measures[m].
                                               voices[0].beats[b]))
                        n += 1
                        t.tracks[tn].measures[m].voices[0].beats[b].notes[
                            n].value = note.value
                        t.tracks[tn].measures[m].voices[0].beats[b].notes[
                            n].string = string
                        string += 1
                        t.tracks[tn].measures[m].voices[0].beats[b].notes[
                            n].velocity = 127
                        t.tracks[tn].measures[m].voices[0].beats[b].notes[
                            n].type = guitarpro.NoteType.normal
                    t.tracks[tn].measures[m].voices[0].beats[
                        b].status = guitarpro.BeatStatus.normal
                else:
                    t.tracks[tn].measures[m].voices[0].beats[
                        b].status = guitarpro.BeatStatus.rest

                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.value = beat.duration
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.isDotted = beat.isDotted
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.isDoubleDotted = beat.isDoubleDotted
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.tuplet.enters = beat.enters
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.tuplet.times = beat.times
Beispiel #3
0
def addTrack(base_track, y, name, tab):
    print('start saving')
    notes = [38, 92, 35, 47, 93, 99]
    #tab.tempo = guitarTracks[0].song.tempo
    #tab.version = 'FICHIER GUITAR PRO v3.00'
    #tab.tracks = guitarTracks

    y = y.tolist()
    tab.tracks.append(guitarpro.Track(tab))
    num = len(tab.tracks) - 1

    tab.tracks[num].number = 1
    tab.tracks[num].name = name
    tab.tracks[num].isPercussionTrack = True
    for s in tab.tracks[num].strings:
        s.value = 0
    tab.tracks[num].measures = []
    m = -1
    for measure in y:
        measureHeader = guitarpro.models.MeasureHeader()
        tab.tracks[num].measures.append(guitarpro.Measure(tab.tracks[num], measureHeader))
        m += 1
        if m > len(base_track.measures) - 1:
            break
        tab.tracks[num].measures[m].timeSignature.numerator = base_track.measures[m].timeSignature.numerator
        tab.tracks[num].measures[m].timeSignature.denominator.value = base_track.measures[
            m].timeSignature.denominator.value
        tab.tracks[num].measures[m].voices = [guitarpro.Voice(tab.tracks[num].measures[m])]
        b = -1
        takt = tab.tracks[num].measures[m].timeSignature.numerator / tab.tracks[num].measures[m].timeSignature.denominator.value
        takti = 0
        for beat in measure:
            if beat[0] >= 0.03125 and takti + 1 / duration(1 / beat[0]) <= takt:
                takti += 1 / duration(1 / beat[0])
                tab.tracks[num].measures[m].voices[0].beats.append(
                    guitarpro.Beat(tab.tracks[num].measures[m].voices[0]))
                b += 1

                tab.tracks[num].measures[m].voices[0].beats[b].status = guitarpro.BeatStatus.rest
                j = 0
                string = 1
                while j < 5:
                    if beat[1 + j] > 0.5:
                        tab.tracks[num].measures[m].voices[0].beats[b].status = guitarpro.BeatStatus.normal
                        tab.tracks[num].measures[m].voices[0].beats[b].notes.append(
                            guitarpro.Note(tab.tracks[num].measures[m].voices[0].beats[b]))
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[string - 1].value = notes[j]
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[string - 1].string = string
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[string - 1].velocity = 127
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[
                            string - 1].type = guitarpro.NoteType.normal
                        string += 1
                    j += 1

                tab.tracks[num].measures[m].voices[0].beats[b].duration.value = duration(1 / beat[0])
                tab.tracks[num].measures[m].voices[0].beats[b].duration.isDotted = False
                tab.tracks[num].measures[m].voices[0].beats[b].duration.isDoubleDotted = False
                tab.tracks[num].measures[m].voices[0].beats[b].duration.tuplet.enters = 1
                tab.tracks[num].measures[m].voices[0].beats[b].duration.tuplet.times = 1
Beispiel #4
0
    def AddGuitarTrack(self, track, t):
        t.tracks.append(guitarpro.Track(t))
        tn = len(t.tracks) - 1

        t.tracks[tn].measures = []
        m = -1
        for measure in track.measures:
            measureHeader = guitarpro.models.MeasureHeader()
            t.tracks[tn].measures.append(
                guitarpro.Measure(t.tracks[tn], measureHeader))
            m += 1
            t.tracks[tn].measures[m].timeSignature.numerator = measure.upNum
            t.tracks[tn].measures[
                m].timeSignature.denominator.value = measure.downNum
            t.tracks[tn].measures[m].voices = [
                guitarpro.Voice(t.tracks[tn].measures[m])
            ]
            b = -1
            for beat in measure.beats:
                t.tracks[tn].measures[m].voices[0].beats.append(
                    guitarpro.Beat(t.tracks[tn].measures[m].voices[0]))
                b += 1

                if len(beat.notes) > 0:
                    val = beat.notes[len(beat.notes) - 1].value
                    t.tracks[tn].measures[m].voices[0].beats[b].notes.append(
                        guitarpro.Note(
                            t.tracks[tn].measures[m].voices[0].beats[b]))
                    string = 5
                    for k in track.strings:
                        if val > 25:
                            string -= 1
                            val = beat.notes[len(beat.notes) -
                                             1].value - track.strings[string]
                    t.tracks[tn].measures[m].voices[0].beats[b].notes[
                        0].value = val
                    t.tracks[tn].measures[m].voices[0].beats[b].notes[
                        0].string = string + 1
                    t.tracks[tn].measures[m].voices[0].beats[b].notes[
                        0].velocity = 127
                    t.tracks[tn].measures[m].voices[0].beats[b].notes[
                        0].type = guitarpro.NoteType.normal
                    t.tracks[tn].measures[m].voices[0].beats[
                        b].status = guitarpro.BeatStatus.normal
                else:
                    t.tracks[tn].measures[m].voices[0].beats[
                        b].status = guitarpro.BeatStatus.rest

                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.value = beat.duration
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.isDotted = beat.isDotted
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.isDoubleDotted = beat.isDoubleDotted
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.tuplet.enters = beat.enters
                t.tracks[tn].measures[m].voices[0].beats[
                    b].duration.tuplet.times = beat.times
Beispiel #5
0
def addTrack(base_track, y, name, tab, first_string, key, mm):
    print('start saving')
    # 'FICHIER GUITAR PRO v5.00'
    strings = [
        15 + first_string, 10 + first_string, 5 + first_string, first_string
    ]

    y = y.tolist()
    tab.tracks.append(guitarpro.Track(tab))
    num = len(tab.tracks) - 1

    tab.tracks[num].number = num + 1
    tab.tracks[num].name = name
    tab.tracks[num].isPercussionTrack = False

    tab.tracks[num].channel.volume = 120
    tab.tracks[num].channel.balance = 64

    tab.tracks[num].strings = []
    for i, j in zip(strings, range(len(strings))):
        tab.tracks[num].strings.append(guitarpro.models.GuitarString(j + 1, i))

    tab.tracks[num].measures = []
    m = -1
    for measure in y:
        measureHeader = guitarpro.models.MeasureHeader()
        tab.tracks[num].measures.append(
            guitarpro.Measure(tab.tracks[num], measureHeader))
        m += 1
        if m > len(base_track.measures) - 1:
            break
        tab.tracks[num].measures[
            m].timeSignature.numerator = base_track.measures[
                m].timeSignature.numerator
        tab.tracks[num].measures[
            m].timeSignature.denominator.value = base_track.measures[
                m].timeSignature.denominator.value
        tab.tracks[num].measures[m].voices = [
            guitarpro.Voice(tab.tracks[num].measures[m])
        ]
        b = -1
        takt = tab.tracks[num].measures[m].timeSignature.numerator / tab.tracks[
            num].measures[m].timeSignature.denominator.value
        takti = 0
        for beat in measure:
            if beat[2] >= 0.03125 and takti + 1 / duration(
                    1 / beat[2]) <= takt:
                takti += 1 / duration(1 / beat[2])
                tab.tracks[num].measures[m].voices[0].beats.append(
                    guitarpro.Beat(tab.tracks[num].measures[m].voices[0]))
                b += 1

                tab.tracks[num].measures[m].voices[0].beats[
                    b].status = guitarpro.BeatStatus.rest
                if beat[0] > 0.5:
                    tab.tracks[num].measures[m].voices[0].beats[
                        b].status = guitarpro.BeatStatus.normal
                    tab.tracks[num].measures[m].voices[0].beats[b].notes.append(
                        guitarpro.Note(
                            tab.tracks[num].measures[m].voices[0].beats[b]))

                    string = 3
                    for k in strings:
                        val = 36 + correctNote(beat[1] * 12, key,
                                               mm) - strings[string]
                        if val > 25:
                            string -= 1
                        else:
                            break

                    tab.tracks[num].measures[m].voices[0].beats[b].notes[
                        0].value = val
                    tab.tracks[num].measures[m].voices[0].beats[b].notes[
                        0].string = string + 1
                    tab.tracks[num].measures[m].voices[0].beats[b].notes[
                        0].velocity = 127
                    tab.tracks[num].measures[m].voices[0].beats[b].notes[
                        0].type = guitarpro.NoteType.normal

                tab.tracks[num].measures[m].voices[0].beats[
                    b].duration.value = duration(1 / beat[2])
                tab.tracks[num].measures[m].voices[0].beats[
                    b].duration.isDotted = False
                tab.tracks[num].measures[m].voices[0].beats[
                    b].duration.isDoubleDotted = False
                tab.tracks[num].measures[m].voices[0].beats[
                    b].duration.tuplet.enters = 1
                tab.tracks[num].measures[m].voices[0].beats[
                    b].duration.tuplet.times = 1
Beispiel #6
0
def makeTab(guitarTracks, y, names, path):
    print('start saving')
    notes = [38, 92, 35, 47, 1, 99]
    # 'FICHIER GUITAR PRO v5.00'
    tab = guitarpro.models.Song()
    tab.tempo = guitarTracks[0].song.tempo
    tab.version = 'FICHIER GUITAR PRO v3.00'
    tab.tracks = guitarTracks

    for predict, name in zip(y, names):
        predict = predict.tolist()
        tab.tracks.append(guitarpro.Track(tab))
        num = len(tab.tracks) - 1

        tab.tracks[num].number = 1
        tab.tracks[num].name = name
        tab.tracks[num].isPercussionTrack = True

        tab.tracks[num].channel.volume = 120
        tab.tracks[num].channel.balance = 64

        for s in tab.tracks[num].strings:
            s.value = 0
        tab.tracks[num].measures = []
        m = -1
        for measure in predict:
            measureHeader = guitarpro.models.MeasureHeader()
            tab.tracks[num].measures.append(guitarpro.Measure(tab.tracks[num], measureHeader))
            m += 1
            if m > len(guitarTracks[0].measures) - 1:
                break
            tab.tracks[num].measures[m].timeSignature.numerator = guitarTracks[0].measures[m].timeSignature.numerator
            tab.tracks[num].measures[m].timeSignature.denominator.value = guitarTracks[0].measures[
                m].timeSignature.denominator.value
            tab.tracks[num].measures[m].voices = [guitarpro.Voice(tab.tracks[num].measures[m])]
            b = -1
            for beat in measure:
                tab.tracks[num].measures[m].voices[0].beats.append(guitarpro.Beat(tab.tracks[num].measures[m].voices[0]))
                b += 1

                tab.tracks[num].measures[m].voices[0].beats[b].status = guitarpro.BeatStatus.rest
                j = 0
                string = 1
                while j < 5:
                    if beat[1 + j] > 0.5:
                        tab.tracks[num].measures[m].voices[0].beats[b].status = guitarpro.BeatStatus.normal
                        tab.tracks[num].measures[m].voices[0].beats[b].notes.append(
                            guitarpro.Note(tab.tracks[num].measures[m].voices[0].beats[b]))
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[string - 1].value = notes[j]
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[string - 1].string = string
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[string - 1].velocity = 127
                        tab.tracks[num].measures[m].voices[0].beats[b].notes[
                            string - 1].type = guitarpro.NoteType.normal
                        string += 1
                    j += 1

                tab.tracks[num].measures[m].voices[0].beats[b].duration.value = duration(1 / beat[0])
                tab.tracks[num].measures[m].voices[0].beats[b].duration.isDotted = False
                tab.tracks[num].measures[m].voices[0].beats[b].duration.isDoubleDotted = False
                tab.tracks[num].measures[m].voices[0].beats[b].duration.tuplet.enters = 1
                tab.tracks[num].measures[m].voices[0].beats[b].duration.tuplet.times = 1

    # tab.tracks = [tab.tracks[1]]
    guitarpro.write(tab, path)