JulioHerrlein

Here it is:
(setf stimme1 '((h d4 q a4 g4) (q a4 e4 h f4) (h e4 g4) (q f4 e4 d4 cs4) (h d4 q a4 a4))) (setf pitch (omn :pitch stimme1)) (setf len1 (length-rest-series '(2 2 2 2 2 2 2 2) '((1/2 1/4 1/4) (1/4 1/4 1/2) (1/2 1/2) (1/4 1/4 1/4 1/4) (1/2 1/4 1/4)))) => ((1/2 -1/4 1/4) (-1/4 1/4 -1/2) (1/2 -1/2) (1/4 -1/4 1/4 -1/4) (1/2 -1/4 1/4)) (setf len2 (length-rest-series '(1 2 2 2 2 2 2 2 2) '((1/2 1/4 1/4) (1/4 1/4 1/2) (1/2 1/2) (1/4 1/4 1/4 1/4) (1/2 1/4 1/4)))) => ((-1/2 1/4 -1/4) (1/4 -1/4 1/2) (-1/2 1/2) (-1/4 1/4 -1/4 1/4) (-1/2 1/4 -1/4)) (make-omn :length len1 :pitch (gen-swallow len1 pitch)) => ((h d4 -q g4) (-q e4 -h) (h e4 -) (q f4 - d4 -) (h d4 -q a4)) (make-omn :length len2 :pitch (gen-swallow len2 pitch)) => ((-h q a4 -) (q a4 - h f4) (-h g4) (-q e4 - cs4) (-h q a4 -))

;; gen-hoquetus.4 https://en.wikipedia.org/wiki/Hocket ;;; andré meier / 27-4-2016 ;;; write a instrumentation-list (instrument + techniques + velocity), pitch-list ;;; and length-list. the gen-hoquetus-function will split the melody ;;; off... in any possibilities, techniques/articulations/velocities will be added ;;; this is only a function i coded for my actual work... perhaps you could use ;;; it or code it properly :-) ;;; HAVE FUN! regards, andré (setq instrumentation '(((pno ponte ppp)) ((vn pizz p)) ((vn pizz f) (va ponte f)) ((pno tasto ff)) ((pno pizz fff)) ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp)) ((trp mute pp) (vn ponte mf)))) ;; mainfuction: (defun gen-hoquetus.4 (filtered-instrument &key pitch length instrument-list) (let ((events (generate-events.4 length pitch :optional_data instrument-list))) (filtering-color.4 filtered-instrument events))) (gen-hoquetus.4 'vn :pitch '(c4 d4 e5 f6) :length '(1/32 2/32 3/32 4/32) :instrument-list instrumentation) ;; subfunctions (defun generate-events.4 (durations pitches &key (velocity '(mf)) (articulation '(-)) (optional_data 'nil)) (loop repeat (length durations) with cnt-d = 0 with cnt-rest = 0 when (> (nth cnt-d durations) 0) collect (list (nth cnt-d durations) (nth cnt-rest pitches) (nth cnt-rest velocity) (nth cnt-rest articulation) (nth cnt-rest optional_data)) and do (incf cnt-rest) and do (incf cnt-d) else collect (list (nth cnt-d durations) 'nil 'nil 'nil 'nil) and do (incf cnt-d))) (generate-events.4 '(1 2 -3 4) '(60 61 62) :optional_data instrumentation) (defun filtering-color.4 (selected-color event-stream) (loop for i in event-stream with match = 0 append (loop for x in (fifth i) when (equal (first x) selected-color) do (setq articulation (second x) velocity (third x)) and do (setq match 1)) when (and (= match 1) (> (first i) 0)) append (list (first i) (second i) velocity articulation) else collect (* -1 (abs (first i))) do (setq match 0))) (filtering-color.4 'vn (generate-events.4 (gen-length '(1 -100 2 3 4 5) 1/32) '(c4 d4 e4 e5) :optional_data instrumentation)) ;; OMN_EXAMPLE: (setq pitches (midi-to-pitch '(60 61 62 63 64 65 66 67 68 69 70))) ; only an example (setq lengths (gen-length '(1 2 3 -4 5 6 5 -4 3 -2 1) 1/16)) ; only an example (setq instrumentation (loop repeat 10 collect (rnd-pick '(((pno ponte ppp)) ; only an example ((vn pizz p)) ((vn pizz f) (va ponte f)) ((pno tasto ff)) ((pno pizz fff)) ((vn tasto mf) (pno ord ff) (vc tasto mf) (trp ord pp)) ((trp mute pp) (vn ponte mf)))))) (def-score hoquetus.4 (:key-signature '(c maj) :time-signature '(4 4) :tempo '(120) :layout (bracket-group (trumpet-layout 'trumpet) (piano-grand-layout 'piano) (violin-layout 'violin) (viola-layout 'viola) (violoncello-layout 'violoncello))) (trumpet :omn (gen-hoquetus.4 'trp :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (piano :omn (gen-hoquetus.4 'pno :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (violin :omn (gen-hoquetus.4 'vn :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (viola :omn (gen-hoquetus.4 'va :pitch pitches :length lengths :instrument-list instrumentation) :channel 1) (violoncello :omn (gen-hoquetus.4 'vc :pitch pitches :length lengths :instrument-list instrumentation) :channel 1))  

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)  
 
 

