Automatic ottava handling

[David Bellows]

This is probably asking a lot, but is there a way to have ottava markings
used automatically? It sounds like a complicated function since you'd also
want it to be able to span consecutive notes but being able to specify when
(as in how many ledger lines above the staff) it would kick in would be
really nice. The project I'm working on automatically generates Lilypond
files so I can't do this manually. I have given some thought as to how I
would do it in my software but was hoping someone else had already tackled
the problem from a Lilypond perspective.

Thanks,
Dave Bellows
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Malte Meyn]

There is a pitch-dependent staff switching automatism in LilyPond (I 
don’t know how it works but you can have a look at piano/harp section in 
the notation reference) so I think what you are asking for should at 
least not be impossible.


Am 05.10.2014 um 17:52 schrieb David Bellows:

This is probably asking a lot, but is there a way to have ottava markings
used automatically? It sounds like a complicated function since you'd also
want it to be able to span consecutive notes but being able to specify when
(as in how many ledger lines above the staff) it would kick in would be
really nice. The project I'm working on automatically generates Lilypond
files so I can't do this manually. I have given some thought as to how I
would do it in my software but was hoping someone else had already tackled
the problem from a Lilypond perspective.

Thanks,
Dave Bellows



___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user



___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Gilberto Agostinho]

Malte Meyn-3 wrote
> There is a pitch-dependent staff switching automatism in LilyPond (I 
> don’t know how it works but you can have a look at piano/harp section in 
> the notation reference) so I think what you are asking for should at 
> least not be impossible.

You are talking about \autochange (see:
http://lilypond.org/doc/v2.18/Documentation/notation/common-notation-for-keyboards#changing-staff-automatically
). 

And indeed an automatic function to add ottava markings for every pitch
higher than a certain threshold (and ottava bassa lower than another defined
threshold) would be a fantastic addition to LilyPond.

Best,
Gilberto Agostinho




--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167195.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Bellows]

I ended up creating my own solution to use in my code that generates
scores. Unfortunately it doesn't really translate into anything usable by
anyone else. Likewise I created my own staff switching method as well so
that rests would be printed in the other staff.

Still, I think the automatic ottava marking would be a good idea and maybe
even doable. Alas, I am not the one to do it, though.

On Sun, Oct 5, 2014 at 2:14 PM, Gilberto Agostinho <
gilbertohasn...@gmail.com> wrote:

> Malte Meyn-3 wrote
> > There is a pitch-dependent staff switching automatism in LilyPond (I
> > don’t know how it works but you can have a look at piano/harp section in
> > the notation reference) so I think what you are asking for should at
> > least not be impossible.
>
> You are talking about \autochange (see:
>
> http://lilypond.org/doc/v2.18/Documentation/notation/common-notation-for-keyboards#changing-staff-automatically
> ).
>
> And indeed an automatic function to add ottava markings for every pitch
> higher than a certain threshold (and ottava bassa lower than another
> defined
> threshold) would be a fantastic addition to LilyPond.
>
> Best,
> Gilberto Agostinho
>
>
>
>
> --
> View this message in context:
> http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167195.html
> Sent from the User mailing list archive at Nabble.com.
>
> ___
> lilypond-user mailing list
> lilypond-user@gnu.org
> https://lists.gnu.org/mailman/listinfo/lilypond-user
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Hi,

On Mon, Oct 6, 2014 at 3:51 PM, David Bellows  wrote:

> I ended up creating my own solution to use in my code that generates
> scores. Unfortunately it doesn't really translate into anything usable by
> anyone else. Likewise I created my own staff switching method as well so
> that rests would be printed in the other staff.
>
> Still, I think the automatic ottava marking would be a good idea and maybe
> even doable. Alas, I am not the one to do it, though.
>
> On Sun, Oct 5, 2014 at 2:14 PM, Gilberto Agostinho <
> gilbertohasn...@gmail.com> wrote:
>
>> Malte Meyn-3 wrote
>> > There is a pitch-dependent staff switching automatism in LilyPond (I
>> > don’t know how it works but you can have a look at piano/harp section in
>> > the notation reference) so I think what you are asking for should at
>> > least not be impossible.
>>
>> You are talking about \autochange (see:
>>
>> http://lilypond.org/doc/v2.18/Documentation/notation/common-notation-for-keyboards#changing-staff-automatically
>> ).
>>
>> And indeed an automatic function to add ottava markings for every pitch
>> higher than a certain threshold (and ottava bassa lower than another
>> defined
>> threshold) would be a fantastic addition to LilyPond.
>>
>>
I think this should be doable.

Here's a preliminary experiment.  It will add an automatic \ottava 1 before
passages where notes have at least a specified number of ledger lines.

Right now this is pretty limited.  It won't handle \relative, for one
thing.  I'll have to get deeper into the music representation for that, but
this should serve as a proof-of-concept.

Another issue is adapting to different clefs.  The function \octavate is
hard-coded for treble clef at the moment.  The problem is that
'clefMiddleCPosition is a context property, and I'm not sure how to get at
context properties through a music function.  Any ideas?  With this
property it's easy to have this work automatically with different clefs.
 (The number -6 in the function represents the value of
'clefMiddleCPosition for treble clef--middle C is 6 staff-steps below the
center line.)

Best,
David
\version "2.19.10"

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2

