RST

Hi,
 
for such things, i tend to use do-timeline with time resolution parameter (:time keyword).
 
i use also find-bar, replace-bar etc... collection of function.
 
Actually we are in the process of changing many functions in Opusmodus for giving total access of individual omn events.
 
For example, you can now use gen-divide at the event level and it is very useful for micro control.
 
(gen-divide '(2 4 2) '(s c4 ppp d4 pp -q s e4 p f4 mp g4 mf a4 f b4 ff c5 fff)) => ((s c4 ppp d4 pp) (-q s e4 p f4 mp g4 mf) (s a4 f b4 ff) (s c5 fff)) Some over example of omn processing:
 
GEN-TRIM (gen-trim 12 '(q c4 mf e d4 e4)) => (q c4 mf e d4 e4 q c4 e d4 e4 q c4 e d4 e4 q c4 e d4 e4) (gen-trim '(12 4) '((e c4 mf d4) (e e4 mf s f4 g4))) => ((e c4 mf d4 c4 d4 c4 d4 c4 d4 c4 d4 c4 d4) (e e4 mf s f4 g4 e e4)) GEN-REPEAT (gen-repeat 3 '(s c4 q d4)) => (s c4 mf q d4 s c4 q d4 s c4 q d4) (gen-repeat '(3) '(q c4 d4 e4 f4 g4 a4)) => ((q c4 mf c4 c4) (q d4 mf d4 d4) (q e4 mf e4 e4) (q f4 mf f4 f4) (q g4 mf g4 g4) (q a4 mf a4 a4)) (gen-repeat 3 '((q c4 g4) (s c4 a4))) => ((q c4 mf g4) (s c4 mf a4) (q c4 mf g4) (s c4 mf a4) (q c4 mf g4) (s c4 mf a4)) (gen-repeat '(3) '((q c4 e g4) (s c4 a4) (e b4 d5 q fs5))) => ((q c4 mf e g4 q c4 e g4 q c4 e g4) (s c4 mf a4 c4 a4 c4 a4) (e b4 mf d5 q fs5 e b4 d5 q fs5 e b4 d5 q fs5)) (gen-repeat '(3 2) '((q c4 g4) (s c4 a4) (e b4 d5))) => ((q c4 mf g4 c4 g4 c4 g4) (s c4 mf a4 c4 a4) (e b4 mf d5 b4 d5 b4 d5)) GEN-REPEAT-SEQ (gen-repeat-seq 8 1 3 '(q c4 mf e cs4 s d4 s ds4)) => (q c4 mf e cs4 cs4 cs4 s d4 d4 d4 ds4) (gen-repeat-seq '(5 2 7 1) 1 2 '((q c4d4e4f4 p) (s c4 mp fs4) (e c4d4e4f4 f) (e c4 fs4 =) (e c4d4e4f4 p))) => ((q c4d4e4f4 p c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4) (s c4 mp fs4) (e c4d4e4f4 f c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4) (e c4 f) (e c4d4e4f4 p c4d4e4f4 c4d4e4f4 c4d4e4f4 c4d4e4f4)) SB.

Dear all,
 
I am curious to know whether any of you have any tips or strategies for approaching 'structure' in composition using Opusmodus. I often find that one of the challenges I face while using Opusmodus is that I tend to think in terms of the general structure of the composition and its pertaining restraints. I find it very difficult to think about the microstructures within a piece, mainly I think because I don't know enough about how to approach the idea of microstructures.
 
By this, I mean I generally approach composition within Opusmodus by generating pitches/lengths/articulations, and separating them in terms of sections. However, within each section, I find that I wish I knew of strategies/ideas to generate even more complexity at a very subtle/micro level. 
 
Again, I think my main challenge in reaching the next stage in my use of Opusmodus is developing a more clear strategy in regards to structure. I'm very curious to hear how others solve this issue.

Hello,
 
I have been reviewing James Pritchett's The Music of John Cage lately, and was particularly surprised by the detail in which some of the techniques John Cage developed in the 1940s are described such as his "gamut" technique and "chart" technique. I am very curious to see whether you are aware of any attempts to use Opusmodus to create something somewhat similar to these techniques?

