Tabulatur: Neun "Saiten" mit unveränderlichem Ton

[TipTap]

Hallo zusammen,

es geht um Tabulatur-Notation und zwar eine sicherlich ungewöhnliche: Ich möchte ein paar Stücke für eine Kalimba mit 9 Tönen notieren und da macht der Tabulaturteil unerwartet Schwierigkeiten. Die Kalimba hat 9 fest gestimmte Metall-Zungen, es sind also exakt 9 Töne damit spielbar - und zwar sozusagen als "Leersaite" (open string).

So sieht das Instrument übrigens aus: http://tinyurl.com/ordle3m

PNG-Screenshot, Quelltext und PDF im Anhang:

Die Notenlinie und die 9-saitige Tabulatur dazu zeigen beide genau das richtige

Problem:

Die Standard-Stimmung der Kalimba ist, von links nach rechts, wie folgt in absoluter Tonhöhe definiert:

Code: [Auswählen]

\stringTuning <a' c'' c' a' a f' e' e'' b'>
Es geht also fröhlich rauf und runter, zwischen den Zungen ("Saiten"). Nun hatte ich erwartet, dass ich aufgrund der von mir definierten Stimmung (kalimba-b9-standard) genau denselben Code für die standardnotation und die Tabulatur nutzen kann - wie ich es bei anderen Saiteninstrumenten ja immer mache (Gitarren, Ukulelen, Guitalele, Koyabu, ...); es wir ja eigentlich immer nur eine "0" auf einer der 9 "Saiten" benötigt. Ich muss ja lediglich notieren, welche Zunge gerade angeschlagen werden muss ... das sollte doch total einfach sein: Nix als Leersaiten!

Tatsächlich habe ich ziemlich wirre Noten konsturieren müssen, um die gewünschten Nullen auf der jeweiligen "Leersaite" anzuzeigen.

Bitte schaut euch den Quellcode mal an, dann müsste klar sein, was da "komisch" ist. Ich möchte sehr gerne die gleichen Noten, die für die Standardnotation verwendet werden, auch in der Tabulaturbeschreibung nutzen - das kriege ich aber nicht mal im Ansatz hin.

Ich würde mich also über jeden hilfreichen Tipp oder gar eine Lösung freuen - vielen Dank!

TipTap

EDIT: Dateianhänge am 12.03.14/03:10 Uhr erneuert - waren fehlerhaft - bitte PNG-Anhang anschauen.

[fugenkomponist]

Ähm, kann es sein, dass du einfach die Stimmung umdrehen musst? Also \stringTuning <b' e'' e' f' a a' c' c'' a'> ? Wieso gibts eigentlich zweimal a'?
Das mit dem „automatisch nur Leersaiten“ funktioniert halt nicht, weil LilyPond anscheinend von aufsteigend sortierten Tonhöhen ausgeht und dann von oben durchgeht und die erste Saite nimmt, auf der der Ton gerade schon spielbar ist (weil sie tief genug ist)

[TipTap]

Die Stimmung umdrehen hat erwartungsgemäß den gleichen Effekt wie

Code: [Auswählen]

\set TabStaff.stringOneTopmost = ##fhilft also nicht. Es gibt eben keine auf- oder absteigende Reihenfolge der Töne von links nach rechts oder andersrum.

Der Notenteil stimmt ja, ich bräuchte also "nur" eine Möglichkeit, der Tabulatur mitzuteilen, welche von den neun Tonzungen gespielt werden soll - also immer 0. Bund (Leersaite) - da die neun Töne unveränderlich sind und es keine Bünde (frets) gibt, die man zur Tonhöhenänderung greifen könnte.

Ziel:

Egal, welche von den möglichen 9 Noten in der Notendarstellung erscheint, es muss in der Tabulatur immer eine "Leersaite" (also eine "0") markiert werden. Natürlich die zum Ton passende.

Nachdem das nicht auf Anhieb klappte, versuchte ich, das Anschlagen der erforderlichen Tonzunge ("Saite") zu erzwingen:

Code: [Auswählen]

