Jump to content

hujairi

Members
  • Posts

    47
  • Joined

  • Last visited

Reputation Activity

  1. Like
    hujairi reacted to Stephane Boussuge in Coming soon: 5 Opusmodus lessons on Composer workshop   
    Hi, I've just finished a new pack of videos lessons for Composerworkshop, this pack will give you some powerful tools and understanding of the power of OM. Here's the course description:
    5 Opusmodus lessons:
    This set of 5 Opusmodus lessons dive into some advanced possibilities of the Opusmodus Music Composition Environment, bringing an exploration of techniques such as Shapes driven tessiture, dynamics and orchestration control, Algorithmic dictum generation for counterpoint, Process driven composition, Spectral harmony exploration and exploration of different pitch distributions across instrumental parts.
    Who this course is for
    This course is for moderate to advanced users of Opusmodus. It is highly recommended to get all the basics of Opusmodus before to start this course.
    What you'll learn in this course:
    Course 1: Algorithmic Dictum Generation for Counterpoint
    What You Will Learn:
    - Understand the structure and utility of counterpoint functions in Opusmodus.
    - How to manually create simple dictums, a list of pattern numbers and optional parameters.
    - Algorithmic methods for generating lists of pattern numbers and other parameters for Counterpoint function.
    - Techniques to assemble the generated material into a usable and readable dictum.
    - Apply your algorithmically generated dictum in creating a score section using algorithmically designed patterns.
    Course 2: Pitch Distribution across several instrumental parts
    What You Will Learn:
    - How to manually distribute a pitch rowan other pitch material across instrumental parts and understand the underlying logic.
    - Techniques for algorithmic distribution from top to bottom and vice versa.
    - Apply rhythm and pitch variations for richer musical output.
    - Working with various pitch materials like tone rows, Slonimsky patterns, triadic materials, and noise-generated pitch material.
    Course 3: Iterated Process Driven Composition
    What You Will Learn:
    - Introduction to Process-Driven Composition and how to achieve it in Opusmodus.
    - Utility function definitions for adding rehearsal marks and other elements automatically to generated scores.
    - Building a process iterations to generate several sections of a piece in one pass based on rules.
    - How to define your algorithmic process and extract individual instrumental parts.
    - Implement tempo changes and time signature adjustments.
    Course 4: Shapes/Vector driven control of Tessiture, Dynamic, Pitch and Orchestration.
    What You Will Learn:
    - Techniques for generating pitch material based on smoothed white-noise.
    - Algorithmic rhythm generation and control through provided density-length functions.
    - Methods for dynamic markings and ornamentation of repeated notes.
    - Assemble sections into a complete piece while applying orchestration techniques.
    Course 5: Spectral Harmony Exploration
    What You Will Learn:
    - Techniques for spectral pitch remapping.
    - Methods for vector generation and pitch contour shaping.
    - How to import and manipulate spectral data for pitch mapping.
    - Techniques for ambitus constraint, frames filtering and chord generation in spectral frames.
    - Learn to apply dynamic markings, articulations, and the play-mute system to your composition.
    By the end of this course series, you will have a strong understanding of advanced algorithmic composition techniques using Opusmodus. You'll be equipped with the skills to generate sophisticated compositions using an algorithmic approach, taking advantage of Opusmodus's rich set of functions and utilities.
  2. Thanks
    hujairi reacted to opmo in Opusmodus 3.0.29046 Update   
    Thanks to Sungmin's support and the introduction of the new DEF-SC-SCORE macro, Opusmodus users can now create a series of instruments similar to those created with the DEF-SCORE macro for traditional instrument scores.
     
    The primary objective of the DEF-SC-SCORE was to enable users to take Opusmodus scores (whether in omn-form or single-element omn forms) and convert them to the CL-Collider (SuperCollider) input format. To achieve this, we introduced the OMN-TO-SC function specifically for this task.
     
    Below are a few examples that illustrate the conversion process and the use of the DEF-SC-SCORE macro:
     
    Example 1:

    DEFSYNTH:
    (sc:defsynth snd2 ((dur 2.0) (vel 1.0) (left 10) (right 10) (index-low 4) (index-high 12)) (let* ((trigger (sc:impulse.kr (list left right))) (pitch (round (sc:t-rand.kr 36 72 trigger) 1)) (timbre (sc:lf-noise0.kr 1/20 0.2 2)) (env (* 1.0 (sc:env-gen.kr (sc:perc .0 (* 2.0 dur)) :act :free) (sc:linen.kr trigger 0.0 vel (/ 1 (list left right))))) (index (+ (* env index-high) index-low)) (pitch (sc:midicps pitch)) (out (sc:pm-osc.ar pitch (* pitch timbre) index 0 env))) (sc:out.ar 0 out))) (sc:defsynth pm-crotale ((note 60) (dur 2.0) (vel 1.0) (pan 0)) (declare (ignore amp)) (let* ((freq (sc:midicps (+ 0 note))) (envl (sc:perc 0 (* 4.0 dur))) (mod! (+ 5 (/ 1 (sc:i-rand.ir 2 6)))) (out (sc:pm-osc.ar freq (* mod! freq) (sc:env-gen.kr envl :time-scale (* 4.0 dur) :level-scale vel) 0 (sc:env-gen.kr envl :time-scale (* 4.0 dur) :level-scale 0.3))) (out (sc:pan2.ar out pan)) (out (* out (sc:env-gen.kr envl :time-scale (* 1.3 (* 4.0 dur)) :level-scale (sc:rand.ir 0.1 0.4) :act :free)))) (sc:out.ar 0 out)))
    OMN Score:
    (setf size 120) (setf vector       (list-plot        (gen-sine         size 1 '(0.5 0.4 0.3 0.6)         :modulation (gen-sine size 1 0.3 :phase 180))))          (setf pitch (vector-to-pitch '(g1 g6) vector)) (setf pitch1 (gen-divide 4 pitch)) (setf pitch-transp (pitch-transpose -12 pitch1)) (setf section (rnd-unique 15 (gen-integer 0 27))) (setf pitch2 (pitch-variant pitch-transp :variant '? :section section)) (setf length1 (rnd-sample size '(s e s s))) (setf span (get-span length1)) (setf length2 (length-span span (rnd-sample size '(s e s s)))) (setf len-sum (list (sum (abs! length1)))) (setf dynamic1 (rnd-sample size '(p mp mf f ff))) (setf dynamic2 (rnd-sample size '(p mp mf f ff))) (setf omn1 (make-omn :length length1 :pitch pitch1 :velocity dynamic1)) (setf omn2 (make-omn :length length2 :pitch pitch2 :velocity dynamic2))  
    DEF-SC-SCORE:
    (def-sc-score example1     (:tempo 120      :layout ((in1 . len1) (in2 . len2) (in3 . len-sum)))   (in1 :synth pm-crotale        :note midi1        :dur len1        :vel vel1        :pan (gen-loop size (rnd1)))   (in2 :synth pm-crotale        :note midi2        :dur len2        :vel vel2        :pan (gen-loop size (rnd1)))   (in3 :synth snd2        :note '(60)        :dur length-sum        :vel '(0.1))   )  
     
    Example 2:
     
    DEFSYNTH:
    (sc:defsynth pm-crotale ((note 60) (dur 2.0) (vel 1.0) (pan 0))   (declare (ignore amp))   (let* ((freq (sc:midicps (+ 0 note)))          (envl (sc:perc 0 (* 4.0 dur)))          (mod! (+ 5 (/ 1 (sc:i-rand.ir 2 6))))          (out (sc:pm-osc.ar freq                             (* mod! freq)                             (sc:env-gen.kr envl                                            :time-scale (* 4.0 dur)                                            :level-scale vel)                             0                             (sc:env-gen.kr envl                                            :time-scale (* 4.0 dur)                                            :level-scale 0.3)))          (out (sc:pan2.ar out pan))          (out (* out                  (sc:env-gen.kr envl                                 :time-scale (* 1.3 (* 4.0 dur))                                 :level-scale (sc:rand.ir 0.1 0.4)                                 :act :free))))     (sc:out.ar 0 out)))  
    OMN Score:
    (setf chrom '(c4 cs4 d4 ds4 e4 f4 fs4 g4 gs4 a4 bb4 b4)) (setf chords (gen-chord-series chrom chrom :method 1 :type '? :segment '?)) (setf size (length chords)) (setf length (rnd-sample size '(w h q -q)))  
    DEF-SC-SCORE:
    (def-sc-score example2 (:tempo 102 :layout ((ins . length))) (ins :synth pm-crotale :note (omn-to-sc :midi chords) :dur length :vel (gen-loop size (rnd1))) )  
    To see more CL-Collider (SuperCollider) examples and understand the usage of the DEF- SC-SCORE macro, please follow these steps:
     
    Navigate to the Assistant navigator.
    Press the (D) icon.
    Look for the 'CL-Collider Examples' folder. Open the 'CL-Collider.opmo' file.
     
    Happy coding,
    Janusz
  3. Thanks
    hujairi reacted to AM in sending OSC data to MAX   
    here is the solution to send any data by OSC!
    a big thanks to janusz who made it for me/us!! now a wide variety of externals can be controlled via OSC, in any format... (not only reaktor)
     
    (defun osc-send (&rest args) (let* ((host #(127 0 0 1)) ;; host (port 7500) ;; port (s (usocket:socket-connect host port :protocol :datagram :element-type '(unsigned-byte 8))) (b (apply' osc:encode-message args))) (format t "sending to ~a on port ~A~%~%" host port) (unwind-protect (usocket:socket-send s b (length b)) (when s (usocket:socket-close s))))) (osc-send "/player" "120" 1 1 1) (osc-send "/beat" "defer" 0 "duration" 1 "pattern" 12)  
  4. Like
    hujairi reacted to Stephane Boussuge in New sessions with v3   
    Hi,
     
    Yes I'm working on future "Zoom into Opusmodus" and a full website dedicated to OM and will start in January.
     
    Best
     
    SB.
  5. Thanks
    hujairi reacted to opmo in Opusmodus 2.2 (Upgrade)   
    Opusmodus version 2.2
    Language: English, French, Italian and German
     
    Opusmodus 2.2 requires a new serial number to run. When purchasing the upgrade the current user will need to provide an Opusmodus 1.0 - 2.1 serial number.
     
    To purchase version 2.2 please go to Upgrade Now page.
     

    – New Functions:
    OMN-ANALYSIS STATISTIC-ANALYSIS CHORD-DISSOLVE SCORE-INSTRUMENT-EVENTS REWRITE-ACCIDENTALS  
    – Fixed:
    POLYPHONY OMN-DICTUM GEN-STEPS CLM French version and minor bugs
    – Enhancement:
    MIDI-TO-EDITOR COUNTERPOINT GEN-DIVIDE MUSICXML-TO-EDITOR Musicxml – notation display Documents format.  
    New Documentation:
    Quick Guide, Nigel Morgan Tutorials, OMN The Language and How-to Score are now in English, French, Italian and German language. The System Function library documents in German will be released in the coming weeks and months (1000 pages :-).
  6. Like
    hujairi reacted to JulioHerrlein in Inspiring Idea For Rhythm (with Nested Tuplets)   
    INSPIRING IDEA FOR RHYTHM (Nested Tuplets)
     
    Nestup [[]_[]]
    NESTUP.CUTELAB.NYC Nestup, a Language for Musical Rhythms  
     
     
  7. Thanks
    hujairi reacted to Stephane Boussuge in Session 20 - Basic Spectral Harmony Example with Data Importation   
    Hi,
     
    here's the material from this sessions.
     
    Enjoy !!
     
     
    Stéphane
     
    Videos-ZoomIntoOM-session20.zip ZoomOmSession20-171020a.opmo Bassoon-c1.aif
  8. Thanks
    hujairi reacted to Stephane Boussuge in Session 19 - 10.10.20   
    Here's the file from this session and the videos recording of the session.
     
    Happy studies !!
     
    Stéphane
     
    ZoomOM-101020a.opmo Videos-Zoom-OM-10102020.zip
  9. Thanks
    hujairi reacted to opmo in Opusmodus 2.1.26015   
    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.
  10. Thanks
    hujairi reacted to Avner Dorman in Negative Harmony Function   
    Hi Julio,
     
    The so called "negative harmony" is the same as "inversion and symmetrical axes" in set theory (which is the same as saying Neo-Riemannian theory - all transformations are In operations).
     
    An inversion of a pitch class is given by subtracting the pc from index of the inversion operation, n.
     
    In(pc1, pc2,pc3) = (n-pc1, n-pc2, n-pc3)
     
    If you want to think of it as an inversion around an axis, the axis would be n/2 (or 12-n/2 on the other side of the clock-face). 
     
    So the function could be written like this: 
     
    (defun axis-inversion (axis pitches) (integer-to-pitch (loop for i in pitches collect (- (* 2 axis) (pitch-to-integer i))))) And if you want to use Eb-E as the axis it would be 3.5 (e is pc3 and eb is pc4)
     
    (axis-inversion 3.5 '(c4 e4 g4)) ;;; results in (g4 eb4 c4)  
    This doesn't account for octaves etc. - for that you'll need to use midi. Now the axis is given in midi number - so 63.5 would be Eb4:
     
    (defun midi-inversion (axis pitches) (midi-to-pitch (loop for i in pitches collect (- (* 2 axis) (pitch-to-midi i))))) (midi-inversion 63.5 '(c4 e4 g4)) ;;; you get (g4 eb4 c4) (midi-inversion 60 '(c4 e4 g4)) ;;; you get (g4 eb4 c4) (midi-inversion 53.5 '(c4 e4 g4)) ;;; you get (b2 g2 e2)  
    If I missed any cases I am happy to check them out 🙂 
     
    All the best,
    Avner 
     
     
    p.s. - 
     
    (midi-inversion 63.5 '(a4 g4 fs4 a4 d5 a4 fs5 d5 a5 fs5 e5 d5)) ;;; results in (bb3 c4 cs4 bb3 f3 bb3 cs3 f3 bb2 cs3 eb3 f3) ;;; as you expected (I think? I only checked the first few notes :-)  
  11. Like
    hujairi reacted to opmo in Did gen-repeat change?   
    (setf instrument1 (gen-repeat (length chords) '((s g4c4 c4 g4e4 g4 d4 c4 g4f4 g4)))) Nothing change, it needs to be a list with sublists.
     
    (gen-repeat 3 '((c4 g4) (c4 a4))) => ((c4 g4) (c4 a4) (c4 g4) (c4 a4) (c4 g4) (c4 a4)) If number is a list then each list is repeat individually. (gen-repeat '(3) '((c4 g4) (c4 a4))) => ((c4 g4 c4 g4 c4 g4) (c4 a4 c4 a4 c4 a4))  
  12. Like
    hujairi reacted to Stephane Boussuge in Session 7 - 27.06.20   
    Hi everybody,
    Here are the files from session 7.
    Happy Opusmodusing !
    Stéphane
     
    Counterpoint27062020.opmo Unfold1-27062020.opmo Rules1-27062020.opmo
  13. Like
    hujairi reacted to Dpcoffin in Importing MIDI Files—Process, please!   
    Hello, new user here— among the first things I did with OM was to import some simple MIDI files, using directions in a video that has now been lost, as I understand. Just tried to do this again and realized I'd no recollection of exactly how to do it, or how I did it. I've read the two functions for doing this, and I definitely didn't use either of those methods before! 
     
    Could someone who knows the method please describe it here, until a new video or other tutorial about it reappears? Many thanks in advance!
  14. Like
    hujairi reacted to JulioHerrlein in Why I Use Opusmodus   
    WHY I USE OPUSMODUS SOFTWARE IN MY MUSICAL COMPOSITION PROCESS
     
    In this video I will describe some of the techniques I used in my compositional process and why I decided to use OPUSMODUS Software for compose music ! Also my experience with Pure Data and Nodal Software before moving to Opusmodus.
     
     
     
     
  15. Like
    hujairi reacted to Stephane Boussuge in Session 6 - 20.06.20 - From Nothing (Part 2)   
    Hi folks,
    here's the file from the last session.
     
    Happy study !
    Stéphane
     
    FromNothingSuite-20-06-2020.opmo
  16. Like
    hujairi reacted to opmo in Micropolyphony (coming soon)   
    MICROPOLYPHONY is a polyphonic musical texture developed by György Ligeti which consists of many lines of dense canons moving at different tempos or rhythms, thus resulting in tone clusters vertically. According to David Cope, "micropolyphony resembles cluster chords, but differs in its use of moving rather than static lines"; it is "a simultaneity of different lines, rhythms, and timbres".
     
    Example with two choirs:
     

       
  17. Like
    hujairi reacted to Stephane Boussuge in split-point   
    Hi,
     
    here's a function i've made for my own usage and i think could be useful for others.
    It is a split point function which divide an OMN flux according to a list of split points.
     
    Attached, you will find the French doc of the function 😉
    ;;; SPLIT-POINT ;;; SB. 2020 ;;; Fonction utile pour séparer les 2 mains pour une partie de piano ;;; renvoie une liste de listes (defun split-point (split-points omn-seq) (do-verbose ("split-point") (let* ( (spltconvert (if (numberp (car split-points)) split-points (pitch-to-integer split-points))) (spltp (gen-trim (length omn-seq) spltconvert)) (p1 (loop for sp in spltp for l in omn-seq collect (ambitus-filter `(,sp 128) l) )) (p2 (loop for sp in spltp for l in omn-seq collect (ambitus-filter `(-128 ,(- sp 1)) l) )) ) (list p1 p2)))) #| (split-point '(c4 d4) '((e a3d4 c4e4 f4c5 q g3d4 e4)(e a3d4 c4e4 f4c5 q g3d4 e4))) => (((e d4 c4e4 f4c5 q d4 e4)(q d4 e4 f4c5 d4 e4)) ((e a3 - - q g3 -)(e a3 c4 - q g3 -))) ;;; Example (setf pmat (make-scale 'c2 32 :alt '(2 1 2 3))) (setf pch (rnd-sample 128 pmat)) (setf chrd (chordize-list (gen-divide (rnd-number 8 1 4) pch))) (setf mat (length-legato (gen-filter-euclidean 8 16 4 16 chrd 's '(mf)))) (setf split (split-point '(c4) mat)) (setf piano-rh (ambitus-chord 12 (first split))) (setf piano-lh (ambitus-chord 12 (second split))) (ps 'gm :p (list piano-rh piano-lh) ) |#  
    SB.
    split-point.rtfd.zip
  18. Thanks
    hujairi reacted to Stephane Boussuge in omn-replace-articulation-if-repeat   
    Hi,
    i've made this function for my own usage.
    Sharing here if it can be useful for some others.
    It is a function who replace articulation by a given one on repeated notes.
    Best
    SB.
     
    ;;; OMN-REPLACE-ARTICULATION-IF-REPEAT (defun omn-replace-articulation-if-repeat (new-art omn-sequence) (do-verbose ("omn-replace-articulation-if-repeat") (let ((spn '()) (res '()) ) (progn (setf spn (get-span omn-sequence)) (setf res (loop for i from 0 to (- (length (flatten-sublist (single-events omn-sequence))) 1) collect (if (or (eq (second (nth i (flatten-sublist (single-events omn-sequence)))) (second (nth (+ 1 i) (flatten-sublist (single-events omn-sequence))))) (if (> i 0) (eq (second (nth i (flatten-sublist (single-events omn-sequence)))) (second (nth (- i 1) (flatten-sublist (single-events omn-sequence))))) ) ) (omn-replace :articulation new-art (nth i (flatten-sublist (single-events omn-sequence)))) (nth i (flatten-sublist (single-events omn-sequence))) ))) (length-span spn (flatten res)))))) ;;; EXEMPLE #| (setf mat '((s c4 p leg d4 leg e4 leg f4 q g4 f marc)(s a4 mp leg g4 leg leg f4 leg e4 leg leg leg d4 q c4 mf marc))) (omn-replace-articulation-if-repeat '(stacc) mat) => '((s c4 p leg d4 leg e4 leg f4 q g4 f marc) (s a4 mp leg g4 stacc g4 stacc f4 leg e4 stacc e4 stacc e4 stacc d4 q c4 mf marc)) |#  
     
  19. Thanks
    hujairi reacted to opmo in Opusmodus on macOS 10.15   
    We have successfully built Opusmodus on macOS 10.15
    An update will follow shortly.
  20. Thanks
    hujairi reacted to opmo in Opusmodus 2.0 release soon!   
    Opusmodus 2.0 - New Functions:
     
    POLYPHONY
     
    The POLYPHONY function allows you to modify unwanted events (interval, velocity or attribute) in a musical texture consisting of two or more simultaneous lines (voices). The unwanted pitch can be removed with (p) symbol (pause), replaced with the an octave (o) of the leading voice or replaced with an interval value in relation to the leading voice pitch.
     
    Dictum form:
    (<interval><pitch-event><velocity><attribute>) in that order.
     
    Dictum examples
    If true:
    (7 p) 7 - test interval
    p - pause
     
    (7 o) 7 - test interval
    o - octave
     
    (7 t) 7 - test interval
    t - replaced with the leading voice pitch value
     
    (7 p t) 7 - test interval
    p - pause
    t - replaced with the leading voice velocity value
     
    (7 ? mp t) 7 - test interval
    ? -  at random, octave or pause
    pp - velocity set to pp
    t - replaced with the leading voice attribute value
     
    (1 13 mp stacc) 1 - test interval
    13 - interval replacement in relation to the leading voice pitch
    mp - velocity set to mp
    stacc - attribute set to stacc
     
    (7 (6 13) t t) 7 - test interval
    (6 13) - at random, 6 or 13
    t - replaced with the leading voice velocity value
    t - replaced with the leading voice attribute value
     
    Leading
    The leading option is a voice number from which the iteration process will start. If the leading voice is not defined or set to NIL then the first voice in the voice list becomes the leading voice.
     
    Iterate
    The iterate option allows us to control the iteration of the polyphony process. Each repetition of the process is a single iteration, and the outcome of each iteration is then the starting point of the next iteration.
     
    If iterate is set to T the process is iterated until all voices complete the process consecutively applying the process each time to the result of the previous polyphony process:
     
    1 (leading voice) on  2 3 4
    2  on  3 4
    3  on  4
     
    If iterate is set to NIL (default) only a single iteration from the leading voice is triggered:
     
    1  (leading voice)  on  2 3 4
     
    Examples:
    I.
    (setf v1 '((e c4 d4  e4  f4  g4 a4  b4  c5))) (setf v2 '((e g4 eb4 fs4 a4  c5 eb5 fs5 a5))) (setf v3 '((e c4 eb4 f4  as4 c5 e5  fs5 ab5))) (setf v4 '((e a5 fs5 eb5 c5  a4 fs4 e4  c4))) (setf voices (list v1 v2 v3 v4))
     
     
    By default the 1st voice in the list is a leading voice from which the POLYPHONY test will start.
    (polyphony '(7 p) voices) => (((e c4 d4  e4  f4  g4 a4  b4 c5))     ((-e   eb4 fs4 a4  c5 eb5 -  a5))     ((e c4 eb4 f4  as4 c5 -   - ab5))     ((e a5 fs5 eb5 -   a4 fs4 - c4)))  
    After POLYPHONY test:

     
    II.
    (setf s1 '((e c4 p ten+leg d4 pp leg e4 mp f4 p g4 pp a4  b4 f c5)) s2 '((e g4 mp        eb4 p     fs4   a4   c5 mf eb5 fs5  a5)) s3 '((e c4 mp        eb4 p     f4    as4  c5    e5  fs5  ab5)) s4 '((e a5 mp        fs5 p     eb5   c5   a4    fs4 e4   c4))) (setf seq (list s1 s2 s3 s4))
     
     
    If true the pitch will be replaced with the an octave of the leading voice and velocity and articulation event will be replaced with the leading voice events respectively.
    (polyphony '(7 o t t) seq)
     
     
    (polyphony '((7 6 t t) (1 -13 t t)) seq)
     
     
    III.
    (setf p1 '(q d4 pp s eb4 leg g4 p leg bb4 leg a4 q. cs5 mf -e            3q gs5 leg fs5 leg c5 b4 ff leg f4 leg e4)) (setf p2 '(t d4 p leg eb4 leg g4 leg bb4 f q. a4 marc            t fs4 mf leg gs4 leg e. c5 e b4 t f5 leg e5 leg              d5 leg eb5 f 3q bb5 a4 bb5 e a4 pp stacc -e)) (setf p3 '(q d5 leg eb5 3q g4 stacc bb4 stacc a4 stacc e. cs4 marc            s gs4 leg q gs4 -q)) (setf p4 '(q. fs5 pp 3e c5 leg b4 leg f4 e d5 mf s eb5 leg g5 leg               bb5 leg a5 e fs5 leg fs5 3e gs4 > stacc c5 stacc               b5 stacc t f5 pp e.. e5)) (setf patterns (list p1 p2 p3 p4))
     
     
    The intervals 7, 10 and 11 if found in POLYPHONY will turn to a pause for the length of its value.
    (polyphony '((7 p) (10 p) (11 p)) patterns)
     
     
    Instead of turning the unwanted interval to a pause, we set the pitch-event to (o) which will replace the pitch with an octave value, taken from the leading voice.
    (polyphony '((7 o) (10 o) (11 o)) patterns)
     
     
     
    I the next example the 3rd voice is set to a leading voice. If true, the velocity and the articulation will be replaced with the values of the leading voice. In this example we set the :iterate to T.
    (polyphony '((7 0 t t) (10 o t t) (11 o t t)) patterns :leading 3 :iterate t)
     
     
    (polyphony '((7 6 t t) (2 10 t t) (1 13 t t)) patterns :leading 2)
     
     
     
     
    COUNTERPOINT
     
    This function designates patterns to a number of voices with defined methods for each voice. The voices in the COUNTERPOINT dictum list are in sequential numerical order.
     
    In the dictum below the 1st voice is assigned to the 1st pattern, the 2nd voice to the 2nd pattern, the 3rd voice to the 1st pattern and the 4th voice to the 2nd pattern.
     
    Dictum:
    ((1 2 1 2) :methods (- - (ri dl.5) (r dl.2)) :polyphony (7 p) :iterate t)  
    voices:       1 2 3 4
    patterns:   1 2 1 2
     
    Patterns:
    (setf p01 '((-5h 5w. e6 5h bb3 -e bb3 q e5 bb4 -) (-q)            (-5h b5 5w c5 5h b4 q c6 - 3h b4 - -) (-q))) (setf p02 '((q. f6 -e q. fs6 -e -5h - 5w. b6) (-q)            (-3h 3w b5 -3h 3w bb6 5w b5 -5h - -) (-q))) (setf patterns (list p01 p02)) (counterpoint patterns '(((1 2 1 2) :methods (- - (ri dl.5) (r dl.2)))))
     
     
    Methods
    Each of the voices use their own methods which are defined in the DEF-UNFOLD-SET library. The method symbols are method names used in UNFOLD function. In our example we use the default set 'om which can be found in the Utilities/Library/Default-Unfold-Sets library. It is imperative to understand how the unfold sets are created and how they are working. This will allow you to define your own libraries with your own method names and functions.
     
    Let us examine in more detail the methods we are using in our dictum. In the first and second voice the symbol (-) method means, no method is defined (the pattern in the specified voice is unchanged). In the third voice we apply the retrograde-inversion first, then we scale the density of the pattern to 0.5 (mid density) with a length-legato. In the fourth voice we apply retrograde first, then we scale the density of the pattern to 0.2 (low density) with a length-legato.
     
    Lets add two more dictums to our example:
    (counterpoint patterns '(((1 2 1 2) :methods (- - (ri dl.5) (r dl.2)))   ((2 2 1 2) :methods (d.8 (d.8 >) (r dl.2) (d.3 ri)))    ((2 1 2 2) :methods ((dl.7 t-13) (dl.5 <>) (ri dl.4) (dl.3 r t-7)))))  
    Copy the expressions from above to the Composer panel, evaluate each of them and call the ⌘2 shortcut to audition the result.
    In the next four voices COUNTERPOINT example we use 8 patterns with a number of dictum lists.
     
    Patterns:
    (setf p1 '(5q. d3 f cs2 pp 5q d1 mp bb1            5q gs1 p a2 f - eb2 5e e3 pp gs2            7e d2 f c2 ff 7q cs3 mf eb3 f - d4 7e c4 bb3 pp 7q e3)) (setf p2 '(7q f2 ff bb2 mp e3 f eb4 7e e3 mp f4 p 7q b3 ppp g4 pp            7q cs4 mp g3 mf 7e. a3 p pp 7q. gs3 mp -7q -            7q g4 p 7e cs5 f g4 7q cs4 mp c5 7e fs5 g6 pp 7q cs7 mf -)) (setf p3 '(5q. cs5 mf 5e. d6 ppp fs5 5q c6 mp cs5 p            5q. g4 mp b3 5q f3 b2 f            5q. f2 f b2 mp 5q eb2 mf 5e d1 f eb2)) (setf p4 '(5q. d2 f cs1 p -5q g1 mp            5q f1 p fs2 mf - 5e c2 p fs2 mf gs2 p g1 f            7q gs2 mp g1 gs2 p 7e g1 f f1 mf -7q b1 f f2 mp)) (setf p5 '(3q e3 bb3 ff 3e b4 mp c6 ff q d6 ff e gs6 a7)) (setf p6 '(e cs5 pp d6 ppp            3q gs6 ff bb6 3e c7 pp b7 f            3e bb6 mp a5 3q b5 pp f5 ppp)) (setf p7 '(e e2 pp bb1 mp b2 ppp g1 ff 5h f2 p 5q b2 g2 gs3 mp)) (setf p8 '(q f4 mf fs5 pp f5 ff))  
    Span
    The span option will overwrite the original pattern span with a given length. If the original pattern is longer than the span then the pattern is shortened and vice versa. The span applies to all voices in the list. The symbol (-) in a voice list means the voice is paused for the length of the pattern. All patterns in a voice list will align to the longest (span) pattern in the voice list. If the pattern is shorter than the longest pattern the length-rests will be inserted at the end of the pattern.
     
    Extend
    The extend option allows you to place the additional length-rests at the start of the pattern with the symbol (s).
     
    Polyphony
    The polyphony option allows you to avoid unwanted intervals in the voice polyphony and modify the velocity or attributes (articulations) values. The unwanted interval can be removed with (p) symbol (pause), replaced with an octave (o) of the leading voice or be replaced with an interval value in relation to the leading voice pitch.
     
    Leading
    The leading option is a voice number from which the iteration process will start. If the leading voice is not defined or set to NIL then the first voice in the voice list becomes the leading voice.
     
    Iterate
    The iterate option allows us to control the iteration of the polyphony process. Each repetition of the process is a single iteration, and the outcome of each iteration is then the starting point of the next iteration.
     
    If iterate is set to T the process is iterated until all voices complete the process consecutively applying the process each time to the result of the previous polyphony process:
     
    1 (leading voice) on  2 3 4
    2  on  3 4
    3  on  4
     
    If iterate is set to NIL (default) only a single iteration from the leading voice is triggered:
     
    1  (leading voice)  on  2 3 4
     
    Globals
    The global-methods and global-polyphony option is used at the end of the process if a global process is required to an individual voice sequence.
     
    Examples:
    (setf voices       (counterpoint        (list p1 p2 p3 p4 p5 p6 p7 p8)        '(((- 7 1 -) :span 5/4 :methods (- (i dl.7) (dl.7 r) -) :polyphony (7 p) :leading 3)          ((- 6 3 8) :span 3/4 :methods (- ri (t7 >) <) :polyphony (7 p))          ((7 2 5 -) :span 3/4 :methods ((d.4 r) - ri -) :polyphony (7 p))          ((6 3 8 -) :span 3/2 :methods (d.2 < i -) :polyphony (7 p))          ((- 5 - -) :span 5/4 :methods (- (i d.8) - -))          ((4 8 - 4) :span 3/2 :methods (- ri - ri) :polyphony (7 p))          ((- - - 4) :span 3/2 :methods (- - - ><))          ((8 - 4 8) :span 5/4 :methods ((i > d.2) (d.2) (d.2) (d.2)) :polyphony (7 p))          ((- 3 8 -) :span 5/4 :methods (- (dl.2 i) <> -) :polyphony (7 p))          ((3 8 - 4) :span 3/2 :methods (< - - <>) :polyphony ((7 p) (1 p) (11 p)))          (- :span 3/4)          ((- 6 - 8) :methods (- > - ><) :polyphony (7 ?))          ((- - 4 6) :methods (- - > (d.2 ll)) :polyphony (7 ?))          ((- 4 8 3) :methods (- - - v?) :polyphony (7 p) :leading 4)          ((- 4 6 8) :methods (- d.2 - (d.8 <>)) :polyphony (7 ?))          ((6 - 8 -) :methods ((i > d.3) - > -) :polyphony (7 ?))          ((3 8 - 4) :methods (- ri - (d.2 r ll)) :polyphony (7 ?))          ((1 2 - 3) :methods (>< (d.8 <>) - -) :polyphony (7 ?)))        :global-methods '((fl)      ;voice 1                          (t12 cl)  ;voice 2                          (hn)      ;voice 3                          (t-12 vc) ;voice 4       )))  
     In the PS function we assign each voice to an instrument and the ASSEMBLE-VOICES function helps us to extract a particular voice number:
    (ps 'gm     :fl (list (assemble-voices 1 voices))     :cl (list (assemble-voices 2 voices))     :hn (list (assemble-voices 3 voices))     :vc (list (assemble-voices 4 voices))     :octave-shift '(c2 a6)     :tempo (gen-tempo '(44 72 88) '(5 7 11)                       (assemble-voices 1 voices) :seed 34)     :time-signature '(3 4)     )  
     
     
     
    GEN-DICTUM
     
    This function allows you to generate a list of voices with a number of optional dictum methods. This function is a companion to the COUNTERPOINT function.
     
    The simplest use of the function:
    (gen-dictum '((6 - 1 2) (3 2 1 6) (- 1 2 3) (2 1 6 2))) => (((6 - 1 2) :span nil :extend nil :methods nil :polyphony nil :leading nil :iterate nil)     ((3 2 1 6) :span nil :extend nil :methods nil :polyphony nil :leading nil :iterate nil)     ((- 1 2 3) :span nil :extend nil :methods nil :polyphony nil :leading nil :iterate nil)     ((2 1 6 2) :span nil :extend nil :methods nil :polyphony nil :leading nil :iterate nil))  
    Examples:
    In the examples below we use the GEN-PROB and RND-ORDER functions to generate the voice lists and the optional dictum values:
    (setf voice-weight '((1 .4) (2 .2) (3 .4) (4 .3) (5 .2) (6 .3) (- .5))) (setf voices (gen-eval 12 '(gen-prob 4 voice-weight) :seed 34)) => ((- 3 4 -) (6 5 4 3) (3 4 - 1) (5 4 3 4)     (4 - 1 3) (4 3 4 1) (- 1 3 3) (3 4 1 6)     (1 3 3 4) (4 1 6 2) (3 3 4 3) (1 6 2 4)) (setf span-weight '((3/4 .3) (6/4 .2) (5/4 .5))) (setf span (flatten (gen-eval 12 '(gen-prob 1 span-weight) :seed 53))) => (5/4 5/4 5/4 3/2 3/2 5/4 5/4 3/4 5/4 5/4 3/4 5/4) (setf extend (gen-eval 12 '(rnd-order '(s - s -) :encode nil) :seed 27)) => ((- - s s) (- - s s) (- - s s) (- - s s)     (- s s -) (- s - s) (s s - -) (- s s -)     (s - s -) (- s s -) (- s s -) (- s s -)) (gen-dictum voices :span span :extend extend :print t)  
    Listener:
    (setf name '(    #|1|# ((- 3 4 -) :span 5/4 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|2|# ((6 5 4 3) :span 5/4 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|3|# ((3 4 - 1) :span 5/4 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|4|# ((5 4 3 4) :span 3/2 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|5|# ((4 - 1 3) :span 3/2 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|6|# ((4 3 4 1) :span 5/4 :extend (- s - s) :methods nil :polyphony nil :leading nil :iterate nil)    #|7|# ((- 1 3 3) :span 5/4 :extend (s s - -) :methods nil :polyphony nil :leading nil :iterate nil)    #|8|# ((3 4 1 6) :span 3/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|9|# ((1 3 3 4) :span 5/4 :extend (s - s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|10|# ((4 1 6 2) :span 5/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|11|# ((3 3 4 3) :span 3/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|12|# ((1 6 2 4) :span 5/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    ) )  
    To use the output of the function from above as a counterpoint template, we copy the result from the Listener panel and paste it into the COUNTERPOINT function:
    (counterpoint patterns '(    #|1|# ((- 3 4 -) :span 5/4 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|2|# ((6 5 4 3) :span 5/4 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|3|# ((3 4 - 1) :span 5/4 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|4|# ((5 4 3 4) :span 3/2 :extend (- - s s) :methods nil :polyphony nil :leading nil :iterate nil)    #|5|# ((4 - 1 3) :span 3/2 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|6|# ((4 3 4 1) :span 5/4 :extend (- s - s) :methods nil :polyphony nil :leading nil :iterate nil)    #|7|# ((- 1 3 3) :span 5/4 :extend (s s - -) :methods nil :polyphony nil :leading nil :iterate nil)    #|8|# ((3 4 1 6) :span 3/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|9|# ((1 3 3 4) :span 5/4 :extend (s - s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|10|# ((4 1 6 2) :span 5/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|11|# ((3 3 4 3) :span 3/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    #|12|# ((1 6 2 4) :span 5/4 :extend (- s s -) :methods nil :polyphony nil :leading nil :iterate nil)    ))  
     
     
     
    MAKE-DICTUM
     
    The MAKE-DICTUM macro generates a counterpoint template with a number of dictum lists. Every list contains a list of voices and methods ready to be defined by the composer. This function is a companion to the COUNTERPOINT function.
     
    Examples:
    (make-dictum 4 12)  
    The result in the Listener:
    (counterpoint patterns '(    #|1|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|2|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|3|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|4|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|5|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|6|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|7|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|8|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|9|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|10|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|11|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    #|12|# ((- - - -) :span nil :extend nil :methods (- - - -) :polyphony nil :leading nil :iterate nil)    ) :global-methods '(- - - -) :global-polyphony nil )  
    Depending on your rules and methods the defined counterpoint template could look something like this:
    (setf Sec-A (counterpoint   patterns   '(     #|1|# ((2 - 7 4) :span nil :extend nil :methods (d.2 - v? -))     #|2|# ((4 10 9 10) :span nil :extend nil :methods (- d.6 - (d.4 r)))     #|3|# ((- 4 8 9) :span nil :extend nil :methods (- d.2 - ri))     #|4|# ((- 13 - 12) :span nil :extend nil :methods (- i - t6))     #|5|# ((- - - 13) :span nil :extend nil :methods (- - - d.7))     #|6|# ((9 12 - -) :span nil :extend nil :methods (i d.8 - -))     #|7|# ((- 1 7 11) :span nil :extend nil :methods (- ri r i))     #|8|# ((10 4 3 1) :span nil :extend nil :methods (i > - <))     #|9|# ((8 8 - 8) :span nil :extend nil :methods (>< <> - d.3))     #|10|# ((1 8 - 3) :span nil :extend nil :methods (v? (d.6 i) - d.3))     #|11|# ((- 3 9 4) :span nil :extend nil :methods (- - i -))     #|12|# ((8 13 9 -) :span nil :extend nil :methods (d.6 d.3 d.2 -)))   :global-methods '((dyn fl) (dyn cl) (t-12 dyn hn) (t-12 dyn vc))   :global-polyphony '(7 p)))  
     
     
     
    ASSEMBLE-VOICES
     
    ASSEMBLE-VOICES is a twofold operation function. If the index value is a number, the function returns a list of that number. If the index value is a name the function will set indexed variable names to all the voices in the list. The index value set to NIL will return all voices in the list. The assembling of the voices is made by the matrix-transpose operation on a list of lists. This function is a companion to the COUNTERPOINT function.
     
    Examples:
    (setf sec-a       (counterpoint        patterns        '(((5 - - -))          ((4 - - -))          ((2 - - -))          ((3 - - -))          (- :span 2/4))        :global-methods '((dyn fl) - - -))) (setf sec-b       (counterpoint        patterns        '(((- 5 2 -) :span 3/4 :methods (- ri - -))          ((- 2 2 6) :span 3/4 :methods (- > (dl.3) -))          ((5 1 - 5) :span 3/4 :methods (- (dl.2) - i))          ((1 2 6 3) :span 2/4 :methods (< ri i -))          ((- 1 5 3) :span 5/4 :methods (- > t7 i))          ((2 6 3 -) :span 3/4 :methods (- < - ri))          ((5 5 8 3) :span 3/4 :methods ((dl.3 i) >< > -))          ((3 3 - 4) :span 2/4 :methods ((i >) (dl.2 i) - (dl.3)))          ((- 7 - 7) :span 3/4 :methods (- i - (t-12 ri)))          ((4 6 6 8) :span 2/4 :methods (< (dl.2) r -))          (- :span 2/4))        :global-methods '((dyn fl)                          (dyn cl)                          (t-12 dyn hn)                          (t-12 dyn vc)))) (setf sec-c       (counterpoint        patterns        '(((7 4 - 5) :methods (< > i v?) :extend (s - s -))          ((- 3 4 -) :methods (- < > -) :extend (s - s -))          ((2 - 8 1) :methods (- - - v?) :extend (s - s -))          ((8 8 6 6) :methods (< > - (dl.2 i)) :extend (s - s -))          ((- 3 3 -) :methods (- i (dl.2) -) :extend (s - s -))          ((- 4 8 -) :methods (- (ri dl.2) > -) :extend (s - s -))          ((1 2 2 3) :methods (< > i -) :extend (s - s -)))        :global-methods '((dyn fl)                          (dyn cl)                          (t-12 dyn hn)                          (t-12 dyn vc)))) (setf sec-d       (counterpoint        patterns        '(((- 3 - -) :methods (- - - -))          ((- 2 - -) :methods (- - - -))          ((- 4 - -) :methods (< - - -))          ((1 1 1 1) :methods (>< <> (r dl.2) (i dl.2))))        :global-methods '((dyn fl) (dyn cl) (dyn hn) (dyn vc))))  
    Returns 1st voice from all sections:
    (assemble-voices 1 sec-a sec-b sec-c)  
    Returns 4th voice from all sections:
    (assemble-voices 4 sec-a sec-b sec-c)  
    Sets indexed variable names to all voices in the sections:
    (assemble-voices 'vox sec-a sec-b sec-c) => (vox1 vox2 vox3 vox4)  
     
     
     
    CHORALIS
     
    The function CHORALIS returns four voice polyphony (soprano, alto, tenor and bass) by sorting the voices and taking the closest path to the previous chord. There are three path options: closest, relative and comparative.
     
    The ambitus for each voice can be defined with the ambitus option. The default ambitus for bass is (-20 5), for tenor (-10 9), for alto (-7 14) and for soprano (2 21). The ambitus form is: '((-20 5) (-10 9) (-7 14) (2 21)) or '(bass tenor alto soprano).
     
    The interval option, defines the largest interval step in a voice.
     
    Each of the voices can be modified by methods which are defined in the DEF-UNFOLD-SET library. The method symbols are method names used in the UNFOLD function. The default set 'om can be found in the Utilities/Library/Default-Unfold-Sets library.
     
    The methods can be applied to a bar and events.
    Transposition 6 applied to 6th bar:
    (t5 6)  
    Transposition -12 applied to 4th bar, events 1 and 2 only:
    (t-12 4 (1 2))  
    The edit option allows to replace the entire bar with a new events. This option is useful for creating a melodic movement in a voice.
    Number of chords in a omn-form should be one:
    (h g4b4d5)  
    To repeat a voice polyphony we add an additional length value:
    (q e4g4b4 q) (q g4bb4d5 q q q)  
    Examples:
    I.
    (setf chords       '((w c4e4g4) (h g4b4d5) (h c4e4g4) (-h) (q e4g4b4 q)         (q a4c5e5 mp leg q leg) (q g4b4d5 leg) (q f4a4c5) (w d4f4a4)         (w a4cs5e5 mf) (-q) (q d4f4a4 q q) (q a4c5e5) (h c4e4g4) (h d4f4a4)         (q d4fs4a4 leg q leg q) (h g4b4d5 h) (-q) (q bb4d5f5 q q)         (w eb4g4bb4) (-q) (q c4eb4g4 q) (q g4bb4d5) (h c4eb4g4) (h bb4d5f5)         (w f4a4c5 h) (-q) (q d4fs4a4) (q g4bb4d5 q q q) (h d4fs4a4 h)         (-q) (q g4bb4d5) (h c4eb4g4) (h g4bb4d5) (h d4fs4a4 h) (h. g4bb4d5)         (-q) (w g4bb4d5) (h d4f4a4 h) (-q) (q a4c5e5) (q a4c5e5) (q a4c5e5)         (h c4eb4g4) (h c4eb4g4) (h g4bb4d5) (q g4bb4d5) (q g4bb4d5)         (h d4f4a4) (h d4f4a4) (-q) (q d4f4a4 mf) (q a4c5e5 f) (q d4f4a4 p)         (h. b4d5fs5 p) (q d4f4a4 mp) (q f4a4c5 q q q) (w e4g4b4) (h a4c5e5)         (-h) (h d4fs4a4) (q d4fs4a4 q) (h g4b4d5) (h g4b4d5) (h e4g4b4)         (q e4g4b4) (q e4g4b4) (h. c4e4g4) (q c4e4g4) (h f4a4c5)         (q f4a4c5) (q bb4d5f5) (h. g4b4d5) (q c4e4g4) (h a4cs5e5)         (h d4f4a4) (q g4b4d5) (q d4fs4a4) (w g4b4d5 p) (w g4b4d5 pp)))    (choralis chords           :rotation 1           :index 'v           :interval 8           :path '?           :seed 826083           :methods           '(:sop ((t5 6) (t-4 (31 32) (3 1)) (t-12 32 2))             :ten ((t4 (31 32) (3 1)))             :bass ((t-12 (1 2 3)) (t-12 4 (1 2)))))    (ps 'gm :satb (list v1 v2 v3 v4)     :flexible-clef nil     :tempo 60)
     
    II.
    Example with edit option:
    (progn   (choralis    '((w a4c5e5 p<)      (w g4bb4db5 mp< :r 3)      (q a4c5eb5 < :r 15)      (q a4c5eb5 f)      (q a4c5eb5 > :r 16)      (w e4g4bb4 > :r 2)      (w a4c5e5 pp :r 2))    :rotation '?    :path 'relative    :index 'voice    :methods '(               :sop dyn               :alt dyn               :ten dyn               :bass dyn               )    :edit '(            :alt ((q as4 p c5 f4 e4) 2)            :ten ((q as4 p c5 eb5 as4) 3)            :bass ((q a3 p c4 f3 eb3) 4)           )    :seed 45    )      (ps 'gm :satb (list voice1 voice2 voice3 voice4)       :time-signature '(4 4)       :flexible-clef nil       :tempo 60)   )
     
     
     
     
    GEN-CHORALIS
     
    This function allows you to generate a list of CHORALIS chords with optional velocity and attributes values. This function is a companion to the CHORALIS function.
     
    Examples:
    I.
    (setf bartok '(c4eb4g4 c4e4g4 db4fs4a4 eb4g4bb4 e4g4bb4                fs4a4c5 bb4c5ds5 a4c5eb5 a4c5e5 b4db5fs5)) (setf chords (rnd-sample 31 bartok :seed 857438)) => (fs4a4c5 a4c5e5 b4db5fs5 b4db5fs5 b4db5fs5 c4e4g4     db4fs4a4 fs4a4c5 bb4c5ds5 b4db5fs5 b4db5fs5 b4db5fs5     eb4g4bb4 b4db5fs5 c4eb4g4 c4eb4g4 e4g4bb4 c4e4g4     eb4g4bb4 b4db5fs5 bb4c5ds5 bb4c5ds5 db4fs4a4     a4c5eb5 c4eb4g4 a4c5eb5 c4e4g4 a4c5e5 db4fs4a4     c4eb4g4 fs4a4c5) (setf lengths (gen-prob 31 '((h .4) (q .2) (h. .4) (q .3)                              (-h .2) (-q .3) (w .5)) :seed 441896)) => (-1/2 1 1/4 1 -1/4 3/4 1 1 -1/2 3/4 1/4 1/2 3/4 1 1/2 1     1/4 1/2 1/2 1/4 -1/4 1/4 1/2 1/4 1 3/4 -1/4 1 -1/2 1/2 1) (setf velocity (gen-prob 31 '((p .4) (mp .4) (mf .3) (f .2)) :seed 435)) => (mp f f mf mp mp mp p p p mp p mf mp f mp     mf p mp mf f f mf p p mf mp f mf f p) (setf chords (gen-choralis lengths chords :velocity velocity)) => ((-h) (w fs4a4c5 mp) (q a4c5e5 f) (w b4db5fs5 f) (-q) (h. b4db5fs5 mf)     (w b4db5fs5 mp) (w c4e4g4 mp) (-h) (h. db4fs4a4 mp) (q fs4a4c5 p)     (h bb4c5ds5 p) (h. b4db5fs5 p) (w b4db5fs5 mp) (h b4db5fs5 p)     (w eb4g4bb4 mf) (q b4db5fs5 mp) (h c4eb4g4 f) (h c4eb4g4 mp)     (q e4g4bb4 mf) (-q) (q c4e4g4 p) (h eb4g4bb4 mp) (q b4db5fs5 mf)     (w bb4c5ds5 f) (h. bb4c5ds5 f) (-q) (w db4fs4a4 mf) (-h)     (h a4c5eb5 p) (w c4eb4g4 p)) (choralis chords           :index 'v           :seed 653886           :methods '(:sop dyn                      :alt dyn                      :ten dyn                      :bass dyn)) (ps 'gm :satb (list v1 v2 v3 v4)     :flexible-clef nil     :time-signature '(4 4)     :tempo 60)
     
    II.
    Microtonal example with quarter and eighth tone intervals:
    (setf mbartok '(c4eb4-g4 c4e4g4+ db4fs4+a4 eb4-..g4bb4 e4g4bb4-                 fs4a4+c5. bb4c5ds5 a4c5.eb5 a4c5e5+ b4+db5fs5)) (setf mchords (rnd-sample 31 mbartok :seed 857438)) (setf chords2 (gen-choralis lengths mchords :velocity velocity)) (choralis chords2           :index 'm           :seed 653886           :methods '(:sop dyn                      :alt dyn                      :ten dyn                      :bass dyn)) (ps 'vsl :satb (list m1 m2 m3 m4)     :flexible-clef nil     :time-signature '(4 4)     :tempo 60)
     
     
     
     
    TONNETZ
     
    The principal transformations of neo-Riemannian triadic theory connect triads (major and minor), and are their own inverses (a second application undoes the first). These transformations are purely harmonic, and do not need any particular voice leading between chords: all instances of motion from a C major to a C minor triad represent the same neo-Riemannian transformation, no matter how the voices are distributed in register.
     
    The three transformations move one of the three notes of the triad to produce a different triad:
     
    The P transformation exchanges a triad for its Parallel. In a Major Triad move the third down a semitone (C major to C minor), in a Minor Triad move the third up a semitone (C minor to C major)  
    The R transformation exchanges a triad for its Relative. In a Major Triad move the fifth up a tone (C major to A minor), in a Minor Triad move the root down a tone (A minor to C major)  
    The L transformation exchanges a triad for its Leading-Tone Exchange. In a Major Triad the root moves down by a semitone (C major to E minor), in a Minor Triad the fifth moves up by a semitone (E minor to C major).  
    Observe that P preserves the perfect fifth interval (so given say C and G there are only two candidates for the third note: E and Eb), L preserves the minor third interval (given E and G our candidates are C and B) and R preserves the major third interval (given C and E our candidates are G and A).
     
    Secondary operations can be constructed by combining these basic operations:
     
    The N (or Nebenverwandt) relation exchanges a major triad for its minor subdominant, and a minor triad for its major dominant (C major and F minor). The N transformation can be obtained by applying R, L, and P successively.  
    The S (or Slide) relation exchanges two triads that share a third (C major and Cs minor); it can be obtained by applying L, P, and R successively in that order.  
    The H relation (LPL) exchanges a triad for its hexatonic pole (C major and Ab minor) Any combination of the L, P, and R transformations will act inversely on major and minor triads: for instance, R-then-P transposes C major down a minor third, to A major via A minor, whilst transposing C minor to Eb minor up a minor 3rd via Eb major.
     
    Neo-Riemannian transformations can be modelled with several interrelated geometric structures. The Riemannian Tonnetz (‘tonal grid’, shown below) is a planar array of pitches along three simplicial axes, corresponding to the three consonant intervals. Major and minor triads are represented by triangles which tile the plane of the Tonnetz. Edge-adjacent triads share two common pitches, and so the principal transformations are expressed as minimal motion of the Tonnetz.
     
     

     
     
    One step transformation (basic transformations):
    P (parallel)
    R (relative)
    L (leading)
     
    Secondary One step transformation (combine transformations):
    N (RLP)
    S (LPR)
    H (LPL)
     
    Two step transformations:
    Parallel: PR and PL
    Relative: RL and RP
    Leading: LR and LP
     
    Three step transformations:
    Parallel: PLR and PRL
    Relative: RLP and RPL
    Leading: LPR and LRP
     
    Reflection:
    PLR and RLP are equal.
    PRL and LRP are equal.
    RPL and LPR are equal.
     
    Examples:
    (tonnetz 'c4e4g4 '(p p r r l l)) => (c4e4g4 c4eb4g4 c4e4g4 c4e4a4 c4e4g4 b3e4g4 c4e4g4) (tonnetz '(c4 e4 g4) '(p p r r l l)) => ((c4 e4 g4) (c4 eb4 g4) (c4 e4 g4) (c4 e4 a4)     (c4 e4 g4) (b3 e4 g4) (c4 e4 g4)) (tonnetz 'e4g4b4 '(l r l r p l r l r p)) => (e4g4b4 e4g4c5 e4a4c5 f4a4c5 f4a4d5 fs4a4d5 fs4a4cs5     e4a4cs5 e4gs4cs5 e4gs4b4 e4g4b4) (tonnetz 'ab3c4eb4 '(p l p l p l p l)) => (ab3c4eb4 gs3b3eb4 gs3b3e4 g3b3e4 g3c4e4 g3c4eb4 gs3c4eb4     gs3b3eb4 gs3b3e4) (tonnetz 'ab3c4eb4 '(pl pl pl pl)) => (ab3c4eb4 gs3b3e4 g3c4e4 gs3c4eb4 gs3b3e4) (tonnetz 'c4e4g4 '(p r p r p r p r)) => (c4e4g4 c4eb4g4 bb3eb4g4 bb3eb4fs4 bb3cs4fs4 a3cs4fs4     a3cs4e4 a3c4e4 g3c4e4) (tonnetz '(ab4 m) '(p n l s l n)) => (ab4b4eb5 gs4c5eb5 gs4cs5e5 a4cs5e5 bb4cs5f5 bb4cs5fs5 b4d5fs5) (setf moves (rnd-order '(p l r lr lp rp rl pr pl plr prl rpl) :seed 26)) => (rp rl rpl pr prl lr r p plr pl lp l) (tonnetz 'c4e4g4 moves) => (c4e4g4 cs4e4a4 d4fs4a4 eb4fs4bb4 eb4g4c5 f4a4c5 e4g4c5     e4a4c5 e4a4cs5 f4a4d5 fs4a4cs5 f4a4d5 f4bb4d5) (setf transitions '(p l r lr lp rp rl pr pl plr prl rpl prlpr lrplprpp)) (setf rnd-transition (rnd-sample 15 transitions :seed 750989)) => (prlpr r r p pl pl lrplprpp lr prlpr rpl lp rl prl rl rpl) (tonnetz 'ab3c4eb4 rnd-transition)) => (ab3c4eb4 g3c4eb4 g3bb3eb4 g3c4eb4 g3c4e4 gs3c4eb4 gs3b3e4     f3bb3d4 f3a3c4 e3a3c4 eb3gs3c4 e3g3c4 f3a3c4 eb3g3c4     d3g3bb3 cs3fs3bb3) (tonnetz '(c maj) '(plp rpr lpl rpr lpl lpl rprp lpl)) => (c4e4g4 b3eb4gs4 a3d4fs4 bb3cs4f4 gs3b3e4 g3c4eb4 gs3b3e4 bb3d4f4 a3cs4fs4) (progn   (setf transitions '(p l r lr lp rp rl pr pl plr prl rpl prlpr lrplprpp))   (setf rnd-transition (rnd-sample 15 transitions :seed 750989))   (setf tonnetz (tonnetz '(ab5 m) rnd-transition))   (setf chords (gen-choralis '(w h h h h h h h h h h h h h h w) tonnetz))   (choralis chords             :rotation -1             :index 'v             :interval 6             :path '?             :seed 570136             )      (ps 'gm :satb (list v1 v2 v3 v4)       :flexible-clef nil       :tempo 60)   )
     
     
     
     
    DENSITY
    The DENSITY function will increase or decrease the number of events in a sequence. It will allow you on the fly to change the density and expression of the pattern without changing the original sequence span.
     
    (setf pattern '(e f4 e4 c4 - a4 g4 d4 - ab4 db4 eb4 - gb4 bb4 b4 -))
    To find out the density of a sequence we call the GET-DENSITY function:
    (get-density pattern :type :length) => 0.38  
    Let’s set the density of the sequence to a 0.9 value.  This will increase the number of events, knowing the original density is 0.38:
    (density .9 pattern :seed 45) => (s f4 f4 e4 t t s c4 c4 -e s a4 a4 g4 t t s d4 t t -e     s ab4 ab4 t db4 db4 s t eb4 eb4 s -e s gb4 gb4 bb4 bb4 b4 b4 -e)  

     
    The intervals option allows you to define intervals to align with newly created lengths.
    (density .9 pattern :intervals '(0 6 1 6) :seed 45) => (s f4 b4 e4 t bb4 e5 s c4 fs4 -e s a4 eb5 g4 t cs5 g5     s d4 t gs4 d5 -e s gs4 d5 t cs4 g4 s t eb4 a4 s -e     s fs4 c5 bb4 e5 b4 f5 -e)
     
    In the next example we set the density value to 0.5:
    (density .5 pattern :seed 45) => (e f4 s e4 e4 e c4 - a4 g4 d4 - s ab4 ab4     e db4 s eb4 eb4 -e gb4 bb4 s b4 b4 -e)
     
    Below is an example with a low density value 0.2. This will decrease (swallow) a number of events from the sequence:
    (density .2 pattern :seed 45) => (e f4 mf - c4 - a4 g4 d4 -q e db4 -h.)
     
    The legato option will extend the length-note with a sum of length-rests in sequence:
    (density .2 pattern :seed 45 :legato t) => (q f4 c4 e a4 g4 q. d4 h.. db4)
     
    Examples:
    (setf sequence '((s eb1 p g2 cs3 f e3 mp bb3 g3 a3 b3 3h d4 eb4 d4 p)                  (3h cs4 p b3 f bb3 e a3 mf bb3 gs3 g3)                  (q g3 pp 3h gs3 3q q bb3 5h mp b3 5q c4 p tie)                  (5q c4 p 5h b3 b3 q bb3 mp e bb3 a3 5h. a3 5h gs3 p)                  (q gs3 mf 5h. gs3 5h g3 5q g3 g3 fs3 fs3 mp f3 s f3 - f3 =)))
     
     
    Original density:
    (get-density sequence :type :length) => (0.69 0.44 0.44 0.5 0.69) (density '(1.0 .95 .8 .75 .8) sequence           :intervals '(0 13 1 11) :seed 23)  

     
     
    (density '(.3 .1 .1 .2 .1 .2) sequence :seed 23)
     
     
    (density '(.3 .1 .1 .2 .1 .2) sequence :legato t :seed 23)
     
     
     
    MICROTONALITY
     
    Microtone pitch symbols and values:
    +                       1/4
    -                      -1/4
    .   with sharp          1/8
    ..  with sharp          3/8
    .   with flat          -1/8
    ..  with flat          -3/8
    +.  with flat or sharp  1/8
    +.. with flat or sharp  3/8
    -.  with flat or sharp -1/8
    -.. with flat or sharp -3/8
     
    Quarter tone
    '(q a4 a4+ as4 as4+ b4 b4- bb4 bb4- a4)
     
    Eight tone
    '(q a4 a4. a4+ a4.. as4 as4. as4+ b4-. b4     b4-. b4- b4-.. bb4 bb4. bb4- a4. a4)
     
    Chord
    '(w c4ds4+g4as4+)
     
    Integer, interval and midi microtone values:
     
    0.5   =  1/4 tone
    0.25  =  1/8 tone
     
    Transposition
    (pitch-transpose 2.5 '((a4 a4+ b4 d5) (e5 e5+ fs5 a5))) => ((fs4+ g4 gs4+ b4+) (cs5+ d5 ds5+ fs5+))
     
    In the next example we generate a row of quarter tones using RND-ROW function with optional :quantize 1/4. If :quantize is set to 1/8 value, the function will return 8th tone row with 48 values.
    (setf mat (rnd-row :quantize 1/4 :type :pitch :seed 34)) => (c4 g4 ds4+ cs4 d4+ b4+ f4+ a4+ gs4+ e4+ b4 as4+     e4 bb4 cs4+ a4 d4 g4+ fs4+ eb4 c4+ gs4 fs4 f4)
     
     
    Intervals
    (pitch-to-interval mat) => (7 -3.5 -2.5 1.5 9 -6 4 -1 -4 6.5 0.5 -6.5     6 -8.5 7.5 -7 5.5 -1 -3.5 -2.5 7.5 -2 -1) (interval-to-pitch '(1.5 2 -1 -1.5 1 .5 .5)) => (c4 cs4+ ds4+ d4+ cs4 d4 d4+ eb4)
     
     
    Hertz to pitch (quantize)
    (setf hertz '(448 880 1320 1760 2200 2640 3212 3520)) (hertz-to-pitch hertz :quantize 1/4) => (a4+ a5 e6 a6 cs7 e7 g7+ a7)
     
    (hertz-to-pitch hertz :quantize 1/8) => (a4. a5 e6 a6 c7.. e7 g7+ a7)
     
     
    Thats all for now.
    Best wishes,
    Janusz
  21. Like
    hujairi reacted to Stephane Boussuge in Cells for Ensemble   
    A short piece as an Hommage to Bruno Maderna.
    This piece was presented in Venice Italy for the "Musica Domani" in 7th December 2019. 
    It use a lot of new functionalities from the upcoming Opusmodus Version 1.4 .
    SB.

     
     
  22. Thanks
    hujairi reacted to Stephane Boussuge in VSL Syncron-ized Special Edition Plus Soundset   
    Hello,
     
    here's the VSL Syncron-ized Special Edition Plus Soundset.
     
    All the best !
    Stéphane
    VSL-SynchronSpecial-Edition.lisp
  23. Thanks
    hujairi reacted to opmo in Opusmodus 1.3.24769   
    – New functions: 
    get-sieve-tree sieve-merge sieve-tree-series sieve-tree sieve pick-prob gen-prob create-osc-thread get-osc-thread-from-name send-osc-data osc-thread-alive? end-all-osc-threads end-osc-thread – Howto Score/OSC/OSC Threads.opmo
    – Changes to OSC functions, please check the new OSC documents if you use OSC.
    – Musicxml display improvements.

     
    SIEVE-TREE
    This function returns a sequence of lengths symbols derived from tree-data in a given root, node and level number.
     
    Examples:
    Low density output:
    (sieve-tree 32 2 3)
     
    With a smaller root number and a higher level number we increase the density:
    (sieve-tree 8 2 5)
     
    In the following example we add probability values using lists of paired values to node, level and rest parameters. The first value in the rest lists is a percentage value of the length-rests in a node-level list.
    (sieve-tree '(4 2)             '((2 0.43) (3 0.37))             '((3 0.47) (4 0.56) (5 0.68))             :rest '((20 0.43) (80 0.6) (0 0.7))             :quantize '(1 2 3 4 5 7))  

     
    Here we are increasing the length-rest probability and set the quantize to quarter, eight and quintuplet only:
    (sieve-tree '(4 2)             '((2 0.43) (3 0.37))             '((3 0.47) (4 0.56) (5 0.68))             :rest '((20 0.43) (80 0.6) (90 0.7))             :quantize '(1 2 5))  

     
    The expression below will generate 96 bars of gradual increase in the density:
    (sieve-tree 96 2 7 :seed 43)  
    Let's examine the original tree-data from the expression above. To do that we call the GET-SIEVE-TREE function with the same tree values:
    (get-sieve-tree 96 2 7)  
     
    SIEVE-TREE-SERIES
    SIEVE-TREE-SERIES returns a sequence of lengths symbols derived from a series of tree-data in a given root, node and level number. This function allows you to control individual tree-data parameters ie. density results. Please note, every parameter has a keyword, except the root number.
     
    Examples:
    (sieve-tree-series '((8 :node 2 :level ((3 0.47) (4 0.56) (5 0.68))                         :rest ((40 0.43) (80 0.6) (0 0.7))                         :quantize (1 2 4))                      (3 :node 2 :level ((3 0.47) (4 0.56) (5 0.68))                         :quantize (1 2 3 5 6))                      (2 :node 3 :level ((4 0.46) (5 0.58)) :seed 23)))
     
    (sieve-tree-series '((2 :node 2 :level ((4 0.47) (5 0.66))                         :rest ((40 0.43) (80 0.6) (0 0.7)))                      (8 :node 2 :level ((3 0.47) (4 0.56))                         :quantize (1 2 3 5 6))                      (3 :node 3 :level ((4 0.46) (5 0.58))                         :rest ((40 0.43) (80 0.6) (0 0.7)))))
     
     
    GET-SIEVE-TREE
    GET-SIEVE-TREE returns a tree node degree data from a given root, node and level number.  This function is useful for analysis of the original tree-data used in the SIEVE-TREE function.
     
    Examples:
    (get-sieve-tree 96 2 1) => ((48 48)) (get-sieve-tree 96 3 1) => ((32 32 32)) (get-sieve-tree 96 2 2) => (((24 24) (16 16 16))) (get-sieve-tree 96 3 2) => (((32) (16 16) (32/3 32/3 32/3))) (get-sieve-tree 96 2 3) => (((12 12) (8 8 8)) ((16) (8 8) (16/3 16/3 16/3))) (get-sieve-tree 96 3 3) => (((16 16)) ((8 8) (16/3 16/3 16/3)) ((32/3) (16/3 16/3) (32/9 32/9 32/9))) (get-sieve-tree 96 2 5) => (((3 3) (2 2 2)) ((4) (2 2) (4/3 4/3 4/3)) ((4 4)) ((2 2) (4/3 4/3 4/3))     ((8/3) (4/3 4/3) (8/9 8/9 8/9)) ((4 4) (8/3 8/3 8/3)) ((2 2) (4/3 4/3 4/3))     ((8/3) (4/3 4/3) (8/9 8/9 8/9)) ((8/3 8/3)) ((4/3 4/3) (8/9 8/9 8/9))     ((16/9) (8/9 8/9) (16/27 16/27 16/27)))  
    SIEVE-TREE example with root 8, node 2 and level 5:
    (sieve-tree 8 2 5)
     
    Analysis of the above tree-data:
    (get-sieve-tree 8 2 5) => (((1/4 1/4) (1/6 1/6 1/6)) ((1/3) (1/6 1/6) (1/9 1/9 1/9)) ((1/3 1/3))     ((1/6 1/6) (1/9 1/9 1/9)) ((2/9) (1/9 1/9) (2/27 2/27 2/27))     ((1/3 1/3) (2/9 2/9 2/9)) ((1/6 1/6) (1/9 1/9 1/9))     ((2/9) (1/9 1/9) (2/27 2/27 2/27)) ((2/9 2/9)) ((1/9 1/9) (2/27 2/27 2/27))     ((4/27) (2/27 2/27) (4/81 4/81 4/81)))  
     
    SIEVE
    SIEVE returns a list of numbers to a given modulus, shift and maximum number. This function can be useful in generating root numbers for the SIEVE-TREE function.
    (sieve 4 0 96) => (0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 72 76 80 84 88 92 96)  
    Examples:
    (sieve 2 0 60) => (0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32     34 36 38 40 42 44 46 48 50 52 54 56 58 60) (sieve 2 1 60) => (1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33     35 37 39 41 43 45 47 49 51 53 55 57 59)  
    Example with SIEVE-TREE function:
    (sieve-tree (sieve 3 4 14)             '((2 0.43) (3 0.37))             '((3 0.47) (4 0.56) (5 0.68))             :rest '((20 0.43) (80 0.6) (90 0.7)))
     
     
    SIEVE-MERGE
    SIEVE-MERGE returns a list of numbers derived from merging a number of sieve lists. This function can be useful in generating root numbers for the SIEVE-TREE function.
     
    Examples:
    Here we merge two sieve lists, one from (sieve 3 0 96) and one from (sieve 4 0 96):
    (sieve-merge '(3 0 4 0) 96) => (0 3 4 6 8 9 12 15 16 18 20 21 24 27 28 30 32 33 36 39 40 42 44 45 48 51     52 54 56 57 60 63 64 66 68 69 72 75 76 78 80 81 84 87 88 90 92 93 96)  
    Example with SIEVE-TREE and SIEVE-MERGE function:
    (sieve-tree (sieve-merge '(3 2 4 2) 12)             '((2 0.43) (3 0.37))             '((3 0.47) (4 0.56) (5 0.68))             :quantize '(1 2 4 8))
     
     
    PLEASE NOTE!
    The changes to OSC implementation - see below - are thanks to Rangarajan Krishnamoorthy.
    If you use OSC threads please revise your OSC files and make the necessary adjustments.
     
    The CREATE-OSC-THREAD function creates the OSC thread with a given target.
    Here we assign a name Reaktor to a remote-host: 127.0.0.1 and remote-port: 10000:
    (defparameter reaktor '(127.0.0.1 10000)) Here we assign an variable to our OSC thread object, this is important for sending the data with the thread and for ending the thread:
    (setf thd1 (create-osc-thread "thread1" reaktor)) To send OSC messages with the thread we call the SEND-OSC-DATA function:
    (send-osc-data thd1 '((0.0 1/2) (0.0 1/2) (0.08238555 2)                       (0.10876829 1) (0.12127061 11/2))) To end the OSC thread and the sending of the OSC messages, we call the END-OSC-THREAD function:
    (end-osc-thread thd1)  
    The SEND-OSC-THREAD function sends OSC data and performs a small amount of "background" processing on messages in the queue when the processor would otherwise be idle. This function can be called on a created thread any number of times during its lifetime.
    (defparameter reaktor '(127.0.0.1 10000)) (defparameter time (rnd-sample 50 '(1/4 1/2 1/4))) (defparameter values (vector-smooth 0.05 (gen-white-noise 500))) (defparameter data (gen-osc-data 60 values :time time)) (setf thd1 (create-osc-thread "thread1" reaktor)) (send-osc-data thd1 data)  
    The GET-OSC-THREAD-FROM-NAME function returns the OSC thread from a given name. This function is useful if you don’t assign  a variable to the thread object.
     
    Note we are not capturing the thread object returned from this function:
    (create-osc-thread "thread1" reaktor) We can get the thread object using its name when we want:
    (send-osc-data (get-osc-thread-from-name "thread1")                '((0.0 1/2) (0.3254655 1/2) (0.08238555 2)                  (0.10876829 1) (0.12127061 11/2))) (end-osc-thread (get-osc-thread-from-name "thread1")) The OSC-THREAD-ALIVE? function checks if the given OSC thread object is still alive and returns T if true.
    (setf thd1 (create-osc-thread "thread1" '(127.0.0.1 10000))) (end-osc-thread thd1) => nil Test:
    (osc-thread-alive? thd1) => nil  
    The END-OSC-THREAD function will end and destroy a given OSC thread. After the thread is destroyed, you cannot send any messages to it.
    (setf thd1 (create-osc-thread "thread1" '(127.0.0.1 10000))) (end-osc-thread thd1) => nil Test:
    (osc-thread-alive? thd1) => nil The END-ALL-OSC-THREADS function will end and destroy all OSC threads. You cannot send any messages to the threads once they are destroyed.
    (defparameter reaktor '(127.0.0.1 10000)) (create-osc-thread "thread1" reaktor) (create-osc-thread "thread2" reaktor) (create-osc-thread "thread3" reaktor) (create-osc-thread "thread4" reaktor) (end-all-osc-threads) => nil Best wishes,
    Janusz
  24. Thanks
    hujairi reacted to opmo in Opusmodus - second monitor   
    The upcoming release will allow you to open display-midi, display-musicxml, graphs and snippets in a separate window. For any of you using second monitor this will be great addition to your work flow.
     
    Examples:
    (display-midi 'score :display :window) (display-musicxml 'score :display :window)  
    Best,
    Janusz
  25. Thanks
    hujairi reacted to opmo in Opusmodus 1.3 release   
    Whats new in version 1.3
     
    Compatibility with macOS Mojave
    
macOS 10.14 Dark Mode
    
CLM added

    OSC added
    
MIDI player improvements
     
    New functions:
    binary-to-attribute
    merge-attributes
    circle-pitch-plot

    circle-rhythm-plot
    xy-plot
    pcs-rhythm

    edit-events
    find-max-span
    fit-to-span

    gen-osc-data

    osc-thread
    
stop-osc-threads
     
    Enhancements and fixes:
    quantizer returns now the count of given length-notes
    single-events returns given type
    don't join dissimilar rests
    fixed rest grouping
    fixed tied 8va or 8vb tuplets
      Installation:
    There are some changes to the Opusmodus user system folder.
    Before opening the new application you need to delete the old Opusmodus folder.
    Make sure you save your personal files (scores, docs etc...) before. A good solution is to rename the Opusmodus folder first and then compress it.
    After you have deleted the Opusmodus user folder you can start the new application.
    At the start Opusmodus will ask you for permission to create a new user folder in your home directory, if you don’t see a window for it, it means the old folder is still on your computer. Make sure the new Opusmodus folder is installed in your home directory.
     
    New Opusmodus folder:
     


    Upgrade:
    Opusmodus 1.3 requires a new serial number to run.
    When purchasing upgrade 1.3 the current user will need to provide an Opusmodus 1.2 serial number.
    After the confirmation which takes a few seconds only, you will be redirected to the purchase page.
    Following the purchase a new serial number will be sent to you by email.
     
    Happy New Year 2019
     
    Yours,
    Janusz Podrazik
×
×
  • Create New...

Important Information

Terms of Use Privacy Policy