Wiederholungsklammer manuell setzen

[xr]

Hi,

ich bin auf der Suche nach einer Funktion, mit der ich eine Wiederholungsklammer setzen kann, ohne \alternative zu benutzen.
(Da ich meine Noten mittels eines Python Skriptes erzeuge, wäre die Programmierung des gesamten Kontextes  (z.B. \repeat volta 3 \alternative {...} {...} ) inklusive der Verteilung eines Gesangstextes immens kompliziert)

Gibt es die Möglichkeit z.B. mittels einer Scheme-Funktion Klammern zu erzeugen?
Wie muss die aussehen? Kann mir jemand ein einfaches Beispiel zeigen?

Ich würde gern einen Befehl erzeugen wie:

\Klammer_an '#(1 . 3)      % soll Klammer 1 und 3 erzeugen
 ... mein Notentext ...
\Klammer_aus                 % soll die Klammer beenden
\Klammer_an '#(2 . 4)     % soll Klammer 2 und 4 erzeugen
... mein Notentext ...
\Klammer_aus                 % soll die Klammer beenden

Danke für Hilfe im Voraus,
Xaver

[Arnold]

Hallo,

in meiner "stradella-toolbox" (siehe https://liarchiv.joonet.de/index.php?topic=1158.0) habe ich rudimentäre Funktionen \pmpStartRepeat, \pmpStartRepeatEx, \pmpEndRepeat und \pmpStartAlternative definiert.
Anwendung: Mit \parallelMusic erzeuge ich mehrere "sequentielle Musiken" mit diesen "Kommandos" drinnen, (denn \repeat volta würde das \parallelMusic durcheinander bringen) und anschließend wird jede dieser "sequentiellen Musiken" an diesen Markierungen zerschnitten und neu (mit \repeat volta) zusammengesetzt.
Wichtig ist: Diese "Steuerkommandos" müssen genau in der gleichen Ebene der sequentiellen Musik vorkommen, nicht in Unterstrukturen gepackt!
Bisher habe ich auch kein Kommando \pmpStartAlternativeEx defniert, mit welcher man den Alternativtext für die Klammerzählung übergibt, aber der existierende Code könnte als Ausgangspunkt dienen. Und #parallel-music-results-postprocess wird sogar nur intern als Scheme-Aufruf gestartet, ist also noch nicht als normale Musikfunction definiert.

Die Anwendung sähe in Endeffekt etwa so aus, wenn man die Funktionen entsprechend erweitert:

Code: [Auswählen]

\convertPMPRepeatMarksIntoRepeats {
  \pmpStartRepeat
  ...
  \pmpStartAlternativeEx #"1.+3."
  ...
  \pmpStartAlternativeEx #"2.+4."
  ...
  \pmpEndRepeat
}
Arnold

[xr]

Prima, herzlichen Dank. Schaue ich mir direkt an.

Gruß,
Xaver

[xr]

Das Beispiel ist wirklich kompliziert. Und da es, soweit ich es verstehe, gleich zwei Wrapper nutzt, ist es schwierig hinter die Funktionsweise zu kommen.
Ich habe deine Beispieldateien mal soweit reduziert, wie ich konnte. (s.u.)

Wird das, was in den Parser gegeben wird, jetzt soweit umgemodelt, dass für den Lilypond Parser letztlich wieder ein \repeat volta 3 \alternative {...} {...} erscheint?

Ich suche eine Möglichkeit, eine Klammer einfach wie eine Zeichnung zu setzen. Lilypond bräuchte sich um die musikalische Logik nicht weiter zu kümmern.

Hier die reduzierten Beispiele:

Code: [Auswählen]

\version "2.15.39"
\include "stradella-toolbox--1.0.ly"

\parallelMusicWithStradella #'(AkkT) {

  \pmpStartRepeat
 
  c 4 e e e       |

  \pmpStartAlternative
  c 4 c' c r |
  \pmpStartAlternative
  e 4  e e r |

  \pmpStartAlternative
  e4 e e e'|
  \pmpStartAlternative
  e4        e e r    |
 
  \mark "Mark"
  \pmpStartRepeat
  e'2.      a'8 b' | 
  \pmpStartAlternative
  e 4 e e e'\p | 
  \pmpStartAlternative
  e 4 e e r |
 
}


\score {
  \new Staff <<   
      \AkkT   
  >>
 
}


Code: [Auswählen]

%{
stradella-toolbox reduced
%}
\version "2.15.30"


