Jump to content

AM

Members

  • Joined

  • Last visited

View Profile Find content

Posts posted by AM

    one other interesting approach could be, to use l-systems on a "higher level"... (a lot of work to this is already made in OPENMUSIC)

    a sequence like '(a b a c a d a a b a e ...) ;; as a "nonsense-l-system-example-seq"

    could be used as a seq for FUNCTIONS... means:

     

    an input/omn-seq would be transformed by an l-system-function-sequence, for example...

     

    a = rotate pitches and lengths

    b = invert pitches

    c = sample-seq pitches

    d = change velocities

     

    so you could work with more complex input-gestalts... and when you are doing this on a second/third-level inside of such GESTALTS you will have something like this MODEL...

     

    1200px-Hypercycle-eigen.svg.png

     

     

    i think HANSPETER KYBURZ is "the MASTER" for L-SYSTEMS in MUSICAL COMPOSITION, and i he talked about this things in his lectures

     

    wikipedia.ico Hanspeter Kyburz - Wikipedia

    EN.WIKIPEDIA.ORG

     

    famous pieces with/on this are:

     

    CELLS

     

     

    Posted

    here  a function... to barraqué's techniques

      

    
(defun serie-proliferantes (row)
  (let* ((ri_row (pitch-invert (gen-retrograde row)))
         (row (loop for z in (loop for x in (pitch-to-midi ri_row)
                          collect (or (position x (pitch-to-midi row))
                                      (position (- x 12)
                                                (pitch-to-midi row)) 
                                      (position (+ x 12) 
                                                (pitch-to-midi row))))
           
                collect (nth z ri_row))))

    row))


