score polygon-rhythm

[opmo]

The forthcoming POLYGON-RHYTHM function will allow you to think and compose in a clear symmetrical structures. The great amount of keywords (OPMO stile) makes this algorithm very powerful.

 

This is a short example using POLYGON-RHYTHM exclusively.

Instruments: VSL Tenor Sax and Jazz Drumset.

 

 

 

[AM]

very nice, janusz!! 

[JulioHerrlein]

Cool !

I'm curious !!

Best,

Julio

[loopyc]

You've got my attention! Amazing example, thanks

[opmo]

Second example, this time with code.

VSL: Soprano Sax, Steinway D, Upright Bass and Jazz DrumSet.
 

 

 

(progn
  (init-seed 3578)
  (setf bd '(c2 cs2))
  (setf sd '(d2 ds2 e2 f2 fs2 g2 gs2 a2 bb2 b2))
  (setf lt '(c5 cs5 d5 ds5 e5 f5 fs5 g5 gs5 a5 bb5 b5))
  (setf cc '(g7 c7))
  (setf rc '(c4 cs7 d7 ds7 e7 f7))
  (setf hh '(c4 cs4 d4 ds4 e4))
  
  (setf ds-vel '(ff f fff))
  
  (setf bd-gon (gen-eval 33 '(polygon-rhythm 3 16 0 :pitch (rnd-sample 32 bd) :velocity (rnd-sample 32 ds-vel))))
  (setf sd-gon (gen-eval 32 '(polygon-rhythm 2 16 '? :pitch (rnd-sample 32 sd) :velocity (rnd-sample 32 ds-vel))))
  (setf lt-gon (gen-eval 32 '(polygon-rhythm 2 16 '? :pitch (rnd-sample 32 lt) :velocity (rnd-sample 32 ds-vel))))
  (setf cc-gon (gen-eval 32 '(polygon-rhythm 5 24 '? :pitch (rnd-sample 32 cc) :velocity (rnd-sample 32 ds-vel))))
  (setf rc-gon (gen-eval 32 '(polygon-rhythm 5 24 '? :pitch (rnd-sample 32 rc) :velocity (rnd-sample 32 ds-vel))))
  (setf hh-gon (gen-eval 33 '(polygon-rhythm 5 16 '? :pitch (rnd-sample 32 hh) :velocity (rnd-sample 32 ds-vel))))
  
  (setf hexachord '(d4 eb4 fs4 g4 a4 bb4))
  
  (setf chords 
        (assemble-seq
         (gen-eval 16 '(polygon-rhythm
                        3 16 '?
                        :pitch (gen-chord-series
                                hexachord hexachord
                                :type '?
                                :width '(30 24 36 12)
                                :segment t)))
         
         (gen-eval 4 '(polygon-rhythm
                       5 16 '?
                       :pitch (gen-chord-series
                               hexachord hexachord
                               :type '?
                               :width '(30 24 36 12)
                               :segment t)))

         (gen-eval 7 '(polygon-rhythm
                       4 16 '?
                       :pitch (gen-chord-series
                               hexachord hexachord
                               :type '?
                               :width '(30 24 36 12)
                               :segment nil) :legato t))
         
         (gen-eval 5 '(polygon-rhythm
                       3 16 '?
                       :pitch (gen-chord-series
                               hexachord hexachord
                               :type '?
                               :width '(30 24 36 12)
                               :segment t)))))
  
  (setf piano (assemble-seq '((-1) (-1) (-1) (-1))
                            (rnd-octaves '(c2 b6) (subseq chords 4 31))
                            '(-1)))
  
  (setf ssax
        (make-omn :length
                  (assemble-seq
                   '((-1) (-1) (-1) (-1) (-1) (-1) (-1))
                   (polygon-rhythm 6 16 '?)
                   (polygon-rhythm 7 16 '?)
                   (polygon-rhythm 9 16 '?)
                   (polygon-rhythm 3 8 '?)
                   (polygon-rhythm 16 16 '?)
                   (polygon-rhythm 24 24 '?)
                   (polygon-rhythm 8 16 '?)
                   (polygon-rhythm 11 16 '?)
                   (polygon-rhythm 5 16 '?)
                   (polygon-rhythm 16 24 '?)
                   (polygon-rhythm 6 8 '?)
                   (polygon-rhythm 4 16 2)
                   (polygon-rhythm 5 16 2)
                   (polygon-rhythm 7 16 2)
                   (polygon-rhythm 9 16 0)
                   (polygon-rhythm 13 16 0)
                   (polygon-rhythm 16 16 0)
                   (polygon-rhythm 21 24 0)
                   (polygon-rhythm 22 24 0)
                   (polygon-rhythm 20 24 0)
                   (polygon-rhythm 20 24 0)
                   (polygon-rhythm 16 24 0)
                   (polygon-rhythm 4 16 2)
                   '((-1) (-1))
                   )
                  :pitch (ambitus 'soprano-sax
                                  (pitch-transpose
                                   (vector-to-pitch
                                    '(fs3 fs4)
                                    (mod-sine-waves
                                     5 36 4 0.3
                                     :modulation (gen-sine 120 5 0.4)))
                                   (pitch-variant (melodize (omn :pitch chords)))))
                  :velocity '(ff)))
  
  (setf bass-line (assemble-seq
                   '((-1) (-1))
                   (gen-eval 31 '(polygon-rhythm
                                  9 16 '?
                                  :pitch (ambitus
                                          '(e1 g4)
                                          (pitch-variant
                                           (pitch-transpose -24 (rnd-air :type :pitch))))
                                  :velocity '(fff)))))
  
  (ps 'vsl
      :ssax (list ssax)
      :grand (list piano)
      :cb (list bass-line)
      :ds-bd (list bd-gon)
      :ds-sd (list sd-gon)
      :ds-lt (list lt-gon)
      :ds-cc (list cc-gon)
      :ds-rc (list cc-gon)
      :ds-hh (list hh-gon)
      :tempo 120
      :output :live-coding
      :title "Dada Quartet - EXP.2 (c) 2019 OPMO")
  (init-seed nil)
  )

Best wishes,
Janusz

P.S. I am almost there with the new release. 

[loopyc]

Thank you for the code...can't wait to study and tweak example;-) Will await new release with great anticipation

[opmo]