Jump to content

AM

Members
  • Content Count

    559
  • Joined

  • Last visited

Posts posted by AM


  1. polytemporal fall - algorithmic study

    [with tempo relations 3:5:7:11:17:23:29]

     

    https://soundcloud.com/andr-meier-1/algorithmic-study-polytemporal-fall

     

    this is a small example: i coordinate and play MIDIs (in this case this are simple scales) in OPMO via OSC -> maxmsp_player. you can here how precise you can coordinate simple [but polytemporal] scales => all the MIDIs coincide (?) - 30000ms after the evaluation of the code - in an unsiono pitch!!! 

     

    in that way you can coordinate different scores/midi's (which have individual tempos (!)) very precise. with OSC/maxmsp_player you can change/manipulate the tempi of the midi's (directly from OPMO) so you can be variable with pre-produced midis (perhaps produced in OPMO)...

     

    greetings

    a.

     

     

     

     

     


  2. "What you are doing Andre is quite bad and unsafe"

    very friendly, your answer 🤨

     

    ...and i knew that, but i didn't found some hints (jn the tutorials) how to extract OMN from def-score. of course it is not good, but it took me only 2 minutes to briefly the problem for my specific application. i have not written any official opusmodus-function (which can do anything) but a simple solution which helps me.

     


  3. oh, this was simple 🙂 here is a small program, it works...

     

    (defun get-pitch-from-midi (midipath)
      (loop for i in (flatten (compile-score
                               (midi-to-score midipath)
                               :output :score))
        when (or (chordp i)
                 (pitchp i))
        collect i))
    
    
    
    (get-pitch-from-midi "path/filename")

     

    also with length?!

     

    (defun get-length-from-midi (midipath)
      (loop for i in (flatten (compile-score
                               (midi-to-score midipath)
                               :output :score))
        when (and (lengthp i)
                  (not (integerp i)))
        collect i))
    
    
    (get-length-from-midi "path/filename")

     

    but will not work with more then one voice / its not necessary for MY needs, so i coded only this simple solution - perhaps janusz will do it?


  4. dear all

    here is a setup for playing midi-files/scores in polytempi / follow the instructions and have fun!

    just ask if you have some questions...

     

    greetings

    andré

     

    - personally i will use it for exact sample/e-player perfomance with my pieces which are working with "Technology-Assisted Conducting"

    http://polytempo.zhdk.ch ... in future i will do it all directly from OPMO or lisp - "live score generating" + polytempo-conducting + e-player)

    - i have already done this with my piece MODULAR FORM  but not all controlled by LISP/OPMO, so next step is doing it all in OPMO/LISP

     

    ...some explanations about the piece....

     

     

     

    greetings

    andré

     

    EN.WIKIPEDIA.ORG

     

    ;;; POLYTEMPO-PLAY
    ;;; with a MAX-patch (from my friend thomas peter) and some OSC-send i can play the same/different midis (up to 30) 
    ;;; in different tempos in parallel - any combination, with precise coordination
    ;;; also possible: change global velocity (means: change velocity inside midi)
    ;;;                time-delay (start) in ms
    
    ;;; 1) OSC-send functions:
    
    (defparameter *out-socket* (make-socket :type :datagram))
    (defparameter *remote-host* "127.0.0.1")
    (defparameter *remote-port* 7500)
    
    (defun udpsend (&rest args)
      (let ((message (apply' osc::encode-message args)))
        (send-to *out-socket* message (length message)
                 :remote-host *remote-host*
                 :remote-port *remote-port*)))
    
    
    ;;; 2) a) put the MAX-player-folder on desktop
    ;;;    b) start midiplayer.maxpat
    ;;;    c) midiplayer: define your output source in [midiout@name "from MAX 1"]
    ;;;    d) the MIDIS must be placed in the midi-folder (inside MAX-player-folder)
    
    
    
    ;;; 3) generate SCORE (here a nonsense example)
    (setf omn (make-omn :pitch (setf pitches 
                                     (filter-repeat 1 
                                                    (flatten (gen-sort 
                                                              (rnd-air :type :pitch :seed 45) 
                                                              :step 5 :sort '> :seed 123))))
                        :length (gen-length '(1) 1/32)
                        :velocity (pitch-to-velocity 'p 'mf pitches :type :float)
                        :span :pitch))
    
    
    (def-score sorted-whitenoise
               (:title "sorted-whitenoise"
                       :key-signature 'atonal   
                       :time-signature '(4 4) 
                       :tempo 60
                       :layout (grand-layout 'inst))
      (inst
       :omn omn
       :port 0
       :channel 1
       :sound 'gm
       :program 'acoustic-grand-piano))
    
    
    ;;; 4) COMPILE that score into your Max-Player/midi-folder => PATH+NAME!!!
    
    (compile-score
     'sorted-whitenoise
     :file "your-path/sorted-whitenoise")
    
    
    
    
    ;;; 5) play it by evaluate UPSEND -> some examples
    ;;; /eplayer / midi-name / tempo-factor / velocity factor / time-delay in ms
    
    
    (udpsend "/eplayer" "sorted-whitenoise" 1.0   0.5 0) ;; originaltempo, velocity 0.5
    (udpsend "/eplayer" "sorted-whitenoise" 2.3   1.0 0) ;; (* tempo 2.3) etc...
    (udpsend "/eplayer" "sorted-whitenoise" 0.375 1.0 2000) ;; (* tempo 0.375 with startdelay 2000ms)
    
    (udpsend "/eplayer" "stop") ; you can stop with that
    
    
    ;;; a tempo-relations => 23:17:13:9:3:2 -> a complex example with time-delays
    ;;; also possible with every and different midis you like
    
    (progn
      (udpsend "/eplayer" "sorted-whitenoise" 2.3 1.0 0)
      (udpsend "/eplayer" "sorted-whitenoise" 0.3 0.8 0)
      (udpsend "/eplayer" "sorted-whitenoise" 0.2 0.4 0)
      (udpsend "/eplayer" "sorted-whitenoise" 1.3 1.0 10000)
      (udpsend "/eplayer" "sorted-whitenoise" 1.7 0.9 16000)
      (udpsend "/eplayer" "sorted-whitenoise" 0.9 0.7 20000))
      
    
    
    (udpsend "/eplayer" "stop") ; you can stop with that

     

     

    Max_Player_19-08-23.zip example.aiff

    goldberg_13_11.aiff example_11_7_5_3_2.aiff


  5. too much code and too complicated to post - I do not have the time to write a manual.

     

    it's a "machine" that creates multiple "brownian bridges" combined with "pitch-contour" and "add-rnd-dust".  it's an all-in-ONE tool/machine/bot...

     

    I'm interested in repetition/difference in other contexts than traditional ones; but "brownian bridges" then resemble ornaments. when the sequences are short - brownian bridges are "rnd-processes" between 2 fixed points - then you will keep ornamental sequences between this 2 points/pitches...

     

    (I did not work with a score, just coding and listening - it's only sketching/testing, not composing. and all the examples are "rnd-generated"/not-composed by the machine, you could produce more and more...)

     

    some links:

     

    Brownian_bridge.png
    EN.WIKIPEDIA.ORG

     

     

    -> in OPMO

     


  6. perhaps you have some better ideas - ...perhaps with range/ambitus... sometimes in trouble - but i only use it for my current work, and so it's no problem 🙂

     

    could be nice if you could do the add-system also with an external list input -> not fibonacci or primes or sum, but perhaps also with any integer or float list. so MODIFY-function could be done with any DATA...

     

    and perhaps it could be also nice for LENGTH and DYNAMICS, i would like that (all-in-one)


  7. generate some examples...

     

    
    ;;; evaluate shift-cmd-e
    
    (progn
      ;gen a sieve
      (setf sieve (gen-sieve '((c0 c5) (c3 c6) (c4 c8))
                            '((14 1 2) (5 5 1 2) (6 2 1))
                            :type :pitch))
    
      ; gen a line inside the sieve
      (setf sample (append (gen-rotate (random 8) 
                                       (pick-sample-from-center sieve (rnd-pick '(7 11))))
                         ))
    
      (pitch-list-plot
       (list
        ; gen modified loines with "compr/expand-melody"
        (setf line1 sample)
    
        (setf line2 (compr/expand-melody sample 
                                          sieve
                                          :type 'add
                                          :n 1
                                          :shift -5))
    
        (setf line3 (compr/expand-melody sample 
                                          sieve
                                          :type 'add
                                          :n 2
                                          :shift -8))
    
        (setf line4 (compr/expand-melody sample 
                                          sieve
                                          :type 'add
                                          :n 3
                                          :shift -11)))
       
       :join-points t)
    
    
    
      (setf chordseq (loop 
                       for i in line1
                       for j in line2
                       for k in line3
                       for l in line4
                       
                       append (chordize (list i j k l)))))
    
    
    
    
    ;;; ecvaluate with command2
    (setf omn (list 's chordseq))
    (setf omn (flatten (list 't line1 '-h 't line2 '-h 't line3 '-h 't line4)))

     


  8. greetings

    andré

    ;;; MODIFY THE PITCH CONTOUR inside a pitchfield or tonality
    ;;; please evaluate the example and have a look to the contours
    
    ;;; subfunction
    
    (defun position-items (items alist)
      (loop 
        for item in items
        append (position-item item alist)))
    
    
    ;;; function
    
    (defun compr/expand-melody (melody field &key (type 'add) (n 1) (shift 0))
      (let* ((ints (loop for i in  (difference 
                                    (position-items (pitch-to-midi melody) 
                                                    (pitch-to-midi field)))
                     collect (cond ((equal type 'add)
                                    (cond ((<= i -1)
                                           (- i n))
                                          ((>= i 1)
                                           (+ i n))
                                          (t i)))
    
                                   ((equal type 'fibonacci)
                                    (cond ((>= i 1)
                                           (+ i (fibonacci i)))
                                          ((<= i -1)
                                           (- i (fibonacci (abs i))))
                                          (t i)))
    
                                   ((equal type 'summativ)
                                    (cond ((>= i 1)
                                           (+ i (+ i n)))
                                          ((<= i -1)
                                           (- i (+ (abs i) n)))
                                          (t i)))))))
    
        (position-filter
         (x+b (interval-to-integer ints :start (car  (position-items melody field))) shift)
         field)))
    
    
    
    ;;; expand 1a
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 2)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 3)
    
            (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 5)
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    ;;; expand 1b => using shift (changed startposition)
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 1
                             :shift 1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 2
                             :shift 2)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 3
                             :shift 3)
    
            (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n 5
                             :shift 4)
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    
    ;;; compress 
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n -1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n -2)
    
            (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'add
                             :n -3)
    
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    
    ;;; expand 2 with fibonacci
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'fibonacci)
        
        (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))
    
    
    
    ;;; expand 3 summativ
    
    (progn
      (setf seed (random 100))
    
      (pitch-list-plot
       (list
        
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'summativ
                             :n 1)
    
        (compr/expand-melody (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1)  :type :pitch) :seed seed) 
                             (gen-sieve '(c1 c9) '(2 1 1) :type :pitch)
                             :type 'summativ
                             :n 2)
    
        
       (rnd-sample 7 (gen-sieve '(c4 c5) '(2 1 1) :type :pitch) :seed seed))
       
       :join-points t))

     

     

    some evaluations -> different melodic contours (rnd / in a sieve) and its expansions

     


  9. dear all

     

    is there a possibility to change the PAN in every EVENT?

    1)

    like '((q c4 mp pan-30) (e c3 pp pan100))  

    would be interesting for LIVE-CODING

    is there something predifined? like it will come up with microtonality/tuning

     

    2)

    and why does it work with simple-midi-sound (a list in :pan) and not with a player like conTimbre (there is something i don't understand with midi/players/etc)?

     

    thanx for a  hint

    andré

     

    an example:
    
    (setf omn '((5q c4 5q 5q 5q 5q 5q 5q 5q) 
                (-q)
                (e e e e e) 
                (-q)
                (7q 7q)
                (3q 3q) 
                (-q)
                (5q 5q 5q) 
                (7q 7q) 
                (3q 3q 3q 3q) 
                (e e) 
                (-q)
                (3q 3q 3q 3q 3q) 
                (e e e e e)))
    
    ;;;
    
    (def-score signature
               (:title "signature"
                       :key-signature 'atonal   
                       :time-signature '(4 4) 
                       :tempo 60)
      (instr
       ;:port 0 
       :omn (omn-replace :velocity (pick-norepeat 100 '(pppp ppppp ppp ppp pp p)) (length-diminution 4 (gen-repeat 10 omn)))
       :tuning (gen-white-noise 100 :scale 0.1)
       :pan '(1 1 1 1 1 1 1 1 10 30 1 1 1 100 100 80 77 15 100 100 100)
       :channel 1
       :sound 'gm-trumpet))
     

     


  10. I got a trial version of the new conTimbre-player-maxpatch (from thomas hummel), now the opusmodus-tuning also works well in conTimbre.

    I think it will be in the next update ... 🙂

     

    ...i like it more in cents then in float...

    (defun cents-to-tuning (centlist)
      (a*x 0.01 centlist))
    
    (cents-to-tuning '(-14 +50 5))
    => (-0.14 0.5 0.049999997)

     


  11. i already did that 🙂

    (defun add-rnd-dust (omnseq &key (span '(0.1)) (seed nil) (quantize '(1 2 3 4 5 6 7 8 9)) (scale 1.0) (tolerance 0.05))
      (let ((rhy (omn :length omnseq))
            (sp))
        (progn 
          (setf rhy (loop 
                      with cnt = 0
                      for i in rhy
    
                      do (setf sp (nth cnt span))
    
                      when (not (null seed))
                      do (incf seed)
                      
                      when (> i 0) 
                      collect   (+ i (car (rnd-number 1 0.0 (* i sp) :seed seed)))
                      else collect (- i (car (rnd-number 1 0.0 (* i sp) :seed seed)))
                      
                      when (< cnt (1- (length span)))
                      do (incf cnt)))
    
          (make-omn :length (quantize (float-to-ratio  rhy :ratio 1/1) quantize :scale scale :tolerance tolerance)
                    :pitch (omn :pitch omnseq)
                    :velocity (omn :velocity omnseq)
                    :articulation (omn :articulation omnseq)))))

     


  12. an example: 

     

    this is the BASIC-version (without "dust"):

    all mapped in 1/32 - retrograde sorting processes (with GEN-SORT):

    pitch-process from chromatic to 12tone-row (by sort) and from sorted length-values (all 1/32,

    then all 1/16 etc... to more complex/mixed pattern (by sort))

     

    Bildschirmfoto 2019-04-26 um 10.49.17.png

     

     

    with this setup:

     

    Bildschirmfoto 2019-04-26 um 10.49.48.png

     

     

    the result with some "dust":

    if you you have a look to the span-list above (compare with the new score) you will see:

    no change at the beginning, then more and more randomized (or made flexible).

     

    Bildschirmfoto 2019-04-26 um 10.48.35.png

     

×
×
  • Create New...