Re: Tablatures

[Éric]

Loïc,

Il y a aussi une sorte de gestion des extensions maximales (c'est dans les
fichiers d'initialisation, soit engraver-init.ly, soit dans
property-init.ly, je ne sais plus).

Pas de souci pour les accords réentrant du théorbe et autres.

Pour ce qui d'un éventuel \tabmod permettant de saisir de la tablature par
les symboles à la place des noms des notes, le sujet a été déjà plusieurs
fois discuté (cf forum en anglais).
D'après ce que j'ai compris, tant qu'on ne cherche pas à montrer
l'équivalence automatique de la tablature en musique, cela serait très
faisable.
Par contre, si on compte sur Lilypond pour montrer les notes correspondantes
à la tablature, se pose le pb des enharmonies (sans parler de ceux
insolubles de polyphonie).
Vue que Lilypond différencie les enharmonies dès le plus bas niveau de
saisie, ii faut que quelqu'un/quelque chose choisisse entre do# et réb et
ainsi pour toutes des enharmonies potentielles à un moment ou à un autre.

Pas impossible, mais le jeu en vaut-il la chandelle ? 
Il faudrait avant de commencer à saisir en \tabmod instruire Lilypond d'un
choix d'une gamme chromatique a priori. 
C'est à dire de fixer arbitrairement un seul nom de note pour chaque touche
du piano (cf code plus bas).

