JulioHerrlein

dear all
 
here's an example (from my current work)...
 
this little video shows how i generate/display SCORE (instrumental parts) on a screen + virtual conductor (piano part). the example is "nonsense", but shows how it looks/works... you see the bars (generating), the cue, beat... and the arrow (that shows you where to read/play) ...also you hear some bad (sry) sound-simulation of the setup.
 
in this way i can generate a whole piece in realtime on STAGE (all musicians will read their part from their own screen). this one will be for 5 instruments, ePlayer and modular synthesizer. during the performance an algorithm (or some data-streams) will generate the piece in OPMO. with OSC i can send all datas (score, beat, tempo..)  from OPMO to POLYTEMPO-NETWORK  (https://polytempo.zhdk.ch) and work and coordinate different independent tempo layers, conducting etc...
 
for more POLYTEMPO informations... have a look here: https://polytempo.zhdk.ch
 
greetings
andré
 
IMG_0083.MOV
 

Hi folks,
 
Here's the files from this session showing my process for a work in progress " Extrapolation" for Pierrot Ensemble.
You will find also exceptionally the video recording.
 
All this material is shared here for study purpose naturally, please, don't use it "as this" but use this material as an example to inspire yourself and help you to construct your own workflow and algorithms.
 
All the best and happy Opusmodus-ing
 
Stéphane
 
Part1-Basic-idea.opmo Part2-Main-Process.opmo Part3-Looping-Process.opmo Part4-ScoreOutput.opmo pitch-rotate-vary-segment.lisp Stephane-Video-ZoomOM2609-20.zip

Thanks a lot, Stephane ! Great, as usual !
Best !
Julio

Hi,
 
sorry for this interruption by "pirates"...
 
here's the file used for this session showing some possible ways to connect pitch/intervals to lengths.
 
All the best !
 
Stéphane
 
Zoom19-9-2020.opmo

I will add this option to the function with the next update.

Maybe your Instrument (virtual instruments) is setup to C5 (centre).

Check the sound-set name of the articulation and the program.

Next session 'Zoom into Opusmodus' is on.
Best wishes,
Janusz

2.1.26015
 
– New:
SCALE-NUMBERS

– Changes and Additions (check the documentation for each of the functions below):

GEN-CHORD-SERIES
GEN-COLLECT – tuplet grouping.
GEN-FRAGMENT – tuplet grouping.
GEN-INTERLEAVE – tuplet grouping.
GEN-MORPH – tuplet grouping.
CHORD-INVERSION – extended functionality.
DECHORD
PS – preserve pitch names (composers intend).
COUNTERPOINT – dictum addition: :tempo and :harmony, new voice symbol * (Pedal Point).
DICTUM-TEMPO

– Fixes:
Tempo :length - tempo mark in the middle of a measure.
TIE-BARS – with argument :section and :exclude.
and same minor once.
 
– Documentation:
New score examples in Howto Utilities.
 
– Note:
The Check for Updates... should work and recognise your macOS system and install the correct update for your system.
Please let me know if it works. If dose not work for you please download the update from the Forums Downloads page.
Possibly the download here is safer. 🚦

Best wishes,
Janusz

P.S. Later this week I will make an Announcement on Howto to setup and use Supercollider in Opusmodus.

Amazing, Stephane !
 

Hi,
 
here's a new score made with Opusmodus and Sibelius.

 
SB.

The functions ps and def-instrument-set allow some control over the resulting layout of the score (grouping of instruments by brackets etc.), e.g., by using some predefined ensemble "instruments" like :sq for string quartet.
 
Is it perhaps also possible to somehow set the layout options supported by def-score in this context? For example, would it be possible to specify the music for the left and right hand of a piano separately (i.e. not together in a triple-nested list), but then have both parts notated on a grand staff? Here is an example (not working) -- amended from the ps documentation. How can I define an instrument set such that this score would wrap the two parts below in a grand staff?
 
(ps 'my-instrument-set :rh '(((s a4 leg d5 leg fs4 leg d5 leg g4 leg d5) (s a4 leg d5 leg fs4 leg d5 leg g4 leg d5) (s a4 leg d5 leg cs5 leg b4 leg a4 leg g4 leg) (s fs4 leg d4 leg e4 leg cs4 leg e d4))) :lh '(((e fs3 d3 e3) (e fs3 d3 e3) (e fs3 g3 a3) (e d3 a2 d2)))) Another example would be the four strings of a string quartet specified separately etc. 
 
I know of course that I could include both parts in a triple nested list for the instrument :p with the gm instrument set, or the strings with the instrument :sq (as demonstrated in the ps documentation). However if possible, I would prefer to specify the left and hand right hand (upper and lower stave) separately, e.g., because I am further processing partial polyphonic scores before they are given to ps (e.g., appending multiple partial scores into a larger score), and for this processing it would help me to know which part is which by its keyword label. 
 
Thanks! 

Just use single instruments or clef's names.
As for :rh, :lh (specifically) I could add this to the layout system.

Thanks! Yes, as I said I know that I can write the following, where rh and lh etc. are standard single-nested OMN sequences. 
(ps 'my-instrument-set :p (list rh lh)) (ps 'gm :sq (list vl1 vl2 va vc))  
Perhaps I just need to define some custom function that automatically translates my preferred representation -- where all parts (including rh and lh) are represented individually for simplifying further processing -- into the representation above 🙂 

Just for context: my function preview-score (link to doc) in the tot library -- which was perhaps the inspiration for the later function ps -- expands in the background simply into a call to def-score. In def-score, we can specify a layout of nested brackets, braces etc. separately of the actual music, which is expressed by individual single-nested OMN sequences. The function preview-score retained this separation: individual single-nested OMN sequences on the one hand, and the specification of the nested layout separately. 
 
By contrast, in the function ps this separation of concerns -- the actual music and the nested layout -- is seemingly gone. The input to ps seemingly must already be nested as required by the layout. That may be more convenient in some situations, but is limiting in others. For example, in a full orchestral score we can have a layout of multiple nesting levels (e.g., brackets for orchestral sections wrapped in "squares" for divisions or the standard combination of the violins in a string section, below is an example). 
(bracket-group (square-group (violin1-layout 'vl1) (violin2-layout 'vl2)) (viola-layout 'va) (violoncello-layout 'vc) (contrabass-layout 'cb)) Can the function ps handle such nested layouts, or is it only designed for sketches and a full score should be created separately afterwards? In principle, it would be possible with shorthand functions like ps to allow for arbitrary layouts when it expands to def-score in the background (again, as demonstrated by preview-score), but keeping the actual music and the layout separately would likely then be preferable. 
 
... I am just trying to make a switch from preview-score to ps to unify efforts, but I don't want to loose too much functionality 😊
 
I will soon share a version of ps that supports the tot score format (https://tanders.github.io/tot/sources/score.html) so that we can have ps together with various score processing functions.  
 

I provided a variant for unfold that has some advantages (support for arbitrary function arguments instead of a custom symbol for each argument combination set up with def-unfold-set), but I did not say that it would replace it 🙂  In addition to what you said, the unfold function is also baked into your counterpoint function, while this alternative is not. 
 
> apply the the unfold method to a specific bar
 
Sure. That also works with this variant, as shown above by using the argument section supported by most OPMO functions.  
 
(fn-unfold '((tr 12) (ld (2 3) :section 1)) mat)
 
> even to an event
 
Yes, that is something currently not supported by the alternative fn-unfold (except individual functions would support it). As you can see, the definition of fn-unfold is pretty short, more stuff could be added, if we want to. 
 
> Why so may users do not read/examine the function documentation.
 
Actually, I was aware of that, which is why I included an example showing the same feature (applying a specific function only to a certain bar) in my original post 😊

Thank you, guys !!
 
Yes, I try to read all the stuff, but it does not mean I understand it all by myself...🤣🤣🤣🤣🤣🤣
 
And this quarantine is so lonely... I need to talk with you...
 
Fortunately, I have this marvelous forum !! With amazing people !
It´s very cool to have some functions with short "nicknames" !
 
Thanks a lot. I will try this.
 
 
 
 
 
 

More important you can apply the the unfold method to a specific bar or even to an event in a given bar number:
 
Method applied to entire sequence:
(unfold 'name 'method sequence)  
Method1 applied to 2nd bar only:
(unfold 'name '((method1 2) method2) sequence)  
Method1 applied to the 3rd event in the 1st bar:
(unfold 'name '((method1 1 3) method2) sequence)  
Examples:
(setf mat '((s c4 d4 e4 f4 g4) (s c4 d4 e4 f4 g4) (s c4 d4 e4 f4 g4))) (unfold 'om 't7 mat) => ((s g4 a4 b4 c5 d5) (s g4 a4 b4 c5 d5) (s g4 a4 b4 c5 d5)) (unfold 'om '((t-12 1 3) (t-1 2) (r 3)) mat) => ((s c4 mf d4 e3 f4 g4) (s b3 cs4 eb4 e4 fs4) (s g4 f4 e4 d4 c4)) (unfold 'om '? mat) => ((s c4 d4 e4 f4 g4) (s g4 a4 bb4 c5 d5) (s c4 bb3 gs3 g3 f3))  
Why so may users do not read/examine the function documentation.🤓

> we can call the specific sets in the unfold function without having to evaluate the complete procedure of each method ?
 
Yes naturally,
 
you can create your own unfold-set, save it in unfold-set folder and call it in counterpoint or unfold with the optional keyword :set and specify here the name of your set.
 
SB.

Common Lisp does usually not distinguish between lower and upper case in its symbols. Standard Common Lisp compilers always return symbols with only upper case therefore by default, but Opusmodus seemingly does internally some trickery to change that to always lower case. 
 
It is possible with Common Lisp to specify symbols that distinguish between cases by wrapping the symbol names within bars (|) like so. 
 
? '|TesT|
|TesT|
? '(|TesT|)
(|TesT|)
 
Unfortunately, this does not to work fully in Opusmodus for all cases, possibly because of the internal symbol trickery that Opusmodus does.
 
? '|3M|
3m
 
This symbol does not require the bars in standard Common Lisp, because it only contains upper cases. However, the mentioned Opusmodus magic then turns this case down, so therefore this uppercase preservation does not work here. 😶
 
Summary: if you wrap your symbols in bars and use only symbols that contain both upper can lower case letters or only lowercase letters, the distinction works...

> can we ... a file with our customized methods with your function?
 
You can put this function fn-unfold wherever you want, as long as that file is loaded at startup, and likewise also any other function including functions like tr above  🙂
 
> we can call the specific sets in the unfold function without having to evaluate the complete procedure of each method ?
 
Questions concerning the original unfold function are better answered by Janusz, I guess... 
 
Good night (its 23:00 over here...),
Torsten

I like how the function unfold allows for rather concisely expressed transformations. I also like that with this function, methods can easily by commented out or added without changing the nesting structure of the overall Lisp program. However, what I do not like is that the unfold methods don't support any further arguments, and as a result the required preliminary work with def-unfold-set is rather cumbersome.  
 
So, I rolled by own version of unfold that addresses this shortcoming. This new function works as follows: you can use the names of arbitrary Opusmodus functions, as long as they expect an OMN sequence as first argument. The following example applies first the function gen-retrograde and then quantum to the material mat. 
 
(setf mat '((q c4 d4 e4) (h f4 q b3)))
(fn-unfold '((gen-retrograde) (quantum :fraction -0.2)) mat)
=> ((7W B3 7H._QT F4 -E..) (E E4 D4 S. C4 -ET))
 
If you would like to have functions with more concise names (as unfold does), just define functions with shorter names. Here are some examples.
 
(defun tr (sequence transpose &key (section NIL) (exclude NIL) (ambitus 'piano) (omn NIL))
  "Like pitch-transpose, but sequence as first param."
  (pitch-transpose transpose sequence :section section :exclude exclude :ambitus ambitus :omn omn))
 
(defun ld (sequence values &key set ignore seed (section NIL) (exclude NIL) (omn NIL))
  "Like length-divide, but sequence as first param."
  (length-divide values sequence :set set :ignore ignore :section section :exclude exclude :omn omn :seed seed))

With the definitions above, we can now use fn-unfold as follows for computing an octave transposition of mat and then applying length-divide to the second bar with the given settings.
 
(fn-unfold '((tr 12) (ld (2 3) :section 1)) mat)
=> ((Q C5 D5 E5) (3H E5 FS5 G5 3Q A4 BB4 CS5))
 
BTW: The definition of fn-unfold is pretty short. By far the longest part of this definition is the doc string 🙂
 
(defun fn-unfold (fns sequence) "Much like the buildin Opusmodus `unfold`, but instead works with functions and additional arguments can be given to the functions. Apply to `sequence` all fns in order. * Arguments: - fns (list of lists): Each sublist has the form (<omn-fn> &rest <args>), where <omn-fn> is a function expecting an OMN sequence as first argument and arbitrary further argments, and <args> are the further arguments beyond the OMN sequence given to the function. - sequence: OMN sequence * Examples: Some material to use ;;; (setf mat '((q c4 d4 e4) (h f4 q b3))) Remember: all functions used must expect a OMN sequence as *first* argument. ;;; (fn-unfold '((gen-retrograde) (quantum :fraction -0.2)) mat) Some short-hand versions of common functions are defined for conciseness. ;;; (fn-unfold '((tr 12) (ld (2 3) :section 1)) mat) " (reduce (lambda (seq fn) (apply (if (functionp (first fn)) (first fn) (fdefinition (first fn))) seq (rest fn))) fns :initial-value sequence))  

Thank you, Stephane ! Always great !!

Great, Janusz !
 
Or maybe put a user defined filter/map, like the one I suggested. With this, some people may choose a custom defined spelling.
This is very useful for adapting material, making some scores more readable for performers (all flats, all sharps, tonality map oriented, etc).
 
By the way, in my humble opinion, I don't think that modes and scales are archaic systems, since even Ligeti in the end of his carreer goes back to diatonic principles (the same is true for Penderecki). There are composers like Arvo Part (with some neomodal "Tintinabulation" stuff), Steve Reich, Terry Riley, and others minimalists that uses triadic and diatonic materiais that can be theorized as modal or tonal. You have jazz oriented guys also, like Kapustin, polystylistic guys, like Schnittke (who mix baroque with avant-garde music in the same Concerto), and many other in between possibilities, including Berio's use of quotation. So, in the contamporary music all tools are avaiable, not only the old-fashioned-historic-vanguard-Darmstad-atonal-Adorno stuff, so diversity and tolerance are important to keep music oxigenated. I know you are open minded guys.
 
All the best
 

+1
 
best
 
ole