Another possible way:
 
(setf seeds (vector-round 1 100 (gen-white-noise 8 :seed 13))) (setf rhythm (mapcar (lambda(x) (euclidean-rhythm 16 4 16 's :type 2 :seed x)) seeds)) SB.

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

Thanks, Andre ! I will check the Lachenmann piece, for sure.
 
I was thinking in a possible algorithm for such function:
 
1) Take an OMN expression
2) Calculate the empty spaces (rest space)
3) Fill the spaces with notes, based on each gap, using a predefined quantization (1/16, 1/8, random, etc) and a filling density level (0-100 %,  of the space)
4) Fill the spaces with predefined pitch lists, motifs, rhythmmic sets, etc,  that can be trimmed, rotated and start on any note
5) Fill the spaces like mentioned before with some pitch quality control (tonality-map) and pitch melodic direction control (up, down, repeat, vector).
6) Fill the spaces like before with any predefined method
 
populate-spaces
populate-gap
fill-spaces
fill-gap
 
This would be really useful, IMHO.
 
All the best !
Julio

yes, of course - from "BOTs" to a lot of small simple FUNCTIONS... but: not very well/smart coded (🙄) - i'm musician but only an "amateur programmer" with few experience -  and it's really NOT well documentated for other users. and another point, i have no idea how do that professionally with GUTHUB and these installation-things 😕
 
as ORDINARY text - no problem. perhaps i will share it like that on my website...
 
 

i'm very interested in!! thx to you JULIO!!! 🙂
strukturnetz is not a piece, it's "a kind of technique" he used 🙂
 
you could read about it here:
https://www.amazon.de/Differenzen-Poststrukturalistische-Beispiel-Lachenmann-Ferneyhough/dp/3931264157
 
listen here...
the STRUKTURNETZ is also "notated" in the score (on top)
 

Thanks, Andre ! I will check the Lachenmann piece, for sure.
 
I was thinking in a possible algorithm for such function:
 
1) Take an OMN expression
2) Calculate the empty spaces (rest space)
3) Fill the spaces with notes, based on each gap, using a predefined quantization (1/16, 1/8, random, etc) and a filling density level (0-100 %,  of the space)
4) Fill the spaces with predefined pitch lists, motifs, rhythmmic sets, etc,  that can be trimmed, rotated and start on any note
5) Fill the spaces like mentioned before with some pitch quality control (tonality-map) and pitch melodic direction control (up, down, repeat, vector).
6) Fill the spaces like before with any predefined method
 
populate-spaces
populate-gap
fill-spaces
fill-gap
 
This would be really useful, IMHO.
 
All the best !
Julio

would be interesting. it has quite some (distant?) aspects of LACHENMANN's "strukturnetz", and could be nice to work in such an direction...

Something like this
 

 
For a more refined Idea, this population could be oriented by tonality-map for chord-guided notes and some vector (for melodic directions).
 
