Jump to content

JulioHerrlein

Members
  • Posts

    806
  • Joined

  • Last visited

Posts posted by JulioHerrlein

  1. I can try the gen divide strategy, but first I'm going to save everything in one voice only, using Explode in Finale.

    After That, import Midi to Opusmodus (loosing all articulations and Dynamics) and try to

     use gen divide, gen colletct approach (like the help of Grand Layout).

    I'll have to calculate how many notes are in LH and How Many in RH to divide the staff
    (Actually there's a pattern).

    I don't know if I'm going to suceed.

     

    A Better approach would be a form of merging my materials (LH and RH) all inside Opusmodus,

    without loosing the dynamics and articulations and then use the Grand Layout  example Strategy

    (that of gen-divide and Gen Collect)

    Looks complicated but less tedious than manually doing all the stuff.

     

    Any help ?

    Best

    Julio

  2. Dear Friends,

     

    I'm working on a piano piece where each hand

     plays complementary rhythms.

    For example,

    If LH plays  (s -s s s -s) then

       RH plays  (-s s -s -s s)  accordingly whit the concept.

     

    Everything is parametric, each hand have a set of pitches, dynamics and articulations,

    so I did one OMN assembling for each hand, to have more control over the material.

    It ends like you can see in the code, below.

     

    Since all I have is just the complementary rhythms, I'd like to write it in a form of continuous sixtenth notes, in cross staff.

    So, the problem is that in Finale I have to manually do all this painful work, dragging notes up and down, to make cross staffing, because,

    the output in the XML gives me two independent voices. It's really boring to do.

    Is there some way to automatically generating this cross staff layout, with this architeture of coding, preserving the content

     of each hand ?  I use this kind of writing it a lot.

     

    Thanks for help !

     

    Best,

    Julio

    (setf pianoassemblerh (assemble-seq lhmat1))
    ;;; Material for Left hand
    (setf pianoassemblelh (assemble-seq rhmat1b))
    ;;; Material for Right hand
    
    ;;; SCORE
    
    (def-score Piano-1
               (:key-signature 'atonal
                ;:time-signature '((4 4 3) (4 4 1))
                :time-signature '((3 4))
               :tempo 80
                :layout (piano-layout 'piano-rh 'piano-lh :all-accidentals t))
    (piano-rh
       :omn pianoassemblerh
       :channel 1
       :sound 'gm
       :program 'acoustic-grand-piano)
      (piano-lh
       :omn pianoassemblelh   
    ))

     

  3. Dear Friends,

     

    I have a suggestion to Opusmodus. Maybe a Midi In Collect funcionality could be handy.

    For example, the possibility to plug in a midi controller and collect data, for example, pitches

     from the midi in.  Chords could be collected already with syntax, i.e., like (c4e4g4) and melodies like (c4 e4 g4).

    A function could transform a midi input in lenghts, like c=1/16, d=1/8, or something like this.

    Or even a simple DAW=like recorder (with metronome) to get some motifs and transform it in OMN.

    If you begin working with pre-defined  material, the things can go long.

     

    Just some ideas...

    Best,

    Julio

  4. 6 minutes ago, opmo said:

    (setf r1 '(s s -s) r2 '(s s -s) r3 '(-s -s e -s) r4 '(s -s s -e) r5 '(e -e -e s -s)) You need to flatten the list first: (setf seq (flatten (let ((r-lis nil)) (dotimes (i 10) (push (rnd-unique 5 '(1 2 3 4 5)) r-lis)) r-lis))) (setf r-list (assemble-section 'r seq))

    PERFECT !!!

    added 2 minutes later
    9 minutes ago, opmo said:
    
    (setf r1 '(s s -s)
          r2 '(s s -s)
          r3 '(-s -s e -s)
          r4 '(s -s s -e)
          r5 '(e -e -e s -s))
    
    You need to flatten the list first:
    
    (setf seq
          (flatten
           (let ((r-lis nil))
             (dotimes (i 10)
               (push (rnd-unique 5 '(1 2 3 4 5)) r-lis))
             r-lis)))
    
    (setf r-list (assemble-section 'r seq))

     

    You could do that:

    
    (setf r1 '(s s -s)
          r2 '(s s -s)
          r3 '(-s -s e -s)
          r4 '(s -s s -e)
          r5 '(e -e -e s -s))
    
    (setf seq (flatten (gen-eval 10 '(rnd-unique 5 '(1 2 3 4 5)))))
    (setf r-list (assemble-section 'r seq))

     

    More Elegant !

     

    8 minutes ago, opmo said:
    
    (setf r1 '(s s -s)
          r2 '(s s -s)
          r3 '(-s -s e -s)
          r4 '(s -s s -e)
          r5 '(e -e -e s -s))
    
    You need to flatten the list first:
    
    (setf seq
          (flatten
           (let ((r-lis nil))
             (dotimes (i 10)
               (push (rnd-unique 5 '(1 2 3 4 5)) r-lis))
             r-lis)))
    
    (setf r-list (assemble-section 'r seq))

     

    You could do that:

    
    (setf r1 '(s s -s)
          r2 '(s s -s)
          r3 '(-s -s e -s)
          r4 '(s -s s -e)
          r5 '(e -e -e s -s))
    
    (setf seq (flatten (gen-eval 10 '(rnd-unique 5 '(1 2 3 4 5)))))
    (setf r-list (assemble-section 'r seq))

     

     

    added 3 minutes later

    Thanks a lot, Janusz !

  5. I'm trying this now...

    Workout from Nigel Morgan book

    But need some help..

     

    Rhythm list

    (setf r1 '(s s -s)
          r2 '(s s -s)
          r3 '(-s -s e -s)
          r4 '(s -s s -e)
          r5 '(e -e -e s -s))
          
    ;; shuffling 10 times
    (let ((r-lis nil))
     (dotimes (i 10)
      (push (rnd-unique 5'(1 2 3 4 5)) r-lis))
     r-lis)
     
    ;; Here is the problem: no succes to assemble
    (setf r-list (assemble-section 'r r-lis))
    
    > Error: "3" doesn't match array element type of "r
    While executing: ccl::concat-to-simple*, in process Listener-1(6).

     

    Please, help !

    Best,

    Julio

     

  6. Dear, All

     

    I need a function for shuffle elements. A function similar to URN in Pure Data.

     

    The scenario:

     

    1) I have a list of durations:

    s s -s s s -s -s -s e -s s -s s -e e -e -e s -s

    2) The lenghts together form a 6/4 timesignature or a 12/8.

    3) Just repeating the rhythm is BORING !

    4) I need variations, but I want to still sum 12/8 or 6/4.

    5) So, I need to shuffle this elements, without changing the total of the sum of lenghts.

     

    TWO APPROACHES:

     

     

    1) RANDOM - How to randomize, not like the random sample, but, using each element JUST ONCE,

    like an Hamiltonian Path ?

    (Actually I don't like to random things, because I feel like I'm not composing...) I'm a control Freak ! Sorry !

    2) RANDOM2 - How can I sort from sublists of the same rhtyhm EACH LIST MUST APPEAR JUST ONCE !

    This approach sounds more controled

    3) MY PREFERED ! How to split the lenght list, and make up combinations of sublists (absolutely controlled) ?

    Like this:

     

    COMPLETE LIST - (s s -s s s -s -s -s e -s s -s s -e e -e -e s -s)

     

     

    SUB LISTS 1 (s s -s)

    SUB LISTS 2 (s s -s -s )

    SUB LISTS 4 (-s e -s s -s)

    SUB LISTS 5 (s -e e -e)

    SUB LISTS 6 (-e s -s)

     

    Maybe I can Initialize each one as a setf

    Brute force method...

     

    (setf subleng1 ' (s s -s))

    (setf subleng2  '(s s -s -s ))

    (setf subleng3 '(-s e -s s -s))

    (setf subleng4 '(s -e e -e))

    ETC....

     

    And after that use assemble-seq to the lenghts ?

    Or assemble-seq is just for joining sections of the composition ?

     

    Any help ?

    Thank you all !!!

    Best,

    Julio

     

     

     

     

  7. Dear Friends

    I´m working on sketches for a piano piece.

    I declared some variable setf´s for manipulating pitches, rhythms, etc.

    In the def score instance below, almost in the end of script, OM is evaluating

     a non-declared variable pat-pitches2. "pat-pithes2" or "pat-pitches" is not in any place of this

     script, altought I used this in other file. Can OM pick variables from other files ? 

     

    Why OM is behaving like this ? Seems crazy.

     

    Best,

    Julio

     

    :pitch (ambitus '(g1 g3)(chordize-list (gen-divide '(1 1 1 1 1 1 1 1) (pitch-transpose-n '(0 0 -12 0) pat-pitches2))))
    ;;; HOW OM IS EVALUATING the variable pat-pitches2 - IT is NOT declared in any place of this file !!!!
       :velocity velocity2

     

     

     

     

  8. I tried it today, with my 5 year-old PC, windows 7 64 bit, 4GB Ram with Intel Dual Core (before the I series).

    In this modest setup, I could run Sonar 8.5 with rewire with Finale 25 (Windows) together with Opusmodus

     in VMware. You can share a folder to export your XML to immediately open in the DAW sequencer with rewire Finale.

     

    Great Stuff !

     

    Opusmodus runs flawlessly !

    Very happy with this great software !

    Thank you guys !

    Best,

    Julio

    added 1 minute later

    Exacty the steps of this video tutorial.

    https://www.youtube.com/watch?v=5RQ21XG8Ts4

     

  9. Dear friends,

     

    I'm still learning. This is a simple thing.

    How can I put inside a function the name of a variable, like the example below.

     

    I want to do this:

     

    (gen-binary-row 12 '(0 2 5 7 8 11))

    >> (1 0 1 0 0 1 0 1 1 0 0 1)

     

    But in this way:

     

    (setf binrow '(0 2 5 7 8 11))
    (gen-binary-row 12 '(binrow))

     

    What am I missing ?

     

    Thanks for help.

    Best,

    Julio

  10. Dear Janusz,

     

    This is the closest I get. I suppose it isn't related to Time-point.

    I'll try to explain.

    1) There is a general list of pitches from a certain source (a row, for example)

    2) From this list, we use the rhythm list as a skip list of pitches, picking the notes from a sequence.

    3) The sequence of note picks is related to the lenght of note divided by the small quantized value, for example, the 16th note.

    4) So, the lenght sequence

    (1/2 1/16 7/16 1/8 3/8 3/16 5/16 1/4 1/4 5/16  3/16))

    Will result in a pick skip note sequence like (8, 1, 7, 2, 6, 3, 5, 4, 4, 5, 3)

    5) The pick-skip note acts like

     

    8 - means pick the first and skip 7 from the first list of pitches

    1 - means pick the first and skip 0 from the first list of pitches

    7 - means pick the first and skip 6 from the first list of pitches

    and so on...

     

    This will result in a sublist of first list of pitches, based on the skipped notes, taken every nth notes.

    according to the sequence.

     

    5) The missed step is that I want to chordize this sublist to an desired HARMONIC partition, like

     for example 2 trichords, 1 dyad, 3 single notes and a tetrachord, using something like this:

     

    (chordize (gen-divide '(3 3 2 1 1 1 4) 'pitches sublist))

     

    Here is the closer I get.

     

    Best,

    Julio

     

    (setf lengths  '(1/2 1/16 7/16 1/8 3/8 3/16 5/16 1/4 1/4 5/16  3/16))
    (setf pitches '(g5 gs4 fs4 a4 gs4 g4 f4 bb4 fs4 a4 g4 gs4 a4 fs4 e4 b4 gs4 g4 f4 bb4 g4 gs4 fs4 a4 f4 bb4 gs4 g4 bb4 f4 eb4 c5 fs4 a4 g4 gs4 a4 fs4 e4 b4 g4 gs4 fs4 a4 gs4 g4 f4 bb4 a4 fs4 e4 b4 fs4 a4 g4 gs4 e4 b4 a4 fs4 b4 e4 d4 cs5 gs4 g4 f4 bb4 g4 gs4 fs4 a4 f4 bb4 gs4 g4 bb4 f4 eb4 c5 g4 gs4 fs4 a4 gs4 g4 f4 bb4 fs4 a4 g4 gs4 a4 fs4 e4 b4 f4 bb4 gs4 g4))


    (def-score time
               (
                :key-signature 'chromatic
                :time-signature time-sig
                :tempo 112
                :layout (clarinet-layout 'clarinet)
                )

    (clarinet
     :length lengths
     :pitch (loop for i in (append (list 0) (cumulative-sums (loop for k in lengths
                                                                            collect (/ k 1/16))))
                           collect (nth i pitches))
     :channel 1
     :sound 'gm
     :program 'piano
     ))

  11. Hello, All

     

    I'm trying to work out André's solution examples to make partitions out of tone rows or infinity series

     

    (setf lengths  '(1/2 1/16 7/16 1/8 3/8 3/16 5/16 1/4 1/4 5/16  3/16))
    (setf pitches '(g4 gs4 fs4 a4 gs4 g4 f4 bb4 fs4 a4 g4 gs4 a4 fs4 e4 b4 gs4 g4 f4 bb4 g4 gs4 fs4 a4 f4 bb4 gs4 g4 bb4 f4 eb4 c5 fs4 a4 g4 gs4 a4 fs4 e4 b4 g4 gs4 fs4 a4 gs4 g4 f4 bb4 a4 fs4 e4 b4 fs4 a4 g4 gs4 e4 b4 a4 fs4 b4 e4 d4 cs5 gs4 g4 f4 bb4 g4 gs4 fs4 a4 f4 bb4 gs4 g4 bb4 f4 eb4 c5 g4 gs4 fs4 a4 gs4 g4 f4 bb4 fs4 a4 g4 gs4 a4 fs4 e4 b4 f4 bb4 gs4 g4))

    ;;; get the pitches
     
    (setf pitsublist (loop for i in (append (list 0) (cumulative-sums (loop for k in lengths collect (/ k 1/16)))) collect (nth i pitches))

     

    ; All ok but what I need next is to take the nth order sublist generated in André's solution to chordize it in partitions ala Babbitt.

     

    chordize (gen-divide '(2 1 3) '(pitsublist) chordize-list (gen-divide '(2 1 3) '(pitsublist))))

     

    Any hint ?

    Thanks a lot !

×
×
  • Create New...

Important Information

Terms of Use Privacy Policy