Jump to content

AM

Members
 View Profile  See their activity

  • Posts

    792

  • Joined

  • Last visited

 Content Type 

Posts posted by AM

    tempo as FLOAT

    in Support & Troubleshooting

    Posted

    i like to simulate parts with individual tempo curves (each instrument has its own tempo progession) and calculated "meeting-points". for that you will need INTEGERS. i wrote some pieces with with tempopolyphonic approaches - but i would like to simulate it with OPMO

     

    ---

     

    the software for REALTIME-conducting (PolytempoNetwork) and PolytempoComposer is here:  https://polytempo.zhdk.ch

     

    PolytempoComposer:

    "The application PolytempoComposer allows to explore, sketch and organise complex tempo structures. It is a tool to calculate the exact time of every beat in a constant or variable tempo. Furthermore, it enables composers to find or adjust synchronisation points between voices in different tempos. Due to the graphical user interface, composers can manipulate the parameters of a complex tempo polyphony without any in-depth mathematical knowledge."

     

    ---

     

    in this video (was for something else: i'm sending new tempo curves data from OPMO to the conductingAPP (still without sheet music - only the conducting)) you can see how to manipulate tempo curves so that the end of the phrase is always at second 15. and how to reach a meeting point (e.g. T2 on 1) within the tempo curve at a different point in time. this can be calculated using the POLYTEMPO-COMPOSER app, output/saved as lisp format and then imported and conducted (by the APP). I would like to hear that and simulate it in advance on OPMO. I've already programmed it appropriately (to generate a SCORE with these tempo curves), but the ERROR is always because of float tempos. without float you won't create any usable polytempo structures on OPMO. if you round, the timepoints are of course no longer correct.

     

     

     

    convert-to-binary

    in Function Examples

    Posted

    here is another little function to COMBINE the binary-information i got from CONVERT-TO-BINARY  -> gen a new structure from it

     

    so, with CONVERT-FROM-BINARY and BINARY-LAYER-ADD you could do things like:

    compose music => convert to binary data => generate music by this data  .... ad infinitum 😄 conceptual ....

     

      

    
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; ADDING 3 BINARY-LAYERS IN A WAY THAT INFORMATION COULD BE ENCODED
;;; first layer with 0/1
;;; second layer with 0/2
;;; third layer with 0/4

(defun binary-layer-add (lists)
  (loop 
    for i in (first lists)
    for j in (second lists)
    for k in (if (null (third lists))
               (gen-repeat (length (second lists)) 0)
               (third lists))

    collect (+ i (* j 2)  (* k 4))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(list-plot 
 (binary-layer-add (list
                    (flatten (convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 8))
                    (flatten (convert-to-binary '(-e h -q h e) :bitlength 8))
                    (flatten (convert-to-binary '(p p  ffff mp mf ) :bitlength 8))))
 :join-points t
 :point-radius 0)

(list-plot 
 (binary-layer-add (list
                    (flatten (convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 32))
                    (flatten (convert-to-binary '(-e h -q h e) :bitlength 32))
                    (flatten (convert-to-binary '(p p  ffff mp mf ) :bitlength 32))))
 :join-points t
 :point-radius 0)

(list-plot 
 (binary-layer-add (list
                    (flatten (convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 16))
                    (flatten (convert-to-binary '(-e h -q h e) :bitlength 16  :length-resolution 64))
                    (flatten (convert-to-binary '(p p  ffff mp mf ) :bitlength 16))))
 :join-points t
 :point-radius 0)

     

    some functions

    in Function Examples

    Posted

    here some functions (that i'm using currently). perhaps anyone/OPMO would include/optimze them.. take the ideas...

    greetings

    andré

     

    1) rnd-order/sort-omn => picks omn-seqs/bars in rnd-order and sorting it (a mix-up and sort-process for OMN) 

      

    (defun rnd-order/sort-omn (omnlist &key (type nil) (sort 'a) (step nil))
  (let* ((int-seq (gen-integer 0 (1-(length omnlist))))
         (sorted-int (gen-sort (rnd-order int-seq) :type type :sort sort :step step)))

    (loop for i in (flatten sorted-int)
      collect (nth i omnlist))))

(rnd-order/sort-omn '((w c4 mf) (h d4 ppp ten  e4 ten) (q g4 leg a4 leg b4 leg) (e c5 d5 e5 f5 g5)))
=> ((q g4 leg a4 leg b4 leg) (w c4 mf) (h d4 ppp ten e4 ten) (e c5 d5 e5 f5 g5) (w c4 mf) (q g4 leg a4 leg b4 leg) (h d4 ppp ten e4 ten) (e c5 d5 e5 f5 g5) (w c4 mf) (h d4 ppp ten e4 ten) (q g4 leg a4 leg b4 leg) (e c5 d5 e5 f5 g5))

     

     

     

     

    2) filter-events by pitch (in all octaves!) / pos and neg

      

    ;; SUB

(defun p-octaves (plist)
  (loop for i in '(-48 -36 -24 -12 0 12 24 36 48)
    append (pitch-transpose i plist)))

;;; MAINS
(defun filter-events-pos (pitchlist omnlist)
  (loop 
    for i in (single-events omnlist)
    
    when (null (member (second i) (p-octaves pitchlist)))
    collect '(-1/32) else collect i))


(defun filter-events-neg (pitchlist omnlist)
  (loop 
    for i in (single-events omnlist)
    
    when (null (member (second i) (p-octaves pitchlist)))
    collect i else collect '(-1/32)))


;;;;;

(filter-events-pos '(c4 d4 g4) '(t c4 mf cs4 d4 eb4 e4 f4 fs4 g4 gs4 a4 bb4 b4))
=> ((t c4 mf) (-1/32) (t d4 mf) (-1/32) (-1/32) (-1/32) (-1/32) (t g4 mf) (-1/32) (-1/32) (-1/32) (-1/32))

(filter-events-neg '(c4 d4 g4) '(t c4 mf cs4 d4 eb4 e4 f4 fs4 g4 gs4 a4 bb4 b4))
=> ((-1/32) (t cs4 mf) (-1/32) (t eb4 mf) (t e4 mf) (t f4 mf) (t fs4 mf) (-1/32) (t gs4 mf) (t a4 mf) (t bb4 mf) (t b4 mf))

     

     

     

     

     

    midi-entry / data saving

    in Support & Troubleshooting

    Posted

    i know, of course, that LISP is not an environment for REALTIME actions (pure data / max would be much more suitable) - so I had to outsmart the system a little to import data (from a modularsynth and other applications) almost "on the fly" to generate a LIVE-SCORE (with the influence of this datas) at the concert/on the stage....

     

    maybe i should learn MAX... for more smart-coded REALTIME things 😄

     

     

    midi-entry / data saving

    in Support & Troubleshooting

    Posted

    MIDI KEYBOARD

    to

    OSCulator (translates MIDI to OSC)

    to

    OPMO (reading pitch (midi number) and set to variable X)

     

    1) evaluate (setq *osc-receive*.......)

    2) start/evaluate LOOP-section

    3) start LIVE-CODE

    4) play your midi-keyboard

     

    => in every cycle of LIVE-CODING the "keyboard-pitch" will be read --- to variable X -> tempo and pitch are changing (by new cycle start)

     

    5) stop all, incl.  evaluate (process-kill *osc-receive*)

    midi-entry / data saving

    in Support & Troubleshooting

    Posted

    here is a short sketch of how you can integrate a midi keyboard into live coding. evaluate the BASIC SETUP as before but in a LOOP (here 10 times) the LIVE-CODING setup, so a new value X (the PITCH (midi number) from the external keyboard) is always read in (which comes from the keyboard)...  

     

    these values can now be used on various parameters. for this sketch only pitch + tempo (see: tempo (list (* x 3))

     

    VIDEO: at the beginnig you see data coming in from midi keyboard

     

     

     

    some code/sketch

      

    (defparameter *remote-host* "127.0.0.1")
(defparameter *in-port* 1234)
(defparameter *in-socket* (make-socket :type :datagram :local-port *in-port* :format :binary))

(setq *osc-receive*
      (process-run-function "osc-receive-process"
        #'(lambda ()
            (loop 
              do (print (setf x (second (osc::decode-message (receive-from *in-socket* 2048)))) #.*terminal-io*)))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(loop repeat 10
  do (progn
       (def-score test1
                  (:key-signature '(c maj)
                                  :time-signature '(4 4)
                                  :tempo (list (* x 3))
                                  :start 1 :end 4)
         
         (part1
          :omn (make-omn :pitch (list (midi-to-pitch x))
                         :length (gen-length-cartesian 1 1 'n 'n 'q '(2 3) '(13 4) '(1 2 3 4 5 6))
                         :span :length)
          :port 4
          :channel 1
          :sound 'gm
          :program 0
          :volume 127))
       
       (live-coding-midi (compile-score 'test1)))
  do (print x)
  do (sleep 3))


(process-kill *osc-receive*)  ;; Prozess wieder anhalten

     

    midi-entry / data saving

    in Support & Troubleshooting

    Posted

    I have now found a SOLUTION that might be also interesting for LIVE CODING:

     

    With the APP OSCulator you can convert midi-input (by an external keyboard) into OSC and then read it in real time (via osc-library + code) in OPMO (see video).

     

    Of course, it could also be done directly from OSC (then via an APP such as TouchOSC from the mobile or tablet). you just have to reread the values (by a loop-function) as you can see in the video; in this way, certain parameters of the LIVE-CODING could be controlled / influenced from the outside.

     

    LINKS:

     

    OSC to LISP:

    osc

    favicon.svg GitHub - zzkt/osc: a common lisp implementation of the Open Sound Control protocol aka OSC

    GITHUB.COM
    a common lisp implementation of the Open Sound Control protocol aka OSC - GitHub - zzkt/osc: a common lisp implementation of the Open Sound Control protocol aka OSC

     

    OSCulator:

    6554b6be8c0d829a8bf63ae0c82cf121_link.pn Home | OSCulator

    OSCULATOR.NET
    Links your controllers to your favorite music and video software. Works with Nintendo Wiimote, iPhone and more.

     

    TouchOSC:

     

     

    VIDEO:

     

    left-  PROTOKOL to see what's MIDI-in

    right - midi to osc (OSCulator)

    bottom - OPMO with midi-data PRINT in the listener 

     

     

    BASIC CODE:

      

    (defparameter *remote-host* "127.0.0.1")
(defparameter *in-port* 1234)
(defparameter *in-socket* (make-socket :type :datagram :local-port *in-port* :format :binary))

(setq *osc-receive*
      (process-run-function "osc-receive-process"
        #'(lambda ()
            (loop do (print (osc::decode-message (receive-from *in-socket* 2048)) #.*terminal-io*))))) ;; instead of PRINT you could use SETF

(process-kill *osc-receive*)  ;; STOP "listening process"

;;; CODE by philippe kocher

     

     

    midi-entry / data saving

    in Support & Troubleshooting

    Posted

    with OSC - (with the external osc-library i've sended you) - it should work similiar?

    loop-function which PRINT the revcevied osc-values over and over (it works). i would like to do that with MIDI

     

    but i'm not a lisp pro....

    (code not by me)

     

      

    (defparameter *in-port* 9999)
(defparameter *in-socket* (make-socket :type :datagram :local-port *in-port* :format :binary))

(setq *osc-receive*
      (process-run-function "osc-receive-process"
        #'(lambda ()

            (loop do (print (osc::decode-message (receive-from *in-socket* 2048)) #.*terminal-io*)))))

(process-kill *osc-receive*)  ;; Prozess wieder anhalten

     

    midi-entry / data saving

    in Support & Troubleshooting

    Posted

    dear all

     

    as so often i try out strange things 🙂 i switch on midi-entry, read the pitches which i enter from a keyboard. everything clear so far. I am now trying to do this in a 2-second-loop (with sleep-function), so that variable X would always be assigned new values. at the end of the loop sequence, however, X is NIL. only when I evaluate X again are the values assigned. (see video)

     

    (the idea is... to IMPORT live-midi into a "realtime-process")

     

    some ideas?

     

    thanx
    andré

     

     

     

     

    listener

    in Support & Troubleshooting

    Posted

    the LOOP-cycles produces data-sequences with lengths about 5 to 20 sec 

    for this... stop and wait via SLEEP is oaky....

     

    inside the loop: i send the datas (the sequences) to screens (generative score + conducting for the musicians / polytempo) and MAXMSP (sound/modsynth) ... this is via OSC for accuracy/coordination

     

    so it works fine like that... but: LISP is not exactly suitable for REALTIME processing 😄 

    listener

    in Support & Troubleshooting

    Posted

    is there a possibilty to ONLY show INSIDE the LISTENER what i like to: some (print ....)-stuff

    ...and not all the "function-calls" like 

     

    .....

    ratio-to-msec
    rnd-pick :seed 990096
    rnd1 :seed 858709
    compress
    rnd1 :seed 223329
    compress
    list-to-string
    ratio-to-msec
    ratio-to-msec
    ratio-to-msec
    prob :seed 115209
    prob :seed 40751
    stop-score-player
    score-player
    ....

     

    thanx for a hint

    andré

    Interval distance of a list (integers or pitches) in relation to a chosen note

    in Function Examples

    Posted · Edited by AM 

    
(defun interval-distance (alist n)
  (let ((alist (if (pitchp (car alist))
                 (pitch-to-midi alist)
                 alist))
        (n (if (pitchp n)
             (pitch-to-midi n)
             n)))

    (loop for i in alist
      collect (- i n))))
    
(interval-distance '(c4 d4 b2 e7) 'c4)
=> (0 2 -13 40)
(interval-distance '(c4 d4) 'c4)
=> (0 2)
(interval-distance '(43 44) '41)
=> (2 3)
(interval-distance '(56 48 11) 'c4)
=> (-4 -12 -49)

     

    Rhythmic Resultants

    in Support & Troubleshooting

    Posted

    is  this a solution? ...or some ideas to it...

    greetings

    andré

     

      

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun gen-resultant (r1 r2 &key (rhy 1/4))
  (gen-length (difference (remove-duplicates 
                           (sort-asc (flatten (append (cons 0 (gen-accumulate r1)) 
                                                      (cons 0 (gen-accumulate r2))))))) rhy))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; example.... correct?
(gen-resultant  (primes-to 7) (reverse (primes-to 7)))


;;; another example
(gen-resultant '(9) '(3 1 4))
(gen-resultant '(9) '(3 1 4) :rhy 1/16)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

     

     

    n-version... 

      

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; for several layers

(defun gen-resultant* (r &key (rhy 1/4))
  (gen-length (difference (remove-duplicates 
                           (sort-asc (flatten (loop for i in r
                                                        append (cons 0 (gen-accumulate i)))))))
              rhy))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; correct? 

(gen-resultant* '((16) 
                  (9) 
                  (3 1 4)
                  (7)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

     

    a version with length-input - but test it, correct...?

      

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; for several layers / with direct rhythm-input

(defun gen-resultant** (r)
  (difference (remove-duplicates 
               (sort-asc (flatten (loop for i in r
                                    append (cons 0 (gen-accumulate i))))))))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; correct? 

(gen-resultant** '((2/4 1/4 3/4) (1/16 3/16 2/12 1/12) (3/4 3/20 2/20)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

     

    Tom Johnson / Pascal's Triangle Modulo Seven ... and more

    in Function Examples

    Posted

    listen to the processes...

      

    (make-omn :pitch (integer-to-pitch (pascal-triangle 50 :johnson-modulo (1+ (random 23))))
          :length '(t)
          :span :pitch)

     

    an example with parallel processes (chordized).. 

    
(setf chordlist (loop 
                  for i in (flatten (integer-to-pitch (pascal-triangle 20 :johnson-modulo (1+ (random 23)))))
                  for j in (flatten (integer-to-pitch (pascal-triangle 20 :johnson-modulo (1+ (random 23)))))
                  for k in (flatten (integer-to-pitch (pascal-triangle 20 :johnson-modulo (1+ (random 23)))))
                  append (chordize (list i j k))))



(make-omn :pitch chordlist
          :length '(t)
          :span :pitch)

     

    Tom Johnson / Pascal's Triangle Modulo Seven ... and more

    in Function Examples

    Posted

    here is a short program (based on JOHNSON's writing... pascal-code found in www and modified) to generate TOM JOHNSON's series of numbers for "pascal's triangle ...".

     

    maybe interesting to play with the MODULO like JOHNSON did (mod 7)... try it!

     

    greetings

    andré

      

    ;;; SUB
(defun pascal-next-row (a &key (johnson-modulo nil))
    (loop :for q :in a
          :and p = 0 :then q
          :as s = (if (null johnson-modulo)
                    (list (+ p q))
                    (list (mod (+ p q) johnson-modulo)))
          :nconc s :into a
          :finally (rplacd s (list 1))
                  (return a)))
 
;;; MAIN
(defun pascal-triangle (n &key (johnson-modulo nil))
    (loop :for a = (list 1) :then (pascal-next-row a :johnson-modulo johnson-modulo)
          :repeat n
          :collect a))


;;; => pascal-triangle 
(pascal-triangle 7)
=> ((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1) (1 5 10 10 5 1) (1 6 15 20 15 6 1))

;;; => pascal-triangle with MODULO like tom johnson in PASCAL'S TRIANGLE MODULO SEVEN
(pascal-triangle 21 :johnson-modulo 7)
=> ((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1) (1 5 3 3 5 1) (1 6 1 6 1 6 1) (1 0 0 0 0 0 0 1) (1 1 0 0 0 0 0 1 1) (1 2 1 0 0 0 0 1 2 1) (1 3 3 1 0 0 0 1 3 3 1) (1 4 6 4 1 0 0 1 4 6 4 1) (1 5 3 3 5 1 0 1 5 3 3 5 1) (1 6 1 6 1 6 1 1 6 1 6 1 6 1) (1 0 0 0 0 0 0 2 0 0 0 0 0 0 1) (1 1 0 0 0 0 0 2 2 0 0 0 0 0 1 1) (1 2 1 0 0 0 0 2 4 2 0 0 0 0 1 2 1) (1 3 3 1 0 0 0 2 6 6 2 0 0 0 1 3 3 1) (1 4 6 4 1 0 0 2 1 5 1 2 0 0 1 4 6 4 1) (1 5 3 3 5 1 0 2 3 6 6 3 2 0 1 5 3 3 5 1) (1 6 1 6 1 6 1 2 5 2 5 2 5 2 1 6 1 6 1 6 1))

;;; look!!

(list-plot (flatten (pascal-triangle 50 :johnson-modulo 7))
           :point-radius 0 :style :fill)

(list-plot (flatten (pascal-triangle 50 :johnson-modulo 11))
           :point-radius 0 :style :fill)

(list-plot (flatten (pascal-triangle 80 :johnson-modulo 17))
           :point-radius 0 :style :fill)

(list-plot (flatten (pascal-triangle 50 :johnson-modulo 3))
           :point-radius 0 :style :fill)

;;; rnd-testing
(list-plot (flatten (pascal-triangle 80 :johnson-modulo (1+ (random 23))))
           :point-radius 0 :style :fill)

     

     

     

×
×
  • Create New...

Important Information

Terms of Use Privacy Policy

  I accept