In theory, the gamut technique is a collection of "sound materials" made before the composition is arranged, and that these sound materials (with varying content, and often containing most of the chords in a piece), while the chart technique is a chart that makes a chart of different possible sounds according to the types of instruments that are used in the piece, only each horizontal axis gives more probability for the appearance of a particular instrument (I wonder if that makes sense).
 
It seems like a good exercise in composition if not anything else, but I'm curious to see how to recreate this in OMN. Otherwise, are there any plans to implement some of John Cage's compositional techniques into OMN's functions? 
 
Thanks.
 
 

Here are all Sibelius Sound Sets for Opusmodus.
 
I've only been testing with the Dimension Strings sound sets. So none of the other files I've been able to test so far. Would be great to get feedback if these sound sets need further improvement.
 
Have fun :-)
 
VslSibeliusWoodwindsAndBrassSoundSet.opmo
VslSibeliusStringsSoundSet.opmo
VslSibeliusSpecialEditionSoundSet.opmo
VslSibeliusSpecialEditionPlusSoundSet.opmo
VslSibeliusPercussionSoundSet.opmo
VslSibeliusEpicOrchestraSoundSet.opmo
VslSibeliusChoirSoundSet.opmo

This will be quite helpful.  Last week Jay Spears from Avid was visiting me at my university and informed me of many exciting new developments with Sibelius that are planned.  Thus, keeping the focus on Sibelius for extending Opusmodus work is probably a great idea.  I will look forward to exploring these tools.  Thank you for providing them!

hi yuichi
 