(serie-proliferantes '(c5 ab4 g4 db5 e4 d4 bb4 eb4 b4  f4 fs4 a4))
=> (fs4 a4 g4 cs5 d5 c5 eb5 gs4 b4 f4 e5 bb4)

     

     

    seen here:

    https://www.amazon.de/Jean-Barraqué-Musik-Konzepte-Heinz-Klaus-Metzger/dp/3883774499

     

    page 19-20

     

     

    IMG_9474.jpeg

     

    IMG_9475.jpeg

     

    Posted

    for my current project i have to CONVERT/MAP pitches/lengths/velocity or MIDI into a binary sequence. so i coded this simple FUNCTION... feel free to use/adapt....

     

    greetings

    andré

     

      

    
(defun fill-to-x-bit (listseq &key (bitlength 7))
  (loop for i in listseq
    when (< (length i) bitlength)
    collect (append (gen-repeat (- bitlength (length i)) 0) i)
    else collect i))

;;;; CONVERT PITCH/LENGTH or VELOCITY TO BINARY INFORMATION

(defun convert-to-binary (alist &key (parameter 'pitch) (length-resolution 127) (velocity-resolution 127) (pitch-resolution 127) (event nil)  (bitlength 7))
  (let ((pitch) (length) (velocity)
        (alist (progn 
                 (setf alist (cond ((stringp alist)
                                    (flatten (midi-to-omn alist :instrument 1)))
                                   (t alist)))
                 
                 (if (omn-formp alist)
                   (cond ((equal parameter 'pitch)
                          (setf alist (omn :pitch alist)))
                         ((equal parameter 'length)
                          (setf alist (omn :length alist)))
                         ((equal parameter 'velocity)
                          (setf alist (omn :velocity alist)))
                         ((equal event 't)
                          (setf alist (single-events alist))))
                         alist))))
                           
    (if (null event)
      (cond ((pitchp (car alist))
             (progn
               (setf alist  (pitch-to-midi (pitch-melodize alist)))
               (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution)
                                                                  (- (find-max alist) (find-min alist))
                                                                  pitch-resolution) alist)) :bitlength bitlength)))
            
            ((lengthp (car alist))
             (fill-to-x-bit (decimal-to-binary  (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength))
            
            ((velocityp (car alist))
             (fill-to-x-bit (decimal-to-binary  (vector-round 1 velocity-resolution (get-velocity  alist))) :bitlength bitlength)))

      (progn 
        (setf pitch (progn
                      (setf alist  (pitch-to-midi (pitch-melodize  (omn :pitch alist))))
                      (fill-to-x-bit (decimal-to-binary (vector-round 0 (if (null pitch-resolution)
                                                                         (- (find-max alist) (find-min alist))
                                                                         pitch-resolution) alist)) :bitlength bitlength)))
        (setf length (fill-to-x-bit (decimal-to-binary  (vector-round 1 length-resolution (mapcar 'float (omn :length alist)))) :bitlength bitlength))
        (setf velocity (fill-to-x-bit (decimal-to-binary  (vector-round 1 velocity-resolution (get-velocity  (omn :velocity alist))))  :bitlength bitlength))))))


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

(convert-to-binary '(c4 cs5 fs3 c5 f5) :bitlength 15)
(convert-to-binary '(-e e -q h e) :bitlength 15)
(convert-to-binary '(p p ffff mp ) :bitlength 15)

     

     

     

    like that? should work...

    it "loops" x-times (depends on length of seeds-list) and collect the rhythms...

      

    (setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13)))


(setf rhythm (loop for i in seeds 
               collect (euclidean-rhythm 16 4 16 's :type 2 :seed i)))

     

     

    perhaps there is an OPMO-solution, this is LISP

    dear ole  

     

    i have no "preseted" soundsets for my work...

    in my current "sketch" i'm using/something something like this..

      

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

(add-text-attributes
 '(e-bow "e-bow")
 '(harm-I "harm-1")
 '(harm-II "harm-II")
 '(harm-III "harm-III")
 '(harm-IV "harm-IV")
  '(harm-V "harm-V")
 '(harm-VI "harm-VI"))

(def-sound-set gm-guitar
   :programs
  (:group guitar 
          ord 0
          bartok-pizz 1
          tap 2
          ponte 3
          harm-I 4
          harm-II 5
          harm-III 6
          harm-IV 7
          harm-V 8
          harm-VI 9))


(def-sound-set gm-vibraphone
   :programs
  (:group vibraphone 
          ord 0
          tap 2))


(def-sound-set gm-piano
   :programs
  (:group piano 
          ord 0
          e-bow 1))

     

    for this CT-setup...

     

    git vibra pno.cePlayerOrc

     

     

     

    i have been working with conTimbre for a long time and it is exactly what i was looking for. playing techniques can easily be done by OPMO or SIBELIUS (vst3) via program changes. it has a great many different playing techniques. I always found IRCAM_LIB to be very inadequate, as there were not enough playing techniques etc. / you can also control CT via OSC (and as standalone or via MAXMSP). when I wrote for ensemble with additional e-player, CT-live always worked very well.

     

    (The only negative point I could say is that there are a few SAMPLES that weren't played / recorded very well. But with the size of the library, that's okay with me)

    Posted

    Dear all

     

    Today I dealt briefly how to control PROCESSING (software and programming language) by Midi. There is a great interface for this: "rwmidi" by Giuseppe Torre. You can download and install it, it works fine!  

     

    A short Video (no Sound) with a very simple Processing Example

     

     

    I think this is a good combination if you want to visualize your midi output (or just use de midi-data in realtime)  or if you want to program a separate VISUAL track in OPMO. Here is a small example (I can't program usable in PROCESSING yet, sorry :-)) Downloads etc. are here ...

     

    https://processing.org

    https://gitlab.com/giuseppetorre/rwmidi-revival-master

     

    here's a video, how to install etc...

    https://www.youtube.com/watch?v=7iFUenT5B68&feature=youtu.be

     

    and as an attachm. my "sketch" in processing

    sketch_Processing_from_Midi.pde

     

    Greetings André

     

    P.S. I think there ist also a way to send data by OSC

     

    Posted

    dear all

     

    here's an example (from my current work)...

     

    this little video shows how i generate/display SCORE (instrumental parts) on a screen + virtual conductor (piano part). the example is "nonsense", but shows how it looks/works... you see the bars (generating), the cue, beat... and the arrow (that shows you where to read/play) ...also you hear some bad (sry) sound-simulation of the setup.

     

    in this way i can generate a whole piece in realtime on STAGE (all musicians will read their part from their own screen). this one will be for 5 instruments, ePlayer and modular synthesizer. during the performance an algorithm (or some data-streams) will generate the piece in OPMO. with OSC i can send all datas (score, beat, tempo..)  from OPMO to POLYTEMPO-NETWORK  (https://polytempo.zhdk.ch) and work and coordinate different independent tempo layers, conducting etc...

     

    for more POLYTEMPO informations... have a look here: https://polytempo.zhdk.ch

     

    greetings

    andré

     

     

    Posted

    here is a sketch for an alternative "binary-(or element-)layer-FUNCTION

      

    (defun element-layer (lists &key (rnd nil))
  (let ((lists (if (null rnd)
                 lists
                 (rnd-order lists :list t))))
    (car 
     (last 
      (loop for x in (rest lists)
        with list = (car lists)
        collect (setf list (loop for i in list
                             with cnt = 0 
                             when (equal i 0)
                             collect (nth cnt x)
                             and do (incf cnt)
                             else collect i)))))))
  

(element-layer  (list  '(1 0 0 1 1 0 0 1 0 0 0 0)
                       '(0 2 3 0 4 5 0 6 0 7 8 0)
                       '(11 12 13 14 15 16 17))
                :rnd nil)

 => (1 11 2 1 1 3 12 1 4 5 13 6)

;;; hierarchic: every 0's will be replaced by the values from the next/sub-list...

     

    you want to map some integers (in your case pc..) to attributes? like that?

      

    (position-filter  '(0 1 2 3 4 5)  '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte))
=> (pizz arco ponte molto-ponte stacc stacc+pizz)


(position-filter  (pcs '6-Z10) '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte))
=> (pizz arco molto-ponte stacc stacc+pizz ten+molto-ponte)

or in pure CCL

(loop 
  for i in '(0 1 2 3 4 5)
  with attr-list = '(pizz arco ponte molto-ponte stacc stacc+pizz ten+arco ten+molto-ponte)
  collect (nth i  attr-list))
=> (pizz arco ponte molto-ponte stacc stacc+pizz)

     

    like that..?... some code...

    greetings

    andré

      

    (defun replace-velocities-in-a-seq (omn-list &key pitch velocity-list)
  (flatten 
   (loop 
     with cnt = 0
     for i in (single-events omn-list)
     
     when (equal (cadr i) pitch)
     collect (omn-replace :velocity (nth cnt velocity-list) i)
     and do (incf cnt)
     else collect i

     when (> cnt (length velocity-list))
     do (setf cnt 0))))



(replace-velocities-in-a-seq '(e c4 ppppp d4 d4 e4 f4 d4 d4 g4 b4 d4 d4 d4 d4)
                             :pitch 'd4
                             :velocity-list '(p mp mf f ff))

;=> (e c4 ppppp e d4 p e d4 mp e e4 ppppp e f4 ppppp e d4 mf e d4 f e g4 ppppp e b4 ppppp e d4 ff e d4 ppppp e d4 p e d4 mp)

;; if there are more 'd4's then velocity-values, -> it starts again with first velocity-value (= cycle)

     

    Posted

    dear janusz

     

    at the moment i'm working with AUDULUS 3 and OPMO, work's fine.

    but there are some problems with the articulation. is it possible that in ord. there is a little "overlapping" between two notes? in this case AUDULUS don't "recognize" a change of velocity etc... with stacc it works fine (but with a gap).

     

    is there a "non-overlapping"-articulation with almost no gap between the notes?

     

    thanks

    andré

     

     

Copyright © 2014-2025 Opusmodus™ Ltd. All rights reserved.
Product features, specifications, system requirements and availability are subject to change without notice.
Opusmodus, the Opusmodus logo, and other Opusmodus trademarks are either registered trademarks or trademarks of Opusmodus Ltd.
All other trademarks contained herein are the property of their respective owners.

 Powered by Invision Community

Important Information

Terms of Use Privacy Policy

I accept