En fin de saisie, une fois la tablature établie, si l'on veux voire la
musique correspondante, il faut soit :
- accepter de lire une partition fautive tonalement parlant, et sans
polyphonie,
- corriger les enharmonies fautives manuellement,
- corriger les enharmonies fautives semi-automatiquement en donnant des
instructions modales en cours de pièces (il existe des outils allant dans ce
sens (cf manuel ou bien Frescobaldi > outils > hauteurs > transposition
modale par ex.).
- prendre à bras le corps la questions de la polyphonie (là en générale, on
finis par complètement réécrire une autre saisie, éventuellement sur 2
portées, c'est potentiellement complexe… et passionnant).

Je pense qu'il serait efficace, pour convaincre qlqu'un de passer du temps à
bâtir du code pour un \tabmod, d'accepter qu'il n'y ai pas de gestion
dynamique des enharmonies, et qu'elles soient supposées être prise en charge
"à la main" par le scripteur, après saisie. Pas non plus de prise en charge
de polyphonie. 
On aurait là un outils de pure conversion, dans le cas où l'accord de
l'instrument n'est pas maîtriser par le scripteur, où que l'on n'a pas assez
de connaissance du solfège (mais là, quid des corrections ???).


David Kastrup (un des gds "manitou" du code.ly) m'avait répondu il y a qlqs
années par une ébauche de code que voici.
C'est assez limité (et bien présenté comme tel par lui) : 
- les frettes ne dépassent pas "g" , car à partir de "h" les symboles ne
sont plus reconnus comme de potentielles nom de notes (de a à g en anglais)
- il faut donner la corde à chaque fois, ce qui est fastidieux en 1ère
position,
- il faut donner une gamme chromatique à slt 12 noms de notes (pas de
souci),
- il est possible que ce soit une mauvaise piste comme point de départ de
codage !??


\version "2.19.50"

lute-tuning = \stringTuning <d, g, c f a d' g'>

tabtranslate =
#(define-music-function (pitches tuning music) (ly:music? pair? ly:music?)
   (define my-pitch (make-semitone->pitch (event-chord-pitches pitches)))
   (define string-number? (music-type-predicate 'string-number-event))
   (define semivec (list->vector (map ly:pitch-semitones tuning)))
   (map-some-music
    (lambda (m)
      (and (music-is-of-type? m 'note-event)
           (let* ((strs (ly:music-property m 'articulations))
                  (no
                   (case (length strs)
                     ((0) (ly:music-warning m "Needs string number") 1)
                     ((1) (ly:music-property (car strs) 'string-number))
                     (else (ly:music-warning m "Multiple string numbers")
                           (ly:music-property (car strs) 'string-number))))
                  (pit (ly:music-property m 'pitch))
                  (ab? (> (ly:pitch-notename pit) 4))
                  (num (+ (ly:pitch-steps pit) (if ab? 2 9)))
                  (no (if (and (integer? no)
                               (<= 1 no (vector-length semivec)))
                          (1- no)
                          (begin
                            (ly:music-warning (car strs)
                                              "Invalid string number")
                           0))))
             (set! (ly:music-property m 'pitch)
                   (my-pitch (+ (vector-ref semivec no) num)))
             m)))
    (tabChordRepeats music)))
%%

"|" = {
  \partial 1*0 \bar "|"
}

content =
\tabtranslate <c cis d dis e f fis g gis a bes b> \lute-tuning
{
  \set Staff.midiInstrument = "acoustic guitar (nylon)"
  \time 4/8
  \set Timing.measureLength = #(ly:make-moment 100000)
  \set Timing.beamExceptions = #'()
  \set Timing.baseMoment = #(ly:make-moment 1/4)
 
  <e\4 d\3 c\2>4
  q8 d\2 |
  <c\4 c\3 d\2>16
  c\2 c8\2
  <a\4 a\3 c\2>16
  a32\2 d\3 a8\2 |
  <e\5 e\4 c\3 c\2>16. e32\4 d16\4 g\5
  <e\5 d\4 c\3 c\2> e\4 e\5 d\4 |
  <c\6 e\5 e\4 d\3 c\2>8 <d\3 c\2>16 c\6 <b\6 c\3 c\2>8 a\2
  <c\6 e\5 e\4 d\3> <e\4 d\3>16 c\6 <e\5 e\4 c\3>8
  <c\3 c\2>16 e\5 <a\4 a\3 c\2>8 a16\2 c\3 |
  <e\5 d\3 c\2 a\1>8 c16\3 a\1 <c\5 d\2> a\3 <a\5 a\3 c\2>8 |
  <e\6 a\2>16 e\4 d\4 c\2 <c\6 a\3 d\2>8 c16\2 c\6 |
  <e\5 c\3 c\2>8 <c\3 c\2 a\1>16 e\5
  <a\4 a\3>8 d\2 <c\4 c\3> <d\3 c\2> <c\4 d\3 a\2 a\1> a16\6 a\2
  <a\5 c\4 d\3 c\2>8 d16\3 a\2 |
  <a\5 c\4 d\3 c\2> d\2 <a\5 a\1> c\2
  <d\7 a\4 a\3 d\2> <a\6 c\2>32 a\2 <c\6 d\3>16 <e\6 a\2> |
  <a\5 c\4 d\3 c\2>8 <d\3 c\2>16 a\5 <e\6 c\4 a\2>8 <e\5 c\3 c\2> |
  <b\5 a\3 c\2> <b\4 a\3 a\2> <d\5 c\3 e\2> <e\5 d\4 c\3 c\2> <c\6 e\5 e\4
d\3 c\2>
  <d\3 c\2>16 c\6 <c\5 a\4 a\2>8 <a\3 a\2>16 a\5  d8\6 a\2
  <c\6 e\5>32 f\3 e\3 c\3 e16\3 c\6 |
  <c\5 a\3 a\2>4 r8 <e\6 b\4 b\2>8 q8. a16\2 <e\5 d\3>8 c16\3 c\5 |
  a\5 c\3 a8\3 <e\6 e\5 c\3> d16\5 e\6 |
  <e\5 d\4 c\3>4 <e\5 c\3 c\2>8 <c\6 e\5 e\4 e\3> |
  <c\5 b\4 a\2> c\4 <b\5 c\2>16 c\4 <c\5 b\4> a\2 |
  <e\5 d\4> d\3 e\4 a\2 <e\5 e\4 c\3 c\2>8 d16\4 a\2 |
  <c\6 a\3 d\2>8 c16\2 c\1 e\5 a\1 <e\6 a\2> <a\5 c\4 d\3 c\2>16. d32\2
  <a\6 c\3 a\2 a\1>16 <c\6 d\2>32 c\2 d16\3 |
  e\4 c\6 <a\6 c\3>8 <d\7 e\4 d\3>16. d32\3 <c\3 a\2>16 a\3 |
  <c\7 e\6 e\5 d\4 c\3 c\2>8. c16\2 q4 |
}

\score {
  \new StaffGroup
  <<
    \new Staff \with { \clef "treble_8"
                       \omit StringNumber
                     } \content
    \new TabStaff \with { stringTunings = \lute-tuning
                          tablatureFormat = #fret-letter-tablature-format
                          fretLabels = \markuplist \fontsize #2 \lower #0.2
                          { 𝖆 𝖇 𝖈 𝖉 𝖊 𝖋 𝖌 𝖍 𝖎 𝖐 𝖑 𝖒 𝖓 𝖔 𝖕 }
                        } \content
  >>
  \layout {}
}

%{
\score {
  \new TabStaff \with { stringTunings = \lute-tuning } \content
  \midi {}
}
%}


Perso, je n'ai pas de compétence en Scheme, je code mes tablatures par les
notes de musique.
Mais c'est vrai que de tant à autres, j'aimerais bien voire la musique qui
se cache derrière des accords rares que je ne maîtrise pas sans avoir à me
croiser les neurones.

À la votre…
Éric





--
Sent from: http://lilypond-french-users.1298960.n2.nabble.com/