here a version without exit-problems... a simple loop (with x-generations), that's what your code is doing... so you don't have to re-evaluate, loop is doing this...
(setf generations 20) (setf omn (loop repeat generations do (setf pitch (integer-to-pitch (rnd-row))) do (setf len (span pitch '(s))) collect (make-omn :pitch pitch :length len))) (def-score 12-tone (:key-signature 'atonal :time-signature '(4 4) :tempo 120) (inst :omn omn)) (display-musicxml '12-tone) (display-midi '12-tone)  
 
 

Would be great to have all VSL Instrument programs in Opusmodus Library.

I've started to develop a converter that converts Sibelius SoundSet files (xml) to Opusmodus SoundSet format. It's very preliminary yet but attached you'll find the result of using the Sibelius Special Edition Sound Set as well as the Sibelius Strings Sound Set as test input. Looks promising I think. 
 
The Controllers group is missing but I'll be able to implement that part soon. Need a better understanding of what it's supposed to do and will start testing the output so far.
 
VSL has created Sibelius specific presets for Vienna Instruments which are meant to be used in conjunction with the Sibelius Sound Set. The converter I wrote converts these Sibelius Sound Set XML files into Opusmodus sound files that will work with those same Sibelius presets for Vienna Instruments. They won't work with the standard VSL presets but as far from what I understand now those Sibelius specific Sound Set formats & presets are very useful for Opusmodus too. 
 
You don't have to have Sibelius in order to use these Opusmodus sound sets. I just use the word Sibelius to make clear that the Vienna Instruments Sibelius presets shall be used.
 
Any suggestions are more than welcome.
 
(see post below for the latest version of the sound sets.)
 
 

NEW:
MODUS is working with omn-form lists now.
 
(modus '((q c6 cs4 e a4 e3 d6 f4) (q b4 gs3 e bb4 eb4 g5 fs6)))
=> ((0 1 9 4 2 5) (11 8 10 3 7 6))
 
 
MOTIF-MAP function name has change to PATTERN-MAP with additional functionality.
 
(setf omn '((s c4 d4 e4 f4 g4 a4 b4 c5)
            (5q c4 d4 e4 f4 g4 g4 f4 e4 d4 c4)))
 
(pattern-map 
  '(((c4 d4 e4) (cs4 ds4 f4)) 
    ((f4 g4) (eb4 fs4))) omn
  :type :pitch)
=> ((s cs4 ds4 f4 eb4 fs4 a4 b4 c5)
    (5q cs4 ds4 f4 eb4 fs4 g4 f4 e4 d4 c4))
 
(pattern-map 
  '(((c4 d4 e4) (cs4 ds4 f4)) 
    ((f4 g4) (eb4 fs4))) omn
  :type :pitch :loop t)
=> ((s cs4 ds4 f4 f4 g4 a4 b4 c5)
    (5q c4 d4 e4 eb4 fs4 g4 f4 e4 d4 c4))
 
 
(setf mat '((q c6 cs4 a4 e3 d6 f4) (q b4 gs3 bb4 eb4 g5 fs6)))
 
(modus mat)
=> ((0 1 9 4 2 5) (11 8 10 3 7 6))
 
(pattern-map 
 '(((0 1 9 4 2 5) (0 4 2 1 9 5))
   ((11 8 10 3 7 6) (10 8 11 3 7 6)))
 mat :type :pitch :pcs t)
=> ((q c6 e4 d4 cs3 a6 f4)
    (q bb4 gs3 b4 eb4 g5 fs6))
 
(pattern-map
 '(((0 1 9) (10 8 11))
   ((11 8 10) (0 1 9)))
 mat :type :pitch :pcs t :loop t)
=> ((q bb6 gs4 b4 e3 d6 f4)
    (q c4 cs3 a4 eb4 g5 fs6))
 

New:
Improvement to tuplet brackets placement. MUSICXML-TO-EDITOR function.  
musicxml-to-editor file-name &key application identifier
 
[Function]
 
Arguments and Values:
 
file-name                 a string.
application            a string. The default is "Sibelius".
identifier               a string.
 
Description:
 
The MUSICXML-TO-EDITOR function opens musicxml score files in any musicxml editor, like Sibelius, Finale etc...
 
Examples:
 
First, you need to create a musicxml file from your score:
 
(compile-score 'file-name :output :musicxml :file "file-name")
 
Next:
 
(musicxml-to-editor "file-name")
 
To open the file in Finale:
 
(musicxml-to-editor "file-name" :application "Finale")
 
If the application name is not working you can use the identifier keyword with the bundle-identifier.
For example the Sibelius 7.5 version identifier is "com.avid.Sibelius75"
 
(musicxml-to-editor "file-name" :identifier "com.avid.Sibelius75")
 
 

Hybrid piece for solo cello and electronic.
 
Based on magic square with magic constant 48.
 
Thanks to opmo for the mapping.
 

 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ASHBY-OPERATOR => some nonsense-sound-examples ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; little function for mapping... (defun eliminate-repetitions (liste) (let ((liste (append liste (list 'nil)))) (loop repeat (1- (length liste)) with cnt = 0 when (not (equal (nth cnt liste) (nth (+ 1 cnt) liste))) collect (nth cnt liste) do (incf cnt)))) ;;; some examples ;(setq integers ; (flatten (ashby-operator-1 '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)))) (setq integers (flatten (ashby-operator-1 '( 3 1 4 0 7 8 9 10 5 6 2 11)))) ;(setq integers ; (flatten (ashby-operator-1 (gen-sieve '(c4 c7) '(1 2 3))))) ;;; mapping (setq pitches (eliminate-repetitions (integer-to-pitch integers))) (def-score example (:key-signature 'chromatic :time-signature '(4 8) :tempo '(e 176) :layout (bracket-group (piano-grand-layout 'piano))) (piano :omn (setq omn-list (make-omn :pitch pitches :length (loop repeat (length pitches) collect 1/32))) :sound 'gm-piano)) #| (def-score example-reverse (:key-signature 'chromatic :time-signature '(4 8) :tempo '(e 176) :layout (bracket-group (piano-grand-layout 'piano))) (piano :omn (setq omn-list (make-omn :pitch (reverse pitches) :length (loop repeat (length pitches) collect 1/32))) :sound 'gm-piano)) |#  

Better segregation with SPLIT-TUPLET-LENGTHS:
(split-tuplet-lengths '(3q a4 b4 d4 f4 d4 q a4 b4 5q g3 a4 q - -)) => ((3q a4 b4 d4 f4 d4) (q a4 b4) (5q g3 a4) (q a4 - -))  

 
RND-UNIQUE new keyword :extend.
Extends the result to a given number:
(rnd-unique 13 '(c4 cs4 d4 ds4 e4 f4 fs4) :extend :loop :seed 45) => (f4 d4 fs4 ds4 c4 cs4 e4 f4 d4 fs4 ds4 c4 cs4) (rnd-unique 13 '(c4 cs4 d4 ds4 e4 f4 fs4) :extend :rnd :seed 45) => (fs4 f4 cs4 ds4 c4 e4 f4 cs4 d4 ds4 fs4 d4 c4)  

(progn   ;;; Laod score files.   ;;; There is no need for an .opmo extension if all of the scores are in the workspace folder.   (let ((files          '(score1            score2            score3            score4            )))     (mapcar #'(lambda (x)                 (load (merge-pathnames (string x) *load-truename*)))             files))      ;;; To assemble the final score form scores:   (compile-score    '(score1 ;; score name      score2      score2      score2      ))    ;;; The *last-score* is the last compiled score.   (display-musicxml *last-score*)   (display-midi *last-score* :display :quick-view)   )  

The function MERGE-VOICES will merge a number of omn script lines (voices) into one line of omn script with the time signature take form the first voice.
 
Note: The MERGE-VOICES in general should be use with simple (base) lengths only.
For more complex lengths the layout is more effective tool:
:layout (piano-solo-layout '(pno-rh1 pno-rh2) 'pno-lh))  
Optimisation to ASSEMBLE-SEQ function with a small bug fix.

i coded my own algorithm... so the ouput is like that, but a problem with ambitus-swallow...
(setq omn-list '(s. c4 pp ponte (acc t b3 ppp flaut t f3 ppp flaut) s. e3 pp ponte -t (acc t c4 pp flaut) s. fs3 ppp tasto s. b3 ppp tasto (acc t f3 pp flaut) -t (acc t c4 pppp ord) s. cs4 pp ponte s g4 ppp ord s f4 ppp ord s. b4 pp ponte (acc t c5 pppp ord) -t s c4 pp flaut e_t b3 p tasto s f3 ppp tasto s bb3 ppp tasto e_t e3 p tasto s eb3 pp flaut -w s. c4 ppp tasto (acc t b3 pppp ord t f3 p tasto t d3 p tasto t gs2 pppp ord) s. g2 ppp tasto -w (acc t c4 ppp ord) e_t fs3 pppp tasto (acc t g3 pppp flaut t cs3 pppp flaut) e_t d3 pppp tasto (acc t gs2 ppp ord) -t s c4 pppp ponte (acc t eb4 p tasto) s e4 pp tasto s g4 pp tasto (acc t gs4 p tasto) s b4 pppp ponte -t (acc t c4 p flaut) s. g3 ppp tasto s. gs3 ppp tasto (acc t eb3 p flaut) -t e_t c4 pppp ponte s fs4 pp ord)) ;;; it works well with cmd2, but the function: ambitus-swallow ...has a problem... why? (ambitus-swallow '(cs3 fs5) omn-list) > Error: Duration must be positive when duration-add is false. > While executing: normalize-duration, in process Listener-1(6). > Type cmd-. to abort, cmd-\ for a list of available restarts. > Type :? for other options.  

hi all,
i coded a little markov-program who changes the LEVEL-size if necessary to generate the number of values you want exactly.
 
it would be nice if someone could check/test the IDEA, and if it's correct and makes sense :-)
 
the markov starts on LEVEL 3 and tries to generate a number of output-levels with its TRANSITION-rules (level-3-rules), if it's possible (=generating the size) everything's fine. but if it's not possible, then the programm changes on LEVEL-2-rules ... if this is also not possible (to generate the size) then it changes to LEVEL 1... 
 
here is the code...
 
;;;FUNCTION (defun gen-multiple-markov (sequence &key size) (let ((transitions-level-1 (gen-markov-transitions sequence :level 1)) ;; gen transition-table level-1 (transitions-level-2 (gen-markov-transitions sequence :level 2)) ;; gen transition-table level-2 (seq (gen-markov-from-transitions (gen-markov-transitions sequence :level 3) :size size))) ;; gen markov-seq on level-3 (if (< (length seq) size) ;; test if seq is too short (/= (length seq) size) (progn ;; if too short -> combine the last seq with a new one (level 2) (setq seq (append seq (gen-markov-from-transitions transitions-level-2 :size (- size (length seq)) :start (last seq)))) (if (< (length seq) size) ;; same test as above (append (append seq (gen-markov-from-transitions transitions-level-1 :size (- size (length seq)) :start (last seq)))) (append seq))) (append seq)))) ;;;TEST (gen-multiple-markov '(1 2 3 2 1 2 3 2 1 2 2 2 2 1 1 1 1 2 2 3 2 1 1 2) :size 36)  
best wishes and THANX
andré
 
 

Hi,
 
often when we generate articulation and particularly legato articulation with functions like LENGTH-MAP, the legato slur could finished on marc or stacc notes like that:
 

 
a possible way for improve this could be to use a post processing of LENGTH-MAP outputs with a MOTIF-MAP function:
 

 
Attached to this post, a work in progress, Flux for ensemble, as an example of a possible use "in context" of this technique.
 
Have a good day.
 
SB.
 
Flux-Extrait.pdf
flux1.mp3
Flux1-02.opmo

HARMONIC-PROGRESSION coming soon:
 
harmonic-progression degree scale &key (size 3) (step 2) relative
                            root row variant (chord t) (flatten t) seed
 
(harmonic-progression '(2 3 4) '(c major)) => (e4g4b4 f4a4c5 g4b4d5) (harmonic-progression '(3 4 0) '(c major)) => (f4a4c5 g4b4d5 c4e4g4) (harmonic-progression '(0 1 2 3 4 5 6 7) '(c major)) => (c4e4g4 d4f4a4 e4g4b4 f4a4c5 g4b4d5 a4c5e5 b4d5f5 c5e5g5) (harmonic-progression '(2 6 5 4) '(a minor)) => (c5e5g5 g5b5d6 f5a5c6 e5g5b5)  
(setf scale '(c4 d4 e4 f4 g4 a4)) (harmonic-progression '(0 1 2 3 4 5 6 7) scale) => (c4e4g4 d4f4a4 e4g4c5 f4a4d5 g4c5e5 a4d5f5 c5e5g5 d5f5a5) (harmonic-progression '(0 1 2 3 4 5 6 7) scale :step '(2 (2 1) 2)) => (c4e4g4 d4f4g4 e4g4c5 f4a4d5 g4c5d5 a4d5f5 c5e5g5 d5f5g5) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) scale) => (c4e4g4 f4a4d5 g4c5e5 c4e4g4 g3c4e4 f3a3d4 a3d4f4 c4e4g4 g3c4e4) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) scale :size '(3 3 4 5 4 4 3 3 3)) => (c4e4g4 f4a4d5 g4c5e5g5 c4e4g4c5e5 g3c4e4g4 f3a3d4f4 a3d4f4 c4e4g4 g3c4e4) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) scale :step '(2 2 1 2 (1 2) 2 2 2 1)) => (c4e4g4 f4a4d5 g4a4c5 c4e4g4 g3a3d4 f3a3d4 a3d4f4 c4e4g4 g3a3c4) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) scale :root '(-6 -2 3 -3 2 -1 0)) => (fs3bb3cs4 eb4g4c5 bb4eb5g5 a3cs4e4 a3d4fs4 e3gs3cs4 a3d4f4 fs3bb3cs4 f3bb3d4) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) scale :size '(3 3 4 5 4 4 3 3 3) :step '(2 2 1 2 (2 1) 2 2 2 (2 1)) :root '(c4 g4 a4 bb4 c5 ds5 e4 e5 bb4)) => (c4e4g4 c5e5a5 e5fs5a5b5 bb4d5f5bb5d6 g4c5d5f5 gs4c5f5gs5 cs4fs4a4 e5gs5b5 f4bb4c5) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) scale :size '(3 3 4 5 4 4 3 3 3) :step '(2 2 1 2 (2 1) 2 2 2 (2 1)) :root '(c4 g4 a4 bb4 c5 ds5 e4 e5 bb4) :row t) => (c4e4g4 c5e5a5 e5fs5a5b5 bb4d5f5 g4c5d5f5 gs4c5f5 cs4fs4a4 e5gs5b5 f4bb4c5)  
(setf row '(gs4 ds4 g4 e4 as4 fs4 d4 f4 cs4 c4 a4 b4)) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) row) => (gs4g4bb4 e4fs4f4 bb4d4cs4 gs4g4bb4 a3gs4g4 c3b3eb4 b3eb4e4 gs4g4bb4 a3gs4g4) (harmonic-progression '(0 3 4 0 -2 -3 -1 0 -2) row :size '(3 4) :root '(-6 -2 3 -3 2 0 3 -2)) => (fs3f3gs3 fs3gs3g3d3 f4a3gs3 a3gs3b3eb3 eb3d4cs4 e2eb3g3gs3 fs3bb3b3 bb3a3c4e3 g2fs3f3)  
(setf p45 (partial-row (library 'tbn-cs3-frames 'partials 'p45))) (harmonic-progression '(1 4 5 1 3 4 2 4 3) p45 :size '(3 4) :root '(-6 -2 3 -3 2 0 3 -2)) => (c4a4b5 b5f6c7fs7 gs6d7g7 eb4c5d6gs6 f5g6cs7 cs6g6d7gs7 cs5e6bb6 b5f6c7fs7 a4b5f6) (harmonic-progression '(1 4 5 1 3 4 2 4 3) p45 :size '(3 4) :root '(-6 -2 3 -3 2 0 3 -2) :chord nil :flatten nil :variant '? :seed 8634) => ((c4 a4 b5) (b5 f5 bb4 e4) (gs6 d7 g7) (eb4 fs3 e2 bb1) (cs7 g7 f6) (cs6 g5 c5 fs4) (cs5 bb3 e3) (fs7 c7 f6 b5) (a4 g3 cs3))  

Here is a small project to explore pitch-mapping.  There are some results but not the best ones yet.  If anyone has an idea on how to improve this I would really appreciate the advice.  What would be ideal as the result would be the same musical list (and notation) but with the transformed pitches.  As you can see from the result, there are many changes and the result is not clean but rather seriously garbled instead! 
 
The goal is to remap the pitch content of the original with a new tonality-map.  Here is the beginning attempt.  A confusing element is the return of NIL when parsing :articulation from the original material.
 
;;; Pitch mapping project idea
;;; Original musical sequence:
(setf alto-flute-orig
'(
(-q e b4 -e (-app e eb4 f4) h. eb4 (-acc e f4 eb4 f4))

(-3q 3q b4 -3q (-app e eb4 f4) q eb4 (-acc e f4) h eb4 (-acc e f4 a4 b4))
(-q e f5 -e (-app e b4 ds5) a4 (-app e. g4) a4 t b4 a4 b4 -e (-app e eb5) e f5) 
((acc e b4 d5 ds5) q. c5 (acc s f5) e. b4 (acc e c5 d5 ds5) e. a4 (acc e b4 a4) e b4)
(-q e b4 (app e f4 a4 f4) e b4 t g4 a4 eb4 a4 q. b4 (-acc e f4 a4) h bb4 t bb4 c5)  
(-e. b4 -e (acc a4 b4) h bb4 (app e c5) q b4 (acc e d5 ds5 e5) q. b4 (app e f4 bb4) s c5)
(-e gs5 3s a4 d4 gs4 -e. bb4 tie q bb4 (3e b4 a4 b4 -e -e))
((acc e a4 b4 fs4) h c5 (acc e b4) q c5 (acc e ds5 e5 fs5) 3e b4 c5 fs4 q a4 tie q a4 tie e. a4 s bb4 a4 e b4)
(-e (acc e eb4) h f4 tie e. f4 s gb5 -e (acc eb5 f5) e e5 tie q e5 tie 3q e5 3q e5 3q f5 3q b4 -3q -3q)
((acc e bb4 b4) a4 (acc e bb4) h a4 (acc e bb4) e a4 s gs5 -s)
)
)
 
;;;
;;; Disassemble OMN: There are some errors here - in particular for :articulation which seems to return NIL
(disassemble-omn alto-flute-orig)
(setf pit (omn :pitch alto-flute-orig))
(setf len (omn :length alto-flute-orig))
;;; next line result is confusing - returns nil
(setf art (omn :articluation alto-flute-orig))
;;; next line returns a result
(setf artr (omn :rest-articulation alto-flute-orig))
 
;;; Create 12-tone mapping and pitch transformation of original
(setf map '(0 1 3 4 7 8 10 11 17 18 21))
(setf mapping (integer-to-pitch map))
(create-tonality 12T2 '(0 1 3 4 7 8 10 11 17 18 21))
(setf output (tonality-map '(12T2 :root c3 :fixed t) pit))
 
;;; Assemble the parameters into a new OMN with transformed pitches
(make-omn 
 :length len
 :pitch output
 :articulation art
 :rest-articulation artr
)
;;; The result is unsuable so far.  There are some things to iron-out here! :-)

Recorded LiveCoding improvisation performance.

 
SB.

Hi,
 
here's 2 piece from the same algorithm slightly modified for the second version.

 
SB.