% original Kalimba B9 tuning (left to right):                 a' c"  c' a' a f' e' e"  b'
\makeDefaultStringTuning #'kalimba-b9-standard \stringTuning <a' c'' c' a' a f' e' e'' b'>
  ...
% alle tones/tines from left to right
<b'\1>8 <e''\2> <e'\3> <f'\4> <a\5> <a'\6> <c'\7> <c''\8> <a'\9>1
% standard arpeggio from lowest to highest tones/tines
<a\5>8 <e'\3> <c'\7> <b'\1> <a'\9> <e''\2> <c''\8> <f'\4> <a'\6>1

Kann man Lilypond irgendwie[TM] mitteilen oder zwingen, dass es auf lediglich die zu schlagende TAB-Saite markiert (Notenkopf, Kreis, Punkt, ...) - unabhängig von der Tonhöhe? Bei Percussion-Notation gibt es sowas doch, aber da kenne ich mich nicht aus ...

[TipTap]

Ähm, kann es sein, dass du einfach die Stimmung umdrehen musst? Also \stringTuning <b' e'' e' f' a a' c' c'' a'> ?

Hmm ... an der Drehung ist doch mehr dran, als ich dachte. Anscheinend spiegelt "\set TabStaff.stringOneTopmost = ##f" lediglich die Darstellung, ohne den Algorithmus für die Greifpositionen in der Tabulatur anzufassen. Ich bin also jetzt ein gutes Stück weiter, weil ich die (absoluten) Noten der Notenlinie jetzt auch für die Tabulatur verwenden kann.

Aktualisiertes Minimalbeispiel:

Code: [Auswählen]

\version "2.18"

global= { \time 4/4 }

% Definition: Kalimba B9 standard tuning
%
% tine ("string") number: 1  2  3  4  5  6  7  8  9
% left-to-right tuning  : a' c" c' a' a  f' e' e" b'
%
%   must be used with the highest tine NUMBER first:
%
% tine ("string") number: 9  8  7  6  5  4  3  2  1
% right-to-left order   : b' e" e' f' a  a' c' c" a'
\makeDefaultStringTuning #'kalimba-b9-standard \stringTuning <b' e'' e' f' a a' c' c'' a'>

<<
  \new Staff { \clef treble \stemUp
    % Melody
    \global
    \set Staff.instrumentName = "Melody"
    \override Staff.StaffSymbol.color = #(x11-color 'grey60)
    \absolute {
      % all tones/tines from left to right
      a'8 c'' c' a' a  f' e' e'' b'1
      % standard arpeggio from lowest to highest tone/tine
      a8 c' e' a' b' c'' e'' a' f'1
    }
  }

  \new TabStaff {
    % Kalimba
    \global
    \set TabStaff.instrumentName = "Kalimba"
    \set TabStaff.stringTunings = #kalimba-b9-standard
    \stemDown
    \tabFullNotation

    \absolute {
      % alle tones/tines from left to right
      <a'\1>8 <c''\2> <c'\3> <a'\4> <a\5> <f'\6> <e'\7> <e''\8> <b'\9>1
      % standard arpeggio from lowest to highest tone/tine
      <a\5>8 <c'\3> <e'\7> <a'\1> <b'\9> <c''\2> <e''\8> <a'\4> <f'\6>1
    }
  }
>>
Danke für den wichtigen Tipp mit der Notenreihenfolge!

Jetzt brauche ich noch eine gute Idee, wie ich die explizite Angabe der "Saitennummer" für jeden einzelnen Ton vermeiden kann (z.B. "<a'\1>8 <c''\2>"), denn das ist die meiste Schreibarbeit. Kann man dem TabStaff irgendwie mitteilen, dass der gar nicht rechnen, sondern lediglich eine "0" (oder was anderes) als Notenkopf auf die richtige Saite malen soll?

So wie für notierte Percussion oder Percussion-Elemente bei der Gitarre (Notenkopf="x"), die ja unabhängig von der Tonhöhe sind und immer auf der gleichen Saite erscheinen.

Hinweis:
Das a' ist tatsächlich doppelt, das gehört so. Da die a'-Saiten (1 oder 4) identisch klingen, ist eine Unterscheidung nur für besondere Spielweisen angebracht - aber nicht lebenswichtig.

TipTap

