Search the Community

Hi, An example of group orchestration. I first create some binary représentation of some group of instruments and apply this groups with do-timeline: ;;; Parameters (setf size 12) ;;; Length generation (setf len1 (euclidean-rhythm (gen-repeat size '(16)) 1 12 's :type 2)) (setf len2 (euclidean-rhythm (gen-repeat size '(16)) 1 12 's :type 2)) (setf len3 (euclidean-rhythm (gen-repeat size '(16)) 1 12 's :type 2)) (setf len4 (euclidean-rhythm (gen-repeat size '(16)) 1 12 's :type 2)) ;;; Pitch generation (setf pmat (gen-divide 8 (vector-to-pitch '(c3 c5)(gen-white-noise 32)))) (setf pch1 (pitch-transpose 12 (rnd-sample size pmat))) (setf pch2 (pitch-transpose 8 (rnd-sample size pmat))) (setf pch3 (pitch-transpose 0 (rnd-sample size pmat))) (setf pch4 (pitch-transpose -24 (rnd-sample size pmat))) ;;; Global dynamics (setf dyna (mclist (pink-noise-sample 64 '(pp p mp mf f ff)))) ;;; OMN assembly (setf line1 (make-omn :pitch pch1 :length len1 :velocity dyna)) (setf line2 (make-omn :pitch pch2 :length len2 :velocity dyna)) (setf line3 (make-omn :pitch pch3 :length len3 :velocity dyna)) (setf line4 (make-omn :pitch pch4 :length len4 :velocity dyna)) (setf flute line1) (setf oboe line2) (setf clarinet line3) (setf bassoon line4) ;;; Orchestration and post processing ;; Ambitus (setf flute (ambitus '(g4 c6) flute)) (setf oboe (ambitus '(d4 d5) oboe)) (setf clarinet (ambitus '(c4 g5) clarinet)) (setf bassoon (ambitus '(c2 g3) bassoon)) ;; Re-barring (setf master-meters '(4/4)) (setf flute (omn-to-measure flute master-meters)) (setf oboe (omn-to-measure oboe master-meters)) (setf clarinet (omn-to-measure clarinet master-meters)) (setf bassoon (omn-to-measure bassoon master-meters)) ;; Mute / play (setf olen (length flute)) ;(setf otime (rnd-sample 8 '(wwww www ww w h w ww www))) (setf otime 1) ;; Group orchestration (setf grp1 '(1 1 0 0)) (setf grp2 '(1 1 1 0)) (setf grp3 '(1 1 1 1)) (setf grp4 '(1 0 1 1)) (setf grp5 '(0 0 1 1)) (setf grp6 '(1 1 0 1)) (setf grp7 '(1 0 1 1)) (setf i-list '(grp1 grp2 grp3 grp4 grp5 grp6 grp7)) (setf orchestration (rnd-sample olen i-list)) (setf orch-proc1 (binary-invert (apply-eval orchestration))) (setf instrumentation (matrix-transpose orch-proc1)) (do-timeline2 '(flute oboe clarinet bassoon) instrumentation '(gen-pause x) :time otime) (setf ts (get-time-signature flute)) (def-score group-orch-example (:title "Group orch example " :composer "S.Boussuge" :copyright "2017 s.boussuge " :key-signature 'chromatic :time-signature ts :tempo 88 :layout (list (bracket-group (flute-layout 'flute) (oboe-layout 'oboe) (clarinet-layout 'clarinet) (bassoon-layout 'bassoon)))) (flute :omn flute :channel 1 :sound 'gm :program 'flute :volume 95 :pan 70 :controllers (91 '(52))) (oboe :omn oboe :channel 2 :sound 'gm :program 'oboe :volume 95 :pan 54 :controllers (91 '(55))) (clarinet :omn clarinet :channel 3 :sound 'gm :program 'clarinet :volume 95 :pan 60 :controllers (91 '(57))) (bassoon :omn bassoon :channel 4 :sound 'gm :program 'bassoon :volume 95 :pan 70 :controllers (91 '(57))) ) SB. Group & Orchestration.opmo

Dear Alain Jamot, here is a function that may help you. This function is useful for customising sound playback with multiple sound libraries or for algorithmic orchestration. The function expects an OMN expression and returns a list of multiple OMN sequences (multiple parts). It basically sorts notes from the OMN sequence into different parts, depending on the articulations of individual notes. All notes with certain articulations go in one resulting parts, and notes with other articulations in another part. Here is an example. It sorts all notes with pizz or arco articulations into one part, and notes with trem articulations into another part. Each time, notes are substituted by rests in other parts, so that timing relations of notes in different parts are preserved. (separate-parts '((h c4 pizz q arco) (h trem q h pizz) (h arco+stacc -q fermata)) '((pizz arco) (trem))) => ; part 1: pizz and arco ((h c4 mf pizz q arco) (-h q c4 mf h pizz) (h c4 mf arco+stacc -q fermata)) ; part 2: trem ((-h -q) (h c4 mf trem -q -h) (-h -q fermata))) You can then assign your first part to on MIDI channel in your def-score call, and the next part to another MIDI channel, e.g., like so. (setf omn-expr '((h c4 pizz q arco) (h trem q h pizz) (h arco+stacc -q fermata))) (setf parts (separate-parts omn-expr '((pizz arco) (trem)))) (def-score two-violins (:title "Title" :composer "Composer" :copyright "Copyright © " :key-signature 'chromatic :time-signature '((1 1 1 1) 4) :tempo 100 :layout (bracket-group (violin1-layout 'violin1) (violin2-layout 'violin2))) (violin1 :omn (nth 0 parts) :channel 1 :sound 'gm :program 'violin :volume 100 :pan 54 :controllers (91 '(48)) ) (violin2 :omn (nth 1 parts) :channel 2 :sound 'gm :program 'violin :volume 100 :pan 74 :controllers (91 '(60)) ) ) The function definition of separate-parts is below. Best, Torsten Janusz: This is another example of a function showing how processing polyphonic music with double-nested OMN expressions can be useful. Once we have a standard notation for polyphonic OMN expressions with multiple voices/parts in Opusmodus 2, as discussed earlier, then this function can easily be adapted to output that format. (labels ((make-corresponding-rest (event) (let ((len (omn-encode (first event)))) (cons ;; rests should remain rests (if (> len 0) (* len -1) len) (omn :rest-articulation event)))) (push-event-and-rests (event matching-position result-omns articulation-sets-length) (push event (nth matching-position result-omns)) (loop for i in (remove matching-position (gen-integer 0 (1- articulation-sets-length))) do (push (make-corresponding-rest event) (nth i result-omns))))) (defun separate-parts (sequence articulation-sets) "The function `separate-parts' is useful for customising your sound playback with multiple sound libraries or for algorithmic orchestration. The function breaks an OMN sequence (a single part) into a list of multiple OMN sequences (multiple parts). It basically sorts notes from the OMN sequence into different parts, depending on the articulations of individual notes. All notes with certain articulations go in one resulting parts, and notes with other articulations in another part. In all other resulting parts, notes are substituted by rests, so that timing relations of notes in different parts are preserved. This function can be useful, when you have multiple sound libraries that support different articulations of the same instrument. You can then perform notes with certain articulations on one software instrument (on its own MIDI channel etc.), and notes with other articulations on another instrument. Alternatively, you can use the function for algorithmic orchestration, where you assign custom articulations (typically declared with add-text-attributes first) such as instrument labels with your custom algorithm, and then use this function in a second step to separate your instruments. Remember that the result of this function is a list of multiple OMN sequences (multiple parts). You have to split it into its individual parts for use in OMN. Args: - sequence: OMN sequence, can be nested - articulation-sets: list of list of articulations. All notes with articulations contained in the first articulation-set end up in the first resulting part, notes with articulations in the second set end up in the second part and so forth. The decision which part a note belongs to is always made based on the first articulation that matches an articulation-set. If a note contains no articulation, or an articulation contained in no set, then it is matched to the first articulation-set. If an articulation is contained in multiple articulation-sets, then the earlier match in articulation-sets is used. Examples: (separate-parts '(h c4 pizz q arco) '((pizz) (arco))) => ((h c4 mf pizz -q) ; part 1 with pizz articulations (-h q c4 mf arco)) ; part 2 with arco (separate-parts '((h c4 pizz q arco) (h trem q h pizz) (h arco+stacc -q fermata)) '((pizz arco) (trem))) => (((h c4 mf pizz q arco) (-h q c4 mf h pizz) (h c4 mf arco+stacc -q fermata)) ; part 1: pizz and arco ((-h -q) (h c4 mf trem -q -h) (-h -q fermata))) ; part 2: trem " (if (listp (first sequence)) ;; sequence is nested (matrix-transpose (mapcar #'(lambda (seq) (separate-parts seq articulation-sets)) sequence)) ;; sequence is flat list (let* ((articulation-sets-length (length articulation-sets)) (result-omns (make-list articulation-sets-length :initial-element nil))) (loop for event in (single-events sequence) do (let ((event-articulation (fourth event))) (if event-articulation (let ((matching-position (position-if #'(lambda (articulation-set) (some #'(lambda (art) (member art (disassemble-articulations event-articulation))) articulation-set)) articulation-sets))) (if matching-position (push-event-and-rests event matching-position result-omns articulation-sets-length) ;; if no match, then add event to first omn result (push-event-and-rests event 0 result-omns articulation-sets-length))) ;; if no articulation, then add event to first omn result (push-event-and-rests event 0 result-omns articulation-sets-length)))) (mapcar #'(lambda (result) (flatten-omn (reverse result))) result-omns))))) ;; for your convenience, I include the following definition already shared earlier (defun disassemble-articulations (art) "Splits a combined OMN articulations into a list of its individual attributes. Example: (disassemble-articulations 'leg+ponte) => (leg ponte)" (mapcar #'intern (split-string (symbol-name art) :separator "+")))

Hello, Here's an example of a possible way for achieve group instrumentation. The idea is to create names of instrumental groups and extract some binary list from this groups for using in do-timeline2 function for apply the instrumentation. The score is also attached to this post. ;;;--------------------------------------------------------- ;;; GROUP INSTRUMENTATION EXAMPLE ;;;--------------------------------------------------------- (setf size 12) ;;; Basic Pitch material generation (setf pmat (integer-to-pitch (rnd-number 24 -4 16))) ;;; Global velocity definition (setf gvel (rnd-sample size '((pp)(p)(mp)(mf)(f)))) ;;; OMN material for each instrument (setf flute (make-omn :pitch (pitch-transpose 12 (rnd-sample-seq (rnd-number size 2 8) (gen-repeat 6 (list pmat)))) :length (euclidean-rhythm (gen-repeat size '(16)) 1 16 's :type '(2)) :velocity gvel )) (setf clarinet (make-omn :pitch (pitch-transpose 7 (rnd-sample-seq (rnd-number size 2 8) (gen-repeat 6 (list pmat)))) :length (euclidean-rhythm (gen-repeat size '(16)) 1 16 's :type '(2)) :velocity gvel )) (setf violin (make-omn :pitch (pitch-transpose 10 (rnd-sample-seq (rnd-number size 2 8) (gen-repeat 6 (list pmat)))) :length (euclidean-rhythm (gen-repeat size '(16)) 1 8 's :type '(2)) :velocity gvel )) (setf violoncello (make-omn :pitch (pitch-transpose -12 (rnd-sample-seq (rnd-number size 2 8) (gen-repeat 6 (list pmat)))) :length (euclidean-rhythm (gen-repeat size '(16)) 1 8 's :type '(2)) :velocity gvel )) (setf piano-rh (make-omn :pitch (pitch-transpose 4 (rnd-sample-seq (rnd-number size 2 8) (gen-repeat 6 (list pmat)))) :length (euclidean-rhythm (gen-repeat size '(16)) 1 8 's :type '(2)) :velocity gvel )) (setf piano-lh (make-omn :pitch (pitch-transpose -17 (rnd-sample-seq (rnd-number size 2 8) (gen-repeat 6 (list pmat)))) :length (euclidean-rhythm (gen-repeat size '(16)) 1 4 's :type '(2)) :velocity gvel )) ;;; GROUP INSTRUMENTATION ;;; the main idea is to generate some binary list ;;; based on the interpretation of "instrumental textures or group names). ;; INSTRUMENTAL GROUPS DEFINITION (setf texture1 '(flute clarinet)) (setf texture2 '(flute violin)) (setf texture3 '(flute clarinet violoncello piano-rh piano lh)) (setf texture4 '(clarinet violin violoncello)) (setf texture5 '(violin violoncello piano-rh piano-lh)) (setf texture6 '(flute)) (setf orch-template '(flute clarinet violin violoncello piano-rh piano-lh )) ;; utility function definition (defun binary-orch1 (orch-template groups) (loop for i in orch-template collect (if (member i groups) 0 1))) ;; main function (defun binary-orch (orch-template groups) (mapcar (lambda(x) (binary-orch1 orch-template x)) groups)) ;; group order choice (setf orchestration1 (apply-eval (rnd-sample size '( texture1 texture2 texture3 texture4 texture5 texture6 )))) ;; generate binary from group order (setf binary-from-orch (binary-orch orch-template orchestration1 )) ;; apply the orchestration (do-timeline2 '(flute clarinet violin violoncello piano-rh piano-lh) (matrix-transpose binary-from-orch) '(gen-pause x) ) ;;;--------------------------------------------------------- ;;; Score and Layout ;;;--------------------------------------------------------- (def-score pierrot-ensemble (:title "Title" :composer "Composer" :copyright "Copyright ©" :key-signature 'chromatic :time-signature '((1 1 1 1) 4) :tempo 71 :layout (list (bracket-group (flute-layout 'flute) (clarinet-layout 'clarinet) (violin-layout 'violin) (violoncello-layout 'violoncello)) (piano-layout 'piano-rh 'piano-lh))) (flute :omn flute :channel 1 :sound 'gm :program 'flute :volume 95 :pan 70 :controllers (91 '(52)) ) (clarinet :omn clarinet :channel 3 :sound 'gm :program 'clarinet :volume 95 :pan 60 :controllers (91 '(57)) ) (violin :omn violin :channel 14 :sound 'gm :program 'violin :volume 100 :pan 16 :controllers (91 '(48)) ) (violoncello :omn violoncello :channel 15 :sound 'gm :program 'cello :volume 90 :pan 95 :controllers (91 '(60)) ) (piano-rh :omn piano-rh :channel 7 :sound 'gm :program 'acoustic-grand-piano :volume 100 :pan 64 :controllers (91 '(60)) ) (piano-lh :omn piano-lh :channel 8 :sound 'gm :program 'acoustic-grand-piano :volume 100 :pan 64 :controllers (91 '(60)) ) ) SB. ExempleForumInstrumentation.opmo

I'm curious to know if there is any way to contribute to the list of instruments as found under ambitus-instrument? I often compose for Oud and Korean traditional instruments, and it would be nice to find other instrument templates that are ready to work with.