%§ post processing marks for the extended parallelMusic
pmpStartRepeat = #(define-music-function (parser location) () (make-music 'MarkEvent
 'label "<parallel-music-results-postprocess:start repeat volta 2>"))
pmpStartRepeatEx = #(define-music-function (parser location count) (integer?) (make-music 'MarkEvent
 'label (string-append "<parallel-music-results-postprocess:start repeat volta " (number->string count) ">")))
pmpEndRepeat = #(define-music-function (parser location) () (make-music 'MarkEvent
 'label "<parallel-music-results-postprocess:end repeat>"))
pmpStartAlternative = #(define-music-function (parser location) () (make-music 'MarkEvent
 'label "<parallel-music-results-postprocess:start alternative>"))

#(define (pmpMark mus)
  (if (ly:music? mus)
   (let
    ((eventtype (ly:music-property mus 'name))
     (labeltext (ly:music-property mus 'label))
    )
    (if (and (eq? eventtype 'MarkEvent) (string? labeltext))
     (let*
      ((head "<parallel-music-results-postprocess:")
       (headlen (string-length head))
       (labellen (string-length labeltext)))
      (if (<= labellen headlen) 0
       (let*
        ((labelhead (string-copy labeltext 0 headlen))
         (labelpost (string-copy labeltext headlen))
         (postlen (string-length labelpost))
         (labelshortpost (string-copy labelpost 0 (min postlen 19)))
        )
        (if (string=? labelhead head)
         (if (string=? labelshortpost "start repeat volta ") 1
          (if (string=? labelpost "end repeat>") 2
           (if (string=? labelpost "start alternative>") 3
            0)))
         0))))
     0))
   0))


#(define (parallel-music-results-postprocess mus)
  (let ((eventtype (ly:music-property mus 'name)))
   (if (eq? eventtype 'SequentialMusic)
    (let
     ((es (ly:music-property mus 'elements))
      (new-es '())
      (active-dest 0)
      (rep-collect '())
      (alt-collect '())
      (alt-list-collect '())
      (rep-count 2)
     )
     (for-each (lambda (ese)
       (let ((etype (pmpMark ese)))
        (if (eq? etype 2) ;; end repeat ;;
         (begin
          (if (eq? active-dest 3)
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '()))))
          (set! new-es (append new-es (cons
           (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
            'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '())))
          (set! active-dest 0)
          (set! rep-collect '())
          (set! alt-collect '())
          (set! alt-list-collect '())))
        (if (eq? etype 1) ;; start repeat ;;
         (begin
          (if (eq? active-dest 3)
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '()))))
          (if (>= active-dest 1) ;; terminate existing repeat and start new repeat block
           (set! new-es (append new-es (cons
            (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
             'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '()))))
          (set! active-dest 1)
          (set! rep-collect '())
          (set! alt-collect '())
          (set! alt-list-collect '())))
        (if (and (eq? etype 3) (>= active-dest 1)) ;; start alternative (only when repeat allready started) ;;
         (if (eq? active-dest 3) ;; next alternative ;;
          (begin
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '())))
           (set! alt-collect '()))
          (set! active-dest 3)))
        (if (eq? etype 0)
         (begin
          (if (eq? active-dest 0)
           (set! new-es (append new-es (cons ese '()))))
          (if (eq? active-dest 1)
           (set! rep-collect (append rep-collect (cons ese '()))))
          (if (eq? active-dest 3)
           (set! alt-collect (append alt-collect (cons ese '()))))))))
      es)
     (if (eq? active-dest 1) ;; start repeat is open ;;
      (set! new-es (append new-es (cons
       (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
        'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '()))))
     (if (eq? active-dest 3) ;; start alternative is open ;;
      (begin
       (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '())))
       (set! new-es (append new-es (cons
        (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
         'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '())))))
     (ly:music-set-property! mus 'elements new-es)
     mus)
    mus)))



%§ \paralleMusic with \stradellaMode applied to the last voice
% and another postprocessor applied to all voices
parallelMusicWithStradella =
#(define-void-function (parser location voice-ids music) (list? ly:music?)
  (let ((parmus (ly:parser-lookup parser 'parallelMusic)))
   
     (let ((parex (ly:music-function-extract parmus)))
      (parex parser location voice-ids music)     
         
      (let ((counter 0))
       (for-each (lambda (voice-id)
         (let ((pme (ly:parser-lookup parser voice-id)))
         
           (if (eq? counter 0)
           
            (ly:parser-define! parser voice-id
             (parallel-music-results-postprocess
              pme)
             
             )
 
         )
           )
         )
           
        (reverse voice-ids))
       )
      )))

Xaver

[Arnold]

O.K.

Und alle mit weniger Scheme-Programmier-Erfahrung durfen das hier ausprobieren:

Code: [Auswählen]

\version "2.18.2"

pmpStartRepeat = #(define-music-function (parser location) () (make-music 'MarkEvent
 'label "<parallel-music-results-postprocess:start repeat volta 2>"))
pmpStartRepeatEx = #(define-music-function (parser location count) (integer?) (make-music 'MarkEvent
 'label (string-append "<parallel-music-results-postprocess:start repeat volta " (number->string count) ">")
 'extra-int count))
pmpEndRepeat = #(define-music-function (parser location) () (make-music 'MarkEvent
 'label "<parallel-music-results-postprocess:end repeat>"))
pmpStartAlternative = #(define-music-function (parser location) () (make-music 'MarkEvent
 'label "<parallel-music-results-postprocess:start alternative>"))
pmpStartAlternativeEx = #(define-music-function (parser location s) (string?) (make-music 'MarkEvent
 'label (string-append "<parallel-music-results-postprocess:start named alternative:" s ">")
 'extra-text s))

#(define (pmpMark mus)
  (if (ly:music? mus)
   (let
    ((eventtype (ly:music-property mus 'name))
     (labeltext (ly:music-property mus 'label))
    )
    (if (and (eq? eventtype 'MarkEvent) (string? labeltext))
     (let*
      ((head "<parallel-music-results-postprocess:")
       (headlen (string-length head))
       (labellen (string-length labeltext)))
      (if (<= labellen headlen) 0
       (let*
        ((labelhead (string-copy labeltext 0 headlen))
         (labelpost (string-copy labeltext headlen))
         (postlen (string-length labelpost))
         (labelshortpost (string-copy labelpost 0 (min postlen 19)))
        )
        (if (string=? labelhead head)
         (if (string=? labelshortpost "start repeat volta ") 1
          (if (string=? labelpost "end repeat>") 2
           (if (string=? labelpost "start alternative>") 3
            (if (string=? labelshortpost "start named alterna") 4
             0))))
         0))))
     0))
   0))

#(define (pmpMarkRepeatCount mus)
  (if (ly:music? mus)
   (let
    ((eventtype (ly:music-property mus 'name))
     (labeltext (ly:music-property mus 'label)))
    (if (and (eq? eventtype 'MarkEvent) (string? labeltext))
     (let*
      ((head "<parallel-music-results-postprocess:")
       (headlen (+ (string-length head) 19))
       (labellen (string-length labeltext)))
      (if (<= labellen headlen) 2
       (let*
        ((labelhead (string-copy labeltext 0 headlen))
         (labelpost (string-copy labeltext headlen (- labellen 1)))
         (labelterm (string-copy labeltext (- labellen 1))))
        (if (string=? labelterm ">") (string->number labelpost)
         2))))
     2))
   2))

#(define (parallel-music-results-postprocess mus)
  (let ((eventtype (ly:music-property mus 'name)))
   (if (eq? eventtype 'SequentialMusic)
    (let
     ((es (ly:music-property mus 'elements))
      (new-es '())
      (active-dest 0)
      (rep-collect '())
      (alt-collect '())
      (alt-list-collect '())
      (rep-count 2)
     )
     (for-each (lambda (ese)
       (let ((etype (pmpMark ese)))
        (if (eq? etype 2) ;; end repeat ;;
         (begin
          (if (eq? active-dest 3)
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '()))))
          (set! new-es (append new-es (cons
           (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
            'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '())))
          (set! active-dest 0)
          (set! rep-collect '())
          (set! alt-collect '())
          (set! alt-list-collect '())))
        (if (eq? etype 1) ;; start repeat ;;
         (begin
          (if (eq? active-dest 3)
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '()))))
          (if (>= active-dest 1) ;; terminate existing repeat and start new repeat block
           (set! new-es (append new-es (cons
            (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
             'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '()))))
          (set! active-dest 1)
          (set! rep-collect '())
          (set! alt-collect '())
          (set! rep-count (ly:music-property ese 'extra-int 2))
          (set! alt-list-collect '())))
        (if (and (eq? etype 3) (>= active-dest 1)) ;; start alternative (only when repeat allready started) ;;
         (if (eq? active-dest 3) ;; next alternative ;;
          (begin
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '())))
           (set! alt-collect '()))
          (set! active-dest 3)))
        (if (and (eq? etype 4) (>= active-dest 1)) ;; start named alternative (only when repeat allready started) ;;
         (begin
          (if (eq? active-dest 3) ;; next alternative ;;
           (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '())))
          (set! active-dest 3))
         (set! alt-collect (cons
           (make-music 'ApplyContext
            'procedure (lambda (ctx)
                        (let ((score-ctx (ly:context-find ctx 'Score)))
                         (if (ly:context? score-ctx)
                          (let ((old-rc (ly:context-property score-ctx 'repeatCommands '())))
                           (ly:context-set-property! score-ctx 'repeatCommands (cons (list 'volta (ly:music-property ese 'extra-text "?")) old-rc)))))))
           '()))))
        (if (eq? etype 0)
         (begin
          (if (eq? active-dest 0)
           (set! new-es (append new-es (cons ese '()))))
          (if (eq? active-dest 1)
           (set! rep-collect (append rep-collect (cons ese '()))))
          (if (eq? active-dest 3)
           (set! alt-collect (append alt-collect (cons ese '()))))))))
      es)
     (if (eq? active-dest 1) ;; start repeat is open ;;
      (set! new-es (append new-es (cons
       (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
        'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '()))))
     (if (eq? active-dest 3) ;; start alternative is open ;;
      (begin
       (set! alt-list-collect (append alt-list-collect (cons (make-music 'SequentialMusic 'elements alt-collect) '())))
       (set! new-es (append new-es (cons
        (make-music 'VoltaRepeatedMusic 'repeat-count rep-count
         'element (make-music 'SequentialMusic 'elements rep-collect) 'elements alt-list-collect) '())))))
     (ly:music-set-property! mus 'elements new-es)
     mus)
    mus)))

LinearToVoltaRepeats =
#(define-music-function (parser location m) (ly:music?)
  (parallel-music-results-postprocess m))


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\LinearToVoltaRepeats {
  c'1
  \pmpStartRepeat
  d'
  \pmpStartAlternative
  e'
  \pmpStartAlternative
  f'
  \pmpStartRepeat
  g'
  \pmpStartAlternative
  a'
  \pmpStartAlternative
  b'
  \pmpStartRepeatEx #5
  c''
  \pmpStartAlternativeEx #"1., 3."
  d''
  \pmpStartAlternativeEx #"2., 4."
  e''
  \pmpStartAlternative
  f''
  \pmpEndRepeat
  g''
}

A propos, bis jetzt sind nur Zeichenketten (Strings, unformatierte Texte) als Klammerbenennung möglich, keine markups (z. Bsp. um das Wörtchen »Fine« in eine Klammer zu setzen.)

Arnold

[Arnold]

Hallo xr,

es wird die übergebene »sequentielle Musik« Schritt für Schritt durchgegangen - aber nur in der obersten Ebene - und an den »Markierungen« wird die Liste in Einzellisten unterteilt, um daraus die eingebetteten \repeat volta Strukturen einzufügen.
Dadurch kann später auch \unfoldRepeats angewandt werden, z. Bsp. um Midi zu erzeugen.

Wollte man nur die Grafik, könnte man sich eine Liste der in Handbuch nachzulesenden manuellen Wiederholungszeichen- und Voltenklammern in einer eigenen Datei zusammenstellen (und in jedes neue Projekt mittels \include einbinden). Jedes dort abgelegte Schnipsel enthält alles was an einem "Taktstrich" zu passieren hat, im einfachsten Fall nur die Taktstrichdefinition, meistens Taktstrich- und Volta-Definition zusammen.

Arnold.

[xr]

Wollte man nur die Grafik, könnte man sich eine Liste der in Handbuch nachzulesenden manuellen Wiederholungszeichen- und Voltenklammern in einer eigenen Datei zusammenstellen (und in jedes neue Projekt mittels \include einbinden). Jedes dort abgelegte Schnipsel enthält alles was an einem "Taktstrich" zu passieren hat, im einfachsten Fall nur die Taktstrichdefinition, meistens Taktstrich- und Volta-Definition zusammen.

Das ist quasi die Antwort. Ich habe nämlich nicht gesehen, dass man eine Voltenklammer auch manuell erzeugen kann. Die Befehle lauten ganz einfach:
\set Score.repeatCommands = #'((volta "2"))
\set Score.repeatCommands = #'((volta #f))

Es ist natürlich ganz einfach, daraus eine Funktion zu basteln.

Vielen Dank,
Xaver

[Manuela]

Wieder was gelernt 

[xr]

Da die Funktionen doch nicht so einfach zu erzeugen waren, wie ich behauptet habe - zumindest nicht für mich - poste ich nun doch noch die Lösung:

Code: [Auswählen]

Klammer =
#(define-music-function
    (parser location num)
    (number?)

    (define liste '(list (volta "1")) )
   
    (set! nr (integer->char (+ 48 num)) )
    (set! nr (make-string 1 nr))
    (set-car! (cdr(car (cdr liste)))   nr)
       
    #{       
    \set Score.repeatCommands = # liste
    #})


Klammer_aus =
#(define-music-function
    (parser location)
    ()
   
    #{
     \set Score.repeatCommands = #'((volta #f))
    #})

Das funktioniert für die Zahlen 1 - 9, für höhere müsste man den Code erweitern.
Gibt es in Scheme eine einfache Funktion, um Integer jeglicher Größe in Strings umzuwandeln?

[Manuela]

Ja, gibt es, hier z.B. nachzulesen

[xr]

Ok, dann gehts doch einfacher für jede Zahl:

Code: [Auswählen]

nr = ""

Klammer =
#(define-music-function
    (parser location num)
    (number?)

    (define liste '(list (volta "1")) )
   
    (set! nr (number->string num))
    (set-car! (cdr(car (cdr liste)))   nr)
       
    #{       
    \set Score.repeatCommands = # liste
    #})


[Manuela]

Mein Scheme ist wieder eingerostet, aber das geht sicher noch einfacher.

Was genau macht dein Programm, hängt es num als String an die Liste?

[xr]

Ich habe hier nochmal den vollständigen Code. Funktioniert leider immer noch nicht. Statt Klammer 1 und Klammer 2 wird 2x Klammer 2 ausgegeben. Außerdem bekomme ich folgende Fehlermeldung:
Warnung: Wiederholungsklammer bereits vorhanden, wird vorzeitig beendet

Code: [Auswählen]

\version "2.18.2"
         
#(define liste '(list (volta "1")) )         

txt = ""


Klammer =
#(define-music-function
    (parser location num)
    (number?)

    (set! txt (number->string num))
    (set-car! (cdr(car (cdr liste)))   txt)
       
    #{       
    \set Score.repeatCommands = # liste
    #})


Klammer-aus =
#(define-music-function
    (parser location)
    ()
   
    #{
     \set Score.repeatCommands = #'((volta #f))
    #})


\score {
 
    <<
      \relative {   
       
        \time 4/4 
       
        f'4 g f f 
       
        \Klammer 1
        e4 f e e
        g4 e e e
        f4 g f f 
        \Klammer-aus
        \bar ":|."
       
        \Klammer 2
        e4 f e e
        g4 e e e
        \Klammer-aus
       
        c4 d c c     
      }
 
    >>
 
}


[xr]

So, Stunden später habe ich jetzt endlich eine funktionierende Lösung.
Von C oder Python kommend, kann einen Scheme echt in die Verzweiflung treiben.

Code: [Auswählen]

\version "2.18.2"


txt = ""

Klammer =
#(define-music-function
    (parser location num)
    (number?)
   
    (define listeA '(list  (volta "1")) )
    (define listeB '( (volta #f) (volta "2")) )
   
    (newline)
   
    ( if ( < num 2)
        (begin
            (set! txt (number->string num))
            (set-car! (cdr(car(cdr listeA))) txt)

            #{       
            \set Score.repeatCommands = #listeA
            #}
        )
   
        (begin
            (set! txt (number->string num))
            (set-car!(cdr(car(cdr listeB))) txt )
       
            #{       
            \set Score.repeatCommands = #listeB
            #}
        )   
    )
)

Klammer-aus =
#(define-music-function
    (parser location)
    ()   
    #{
     \set Score.repeatCommands = #'((volta #f))
    #})


\score { 
    <<
      \relative {   
       
        \time 4/4 
       
        f'4 g f f 
       
        \Klammer 1
        e4 f e e
        g4 e e e
        f4 g f  f 
        \Klammer-aus
        \bar ":|."
       
        \Klammer 3
        e4 f e e
        g4 e e e
        \Klammer-aus
       
        c4 d c c     
      }
 
    >>
}
[code]

[xr]

Ah - ich werde doch noch wahnsinnig!
Dummerweise überschreibt immer die letzte Zahl alle Zahlen der vorangegangenen Klammern. Das fällt natürlich erst bei mehreren Klammern auf.

Weiß irgendwer warum das so ist? Werden Variablen an den Lilypond Parser übergeben und erst am Schluss ausgewertet? Oder was mache ich falsch?