[trulli]

Hallo,

könnten da Abkürzungen helfen?

In Frescobaldi geht es dann außerdem sehr schnell, weil nach Eingabe des \k sofort ein Menü erscheint, wo du den entsprechenden Ton auswählen kannst.
Nachteil: die Tonlänge muss in der Abkürzung stehen. Ich rate deshalb dazu für die Komposition nur eine Tonlänge zu verwenden. 

Code: [Auswählen]

\version "2.18"

global= { \time 4/4 }

% Definition: Kalimba B9 standard tuning
%
% tine ("string") number: 1  2  3  4  5  6  7  8  9
% left-to-right tuning  : a' c" c' a' a  f' e' e" b'
%
%   must be used with the highest tine NUMBER first:
%
% tine ("string") number: 9  8  7  6  5  4  3  2  1
% right-to-left order   : b' e" e' f' a  a' c' c" a'
\makeDefaultStringTuning #'kalimba-b9-standard \stringTuning <b' e'' e' f' a a' c' c'' a'>


keins = <a'\1>8
kzwei = <c''\2>8
kdrei = <c'\3>8
kvier = <a'\4>8
kfuenf = <a\5>8
ksechs = <f'\6> 8
ksieben = <e'\7> 8
kacht = <e''\8>8
kneun = <b'\9>1

<<
  \new Staff { \clef treble \stemUp
    % Melody
    \global
    \set Staff.instrumentName = "Melody"
    \override Staff.StaffSymbol.color = #(x11-color 'grey60)
    \absolute {
      % all tones/tines from left to right
      a'8 c'' c' a' a  f' e' e'' b'1
     
    }
  }

  \new TabStaff {
    % Kalimba
    \global
    \set TabStaff.instrumentName = "Kalimba"
    \set TabStaff.stringTunings = #kalimba-b9-standard
    \stemDown
    \tabFullNotation

    \absolute {
      % alle tones/tines from left to right
       \keins \kzwei \kdrei \kvier \kfuenf \ksechs \ksieben \kacht \kneun
     
    }
  }
>>

Gruß

[fugenkomponist]

Da kann man aber bestimmt eine Funktion schreiben, die die Länge als Argument nimmt Nur hab ich gerade leider keine Zeit, mich daran zu probieren …

[trulli]

Klar, man kann ja z.B. so etwas definieren wie \keinsachtel und \keinsviertel...

Trotzdem finde ich, dass die Vorteile eines einzigen Notenwertes für die gesamte Komposition nicht ganz von der Hand zu weisen sind.     

[TipTap]

Ah ... schön: das mit den Makros gefällt mir schon mal ganz gut. Ich hätte nicht gedacht, dass eine Makrodefinition lediglich eine schlichte Zuweisung ala "name = wert" benötigt.

Mir wäre es allerdings wichtig, dass die Notenlängen ebenfalls erhalten bleiben, weil es natürlich auch verschiedene Artikulationen gibt, z.B. einen Ton einen Takt klingen lasse, vor allem auch schöne Arpeggios usw.

Kostante: jede Tonzunge ("Saite") hat eine feste Stimmung, das a' existiert zweimal
Variable: die Tondauer

Daher wäre eine Funktion schön, die beispielsweise einen Schwung Noten als Argument nimmt und im Ergebnis die richtigen Saiten mit passender Dauser setzt. Notenhälse, auch Synkopen, Punktierungen, Bindebögen usw. sollten verwendet werden können. Wäre schön, wenn die Funktion sowas könnte (Pseudocode, ich kenne die Funktionssyntax nicht):

Code: [Auswählen]

\vieleNoten = { a'8 c'' c' a' a  f' e' e'' b'1 }
 ...
\myFunction{\vieleNoten}
... mit dem gewünschten Resultat natürlich.

Bin sehr gespannt, wer sich traut ...

TipTap

[trulli]

Hallo TipTap,

lass deine Fantasie nicht mit dir durchgehen. Lily kann fast alles, aber die Noten musst du schon noch selbst schreiben. 

Hier mal eine Möglichkeit die Tondauer in die Definition mit einzubeziehen. Man kann sie jetzt direkt an die Abkürzung anhängen.