octavate =
#(define-music-function (parser location threshold mus)
   (integer? ly:music?)
   "Create an ottava for notes which have at least @var{threshold} ledger lines"
   (let ((elts (ly:music-property mus 'elements)))
 
 ; Put an "ottava 1" in front of the first NoteEvent
 ; such that pitch will result in more than one ledger line
 ; Put an "ottava 0" in front of the first NoteEvent
 ; such that one or fewer ledger lines are needed.
 ; start-loco? and start-ottava? are flags which ensure that
 ; only the first pitch qualifying for an ottava 0 or 1, respectively,
 ; receives 'OttavaMusic
 
 (define (build-new-elts mus-expr new-expr start-loco? start-ottava?)
   (if (null? mus-expr)
   new-expr
   (let ((p (ly:music-property (car mus-expr) 'pitch)))
 (cond
  ((not (ly:pitch? p))
   (build-new-elts
(cdr mus-expr)
(append new-expr (list (car mus-expr)))
#t #t))
  ((and (ly:pitch? p)
start-ottava?
(>= (ledger-line-no -6 p) threshold))
   (build-new-elts
(cdr mus-expr)
(append
 new-expr
 (list (make-music 'OttavaMusic 'ottava-number 1))
 (list (car mus-expr)))
#t #f))
  ((and (ly:pitch? p)
start-loco?
(< (ledger-line-no -6 p) threshold))
   (build-new-elts
(cdr mus-expr)
(append
 new-expr
 (list (make-music 'OttavaMusic 'ottava-number 0))
 (list (car mus-expr)))
#f #t))
  (else 
   (build-new-elts
(cdr mus-expr)
(append new-expr (list (car mus-expr)))
#t #t))
 
 (make-music 'SequentialMusic 'elements (build-new-elts elts '() #t #t

%%% EXAMPLE 

music = {
  a''8 b'' c''' d''' e''' f''' g''' a'''
}

{
  \music \bar "||"
  \octavate #1 \music \bar "||"
  \octavate #2 \music \bar "||"
  \octavate #3 \music \bar "||"
  \octavate #4 \mus

Re: Automatic ottava handling

[David Bellows]

>Here's a preliminary experiment.  It will add an automatic \ottava 1
before passages where notes have at least a specified number of ledger
lines.

This is a terrific start! The solution I'm using in my program counts the
number of commas or single quotes and applies the ottava marking based on
that which works fine but doesn't give as aesthetically a pleasing result
as your method does. I will totally ditch my method if this one progresses
much further.

On Tue, Oct 7, 2014 at 4:32 PM, David Nalesnik 
wrote:

> Hi,
>
> On Mon, Oct 6, 2014 at 3:51 PM, David Bellows 
> wrote:
>
>> I ended up creating my own solution to use in my code that generates
>> scores. Unfortunately it doesn't really translate into anything usable by
>> anyone else. Likewise I created my own staff switching method as well so
>> that rests would be printed in the other staff.
>>
>> Still, I think the automatic ottava marking would be a good idea and
>> maybe even doable. Alas, I am not the one to do it, though.
>>
>> On Sun, Oct 5, 2014 at 2:14 PM, Gilberto Agostinho <
>> gilbertohasn...@gmail.com> wrote:
>>
>>> Malte Meyn-3 wrote
>>> > There is a pitch-dependent staff switching automatism in LilyPond (I
>>> > don’t know how it works but you can have a look at piano/harp section
>>> in
>>> > the notation reference) so I think what you are asking for should at
>>> > least not be impossible.
>>>
>>> You are talking about \autochange (see:
>>>
>>> http://lilypond.org/doc/v2.18/Documentation/notation/common-notation-for-keyboards#changing-staff-automatically
>>> ).
>>>
>>> And indeed an automatic function to add ottava markings for every pitch
>>> higher than a certain threshold (and ottava bassa lower than another
>>> defined
>>> threshold) would be a fantastic addition to LilyPond.
>>>
>>>
> I think this should be doable.
>
> Here's a preliminary experiment.  It will add an automatic \ottava 1
> before passages where notes have at least a specified number of ledger
> lines.
>
> Right now this is pretty limited.  It won't handle \relative, for one
> thing.  I'll have to get deeper into the music representation for that, but
> this should serve as a proof-of-concept.
>
> Another issue is adapting to different clefs.  The function \octavate is
> hard-coded for treble clef at the moment.  The problem is that
> 'clefMiddleCPosition is a context property, and I'm not sure how to get at
> context properties through a music function.  Any ideas?  With this
> property it's easy to have this work automatically with different clefs.
>  (The number -6 in the function represents the value of
> 'clefMiddleCPosition for treble clef--middle C is 6 staff-steps below the
> center line.)
>
> Best,
> David
>
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Hi,

On Wed, Oct 8, 2014 at 9:48 AM, David Bellows  wrote:

> >Here's a preliminary experiment.  It will add an automatic \ottava 1
> before passages where notes have at least a specified number of ledger
> lines.
>
>
The attached function will work with more complex music expressions.

The only problem here is with the handling of chords.  Right now, the
function either ignores them or attempts to add the ottava within the
EventChord expression (which causes an error).  This shouldn't be too hard
to fix, though it will take some thought.

Hope this proves useful!

David
\version "2.19.10"

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2


octavate =
#(define-music-function (parser location threshold mus)
   (integer? ly:music?)
   "Create an ottava for notes which have at least @var{threshold} ledger lines"
   (let ((e (ly:music-property mus 'element))
 (elts (ly:music-property mus 'elements)))
 
 (define (build-new-elts mus-expr new-expr start-loco? start-ottava?)
   (if (null? mus-expr)
   ;; ensure that ottava does not extend past a localized
   ;; use of \octavate
   (append new-expr
 (list (make-music 'OttavaMusic 'ottava-number 0)))
   (let ((p (ly:music-property (car mus-expr) 'pitch)))
 (cond
  ((not (ly:pitch? p))
   (build-new-elts
(cdr mus-expr)
(append new-expr (list (car mus-expr)))
#t #t))
  ((and (ly:pitch? p)
start-ottava?
(>= (ledger-line-no -6 p) threshold))
   (build-new-elts
(cdr mus-expr)
(append
 new-expr
 (list (make-music 'OttavaMusic 'ottava-number 1))
 (list (car mus-expr)))
#t #f))
  ((and (ly:pitch? p)
start-loco?
(< (ledger-line-no -6 p) threshold))
   (build-new-elts
(cdr mus-expr)
(append
 new-expr
 (list (make-music 'OttavaMusic 'ottava-number 0))
 (list (car mus-expr)))
#f #t))
  (else 
   (build-new-elts
(cdr mus-expr)
(append new-expr (list (car mus-expr)))
#t #t))
 
 (define (recurse music)
   (let ((elts (ly:music-property music 'elements))
 (e (ly:music-property music 'element)))
 (if (ly:music? e)
 (recurse e))
 (if (pair? elts)
 (if (any (lambda (elt) (music-is-of-type? elt 'note-event)) elts)
 (set! (ly:music-property music 'elements)
   (build-new-elts elts '() #t #t))
 (map recurse elts)
 
 (recurse mus)
 
 mus))

%%% EXAMPLE 

music = \relative c''' {
  \repeat volta 2 {
a8 b c d e f g a
  }
}

musictwo = \new PianoStaff <<
  \new Staff { \music R1 }
  \new Staff { \unfoldRepeats \transpose c e { \music } }
>>

{
  \octavate #5 \music
  \octavate #4 \music
  \octavate #3 \music
  \octavate #2 \music
}

{
  \octavate #3 \musictwo
}___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Bellows]

>The attached function will work with more complex music expressions.

Nicely done! I really like the greater flexibility achieved based on using
ledger lines. Fortunately in this project I don't use chords so that's not
a problem, less fortunately is that I need it for the bassa as well. But I
will look over the code and see if I can't figure it out for myself.

Thanks!

On Sat, Oct 11, 2014 at 7:57 AM, David Nalesnik 
wrote:

> Hi,
>
> On Wed, Oct 8, 2014 at 9:48 AM, David Bellows 
> wrote:
>
>> >Here's a preliminary experiment.  It will add an automatic \ottava 1
>> before passages where notes have at least a specified number of ledger
>> lines.
>>
>>
> The attached function will work with more complex music expressions.
>
> The only problem here is with the handling of chords.  Right now, the
> function either ignores them or attempts to add the ottava within the
> EventChord expression (which causes an error).  This shouldn't be too hard
> to fix, though it will take some thought.
>
> Hope this proves useful!
>
> David
>
>
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Hi David,

On Sat, Oct 11, 2014 at 4:45 PM, David Bellows 
wrote:

> >The attached function will work with more complex music expressions.
>
> Nicely done! I really like the greater flexibility achieved based on using
> ledger lines. Fortunately in this project I don't use chords so that's not
> a problem
>
>
Well, in any case the attached now works with chords :)

The rule is that an ottava is only applied if all of the notes within the
chord have at least a certain number of ledger lines.

I'm thinking there ought to be some sort of resistance-to-change factor
which overrules the strict this-many-ledger-lines-gets-an-ottava rule.
Otherwise, if you hop between chords and single notes, you can get more
ottavas than is comfortable to read.

The code for build-new-elts needs to be refactored a bit.

less fortunately is that I need it for the bassa as well. But I will look
> over the code and see if I can't figure it out for myself.
>

Yes, you could insert an expression into build-new-elts which would look at
the number of ledger lines and insert a (list (makeMusic 'OttavaMusic
'ottava-number -1)) to create the 8va bassa.  Of course, you'd need one to
shut it off with (list (makeMusic 'OttavaMusic 'ottava-number 0)).

This will all be better once this thing has the ability to detect the
current clef.  It looks like that's possible, because calling \clef ...
adds a 'PropertySet event to the mix, and 'clefMiddleCPosition (which the
ledger-line counter is designed to work with) is available.

Detecting the clef would be useful for 8va bassa, because it's never used
with treble clef (as I remember from Gardner Read).

Anyway, hope this is helpful.

--David

P.S.  It's now \ottavate instead of \octavate
\version "2.19.10"

\header {
  tagline = ##f
}

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2


ottavate =
#(define-music-function (parser location threshold mus)
   (integer? ly:music?)
   "Create an ottava for notes which have at least @var{threshold} ledger lines"
   (let ((up-an-octave (list (make-music 'OttavaMusic 'ottava-number 1)))
 (loco (list (make-music 'OttavaMusic 'ottava-number 0
 
 (define (build-new-elts mus-expr new-expr start-loco? start-ottava?)
   (if (null? mus-expr)
   ;; ensure that ottava does not extend past a localized
   ;; use of \octavate
   (append new-expr loco)
  
   (cond
((music-is-of-type? (car mus-expr) 'event-chord)
 (cond
  ((and
start-ottava?
(every (lambda (p)
 (>= (ledger-line-no -6 (ly:music-property p 'pitch)) threshold))
  (ly:music-property (car mus-expr) 'elements)))
   (build-new-elts
(cdr mus-expr)
(append
 new-expr
 up-an-octave
 (list (car mus-expr)))
#t #f))
  ((and 
start-loco?
(any (lambda (p)
   (< (ledger-line-no -6 (ly:music-property p 'pitch)) threshold))
  (ly:music-property (car mus-expr) 'elements)))
   (build-new-elts
(cdr mus-expr)
(append
 new-expr
 loco
 (list (car mus-expr)))
#f #t))
  (else (build-new-elts
 (cdr mus-expr)
 (append new-expr (list (car mus-expr)))
 #t #t

((music-is-of-type? (car mus-expr) 'note-event)
 (let ((p (ly:music-property (car mus-expr) 'pitch)))
   (cond
((and (ly:pitch? p)
  start-ottava?
  (>= (ledger-line-no -6 p) threshold))
 (build-new-elts
  (cdr mus-expr)
  (append
   new-expr
   up-an-octave
   (list (car mus-expr)))
  #t #f))
((and (ly:pitch? p)
  start-loco?
  (< (ledger-line-no -6 p) threshold))
 (build-new-elts
  (cdr mus-expr)
  (append
   new-expr
   loco
   (list (car mus-expr)))
  #f #t))
(else
 

Re: Automatic ottava handling

[David Nalesnik]

On Sat, Oct 11, 2014 at 5:38 PM, David Nalesnik
>
>
> This will all be better once this thing has the ability to detect the
> current clef.  It looks like that's possible, because calling \clef ...
> adds a 'PropertySet event to the mix, and 'clefMiddleCPosition (which the
> ledger-line counter is designed to work with) is available.
>
>
OK, we've got clefs!

I'll look into fixing up build-new-elts so there won't be so much
duplication of code.  Then it will be a lot cleaner to deals with bassas,
I'm too tired to even think about that now.

Best,
David
\version "2.19.10"

\header {
  tagline = ##f
}

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2

#(define (find-clefMiddleCPosition mus)
   (let ((clef-pos -6)) ; treble is default
 (for-some-music
  (lambda (x)
(let ((n (ly:music-property x 'symbol)))
  (and (eq? n 'middleCClefPosition)
   (set! clef-pos (ly:music-property x 'value)
  mus)
 clef-pos))

ottavate =
#(define-music-function (parser location threshold mus)
   (integer? ly:music?)
   "Create an ottava for notes which have at least @var{threshold} ledger lines"
   (let ((up-an-octave (list (make-music 'OttavaMusic 'ottava-number 1)))
 (loco (list (make-music 'OttavaMusic 'ottava-number 0
 
 (define (build-new-elts mus-expr new-expr start-loco? start-ottava? clef-pos)
   (if (null? mus-expr)
   ;; ensure that ottava does not extend past a localized
   ;; use of \ottavate
   (append new-expr loco)
   
   (begin
;; find value for 'clefMiddleCPosition
(if (eq? (ly:music-property (car mus-expr) 'name) 'ContextSpeccedMusic)
(set! clef-pos (find-clefMiddleCPosition (car mus-expr

(cond
 ((music-is-of-type? (car mus-expr) 'event-chord)
  (cond
   ((and
 start-ottava?
 (every (lambda (p)
  (>= (ledger-line-no clef-pos (ly:music-property p 'pitch)) threshold))
   (ly:music-property (car mus-expr) 'elements)))
(build-new-elts
 (cdr mus-expr)
 (append
  new-expr
  up-an-octave
  (list (car mus-expr)))
 #t #f clef-pos))
   ((and 
 start-loco?
 (any (lambda (p)
(< (ledger-line-no clef-pos (ly:music-property p 'pitch)) threshold))
   (ly:music-property (car mus-expr) 'elements)))
(build-new-elts
 (cdr mus-expr)
 (append
  new-expr
  loco
  (list (car mus-expr)))
 #f #t clef-pos))
   (else (build-new-elts
  (cdr mus-expr)
  (append new-expr (list (car mus-expr)))
  #t #t clef-pos

 ((music-is-of-type? (car mus-expr) 'note-event)
  (let ((p (ly:music-property (car mus-expr) 'pitch)))
(cond
 ((and (ly:pitch? p)
   start-ottava?
   (>= (ledger-line-no clef-pos p) threshold))
  (build-new-elts
   (cdr mus-expr)
   (append
new-expr
up-an-octave
(list (car mus-expr)))
   #t #f clef-pos))
 ((and (ly:pitch? p)
   start-loco?
   (< (ledger-line-no clef-pos p) threshold))
  (build-new-elts
   (cdr mus-expr)
   (append
new-expr
loco
(list (car mus-expr)))
   #f #t clef-pos))
 (else
  (build-new-elts
   (cdr mus-expr)
   (append new-expr (list (car mus-expr)))
   #t #t clef-pos)

 (else 
  (build-new-elts
   (cdr mus-expr)
   (append new-expr (list (car mus-expr)))
   #t #t clef-pos))
   
 (define (recurse music)
   (let ((elts (ly:music-property music 'elements))
 (e (ly:music-property music 'element)))
   

Re: Automatic ottava handling

[David Nalesnik]

Hi,

On Sat, Oct 11, 2014 at 9:05 PM, David Nalesnik
>
>
> I'll look into fixing up build-new-elts so there won't be so much
> duplication of code.  Then it will be a lot cleaner to deals with bassas,
>

OK, now it will provide automatic bassas as well.

The function \ottavate now takes two numbers, one for the upper threshold
and another for the lower.  I decided to specify the lower threshold in
negative numbers, but that could be changed.

If you want to turn off one or the other, you can just pick a number out of
range.  (So, for example, you can ensure no bassas with treble clef.)

Let me know how this works for you!

Enjoy,
David
\version "2.19.10"

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2

#(define (find-clefMiddleCPosition mus)
   (let ((clef-pos -6)) ; treble is default
 (for-some-music
  (lambda (x)
(let ((n (ly:music-property x 'symbol)))
  (and (eq? n 'middleCClefPosition)
   (set! clef-pos (ly:music-property x 'value)
  mus)
 clef-pos))

#(define (make-ottava-music arg)
   (list (make-music 'OttavaMusic 'ottava-number arg)))

ottavate =
#(define-music-function (parser location upper lower mus)
   (integer? number? ly:music?)
   "Create an ottava for notes based on number of ledger lines.  Ledger lines above the staff
are specified in @var{upper} as positive integers; an 8va will be created for notes with at least
this many lines.  Ledger lines below the staff are specified in @var{lower} as negative numbers;
an 8va bassa will be created for notes with at least the absolute value of this number.  Choose
an number of ledger lines which does not appear in the music expression to prevent either
from appearing.

All notes in a chord must pass the threshold to receive an ottava."
   (let ((up-an-octave (make-ottava-music 1))
 (down-an-octave (make-ottava-music -1))
 (loco (make-ottava-music 0)))
 
 (define (up-or-down-an-octave clef-pos mus-expr)
   ; select from variables up-an-octave and down-an-octave
   ; return #f if no displacement
   (cond
((music-is-of-type? mus-expr 'event-chord)
 (cond
  ((every (lambda (p)
(>= (ledger-line-no clef-pos (ly:music-property p 'pitch)) upper))
 (ly:music-property mus-expr 'elements))
   up-an-octave)
  ((every (lambda (p)
(<= (ledger-line-no clef-pos (ly:music-property p 'pitch)) lower))
 (ly:music-property mus-expr 'elements))
   down-an-octave)
  (else #f)))
((music-is-of-type? mus-expr 'note-event)
 (cond
  ((>= (ledger-line-no clef-pos
 (ly:music-property mus-expr 'pitch))
   upper)
   up-an-octave)
  ((<= (ledger-line-no clef-pos
 (ly:music-property mus-expr 'pitch))
   lower)
   down-an-octave)
  (else #f)
 
 (define (no-ottava clef-pos mus-expr)
   (not (up-or-down-an-octave clef-pos mus-expr)))
 
 (define (build-new-elts mus-expr new-expr start-loco? start-ottava? clef-pos)
   (if (null? mus-expr)
   ;; ensure that ottava does not extend past a localized
   ;; use of \ottavate
   (append new-expr loco)
   
   (begin
;; find value for 'clefMiddleCPosition
(if (eq? (ly:music-property (car mus-expr) 'name) 'ContextSpeccedMusic)
(set! clef-pos (find-clefMiddleCPosition (car mus-expr

(cond
 ((or (music-is-of-type? (car mus-expr) 'event-chord)
  (music-is-of-type? (car mus-expr) 'note-event))
  (cond
   ((and
 start-ottava?
 (up-or-down-an-octave clef-pos (car mus-expr)))
(build-new-elts
 (cdr mus-expr)
 (append
  new-expr
  (up-or-down-an-octave clef-pos (car mus-expr))
  (list (car mus-expr)))
 #t #f clef-pos))
   ((and 
 start-loco?
 (no-ottava clef-pos (car mus-expr)))
(build-new-elts
 (cdr mus-expr)
 (append
  new-expr
  loco
  (list (car mus-expr)))
 #f #t clef-pos))

Re: Automatic ottava handling

[David Bellows]

That is amazing work! I don't have the time to experiment with it right now
but I will do so tonight and let you know tomorrow the results. But based
on your example this looks like it will be perfect. I think the negative
numbers for the bassa is a good choice as that was what I was imagining in
the first place.

Thanks for all your work on this!

On Sun, Oct 12, 2014 at 12:07 PM, David Nalesnik 
wrote:

> Hi,
>
> On Sat, Oct 11, 2014 at 9:05 PM, David Nalesnik
>>
>>
>> I'll look into fixing up build-new-elts so there won't be so much
>> duplication of code.  Then it will be a lot cleaner to deals with bassas,
>>
>
> OK, now it will provide automatic bassas as well.
>
> The function \ottavate now takes two numbers, one for the upper threshold
> and another for the lower.  I decided to specify the lower threshold in
> negative numbers, but that could be changed.
>
> If you want to turn off one or the other, you can just pick a number out
> of range.  (So, for example, you can ensure no bassas with treble clef.)
>
> Let me know how this works for you!
>
> Enjoy,
> David
>
>
>
>
>
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Janek Warchoł]

Awesome work, David!
I think it would be great to actually have some default ottava
settings in official lilypond (e.g. something like \ottavate #4 #-4).

best,
Janek

2014-10-12 21:07 GMT+02:00 David Nalesnik :
> Hi,
>
> On Sat, Oct 11, 2014 at 9:05 PM, David Nalesnik
>>
>>
>> I'll look into fixing up build-new-elts so there won't be so much
>> duplication of code.  Then it will be a lot cleaner to deals with bassas,
>
>
> OK, now it will provide automatic bassas as well.
>
> The function \ottavate now takes two numbers, one for the upper threshold
> and another for the lower.  I decided to specify the lower threshold in
> negative numbers, but that could be changed.
>
> If you want to turn off one or the other, you can just pick a number out of
> range.  (So, for example, you can ensure no bassas with treble clef.)
>
> Let me know how this works for you!
>
> Enjoy,
> David
>
>
>
>
>
> ___
> lilypond-user mailing list
> lilypond-user@gnu.org
> https://lists.gnu.org/mailman/listinfo/lilypond-user
>

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Hi,

On Mon, Oct 13, 2014 at 1:18 PM, David Bellows 
wrote:

> OK, I've now played around with it and it works very nicely and will be
> easy to integrate into my software. You've already put a lot of work into
> this so I hate to point out any of my peculiar preferences, but just in
> case you feel like putting even more time into it here they are:
>
> 1. Add the 15va/vb marking as well.
>

Done.


> 2. I'm not sure what standard practice is but you'll see in the score that
> my software produces it does not extend the ottava marking over rests. My
> music tends to have a lot of rests (a consequence of how it automatically
> changes staves) so it has a big effect on the overall look.
>

Fixed.

Standard practice is that an ottava should extend across rests if the note
afterwards takes the ottava, too.  If the rest is sufficiently long, the
ottava is broken.

I've incorporated the behavior you like, but I definitely believe that
there should be a choice for the user to extend across rests.  The function
ought to be able to detect whether the ottava can extend: there are rests
of sufficient length and the note after the rest needs the ottava.

Under no circumstances should an ottava end over a rest, like you see on
the version of your piece using \ottavate!



> 3. Change the text. In my score I just use "8" and "15" which given how
> crowded the score gets at times makes a big difference.
>

It turns out that \set Staff.ottavation = #"8" and the like have to be used
after \ottava #1, so I had to work it into the function.

In the future I could add an argument to the \ottavate to allow user
variations--like "8b," for example.  Right now, I hardcoded "8" and "15,"
as in your score.

You select the version--default or short names--with a boolean value--that
is ##t (short), ##f (default).


%%%
USAGE NOTES:

Take the following example:

musOne = \relative c''' {
  \clef treble
  g2 a b c d e f g a b c d e f g a b c d e f g
}

{
  \ottavate #'(4 . 7) #'(-3 . -6) ##t \musOne
}

##t selects the shortened names "8" and "15"

(4 . 7) specifies the range for "8": any note having 4-7 ledger lines
(inclusive) gets an "8."  Anything above this will get "15."

(-3 . -6) specifies the range for "15": here the range is 3-6 ledger
lines.  I like the negative numbers because they are visually more
expressive, though of course, there's no sense to negative numbers of
ledger lines

Chords are assigned ottavas based on the average of the ledger-line count
of their constituent notes.  I'm sure there's a better algorithm.  If
you're more mathematically able than me, please feel free to suggest
something a bit more elegant :)

In the future, there ought to be some analysis of groups of notes.  So, for
example, an out-of-range note within a group of notes receiving an ottava
doesn't break the line.  But I'd like to make sure what I have now works
before I start enhancing it.


> Thanks again for the work you've put into this!
>

You're very welcome.

--David
\version "2.19.10"

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2

#(define (find-clefMiddleCPosition mus)
   (let ((clef-pos -6)) ; treble is default
 (for-some-music
  (lambda (x)
(let ((n (ly:music-property x 'symbol)))
  (and (eq? n 'middleCClefPosition)
   (set! clef-pos (ly:music-property x 'value)
  mus)
 clef-pos))

#(define (make-ottava-music arg)
   (list (make-music 'OttavaMusic 'ottava-number arg)))

ottavate =
#(define-music-function (parser location upper lower short-name? mus)
   (number-pair? number-pair? boolean? ly:music?)
   "Create ottavas for music based on numbers of ledger lines.  Both @var{upper}
and @var{lower} are pairs specifying a range of ledger lines: @var{upper}
determines @code{8va} and @code{15ma}, and @var{lower} determines @var{8vb} and
@var{15mb}.  Within this range (inclusive), an @code{8va} or @code{8ba} will
be created.  Notes with numbers of ledger lines exceeding these ranges will be
assigned @code{15ma} or @code{15mb}.

Numbers of ledger lines above the staff are specified in @var{upper} as
positive integers, while ledger lines below the staff are specified in @var{lower}
as negative numbers.

The numbers of ledger lines within chords are averaged.

The strings used for ottavas are selected by @var{short-name?}, which accepts
a boolean.  A setting of @code{#f} chooses the default strings, while @code{#t}

Re: Automatic ottava handling

[David Nalesnik]

On Mon, Oct 13, 2014 at 3:01 PM, Janek Warchoł 
wrote:

> Awesome work, David!
>

Thanks!


> I think it would be great to actually have some default ottava
> settings in official lilypond (e.g. something like \ottavate #4 #-4).
>
>
I think so too, but I'd like for the function to be more intelligent first
:)

--David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Bellows]

Wow! It works perfectly! I am officially replacing my software method with
your Lilypond approach. Not only does it do everything I wanted but it has
better fined-grained control since it uses ledger lines and not octave
markings (like mine does). And it's got to be more efficient than mine (I
had to create two separate loops outside the main Lilypond generating loop
to handle both the treble and the bass). It's a superior solution all the
way around.

I've attached the same Lilypond file that I used yesterday and you can see
that it handles everything just like I wanted. Amazing!

Thank you very much!

On Mon, Oct 13, 2014 at 6:47 PM, David Nalesnik 
wrote:

> Hi,
>
> On Mon, Oct 13, 2014 at 1:18 PM, David Bellows 
> wrote:
>
>> OK, I've now played around with it and it works very nicely and will be
>> easy to integrate into my software. You've already put a lot of work into
>> this so I hate to point out any of my peculiar preferences, but just in
>> case you feel like putting even more time into it here they are:
>>
>> 1. Add the 15va/vb marking as well.
>>
>
> Done.
>
>
>> 2. I'm not sure what standard practice is but you'll see in the score
>> that my software produces it does not extend the ottava marking over rests.
>> My music tends to have a lot of rests (a consequence of how it
>> automatically changes staves) so it has a big effect on the overall look.
>>
>
> Fixed.
>
> Standard practice is that an ottava should extend across rests if the note
> afterwards takes the ottava, too.  If the rest is sufficiently long, the
> ottava is broken.
>
> I've incorporated the behavior you like, but I definitely believe that
> there should be a choice for the user to extend across rests.  The function
> ought to be able to detect whether the ottava can extend: there are rests
> of sufficient length and the note after the rest needs the ottava.
>
> Under no circumstances should an ottava end over a rest, like you see on
> the version of your piece using \ottavate!
>
>
>
>> 3. Change the text. In my score I just use "8" and "15" which given how
>> crowded the score gets at times makes a big difference.
>>
>
> It turns out that \set Staff.ottavation = #"8" and the like have to be
> used after \ottava #1, so I had to work it into the function.
>
> In the future I could add an argument to the \ottavate to allow user
> variations--like "8b," for example.  Right now, I hardcoded "8" and "15,"
> as in your score.
>
> You select the version--default or short names--with a boolean value--that
> is ##t (short), ##f (default).
>
>
> %%%
> USAGE NOTES:
>
> Take the following example:
>
> musOne = \relative c''' {
>   \clef treble
>   g2 a b c d e f g a b c d e f g a b c d e f g
> }
>
> {
>   \ottavate #'(4 . 7) #'(-3 . -6) ##t \musOne
> }
>
> ##t selects the shortened names "8" and "15"
>
> (4 . 7) specifies the range for "8": any note having 4-7 ledger lines
> (inclusive) gets an "8."  Anything above this will get "15."
>
> (-3 . -6) specifies the range for "15": here the range is 3-6 ledger
> lines.  I like the negative numbers because they are visually more
> expressive, though of course, there's no sense to negative numbers of
> ledger lines
>
> Chords are assigned ottavas based on the average of the ledger-line count
> of their constituent notes.  I'm sure there's a better algorithm.  If
> you're more mathematically able than me, please feel free to suggest
> something a bit more elegant :)
>
> In the future, there ought to be some analysis of groups of notes.  So,
> for example, an out-of-range note within a group of notes receiving an
> ottava doesn't break the line.  But I'd like to make sure what I have now
> works before I start enhancing it.
>
>
>> Thanks again for the work you've put into this!
>>
>
> You're very welcome.
>
> --David
>


Piano_Standard.pdf
Description: Adobe PDF document
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

On Tue, Oct 14, 2014 at 1:57 AM, Janek Warchoł
>
>
> What i find most fascinating about your work is that you say this
> after already making the function quite intelligent :)
>

I appreciate that, but I'd like to have some sort of analysis of context,
so you wouldn't end up shutting it off for inconvenient results.

For example, compare the results of this:

{
  \ottavate #'(4 . 7) #'(-3 . -6) ##t {
\relative c {
  c16 c, c' c c c, c' c
}
  }
}

with the much more readable:

{
  \relative c {
  \ottava #1 c16 c, c' c c c, c' c
}
}

But maybe this is an enhancement which could come later?

BTW, I've verified that you can do overrides of individual brackets.  You
just don't have the benefit of \ottava #1 and the like in the ly file to
tell you where to put them.

--David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

David,

On Tue, Oct 14, 2014 at 10:53 AM, David Bellows 
wrote:

> Wow! It works perfectly! I am officially replacing my software method with
> your Lilypond approach. Not only does it do everything I wanted but it has
> better fined-grained control since it uses ledger lines and not octave
> markings (like mine does). And it's got to be more efficient than mine (I
> had to create two separate loops outside the main Lilypond generating loop
> to handle both the treble and the bass). It's a superior solution all the
> way around.
>
> I've attached the same Lilypond file that I used yesterday and you can see
> that it handles everything just like I wanted. Amazing!
>
> Thank you very much!
>
You're very welcome!  I'm glad to hear that it is working without a hitch.

I'll continue to look at this, and make what improvements I can.

If you run into any problems, please let me know.

All the best,
David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Kieren MacMillan]

Hi David,

> But maybe this is an enhancement which could come later?

I was going to chime in a lot earlier in this thread, with a suggestion for a 
“minimum in/out” parameter… but I thought better of it, since you were pushing 
ahead with improvements so quickly.  =)
Clearly, such an enhancement would make this just about the perfect ottavator.
Great work.

Best,
Kieren.

___

Kieren MacMillan, composer
www:  
email:  i...@kierenmacmillan.info


___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Gilberto Agostinho]

Hi David, this is a really wonderful job, thank you so much for sharing it! I
am adding your function to every score of mine right now :)


David Nalesnik-2 wrote
> Standard practice is that an ottava should extend across rests if the note
> afterwards takes the ottava, too.  If the rest is sufficiently long, the
> ottava is broken.

About this comment above, would it be possible to implement another variable
in your function which would take care of the maximal rest value between two
consecutive ottaved notes? This way, some users can just set it to 0 to
avoid any ottavation above rests, while others can set it to their own
personal values to generate a more traditionally looking score. What do you
think about this, how difficult would it be to implement this? 

Thanks a lot and take care,
Gilberto



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167744.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Hi Gilberto,

On Tue, Oct 21, 2014 at 3:23 AM, Gilberto Agostinho <
gilbertohasn...@gmail.com> wrote:

> Hi David, this is a really wonderful job, thank you so much for sharing
> it! I
> am adding your function to every score of mine right now :)
>
>
> David Nalesnik-2 wrote
> > Standard practice is that an ottava should extend across rests if the
> note
> > afterwards takes the ottava, too.  If the rest is sufficiently long, the
> > ottava is broken.
>
> About this comment above, would it be possible to implement another
> variable
> in your function which would take care of the maximal rest value between
> two
> consecutive ottaved notes? This way, some users can just set it to 0 to
> avoid any ottavation above rests, while others can set it to their own
> personal values to generate a more traditionally looking score. What do you
> think about this, how difficult would it be to implement this?
>
> Thanks a lot and take care,
> Gilberto
>

Yes, the function needs some way to collect pitches and rests in order to
do various calculations.  Then it could do as you say.  Also, it could
examine groups of notes for outliers which shouldn't break the ottava for
readability purposes.  (There's an example of that somewhere earlier in the
thread.)

I've been working on making sure what I have now produces the same
expressions as a score with manual ottavas does before I venture into
enhancing it.  I hit a problem with << >> (SimultaneousMusic), but I have
your request in mind   I do realize that these "enhancements" make the
difference between usability and "thanks, nice toy" :)

Best,
David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Gilberto Agostinho]

Hi David,


David Nalesnik-2 wrote
> I do realize that these "enhancements" make the
> difference between usability and "thanks, nice toy" :)

That may be true on a practical level, but I am truly thankful for your
efforts. I do know a bit of programming myself, but LISP and its dialects
are absolutely beyond me - it is one of those languages that still look
completely inaccessible to me, which is a pity since I'd really love to help
by coding. 


David Nalesnik-2 wrote
> I've been working on making sure what I have now produces the same
> expressions as a score with manual ottavas does before I venture into
> enhancing it.  I hit a problem with << >> (SimultaneousMusic), but I have
> your request in mind

This is indeed tricky, I didn't think about this situation before. Here is
an example /without/ any rhythmical complexities (with those, things can
turn into nightmares very quickly, since ottavation affects the whole
staff...):

<http://lilypond.1069038.n5.nabble.com/file/n167757/53.png> 

(this example above is a bit exaggerated, but think of instruments that have
a nice range and are traditionally notated in one single staff, such as a
xylophone).

If I may suggest something, what about simply ignoring places where two or
more voices occur and outputting an error message to the user telling the
lines that are problematic? This way, one can find the problem and solve it
by:

\ottavation #'(4 . 7) #'(-4 . -7) { \musicPartA }
\musicPartB
\ottavation #'(4 . 7) #'(-4 . -7) { \musicPartC }

where \musicPartB would be the passage that needs manual tweaking.

I think a lot of these decisions are easy to take by a human but very
difficult to generalize (I have been myself working on a code (not in Scheme
;) ) to decide between flat and sharp accidentals in atonal music, but there
are situation that makes the computer go nuts (or makes the code
increasingly complex and long), where a human can spot right away what is
the best solution, or the least worse alternative).

Best,
Gilberto



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167757.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

On Tue, Oct 21, 2014 at 8:34 AM, Gilberto Agostinho <
gilbertohasn...@gmail.com> wrote:

> Hi David,
>
>
> David Nalesnik-2 wrote
> > I do realize that these "enhancements" make the
> > difference between usability and "thanks, nice toy" :)
>
> That may be true on a practical level, but I am truly thankful for your
> efforts. I do know a bit of programming myself, but LISP and its dialects
> are absolutely beyond me - it is one of those languages that still look
> completely inaccessible to me, which is a pity since I'd really love to
> help
> by coding.
>
>
> David Nalesnik-2 wrote
> > I've been working on making sure what I have now produces the same
> > expressions as a score with manual ottavas does before I venture into
> > enhancing it.  I hit a problem with << >> (SimultaneousMusic), but I have
> > your request in mind
>
> This is indeed tricky, I didn't think about this situation before. Here is
> an example /without/ any rhythmical complexities (with those, things can
> turn into nightmares very quickly, since ottavation affects the whole
> staff...):
>
> 
>
> (this example above is a bit exaggerated, but think of instruments that
> have
> a nice range and are traditionally notated in one single staff, such as a
> xylophone).
>
> If I may suggest something, what about simply ignoring places where two or
> more voices occur and outputting an error message to the user telling the
> lines that are problematic? This way, one can find the problem and solve it
> by:
>
> \ottavation #'(4 . 7) #'(-4 . -7) { \musicPartA }
> \musicPartB
> \ottavation #'(4 . 7) #'(-4 . -7) { \musicPartC }
>
> where \musicPartB would be the passage that needs manual tweaking.
>

I had pretty much decided not to try to make any rational decisions with
examples like you post!  What you say about an error message (or simply a
warning) is a good idea.  I'm not going to venture into automating the
process described in the manual for having an ottava apply to one voice,
but not the other.  (See the snippet at
http://lilypond.org/doc/v2.18/Documentation/notation/displaying-pitches#index-ottava-2).
No way.

My issue at this point is adding the ottava before the SequentialMusic
expression, rather than inside it: for example, creating \ottava #1 << ...
>>, based on the contents of << >>.  Instead the routine puts the ottavas
where "needed" inside the expression.

Maybe best would be to throw a warning and completely ignore the << >>
passage.  Certainly easier from my standpoint!


You're right that you can turn it off and on wherever you want.  But there
is one big issue--which I will not be able to solve.  There is no access to
context properties from within a music function.  So determining the clef
relies on its explicit creation within the music expression that \ottavate
considers.  Otherwise, it can only assume treble clef.

So you will run into some oddness when you turn it on within a passage
where, say, bass clef is already in force--namely, the function will use
treble clef to calculate the number of ledger lines for notes.  But there's
no help for that, unless there's an argument for
opening-clef-if-different-than-treble, but that's getting perverse :)

(The number of ledger lines a note gets has not been determined yet, hence
the casting around for a clef to do our own calculations.)


>
> I think a lot of these decisions are easy to take by a human but very
> difficult to generalize (I have been myself working on a code (not in
> Scheme
> ;) ) to decide between flat and sharp accidentals in atonal music, but
> there
> are situation that makes the computer go nuts (or makes the code
> increasingly complex and long), where a human can spot right away what is
> the best solution, or the least worse alternative).


All I can say is: yup.

--David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Gilberto Agostinho]

Hi David,


David Nalesnik-2 wrote
> I'm not going to venture into automating the process described in the
> manual for having an ottava apply to one voice, but not the other.

That would be indeed painful to implement... this is exactly the type of
notation that a human can spot as "okay" in some cases, even though it
breaks some conventions for a brief moment. Nevertheless, this is quite a
rare case - and I still would avoid using it at all, I'd rather create a new
stave if necessary, which is a more contemporary approach to these types of
passages.


David Nalesnik-2 wrote
> Maybe best would be to throw a warning and completely ignore the << >>
> passage.  Certainly easier from my standpoint!

I guess this would be a very fair solution. Your function already handles
chords (it always considers the bottom note for treble clef and the top note
for bass clef, am I right?), which is wonderful. If someone is dealing with
more complex polyphony, then better do it manually.


David Nalesnik-2 wrote
> There is no access to context properties from within a music function.  So
> determining the clef relies on its explicit creation within the music
> expression that \ottavate considers.  Otherwise, it can only assume treble
> clef.

What about adding a optional variable to set the clef? So if the music
starts with a different clef, the user would have to explicitely have to
inform this.

And here is a minor thing I just spotted: there is also a small
inconsistense with the negative values in your function. Try this:

{
  \ottavate #'(4 . 7) #'(-4 . -7) ##f { f''' g''' \clef bass g,, e,,}
}

So up to (inclusive) 4 ledger lines above the treble cleff is displayed
without ottavation, but only notes with less (not inclusive) than 4 ledger
lines are displayed without ottava bassa in the bass clef. 

Best,
Gilberto



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167762.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

On Tue, Oct 21, 2014 at 12:03 PM, David Nalesnik 
wrote:

>
>
> Well, I could.  The only thing is that number of optional variables is
> limited.  I suppose there could be an argument which takes an alist of
> symbols and settings: '((starting-clef . bass) (short-names . #t)
> (stop-at-rests . #t) ...).  If a pair isn't present, a default is taken.
> My goal was simplicity, though :(
>

I should say my "goal" was that automatic ottavas would be a simple,
uncomplicated thing to achieve.  And of course wishing makes it so.

The alist idea seems like a great alternative to a long list of arguments
you have to look up every time you use the command.

--David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

On Tue, Oct 21, 2014 at 9:35 AM, Gilberto Agostinho <
gilbertohasn...@gmail.com> wrote:

> Hi David,
>
>
> David Nalesnik-2 wrote
> > I'm not going to venture into automating the process described in the
> > manual for having an ottava apply to one voice, but not the other.
>
> That would be indeed painful to implement... this is exactly the type of
> notation that a human can spot as "okay" in some cases, even though it
> breaks some conventions for a brief moment. Nevertheless, this is quite a
> rare case - and I still would avoid using it at all, I'd rather create a
> new
> stave if necessary, which is a more contemporary approach to these types of
> passages.
>
>
> David Nalesnik-2 wrote
> > Maybe best would be to throw a warning and completely ignore the << >>
> > passage.  Certainly easier from my standpoint!
>
> I guess this would be a very fair solution. Your function already handles
> chords (it always considers the bottom note for treble clef and the top
> note
> for bass clef, am I right?), which is wonderful. If someone is dealing with
> more complex polyphony, then better do it manually.
>

Actually, no, it averages the ledger lines of the chord members.  If the
average is above the threshold, we get an ottava.  I'm welcome to better
algorithms!  (It would be easy enough to implement what you describe.)


>
>
> David Nalesnik-2 wrote
> > There is no access to context properties from within a music function.
> So
> > determining the clef relies on its explicit creation within the music
> > expression that \ottavate considers.  Otherwise, it can only assume
> treble
> > clef.
>
> What about adding a optional variable to set the clef? So if the music
> starts with a different clef, the user would have to explicitely have to
> inform this.
>

Well, I could.  The only thing is that number of optional variables is
limited.  I suppose there could be an argument which takes an alist of
symbols and settings: '((starting-clef . bass) (short-names . #t)
(stop-at-rests . #t) ...).  If a pair isn't present, a default is taken.
My goal was simplicity, though :(

>
> And here is a minor thing I just spotted: there is also a small
> inconsistense with the negative values in your function. Try this:
>
> {
>   \ottavate #'(4 . 7) #'(-4 . -7) ##f { f''' g''' \clef bass g,, e,,}
> }
>
> So up to (inclusive) 4 ledger lines above the treble cleff is displayed
> without ottavation, but only notes with less (not inclusive) than 4 ledger
> lines are displayed without ottava bassa in the bass clef.
>

I don't see the problem you've describe.  The attached shows the snippet
without and with \ottavate, with short names for clarity.  The notes
affected by the ottavas both have four ledger lines.

Best,
David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Gilberto Agostinho]

Hi David,


David Nalesnik-2 wrote
> Actually, no, it averages the ledger lines of the chord members.  If the
> average is above the threshold, we get an ottava.  I'm welcome to better
> algorithms!  (It would be easy enough to implement what you describe.)

I believe that considering the lowest note of a chord for ottava and the
highest note for ottava bassa would be better. This way you'd get more
consistent results (think of some extreme cases like with a xylophone), but
this is obviously up to you. The way it is now also works fine during most
of the cases, but it may come across lacking consistency for someone viewing
the score.


David Nalesnik-2 wrote
> I don't see the problem you've describe.  The attached shows the snippet
> without and with \ottavate, with short names for clarity.

Me neither! I believe I miscounted the ledger lines, or I used your default
settings #'(4 . 7) #'(-3 . -6) instead of #'(4 . 7) #'(-4 . -7) and got
confused. I spent way too much time with LilyPond and Pure Data today, so
forgive my lack of sense sometimes.


David Nalesnik-2 wrote
> I should say my "goal" was that automatic ottavas would be a simple,
> uncomplicated thing to achieve.  And of course wishing makes it so.
> The alist idea seems like a great alternative to a long list of arguments
> you have to look up every time you use the command.

This alist idea seems very interesting indeed. I am really looking forward
to v3.0 of your function!

Thanks once again for your effort, and take care,
Gilberto



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167775.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Hi Gilberto,

On Tue, Oct 21, 2014 at 4:43 PM, Gilberto Agostinho <
gilbertohasn...@gmail.com> wrote:

> Hi David,
>
>
> David Nalesnik-2 wrote
> > Actually, no, it averages the ledger lines of the chord members.  If the
> > average is above the threshold, we get an ottava.  I'm welcome to better
> > algorithms!  (It would be easy enough to implement what you describe.)
>
> I believe that considering the lowest note of a chord for ottava and the
> highest note for ottava bassa would be better. This way you'd get more
> consistent results (think of some extreme cases like with a xylophone), but
> this is obviously up to you. The way it is now also works fine during most
> of the cases, but it may come across lacking consistency for someone
> viewing
> the score.
>
>
Ok, that's what this version now does.  See what you think.


>
> David Nalesnik-2 wrote
> > I don't see the problem you've describe.  The attached shows the snippet
> > without and with \ottavate, with short names for clarity.
>
> Me neither! I believe I miscounted the ledger lines, or I used your default
> settings #'(4 . 7) #'(-3 . -6) instead of #'(4 . 7) #'(-4 . -7) and got
> confused. I spent way too much time with LilyPond and Pure Data today, so
> forgive my lack of sense sometimes.
>

No problem!


>
>
> David Nalesnik-2 wrote
> > I should say my "goal" was that automatic ottavas would be a simple,
> > uncomplicated thing to achieve.  And of course wishing makes it so.
> > The alist idea seems like a great alternative to a long list of arguments
> > you have to look up every time you use the command.
>
> This alist idea seems very interesting indeed. I am really looking forward
> to v3.0 of your function!
>
>
This version incorporates the alist idea.  The boolean for short
names/default is gone, replaced by the key/value pair (name-style .
short).  The value can be long, or default (and you could easily add your
own to the definition of naming-options).

I made provision for the clef issue we talked about above.

So, the way to call the function is
\ottavate #'(4 . 7) #'(-4 . -7) #'((name-style . short) (opening-clef .
bass)) { ... }

If you leave any elements out of the alist, the default will be chosen.  So

 \ottavate #'(4 . 7) #'(-4 . -7) #'((name-style . long)) { ... }

will result in the treble clef default for opening clef (which is generally
what you want).

The alist argument needs to be there.  I don't believe you can have an
optional parameter except at the tail end of the music function, but I'll
need to verify that. (And you definitely don't want the variable coming
after the music expression)

But you can write:
\ottavate #'(4 . 7) #'(-4 . -7) #'() { ... }

and select all the defaults.

There will be room for more selectors once I figure something out about
context (the rest issue you mentioned, for one).

Thanks once again for your effort, and take care,
> Gilberto
>

You're welcome.  Thanks for the input!

Best,
David
\version "2.19.15"

#(define (ledger-line-no middle-C-pos p)
   "Returns the number of ledger-lines a pitch @var{p} will have with
middle C position @var{middle-C-pos} expressed as staff-steps from the
middle staff line."
   (let* ((ps (ly:pitch-steps p))
  (mid-staff-steps (- middle-C-pos))
  (top-line (+ mid-staff-steps 4))
  (bottom-line (- mid-staff-steps 4))
  (above? (> ps top-line))
  (below? (< ps bottom-line))
  (steps-outside-staff
   (cond
(below? (- ps bottom-line))
(above? (- ps top-line))
(else 0
 (truncate (/ steps-outside-staff 2

#(define (find-clefMiddleCPosition mus)
   (let ((clef-pos -6)) ; treble is default
 (for-some-music
  (lambda (x)
(let ((n (ly:music-property x 'symbol)))
  (and (eq? n 'middleCClefPosition)
   (set! clef-pos (ly:music-property x 'value)
  mus)
 clef-pos))

#(define clefs
   ; An alist of (clef . position of middle C) pairs.  Center line of staff = 0.
   ; For use when \ottavate is called on a music expression which begins with a
   ; clef other than treble, which has been set before that expression.
   '((treble . -6)
 (treble_8 . 1)
 (bass . 6)
 (bass_8 . 13)
 (alto . 0)
 (tenor . 2)))

#(define (make-ottava-music arg)
   (list (make-music
  'OttavaMusic
  'ottava-number arg)))

#(define (select-ottava-music str)
   (let ((options
  '(("up-an-octave" . 1)
("down-an-octave" . -1)
("up-two-octaves" . 2)
("down-two-octaves" . -2)
("loco" . 0
 (make-ottava-music (assoc-get str options

#(define naming-options
   '((short . (("up-an-octave" . "8")
   ("down-an-octave" . "8")
   ("up-two-octaves" . "15")
   ("down-two-octaves" . "15")
   ("loco" . #f)))
 (long . (("up-an-octave" . "8va")
  ("down-an-octave" . "8va bassa")
  ("up-two-octav

Re: Automatic ottava handling

[Gilberto Agostinho]

Hi David,

This new version is really excellent! I think it handles chords wonderfully
well, and I also like the alist idea very much!


David Nalesnik-2 wrote
> The alist argument needs to be there.  I don't believe you can have an
> optional parameter except at the tail end of the music function, but I'll
> need to verify that. (And you definitely don't want the variable coming
> after the music expression)

That's indeed a pity, I often forget that the music expression itself is
considered as a variable in these functions, so you really can't have an
optional argument in between. But the empty alist is not a bad solution at
all, I think, and it is wonderful to have the possibility to deal with bass
clefs and short/long ottavation names.

As for that idea of handling rests, how difficult would it be to implement
it as another variable inside of this alist? So the user would inform how
many quarter note rests (or some other time unit) in between two "ottaved"
notes would be necessary in order to break the ottavation. I don't know how
tricky this can be (I have no clue how difficult it would be to deal with
the number of quarter notes/beats/time units/bars between notes in
LilyPond). 

Thanks once again and take care!
Gilberto



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167790.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[David Nalesnik]

Gilberto,

On Wed, Oct 22, 2014 at 4:39 AM, Gilberto Agostinho <
gilbertohasn...@gmail.com> wrote:

> Hi David,
>
> This new version is really excellent! I think it handles chords wonderfully
> well, and I also like the alist idea very much!
>

Great--good to hear!


>
>
> David Nalesnik-2 wrote
> > The alist argument needs to be there.  I don't believe you can have an
> > optional parameter except at the tail end of the music function, but I'll
> > need to verify that. (And you definitely don't want the variable coming
> > after the music expression)
>
> That's indeed a pity, I often forget that the music expression itself is
> considered as a variable in these functions, so you really can't have an
> optional argument in between. But the empty alist is not a bad solution at
> all, I think, and it is wonderful to have the possibility to deal with bass
> clefs and short/long ottavation names.
>

This is indeed my mistake.  There is no such requirement for optional
parameters.
To make the parameter for the alist-variable optional, you need only make a
simple change to the list of predicates in the definition of ottavate:

ottavate =
#(define-music-function (parser location upper lower options mus)
   (number-pair? number-pair? (list? '()) ly:music?)

Then, you are able to write

{
  \ottavate #'(3 . 6) #'(-3 . -6) { ... }
}

or, if you like

{
  \ottavate #'(3 . 6) #'(-3 . -6) \default { ... }
}

and the function will use the default values for "options"--here, the empty
list '(), which will select the default values for all of the various
symbols--well, the two that are provided now: opening-clef and name-style.


> As for that idea of handling rests, how difficult would it be to implement
> it as another variable inside of this alist? So the user would inform how
> many quarter note rests (or some other time unit) in between two "ottaved"
> notes would be necessary in order to break the ottavation. I don't know how
> tricky this can be (I have no clue how difficult it would be to deal with
> the number of quarter notes/beats/time units/bars between notes in
> LilyPond).
>

I can add any number of symbols to the alist, and one representing length
of rests.  But this (and any smart analysis of pitch groupings) requires
collecting them, which is the big stumbling block for me at the moment.
Well, I should say it is probably going to require a big rewrite.  I'll
keep you posted.

Best,
David
___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user

Re: Automatic ottava handling

[Gilberto Agostinho]

Hi David,


David Nalesnik-2 wrote
> To make the parameter for the alist-variable optional, you need only make
> a
> simple change to the list of predicates in the definition of ottavate

This is great! I now works perfectly only with two pair of numbers, i.e.,
without #'()


David Nalesnik-2 wrote
> I can add any number of symbols to the alist, and one representing length
> of rests.  But this (and any smart analysis of pitch groupings) requires
> collecting them, which is the big stumbling block for me at the moment.
> Well, I should say it is probably going to require a big rewrite.  I'll
> keep you posted.

I totally understand it. It is very easy to say "value of rests between two
pitches", but calculating it would be a completely different story. If one
day you tackle this problem, please give us all an update on this thread (or
on a new one). But I can't emphasize this enough: your function is extremely
useful as it is right now!

Take care and thanks again for all of your efforts,
Gilberto



--
View this message in context: 
http://lilypond.1069038.n5.nabble.com/Automatic-ottava-handling-tp167190p167807.html
Sent from the User mailing list archive at Nabble.com.

___
lilypond-user mailing list
lilypond-user@gnu.org
https://lists.gnu.org/mailman/listinfo/lilypond-user