Search the Community

Showing results for tags 'omn'.

More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


  • Welcome to Opusmodus
    • Announcements
    • Pre-Sales Questions
  • Support Forum
    • Support & Troubleshooting
    • OMN Lingo
    • Function examples
    • Score & Methods
    • Notation & Layout
    • Live Coding Instrument
    • Library & Sound Sets
    • MIDI Setup
    • Programming (Common Lisp)
  • Sharing
    • Made in Opusmodus
    • Templates & Customisation
  • Feedback
    • Suggestions & Ideas


  • Stephane Boussuge's Blog
  • Deb76's Blog
  • Janusz Podrazik


  • Community Calendar


  • Howto
  • Getting Started
  • Live Coding
  • Music Theory and Analysis

Found 16 results

  1. There are many occasions when we would like to add articulations by hand to our generated scores. The first thing we need to do is to convert (output) the score into omn format. Algorithmically generated score. (setf size 200) (setf vector (add-triangle-waves 4 size 1 0.6 :modulation (gen-triangle size 1 '(0.5 0.4 0.3 0.6) :modulation (gen-triangle size 1 0.3 :phase 180)))) (setf pitches (gen-divide 4 (vector-to-pitch '(g1 g6) vector))) (setf transpose (pitch-transpose -12 pitches)) (setf variants (pitch-variant transpose :variant '?)) (setf length (rnd-sample 120 '(s e s s))) (setf time (span pitches length)) (setf dynamics '(p mf ff)) (def-score add-triangle (:title "Waves Add-Triangle" :composer "OPMO" :copyright "© 2014 Opusmodus" :key-signature 'chromatic :time-signature (get-time-signature time) :tempo 120 :layout (piano-solo-layout 'rh 'lh :flexible-clef t)) (rh :length time :pitch pitches :velocity (rnd-sample size dynamics) :port 0 :sound 'gm :channel 1 :program 'acoustic-grand-piano) (lh :length time :pitch variants :velocity (rnd-sample size dynamics))) The expression below will convert the score into omn score format. (compile-score 'add-triangle :output :score) To get a more readable version of the score add PPRINT (print pretty) at the beginning of the expression. (pprint (compile-score 'add-triangle :output :score)) Output in the Listener: (def-score add-triangle (:title "Waves Add-Triangle" :composer "OPMO" :copyright "© 2014 Opusmodus" :key-signature 'chromatic :layout '(:brace (:flexible-treble rh) (:flexible-bass lh) :name "" :abbr "" :flexible-clef t) :time-signature '((1 4 2) (5 16 2) (1 4 1) (5 16 1) (3 8 2) (5 16 2) (3 8 1) (5 16 2) (1 4 1) (5 16 1) (1 4 1) (3 8 2) (1 4 1) (3 8 1) (5 16 1) (3 8 1) (5 16 2) (3 8 1) (7 16 1) (1 4 1) (3 8 1) (1 4 1) (5 16 1) (1 4 2) (5 16 2) (1 4 1) (5 16 1) (3 8 2) (5 16 2) (3 8 1) (5 16 2) (1 4 1) (5 16 1) (1 4 1) (3 8 2) (1 4 1) (3 8 1)) :tempo '120) (rh :omn '((s g1 ff gs1 p a1 ff b1) (s c2 mf cs2 ff d2 e2 mf) (e f2 p s fs2 ff g2 p a2) (s b2 mf e c3 s cs3 ff eb3) (s e3 mf f3 ff fs3 p a3 mf) (s bb3 ff b3 e c4 p s e4) (e e4 ff s f4 e s b4 p) (e b4 s s mf e fs5 ff) (s fs5 mf f5 p mf e cs6) (s cs6 c6 p e b5 mf s g6 ff) (s g6 p ff e f6 g6 mf) (s g6 g6 p ff e fs6) (s g6 mf p e s fs6) (s fs6 fs6 ff mf ff) (e fs6 p s ff fs6 fs6 mf) (s fs6 fs6 ff p f6) (s fs6 ff mf e e f6) (s f6 e fs6 fs6 p s f6) (s f6 mf fs6 fs6 p f6) (e f6 f6 ff s fs6 p f6 ff) (s f6 p e s s) (s f6 e mf p s ff) (s f6 mf p mf e ff) (s f6 p e s mf p) (s f6 ff e mf s e p) (e f6 s e ff mf) (s f6 p mf e6 ff f6 p) (s f6 ff e6 mf e eb6 p f6 mf) (s f6 e6 d6 f6) (s f6 e6 ff d6 e f6 p) (s f6 mf e6 ff cs6 f6 mf) (s f6 ff f6 cs6 mf f6 ff) (e f6 mf s s cs6 p fs6 mf) (s f6 ff e e6 p s bb5 mf f6) (s e6 p b5 f5 eb6) (s bb5 fs5 ff e cs5 p s a5 mf) (e e5 ff s c5 e gs4 mf s d5) (e bb4 s fs4 d4 e g4) (s e4 ff d4 b3 mf e eb4) (s cs4 p bb3 mf e gs3 p s c4 ff) (s a3 a3 mf e b3 ff gs3) (s bb3 c4 d4 e b3 mf) (s cs4 p eb4 mf e f4 p s eb4 ff) (s e4 fs4 gs4 p fs4 ff) (e g4 p s a4 mf bb4 a4) (s bb4 c5 cs5 p c5 mf) (s cs5 eb5 ff e e5 mf eb5 ff) (s e5 mf e fs5 g5 p s fs5 ff) (s g5 mf gs5 a5 p a5) (e bb5 ff b5 mf s c6 ff c6)) :channel 1 :sound 'gm :program 'acoustic-grand-piano :volume 90 :pan 64) (lh :omn '((s b0 p a0 mf gs1 g1) (s e1 d1 cs1 ff c1) (e a1 mf s g1 p fs1 mf f1) (s eb2 ff e cs2 s c2 mf b1 p) (s e2 mf eb2 d2 b1 p) (s e3 mf c3 p e b2 ff s bb2) (e b3 p s f3 mf e s e3 ff) (e b3 p s s ff e e3 mf) (s cs5 ff a5 p a5 e gs5 mf) (s cs5 ff c5 e b4 mf s g5 ff) (s g5 mf a5 ff e g5 p g5) (s g5 g5 mf g5 e fs5 ff) (s g5 p g5 e ff s gs5 mf) (s fs5 fs5 ff mf fs5) (e fs5 s p mf fs5) (s fs5 p ff p f5 mf) (s f5 p fs5 mf e e) (s f5 p e e5 e5 ff s f5) (s f5 p e5 e5 f5) (e f5 ff fs5 p s f5 ff f5) (s f5 e s p f5) (s f5 ff e e p s ff) (s f5 mf f5 f5 e p) (s f5 e ff s mf ff) (s f5 mf e p s e mf) (e f5 s e p f5) (s e5 f5 mf p f5) (s f5 g5 ff e fs5 p f5 ff) (s f5 fs5 mf gs5 f5 ff) (s f5 d5 e5 e f5 mf) (s cs5 e5 f5 f5 p) (s f5 ff mf p cs5) (e cs5 ff s f5 mf p fs5 mf) (s f5 e fs5 s c6 f5) (s e5 b4 p f4 eb5 mf) (s bb4 p a4 mf e fs4 p s cs4 ff) (e e4 mf s gs4 p e c5 mf s fs4 ff) (e bb3 s fs3 d3 e g3 mf) (s e3 p d3 b2 e eb3 ff) (s c3 mf e3 p e d3 ff s b2 mf) (s b2 ff a2 p e e gs2) (s b2 ff gs2 mf bb2 ff e c3 p) (s cs3 b2 mf e a2 ff s b2 p) (s fs3 e3 mf fs3 p gs3) (e g3 ff s f3 e3 p f3 ff) (s c4 mf cs4 c4 bb3) (s cs4 p eb4 mf e e4 eb4) (s fs4 p e g4 mf fs4 s e4) (s g4 gs4 p a4 a4) (e c5 ff mf s cs5 ff d5 p)) :channel 1 :sound 'gm :program 'acoustic-grand-piano :volume 90 :pan 64)) Copy the score from the Listener and paste it into the Composer panel. Now we are ready to add articulations etc... to the score by hand.
  2. It is highly useful to have functions that support the full OMN language, because they allow us transform rich music snippets with all parameters. On the other hand, it is easier to define functions for individual parameters. So, why not having a function that automatically adds OMN support (including nested lists) for a function transforming only a single parameter. Here is an example. Lets assume you want to roll your custom pitch transposition function. I choose this example, because everyone hopefully understands that very easily, and can then use this overall approach for their user functions. This demonstration function expects a list of pitch symbols and a numeric transposition interval -- it returns the transposed pitches. Here is the definition of this auxiliary function and a test. (defun my-transposition-aux (interval pitches) (midi-to-pitch (loop for p in (pitch-to-midi pitches) collect (+ p interval)))) ; test (my-transposition-aux 7 '(c4 e4 g4)) ; => (g4 b4 d5) Now, lets generalise this function to support arbitrary OMN input, including nested lists. Some background info for less experienced Lisp programmers: we need to give the new function edit-omn (defined below) as an argument another computer program -- another function. This function does not even have its own name, because it is not a big deal -- it is therefore a lambda expression (an anonymous function, for more on this see (defun my-transposition (interval omn) (edit-omn :pitch omn #'(lambda (ps) (my-transposition-aux interval ps)))) ; my-transposition now "magically" supports arbitrary OMN expressions including nested lists and rests (my-transposition 7 '((q c4 mp -q q e4 q f4) (h g4 tr2))) ; => ((q g4 mp - b4 c5) (h d5 mp tr2)) Below this message is the definition of edit-omn. As you can see, it is not a big deal either (the doc string is much longer than the definition), but hopefully useful. Best, Torsten (defun edit-omn (type notation fun &key (flat T)) "Use function `fun', defined for transforming individual OMN parameters of `type' (e.g., :length, or :velocity) to transform omn expression `notation'. This function is intended as a convenient way to generalise functions your functions to support omn notation as input. Args type: a keyword like :length, :pitch, :velocity, :duration, or :articulation (any keyword supported by function omn or make-omn). fun: a function expecting a parameter sequence of given type. It is sufficient to support only a flat input list, support for nested lists is added implicitly. notation: a omn sequence (can be nested). flat (default T): whether or not `fun' expects a flat input list. Example: roll your own transposition supporting omn input ; first aux def supporting only pitches (defun my-transposition-aux (interval pitches) (midi-to-pitch (loop for p in (pitch-to-midi pitches) collect (+ p interval)))) ; test (my-transposition-aux 7 '(c4 e4 g4)) ; => (g4 b4 d5) ; variant supporting also omn expressions (defun my-transposition (interval omn) (edit-omn :pitch omn #'(lambda (ps) (my-transposition-aux interval ps)))) ; test with nested OMN including a rest (my-transposition 7 '((q c4 mp -q q e4 q f4) (h g4 tr2))) ; => ((q g4 mp - b4 c5) (h d5 mp tr2)) " (let ((params (omn nil notation))) (apply #'make-omn (append (list type (span notation (funcall fun (if flat (flatten (getf params type)) (getf params type))))) (remove-property type params))))) ;; Auxiliary definition (defun remove-property (property property-list) "Removes a property and its value out of a property list" (let ((pos (position property property-list))) (if pos (append (subseq property-list 0 pos) (subseq property-list (+ pos 2))) property-list))) ; (remove-property :test '(:a 1 :test 2 :x 3)) ; => (:A 1 :X 3)
  3. Hi, Here is a short example of OMN deconstruction/reconstruction technique useful when you want to do functions for working directly with omn. ;; Example of function application based on binary-list. (flatten (do-section '(0 1 0) '(chord-interval-add '(4) x) (mclist '(c4 d4 e4)))) ;;; Function example to search for '1/4 length and process the corresponding ;;; pitch for add Major 3rd interval when '1/4 is found. ;;; It is also a good example of deconstruction/reconstruction of OMN ;;; inside a function (defun add-3rd-quarter (omn) (let ((plist (disassemble-omn omn))) (setf (getf plist :pitch) (flatten (do-section (binary-invert (gen-binary-remove '1/4 (getf plist :length))) '(chord-interval-add '(4) x) (mclist (getf plist :pitch))))) (apply 'make-omn plist))) (add-3rd-quarter '(e c4 p d4 q e4 f stacc e f4 p a4 q g4 f stacc)) => (e c4 p d4 q e4gs4 f stacc e f4 p a4 q g4b4 f stacc) SB.
  4. Below is a function that might be interesting for others as well. When I starting writing this function it was much more complicated, but it got more simple by and by :) A formatted version as an RTF file of the documentation is attached, below is a plain text version. For completeness I also attached the documentation of the function circle-repeat, used by the function below. Unfortunately, the file names are destroyed by the software of this forum, sorry. Best, Torsten alternate-omns ids omns Arguments and Values ids a list of integers, indicating the position of OMN expressions in omns. omns a list of OMN expressions (can also be plain lengths, or pitches etc.) between which to switch. Description This function alternates between sublists of multiple OMN expressions. This function can be useful, e.g., to switch between different musical characteristics. Each characteristic (e.g., gesture) and its development can be specified by a combination of parameters (rhythm, pitches, dynamics, and playing techniques) in a sequence of OMN expressions. The output of the function switches between these characteristics as specified in the first argument to the function. The following example demonstrates this. (alternate-omns (gen-eval 10 '(rnd-pick '(0 1))) (list (make-omn :length (length-rest-series (rnd-sample 7 '(7 8 9)) (length-divide 3 2 (rnd-sample 7 '((q q q) (h e e) (h.) (h q))))) :pitch '(d4 e4 f4 g4) :velocity '(pp)) (make-omn :length '(s s s s) :pitch (gen-rotate :right '(c5 d5 f5 a5 g5 e5) :type :seq) :velocity '(ff) :span :pitch))) Alternatively, one can switch between plain sequences of OMN lengths, or pitches etc. (alternate-omns '(0 0 1 0 1 0 1 1 0 0 1 1 1) (list (gen-rotate :left '(-1/20 1/20 1/20 1/20 1/20) :type :seq) '((q e e)))) Examples Remember that resulting OMN expressions can be “re-barred”. (omn-to-time-signature (alternate-omns '(0 0 1 0 1 0 1 1 0 0 1 1 1) (list (make-omn :length (gen-rotate :left '(-1/20 1/20 1/20 1/20 1/20) :type :seq) :pitch '(d4 e4 f4 g4) :velocity '(ff)) (make-omn :length '(q e e) :pitch (gen-rotate :left '(c5 e5 f5) :type :seq) :velocity '(pp pp) :attribute '(ten stacc stacc) :span :pitch))) '(4 4)) Implementation (defun alternate-omns (ids omns) "This function alternates between sublists of multiple omn expressions. It can be useful, e.g., to switch between different musical characteristics. Args: ids: a list of integers, indicating the position of OMN expressions in omns. omns: a list of OMN expressions (can also be plain lengths, or pitches etc.) between which to switch." (let ((omn-no (length omns))) (assert (every #'(lambda (x) (and (integerp x) (< x omn-no))) ids) (ids) "alternate-omns: must be a list of integers between 0 and (1- (length omns)): ~A" ids) (let ((hash (make-hash-table))) (loop for i from 0 to (1- omn-no) for my-omn in omns ;; span (circular repeat if necessary) omn sublists to number of occurences in specs ;; and fill hash table with that as side effect do (setf (gethash i hash) (circle-repeat my-omn (count i ids)))) (alternate-omns-aux ids hash)))) (defun alternate-omns-aux (ids hash) (loop for id in ids collect (pop (gethash id hash)))) (defun circle-repeat (pattern n) "Circle through elements in pattern (a list) until n elements are collected. NOTE: only supports flat list so far." (let ((l (length pattern))) (loop for i from 0 to (- n 1) collect (nth (mod i l) pattern)))) TXT.rtf TXT.rtf
  5. Hello, I'm a new user and wondering if there is a recommended method to input and convert a score to OpusModus. I have a score I've written in 4 parts each part represented in its own file in both MusicXML and MIDI. My goal is to import (either the MIDI or MusicXML) and convert these to OMN so that I can modify them using functions. I have been able to import them but I'm having difficulty converting them to OMN and I haven't been able to find this specific use case in any of the documentation. Any best practice or advice is appreciated. Regards, Tom
  6. is there a function to ROTATE a complete omn-sequence? (like a sample) .... thanks for help!
  7. ;; little function. don't know if something like this already exits ;; in OMN: i wanted to READ the swallowed pitches after ambitus-swallow ;; i hope it works fine... ;;function (defun read-ambitus-swallowed (min/max omn-sequence) (let ((up (ambitus-swallow (list (second min/max) 'g9) omn-sequence)) (down (ambitus-swallow (list 'c0 (first min/max)) omn-sequence))) (merge-voices up down))) ;;nonsense-sequence (setq omn-sequence '(e f4 t a0 q g0 d9 s. eb6 t. f3 cs9 t ab0 q c0)) ;;ord ambitus-swallow (ambitus-swallow '(a0 g8) omn-sequence) ;;the excluded pitches (read-ambitus-swallowed '(a0 g8) omn-sequence)
  8. in OMN: is there a possibilty to replace - for example all 1/32-values of an OMN-sequence - into acciaccaturas? thanxs for help andré
  9. Hello, I have converted one of my scores to OMN. The sequence of pitches, velocity and length are all demonstrated explicitly example - (q b3 e -s b2b2 gs2 as2 a3 g2g2 g2 e2 -e) I would like to take the sequence and convert it to the most appropriate function. I'm assuming this would take a step of analysis. That is, instead of Function > Sequence, I want to perform Sequence> Analysis > map to a Function. Then I could eliminate the explicit OMN sequences and have a score that is (mostly) functions. I'm not sure if this is possible, as it seems incredibly difficult to perform without manual data transformation. However, I'm curious if anyone else has attempted this sort of process? Regards, Tom
  10. Hi! I have a small tuplet question: best way to notate this kind of structure in OMN?
  11. 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! :-)
  12. i would like to re-organize the notation of a sequence like '(5/32 1/32 1/4 1/32 5/32 1/4 3/32 1/32 5/32 1/16 1/16). is it possible to modifiy it, so that all this will be notated in "groups of quarter notes"? like this... much easyer to handle it in SIBELIUS etc... thanks for help... andré
  13. Good morning. I'm interested in score analysis and I've encountered an issue. Is it possibile in Opusmodus, after I've create a score in OMN form (for example : (h c6 mp) (w. f5 pp) (d a4 mp) ) sort these sublist in PITCH ascending order linking the corresponding value of LENGTH? example: convert this: (h c6 mp) (w. f5 pp) (d a4 mp) in this: (d a4 mp) (w. f5 pp) (h c6 mp) where every sublist remains the same but the order is changed on a pitch base (in this case ascending). I've tried SORT-ASC and similar, but probably there's something to try and I'm new to the program. Thank you a lot! Pietro
  14. (q) (q c4) (q c4 mp) (q c4 mp trem) TIME EXISTENCE DYNAMIC EXPRESSION LENGTH PITCH VELOCITY ATTRIBUTE OMN is designed as a scripting language for musical events. It’s not about sounds themselves, it is about their control and organisation in a musical composition. As a linear script rather than a graphic stave, musical events can be transformed, extended, reorganised by powerful computer algorithms. Some sequencers and score writers provide basic algorithms, but they do not represent the way composers now think about the process of music composition. Composing has become such a multi-faceted process and takes ideas about structure and content from many disciplines: mathematics, astronomy, literature, the visual arts. As such it requires extensive mental resources and experience from the composer. Much of this is still done by hand and eye and brain because although computer systems do exist to help the process along they don’t provide what has become known as the composing continuum. This means that a single workspace and workflow environment has not been generally available that can take in the whole process of composing a piece - from first thoughts to a printed score and reference recording. Wouldn’t it be good to be able to do everything in one place? Most composers acquire a bag full of musical tools to act on musical ideas. These still include those tools Bach used for repetition, inversion, retrograde, transposition, but with computer help musical material can be copied, cut, pasted and generally structured and orchestrated. Since the 1950s composers have been experimenting with tools and processes that take musical transformation into wholly new areas; of random numbers, fractals, statistical distribution, graphical plotting to name just a few. To use such experimental things it is composing with a script that is acknowledged as the most efficient and practical way forward. And to work with a script means working with a language: OMN. OMN and Musical Notation The truly original aspect of OMN is that it has been designed to speak directly to traditional musical notation. Everything written in OMN script can be rendered instantly to notation and to a performance simulation. For most composers staff notation remains the common currency they have to work in and with. You couldn’t expect performers to read from a MIDI event display or indeed from OMN script. As the OMN language is laid out and explored we’ll see just how fully the language of music staff notation is mirrored. This is not just in the standard elements of rhythms, pitch and dynamics but in the vast library of musical attributes that cover the way pitches and rhythms are performed by different instruments and voices. So musical notation is always there. Whatever you write there can be an instant ’snippet’ rendered to view alongside your script. OMN: the concept Most languages have developed orderings for parts of speech. Romance languages place the verb after the subject, and in the middle of the sentence. Germanic languages tend to conclude sentences with a verb. In music we’re used to the single intersection of pitch position on a stave line with a rhythmic symbol with or without a stem. In developing a right concept for the OMN language much thought was given to choosing the most effective ordering of elements. Culturally our music is one governed by our past experiences, elements of musical tradition gathered through informal and formal musical education, and what is active in the memory. Descartes adage ‘Cogito ergo sum’ (‘I think, therefore I am’) remains an important cornerstone of an individual’s relationship with composing music. It is something known. It is a made thing; it possess architecture. We can say with confidence that we experience music in a hierarchical sequence of time, existence, dynamics and expression. So it is right that the linear ordering of OMN reflects this. In architecture this might be translated as dimension, materials, volume of space, decoration. These are established architectural parametrics able to form the basis for CAD rendering in the new parametric systems architects are now using to allow the conditions surrounding to influence design. OMN is a language wholly sympathetic to parametric composition in music. OMN: the four elements in detail <length> OMN was created to think about the element of TIME first. After all we can be musical without a pitched note being present. If we are going to use the OMN script we need a reference guide to help us whilst we learn the language. What accompanies this introduction is a special dictionary of language terms arranged in the four elements that make up the concept. However, there are some necessary redefinitions required. TIME is a very general element that subdivides in music to rhythm and length. When we describe what makes up a rhythm in notation it is usually a mixture of symbols that have different lengths. So the OMN vocabulary uses the term LENGTH as its general title. (q) <pitch> The second element of the OMN language is PITCH. Although each piece of music is defined by the length of time, it only starts to EXIST as a proper musical entity when pitch is added. (q c4) <velocity> The third element of the OMN language is VELOCITY. Staff notation has a set of common symbols that are formed from the first letter of Italian words for degrees of intensity we want to attach to a note or a phrase. In OMN there are 12 such terms ranging from ppppp to fffff. OMN includes many symbols that can only be classed as Dynamics because they are not identified directly with a data value. (e c4 mp) <attribute> The fourth element of the OMN language is ATTRIBUTE. The number of general symbols and words used to describe expression in music is vast: tenuto, staccato, legato, trill, fermata etc... Many instruments, particularly those of the string family have their own vocabulary of technical expressive terms: pizzicato, sul ponticello, flautando. Remarkably these can be included in an OMN script and, if your sampler has a string effects library, these expressive instructions can be realised directly. (e c4 mp trem) Finally, there is SIMULTANEITY possible in the layering of attributes. This is achieved by the + symbol. (q c4 mp trem+fermata) Repetition An important fifth element of REPETITION is also present in the OMN language structure. (q c4 q c4) (q c4 =) Assemble And Disassemble It is valuable to remember that the composer may need to create material one parameter at a time. OMN allows for discrete parameters to be brought together to make a composite list in OMN. By the same token it may also be necessary to focus on just a single parameter to develop further the argument of a composition. An OMN list can easily be disassembled into its component parts for such work to take place and then made back into an OMN list. (disassemble-omn '(q c4 mp d4 e4 e f4 f g4)) (make-omn :length '(q q q e e) :pitch '(c4 d4 e4 f4 g4) :velocity '(mp mp mp f f)) OMN script responds directly to the Opusmodus library of algorithmic functions, and with keywords particular elements can be selected to be processed or not. (rnd-order '(q c4 mp d4 e4 e f4 f g4)) OMN: the way forward This introduction should set you on your way. With what has been covered here, the Stages Tutorial files will demonstrate how closely the OMN language can be integrated with algorithmic composing. In fact, when composing in this way you’ll often only write material in one parameter at a time. Although every function will read an OMN list, it’s often better to keep parameters apart to begin with. You’ll see this clearly in the Tutorial files. There will be some music projects where writing directly in OMN is really necessary. Composing for voice is certainly one medium. There are examples in the Howto Score section to demonstrate word setting with full attention given to syllabic splitting. For more experimental approaches to composing OMN can be integrated with the conversion of integers and intervals into the parameter of pitch. The Stages Tutorials show how this can be achieved with examples that use pitch-class sets to create tone rows. OMN is a way of scripting the whole language of traditional staff notation and modes of experimental and conceptual composition using the tools of parametric modelling. It is a language that responds to the future of music presentation, as notation moves inextricably from the printed page to the backlit digital display. New music technology has focused largely on production and presentation, whereas the conceptualisation and origination of new music requires a very different paradigm. Sequencer and Scorewriters continue to provide valuable ways into composition. Opusmodus provides the 3rd way forward, and one driven by its own notation script: OMN. OMN is perfect for those ‘on the fly’ experiments that all composers make when they are starting out on a project. It is like having a piano close by to try out this or that, but one that always plays what’s written quite flawlessly. What is wonderful about scripting is that those experiments if successful can remain part of the score for the whole progress of the composition. With OMN a composing continuum can be achieved. OMN may look a little hard to decipher at first, but once the logic is understood, be assured, OMN can be read with ease. OMN is the first notation that has been designed from the outset to communicate with MusicXML the de facto standard for communication of notated scores between different software applications. Opusmodus scripts can be converted seamlessly into both Midi and MusicXML.
  15. Hi, I noticed this behavior using length-adjust: (length-adjust '3/4 '(-s = = =) :type 'r :position 's) => (-h -s nil nil nil) This works though: (length-adjust '3/4 '(s = = =) :type 'r :position 's) => (-1/2 1/16 1/16 1/16 1/16) and this: (length-adjust '3/4 '(-s s s s) :type 'r :position 's) => (-1/2 -1/16 1/16 1/16 1/16) Seems as if the -s in combination with = causes the problem. I'm still on OM 1.0, maybe this behaves differently in 1.1. All the best, Erik