Code: [Auswählen]

\version "2.18.0"


\makeDefaultStringTuning #'kalimba-b9-standard
\stringTuning <b' e'' e' f' a a' c' c'' a'>

dauer = #(define-scheme-function (parser location m) (ly:music?)
                  (define-music-function (parser location d) (ly:duration?)
                    (map-some-music
                      (lambda (m)
                        (and (ly:duration? (ly:music-property m 'duration))
                             (begin
                                (set! (ly:music-property m 'duration) d)
                                m)))
                      (ly:music-deep-copy m))))

keins = \dauer <a'\1>
kzwei = \dauer <c''\2>
kdrei = \dauer <c'\3>
kvier = \dauer <a'\4>
kfuenf =  \dauer <a\5>8
ksechs =  \dauer <f'\6>
ksieben = \dauer <e'\7>
kacht =   \dauer <e''\8>
kneun =   \dauer <b'\9>

meinNotenSchwung = { \keins4 \kzwei8 \kdrei8 \kvier16 \kfuenf16 \ksechs16 \ksieben16
       \kacht4 \kneun4 \kneun4. \kneun8 \kneun4 }

  \new TabStaff {
    \set TabStaff.instrumentName = "Kalimba"
    \set TabStaff.stringTunings = #kalimba-b9-standard
    \stemDown
    \tabFullNotation
    \override Staff.TimeSignature #'stencil = ##f
    \absolute {
       \keins4 \kzwei8 \kdrei8 \kvier16 \kfuenf16 \ksechs16 \ksieben16
       \kacht4 \kneun4 \kneun4. \kneun8 \kneun4
       \meinNotenSchwung
 
    }
  }

Bögen und Artikulation kann man nicht einfügen. Dafür müssen wieder die originalen Tonhöhen geschrieben werden. Im übrigen finde ich das gar nicht schlimm die realen Tonhöhen zu schreiben. Ich persönlich möchte immer wissen welche Tonhöhe ich schreibe und nicht welche Abkürzung.

Was du mit deinem "Schwung Noten" bezwecken willst, ist mir noch unklar. Das macht nur Sinn, wenn sich die Noten genau so wiederholen sollen. Dafür brauchst du nur die Noten in meinNotenSchwung = {...} einfügen und mit \meinNotenSchwung wieder aufrufen.

Gruß

[TipTap]

Hallo trulli,

danke für die Funktion, die funktion-iert (sic!). Mir geht es nicht darum, eine einmalige Noteneingabe zu vermeiden. Klar werde ich jeden einzelnen Ton erfassen müssen - das mache ich ja auch schon seit Jahren ohne zu murren.

Ich würde allerdings gerne jeden Ton nur einmal erfassen müssen und dann sowohl in der Standardnotation als auch in der TAB das "richtige" Ergebnis sehen. Der Screenshot im Anhang zeigt, wie es für eine 15-tönige Kalimba richtig wäre:

• Kalimba-Tonfolgen steigen fächerformig von der Mitte nach außen.
• Der tiefste Ton ist also in der Mitte - vgl. TAB mit Notation
• Die ungeraden "Saitennummern" steigen nach rechts an (TAB: unten), die geraden nach links (TAB: oben)

Um dieses (richtige) Erscheinungsbild zu bekommen, muss ich allerdings die Saitennummern für die TAB völlig anders beschreiben (nämlich abgezählt von der obersten zur untersten TAB-Linie) als sie üblicherweise bei Kalimbas angegeben sind: Die Saite "1" der Kalimba liegt in deren Mitte, ich muss sie aber für die TAB als Saite "8" \8 beschreiben.

Hier der Code dazu:

Code: [Auswählen]

\version "2.18"

global= { \time 4/4 }

\makeDefaultStringTuning #'kalimba-15-alto \stringTuning <g'' e'' c'' a' fis' d' b  g  a  c' e' g' b' d'' fis''>

<<
  \new Staff { \clef treble \stemUp
    % Melody
    \global
    \set Staff.instrumentName = "Melody"
    \override Staff.StaffSymbol.color = #(x11-color 'grey60)
    \absolute {
      % standard arpeggio from lowest to highest tone/tine
      <g\1>8 <a\2> <b\3> <c'\4> <d'\5> <e'\6> <fis'\7> <g'\8>
      <a'\9> <b'\10> <c''\11> <d''\12> <e''\13> <fis''\14> <g''\15>4
    }
  }

\new TabStaff {
    % Kalimba 15 (G)
    \global
    \set TabStaff.instrumentName = "Kalimba 15"
    \set TabStaff.stringTunings = #kalimba-15-alto
    \stemDown
    \tabFullNotation

    \absolute {
      % standard arpeggio from lowest to highest tone/tine
      <g\8>8 <a\7> <b\9> <c'\6> <d'\10> <e'\5> <fis'\11> <g'\4>
      <a'\12> <b'\3> <c''\13> <d''\2> <e''\14> <fis''\1> <g''\15>4
    }
  }
>>

Es wäre super, wenn ich die Saiten der Kalimba-TAB so ansprechen könnte, wie sie hier als "Fingersatz" über der Standardnotation erscheinen. Wenn ich also in der TAB "\1" referenziere, soll der Ton auf die mittlere Linie gesetzt werden. TAB "\2" wäre dann die Linie oberhalb davon (gerade Saitenzahlen liegen oben), TAB "\3" wäre die Linie unterhalb der Mittelline usw. (vgl. TAB im Screenshot).

Wäre klasse, wenn man das mit Lilypond hinbekäme - dann könnte man für Standardnotation und TAB dieselben, nur einmal formulierten, Notenfolgen benutzen.

TipTap

[trulli]

Hallo TipTap,

nein, solche Definitionen mit Zahlen wie \1 oder 1 gehen nicht, weil das Standardwerte von LilyPond für bestimmte Funktionen sind, wie z.B. Saitennummern und Notenwerte.

Hier mal ein Versuch das Ganze mit Text umzusetzen. Statt \1 \2 habe ich deshalb einfach eins, zwei, drei definiert. Außerdem habe ich nur Melody ausgeschrieben und unten in einer \Score Umgebung den Tab umrechnen lassen. Das sollte die Sache noch weiter vereinfachen.
Jetzt braucht man nur die "Saitenzahl" mit Notenwert als Text eingeben.

Code: [Auswählen]

\version "2.18.0"
 
\makeDefaultStringTuning #'kalimba-15-alto
\stringTuning <g'' e'' c'' a' fis' d' b  g  a  c' e' g' b' d'' fis''>

dauer = #(define-scheme-function (parser location m) (ly:music?)
                  (define-music-function (parser location d) (ly:duration?)
                    (map-some-music
                      (lambda (m)
                        (and (ly:duration? (ly:music-property m 'duration))
                             (begin
                                (set! (ly:music-property m 'duration) d)
                                m)))
                      (ly:music-deep-copy m))))


acht = \dauer g
sieben =\dauer a
neun = \dauer b\9
sechs= \dauer c'
zehn= \dauer d'\10
fuenf= \dauer  e'
elf= \dauer fis'\11
vier= \dauer g'
zwoelf= \dauer a'\12
drei = \dauer  b'
dreizehn = \dauer  c''\13
zwei = \dauer d''
vierzehn = \dauer e''\14
eins = \dauer fis''\1 
fuenfzehn = \dauer g''\15

  melody =
    \absolute {
     \override Beam.concaveness = #10000
      \stemDown
      \override StringNumber.stencil = ##f
     
      \acht8 \sieben8     
      \neun8 \sechs8
      \zehn8 \fuenf8
      \elf8  \vier8
      \zwoelf8 \drei8
      \dreizehn8 \zwei8
      \vierzehn8 \eins8
      \fuenfzehn4
    }



\score {
  <<
    \new StaffGroup = "tab with traditional" <<
      \new Staff = "melody" <<
      \global
      \clef treble
      \set Staff.instrumentName = "Melody"
      \override Staff.StaffSymbol.color = #(x11-color 'grey60)
        \context Voice = "melody" \melody
      >>
      \new TabStaff = "tab" << 
    \set TabStaff.instrumentName = "Kalimba 15"
    \set TabStaff.stringTunings = #kalimba-15-alto
    \tabFullNotation
        \context TabVoice = "melody"  \melody
      >>
    >>
  >>
 
 
}
Mal sehen, obs hilft...
Trulli

[harm6]

Hallo zusammen,

leider habe ich keine Möglichkeit gefunden den TabStaff selbst dazu zu bringen, daß er nur leere Saiten ausgibt.

Daher habe ich kalimba-trickery geschrieben. 

kalimba-trickery ist eine Musik-Funktion, die zuerst alle angegebenen Saiten löscht und dann neu setzt, indem der verlangte Ton in der vordefinierten table nachgeschlagen wird und die richtige Saite ausgegeben wird.

Man kann also bei allen Tönen eine Saite angeben, die im normalen Staff auch so erscheint. Im TabStaff jedoch wird die wirklich benötigte Saite benutzt.

Tatsächlich kommt man auch ohne Angabe irgendeiner Saite aus.

Code: [Auswählen]

\version "2.18.0"

table =
#`(
   (,(ly:make-pitch -1 4 0)  . 8)   ;g
   (,(ly:make-pitch -1 5 0)  . 7)   ;a
   (,(ly:make-pitch -1 6 0)  . 9)   ;b
   (,(ly:make-pitch 0 0 0)   . 6)   ;c'
   (,(ly:make-pitch 0 1 0)   . 10)  ;d'
   (,(ly:make-pitch 0 2 0)   . 5)   ;e'
   (,(ly:make-pitch 0 3 1/2) . 11)  ;fis'
   (,(ly:make-pitch 0 4 0)   . 4)   ;g'
   (,(ly:make-pitch 0 5 0)   . 12)  ;a'
   (,(ly:make-pitch 0 6 0)   . 3)   ;b'
   (,(ly:make-pitch 1 0 0)   . 13)  ;c''
   (,(ly:make-pitch 1 1 0)   . 2)   ;d''
   (,(ly:make-pitch 1 2 0)   . 14)  ;e''
   (,(ly:make-pitch 1 3 1/2) . 1)   ;fis''
   (,(ly:make-pitch 1 4 0)   . 15)  ;g''
  )

kalimba-trickery =
#(define-music-function (parser location music)(ly:music?)

  ;; clear 'articulations from previous StringNumber-settings, if any.
  (music-map
    (lambda (mus)
      (if (music-is-of-type? mus 'note-event)
          (music-filter
             (lambda (m) (not (music-is-of-type? m 'string-number-event)))
             mus)
          mus))
    music)

  ;; insert new StringNumber-settings taken from the predefined table
  (music-map
    (lambda (mus)
      (if (music-is-of-type? mus 'note-event)
          (begin   
            (let ((new-string-number
                      (assoc-get (ly:music-property mus 'pitch) table)))
            (if new-string-number
                (ly:music-set-property! mus 'articulations
                  (append
                    (list (make-music
                            'StringNumberEvent
                            'string-number
                            new-string-number))
                    (ly:music-property mus 'articulations)))))
            mus)
           mus))
    music))

\makeDefaultStringTuning #'kalimba-15-alto
  \stringTuning <g'' e'' c'' a' fis' d' b  g  a  c' e' g' b' d'' fis''>
 
 
%%%%%%%%%%%%%%%%
% EXAMPLE
%%%%%%%%%%%%%%%%

m =
\absolute {
  g8\1 a b c' d' e' fis' g' a' b' c'' d'' e'' fis'' g''4
  \break
  d''8 b' b'4 c''8 a' a'4 g'8 a' b' c'' d'' d'' d''4
  <g b d' g' b' d'' g''>1
}

%% Also works with \relative
%% uncomment:
%{
m =
\relative g {
  g8 a b c d e fis g a b c d e fis g4
  \break
  d8 b b4 c8 a a4 g8 a b c d d d4
  <g b d g b d g>1
}
%}

<<
\new Staff
  % Melody
  \with {
    instrumentName = "Melody"
    \override StaffSymbol.color = #(x11-color 'grey60)
  }
  \m

\new TabStaff
  % Kalimba 15 (G)
  \with {
    instrumentName = "Kalimba 15"
    stringTunings = #kalimba-15-alto
    \tabFullNotation
    \stemDown
  }
  \kalimba-trickery \m
>>
HTH,
  Harm

Und ja, LilyPond kann (fast) alles!!

[harm6]

Hallo,

ich hab' das Ganze nochmal überarbeitet:

1. Die table manuell anzugeben ist zuviel hantier...
 
Stattdessen wird ein Akkord definiert, der dann in \stringTuning aufgerufen wird.
Derselbe Akkord wird benutzt um mittels des neu definierten make-pitch-string-alist die table zu erstellen.
Läuft dann automatisch.


2. Falls die Stimmung mehrere gleiche Tonhöhen verwendet, muß man ja irgendwie angeben können welche Saite/Zunge genommen werden soll.

Unterscheidungskriterium ist hier der EventChord.
D.h. Bei einer Eingabe von
  a' oder <a'>
wird die erste Saite/Zunge mit dieser Tonhöhe aus der table aufgerufen.
Falls man etwas anderes haben möchte, so kann man
  <a'>\4
schreiben.
Im TabStaff wird jetzt die vierte Saite/Zunge genommen, nach Standardzählung, d.h. die "vierte von oben".
Falls man
  <a'\2>\4
schreibt so benutzt der TabStaff die vierte Saite/Zunge, im normalen Staff wird aber die zweite gedruckt.

Code: [Auswählen]

\version "2.18.0"

#(define (make-pitch-string-alist evt-chrd)
  (count-list (reverse (event-chord-pitches evt-chrd))))
 
kalimba-trickery =
#(define-music-function (parser location table music)(list? ly:music?)

  ;; clear NoteEvents 'articulations from StringNumber-settings, if any.
  (music-map
    (lambda (mus)
      (if (music-is-of-type? mus 'note-event)
          (music-filter
             (lambda (m) (not (music-is-of-type? m 'string-number-event)))
             mus)
          mus))
    music)

  ;; insert new StringNumber-settings taken from the predefined table into
  ;; NoteEvents 'articulations
  (music-map
    (lambda (mus)
      (if (music-is-of-type? mus 'note-event)
          (begin   
            (let ((new-string-number
                      (assoc-get (ly:music-property mus 'pitch) table)))
            (if new-string-number
                (ly:music-set-property! mus 'articulations
                  (append
                    (list (make-music
                            'StringNumberEvent
                            'string-number
                            new-string-number))
                    (ly:music-property mus 'articulations)))))
            mus)
           mus))
    music)
   
  ;; If EventChord has StringNumberEvent, clear the NoteEvents from
  ;; StringNumber-settings.
  ;; Ugh, first clear, second set, third clear some?
  ;; TODO: better coding!
  (music-map
    (lambda (mus)
      (if (music-is-of-type? mus 'event-chord)
          (begin
            (let* ((elts (ly:music-property mus 'elements))
                   (evt-chrd-strg-nmbr
                     (filter
                       (lambda (e) (music-is-of-type? e 'string-number-event))
                       elts)))
               (music-map
                  (lambda (m)
                     (if (and (music-is-of-type? m 'note-event)
                              (not (null? evt-chrd-strg-nmbr)))
                         (music-filter
                            (lambda (st)
                              (not (music-is-of-type? st 'string-number-event)))
                            m)
                         m))
                   mus))
            mus)   
          mus))
    music))

 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% EXAMPLE 1: Kalimba-15-alto
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Make sure the chord is given from bottom-string to top-string
"kalimba-15-tuning" =  <g'' e'' c'' a' fis' d' b  g  a  c' e' g' b' d'' fis''>

"kalimba-15-table" = #(make-pitch-string-alist kalimba-15-tuning)

%% To look at the created table uncomment the foolowing lines.
%% The table will be returned to the terminal
%#(use-modules (ice-9 pretty-print))
%#(newline)
%#(pretty-print kalimba-15-table)

\makeDefaultStringTuning #'kalimba-15-alto
  \stringTuning \"kalimba-15-tuning"

"m1" =
\absolute {
  g8\1 a b c' d' e' fis' g' a' b' c'' d'' e'' fis'' g''4
  \break
  d''8 b' b'4 c''8 a' a'4 g'8 a' b' c'' d'' d'' d''4
  <g b d' g' b' d'' g''>1
  \break
  << { c'4 d' }
  \\
  { a b }
  >>
  r2
}

%% Also works with \relative
%% uncomment:
%{
"m1" =
\relative g {
  g8 a b c d e fis g a b c d e fis g4
  \break
  d8 b b4 c8 a a4 g8 a b c d d d4
  <g,, b d g b d g>1
}
%}

<<
\new Staff
  % Melody
  \with {
    instrumentName = "Melody"
    \override StaffSymbol.color = #(x11-color 'grey60)
  }
  \"m1"

\new TabStaff
  % Kalimba 15 (G)
  \with {
    instrumentName = "Kalimba 15"
    stringTunings = #kalimba-15-alto
    \tabFullNotation
    \stemDown
  }
  \kalimba-trickery #kalimba-15-table
  \"m1"
>>

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% EXAMPLE 2: kalimba-b9-standard
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Make sure the chord is given from bottom-string to top-string
"kalimba-b9-tuning" =  <b' e'' e' f' a a' c' c'' a'>

"kalimba-b9-table" = #(make-pitch-string-alist kalimba-b9-tuning)

\makeDefaultStringTuning #'kalimba-b9-standard
  \stringTuning \"kalimba-b9-tuning"
 
"m2" =
\absolute {
  % alle tones/tines from left to right
  a'8 c'' c' <a'>\4 a f' e' e'' b'1
  % standard arpeggio from lowest to highest tone/tine
  a8 c' e' <a'\2>\4 b' c'' e'' a'\8 f'1
}

<<
  \new Staff
  % Melody
  \with {
    instrumentName = "Melody"
    \override StaffSymbol.color = #(x11-color 'grey60)
  }
  \"m2"

  \new TabStaff
  % Kalimba b9
  \with {
    instrumentName = "Kalimba b9"
    stringTunings = #kalimba-b9-standard
    \tabFullNotation
    \stemDown
  }
  \kalimba-trickery #kalimba-b9-table
  \"m2"
>>

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% EXAMPLE 3: crazy-kalimba
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% Make sure the chord is given from bottom-string to top-string
"crazy" =  <a' a' a' a' a'>

"crazy-table" = #(make-pitch-string-alist crazy)

\makeDefaultStringTuning #'crazy-kalimba
  \stringTuning \"crazy"
 
i-c = \once \override TabStaff.NoteColumn #'ignore-collision = ##t
omit-stem = \once \omit TabVoice.Stem
 
cr = \absolute {
  a'8 <a'> a'\4 <a'\2>\2 <a'\1>\3 <a'\3>\4 <a'\5>4\5
 
  %% writing chords containing equal tuned strings will be tricky
  \i-c
  <<
  {  \omit-stem <a'\4>\1 }
  \\
  {  \omit-stem <a'\2>\2 }
  \\
  {  \omit-stem <a'\1>\3 }
  \\
  {  \omit-stem <a'\3>\4 }
  \\
  {  \stemDown  <a'\5>\5 }
  >>
}

<<
  \new Staff \cr

  \new TabStaff
  % crazy-kalimba
  \with {
    stringTunings = #crazy-kalimba
    \tabFullNotation
    \stemDown
    instrumentName = "crazy"
  }
  \kalimba-trickery #crazy-table
  \cr
>>

HTH,
  Harm

[trulli]

Gute Lösung, harm. Da komme ich als Scheme-Legastheniker nicht mehr mit... 

Sag mal, warum sind in deiner Tabulatur die "Nullen" unterschiedlich? Manchmal sehen sie aus wie eine normale "Null" und manchmal wie der Buchstabe "O". Wenn ich deinen Code kompiliere, sehen bei mir alle Nullen gleich aus...

Grüße

[TipTap]

Liebe Leute,

großartige Sache! Vielen Dank dafür!

Ich bin gerade über's Wochenende auf einem Lehrgang und werde das in der neuen Woche mal anwenden und ausprobieren. Soweit ich den Code verstehe, ist es genau das, was ich mir gewünscht habe - ihr seid Klasse!

TipTap