Thanks, Stephane
I´ll try your suggestion
 

I will have a think.

I've experimented different approach to this in past.
One of the possible way is to use passing-interval function to populate between you anchor chords.
 
SB.

Will be implemented in the next update.
 
All you need to do is to add a line of code (below) into the ~/Opusmodus/Extensions/User Source.lisp file.
 
(defparameter *snippet-clef-default* :treble-down8)  

Hi,
 
I would like to make annotations in the doc files of the functions, so when I come back I can see at a glance if I've already worked with that function..
Now the docs are overwritten with every update, is there a way to preserve our personal annotations?
OM is so big and complex, such possiiblity really would help me!
 
Thanks!

Thanks, Stephane. This is very helpful and informative. 

I use HARMONIC-PATH function to apply harmony when I want to keep the voice leading of my applied chords.
 
HARMONIC-PATH change totally the harmonic content when applying. TONALITY-MAP just "map" pitches on closest other pitches.
 
Try to use as path some chords with a very typical classical and well defined voice leading with both functions on a more complex material and you will see the difference .
 
S.

I've been studying HARMONIC-PATH and TONALITY-MAP functions to determine the exact similarities and differences between the two. While I understand the purpose of those functions in principle from reading the documentation and experimenting with different ideas, I wonder if - for educational purposes - someone could briefly highlight the main explicit differences between the two. In the short example below, both functions produce very similar results, so the question may be when to use one function instead of the other. And is it possible to achieve the same result with both functions? I appreciate anyone's advice or insight into this.
 
Thanks!
 
(setf chords '(c4e4g4 c4f4a4 b3d4g4)) (setf voice (gen-repeat (length chords) '((c4d4 e4)))) (setf harmonic-path (harmonic-path chords voice :octave :path)) => ((c4e4 g4) (c4f4 a4) (b3d4 g4)) (setf tonality-series (tonality-series chords :map '(step) :closest 'up)) (setf tonality-map (tonality-map tonality-series voice)) => ((c4g4 e5) (c4a4 f5) (b3g4 d5))  
 

Dear Rangarajan,
You can use the :size parameter in the harmonic-progression function to create 4 pitch chords.
 
S.
 

Opusmodus has a rich set of predefined chords. But I am a bit confused about how to use this. For example, how do I get the "major" triad with "d4" as the tonic in C Major scale?
 
I tried this: (expand-chord '(d4 maj)) but I get "(d4fs4a4)" instead of "(d4f4a4)"
 
- Rangarajan

Yes, it is because the randomness in tonality-map process call randomly the parameter up or down in the :closest option.
 
You can fix this by setting up or down explicitly:
 
(setf path (tonality-series modes :map '(octave) :root roots :closest '(up))) S.

Hi all,
 
I would like to continue with the 'Zoom into OM' sessions and would like to ask if there are other people who are also interested and are willing to pay for it? If we get minimum 6 participants together and everybody is paying 10€ per session we can ask Stéphane to continue.
To have a little planning certainty, I thought about that everybody is paying 50€ so we can have a serie of 5 sessions (and then make a new collection/appointment)..
And I think we can have  sessions on topics that the participants are suggesting..
If that sounds convincing to you, please send me a PM with your name and emailadress and I will start to organise it..
 
Thanks and all the best!
 
ole

I am implementing a library of algorithms for music generation using Opusmodus. Here are 3 snippets generated using this library. The midi outputs are sent to Reaper DAW, which in turn uses instruments available in Propellerhead Reason 11 (through VST3i Reason Rack Plugin).
 
- Rangarajan
rnd-nil3-4_4.mp3
rnd-nil2-4_4.mp3
rnd5654328-4_4.mp3

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
 

movie.mov  
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
 

Concerning own GUI applications: you can already do that. This is independent of Opusmodus. 
 
For example, on a Mac CCL (the Lisp compiler on which Opusmodus is built) has a built-in Cocoa Interface  and Objective-C bridge. There also exist other GUI libraries for Lisp. For example, check out 
GUI toolkits
LISPCOOKBOOK.GITHUB.IO A collection of examples of using Common Lisp